move the dir of fe to console-fe

console/src/main/resources/static/build.js

@@ -1,38 +0,0 @@
-/*
- * Copyright 1999-2018 Alibaba Group Holding Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *      http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-const cp = require('child_process');
-const fs = require('fs');
-const path = require('path');
-// 默认打包存放地址
-const buildDir = 'build';
-// 打包后文件存放地址
-const targetDir = __dirname;
-
-const spawnAsync = (...args) => new Promise((resolve, reject) => {
-    const worker = cp.spawn(...args, { stdio: 'inherit' });
-    worker.on('close', resolve);
-    worker.on('error', reject);
-});
-
-spawnAsync('roadhog', ['build'])
-    .then(() => {
-        // 复制index.js
-        const copyFileList = ['index.js', 'index.css'];
-        copyFileList.forEach((fileName) => {
-            const _srcFileName = path.join(buildDir, fileName);
-            const _targetFileName = path.join(targetDir, fileName);
-
-            fs.writeFileSync(_targetFileName, fs.readFileSync(_srcFileName, "utf8"), "utf8");
-        });
-    });

console/src/main/resources/static/console-fe/build.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+// 默认打包存放地址
+const buildDir = path.join(__dirname, 'build');
+// 打包后文件存放地址
+const targetDir = path.join(__dirname, '../');
+
+const spawnAsync = (...args) =>
+  new Promise((resolve, reject) => {
+    const worker = cp.spawn(...args, { stdio: 'inherit' });
+    worker.on('close', resolve);
+    worker.on('error', reject);
+  });
+
+const mkdir = dir => {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+};
+
+const copyDir = (sourceDir, targetDir) => {
+  if (!fs.existsSync(sourceDir) || !fs.statSync(sourceDir).isDirectory()) {
+    return;
+  }
+
+  mkdir(targetDir);
+
+  fs.readdirSync(sourceDir).forEach(_fileName => {
+    const sourceFileName = path.join(sourceDir, _fileName);
+    const targetFileName = path.join(targetDir, _fileName);
+    const fileStat = fs.statSync(sourceFileName);
+    if (fileStat.isDirectory()) {
+      copyDir(sourceFileName, targetFileName);
+    }
+
+    if (fileStat.isFile()) {
+      fs.writeFileSync(targetFileName, fs.readFileSync(sourceFileName, 'utf8'), 'utf8');
+    }
+  });
+};
+
+spawnAsync('roadhog', ['build']).then(() => copyDir(buildDir, targetDir));

console/src/main/resources/static/console-fe/package.json

@@ -6,8 +6,8 @@
     }
   },
   "lint-staged": {
-    "*.js": [
-      "eslint --fix",
+    "*.{js,css,less}": [
+      "prettier --write",
       "git add"
     ]
   },
@@ -43,6 +43,7 @@
     "eslint-plugin-react": "^7.11.1",
     "husky": "^1.1.4",
     "lint-staged": "^8.0.4",
+    "prettier": "1.15.2",
     "roadhog": "^2.0.0"
   }
 }

console/src/main/resources/static/console-fe/public/css/codemirror.css

@@ -0,0 +1,491 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* BASICS */
+
+.CodeMirror {
+  /* Set height, width, borders, and global font properties here */
+  font-family: monospace;
+  height: 300px;
+  color: black;
+}
+
+/* PADDING */
+
+.CodeMirror-lines {
+  padding: 4px 0; /* Vertical padding around content */
+}
+.CodeMirror pre {
+  padding: 0 4px; /* Horizontal padding of content */
+}
+
+.CodeMirror-scrollbar-filler,
+.CodeMirror-gutter-filler {
+  background-color: white; /* The little square between H and V scrollbars */
+}
+
+/* GUTTER */
+
+.CodeMirror-gutters {
+  border-right: 1px solid #ddd;
+  background-color: #f7f7f7;
+  white-space: nowrap;
+}
+.CodeMirror-linenumbers {
+}
+.CodeMirror-linenumber {
+  padding: 0 3px 0 5px;
+  min-width: 20px;
+  text-align: right;
+  color: #999;
+  white-space: nowrap;
+}
+
+.CodeMirror-guttermarker {
+  color: black;
+}
+.CodeMirror-guttermarker-subtle {
+  color: #999;
+}
+
+/* CURSOR */
+
+.CodeMirror-cursor {
+  border-left: 1px solid black;
+  border-right: none;
+  width: 0;
+}
+/* Shown when moving in bi-directional text */
+.CodeMirror div.CodeMirror-secondarycursor {
+  border-left: 1px solid silver;
+}
+.cm-fat-cursor .CodeMirror-cursor {
+  width: auto;
+  border: 0 !important;
+  background: #7e7;
+}
+.cm-fat-cursor div.CodeMirror-cursors {
+  z-index: 1;
+}
+
+.cm-animate-fat-cursor {
+  width: auto;
+  border: 0;
+  -webkit-animation: blink 1.06s steps(1) infinite;
+  -moz-animation: blink 1.06s steps(1) infinite;
+  animation: blink 1.06s steps(1) infinite;
+  background-color: #7e7;
+}
+@-moz-keyframes blink {
+  0% {
+  }
+  50% {
+    background-color: transparent;
+  }
+  100% {
+  }
+}
+@-webkit-keyframes blink {
+  0% {
+  }
+  50% {
+    background-color: transparent;
+  }
+  100% {
+  }
+}
+@keyframes blink {
+  0% {
+  }
+  50% {
+    background-color: transparent;
+  }
+  100% {
+  }
+}
+
+/* Can style cursor different in overwrite (non-insert) mode */
+.CodeMirror-overwrite .CodeMirror-cursor {
+}
+
+.cm-tab {
+  display: inline-block;
+  text-decoration: inherit;
+}
+
+.CodeMirror-rulers {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: -50px;
+  bottom: -20px;
+  overflow: hidden;
+}
+.CodeMirror-ruler {
+  border-left: 1px solid #ccc;
+  top: 0;
+  bottom: 0;
+  position: absolute;
+}
+
+/* DEFAULT THEME */
+
+.cm-s-default .cm-header {
+  color: blue;
+}
+.cm-s-default .cm-quote {
+  color: #090;
+}
+.cm-negative {
+  color: #d44;
+}
+.cm-positive {
+  color: #292;
+}
+.cm-header,
+.cm-strong {
+  font-weight: bold;
+}
+.cm-em {
+  font-style: italic;
+}
+.cm-link {
+  text-decoration: underline;
+}
+.cm-strikethrough {
+  text-decoration: line-through;
+}
+
+.cm-s-default .cm-keyword {
+  color: #708;
+}
+.cm-s-default .cm-atom {
+  color: #219;
+}
+.cm-s-default .cm-number {
+  color: #164;
+}
+.cm-s-default .cm-def {
+  color: #00f;
+}
+.cm-s-default .cm-variable,
+.cm-s-default .cm-punctuation,
+.cm-s-default .cm-property,
+.cm-s-default .cm-operator {
+}
+.cm-s-default .cm-variable-2 {
+  color: #05a;
+}
+.cm-s-default .cm-variable-3,
+.cm-s-default .cm-type {
+  color: #085;
+}
+.cm-s-default .cm-comment {
+  color: #a50;
+}
+.cm-s-default .cm-string {
+  color: #a11;
+}
+.cm-s-default .cm-string-2 {
+  color: #f50;
+}
+.cm-s-default .cm-meta {
+  color: #555;
+}
+.cm-s-default .cm-qualifier {
+  color: #555;
+}
+.cm-s-default .cm-builtin {
+  color: #30a;
+}
+.cm-s-default .cm-bracket {
+  color: #997;
+}
+.cm-s-default .cm-tag {
+  color: #170;
+}
+.cm-s-default .cm-attribute {
+  color: #00c;
+}
+.cm-s-default .cm-hr {
+  color: #999;
+}
+.cm-s-default .cm-link {
+  color: #00c;
+}
+
+.cm-s-default .cm-error {
+  color: #f00;
+}
+.cm-invalidchar {
+  color: #f00;
+}
+
+.CodeMirror-composing {
+  border-bottom: 2px solid;
+}
+
+/* Default styles for common addons */
+
+div.CodeMirror span.CodeMirror-matchingbracket {
+  color: #0f0;
+}
+div.CodeMirror span.CodeMirror-nonmatchingbracket {
+  color: #f22;
+}
+.CodeMirror-matchingtag {
+  background: rgba(255, 150, 0, 0.3);
+}
+.CodeMirror-activeline-background {
+  background: #e8f2ff;
+}
+
+/* STOP */
+
+/* The rest of this file contains styles related to the mechanics of
+   the editor. You probably shouldn't touch them. */
+
+.CodeMirror {
+  position: relative;
+  overflow: hidden;
+  background: white;
+}
+
+.CodeMirror-scroll {
+  overflow: scroll !important; /* Things will break if this is overridden */
+  /* 30px is the magic margin used to hide the element's real scrollbars */
+  /* See overflow: hidden in .CodeMirror */
+  margin-bottom: -30px;
+  margin-right: -30px;
+  padding-bottom: 30px;
+  height: 100%;
+  outline: none; /* Prevent dragging from highlighting the element */
+  position: relative;
+}
+.CodeMirror-sizer {
+  position: relative;
+  border-right: 30px solid transparent;
+}
+
+/* The fake, visible scrollbars. Used to force redraw during scrolling
+   before actual scrolling happens, thus preventing shaking and
+   flickering artifacts. */
+.CodeMirror-vscrollbar,
+.CodeMirror-hscrollbar,
+.CodeMirror-scrollbar-filler,
+.CodeMirror-gutter-filler {
+  position: absolute;
+  z-index: 6;
+  display: none;
+}
+.CodeMirror-vscrollbar {
+  right: 0;
+  top: 0;
+  overflow-x: hidden;
+  overflow-y: scroll;
+}
+.CodeMirror-hscrollbar {
+  bottom: 0;
+  left: 0;
+  overflow-y: hidden;
+  overflow-x: scroll;
+}
+.CodeMirror-scrollbar-filler {
+  right: 0;
+  bottom: 0;
+}
+.CodeMirror-gutter-filler {
+  left: 0;
+  bottom: 0;
+}
+
+.CodeMirror-gutters {
+  position: absolute;
+  left: 0;
+  top: 0;
+  min-height: 100%;
+  z-index: 3;
+}
+.CodeMirror-gutter {
+  white-space: normal;
+  height: 100%;
+  display: inline-block;
+  vertical-align: top;
+  margin-bottom: -30px;
+}
+.CodeMirror-gutter-wrapper {
+  position: absolute;
+  z-index: 4;
+  background: none !important;
+  border: none !important;
+}
+.CodeMirror-gutter-background {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  z-index: 4;
+}
+.CodeMirror-gutter-elt {
+  position: absolute;
+  cursor: default;
+  z-index: 4;
+}
+.CodeMirror-gutter-wrapper ::selection {
+  background-color: transparent;
+}
+.CodeMirror-gutter-wrapper ::-moz-selection {
+  background-color: transparent;
+}
+
+.CodeMirror-lines {
+  cursor: text;
+  min-height: 1px; /* prevents collapsing before first draw */
+}
+.CodeMirror pre {
+  /* Reset some styles that the rest of the page might have set */
+  -moz-border-radius: 0;
+  -webkit-border-radius: 0;
+  border-radius: 0;
+  border-width: 0;
+  background: transparent;
+  font-family: inherit;
+  font-size: inherit;
+  margin: 0;
+  white-space: pre;
+  word-wrap: normal;
+  line-height: inherit;
+  color: inherit;
+  z-index: 2;
+  position: relative;
+  overflow: visible;
+  -webkit-tap-highlight-color: transparent;
+  -webkit-font-variant-ligatures: contextual;
+  font-variant-ligatures: contextual;
+}
+.CodeMirror-wrap pre {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  word-break: normal;
+}
+
+.CodeMirror-linebackground {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  z-index: 0;
+}
+
+.CodeMirror-linewidget {
+  position: relative;
+  z-index: 2;
+  overflow: auto;
+}
+
+.CodeMirror-widget {
+}
+
+.CodeMirror-rtl pre {
+  direction: rtl;
+}
+
+.CodeMirror-code {
+  outline: none;
+}
+
+/* Force content-box sizing for the elements where we expect it */
+.CodeMirror-scroll,
+.CodeMirror-sizer,
+.CodeMirror-gutter,
+.CodeMirror-gutters,
+.CodeMirror-linenumber {
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+}
+
+.CodeMirror-measure {
+  position: absolute;
+  width: 100%;
+  height: 0;
+  overflow: hidden;
+  visibility: hidden;
+}
+
+.CodeMirror-cursor {
+  position: absolute;
+  pointer-events: none;
+}
+.CodeMirror-measure pre {
+  position: static;
+}
+
+div.CodeMirror-cursors {
+  visibility: hidden;
+  position: relative;
+  z-index: 3;
+}
+div.CodeMirror-dragcursors {
+  visibility: visible;
+}
+
+.CodeMirror-focused div.CodeMirror-cursors {
+  visibility: visible;
+}
+
+.CodeMirror-selected {
+  background: #d9d9d9;
+}
+.CodeMirror-focused .CodeMirror-selected {
+  background: #d7d4f0;
+}
+.CodeMirror-crosshair {
+  cursor: crosshair;
+}
+.CodeMirror-line::selection,
+.CodeMirror-line > span::selection,
+.CodeMirror-line > span > span::selection {
+  background: #d7d4f0;
+}
+.CodeMirror-line::-moz-selection,
+.CodeMirror-line > span::-moz-selection,
+.CodeMirror-line > span > span::-moz-selection {
+  background: #d7d4f0;
+}
+
+.cm-searching {
+  background: #ffa;
+  background: rgba(255, 255, 0, 0.4);
+}
+
+/* Used to force a border model for a node */
+.cm-force-border {
+  padding-right: 0.1px;
+}
+
+@media print {
+  /* Hide the cursor when printing */
+  .CodeMirror div.CodeMirror-cursors {
+    visibility: hidden;
+  }
+}
+
+/* See issue #2901 */
+.cm-tab-wrap-hack:after {
+  content: '';
+}
+
+/* Help users use markselection to safely style text background */
+span.CodeMirror-selectedtext {
+  background: none;
+}

console/src/main/resources/static/console-fe/public/css/icon.css

@@ -0,0 +1,269 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@font-face {
+  /*无边框*/
+  font-family: 'iconfont-1';
+  src: url('icon1/iconfont.eot?t=1458627591'); /* IE9*/
+  src: url('icon1/iconfont.eot?t=1458627591#iefix') format('embedded-opentype'),
+    /* IE6-IE8 */ url('icon1/iconfont.woff?t=1458627591') format('woff'),
+    /* chrome, firefox */ url('icon1/iconfont.ttf?t=1458627591') format('truetype'),
+    /* chrome, firefox, opera, Safari, Android, iOS 4.2+*/
+      url('icon1/iconfont.svg?t=1458627591#iconfont') format('svg'); /* iOS 4.1- */
+}
+
+@font-face {
+  /*有边框*/
+  font-family: 'iconfont-2';
+  src: url('icon/iconfont.eot'); /* IE9*/
+  src: url('icon/iconfont.eot?#iefix') format('embedded-opentype'),
+    /* IE6-IE8 */ url('icon/iconfont.woff') format('woff'),
+    /* chrome, firefox */ url('icon/iconfont.ttf') format('truetype'),
+    /* chrome, firefox, opera, Safari, Android, iOS 4.2+*/ url('icon/iconfont.svg#iconfont')
+      format('svg'); /* iOS 4.1- */
+}
+
+.iconfont {
+  /* 有边框 */
+  font-family: 'iconfont' !important;
+  font-size: 16px;
+  font-style: normal;
+  -webkit-font-smoothing: antialiased;
+  -webkit-text-stroke-width: 0.2px;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+.iconfont-1 {
+  /*无边框*/
+
+  font-family: 'iconfont-1' !important;
+  font-size: 16px;
+  font-style: normal;
+  -webkit-font-smoothing: antialiased;
+  -webkit-text-stroke-width: 0.2px;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+.iconfont-2 {
+  /*有边框*/
+  font-family: 'iconfont-2' !important;
+  font-size: 16px;
+  font-style: normal;
+  -webkit-font-smoothing: antialiased;
+  -webkit-text-stroke-width: 0.2px;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+.logo {
+}
+
+.panel-logo {
+  padding-right: 2px;
+  font-size: 18px;
+  display: inline-block;
+  color: #333;
+}
+
+.icon-lg {
+  font-size: 80px !important;
+}
+
+.icon-size-md {
+  font-size: 40px !important;
+  vertical-align: middle;
+}
+
+.icon-size-lg {
+  font-size: 80px !important;
+  vertical-align: middle;
+}
+
+.icon-hsf:before {
+  content: '\e62f' !important;
+}
+
+.icon-rocketmq:before {
+  content: '\e632' !important;
+}
+
+.icon-notify:before {
+  content: '\e61e' !important;
+}
+
+.icon-tddl:before {
+  content: '\e61e' !important;
+}
+
+.icon-pandora:before {
+  content: '\e622' !important;
+}
+
+.icon-ailtomcat:before {
+  content: '\e628' !important;
+}
+
+.icon-configserver:before {
+  content: '\e61e' !important;
+}
+
+.icon-diamondserver:before {
+  content: '\e62a' !important;
+}
+
+.icon-vipserver:before {
+  content: '\e625' !important;
+}
+
+.icon-eagleeye:before {
+  content: '\e62c' !important;
+}
+
+.icon-tengine:before {
+  content: '\e635' !important;
+}
+
+.icon-tair:before {
+  content: '\e634' !important;
+}
+
+.icon-hbase:before {
+  content: '\e62d' !important;
+}
+
+.icon-jstorm:before {
+  content: '\e627' !important;
+}
+
+.icon-histore:before {
+  content: '\e62e' !important;
+}
+
+.icon-jingwei:before {
+  content: '\e61e' !important;
+}
+
+.icon-txc:before {
+  content: '\e636' !important;
+}
+
+.icon-edas:before {
+  content: '\e620' !important;
+}
+
+.icon-csb:before {
+  content: '\e61e' !important;
+}
+
+.icon-ons:before {
+  content: '\e630' !important;
+}
+
+.icon-drds:before {
+  content: '\e61f' !important;
+}
+
+.icon-duct:before {
+  content: '\e62b' !important;
+}
+
+.icon-amazon:before {
+  content: '\e61e' !important;
+}
+
+.icon-autoload:before {
+  content: '\e61e' !important;
+}
+
+.icon-switch:before {
+  content: '\e633' !important;
+}
+
+.icon-sentinel:before {
+  content: '\e623' !important;
+}
+
+.icon-preplan:before {
+  content: '\e631' !important;
+}
+
+.icon-moses:before {
+  content: '\e61e' !important;
+}
+
+.icon-zeus:before {
+  content: '\e61e' !important;
+}
+
+.icon-athena:before {
+  content: '\e61e' !important;
+}
+
+.icon-bcp:before {
+  content: '\e61e' !important;
+}
+
+.icon-lark:before {
+  content: '\e61e' !important;
+}
+
+.icon-nest:before {
+  content: '\e61e' !important;
+}
+
+.icon-monkeyking:before {
+  content: '\e61e' !important;
+}
+
+.icon-tab:before {
+  content: '\e61e' !important;
+}
+
+.icon-oceanus:before {
+  content: '\e61e' !important;
+}
+
+.icon-eos :before {
+  content: '\e61e' !important;
+}
+
+.icon-sonar:before {
+  content: '\e61e' !important;
+}
+
+.icon-ai:before {
+  content: '\e605' !important;
+}
+
+.icon-hotcode:before {
+  content: '\e621' !important;
+}
+
+.icon-taokeeper:before {
+  content: '\e624' !important;
+}
+
+.icon-mdl:before {
+  content: '\e61e' !important;
+}
+
+.icon-mw:before {
+  content: '\e61e' !important;
+}
+
+.icon-default:before {
+  content: '\e607' !important;
+}
+
+.icon-alitomcat:before {
+  content: '\e607' !important;
+}

console/src/main/resources/static/console-fe/public/css/merge.css

@@ -0,0 +1,173 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+.CodeMirror-merge {
+  position: relative;
+  border: 1px solid #ddd;
+  white-space: pre;
+}
+
+.CodeMirror-merge,
+.CodeMirror-merge .CodeMirror {
+  height: 350px;
+}
+
+.CodeMirror-merge-2pane .CodeMirror-merge-pane {
+  width: 47%;
+}
+.CodeMirror-merge-2pane .CodeMirror-merge-gap {
+  width: 6%;
+}
+.CodeMirror-merge-3pane .CodeMirror-merge-pane {
+  width: 31%;
+}
+.CodeMirror-merge-3pane .CodeMirror-merge-gap {
+  width: 3.5%;
+}
+
+.CodeMirror-merge-pane {
+  display: inline-block;
+  white-space: normal;
+  vertical-align: top;
+}
+.CodeMirror-merge-pane-rightmost {
+  position: absolute;
+  right: 0px;
+  z-index: 1;
+}
+
+.CodeMirror-merge-gap {
+  z-index: 2;
+  display: inline-block;
+  height: 100%;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  overflow: hidden;
+  border-left: 1px solid #ddd;
+  border-right: 1px solid #ddd;
+  position: relative;
+  background: #f8f8f8;
+}
+
+.CodeMirror-merge-scrolllock-wrap {
+  position: absolute;
+  bottom: 0;
+  left: 50%;
+}
+.CodeMirror-merge-scrolllock {
+  position: relative;
+  left: -50%;
+  cursor: pointer;
+  color: #555;
+  line-height: 1;
+}
+
+.CodeMirror-merge-copybuttons-left,
+.CodeMirror-merge-copybuttons-right {
+  position: absolute;
+  left: 0;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  line-height: 1;
+}
+
+.CodeMirror-merge-copy {
+  position: absolute;
+  cursor: pointer;
+  color: #44c;
+  z-index: 3;
+}
+
+.CodeMirror-merge-copy-reverse {
+  position: absolute;
+  cursor: pointer;
+  color: #44c;
+}
+
+.CodeMirror-merge-copybuttons-left .CodeMirror-merge-copy {
+  left: 2px;
+}
+.CodeMirror-merge-copybuttons-right .CodeMirror-merge-copy {
+  right: 2px;
+}
+
+.CodeMirror-merge-r-inserted,
+.CodeMirror-merge-l-inserted {
+  background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAYAAACddGYaAAAAGUlEQVQI12MwuCXy3+CWyH8GBgYGJgYkAABZbAQ9ELXurwAAAABJRU5ErkJggg==);
+  background-position: bottom left;
+  background-repeat: repeat-x;
+}
+
+.CodeMirror-merge-r-deleted,
+.CodeMirror-merge-l-deleted {
+  background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAYAAACddGYaAAAAGUlEQVQI12M4Kyb2/6yY2H8GBgYGJgYkAABURgPz6Ks7wQAAAABJRU5ErkJggg==);
+  background-position: bottom left;
+  background-repeat: repeat-x;
+}
+
+.CodeMirror-merge-r-chunk {
+  background: #ffffe0;
+}
+.CodeMirror-merge-r-chunk-start {
+  border-top: 1px solid #ee8;
+}
+.CodeMirror-merge-r-chunk-end {
+  border-bottom: 1px solid #ee8;
+}
+.CodeMirror-merge-r-connect {
+  fill: #ffffe0;
+  stroke: #ee8;
+  stroke-width: 1px;
+}
+
+.CodeMirror-merge-l-chunk {
+  background: #eef;
+}
+.CodeMirror-merge-l-chunk-start {
+  border-top: 1px solid #88e;
+}
+.CodeMirror-merge-l-chunk-end {
+  border-bottom: 1px solid #88e;
+}
+.CodeMirror-merge-l-connect {
+  fill: #eef;
+  stroke: #88e;
+  stroke-width: 1px;
+}
+
+.CodeMirror-merge-l-chunk.CodeMirror-merge-r-chunk {
+  background: #dfd;
+}
+.CodeMirror-merge-l-chunk-start.CodeMirror-merge-r-chunk-start {
+  border-top: 1px solid #4e4;
+}
+.CodeMirror-merge-l-chunk-end.CodeMirror-merge-r-chunk-end {
+  border-bottom: 1px solid #4e4;
+}
+
+.CodeMirror-merge-collapsed-widget:before {
+  content: '(...)';
+}
+.CodeMirror-merge-collapsed-widget {
+  cursor: pointer;
+  color: #88b;
+  background: #eef;
+  border: 1px solid #ddf;
+  font-size: 90%;
+  padding: 0 3px;
+  border-radius: 4px;
+}
+.CodeMirror-merge-collapsed-line .CodeMirror-gutter-elt {
+  display: none;
+}

console/src/main/resources/static/console-fe/public/js/codemirror.addone.fullscreen.js

@@ -0,0 +1,58 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+(function(mod) {
+  if (typeof exports == 'object' && typeof module == 'object')
+    // CommonJS
+    mod(require('../../lib/codemirror'));
+  else if (typeof define == 'function' && define.amd)
+    // AMD
+    define(['../../lib/codemirror'], mod);
+  // Plain browser env
+  else mod(CodeMirror);
+})(function(CodeMirror) {
+  'use strict';
+
+  CodeMirror.defineOption('fullScreen', false, function(cm, val, old) {
+    if (old == CodeMirror.Init) old = false;
+    if (!old == !val) return;
+    if (val) setFullscreen(cm);
+    else setNormal(cm);
+  });
+
+  function setFullscreen(cm) {
+    var wrap = cm.getWrapperElement();
+    cm.state.fullScreenRestore = {
+      scrollTop: window.pageYOffset,
+      scrollLeft: window.pageXOffset,
+      width: wrap.style.width,
+      height: wrap.style.height,
+    };
+    wrap.style.width = '';
+    wrap.style.height = 'auto';
+    wrap.className += ' CodeMirror-fullscreen';
+    document.documentElement.style.overflow = 'hidden';
+    cm.refresh();
+  }
+
+  function setNormal(cm) {
+    var wrap = cm.getWrapperElement();
+    wrap.className = wrap.className.replace(/\s*CodeMirror-fullscreen\b/, '');
+    document.documentElement.style.overflow = '';
+    var info = cm.state.fullScreenRestore;
+    wrap.style.width = info.width;
+    wrap.style.height = info.height;
+    window.scrollTo(info.scrollLeft, info.scrollTop);
+    cm.refresh();
+  }
+});

console/src/main/resources/static/console-fe/public/js/codemirror.addone.json-lint.js

@@ -0,0 +1,45 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Depends on jsonlint.js from https://github.com/zaach/jsonlint
+
+// declare global: jsonlint
+
+(function(mod) {
+  if (typeof exports == 'object' && typeof module == 'object')
+    // CommonJS
+    mod(require('../../lib/codemirror'));
+  else if (typeof define == 'function' && define.amd)
+    // AMD
+    define(['../../lib/codemirror'], mod);
+  // Plain browser env
+  else mod(CodeMirror);
+})(function(CodeMirror) {
+  'use strict';
+
+  CodeMirror.registerHelper('lint', 'json', function(text) {
+    var found = [];
+    jsonlint.parseError = function(str, hash) {
+      var loc = hash.loc;
+      found.push({
+        from: CodeMirror.Pos(loc.first_line - 1, loc.first_column),
+        to: CodeMirror.Pos(loc.last_line - 1, loc.last_column),
+        message: str,
+      });
+    };
+    try {
+      jsonlint.parse(text);
+    } catch (e) {}
+    return found;
+  });
+});

console/src/main/resources/static/console-fe/public/js/codemirror.addone.lint.js

@@ -0,0 +1,279 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+(function(mod) {
+  if (typeof exports == 'object' && typeof module == 'object')
+    // CommonJS
+    mod(require('../../lib/codemirror'));
+  else if (typeof define == 'function' && define.amd)
+    // AMD
+    define(['../../lib/codemirror'], mod);
+  // Plain browser env
+  else mod(CodeMirror);
+})(function(CodeMirror) {
+  'use strict';
+  var GUTTER_ID = 'CodeMirror-lint-markers';
+
+  function showTooltip(e, content) {
+    var tt = document.createElement('div');
+    tt.className = 'CodeMirror-lint-tooltip';
+    tt.appendChild(content.cloneNode(true));
+    document.body.appendChild(tt);
+
+    function position(e) {
+      if (!tt.parentNode) return CodeMirror.off(document, 'mousemove', position);
+      tt.style.top = Math.max(0, e.clientY - tt.offsetHeight - 5) + 'px';
+      tt.style.left = e.clientX + 5 + 'px';
+    }
+    CodeMirror.on(document, 'mousemove', position);
+    position(e);
+    if (tt.style.opacity != null) tt.style.opacity = 1;
+    return tt;
+  }
+  function rm(elt) {
+    if (elt.parentNode) elt.parentNode.removeChild(elt);
+  }
+  function hideTooltip(tt) {
+    if (!tt.parentNode) return;
+    if (tt.style.opacity == null) rm(tt);
+    tt.style.opacity = 0;
+    setTimeout(function() {
+      rm(tt);
+    }, 600);
+  }
+
+  function showTooltipFor(e, content, node) {
+    var tooltip = showTooltip(e, content);
+    function hide() {
+      CodeMirror.off(node, 'mouseout', hide);
+      if (tooltip) {
+        hideTooltip(tooltip);
+        tooltip = null;
+      }
+    }
+    var poll = setInterval(function() {
+      if (tooltip)
+        for (var n = node; ; n = n.parentNode) {
+          if (n && n.nodeType == 11) n = n.host;
+          if (n == document.body) return;
+          if (!n) {
+            hide();
+            break;
+          }
+        }
+      if (!tooltip) return clearInterval(poll);
+    }, 400);
+    CodeMirror.on(node, 'mouseout', hide);
+  }
+
+  function LintState(cm, options, hasGutter) {
+    this.marked = [];
+    this.options = options;
+    this.timeout = null;
+    this.hasGutter = hasGutter;
+    this.onMouseOver = function(e) {
+      onMouseOver(cm, e);
+    };
+    this.waitingFor = 0;
+  }
+
+  function parseOptions(_cm, options) {
+    if (options instanceof Function) return { getAnnotations: options };
+    if (!options || options === true) options = {};
+    return options;
+  }
+
+  function clearMarks(cm) {
+    var state = cm.state.lint;
+    if (state.hasGutter) cm.clearGutter(GUTTER_ID);
+    for (var i = 0; i < state.marked.length; ++i) state.marked[i].clear();
+    state.marked.length = 0;
+  }
+
+  function makeMarker(labels, severity, multiple, tooltips) {
+    var marker = document.createElement('div'),
+      inner = marker;
+    marker.className = 'CodeMirror-lint-marker-' + severity;
+    if (multiple) {
+      inner = marker.appendChild(document.createElement('div'));
+      inner.className = 'CodeMirror-lint-marker-multiple';
+    }
+
+    if (tooltips != false)
+      CodeMirror.on(inner, 'mouseover', function(e) {
+        showTooltipFor(e, labels, inner);
+      });
+
+    return marker;
+  }
+
+  function getMaxSeverity(a, b) {
+    if (a == 'error') return a;
+    else return b;
+  }
+
+  function groupByLine(annotations) {
+    var lines = [];
+    for (var i = 0; i < annotations.length; ++i) {
+      var ann = annotations[i],
+        line = ann.from.line;
+      (lines[line] || (lines[line] = [])).push(ann);
+    }
+    return lines;
+  }
+
+  function annotationTooltip(ann) {
+    var severity = ann.severity;
+    if (!severity) severity = 'error';
+    var tip = document.createElement('div');
+    tip.className = 'CodeMirror-lint-message-' + severity;
+    tip.appendChild(document.createTextNode(ann.message));
+    return tip;
+  }
+
+  function lintAsync(cm, getAnnotations, passOptions) {
+    var state = cm.state.lint;
+    var id = ++state.waitingFor;
+    function abort() {
+      id = -1;
+      cm.off('change', abort);
+    }
+    cm.on('change', abort);
+    getAnnotations(
+      cm.getValue(),
+      function(annotations, arg2) {
+        cm.off('change', abort);
+        if (state.waitingFor != id) return;
+        if (arg2 && annotations instanceof CodeMirror) annotations = arg2;
+        updateLinting(cm, annotations);
+      },
+      passOptions,
+      cm
+    );
+  }
+
+  function startLinting(cm) {
+    var state = cm.state.lint,
+      options = state.options;
+    var passOptions = options.options || options; // Support deprecated passing of `options` property in options
+    var getAnnotations = options.getAnnotations || cm.getHelper(CodeMirror.Pos(0, 0), 'lint');
+    if (!getAnnotations) return;
+    if (options.async || getAnnotations.async) {
+      lintAsync(cm, getAnnotations, passOptions);
+    } else {
+      updateLinting(cm, getAnnotations(cm.getValue(), passOptions, cm));
+    }
+  }
+
+  function updateLinting(cm, annotationsNotSorted) {
+    clearMarks(cm);
+    var state = cm.state.lint,
+      options = state.options;
+
+    var annotations = groupByLine(annotationsNotSorted);
+
+    for (var line = 0; line < annotations.length; ++line) {
+      var anns = annotations[line];
+      if (!anns) continue;
+
+      var maxSeverity = null;
+      var tipLabel = state.hasGutter && document.createDocumentFragment();
+
+      for (var i = 0; i < anns.length; ++i) {
+        var ann = anns[i];
+        var severity = ann.severity;
+        if (!severity) severity = 'error';
+        maxSeverity = getMaxSeverity(maxSeverity, severity);
+
+        if (options.formatAnnotation) ann = options.formatAnnotation(ann);
+        if (state.hasGutter) tipLabel.appendChild(annotationTooltip(ann));
+
+        if (ann.to)
+          state.marked.push(
+            cm.markText(ann.from, ann.to, {
+              className: 'CodeMirror-lint-mark-' + severity,
+              __annotation: ann,
+            })
+          );
+      }
+
+      if (state.hasGutter)
+        cm.setGutterMarker(
+          line,
+          GUTTER_ID,
+          makeMarker(tipLabel, maxSeverity, anns.length > 1, state.options.tooltips)
+        );
+    }
+    if (options.onUpdateLinting) options.onUpdateLinting(annotationsNotSorted, annotations, cm);
+  }
+
+  function onChange(cm) {
+    var state = cm.state.lint;
+    if (!state) return;
+    clearTimeout(state.timeout);
+    state.timeout = setTimeout(function() {
+      startLinting(cm);
+    }, state.options.delay || 500);
+  }
+
+  function popupTooltips(annotations, e) {
+    var target = e.target || e.srcElement;
+    var tooltip = document.createDocumentFragment();
+    for (var i = 0; i < annotations.length; i++) {
+      var ann = annotations[i];
+      tooltip.appendChild(annotationTooltip(ann));
+    }
+    showTooltipFor(e, tooltip, target);
+  }
+
+  function onMouseOver(cm, e) {
+    var target = e.target || e.srcElement;
+    if (!/\bCodeMirror-lint-mark-/.test(target.className)) return;
+    var box = target.getBoundingClientRect(),
+      x = (box.left + box.right) / 2,
+      y = (box.top + box.bottom) / 2;
+    var spans = cm.findMarksAt(cm.coordsChar({ left: x, top: y }, 'client'));
+
+    var annotations = [];
+    for (var i = 0; i < spans.length; ++i) {
+      annotations.push(spans[i].__annotation);
+    }
+    if (annotations.length) popupTooltips(annotations, e);
+  }
+
+  CodeMirror.defineOption('lint', false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init) {
+      clearMarks(cm);
+      if (cm.state.lint.options.lintOnChange !== false) cm.off('change', onChange);
+      CodeMirror.off(cm.getWrapperElement(), 'mouseover', cm.state.lint.onMouseOver);
+      clearTimeout(cm.state.lint.timeout);
+      delete cm.state.lint;
+    }
+
+    if (val) {
+      var gutters = cm.getOption('gutters'),
+        hasLintGutter = false;
+      for (var i = 0; i < gutters.length; ++i) if (gutters[i] == GUTTER_ID) hasLintGutter = true;
+      var state = (cm.state.lint = new LintState(cm, parseOptions(cm, val), hasLintGutter));
+      if (state.options.lintOnChange !== false) cm.on('change', onChange);
+      if (state.options.tooltips != false)
+        CodeMirror.on(cm.getWrapperElement(), 'mouseover', state.onMouseOver);
+
+      startLinting(cm);
+    }
+  });
+
+  CodeMirror.defineExtension('performLint', function() {
+    if (this.state.lint) startLinting(this);
+  });
+});

console/src/main/resources/static/console-fe/public/js/codemirror.lib.clike-lint.js

@@ -0,0 +1,859 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+(function(mod) {
+  if (typeof exports == 'object' && typeof module == 'object')
+    // CommonJS
+    mod(require('../../lib/codemirror'));
+  else if (typeof define == 'function' && define.amd)
+    // AMD
+    define(['../../lib/codemirror'], mod);
+  // Plain browser env
+  else mod(CodeMirror);
+})(function(CodeMirror) {
+  'use strict';
+
+  function Context(indented, column, type, info, align, prev) {
+    this.indented = indented;
+    this.column = column;
+    this.type = type;
+    this.info = info;
+    this.align = align;
+    this.prev = prev;
+  }
+  function pushContext(state, col, type, info) {
+    var indent = state.indented;
+    if (state.context && state.context.type == 'statement' && type != 'statement')
+      indent = state.context.indented;
+    return (state.context = new Context(indent, col, type, info, null, state.context));
+  }
+  function popContext(state) {
+    var t = state.context.type;
+    if (t == ')' || t == ']' || t == '}') state.indented = state.context.indented;
+    return (state.context = state.context.prev);
+  }
+
+  function typeBefore(stream, state, pos) {
+    if (state.prevToken == 'variable' || state.prevToken == 'type') return true;
+    if (/\S(?:[^- ]>|[*\]])\s*$|\*$/.test(stream.string.slice(0, pos))) return true;
+    if (state.typeAtEndOfLine && stream.column() == stream.indentation()) return true;
+  }
+
+  function isTopScope(context) {
+    for (;;) {
+      if (!context || context.type == 'top') return true;
+      if (context.type == '}' && context.prev.info != 'namespace') return false;
+      context = context.prev;
+    }
+  }
+
+  CodeMirror.defineMode('clike', function(config, parserConfig) {
+    var indentUnit = config.indentUnit,
+      statementIndentUnit = parserConfig.statementIndentUnit || indentUnit,
+      dontAlignCalls = parserConfig.dontAlignCalls,
+      keywords = parserConfig.keywords || {},
+      types = parserConfig.types || {},
+      builtin = parserConfig.builtin || {},
+      blockKeywords = parserConfig.blockKeywords || {},
+      defKeywords = parserConfig.defKeywords || {},
+      atoms = parserConfig.atoms || {},
+      hooks = parserConfig.hooks || {},
+      multiLineStrings = parserConfig.multiLineStrings,
+      indentStatements = parserConfig.indentStatements !== false,
+      indentSwitch = parserConfig.indentSwitch !== false,
+      namespaceSeparator = parserConfig.namespaceSeparator,
+      isPunctuationChar = parserConfig.isPunctuationChar || /[\[\]{}\(\),;\:\.]/,
+      numberStart = parserConfig.numberStart || /[\d\.]/,
+      number =
+        parserConfig.number ||
+        /^(?:0x[a-f\d]+|0b[01]+|(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(u|ll?|l|f)?/i,
+      isOperatorChar = parserConfig.isOperatorChar || /[+\-*&%=<>!?|\/]/,
+      isIdentifierChar = parserConfig.isIdentifierChar || /[\w\$_\xa1-\uffff]/;
+
+    var curPunc, isDefKeyword;
+
+    function tokenBase(stream, state) {
+      var ch = stream.next();
+      if (hooks[ch]) {
+        var result = hooks[ch](stream, state);
+        if (result !== false) return result;
+      }
+      if (ch == '"' || ch == "'") {
+        state.tokenize = tokenString(ch);
+        return state.tokenize(stream, state);
+      }
+      if (isPunctuationChar.test(ch)) {
+        curPunc = ch;
+        return null;
+      }
+      if (numberStart.test(ch)) {
+        stream.backUp(1);
+        if (stream.match(number)) return 'number';
+        stream.next();
+      }
+      if (ch == '/') {
+        if (stream.eat('*')) {
+          state.tokenize = tokenComment;
+          return tokenComment(stream, state);
+        }
+        if (stream.eat('/')) {
+          stream.skipToEnd();
+          return 'comment';
+        }
+      }
+      if (isOperatorChar.test(ch)) {
+        while (!stream.match(/^\/[\/*]/, false) && stream.eat(isOperatorChar)) {}
+        return 'operator';
+      }
+      stream.eatWhile(isIdentifierChar);
+      if (namespaceSeparator)
+        while (stream.match(namespaceSeparator)) stream.eatWhile(isIdentifierChar);
+
+      var cur = stream.current();
+      if (contains(keywords, cur)) {
+        if (contains(blockKeywords, cur)) curPunc = 'newstatement';
+        if (contains(defKeywords, cur)) isDefKeyword = true;
+        return 'keyword';
+      }
+      if (contains(types, cur)) return 'type';
+      if (contains(builtin, cur)) {
+        if (contains(blockKeywords, cur)) curPunc = 'newstatement';
+        return 'builtin';
+      }
+      if (contains(atoms, cur)) return 'atom';
+      return 'variable';
+    }
+
+    function tokenString(quote) {
+      return function(stream, state) {
+        var escaped = false,
+          next,
+          end = false;
+        while ((next = stream.next()) != null) {
+          if (next == quote && !escaped) {
+            end = true;
+            break;
+          }
+          escaped = !escaped && next == '\\';
+        }
+        if (end || !(escaped || multiLineStrings)) state.tokenize = null;
+        return 'string';
+      };
+    }
+
+    function tokenComment(stream, state) {
+      var maybeEnd = false,
+        ch;
+      while ((ch = stream.next())) {
+        if (ch == '/' && maybeEnd) {
+          state.tokenize = null;
+          break;
+        }
+        maybeEnd = ch == '*';
+      }
+      return 'comment';
+    }
+
+    function maybeEOL(stream, state) {
+      if (parserConfig.typeFirstDefinitions && stream.eol() && isTopScope(state.context))
+        state.typeAtEndOfLine = typeBefore(stream, state, stream.pos);
+    }
+
+    // Interface
+
+    return {
+      startState: function(basecolumn) {
+        return {
+          tokenize: null,
+          context: new Context((basecolumn || 0) - indentUnit, 0, 'top', null, false),
+          indented: 0,
+          startOfLine: true,
+          prevToken: null,
+        };
+      },
+
+      token: function(stream, state) {
+        var ctx = state.context;
+        if (stream.sol()) {
+          if (ctx.align == null) ctx.align = false;
+          state.indented = stream.indentation();
+          state.startOfLine = true;
+        }
+        if (stream.eatSpace()) {
+          maybeEOL(stream, state);
+          return null;
+        }
+        curPunc = isDefKeyword = null;
+        var style = (state.tokenize || tokenBase)(stream, state);
+        if (style == 'comment' || style == 'meta') return style;
+        if (ctx.align == null) ctx.align = true;
+
+        if (
+          curPunc == ';' ||
+          curPunc == ':' ||
+          (curPunc == ',' && stream.match(/^\s*(?:\/\/.*)?$/, false))
+        )
+          while (state.context.type == 'statement') popContext(state);
+        else if (curPunc == '{') pushContext(state, stream.column(), '}');
+        else if (curPunc == '[') pushContext(state, stream.column(), ']');
+        else if (curPunc == '(') pushContext(state, stream.column(), ')');
+        else if (curPunc == '}') {
+          while (ctx.type == 'statement') ctx = popContext(state);
+          if (ctx.type == '}') ctx = popContext(state);
+          while (ctx.type == 'statement') ctx = popContext(state);
+        } else if (curPunc == ctx.type) popContext(state);
+        else if (
+          indentStatements &&
+          (((ctx.type == '}' || ctx.type == 'top') && curPunc != ';') ||
+            (ctx.type == 'statement' && curPunc == 'newstatement'))
+        ) {
+          pushContext(state, stream.column(), 'statement', stream.current());
+        }
+
+        if (
+          style == 'variable' &&
+          (state.prevToken == 'def' ||
+            (parserConfig.typeFirstDefinitions &&
+              typeBefore(stream, state, stream.start) &&
+              isTopScope(state.context) &&
+              stream.match(/^\s*\(/, false)))
+        )
+          style = 'def';
+
+        if (hooks.token) {
+          var result = hooks.token(stream, state, style);
+          if (result !== undefined) style = result;
+        }
+
+        if (style == 'def' && parserConfig.styleDefs === false) style = 'variable';
+
+        state.startOfLine = false;
+        state.prevToken = isDefKeyword ? 'def' : style || curPunc;
+        maybeEOL(stream, state);
+        return style;
+      },
+
+      indent: function(state, textAfter) {
+        if ((state.tokenize != tokenBase && state.tokenize != null) || state.typeAtEndOfLine)
+          return CodeMirror.Pass;
+        var ctx = state.context,
+          firstChar = textAfter && textAfter.charAt(0);
+        if (ctx.type == 'statement' && firstChar == '}') ctx = ctx.prev;
+        if (parserConfig.dontIndentStatements)
+          while (ctx.type == 'statement' && parserConfig.dontIndentStatements.test(ctx.info))
+            ctx = ctx.prev;
+        if (hooks.indent) {
+          var hook = hooks.indent(state, ctx, textAfter);
+          if (typeof hook == 'number') return hook;
+        }
+        var closing = firstChar == ctx.type;
+        var switchBlock = ctx.prev && ctx.prev.info == 'switch';
+        if (parserConfig.allmanIndentation && /[{(]/.test(firstChar)) {
+          while (ctx.type != 'top' && ctx.type != '}') ctx = ctx.prev;
+          return ctx.indented;
+        }
+        if (ctx.type == 'statement')
+          return ctx.indented + (firstChar == '{' ? 0 : statementIndentUnit);
+        if (ctx.align && (!dontAlignCalls || ctx.type != ')'))
+          return ctx.column + (closing ? 0 : 1);
+        if (ctx.type == ')' && !closing) return ctx.indented + statementIndentUnit;
+
+        return (
+          ctx.indented +
+          (closing ? 0 : indentUnit) +
+          (!closing && switchBlock && !/^(?:case|default)\b/.test(textAfter) ? indentUnit : 0)
+        );
+      },
+
+      electricInput: indentSwitch ? /^\s*(?:case .*?:|default:|\{\}?|\})$/ : /^\s*[{}]$/,
+      blockCommentStart: '/*',
+      blockCommentEnd: '*/',
+      lineComment: '//',
+      fold: 'brace',
+    };
+  });
+
+  function words(str) {
+    var obj = {},
+      words = str.split(' ');
+    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+    return obj;
+  }
+  function contains(words, word) {
+    if (typeof words === 'function') {
+      return words(word);
+    } else {
+      return words.propertyIsEnumerable(word);
+    }
+  }
+  var cKeywords =
+    'auto if break case register continue return default do sizeof ' +
+    'static else struct switch extern typedef union for goto while enum const volatile';
+  var cTypes = 'int long char short double float unsigned signed void size_t ptrdiff_t';
+
+  function cppHook(stream, state) {
+    if (!state.startOfLine) return false;
+    for (var ch, next = null; (ch = stream.peek()); ) {
+      if (ch == '\\' && stream.match(/^.$/)) {
+        next = cppHook;
+        break;
+      } else if (ch == '/' && stream.match(/^\/[\/\*]/, false)) {
+        break;
+      }
+      stream.next();
+    }
+    state.tokenize = next;
+    return 'meta';
+  }
+
+  function pointerHook(_stream, state) {
+    if (state.prevToken == 'type') return 'type';
+    return false;
+  }
+
+  function cpp14Literal(stream) {
+    stream.eatWhile(/[\w\.']/);
+    return 'number';
+  }
+
+  function cpp11StringHook(stream, state) {
+    stream.backUp(1);
+    // Raw strings.
+    if (stream.match(/(R|u8R|uR|UR|LR)/)) {
+      var match = stream.match(/"([^\s\\()]{0,16})\(/);
+      if (!match) {
+        return false;
+      }
+      state.cpp11RawStringDelim = match[1];
+      state.tokenize = tokenRawString;
+      return tokenRawString(stream, state);
+    }
+    // Unicode strings/chars.
+    if (stream.match(/(u8|u|U|L)/)) {
+      if (stream.match(/["']/, /* eat */ false)) {
+        return 'string';
+      }
+      return false;
+    }
+    // Ignore this hook.
+    stream.next();
+    return false;
+  }
+
+  function cppLooksLikeConstructor(word) {
+    var lastTwo = /(\w+)::~?(\w+)$/.exec(word);
+    return lastTwo && lastTwo[1] == lastTwo[2];
+  }
+
+  // C#-style strings where "" escapes a quote.
+  function tokenAtString(stream, state) {
+    var next;
+    while ((next = stream.next()) != null) {
+      if (next == '"' && !stream.eat('"')) {
+        state.tokenize = null;
+        break;
+      }
+    }
+    return 'string';
+  }
+
+  // C++11 raw string literal is <prefix>"<delim>( anything )<delim>", where
+  // <delim> can be a string up to 16 characters long.
+  function tokenRawString(stream, state) {
+    // Escape characters that have special regex meanings.
+    var delim = state.cpp11RawStringDelim.replace(/[^\w\s]/g, '\\$&');
+    var match = stream.match(new RegExp('.*?\\)' + delim + '"'));
+    if (match) state.tokenize = null;
+    else stream.skipToEnd();
+    return 'string';
+  }
+
+  function def(mimes, mode) {
+    if (typeof mimes == 'string') mimes = [mimes];
+    var words = [];
+    function add(obj) {
+      if (obj) for (var prop in obj) if (obj.hasOwnProperty(prop)) words.push(prop);
+    }
+    add(mode.keywords);
+    add(mode.types);
+    add(mode.builtin);
+    add(mode.atoms);
+    if (words.length) {
+      mode.helperType = mimes[0];
+      CodeMirror.registerHelper('hintWords', mimes[0], words);
+    }
+
+    for (var i = 0; i < mimes.length; ++i) CodeMirror.defineMIME(mimes[i], mode);
+  }
+
+  def(['text/x-csrc', 'text/x-c', 'text/x-chdr'], {
+    name: 'clike',
+    keywords: words(cKeywords),
+    types: words(
+      cTypes +
+        ' bool _Complex _Bool float_t double_t intptr_t intmax_t ' +
+        'int8_t int16_t int32_t int64_t uintptr_t uintmax_t uint8_t uint16_t ' +
+        'uint32_t uint64_t'
+    ),
+    blockKeywords: words('case do else for if switch while struct'),
+    defKeywords: words('struct'),
+    typeFirstDefinitions: true,
+    atoms: words('null true false'),
+    hooks: { '#': cppHook, '*': pointerHook },
+    modeProps: { fold: ['brace', 'include'] },
+  });
+
+  def(['text/x-c++src', 'text/x-c++hdr'], {
+    name: 'clike',
+    keywords: words(
+      cKeywords +
+        ' asm dynamic_cast namespace reinterpret_cast try explicit new ' +
+        'static_cast typeid catch operator template typename class friend private ' +
+        'this using const_cast inline public throw virtual delete mutable protected ' +
+        'alignas alignof constexpr decltype nullptr noexcept thread_local final ' +
+        'static_assert override'
+    ),
+    types: words(cTypes + ' bool wchar_t'),
+    blockKeywords: words('catch class do else finally for if struct switch try while'),
+    defKeywords: words('class namespace struct enum union'),
+    typeFirstDefinitions: true,
+    atoms: words('true false null'),
+    dontIndentStatements: /^template$/,
+    isIdentifierChar: /[\w\$_~\xa1-\uffff]/,
+    hooks: {
+      '#': cppHook,
+      '*': pointerHook,
+      u: cpp11StringHook,
+      U: cpp11StringHook,
+      L: cpp11StringHook,
+      R: cpp11StringHook,
+      '0': cpp14Literal,
+      '1': cpp14Literal,
+      '2': cpp14Literal,
+      '3': cpp14Literal,
+      '4': cpp14Literal,
+      '5': cpp14Literal,
+      '6': cpp14Literal,
+      '7': cpp14Literal,
+      '8': cpp14Literal,
+      '9': cpp14Literal,
+      token: function(stream, state, style) {
+        if (
+          style == 'variable' &&
+          stream.peek() == '(' &&
+          (state.prevToken == ';' || state.prevToken == null || state.prevToken == '}') &&
+          cppLooksLikeConstructor(stream.current())
+        )
+          return 'def';
+      },
+    },
+    namespaceSeparator: '::',
+    modeProps: { fold: ['brace', 'include'] },
+  });
+
+  def('text/x-java', {
+    name: 'clike',
+    keywords: words(
+      'abstract assert break case catch class const continue default ' +
+        'do else enum extends final finally float for goto if implements import ' +
+        'instanceof interface native new package private protected public ' +
+        'return static strictfp super switch synchronized this throw throws transient ' +
+        'try volatile while @interface'
+    ),
+    types: words(
+      'byte short int long float double boolean char void Boolean Byte Character Double Float ' +
+        'Integer Long Number Object Short String StringBuffer StringBuilder Void'
+    ),
+    blockKeywords: words('catch class do else finally for if switch try while'),
+    defKeywords: words('class interface package enum @interface'),
+    typeFirstDefinitions: true,
+    atoms: words('true false null'),
+    number: /^(?:0x[a-f\d_]+|0b[01_]+|(?:[\d_]+\.?\d*|\.\d+)(?:e[-+]?[\d_]+)?)(u|ll?|l|f)?/i,
+    hooks: {
+      '@': function(stream) {
+        // Don't match the @interface keyword.
+        if (stream.match('interface', false)) return false;
+
+        stream.eatWhile(/[\w\$_]/);
+        return 'meta';
+      },
+    },
+    modeProps: { fold: ['brace', 'import'] },
+  });
+
+  def('text/x-csharp', {
+    name: 'clike',
+    keywords: words(
+      'abstract as async await base break case catch checked class const continue' +
+        ' default delegate do else enum event explicit extern finally fixed for' +
+        ' foreach goto if implicit in interface internal is lock namespace new' +
+        ' operator out override params private protected public readonly ref return sealed' +
+        ' sizeof stackalloc static struct switch this throw try typeof unchecked' +
+        ' unsafe using virtual void volatile while add alias ascending descending dynamic from get' +
+        ' global group into join let orderby partial remove select set value var yield'
+    ),
+    types: words(
+      'Action Boolean Byte Char DateTime DateTimeOffset Decimal Double Func' +
+        ' Guid Int16 Int32 Int64 Object SByte Single String Task TimeSpan UInt16 UInt32' +
+        ' UInt64 bool byte char decimal double short int long object' +
+        ' sbyte float string ushort uint ulong'
+    ),
+    blockKeywords: words('catch class do else finally for foreach if struct switch try while'),
+    defKeywords: words('class interface namespace struct var'),
+    typeFirstDefinitions: true,
+    atoms: words('true false null'),
+    hooks: {
+      '@': function(stream, state) {
+        if (stream.eat('"')) {
+          state.tokenize = tokenAtString;
+          return tokenAtString(stream, state);
+        }
+        stream.eatWhile(/[\w\$_]/);
+        return 'meta';
+      },
+    },
+  });
+
+  function tokenTripleString(stream, state) {
+    var escaped = false;
+    while (!stream.eol()) {
+      if (!escaped && stream.match('"""')) {
+        state.tokenize = null;
+        break;
+      }
+      escaped = stream.next() == '\\' && !escaped;
+    }
+    return 'string';
+  }
+
+  def('text/x-scala', {
+    name: 'clike',
+    keywords: words(
+      /* scala */
+      'abstract case catch class def do else extends final finally for forSome if ' +
+        'implicit import lazy match new null object override package private protected return ' +
+        'sealed super this throw trait try type val var while with yield _ ' +
+        /* package scala */
+        'assert assume require print println printf readLine readBoolean readByte readShort ' +
+        'readChar readInt readLong readFloat readDouble'
+    ),
+    types: words(
+      'AnyVal App Application Array BufferedIterator BigDecimal BigInt Char Console Either ' +
+        'Enumeration Equiv Error Exception Fractional Function IndexedSeq Int Integral Iterable ' +
+        'Iterator List Map Numeric Nil NotNull Option Ordered Ordering PartialFunction PartialOrdering ' +
+        'Product Proxy Range Responder Seq Serializable Set Specializable Stream StringBuilder ' +
+        'StringContext Symbol Throwable Traversable TraversableOnce Tuple Unit Vector ' +
+        /* package java.lang */
+        'Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable ' +
+        'Compiler Double Exception Float Integer Long Math Number Object Package Pair Process ' +
+        'Runtime Runnable SecurityManager Short StackTraceElement StrictMath String ' +
+        'StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void'
+    ),
+    multiLineStrings: true,
+    blockKeywords: words('catch class enum do else finally for forSome if match switch try while'),
+    defKeywords: words('class enum def object package trait type val var'),
+    atoms: words('true false null'),
+    indentStatements: false,
+    indentSwitch: false,
+    isOperatorChar: /[+\-*&%=<>!?|\/#:@]/,
+    hooks: {
+      '@': function(stream) {
+        stream.eatWhile(/[\w\$_]/);
+        return 'meta';
+      },
+      '"': function(stream, state) {
+        if (!stream.match('""')) return false;
+        state.tokenize = tokenTripleString;
+        return state.tokenize(stream, state);
+      },
+      "'": function(stream) {
+        stream.eatWhile(/[\w\$_\xa1-\uffff]/);
+        return 'atom';
+      },
+      '=': function(stream, state) {
+        var cx = state.context;
+        if (cx.type == '}' && cx.align && stream.eat('>')) {
+          state.context = new Context(cx.indented, cx.column, cx.type, cx.info, null, cx.prev);
+          return 'operator';
+        } else {
+          return false;
+        }
+      },
+    },
+    modeProps: { closeBrackets: { triples: '"' } },
+  });
+
+  function tokenKotlinString(tripleString) {
+    return function(stream, state) {
+      var escaped = false,
+        next,
+        end = false;
+      while (!stream.eol()) {
+        if (!tripleString && !escaped && stream.match('"')) {
+          end = true;
+          break;
+        }
+        if (tripleString && stream.match('"""')) {
+          end = true;
+          break;
+        }
+        next = stream.next();
+        if (!escaped && next == '$' && stream.match('{')) stream.skipTo('}');
+        escaped = !escaped && next == '\\' && !tripleString;
+      }
+      if (end || !tripleString) state.tokenize = null;
+      return 'string';
+    };
+  }
+
+  def('text/x-kotlin', {
+    name: 'clike',
+    keywords: words(
+      /*keywords*/
+      'package as typealias class interface this super val ' +
+        'var fun for is in This throw return ' +
+        'break continue object if else while do try when !in !is as? ' +
+        /*soft keywords*/
+        'file import where by get set abstract enum open inner override private public internal ' +
+        'protected catch finally out final vararg reified dynamic companion constructor init ' +
+        'sealed field property receiver param sparam lateinit data inline noinline tailrec ' +
+        'external annotation crossinline const operator infix suspend'
+    ),
+    types: words(
+      /* package java.lang */
+      'Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable ' +
+        'Compiler Double Exception Float Integer Long Math Number Object Package Pair Process ' +
+        'Runtime Runnable SecurityManager Short StackTraceElement StrictMath String ' +
+        'StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void'
+    ),
+    intendSwitch: false,
+    indentStatements: false,
+    multiLineStrings: true,
+    number: /^(?:0x[a-f\d_]+|0b[01_]+|(?:[\d_]+\.?\d*|\.\d+)(?:e[-+]?[\d_]+)?)(u|ll?|l|f)?/i,
+    blockKeywords: words('catch class do else finally for if where try while enum'),
+    defKeywords: words('class val var object package interface fun'),
+    atoms: words('true false null this'),
+    hooks: {
+      '"': function(stream, state) {
+        state.tokenize = tokenKotlinString(stream.match('""'));
+        return state.tokenize(stream, state);
+      },
+    },
+    modeProps: { closeBrackets: { triples: '"' } },
+  });
+
+  def(['x-shader/x-vertex', 'x-shader/x-fragment'], {
+    name: 'clike',
+    keywords: words(
+      'sampler1D sampler2D sampler3D samplerCube ' +
+        'sampler1DShadow sampler2DShadow ' +
+        'const attribute uniform varying ' +
+        'break continue discard return ' +
+        'for while do if else struct ' +
+        'in out inout'
+    ),
+    types: words(
+      'float int bool void ' +
+        'vec2 vec3 vec4 ivec2 ivec3 ivec4 bvec2 bvec3 bvec4 ' +
+        'mat2 mat3 mat4'
+    ),
+    blockKeywords: words('for while do if else struct'),
+    builtin: words(
+      'radians degrees sin cos tan asin acos atan ' +
+        'pow exp log exp2 sqrt inversesqrt ' +
+        'abs sign floor ceil fract mod min max clamp mix step smoothstep ' +
+        'length distance dot cross normalize ftransform faceforward ' +
+        'reflect refract matrixCompMult ' +
+        'lessThan lessThanEqual greaterThan greaterThanEqual ' +
+        'equal notEqual any all not ' +
+        'texture1D texture1DProj texture1DLod texture1DProjLod ' +
+        'texture2D texture2DProj texture2DLod texture2DProjLod ' +
+        'texture3D texture3DProj texture3DLod texture3DProjLod ' +
+        'textureCube textureCubeLod ' +
+        'shadow1D shadow2D shadow1DProj shadow2DProj ' +
+        'shadow1DLod shadow2DLod shadow1DProjLod shadow2DProjLod ' +
+        'dFdx dFdy fwidth ' +
+        'noise1 noise2 noise3 noise4'
+    ),
+    atoms: words(
+      'true false ' +
+        'gl_FragColor gl_SecondaryColor gl_Normal gl_Vertex ' +
+        'gl_MultiTexCoord0 gl_MultiTexCoord1 gl_MultiTexCoord2 gl_MultiTexCoord3 ' +
+        'gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6 gl_MultiTexCoord7 ' +
+        'gl_FogCoord gl_PointCoord ' +
+        'gl_Position gl_PointSize gl_ClipVertex ' +
+        'gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor ' +
+        'gl_TexCoord gl_FogFragCoord ' +
+        'gl_FragCoord gl_FrontFacing ' +
+        'gl_FragData gl_FragDepth ' +
+        'gl_ModelViewMatrix gl_ProjectionMatrix gl_ModelViewProjectionMatrix ' +
+        'gl_TextureMatrix gl_NormalMatrix gl_ModelViewMatrixInverse ' +
+        'gl_ProjectionMatrixInverse gl_ModelViewProjectionMatrixInverse ' +
+        'gl_TexureMatrixTranspose gl_ModelViewMatrixInverseTranspose ' +
+        'gl_ProjectionMatrixInverseTranspose ' +
+        'gl_ModelViewProjectionMatrixInverseTranspose ' +
+        'gl_TextureMatrixInverseTranspose ' +
+        'gl_NormalScale gl_DepthRange gl_ClipPlane ' +
+        'gl_Point gl_FrontMaterial gl_BackMaterial gl_LightSource gl_LightModel ' +
+        'gl_FrontLightModelProduct gl_BackLightModelProduct ' +
+        'gl_TextureColor gl_EyePlaneS gl_EyePlaneT gl_EyePlaneR gl_EyePlaneQ ' +
+        'gl_FogParameters ' +
+        'gl_MaxLights gl_MaxClipPlanes gl_MaxTextureUnits gl_MaxTextureCoords ' +
+        'gl_MaxVertexAttribs gl_MaxVertexUniformComponents gl_MaxVaryingFloats ' +
+        'gl_MaxVertexTextureImageUnits gl_MaxTextureImageUnits ' +
+        'gl_MaxFragmentUniformComponents gl_MaxCombineTextureImageUnits ' +
+        'gl_MaxDrawBuffers'
+    ),
+    indentSwitch: false,
+    hooks: { '#': cppHook },
+    modeProps: { fold: ['brace', 'include'] },
+  });
+
+  def('text/x-nesc', {
+    name: 'clike',
+    keywords: words(
+      cKeywords +
+        'as atomic async call command component components configuration event generic ' +
+        'implementation includes interface module new norace nx_struct nx_union post provides ' +
+        'signal task uses abstract extends'
+    ),
+    types: words(cTypes),
+    blockKeywords: words('case do else for if switch while struct'),
+    atoms: words('null true false'),
+    hooks: { '#': cppHook },
+    modeProps: { fold: ['brace', 'include'] },
+  });
+
+  def('text/x-objectivec', {
+    name: 'clike',
+    keywords: words(
+      cKeywords +
+        'inline restrict _Bool _Complex _Imaginary BOOL Class bycopy byref id IMP in ' +
+        'inout nil oneway out Protocol SEL self super atomic nonatomic retain copy readwrite readonly'
+    ),
+    types: words(cTypes),
+    atoms: words('YES NO NULL NILL ON OFF true false'),
+    hooks: {
+      '@': function(stream) {
+        stream.eatWhile(/[\w\$]/);
+        return 'keyword';
+      },
+      '#': cppHook,
+      indent: function(_state, ctx, textAfter) {
+        if (ctx.type == 'statement' && /^@\w/.test(textAfter)) return ctx.indented;
+      },
+    },
+    modeProps: { fold: 'brace' },
+  });
+
+  def('text/x-squirrel', {
+    name: 'clike',
+    keywords: words(
+      'base break clone continue const default delete enum extends function in class' +
+        ' foreach local resume return this throw typeof yield constructor instanceof static'
+    ),
+    types: words(cTypes),
+    blockKeywords: words('case catch class else for foreach if switch try while'),
+    defKeywords: words('function local class'),
+    typeFirstDefinitions: true,
+    atoms: words('true false null'),
+    hooks: { '#': cppHook },
+    modeProps: { fold: ['brace', 'include'] },
+  });
+
+  // Ceylon Strings need to deal with interpolation
+  var stringTokenizer = null;
+  function tokenCeylonString(type) {
+    return function(stream, state) {
+      var escaped = false,
+        next,
+        end = false;
+      while (!stream.eol()) {
+        if (!escaped && stream.match('"') && (type == 'single' || stream.match('""'))) {
+          end = true;
+          break;
+        }
+        if (!escaped && stream.match('``')) {
+          stringTokenizer = tokenCeylonString(type);
+          end = true;
+          break;
+        }
+        next = stream.next();
+        escaped = type == 'single' && !escaped && next == '\\';
+      }
+      if (end) state.tokenize = null;
+      return 'string';
+    };
+  }
+
+  def('text/x-ceylon', {
+    name: 'clike',
+    keywords: words(
+      'abstracts alias assembly assert assign break case catch class continue dynamic else' +
+        ' exists extends finally for function given if import in interface is let module new' +
+        ' nonempty object of out outer package return satisfies super switch then this throw' +
+        ' try value void while'
+    ),
+    types: function(word) {
+      // In Ceylon all identifiers that start with an uppercase are types
+      var first = word.charAt(0);
+      return first === first.toUpperCase() && first !== first.toLowerCase();
+    },
+    blockKeywords: words(
+      'case catch class dynamic else finally for function if interface module new object switch try while'
+    ),
+    defKeywords: words('class dynamic function interface module object package value'),
+    builtin: words(
+      'abstract actual aliased annotation by default deprecated doc final formal late license' +
+        ' native optional sealed see serializable shared suppressWarnings tagged throws variable'
+    ),
+    isPunctuationChar: /[\[\]{}\(\),;\:\.`]/,
+    isOperatorChar: /[+\-*&%=<>!?|^~:\/]/,
+    numberStart: /[\d#$]/,
+    number: /^(?:#[\da-fA-F_]+|\$[01_]+|[\d_]+[kMGTPmunpf]?|[\d_]+\.[\d_]+(?:[eE][-+]?\d+|[kMGTPmunpf]|)|)/i,
+    multiLineStrings: true,
+    typeFirstDefinitions: true,
+    atoms: words('true false null larger smaller equal empty finished'),
+    indentSwitch: false,
+    styleDefs: false,
+    hooks: {
+      '@': function(stream) {
+        stream.eatWhile(/[\w\$_]/);
+        return 'meta';
+      },
+      '"': function(stream, state) {
+        state.tokenize = tokenCeylonString(stream.match('""') ? 'triple' : 'single');
+        return state.tokenize(stream, state);
+      },
+      '`': function(stream, state) {
+        if (!stringTokenizer || !stream.match('`')) return false;
+        state.tokenize = stringTokenizer;
+        stringTokenizer = null;
+        return state.tokenize(stream, state);
+      },
+      "'": function(stream) {
+        stream.eatWhile(/[\w\$_\xa1-\uffff]/);
+        return 'atom';
+      },
+      token: function(_stream, state, style) {
+        if ((style == 'variable' || style == 'type') && state.prevToken == '.') {
+          return 'variable-2';
+        }
+      },
+    },
+    modeProps: {
+      fold: ['brace', 'import'],
+      closeBrackets: { triples: '"' },
+    },
+  });
+});

console/src/main/resources/static/console-fe/public/js/codemirror.lib.json-lint.js

@@ -0,0 +1,700 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* Jison generated parser */
+var jsonlint = (function() {
+  var parser = {
+    trace: function trace() {},
+    yy: {},
+    symbols_: {
+      error: 2,
+      JSONString: 3,
+      STRING: 4,
+      JSONNumber: 5,
+      NUMBER: 6,
+      JSONNullLiteral: 7,
+      NULL: 8,
+      JSONBooleanLiteral: 9,
+      TRUE: 10,
+      FALSE: 11,
+      JSONText: 12,
+      JSONValue: 13,
+      EOF: 14,
+      JSONObject: 15,
+      JSONArray: 16,
+      '{': 17,
+      '}': 18,
+      JSONMemberList: 19,
+      JSONMember: 20,
+      ':': 21,
+      ',': 22,
+      '[': 23,
+      ']': 24,
+      JSONElementList: 25,
+      $accept: 0,
+      $end: 1,
+    },
+    terminals_: {
+      2: 'error',
+      4: 'STRING',
+      6: 'NUMBER',
+      8: 'NULL',
+      10: 'TRUE',
+      11: 'FALSE',
+      14: 'EOF',
+      17: '{',
+      18: '}',
+      21: ':',
+      22: ',',
+      23: '[',
+      24: ']',
+    },
+    productions_: [
+      0,
+      [3, 1],
+      [5, 1],
+      [7, 1],
+      [9, 1],
+      [9, 1],
+      [12, 2],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [15, 2],
+      [15, 3],
+      [20, 3],
+      [19, 1],
+      [19, 3],
+      [16, 2],
+      [16, 3],
+      [25, 1],
+      [25, 3],
+    ],
+    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
+      var $0 = $$.length - 1;
+      switch (yystate) {
+        case 1: // replace escaped characters with actual character
+          this.$ = yytext
+            .replace(/\\(\\|")/g, '$' + '1')
+            .replace(/\\n/g, '\n')
+            .replace(/\\r/g, '\r')
+            .replace(/\\t/g, '\t')
+            .replace(/\\v/g, '\v')
+            .replace(/\\f/g, '\f')
+            .replace(/\\b/g, '\b');
+
+          break;
+        case 2:
+          this.$ = Number(yytext);
+          break;
+        case 3:
+          this.$ = null;
+          break;
+        case 4:
+          this.$ = true;
+          break;
+        case 5:
+          this.$ = false;
+          break;
+        case 6:
+          return (this.$ = $$[$0 - 1]);
+          break;
+        case 13:
+          this.$ = {};
+          break;
+        case 14:
+          this.$ = $$[$0 - 1];
+          break;
+        case 15:
+          this.$ = [$$[$0 - 2], $$[$0]];
+          break;
+        case 16:
+          this.$ = {};
+          this.$[$$[$0][0]] = $$[$0][1];
+          break;
+        case 17:
+          this.$ = $$[$0 - 2];
+          $$[$0 - 2][$$[$0][0]] = $$[$0][1];
+          break;
+        case 18:
+          this.$ = [];
+          break;
+        case 19:
+          this.$ = $$[$0 - 1];
+          break;
+        case 20:
+          this.$ = [$$[$0]];
+          break;
+        case 21:
+          this.$ = $$[$0 - 2];
+          $$[$0 - 2].push($$[$0]);
+          break;
+      }
+    },
+    table: [
+      {
+        3: 5,
+        4: [1, 12],
+        5: 6,
+        6: [1, 13],
+        7: 3,
+        8: [1, 9],
+        9: 4,
+        10: [1, 10],
+        11: [1, 11],
+        12: 1,
+        13: 2,
+        15: 7,
+        16: 8,
+        17: [1, 14],
+        23: [1, 15],
+      },
+      { 1: [3] },
+      { 14: [1, 16] },
+      { 14: [2, 7], 18: [2, 7], 22: [2, 7], 24: [2, 7] },
+      { 14: [2, 8], 18: [2, 8], 22: [2, 8], 24: [2, 8] },
+      { 14: [2, 9], 18: [2, 9], 22: [2, 9], 24: [2, 9] },
+      { 14: [2, 10], 18: [2, 10], 22: [2, 10], 24: [2, 10] },
+      { 14: [2, 11], 18: [2, 11], 22: [2, 11], 24: [2, 11] },
+      { 14: [2, 12], 18: [2, 12], 22: [2, 12], 24: [2, 12] },
+      { 14: [2, 3], 18: [2, 3], 22: [2, 3], 24: [2, 3] },
+      { 14: [2, 4], 18: [2, 4], 22: [2, 4], 24: [2, 4] },
+      { 14: [2, 5], 18: [2, 5], 22: [2, 5], 24: [2, 5] },
+      { 14: [2, 1], 18: [2, 1], 21: [2, 1], 22: [2, 1], 24: [2, 1] },
+      { 14: [2, 2], 18: [2, 2], 22: [2, 2], 24: [2, 2] },
+      { 3: 20, 4: [1, 12], 18: [1, 17], 19: 18, 20: 19 },
+      {
+        3: 5,
+        4: [1, 12],
+        5: 6,
+        6: [1, 13],
+        7: 3,
+        8: [1, 9],
+        9: 4,
+        10: [1, 10],
+        11: [1, 11],
+        13: 23,
+        15: 7,
+        16: 8,
+        17: [1, 14],
+        23: [1, 15],
+        24: [1, 21],
+        25: 22,
+      },
+      { 1: [2, 6] },
+      { 14: [2, 13], 18: [2, 13], 22: [2, 13], 24: [2, 13] },
+      { 18: [1, 24], 22: [1, 25] },
+      { 18: [2, 16], 22: [2, 16] },
+      { 21: [1, 26] },
+      { 14: [2, 18], 18: [2, 18], 22: [2, 18], 24: [2, 18] },
+      { 22: [1, 28], 24: [1, 27] },
+      { 22: [2, 20], 24: [2, 20] },
+      { 14: [2, 14], 18: [2, 14], 22: [2, 14], 24: [2, 14] },
+      { 3: 20, 4: [1, 12], 20: 29 },
+      {
+        3: 5,
+        4: [1, 12],
+        5: 6,
+        6: [1, 13],
+        7: 3,
+        8: [1, 9],
+        9: 4,
+        10: [1, 10],
+        11: [1, 11],
+        13: 30,
+        15: 7,
+        16: 8,
+        17: [1, 14],
+        23: [1, 15],
+      },
+      { 14: [2, 19], 18: [2, 19], 22: [2, 19], 24: [2, 19] },
+      {
+        3: 5,
+        4: [1, 12],
+        5: 6,
+        6: [1, 13],
+        7: 3,
+        8: [1, 9],
+        9: 4,
+        10: [1, 10],
+        11: [1, 11],
+        13: 31,
+        15: 7,
+        16: 8,
+        17: [1, 14],
+        23: [1, 15],
+      },
+      { 18: [2, 17], 22: [2, 17] },
+      { 18: [2, 15], 22: [2, 15] },
+      { 22: [2, 21], 24: [2, 21] },
+    ],
+    defaultActions: { 16: [2, 6] },
+    parseError: function parseError(str, hash) {
+      throw new Error(str);
+    },
+    parse: function parse(input) {
+      var self = this,
+        stack = [0],
+        vstack = [null], // semantic value stack
+        lstack = [], // location stack
+        table = this.table,
+        yytext = '',
+        yylineno = 0,
+        yyleng = 0,
+        recovering = 0,
+        TERROR = 2,
+        EOF = 1;
+
+      //this.reductionCount = this.shiftCount = 0;
+
+      this.lexer.setInput(input);
+      this.lexer.yy = this.yy;
+      this.yy.lexer = this.lexer;
+      if (typeof this.lexer.yylloc == 'undefined') this.lexer.yylloc = {};
+      var yyloc = this.lexer.yylloc;
+      lstack.push(yyloc);
+
+      if (typeof this.yy.parseError === 'function') this.parseError = this.yy.parseError;
+
+      function popStack(n) {
+        stack.length = stack.length - 2 * n;
+        vstack.length = vstack.length - n;
+        lstack.length = lstack.length - n;
+      }
+
+      function lex() {
+        var token;
+        token = self.lexer.lex() || 1; // $end = 1
+        // if token isn't its numeric value, convert
+        if (typeof token !== 'number') {
+          token = self.symbols_[token] || token;
+        }
+        return token;
+      }
+
+      var symbol,
+        preErrorSymbol,
+        state,
+        action,
+        a,
+        r,
+        yyval = {},
+        p,
+        len,
+        newState,
+        expected;
+      while (true) {
+        // retreive state number from top of stack
+        state = stack[stack.length - 1];
+
+        // use default actions if available
+        if (this.defaultActions[state]) {
+          action = this.defaultActions[state];
+        } else {
+          if (symbol == null) symbol = lex();
+          // read action for current state and first input
+          action = table[state] && table[state][symbol];
+        }
+
+        // handle parse error
+        _handle_error: if (typeof action === 'undefined' || !action.length || !action[0]) {
+          if (!recovering) {
+            // Report error
+            expected = [];
+            for (p in table[state])
+              if (this.terminals_[p] && p > 2) {
+                expected.push("'" + this.terminals_[p] + "'");
+              }
+            var errStr = '';
+            if (this.lexer.showPosition) {
+              errStr =
+                'Parse error on line ' +
+                (yylineno + 1) +
+                ':\n' +
+                this.lexer.showPosition() +
+                '\nExpecting ' +
+                expected.join(', ') +
+                ", got '" +
+                this.terminals_[symbol] +
+                "'";
+            } else {
+              errStr =
+                'Parse error on line ' +
+                (yylineno + 1) +
+                ': Unexpected ' +
+                (symbol == 1 /*EOF*/
+                  ? 'end of input'
+                  : "'" + (this.terminals_[symbol] || symbol) + "'");
+            }
+            this.parseError(errStr, {
+              text: this.lexer.match,
+              token: this.terminals_[symbol] || symbol,
+              line: this.lexer.yylineno,
+              loc: yyloc,
+              expected: expected,
+            });
+          }
+
+          // just recovered from another error
+          if (recovering == 3) {
+            if (symbol == EOF) {
+              throw new Error(errStr || 'Parsing halted.');
+            }
+
+            // discard current lookahead and grab another
+            yyleng = this.lexer.yyleng;
+            yytext = this.lexer.yytext;
+            yylineno = this.lexer.yylineno;
+            yyloc = this.lexer.yylloc;
+            symbol = lex();
+          }
+
+          // try to recover from error
+          while (1) {
+            // check for error recovery rule in this state
+            if (TERROR.toString() in table[state]) {
+              break;
+            }
+            if (state == 0) {
+              throw new Error(errStr || 'Parsing halted.');
+            }
+            popStack(1);
+            state = stack[stack.length - 1];
+          }
+
+          preErrorSymbol = symbol; // save the lookahead token
+          symbol = TERROR; // insert generic error symbol as new lookahead
+          state = stack[stack.length - 1];
+          action = table[state] && table[state][TERROR];
+          recovering = 3; // allow 3 real symbols to be shifted before reporting a new error
+        }
+
+        // this shouldn't happen, unless resolve defaults are off
+        if (action[0] instanceof Array && action.length > 1) {
+          throw new Error(
+            'Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol
+          );
+        }
+
+        switch (action[0]) {
+          case 1: // shift
+            //this.shiftCount++;
+
+            stack.push(symbol);
+            vstack.push(this.lexer.yytext);
+            lstack.push(this.lexer.yylloc);
+            stack.push(action[1]); // push state
+            symbol = null;
+            if (!preErrorSymbol) {
+              // normal execution/no error
+              yyleng = this.lexer.yyleng;
+              yytext = this.lexer.yytext;
+              yylineno = this.lexer.yylineno;
+              yyloc = this.lexer.yylloc;
+              if (recovering > 0) recovering--;
+            } else {
+              // error just occurred, resume old lookahead f/ before error
+              symbol = preErrorSymbol;
+              preErrorSymbol = null;
+            }
+            break;
+
+          case 2: // reduce
+            //this.reductionCount++;
+
+            len = this.productions_[action[1]][1];
+
+            // perform semantic action
+            yyval.$ = vstack[vstack.length - len]; // default to $$ = $1
+            // default location, uses first token for firsts, last for lasts
+            yyval._$ = {
+              first_line: lstack[lstack.length - (len || 1)].first_line,
+              last_line: lstack[lstack.length - 1].last_line,
+              first_column: lstack[lstack.length - (len || 1)].first_column,
+              last_column: lstack[lstack.length - 1].last_column,
+            };
+            r = this.performAction.call(
+              yyval,
+              yytext,
+              yyleng,
+              yylineno,
+              this.yy,
+              action[1],
+              vstack,
+              lstack
+            );
+
+            if (typeof r !== 'undefined') {
+              return r;
+            }
+
+            // pop off stack
+            if (len) {
+              stack = stack.slice(0, -1 * len * 2);
+              vstack = vstack.slice(0, -1 * len);
+              lstack = lstack.slice(0, -1 * len);
+            }
+
+            stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce)
+            vstack.push(yyval.$);
+            lstack.push(yyval._$);
+            // goto new state = table[STATE][NONTERMINAL]
+            newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+            stack.push(newState);
+            break;
+
+          case 3: // accept
+            return true;
+        }
+      }
+
+      return true;
+    },
+  };
+  /* Jison generated lexer */
+  var lexer = (function() {
+    var lexer = {
+      EOF: 1,
+      parseError: function parseError(str, hash) {
+        if (this.yy.parseError) {
+          this.yy.parseError(str, hash);
+        } else {
+          throw new Error(str);
+        }
+      },
+      setInput: function(input) {
+        this._input = input;
+        this._more = this._less = this.done = false;
+        this.yylineno = this.yyleng = 0;
+        this.yytext = this.matched = this.match = '';
+        this.conditionStack = ['INITIAL'];
+        this.yylloc = { first_line: 1, first_column: 0, last_line: 1, last_column: 0 };
+        return this;
+      },
+      input: function() {
+        var ch = this._input[0];
+        this.yytext += ch;
+        this.yyleng++;
+        this.match += ch;
+        this.matched += ch;
+        var lines = ch.match(/\n/);
+        if (lines) this.yylineno++;
+        this._input = this._input.slice(1);
+        return ch;
+      },
+      unput: function(ch) {
+        this._input = ch + this._input;
+        return this;
+      },
+      more: function() {
+        this._more = true;
+        return this;
+      },
+      less: function(n) {
+        this._input = this.match.slice(n) + this._input;
+      },
+      pastInput: function() {
+        var past = this.matched.substr(0, this.matched.length - this.match.length);
+        return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, '');
+      },
+      upcomingInput: function() {
+        var next = this.match;
+        if (next.length < 20) {
+          next += this._input.substr(0, 20 - next.length);
+        }
+        return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, '');
+      },
+      showPosition: function() {
+        var pre = this.pastInput();
+        var c = new Array(pre.length + 1).join('-');
+        return pre + this.upcomingInput() + '\n' + c + '^';
+      },
+      next: function() {
+        if (this.done) {
+          return this.EOF;
+        }
+        if (!this._input) this.done = true;
+
+        var token, match, tempMatch, index, col, lines;
+        if (!this._more) {
+          this.yytext = '';
+          this.match = '';
+        }
+        var rules = this._currentRules();
+        for (var i = 0; i < rules.length; i++) {
+          tempMatch = this._input.match(this.rules[rules[i]]);
+          if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+            match = tempMatch;
+            index = i;
+            if (!this.options.flex) break;
+          }
+        }
+        if (match) {
+          lines = match[0].match(/\n.*/g);
+          if (lines) this.yylineno += lines.length;
+          this.yylloc = {
+            first_line: this.yylloc.last_line,
+            last_line: this.yylineno + 1,
+            first_column: this.yylloc.last_column,
+            last_column: lines
+              ? lines[lines.length - 1].length - 1
+              : this.yylloc.last_column + match[0].length,
+          };
+          this.yytext += match[0];
+          this.match += match[0];
+          this.yyleng = this.yytext.length;
+          this._more = false;
+          this._input = this._input.slice(match[0].length);
+          this.matched += match[0];
+          token = this.performAction.call(
+            this,
+            this.yy,
+            this,
+            rules[index],
+            this.conditionStack[this.conditionStack.length - 1]
+          );
+          if (this.done && this._input) this.done = false;
+          if (token) return token;
+          else return;
+        }
+        if (this._input === '') {
+          return this.EOF;
+        } else {
+          this.parseError(
+            'Lexical error on line ' +
+              (this.yylineno + 1) +
+              '. Unrecognized text.\n' +
+              this.showPosition(),
+            { text: '', token: null, line: this.yylineno }
+          );
+        }
+      },
+      lex: function lex() {
+        var r = this.next();
+        if (typeof r !== 'undefined') {
+          return r;
+        } else {
+          return this.lex();
+        }
+      },
+      begin: function begin(condition) {
+        this.conditionStack.push(condition);
+      },
+      popState: function popState() {
+        return this.conditionStack.pop();
+      },
+      _currentRules: function _currentRules() {
+        return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
+      },
+      topState: function() {
+        return this.conditionStack[this.conditionStack.length - 2];
+      },
+      pushState: function begin(condition) {
+        this.begin(condition);
+      },
+    };
+    lexer.options = {};
+    lexer.performAction = function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
+      var YYSTATE = YY_START;
+      switch ($avoiding_name_collisions) {
+        case 0 /* skip whitespace */:
+          break;
+        case 1:
+          return 6;
+          break;
+        case 2:
+          yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2);
+          return 4;
+          break;
+        case 3:
+          return 17;
+          break;
+        case 4:
+          return 18;
+          break;
+        case 5:
+          return 23;
+          break;
+        case 6:
+          return 24;
+          break;
+        case 7:
+          return 22;
+          break;
+        case 8:
+          return 21;
+          break;
+        case 9:
+          return 10;
+          break;
+        case 10:
+          return 11;
+          break;
+        case 11:
+          return 8;
+          break;
+        case 12:
+          return 14;
+          break;
+        case 13:
+          return 'INVALID';
+          break;
+      }
+    };
+    lexer.rules = [
+      /^(?:\s+)/,
+      /^(?:(-?([0-9]|[1-9][0-9]+))(\.[0-9]+)?([eE][-+]?[0-9]+)?\b)/,
+      /^(?:"(?:\\[\\"bfnrt/]|\\u[a-fA-F0-9]{4}|[^\\\0-\x09\x0a-\x1f"])*")/,
+      /^(?:\{)/,
+      /^(?:\})/,
+      /^(?:\[)/,
+      /^(?:\])/,
+      /^(?:,)/,
+      /^(?::)/,
+      /^(?:true\b)/,
+      /^(?:false\b)/,
+      /^(?:null\b)/,
+      /^(?:$)/,
+      /^(?:.)/,
+    ];
+    lexer.conditions = {
+      INITIAL: { rules: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], inclusive: true },
+    };
+
+    return lexer;
+  })();
+  parser.lexer = lexer;
+  return parser;
+})();
+if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
+  exports.parser = jsonlint;
+  exports.parse = function() {
+    return jsonlint.parse.apply(jsonlint, arguments);
+  };
+  exports.main = function commonjsMain(args) {
+    if (!args[1]) throw new Error('Usage: ' + args[0] + ' FILE');
+    if (typeof process !== 'undefined') {
+      var source = require('fs').readFileSync(require('path').join(process.cwd(), args[1]), 'utf8');
+    } else {
+      var cwd = require('file').path(require('file').cwd());
+      var source = cwd.join(args[1]).read({ charset: 'utf-8' });
+    }
+    return exports.parser.parse(source);
+  };
+  if (typeof module !== 'undefined' && require.main === module) {
+    exports.main(typeof process !== 'undefined' ? process.argv.slice(1) : require('system').args);
+  }
+}

console/src/main/resources/static/console-fe/public/js/diff_match_patch.js

@@ -0,0 +1,865 @@
+(function() {
+  function diff_match_patch() {
+    this.Diff_Timeout = 1;
+    this.Diff_EditCost = 4;
+    this.Match_Threshold = 0.5;
+    this.Match_Distance = 1e3;
+    this.Patch_DeleteThreshold = 0.5;
+    this.Patch_Margin = 4;
+    this.Match_MaxBits = 32;
+  }
+  diff_match_patch.prototype.diff_main = function(a, b, c, d) {
+    'undefined' == typeof d &&
+      (d =
+        0 >= this.Diff_Timeout ? Number.MAX_VALUE : new Date().getTime() + 1e3 * this.Diff_Timeout);
+    if (null == a || null == b) throw Error('Null input. (diff_main)');
+    if (a == b) return a ? [[0, a]] : [];
+    'undefined' == typeof c && (c = !0);
+    var e = c,
+      f = this.diff_commonPrefix(a, b);
+    c = a.substring(0, f);
+    a = a.substring(f);
+    b = b.substring(f);
+    var f = this.diff_commonSuffix(a, b),
+      g = a.substring(a.length - f);
+    a = a.substring(0, a.length - f);
+    b = b.substring(0, b.length - f);
+    a = this.diff_compute_(a, b, e, d);
+    c && a.unshift([0, c]);
+    g && a.push([0, g]);
+    this.diff_cleanupMerge(a);
+    return a;
+  };
+  diff_match_patch.prototype.diff_compute_ = function(a, b, c, d) {
+    if (!a) return [[1, b]];
+    if (!b) return [[-1, a]];
+    var e = a.length > b.length ? a : b,
+      f = a.length > b.length ? b : a,
+      g = e.indexOf(f);
+    return -1 != g
+      ? ((c = [[1, e.substring(0, g)], [0, f], [1, e.substring(g + f.length)]]),
+        a.length > b.length && (c[0][0] = c[2][0] = -1),
+        c)
+      : 1 == f.length
+      ? [[-1, a], [1, b]]
+      : (e = this.diff_halfMatch_(a, b))
+      ? ((f = e[0]),
+        (a = e[1]),
+        (g = e[2]),
+        (b = e[3]),
+        (e = e[4]),
+        (f = this.diff_main(f, g, c, d)),
+        (c = this.diff_main(a, b, c, d)),
+        f.concat([[0, e]], c))
+      : c && 100 < a.length && 100 < b.length
+      ? this.diff_lineMode_(a, b, d)
+      : this.diff_bisect_(a, b, d);
+  };
+  diff_match_patch.prototype.diff_lineMode_ = function(a, b, c) {
+    var d = this.diff_linesToChars_(a, b);
+    a = d.chars1;
+    b = d.chars2;
+    d = d.lineArray;
+    a = this.diff_main(a, b, !1, c);
+    this.diff_charsToLines_(a, d);
+    this.diff_cleanupSemantic(a);
+    a.push([0, '']);
+    for (var e = (d = b = 0), f = '', g = ''; b < a.length; ) {
+      switch (a[b][0]) {
+        case 1:
+          e++;
+          g += a[b][1];
+          break;
+        case -1:
+          d++;
+          f += a[b][1];
+          break;
+        case 0:
+          if (1 <= d && 1 <= e) {
+            a.splice(b - d - e, d + e);
+            b = b - d - e;
+            d = this.diff_main(f, g, !1, c);
+            for (e = d.length - 1; 0 <= e; e--) a.splice(b, 0, d[e]);
+            b += d.length;
+          }
+          d = e = 0;
+          g = f = '';
+      }
+      b++;
+    }
+    a.pop();
+    return a;
+  };
+  diff_match_patch.prototype.diff_bisect_ = function(a, b, c) {
+    for (
+      var d = a.length,
+        e = b.length,
+        f = Math.ceil((d + e) / 2),
+        g = f,
+        h = 2 * f,
+        j = Array(h),
+        i = Array(h),
+        k = 0;
+      k < h;
+      k++
+    )
+      (j[k] = -1), (i[k] = -1);
+    j[g + 1] = 0;
+    i[g + 1] = 0;
+    for (
+      var k = d - e, q = 0 != k % 2, r = 0, t = 0, p = 0, w = 0, v = 0;
+      v < f && !(new Date().getTime() > c);
+      v++
+    ) {
+      for (var n = -v + r; n <= v - t; n += 2) {
+        var l = g + n,
+          m;
+        m = n == -v || (n != v && j[l - 1] < j[l + 1]) ? j[l + 1] : j[l - 1] + 1;
+        for (var s = m - n; m < d && s < e && a.charAt(m) == b.charAt(s); ) m++, s++;
+        j[l] = m;
+        if (m > d) t += 2;
+        else if (s > e) r += 2;
+        else if (q && ((l = g + k - n), 0 <= l && l < h && -1 != i[l])) {
+          var u = d - i[l];
+          if (m >= u) return this.diff_bisectSplit_(a, b, m, s, c);
+        }
+      }
+      for (n = -v + p; n <= v - w; n += 2) {
+        l = g + n;
+        u = n == -v || (n != v && i[l - 1] < i[l + 1]) ? i[l + 1] : i[l - 1] + 1;
+        for (m = u - n; u < d && m < e && a.charAt(d - u - 1) == b.charAt(e - m - 1); ) u++, m++;
+        i[l] = u;
+        if (u > d) w += 2;
+        else if (m > e) p += 2;
+        else if (
+          !q &&
+          ((l = g + k - n),
+          0 <= l && (l < h && -1 != j[l]) && ((m = j[l]), (s = g + m - l), (u = d - u), m >= u))
+        )
+          return this.diff_bisectSplit_(a, b, m, s, c);
+      }
+    }
+    return [[-1, a], [1, b]];
+  };
+  diff_match_patch.prototype.diff_bisectSplit_ = function(a, b, c, d, e) {
+    var f = a.substring(0, c),
+      g = b.substring(0, d);
+    a = a.substring(c);
+    b = b.substring(d);
+    f = this.diff_main(f, g, !1, e);
+    e = this.diff_main(a, b, !1, e);
+    return f.concat(e);
+  };
+  diff_match_patch.prototype.diff_linesToChars_ = function(a, b) {
+    function c(a) {
+      for (var b = '', c = 0, f = -1, g = d.length; f < a.length - 1; ) {
+        f = a.indexOf('\n', c);
+        -1 == f && (f = a.length - 1);
+        var r = a.substring(c, f + 1),
+          c = f + 1;
+        (e.hasOwnProperty
+        ? e.hasOwnProperty(r)
+        : void 0 !== e[r])
+          ? (b += String.fromCharCode(e[r]))
+          : ((b += String.fromCharCode(g)), (e[r] = g), (d[g++] = r));
+      }
+      return b;
+    }
+    var d = [],
+      e = {};
+    d[0] = '';
+    var f = c(a),
+      g = c(b);
+    return { chars1: f, chars2: g, lineArray: d };
+  };
+  diff_match_patch.prototype.diff_charsToLines_ = function(a, b) {
+    for (var c = 0; c < a.length; c++) {
+      for (var d = a[c][1], e = [], f = 0; f < d.length; f++) e[f] = b[d.charCodeAt(f)];
+      a[c][1] = e.join('');
+    }
+  };
+  diff_match_patch.prototype.diff_commonPrefix = function(a, b) {
+    if (!a || !b || a.charAt(0) != b.charAt(0)) return 0;
+    for (var c = 0, d = Math.min(a.length, b.length), e = d, f = 0; c < e; )
+      a.substring(f, e) == b.substring(f, e) ? (f = c = e) : (d = e),
+        (e = Math.floor((d - c) / 2 + c));
+    return e;
+  };
+  diff_match_patch.prototype.diff_commonSuffix = function(a, b) {
+    if (!a || !b || a.charAt(a.length - 1) != b.charAt(b.length - 1)) return 0;
+    for (var c = 0, d = Math.min(a.length, b.length), e = d, f = 0; c < e; )
+      a.substring(a.length - e, a.length - f) == b.substring(b.length - e, b.length - f)
+        ? (f = c = e)
+        : (d = e),
+        (e = Math.floor((d - c) / 2 + c));
+    return e;
+  };
+  diff_match_patch.prototype.diff_commonOverlap_ = function(a, b) {
+    var c = a.length,
+      d = b.length;
+    if (0 == c || 0 == d) return 0;
+    c > d ? (a = a.substring(c - d)) : c < d && (b = b.substring(0, c));
+    c = Math.min(c, d);
+    if (a == b) return c;
+    for (var d = 0, e = 1; ; ) {
+      var f = a.substring(c - e),
+        f = b.indexOf(f);
+      if (-1 == f) return d;
+      e += f;
+      if (0 == f || a.substring(c - e) == b.substring(0, e)) (d = e), e++;
+    }
+  };
+  diff_match_patch.prototype.diff_halfMatch_ = function(a, b) {
+    function c(a, b, c) {
+      for (
+        var d = a.substring(c, c + Math.floor(a.length / 4)), e = -1, g = '', h, j, n, l;
+        -1 != (e = b.indexOf(d, e + 1));
+
+      ) {
+        var m = f.diff_commonPrefix(a.substring(c), b.substring(e)),
+          s = f.diff_commonSuffix(a.substring(0, c), b.substring(0, e));
+        g.length < s + m &&
+          ((g = b.substring(e - s, e) + b.substring(e, e + m)),
+          (h = a.substring(0, c - s)),
+          (j = a.substring(c + m)),
+          (n = b.substring(0, e - s)),
+          (l = b.substring(e + m)));
+      }
+      return 2 * g.length >= a.length ? [h, j, n, l, g] : null;
+    }
+    if (0 >= this.Diff_Timeout) return null;
+    var d = a.length > b.length ? a : b,
+      e = a.length > b.length ? b : a;
+    if (4 > d.length || 2 * e.length < d.length) return null;
+    var f = this,
+      g = c(d, e, Math.ceil(d.length / 4)),
+      d = c(d, e, Math.ceil(d.length / 2)),
+      h;
+    if (!g && !d) return null;
+    h = d ? (g ? (g[4].length > d[4].length ? g : d) : d) : g;
+    var j;
+    a.length > b.length
+      ? ((g = h[0]), (d = h[1]), (e = h[2]), (j = h[3]))
+      : ((e = h[0]), (j = h[1]), (g = h[2]), (d = h[3]));
+    h = h[4];
+    return [g, d, e, j, h];
+  };
+  diff_match_patch.prototype.diff_cleanupSemantic = function(a) {
+    for (var b = !1, c = [], d = 0, e = null, f = 0, g = 0, h = 0, j = 0, i = 0; f < a.length; )
+      0 == a[f][0]
+        ? ((c[d++] = f), (g = j), (h = i), (i = j = 0), (e = a[f][1]))
+        : (1 == a[f][0] ? (j += a[f][1].length) : (i += a[f][1].length),
+          e &&
+            (e.length <= Math.max(g, h) && e.length <= Math.max(j, i)) &&
+            (a.splice(c[d - 1], 0, [-1, e]),
+            (a[c[d - 1] + 1][0] = 1),
+            d--,
+            d--,
+            (f = 0 < d ? c[d - 1] : -1),
+            (i = j = h = g = 0),
+            (e = null),
+            (b = !0))),
+        f++;
+    b && this.diff_cleanupMerge(a);
+    this.diff_cleanupSemanticLossless(a);
+    for (f = 1; f < a.length; ) {
+      if (-1 == a[f - 1][0] && 1 == a[f][0]) {
+        b = a[f - 1][1];
+        c = a[f][1];
+        d = this.diff_commonOverlap_(b, c);
+        e = this.diff_commonOverlap_(c, b);
+        if (d >= e) {
+          if (d >= b.length / 2 || d >= c.length / 2)
+            a.splice(f, 0, [0, c.substring(0, d)]),
+              (a[f - 1][1] = b.substring(0, b.length - d)),
+              (a[f + 1][1] = c.substring(d)),
+              f++;
+        } else if (e >= b.length / 2 || e >= c.length / 2)
+          a.splice(f, 0, [0, b.substring(0, e)]),
+            (a[f - 1][0] = 1),
+            (a[f - 1][1] = c.substring(0, c.length - e)),
+            (a[f + 1][0] = -1),
+            (a[f + 1][1] = b.substring(e)),
+            f++;
+        f++;
+      }
+      f++;
+    }
+  };
+  diff_match_patch.prototype.diff_cleanupSemanticLossless = function(a) {
+    function b(a, b) {
+      if (!a || !b) return 6;
+      var c = a.charAt(a.length - 1),
+        d = b.charAt(0),
+        e = c.match(diff_match_patch.nonAlphaNumericRegex_),
+        f = d.match(diff_match_patch.nonAlphaNumericRegex_),
+        g = e && c.match(diff_match_patch.whitespaceRegex_),
+        h = f && d.match(diff_match_patch.whitespaceRegex_),
+        c = g && c.match(diff_match_patch.linebreakRegex_),
+        d = h && d.match(diff_match_patch.linebreakRegex_),
+        i = c && a.match(diff_match_patch.blanklineEndRegex_),
+        j = d && b.match(diff_match_patch.blanklineStartRegex_);
+      return i || j ? 5 : c || d ? 4 : e && !g && h ? 3 : g || h ? 2 : e || f ? 1 : 0;
+    }
+    for (var c = 1; c < a.length - 1; ) {
+      if (0 == a[c - 1][0] && 0 == a[c + 1][0]) {
+        var d = a[c - 1][1],
+          e = a[c][1],
+          f = a[c + 1][1],
+          g = this.diff_commonSuffix(d, e);
+        if (g)
+          var h = e.substring(e.length - g),
+            d = d.substring(0, d.length - g),
+            e = h + e.substring(0, e.length - g),
+            f = h + f;
+        for (var g = d, h = e, j = f, i = b(d, e) + b(e, f); e.charAt(0) === f.charAt(0); ) {
+          var d = d + e.charAt(0),
+            e = e.substring(1) + f.charAt(0),
+            f = f.substring(1),
+            k = b(d, e) + b(e, f);
+          k >= i && ((i = k), (g = d), (h = e), (j = f));
+        }
+        a[c - 1][1] != g &&
+          (g ? (a[c - 1][1] = g) : (a.splice(c - 1, 1), c--),
+          (a[c][1] = h),
+          j ? (a[c + 1][1] = j) : (a.splice(c + 1, 1), c--));
+      }
+      c++;
+    }
+  };
+  diff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
+  diff_match_patch.whitespaceRegex_ = /\s/;
+  diff_match_patch.linebreakRegex_ = /[\r\n]/;
+  diff_match_patch.blanklineEndRegex_ = /\n\r?\n$/;
+  diff_match_patch.blanklineStartRegex_ = /^\r?\n\r?\n/;
+  diff_match_patch.prototype.diff_cleanupEfficiency = function(a) {
+    for (
+      var b = !1, c = [], d = 0, e = null, f = 0, g = !1, h = !1, j = !1, i = !1;
+      f < a.length;
+
+    ) {
+      if (0 == a[f][0])
+        a[f][1].length < this.Diff_EditCost && (j || i)
+          ? ((c[d++] = f), (g = j), (h = i), (e = a[f][1]))
+          : ((d = 0), (e = null)),
+          (j = i = !1);
+      else if (
+        (-1 == a[f][0] ? (i = !0) : (j = !0),
+        e && ((g && h && j && i) || (e.length < this.Diff_EditCost / 2 && 3 == g + h + j + i)))
+      )
+        a.splice(c[d - 1], 0, [-1, e]),
+          (a[c[d - 1] + 1][0] = 1),
+          d--,
+          (e = null),
+          g && h ? ((j = i = !0), (d = 0)) : (d--, (f = 0 < d ? c[d - 1] : -1), (j = i = !1)),
+          (b = !0);
+      f++;
+    }
+    b && this.diff_cleanupMerge(a);
+  };
+  diff_match_patch.prototype.diff_cleanupMerge = function(a) {
+    a.push([0, '']);
+    for (var b = 0, c = 0, d = 0, e = '', f = '', g; b < a.length; )
+      switch (a[b][0]) {
+        case 1:
+          d++;
+          f += a[b][1];
+          b++;
+          break;
+        case -1:
+          c++;
+          e += a[b][1];
+          b++;
+          break;
+        case 0:
+          1 < c + d
+            ? (0 !== c &&
+                0 !== d &&
+                ((g = this.diff_commonPrefix(f, e)),
+                0 !== g &&
+                  (0 < b - c - d && 0 == a[b - c - d - 1][0]
+                    ? (a[b - c - d - 1][1] += f.substring(0, g))
+                    : (a.splice(0, 0, [0, f.substring(0, g)]), b++),
+                  (f = f.substring(g)),
+                  (e = e.substring(g))),
+                (g = this.diff_commonSuffix(f, e)),
+                0 !== g &&
+                  ((a[b][1] = f.substring(f.length - g) + a[b][1]),
+                  (f = f.substring(0, f.length - g)),
+                  (e = e.substring(0, e.length - g)))),
+              0 === c
+                ? a.splice(b - d, c + d, [1, f])
+                : 0 === d
+                ? a.splice(b - c, c + d, [-1, e])
+                : a.splice(b - c - d, c + d, [-1, e], [1, f]),
+              (b = b - c - d + (c ? 1 : 0) + (d ? 1 : 0) + 1))
+            : 0 !== b && 0 == a[b - 1][0]
+            ? ((a[b - 1][1] += a[b][1]), a.splice(b, 1))
+            : b++,
+            (c = d = 0),
+            (f = e = '');
+      }
+    '' === a[a.length - 1][1] && a.pop();
+    c = !1;
+    for (b = 1; b < a.length - 1; )
+      0 == a[b - 1][0] &&
+        0 == a[b + 1][0] &&
+        (a[b][1].substring(a[b][1].length - a[b - 1][1].length) == a[b - 1][1]
+          ? ((a[b][1] = a[b - 1][1] + a[b][1].substring(0, a[b][1].length - a[b - 1][1].length)),
+            (a[b + 1][1] = a[b - 1][1] + a[b + 1][1]),
+            a.splice(b - 1, 1),
+            (c = !0))
+          : a[b][1].substring(0, a[b + 1][1].length) == a[b + 1][1] &&
+            ((a[b - 1][1] += a[b + 1][1]),
+            (a[b][1] = a[b][1].substring(a[b + 1][1].length) + a[b + 1][1]),
+            a.splice(b + 1, 1),
+            (c = !0))),
+        b++;
+    c && this.diff_cleanupMerge(a);
+  };
+  diff_match_patch.prototype.diff_xIndex = function(a, b) {
+    var c = 0,
+      d = 0,
+      e = 0,
+      f = 0,
+      g;
+    for (g = 0; g < a.length; g++) {
+      1 !== a[g][0] && (c += a[g][1].length);
+      -1 !== a[g][0] && (d += a[g][1].length);
+      if (c > b) break;
+      e = c;
+      f = d;
+    }
+    return a.length != g && -1 === a[g][0] ? f : f + (b - e);
+  };
+  diff_match_patch.prototype.diff_prettyHtml = function(a) {
+    for (var b = [], c = /&/g, d = /</g, e = />/g, f = /\n/g, g = 0; g < a.length; g++) {
+      var h = a[g][0],
+        j = a[g][1],
+        j = j
+          .replace(c, '&amp;')
+          .replace(d, '&lt;')
+          .replace(e, '&gt;')
+          .replace(f, '&para;<br>');
+      switch (h) {
+        case 1:
+          b[g] = '<ins style="background:#e6ffe6;">' + j + '</ins>';
+          break;
+        case -1:
+          b[g] = '<del style="background:#ffe6e6;">' + j + '</del>';
+          break;
+        case 0:
+          b[g] = '<span>' + j + '</span>';
+      }
+    }
+    return b.join('');
+  };
+  diff_match_patch.prototype.diff_text1 = function(a) {
+    for (var b = [], c = 0; c < a.length; c++) 1 !== a[c][0] && (b[c] = a[c][1]);
+    return b.join('');
+  };
+  diff_match_patch.prototype.diff_text2 = function(a) {
+    for (var b = [], c = 0; c < a.length; c++) -1 !== a[c][0] && (b[c] = a[c][1]);
+    return b.join('');
+  };
+  diff_match_patch.prototype.diff_levenshtein = function(a) {
+    for (var b = 0, c = 0, d = 0, e = 0; e < a.length; e++) {
+      var f = a[e][0],
+        g = a[e][1];
+      switch (f) {
+        case 1:
+          c += g.length;
+          break;
+        case -1:
+          d += g.length;
+          break;
+        case 0:
+          (b += Math.max(c, d)), (d = c = 0);
+      }
+    }
+    return (b += Math.max(c, d));
+  };
+  diff_match_patch.prototype.diff_toDelta = function(a) {
+    for (var b = [], c = 0; c < a.length; c++)
+      switch (a[c][0]) {
+        case 1:
+          b[c] = '+' + encodeURI(a[c][1]);
+          break;
+        case -1:
+          b[c] = '-' + a[c][1].length;
+          break;
+        case 0:
+          b[c] = '=' + a[c][1].length;
+      }
+    return b.join('\t').replace(/%20/g, ' ');
+  };
+  diff_match_patch.prototype.diff_fromDelta = function(a, b) {
+    for (var c = [], d = 0, e = 0, f = b.split(/\t/g), g = 0; g < f.length; g++) {
+      var h = f[g].substring(1);
+      switch (f[g].charAt(0)) {
+        case '+':
+          try {
+            c[d++] = [1, decodeURI(h)];
+          } catch (j) {
+            throw Error('Illegal escape in diff_fromDelta: ' + h);
+          }
+          break;
+        case '-':
+        case '=':
+          var i = parseInt(h, 10);
+          if (isNaN(i) || 0 > i) throw Error('Invalid number in diff_fromDelta: ' + h);
+          h = a.substring(e, (e += i));
+          '=' == f[g].charAt(0) ? (c[d++] = [0, h]) : (c[d++] = [-1, h]);
+          break;
+        default:
+          if (f[g]) throw Error('Invalid diff operation in diff_fromDelta: ' + f[g]);
+      }
+    }
+    if (e != a.length)
+      throw Error('Delta length (' + e + ') does not equal source text length (' + a.length + ').');
+    return c;
+  };
+  diff_match_patch.prototype.match_main = function(a, b, c) {
+    if (null == a || null == b || null == c) throw Error('Null input. (match_main)');
+    c = Math.max(0, Math.min(c, a.length));
+    return a == b
+      ? 0
+      : a.length
+      ? a.substring(c, c + b.length) == b
+        ? c
+        : this.match_bitap_(a, b, c)
+      : -1;
+  };
+  diff_match_patch.prototype.match_bitap_ = function(a, b, c) {
+    function d(a, d) {
+      var e = a / b.length,
+        g = Math.abs(c - d);
+      return !f.Match_Distance ? (g ? 1 : e) : e + g / f.Match_Distance;
+    }
+    if (b.length > this.Match_MaxBits) throw Error('Pattern too long for this browser.');
+    var e = this.match_alphabet_(b),
+      f = this,
+      g = this.Match_Threshold,
+      h = a.indexOf(b, c);
+    -1 != h &&
+      ((g = Math.min(d(0, h), g)),
+      (h = a.lastIndexOf(b, c + b.length)),
+      -1 != h && (g = Math.min(d(0, h), g)));
+    for (
+      var j = 1 << (b.length - 1), h = -1, i, k, q = b.length + a.length, r, t = 0;
+      t < b.length;
+      t++
+    ) {
+      i = 0;
+      for (k = q; i < k; ) d(t, c + k) <= g ? (i = k) : (q = k), (k = Math.floor((q - i) / 2 + i));
+      q = k;
+      i = Math.max(1, c - k + 1);
+      var p = Math.min(c + k, a.length) + b.length;
+      k = Array(p + 2);
+      for (k[p + 1] = (1 << t) - 1; p >= i; p--) {
+        var w = e[a.charAt(p - 1)];
+        k[p] =
+          0 === t
+            ? ((k[p + 1] << 1) | 1) & w
+            : (((k[p + 1] << 1) | 1) & w) | (((r[p + 1] | r[p]) << 1) | 1) | r[p + 1];
+        if (k[p] & j && ((w = d(t, p - 1)), w <= g))
+          if (((g = w), (h = p - 1), h > c)) i = Math.max(1, 2 * c - h);
+          else break;
+      }
+      if (d(t + 1, c) > g) break;
+      r = k;
+    }
+    return h;
+  };
+  diff_match_patch.prototype.match_alphabet_ = function(a) {
+    for (var b = {}, c = 0; c < a.length; c++) b[a.charAt(c)] = 0;
+    for (c = 0; c < a.length; c++) b[a.charAt(c)] |= 1 << (a.length - c - 1);
+    return b;
+  };
+  diff_match_patch.prototype.patch_addContext_ = function(a, b) {
+    if (0 != b.length) {
+      for (
+        var c = b.substring(a.start2, a.start2 + a.length1), d = 0;
+        b.indexOf(c) != b.lastIndexOf(c) &&
+        c.length < this.Match_MaxBits - this.Patch_Margin - this.Patch_Margin;
+
+      )
+        (d += this.Patch_Margin), (c = b.substring(a.start2 - d, a.start2 + a.length1 + d));
+      d += this.Patch_Margin;
+      (c = b.substring(a.start2 - d, a.start2)) && a.diffs.unshift([0, c]);
+      (d = b.substring(a.start2 + a.length1, a.start2 + a.length1 + d)) && a.diffs.push([0, d]);
+      a.start1 -= c.length;
+      a.start2 -= c.length;
+      a.length1 += c.length + d.length;
+      a.length2 += c.length + d.length;
+    }
+  };
+  diff_match_patch.prototype.patch_make = function(a, b, c) {
+    var d;
+    if ('string' == typeof a && 'string' == typeof b && 'undefined' == typeof c)
+      (d = a),
+        (b = this.diff_main(d, b, !0)),
+        2 < b.length && (this.diff_cleanupSemantic(b), this.diff_cleanupEfficiency(b));
+    else if (a && 'object' == typeof a && 'undefined' == typeof b && 'undefined' == typeof c)
+      (b = a), (d = this.diff_text1(b));
+    else if ('string' == typeof a && b && 'object' == typeof b && 'undefined' == typeof c) d = a;
+    else if ('string' == typeof a && 'string' == typeof b && c && 'object' == typeof c)
+      (d = a), (b = c);
+    else throw Error('Unknown call format to patch_make.');
+    if (0 === b.length) return [];
+    c = [];
+    a = new diff_match_patch.patch_obj();
+    for (var e = 0, f = 0, g = 0, h = d, j = 0; j < b.length; j++) {
+      var i = b[j][0],
+        k = b[j][1];
+      !e && 0 !== i && ((a.start1 = f), (a.start2 = g));
+      switch (i) {
+        case 1:
+          a.diffs[e++] = b[j];
+          a.length2 += k.length;
+          d = d.substring(0, g) + k + d.substring(g);
+          break;
+        case -1:
+          a.length1 += k.length;
+          a.diffs[e++] = b[j];
+          d = d.substring(0, g) + d.substring(g + k.length);
+          break;
+        case 0:
+          k.length <= 2 * this.Patch_Margin && e && b.length != j + 1
+            ? ((a.diffs[e++] = b[j]), (a.length1 += k.length), (a.length2 += k.length))
+            : k.length >= 2 * this.Patch_Margin &&
+              e &&
+              (this.patch_addContext_(a, h),
+              c.push(a),
+              (a = new diff_match_patch.patch_obj()),
+              (e = 0),
+              (h = d),
+              (f = g));
+      }
+      1 !== i && (f += k.length);
+      -1 !== i && (g += k.length);
+    }
+    e && (this.patch_addContext_(a, h), c.push(a));
+    return c;
+  };
+  diff_match_patch.prototype.patch_deepCopy = function(a) {
+    for (var b = [], c = 0; c < a.length; c++) {
+      var d = a[c],
+        e = new diff_match_patch.patch_obj();
+      e.diffs = [];
+      for (var f = 0; f < d.diffs.length; f++) e.diffs[f] = d.diffs[f].slice();
+      e.start1 = d.start1;
+      e.start2 = d.start2;
+      e.length1 = d.length1;
+      e.length2 = d.length2;
+      b[c] = e;
+    }
+    return b;
+  };
+  diff_match_patch.prototype.patch_apply = function(a, b) {
+    if (0 == a.length) return [b, []];
+    a = this.patch_deepCopy(a);
+    var c = this.patch_addPadding(a);
+    b = c + b + c;
+    this.patch_splitMax(a);
+    for (var d = 0, e = [], f = 0; f < a.length; f++) {
+      var g = a[f].start2 + d,
+        h = this.diff_text1(a[f].diffs),
+        j,
+        i = -1;
+      if (h.length > this.Match_MaxBits) {
+        if (
+          ((j = this.match_main(b, h.substring(0, this.Match_MaxBits), g)),
+          -1 != j &&
+            ((i = this.match_main(
+              b,
+              h.substring(h.length - this.Match_MaxBits),
+              g + h.length - this.Match_MaxBits
+            )),
+            -1 == i || j >= i))
+        )
+          j = -1;
+      } else j = this.match_main(b, h, g);
+      if (-1 == j) (e[f] = !1), (d -= a[f].length2 - a[f].length1);
+      else if (
+        ((e[f] = !0),
+        (d = j - g),
+        (g = -1 == i ? b.substring(j, j + h.length) : b.substring(j, i + this.Match_MaxBits)),
+        h == g)
+      )
+        b = b.substring(0, j) + this.diff_text2(a[f].diffs) + b.substring(j + h.length);
+      else if (
+        ((g = this.diff_main(h, g, !1)),
+        h.length > this.Match_MaxBits &&
+          this.diff_levenshtein(g) / h.length > this.Patch_DeleteThreshold)
+      )
+        e[f] = !1;
+      else {
+        this.diff_cleanupSemanticLossless(g);
+        for (var h = 0, k, i = 0; i < a[f].diffs.length; i++) {
+          var q = a[f].diffs[i];
+          0 !== q[0] && (k = this.diff_xIndex(g, h));
+          1 === q[0]
+            ? (b = b.substring(0, j + k) + q[1] + b.substring(j + k))
+            : -1 === q[0] &&
+              (b = b.substring(0, j + k) + b.substring(j + this.diff_xIndex(g, h + q[1].length)));
+          -1 !== q[0] && (h += q[1].length);
+        }
+      }
+    }
+    b = b.substring(c.length, b.length - c.length);
+    return [b, e];
+  };
+  diff_match_patch.prototype.patch_addPadding = function(a) {
+    for (var b = this.Patch_Margin, c = '', d = 1; d <= b; d++) c += String.fromCharCode(d);
+    for (d = 0; d < a.length; d++) (a[d].start1 += b), (a[d].start2 += b);
+    var d = a[0],
+      e = d.diffs;
+    if (0 == e.length || 0 != e[0][0])
+      e.unshift([0, c]), (d.start1 -= b), (d.start2 -= b), (d.length1 += b), (d.length2 += b);
+    else if (b > e[0][1].length) {
+      var f = b - e[0][1].length;
+      e[0][1] = c.substring(e[0][1].length) + e[0][1];
+      d.start1 -= f;
+      d.start2 -= f;
+      d.length1 += f;
+      d.length2 += f;
+    }
+    d = a[a.length - 1];
+    e = d.diffs;
+    0 == e.length || 0 != e[e.length - 1][0]
+      ? (e.push([0, c]), (d.length1 += b), (d.length2 += b))
+      : b > e[e.length - 1][1].length &&
+        ((f = b - e[e.length - 1][1].length),
+        (e[e.length - 1][1] += c.substring(0, f)),
+        (d.length1 += f),
+        (d.length2 += f));
+    return c;
+  };
+  diff_match_patch.prototype.patch_splitMax = function(a) {
+    for (var b = this.Match_MaxBits, c = 0; c < a.length; c++)
+      if (!(a[c].length1 <= b)) {
+        var d = a[c];
+        a.splice(c--, 1);
+        for (var e = d.start1, f = d.start2, g = ''; 0 !== d.diffs.length; ) {
+          var h = new diff_match_patch.patch_obj(),
+            j = !0;
+          h.start1 = e - g.length;
+          h.start2 = f - g.length;
+          '' !== g && ((h.length1 = h.length2 = g.length), h.diffs.push([0, g]));
+          for (; 0 !== d.diffs.length && h.length1 < b - this.Patch_Margin; ) {
+            var g = d.diffs[0][0],
+              i = d.diffs[0][1];
+            1 === g
+              ? ((h.length2 += i.length), (f += i.length), h.diffs.push(d.diffs.shift()), (j = !1))
+              : -1 === g && 1 == h.diffs.length && 0 == h.diffs[0][0] && i.length > 2 * b
+              ? ((h.length1 += i.length),
+                (e += i.length),
+                (j = !1),
+                h.diffs.push([g, i]),
+                d.diffs.shift())
+              : ((i = i.substring(0, b - h.length1 - this.Patch_Margin)),
+                (h.length1 += i.length),
+                (e += i.length),
+                0 === g ? ((h.length2 += i.length), (f += i.length)) : (j = !1),
+                h.diffs.push([g, i]),
+                i == d.diffs[0][1]
+                  ? d.diffs.shift()
+                  : (d.diffs[0][1] = d.diffs[0][1].substring(i.length)));
+          }
+          g = this.diff_text2(h.diffs);
+          g = g.substring(g.length - this.Patch_Margin);
+          i = this.diff_text1(d.diffs).substring(0, this.Patch_Margin);
+          '' !== i &&
+            ((h.length1 += i.length),
+            (h.length2 += i.length),
+            0 !== h.diffs.length && 0 === h.diffs[h.diffs.length - 1][0]
+              ? (h.diffs[h.diffs.length - 1][1] += i)
+              : h.diffs.push([0, i]));
+          j || a.splice(++c, 0, h);
+        }
+      }
+  };
+  diff_match_patch.prototype.patch_toText = function(a) {
+    for (var b = [], c = 0; c < a.length; c++) b[c] = a[c];
+    return b.join('');
+  };
+  diff_match_patch.prototype.patch_fromText = function(a) {
+    var b = [];
+    if (!a) return b;
+    a = a.split('\n');
+    for (var c = 0, d = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/; c < a.length; ) {
+      var e = a[c].match(d);
+      if (!e) throw Error('Invalid patch string: ' + a[c]);
+      var f = new diff_match_patch.patch_obj();
+      b.push(f);
+      f.start1 = parseInt(e[1], 10);
+      '' === e[2]
+        ? (f.start1--, (f.length1 = 1))
+        : '0' == e[2]
+        ? (f.length1 = 0)
+        : (f.start1--, (f.length1 = parseInt(e[2], 10)));
+      f.start2 = parseInt(e[3], 10);
+      '' === e[4]
+        ? (f.start2--, (f.length2 = 1))
+        : '0' == e[4]
+        ? (f.length2 = 0)
+        : (f.start2--, (f.length2 = parseInt(e[4], 10)));
+      for (c++; c < a.length; ) {
+        e = a[c].charAt(0);
+        try {
+          var g = decodeURI(a[c].substring(1));
+        } catch (h) {
+          throw Error('Illegal escape in patch_fromText: ' + g);
+        }
+        if ('-' == e) f.diffs.push([-1, g]);
+        else if ('+' == e) f.diffs.push([1, g]);
+        else if (' ' == e) f.diffs.push([0, g]);
+        else if ('@' == e) break;
+        else if ('' !== e) throw Error('Invalid patch mode "' + e + '" in: ' + g);
+        c++;
+      }
+    }
+    return b;
+  };
+  diff_match_patch.patch_obj = function() {
+    this.diffs = [];
+    this.start2 = this.start1 = null;
+    this.length2 = this.length1 = 0;
+  };
+  diff_match_patch.patch_obj.prototype.toString = function() {
+    var a, b;
+    a =
+      0 === this.length1
+        ? this.start1 + ',0'
+        : 1 == this.length1
+        ? this.start1 + 1
+        : this.start1 + 1 + ',' + this.length1;
+    b =
+      0 === this.length2
+        ? this.start2 + ',0'
+        : 1 == this.length2
+        ? this.start2 + 1
+        : this.start2 + 1 + ',' + this.length2;
+    a = ['@@ -' + a + ' +' + b + ' @@\n'];
+    var c;
+    for (b = 0; b < this.diffs.length; b++) {
+      switch (this.diffs[b][0]) {
+        case 1:
+          c = '+';
+          break;
+        case -1:
+          c = '-';
+          break;
+        case 0:
+          c = ' ';
+      }
+      a[b + 1] = c + encodeURI(this.diffs[b][1]) + '\n';
+    }
+    return a.join('').replace(/%20/g, ' ');
+  };
+  this.diff_match_patch = diff_match_patch;
+  this.DIFF_DELETE = -1;
+  this.DIFF_INSERT = 1;
+  this.DIFF_EQUAL = 0;
+})();

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/bat.js

@@ -0,0 +1,74 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/bat', ['require', 'exports'], function(e, s) {
+  'use strict';
+  Object.defineProperty(s, '__esModule', { value: !0 }),
+    (s.conf = {
+      comments: { lineComment: 'REM' },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+      ],
+      surroundingPairs: [
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+      ],
+    }),
+    (s.language = {
+      defaultToken: '',
+      ignoreCase: !0,
+      tokenPostfix: '.bat',
+      brackets: [
+        { token: 'delimiter.bracket', open: '{', close: '}' },
+        { token: 'delimiter.parenthesis', open: '(', close: ')' },
+        { token: 'delimiter.square', open: '[', close: ']' },
+      ],
+      keywords: /call|defined|echo|errorlevel|exist|for|goto|if|pause|set|shift|start|title|not|pushd|popd/,
+      symbols: /[=><!~?&|+\-*\/\^;\.,]+/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      tokenizer: {
+        root: [
+          [/^(\s*)(rem(?:\s.*|))$/, ['', 'comment']],
+          [/(\@?)(@keywords)(?!\w)/, [{ token: 'keyword' }, { token: 'keyword.$2' }]],
+          [/[ \t\r\n]+/, ''],
+          [/setlocal(?!\w)/, 'keyword.tag-setlocal'],
+          [/endlocal(?!\w)/, 'keyword.tag-setlocal'],
+          [/[a-zA-Z_]\w*/, ''],
+          [/:\w*/, 'metatag'],
+          [/%[^%]+%/, 'variable'],
+          [/%%[\w]+(?!\w)/, 'variable'],
+          [/[{}()\[\]]/, '@brackets'],
+          [/@symbols/, 'delimiter'],
+          [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+          [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
+          [/\d+/, 'number'],
+          [/[;,.]/, 'delimiter'],
+          [/"/, 'string', '@string."'],
+          [/'/, 'string', "@string.'"],
+        ],
+        string: [
+          [
+            /[^\\"'%]+/,
+            { cases: { '@eos': { token: 'string', next: '@popall' }, '@default': 'string' } },
+          ],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [/%[\w ]+%/, 'variable'],
+          [/%%[\w]+(?!\w)/, 'variable'],
+          [
+            /["']/,
+            { cases: { '$#==$S2': { token: 'string', next: '@pop' }, '@default': 'string' } },
+          ],
+          [/$/, 'string', '@popall'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/coffee.js

@@ -0,0 +1,186 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/coffee', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+      comments: { blockComment: ['###', '###'], lineComment: '#' },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      ignoreCase: !0,
+      tokenPostfix: '.coffee',
+      brackets: [
+        { open: '{', close: '}', token: 'delimiter.curly' },
+        { open: '[', close: ']', token: 'delimiter.square' },
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+      ],
+      regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
+      keywords: [
+        'and',
+        'or',
+        'is',
+        'isnt',
+        'not',
+        'on',
+        'yes',
+        '@',
+        'no',
+        'off',
+        'true',
+        'false',
+        'null',
+        'this',
+        'new',
+        'delete',
+        'typeof',
+        'in',
+        'instanceof',
+        'return',
+        'throw',
+        'break',
+        'continue',
+        'debugger',
+        'if',
+        'else',
+        'switch',
+        'for',
+        'while',
+        'do',
+        'try',
+        'catch',
+        'finally',
+        'class',
+        'extends',
+        'super',
+        'undefined',
+        'then',
+        'unless',
+        'until',
+        'loop',
+        'of',
+        'by',
+        'when',
+      ],
+      symbols: /[=><!~?&%|+\-*\/\^\.,\:]+/,
+      escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      tokenizer: {
+        root: [
+          [/\@[a-zA-Z_]\w*/, 'variable.predefined'],
+          [
+            /[a-zA-Z_]\w*/,
+            {
+              cases: {
+                this: 'variable.predefined',
+                '@keywords': { token: 'keyword.$0' },
+                '@default': '',
+              },
+            },
+          ],
+          [/[ \t\r\n]+/, ''],
+          [/###/, 'comment', '@comment'],
+          [/#.*$/, 'comment'],
+          ['///', { token: 'regexp', next: '@hereregexp' }],
+          [/^(\s*)(@regEx)/, ['', 'regexp']],
+          [/(\()(\s*)(@regEx)/, ['@brackets', '', 'regexp']],
+          [/(\,)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+          [/(\=)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+          [/(\:)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+          [/(\[)(\s*)(@regEx)/, ['@brackets', '', 'regexp']],
+          [/(\!)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+          [/(\&)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+          [/(\|)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+          [/(\?)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+          [/(\{)(\s*)(@regEx)/, ['@brackets', '', 'regexp']],
+          [/(\;)(\s*)(@regEx)/, ['', '', 'regexp']],
+          [
+            /}/,
+            {
+              cases: {
+                '$S2==interpolatedstring': { token: 'string', next: '@pop' },
+                '@default': '@brackets',
+              },
+            },
+          ],
+          [/[{}()\[\]]/, '@brackets'],
+          [/@symbols/, 'delimiter'],
+          [/\d+[eE]([\-+]?\d+)?/, 'number.float'],
+          [/\d+\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+          [/0[xX][0-9a-fA-F]+/, 'number.hex'],
+          [/0[0-7]+(?!\d)/, 'number.octal'],
+          [/\d+/, 'number'],
+          [/[,.]/, 'delimiter'],
+          [/"""/, 'string', '@herestring."""'],
+          [/'''/, 'string', "@herestring.'''"],
+          [
+            /"/,
+            { cases: { '@eos': 'string', '@default': { token: 'string', next: '@string."' } } },
+          ],
+          [
+            /'/,
+            { cases: { '@eos': 'string', '@default': { token: 'string', next: "@string.'" } } },
+          ],
+        ],
+        string: [
+          [/[^"'\#\\]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\./, 'string.escape.invalid'],
+          [/\./, 'string.escape.invalid'],
+          [
+            /#{/,
+            {
+              cases: {
+                '$S2=="': { token: 'string', next: 'root.interpolatedstring' },
+                '@default': 'string',
+              },
+            },
+          ],
+          [
+            /["']/,
+            { cases: { '$#==$S2': { token: 'string', next: '@pop' }, '@default': 'string' } },
+          ],
+          [/#/, 'string'],
+        ],
+        herestring: [
+          [
+            /("""|''')/,
+            { cases: { '$1==$S2': { token: 'string', next: '@pop' }, '@default': 'string' } },
+          ],
+          [/[^#\\'"]+/, 'string'],
+          [/['"]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\./, 'string.escape.invalid'],
+          [/#{/, { token: 'string.quote', next: 'root.interpolatedstring' }],
+          [/#/, 'string'],
+        ],
+        comment: [[/[^#]+/, 'comment'], [/###/, 'comment', '@pop'], [/#/, 'comment']],
+        hereregexp: [
+          [/[^\\\/#]+/, 'regexp'],
+          [/\\./, 'regexp'],
+          [/#.*$/, 'comment'],
+          ['///[igm]*', { token: 'regexp', next: '@pop' }],
+          [/\//, 'regexp'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/cpp.js

@@ -0,0 +1,305 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/cpp', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '[', close: ']' },
+        { open: '{', close: '}' },
+        { open: '(', close: ')' },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+        { open: '"', close: '"', notIn: ['string'] },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.cpp',
+      brackets: [
+        { token: 'delimiter.curly', open: '{', close: '}' },
+        { token: 'delimiter.parenthesis', open: '(', close: ')' },
+        { token: 'delimiter.square', open: '[', close: ']' },
+        { token: 'delimiter.angle', open: '<', close: '>' },
+      ],
+      keywords: [
+        'abstract',
+        'amp',
+        'array',
+        'auto',
+        'bool',
+        'break',
+        'case',
+        'catch',
+        'char',
+        'class',
+        'const',
+        'constexpr',
+        'const_cast',
+        'continue',
+        'cpu',
+        'decltype',
+        'default',
+        'delegate',
+        'delete',
+        'do',
+        'double',
+        'dynamic_cast',
+        'each',
+        'else',
+        'enum',
+        'event',
+        'explicit',
+        'export',
+        'extern',
+        'false',
+        'final',
+        'finally',
+        'float',
+        'for',
+        'friend',
+        'gcnew',
+        'generic',
+        'goto',
+        'if',
+        'in',
+        'initonly',
+        'inline',
+        'int',
+        'interface',
+        'interior_ptr',
+        'internal',
+        'literal',
+        'long',
+        'mutable',
+        'namespace',
+        'new',
+        'noexcept',
+        'nullptr',
+        '__nullptr',
+        'operator',
+        'override',
+        'partial',
+        'pascal',
+        'pin_ptr',
+        'private',
+        'property',
+        'protected',
+        'public',
+        'ref',
+        'register',
+        'reinterpret_cast',
+        'restrict',
+        'return',
+        'safe_cast',
+        'sealed',
+        'short',
+        'signed',
+        'sizeof',
+        'static',
+        'static_assert',
+        'static_cast',
+        'struct',
+        'switch',
+        'template',
+        'this',
+        'thread_local',
+        'throw',
+        'tile_static',
+        'true',
+        'try',
+        'typedef',
+        'typeid',
+        'typename',
+        'union',
+        'unsigned',
+        'using',
+        'virtual',
+        'void',
+        'volatile',
+        'wchar_t',
+        'where',
+        'while',
+        '_asm',
+        '_based',
+        '_cdecl',
+        '_declspec',
+        '_fastcall',
+        '_if_exists',
+        '_if_not_exists',
+        '_inline',
+        '_multiple_inheritance',
+        '_pascal',
+        '_single_inheritance',
+        '_stdcall',
+        '_virtual_inheritance',
+        '_w64',
+        '__abstract',
+        '__alignof',
+        '__asm',
+        '__assume',
+        '__based',
+        '__box',
+        '__builtin_alignof',
+        '__cdecl',
+        '__clrcall',
+        '__declspec',
+        '__delegate',
+        '__event',
+        '__except',
+        '__fastcall',
+        '__finally',
+        '__forceinline',
+        '__gc',
+        '__hook',
+        '__identifier',
+        '__if_exists',
+        '__if_not_exists',
+        '__inline',
+        '__int128',
+        '__int16',
+        '__int32',
+        '__int64',
+        '__int8',
+        '__interface',
+        '__leave',
+        '__m128',
+        '__m128d',
+        '__m128i',
+        '__m256',
+        '__m256d',
+        '__m256i',
+        '__m64',
+        '__multiple_inheritance',
+        '__newslot',
+        '__nogc',
+        '__noop',
+        '__nounwind',
+        '__novtordisp',
+        '__pascal',
+        '__pin',
+        '__pragma',
+        '__property',
+        '__ptr32',
+        '__ptr64',
+        '__raise',
+        '__restrict',
+        '__resume',
+        '__sealed',
+        '__single_inheritance',
+        '__stdcall',
+        '__super',
+        '__thiscall',
+        '__try',
+        '__try_cast',
+        '__typeof',
+        '__unaligned',
+        '__unhook',
+        '__uuidof',
+        '__value',
+        '__virtual_inheritance',
+        '__w64',
+        '__wchar_t',
+      ],
+      operators: [
+        '=',
+        '>',
+        '<',
+        '!',
+        '~',
+        '?',
+        ':',
+        '==',
+        '<=',
+        '>=',
+        '!=',
+        '&&',
+        '||',
+        '++',
+        '--',
+        '+',
+        '-',
+        '*',
+        '/',
+        '&',
+        '|',
+        '^',
+        '%',
+        '<<',
+        '>>',
+        '>>>',
+        '+=',
+        '-=',
+        '*=',
+        '/=',
+        '&=',
+        '|=',
+        '^=',
+        '%=',
+        '<<=',
+        '>>=',
+        '>>>=',
+      ],
+      symbols: /[=><!~?:&|+\-*\/\^%]+/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      integersuffix: /(ll|LL|u|U|l|L)?(ll|LL|u|U|l|L)?/,
+      floatsuffix: /[fFlL]?/,
+      tokenizer: {
+        root: [
+          [
+            /[a-zA-Z_]\w*/,
+            { cases: { '@keywords': { token: 'keyword.$0' }, '@default': 'identifier' } },
+          ],
+          { include: '@whitespace' },
+          [/\[\[.*\]\]/, 'annotation'],
+          [/^\s*#\w+/, 'keyword'],
+          [/[{}()\[\]]/, '@brackets'],
+          [/[<>](?!@symbols)/, '@brackets'],
+          [/@symbols/, { cases: { '@operators': 'delimiter', '@default': '' } }],
+          [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+          [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+          [/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/, 'number.hex'],
+          [/0[0-7']*[0-7](@integersuffix)/, 'number.octal'],
+          [/0[bB][0-1']*[0-1](@integersuffix)/, 'number.binary'],
+          [/\d[\d']*\d(@integersuffix)/, 'number'],
+          [/\d(@integersuffix)/, 'number'],
+          [/[;,.]/, 'delimiter'],
+          [/"([^"\\]|\\.)*$/, 'string.invalid'],
+          [/"/, 'string', '@string'],
+          [/'[^\\']'/, 'string'],
+          [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+          [/'/, 'string.invalid'],
+        ],
+        whitespace: [
+          [/[ \t\r\n]+/, ''],
+          [/\/\*\*(?!\/)/, 'comment.doc', '@doccomment'],
+          [/\/\*/, 'comment', '@comment'],
+          [/\/\/.*$/, 'comment'],
+        ],
+        comment: [[/[^\/*]+/, 'comment'], [/\*\//, 'comment', '@pop'], [/[\/*]/, 'comment']],
+        doccomment: [
+          [/[^\/*]+/, 'comment.doc'],
+          [/\*\//, 'comment.doc', '@pop'],
+          [/[\/*]/, 'comment.doc'],
+        ],
+        string: [
+          [/[^\\"]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [/"/, 'string', '@pop'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/csharp.js

@@ -0,0 +1,280 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/csharp', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+      comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+        { open: '"', close: '"', notIn: ['string', 'comment'] },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '<', close: '>' },
+        { open: "'", close: "'" },
+        { open: '"', close: '"' },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.cs',
+      brackets: [
+        { open: '{', close: '}', token: 'delimiter.curly' },
+        { open: '[', close: ']', token: 'delimiter.square' },
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+        { open: '<', close: '>', token: 'delimiter.angle' },
+      ],
+      keywords: [
+        'extern',
+        'alias',
+        'using',
+        'bool',
+        'decimal',
+        'sbyte',
+        'byte',
+        'short',
+        'ushort',
+        'int',
+        'uint',
+        'long',
+        'ulong',
+        'char',
+        'float',
+        'double',
+        'object',
+        'dynamic',
+        'string',
+        'assembly',
+        'is',
+        'as',
+        'ref',
+        'out',
+        'this',
+        'base',
+        'new',
+        'typeof',
+        'void',
+        'checked',
+        'unchecked',
+        'default',
+        'delegate',
+        'var',
+        'const',
+        'if',
+        'else',
+        'switch',
+        'case',
+        'while',
+        'do',
+        'for',
+        'foreach',
+        'in',
+        'break',
+        'continue',
+        'goto',
+        'return',
+        'throw',
+        'try',
+        'catch',
+        'finally',
+        'lock',
+        'yield',
+        'from',
+        'let',
+        'where',
+        'join',
+        'on',
+        'equals',
+        'into',
+        'orderby',
+        'ascending',
+        'descending',
+        'select',
+        'group',
+        'by',
+        'namespace',
+        'partial',
+        'class',
+        'field',
+        'event',
+        'method',
+        'param',
+        'property',
+        'public',
+        'protected',
+        'internal',
+        'private',
+        'abstract',
+        'sealed',
+        'static',
+        'struct',
+        'readonly',
+        'volatile',
+        'virtual',
+        'override',
+        'params',
+        'get',
+        'set',
+        'add',
+        'remove',
+        'operator',
+        'true',
+        'false',
+        'implicit',
+        'explicit',
+        'interface',
+        'enum',
+        'null',
+        'async',
+        'await',
+        'fixed',
+        'sizeof',
+        'stackalloc',
+        'unsafe',
+        'nameof',
+        'when',
+      ],
+      namespaceFollows: ['namespace', 'using'],
+      parenFollows: ['if', 'for', 'while', 'switch', 'foreach', 'using', 'catch', 'when'],
+      operators: [
+        '=',
+        '??',
+        '||',
+        '&&',
+        '|',
+        '^',
+        '&',
+        '==',
+        '!=',
+        '<=',
+        '>=',
+        '<<',
+        '+',
+        '-',
+        '*',
+        '/',
+        '%',
+        '!',
+        '~',
+        '++',
+        '--',
+        '+=',
+        '-=',
+        '*=',
+        '/=',
+        '%=',
+        '&=',
+        '|=',
+        '^=',
+        '<<=',
+        '>>=',
+        '>>',
+        '=>',
+      ],
+      symbols: /[=><!~?:&|+\-*\/\^%]+/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      tokenizer: {
+        root: [
+          [
+            /\@?[a-zA-Z_]\w*/,
+            {
+              cases: {
+                '@namespaceFollows': { token: 'keyword.$0', next: '@namespace' },
+                '@keywords': { token: 'keyword.$0', next: '@qualified' },
+                '@default': { token: 'identifier', next: '@qualified' },
+              },
+            },
+          ],
+          { include: '@whitespace' },
+          [
+            /}/,
+            {
+              cases: {
+                '$S2==interpolatedstring': { token: 'string.quote', next: '@pop' },
+                '$S2==litinterpstring': { token: 'string.quote', next: '@pop' },
+                '@default': '@brackets',
+              },
+            },
+          ],
+          [/[{}()\[\]]/, '@brackets'],
+          [/[<>](?!@symbols)/, '@brackets'],
+          [/@symbols/, { cases: { '@operators': 'delimiter', '@default': '' } }],
+          [/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?[fFdD]?/, 'number.float'],
+          [/0[xX][0-9a-fA-F_]+/, 'number.hex'],
+          [/0[bB][01_]+/, 'number.hex'],
+          [/[0-9_]+/, 'number'],
+          [/[;,.]/, 'delimiter'],
+          [/"([^"\\]|\\.)*$/, 'string.invalid'],
+          [/"/, { token: 'string.quote', next: '@string' }],
+          [/\$\@"/, { token: 'string.quote', next: '@litinterpstring' }],
+          [/\@"/, { token: 'string.quote', next: '@litstring' }],
+          [/\$"/, { token: 'string.quote', next: '@interpolatedstring' }],
+          [/'[^\\']'/, 'string'],
+          [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+          [/'/, 'string.invalid'],
+        ],
+        qualified: [
+          [
+            /[a-zA-Z_][\w]*/,
+            { cases: { '@keywords': { token: 'keyword.$0' }, '@default': 'identifier' } },
+          ],
+          [/\./, 'delimiter'],
+          ['', '', '@pop'],
+        ],
+        namespace: [
+          { include: '@whitespace' },
+          [/[A-Z]\w*/, 'namespace'],
+          [/[\.=]/, 'delimiter'],
+          ['', '', '@pop'],
+        ],
+        comment: [[/[^\/*]+/, 'comment'], ['\\*/', 'comment', '@pop'], [/[\/*]/, 'comment']],
+        string: [
+          [/[^\\"]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [/"/, { token: 'string.quote', next: '@pop' }],
+        ],
+        litstring: [
+          [/[^"]+/, 'string'],
+          [/""/, 'string.escape'],
+          [/"/, { token: 'string.quote', next: '@pop' }],
+        ],
+        litinterpstring: [
+          [/[^"{]+/, 'string'],
+          [/""/, 'string.escape'],
+          [/{{/, 'string.escape'],
+          [/}}/, 'string.escape'],
+          [/{/, { token: 'string.quote', next: 'root.litinterpstring' }],
+          [/"/, { token: 'string.quote', next: '@pop' }],
+        ],
+        interpolatedstring: [
+          [/[^\\"{]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [/{{/, 'string.escape'],
+          [/}}/, 'string.escape'],
+          [/{/, { token: 'string.quote', next: 'root.interpolatedstring' }],
+          [/"/, { token: 'string.quote', next: '@pop' }],
+        ],
+        whitespace: [
+          [/^[ \t\v\f]*#((r)|(load))(?=\s)/, 'directive.csx'],
+          [/^[ \t\v\f]*#\w.*$/, 'namespace.cpp'],
+          [/[ \t\v\f\r\n]+/, ''],
+          [/\/\*/, 'comment', '@comment'],
+          [/\/\/.*$/, 'comment'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/css.js

@@ -0,0 +1,170 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/css', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      wordPattern: /(#?-?\d*\.\d\w*%?)|((::|[@#.!:])?[\w-?]+%?)|::|[@#.!:]/g,
+      comments: { blockComment: ['/*', '*/'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}', notIn: ['string', 'comment'] },
+        { open: '[', close: ']', notIn: ['string', 'comment'] },
+        { open: '(', close: ')', notIn: ['string', 'comment'] },
+        { open: '"', close: '"', notIn: ['string', 'comment'] },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.css',
+      ws: '[ \t\n\r\f]*',
+      identifier:
+        '-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
+      brackets: [
+        { open: '{', close: '}', token: 'delimiter.bracket' },
+        { open: '[', close: ']', token: 'delimiter.bracket' },
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+        { open: '<', close: '>', token: 'delimiter.angle' },
+      ],
+      tokenizer: {
+        root: [{ include: '@selector' }],
+        selector: [
+          { include: '@comments' },
+          { include: '@import' },
+          { include: '@strings' },
+          [
+            '[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)',
+            { token: 'keyword', next: '@keyframedeclaration' },
+          ],
+          ['[@](page|content|font-face|-moz-document)', { token: 'keyword' }],
+          ['[@](charset|namespace)', { token: 'keyword', next: '@declarationbody' }],
+          [
+            '(url-prefix)(\\()',
+            ['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }],
+          ],
+          [
+            '(url)(\\()',
+            ['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }],
+          ],
+          { include: '@selectorname' },
+          ['[\\*]', 'tag'],
+          ['[>\\+,]', 'delimiter'],
+          ['\\[', { token: 'delimiter.bracket', next: '@selectorattribute' }],
+          ['{', { token: 'delimiter.bracket', next: '@selectorbody' }],
+        ],
+        selectorbody: [
+          { include: '@comments' },
+          ['[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))', 'attribute.name', '@rulevalue'],
+          ['}', { token: 'delimiter.bracket', next: '@pop' }],
+        ],
+        selectorname: [['(\\.|#(?=[^{])|%|(@identifier)|:)+', 'tag']],
+        selectorattribute: [
+          { include: '@term' },
+          [']', { token: 'delimiter.bracket', next: '@pop' }],
+        ],
+        term: [
+          { include: '@comments' },
+          [
+            '(url-prefix)(\\()',
+            ['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }],
+          ],
+          [
+            '(url)(\\()',
+            ['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }],
+          ],
+          { include: '@functioninvocation' },
+          { include: '@numbers' },
+          { include: '@name' },
+          ['([<>=\\+\\-\\*\\/\\^\\|\\~,])', 'delimiter'],
+          [',', 'delimiter'],
+        ],
+        rulevalue: [
+          { include: '@comments' },
+          { include: '@strings' },
+          { include: '@term' },
+          ['!important', 'keyword'],
+          [';', 'delimiter', '@pop'],
+          ['(?=})', { token: '', next: '@pop' }],
+        ],
+        warndebug: [['[@](warn|debug)', { token: 'keyword', next: '@declarationbody' }]],
+        import: [['[@](import)', { token: 'keyword', next: '@declarationbody' }]],
+        urldeclaration: [
+          { include: '@strings' },
+          ['[^)\r\n]+', 'string'],
+          ['\\)', { token: 'delimiter.parenthesis', next: '@pop' }],
+        ],
+        parenthizedterm: [
+          { include: '@term' },
+          ['\\)', { token: 'delimiter.parenthesis', next: '@pop' }],
+        ],
+        declarationbody: [
+          { include: '@term' },
+          [';', 'delimiter', '@pop'],
+          ['(?=})', { token: '', next: '@pop' }],
+        ],
+        comments: [['\\/\\*', 'comment', '@comment'], ['\\/\\/+.*', 'comment']],
+        comment: [['\\*\\/', 'comment', '@pop'], [/[^*/]+/, 'comment'], [/./, 'comment']],
+        name: [['@identifier', 'attribute.value']],
+        numbers: [
+          [
+            '-?(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?',
+            { token: 'attribute.value.number', next: '@units' },
+          ],
+          ['#[0-9a-fA-F_]+(?!\\w)', 'attribute.value.hex'],
+        ],
+        units: [
+          [
+            '(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?',
+            'attribute.value.unit',
+            '@pop',
+          ],
+        ],
+        keyframedeclaration: [
+          ['@identifier', 'attribute.value'],
+          ['{', { token: 'delimiter.bracket', switchTo: '@keyframebody' }],
+        ],
+        keyframebody: [
+          { include: '@term' },
+          ['{', { token: 'delimiter.bracket', next: '@selectorbody' }],
+          ['}', { token: 'delimiter.bracket', next: '@pop' }],
+        ],
+        functioninvocation: [
+          ['@identifier\\(', { token: 'attribute.value', next: '@functionarguments' }],
+        ],
+        functionarguments: [
+          ['\\$@identifier@ws:', 'attribute.name'],
+          ['[,]', 'delimiter'],
+          { include: '@term' },
+          ['\\)', { token: 'attribute.value', next: '@pop' }],
+        ],
+        strings: [
+          ['~?"', { token: 'string', next: '@stringenddoublequote' }],
+          ["~?'", { token: 'string', next: '@stringendquote' }],
+        ],
+        stringenddoublequote: [
+          ['\\\\.', 'string'],
+          ['"', { token: 'string', next: '@pop' }],
+          [/[^\\"]+/, 'string'],
+          ['.', 'string'],
+        ],
+        stringendquote: [
+          ['\\\\.', 'string'],
+          ["'", { token: 'string', next: '@pop' }],
+          [/[^\\']+/, 'string'],
+          ['.', 'string'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/dockerfile.js

@@ -0,0 +1,94 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/dockerfile', ['require', 'exports'], function(e, s) {
+  'use strict';
+  Object.defineProperty(s, '__esModule', { value: !0 }),
+    (s.conf = {
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (s.language = {
+      defaultToken: '',
+      tokenPostfix: '.dockerfile',
+      instructions: /FROM|MAINTAINER|RUN|EXPOSE|ENV|ADD|VOLUME|LABEL|USER|WORKDIR|COPY|CMD|STOPSIGNAL|SHELL|ENTRYPOINT/,
+      instructionAfter: /ONBUILD/,
+      variableAfter: /ENV/,
+      variable: /\${?[\w]+}?/,
+      tokenizer: {
+        root: [
+          { include: '@whitespace' },
+          { include: '@comment' },
+          [/(@instructionAfter)(\s+)/, ['keyword', { token: '', next: '@instructions' }]],
+          ['', 'keyword', '@instructions'],
+        ],
+        instructions: [
+          [
+            /(@variableAfter)(\s+)([\w]+)/,
+            ['keyword', '', { token: 'variable', next: '@arguments' }],
+          ],
+          [/(@instructions)/, 'keyword', '@arguments'],
+        ],
+        arguments: [
+          { include: '@whitespace' },
+          { include: '@strings' },
+          [
+            /(@variable)/,
+            { cases: { '@eos': { token: 'variable', next: '@popall' }, '@default': 'variable' } },
+          ],
+          [/\\/, { cases: { '@eos': '', '@default': '' } }],
+          [/./, { cases: { '@eos': { token: '', next: '@popall' }, '@default': '' } }],
+        ],
+        whitespace: [
+          [/\s+/, { cases: { '@eos': { token: '', next: '@popall' }, '@default': '' } }],
+        ],
+        comment: [[/(^#.*$)/, 'comment', '@popall']],
+        strings: [
+          [/'$/, 'string', '@popall'],
+          [/'/, 'string', '@stringBody'],
+          [/"$/, 'string', '@popall'],
+          [/"/, 'string', '@dblStringBody'],
+        ],
+        stringBody: [
+          [
+            /[^\\\$']/,
+            { cases: { '@eos': { token: 'string', next: '@popall' }, '@default': 'string' } },
+          ],
+          [/\\./, 'string.escape'],
+          [/'$/, 'string', '@popall'],
+          [/'/, 'string', '@pop'],
+          [/(@variable)/, 'variable'],
+          [/\\$/, 'string'],
+          [/$/, 'string', '@popall'],
+        ],
+        dblStringBody: [
+          [
+            /[^\\\$"]/,
+            { cases: { '@eos': { token: 'string', next: '@popall' }, '@default': 'string' } },
+          ],
+          [/\\./, 'string.escape'],
+          [/"$/, 'string', '@popall'],
+          [/"/, 'string', '@pop'],
+          [/(@variable)/, 'variable'],
+          [/\\$/, 'string'],
+          [/$/, 'string', '@popall'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/fsharp.js

@@ -0,0 +1,178 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/fsharp', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      comments: { lineComment: '//', blockComment: ['(*', '*)'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.fs',
+      keywords: [
+        'abstract',
+        'and',
+        'atomic',
+        'as',
+        'assert',
+        'asr',
+        'base',
+        'begin',
+        'break',
+        'checked',
+        'component',
+        'const',
+        'constraint',
+        'constructor',
+        'continue',
+        'class',
+        'default',
+        'delegate',
+        'do',
+        'done',
+        'downcast',
+        'downto',
+        'elif',
+        'else',
+        'end',
+        'exception',
+        'eager',
+        'event',
+        'external',
+        'extern',
+        'false',
+        'finally',
+        'for',
+        'fun',
+        'function',
+        'fixed',
+        'functor',
+        'global',
+        'if',
+        'in',
+        'include',
+        'inherit',
+        'inline',
+        'interface',
+        'internal',
+        'land',
+        'lor',
+        'lsl',
+        'lsr',
+        'lxor',
+        'lazy',
+        'let',
+        'match',
+        'member',
+        'mod',
+        'module',
+        'mutable',
+        'namespace',
+        'method',
+        'mixin',
+        'new',
+        'not',
+        'null',
+        'of',
+        'open',
+        'or',
+        'object',
+        'override',
+        'private',
+        'parallel',
+        'process',
+        'protected',
+        'pure',
+        'public',
+        'rec',
+        'return',
+        'static',
+        'sealed',
+        'struct',
+        'sig',
+        'then',
+        'to',
+        'true',
+        'tailcall',
+        'trait',
+        'try',
+        'type',
+        'upcast',
+        'use',
+        'val',
+        'void',
+        'virtual',
+        'volatile',
+        'when',
+        'while',
+        'with',
+        'yield',
+      ],
+      symbols: /[=><!~?:&|+\-*\^%;\.,\/]+/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      integersuffix: /[uU]?[yslnLI]?/,
+      floatsuffix: /[fFmM]?/,
+      tokenizer: {
+        root: [
+          [
+            /[a-zA-Z_]\w*/,
+            { cases: { '@keywords': { token: 'keyword.$0' }, '@default': 'identifier' } },
+          ],
+          { include: '@whitespace' },
+          [/\[<.*>\]/, 'annotation'],
+          [/^#(if|else|endif)/, 'keyword'],
+          [/[{}()\[\]]/, '@brackets'],
+          [/[<>](?!@symbols)/, '@brackets'],
+          [/@symbols/, 'delimiter'],
+          [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+          [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+          [/0x[0-9a-fA-F]+LF/, 'number.float'],
+          [/0x[0-9a-fA-F]+(@integersuffix)/, 'number.hex'],
+          [/0b[0-1]+(@integersuffix)/, 'number.bin'],
+          [/\d+(@integersuffix)/, 'number'],
+          [/[;,.]/, 'delimiter'],
+          [/"([^"\\]|\\.)*$/, 'string.invalid'],
+          [/"""/, 'string', '@string."""'],
+          [/"/, 'string', '@string."'],
+          [/\@"/, { token: 'string.quote', next: '@litstring' }],
+          [/'[^\\']'B?/, 'string'],
+          [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+          [/'/, 'string.invalid'],
+        ],
+        whitespace: [[/[ \t\r\n]+/, ''], [/\(\*/, 'comment', '@comment'], [/\/\/.*$/, 'comment']],
+        comment: [[/[^\*]+/, 'comment'], [/\*\)/, 'comment', '@pop'], [/\*/, 'comment']],
+        string: [
+          [/[^\\"]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [
+            /("""|"B?)/,
+            { cases: { '$#==$S2': { token: 'string', next: '@pop' }, '@default': 'string' } },
+          ],
+        ],
+        litstring: [
+          [/[^"]+/, 'string'],
+          [/""/, 'string.escape'],
+          [/"/, { token: 'string.quote', next: '@pop' }],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/go.js

@@ -0,0 +1,182 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/go', ['require', 'exports'], function(e, n) {
+  'use strict';
+  Object.defineProperty(n, '__esModule', { value: !0 }),
+    (n.conf = {
+      comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '`', close: '`', notIn: ['string'] },
+        { open: '"', close: '"', notIn: ['string'] },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '`', close: '`' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (n.language = {
+      defaultToken: '',
+      tokenPostfix: '.go',
+      keywords: [
+        'break',
+        'case',
+        'chan',
+        'const',
+        'continue',
+        'default',
+        'defer',
+        'else',
+        'fallthrough',
+        'for',
+        'func',
+        'go',
+        'goto',
+        'if',
+        'import',
+        'interface',
+        'map',
+        'package',
+        'range',
+        'return',
+        'select',
+        'struct',
+        'switch',
+        'type',
+        'var',
+        'bool',
+        'true',
+        'false',
+        'uint8',
+        'uint16',
+        'uint32',
+        'uint64',
+        'int8',
+        'int16',
+        'int32',
+        'int64',
+        'float32',
+        'float64',
+        'complex64',
+        'complex128',
+        'byte',
+        'rune',
+        'uint',
+        'int',
+        'uintptr',
+        'string',
+        'nil',
+      ],
+      operators: [
+        '+',
+        '-',
+        '*',
+        '/',
+        '%',
+        '&',
+        '|',
+        '^',
+        '<<',
+        '>>',
+        '&^',
+        '+=',
+        '-=',
+        '*=',
+        '/=',
+        '%=',
+        '&=',
+        '|=',
+        '^=',
+        '<<=',
+        '>>=',
+        '&^=',
+        '&&',
+        '||',
+        '<-',
+        '++',
+        '--',
+        '==',
+        '<',
+        '>',
+        '=',
+        '!',
+        '!=',
+        '<=',
+        '>=',
+        ':=',
+        '...',
+        '(',
+        ')',
+        '',
+        ']',
+        '{',
+        '}',
+        ',',
+        ';',
+        '.',
+        ':',
+      ],
+      symbols: /[=><!~?:&|+\-*\/\^%]+/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      tokenizer: {
+        root: [
+          [
+            /[a-zA-Z_]\w*/,
+            { cases: { '@keywords': { token: 'keyword.$0' }, '@default': 'identifier' } },
+          ],
+          { include: '@whitespace' },
+          [/\[\[.*\]\]/, 'annotation'],
+          [/^\s*#\w+/, 'keyword'],
+          [/[{}()\[\]]/, '@brackets'],
+          [/[<>](?!@symbols)/, '@brackets'],
+          [/@symbols/, { cases: { '@operators': 'delimiter', '@default': '' } }],
+          [/\d*\d+[eE]([\-+]?\d+)?/, 'number.float'],
+          [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+          [/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, 'number.hex'],
+          [/0[0-7']*[0-7]/, 'number.octal'],
+          [/0[bB][0-1']*[0-1]/, 'number.binary'],
+          [/\d[\d']*/, 'number'],
+          [/\d/, 'number'],
+          [/[;,.]/, 'delimiter'],
+          [/"([^"\\]|\\.)*$/, 'string.invalid'],
+          [/"/, 'string', '@string'],
+          [/`/, 'string', '@rawstring'],
+          [/'[^\\']'/, 'string'],
+          [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+          [/'/, 'string.invalid'],
+        ],
+        whitespace: [
+          [/[ \t\r\n]+/, ''],
+          [/\/\*\*(?!\/)/, 'comment.doc', '@doccomment'],
+          [/\/\*/, 'comment', '@comment'],
+          [/\/\/.*$/, 'comment'],
+        ],
+        comment: [[/[^\/*]+/, 'comment'], [/\*\//, 'comment', '@pop'], [/[\/*]/, 'comment']],
+        doccomment: [
+          [/[^\/*]+/, 'comment.doc'],
+          [/\/\*/, 'comment.doc.invalid'],
+          [/\*\//, 'comment.doc', '@pop'],
+          [/[\/*]/, 'comment.doc'],
+        ],
+        string: [
+          [/[^\\"]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [/"/, 'string', '@pop'],
+        ],
+        rawstring: [[/[^\`]/, 'string'], [/`/, 'string', '@pop']],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/handlebars.js

@@ -0,0 +1,260 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/handlebars', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 });
+  var n = 'undefined' == typeof monaco ? self.monaco : monaco,
+    a = [
+      'area',
+      'base',
+      'br',
+      'col',
+      'embed',
+      'hr',
+      'img',
+      'input',
+      'keygen',
+      'link',
+      'menuitem',
+      'meta',
+      'param',
+      'source',
+      'track',
+      'wbr',
+    ];
+  (t.conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+    comments: { blockComment: ['{{!--', '--}}'] },
+    brackets: [['\x3c!--', '--\x3e'], ['<', '>'], ['{{', '}}'], ['{', '}'], ['(', ')']],
+    autoClosingPairs: [
+      { open: '{', close: '}' },
+      { open: '[', close: ']' },
+      { open: '(', close: ')' },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+    ],
+    surroundingPairs: [
+      { open: '<', close: '>' },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+    ],
+    onEnterRules: [
+      {
+        beforeText: new RegExp(
+          '<(?!(?:' + a.join('|') + '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$',
+          'i'
+        ),
+        afterText: /^<\/(\w[\w\d]*)\s*>$/i,
+        action: { indentAction: n.languages.IndentAction.IndentOutdent },
+      },
+      {
+        beforeText: new RegExp(
+          '<(?!(?:' + a.join('|') + '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$',
+          'i'
+        ),
+        action: { indentAction: n.languages.IndentAction.Indent },
+      },
+    ],
+  }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '',
+      tokenizer: {
+        root: [
+          [/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.root' }],
+          [/<!DOCTYPE/, 'metatag.html', '@doctype'],
+          [/<!--/, 'comment.html', '@comment'],
+          [/(<)(\w+)(\/>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
+          [/(<)(script)/, ['delimiter.html', { token: 'tag.html', next: '@script' }]],
+          [/(<)(style)/, ['delimiter.html', { token: 'tag.html', next: '@style' }]],
+          [/(<)([:\w]+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
+          [/(<\/)(\w+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
+          [/</, 'delimiter.html'],
+          [/\{/, 'delimiter.html'],
+          [/[^<{]+/],
+        ],
+        doctype: [
+          [/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.comment' }],
+          [/[^>]+/, 'metatag.content.html'],
+          [/>/, 'metatag.html', '@pop'],
+        ],
+        comment: [
+          [/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.comment' }],
+          [/-->/, 'comment.html', '@pop'],
+          [/[^-]+/, 'comment.content.html'],
+          [/./, 'comment.content.html'],
+        ],
+        otherTag: [
+          [/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.otherTag' }],
+          [/\/?>/, 'delimiter.html', '@pop'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+        ],
+        script: [
+          [/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.script' }],
+          [/type/, 'attribute.name', '@scriptAfterType'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [
+            />/,
+            {
+              token: 'delimiter.html',
+              next: '@scriptEmbedded.text/javascript',
+              nextEmbedded: 'text/javascript',
+            },
+          ],
+          [/[ \t\r\n]+/],
+          [
+            /(<\/)(script\s*)(>)/,
+            ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }],
+          ],
+        ],
+        scriptAfterType: [
+          [/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.scriptAfterType' }],
+          [/=/, 'delimiter', '@scriptAfterTypeEquals'],
+          [
+            />/,
+            {
+              token: 'delimiter.html',
+              next: '@scriptEmbedded.text/javascript',
+              nextEmbedded: 'text/javascript',
+            },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptAfterTypeEquals: [
+          [
+            /\{\{/,
+            { token: '@rematch', switchTo: '@handlebarsInSimpleState.scriptAfterTypeEquals' },
+          ],
+          [/"([^"]*)"/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
+          [/'([^']*)'/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
+          [
+            />/,
+            {
+              token: 'delimiter.html',
+              next: '@scriptEmbedded.text/javascript',
+              nextEmbedded: 'text/javascript',
+            },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptWithCustomType: [
+          [
+            /\{\{/,
+            { token: '@rematch', switchTo: '@handlebarsInSimpleState.scriptWithCustomType.$S2' },
+          ],
+          [/>/, { token: 'delimiter.html', next: '@scriptEmbedded.$S2', nextEmbedded: '$S2' }],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptEmbedded: [
+          [
+            /\{\{/,
+            {
+              token: '@rematch',
+              switchTo: '@handlebarsInEmbeddedState.scriptEmbedded.$S2',
+              nextEmbedded: '@pop',
+            },
+          ],
+          [/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+        ],
+        style: [
+          [/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.style' }],
+          [/type/, 'attribute.name', '@styleAfterType'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [
+            />/,
+            { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' },
+          ],
+          [/[ \t\r\n]+/],
+          [
+            /(<\/)(style\s*)(>)/,
+            ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }],
+          ],
+        ],
+        styleAfterType: [
+          [/\{\{/, { token: '@rematch', switchTo: '@handlebarsInSimpleState.styleAfterType' }],
+          [/=/, 'delimiter', '@styleAfterTypeEquals'],
+          [
+            />/,
+            { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleAfterTypeEquals: [
+          [
+            /\{\{/,
+            { token: '@rematch', switchTo: '@handlebarsInSimpleState.styleAfterTypeEquals' },
+          ],
+          [/"([^"]*)"/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
+          [/'([^']*)'/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
+          [
+            />/,
+            { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleWithCustomType: [
+          [
+            /\{\{/,
+            { token: '@rematch', switchTo: '@handlebarsInSimpleState.styleWithCustomType.$S2' },
+          ],
+          [/>/, { token: 'delimiter.html', next: '@styleEmbedded.$S2', nextEmbedded: '$S2' }],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleEmbedded: [
+          [
+            /\{\{/,
+            {
+              token: '@rematch',
+              switchTo: '@handlebarsInEmbeddedState.styleEmbedded.$S2',
+              nextEmbedded: '@pop',
+            },
+          ],
+          [/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+        ],
+        handlebarsInSimpleState: [
+          [/\{\{\{?/, 'delimiter.handlebars'],
+          [/\}\}\}?/, { token: 'delimiter.handlebars', switchTo: '@$S2.$S3' }],
+          { include: 'handlebarsRoot' },
+        ],
+        handlebarsInEmbeddedState: [
+          [/\{\{\{?/, 'delimiter.handlebars'],
+          [/\}\}\}?/, { token: 'delimiter.handlebars', switchTo: '@$S2.$S3', nextEmbedded: '$S3' }],
+          { include: 'handlebarsRoot' },
+        ],
+        handlebarsRoot: [
+          [/[#/][^\s}]+/, 'keyword.helper.handlebars'],
+          [/else\b/, 'keyword.helper.handlebars'],
+          [/[\s]+/],
+          [/[^}]/, 'variable.parameter.handlebars'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/html.js

@@ -0,0 +1,170 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/html', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 });
+  var n = 'undefined' == typeof monaco ? self.monaco : monaco,
+    i = [
+      'area',
+      'base',
+      'br',
+      'col',
+      'embed',
+      'hr',
+      'img',
+      'input',
+      'keygen',
+      'link',
+      'menuitem',
+      'meta',
+      'param',
+      'source',
+      'track',
+      'wbr',
+    ];
+  (t.conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+    comments: { blockComment: ['\x3c!--', '--\x3e'] },
+    brackets: [['\x3c!--', '--\x3e'], ['<', '>'], ['{', '}'], ['(', ')']],
+    autoClosingPairs: [
+      { open: '{', close: '}' },
+      { open: '[', close: ']' },
+      { open: '(', close: ')' },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+    ],
+    surroundingPairs: [
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: '{', close: '}' },
+      { open: '[', close: ']' },
+      { open: '(', close: ')' },
+      { open: '<', close: '>' },
+    ],
+    onEnterRules: [
+      {
+        beforeText: new RegExp(
+          '<(?!(?:' + i.join('|') + '))([_:\\w][_:\\w-.\\d]*)([^/>]*(?!/)>)[^<]*$',
+          'i'
+        ),
+        afterText: /^<\/([_:\w][_:\w-.\d]*)\s*>$/i,
+        action: { indentAction: n.languages.IndentAction.IndentOutdent },
+      },
+      {
+        beforeText: new RegExp(
+          '<(?!(?:' + i.join('|') + '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$',
+          'i'
+        ),
+        action: { indentAction: n.languages.IndentAction.Indent },
+      },
+    ],
+  }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.html',
+      ignoreCase: !0,
+      tokenizer: {
+        root: [
+          [/<!DOCTYPE/, 'metatag', '@doctype'],
+          [/<!--/, 'comment', '@comment'],
+          [/(<)((?:[\w\-]+:)?[\w\-]+)(\s*)(\/>)/, ['delimiter', 'tag', '', 'delimiter']],
+          [/(<)(script)/, ['delimiter', { token: 'tag', next: '@script' }]],
+          [/(<)(style)/, ['delimiter', { token: 'tag', next: '@style' }]],
+          [/(<)((?:[\w\-]+:)?[\w\-]+)/, ['delimiter', { token: 'tag', next: '@otherTag' }]],
+          [/(<\/)((?:[\w\-]+:)?[\w\-]+)/, ['delimiter', { token: 'tag', next: '@otherTag' }]],
+          [/</, 'delimiter'],
+          [/[^<]+/],
+        ],
+        doctype: [[/[^>]+/, 'metatag.content'], [/>/, 'metatag', '@pop']],
+        comment: [
+          [/-->/, 'comment', '@pop'],
+          [/[^-]+/, 'comment.content'],
+          [/./, 'comment.content'],
+        ],
+        otherTag: [
+          [/\/?>/, 'delimiter', '@pop'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+        ],
+        script: [
+          [/type/, 'attribute.name', '@scriptAfterType'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/>/, { token: 'delimiter', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }],
+          [/[ \t\r\n]+/],
+          [/(<\/)(script\s*)(>)/, ['delimiter', 'tag', { token: 'delimiter', next: '@pop' }]],
+        ],
+        scriptAfterType: [
+          [/=/, 'delimiter', '@scriptAfterTypeEquals'],
+          [/>/, { token: 'delimiter', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptAfterTypeEquals: [
+          [/"([^"]*)"/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
+          [/'([^']*)'/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
+          [/>/, { token: 'delimiter', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptWithCustomType: [
+          [/>/, { token: 'delimiter', next: '@scriptEmbedded.$S2', nextEmbedded: '$S2' }],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptEmbedded: [
+          [/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+          [/[^<]+/, ''],
+        ],
+        style: [
+          [/type/, 'attribute.name', '@styleAfterType'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/>/, { token: 'delimiter', next: '@styleEmbedded', nextEmbedded: 'text/css' }],
+          [/[ \t\r\n]+/],
+          [/(<\/)(style\s*)(>)/, ['delimiter', 'tag', { token: 'delimiter', next: '@pop' }]],
+        ],
+        styleAfterType: [
+          [/=/, 'delimiter', '@styleAfterTypeEquals'],
+          [/>/, { token: 'delimiter', next: '@styleEmbedded', nextEmbedded: 'text/css' }],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleAfterTypeEquals: [
+          [/"([^"]*)"/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
+          [/'([^']*)'/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
+          [/>/, { token: 'delimiter', next: '@styleEmbedded', nextEmbedded: 'text/css' }],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleWithCustomType: [
+          [/>/, { token: 'delimiter', next: '@styleEmbedded.$S2', nextEmbedded: '$S2' }],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleEmbedded: [
+          [/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+          [/[^<]+/, ''],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/ini.js

@@ -0,0 +1,55 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/ini', ['require', 'exports'], function(e, n) {
+  'use strict';
+  Object.defineProperty(n, '__esModule', { value: !0 }),
+    (n.conf = {
+      comments: { lineComment: '#' },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (n.language = {
+      defaultToken: '',
+      tokenPostfix: '.ini',
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      tokenizer: {
+        root: [
+          [/^\[[^\]]*\]/, 'metatag'],
+          [/(^\w+)(\s*)(\=)/, ['key', '', 'delimiter']],
+          { include: '@whitespace' },
+          [/\d+/, 'number'],
+          [/"([^"\\]|\\.)*$/, 'string.invalid'],
+          [/'([^'\\]|\\.)*$/, 'string.invalid'],
+          [/"/, 'string', '@string."'],
+          [/'/, 'string', "@string.'"],
+        ],
+        whitespace: [[/[ \t\r\n]+/, ''], [/^\s*[#;].*$/, 'comment']],
+        string: [
+          [/[^\\"']+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [
+            /["']/,
+            { cases: { '$#==$S2': { token: 'string', next: '@pop' }, '@default': 'string' } },
+          ],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/java.js

@@ -0,0 +1,178 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/java', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+      comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+        { open: '<', close: '>' },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.java',
+      keywords: [
+        'abstract',
+        'continue',
+        'for',
+        'new',
+        'switch',
+        'assert',
+        'default',
+        'goto',
+        'package',
+        'synchronized',
+        'boolean',
+        'do',
+        'if',
+        'private',
+        'this',
+        'break',
+        'double',
+        'implements',
+        'protected',
+        'throw',
+        'byte',
+        'else',
+        'import',
+        'public',
+        'throws',
+        'case',
+        'enum',
+        'instanceof',
+        'return',
+        'transient',
+        'catch',
+        'extends',
+        'int',
+        'short',
+        'try',
+        'char',
+        'final',
+        'interface',
+        'static',
+        'void',
+        'class',
+        'finally',
+        'long',
+        'strictfp',
+        'volatile',
+        'const',
+        'float',
+        'native',
+        'super',
+        'while',
+        'true',
+        'false',
+      ],
+      operators: [
+        '=',
+        '>',
+        '<',
+        '!',
+        '~',
+        '?',
+        ':',
+        '==',
+        '<=',
+        '>=',
+        '!=',
+        '&&',
+        '||',
+        '++',
+        '--',
+        '+',
+        '-',
+        '*',
+        '/',
+        '&',
+        '|',
+        '^',
+        '%',
+        '<<',
+        '>>',
+        '>>>',
+        '+=',
+        '-=',
+        '*=',
+        '/=',
+        '&=',
+        '|=',
+        '^=',
+        '%=',
+        '<<=',
+        '>>=',
+        '>>>=',
+      ],
+      symbols: /[=><!~?:&|+\-*\/\^%]+/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      digits: /\d+(_+\d+)*/,
+      octaldigits: /[0-7]+(_+[0-7]+)*/,
+      binarydigits: /[0-1]+(_+[0-1]+)*/,
+      hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+      tokenizer: {
+        root: [
+          [
+            /[a-zA-Z_$][\w$]*/,
+            { cases: { '@keywords': { token: 'keyword.$0' }, '@default': 'identifier' } },
+          ],
+          { include: '@whitespace' },
+          [/[{}()\[\]]/, '@brackets'],
+          [/[<>](?!@symbols)/, '@brackets'],
+          [/@symbols/, { cases: { '@operators': 'delimiter', '@default': '' } }],
+          [/@\s*[a-zA-Z_\$][\w\$]*/, 'annotation'],
+          [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, 'number.float'],
+          [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, 'number.float'],
+          [/0[xX](@hexdigits)[Ll]?/, 'number.hex'],
+          [/0(@octaldigits)[Ll]?/, 'number.octal'],
+          [/0[bB](@binarydigits)[Ll]?/, 'number.binary'],
+          [/(@digits)[fFdD]/, 'number.float'],
+          [/(@digits)[lL]?/, 'number'],
+          [/[;,.]/, 'delimiter'],
+          [/"([^"\\]|\\.)*$/, 'string.invalid'],
+          [/"/, 'string', '@string'],
+          [/'[^\\']'/, 'string'],
+          [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+          [/'/, 'string.invalid'],
+        ],
+        whitespace: [
+          [/[ \t\r\n]+/, ''],
+          [/\/\*\*(?!\/)/, 'comment.doc', '@javadoc'],
+          [/\/\*/, 'comment', '@comment'],
+          [/\/\/.*$/, 'comment'],
+        ],
+        comment: [[/[^\/*]+/, 'comment'], [/\*\//, 'comment', '@pop'], [/[\/*]/, 'comment']],
+        javadoc: [
+          [/[^\/*]+/, 'comment.doc'],
+          [/\/\*/, 'comment.doc.invalid'],
+          [/\*\//, 'comment.doc', '@pop'],
+          [/[\/*]/, 'comment.doc'],
+        ],
+        string: [
+          [/[^\\"]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [/"/, 'string', '@pop'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/less.js

@@ -0,0 +1,138 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/less', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      wordPattern: /(#?-?\d*\.\d\w*%?)|([@#!.:]?[\w-?]+%?)|[@#!.]/g,
+      comments: { blockComment: ['/*', '*/'], lineComment: '//' },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}', notIn: ['string', 'comment'] },
+        { open: '[', close: ']', notIn: ['string', 'comment'] },
+        { open: '(', close: ')', notIn: ['string', 'comment'] },
+        { open: '"', close: '"', notIn: ['string', 'comment'] },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.less',
+      identifier:
+        '-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
+      identifierPlus:
+        '-?-?([a-zA-Z:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
+      brackets: [
+        { open: '{', close: '}', token: 'delimiter.curly' },
+        { open: '[', close: ']', token: 'delimiter.bracket' },
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+        { open: '<', close: '>', token: 'delimiter.angle' },
+      ],
+      tokenizer: {
+        root: [
+          { include: '@nestedJSBegin' },
+          ['[ \\t\\r\\n]+', ''],
+          { include: '@comments' },
+          { include: '@keyword' },
+          { include: '@strings' },
+          { include: '@numbers' },
+          ['[*_]?[a-zA-Z\\-\\s]+(?=:.*(;|(\\\\$)))', 'attribute.name', '@attribute'],
+          ['url(\\-prefix)?\\(', { token: 'tag', next: '@urldeclaration' }],
+          ['[{}()\\[\\]]', '@brackets'],
+          ['[,:;]', 'delimiter'],
+          ['#@identifierPlus', 'tag.id'],
+          ['&', 'tag'],
+          ['\\.@identifierPlus(?=\\()', 'tag.class', '@attribute'],
+          ['\\.@identifierPlus', 'tag.class'],
+          ['@identifierPlus', 'tag'],
+          { include: '@operators' },
+          ['@(@identifier(?=[:,\\)]))', 'variable', '@attribute'],
+          ['@(@identifier)', 'variable'],
+          ['@', 'key', '@atRules'],
+        ],
+        nestedJSBegin: [
+          ['``', 'delimiter.backtick'],
+          [
+            '`',
+            { token: 'delimiter.backtick', next: '@nestedJSEnd', nextEmbedded: 'text/javascript' },
+          ],
+        ],
+        nestedJSEnd: [['`', { token: 'delimiter.backtick', next: '@pop', nextEmbedded: '@pop' }]],
+        operators: [['[<>=\\+\\-\\*\\/\\^\\|\\~]', 'operator']],
+        keyword: [
+          [
+            '(@[\\s]*import|![\\s]*important|true|false|when|iscolor|isnumber|isstring|iskeyword|isurl|ispixel|ispercentage|isem|hue|saturation|lightness|alpha|lighten|darken|saturate|desaturate|fadein|fadeout|fade|spin|mix|round|ceil|floor|percentage)\\b',
+            'keyword',
+          ],
+        ],
+        urldeclaration: [
+          { include: '@strings' },
+          ['[^)\r\n]+', 'string'],
+          ['\\)', { token: 'tag', next: '@pop' }],
+        ],
+        attribute: [
+          { include: '@nestedJSBegin' },
+          { include: '@comments' },
+          { include: '@strings' },
+          { include: '@numbers' },
+          { include: '@keyword' },
+          ['[a-zA-Z\\-]+(?=\\()', 'attribute.value', '@attribute'],
+          ['>', 'operator', '@pop'],
+          ['@identifier', 'attribute.value'],
+          { include: '@operators' },
+          ['@(@identifier)', 'variable'],
+          ['[)\\}]', '@brackets', '@pop'],
+          ['[{}()\\[\\]>]', '@brackets'],
+          ['[;]', 'delimiter', '@pop'],
+          ['[,=:]', 'delimiter'],
+          ['\\s', ''],
+          ['.', 'attribute.value'],
+        ],
+        comments: [['\\/\\*', 'comment', '@comment'], ['\\/\\/+.*', 'comment']],
+        comment: [['\\*\\/', 'comment', '@pop'], ['.', 'comment']],
+        numbers: [
+          ['(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?', { token: 'attribute.value.number', next: '@units' }],
+          ['#[0-9a-fA-F_]+(?!\\w)', 'attribute.value.hex'],
+        ],
+        units: [
+          [
+            '(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?',
+            'attribute.value.unit',
+            '@pop',
+          ],
+        ],
+        strings: [
+          ['~?"', { token: 'string.delimiter', next: '@stringsEndDoubleQuote' }],
+          ["~?'", { token: 'string.delimiter', next: '@stringsEndQuote' }],
+        ],
+        stringsEndDoubleQuote: [
+          ['\\\\"', 'string'],
+          ['"', { token: 'string.delimiter', next: '@popall' }],
+          ['.', 'string'],
+        ],
+        stringsEndQuote: [
+          ["\\\\'", 'string'],
+          ["'", { token: 'string.delimiter', next: '@popall' }],
+          ['.', 'string'],
+        ],
+        atRules: [
+          { include: '@comments' },
+          { include: '@strings' },
+          ['[()]', 'delimiter'],
+          ['[\\{;]', 'delimiter', '@pop'],
+          ['.', 'key'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/lua.js

@@ -0,0 +1,128 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/lua', ['require', 'exports'], function(e, n) {
+  'use strict';
+  Object.defineProperty(n, '__esModule', { value: !0 }),
+    (n.conf = {
+      comments: { lineComment: '--', blockComment: ['--[[', ']]'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (n.language = {
+      defaultToken: '',
+      tokenPostfix: '.lua',
+      keywords: [
+        'and',
+        'break',
+        'do',
+        'else',
+        'elseif',
+        'end',
+        'false',
+        'for',
+        'function',
+        'goto',
+        'if',
+        'in',
+        'local',
+        'nil',
+        'not',
+        'or',
+        'repeat',
+        'return',
+        'then',
+        'true',
+        'until',
+        'while',
+      ],
+      brackets: [
+        { token: 'delimiter.bracket', open: '{', close: '}' },
+        { token: 'delimiter.array', open: '[', close: ']' },
+        { token: 'delimiter.parenthesis', open: '(', close: ')' },
+      ],
+      operators: [
+        '+',
+        '-',
+        '*',
+        '/',
+        '%',
+        '^',
+        '#',
+        '==',
+        '~=',
+        '<=',
+        '>=',
+        '<',
+        '>',
+        '=',
+        ';',
+        ':',
+        ',',
+        '.',
+        '..',
+        '...',
+      ],
+      symbols: /[=><!~?:&|+\-*\/\^%]+/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      tokenizer: {
+        root: [
+          [
+            /[a-zA-Z_]\w*/,
+            { cases: { '@keywords': { token: 'keyword.$0' }, '@default': 'identifier' } },
+          ],
+          { include: '@whitespace' },
+          [/(,)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/, ['delimiter', '', 'key', '', 'delimiter']],
+          [/({)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/, ['@brackets', '', 'key', '', 'delimiter']],
+          [/[{}()\[\]]/, '@brackets'],
+          [/@symbols/, { cases: { '@operators': 'delimiter', '@default': '' } }],
+          [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+          [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
+          [/\d+?/, 'number'],
+          [/[;,.]/, 'delimiter'],
+          [/"([^"\\]|\\.)*$/, 'string.invalid'],
+          [/'([^'\\]|\\.)*$/, 'string.invalid'],
+          [/"/, 'string', '@string."'],
+          [/'/, 'string', "@string.'"],
+        ],
+        whitespace: [
+          [/[ \t\r\n]+/, ''],
+          [/--\[([=]*)\[/, 'comment', '@comment.$1'],
+          [/--.*$/, 'comment'],
+        ],
+        comment: [
+          [/[^\]]+/, 'comment'],
+          [
+            /\]([=]*)\]/,
+            { cases: { '$1==$S2': { token: 'comment', next: '@pop' }, '@default': 'comment' } },
+          ],
+          [/./, 'comment'],
+        ],
+        string: [
+          [/[^\\"']+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [
+            /["']/,
+            { cases: { '$#==$S2': { token: 'string', next: '@pop' }, '@default': 'string' } },
+          ],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/markdown.js

@@ -0,0 +1,166 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/markdown', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 });
+  var s = 'attribute.name.html';
+  (t.conf = {
+    comments: { blockComment: ['\x3c!--', '--\x3e'] },
+    brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+    autoClosingPairs: [
+      { open: '{', close: '}' },
+      { open: '[', close: ']' },
+      { open: '(', close: ')' },
+      { open: '<', close: '>', notIn: ['string'] },
+    ],
+    surroundingPairs: [
+      { open: '(', close: ')' },
+      { open: '[', close: ']' },
+      { open: '`', close: '`' },
+    ],
+  }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.md',
+      control: /[\\`*_\[\]{}()#+\-\.!]/,
+      noncontrol: /[^\\`*_\[\]{}()#+\-\.!]/,
+      escapes: /\\(?:@control)/,
+      jsescapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
+      empty: [
+        'area',
+        'base',
+        'basefont',
+        'br',
+        'col',
+        'frame',
+        'hr',
+        'img',
+        'input',
+        'isindex',
+        'link',
+        'meta',
+        'param',
+      ],
+      tokenizer: {
+        root: [
+          [
+            /^(\s{0,3})(#+)((?:[^\\#]|@escapes)+)((?:#+)?)/,
+            ['white', 'keyword', 'keyword', 'keyword'],
+          ],
+          [/^\s*(=+|\-+)\s*$/, 'keyword'],
+          [/^\s*((\*[ ]?)+)\s*$/, 'meta.separator'],
+          [/^\s*>+/, 'comment'],
+          [/^\s*([\*\-+:]|\d+\.)\s/, 'keyword'],
+          [/^(\t|[ ]{4})[^ ].*$/, 'string'],
+          [/^\s*~~~\s*((?:\w|[\/\-#])+)?\s*$/, { token: 'string', next: '@codeblock' }],
+          [
+            /^\s*```\s*((?:\w|[\/\-#])+)\s*$/,
+            { token: 'string', next: '@codeblockgh', nextEmbedded: '$1' },
+          ],
+          [/^\s*```\s*$/, { token: 'string', next: '@codeblock' }],
+          { include: '@linecontent' },
+        ],
+        codeblock: [
+          [/^\s*~~~\s*$/, { token: 'string', next: '@pop' }],
+          [/^\s*```\s*$/, { token: 'string', next: '@pop' }],
+          [/.*$/, 'variable.source'],
+        ],
+        codeblockgh: [
+          [/```\s*$/, { token: 'variable.source', next: '@pop', nextEmbedded: '@pop' }],
+          [/[^`]+/, 'variable.source'],
+        ],
+        linecontent: [
+          [/&\w+;/, 'string.escape'],
+          [/@escapes/, 'escape'],
+          [/\b__([^\\_]|@escapes|_(?!_))+__\b/, 'strong'],
+          [/\*\*([^\\*]|@escapes|\*(?!\*))+\*\*/, 'strong'],
+          [/\b_[^_]+_\b/, 'emphasis'],
+          [/\*([^\\*]|@escapes)+\*/, 'emphasis'],
+          [/`([^\\`]|@escapes)+`/, 'variable'],
+          [/\{[^}]+\}/, 'string.target'],
+          [/(!?\[)((?:[^\]\\]|@escapes)*)(\]\([^\)]+\))/, ['string.link', '', 'string.link']],
+          [/(!?\[)((?:[^\]\\]|@escapes)*)(\])/, 'string.link'],
+          { include: 'html' },
+        ],
+        html: [
+          [/<(\w+)\/>/, 'tag'],
+          [
+            /<(\w+)/,
+            {
+              cases: {
+                '@empty': { token: 'tag', next: '@tag.$1' },
+                '@default': { token: 'tag', next: '@tag.$1' },
+              },
+            },
+          ],
+          [/<\/(\w+)\s*>/, { token: 'tag' }],
+          [/<!--/, 'comment', '@comment'],
+        ],
+        comment: [
+          [/[^<\-]+/, 'comment.content'],
+          [/-->/, 'comment', '@pop'],
+          [/<!--/, 'comment.content.invalid'],
+          [/[<\-]/, 'comment.content'],
+        ],
+        tag: [
+          [/[ \t\r\n]+/, 'white'],
+          [
+            /(type)(\s*=\s*)(")([^"]+)(")/,
+            [
+              s,
+              'delimiter.html',
+              'string.html',
+              { token: 'string.html', switchTo: '@tag.$S2.$4' },
+              'string.html',
+            ],
+          ],
+          [
+            /(type)(\s*=\s*)(')([^']+)(')/,
+            [
+              s,
+              'delimiter.html',
+              'string.html',
+              { token: 'string.html', switchTo: '@tag.$S2.$4' },
+              'string.html',
+            ],
+          ],
+          [/(\w+)(\s*=\s*)("[^"]*"|'[^']*')/, [s, 'delimiter.html', 'string.html']],
+          [/\w+/, s],
+          [/\/>/, 'tag', '@pop'],
+          [
+            />/,
+            {
+              cases: {
+                '$S2==style': { token: 'tag', switchTo: 'embeddedStyle', nextEmbedded: 'text/css' },
+                '$S2==script': {
+                  cases: {
+                    $S3: { token: 'tag', switchTo: 'embeddedScript', nextEmbedded: '$S3' },
+                    '@default': {
+                      token: 'tag',
+                      switchTo: 'embeddedScript',
+                      nextEmbedded: 'text/javascript',
+                    },
+                  },
+                },
+                '@default': { token: 'tag', next: '@pop' },
+              },
+            },
+          ],
+        ],
+        embeddedStyle: [
+          [/[^<]+/, ''],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+          [/</, ''],
+        ],
+        embeddedScript: [
+          [/[^<]+/, ''],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+          [/</, ''],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/msdax.js

@@ -0,0 +1,360 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/msdax', ['require', 'exports'], function(E, T) {
+  'use strict';
+  Object.defineProperty(T, '__esModule', { value: !0 }),
+    (T.conf = {
+      comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+      brackets: [['[', ']'], ['(', ')'], ['{', '}']],
+      autoClosingPairs: [
+        { open: '"', close: '"', notIn: ['string', 'comment'] },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+        { open: '[', close: ']', notIn: ['string', 'comment'] },
+        { open: '(', close: ')', notIn: ['string', 'comment'] },
+        { open: '{', close: '}', notIn: ['string', 'comment'] },
+      ],
+    }),
+    (T.language = {
+      defaultToken: '',
+      tokenPostfix: '.msdax',
+      ignoreCase: !0,
+      brackets: [
+        { open: '[', close: ']', token: 'delimiter.square' },
+        { open: '{', close: '}', token: 'delimiter.brackets' },
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+      ],
+      keywords: [
+        'VAR',
+        'RETURN',
+        'NOT',
+        'EVALUATE',
+        'DATATABLE',
+        'ORDER',
+        'BY',
+        'START',
+        'AT',
+        'DEFINE',
+        'MEASURE',
+        'ASC',
+        'DESC',
+        'IN',
+        'BOOLEAN',
+        'DOUBLE',
+        'INTEGER',
+        'DATETIME',
+        'CURRENCY',
+        'STRING',
+      ],
+      functions: [
+        'CLOSINGBALANCEMONTH',
+        'CLOSINGBALANCEQUARTER',
+        'CLOSINGBALANCEYEAR',
+        'DATEADD',
+        'DATESBETWEEN',
+        'DATESINPERIOD',
+        'DATESMTD',
+        'DATESQTD',
+        'DATESYTD',
+        'ENDOFMONTH',
+        'ENDOFQUARTER',
+        'ENDOFYEAR',
+        'FIRSTDATE',
+        'FIRSTNONBLANK',
+        'LASTDATE',
+        'LASTNONBLANK',
+        'NEXTDAY',
+        'NEXTMONTH',
+        'NEXTQUARTER',
+        'NEXTYEAR',
+        'OPENINGBALANCEMONTH',
+        'OPENINGBALANCEQUARTER',
+        'OPENINGBALANCEYEAR',
+        'PARALLELPERIOD',
+        'PREVIOUSDAY',
+        'PREVIOUSMONTH',
+        'PREVIOUSQUARTER',
+        'PREVIOUSYEAR',
+        'SAMEPERIODLASTYEAR',
+        'STARTOFMONTH',
+        'STARTOFQUARTER',
+        'STARTOFYEAR',
+        'TOTALMTD',
+        'TOTALQTD',
+        'TOTALYTD',
+        'ADDCOLUMNS',
+        'ADDMISSINGITEMS',
+        'ALL',
+        'ALLEXCEPT',
+        'ALLNOBLANKROW',
+        'ALLSELECTED',
+        'CALCULATE',
+        'CALCULATETABLE',
+        'CALENDAR',
+        'CALENDARAUTO',
+        'CROSSFILTER',
+        'CROSSJOIN',
+        'CURRENTGROUP',
+        'DATATABLE',
+        'DETAILROWS',
+        'DISTINCT',
+        'EARLIER',
+        'EARLIEST',
+        'EXCEPT',
+        'FILTER',
+        'FILTERS',
+        'GENERATE',
+        'GENERATEALL',
+        'GROUPBY',
+        'IGNORE',
+        'INTERSECT',
+        'ISONORAFTER',
+        'KEEPFILTERS',
+        'LOOKUPVALUE',
+        'NATURALINNERJOIN',
+        'NATURALLEFTOUTERJOIN',
+        'RELATED',
+        'RELATEDTABLE',
+        'ROLLUP',
+        'ROLLUPADDISSUBTOTAL',
+        'ROLLUPGROUP',
+        'ROLLUPISSUBTOTAL',
+        'ROW',
+        'SAMPLE',
+        'SELECTCOLUMNS',
+        'SUBSTITUTEWITHINDEX',
+        'SUMMARIZE',
+        'SUMMARIZECOLUMNS',
+        'TOPN',
+        'TREATAS',
+        'UNION',
+        'USERELATIONSHIP',
+        'VALUES',
+        'SUM',
+        'SUMX',
+        'PATH',
+        'PATHCONTAINS',
+        'PATHITEM',
+        'PATHITEMREVERSE',
+        'PATHLENGTH',
+        'AVERAGE',
+        'AVERAGEA',
+        'AVERAGEX',
+        'COUNT',
+        'COUNTA',
+        'COUNTAX',
+        'COUNTBLANK',
+        'COUNTROWS',
+        'COUNTX',
+        'DISTINCTCOUNT',
+        'DIVIDE',
+        'GEOMEAN',
+        'GEOMEANX',
+        'MAX',
+        'MAXA',
+        'MAXX',
+        'MEDIAN',
+        'MEDIANX',
+        'MIN',
+        'MINA',
+        'MINX',
+        'PERCENTILE.EXC',
+        'PERCENTILE.INC',
+        'PERCENTILEX.EXC',
+        'PERCENTILEX.INC',
+        'PRODUCT',
+        'PRODUCTX',
+        'RANK.EQ',
+        'RANKX',
+        'STDEV.P',
+        'STDEV.S',
+        'STDEVX.P',
+        'STDEVX.S',
+        'VAR.P',
+        'VAR.S',
+        'VARX.P',
+        'VARX.S',
+        'XIRR',
+        'XNPV',
+        'DATE',
+        'DATEDIFF',
+        'DATEVALUE',
+        'DAY',
+        'EDATE',
+        'EOMONTH',
+        'HOUR',
+        'MINUTE',
+        'MONTH',
+        'NOW',
+        'SECOND',
+        'TIME',
+        'TIMEVALUE',
+        'TODAY',
+        'WEEKDAY',
+        'WEEKNUM',
+        'YEAR',
+        'YEARFRAC',
+        'CONTAINS',
+        'CONTAINSROW',
+        'CUSTOMDATA',
+        'ERROR',
+        'HASONEFILTER',
+        'HASONEVALUE',
+        'ISBLANK',
+        'ISCROSSFILTERED',
+        'ISEMPTY',
+        'ISERROR',
+        'ISEVEN',
+        'ISFILTERED',
+        'ISLOGICAL',
+        'ISNONTEXT',
+        'ISNUMBER',
+        'ISODD',
+        'ISSUBTOTAL',
+        'ISTEXT',
+        'USERNAME',
+        'USERPRINCIPALNAME',
+        'AND',
+        'FALSE',
+        'IF',
+        'IFERROR',
+        'NOT',
+        'OR',
+        'SWITCH',
+        'TRUE',
+        'ABS',
+        'ACOS',
+        'ACOSH',
+        'ACOT',
+        'ACOTH',
+        'ASIN',
+        'ASINH',
+        'ATAN',
+        'ATANH',
+        'BETA.DIST',
+        'BETA.INV',
+        'CEILING',
+        'CHISQ.DIST',
+        'CHISQ.DIST.RT',
+        'CHISQ.INV',
+        'CHISQ.INV.RT',
+        'COMBIN',
+        'COMBINA',
+        'CONFIDENCE.NORM',
+        'CONFIDENCE.T',
+        'COS',
+        'COSH',
+        'COT',
+        'COTH',
+        'CURRENCY',
+        'DEGREES',
+        'EVEN',
+        'EXP',
+        'EXPON.DIST',
+        'FACT',
+        'FLOOR',
+        'GCD',
+        'INT',
+        'ISO.CEILING',
+        'LCM',
+        'LN',
+        'LOG',
+        'LOG10',
+        'MOD',
+        'MROUND',
+        'ODD',
+        'PERMUT',
+        'PI',
+        'POISSON.DIST',
+        'POWER',
+        'QUOTIENT',
+        'RADIANS',
+        'RAND',
+        'RANDBETWEEN',
+        'ROUND',
+        'ROUNDDOWN',
+        'ROUNDUP',
+        'SIGN',
+        'SIN',
+        'SINH',
+        'SQRT',
+        'SQRTPI',
+        'TAN',
+        'TANH',
+        'TRUNC',
+        'BLANK',
+        'CONCATENATE',
+        'CONCATENATEX',
+        'EXACT',
+        'FIND',
+        'FIXED',
+        'FORMAT',
+        'LEFT',
+        'LEN',
+        'LOWER',
+        'MID',
+        'REPLACE',
+        'REPT',
+        'RIGHT',
+        'SEARCH',
+        'SUBSTITUTE',
+        'TRIM',
+        'UNICHAR',
+        'UNICODE',
+        'UPPER',
+        'VALUE',
+      ],
+      tokenizer: {
+        root: [
+          { include: '@comments' },
+          { include: '@whitespace' },
+          { include: '@numbers' },
+          { include: '@strings' },
+          { include: '@complexIdentifiers' },
+          [/[;,.]/, 'delimiter'],
+          [/[({})]/, '@brackets'],
+          [
+            /[a-z_][a-zA-Z0-9_]*/,
+            {
+              cases: { '@keywords': 'keyword', '@functions': 'keyword', '@default': 'identifier' },
+            },
+          ],
+          [/[<>=!%&+\-*/|~^]/, 'operator'],
+        ],
+        whitespace: [[/\s+/, 'white']],
+        comments: [[/\/\/+.*/, 'comment'], [/\/\*/, { token: 'comment.quote', next: '@comment' }]],
+        comment: [
+          [/[^*/]+/, 'comment'],
+          [/\*\//, { token: 'comment.quote', next: '@pop' }],
+          [/./, 'comment'],
+        ],
+        numbers: [
+          [/0[xX][0-9a-fA-F]*/, 'number'],
+          [/[$][+-]*\d*(\.\d*)?/, 'number'],
+          [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number'],
+        ],
+        strings: [
+          [/N"/, { token: 'string', next: '@string' }],
+          [/"/, { token: 'string', next: '@string' }],
+        ],
+        string: [[/[^"]+/, 'string'], [/""/, 'string'], [/"/, { token: 'string', next: '@pop' }]],
+        complexIdentifiers: [
+          [/\[/, { token: 'identifier.quote', next: '@bracketedIdentifier' }],
+          [/'/, { token: 'identifier.quote', next: '@quotedIdentifier' }],
+        ],
+        bracketedIdentifier: [
+          [/[^\]]+/, 'identifier'],
+          [/]]/, 'identifier'],
+          [/]/, { token: 'identifier.quote', next: '@pop' }],
+        ],
+        quotedIdentifier: [
+          [/[^']+/, 'identifier'],
+          [/''/, 'identifier'],
+          [/'/, { token: 'identifier.quote', next: '@pop' }],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/objective-c.js

@@ -0,0 +1,163 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/objective-c', ['require', 'exports'], function(e, n) {
+  'use strict';
+  Object.defineProperty(n, '__esModule', { value: !0 }),
+    (n.conf = {
+      comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (n.language = {
+      defaultToken: '',
+      tokenPostfix: '.objective-c',
+      keywords: [
+        '#import',
+        '#include',
+        '#define',
+        '#else',
+        '#endif',
+        '#if',
+        '#ifdef',
+        '#ifndef',
+        '#ident',
+        '#undef',
+        '@class',
+        '@defs',
+        '@dynamic',
+        '@encode',
+        '@end',
+        '@implementation',
+        '@interface',
+        '@package',
+        '@private',
+        '@protected',
+        '@property',
+        '@protocol',
+        '@public',
+        '@selector',
+        '@synthesize',
+        '__declspec',
+        'assign',
+        'auto',
+        'BOOL',
+        'break',
+        'bycopy',
+        'byref',
+        'case',
+        'char',
+        'Class',
+        'const',
+        'copy',
+        'continue',
+        'default',
+        'do',
+        'double',
+        'else',
+        'enum',
+        'extern',
+        'FALSE',
+        'false',
+        'float',
+        'for',
+        'goto',
+        'if',
+        'in',
+        'int',
+        'id',
+        'inout',
+        'IMP',
+        'long',
+        'nil',
+        'nonatomic',
+        'NULL',
+        'oneway',
+        'out',
+        'private',
+        'public',
+        'protected',
+        'readwrite',
+        'readonly',
+        'register',
+        'return',
+        'SEL',
+        'self',
+        'short',
+        'signed',
+        'sizeof',
+        'static',
+        'struct',
+        'super',
+        'switch',
+        'typedef',
+        'TRUE',
+        'true',
+        'union',
+        'unsigned',
+        'volatile',
+        'void',
+        'while',
+      ],
+      decpart: /\d(_?\d)*/,
+      decimal: /0|@decpart/,
+      tokenizer: {
+        root: [
+          { include: '@comments' },
+          { include: '@whitespace' },
+          { include: '@numbers' },
+          { include: '@strings' },
+          [/[,:;]/, 'delimiter'],
+          [/[{}\[\]()<>]/, '@brackets'],
+          [/[a-zA-Z@#]\w*/, { cases: { '@keywords': 'keyword', '@default': 'identifier' } }],
+          [/[<>=\\+\\-\\*\\/\\^\\|\\~,]|and\\b|or\\b|not\\b]/, 'operator'],
+        ],
+        whitespace: [[/\s+/, 'white']],
+        comments: [['\\/\\*', 'comment', '@comment'], ['\\/\\/+.*', 'comment']],
+        comment: [['\\*\\/', 'comment', '@pop'], ['.', 'comment']],
+        numbers: [
+          [/0[xX][0-9a-fA-F]*(_?[0-9a-fA-F])*/, 'number.hex'],
+          [
+            /@decimal((\.@decpart)?([eE][\-+]?@decpart)?)[fF]*/,
+            { cases: { '(\\d)*': 'number', $0: 'number.float' } },
+          ],
+        ],
+        strings: [
+          [/'$/, 'string.escape', '@popall'],
+          [/'/, 'string.escape', '@stringBody'],
+          [/"$/, 'string.escape', '@popall'],
+          [/"/, 'string.escape', '@dblStringBody'],
+        ],
+        stringBody: [
+          [/\\./, 'string'],
+          [/'/, 'string.escape', '@popall'],
+          [/.(?=.*')/, 'string'],
+          [/.*\\$/, 'string'],
+          [/.*$/, 'string', '@popall'],
+        ],
+        dblStringBody: [
+          [/\\./, 'string'],
+          [/"/, 'string.escape', '@popall'],
+          [/.(?=.*")/, 'string'],
+          [/.*\\$/, 'string'],
+          [/.*$/, 'string', '@popall'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/php.js

@@ -0,0 +1,376 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/php', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+      comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}', notIn: ['string'] },
+        { open: '[', close: ']', notIn: ['string'] },
+        { open: '(', close: ')', notIn: ['string'] },
+        { open: '"', close: '"', notIn: ['string'] },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '',
+      tokenizer: {
+        root: [
+          [/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.root' }],
+          [/<!DOCTYPE/, 'metatag.html', '@doctype'],
+          [/<!--/, 'comment.html', '@comment'],
+          [/(<)(\w+)(\/>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
+          [/(<)(script)/, ['delimiter.html', { token: 'tag.html', next: '@script' }]],
+          [/(<)(style)/, ['delimiter.html', { token: 'tag.html', next: '@style' }]],
+          [/(<)([:\w]+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
+          [/(<\/)(\w+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
+          [/</, 'delimiter.html'],
+          [/[^<]+/],
+        ],
+        doctype: [
+          [/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.comment' }],
+          [/[^>]+/, 'metatag.content.html'],
+          [/>/, 'metatag.html', '@pop'],
+        ],
+        comment: [
+          [/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.comment' }],
+          [/-->/, 'comment.html', '@pop'],
+          [/[^-]+/, 'comment.content.html'],
+          [/./, 'comment.content.html'],
+        ],
+        otherTag: [
+          [/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.otherTag' }],
+          [/\/?>/, 'delimiter.html', '@pop'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+        ],
+        script: [
+          [/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.script' }],
+          [/type/, 'attribute.name', '@scriptAfterType'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [
+            />/,
+            {
+              token: 'delimiter.html',
+              next: '@scriptEmbedded.text/javascript',
+              nextEmbedded: 'text/javascript',
+            },
+          ],
+          [/[ \t\r\n]+/],
+          [
+            /(<\/)(script\s*)(>)/,
+            ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }],
+          ],
+        ],
+        scriptAfterType: [
+          [/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.scriptAfterType' }],
+          [/=/, 'delimiter', '@scriptAfterTypeEquals'],
+          [
+            />/,
+            {
+              token: 'delimiter.html',
+              next: '@scriptEmbedded.text/javascript',
+              nextEmbedded: 'text/javascript',
+            },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptAfterTypeEquals: [
+          [
+            /<\?((php)|=)?/,
+            { token: '@rematch', switchTo: '@phpInSimpleState.scriptAfterTypeEquals' },
+          ],
+          [/"([^"]*)"/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
+          [/'([^']*)'/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
+          [
+            />/,
+            {
+              token: 'delimiter.html',
+              next: '@scriptEmbedded.text/javascript',
+              nextEmbedded: 'text/javascript',
+            },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptWithCustomType: [
+          [
+            /<\?((php)|=)?/,
+            { token: '@rematch', switchTo: '@phpInSimpleState.scriptWithCustomType.$S2' },
+          ],
+          [/>/, { token: 'delimiter.html', next: '@scriptEmbedded.$S2', nextEmbedded: '$S2' }],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptEmbedded: [
+          [
+            /<\?((php)|=)?/,
+            {
+              token: '@rematch',
+              switchTo: '@phpInEmbeddedState.scriptEmbedded.$S2',
+              nextEmbedded: '@pop',
+            },
+          ],
+          [/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+        ],
+        style: [
+          [/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.style' }],
+          [/type/, 'attribute.name', '@styleAfterType'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [
+            />/,
+            { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' },
+          ],
+          [/[ \t\r\n]+/],
+          [
+            /(<\/)(style\s*)(>)/,
+            ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }],
+          ],
+        ],
+        styleAfterType: [
+          [/<\?((php)|=)?/, { token: '@rematch', switchTo: '@phpInSimpleState.styleAfterType' }],
+          [/=/, 'delimiter', '@styleAfterTypeEquals'],
+          [
+            />/,
+            { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleAfterTypeEquals: [
+          [
+            /<\?((php)|=)?/,
+            { token: '@rematch', switchTo: '@phpInSimpleState.styleAfterTypeEquals' },
+          ],
+          [/"([^"]*)"/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
+          [/'([^']*)'/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
+          [
+            />/,
+            { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleWithCustomType: [
+          [
+            /<\?((php)|=)?/,
+            { token: '@rematch', switchTo: '@phpInSimpleState.styleWithCustomType.$S2' },
+          ],
+          [/>/, { token: 'delimiter.html', next: '@styleEmbedded.$S2', nextEmbedded: '$S2' }],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleEmbedded: [
+          [
+            /<\?((php)|=)?/,
+            {
+              token: '@rematch',
+              switchTo: '@phpInEmbeddedState.styleEmbedded.$S2',
+              nextEmbedded: '@pop',
+            },
+          ],
+          [/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+        ],
+        phpInSimpleState: [
+          [/<\?((php)|=)?/, 'metatag.php'],
+          [/\?>/, { token: 'metatag.php', switchTo: '@$S2.$S3' }],
+          { include: 'phpRoot' },
+        ],
+        phpInEmbeddedState: [
+          [/<\?((php)|=)?/, 'metatag.php'],
+          [/\?>/, { token: 'metatag.php', switchTo: '@$S2.$S3', nextEmbedded: '$S3' }],
+          { include: 'phpRoot' },
+        ],
+        phpRoot: [
+          [
+            /[a-zA-Z_]\w*/,
+            {
+              cases: {
+                '@phpKeywords': { token: 'keyword.php' },
+                '@phpCompileTimeConstants': { token: 'constant.php' },
+                '@default': 'identifier.php',
+              },
+            },
+          ],
+          [
+            /[$a-zA-Z_]\w*/,
+            {
+              cases: {
+                '@phpPreDefinedVariables': { token: 'variable.predefined.php' },
+                '@default': 'variable.php',
+              },
+            },
+          ],
+          [/[{}]/, 'delimiter.bracket.php'],
+          [/[\[\]]/, 'delimiter.array.php'],
+          [/[()]/, 'delimiter.parenthesis.php'],
+          [/[ \t\r\n]+/],
+          [/#/, 'comment.php', '@phpLineComment'],
+          [/\/\//, 'comment.php', '@phpLineComment'],
+          [/\/\*/, 'comment.php', '@phpComment'],
+          [/"/, 'string.php', '@phpDoubleQuoteString'],
+          [/'/, 'string.php', '@phpSingleQuoteString'],
+          [/[\+\-\*\%\&\|\^\~\!\=\<\>\/\?\;\:\.\,\@]/, 'delimiter.php'],
+          [/\d*\d+[eE]([\-+]?\d+)?/, 'number.float.php'],
+          [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float.php'],
+          [/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, 'number.hex.php'],
+          [/0[0-7']*[0-7]/, 'number.octal.php'],
+          [/0[bB][0-1']*[0-1]/, 'number.binary.php'],
+          [/\d[\d']*/, 'number.php'],
+          [/\d/, 'number.php'],
+        ],
+        phpComment: [
+          [/\*\//, 'comment.php', '@pop'],
+          [/[^*]+/, 'comment.php'],
+          [/./, 'comment.php'],
+        ],
+        phpLineComment: [
+          [/\?>/, { token: '@rematch', next: '@pop' }],
+          [/.$/, 'comment.php', '@pop'],
+          [/[^?]+$/, 'comment.php', '@pop'],
+          [/[^?]+/, 'comment.php'],
+          [/./, 'comment.php'],
+        ],
+        phpDoubleQuoteString: [
+          [/[^\\"]+/, 'string.php'],
+          [/@escapes/, 'string.escape.php'],
+          [/\\./, 'string.escape.invalid.php'],
+          [/"/, 'string.php', '@pop'],
+        ],
+        phpSingleQuoteString: [
+          [/[^\\']+/, 'string.php'],
+          [/@escapes/, 'string.escape.php'],
+          [/\\./, 'string.escape.invalid.php'],
+          [/'/, 'string.php', '@pop'],
+        ],
+      },
+      phpKeywords: [
+        'abstract',
+        'and',
+        'array',
+        'as',
+        'break',
+        'callable',
+        'case',
+        'catch',
+        'cfunction',
+        'class',
+        'clone',
+        'const',
+        'continue',
+        'declare',
+        'default',
+        'do',
+        'else',
+        'elseif',
+        'enddeclare',
+        'endfor',
+        'endforeach',
+        'endif',
+        'endswitch',
+        'endwhile',
+        'extends',
+        'false',
+        'final',
+        'for',
+        'foreach',
+        'function',
+        'global',
+        'goto',
+        'if',
+        'implements',
+        'interface',
+        'instanceof',
+        'insteadof',
+        'namespace',
+        'new',
+        'null',
+        'object',
+        'old_function',
+        'or',
+        'private',
+        'protected',
+        'public',
+        'resource',
+        'static',
+        'switch',
+        'throw',
+        'trait',
+        'try',
+        'true',
+        'use',
+        'var',
+        'while',
+        'xor',
+        'die',
+        'echo',
+        'empty',
+        'exit',
+        'eval',
+        'include',
+        'include_once',
+        'isset',
+        'list',
+        'require',
+        'require_once',
+        'return',
+        'print',
+        'unset',
+        'yield',
+        '__construct',
+      ],
+      phpCompileTimeConstants: [
+        '__CLASS__',
+        '__DIR__',
+        '__FILE__',
+        '__LINE__',
+        '__NAMESPACE__',
+        '__METHOD__',
+        '__FUNCTION__',
+        '__TRAIT__',
+      ],
+      phpPreDefinedVariables: [
+        '$GLOBALS',
+        '$_SERVER',
+        '$_GET',
+        '$_POST',
+        '$_FILES',
+        '$_REQUEST',
+        '$_SESSION',
+        '$_ENV',
+        '$_COOKIE',
+        '$php_errormsg',
+        '$HTTP_RAW_POST_DATA',
+        '$http_response_header',
+        '$argc',
+        '$argv',
+      ],
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/postiats.js

@@ -0,0 +1,445 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/postiats', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      comments: { lineComment: '//', blockComment: ['(*', '*)'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')'], ['<', '>']],
+      autoClosingPairs: [
+        { open: '"', close: '"', notIn: ['string', 'comment'] },
+        { open: '{', close: '}', notIn: ['string', 'comment'] },
+        { open: '[', close: ']', notIn: ['string', 'comment'] },
+        { open: '(', close: ')', notIn: ['string', 'comment'] },
+      ],
+    }),
+    (t.language = {
+      tokenPostfix: '.pats',
+      defaultToken: 'invalid',
+      keywords: [
+        'abstype',
+        'abst0ype',
+        'absprop',
+        'absview',
+        'absvtype',
+        'absviewtype',
+        'absvt0ype',
+        'absviewt0ype',
+        'as',
+        'and',
+        'assume',
+        'begin',
+        'classdec',
+        'datasort',
+        'datatype',
+        'dataprop',
+        'dataview',
+        'datavtype',
+        'dataviewtype',
+        'do',
+        'end',
+        'extern',
+        'extype',
+        'extvar',
+        'exception',
+        'fn',
+        'fnx',
+        'fun',
+        'prfn',
+        'prfun',
+        'praxi',
+        'castfn',
+        'if',
+        'then',
+        'else',
+        'ifcase',
+        'in',
+        'infix',
+        'infixl',
+        'infixr',
+        'prefix',
+        'postfix',
+        'implmnt',
+        'implement',
+        'primplmnt',
+        'primplement',
+        'import',
+        'let',
+        'local',
+        'macdef',
+        'macrodef',
+        'nonfix',
+        'symelim',
+        'symintr',
+        'overload',
+        'of',
+        'op',
+        'rec',
+        'sif',
+        'scase',
+        'sortdef',
+        'sta',
+        'stacst',
+        'stadef',
+        'static',
+        'staload',
+        'dynload',
+        'try',
+        'tkindef',
+        'typedef',
+        'propdef',
+        'viewdef',
+        'vtypedef',
+        'viewtypedef',
+        'prval',
+        'var',
+        'prvar',
+        'when',
+        'where',
+        'with',
+        'withtype',
+        'withprop',
+        'withview',
+        'withvtype',
+        'withviewtype',
+      ],
+      keywords_dlr: [
+        '$delay',
+        '$ldelay',
+        '$arrpsz',
+        '$arrptrsize',
+        '$d2ctype',
+        '$effmask',
+        '$effmask_ntm',
+        '$effmask_exn',
+        '$effmask_ref',
+        '$effmask_wrt',
+        '$effmask_all',
+        '$extern',
+        '$extkind',
+        '$extype',
+        '$extype_struct',
+        '$extval',
+        '$extfcall',
+        '$extmcall',
+        '$literal',
+        '$myfilename',
+        '$mylocation',
+        '$myfunction',
+        '$lst',
+        '$lst_t',
+        '$lst_vt',
+        '$list',
+        '$list_t',
+        '$list_vt',
+        '$rec',
+        '$rec_t',
+        '$rec_vt',
+        '$record',
+        '$record_t',
+        '$record_vt',
+        '$tup',
+        '$tup_t',
+        '$tup_vt',
+        '$tuple',
+        '$tuple_t',
+        '$tuple_vt',
+        '$break',
+        '$continue',
+        '$raise',
+        '$showtype',
+        '$vcopyenv_v',
+        '$vcopyenv_vt',
+        '$tempenver',
+        '$solver_assert',
+        '$solver_verify',
+      ],
+      keywords_srp: [
+        '#if',
+        '#ifdef',
+        '#ifndef',
+        '#then',
+        '#elif',
+        '#elifdef',
+        '#elifndef',
+        '#else',
+        '#endif',
+        '#error',
+        '#prerr',
+        '#print',
+        '#assert',
+        '#undef',
+        '#define',
+        '#include',
+        '#require',
+        '#pragma',
+        '#codegen2',
+        '#codegen3',
+      ],
+      irregular_keyword_list: [
+        'val+',
+        'val-',
+        'val',
+        'case+',
+        'case-',
+        'case',
+        'addr@',
+        'addr',
+        'fold@',
+        'free@',
+        'fix@',
+        'fix',
+        'lam@',
+        'lam',
+        'llam@',
+        'llam',
+        'viewt@ype+',
+        'viewt@ype-',
+        'viewt@ype',
+        'viewtype+',
+        'viewtype-',
+        'viewtype',
+        'view+',
+        'view-',
+        'view@',
+        'view',
+        'type+',
+        'type-',
+        'type',
+        'vtype+',
+        'vtype-',
+        'vtype',
+        'vt@ype+',
+        'vt@ype-',
+        'vt@ype',
+        'viewt@ype+',
+        'viewt@ype-',
+        'viewt@ype',
+        'viewtype+',
+        'viewtype-',
+        'viewtype',
+        'prop+',
+        'prop-',
+        'prop',
+        'type+',
+        'type-',
+        'type',
+        't@ype',
+        't@ype+',
+        't@ype-',
+        'abst@ype',
+        'abstype',
+        'absviewt@ype',
+        'absvt@ype',
+        'for*',
+        'for',
+        'while*',
+        'while',
+      ],
+      keywords_types: [
+        'bool',
+        'double',
+        'byte',
+        'int',
+        'short',
+        'char',
+        'void',
+        'unit',
+        'long',
+        'float',
+        'string',
+        'strptr',
+      ],
+      keywords_effects: ['0', 'fun', 'clo', 'prf', 'funclo', 'cloptr', 'cloref', 'ref', 'ntm', '1'],
+      operators: [
+        '@',
+        '!',
+        '|',
+        '`',
+        ':',
+        '$',
+        '.',
+        '=',
+        '#',
+        '~',
+        '..',
+        '...',
+        '=>',
+        '=<>',
+        '=/=>',
+        '=>>',
+        '=/=>>',
+        '<',
+        '>',
+        '><',
+        '.<',
+        '>.',
+        '.<>.',
+        '->',
+        '-<>',
+      ],
+      brackets: [
+        { open: ',(', close: ')', token: 'delimiter.parenthesis' },
+        { open: '`(', close: ')', token: 'delimiter.parenthesis' },
+        { open: '%(', close: ')', token: 'delimiter.parenthesis' },
+        { open: "'(", close: ')', token: 'delimiter.parenthesis' },
+        { open: "'{", close: '}', token: 'delimiter.parenthesis' },
+        { open: '@(', close: ')', token: 'delimiter.parenthesis' },
+        { open: '@{', close: '}', token: 'delimiter.brace' },
+        { open: '@[', close: ']', token: 'delimiter.square' },
+        { open: '#[', close: ']', token: 'delimiter.square' },
+        { open: '{', close: '}', token: 'delimiter.curly' },
+        { open: '[', close: ']', token: 'delimiter.square' },
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+        { open: '<', close: '>', token: 'delimiter.angle' },
+      ],
+      symbols: /[=><!~?:&|+\-*\/\^%]+/,
+      IDENTFST: /[a-zA-Z_]/,
+      IDENTRST: /[a-zA-Z0-9_'$]/,
+      symbolic: /[%&+-./:=@~`^|*!$#?<>]/,
+      digit: /[0-9]/,
+      digitseq0: /@digit*/,
+      xdigit: /[0-9A-Za-z]/,
+      xdigitseq0: /@xdigit*/,
+      INTSP: /[lLuU]/,
+      FLOATSP: /[fFlL]/,
+      fexponent: /[eE][+-]?[0-9]+/,
+      fexponent_bin: /[pP][+-]?[0-9]+/,
+      deciexp: /\.[0-9]*@fexponent?/,
+      hexiexp: /\.[0-9a-zA-Z]*@fexponent_bin?/,
+      irregular_keywords: /val[+-]?|case[+-]?|addr\@?|fold\@|free\@|fix\@?|lam\@?|llam\@?|prop[+-]?|type[+-]?|view[+-@]?|viewt@?ype[+-]?|t@?ype[+-]?|v(iew)?t@?ype[+-]?|abst@?ype|absv(iew)?t@?ype|for\*?|while\*?/,
+      ESCHAR: /[ntvbrfa\\\?'"\(\[\{]/,
+      start: 'root',
+      tokenizer: {
+        root: [
+          { regex: /[ \t\r\n]+/, action: { token: '' } },
+          { regex: /\(\*\)/, action: { token: 'invalid' } },
+          { regex: /\(\*/, action: { token: 'comment', next: 'lexing_COMMENT_block_ml' } },
+          { regex: /\(/, action: '@brackets' },
+          { regex: /\)/, action: '@brackets' },
+          { regex: /\[/, action: '@brackets' },
+          { regex: /\]/, action: '@brackets' },
+          { regex: /\{/, action: '@brackets' },
+          { regex: /\}/, action: '@brackets' },
+          { regex: /,\(/, action: '@brackets' },
+          { regex: /,/, action: { token: 'delimiter.comma' } },
+          { regex: /;/, action: { token: 'delimiter.semicolon' } },
+          { regex: /@\(/, action: '@brackets' },
+          { regex: /@\[/, action: '@brackets' },
+          { regex: /@\{/, action: '@brackets' },
+          { regex: /:</, action: { token: 'keyword', next: '@lexing_EFFECT_commaseq0' } },
+          { regex: /\.@symbolic+/, action: { token: 'identifier.sym' } },
+          { regex: /\.@digit*@fexponent@FLOATSP*/, action: { token: 'number.float' } },
+          { regex: /\.@digit+/, action: { token: 'number.float' } },
+          {
+            regex: /\$@IDENTFST@IDENTRST*/,
+            action: {
+              cases: {
+                '@keywords_dlr': { token: 'keyword.dlr' },
+                '@default': { token: 'namespace' },
+              },
+            },
+          },
+          {
+            regex: /\#@IDENTFST@IDENTRST*/,
+            action: {
+              cases: {
+                '@keywords_srp': { token: 'keyword.srp' },
+                '@default': { token: 'identifier' },
+              },
+            },
+          },
+          { regex: /%\(/, action: { token: 'delimiter.parenthesis' } },
+          {
+            regex: /^%{(#|\^|\$)?/,
+            action: { token: 'keyword', next: '@lexing_EXTCODE', nextEmbedded: 'text/javascript' },
+          },
+          { regex: /^%}/, action: { token: 'keyword' } },
+          { regex: /'\(/, action: { token: 'delimiter.parenthesis' } },
+          { regex: /'\[/, action: { token: 'delimiter.bracket' } },
+          { regex: /'\{/, action: { token: 'delimiter.brace' } },
+          [/(')(\\@ESCHAR|\\[xX]@xdigit+|\\@digit+)(')/, ['string', 'string.escape', 'string']],
+          [/'[^\\']'/, 'string'],
+          [/"/, 'string.quote', '@lexing_DQUOTE'],
+          { regex: /`\(/, action: '@brackets' },
+          { regex: /\\/, action: { token: 'punctuation' } },
+          { regex: /@irregular_keywords(?!@IDENTRST)/, action: { token: 'keyword' } },
+          {
+            regex: /@IDENTFST@IDENTRST*[<!\[]?/,
+            action: {
+              cases: {
+                '@keywords': { token: 'keyword' },
+                '@keywords_types': { token: 'type' },
+                '@default': { token: 'identifier' },
+              },
+            },
+          },
+          { regex: /\/\/\/\//, action: { token: 'comment', next: '@lexing_COMMENT_rest' } },
+          { regex: /\/\/.*$/, action: { token: 'comment' } },
+          { regex: /\/\*/, action: { token: 'comment', next: '@lexing_COMMENT_block_c' } },
+          { regex: /-<|=</, action: { token: 'keyword', next: '@lexing_EFFECT_commaseq0' } },
+          {
+            regex: /@symbolic+/,
+            action: { cases: { '@operators': 'keyword', '@default': 'operator' } },
+          },
+          {
+            regex: /0[xX]@xdigit+(@hexiexp|@fexponent_bin)@FLOATSP*/,
+            action: { token: 'number.float' },
+          },
+          { regex: /0[xX]@xdigit+@INTSP*/, action: { token: 'number.hex' } },
+          { regex: /0[0-7]+(?![0-9])@INTSP*/, action: { token: 'number.octal' } },
+          { regex: /@digit+(@fexponent|@deciexp)@FLOATSP*/, action: { token: 'number.float' } },
+          { regex: /@digit@digitseq0@INTSP*/, action: { token: 'number.decimal' } },
+          { regex: /@digit+@INTSP*/, action: { token: 'number' } },
+        ],
+        lexing_COMMENT_block_ml: [
+          [/[^\(\*]+/, 'comment'],
+          [/\(\*/, 'comment', '@push'],
+          [/\(\*/, 'comment.invalid'],
+          [/\*\)/, 'comment', '@pop'],
+          [/\*/, 'comment'],
+        ],
+        lexing_COMMENT_block_c: [
+          [/[^\/*]+/, 'comment'],
+          [/\*\//, 'comment', '@pop'],
+          [/[\/*]/, 'comment'],
+        ],
+        lexing_COMMENT_rest: [[/$/, 'comment', '@pop'], [/.*/, 'comment']],
+        lexing_EFFECT_commaseq0: [
+          {
+            regex: /@IDENTFST@IDENTRST+|@digit+/,
+            action: {
+              cases: {
+                '@keywords_effects': { token: 'type.effect' },
+                '@default': { token: 'identifier' },
+              },
+            },
+          },
+          { regex: /,/, action: { token: 'punctuation' } },
+          { regex: />/, action: { token: '@rematch', next: '@pop' } },
+        ],
+        lexing_EXTCODE: [
+          { regex: /^%}/, action: { token: '@rematch', next: '@pop', nextEmbedded: '@pop' } },
+          { regex: /[^%]+/, action: '' },
+        ],
+        lexing_DQUOTE: [
+          { regex: /"/, action: { token: 'string.quote', next: '@pop' } },
+          {
+            regex: /(\{\$)(@IDENTFST@IDENTRST*)(\})/,
+            action: [
+              { token: 'string.escape' },
+              { token: 'identifier' },
+              { token: 'string.escape' },
+            ],
+          },
+          { regex: /\\$/, action: { token: 'string.escape' } },
+          { regex: /\\(@ESCHAR|[xX]@xdigit+|@digit+)/, action: { token: 'string.escape' } },
+          { regex: /[^\\"]+/, action: { token: 'string' } },
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/powershell.js

@@ -0,0 +1,171 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/powershell', ['require', 'exports'], function(e, s) {
+  'use strict';
+  Object.defineProperty(s, '__esModule', { value: !0 }),
+    (s.conf = {
+      wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+      comments: { lineComment: '#', blockComment: ['<#', '#>'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"', notIn: ['string'] },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (s.language = {
+      defaultToken: '',
+      ignoreCase: !0,
+      tokenPostfix: '.ps1',
+      brackets: [
+        { token: 'delimiter.curly', open: '{', close: '}' },
+        { token: 'delimiter.square', open: '[', close: ']' },
+        { token: 'delimiter.parenthesis', open: '(', close: ')' },
+      ],
+      keywords: [
+        'begin',
+        'break',
+        'catch',
+        'class',
+        'continue',
+        'data',
+        'define',
+        'do',
+        'dynamicparam',
+        'else',
+        'elseif',
+        'end',
+        'exit',
+        'filter',
+        'finally',
+        'for',
+        'foreach',
+        'from',
+        'function',
+        'if',
+        'in',
+        'param',
+        'process',
+        'return',
+        'switch',
+        'throw',
+        'trap',
+        'try',
+        'until',
+        'using',
+        'var',
+        'while',
+        'workflow',
+        'parallel',
+        'sequence',
+        'inlinescript',
+        'configuration',
+      ],
+      helpKeywords: /SYNOPSIS|DESCRIPTION|PARAMETER|EXAMPLE|INPUTS|OUTPUTS|NOTES|LINK|COMPONENT|ROLE|FUNCTIONALITY|FORWARDHELPTARGETNAME|FORWARDHELPCATEGORY|REMOTEHELPRUNSPACE|EXTERNALHELP/,
+      symbols: /[=><!~?&%|+\-*\/\^;\.,]+/,
+      escapes: /`(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      tokenizer: {
+        root: [
+          [/[a-zA-Z_][\w-]*/, { cases: { '@keywords': { token: 'keyword.$0' }, '@default': '' } }],
+          [/[ \t\r\n]+/, ''],
+          [/^:\w*/, 'metatag'],
+          [
+            /\$(\{((global|local|private|script|using):)?[\w]+\}|((global|local|private|script|using):)?[\w]+)/,
+            'variable',
+          ],
+          [/<#/, 'comment', '@comment'],
+          [/#.*$/, 'comment'],
+          [/[{}()\[\]]/, '@brackets'],
+          [/@symbols/, 'delimiter'],
+          [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+          [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
+          [/\d+?/, 'number'],
+          [/[;,.]/, 'delimiter'],
+          [/\@"/, 'string', '@herestring."'],
+          [/\@'/, 'string', "@herestring.'"],
+          [
+            /"/,
+            { cases: { '@eos': 'string', '@default': { token: 'string', next: '@string."' } } },
+          ],
+          [
+            /'/,
+            { cases: { '@eos': 'string', '@default': { token: 'string', next: "@string.'" } } },
+          ],
+        ],
+        string: [
+          [
+            /[^"'\$`]+/,
+            { cases: { '@eos': { token: 'string', next: '@popall' }, '@default': 'string' } },
+          ],
+          [
+            /@escapes/,
+            {
+              cases: {
+                '@eos': { token: 'string.escape', next: '@popall' },
+                '@default': 'string.escape',
+              },
+            },
+          ],
+          [
+            /`./,
+            {
+              cases: {
+                '@eos': { token: 'string.escape.invalid', next: '@popall' },
+                '@default': 'string.escape.invalid',
+              },
+            },
+          ],
+          [
+            /\$[\w]+$/,
+            {
+              cases: {
+                '$S2=="': { token: 'variable', next: '@popall' },
+                '@default': { token: 'string', next: '@popall' },
+              },
+            },
+          ],
+          [/\$[\w]+/, { cases: { '$S2=="': 'variable', '@default': 'string' } }],
+          [
+            /["']/,
+            {
+              cases: {
+                '$#==$S2': { token: 'string', next: '@pop' },
+                '@default': {
+                  cases: { '@eos': { token: 'string', next: '@popall' }, '@default': 'string' },
+                },
+              },
+            },
+          ],
+        ],
+        herestring: [
+          [
+            /^\s*(["'])@/,
+            { cases: { '$1==$S2': { token: 'string', next: '@pop' }, '@default': 'string' } },
+          ],
+          [/[^\$`]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/`./, 'string.escape.invalid'],
+          [/\$[\w]+/, { cases: { '$S2=="': 'variable', '@default': 'string' } }],
+        ],
+        comment: [
+          [/[^#\.]+/, 'comment'],
+          [/#>/, 'comment', '@pop'],
+          [/(\.)(@helpKeywords)(?!\w)/, { token: 'comment.keyword.$2' }],
+          [/[\.#]/, 'comment'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/pug.js

@@ -0,0 +1,356 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/pug', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      comments: { lineComment: '//' },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '"', close: '"', notIn: ['string', 'comment'] },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+        { open: '{', close: '}', notIn: ['string', 'comment'] },
+        { open: '[', close: ']', notIn: ['string', 'comment'] },
+        { open: '(', close: ')', notIn: ['string', 'comment'] },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.pug',
+      ignoreCase: !0,
+      brackets: [
+        { token: 'delimiter.curly', open: '{', close: '}' },
+        { token: 'delimiter.array', open: '[', close: ']' },
+        { token: 'delimiter.parenthesis', open: '(', close: ')' },
+      ],
+      keywords: [
+        'append',
+        'block',
+        'case',
+        'default',
+        'doctype',
+        'each',
+        'else',
+        'extends',
+        'for',
+        'if',
+        'in',
+        'include',
+        'mixin',
+        'typeof',
+        'unless',
+        'var',
+        'when',
+      ],
+      tags: [
+        'a',
+        'abbr',
+        'acronym',
+        'address',
+        'area',
+        'article',
+        'aside',
+        'audio',
+        'b',
+        'base',
+        'basefont',
+        'bdi',
+        'bdo',
+        'blockquote',
+        'body',
+        'br',
+        'button',
+        'canvas',
+        'caption',
+        'center',
+        'cite',
+        'code',
+        'col',
+        'colgroup',
+        'command',
+        'datalist',
+        'dd',
+        'del',
+        'details',
+        'dfn',
+        'div',
+        'dl',
+        'dt',
+        'em',
+        'embed',
+        'fieldset',
+        'figcaption',
+        'figure',
+        'font',
+        'footer',
+        'form',
+        'frame',
+        'frameset',
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6',
+        'head',
+        'header',
+        'hgroup',
+        'hr',
+        'html',
+        'i',
+        'iframe',
+        'img',
+        'input',
+        'ins',
+        'keygen',
+        'kbd',
+        'label',
+        'li',
+        'link',
+        'map',
+        'mark',
+        'menu',
+        'meta',
+        'meter',
+        'nav',
+        'noframes',
+        'noscript',
+        'object',
+        'ol',
+        'optgroup',
+        'option',
+        'output',
+        'p',
+        'param',
+        'pre',
+        'progress',
+        'q',
+        'rp',
+        'rt',
+        'ruby',
+        's',
+        'samp',
+        'script',
+        'section',
+        'select',
+        'small',
+        'source',
+        'span',
+        'strike',
+        'strong',
+        'style',
+        'sub',
+        'summary',
+        'sup',
+        'table',
+        'tbody',
+        'td',
+        'textarea',
+        'tfoot',
+        'th',
+        'thead',
+        'time',
+        'title',
+        'tr',
+        'tracks',
+        'tt',
+        'u',
+        'ul',
+        'video',
+        'wbr',
+      ],
+      symbols: /[\+\-\*\%\&\|\!\=\/\.\,\:]+/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      tokenizer: {
+        root: [
+          [
+            /^(\s*)([a-zA-Z_-][\w-]*)/,
+            {
+              cases: {
+                '$2@tags': {
+                  cases: {
+                    '@eos': ['', 'tag'],
+                    '@default': ['', { token: 'tag', next: '@tag.$1' }],
+                  },
+                },
+                '$2@keywords': ['', { token: 'keyword.$2' }],
+                '@default': ['', ''],
+              },
+            },
+          ],
+          [
+            /^(\s*)(#[a-zA-Z_-][\w-]*)/,
+            {
+              cases: {
+                '@eos': ['', 'tag.id'],
+                '@default': ['', { token: 'tag.id', next: '@tag.$1' }],
+              },
+            },
+          ],
+          [
+            /^(\s*)(\.[a-zA-Z_-][\w-]*)/,
+            {
+              cases: {
+                '@eos': ['', 'tag.class'],
+                '@default': ['', { token: 'tag.class', next: '@tag.$1' }],
+              },
+            },
+          ],
+          [/^(\s*)(\|.*)$/, ''],
+          { include: '@whitespace' },
+          [/[a-zA-Z_$][\w$]*/, { cases: { '@keywords': { token: 'keyword.$0' }, '@default': '' } }],
+          [/[{}()\[\]]/, '@brackets'],
+          [/@symbols/, 'delimiter'],
+          [/\d+\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+          [/\d+/, 'number'],
+          [/"/, 'string', '@string."'],
+          [/'/, 'string', "@string.'"],
+        ],
+        tag: [
+          [/(\.)(\s*$)/, [{ token: 'delimiter', next: '@blockText.$S2.' }, '']],
+          [/\s+/, { token: '', next: '@simpleText' }],
+          [
+            /#[a-zA-Z_-][\w-]*/,
+            { cases: { '@eos': { token: 'tag.id', next: '@pop' }, '@default': 'tag.id' } },
+          ],
+          [
+            /\.[a-zA-Z_-][\w-]*/,
+            { cases: { '@eos': { token: 'tag.class', next: '@pop' }, '@default': 'tag.class' } },
+          ],
+          [/\(/, { token: 'delimiter.parenthesis', next: '@attributeList' }],
+        ],
+        simpleText: [
+          [/[^#]+$/, { token: '', next: '@popall' }],
+          [/[^#]+/, { token: '' }],
+          [
+            /(#{)([^}]*)(})/,
+            {
+              cases: {
+                '@eos': [
+                  'interpolation.delimiter',
+                  'interpolation',
+                  { token: 'interpolation.delimiter', next: '@popall' },
+                ],
+                '@default': ['interpolation.delimiter', 'interpolation', 'interpolation.delimiter'],
+              },
+            },
+          ],
+          [/#$/, { token: '', next: '@popall' }],
+          [/#/, ''],
+        ],
+        attributeList: [
+          [/\s+/, ''],
+          [
+            /(\w+)(\s*=\s*)("|')/,
+            ['attribute.name', 'delimiter', { token: 'attribute.value', next: '@value.$3' }],
+          ],
+          [/\w+/, 'attribute.name'],
+          [
+            /,/,
+            {
+              cases: {
+                '@eos': { token: 'attribute.delimiter', next: '@popall' },
+                '@default': 'attribute.delimiter',
+              },
+            },
+          ],
+          [/\)$/, { token: 'delimiter.parenthesis', next: '@popall' }],
+          [/\)/, { token: 'delimiter.parenthesis', next: '@pop' }],
+        ],
+        whitespace: [
+          [/^(\s*)(\/\/.*)$/, { token: 'comment', next: '@blockText.$1.comment' }],
+          [/[ \t\r\n]+/, ''],
+          [/<!--/, { token: 'comment', next: '@comment' }],
+        ],
+        blockText: [
+          [
+            /^\s+.*$/,
+            {
+              cases: {
+                '($S2\\s+.*$)': { token: '$S3' },
+                '@default': { token: '@rematch', next: '@popall' },
+              },
+            },
+          ],
+          [/./, { token: '@rematch', next: '@popall' }],
+        ],
+        comment: [
+          [/[^<\-]+/, 'comment.content'],
+          [/-->/, { token: 'comment', next: '@pop' }],
+          [/<!--/, 'comment.content.invalid'],
+          [/[<\-]/, 'comment.content'],
+        ],
+        string: [
+          [
+            /[^\\"'#]+/,
+            { cases: { '@eos': { token: 'string', next: '@popall' }, '@default': 'string' } },
+          ],
+          [
+            /@escapes/,
+            {
+              cases: {
+                '@eos': { token: 'string.escape', next: '@popall' },
+                '@default': 'string.escape',
+              },
+            },
+          ],
+          [
+            /\\./,
+            {
+              cases: {
+                '@eos': { token: 'string.escape.invalid', next: '@popall' },
+                '@default': 'string.escape.invalid',
+              },
+            },
+          ],
+          [
+            /(#{)([^}]*)(})/,
+            ['interpolation.delimiter', 'interpolation', 'interpolation.delimiter'],
+          ],
+          [/#/, 'string'],
+          [
+            /["']/,
+            {
+              cases: {
+                '$#==$S2': { token: 'string', next: '@pop' },
+                '@default': { token: 'string' },
+              },
+            },
+          ],
+        ],
+        value: [
+          [
+            /[^\\"']+/,
+            {
+              cases: {
+                '@eos': { token: 'attribute.value', next: '@popall' },
+                '@default': 'attribute.value',
+              },
+            },
+          ],
+          [
+            /\\./,
+            {
+              cases: {
+                '@eos': { token: 'attribute.value', next: '@popall' },
+                '@default': 'attribute.value',
+              },
+            },
+          ],
+          [
+            /["']/,
+            {
+              cases: {
+                '$#==$S2': { token: 'attribute.value', next: '@pop' },
+                '@default': { token: 'attribute.value' },
+              },
+            },
+          ],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/python.js

@@ -0,0 +1,209 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/python', ['require', 'exports'], function(e, s) {
+  'use strict';
+  Object.defineProperty(s, '__esModule', { value: !0 }),
+    (s.conf = {
+      comments: { lineComment: '#', blockComment: ["'''", "'''"] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"', notIn: ['string'] },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (s.language = {
+      defaultToken: '',
+      tokenPostfix: '.python',
+      keywords: [
+        'and',
+        'as',
+        'assert',
+        'break',
+        'class',
+        'continue',
+        'def',
+        'del',
+        'elif',
+        'else',
+        'except',
+        'exec',
+        'finally',
+        'for',
+        'from',
+        'global',
+        'if',
+        'import',
+        'in',
+        'is',
+        'lambda',
+        'None',
+        'not',
+        'or',
+        'pass',
+        'print',
+        'raise',
+        'return',
+        'self',
+        'try',
+        'while',
+        'with',
+        'yield',
+        'int',
+        'float',
+        'long',
+        'complex',
+        'hex',
+        'abs',
+        'all',
+        'any',
+        'apply',
+        'basestring',
+        'bin',
+        'bool',
+        'buffer',
+        'bytearray',
+        'callable',
+        'chr',
+        'classmethod',
+        'cmp',
+        'coerce',
+        'compile',
+        'complex',
+        'delattr',
+        'dict',
+        'dir',
+        'divmod',
+        'enumerate',
+        'eval',
+        'execfile',
+        'file',
+        'filter',
+        'format',
+        'frozenset',
+        'getattr',
+        'globals',
+        'hasattr',
+        'hash',
+        'help',
+        'id',
+        'input',
+        'intern',
+        'isinstance',
+        'issubclass',
+        'iter',
+        'len',
+        'locals',
+        'list',
+        'map',
+        'max',
+        'memoryview',
+        'min',
+        'next',
+        'object',
+        'oct',
+        'open',
+        'ord',
+        'pow',
+        'print',
+        'property',
+        'reversed',
+        'range',
+        'raw_input',
+        'reduce',
+        'reload',
+        'repr',
+        'reversed',
+        'round',
+        'set',
+        'setattr',
+        'slice',
+        'sorted',
+        'staticmethod',
+        'str',
+        'sum',
+        'super',
+        'tuple',
+        'type',
+        'unichr',
+        'unicode',
+        'vars',
+        'xrange',
+        'zip',
+        'True',
+        'False',
+        '__dict__',
+        '__methods__',
+        '__members__',
+        '__class__',
+        '__bases__',
+        '__name__',
+        '__mro__',
+        '__subclasses__',
+        '__init__',
+        '__import__',
+      ],
+      brackets: [
+        { open: '{', close: '}', token: 'delimiter.curly' },
+        { open: '[', close: ']', token: 'delimiter.bracket' },
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+      ],
+      tokenizer: {
+        root: [
+          { include: '@whitespace' },
+          { include: '@numbers' },
+          { include: '@strings' },
+          [/[,:;]/, 'delimiter'],
+          [/[{}\[\]()]/, '@brackets'],
+          [/@[a-zA-Z]\w*/, 'tag'],
+          [/[a-zA-Z]\w*/, { cases: { '@keywords': 'keyword', '@default': 'identifier' } }],
+        ],
+        whitespace: [
+          [/\s+/, 'white'],
+          [/(^#.*$)/, 'comment'],
+          [/('''.*''')|(""".*""")/, 'string'],
+          [/'''.*$/, 'string', '@endDocString'],
+          [/""".*$/, 'string', '@endDblDocString'],
+        ],
+        endDocString: [[/\\'/, 'string'], [/.*'''/, 'string', '@popall'], [/.*$/, 'string']],
+        endDblDocString: [[/\\"/, 'string'], [/.*"""/, 'string', '@popall'], [/.*$/, 'string']],
+        numbers: [
+          [/-?0x([abcdef]|[ABCDEF]|\d)+[lL]?/, 'number.hex'],
+          [/-?(\d*\.)?\d+([eE][+\-]?\d+)?[jJ]?[lL]?/, 'number'],
+        ],
+        strings: [
+          [/'$/, 'string.escape', '@popall'],
+          [/'/, 'string.escape', '@stringBody'],
+          [/"$/, 'string.escape', '@popall'],
+          [/"/, 'string.escape', '@dblStringBody'],
+        ],
+        stringBody: [
+          [/\\./, 'string'],
+          [/'/, 'string.escape', '@popall'],
+          [/.(?=.*')/, 'string'],
+          [/.*\\$/, 'string'],
+          [/.*$/, 'string', '@popall'],
+        ],
+        dblStringBody: [
+          [/\\./, 'string'],
+          [/"/, 'string.escape', '@popall'],
+          [/.(?=.*")/, 'string'],
+          [/.*\\$/, 'string'],
+          [/.*$/, 'string', '@popall'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/r.js

@@ -0,0 +1,188 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/r', ['require', 'exports'], function(e, o) {
+  'use strict';
+  Object.defineProperty(o, '__esModule', { value: !0 }),
+    (o.conf = {
+      comments: { lineComment: '#' },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+      ],
+    }),
+    (o.language = {
+      defaultToken: '',
+      tokenPostfix: '.r',
+      roxygen: [
+        '@param',
+        '@return',
+        '@name',
+        '@rdname',
+        '@examples',
+        '@include',
+        '@docType',
+        '@S3method',
+        '@TODO',
+        '@aliases',
+        '@alias',
+        '@assignee',
+        '@author',
+        '@callGraphDepth',
+        '@callGraph',
+        '@callGraphPrimitives',
+        '@concept',
+        '@exportClass',
+        '@exportMethod',
+        '@exportPattern',
+        '@export',
+        '@formals',
+        '@format',
+        '@importClassesFrom',
+        '@importFrom',
+        '@importMethodsFrom',
+        '@import',
+        '@keywords',
+        '@method',
+        '@nord',
+        '@note',
+        '@references',
+        '@seealso',
+        '@setClass',
+        '@slot',
+        '@source',
+        '@title',
+        '@usage',
+      ],
+      constants: [
+        'NULL',
+        'FALSE',
+        'TRUE',
+        'NA',
+        'Inf',
+        'NaN ',
+        'NA_integer_',
+        'NA_real_',
+        'NA_complex_',
+        'NA_character_ ',
+        'T',
+        'F',
+        'LETTERS',
+        'letters',
+        'month.abb',
+        'month.name',
+        'pi',
+        'R.version.string',
+      ],
+      keywords: [
+        'break',
+        'next',
+        'return',
+        'if',
+        'else',
+        'for',
+        'in',
+        'repeat',
+        'while',
+        'array',
+        'category',
+        'character',
+        'complex',
+        'double',
+        'function',
+        'integer',
+        'list',
+        'logical',
+        'matrix',
+        'numeric',
+        'vector',
+        'data.frame',
+        'factor',
+        'library',
+        'require',
+        'attach',
+        'detach',
+        'source',
+      ],
+      special: ['\\n', '\\r', '\\t', '\\b', '\\a', '\\f', '\\v', "\\'", '\\"', '\\\\'],
+      brackets: [
+        { open: '{', close: '}', token: 'delimiter.curly' },
+        { open: '[', close: ']', token: 'delimiter.bracket' },
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+      ],
+      tokenizer: {
+        root: [
+          { include: '@numbers' },
+          { include: '@strings' },
+          [/[{}\[\]()]/, '@brackets'],
+          { include: '@operators' },
+          [/#'/, 'comment.doc', '@roxygen'],
+          [/(^#.*$)/, 'comment'],
+          [/\s+/, 'white'],
+          [/[,:;]/, 'delimiter'],
+          [/@[a-zA-Z]\w*/, 'tag'],
+          [
+            /[a-zA-Z]\w*/,
+            {
+              cases: { '@keywords': 'keyword', '@constants': 'constant', '@default': 'identifier' },
+            },
+          ],
+        ],
+        roxygen: [
+          [
+            /@\w+/,
+            {
+              cases: {
+                '@roxygen': 'tag',
+                '@eos': { token: 'comment.doc', next: '@pop' },
+                '@default': 'comment.doc',
+              },
+            },
+          ],
+          [
+            /\s+/,
+            {
+              cases: { '@eos': { token: 'comment.doc', next: '@pop' }, '@default': 'comment.doc' },
+            },
+          ],
+          [/.*/, { token: 'comment.doc', next: '@pop' }],
+        ],
+        numbers: [[/0[xX][0-9a-fA-F]+/, 'number.hex'], [/-?(\d*\.)?\d+([eE][+\-]?\d+)?/, 'number']],
+        operators: [
+          [/<{1,2}-/, 'operator'],
+          [/->{1,2}/, 'operator'],
+          [/%[^%\s]+%/, 'operator'],
+          [/\*\*/, 'operator'],
+          [/%%/, 'operator'],
+          [/&&/, 'operator'],
+          [/\|\|/, 'operator'],
+          [/<</, 'operator'],
+          [/>>/, 'operator'],
+          [/[-+=&|!<>^~*/:$]/, 'operator'],
+        ],
+        strings: [[/'/, 'string.escape', '@stringBody'], [/"/, 'string.escape', '@dblStringBody']],
+        stringBody: [
+          [/\\./, { cases: { '@special': 'string', '@default': 'error-token' } }],
+          [/'/, 'string.escape', '@popall'],
+          [/./, 'string'],
+        ],
+        dblStringBody: [
+          [/\\./, { cases: { '@special': 'string', '@default': 'error-token' } }],
+          [/"/, 'string.escape', '@popall'],
+          [/./, 'string'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/razor.js

@@ -0,0 +1,395 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/razor', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 });
+  var r = 'undefined' == typeof monaco ? self.monaco : monaco,
+    o = [
+      'area',
+      'base',
+      'br',
+      'col',
+      'embed',
+      'hr',
+      'img',
+      'input',
+      'keygen',
+      'link',
+      'menuitem',
+      'meta',
+      'param',
+      'source',
+      'track',
+      'wbr',
+    ];
+  (t.conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+    comments: { blockComment: ['\x3c!--', '--\x3e'] },
+    brackets: [['\x3c!--', '--\x3e'], ['<', '>'], ['{', '}'], ['(', ')']],
+    autoClosingPairs: [
+      { open: '{', close: '}' },
+      { open: '[', close: ']' },
+      { open: '(', close: ')' },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+    ],
+    surroundingPairs: [
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: '<', close: '>' },
+    ],
+    onEnterRules: [
+      {
+        beforeText: new RegExp(
+          '<(?!(?:' + o.join('|') + '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$',
+          'i'
+        ),
+        afterText: /^<\/(\w[\w\d]*)\s*>$/i,
+        action: { indentAction: r.languages.IndentAction.IndentOutdent },
+      },
+      {
+        beforeText: new RegExp(
+          '<(?!(?:' + o.join('|') + '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$',
+          'i'
+        ),
+        action: { indentAction: r.languages.IndentAction.Indent },
+      },
+    ],
+  }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '',
+      tokenizer: {
+        root: [
+          [/@@/],
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.root' }],
+          [/<!DOCTYPE/, 'metatag.html', '@doctype'],
+          [/<!--/, 'comment.html', '@comment'],
+          [/(<)(\w+)(\/>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
+          [/(<)(script)/, ['delimiter.html', { token: 'tag.html', next: '@script' }]],
+          [/(<)(style)/, ['delimiter.html', { token: 'tag.html', next: '@style' }]],
+          [/(<)([:\w]+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
+          [/(<\/)(\w+)/, ['delimiter.html', { token: 'tag.html', next: '@otherTag' }]],
+          [/</, 'delimiter.html'],
+          [/[ \t\r\n]+/],
+          [/[^<@]+/],
+        ],
+        doctype: [
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.comment' }],
+          [/[^>]+/, 'metatag.content.html'],
+          [/>/, 'metatag.html', '@pop'],
+        ],
+        comment: [
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.comment' }],
+          [/-->/, 'comment.html', '@pop'],
+          [/[^-]+/, 'comment.content.html'],
+          [/./, 'comment.content.html'],
+        ],
+        otherTag: [
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.otherTag' }],
+          [/\/?>/, 'delimiter.html', '@pop'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+        ],
+        script: [
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.script' }],
+          [/type/, 'attribute.name', '@scriptAfterType'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [
+            />/,
+            {
+              token: 'delimiter.html',
+              next: '@scriptEmbedded.text/javascript',
+              nextEmbedded: 'text/javascript',
+            },
+          ],
+          [/[ \t\r\n]+/],
+          [
+            /(<\/)(script\s*)(>)/,
+            ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }],
+          ],
+        ],
+        scriptAfterType: [
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.scriptAfterType' }],
+          [/=/, 'delimiter', '@scriptAfterTypeEquals'],
+          [
+            />/,
+            {
+              token: 'delimiter.html',
+              next: '@scriptEmbedded.text/javascript',
+              nextEmbedded: 'text/javascript',
+            },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptAfterTypeEquals: [
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.scriptAfterTypeEquals' }],
+          [/"([^"]*)"/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
+          [/'([^']*)'/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
+          [
+            />/,
+            {
+              token: 'delimiter.html',
+              next: '@scriptEmbedded.text/javascript',
+              nextEmbedded: 'text/javascript',
+            },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptWithCustomType: [
+          [
+            /@[^@]/,
+            { token: '@rematch', switchTo: '@razorInSimpleState.scriptWithCustomType.$S2' },
+          ],
+          [/>/, { token: 'delimiter.html', next: '@scriptEmbedded.$S2', nextEmbedded: '$S2' }],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+          [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        scriptEmbedded: [
+          [
+            /@[^@]/,
+            {
+              token: '@rematch',
+              switchTo: '@razorInEmbeddedState.scriptEmbedded.$S2',
+              nextEmbedded: '@pop',
+            },
+          ],
+          [/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+        ],
+        style: [
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.style' }],
+          [/type/, 'attribute.name', '@styleAfterType'],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [
+            />/,
+            { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' },
+          ],
+          [/[ \t\r\n]+/],
+          [
+            /(<\/)(style\s*)(>)/,
+            ['delimiter.html', 'tag.html', { token: 'delimiter.html', next: '@pop' }],
+          ],
+        ],
+        styleAfterType: [
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.styleAfterType' }],
+          [/=/, 'delimiter', '@styleAfterTypeEquals'],
+          [
+            />/,
+            { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleAfterTypeEquals: [
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.styleAfterTypeEquals' }],
+          [/"([^"]*)"/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
+          [/'([^']*)'/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
+          [
+            />/,
+            { token: 'delimiter.html', next: '@styleEmbedded.text/css', nextEmbedded: 'text/css' },
+          ],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleWithCustomType: [
+          [/@[^@]/, { token: '@rematch', switchTo: '@razorInSimpleState.styleWithCustomType.$S2' }],
+          [/>/, { token: 'delimiter.html', next: '@styleEmbedded.$S2', nextEmbedded: '$S2' }],
+          [/"([^"]*)"/, 'attribute.value'],
+          [/'([^']*)'/, 'attribute.value'],
+          [/[\w\-]+/, 'attribute.name'],
+          [/=/, 'delimiter'],
+          [/[ \t\r\n]+/],
+          [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+        ],
+        styleEmbedded: [
+          [
+            /@[^@]/,
+            {
+              token: '@rematch',
+              switchTo: '@razorInEmbeddedState.styleEmbedded.$S2',
+              nextEmbedded: '@pop',
+            },
+          ],
+          [/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+        ],
+        razorInSimpleState: [
+          [/@\*/, 'comment.cs', '@razorBlockCommentTopLevel'],
+          [/@[{(]/, 'metatag.cs', '@razorRootTopLevel'],
+          [/(@)(\s*[\w]+)/, ['metatag.cs', { token: 'identifier.cs', switchTo: '@$S2.$S3' }]],
+          [/[})]/, { token: 'metatag.cs', switchTo: '@$S2.$S3' }],
+          [/\*@/, { token: 'comment.cs', switchTo: '@$S2.$S3' }],
+        ],
+        razorInEmbeddedState: [
+          [/@\*/, 'comment.cs', '@razorBlockCommentTopLevel'],
+          [/@[{(]/, 'metatag.cs', '@razorRootTopLevel'],
+          [
+            /(@)(\s*[\w]+)/,
+            ['metatag.cs', { token: 'identifier.cs', switchTo: '@$S2.$S3', nextEmbedded: '$S3' }],
+          ],
+          [/[})]/, { token: 'metatag.cs', switchTo: '@$S2.$S3', nextEmbedded: '$S3' }],
+          [/\*@/, { token: 'comment.cs', switchTo: '@$S2.$S3', nextEmbedded: '$S3' }],
+        ],
+        razorBlockCommentTopLevel: [
+          [/\*@/, '@rematch', '@pop'],
+          [/[^*]+/, 'comment.cs'],
+          [/./, 'comment.cs'],
+        ],
+        razorBlockComment: [
+          [/\*@/, 'comment.cs', '@pop'],
+          [/[^*]+/, 'comment.cs'],
+          [/./, 'comment.cs'],
+        ],
+        razorRootTopLevel: [
+          [/\{/, 'delimiter.bracket.cs', '@razorRoot'],
+          [/\(/, 'delimiter.parenthesis.cs', '@razorRoot'],
+          [/[})]/, '@rematch', '@pop'],
+          { include: 'razorCommon' },
+        ],
+        razorRoot: [
+          [/\{/, 'delimiter.bracket.cs', '@razorRoot'],
+          [/\(/, 'delimiter.parenthesis.cs', '@razorRoot'],
+          [/\}/, 'delimiter.bracket.cs', '@pop'],
+          [/\)/, 'delimiter.parenthesis.cs', '@pop'],
+          { include: 'razorCommon' },
+        ],
+        razorCommon: [
+          [
+            /[a-zA-Z_]\w*/,
+            { cases: { '@razorKeywords': { token: 'keyword.cs' }, '@default': 'identifier.cs' } },
+          ],
+          [/[\[\]]/, 'delimiter.array.cs'],
+          [/[ \t\r\n]+/],
+          [/\/\/.*$/, 'comment.cs'],
+          [/@\*/, 'comment.cs', '@razorBlockComment'],
+          [/"([^"]*)"/, 'string.cs'],
+          [/'([^']*)'/, 'string.cs'],
+          [/(<)(\w+)(\/>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
+          [/(<)(\w+)(>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
+          [/(<\/)(\w+)(>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
+          [/[\+\-\*\%\&\|\^\~\!\=\<\>\/\?\;\:\.\,]/, 'delimiter.cs'],
+          [/\d*\d+[eE]([\-+]?\d+)?/, 'number.float.cs'],
+          [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float.cs'],
+          [/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, 'number.hex.cs'],
+          [/0[0-7']*[0-7]/, 'number.octal.cs'],
+          [/0[bB][0-1']*[0-1]/, 'number.binary.cs'],
+          [/\d[\d']*/, 'number.cs'],
+          [/\d/, 'number.cs'],
+        ],
+      },
+      razorKeywords: [
+        'abstract',
+        'as',
+        'async',
+        'await',
+        'base',
+        'bool',
+        'break',
+        'by',
+        'byte',
+        'case',
+        'catch',
+        'char',
+        'checked',
+        'class',
+        'const',
+        'continue',
+        'decimal',
+        'default',
+        'delegate',
+        'do',
+        'double',
+        'descending',
+        'explicit',
+        'event',
+        'extern',
+        'else',
+        'enum',
+        'false',
+        'finally',
+        'fixed',
+        'float',
+        'for',
+        'foreach',
+        'from',
+        'goto',
+        'group',
+        'if',
+        'implicit',
+        'in',
+        'int',
+        'interface',
+        'internal',
+        'into',
+        'is',
+        'lock',
+        'long',
+        'nameof',
+        'new',
+        'null',
+        'namespace',
+        'object',
+        'operator',
+        'out',
+        'override',
+        'orderby',
+        'params',
+        'private',
+        'protected',
+        'public',
+        'readonly',
+        'ref',
+        'return',
+        'switch',
+        'struct',
+        'sbyte',
+        'sealed',
+        'short',
+        'sizeof',
+        'stackalloc',
+        'static',
+        'string',
+        'select',
+        'this',
+        'throw',
+        'true',
+        'try',
+        'typeof',
+        'uint',
+        'ulong',
+        'unchecked',
+        'unsafe',
+        'ushort',
+        'using',
+        'var',
+        'virtual',
+        'volatile',
+        'void',
+        'when',
+        'while',
+        'where',
+        'yield',
+        'model',
+        'inject',
+      ],
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/ruby.js

@@ -0,0 +1,405 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/ruby', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      comments: { lineComment: '#', blockComment: ['=begin', '=end'] },
+      brackets: [['(', ')'], ['{', '}'], ['[', ']']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (t.language = {
+      tokenPostfix: '.ruby',
+      keywords: [
+        '__LINE__',
+        '__ENCODING__',
+        '__FILE__',
+        'BEGIN',
+        'END',
+        'alias',
+        'and',
+        'begin',
+        'break',
+        'case',
+        'class',
+        'def',
+        'defined?',
+        'do',
+        'else',
+        'elsif',
+        'end',
+        'ensure',
+        'for',
+        'false',
+        'if',
+        'in',
+        'module',
+        'next',
+        'nil',
+        'not',
+        'or',
+        'redo',
+        'rescue',
+        'retry',
+        'return',
+        'self',
+        'super',
+        'then',
+        'true',
+        'undef',
+        'unless',
+        'until',
+        'when',
+        'while',
+        'yield',
+      ],
+      keywordops: ['::', '..', '...', '?', ':', '=>'],
+      builtins: [
+        'require',
+        'public',
+        'private',
+        'include',
+        'extend',
+        'attr_reader',
+        'protected',
+        'private_class_method',
+        'protected_class_method',
+        'new',
+      ],
+      declarations: [
+        'module',
+        'class',
+        'def',
+        'case',
+        'do',
+        'begin',
+        'for',
+        'if',
+        'while',
+        'until',
+        'unless',
+      ],
+      linedecls: ['def', 'case', 'do', 'begin', 'for', 'if', 'while', 'until', 'unless'],
+      operators: [
+        '^',
+        '&',
+        '|',
+        '<=>',
+        '==',
+        '===',
+        '!~',
+        '=~',
+        '>',
+        '>=',
+        '<',
+        '<=',
+        '<<',
+        '>>',
+        '+',
+        '-',
+        '*',
+        '/',
+        '%',
+        '**',
+        '~',
+        '+@',
+        '-@',
+        '[]',
+        '[]=',
+        '`',
+        '+=',
+        '-=',
+        '*=',
+        '**=',
+        '/=',
+        '^=',
+        '%=',
+        '<<=',
+        '>>=',
+        '&=',
+        '&&=',
+        '||=',
+        '|=',
+      ],
+      brackets: [
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+        { open: '{', close: '}', token: 'delimiter.curly' },
+        { open: '[', close: ']', token: 'delimiter.square' },
+      ],
+      symbols: /[=><!~?:&|+\-*\/\^%\.]+/,
+      escape: /(?:[abefnrstv\\"'\n\r]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4})/,
+      escapes: /\\(?:C\-(@escape|.)|c(@escape|.)|@escape)/,
+      decpart: /\d(_?\d)*/,
+      decimal: /0|@decpart/,
+      delim: /[^a-zA-Z0-9\s\n\r]/,
+      heredelim: /(?:\w+|'[^']*'|"[^"]*"|`[^`]*`)/,
+      regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+      regexpesc: /\\(?:[AzZbBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})?/,
+      tokenizer: {
+        root: [
+          [
+            /^(\s*)([a-z_]\w*[!?=]?)/,
+            [
+              'white',
+              {
+                cases: {
+                  'for|until|while': { token: 'keyword.$2', next: '@dodecl.$2' },
+                  '@declarations': { token: 'keyword.$2', next: '@root.$2' },
+                  end: { token: 'keyword.$S2', next: '@pop' },
+                  '@keywords': 'keyword',
+                  '@builtins': 'predefined',
+                  '@default': 'identifier',
+                },
+              },
+            ],
+          ],
+          [
+            /[a-z_]\w*[!?=]?/,
+            {
+              cases: {
+                'if|unless|while|until': { token: 'keyword.$0x', next: '@modifier.$0x' },
+                for: { token: 'keyword.$2', next: '@dodecl.$2' },
+                '@linedecls': { token: 'keyword.$0', next: '@root.$0' },
+                end: { token: 'keyword.$S2', next: '@pop' },
+                '@keywords': 'keyword',
+                '@builtins': 'predefined',
+                '@default': 'identifier',
+              },
+            },
+          ],
+          [/[A-Z][\w]*[!?=]?/, 'constructor.identifier'],
+          [/\$[\w]*/, 'global.constant'],
+          [/@[\w]*/, 'namespace.instance.identifier'],
+          [/@@[\w]*/, 'namespace.class.identifier'],
+          [/<<-(@heredelim).*/, { token: 'string.heredoc.delimiter', next: '@heredoc.$1' }],
+          [
+            /[ \t\r\n]+<<(@heredelim).*/,
+            { token: 'string.heredoc.delimiter', next: '@heredoc.$1' },
+          ],
+          [/^<<(@heredelim).*/, { token: 'string.heredoc.delimiter', next: '@heredoc.$1' }],
+          { include: '@whitespace' },
+          [/"/, { token: 'string.d.delim', next: '@dstring.d."' }],
+          [/'/, { token: 'string.sq.delim', next: '@sstring.sq' }],
+          [/%([rsqxwW]|Q?)/, { token: '@rematch', next: 'pstring' }],
+          [/`/, { token: 'string.x.delim', next: '@dstring.x.`' }],
+          [/:(\w|[$@])\w*[!?=]?/, 'string.s'],
+          [/:"/, { token: 'string.s.delim', next: '@dstring.s."' }],
+          [/:'/, { token: 'string.s.delim', next: '@sstring.s' }],
+          [/\/(?=(\\\/|[^\/\n])+\/)/, { token: 'regexp.delim', next: '@regexp' }],
+          [/[{}()\[\]]/, '@brackets'],
+          [
+            /@symbols/,
+            { cases: { '@keywordops': 'keyword', '@operators': 'operator', '@default': '' } },
+          ],
+          [/[;,]/, 'delimiter'],
+          [/0[xX][0-9a-fA-F](_?[0-9a-fA-F])*/, 'number.hex'],
+          [/0[_oO][0-7](_?[0-7])*/, 'number.octal'],
+          [/0[bB][01](_?[01])*/, 'number.binary'],
+          [/0[dD]@decpart/, 'number'],
+          [
+            /@decimal((\.@decpart)?([eE][\-+]?@decpart)?)/,
+            { cases: { $1: 'number.float', '@default': 'number' } },
+          ],
+        ],
+        dodecl: [
+          [/^/, { token: '', switchTo: '@root.$S2' }],
+          [
+            /[a-z_]\w*[!?=]?/,
+            {
+              cases: {
+                end: { token: 'keyword.$S2', next: '@pop' },
+                do: { token: 'keyword', switchTo: '@root.$S2' },
+                '@linedecls': { token: '@rematch', switchTo: '@root.$S2' },
+                '@keywords': 'keyword',
+                '@builtins': 'predefined',
+                '@default': 'identifier',
+              },
+            },
+          ],
+          { include: '@root' },
+        ],
+        modifier: [
+          [/^/, '', '@pop'],
+          [
+            /[a-z_]\w*[!?=]?/,
+            {
+              cases: {
+                end: { token: 'keyword.$S2', next: '@pop' },
+                'then|else|elsif|do': { token: 'keyword', switchTo: '@root.$S2' },
+                '@linedecls': { token: '@rematch', switchTo: '@root.$S2' },
+                '@keywords': 'keyword',
+                '@builtins': 'predefined',
+                '@default': 'identifier',
+              },
+            },
+          ],
+          { include: '@root' },
+        ],
+        sstring: [
+          [/[^\\']+/, 'string.$S2'],
+          [/\\\\|\\'|\\$/, 'string.$S2.escape'],
+          [/\\./, 'string.$S2.invalid'],
+          [/'/, { token: 'string.$S2.delim', next: '@pop' }],
+        ],
+        dstring: [
+          [/[^\\`"#]+/, 'string.$S2'],
+          [/#/, 'string.$S2.escape', '@interpolated'],
+          [/\\$/, 'string.$S2.escape'],
+          [/@escapes/, 'string.$S2.escape'],
+          [/\\./, 'string.$S2.escape.invalid'],
+          [
+            /[`"]/,
+            {
+              cases: {
+                '$#==$S3': { token: 'string.$S2.delim', next: '@pop' },
+                '@default': 'string.$S2',
+              },
+            },
+          ],
+        ],
+        heredoc: [
+          [
+            /^(\s*)(@heredelim)$/,
+            {
+              cases: {
+                '$2==$S2': ['string.heredoc', { token: 'string.heredoc.delimiter', next: '@pop' }],
+                '@default': ['string.heredoc', 'string.heredoc'],
+              },
+            },
+          ],
+          [/.*/, 'string.heredoc'],
+        ],
+        interpolated: [
+          [/\$\w*/, 'global.constant', '@pop'],
+          [/@\w*/, 'namespace.class.identifier', '@pop'],
+          [/@@\w*/, 'namespace.instance.identifier', '@pop'],
+          [/[{]/, { token: 'string.escape.curly', switchTo: '@interpolated_compound' }],
+          ['', '', '@pop'],
+        ],
+        interpolated_compound: [
+          [/[}]/, { token: 'string.escape.curly', next: '@pop' }],
+          { include: '@root' },
+        ],
+        pregexp: [
+          { include: '@whitespace' },
+          [
+            /[^\(\{\[\\]/,
+            {
+              cases: {
+                '$#==$S3': { token: 'regexp.delim', next: '@pop' },
+                '$#==$S2': { token: 'regexp.delim', next: '@push' },
+                '~[)}\\]]': '@brackets.regexp.escape.control',
+                '~@regexpctl': 'regexp.escape.control',
+                '@default': 'regexp',
+              },
+            },
+          ],
+          { include: '@regexcontrol' },
+        ],
+        regexp: [
+          { include: '@regexcontrol' },
+          [/[^\\\/]/, 'regexp'],
+          ['/[ixmp]*', { token: 'regexp.delim' }, '@pop'],
+        ],
+        regexcontrol: [
+          [
+            /(\{)(\d+(?:,\d*)?)(\})/,
+            [
+              '@brackets.regexp.escape.control',
+              'regexp.escape.control',
+              '@brackets.regexp.escape.control',
+            ],
+          ],
+          [
+            /(\[)(\^?)/,
+            [
+              '@brackets.regexp.escape.control',
+              { token: 'regexp.escape.control', next: '@regexrange' },
+            ],
+          ],
+          [/(\()(\?[:=!])/, ['@brackets.regexp.escape.control', 'regexp.escape.control']],
+          [/\(\?#/, { token: 'regexp.escape.control', next: '@regexpcomment' }],
+          [/[()]/, '@brackets.regexp.escape.control'],
+          [/@regexpctl/, 'regexp.escape.control'],
+          [/\\$/, 'regexp.escape'],
+          [/@regexpesc/, 'regexp.escape'],
+          [/\\\./, 'regexp.invalid'],
+          [/#/, 'regexp.escape', '@interpolated'],
+        ],
+        regexrange: [
+          [/-/, 'regexp.escape.control'],
+          [/\^/, 'regexp.invalid'],
+          [/\\$/, 'regexp.escape'],
+          [/@regexpesc/, 'regexp.escape'],
+          [/[^\]]/, 'regexp'],
+          [/\]/, '@brackets.regexp.escape.control', '@pop'],
+        ],
+        regexpcomment: [
+          [/[^)]+/, 'comment'],
+          [/\)/, { token: 'regexp.escape.control', next: '@pop' }],
+        ],
+        pstring: [
+          [/%([qws])\(/, { token: 'string.$1.delim', switchTo: '@qstring.$1.(.)' }],
+          [/%([qws])\[/, { token: 'string.$1.delim', switchTo: '@qstring.$1.[.]' }],
+          [/%([qws])\{/, { token: 'string.$1.delim', switchTo: '@qstring.$1.{.}' }],
+          [/%([qws])</, { token: 'string.$1.delim', switchTo: '@qstring.$1.<.>' }],
+          [/%([qws])(@delim)/, { token: 'string.$1.delim', switchTo: '@qstring.$1.$2.$2' }],
+          [/%r\(/, { token: 'regexp.delim', switchTo: '@pregexp.(.)' }],
+          [/%r\[/, { token: 'regexp.delim', switchTo: '@pregexp.[.]' }],
+          [/%r\{/, { token: 'regexp.delim', switchTo: '@pregexp.{.}' }],
+          [/%r</, { token: 'regexp.delim', switchTo: '@pregexp.<.>' }],
+          [/%r(@delim)/, { token: 'regexp.delim', switchTo: '@pregexp.$1.$1' }],
+          [/%(x|W|Q?)\(/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.(.)' }],
+          [/%(x|W|Q?)\[/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.[.]' }],
+          [/%(x|W|Q?)\{/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.{.}' }],
+          [/%(x|W|Q?)</, { token: 'string.$1.delim', switchTo: '@qqstring.$1.<.>' }],
+          [/%(x|W|Q?)(@delim)/, { token: 'string.$1.delim', switchTo: '@qqstring.$1.$2.$2' }],
+          [/%([rqwsxW]|Q?)./, { token: 'invalid', next: '@pop' }],
+          [/./, { token: 'invalid', next: '@pop' }],
+        ],
+        qstring: [
+          [/\\$/, 'string.$S2.escape'],
+          [/\\./, 'string.$S2.escape'],
+          [
+            /./,
+            {
+              cases: {
+                '$#==$S4': { token: 'string.$S2.delim', next: '@pop' },
+                '$#==$S3': { token: 'string.$S2.delim', next: '@push' },
+                '@default': 'string.$S2',
+              },
+            },
+          ],
+        ],
+        qqstring: [[/#/, 'string.$S2.escape', '@interpolated'], { include: '@qstring' }],
+        whitespace: [
+          [/[ \t\r\n]+/, ''],
+          [/^\s*=begin\b/, 'comment', '@comment'],
+          [/#.*$/, 'comment'],
+        ],
+        comment: [
+          [/[^=]+/, 'comment'],
+          [/^\s*=begin\b/, 'comment.invalid'],
+          [/^\s*=end\b.*/, 'comment', '@pop'],
+          [/[=]/, 'comment'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/sb.js

@@ -0,0 +1,90 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/sb', ['require', 'exports'], function(e, o) {
+  'use strict';
+  Object.defineProperty(o, '__esModule', { value: !0 }),
+    (o.conf = {
+      comments: { lineComment: "'" },
+      brackets: [
+        ['(', ')'],
+        ['[', ']'],
+        ['If', 'EndIf'],
+        ['While', 'EndWhile'],
+        ['For', 'EndFor'],
+        ['Sub', 'EndSub'],
+      ],
+      autoClosingPairs: [
+        { open: '"', close: '"', notIn: ['string', 'comment'] },
+        { open: '(', close: ')', notIn: ['string', 'comment'] },
+        { open: '[', close: ']', notIn: ['string', 'comment'] },
+      ],
+    }),
+    (o.language = {
+      defaultToken: '',
+      tokenPostfix: '.sb',
+      ignoreCase: !0,
+      brackets: [
+        { token: 'delimiter.array', open: '[', close: ']' },
+        { token: 'delimiter.parenthesis', open: '(', close: ')' },
+        { token: 'keyword.tag-if', open: 'If', close: 'EndIf' },
+        { token: 'keyword.tag-while', open: 'While', close: 'EndWhile' },
+        { token: 'keyword.tag-for', open: 'For', close: 'EndFor' },
+        { token: 'keyword.tag-sub', open: 'Sub', close: 'EndSub' },
+      ],
+      keywords: [
+        'Else',
+        'ElseIf',
+        'EndFor',
+        'EndIf',
+        'EndSub',
+        'EndWhile',
+        'For',
+        'Goto',
+        'If',
+        'Step',
+        'Sub',
+        'Then',
+        'To',
+        'While',
+      ],
+      tagwords: ['If', 'Sub', 'While', 'For'],
+      operators: ['>', '<', '<>', '<=', '>=', 'And', 'Or', '+', '-', '*', '/', '='],
+      identifier: /[a-zA-Z_][\w]*/,
+      symbols: /[=><:+\-*\/%\.,]+/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      tokenizer: {
+        root: [
+          { include: '@whitespace' },
+          [/(@identifier)(?=[.])/, 'type'],
+          [
+            /@identifier/,
+            {
+              cases: {
+                '@keywords': { token: 'keyword.$0' },
+                '@operators': 'operator',
+                '@default': 'variable.name',
+              },
+            },
+          ],
+          [/([.])(@identifier)/, { cases: { $2: ['delimiter', 'type.member'], '@default': '' } }],
+          [/\d*\.\d+/, 'number.float'],
+          [/\d+/, 'number'],
+          [/[()\[\]]/, '@brackets'],
+          [/@symbols/, { cases: { '@operators': 'operator', '@default': 'delimiter' } }],
+          [/"([^"\\]|\\.)*$/, 'string.invalid'],
+          [/"/, 'string', '@string'],
+        ],
+        whitespace: [[/[ \t\r\n]+/, ''], [/(\').*$/, 'comment']],
+        string: [
+          [/[^\\"]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [/"C?/, 'string', '@pop'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/scss.js

@@ -0,0 +1,226 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/scss', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      wordPattern: /(#?-?\d*\.\d\w*%?)|([@$#!.:]?[\w-?]+%?)|[@#!.]/g,
+      comments: { blockComment: ['/*', '*/'], lineComment: '//' },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}', notIn: ['string', 'comment'] },
+        { open: '[', close: ']', notIn: ['string', 'comment'] },
+        { open: '(', close: ')', notIn: ['string', 'comment'] },
+        { open: '"', close: '"', notIn: ['string', 'comment'] },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.scss',
+      ws: '[ \t\n\r\f]*',
+      identifier:
+        '-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
+      brackets: [
+        { open: '{', close: '}', token: 'delimiter.curly' },
+        { open: '[', close: ']', token: 'delimiter.bracket' },
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+        { open: '<', close: '>', token: 'delimiter.angle' },
+      ],
+      tokenizer: {
+        root: [{ include: '@selector' }],
+        selector: [
+          { include: '@comments' },
+          { include: '@import' },
+          { include: '@variabledeclaration' },
+          { include: '@warndebug' },
+          ['[@](include)', { token: 'keyword', next: '@includedeclaration' }],
+          [
+            '[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)',
+            { token: 'keyword', next: '@keyframedeclaration' },
+          ],
+          ['[@](page|content|font-face|-moz-document)', { token: 'keyword' }],
+          ['[@](charset|namespace)', { token: 'keyword', next: '@declarationbody' }],
+          ['[@](function)', { token: 'keyword', next: '@functiondeclaration' }],
+          ['[@](mixin)', { token: 'keyword', next: '@mixindeclaration' }],
+          ['url(\\-prefix)?\\(', { token: 'meta', next: '@urldeclaration' }],
+          { include: '@controlstatement' },
+          { include: '@selectorname' },
+          ['[&\\*]', 'tag'],
+          ['[>\\+,]', 'delimiter'],
+          ['\\[', { token: 'delimiter.bracket', next: '@selectorattribute' }],
+          ['{', { token: 'delimiter.curly', next: '@selectorbody' }],
+        ],
+        selectorbody: [
+          ['[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))', 'attribute.name', '@rulevalue'],
+          { include: '@selector' },
+          ['[@](extend)', { token: 'keyword', next: '@extendbody' }],
+          ['[@](return)', { token: 'keyword', next: '@declarationbody' }],
+          ['}', { token: 'delimiter.curly', next: '@pop' }],
+        ],
+        selectorname: [
+          ['#{', { token: 'meta', next: '@variableinterpolation' }],
+          ['(\\.|#(?=[^{])|%|(@identifier)|:)+', 'tag'],
+        ],
+        selectorattribute: [
+          { include: '@term' },
+          [']', { token: 'delimiter.bracket', next: '@pop' }],
+        ],
+        term: [
+          { include: '@comments' },
+          ['url(\\-prefix)?\\(', { token: 'meta', next: '@urldeclaration' }],
+          { include: '@functioninvocation' },
+          { include: '@numbers' },
+          { include: '@strings' },
+          { include: '@variablereference' },
+          ['(and\\b|or\\b|not\\b)', 'operator'],
+          { include: '@name' },
+          ['([<>=\\+\\-\\*\\/\\^\\|\\~,])', 'operator'],
+          [',', 'delimiter'],
+          ['!default', 'literal'],
+          ['\\(', { token: 'delimiter.parenthesis', next: '@parenthizedterm' }],
+        ],
+        rulevalue: [
+          { include: '@term' },
+          ['!important', 'literal'],
+          [';', 'delimiter', '@pop'],
+          ['{', { token: 'delimiter.curly', switchTo: '@nestedproperty' }],
+          ['(?=})', { token: '', next: '@pop' }],
+        ],
+        nestedproperty: [
+          ['[*_]?@identifier@ws:', 'attribute.name', '@rulevalue'],
+          { include: '@comments' },
+          ['}', { token: 'delimiter.curly', next: '@pop' }],
+        ],
+        warndebug: [['[@](warn|debug)', { token: 'keyword', next: '@declarationbody' }]],
+        import: [['[@](import)', { token: 'keyword', next: '@declarationbody' }]],
+        variabledeclaration: [['\\$@identifier@ws:', 'variable.decl', '@declarationbody']],
+        urldeclaration: [
+          { include: '@strings' },
+          ['[^)\r\n]+', 'string'],
+          ['\\)', { token: 'meta', next: '@pop' }],
+        ],
+        parenthizedterm: [
+          { include: '@term' },
+          ['\\)', { token: 'delimiter.parenthesis', next: '@pop' }],
+        ],
+        declarationbody: [
+          { include: '@term' },
+          [';', 'delimiter', '@pop'],
+          ['(?=})', { token: '', next: '@pop' }],
+        ],
+        extendbody: [
+          { include: '@selectorname' },
+          ['!optional', 'literal'],
+          [';', 'delimiter', '@pop'],
+          ['(?=})', { token: '', next: '@pop' }],
+        ],
+        variablereference: [
+          ['\\$@identifier', 'variable.ref'],
+          ['\\.\\.\\.', 'operator'],
+          ['#{', { token: 'meta', next: '@variableinterpolation' }],
+        ],
+        variableinterpolation: [
+          { include: '@variablereference' },
+          ['}', { token: 'meta', next: '@pop' }],
+        ],
+        comments: [['\\/\\*', 'comment', '@comment'], ['\\/\\/+.*', 'comment']],
+        comment: [['\\*\\/', 'comment', '@pop'], ['.', 'comment']],
+        name: [['@identifier', 'attribute.value']],
+        numbers: [
+          ['(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?', { token: 'number', next: '@units' }],
+          ['#[0-9a-fA-F_]+(?!\\w)', 'number.hex'],
+        ],
+        units: [
+          [
+            '(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?',
+            'number',
+            '@pop',
+          ],
+        ],
+        functiondeclaration: [
+          ['@identifier@ws\\(', { token: 'meta', next: '@parameterdeclaration' }],
+          ['{', { token: 'delimiter.curly', switchTo: '@functionbody' }],
+        ],
+        mixindeclaration: [
+          ['@identifier@ws\\(', { token: 'meta', next: '@parameterdeclaration' }],
+          ['@identifier', 'meta'],
+          ['{', { token: 'delimiter.curly', switchTo: '@selectorbody' }],
+        ],
+        parameterdeclaration: [
+          ['\\$@identifier@ws:', 'variable.decl'],
+          ['\\.\\.\\.', 'operator'],
+          [',', 'delimiter'],
+          { include: '@term' },
+          ['\\)', { token: 'meta', next: '@pop' }],
+        ],
+        includedeclaration: [
+          { include: '@functioninvocation' },
+          ['@identifier', 'meta'],
+          [';', 'delimiter', '@pop'],
+          ['(?=})', { token: '', next: '@pop' }],
+          ['{', { token: 'delimiter.curly', switchTo: '@selectorbody' }],
+        ],
+        keyframedeclaration: [
+          ['@identifier', 'meta'],
+          ['{', { token: 'delimiter.curly', switchTo: '@keyframebody' }],
+        ],
+        keyframebody: [
+          { include: '@term' },
+          ['{', { token: 'delimiter.curly', next: '@selectorbody' }],
+          ['}', { token: 'delimiter.curly', next: '@pop' }],
+        ],
+        controlstatement: [
+          [
+            '[@](if|else|for|while|each|media)',
+            { token: 'keyword.flow', next: '@controlstatementdeclaration' },
+          ],
+        ],
+        controlstatementdeclaration: [
+          ['(in|from|through|if|to)\\b', { token: 'keyword.flow' }],
+          { include: '@term' },
+          ['{', { token: 'delimiter.curly', switchTo: '@selectorbody' }],
+        ],
+        functionbody: [
+          ['[@](return)', { token: 'keyword' }],
+          { include: '@variabledeclaration' },
+          { include: '@term' },
+          { include: '@controlstatement' },
+          [';', 'delimiter'],
+          ['}', { token: 'delimiter.curly', next: '@pop' }],
+        ],
+        functioninvocation: [['@identifier\\(', { token: 'meta', next: '@functionarguments' }]],
+        functionarguments: [
+          ['\\$@identifier@ws:', 'attribute.name'],
+          ['[,]', 'delimiter'],
+          { include: '@term' },
+          ['\\)', { token: 'meta', next: '@pop' }],
+        ],
+        strings: [
+          ['~?"', { token: 'string.delimiter', next: '@stringenddoublequote' }],
+          ["~?'", { token: 'string.delimiter', next: '@stringendquote' }],
+        ],
+        stringenddoublequote: [
+          ['\\\\.', 'string'],
+          ['"', { token: 'string.delimiter', next: '@pop' }],
+          ['.', 'string'],
+        ],
+        stringendquote: [
+          ['\\\\.', 'string'],
+          ["'", { token: 'string.delimiter', next: '@pop' }],
+          ['.', 'string'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/swift.js

@@ -0,0 +1,221 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+/*!---------------------------------------------------------------------------------------------
+ *  Copyright (C) David Owens II, owensd.io. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+define('vs/basic-languages/src/swift', ['require', 'exports'], function(e, o) {
+  'use strict';
+  Object.defineProperty(o, '__esModule', { value: !0 }),
+    (o.conf = {
+      comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+        { open: '`', close: '`' },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+        { open: '`', close: '`' },
+      ],
+    }),
+    (o.language = {
+      defaultToken: '',
+      tokenPostfix: '.swift',
+      identifier: /[a-zA-Z_][\w$]*/,
+      attributes: [
+        '@autoclosure',
+        '@noescape',
+        '@noreturn',
+        '@NSApplicationMain',
+        '@NSCopying',
+        '@NSManaged',
+        '@objc',
+        '@UIApplicationMain',
+        '@noreturn',
+        '@availability',
+        '@IBAction',
+        '@IBDesignable',
+        '@IBInspectable',
+        '@IBOutlet',
+      ],
+      accessmodifiers: ['public', 'private', 'internal'],
+      keywords: [
+        '__COLUMN__',
+        '__FILE__',
+        '__FUNCTION__',
+        '__LINE__',
+        'as',
+        'as!',
+        'as?',
+        'associativity',
+        'break',
+        'case',
+        'catch',
+        'class',
+        'continue',
+        'convenience',
+        'default',
+        'deinit',
+        'didSet',
+        'do',
+        'dynamic',
+        'dynamicType',
+        'else',
+        'enum',
+        'extension',
+        'fallthrough',
+        'final',
+        'for',
+        'func',
+        'get',
+        'guard',
+        'if',
+        'import',
+        'in',
+        'infix',
+        'init',
+        'inout',
+        'internal',
+        'is',
+        'lazy',
+        'left',
+        'let',
+        'mutating',
+        'nil',
+        'none',
+        'nonmutating',
+        'operator',
+        'optional',
+        'override',
+        'postfix',
+        'precedence',
+        'prefix',
+        'private',
+        'protocol',
+        'Protocol',
+        'public',
+        'repeat',
+        'required',
+        'return',
+        'right',
+        'self',
+        'Self',
+        'set',
+        'static',
+        'struct',
+        'subscript',
+        'super',
+        'switch',
+        'throw',
+        'throws',
+        'try',
+        'try!',
+        'Type',
+        'typealias',
+        'unowned',
+        'var',
+        'weak',
+        'where',
+        'while',
+        'willSet',
+        'FALSE',
+        'TRUE',
+      ],
+      symbols: /[=(){}\[\].,:;@#\_&\-<>`?!+*\\\/]/,
+      operatorstart: /[\/=\-+!*%<>&|^~?\u00A1-\u00A7\u00A9\u00AB\u00AC\u00AE\u00B0-\u00B1\u00B6\u00BB\u00BF\u00D7\u00F7\u2016-\u2017\u2020-\u2027\u2030-\u203E\u2041-\u2053\u2055-\u205E\u2190-\u23FF\u2500-\u2775\u2794-\u2BFF\u2E00-\u2E7F\u3001-\u3003\u3008-\u3030]/,
+      operatorend: /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE00-\uFE0F\uFE20-\uFE2F\uE0100-\uE01EF]/,
+      operators: /(@operatorstart)((@operatorstart)|(@operatorend))*/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      tokenizer: {
+        root: [
+          { include: '@comment' },
+          { include: '@attribute' },
+          { include: '@literal' },
+          { include: '@keyword' },
+          { include: '@invokedmethod' },
+          { include: '@symbol' },
+        ],
+        symbol: [
+          [/[{}()\[\]]/, '@brackets'],
+          [/[<>](?!@symbols)/, '@brackets'],
+          [/[.]/, 'delimiter'],
+          [/@operators/, 'operator'],
+          [/@symbols/, 'operator'],
+        ],
+        comment: [
+          [/\/\/\/.*$/, 'comment.doc'],
+          [/\/\*\*/, 'comment.doc', '@commentdocbody'],
+          [/\/\/.*$/, 'comment'],
+          [/\/\*/, 'comment', '@commentbody'],
+        ],
+        commentdocbody: [
+          [/\/\*/, 'comment', '@commentbody'],
+          [/\*\//, 'comment.doc', '@pop'],
+          [/\:[a-zA-Z]+\:/, 'comment.doc.param'],
+          [/./, 'comment.doc'],
+        ],
+        commentbody: [
+          [/\/\*/, 'comment', '@commentbody'],
+          [/\*\//, 'comment', '@pop'],
+          [/./, 'comment'],
+        ],
+        attribute: [
+          [/\@@identifier/, { cases: { '@attributes': 'keyword.control', '@default': '' } }],
+        ],
+        literal: [
+          [/"/, { token: 'string.quote', next: '@stringlit' }],
+          [/0[b]([01]_?)+/, 'number.binary'],
+          [/0[o]([0-7]_?)+/, 'number.octal'],
+          [/0[x]([0-9a-fA-F]_?)+([pP][\-+](\d_?)+)?/, 'number.hex'],
+          [/(\d_?)*\.(\d_?)+([eE][\-+]?(\d_?)+)?/, 'number.float'],
+          [/(\d_?)+/, 'number'],
+        ],
+        stringlit: [
+          [/\\\(/, { token: 'operator', next: '@interpolatedexpression' }],
+          [/@escapes/, 'string'],
+          [/\\./, 'string.escape.invalid'],
+          [/"/, { token: 'string.quote', next: '@pop' }],
+          [/./, 'string'],
+        ],
+        interpolatedexpression: [
+          [/\(/, { token: 'operator', next: '@interpolatedexpression' }],
+          [/\)/, { token: 'operator', next: '@pop' }],
+          { include: '@literal' },
+          { include: '@keyword' },
+          { include: '@symbol' },
+        ],
+        keyword: [
+          [/`/, { token: 'operator', next: '@escapedkeyword' }],
+          [
+            /@identifier/,
+            {
+              cases: {
+                '@keywords': 'keyword',
+                '[A-Z][a-zA-Z0-9$]*': 'type.identifier',
+                '@default': 'identifier',
+              },
+            },
+          ],
+        ],
+        escapedkeyword: [[/`/, { token: 'operator', next: '@pop' }], [/./, 'identifier']],
+        invokedmethod: [
+          [
+            /([.])(@identifier)/,
+            { cases: { $2: ['delimeter', 'type.identifier'], '@default': '' } },
+          ],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/vb.js

@@ -0,0 +1,313 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/vb', ['require', 'exports'], function(e, n) {
+  'use strict';
+  Object.defineProperty(n, '__esModule', { value: !0 }),
+    (n.conf = {
+      comments: { lineComment: "'", blockComment: ['/*', '*/'] },
+      brackets: [
+        ['{', '}'],
+        ['[', ']'],
+        ['(', ')'],
+        ['<', '>'],
+        ['addhandler', 'end addhandler'],
+        ['class', 'end class'],
+        ['enum', 'end enum'],
+        ['event', 'end event'],
+        ['function', 'end function'],
+        ['get', 'end get'],
+        ['if', 'end if'],
+        ['interface', 'end interface'],
+        ['module', 'end module'],
+        ['namespace', 'end namespace'],
+        ['operator', 'end operator'],
+        ['property', 'end property'],
+        ['raiseevent', 'end raiseevent'],
+        ['removehandler', 'end removehandler'],
+        ['select', 'end select'],
+        ['set', 'end set'],
+        ['structure', 'end structure'],
+        ['sub', 'end sub'],
+        ['synclock', 'end synclock'],
+        ['try', 'end try'],
+        ['while', 'end while'],
+        ['with', 'end with'],
+        ['using', 'end using'],
+        ['do', 'loop'],
+        ['for', 'next'],
+      ],
+      autoClosingPairs: [
+        { open: '{', close: '}', notIn: ['string', 'comment'] },
+        { open: '[', close: ']', notIn: ['string', 'comment'] },
+        { open: '(', close: ')', notIn: ['string', 'comment'] },
+        { open: '"', close: '"', notIn: ['string', 'comment'] },
+        { open: '<', close: '>', notIn: ['string', 'comment'] },
+      ],
+    }),
+    (n.language = {
+      defaultToken: '',
+      tokenPostfix: '.vb',
+      ignoreCase: !0,
+      brackets: [
+        { token: 'delimiter.bracket', open: '{', close: '}' },
+        { token: 'delimiter.array', open: '[', close: ']' },
+        { token: 'delimiter.parenthesis', open: '(', close: ')' },
+        { token: 'delimiter.angle', open: '<', close: '>' },
+        { token: 'keyword.tag-addhandler', open: 'addhandler', close: 'end addhandler' },
+        { token: 'keyword.tag-class', open: 'class', close: 'end class' },
+        { token: 'keyword.tag-enum', open: 'enum', close: 'end enum' },
+        { token: 'keyword.tag-event', open: 'event', close: 'end event' },
+        { token: 'keyword.tag-function', open: 'function', close: 'end function' },
+        { token: 'keyword.tag-get', open: 'get', close: 'end get' },
+        { token: 'keyword.tag-if', open: 'if', close: 'end if' },
+        { token: 'keyword.tag-interface', open: 'interface', close: 'end interface' },
+        { token: 'keyword.tag-module', open: 'module', close: 'end module' },
+        { token: 'keyword.tag-namespace', open: 'namespace', close: 'end namespace' },
+        { token: 'keyword.tag-operator', open: 'operator', close: 'end operator' },
+        { token: 'keyword.tag-property', open: 'property', close: 'end property' },
+        { token: 'keyword.tag-raiseevent', open: 'raiseevent', close: 'end raiseevent' },
+        { token: 'keyword.tag-removehandler', open: 'removehandler', close: 'end removehandler' },
+        { token: 'keyword.tag-select', open: 'select', close: 'end select' },
+        { token: 'keyword.tag-set', open: 'set', close: 'end set' },
+        { token: 'keyword.tag-structure', open: 'structure', close: 'end structure' },
+        { token: 'keyword.tag-sub', open: 'sub', close: 'end sub' },
+        { token: 'keyword.tag-synclock', open: 'synclock', close: 'end synclock' },
+        { token: 'keyword.tag-try', open: 'try', close: 'end try' },
+        { token: 'keyword.tag-while', open: 'while', close: 'end while' },
+        { token: 'keyword.tag-with', open: 'with', close: 'end with' },
+        { token: 'keyword.tag-using', open: 'using', close: 'end using' },
+        { token: 'keyword.tag-do', open: 'do', close: 'loop' },
+        { token: 'keyword.tag-for', open: 'for', close: 'next' },
+      ],
+      keywords: [
+        'AddHandler',
+        'AddressOf',
+        'Alias',
+        'And',
+        'AndAlso',
+        'As',
+        'Async',
+        'Boolean',
+        'ByRef',
+        'Byte',
+        'ByVal',
+        'Call',
+        'Case',
+        'Catch',
+        'CBool',
+        'CByte',
+        'CChar',
+        'CDate',
+        'CDbl',
+        'CDec',
+        'Char',
+        'CInt',
+        'Class',
+        'CLng',
+        'CObj',
+        'Const',
+        'Continue',
+        'CSByte',
+        'CShort',
+        'CSng',
+        'CStr',
+        'CType',
+        'CUInt',
+        'CULng',
+        'CUShort',
+        'Date',
+        'Decimal',
+        'Declare',
+        'Default',
+        'Delegate',
+        'Dim',
+        'DirectCast',
+        'Do',
+        'Double',
+        'Each',
+        'Else',
+        'ElseIf',
+        'End',
+        'EndIf',
+        'Enum',
+        'Erase',
+        'Error',
+        'Event',
+        'Exit',
+        'False',
+        'Finally',
+        'For',
+        'Friend',
+        'Function',
+        'Get',
+        'GetType',
+        'GetXMLNamespace',
+        'Global',
+        'GoSub',
+        'GoTo',
+        'Handles',
+        'If',
+        'Implements',
+        'Imports',
+        'In',
+        'Inherits',
+        'Integer',
+        'Interface',
+        'Is',
+        'IsNot',
+        'Let',
+        'Lib',
+        'Like',
+        'Long',
+        'Loop',
+        'Me',
+        'Mod',
+        'Module',
+        'MustInherit',
+        'MustOverride',
+        'MyBase',
+        'MyClass',
+        'NameOf',
+        'Namespace',
+        'Narrowing',
+        'New',
+        'Next',
+        'Not',
+        'Nothing',
+        'NotInheritable',
+        'NotOverridable',
+        'Object',
+        'Of',
+        'On',
+        'Operator',
+        'Option',
+        'Optional',
+        'Or',
+        'OrElse',
+        'Out',
+        'Overloads',
+        'Overridable',
+        'Overrides',
+        'ParamArray',
+        'Partial',
+        'Private',
+        'Property',
+        'Protected',
+        'Public',
+        'RaiseEvent',
+        'ReadOnly',
+        'ReDim',
+        'RemoveHandler',
+        'Resume',
+        'Return',
+        'SByte',
+        'Select',
+        'Set',
+        'Shadows',
+        'Shared',
+        'Short',
+        'Single',
+        'Static',
+        'Step',
+        'Stop',
+        'String',
+        'Structure',
+        'Sub',
+        'SyncLock',
+        'Then',
+        'Throw',
+        'To',
+        'True',
+        'Try',
+        'TryCast',
+        'TypeOf',
+        'UInteger',
+        'ULong',
+        'UShort',
+        'Using',
+        'Variant',
+        'Wend',
+        'When',
+        'While',
+        'Widening',
+        'With',
+        'WithEvents',
+        'WriteOnly',
+        'Xor',
+      ],
+      tagwords: [
+        'If',
+        'Sub',
+        'Select',
+        'Try',
+        'Class',
+        'Enum',
+        'Function',
+        'Get',
+        'Interface',
+        'Module',
+        'Namespace',
+        'Operator',
+        'Set',
+        'Structure',
+        'Using',
+        'While',
+        'With',
+        'Do',
+        'Loop',
+        'For',
+        'Next',
+        'Property',
+        'Continue',
+        'AddHandler',
+        'RemoveHandler',
+        'Event',
+        'RaiseEvent',
+        'SyncLock',
+      ],
+      symbols: /[=><!~?;\.,:&|+\-*\/\^%]+/,
+      escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+      integersuffix: /U?[DI%L&S@]?/,
+      floatsuffix: /[R#F!]?/,
+      tokenizer: {
+        root: [
+          { include: '@whitespace' },
+          [/next(?!\w)/, { token: 'keyword.tag-for' }],
+          [/loop(?!\w)/, { token: 'keyword.tag-do' }],
+          [/end\s+(?!for|do)([a-zA-Z_]\w*)/, { token: 'keyword.tag-$1' }],
+          [
+            /[a-zA-Z_]\w*/,
+            {
+              cases: {
+                '@tagwords': { token: 'keyword.tag-$0' },
+                '@keywords': { token: 'keyword.$0' },
+                '@default': 'identifier',
+              },
+            },
+          ],
+          [/^\s*#\w+/, 'keyword'],
+          [/\d*\d+e([\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+          [/\d*\.\d+(e[\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+          [/&H[0-9a-f]+(@integersuffix)/, 'number.hex'],
+          [/&0[0-7]+(@integersuffix)/, 'number.octal'],
+          [/\d+(@integersuffix)/, 'number'],
+          [/#.*#/, 'number'],
+          [/[{}()\[\]]/, '@brackets'],
+          [/@symbols/, 'delimiter'],
+          [/"([^"\\]|\\.)*$/, 'string.invalid'],
+          [/"/, 'string', '@string'],
+        ],
+        whitespace: [[/[ \t\r\n]+/, ''], [/(\'|REM(?!\w)).*$/, 'comment']],
+        string: [
+          [/[^\\"]+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [/"C?/, 'string', '@pop'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/xml.js

@@ -0,0 +1,66 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/xml', ['require', 'exports'], function(e, t) {
+  'use strict';
+  Object.defineProperty(t, '__esModule', { value: !0 }),
+    (t.conf = {
+      comments: { blockComment: ['\x3c!--', '--\x3e'] },
+      brackets: [['<', '>']],
+      autoClosingPairs: [
+        { open: '<', close: '>' },
+        { open: "'", close: "'" },
+        { open: '"', close: '"' },
+      ],
+      surroundingPairs: [
+        { open: '<', close: '>' },
+        { open: "'", close: "'" },
+        { open: '"', close: '"' },
+      ],
+    }),
+    (t.language = {
+      defaultToken: '',
+      tokenPostfix: '.xml',
+      ignoreCase: !0,
+      qualifiedName: /(?:[\w\.\-]+:)?[\w\.\-]+/,
+      tokenizer: {
+        root: [
+          [/[^<&]+/, ''],
+          { include: '@whitespace' },
+          [/(<)(@qualifiedName)/, [{ token: 'delimiter' }, { token: 'tag', next: '@tag' }]],
+          [
+            /(<\/)(@qualifiedName)(\s*)(>)/,
+            [{ token: 'delimiter' }, { token: 'tag' }, '', { token: 'delimiter' }],
+          ],
+          [/(<\?)(@qualifiedName)/, [{ token: 'delimiter' }, { token: 'metatag', next: '@tag' }]],
+          [/(<\!)(@qualifiedName)/, [{ token: 'delimiter' }, { token: 'metatag', next: '@tag' }]],
+          [/<\!\[CDATA\[/, { token: 'delimiter.cdata', next: '@cdata' }],
+          [/&\w+;/, 'string.escape'],
+        ],
+        cdata: [[/[^\]]+/, ''], [/\]\]>/, { token: 'delimiter.cdata', next: '@pop' }], [/\]/, '']],
+        tag: [
+          [/[ \t\r\n]+/, ''],
+          [/(@qualifiedName)(\s*=\s*)("[^"]*"|'[^']*')/, ['attribute.name', '', 'attribute.value']],
+          [
+            /(@qualifiedName)(\s*=\s*)("[^">?\/]*|'[^'>?\/]*)(?=[\?\/]\>)/,
+            ['attribute.name', '', 'attribute.value'],
+          ],
+          [/(@qualifiedName)(\s*=\s*)("[^">]*|'[^'>]*)/, ['attribute.name', '', 'attribute.value']],
+          [/@qualifiedName/, 'attribute.name'],
+          [/\?>/, { token: 'delimiter', next: '@pop' }],
+          [/(\/)(>)/, [{ token: 'tag' }, { token: 'delimiter', next: '@pop' }]],
+          [/>/, { token: 'delimiter', next: '@pop' }],
+        ],
+        whitespace: [[/[ \t\r\n]+/, ''], [/<!--/, { token: 'comment', next: '@comment' }]],
+        comment: [
+          [/[^<\-]+/, 'comment.content'],
+          [/-->/, { token: 'comment', next: '@pop' }],
+          [/<!--/, 'comment.content.invalid'],
+          [/[<\-]/, 'comment.content'],
+        ],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/basic-languages/src/yaml.js

@@ -0,0 +1,126 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-languages version: 0.9.0(e162b4ba29044167bc7181c42b3270fa8a467424)
+ * Released under the MIT license
+ * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
+ *-----------------------------------------------------------------------------*/
+define('vs/basic-languages/src/yaml', ['require', 'exports'], function(e, n) {
+  'use strict';
+  Object.defineProperty(n, '__esModule', { value: !0 }),
+    (n.conf = {
+      comments: { lineComment: '#' },
+      brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+      autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+      surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+      ],
+    }),
+    (n.language = {
+      tokenPostfix: '.yaml',
+      brackets: [
+        { token: 'delimiter.bracket', open: '{', close: '}' },
+        { token: 'delimiter.square', open: '[', close: ']' },
+      ],
+      keywords: ['true', 'True', 'TRUE', 'false', 'False', 'FALSE', 'null', 'Null', 'Null', '~'],
+      numberInteger: /(?:0|[+-]?[0-9]+)/,
+      numberFloat: /(?:0|[+-]?[0-9]+)(?:\.[0-9]+)?(?:e[-+][1-9][0-9]*)?/,
+      numberOctal: /0o[0-7]+/,
+      numberHex: /0x[0-9a-fA-F]+/,
+      numberInfinity: /[+-]?\.(?:inf|Inf|INF)/,
+      numberNaN: /\.(?:nan|Nan|NAN)/,
+      numberDate: /\d{4}-\d\d-\d\d([Tt ]\d\d:\d\d:\d\d(\.\d+)?(( ?[+-]\d\d?(:\d\d)?)|Z)?)?/,
+      escapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
+      tokenizer: {
+        root: [
+          { include: '@whitespace' },
+          { include: '@comment' },
+          [/%[^ ]+.*$/, 'meta.directive'],
+          [/---/, 'operators.directivesEnd'],
+          [/\.{3}/, 'operators.documentEnd'],
+          [/[-?:](?= )/, 'operators'],
+          { include: '@anchor' },
+          { include: '@tagHandle' },
+          { include: '@flowCollections' },
+          { include: '@blockStyle' },
+          [/@numberInteger(?![ \t]*\S+)/, 'number'],
+          [/@numberFloat(?![ \t]*\S+)/, 'number.float'],
+          [/@numberOctal(?![ \t]*\S+)/, 'number.octal'],
+          [/@numberHex(?![ \t]*\S+)/, 'number.hex'],
+          [/@numberInfinity(?![ \t]*\S+)/, 'number.infinity'],
+          [/@numberNaN(?![ \t]*\S+)/, 'number.nan'],
+          [/@numberDate(?![ \t]*\S+)/, 'number.date'],
+          [/(".*?"|'.*?'|.*?)([ \t]*)(:)( |$)/, ['type', 'white', 'operators', 'white']],
+          { include: '@flowScalars' },
+          [/.+$/, { cases: { '@keywords': 'keyword', '@default': 'string' } }],
+        ],
+        object: [
+          { include: '@whitespace' },
+          { include: '@comment' },
+          [/\}/, '@brackets', '@pop'],
+          [/,/, 'delimiter.comma'],
+          [/:(?= )/, 'operators'],
+          [/(?:".*?"|'.*?'|[^,\{\[]+?)(?=: )/, 'type'],
+          { include: '@flowCollections' },
+          { include: '@flowScalars' },
+          { include: '@tagHandle' },
+          { include: '@anchor' },
+          { include: '@flowNumber' },
+          [/[^\},]+/, { cases: { '@keywords': 'keyword', '@default': 'string' } }],
+        ],
+        array: [
+          { include: '@whitespace' },
+          { include: '@comment' },
+          [/\]/, '@brackets', '@pop'],
+          [/,/, 'delimiter.comma'],
+          { include: '@flowCollections' },
+          { include: '@flowScalars' },
+          { include: '@tagHandle' },
+          { include: '@anchor' },
+          { include: '@flowNumber' },
+          [/[^\],]+/, { cases: { '@keywords': 'keyword', '@default': 'string' } }],
+        ],
+        string: [
+          [/[^\\"']+/, 'string'],
+          [/@escapes/, 'string.escape'],
+          [/\\./, 'string.escape.invalid'],
+          [
+            /["']/,
+            { cases: { '$#==$S2': { token: 'string', next: '@pop' }, '@default': 'string' } },
+          ],
+        ],
+        multiString: [[/^( +).+$/, 'string', '@multiStringContinued.$1']],
+        multiStringContinued: [
+          [
+            /^( *).+$/,
+            { cases: { '$1==$S2': 'string', '@default': { token: '@rematch', next: '@popall' } } },
+          ],
+        ],
+        whitespace: [[/[ \t\r\n]+/, 'white']],
+        comment: [[/#.*$/, 'comment']],
+        flowCollections: [[/\[/, '@brackets', '@array'], [/\{/, '@brackets', '@object']],
+        flowScalars: [[/"/, 'string', '@string."'], [/'/, 'string', "@string.'"]],
+        blockStyle: [[/[>|][0-9]*[+-]?$/, 'operators', '@multiString']],
+        flowNumber: [
+          [/@numberInteger(?=[ \t]*[,\]\}])/, 'number'],
+          [/@numberFloat(?=[ \t]*[,\]\}])/, 'number.float'],
+          [/@numberOctal(?=[ \t]*[,\]\}])/, 'number.octal'],
+          [/@numberHex(?=[ \t]*[,\]\}])/, 'number.hex'],
+          [/@numberInfinity(?=[ \t]*[,\]\}])/, 'number.infinity'],
+          [/@numberNaN(?=[ \t]*[,\]\}])/, 'number.nan'],
+          [/@numberDate(?=[ \t]*[,\]\}])/, 'number.date'],
+        ],
+        tagHandle: [[/\![^ ]*/, 'tag']],
+        anchor: [[/[&*][^ ]+/, 'namespace']],
+      },
+    });
+});

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.de.js

@@ -0,0 +1,539 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.de', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (erneut aufgetreten)'],
+  'vs/base/browser/ui/findinput/findInput': ['Eingabe'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    'Groß-/Kleinschreibung beachten',
+    'Nur ganzes Wort suchen',
+    'Regulären Ausdruck verwenden',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['Fehler: {0}', 'Warnung: {0}', 'Info: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'STRG',
+    'UMSCHALTTASTE',
+    'ALT',
+    'Windows',
+    'STRG',
+    'UMSCHALTTASTE',
+    'ALT',
+    'Befehlstaste',
+    'STRG',
+    'UMSCHALTTASTE',
+    'ALT',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['Fehler', 'Warnung', 'Info'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}, Auswahl', 'Auswahl'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    'Schnellauswahl. Nehmen Sie eine Eingabe vor, um die Ergebnisse einzugrenzen.',
+    'Schnellauswahl',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['Zuklappen'],
+  'vs/editor/browser/widget/diffEditorWidget': [
+    'Kann die Dateien nicht vergleichen, da eine Datei zu groß ist.',
+  ],
+  'vs/editor/browser/widget/diffReview': [
+    'Schließen',
+    'Unterschied von {0} zu {1}: Original {2}, {3} Zeilen, Geändert {4}, {5} Zeilen',
+    'leer',
+    'Original {0}, geändert {1}: {2}',
+    '+ geändert {0}: {1}',
+    '- Original {0}: {1}',
+    'Zum nächsten Unterschied wechseln',
+    'Zum vorherigen Unterschied wechseln',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    'Editor',
+    'Steuert die Schriftfamilie.',
+    'Steuert die Schriftbreite.',
+    'Steuert den Schriftgrad in Pixeln.',
+    'Steuert die Zeilenhöhe. Verwenden Sie 0, um LineHeight aus der FontSize-Angabe zu berechnen.',
+    'Steuert den Zeichenabstand in Pixeln.',
+    'Steuert die Anzeige von Zeilennummern. Mögliche Werte sind "Ein", "Aus" und "Relativ". "Relativ" zeigt die Zeilenanzahl ab der aktuellen Cursorposition.',
+    'Spalten, an denen vertikale Lineale angezeigt werden sollen',
+    'Zeichen, die als Worttrennzeichen verwendet werden, wenn wortbezogene Navigationen oder Vorgänge ausgeführt werden.',
+    'Die Anzahl der Leerzeichen, denen ein Tabstopp entspricht. Diese Einstellung wird basierend auf dem Inhalt der Datei überschrieben, wenn "editor.detectIndentation" aktiviert ist.',
+    '"number" wurde erwartet. Beachten Sie, dass der Wert "auto" durch die Einstellung "editor.detectIndentation" ersetzt wurde.',
+    'Fügt beim Drücken der TAB-TASTE Leerzeichen ein. Diese Einstellung wird basierend auf dem Inhalt der Datei überschrieben, wenn "editor.detectIndentation" aktiviert ist.',
+    '"boolean" wurde erwartet. Beachten Sie, dass der Wert "auto" durch die Einstellung "editor.detectIndentation" ersetzt wurde.',
+    'Beim Öffnen einer Datei werden "editor.tabSize" und "editor.insertSpaces" basierend auf den Dateiinhalten erkannt.',
+    'Steuert, ob die Auswahl runde Ecken aufweist.',
+    'Legt fest, ob der Editor Bildläufe über die letzte Zeile hinaus ausführt.',
+    'Steuert, ob die Minikarte angezeigt wird',
+    'Steuert, ob der Minimap-Schieberegler automatisch ausgeblendet wird.',
+    'Die tatsächlichen Zeichen in einer Zeile rendern (im Gegensatz zu Farbblöcken)',
+    'Breite der Minikarte beschränken, um höchstens eine bestimmte Anzahl von Spalten zu rendern',
+    'Steuert, ob wir für die Suchzeichenfolge im Suchwidget aus der Editorauswahl ein Seeding ausführen.',
+    'Steuert, ob die Kennzeichnung "In Auswahl suchen" aktiviert ist, wenn mehrere Zeichen oder Textzeilen im Editor ausgewählt wurden.',
+    'Zeilenumbrüche erfolgen nie.',
+    'Der Zeilenumbruch erfolgt an der Breite des Anzeigebereichs.',
+    'Der Zeilenbereich erfolgt bei "editor.wordWrapColumn".',
+    'Der Zeilenumbruch erfolgt beim Mindestanzeigebereich und "editor.wordWrapColumn".',
+    'Steuert den Zeilenumbruch. Mögliche Einstellungen sind:\n - "off" (Umbruch deaktivieren),\n - "on" (Anzeigebereichsumbruch),\n - "wordWrapColumn" (Umbruch bei "editor.wordWrapColumn") oder\n - "bounded" (der Zeilenumbruch erfolgt beim Mindestanzeigebereich und "editor.wordWrapColumn").',
+    'Steuert die Umbruchspalte des Editors, wenn für "editor.wordWrap" die Option "wordWrapColumn" oder "bounded" festgelegt ist.',
+    'Steuert den Einzug der umbrochenen Zeilen. Der Wert kann "none", "same" oder "indent" sein.',
+    'Ein Multiplikator, der für die Mausrad-Bildlaufereignisse "deltaX" und "deltaY" verwendet werden soll.',
+    'Ist unter Windows und Linux der Taste "STRG" und unter OSX der Befehlstaste zugeordnet.',
+    'Ist unter Windows und Linux der Taste "Alt" und unter OSX der Wahltaste zugeordnet. ',
+    'Der Modifizierer, der zum Hinzufügen mehrerer Cursor mit der Maus verwendet wird. "ctrlCmd" wird unter Windows und Linux der Taste "STRG" und unter OSX der Befehlstaste zugeordnet. Die Mausbewegungen "Gehe zu Definition" und "Link öffnen" werden so angepasst, dass kein Konflikt mit dem Multi-Cursor-Modifizierer entsteht.',
+    'Schnellvorschläge innerhalb von Zeichenfolgen aktivieren.',
+    'Schnellvorschläge innerhalb von Kommentaren aktivieren.',
+    'Schnellvorschläge außerhalb von Zeichenfolgen und Kommentaren aktivieren.',
+    'Steuert, ob Vorschläge während der Eingabe automatisch angezeigt werden sollen.',
+    'Steuert die Verzögerung in ms für die Anzeige der Schnellvorschläge.',
+    'Aktiviert ein Pop-Up, das Parameter-Dokumentation und Typ-Information während des Tippens anzeigt',
+    'Steuert, ob der Editor Klammern automatisch nach dem Öffnen schließt.',
+    'Steuert, ob der Editor Zeilen automatisch nach der Eingabe formatiert.',
+    'Steuert, ob der Editor den eingefügten Inhalt automatisch formatiert.',
+    'Steuert, ob der Editor die Einzüge automatisch anpasst, wenn Benutzer Text eingeben oder Zeilen einfügen oder verschieben. Einzugsregeln der Sprache müssen verfügbar sein. ',
+    'Steuert, ob Vorschläge automatisch bei der Eingabe von Triggerzeichen angezeigt werden.',
+    'Steuert, ob Vorschläge über die Eingabetaste (zusätzlich zur TAB-Taste) angenommen werden sollen. Vermeidet Mehrdeutigkeit zwischen dem Einfügen neuer Zeilen oder dem Annehmen von Vorschlägen. Der Wert "smart" bedeutet, dass ein Vorschlag nur über die Eingabetaste akzeptiert wird, wenn eine Textänderung vorgenommen wird.',
+    'Steuert, ob Vorschläge über Commitzeichen angenommen werden sollen. In JavaScript kann ein Semikolon (";") beispielsweise ein Commitzeichen sein, das einen Vorschlag annimmt und dieses Zeichen eingibt.',
+    'Zeige Snippet Vorschläge über den anderen Vorschlägen.',
+    'Snippet Vorschläge unter anderen Vorschlägen anzeigen.',
+    'Zeige Snippet Vorschläge mit anderen Vorschlägen.',
+    'Snippet Vorschläge nicht anzeigen.',
+    'Steuert, ob Codeausschnitte mit anderen Vorschlägen angezeigt und wie diese sortiert werden.',
+    'Steuert, ob ein Kopiervorgang ohne Auswahl die aktuelle Zeile kopiert.',
+    'Steuert, ob Vervollständigungen auf Grundlage der Wörter im Dokument berechnet werden sollen.',
+    'Schriftgröße für Vorschlagswidget',
+    'Zeilenhöhe für Vorschlagswidget',
+    'Steuert, ob der Editor der Auswahl ähnelnde Übereinstimmungen hervorheben soll.',
+    'Steuert, ob der Editor das Vorkommen semantischer Symbole markieren soll.',
+    'Steuert die Anzahl von Dekorationen, die an derselben Position im Übersichtslineal angezeigt werden.',
+    'Steuert, ob um das Übersichtslineal ein Rahmen gezeichnet werden soll.',
+    'Steuert den Cursoranimationsstil. Gültige Werte sind "blink", "smooth", "phase", "expand" und "solid".',
+    'Schriftart des Editors vergrößern, wenn das Mausrad verwendet und die STRG-TASTE gedrückt wird',
+    'Steuert den Cursorstil. Gültige Werte sind  "block", "block-outline", "line", "line-thin", "underline" und "underline-thin".',
+    'Aktiviert Schriftartligaturen.',
+    'Steuert die Sichtbarkeit des Cursors im Übersichtslineal.',
+    'Steuert, wie der Editor Leerzeichen rendert. Mögliche Optionen: "none", "boundary" und "all". Die Option "boundary" rendert keine einzelnen Leerzeichen zwischen Wörtern.',
+    'Steuert, ob der Editor Steuerzeichen rendern soll.',
+    'Steuert, ob der Editor Einzugsführungslinien rendern soll.',
+    'Steuert, wie der Editor die aktuelle Zeilenhervorhebung rendern soll. Mögliche Werte sind "none", "gutter", "line" und "all".',
+    'Steuert, ob der Editor CodeLenses anzeigt.',
+    'Steuert, ob für den Editor Codefaltung aktiviert ist.',
+    'Steuert, ob die Falt-Steuerelemente an der Leiste automatisch ausgeblendet werden.',
+    'Übereinstimmende Klammern hervorheben, wenn eine davon ausgewählt wird.',
+    'Steuert, ob der Editor den vertikalen Glyphenrand rendert. Der Glyphenrand wird hauptsächlich zum Debuggen verwendet.',
+    'Das Einfügen und Löschen von Leerzeichen folgt auf Tabstopps.',
+    'Nachfolgendes automatisch eingefügtes Leerzeichen entfernen',
+    'Peek-Editoren geöffnet lassen, auch wenn auf ihren Inhalt doppelgeklickt oder die ESC-TASTE gedrückt wird.',
+    'Steuert, ob der Editor das Verschieben einer Auswahl per Drag and Drop zulässt.',
+    'Der Editor verwendet Plattform-APIs, um zu erkennen, wenn eine Sprachausgabe angefügt wird.',
+    'Der Editor wird durchgehend für die Verwendung mit einer Sprachausgabe optimiert.',
+    'Der Editor wird nie für die Verwendung mit einer Sprachausgabe optimiert. ',
+    'Steuert, ob der Editor in einem Modus ausgeführt werden soll, in dem er für die Sprachausgabe optimiert wird.',
+    'Steuert, ob der Editor Links erkennen und anklickbar machen soll',
+    'Steuert, ob der Diff-Editor das Diff nebeneinander oder inline anzeigt.',
+    'Steuert, ob der Diff-Editor Änderungen in führenden oder nachgestellten Leerzeichen als Diffs anzeigt.',
+    'Steuert, ob der Diff-Editor die Indikatoren "+" und "-" für hinzugefügte/entfernte Änderungen anzeigt.',
+    'Steuert, ob die primäre Linux-Zwischenablage unterstützt werden soll.',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    'Der Editor ist zurzeit nicht verfügbar. Drücken Sie Alt+F1 für Optionen.',
+    'Editor-Inhalt',
+  ],
+  'vs/editor/common/controller/cursor': ['Unerwartete Ausnahme beim Ausführen des Befehls.'],
+  'vs/editor/common/model/textModelWithTokens': [
+    'Fehler des Modus bei der Tokenumwandlung der Eingabe.',
+  ],
+  'vs/editor/common/modes/modesRegistry': ['Nur-Text'],
+  'vs/editor/common/services/bulkEdit': [
+    'Die folgenden Dateien wurden in der Zwischenzeit geändert: {0}',
+    'Keine Änderungen vorgenommen',
+    '{0} Änderungen am Text in {1} Dateien vorgenommen',
+    '{0} Änderungen am Text in einer Datei vorgenommen',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    'Hintergrundfarbe zur Hervorhebung der Zeile an der Cursorposition.',
+    'Hintergrundfarbe für den Rahmen um die Zeile an der Cursorposition.',
+    'Hintergrundfarbe hervorgehobener Bereiche (beispielsweise durch Features wie Quick Open und Suche).',
+    'Farbe des Cursors im Editor.',
+    'Hintergrundfarbe vom Editor-Cursor. Erlaubt die Anpassung der Farbe von einem Zeichen, welches von einem Block-Cursor überdeckt wird.',
+    'Farbe der Leerzeichen im Editor.',
+    'Farbe der Führungslinien für Einzüge im Editor.',
+    'Zeilennummernfarbe im Editor.',
+    'Farbe des Editor-Lineals.',
+    'Vordergrundfarbe der CodeLens-Links im Editor',
+    'Hintergrundfarbe für zusammengehörige Klammern',
+    'Farbe für zusammengehörige Klammern',
+    'Farbe des Rahmens für das Übersicht-Lineal.',
+    'Hintergrundfarbe der Editorleiste. Die Leiste enthält die Glyphenränder und die Zeilennummern.',
+    'Vordergrundfarbe von Fehlerunterstreichungen im Editor.',
+    'Rahmenfarbe von Fehlerunterstreichungen im Editor.',
+    'Vordergrundfarbe von Warnungsunterstreichungen im Editor.',
+    'Rahmenfarbe von Warnungsunterstreichungen im Editor.',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['Gehe zu Klammer'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    'Caretzeichen nach links verschieben',
+    'Caretzeichen nach rechts verschieben',
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['Buchstaben austauschen'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    'Ausschneiden',
+    'Kopieren',
+    'Einfügen',
+    'Mit Syntaxhervorhebung kopieren',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    'Zeilenkommentar umschalten',
+    'Zeilenkommentar hinzufügen',
+    'Zeilenkommentar entfernen',
+    'Blockkommentar umschalten',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['Editor-Kontextmenü anzeigen'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    'Suchen',
+    'Suchen',
+    'Vorherige Übereinstimmung',
+    'Nächste Übereinstimmung',
+    'In Auswahl suchen',
+    'Schließen',
+    'Ersetzen',
+    'Ersetzen',
+    'Ersetzen',
+    'Alle ersetzen',
+    'Ersetzen-Modus wechseln',
+    'Nur die ersten 999 Ergebnisse werden hervorgehoben, alle Suchvorgänge beziehen sich aber auf den gesamten Text.',
+    '{0} von {1}',
+    'Keine Ergebnisse',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    'Suchen',
+    'Nächstes Element suchen',
+    'Vorheriges Element suchen',
+    'Nächste Auswahl suchen',
+    'Vorherige Auswahl suchen',
+    'Ersetzen',
+    'Auswahl zur nächsten Übereinstimmungssuche hinzufügen',
+    'Letzte Auswahl zu vorheriger Übereinstimmungssuche hinzufügen',
+    'Letzte Auswahl in nächste Übereinstimmungssuche verschieben',
+    'Letzte Auswahl in vorherige Übereinstimmungssuche verschieben',
+    'Alle Vorkommen auswählen und Übereinstimmung suchen',
+    'Alle Vorkommen ändern',
+    'Nächsten Suchbegriff anzeigen',
+    'Vorherigen Suchbegriff anzeigen',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    'Auffalten',
+    'Faltung rekursiv aufheben',
+    'Falten',
+    'Rekursiv falten',
+    'Alle falten',
+    'Alle auffalten',
+    'Faltebene {0}',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    '1 Formatierung in Zeile {0} vorgenommen',
+    '{0} Formatierungen in Zeile {1} vorgenommen',
+    '1 Formatierung zwischen Zeilen {0} und {1} vorgenommen',
+    '{0} Formatierungen zwischen Zeilen {1} und {2} vorgenommen',
+    'Format Document',
+    'Format Selection',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    'Keine Definition gefunden für "{0}".',
+    'Keine Definition gefunden',
+    ' – {0} Definitionen',
+    'Gehe zu Definition',
+    'Definition an der Seite öffnen',
+    'Peek-Definition',
+    'Keine Implementierung gefunden für "{0}"',
+    'Keine Implementierung gefunden',
+    '{0} Implementierungen',
+    'Zur Implementierung wechseln',
+    'Vorschau der Implementierung anzeigen',
+    'Keine Typendefinition gefunden für "{0}"',
+    'Keine Typendefinition gefunden',
+    '{0} Typdefinitionen',
+    'Zur Typdefinition wechseln',
+    'Vorschau der Typdefinition anzeigen',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    'Klicken Sie, um {0} Definitionen anzuzeigen.',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    'Gehe zum nächsten Fehler oder zur nächsten Warnung',
+    'Gehe zum vorherigen Fehler oder zur vorherigen Warnung',
+    'Editormarkierung: Farbe bei Fehler des Navigationswidgets.',
+    'Editormarkierung: Farbe bei Warnung des Navigationswidgets.',
+    'Editormarkierung: Hintergrund des Navigationswidgets.',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['Hovern anzeigen'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['Wird geladen...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': [
+    'Durch vorherigen Wert ersetzen',
+    'Durch nächsten Wert ersetzen',
+  ],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    'Zeile nach oben kopieren',
+    'Zeile nach unten kopieren',
+    'Zeile nach oben verschieben',
+    'Zeile nach unten verschieben',
+    'Zeilen aufsteigend sortieren',
+    'Zeilen absteigend sortieren',
+    'Nachgestelltes Leerzeichen kürzen',
+    'Zeile löschen',
+    'Zeileneinzug',
+    'Zeile ausrücken',
+    'Zeile oben einfügen',
+    'Zeile unten einfügen',
+    'Alle übrigen löschen',
+    'Alle rechts löschen',
+    'Zeilen verknüpfen',
+    'Zeichen um den Cursor herum transponieren',
+    'In Großbuchstaben umwandeln',
+    'In Kleinbuchstaben umwandeln',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'BEFEHLSTASTE + Mausklick zum Aufrufen des Links',
+    'STRG + Mausklick zum Aufrufen des Links',
+    'Cmd + Klick um Befehl auszuführen',
+    'Ctrl + Klick um Befehl auszuführen.',
+    'ALT + Mausklick zum Aufrufen des Links',
+    'Alt + Klick um Befehl auszuführen.',
+    'Fehler beim Öffnen dieses Links, weil er nicht wohlgeformt ist: {0}',
+    'Fehler beim Öffnen dieses Links, weil das Ziel fehlt.',
+    'Link öffnen',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    'Cursor oberhalb hinzufügen',
+    'Cursor unterhalb hinzufügen',
+    'Cursor an Zeilenenden hinzufügen',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['Parameterhinweise auslösen'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}, Hinweis'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    'Korrekturen anzeigen ({0})',
+    'Korrekturen anzeigen',
+    'Schnelle Problembehebung',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [
+    ' – {0} Verweise',
+    'Alle Verweise suchen',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['Wird geladen...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    'Symbol in {0} in Zeile {1}, Spalte {2}',
+    '1 Symbol in {0}, vollständiger Pfad {1}',
+    '{0} Symbole in {1}, vollständiger Pfad {2}',
+    'Es wurden keine Ergebnisse gefunden.',
+    '1 Symbol in {0} gefunden',
+    '{0} Symbole in {1} gefunden',
+    '{0} Symbole in {1} Dateien gefunden',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    'Fehler beim Auflösen der Datei.',
+    '{0} Verweise',
+    '{0} Verweis',
+    'Keine Vorschau verfügbar.',
+    'Verweise',
+    'Keine Ergebnisse',
+    'Verweise',
+    'Hintergrundfarbe des Titelbereichs der Peek-Ansicht.',
+    'Farbe des Titels in der Peek-Ansicht.',
+    'Farbe der Titelinformationen in der Peek-Ansicht.',
+    'Farbe der Peek-Ansichtsränder und des Pfeils.',
+    'Hintergrundfarbe der Ergebnisliste in der Peek-Ansicht.',
+    'Vordergrundfarbe für Zeilenknoten in der Ergebnisliste der Peek-Ansicht.',
+    'Vordergrundfarbe für Dateiknoten in der Ergebnisliste der Peek-Ansicht.',
+    'Hintergrundfarbe des ausgewählten Eintrags in der Ergebnisliste der Peek-Ansicht.',
+    'Vordergrundfarbe des ausgewählten Eintrags in der Ergebnisliste der Peek-Ansicht.',
+    'Hintergrundfarbe des Peek-Editors.',
+    'Hintergrundfarbe der Leiste im Peek-Editor.',
+    'Farbe für Übereinstimmungsmarkierungen in der Ergebnisliste der Peek-Ansicht.',
+    'Farbe für Übereinstimmungsmarkierungen im Peek-Editor.',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    'Kein Ergebnis.',
+    '"{0}" erfolgreich in "{1}" umbenannt. Zusammenfassung: {2}',
+    'Fehler bei der Ausführung der Umbenennung.',
+    'Symbol umbenennen',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    'Benennen Sie die Eingabe um. Geben Sie einen neuen Namen ein, und drücken Sie die EINGABETASTE, um den Commit auszuführen.',
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['Auswahl erweitern', 'Auswahl verkleinern'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    'Durch Annahme von "{0}" wurde folgender Text eingefügt: {1}',
+    'Vorschlag auslösen',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    'Hintergrundfarbe des Vorschlagswidgets.',
+    'Rahmenfarbe des Vorschlagswidgets.',
+    'Vordergrundfarbe des Vorschlagswidgets.',
+    'Hintergrundfarbe des ausgewählten Eintrags im Vorschlagswidget.',
+    'Farbe der Trefferhervorhebung im Vorschlagswidget.',
+    'Mehr anzeigen...{0}',
+    '{0}, Vorschlag, hat Details',
+    '{0}, Vorschlag',
+    'Weniger anzeigen...{0}',
+    'Wird geladen...',
+    'Keine Vorschläge.',
+    '{0}, angenommen',
+    '{0}, Vorschlag, hat Details',
+    '{0}, Vorschlag',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': [
+    'TAB-Umschalttaste verschiebt Fokus',
+  ],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    'Hintergrundfarbe eines Symbols beim Lesezugriff (beispielsweise beim Lesen einer Variablen).',
+    'Hintergrundfarbe eines Symbols beim Schreibzugriff (beispielsweise beim Schreiben in eine Variable).',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['Schließen'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    'Standard-Konfiguration überschreibt',
+    'Zu überschreibende Einstellungen für Sprache {0} konfigurieren.',
+    'Zu überschreibende Editor-Einstellungen für eine Sprache konfigurieren.',
+    '"{0}" kann nicht registriert werden. Die Eigenschaft stimmt mit dem Eigenschaftsmuster \'\\\\[.*\\\\]$\' zum Beschreiben sprachspezifischer Editor-Einstellungen überein. Verwenden Sie den Beitrag "configurationDefaults".',
+    '"{0}" kann nicht registriert werden. Diese Eigenschaft ist bereits registriert.',
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    '({0}) wurde gedrückt. Es wird auf die zweite Taste der Kombination gewartet...',
+    'Die Tastenkombination ({0}, {1}) ist kein Befehl.',
+  ],
+  'vs/platform/message/common/message': ['Schließen', 'Später', 'Abbrechen'],
+  'vs/platform/theme/common/colorRegistry': [
+    'Ungültiges Farbformat. Verwenden Sie #RGB, #RGBA, #RRGGBB oder #RRGGBBAA.',
+    'In der Workbench verwendete Farben.',
+    'Allgemeine Vordergrundfarbe. Diese Farbe wird nur verwendet, wenn sie nicht durch eine Komponente überschrieben wird.',
+    'Allgemeine Vordergrundfarbe. Diese Farbe wird nur verwendet, wenn sie nicht durch eine Komponente überschrieben wird.',
+    'Vordergrundfarbe für Beschreibungstexte, die weitere Informationen anzeigen, z. B. für ein Label.',
+    'Allgemeine Rahmenfarbe für fokussierte Elemente. Diese Farbe wird nur verwendet, wenn sie nicht durch eine Komponente überschrieben wird.',
+    'Ein zusätzlicher Rahmen um Elemente, mit dem diese von anderen getrennt werden, um einen größeren Kontrast zu erreichen.',
+    'Ein zusätzlicher Rahmen um aktive Elemente, mit dem diese von anderen getrennt werden, um einen größeren Kontrast zu erreichen.',
+    'Hintergrundfarbe der Textauswahl in der Workbench (z. B. für Eingabefelder oder Textbereiche). Diese Farbe gilt nicht für die Auswahl im Editor. ',
+    'Farbe für Text-Trennzeichen.',
+    'Vordergrundfarbe für Links im Text.',
+    'Vordergrundfarbe für aktive Links im Text.',
+    'Vordergrundfarbe für vorformatierte Textsegmente.',
+    'Hintergrundfarbe für block quotes im Text.',
+    'Rahmenfarbe für block quotes im Text.',
+    'Hintergrundfarbe für Code-Blöcke im Text.',
+    'Schattenfarbe von Widgets wie zum Beispiel Suchen/Ersetzen innerhalb des Editors.',
+    'Hintergrund für Eingabefeld.',
+    'Vordergrund für Eingabefeld.',
+    'Rahmen für Eingabefeld.',
+    'Rahmenfarbe für aktivierte Optionen in Eingabefeldern.',
+    'Input box - Vordergrundfarbe für Platzhalter-Text.',
+    'Hintergrundfarbe bei der Eingabevalidierung für den Schweregrad der Information.',
+    'Rahmenfarbe bei der Eingabevalidierung für den Schweregrad der Information.',
+    'Hintergrundfarbe bei der Eingabevalidierung für eine Warnung zur Information.',
+    'Rahmenfarbe bei der Eingabevalidierung für den Schweregrad der Warnung.',
+    'Hintergrundfarbe bei der Eingabevalidierung für den Schweregrad des Fehlers.',
+    'Rahmenfarbe bei der Eingabevalidierung für den Schweregrad des Fehlers.',
+    'Hintergrund für Dropdown.',
+    'Vordergrund für Dropdown.',
+    'Rahmen für Dropdown.',
+    'Hintergrundfarbe der Liste/Struktur für das fokussierte Element, wenn die Liste/Struktur aktiv ist. Eine aktive Liste/Struktur hat Tastaturfokus, eine inaktive hingegen nicht.',
+    'Vordergrundfarbe der Liste/Struktur für das fokussierte Element, wenn die Liste/Struktur aktiv ist. Eine aktive Liste/Struktur hat Tastaturfokus, eine inaktive hingegen nicht.',
+    'Hintergrundfarbe der Liste/Struktur für das ausgewählte Element, wenn die Liste/Struktur aktiv ist. Eine aktive Liste/Struktur hat Tastaturfokus, eine inaktive hingegen nicht.',
+    'Vordergrundfarbe der Liste/Struktur für das ausgewählte Element, wenn die Liste/Struktur aktiv ist. Eine aktive Liste/Struktur hat Tastaturfokus, eine inaktive hingegen nicht.',
+    'Hintergrundfarbe der Liste/Struktur für das ausgewählte Element, wenn die Liste/Struktur inaktiv ist. Eine aktive Liste/Struktur hat Tastaturfokus, eine inaktive hingegen nicht.',
+    'Liste/Baumstruktur - Vordergrundfarbe für das ausgewählte Element, wenn die Liste/Baumstruktur inaktiv ist. Eine aktive Liste/Baumstruktur hat Tastaturfokus, eine inaktive hingegen nicht.',
+    'Hintergrundfarbe der Liste/Struktur für das ausgewählte Element, wenn die Liste/Struktur inaktiv ist. Eine aktive Liste/Struktur hat Tastaturfokus, eine inaktive hingegen nicht.',
+    'Liste/Baumstruktur - Vordergrundfarbe für das ausgewählte Element, wenn die Liste/Baumstruktur inaktiv ist. Eine aktive Liste/Baumstruktur hat Tastaturfokus, eine inaktive hingegen nicht.',
+    'Hintergrund der Liste/Struktur, wenn mit der Maus auf Elemente gezeigt wird.',
+    'Vordergrund der Liste/Struktur, wenn mit der Maus auf Elemente gezeigt wird.',
+    'Drag & Drop-Hintergrund der Liste/Struktur, wenn Elemente mithilfe der Maus verschoben werden.',
+    'Vordergrundfarbe der Liste/Struktur zur Trefferhervorhebung beim Suchen innerhalb der Liste/Struktur.',
+    'Schnellauswahlfarbe für das Gruppieren von Bezeichnungen.',
+    'Schnellauswahlfarbe für das Gruppieren von Rahmen.',
+    'Vordergrundfarbe der Schaltfläche.',
+    'Hintergrundfarbe der Schaltfläche.',
+    'Hintergrundfarbe der Schaltfläche, wenn darauf gezeigt wird.',
+    'Badge - Hintergrundfarbe. Badges sind kurze Info-Texte, z. B. für Anzahl Suchergebnisse.',
+    'Badge - Vordergrundfarbe. Badges sind kurze Info-Texte, z. B. für Anzahl Suchergebnisse.',
+    'Schatten der Scrollleiste, um anzuzeigen, dass die Ansicht gescrollt wird.',
+    'Hintergrundfarbe vom Scrollbar-Schieber',
+    'Hintergrundfarbe des Schiebereglers, wenn darauf gezeigt wird.',
+    'Hintergrundfarbe des Schiebereglers, wenn dieser aktiv ist.',
+    'Hintergrundfarbe des Fortschrittbalkens, der für lang ausgeführte Vorgänge angezeigt werden kann.',
+    'Hintergrundfarbe des Editors.',
+    'Standardvordergrundfarbe des Editors.',
+    'Hintergrundfarbe von Editor-Widgets wie zum Beispiel Suchen/Ersetzen.',
+    'Rahmenfarbe von Editorwigdets. Die Farbe wird nur verwendet, wenn für das Widget ein Rahmen verwendet wird und die Farbe nicht von einem Widget überschrieben wird.',
+    'Farbe der Editor-Auswahl.',
+    'Farbe des gewählten Text für einen hohen Kontrast',
+    'Farbe der Auswahl in einem inaktiven Editor.',
+    'Farbe für Bereiche, deren Inhalt der Auswahl entspricht.',
+    'Farbe des aktuellen Suchergebnisses.',
+    'Farbe der anderen Suchtreffer.',
+    'Farbe des Bereichs zur Einschränkung der Suche.',
+    'Hervorhebung eines Worts, unter dem ein Mauszeiger angezeigt wird.',
+    'Background color of the editor hover.',
+    'Rahmenfarbe des Editor-Mauszeigers.',
+    'Farbe der aktiven Links.',
+    'Hintergrundfarbe für eingefügten Text.',
+    'Hintergrundfarbe für entfernten Text.',
+    'Konturfarbe für eingefügten Text.',
+    'Konturfarbe für entfernten Text.',
+    'Aktueller Kopfzeilenhintergrund in Inline-Mergingkonflikten.',
+    'Aktueller Inhaltshintergrund in Inline-Mergingkonflikten.',
+    'Eingehender Kopfzeilenhintergrund in Inline-Mergingkonflikten. ',
+    'Eingehender Inhaltshintergrund in Inline-Mergingkonflikten.',
+    'Kopfzeilenhintergrund des gemeinsamen übergeordneten Elements bei Inlinezusammenführungskonflikten. ',
+    'Inhaltshintergrund des gemeinsamen übergeordneten Elements bei Inlinezusammenführungskonflikten.',
+    'Rahmenfarbe für Kopfzeilen und die Aufteilung in Inline-Mergingkonflikten.',
+    'Aktueller Übersichtslineal-Vordergrund für Inline-Mergingkonflikte.',
+    'Eingehender Übersichtslineal-Vordergrund für Inline-Mergingkonflikte. ',
+    'Hintergrund des Übersichtslineals des gemeinsamen übergeordneten Elements bei Inlinezusammenführungskonflikten.',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.de.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.es.js

@@ -0,0 +1,541 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.es', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (ocurrió de nuevo)'],
+  'vs/base/browser/ui/findinput/findInput': ['entrada'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    'Coincidir mayúsculas y minúsculas',
+    'Solo palabras completas',
+    'Usar expresión regular',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['Error: {0}', 'Advertencia: {0}', 'Información: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'Ctrl',
+    'Mayús',
+    'Alt',
+    'Windows',
+    'Control',
+    'Mayús',
+    'Alt',
+    'Comando',
+    'Control',
+    'Mayús',
+    'Alt',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['Error', 'Advertencia', 'Información'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}, selector', 'selector'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    'Selector rápido. Escriba para restringir los resultados.',
+    'Selector rápido',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['Contraer'],
+  'vs/editor/browser/widget/diffEditorWidget': [
+    'Los archivos no se pueden comparar porque uno de ellos es demasiado grande.',
+  ],
+  'vs/editor/browser/widget/diffReview': [
+    'Cerrar',
+    'Diferencia {0} de {1}: original {2}, {3} líneas, modificado {4}, {5} líneas',
+    'vacío',
+    'original {0}, modificado {1}: {2}',
+    '+ modificado {0}: {1}',
+    '- original {0}: {1}',
+    'Ir a la siguiente diferencia',
+    'Ir a la diferencia anterior',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    'Editor',
+    'Controla la familia de fuentes.',
+    'Controla el grosor de la fuente.',
+    'Controla el tamaño de fuente en píxeles.',
+    'Controla la altura de línea. Utilice 0 para calcular el valor de lineHeight a partir de fontSize.',
+    'Controla el espacio entre letras en pixels.',
+    'Controla la presentación de los números de línea. Los valores posibles son "on", "off" y "relative". "relative" muestra el número de líneas desde la posición actual del cursor.',
+    'Columnas en las que mostrar reglas verticales',
+    'Caracteres que se usarán como separadores de palabras al realizar operaciones o navegaciones relacionadas con palabras.',
+    'El número de espacios a los que equivale una tabulación. Este valor se invalida según el contenido del archivo cuando `editor.detectIndentation` está activado.',
+    'Se esperaba "number". Tenga en cuenta que el ajuste "editor.detectIndentation" ha reemplazado al valor "auto".',
+    'Insertar espacios al presionar TAB. Este valor se invalida en función del contenido del archivo cuando "editor.detectIndentation" está activado.',
+    'Se esperaba "boolean". Tenga en cuenta que el ajuste "editor.detectIndentation" ha reemplazado al valor "auto".',
+    'Al abrir un archivo, se detectarán `editor.tabSize` y `editor.insertSpaces` en función del contenido del archivo.',
+    'Controla si las selecciones tienen esquinas redondeadas',
+    'Controla si el editor se seguirá desplazando después de la última línea',
+    'Controla si se muestra el minimapa',
+    'Controla si el control deslizante del minimapa es ocultado automáticamente.',
+    'Presentar los caracteres reales en una línea (por oposición a bloques de color)',
+    'Limitar el ancho del minimapa para presentar como mucho un número de columnas determinado',
+    'Controla si se inicializa la cadena de búsqueda en Buscar widget en la selección del editor',
+    'Controla si el indicador Buscar en selección se activa cuando se seleccionan varios caracteres o líneas de texto en el editor',
+    'Las líneas no se ajustarán nunca.',
+    'Las líneas se ajustarán en el ancho de la ventanilla.',
+    'Las líneas se ajustarán en "editor.wordWrapColumn".',
+    'Las líneas se ajustarán al valor que sea inferior: el tamaño de la ventanilla o el valor de "editor.wordWrapColumn".',
+    'Controla cómo se deben ajustar las líneas. Pueden ser:\n - "off" (deshabilitar ajuste),\n - "on" (ajuste de ventanilla),\n - "wordWrapColumn" (ajustar en "editor.wordWrapColumn") o\n - "bounded" (ajustar en la parte mínima de la ventanilla y "editor.wordWrapColumn").',
+    "Controls the wrapping column of the editor when `editor.wordWrap` is 'wordWrapColumn' or 'bounded'.",
+    "Controla el sangrado de las líneas ajustadas. Puede ser uno los valores 'none', 'same' o 'indent'.",
+    'Se utilizará un multiplicador en los eventos de desplazamiento de la rueda del mouse `deltaX` y `deltaY`',
+    'Se asigna a "Control" en Windows y Linux y a "Comando" en OSX.',
+    'Se asigna a "Alt" en Windows y Linux y a "Opción" en OSX.',
+    'El modificador que se usará para agregar varios cursores con el mouse. "ctrlCmd" se asigna a "Control" en Windows y Linux y a "Comando" en OSX. Los gestos del mouse Ir a la definición y Abrir vínculo se adaptarán de modo que no entren en conflicto con el modificador multicursor.',
+    'Habilita sugerencias rápidas en las cadenas.',
+    'Habilita sugerencias rápidas en los comentarios.',
+    'Habilita sugerencias rápidas fuera de las cadenas y los comentarios.',
+    'Controla si las sugerencias deben mostrarse automáticamente mientras se escribe',
+    'Controla el retardo en ms tras el cual aparecerán sugerencias rápidas',
+    'Habilita el desplegable que muestra documentación de los parámetros e información de los tipos mientras escribe',
+    'Controla si el editor debe cerrar automáticamente los corchetes después de abrirlos',
+    'Controla si el editor debe dar formato automáticamente a la línea después de escribirla',
+    'Controla si el editor debe formatear automáticamente el contenido pegado. Debe haber disponible un formateador capaz de aplicar formato a un intervalo dentro de un documento.',
+    'Controla si el editor debería ajustar automáticamente la sangría cuando los usuarios escriben, pegan o mueven líneas. Las reglas de sangría del idioma deben estar disponibles.',
+    'Controla si las sugerencias deben aparecer de forma automática al escribir caracteres desencadenadores',
+    'Controla si las sugerencias deben aceptarse en "Entrar" (además de "TAB"). Ayuda a evitar la ambigüedad entre insertar nuevas líneas o aceptar sugerencias. El valor "smart" significa que solo se acepta una sugerencia con Entrar cuando se realiza un cambio textual.',
+    'Controla si se deben aceptar sugerencias en los caracteres de confirmación. Por ejemplo, en Javascript, el punto y coma (";") puede ser un carácter de confirmación que acepta una sugerencia y escribe ese carácter.',
+    'Mostrar sugerencias de fragmentos de código por encima de otras sugerencias.',
+    'Mostrar sugerencias de fragmentos de código por debajo de otras sugerencias.',
+    'Mostrar sugerencias de fragmentos de código con otras sugerencias.',
+    'No mostrar sugerencias de fragmentos de código.',
+    'Controla si se muestran los fragmentos de código con otras sugerencias y cómo se ordenan.',
+    'Controla si al copiar sin selección se copia la línea actual.',
+    'Habilita sugerencias basadas en palabras.',
+    'Tamaño de fuente para el widget de sugerencias',
+    'Alto de línea para el widget de sugerencias',
+    'Controla si el editor debería destacar coincidencias similares a la selección',
+    'Controla si el editor debe resaltar los símbolos semánticos.',
+    'Controla el número de decoraciones que pueden aparecer en la misma posición en la regla de visión general',
+    'Controla si debe dibujarse un borde alrededor de la regla de información general.',
+    'Controlar el estilo de animación del cursor. Los valores posibles son "blink", "smooth", "phase", "expand" y "solid".',
+    'Ampliar la fuente del editor cuando se use la rueda del mouse mientras se presiona Ctrl',
+    'Controla el estilo del cursor. Los valores aceptados son "block", "block-outline", "line", "line-thin", "underline" y "underline-thin"',
+    'Habilita las ligaduras tipográficas.',
+    'Controla si el cursor debe ocultarse en la regla de visión general.',
+    'Controla cómo debe representar el editor los espacios en blanco. Las posibilidades son "none", "boundary" y "all". La opción "boundary" no representa los espacios individuales entre palabras.',
+    'Controla si el editor debe representar caracteres de control',
+    'Controla si el editor debe representar guías de sangría.',
+    'Controla cómo el editor debe presentar el resaltado de línea. Las posibilidades son "ninguno", "margen", "línea" y "todo".',
+    'Controla si el editor muestra lentes de código',
+    'Controla si el editor tiene habilitado el plegado de código.',
+    'Controla cuándo los controles de plegado del margen son ocultados automáticamente.',
+    'Resaltar corchetes coincidentes cuando se seleccione uno de ellos.',
+    'Controla si el editor debe representar el margen de glifo vertical. El margen de glifo se usa, principalmente, para depuración.',
+    'La inserción y eliminación del espacio en blanco sigue a las tabulaciones.',
+    'Quitar espacio en blanco final autoinsertado',
+    'Mantiene abierto el editor interactivo incluso al hacer doble clic en su contenido o presionar Escape.',
+    'Controla si el editor debe permitir mover selecciones mediante arrastrar y colocar.',
+    'El editor usará API de plataforma para detectar cuándo está conectado un lector de pantalla.',
+    'El editor se optimizará de forma permanente para su uso con un editor de pantalla.',
+    'El editor nunca se optimizará para su uso con un lector de pantalla.',
+    'Controla si el editor se debe ejecutar en un modo optimizado para lectores de pantalla.',
+    'Controla si el editor debe detectar enlaces y hacerlos cliqueables',
+    'Controla si el editor de diferencias muestra las diferencias en paralelo o alineadas.',
+    'Controla si el editor de diferencias muestra los cambios de espacio inicial o espacio final como diferencias.',
+    'Controla si el editor de diff muestra indicadores +/- para cambios agregados/quitados',
+    'Controla si el portapapeles principal de Linux debe admitirse.',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    'No se puede acceder al editor en este momento. Presione Alt+F1 para ver opciones.',
+    'Contenido del editor',
+  ],
+  'vs/editor/common/controller/cursor': ['Excepción inesperada al ejecutar el comando.'],
+  'vs/editor/common/model/textModelWithTokens': [
+    'Error en el modo al convertir la entrada en tokens.',
+  ],
+  'vs/editor/common/modes/modesRegistry': ['Texto sin formato'],
+  'vs/editor/common/services/bulkEdit': [
+    'Estos archivos han cambiado durante el proceso: {0}',
+    'No se realizaron ediciones',
+    '{0} ediciones de texto en {1} archivos',
+    '{0} ediciones de texto en un archivo',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    'Color de fondo del resaltado de línea en la posición del cursor.',
+    'Color de fondo del borde alrededor de la línea en la posición del cursor.',
+    'Color de fondo de los intervalos resaltados; por ejemplo, para Apertura Rápida y Buscar.',
+    'Color del cursor del editor.',
+    'Color de fondo del cursor de edición. Permite personalizar el color del carácter solapado por el bloque del cursor.',
+    'Color de los caracteres de espacio en blanco del editor.',
+    'Color de las guías de sangría del editor.',
+    'Color de números de línea del editor.',
+    'Color de las reglas del editor',
+    'Color principal de lentes de código en el editor',
+    'Color de fondo tras corchetes coincidentes',
+    'Color de bloques con corchetes coincidentes',
+    'Color del borde de la regla de visión general.',
+    'Color de fondo del margen del editor. Este espacio contiene los márgenes de glifos y los números de línea.',
+    'Color de primer plano de squigglies de error en el editor.',
+    'Color de borde de squigglies de error en el editor.',
+    'Color de primer plano de squigglies de advertencia en el editor.',
+    'Color de borde de squigglies de advertencia en el editor.',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['Ir al corchete'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    'Mover símbolo de inserción a la izquierda',
+    'Mover símbolo de inserción a la derecha',
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['Transponer letras'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    'Cortar',
+    'Copiar',
+    'Pegar',
+    'Copiar con resaltado de sintaxis',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    'Alternar comentario de línea',
+    'Agregar comentario de línea',
+    'Quitar comentario de línea',
+    'Alternar comentario de bloque',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['Mostrar menú contextual del editor'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    'Buscar',
+    'Buscar',
+    'Coincidencia anterior',
+    'Coincidencia siguiente',
+    'Buscar en selección',
+    'Cerrar',
+    'Reemplazar',
+    'Reemplazar',
+    'Reemplazar',
+    'Reemplazar todo',
+    'Alternar modo de reemplazar',
+    'Solo se resaltan los primeros 999 resultados, pero todas las operaciones de búsqueda trabajan en todo el texto.',
+    '{0} de {1}',
+    'Sin resultados',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    'Buscar',
+    'Buscar siguiente',
+    'Buscar anterior',
+    'Buscar selección siguiente',
+    'Buscar selección anterior',
+    'Reemplazar',
+    'Agregar selección hasta la siguiente coincidencia de búsqueda',
+    'Agregar selección hasta la anterior coincidencia de búsqueda',
+    'Mover última selección hasta la siguiente coincidencia de búsqueda',
+    'Mover última selección hasta la anterior coincidencia de búsqueda',
+    'Seleccionar todas las repeticiones de coincidencia de búsqueda',
+    'Cambiar todas las ocurrencias',
+    'Mostrar el siguiente término de búsqueda',
+    'Mostrar término de búsqueda anterior',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    'Desplegar',
+    'Desplegar de forma recursiva',
+    'Plegar',
+    'Plegar de forma recursiva',
+    'Plegar todo',
+    'Desplegar todo',
+    'Nivel de plegamiento {0}',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    '1 edición de formato en la línea {0}',
+    '{0} ediciones de formato en la línea {1}',
+    '1 edición de formato entre las líneas {0} y {1}',
+    '{0} ediciones de formato entre las líneas {1} y {2}',
+    'Dar formato al documento',
+    'Dar formato a la selección',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    'No se encontró ninguna definición para "{0}"',
+    'No se encontró ninguna definición',
+    ' – {0} definiciones',
+    'Ir a definición',
+    'Abrir definición en el lateral',
+    'Ver la definición',
+    'No se encontró ninguna implementación para "{0}"',
+    'No se encontró ninguna implementación',
+    '{0} implementaciones',
+    'Ir a implementación',
+    'Inspeccionar implementación',
+    'No se encontró ninguna definición de tipo para "{0}"',
+    'No se encontró ninguna definición de tipo',
+    ' – {0} definiciones de tipo',
+    'Ir a la definición de tipo',
+    'Inspeccionar definición de tipo',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    'Haga clic para mostrar {0} definiciones.',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    'Ir al error o la advertencia siguiente',
+    'Ir al error o la advertencia anterior',
+    'Color de los errores del widget de navegación de marcadores del editor.',
+    'Color de las advertencias del widget de navegación de marcadores del editor.',
+    'Fondo del widget de navegación de marcadores del editor.',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['Mostrar al mantener el puntero'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['Cargando...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': [
+    'Reemplazar con el valor anterior',
+    'Reemplazar con el valor siguiente',
+  ],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    'Copiar línea arriba',
+    'Copiar línea abajo',
+    'Mover línea hacia arriba',
+    'Mover línea hacia abajo',
+    'Ordenar líneas en orden ascendente',
+    'Ordenar líneas en orden descendente',
+    'Recortar espacio final',
+    'Eliminar línea',
+    'Sangría de línea',
+    'Anular sangría de línea',
+    'Insertar línea arriba',
+    'Insertar línea debajo',
+    'Eliminar todo a la izquierda',
+    'Eliminar todo lo que está a la derecha',
+    'Unir líneas',
+    'Transponer caracteres alrededor del cursor',
+    'Transformar a mayúsculas',
+    'Transformar a minúsculas',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'Cmd + clic para abrir el vínculo',
+    'Ctrl + clic para abrir el vínculo',
+    'CMD + click para ejecutar el comando',
+    'Ctrl + click para ejecutar el comando',
+    'Alt + clic para seguir el vínculo',
+    'Alt + clic para ejecutar el comando',
+    'No se pudo abrir este vínculo porque no tiene un formato correcto: {0}',
+    'No se pudo abrir este vínculo porque falta el destino.',
+    'Abrir vínculo',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    'Agregar cursor arriba',
+    'Agregar cursor debajo',
+    'Añadir cursores a finales de línea',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': [
+    'Sugerencias para parámetros Trigger',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}, sugerencia'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    'Mostrar correcciones ({0})',
+    'Mostrar correcciones',
+    'Corrección rápida',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [
+    ' – {0} referencias',
+    'Buscar todas las referencias',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['Cargando...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    'símbolo en {0} linea {1} en la columna {2}',
+    '1 símbolo en {0}, ruta de acceso completa {1}',
+    '{0} símbolos en {1}, ruta de acceso completa {2}',
+    'No se encontraron resultados',
+    'Encontró 1 símbolo en {0}',
+    'Encontró {0} símbolos en {1}',
+    'Encontró {0} símbolos en {1} archivos',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    'Error al resolver el archivo.',
+    '{0} referencias',
+    '{0} referencia',
+    'vista previa no disponible',
+    'Referencias',
+    'No hay resultados.',
+    'Referencias',
+    'Color de fondo del área de título de la vista de inspección.',
+    'Color del título de la vista de inpección.',
+    'Color de la información del título de la vista de inspección.',
+    'Color de los bordes y la flecha de la vista de inspección.',
+    'Color de fondo de la lista de resultados de vista de inspección.',
+    'Color de primer plano de los nodos de inspección en la lista de resultados.',
+    'Color de primer plano de los archivos de inspección en la lista de resultados.',
+    'Color de fondo de la entrada seleccionada en la lista de resultados de vista de inspección.',
+    'Color de primer plano de la entrada seleccionada en la lista de resultados de vista de inspección.',
+    'Color de fondo del editor de vista de inspección.',
+    'Color de fondo del margen en el editor de vista de inspección.',
+    'Buscar coincidencia con el color de resaltado de la lista de resultados de vista de inspección.',
+    'Buscar coincidencia del color de resultado del editor de vista de inspección.',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    'No hay ningún resultado.',
+    "Nombre cambiado correctamente de '{0}' a '{1}'. Resumen: {2}",
+    'No se pudo cambiar el nombre.',
+    'Cambiar el nombre del símbolo',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    'Cambie el nombre de la entrada. Escriba el nuevo nombre y presione Entrar para confirmar.',
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['Expandir selección', 'Reducir selección'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    "Aceptando '{0}' Insertó el siguente texto : {1}",
+    'Sugerencias para Trigger',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    'Color de fondo del widget sugerido.',
+    'Color de borde del widget sugerido.',
+    'Color de primer plano del widget sugerido.',
+    'Color de fondo de la entrada seleccionada del widget sugerido.',
+    'Color del resaltado coincidido en el widget sugerido.',
+    'Leer más...{0}',
+    '{0}, sugerencia, con detalles',
+    '{0}, sugerencia',
+    'Leer menos...{0}',
+    'Cargando...',
+    'No hay sugerencias.',
+    '{0}, aceptada',
+    '{0}, sugerencia, con detalles',
+    '{0}, sugerencia',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': [
+    'Alternar tecla de tabulación para mover el punto de atención',
+  ],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    'Color de fondo de un símbolo durante el acceso de lectura; por ejemplo, cuando se lee una variable.',
+    'Color de fondo de un símbolo durante el acceso de escritura; por ejemplo, cuando se escribe una variable.',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['Cerrar'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    'La configuración predeterminada se reemplaza',
+    'Establecer los valores de configuración que se reemplazarán para el lenguaje {0}.',
+    'Establecer los valores de configuración que se reemplazarán para un lenguaje.',
+    'No se puede registrar "{0}". Coincide con el patrón de propiedad \'\\\\[.*\\\\]$\' para describir la configuración del editor específica del lenguaje. Utilice la contribución "configurationDefaults".',
+    'No se puede registrar "{0}". Esta propiedad ya está registrada.',
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    'Se presionó ({0}). Esperando la siguiente tecla...',
+    'La combinación de teclas ({0}, {1}) no es ningún comando.',
+  ],
+  'vs/platform/message/common/message': ['Cerrar', 'Más tarde', 'Cancelar'],
+  'vs/platform/theme/common/colorRegistry': [
+    'Formato de color no válido. Use #TGB, #RBGA, #RRGGBB o #RRGGBBAA',
+    'Colores usados en el área de trabajo.',
+    'Color de primer plano general. Este color solo se usa si un componente no lo invalida.',
+    'Color de primer plano general para los mensajes de erroe. Este color solo se usa si un componente no lo invalida.',
+    'Color de primer plano para el texto descriptivo que proporciona información adicional, por ejemplo para una etiqueta.',
+    'Color de borde de los elementos con foco. Este color solo se usa si un componente no lo invalida.',
+    'Un borde adicional alrededor de los elementos para separarlos unos de otros y así mejorar el contraste.',
+    'Un borde adicional alrededor de los elementos activos para separarlos unos de otros y así mejorar el contraste.',
+    'El color de fondo del texto seleccionado en el área de trabajo (por ejemplo, campos de entrada o áreas de texto). Esto no se aplica a las selecciones dentro del editor.',
+    'Color para los separadores de texto.',
+    'Color de primer plano para los vínculos en el texto.',
+    'Color de primer plano para los vínculos activos en el texto.',
+    'Color de primer plano para los segmentos de texto con formato previo.',
+    'Color de fondo para los bloques en texto.',
+    'Color de borde para los bloques en texto.',
+    'Color de fondo para los bloques de código en el texto.',
+    'Color de sombra de los widgets  dentro del editor, como buscar/reemplazar',
+    'Fondo de cuadro de entrada.',
+    'Primer plano de cuadro de entrada.',
+    'Borde de cuadro de entrada.',
+    'Color de borde de opciones activadas en campos de entrada.',
+    'Color de primer plano para el marcador de posición de texto',
+    'Color de fondo de validación de entrada para gravedad de información.',
+    'Color de borde de validación de entrada para gravedad de información.',
+    'Color de fondo de validación de entrada para advertencia de información.',
+    'Color de borde de validación de entrada para gravedad de advertencia.',
+    'Color de fondo de validación de entrada para gravedad de error.',
+    'Color de borde de valdación de entrada para gravedad de error.',
+    'Fondo de lista desplegable.',
+    'Primer plano de lista desplegable.',
+    'Borde de lista desplegable.',
+    'Color de fondo de la lista o el árbol del elemento con el foco cuando la lista o el árbol están activos. Una lista o un árbol tienen el foco del teclado cuando están activos, cuando están inactivos no.',
+    'Color de fondo de la lista o el árbol del elemento con el foco cuando la lista o el árbol están activos. Una lista o un árbol tienen el foco del teclado cuando están activos, cuando están inactivos no.',
+    'Color de fondo de la lista o el árbol del elemento seleccionado cuando la lista o el árbol están activos. Una lista o un árbol tienen el foco del teclado cuando están activos, cuando están inactivos no.',
+    'Color de primer plano de la lista o el árbol del elemento con el foco cuando la lista o el árbol están activos. Una lista o un árbol tienen el foco del teclado cuando están activos, cuando están inactivos no.',
+    'Color de fondo de la lista o el árbol del elemento seleccionado cuando la lista o el árbol están inactivos. Una lista o un árbol tienen el foco del teclado cuando están activos, cuando están inactivos no.',
+    'Color de primer plano de la lista o el árbol del elemento con el foco cuando la lista o el árbol esta inactiva. Una lista o un árbol tiene el foco del teclado cuando está activo, cuando esta inactiva no.',
+    'Color de fondo de la lista o el árbol del elemento seleccionado cuando la lista o el árbol están inactivos. Una lista o un árbol tienen el foco del teclado cuando están activos, cuando están inactivos no.',
+    'Color de primer plano de la lista o el árbol del elemento con el foco cuando la lista o el árbol esta inactiva. Una lista o un árbol tiene el foco del teclado cuando está activo, cuando esta inactiva no.',
+    'Fondo de la lista o el árbol al mantener el mouse sobre los elementos.',
+    'Color de primer plano de la lista o el árbol al pasar por encima de los elementos con el ratón.',
+    'Fondo de arrastrar y colocar la lista o el árbol al mover los elementos con el mouse.',
+    'Color de primer plano de la lista o el árbol de las coincidencias resaltadas al buscar dentro de la lista o el ábol.',
+    'Selector de color rápido para la agrupación de etiquetas.',
+    'Selector de color rápido para la agrupación de bordes.',
+    'Color de primer plano del botón.',
+    'Color de fondo del botón.',
+    'Color de fondo del botón al mantener el puntero.',
+    'Color de fondo de la insignia. Las insignias son pequeñas etiquetas de información, por ejemplo los resultados de un número de resultados.',
+    'Color de fondo de la insignia. Las insignias son pequeñas etiquetas de información, por ejemplo los resultados de un número de resultados.',
+    'Sombra de la barra de desplazamiento indica que la vista se ha despazado.',
+    'Color de fondo de control deslizante de barra de desplazamiento.',
+    'Color de fondo de barra de desplazamiento cursor cuando se pasar sobre el control.',
+    'Color de fondo de barra de desplazamiento cursor cuando está activo.',
+    'Color de fondo para la barra de progreso que se puede mostrar para las operaciones de larga duración.',
+    'Color de fondo del editor.',
+    'Color de primer plano predeterminado del editor.',
+    'Color de fondo del editor de widgets como buscar/reemplazar',
+    'Color de borde de los widgets del editor. El color solo se usa si el widget elige tener un borde y no invalida el color.',
+    'Color de la selección del editor.',
+    'Color del texto seleccionado para alto contraste.',
+    'Color de la selección en un editor inactivo.',
+    'Color de las regiones con el mismo contenido que la selección.',
+    'Color de la coincidencia de búsqueda actual.',
+    'Color de las demás coincidencias de búsqueda.',
+    'Color del intervalo que limita la búsqueda.',
+    'Resaltado debajo de la palabra para la que se muestra un recuadro al mantener el puntero.',
+    'Color de fondo al mantener el puntero en el editor.',
+    'Color del borde al mantener el puntero en el editor.',
+    'Color de los vínculos activos.',
+    'Color de fondo para el texto insertado.',
+    'Color de fondo para el texto quitado.',
+    'Color de contorno para el texto insertado.',
+    'Color de contorno para el texto quitado.',
+    'Fondo del encabezado actual en conflictos de combinación alineados.',
+    'Fondo del contenido actual en conflictos de combinación alineados.',
+    'Fondo del encabezado de entrada en conflictos de combinación alineados.',
+    'Fondo del contenido de entrada en conflcitos de combinación alineados.',
+    'Fondo del encabezado de ancestros comunes en conflictos de combinación alineados.',
+    'Fondo del contenido de ancestros comunes en conflictos de combinación alineados.',
+    'Color del borde en los encabezados y el divisor en conflictos de combinación alineados.',
+    'Primer plano de la regla de visión general actual para conflictos de combinación alineados.',
+    'Primer plano de regla de visión general de entrada para conflictos de combinación alineados.',
+    'Primer plano de la regla de visión general de ancestros comunes para conflictos de combinación alineados.',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.es.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.fr.js

@@ -0,0 +1,548 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.fr', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ["{0} (s'est reproduit)"],
+  'vs/base/browser/ui/findinput/findInput': ['entrée'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    'Respecter la casse',
+    'Mot entier',
+    'Utiliser une expression régulière',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': [
+    'Erreur : {0}',
+    'Avertissement : {0}',
+    'Information : {0}',
+  ],
+  'vs/base/common/keybindingLabels': [
+    'Ctrl',
+    'Maj',
+    'Alt',
+    'Windows',
+    'Contrôle',
+    'Maj',
+    'Alt',
+    'Commande',
+    'Contrôle',
+    'Maj',
+    'Alt',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['Erreur', 'Avertissement', 'Informations'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}, sélecteur', 'sélecteur'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    'Sélecteur rapide. Tapez pour réduire les résultats.',
+    'Sélecteur rapide',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['Réduire'],
+  'vs/editor/browser/widget/diffEditorWidget': [
+    "Impossible de comparer les fichiers car l'un d'eux est trop volumineux.",
+  ],
+  'vs/editor/browser/widget/diffReview': [
+    'Fermer',
+    "Différence {0} sur {1} : {2} d'origine, {3} lignes, {4} modifiées, {5} lignes",
+    'vide',
+    "{0} d'origine, {1} modifiées : {2}",
+    '+ {0} modifiées : {1}',
+    "- {0} d'origine : {1}",
+    'Accéder à la différence suivante',
+    'Accéder la différence précédente',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    'Éditeur',
+    'Contrôle la famille de polices.',
+    "Contrôle l'épaisseur de police.",
+    'Contrôle la taille de police en pixels.',
+    'Contrôle la hauteur de ligne. Utilisez 0 pour calculer lineHeight à partir de fontSize.',
+    "Définit l'espacement des caractères en pixels.",
+    "Contrôle l'affichage des numéros de ligne. Les valeurs possibles sont 'activé', 'désactivé' et 'relatif'. La valeur 'relatif' indique le numéro de ligne à partir de la position actuelle du curseur.",
+    'Colonnes où afficher les règles verticales',
+    'Caractères utilisés comme séparateurs de mots durant la navigation ou les opérations basées sur les mots',
+    "Nombre d'espaces correspondant à une tabulation. Ce paramètre est remplacé en fonction du contenu du fichier quand 'editor.detectIndentation' est activé.",
+    "'number' attendu. Notez que la valeur \"auto\" a été remplacée par le paramètre 'editor.detectIndentation'.",
+    "Des espaces sont insérés quand vous appuyez sur la touche Tab. Ce paramètre est remplacé en fonction du contenu du fichier quand 'editor.detectIndentation' est activé.",
+    "'boolean' attendu. Notez que la valeur \"auto\" a été remplacée par le paramètre 'editor.detectIndentation'.",
+    "Quand vous ouvrez un fichier, 'editor.tabSize' et 'editor.insertSpaces' sont détectés en fonction du contenu du fichier.",
+    'Contrôle si les sélections ont des angles arrondis',
+    "Contrôle si l'éditeur défile au-delà de la dernière ligne",
+    'Contrôle si la minicarte est affichée',
+    'Contrôle si le curseur de la minicarte est automatiquement masqué',
+    'Afficher les caractères réels sur une ligne (par opposition aux blocs de couleurs)',
+    'Limiter la largeur de la minicarte pour afficher au maximum un certain nombre de colonnes',
+    "Contrôle si nous remplissons la chaîne à rechercher dans le Widget Recherche à partir de la sélection de l'éditeur",
+    "Contrôle si l'indicateur Rechercher dans la sélection est activé quand plusieurs caractères ou lignes de texte sont sélectionnés dans l'éditeur",
+    "Le retour automatique à la ligne n'est jamais effectué.",
+    "Le retour automatique à la ligne s'effectue en fonction de la largeur de la fenêtre d'affichage.",
+    "Le retour automatique à la ligne s'effectue en fonction de 'editor.wordWrapColumn'.",
+    "Retour automatique à la ligne au minimum en fonction de la fenêtre d'affichage et de 'editor.wordWrapColumn'.",
+    "Contrôle le retour automatique à la ligne. Valeurs possibles :\n - 'off' (désactive le retour automatique à la ligne) ;\n - 'on' (retour automatique à la ligne dans la fenêtre d'affichage) ;\n - 'wordWrapColumn' (retour automatique à la ligne en fonction de 'editor.wordWrapColumn') ou ;\n - 'bounded' (retour automatique à la ligne au minimum en fonction de la fenêtre d'affichage et de 'editor.wordWrapColumn').",
+    "Contrôle la colonne de retour automatique à la ligne de l'éditeur quand 'editor.wordWrap' a la valeur 'wordWrapColumn' ou 'bounded'.",
+    "Contrôle le retrait des lignes renvoyées. La valeur peut être 'none', 'same' ou 'indent'.",
+    "Multiplicateur à utiliser pour le 'deltaX' et le 'deltaY' des événements de défilement de la roulette de la souris",
+    "Mappe vers 'Contrôle' dans Windows et Linux, et vers 'Commande' dans OSX.",
+    "Mappe vers 'Alt' dans Windows et Linux, et vers 'Option' dans OSX.",
+    "Modificateur à utiliser pour ajouter plusieurs curseurs avec la souris. 'ctrlCmd' mappe vers 'Contrôle' dans Windows et Linux, et vers 'Commande' dans OSX. Les mouvements de souris Accéder à la définition et Ouvrir le lien s'adaptent pour ne pas entrer en conflit avec le modificateur multicurseur.",
+    'Activez les suggestions rapides dans les chaînes.',
+    'Activez les suggestions rapides dans les commentaires.',
+    'Activez les suggestions rapides en dehors des chaînes et des commentaires.',
+    "Contrôle si les suggestions doivent s'afficher automatiquement en cours de frappe",
+    "Contrôle le délai en ms au bout duquel les suggestions rapides s'affichent",
+    "Active la pop up qui affiche la documentation des paramètres et écrit de l'information pendant que vous écrivez",
+    "Contrôle si l'éditeur doit automatiquement fermer les crochets après les avoir ouverts",
+    "Contrôle si l'éditeur doit automatiquement mettre en forme la ligne après la saisie",
+    "Contrôle si l'éditeur doit automatiquement mettre en forme le contenu collé. Un formateur doit être disponible et doit pouvoir mettre en forme une plage dans un document.",
+    "Contrôle si l'éditeur doit automatiquement ajuster l'indentation quand les utilisateurs écrivent, collent ou déplacent des lignes. Les règles d'indentation du langage doivent être disponibles.",
+    "Contrôle si les suggestions doivent s'afficher automatiquement durant la saisie de caractères de déclenchement",
+    "Contrôle si les suggestions doivent être acceptées avec 'Entrée', en plus de 'Tab'. Cela permet d'éviter toute ambiguïté entre l'insertion de nouvelles lignes et l'acceptation de suggestions. La valeur 'smart' signifie que vous acceptez uniquement une suggestion avec Entrée quand elle applique une modification de texte",
+    "Contrôle si les suggestions doivent être acceptées avec des caractères de validation. Par exemple, en JavaScript, le point-virgule (';') peut être un caractère de validation qui permet d'accepter une suggestion et de taper ce caractère.",
+    'Afficher des suggestions d’extraits au-dessus d’autres suggestions.',
+    'Afficher des suggestions d’extraits en-dessous d’autres suggestions.',
+    'Afficher des suggestions d’extraits avec d’autres suggestions.',
+    'Ne pas afficher de suggestions d’extrait de code.',
+    "Contrôle si les extraits de code s'affichent en même temps que d'autres suggestions, ainsi que leur mode de tri.",
+    'Contrôle si la copie sans sélection permet de copier la ligne actuelle.',
+    'Contrôle si la saisie semi-automatique doit être calculée en fonction des mots présents dans le document.',
+    'Taille de police du widget de suggestion',
+    'Hauteur de ligne du widget de suggestion',
+    "Détermine si l'éditeur doit surligner les correspondances similaires à la sélection",
+    "Contrôle si l'éditeur doit mettre en surbrillance les occurrences de symboles sémantiques",
+    "Contrôle le nombre d'ornements pouvant s'afficher à la même position dans la règle d'aperçu",
+    "Contrôle si une bordure doit être dessinée autour de la règle d'aperçu.",
+    "Contrôle le style d'animation du curseur. Valeurs possibles : 'blink', 'smooth', 'phase', 'expand' et 'solid'",
+    "Agrandir ou réduire la police de l'éditeur quand l'utilisateur fait tourner la roulette de la souris tout en maintenant la touche Ctrl enfoncée",
+    "Contrôle le style du curseur. Les valeurs acceptées sont 'block', 'block-outline', 'line', 'line-thin', 'underline' et 'underline-thin'",
+    'Active les ligatures de police',
+    "Contrôle si le curseur doit être masqué dans la règle d'aperçu.",
+    "Contrôle la façon dont l'éditeur affiche les espaces blancs. Il existe trois options possibles : 'none', 'boundary' et 'all'. L'option 'boundary' n'affiche pas les espaces uniques qui séparent les mots.",
+    "Contrôle si l'éditeur doit afficher les caractères de contrôle",
+    "Contrôle si l'éditeur doit afficher les repères de mise en retrait",
+    "Contrôle la façon dont l'éditeur doit afficher la surbrillance de la ligne active. Les différentes possibilités sont 'none', 'gutter', 'line' et 'all'.",
+    "Contrôle si l'éditeur affiche les indicateurs CodeLens",
+    "Contrôle si le pliage de code est activé dans l'éditeur",
+    'Définit si les contrôles de réduction sur la bordure sont cachés automatiquement',
+    "Met en surbrillance les crochets correspondants quand l'un d'eux est sélectionné.",
+    "Contrôle si l'éditeur doit afficher la marge de glyphes verticale. La marge de glyphes sert principalement au débogage.",
+    "L'insertion et la suppression d'un espace blanc suit les taquets de tabulation",
+    "Supprimer l'espace blanc de fin inséré automatiquement",
+    "Garder les éditeurs d'aperçu ouverts même si l'utilisateur double-clique sur son contenu ou appuie sur la touche Échap.",
+    "Contrôle si l'éditeur autorise le déplacement des sélections par glisser-déplacer.",
+    "L'éditeur utilise les API de la plateforme pour détecter si un lecteur d'écran est attaché.",
+    "L'éditeur est optimisé en permanence pour une utilisation avec un lecteur d'écran.",
+    "L'éditeur n'est jamais optimisé pour une utilisation avec un lecteur d'écran.",
+    "Contrôle si l'éditeur doit s'exécuter dans un mode optimisé pour les lecteurs d'écran.",
+    "Contrôle si l'éditeur doit détecter les liens et les rendre cliquables",
+    "Contrôle si l'éditeur de différences affiche les différences en mode côte à côte ou inline",
+    "Contrôle si l'éditeur de différences affiche les changements liés aux espaces blancs de début ou de fin comme des différences",
+    "Contrôle si l'éditeur de différences affiche les indicateurs +/- pour les modifications ajoutées/supprimées",
+    'Contrôle si le presse-papiers primaire Linux doit être pris en charge.',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    "L'éditeur n'est pas accessible pour le moment. Appuyez sur Alt+F1 pour connaître les options.",
+    "Contenu d'éditeur",
+  ],
+  'vs/editor/common/controller/cursor': [
+    "Exception inattendue pendant l'exécution de la commande.",
+  ],
+  'vs/editor/common/model/textModelWithTokens': [
+    'Le mode a échoué lors de la création de jetons de l’entrée.',
+  ],
+  'vs/editor/common/modes/modesRegistry': ['Texte brut'],
+  'vs/editor/common/services/bulkEdit': [
+    'Ces fichiers ont changé pendant ce temps : {0}',
+    'Aucune modification effectuée',
+    '{0} modifications de texte effectuées dans {1} fichiers',
+    '{0} modifications de texte effectuées dans un fichier',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    "Couleur d'arrière-plan de la mise en surbrillance de la ligne à la position du curseur.",
+    "Couleur d'arrière-plan de la bordure autour de la ligne à la position du curseur.",
+    "Couleur d'arrière-plan des plages mises en surbrillance, par exemple par les fonctionnalités de recherche et Quick Open.",
+    "Couleur du curseur de l'éditeur.",
+    "La couleur de fond du curseur de l'éditeur. Permet de personnaliser la couleur d'un caractère survolé par un curseur de bloc.",
+    "Couleur des espaces blancs dans l'éditeur.",
+    "Couleur des repères de retrait de l'éditeur.",
+    "Couleur des numéros de ligne de l'éditeur.",
+    "Couleur des règles de l'éditeur",
+    'Couleur pour les indicateurs CodeLens',
+    "Couleur d'arrière-plan pour les accolades associées",
+    'Couleur pour le contour des accolades associées',
+    "Couleur de la bordure de la règle d'apperçu.",
+    "Couleur de fond pour la bordure de l'éditeur. La bordure contient les marges pour les symboles et les numéros de ligne.",
+    "Couleur de premier plan de la ligne ondulée marquant les erreurs dans l'éditeur.",
+    "Couleur de bordure de la ligne ondulée marquant les erreurs dans l'éditeur.",
+    "Couleur de premier plan de la ligne ondulée marquant les avertissements dans l'éditeur.",
+    "Couleur de bordure de la ligne ondulée marquant les avertissements dans l'éditeur.",
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['Atteindre le crochet'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    "Déplacer le point d'insertion vers la gauche",
+    "Déplacer le point d'insertion vers la droite",
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['Transposer les lettres'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    'Couper',
+    'Copier',
+    'Coller',
+    'Copier avec la coloration syntaxique',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    'Activer/désactiver le commentaire de ligne',
+    'Ajouter le commentaire de ligne',
+    'Supprimer le commentaire de ligne',
+    'Activer/désactiver le commentaire de bloc',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ["Afficher le menu contextuel de l'éditeur"],
+  'vs/editor/contrib/find/browser/findWidget': [
+    'Rechercher',
+    'Rechercher',
+    'Correspondance précédente',
+    'Correspondance suivante',
+    'Rechercher dans la sélection',
+    'Fermer',
+    'Remplacer',
+    'Remplacer',
+    'Remplacer',
+    'Tout remplacer',
+    'Changer le mode de remplacement',
+    "Seuls les 999 premiers résultats sont mis en surbrillance. Cependant, toutes les opérations de recherche sont appliquées à l'ensemble du texte.",
+    '{0} sur {1}',
+    'Aucun résultat',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    'Rechercher',
+    'Rechercher suivant',
+    'Rechercher précédent',
+    'Sélection suivante',
+    'Sélection précédente',
+    'Remplacer',
+    'Ajouter la sélection à la correspondance de recherche suivante',
+    'Ajouter la sélection à la correspondance de recherche précédente',
+    'Déplacer la dernière sélection vers la correspondance de recherche suivante',
+    'Déplacer la dernière sélection à la correspondance de recherche précédente',
+    'Sélectionner toutes les occurrences des correspondances de la recherche',
+    'Modifier toutes les occurrences',
+    'Afficher le terme de recherche suivant',
+    'Afficher le terme de recherche précédent',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    'Déplier',
+    'Déplier de manière récursive',
+    'Plier',
+    'Plier de manière récursive',
+    'Plier tout',
+    'Déplier tout',
+    'Niveau de pliage {0}',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    '1 modification de format effectuée à la ligne {0}',
+    '{0} modifications de format effectuées à la ligne {1}',
+    '1 modification de format effectuée entre les lignes {0} et {1}',
+    '{0} modifications de format effectuées entre les lignes {1} et {2}',
+    'Mettre en forme le document',
+    'Mettre en forme la sélection',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    "Définition introuvable pour '{0}'",
+    'Définition introuvable',
+    ' – {0} définitions',
+    'Atteindre la définition',
+    'Ouvrir la définition sur le côté',
+    'Apercu de définition',
+    "Implémentation introuvable pour '{0}'",
+    'Implémentation introuvable',
+    '– Implémentations {0}',
+    "Accéder à l'implémentation",
+    "Aperçu de l'implémentation",
+    "Définition de type introuvable pour '{0}'",
+    'Définition de type introuvable',
+    ' – Définitions de type {0}',
+    'Atteindre la définition de type',
+    'Aperçu de la définition du type',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    'Cliquez pour afficher {0} définitions.',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    "Accéder à l'erreur ou l'avertissement suivant",
+    "Accéder à l'erreur ou l'avertissement précédent",
+    "Couleur d'erreur du widget de navigation dans les marqueurs de l'éditeur.",
+    "Couleur d'avertissement du widget de navigation dans les marqueurs de l'éditeur.",
+    "Arrière-plan du widget de navigation dans les marqueurs de l'éditeur.",
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['Afficher par pointage'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['Chargement...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': [
+    'Remplacer par la valeur précédente',
+    'Remplacer par la valeur suivante',
+  ],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    'Copier la ligne en haut',
+    'Copier la ligne en bas',
+    'Déplacer la ligne vers le haut',
+    'Déplacer la ligne vers le bas',
+    "Trier les lignes dans l'ordre croissant",
+    "Trier les lignes dans l'ordre décroissant",
+    "Découper l'espace blanc de fin",
+    'Supprimer la ligne',
+    'Mettre en retrait la ligne',
+    'Ajouter un retrait négatif à la ligne',
+    'Insérer une ligne au-dessus',
+    'Insérer une ligne sous',
+    'Supprimer tout ce qui est à gauche',
+    'Supprimer tout ce qui est à droite',
+    'Joindre les lignes',
+    'Transposer les caractères autour du curseur',
+    'Transformer en majuscule',
+    'Transformer en minuscule',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'Commande + clic pour suivre le lien',
+    'Ctrl + clic pour suivre le lien',
+    'Cmd + clic pour exécuter la commande',
+    'Ctrl + clic pour exécuter la commande',
+    'Alt + clic pour suivre le lien',
+    'Alt + clic pour exécuter la commande',
+    "Échec de l'ouverture de ce lien, car il n'est pas bien formé : {0}",
+    "Échec de l'ouverture de ce lien, car sa cible est manquante.",
+    'Ouvrir le lien',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    'Ajouter un curseur au-dessus',
+    'Ajouter un curseur en dessous',
+    'Ajouter des curseurs à la fin des lignes',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['Indicateurs des paramètres Trigger'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}, conseil'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    'Afficher les correctifs ({0})',
+    'Afficher les correctifs',
+    'Correctif rapide',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [
+    ' – {0} références',
+    'Rechercher toutes les références',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['Chargement...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    'symbole dans {0} sur la ligne {1}, colonne {2}',
+    '1 symbole dans {0}, chemin complet {1}',
+    '{0} symboles dans {1}, chemin complet {2}',
+    'Résultats introuvables',
+    '1 symbole dans {0}',
+    '{0} symboles dans {1}',
+    '{0} symboles dans {1} fichiers',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    'Échec de la résolution du fichier.',
+    '{0} références',
+    '{0} référence',
+    'aperçu non disponible',
+    'Références',
+    'Aucun résultat',
+    'Références',
+    "Couleur d'arrière-plan de la zone de titre de l'affichage d'aperçu.",
+    "Couleur du titre de l'affichage d'aperçu.",
+    "Couleur des informations sur le titre de l'affichage d'aperçu.",
+    "Couleur des bordures et de la flèche de l'affichage d'aperçu.",
+    "Couleur d'arrière-plan de la liste des résultats de l'affichage d'aperçu.",
+    "Couleur de premier plan des noeuds de lignes dans la liste des résultats de l'affichage d'aperçu.",
+    "Couleur de premier plan des noeuds de fichiers dans la liste des résultats de l'affichage d'aperçu.",
+    "Couleur d'arrière-plan de l'entrée sélectionnée dans la liste des résultats de l'affichage d'aperçu.",
+    "Couleur de premier plan de l'entrée sélectionnée dans la liste des résultats de l'affichage d'aperçu.",
+    "Couleur d'arrière-plan de l'éditeur d'affichage d'aperçu.",
+    "Couleur d'arrière-plan de la bordure de l'éditeur d'affichage d'aperçu.",
+    "Couleur de mise en surbrillance d'une correspondance dans la liste des résultats de l'affichage d'aperçu.",
+    "Couleur de mise en surbrillance d'une correspondance dans l'éditeur de l'affichage d'aperçu.",
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    'Aucun résultat.',
+    "'{0}' renommé en '{1}'. Récapitulatif : {2}",
+    "Échec de l'exécution du renommage.",
+    'Renommer le symbole',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    "Renommez l'entrée. Tapez le nouveau nom et appuyez sur Entrée pour valider.",
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': [
+    'Développer la sélection',
+    'Réduire la sélection',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    "L'acceptation de '{0}' a inséré le texte suivant : {1}",
+    'Suggestions pour Trigger',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    "Couleur d'arrière-plan du widget de suggestion.",
+    'Couleur de bordure du widget de suggestion.',
+    'Couleur de premier plan du widget de suggestion.',
+    "Couleur d'arrière-plan de l'entrée sélectionnée dans le widget de suggestion.",
+    'Couleur de la surbrillance des correspondances dans le widget de suggestion.',
+    'En savoir plus...{0}',
+    '{0}, suggestion, avec détails',
+    '{0}, suggestion',
+    'En savoir moins...{0}',
+    'Chargement...',
+    'Pas de suggestions.',
+    '{0}, accepté',
+    '{0}, suggestion, avec détails',
+    '{0}, suggestion',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': [
+    "Activer/désactiver l'utilisation de la touche Tab pour déplacer le focus",
+  ],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    "Couleur d'arrière-plan d'un symbole durant l'accès en lecture, par exemple la lecture d'une variable.",
+    "Couleur d'arrière-plan d'un symbole durant l'accès en écriture, par exemple l'écriture dans une variable.",
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['Fermer'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    'Substitutions de configuration par défaut',
+    "Configurez les paramètres d'éditeur à remplacer pour le langage {0}.",
+    "Configurez les paramètres d'éditeur à remplacer pour un langage.",
+    "Impossible d'inscrire '{0}'. Ceci correspond au modèle de propriété '\\\\[.*\\\\]$' permettant de décrire les paramètres d'éditeur spécifiques à un langage. Utilisez la contribution 'configurationDefaults'.",
+    "Impossible d'inscrire '{0}'. Cette propriété est déjà inscrite.",
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    'Touche ({0}) utilisée. En attente de la seconde touche pour la pression simultanée...',
+    "La combinaison de touches ({0}, {1}) n'est pas une commande.",
+  ],
+  'vs/platform/message/common/message': ['Fermer', 'Plus tard', 'Annuler'],
+  'vs/platform/theme/common/colorRegistry': [
+    'Format de couleur non valide. Utilisez #RGB, #RGBA, #RRGGBB ou #RRGGBBAA',
+    "Couleurs utilisées dans le banc d'essai.",
+    "Couleur de premier plan globale. Cette couleur est utilisée si elle n'est pas remplacée par un composant.",
+    "Couleur principale de premier plan pour les messages d'erreur. Cette couleur est utilisée uniquement si elle n'est pas redéfinie par un composant.",
+    'Couleur de premier plan du texte descriptif fournissant des informations supplémentaires, par exemple pour un label.',
+    "Couleur de bordure globale des éléments ayant le focus. Cette couleur est utilisée si elle n'est pas remplacée par un composant.",
+    'Bordure supplémentaire autour des éléments pour les séparer des autres et obtenir un meilleur contraste.',
+    'Bordure supplémentaire autour des éléments actifs pour les séparer des autres et obtenir un meilleur contraste.',
+    "La couleur d'arrière-plan des sélections de texte dans le banc d'essai (par ex., pour les champs d'entrée ou les zones de texte). Notez que cette couleur ne s'applique pas aux sélections dans l'éditeur et le terminal.",
+    'Couleur pour les séparateurs de texte.',
+    'Couleur des liens dans le texte.',
+    'Couleur des liens actifs dans le texte.',
+    'Couleur des segments de texte préformatés.',
+    "Couleur d'arrière-plan des citations dans le texte.",
+    'Couleur de bordure des citations dans le texte.',
+    "Couleur d'arrière-plan des blocs de code dans le texte.",
+    "Couleur de l'ombre des widgets, comme rechercher/remplacer, au sein de l'éditeur.",
+    "Arrière-plan de la zone d'entrée.",
+    "Premier plan de la zone d'entrée.",
+    "Bordure de la zone d'entrée.",
+    "Couleur de la bordure des options activées dans les champs d'entrée.",
+    "Couleur de premier plan de la zone d'entrée pour le texte d'espace réservé.",
+    "Couleur d'arrière-plan de la validation d'entrée pour la gravité des informations.",
+    "Couleur de bordure de la validation d'entrée pour la gravité des informations.",
+    "Couleur d'arrière-plan de la validation d'entrée pour l'avertissement sur les informations.",
+    "Couleur de bordure de la validation d'entrée pour la gravité de l'avertissement.",
+    "Couleur d'arrière-plan de la validation d'entrée pour la gravité de l'erreur.",
+    "Couleur de bordure de la validation d'entrée pour la gravité de l'erreur. ",
+    'Arrière-plan de la liste déroulante.',
+    'Premier plan de la liste déroulante.',
+    'Bordure de la liste déroulante.',
+    "Couleur d'arrière-plan de la liste/l'arborescence pour l'élément ayant le focus quand la liste/l'arborescence est active. Une liste/aborescence active peut être sélectionnée au clavier, elle ne l'est pas quand elle est inactive.",
+    "Couleur de premier plan de la liste/l'arborescence pour l'élément ayant le focus quand la liste/l'arborescence est active. Une liste/aborescence active peut être sélectionnée au clavier, elle ne l'est pas quand elle est inactive.",
+    "Couleur d'arrière-plan de la liste/l'arborescence de l'élément sélectionné quand la liste/l'arborescence est active. Une liste/arborescence active peut être sélectionnée au clavier, elle ne l'est pas quand elle est inactive.",
+    "Couleur de premier plan de la liste/l'arborescence pour l'élément sélectionné quand la liste/l'arborescence est active. Une liste/aborescence active peut être sélectionnée au clavier, elle ne l'est pas quand elle est inactive.",
+    "Couleur d'arrière-plan de la liste/l'arborescence pour l'élément sélectionné quand la liste/l'arborescence est inactive. Une liste/aborescence active peut être sélectionnée au clavier, elle ne l'est pas quand elle est inactive.",
+    "Couleur de premier plan de la liste/l'arborescence pour l'élément sélectionné quand la liste/l'arborescence est active. Une liste/aborescence active peut être sélectionnée au clavier, elle ne l'est pas quand elle est inactive.",
+    "Couleur d'arrière-plan de la liste/l'arborescence pour l'élément sélectionné quand la liste/l'arborescence est inactive. Une liste/aborescence active peut être sélectionnée au clavier, elle ne l'est pas quand elle est inactive.",
+    "Couleur de premier plan de la liste/l'arborescence pour l'élément sélectionné quand la liste/l'arborescence est active. Une liste/aborescence active peut être sélectionnée au clavier, elle ne l'est pas quand elle est inactive.",
+    "Arrière-plan de la liste/l'arborescence pendant le pointage sur des éléments avec la souris.",
+    "Premier plan de la liste/l'arborescence pendant le pointage sur des éléments avec la souris.",
+    "Arrière-plan de l'opération de glisser-déplacer dans une liste/arborescence pendant le déplacement d'éléments avec la souris.",
+    "Couleur de premier plan dans la liste/l'arborescence pour la surbrillance des correspondances pendant la recherche dans une liste/arborescence.",
+    'Couleur du sélecteur rapide pour les étiquettes de regroupement.',
+    'Couleur du sélecteur rapide pour les bordures de regroupement.',
+    'Couleur de premier plan du bouton.',
+    "Couleur d'arrière-plan du bouton.",
+    "Couleur d'arrière-plan du bouton pendant le pointage.",
+    "Couleur de fond des badges. Les badges sont de courts libelés d'information, ex. le nombre de résultats de recherche.",
+    "Couleur des badges. Les badges sont de courts libelés d'information, ex. le nombre de résultats de recherche.",
+    'Ombre de la barre de défilement pour indiquer que la vue défile.',
+    'Couleur de fond du curseur de la barre de défilement.',
+    'Couleur de fond du curseur de la barre de défilement lors du survol.',
+    'Couleur de fond du curseur de la barre de défilement en utilisation.',
+    "Couleur de fond pour la barre de progression qui peut s'afficher lors d'opérations longues.",
+    "Couleur d'arrière-plan de l'éditeur.",
+    "Couleur de premier plan par défaut de l'éditeur.",
+    "Couleur d'arrière-plan des gadgets de l'éditeur tels que rechercher/remplacer.",
+    "Couleur de bordure des widgets de l'éditeur. La couleur est utilisée uniquement si le widget choisit d'avoir une bordure et si la couleur n'est pas remplacée par un widget.",
+    "Couleur de la sélection de l'éditeur.",
+    'Couleur du texte sélectionné pour le contraste élevé.',
+    'Couleur de la sélection dans un éditeur inactif.',
+    'Couleur des régions dont le contenu est identique à la sélection.',
+    'Couleur du résultat de recherche actif.',
+    'Couleur des autres résultats de recherche.',
+    'Couleur de la plage limitant la recherche.',
+    "Mettez en surbrillance ci-dessous le mot pour lequel un pointage s'affiche.",
+    "Couleur d'arrière-plan du pointage de l'éditeur.",
+    "Couleur de bordure du pointage de l'éditeur.",
+    'Couleur des liens actifs.',
+    "Couleur d'arrière-plan du texte inséré.",
+    "Couleur d'arrière-plan du texte supprimé.",
+    'Couleur de contour du texte inséré.',
+    'Couleur de contour du texte supprimé.',
+    "Arrière-plan de l'en-tête actuel dans les conflits de fusion inline.",
+    'Arrière-plan du contenu actuel dans les conflits de fusion inline.',
+    "Arrière-plan de l'en-tête entrant dans les conflits de fusion inline.",
+    'Arrière-plan du contenu entrant dans les conflits de fusion inline.',
+    "Arrière-plan de l'en-tête de l'ancêtre commun dans les conflits de fusion inline.",
+    "Arrière-plan du contenu de l'ancêtre commun dans les conflits de fusion inline.",
+    'Couleur de bordure des en-têtes et du séparateur dans les conflits de fusion inline.',
+    "Premier plan de la règle d'aperçu actuelle pour les conflits de fusion inline.",
+    "Premier plan de la règle d'aperçu entrante pour les conflits de fusion inline.",
+    "Arrière-plan de la règle d'aperçu de l'ancêtre commun dans les conflits de fusion inline.",
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.fr.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.hu.js

@@ -0,0 +1,541 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.hu', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (ismét előfordult)'],
+  'vs/base/browser/ui/findinput/findInput': ['bemeneti adat'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    'Kis- és nagybetűk megkülönböztetése',
+    'Csak teljes szavas egyezés',
+    'Reguláris kifejezés használata',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['Hiba: {0}', 'Figyelmeztetés: {0}', 'Információ: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'Ctrl',
+    'Shift',
+    'Alt',
+    'Windows',
+    'Control',
+    'Shift',
+    'Alt',
+    'Parancs',
+    'Control',
+    'Shift',
+    'Alt',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['Hiba', 'Figyelmeztetés', 'Információ'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}, választó', 'választó'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    'Gyorsválasztó. Kezdjen el gépelni a találati lista szűkítéséhez!',
+    'Gyorsválasztó',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['Összecsukás'],
+  'vs/editor/browser/widget/diffEditorWidget': [
+    'A fájlok nem hasonlíthatók össze, mert az egyik fájl túl nagy.',
+  ],
+  'vs/editor/browser/widget/diffReview': [
+    'Bezárás',
+    '{0}. eltérés, összesen: {1}. Eredeti: {2}., {3}. sorok, módosított: {4}., {5}. sorok',
+    'üres',
+    'eredeti {0}., módosított {1}.: {2}',
+    '+ módosított {0}.: {1}',
+    '- eredeti {0}.: {1}',
+    'Ugrás a következő eltérésre',
+    'Ugrás az előző eltérésre',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    'Szerkesztőablak',
+    'Ez a beállítás a betűkészletet határozza meg.',
+    'Meghatározza a betűvastagságot.',
+    'Meghatározza a betű méretét, pixelekben.',
+    'Meghatározza a sormagasságot. A 0 érték használata esetén a sormagasság a fontSize értékéből van számolva.',
+    'Meghatározza a betűközt, pixelekben.',
+    "Meghatározza, hogy megjelenjenek-e a sorszámok. A lehetséges értékek 'on', 'off' és 'relative'. A 'relative' érték használata esetén a kurzor aktuális pozíciójához képest számított sorszám jelenik meg.",
+    'Azon oszlopok listája, ahol függőleges segédvonal jelenjen meg.',
+    'Azon karakterek listája, amelyek szóelválasztónak vannak tekintve szavakkal kapcsolatos navigáció vagy műveletek során.',
+    "Egy tabulátor hány szóköznek felel meg. Ez a beállítás felülírásra kerül a fájl tartalma alapján, ha az 'editor.detectIndentation' beállítás aktív.",
+    "A várt érték 'number' típusú. Megjegyzés: az \"auto\" értéket az 'editor.detectIndentation' beállítás helyettesíti.",
+    "Tabulátor billentyű lenyomásánál szóközök legyenek-e beszúrva.  Ez a beállítás felülírásra kerül a fájl tartalma alapján, ha az 'editor.detectIndentation' beállítás aktív.",
+    "A várt érték 'boolean' típusú. Megjegyzés: az \"auto\" értéket az 'editor.detectIndentation' beállítás helyettesíti.",
+    'Fájl megnyitásakor az `editor.tabSize` és az `editor.insertSpaces` értéke a fájl tartalma alapján lesz meghatározva.',
+    'Itt adható meg, hogy a kijelölt elemek sarkai lekerekítettek legyenek-e',
+    'Meghatározza, hogy a szerkesztőablak görgethető-e az utolsó sor után.',
+    'Meghatározza, hogy megjelenjen-e a kódtérkép.',
+    'Meghatározza, hogy automatikusan el legyen-e rejtve a kódtérképes görgetősáv.',
+    'Meghatározza, hogy a tényleges karakterek legyenek-e megjelenítve (színes téglalapok helyett)',
+    'Meghatározza, hogy a kódtérképen legfeljebb hány oszlop legyen kirajzolva.',
+    'Meghatározza, hogy a keresés modulba automatikusan bekerüljön-e a szerkesztőablakban kiválasztott szöveg.',
+    'Meghatározza, hogy a keresés a kijelölésben beállítás be van-e kapcsolva, ha több karakternyi vagy sornyi szöveg ki van jelölve a szerkesztőablakban.',
+    'A sorok soha nem lesznek tördelve.',
+    'A sorok tördelve lesznek a nézetablak szélességénél.',
+    'A sorok tördelve lesznek az `editor.wordWrapColumn` oszlopnál.',
+    'A sorok tördelve lesznek a nézetablak szélességének és az `editor.wordWrapColumn` értékének minimumánál.',
+    "Ez a beállítás meghatározza, hogy a sorok hogyan legyenek tördelve. Lehetséges értékek:\n- 'off' (nincs sortörés)\n- 'on' (sortörés a nézetablakban)\n- 'wordWrapColumn' (sortörés az `editor.wordWrapColumn` oszlopnál) vagy\n- 'bounded' (sortörés az `editor.wordWrapColumn` és a nézetablak minimumánál)",
+    "Meghatározza a sortöréshez használt oszlopszámot a szerkesztőablakban, ha az `editor.wordWrap` értéke 'wordWrapColumn' vagy 'bounded'.",
+    "Meghatározza a tördelt sorok behúzását. Értéke 'none', 'same' vagy 'indent' lehet.",
+    'Az egér görgetési eseményeinél keletkező `deltaX` és `deltaY` paraméterek szorzója',
+    'Windows és Linux alatt a `Control`, OSX alatt a `Command` billentyűt jelenti.',
+    'Windows és Linux alatt az `Alt`, OSX alatt az `Option` billentyűt jelenti.',
+    'Több kurzor hozzáadásához használt módosítóbillentyű. A `ctrlCmd` Windows és Linux alatt a `Control`, OSX alatt a `Command` billentyűt jelenti. A Definíció megkeresése és Hivatkozás megnyitása egérgesztusok automatikusan alkalmazkodnak úgy, hogy ne ütközzenek a többkurzorhoz tartozó módosítóval.',
+    'Kiegészítési javaslatok engedélyezése karakterláncokban (stringekben)',
+    'Kiegészítési javaslatok engedélyezése megjegyzésekben',
+    'Kiegészítési javaslatok engedélyezése karakterláncokon (stringeken) és megjegyzéseken kívül',
+    'Meghatározza, hogy automatikusan megjelenjenek-e a javaslatok gépelés közben',
+    'Meghatározza, hogy hány ezredmásodperc késleltetéssel jelenjenek meg a kiegészítési javaslatok',
+    'Paraméterinformációkat és típusinformációkat tartalmazó felugró ablak engedélyezése gépelés közben',
+    'Meghatározza, hogy a szerkesztő automatikusan beszúrja-e a nyitó zárójelek záró párját',
+    'Meghatározza, hogy a szerkesztő automatikusan formázza-e a sort a gépelés után',
+    'Meghatározza, hogy a szerkesztő automatikusan formázza-e a beillesztett tartalmat. Ehhez szükség van egy formázóra, illetve a formázónak tudnia kell a dokumentum egy részét formázni.',
+    'Meghatározza, hogy a szerkesztőablak automatikusan állítsa-e az indentálást miközben a felhasználó gépel, beilleszt vagy mozgatja a sorokat. Az adott nyelv indentálási szabályainak rendelkezésre kell állnia.',
+    'Itt adható meg, hogy eseményindító karakterek beírásakor automatikusan megjelenjenek-e a javaslatok',
+    "Meghatározza, hogy a javaslatok az 'Enter' gomb leütésére is el legyenek fogadva a 'Tab' mellett. Segít feloldani a bizonytalanságot az új sorok beillesztése és a javaslatok elfogadása között. A 'smart' érték azt jelenti, hogy csak akkor fogadja el a javaslatot az Enter leütése esetén, ha az módosítja a szöveget.",
+    "Meghatározza, hogy a javaslaok a zárókarakterek leütésére is el legyenek fogadva. A JavaScriptben például a pontosvessző (';') számít zárókarakternek, leütésére a javaslat elfogadásra kerül és beillesztődik az adott karakter. ",
+    'A javasolt kódrészletek a többi javaslat előtt jelenjenek meg.',
+    'A javasolt kódrészletek a többi javaslat után jelenjenek meg.',
+    'A javasolt kódrészletek a többi javaslattal együtt jelenjenek meg.',
+    'Ne jelenjenek meg a javasolt kódrészletek.',
+    'Meghatározza, hogy a kódtöredékek megjelenjenek-e a javaslatok között, illetve hogy hogyan legyenek rendezve.',
+    'Meghatározza, hogy kijelölés nélküli másolás esetén a teljes sor legyen-e másolva.',
+    'Meghatározza, hogy a kiegészítések listája a dokumentumban lévő szövegek alapján legyen-e meghatározva.',
+    'Az ajánlásokat tartalmazó modul betűmérete',
+    'Az ajánlásokat tartalmazó modul sormagassága',
+    'Itt adható meg, hogy a szerkesztő kiemelje-e a kijelöléshez hasonló találatokat',
+    'Meghatározza, hogy a szerkesztőablakban ki legyenek-e emelve a szimbólum szemantikailag hozzá tartozó előfordulásai.',
+    'Meghatározza, hogy hány dekoráció jelenhet meg azonos pozícióban az áttekintő sávon.',
+    'Meghatározza, hogy legyen-e kerete az áttekintő sávnak.',
+    "Meghatározza a kurzor animációjának stílusát. Lehetséges értékek: 'blink', 'smooth', 'phase', 'expand' vagy 'solid'",
+    'A szerkesztőablak betűtípusának nagyítása vagy kicsinyítése az egérgörgő Ctrl lenyomása mellett történő használata esetén',
+    "Meghatározza a kurzor stílusát. Lehetséges értékek: 'block', 'block-outline', 'line', 'line-thin', 'underline' vagy 'underline-thin'",
+    'Engedélyezi a betűtípusban található ligatúrák használatát',
+    'Meghatározza, hogy a kurzor pozíciója el legyen-e rejtve az áttekintő sávon.',
+    "Meghatározza, hogy a szerkesztőablakban hogyan legyenek kirajzolva a szóköz karakterek. Lehetséges értékek: 'none', 'boundary', vagy 'all'. A 'boundary' beállítás esetén, ha szavak között egyetlen szóköz található, akkor az nem lesz kirajzolva.",
+    'Meghatározza, hogy a szerkesztőablakban ki legyenek-e rajzolva a vezérlőkarakterek.',
+    'Meghatározza, hogy a szerkesztőablakban ki legyenek-e rajzolva az indentálási segédvonalak.',
+    "Meghatározza, hogy a szerkesztőablakban hogyan legyen kirajzolva az aktuális sor kiemelése. Lehetséges értékek: 'none', 'gutter', 'line', vagy 'all'.",
+    'Meghatározza, hogy megjelenjenek-e a kódlencsék',
+    'Meghatározza, hogy engedélyezve van-e a kódrészletek bezárása a szerkesztőablakban.',
+    'Meghatározza, hogy a kódrészletek bezárásához tartozó vezérlőelemek automatikusan el legyenek-e rejtve.',
+    'Zárójel kiválasztása esetén a hozzátartozó zárójel kiemelése.',
+    'Meghatározza, hogy legyen-e vertikális szimbólummargó a szerkesztőablakban. A szimbólummargó elsősorban hibakeresésnél van használva.',
+    'Szóközök beillesztése és törlése során követve vannak a tabulátorok.',
+    'A sorok végén lévő, automatikusan beillesztett szóközök eltávolítása',
+    'A betekintőablakok maradjanak nyitva akkor is, ha duplán kattintanak a tartalmára vagy megnyomják az Escape gombot.',
+    'Meghatározza, hogy a szerkesztőablakban engedélyezett-e a kijelölt szövegrészletek áhelyezése húzással.',
+    'A szerkesztő a platform által biztosított API-kat használja annak megállapításához, hogy van-e képernyőolvasó csatlakoztatva.',
+    'A szerkesztő folyamatos képernyőolvasóval való használatára van optimalizálva.',
+    'A szerkesztő soha nincs képernyőolvasó használatára optimalizálva.',
+    'Meghatározza, hogy a szerkesztő olyan módban fusson-e, ami optimalizálva van képernyőolvasóval való használathoz.',
+    'Meghatározza, hogy a szerkesztőablak érzékelje-e a hivatkozásokat, és kattinthatóvá tegye-e őket.',
+    'Meghatározza, hogy a differenciaszerkesztő ablakban egymás mellett vagy a sorban jelenjenek meg az eltérések',
+    'Meghatározza, hogy a differenciaszerkesztő ablakban megjelenjenek-e a sor elején vagy végén a szóközökben talált különbségek',
+    'Meghatározza, hogy a differenciaszerkesztő ablakban megjelenjenek-e a +/- jelzők az hozzáadott/eltávolított változásoknál',
+    'Meghatározza-e, hogy támogatva van-e az elsődleges vágólap Linux alatt',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    'A szerkesztőablak jelenleg nem elérhető. Nyomja meg az Alt+F1-et a beállítási lehetőségek megjelenítéséhez!',
+    'Szerkesztőablak tartalma',
+  ],
+  'vs/editor/common/controller/cursor': ['Váratlan kivétel egy parancs végrehajtása során.'],
+  'vs/editor/common/model/textModelWithTokens': [
+    'Ebben az üzemmódban nem sikerült lexikális elemekre bontani a bemenetet.',
+  ],
+  'vs/editor/common/modes/modesRegistry': ['Egyszerű szöveg'],
+  'vs/editor/common/services/bulkEdit': [
+    'A következő fájlok módosultak időközben: {0}',
+    'Nem történtek változtatások',
+    '{0} változtatást végzett {0} fájlban',
+    '{0} változtatást végzett egy fájlban',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    'A kurzor pozícióján található sor kiemelési háttérszíne.',
+    'A kurzor pozícióján található sor keretszíne.',
+    'A kiemelt területek háttérszíne, pl. a gyors megnyitás és keresés funkcióknál.',
+    'A szerkesztőablak kurzorának színe.',
+    'A szerkesztőablak kurzorának háttérszíne. Lehetővé teszik az olyan karakterek színének módosítását, amelyek fölött egy blokk-típusú kurzor áll.',
+    'A szerkesztőablakban található szóköz karakterek színe.',
+    'A szerkesztőablak segédvonalainak színe.',
+    'A szerkesztőablak sorszámainak színe.',
+    'A szerkesztőablak sávjainak színe.',
+    'A szerkesztőablakban található kódlencsék előtérszíne',
+    'Hozzátartozó zárójelek háttérszíne',
+    'Az összetartozó zárójelek dobozának színe',
+    'Az áttekintő sáv keretszíne.',
+    'A szerkesztőablag margójának háttérszíne. A margón található a szimbólummargó és a sorszámok.',
+    'A hibákat jelző hullámvonal előtérszíne a szerkesztőablakban.',
+    'A hibákat jelző hullámvonal keretszíne a szerkesztőablakban.',
+    'A figyelmeztetéseket jelző hullámvonal előtérszíne a szerkesztőablakban.',
+    'A figyelmeztetéseket jelző hullámvonal keretszíne a szerkesztőablakban.',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['Ugrás a zárójelre'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    'Kurzor mozgatása balra',
+    'Kurzor mozgatása jobbra',
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['Betűk megcserélése'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    'Kivágás',
+    'Másolás',
+    'Beillesztés',
+    'Másolás szintaktikai kiemeléssel',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    'Egysoros megjegyzés ki-/bekapcsolása',
+    'Egysoros megjegyzés hozzáadása',
+    'Egysoros megjegyzés eltávolítása',
+    'Megjegyzésblokk ki-/bekapcsolása',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': [
+    'Szerkesztőablak helyi menüjének megjelenítése',
+  ],
+  'vs/editor/contrib/find/browser/findWidget': [
+    'Keresés',
+    'Keresés',
+    'Előző találat',
+    'Következő találat',
+    'Keresés kijelölésben',
+    'Bezárás',
+    'Csere',
+    'Csere',
+    'Csere',
+    'Az összes előfordulás cseréje',
+    'Váltás csere módra',
+    'Csak az első 999 találat van kiemelve, de minden keresési művelet a teljes szöveggel dolgozik.',
+    '{0} (összesen {1})',
+    'Nincs eredmény',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    'Keresés',
+    'Következő találat',
+    'Előző találat',
+    'Következő kijelölés',
+    'Előző kijelölés',
+    'Csere',
+    'Kijelölés hozzáadása a következő keresési találathoz',
+    'Kijelölés hozzáadása az előző keresési találathoz',
+    'Utolsó kijelölés áthelyezése a következő keresési találatra',
+    'Utolsó kijelölés áthelyezése az előző keresési találatra',
+    'Az összes keresési találat kijelölése',
+    'Minden előfordulás módosítása',
+    'Következő keresési kifejezés megjelenítése',
+    'Előző keresési kifejezés megjelenítése',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    'Kibontás',
+    'Kibontás rekurzívan',
+    'Bezárás',
+    'Bezárás rekurzívan',
+    'Az összes bezárása',
+    'Az összes kinyitása',
+    '{0} szintű blokkok bezárása',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    'Egy formázást végzett a(z) {0}. sorban',
+    '{0} formázást végzett a(z) {1}. sorban',
+    'Egy formázást végzett a(z) {0}. és {1}. sorok között',
+    '{0} formázást végzett a(z) {1}. és {2}. sorok között',
+    'Dokumentum formázása',
+    'Kijelölt tartalom formázása',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    "Nem található a(z) '{0}' definíciója",
+    'Definíció nem található',
+    ' – {0} definíció',
+    'Ugrás a definícióra',
+    'Definíció megnyitása oldalt',
+    'Betekintés a definícióba',
+    "Nem található a(z) '{0}' implementációja",
+    'Implementáció nem található',
+    ' – {0} implementáció',
+    'Ugrás az implementációra',
+    'Betekintés az implementációba',
+    "Nem található a(z) '{0}' típusdefiníciója",
+    'Típusdefiníció nem található',
+    ' – {0} típusdefiníció',
+    'Ugrás a típusdefinícióra',
+    'Betekintés a típusdefinícióba',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    'Kattintson {0} definíció megjelenítéséhez.',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    'Következő hiba vagy figyelmeztetés',
+    'Előző hiba vagy figyelmeztetés',
+    'A szerkesztőablak jelzőnavigációs moduljának színe hiba esetén.',
+    'A szerkesztőablak jelzőnavigációs moduljának színe figyelmeztetés esetén.',
+    'A szerkesztőablak jelzőnavigációs moduljának háttérszíne.',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['Súgószöveg megjelenítése'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['Betöltés...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': [
+    'Csere az előző értékre',
+    'Csere a következő értékre',
+  ],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    'Sor másolása eggyel feljebb',
+    'Sor másolása eggyel lejjebb',
+    'Sor feljebb helyezése',
+    'Sor lejjebb helyezése',
+    'Rendezés növekvő sorrendben',
+    'Rendezés csökkenő sorrendben',
+    'Sor végén található szóközök levágása',
+    'Sor törlése',
+    'Sor behúzása',
+    'Sor kihúzása',
+    'Sor beszúrása eggyel feljebb',
+    'Sor beszúrása eggyel lejjebb',
+    'Balra lévő tartalom törlése',
+    'Jobbra lévő tartalom törlése',
+    'Sorok egyesítése',
+    'A kurzor körüli karakterek felcserélése',
+    'Átalakítás nagybetűssé',
+    'Átalakítás kisbetűssé',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'Hivatkozott oldal megnyitása Cmd + kattintás paranccsal',
+    'Hivatkozott oldal megnyitása Ctrl + kattintás paranccsal',
+    'Cmd + kattintás a parancs végrehajtásához',
+    'Ctrl + kattintás a parancs végrehajtásához',
+    'Hivatkozás megnyitása Alt + kattintás paranccsal',
+    'Alt + kattintás a parancs végrehajtásához',
+    'A hivatkozást nem sikerült megnyitni, mert nem jól formázott: {0}',
+    'A hivatkozást nem sikerült megnyitni, hiányzik a célja.',
+    'Hivatkozás megnyitása',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    'Kurzor beszúrása egy sorral feljebb',
+    'Kurzor beszúrása egy sorral lejjebb',
+    'Kurzor beszúrása a sorok végére',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['Paraméterinformációk megjelenítése'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}, információ'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    'Javítások megjelenítése ({0})',
+    'Javítások megjelenítése',
+    'Gyorsjavítás',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [
+    ' – {0} referencia',
+    'Minden hivatkozás megkeresése',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['Betöltés...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    'szimbólum a következő helyen: {0}, sor: {1}, oszlop: {2}',
+    'Egy szimbólum a következő helyen: {0}, teljes elérési út: {1}',
+    '{0} szimbólum a következő helyen: {1}, teljes elérési út: {2}',
+    'Nincs találat',
+    'Egy szimbólum a következő helyen: {0}',
+    '{0} szimbólum a következő helyen: {1}',
+    '{0} szimbólum {1} fájlban',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    'Nem sikerült feloldani a fájlt.',
+    '{0} referencia',
+    '{0} referencia',
+    'előnézet nem érhető el',
+    'Referenciák',
+    'Nincs eredmény',
+    'Referenciák',
+    'A betekintőablak címsorának háttérszíne.',
+    'A betekintőablak címének színe.',
+    'A betekintőablak címsorában található információ színe.',
+    'A betekintőablak keretének és nyilainak színe.',
+    'A betekintőablak eredménylistájának háttérszíne.',
+    'A betekintőablak eredménylistájában található sorhivatkozások előtérszíne.',
+    'A betekintőablak eredménylistájában található fájlhivatkozások előtérszíne.',
+    'A betekintőablak eredménylistájában kiválaszott elem háttérszíne.',
+    'A betekintőablak eredménylistájában kiválaszott elem előtérszíne.',
+    'A betekintőablak szerkesztőablakának háttérszíne.',
+    'A betekintőablak szerkesztőablakában található margó háttérszíne.',
+    'Kiemelt keresési eredmények színe a betekintőablak eredménylistájában.',
+    'Kiemelt keresési eredmények színe a betekintőablak szerkesztőablakában.',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    'Nincs eredmény.',
+    "'{0}' sikeresen át lett nevezve a következőre: '{1}'. Összefoglaló: {2}",
+    'Az átnevezést nem sikerült végrehajtani.',
+    'Szimbólum átnevezése',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    'Átnevezésre szolgáló beviteli mező. Adja meg az új nevet, majd nyomja meg az Enter gombot a változtatások elvégzéséhez.',
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['Kijelölés bővítése', 'Kijelölés szűkítése'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    "A(z) '{0}' elfogadása a következő szöveg beszúrását eredményezte: {1}",
+    'Javaslatok megjelenítése',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    'A javaslatokat tartalmazó modul háttérszíne.',
+    'A javaslatokat tartalmazó modul keretszíne.',
+    'A javaslatokat tartalmazó modul előtérszíne.',
+    'A javaslatokat tartalmazó modulban kiválasztott elem háttérszíne.',
+    'Az illeszkedő szövegrészletek kiemelése a javaslatok modulban.',
+    'További információk megjelenítése...{0}',
+    '{0}, javaslat, részletekkel',
+    '{0}, javaslat',
+    'Kevesebb információ megjelenítése...{0}',
+    'Betöltés...',
+    'Nincsenek javaslatok.',
+    '{0}, elfogadva',
+    '{0}, javaslat, részletekkel',
+    '{0}, javaslat',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': [
+    'Tab billentyűvel mozgatott fókusz ki- és bekapcsolása',
+  ],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    'Szimbólumok háttérszíne olvasási hozzáférés, páldául változó olvasása esetén.',
+    'Szimbólumok háttérszíne írási hozzáférés, páldául változó írása esetén.',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['Bezárás'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    'Felülírt alapértelmezett konfigurációk',
+    'A szerkesztő beállításainak felülírása a(z) {0} nyelvre vonatkozóan',
+    'A szerkesztő beállításainak felülírása egy adott nyelvre vonatkozóan',
+    "A(z) '{0}' nem regisztrálható. Ez a beállítás illeszkedik a '\\\\[.*\\\\]$' mintára, ami a nyelvspecifikus szerkesztőbeállításokhoz van használva. Használja a 'configurationDefaults' szolgáltatási lehetőséget.",
+    "A(z) '{0}' nem regisztrálható: ez a tulajdonság már regisztrálva van.",
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    'Lenyomta a következőt: ({0}). Várakozás a kombináció második billentyűjére...',
+    'A(z) ({0}, {1}) billentyűkombináció nem egy parancs.',
+  ],
+  'vs/platform/message/common/message': ['Bezárás', 'Később', 'Mégse'],
+  'vs/platform/theme/common/colorRegistry': [
+    'Érvénytelen színformátum. Az #RGB, #RGBA, #RRGGBB vagy #RRGGBBAA formátum használható.',
+    'A munkaterületen használt színek.',
+    'Általános előtérszín. Csak akkor van használva, ha nem írja felül az adott komponens.',
+    'A hibaüzenetek általános előtérszíne. Csak akkor van használva, ha nem írja felül az adott komponens.',
+    'A további információkat szolgáltató leíró szövegek, pl. a címkék előtérszíne.',
+    'Fókuszált elemek keretének általános színe. Csak akkor van használva, ha nem írja felül az adott komponens.',
+    'Az elemek körüli extra keret, mely arra szolgál, hogy elválassza egymástól őket, így növelve a kontrasztot.',
+    'Az aktív elemek körüli extra keret, mely arra szolgál, hogy elválassza egymástól őket, így növelve a kontrasztot.',
+    'A munkaterületen kijelölt szövegek háttérszíne (pl. beviteli mezők vagy szövegmezők esetén). Ez a beállítás nem vonatkozik a szerkesztőablakban végzett kijelölésekre. ',
+    'A szövegelválasztók színe.',
+    'A szövegben található hivatkozások előtérszíne.',
+    'A szövegben található aktív hivatkozások előtérszíne.',
+    'Az előformázott szövegrészek előtérszíne.',
+    'A szövegben található idézetblokkok háttérszíne.',
+    'A szövegben található idézetblokkok keretszíne.',
+    'A szövegben található kódblokkok háttérszíne.',
+    'A szerkesztőablakon belül található modulok, pl. a keresés/csere árnyékának színe.',
+    'A beviteli mezők háttérszíne.',
+    'A beviteli mezők előtérszíne.',
+    'A beviteli mezők kerete.',
+    'A beviteli mezőben található aktivált beállítások keretszíne.',
+    'A beviteli mezőkben használt helykitöltő szövegek előtérszíne.',
+    'Beviteli mezők háttérszíne információs szintű validációs állapot esetén.',
+    'Beviteli mezők keretszíne információs szintű validációs állapot esetén.',
+    'Beviteli mezők háttérszíne figyelmeztetés szintű validációs állapot esetén.',
+    'Beviteli mezők keretszíne figyelmeztetés szintű validációs állapot esetén.',
+    'Beviteli mezők háttérszíne hiba szintű validációs állapot esetén.',
+    'Beviteli mezők keretszíne hiba szintű validációs állapot esetén.',
+    'A legördülő menük háttérszíne.',
+    'A legördülő menük előtérszíne.',
+    'A legördülő menük kerete.',
+    'Listák/fák fókuszált elemének háttérszine, amikor a lista aktív. Egy aktív listának/fának van billentyűfőkusza, míg egy inaktívnak nincs.',
+    'Listák/fák fókuszált elemének előtérszíne, amikor a lista aktív. Egy aktív listának/fának van billentyűfőkusza, míg egy inaktívnak nincs.',
+    'Listák/fák kiválasztott elemének háttérszíne, amikor a lista aktív. Egy aktív listának/fának van billentyűfőkusza, míg egy inaktívnak nincs.',
+    'Listák/fák kiválasztott elemének előtérszíne, amikor a lista aktív. Egy aktív listának/fának van billentyűfőkusza, míg egy inaktívnak nincs.',
+    'Listák/fák kiválasztott elemének háttérszíne, amikor a lista inaktív. Egy aktív listának/fának van billentyűfőkusza, míg egy inaktívnak nincs.',
+    'Listák/fák kiválasztott elemének előtérszíne, amikor a lista inaktív. Egy aktív listának/fának van billentyűfőkusza, míg egy inaktívnak nincs.',
+    'Listák/fák kiválasztott elemének háttérszíne, amikor a lista inaktív. Egy aktív listának/fának van billentyűfőkusza, míg egy inaktívnak nincs.',
+    'Listák/fák kiválasztott elemének előtérszíne, amikor a lista inaktív. Egy aktív listának/fának van billentyűfőkusza, míg egy inaktívnak nincs.',
+    'A lista/fa háttérszíne, amikor az egérkurzor egy adott elem fölé kerül.',
+    'A lista/fa előtérszíne, amikor az egérkurzor egy adott elem fölé kerül.',
+    'A lista/fa háttérszíne, amikor az elemek az egérkurzorral vannak mozgatva egyik helyről a másikra.',
+    'Kiemelt találatok előtérszíne a listában/fában való keresés esetén.',
+    'Csoportcímkék színe a gyorsválasztóban.',
+    'Csoportok keretszíne a gyorsválasztóban.',
+    'A gombok előtérszíne.',
+    'A gombok háttérszíne.',
+    'A gomb háttérszine, ha az egérkurzor fölötte van.',
+    'A jelvények háttérszíne. A jelvények apró információs címkék, pl. a keresési eredmények számának jelzésére.',
+    'A jelvények előtérszíne. A jelvények apró információs címkék, pl. a keresési eredmények számának jelzésére.',
+    'A görgetősáv árnyéka, ami jelzi, hogy a nézet el van görgetve.',
+    'A görgetősáv csúszkájának háttérszíne.',
+    'A görgetősáv csúszkájának háttérszíne, ha az egérkurzor fölötte van.',
+    'A görgetősáv csúszkájának háttérszíne, ha aktív.',
+    'A hosszú ideig tartó folyamatok esetén megjelenített folyamatjelző háttérszíne.',
+    'A szerkesztőablak háttérszíne.',
+    'A szerkesztőablak alapértelmezett előtérszíne.',
+    'A szerkesztőablak moduljainak háttérszíne, pl. a keresés/cserének.',
+    'A szerkesztőablak-modulok keretszíne. A szín csak akkor van használva, ha a modul beállítása alapján rendelkezik kerettel, és a színt nem írja felül a modul.',
+    'A szerkesztőablak-szakasz színe.',
+    'A kijelölt szöveg színe nagy kontrasztú téma esetén.',
+    'Az inaktív szerkesztőablakban található kijelölések színe.',
+    'A kijelöléssel megegyező tartalmú területek színe.',
+    'A keresés jelenlegi találatának színe.',
+    'A keresés további találatainak színe.',
+    'A keresést korlátozó terület színe.',
+    'Kiemelés azon szó alatt, amely fölött lebegő elem jelenik meg.',
+    'A szerkesztőablakban lebegő elemek háttérszíne.',
+    'A szerkesztőablakban lebegő elemek keretszíne.',
+    'Az aktív hivatkozások háttérszíne.',
+    'A beillesztett szövegek háttérszíne.',
+    'Az eltávolított szövegek háttérszíne.',
+    'A beillesztett szövegek körvonalának színe.',
+    'Az eltávolított szövegek körvonalának színe.',
+    'A helyi tartalom fejlécének háttérszíne sorok között megjelenített összeolvasztási konfliktusok esetén.',
+    'A helyi tartalom háttérszíne sorok között megjelenített összeolvasztási konfliktusok esetén.',
+    'A beérkező tartalom fejlécének háttérszíne sorok között megjelenített összeolvasztási konfliktusok esetén.',
+    'A beérkező tartalom háttérszíne sorok között megjelenített összeolvasztási konfliktusok esetén.',
+    'A közös ős tartalom fejlécének háttérszíne sorok között megjelenített összeolvasztási konfliktusok esetén. ',
+    'A közös ős tartalom háttérszíne sorok között megjelenített összeolvasztási konfliktusok esetén. ',
+    'A fejlécek és az elválasztó sáv keretszíne a sorok között megjelenített összeolvasztási konfliktusok esetén.',
+    'A helyi tartalom előtérszíne az áttekintő sávon összeolvasztási konfliktusok esetén.',
+    'A beérkező tartalom előtérszíne az áttekintő sávon összeolvasztási konfliktusok esetén.',
+    'A közös ős tartalom előtérszíne az áttekintő sávon összeolvasztási konfliktusok esetén. ',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.hu.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.it.js

@@ -0,0 +1,541 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.it', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (nuova occorrenza)'],
+  'vs/base/browser/ui/findinput/findInput': ['input'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    'Maiuscole/minuscole',
+    'Parola intera',
+    'Usa espressione regolare',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['Errore: {0}', 'Avviso: {0}', 'Info: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'CTRL',
+    'MAIUSC',
+    'ALT',
+    'Windows',
+    'CTRL',
+    'MAIUSC',
+    'ALT',
+    'Comando',
+    'CTRL',
+    'MAIUSC',
+    'ALT',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['Errore', 'Avviso', 'Informazioni'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}, selezione', 'selezione'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    'Selezione rapida. Digitare per ridurre il numero di risultati.',
+    'Selezione rapida',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['Comprimi'],
+  'vs/editor/browser/widget/diffEditorWidget': [
+    'Non è possibile confrontare i file perché uno è troppo grande.',
+  ],
+  'vs/editor/browser/widget/diffReview': [
+    'Chiudi',
+    'Differenza {0} di {1}: originali {2}, {3} righe, modificate {4}, righe {5}',
+    'vuota',
+    'originali {0}, modificate {1}: {2}',
+    '+ modificate {0}: {1}',
+    '- originali {0}: {1}',
+    'Vai alla differenza successiva',
+    'Vai alla differenza precedente',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    'Editor',
+    'Controlla la famiglia di caratteri.',
+    'Controlla lo spessore del carattere.',
+    'Controlla le dimensioni del carattere in pixel.',
+    "Controlla l'altezza della riga. Usare 0 per calcolare l'altezza della riga dalle dimensioni del carattere.",
+    'Controlla la spaziatura tra le lettere in pixel.',
+    "Consente di controllare la visualizzazione dei numeri di riga. I valori possibili sono 'on', 'off' e 'relative'. Con 'relative' viene visualizzato il conteggio delle righe a partire dalla posizione corrente del cursore.",
+    'Colonne in corrispondenza delle quali visualizzare i righelli verticali',
+    'Caratteri che verranno usati come separatori di parola quando si eseguono operazioni o spostamenti correlati a parole',
+    'Numero di spazi a cui equivale una tabulazione. Quando `editor.detectIndentation` è attivo, questa impostazione viene sostituita in base al contenuto del file.',
+    "È previsto 'number'. Nota: il valore \"auto\" è stato sostituito dall'impostazione `editor.detectIndentation`.",
+    'Inserisce spazi quando viene premuto TAB. Quando `editor.detectIndentation` è attivo, questa impostazione viene sostituita in base al contenuto del file.',
+    "È previsto 'boolean'. Nota: il valore \"auto\" è stato sostituito dall'impostazione `editor.detectIndentation`.",
+    "All'apertura di un file, `editor.tabSize` e `editor.insertSpaces` verranno rilevati in base al contenuto del file.",
+    'Controlla se gli angoli delle selezioni sono arrotondati',
+    "Controlla se l'editor scorrerà oltre l'ultima riga",
+    'Controlla se la mini mappa è visualizzata',
+    'Controlla se lo slider della mini mappa viene nascosto automaticamente.',
+    'Esegue il rendering dei caratteri effettivi di una riga (in contrapposizione ai blocchi colore)',
+    'Limita la larghezza della mini mappa in modo da eseguire il rendering al massimo di un certo numero di colonne',
+    "Controlla se inizializzare la stringa di ricerca nel Widget Trova con il testo selezionato nell'editor",
+    "Controlla se l'impostazione Trova nella selezione è attivata quando vengono selezionati più caratteri o righe di testo nell'editor",
+    'Il wrapping delle righe non viene eseguito.',
+    'Verrà eseguito il wrapping delle righe in base alla larghezza del viewport.',
+    'Verrà eseguito il wrapping delle righe alla posizione corrispondente a `editor.wordWrapColumn`.',
+    'Verrà eseguito il wrapping delle righe alla posizione minima del viewport e di `editor.wordWrapColumn`.',
+    "Controlla il wrapping delle righe. Valori possibili:\n - 'off' (disabilita il wrapping),\n - 'on' (wrapping del viewport),\n - 'wordWrapColumn' (esegue il wrapping alla posizione corrispondente a `editor.wordWrapColumn`) o\n - 'bounded' (esegue il wrapping alla posizione minima del viewport e di `editor.wordWrapColumn`).",
+    "Controlla la colonna di wrapping dell'editor quando il valore di `editor.wordWrap` è 'wordWrapColumn' o 'bounded'.",
+    "Controlla il rientro delle righe con ritorno a capo. Può essere uno dei valori seguenti: 'none', 'same' o 'indent'.",
+    'Moltiplicatore da usare sui valori `deltaX` e `deltaY` degli eventi di scorrimento della rotellina del mouse',
+    "Rappresenta il tasto 'Control' (ctrl) su Windows e Linux e il tasto 'Comando' (cmd) su OSX.",
+    "Rappresenta il tasto 'Alt' su Windows e Linux e il tasto 'Opzione' su OSX.",
+    "Il modificatore da utilizzare per aggiungere molteplici cursori con il mouse. 'ctrlCmd' rappresenta il tasto 'Control' su Windows e Linux e  il tasto 'Comando' su OSX. I gesti del mouse Vai a definizione e Apri il Link si adatteranno in modo da non entrare in conflitto con il modificatore multi-cursore.",
+    "Abilita i suggerimenti rapidi all'interno di stringhe.",
+    "Abilita i suggerimenti rapidi all'interno di commenti.",
+    "Abilita i suggerimenti rapidi all'esterno di stringhe e commenti.",
+    'Controlla se visualizzare automaticamente i suggerimenti durante la digitazione',
+    'Controlla il ritardo in ms dopo il quale verranno visualizzati i suggerimenti rapidi',
+    'Abilita un popup che mostra documentazione sui parametri e informazioni sui tipi mentre si digita',
+    "Controlla se l'editor deve chiudere automaticamente le parentesi quadre dopo che sono state aperte",
+    "Controlla se l'editor deve formattare automaticamente la riga dopo la digitazione",
+    "Controlla se l'editor deve formattare automaticamente il contenuto incollato. Deve essere disponibile un formattatore che deve essere in grado di formattare un intervallo in un documento.",
+    "Controlla se l'editor deve correggere automaticamente l'indentazione mentre l'utente digita, incolla o sposta delle righe. Devono essere disponibili le regole di indentazione del linguaggio.",
+    'Controlla se i suggerimenti devono essere visualizzati automaticamente durante la digitazione dei caratteri trigger',
+    "Controlla se i suggerimenti devono essere accettati con 'INVIO' in aggiunta a 'TAB'. In questo modo è possibile evitare ambiguità tra l'inserimento di nuove righe e l'accettazione di suggerimenti. Il valore 'smart' indica di accettare un suggerimento con 'INVIO' quando comporta una modifica al testo",
+    "Controlla se accettare i suggerimenti con i caratteri di commit. Ad esempio, in JavaScript il punto e virgola (';') può essere un carattere di commit che accetta un suggerimento e digita tale carattere.",
+    'Visualizza i suggerimenti dello snippet sopra gli altri suggerimenti.',
+    'Visualizza i suggerimenti dello snippet sotto gli altri suggerimenti.',
+    'Visualizza i suggerimenti degli snippet insieme agli altri suggerimenti.',
+    'Non mostrare i suggerimenti sugli snippet.',
+    'Controlla se i frammenti di codice sono visualizzati con altri suggerimenti e il modo in cui sono ordinati.',
+    'Consente di controllare se, quando si copia senza aver effettuato una selezione, viene copiata la riga corrente.',
+    'Controlla se calcolare i completamenti in base alle parole presenti nel documento.',
+    'Dimensioni del carattere per il widget dei suggerimenti',
+    'Altezza della riga per il widget dei suggerimenti',
+    "Controlla se l'editor deve evidenziare gli elementi corrispondenti simili alla selezione",
+    "Controlla se l'editor deve evidenziare le occorrenze di simboli semantici",
+    'Controlla il numero di effetti che possono essere visualizzati nella stessa posizione nel righello delle annotazioni',
+    'Controlla se deve essere disegnato un bordo intorno al righello delle annotazioni.',
+    "Controlla lo stile di animazione del cursore. I valori possibili sono: 'blink', 'smooth', 'phase', 'expand' e 'solid'",
+    "Ingrandisce il carattere dell'editor quando si usa la rotellina del mouse e si tiene premuto CTRL",
+    "Controlla lo stile del cursore. I valori accettati sono 'block', 'block-outline', 'line', 'line-thin', 'underline' e 'underline-thin'",
+    'Abilita i caratteri legatura',
+    'Controlla se il cursore deve essere nascosto nel righello delle annotazioni.',
+    "Consente di controllare in che modo l'editor deve eseguire il rendering dei caratteri di spazio vuoto. Le opzioni possibili sono: 'none', 'boundary' e 'all'. Con l'opzione 'boundary' non viene eseguito il rendering di singoli spazi tra le parole.",
+    "Controlla se l'editor deve eseguire il rendering dei caratteri di controllo",
+    "Controlla se l'editor deve eseguire il rendering delle guide con rientro",
+    "Consente di controllare in che modo l'editor deve eseguire il rendering dell'evidenziazione di riga corrente. Le opzioni possibili sono 'none', 'gutter', 'line' e 'all'.",
+    "Controlla se nell'editor sono visualizzate le finestre di CodeLens",
+    "Controlla se per l'editor è abilitata la riduzione del codice",
+    'Controlla se i controlli di riduzione sul margine della barra di scorrimento sono automaticamente nascosti.',
+    'Evidenzia le parentesi corrispondenti quando se ne seleziona una.',
+    "Controlla se l'editor deve eseguire il rendering del margine verticale del glifo. Il margine del glifo viene usato principalmente per il debug.",
+    'Inserimento ed eliminazione dello spazio vuoto dopo le tabulazioni',
+    'Rimuovi lo spazio vuoto finale inserito automaticamente',
+    'Mantiene aperti gli editor rapidi anche quando si fa doppio clic sul contenuto o si preme ESC.',
+    "Controlla se l'editor consentire lo spostamento di selezioni tramite trascinamento della selezione.",
+    "L'editor utilizzerà API della piattaforma per rilevare quando è collegata un'utilità per la lettura dello schermo.",
+    "L'editor sarà definitivamente ottimizzato per l'utilizzo con un'utilità per la lettura dello schermo.",
+    "L'editor non sarà mai ottimizzato per l'utilizzo con un'utilità per la lettura dello schermo.",
+    "Controlla se l'editor deve essere eseguito in una modalità ottimizzata per le utilità per la lettura dello schermo.",
+    "Controlla se l'editor deve individuare i collegamenti e renderli cliccabili",
+    "Controlla se l'editor diff mostra le differenze affiancate o incorporate",
+    "Controlla se l'editor diff mostra come differenze le modifiche relative a spazi vuoti iniziali e finali",
+    "Consente di controllare se l'editor diff mostra gli indicatori +/- per le modifiche aggiunte/rimosse",
+    'Controlla se gli appunti primari di Linux devono essere supportati.',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    "L'editor non è accessibile in questo momento. Premere Alt+F1 per le opzioni.",
+    'Contenuto editor',
+  ],
+  'vs/editor/common/controller/cursor': ["Eccezione imprevista durante l'esecuzione del comando."],
+  'vs/editor/common/model/textModelWithTokens': [
+    "Si è verificato un errore della modalità durante la suddivisione in token dell'input.",
+  ],
+  'vs/editor/common/modes/modesRegistry': ['Testo normale'],
+  'vs/editor/common/services/bulkEdit': [
+    'Nel frattempo questi file sono stati modificati: {0}',
+    'Non sono state effettuate modifiche',
+    'Effettuate {0} modifiche al testo in {1} file',
+    'Effettuate {0} modifiche al testo in un file',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    "Colore di sfondo per l'evidenziazione della riga alla posizione del cursore.",
+    'Colore di sfondo per il bordo intorno alla riga alla posizione del cursore.',
+    'Colore di sfondo degli intervalli evidenziati, ad esempio dalle funzionalità Quick Open e Trova.',
+    "Colore del cursore dell'editor.",
+    'Colore di sfondo del cursore editor. Permette di personalizzare il colore di un carattere quando sovrapposto da un blocco cursore.',
+    "Colore dei caratteri di spazio vuoto nell'editor.",
+    "Colore delle guide per i rientri dell'editor.",
+    "Colore dei numeri di riga dell'editor.",
+    "Colore dei righelli dell'editor.",
+    "Colore primo piano delle finestre di CodeLens dell'editor",
+    'Colore di sfondo delle parentesi corrispondenti',
+    'Colore delle caselle di parentesi corrispondenti',
+    'Colore del bordo del righello delle annotazioni.',
+    "Colore di sfondo della barra di navigazione dell'editor. La barra contiene i margini di glifo e i numeri di riga.",
+    "Colore primo piano degli squiggle di errore nell'editor.",
+    "Colore del bordo degli squiggle di errore nell'editor.",
+    "Colore primo piano degli squiggle di avviso nell'editor",
+    "Colore del bordo degli squggle di avviso nell'editor.",
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['Vai alla parentesi'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    'Sposta il punto di inserimento a sinistra',
+    'Sposta il punto di inserimento a destra',
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['Trasponi lettere'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    'Taglia',
+    'Copia',
+    'Incolla',
+    'Copia con evidenziazione sintassi',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    'Attiva/Disattiva commento per la riga',
+    'Aggiungi commento per la riga',
+    'Rimuovi commento per la riga',
+    'Attiva/Disattiva commento per il blocco',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['Mostra il menu di scelta rapida editor'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    'Trova',
+    'Trova',
+    'Risultato precedente',
+    'Risultato successivo',
+    'Trova nella selezione',
+    'Chiudi',
+    'Sostituisci',
+    'Sostituisci',
+    'Sostituisci',
+    'Sostituisci tutto',
+    'Attiva/Disattiva modalità sostituzione',
+    "Vengono evidenziati solo i primi 999 risultati, ma tutte le operazioni di ricerca funzionano sull'intero testo.",
+    '{0} di {1}',
+    'Nessuna impostazione corrispondente',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    'Trova',
+    'Trova successivo',
+    'Trova precedente',
+    'Trova selezione successiva',
+    'Trova selezione precedente',
+    'Sostituisci',
+    'Aggiungi selezione a risultato ricerca successivo',
+    'Aggiungi selezione a risultato ricerca precedente',
+    'Sposta ultima selezione a risultato ricerca successivo',
+    'Sposta ultima selezione a risultato ricerca precedente',
+    'Seleziona tutte le occorrenze del risultato ricerca',
+    'Cambia tutte le occorrenze',
+    'Mostra il termine di ricerca successivo',
+    'Mostra il termine di ricerca precedente',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    'Espandi',
+    'Espandi in modo ricorsivo',
+    'Riduci',
+    'Riduci in modo ricorsivo',
+    'Riduci tutto',
+    'Espandi tutto',
+    'Livello riduzione {0}',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    'È stata apportata 1 modifica di formattazione a riga {0}',
+    'Sono state apportate {0} modifiche di formattazione a riga {1}',
+    'È stata apportata 1 modifica di formattazione tra le righe {0} e {1}',
+    'Sono state apportate {0} modifiche di formattazione tra le righe {1} e {2}',
+    'Formatta documento',
+    'Formatta selezione',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    "Non è stata trovata alcuna definizione per '{0}'",
+    'Non è stata trovata alcuna definizione',
+    ' - Definizioni di {0}',
+    'Vai alla definizione',
+    'Apri definizione lateralmente',
+    'Visualizza la definizione',
+    "Non sono state trovate implementazioni per '{0}'",
+    'Non sono state trovate implementazioni',
+    '- {0} implementazioni',
+    "Vai all'implementazione",
+    'Anteprima implementazione',
+    "Non sono state trovate definizioni di tipi per '{0}'",
+    'Non sono state trovate definizioni di tipi',
+    ' - {0} definizioni di tipo',
+    'Vai alla definizione di tipo',
+    'Anteprima definizione di tipo',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    'Fare clic per visualizzare {0} definizioni.',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    'Vai a errore o avviso successivo',
+    'Vai a errore o avviso precedente',
+    "Colore per gli errori del widget di spostamento tra marcatori dell'editor.",
+    "Colore per gli avvisi del widget di spostamento tra marcatori dell'editor.",
+    "Sfondo del widget di spostamento tra marcatori dell'editor.",
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['Visualizza passaggio del mouse'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['Caricamento...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': [
+    'Sostituisci con il valore precedente',
+    'Sostituisci con il valore successivo',
+  ],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    'Copia la riga in alto',
+    'Copia la riga in basso',
+    'Sposta la riga in alto',
+    'Sposta la riga in basso',
+    'Ordinamento righe crescente',
+    'Ordinamento righe decrescente',
+    'Taglia spazio vuoto finale',
+    'Elimina la riga',
+    'Imposta un rientro per la riga',
+    'Riduci il rientro per la riga',
+    'Inserisci la riga sopra',
+    'Inserisci la riga sotto',
+    'Elimina tutto a sinistra',
+    'Elimina tutto a destra',
+    'Unisci righe',
+    'Trasponi caratteri intorno al cursore',
+    'Converti in maiuscolo',
+    'Converti in minuscolo',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'Cmd + clic per seguire il collegamento',
+    'CTRL + clic per seguire il collegamento',
+    'Cmd + click per eseguire il comando',
+    'Ctrl + clic per eseguire il comando',
+    'Alt + clic per seguire il collegamento',
+    'Alt + clic per eseguire il comando',
+    'Non è stato possibile aprire questo collegamento perché il formato non è valido: {0}',
+    'Non è stato possibile aprire questo collegamento perché manca la destinazione.',
+    'Apri il collegamento',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    'Aggiungi cursore sopra',
+    'Aggiungi cursore sotto',
+    'Aggiungi cursore alla fine delle righe',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': [
+    'Attiva i suggerimenti per i parametri',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}, suggerimento'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    'Mostra correzioni ({0})',
+    'Mostra correzioni',
+    'Correzione rapida',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [
+    ' - Riferimenti di {0}',
+    'Trova tutti i riferimenti',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['Caricamento...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    'simbolo in {0} alla riga {1} colonna {2}',
+    '1 simbolo in {0}, percorso completo {1}',
+    '{0} simboli in {1}, percorso completo {2}',
+    'Non sono stati trovati risultati',
+    'Trovato 1 simbolo in {0}',
+    'Trovati {0} simboli in {1}',
+    'Trovati {0} simboli in {1} file',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    'Non è stato possibile risolvere il file.',
+    '{0} riferimenti',
+    '{0} riferimento',
+    'anteprima non disponibile',
+    'Riferimenti',
+    'Nessun risultato',
+    'Riferimenti',
+    "Colore di sfondo dell'area del titolo della visualizzazione rapida.",
+    'Colore del titolo della visualizzazione rapida.',
+    'Colore delle informazioni del titolo della visualizzazione rapida.',
+    'Colore dei bordi e della freccia della visualizzazione rapida.',
+    "Colore di sfondo dell'elenco risultati della visualizzazione rapida.",
+    "Colore primo piano dei nodi riga nell'elenco risultati della visualizzazione rapida.",
+    "Colore primo piano dei nodi file nell'elenco risultati della visualizzazione rapida.",
+    "Colore di sfondo della voce selezionata nell'elenco risultati della visualizzazione rapida.",
+    "Colore primo piano della voce selezionata nell'elenco risultati della visualizzazione rapida.",
+    "Colore di sfondo dell'editor di visualizzazioni rapide.",
+    "Colore di sfondo della barra di navigazione nell'editor visualizzazione rapida.",
+    "Colore dell'evidenziazione delle corrispondenze nell'elenco risultati della visualizzazione rapida.",
+    "Colore dell'evidenziazione delle corrispondenze nell'editor di visualizzazioni rapide.",
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    'Nessun risultato.',
+    "Correttamente rinominato '{0}' in '{1}'. Sommario: {2}",
+    "L'esecuzione dell'operazione di ridenominazione non è riuscita.",
+    'Rinomina simbolo',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    "Consente di rinominare l'input. Digitare il nuovo nome e premere INVIO per eseguire il commit.",
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['Espandi SELECT', 'Comprimi SELECT'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    "L'accettazione di '{0}' ha inserito il seguente testo: {1}",
+    'Attiva suggerimento',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    'Colore di sfondo del widget dei suggerimenti.',
+    'Colore del bordo del widget dei suggerimenti.',
+    'Colore primo piano del widget dei suggerimenti.',
+    'Colore di sfondo della voce selezionata del widget dei suggerimenti.',
+    'Colore delle evidenziazioni corrispondenze nel widget dei suggerimenti.',
+    'Altre informazioni...{0}',
+    '{0}, suggerimento, con dettagli',
+    '{0}, suggerimento',
+    'Meno informazioni... {0}',
+    'Caricamento...',
+    'Non ci sono suggerimenti.',
+    '{0}, accettato',
+    '{0}, suggerimento, con dettagli',
+    '{0}, suggerimento',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': [
+    "Attiva/Disattiva l'uso di TAB per spostare lo stato attivo",
+  ],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    "Colore di sfondo di un simbolo durante l'accesso in lettura, ad esempio durante la lettura di una variabile.",
+    "Colore di sfondo di un simbolo durante l'accesso in scrittura, ad esempio durante la scrittura in una variabile.",
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['Chiudi'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    'Override configurazione predefinita',
+    "Consente di configurare le impostazioni dell'editor di cui eseguire l'override per il linguaggio {0}.",
+    "Consente di configurare le impostazioni dell'editor di cui eseguire l'override per un linguaggio.",
+    "Non è possibile registrare '{0}'. Corrisponde al criterio di proprietà '\\\\[.*\\\\]$' per la descrizione delle impostazioni dell'editor specifiche del linguaggio. Usare il contributo 'configurationDefaults'.",
+    "Non è possibile registrare '{0}'. Questa proprietà è già registrata.",
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    'È stato premuto ({0}). In attesa del secondo tasto...',
+    'La combinazione di tasti ({0}, {1}) non è un comando.',
+  ],
+  'vs/platform/message/common/message': ['Chiudi', 'In seguito', 'Annulla'],
+  'vs/platform/theme/common/colorRegistry': [
+    'Formato colore non valido. Usare #RGB, #RGBA, #RRGGBB o #RRGGBBAA',
+    "Colori usati nell'area di lavoro.",
+    'Colore primo piano. Questo colore è utilizzato solo se non viene sovrascritto da un componente.',
+    'Colore primo piano globale per i messaggi di errore. Questo colore è utilizzato solamente se non viene sottoposto a override da un componente.',
+    "Colore primo piano del testo che fornisce informazioni aggiuntive, ad esempio per un'etichetta di testo.",
+    'Colore dei bordi degli elementi evidenziati. Questo colore è utilizzato solo se non viene sovrascritto da un componente.',
+    'Un bordo supplementare attorno agli elementi per contrastarli maggiormente rispetto agli altri.',
+    'Un bordo supplementare intorno agli elementi attivi per contrastarli maggiormente rispetto agli altri.',
+    "Il colore di sfondo delle selezioni di testo nel workbench (ad esempio per i campi di input o aree di testo). Si noti che questo non si applica alle selezioni all'interno dell'editor.",
+    'Colore dei separatori di testo.',
+    'Colore primo piano dei link nel testo.',
+    'Colore primo piano dei link attivi nel testo.',
+    'Colore primo piano dei segmenti di testo preformattato.',
+    'Colore di sfondo per le citazioni nel testo.',
+    'Colore bordo per citazioni nel testo.',
+    'Colore sfondo per blocchi di codice nel testo.',
+    "Colore ombreggiatura dei widget, ad es. Trova/Sostituisci all'interno dell'editor.",
+    'Sfondo della casella di input.',
+    'Primo piano della casella di input.',
+    'Bordo della casella di input.',
+    'Colore del bordo di opzioni attivate nei campi di input.',
+    'Colore primo piano di casella di input per il testo segnaposto.',
+    "Colore di sfondo di convalida dell'input di tipo Informazione.",
+    "Colore bordo di convalida dell'input di tipo Informazione.",
+    "Colore di sfondo di convalida dell'input di tipo Avviso.",
+    "Colore bordo di convalida dell'input di tipo Avviso.",
+    "Colore di sfondo di convalida dell'input di tipo Errore.",
+    "Colore bordo di convalida dell'input di tipo Errore.",
+    "Sfondo dell'elenco a discesa.",
+    "Primo piano dell'elenco a discesa.",
+    "Bordo dell'elenco a discesa.",
+    "Colore sfondo Elenco/Struttura ad albero per l'elemento evidenziato quando l'Elenco/Struttura ad albero è attivo. Un Elenco/Struttura ad albero attivo\nha il focus della tastiera, uno inattivo no.",
+    "Colore primo piano Elenco/Struttura ad albero per l'elemento con stato attivo quando l'Elenco/Struttura ad albero è attivo. Un Elenco/Struttura ad albero attivo\nha il focus della tastiera, uno inattivo no.",
+    "Colore sfondo Elenco/Struttura ad albero per l'elemento selezionato quando l'Elenco/Struttura ad albero è attivo. Un Elenco/Struttura ad albero attivo\nha il focus della tastiera, uno inattivo no.",
+    "Colore primo piano Elenco/Struttura ad albero per l'elemento selezionato quando l'Elenco/Struttura ad albero è attivo. Un Elenco/Struttura ad albero attivo\nha il focus della tastiera, uno inattivo no.",
+    "Colore sfondo Elenco/Struttura ad albero per l'elemento selezionato quando l'Elenco/Struttura ad albero è inattivo. Un Elenco/Struttura ad albero attivo\nha il focus della tastiera, uno inattivo no.",
+    "Colore primo piano Elenco/Struttura ad albero per l'elemento selezionato quando l'Elenco/Struttura ad albero è inattivo. Un Elenco/Struttura ad albero attivo\nha il focus della tastiera, uno inattivo no.",
+    "Colore sfondo Elenco/Struttura ad albero per l'elemento selezionato quando l'Elenco/Struttura ad albero è inattivo. Un Elenco/Struttura ad albero attivo\nha il focus della tastiera, uno inattivo no.",
+    "Colore primo piano Elenco/Struttura ad albero per l'elemento selezionato quando l'Elenco/Struttura ad albero è inattivo. Un Elenco/Struttura ad albero attivo\nha il focus della tastiera, uno inattivo no.",
+    'Sfondo Elenco/Struttura ad albero al passaggio del mouse sugli elementi.',
+    'Primo piano Elenco/Struttura ad albero al passaggio del mouse sugli elementi.',
+    'Sfondo Elenco/Struttura ad albero durante il trascinamento degli elementi selezionati.',
+    "Colore primo piano Elenco/Struttura ad albero delle occorrenze trovate durante la ricerca nell'Elenco/Struttura ad albero.",
+    'Colore di selezione rapida per il raggruppamento delle etichette.',
+    'Colore di selezione rapida per il raggruppamento dei bordi.',
+    'Colore primo piano del pulsante.',
+    'Colore di sfondo del pulsante.',
+    'Colore di sfondo del pulsante al passaggio del mouse.',
+    'Colore di sfondo del badge. I badge sono piccole etichette informative, ad esempio per mostrare il conteggio dei risultati di una ricerca.',
+    'Colore primo piano del badge. I badge sono piccole etichette informative, ad esempio per mostrare il conteggio dei risultati di una ricerca.',
+    'Ombra di ScrollBar per indicare lo scorrimento della visualizzazione.',
+    'Colore di sfondo dello slider della barra di scorrimento.',
+    'Colore di sfondo dello Slider della Barra di scorrimento al passaggio del mouse.',
+    'Colore di sfondo dello Slider della Barra di scorrimento quando è attivo.',
+    "Colore di sfondo dell'indicatore di stato che può essere mostrato durante l'esecuzione di operazioni lunghe.",
+    "Colore di sfondo dell'editor.",
+    "Colore primo piano predefinito dell'editor.",
+    "Colore di sfondo dei widget dell'editor, ad esempio Trova/Sostituisci.",
+    "Colore bordo dei widget dell'editor. Il colore viene utilizzato solo se il widget sceglie di avere un bordo e se il colore non è sottoposto a override da un widget.",
+    "Colore della selezione dell'editor.",
+    'Colore del testo selezionato per il contrasto elevato.',
+    'Colore della selezione in un editor inattivo.',
+    'Colore delle aree con lo stesso contenuto della selezione.',
+    'Colore della corrispondenza di ricerca corrente.',
+    'Colore delle altre corrispondenze di ricerca.',
+    "Colore dell'intervallo di ricerca.",
+    "Evidenziazione sotto la parola per cui è visualizzata un'area sensibile al passaggio del mouse.",
+    "Colore di sfondo dell'area sensibile al passaggio del mouse dell'editor.",
+    "Colore del bordo dell'area sensibile al passaggio del mouse dell'editor.",
+    'Colore dei collegamenti attivi.',
+    'Colore di sfondo del testo che è stato inserito.',
+    'Colore di sfondo del testo che è stato rimosso.',
+    'Colore del contorno del testo che è stato inserito.',
+    'Colore del contorno del testo che è stato rimosso.',
+    'Sfondo intestazione corrente in conflitti di merge in linea.',
+    'Sfondo contenuto corrente in conflitti di merge in linea.',
+    'Sfondo intestazione modifica in ingresso in conflitti di merge in linea.',
+    'Sfondo contenuto modifica in ingresso in conflitti di merge in linea.',
+    "Sfondo dell'intestazione dell'antenato comune nei conflitti di merge in linea.",
+    "Sfondo del contenuto dell'antenato comune nei conflitti di merge in linea.",
+    'Colore bordo su intestazioni e sulla barra di divisione di conflitti di merge in linea.',
+    'Colore primo piano righello panoramica attuale per i conflitti di merge in linea.',
+    'Colore primo piano del righello panoramica modifiche in arrivo per i conflitti di merge in linea.',
+    "Colore primo piano righello panoramica dell'antenato comune per i conflitti di merge in linea.",
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.it.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.ja.js

@@ -0,0 +1,534 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.ja', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (再発)'],
+  'vs/base/browser/ui/findinput/findInput': ['入力'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    '大文字と小文字を区別する',
+    '単語単位で検索する',
+    '正規表現を使用する',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['エラー: {0}', '警告: {0}', '情報: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'Ctrl',
+    'Shift',
+    'Alt',
+    'Windows',
+    'Control',
+    'Shift',
+    'Alt',
+    'コマンド',
+    'Control',
+    'Shift',
+    'Alt',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['エラー', '警告', '情報'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}、選択', '選択'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    'クイック選択。入力すると結果が絞り込まれます。',
+    'クイック選択',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['折りたたむ'],
+  'vs/editor/browser/widget/diffEditorWidget': [
+    '一方のファイルが大きすぎるため、ファイルを比較できません。',
+  ],
+  'vs/editor/browser/widget/diffReview': [
+    '閉じる',
+    '{1} の差分 {0}: 変更前の {2}、{3} 行、変更後の {4}、{5} 行',
+    '空白',
+    '変更前の {0}、変更後の {1}: {2}',
+    '+ 変更後の {0}: {1}',
+    '- 変更前の {0}: {1}',
+    '次の差分に移動',
+    '前の差分に移動',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    'エディター',
+    'フォント ファミリを制御します。',
+    'フォントの太さを制御します。',
+    'フォント サイズをピクセル単位で制御します。',
+    '行の高さを制御します。fontSize に基づいて lineHeight を計算する場合には、0 を使用します。',
+    '文字の間隔をピクセル単位で制御します。',
+    "行番号の表示を制御します。使用可能な値は、'on'、'off'、および 'relative' です。'relative' は現在のカーソル位置からの行数を示します。",
+    '垂直ルーラーを表示する列',
+    '単語に関連したナビゲーションまたは操作を実行するときに、単語の区切り文字として使用される文字',
+    '1 つのタブに相当するスペースの数。`editor.detectIndentation` がオンの場合、この設定はファイル コンテンツに基づいて上書きされます。',
+    '\'number\' が必要です。`editor.detectIndentation` 設定によって値 "auto" が置き換えられていることに注意してください。',
+    'Tab キーを押すとスペースが挿入されます。`editor.detectIndentation` がオンの場合、この設定はファイル コンテンツに基づいて上書きされます。',
+    '\'boolean\' が必要です。`editor.detectIndentation` 設定によって値 "auto" が置き換えられていることに注意してください。',
+    'ファイルを開くと、そのファイルの内容に基づいて `editor.tabSize` と `editor.insertSpaces` が検出されます。',
+    '選択範囲の角を丸くするかどうかを制御します',
+    'エディターで最後の行を越えてスクロールするかどうかを制御します',
+    'ミニマップを表示するかどうかを制御します',
+    'ミニマップのスライダーを自動的に非表示にするかどうかを制御します。',
+    '行に (カラー ブロックではなく) 実際の文字を表示します',
+    '表示するミニマップの最大幅を特定の桁数に制限します',
+    'エディターの選択から検索ウィジェット内の検索文字列を与えるかどうかを制御します',
+    'エディター内で複数の文字もしくは行が選択されているときに選択範囲を検索するフラグを有効にするかどうかを制御します',
+    '行を折り返しません。',
+    '行をビューポートの幅で折り返します。',
+    "行を 'editor.wordWrapColumn' で折り返します。",
+    "ビューポートと 'editor.wordWrapColumn' の最小値で行を折り返します。",
+    "行の折り返し方法を制御します。次の値を指定できます。\n - 'off' (折り返さない),\n - 'on' (ビューポート折り返し),\n - 'wordWrapColumn' ('editor.wordWrapColumn' で折り返し) or\n - 'bounded' (ビューポートと 'editor.wordWrapColumn' の最小値で折り返し).",
+    "'editor.wordWrap' が 'wordWrapColumn' または 'bounded' の場合に、エディターの折り返し桁を制御します。",
+    "折り返し行のインデントを制御します。'none'、'same'、または 'indent' のいずれかを指定できます。",
+    'マウス ホイール スクロール イベントの `deltaX` と `deltaY` で使用される乗数',
+    'Windows および Linux 上の `Control` と OSX 上の `Command` にマップします。',
+    'Windows および Linux 上の `Alt` と OSX 上の `Option` にマップします。',
+    'マウスで複数のカーソルを追加するときに使用する修飾キーです。`ctrlCmd` は Windows および Linux 上の `Control` キーと OSX 上の `Command` キーにマップします。「定義に移動」や「リンクを開く」のマウス操作は、マルチカーソルの修飾キーと競合しないように適用されます。',
+    '文字列内でクイック候補を有効にします。',
+    'コメント内でクイック候補を有効にします。',
+    '文字列およびコメント外でクイック候補を有効にします。',
+    '入力中に候補を自動的に表示するかどうかを制御します',
+    'クイック候補が表示されるまでの待ち時間 (ミリ秒) を制御します',
+    '入力時にパラメーター ドキュメントと型情報を表示するポップアップを有効にする',
+    'エディターで左角かっこの後に自動的に右角かっこを挿入するかどうかを制御します',
+    'エディターで入力後に自動的に行の書式設定を行うかどうかを制御します',
+    '貼り付けた内容がエディターにより自動的にフォーマットされるかどうかを制御します。フォーマッタを使用可能にする必要があります。また、フォーマッタがドキュメント内の範囲をフォーマットできなければなりません。',
+    'ユーザーが入力や貼り付け、行の移動をしたとき、エディターがインデントを自動的に調整するかどうかを制御します。言語のインデント ルールを使用できる必要があります。',
+    'トリガー文字の入力時に候補が自動的に表示されるようにするかどうかを制御します',
+    "'Tab' キーに加えて 'Enter' キーで候補を受け入れるかどうかを制御します。改行の挿入や候補の反映の間であいまいさを解消するのに役立ちます。'smart' 値は文字を変更するときに、Enter キーを押すだけで提案を反映することを意味します。",
+    "コミット文字で候補を受け入れるかどうかを制御します。たとえば、JavaScript ではセミコロン (';') をコミット文字にして、候補を受け入れてその文字を入力することができます。",
+    '他の候補の上にスニペットの候補を表示します。',
+    '他の候補の下にスニペットの候補を表示します。',
+    '他の候補と一緒にスニペットの候補を表示します。',
+    'スニペットの候補を表示しません。',
+    '他の修正候補と一緒にスニペットを表示するかどうか、およびその並び替えの方法を制御します。',
+    '選択範囲を指定しないでコピーする場合に現在の行をコピーするかどうかを制御します。',
+    'ドキュメント内の単語に基づいて入力候補を計算するかどうかを制御します。',
+    '候補のウィジェットのフォント サイズ',
+    '候補のウィジェットの行の高さ',
+    'エディターで選択範囲に類似する一致箇所を強調表示するかどうかを制御します',
+    'エディターでセマンティック シンボルの出現箇所を強調表示するかどうかを制御します',
+    '概要ルーラーの同じ位置に表示できる装飾の数を制御します',
+    '概要ルーラーの周囲に境界線が描画されるかどうかを制御します。',
+    "カーソルのアニメーション スタイルを制御します。指定できる値は 'blink'、'smooth'、'phase'、'expand'、'solid' です",
+    'Ctrl キーを押しながらマウス ホイールを使用してエディターのフォントをズームします',
+    "カーソルのスタイルを制御します。指定できる値は 'block'、'block-outline'、'line'、'line-thin'、'underline'、'underline-thin' です",
+    'フォントの合字を使用します',
+    '概要ルーラーでカーソルを非表示にするかどうかを制御します。',
+    "エディターで空白文字を表示する方法を制御します。'none'、'boundary' および 'all' が使用可能です。'boundary' オプションでは、単語間の単一スペースは表示されません。",
+    'エディターで制御文字を表示する必要があるかどうかを制御します',
+    'エディターでインデントのガイドを表示する必要があるかどうかを制御します',
+    "エディターが現在の行をどのように強調表示するかを制御します。考えられる値は 'none'、'gutter'、'line'、'all' です。",
+    'エディターで CodeLens を表示するかどうかを制御する',
+    'エディターでコードの折りたたみを有効にするかどうかを制御します',
+    '余白上の折りたたみコントロールを自動的に非表示にするかどうかを制御します 。',
+    'かっこを選択すると、対応するかっこを強調表示します。',
+    'エディターで縦のグリフ余白が表示されるかどうかを制御します。ほとんどの場合、グリフ余白はデバッグに使用されます。',
+    '空白の挿入や削除はタブ位置に従って行われます',
+    '自動挿入された末尾の空白を削除する',
+    'エディターのコンテンツをダブルクリックするか、Esc キーを押しても、ピーク エディターを開いたままにします。',
+    'ドラッグ アンド ドロップによる選択範囲の移動をエディターが許可する必要があるかどうかを制御します。',
+    'エディターはスクリーン リーダーがいつ接続されたかを検出するためにプラットフォーム API を使用します。',
+    'エディターは永続的にスクリーン リーダー向けに最適化されます。',
+    'エディターはスクリーン リーダー向けに最適化されません。',
+    'エディターをスクリーン リーダーに最適化されたモードで実行するかどうかを制御します。',
+    'エディターがリンクを検出してクリック可能な状態にするかどうかを制御します',
+    '差分エディターが差分を横に並べて表示するか、行内に表示するかを制御します',
+    '差分エディターが、先頭または末尾の空白の変更を差分として表示するかどうかを制御します。',
+    '差分エディターが追加/削除された変更に +/- インジケーターを示すかどうかを制御します',
+    'Linux の PRIMARY クリップボードをサポートするかどうかを制御します。',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    '現在エディターにアクセスすることはできません。 Alt + F1 キーを押してオプションを選択します。',
+    'エディターのコンテンツ',
+  ],
+  'vs/editor/common/controller/cursor': ['コマンドの実行中に予期しない例外が発生しました。'],
+  'vs/editor/common/model/textModelWithTokens': ['入力のトークン化中にモードが失敗しました。'],
+  'vs/editor/common/modes/modesRegistry': ['プレーンテキスト'],
+  'vs/editor/common/services/bulkEdit': [
+    'この間に次のファイルが変更されました: {0}',
+    '編集は行われませんでした',
+    '{1} 個のファイルで {0} 件のテキスト編集を実行',
+    '1 つのファイルで {0} 個のテキストを編集',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    'カーソル位置の行を強調表示する背景色。',
+    'カーソル位置の行の境界線を強調表示する背景色。',
+    'Quick Open 機能や検索機能などによって強調表示された範囲の背景色。',
+    'エディターのカーソルの色。',
+    '選択された文字列の背景色です。選択された文字列の背景色をカスタマイズ出来ます。',
+    'エディターのスペース文字の色。',
+    'エディター インデント ガイドの色。',
+    'エディターの行番号の色。',
+    'エディター ルーラーの色。',
+    'CodeLens エディターの前景色。',
+    '一致するかっこの背景色',
+    '一致するかっこ内のボックスの色',
+    '概要ルーラーの境界色。',
+    'エディターの余白の背景色。余白にはグリフ マージンと行番号が含まれます。',
+    'エディターでエラーを示す波線の前景色。',
+    'エディターでエラーを示す波線の境界線の色。',
+    'エディターで警告を示す波線の前景色。',
+    'エディターで警告を示す波線の境界線の色。',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['ブラケットへ移動'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    'キャレットを左に移動',
+    'キャレットを右に移動',
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['文字の入れ替え'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    '切り取り',
+    'コピー',
+    '貼り付け',
+    '構文を強調表示してコピー',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    '行コメントの切り替え',
+    '行コメントの追加',
+    '行コメントの削除',
+    'ブロック コメントの切り替え',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['エディターのコンテキスト メニューの表示'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    '検索',
+    '検索',
+    '前の一致項目',
+    '次の一致項目',
+    '選択範囲を検索',
+    '閉じる',
+    '置換',
+    '置換',
+    '置換',
+    'すべて置換',
+    '置換モードの切り替え',
+    '最初の 999 の結果だけを強調表示しますが、テキスト全体を検索します。',
+    '{1} の {0}',
+    '結果なし',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    '検索',
+    '次を検索',
+    '前を検索',
+    '次の選択項目を検索',
+    '前の選択項目を検索',
+    '置換',
+    '選択した項目を次の一致項目に追加',
+    '選んだ項目を前の一致項目に追加する',
+    '最後に選択した項目を次の一致項目に移動',
+    '最後に選んだ項目を前の一致項目に移動する',
+    '一致するすべての出現箇所を選択します',
+    'すべての出現箇所を変更',
+    '次の検索語句を表示',
+    '前の検索語句を表示',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    '展開',
+    '再帰的に展開',
+    '折りたたみ',
+    '再帰的に折りたたむ',
+    'すべて折りたたみ',
+    'すべて展開',
+    '折りたたみレベル {0}',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    '行 {0} で 1 つの書式設定を編集',
+    '行 {1} で {0} 個の書式設定を編集',
+    '行 {0} と {1} の間で 1 つの書式設定を編集',
+    '行 {1} と {2} の間で {0} 個の書式設定を編集',
+    'ドキュメントのフォーマット',
+    '選択範囲のフォーマット',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    "'{0}' の定義は見つかりません",
+    '定義が見つかりません',
+    ' – {0} 個の定義',
+    '定義へ移動',
+    '定義を横に開く',
+    '定義をここに表示',
+    "'{0}' の実装が見つかりません",
+    '実装が見つかりません',
+    '– {0} 個の実装',
+    '実装に移動',
+    '実装のプレビュー',
+    "'{0}' の型定義が見つかりません",
+    '型定義が見つかりません',
+    ' – {0} 個の型定義',
+    '型定義へ移動',
+    '型定義を表示',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    'クリックして、{0} の定義を表示します。',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    '次のエラーまたは警告へ移動',
+    '前のエラーまたは警告へ移動',
+    'エディターのマーカー ナビゲーション ウィジェットのエラーの色。',
+    'エディターのマーカー ナビゲーション ウィジェットの警告の色。',
+    'エディターのマーカー ナビゲーション ウィジェットの背景。',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['ホバーの表示'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['読み込んでいます...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': ['前の値に置換', '次の値に置換'],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    '行を上へコピー',
+    '行を下へコピー',
+    '行を上へ移動',
+    '行を下へ移動',
+    '行を昇順に並べ替え',
+    '行を降順に並べ替え',
+    '末尾の空白のトリミング',
+    '行の削除',
+    '行のインデント',
+    '行のインデント解除',
+    '行を上に挿入',
+    '行を下に挿入',
+    '左側をすべて削除',
+    '右側をすべて削除',
+    '行をつなげる',
+    'カーソルの周囲の文字を入れ替える',
+    '大文字に変換',
+    '小文字に変換',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'command キーを押しながらクリックしてリンク先を表示',
+    'Ctrl キーを押しながらクリックしてリンク先を表示',
+    'command キーを押しながらクリックしてコマンドを実行',
+    'Ctrl キーを押しながらクリックしてコマンドを実行',
+    'Altl キーを押しながらクリックしてリンク先を表示',
+    'Alt キーを押しながらクリックしてコマンドを実行',
+    '申し訳ありません。このリンクは形式が正しくないため開くことができませんでした: {0}',
+    '申し訳ありません。このリンクはターゲットが存在しないため開くことができませんでした。',
+    'リンクを開く',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    'カーソルを上に挿入',
+    'カーソルを下に挿入',
+    'カーソルを行末に挿入',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['パラメーター ヒントをトリガー'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}、ヒント'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    '修正プログラム ({0}) を表示する',
+    '修正プログラムを表示する',
+    'クイック修正',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [
+    '– {0} 個の参照',
+    'すべての参照の検索',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['読み込んでいます...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    '列 {2} の {1} 行目に {0} つのシンボル',
+    '{0} に 1 個のシンボル、完全なパス {1}',
+    '{1} に {0} 個のシンボル、完全なパス {2}',
+    '一致する項目はありません',
+    '{0} に 1 個のシンボルが見つかりました',
+    '{1} に {0} 個のシンボルが見つかりました',
+    '{1} 個のファイルに {0} 個のシンボルが見つかりました',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    'ファイルを解決できませんでした。',
+    '{0} 個の参照',
+    '{0} 個の参照',
+    'プレビューを表示できません',
+    '参照',
+    '結果がありません',
+    '参照',
+    'ピーク ビューのタイトル領域の背景色。',
+    'ピーク ビュー タイトルの色。',
+    'ピーク ビューのタイトル情報の色。',
+    'ピーク ビューの境界と矢印の色。',
+    'ピーク ビュー結果リストの背景色。',
+    'ピーク ビュー結果リストのライン ノードの前景色。',
+    'ピーク ビュー結果リストのファイル ノードの前景色。',
+    'ピーク ビュー結果リストの選択済みエントリの背景色。',
+    'ピーク ビュー結果リストの選択済みエントリの前景色。',
+    'ピーク ビュー エディターの背景色。',
+    'ピーク ビュー エディターの余白の背景色。',
+    'ピーク ビュー結果リストの一致した強調表示色。',
+    'ピーク ビュー エディターの一致した強調表示色。',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    '結果がありません。',
+    "'{0}' から '{1}' への名前変更が正常に完了しました。概要: {2}",
+    '申し訳ありません。名前の変更を実行できませんでした。',
+    'シンボルの名前を変更',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    '名前変更入力。新しい名前を入力し、Enter キーを押してコミットしてください。',
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['選択範囲を拡大', '選択範囲を縮小'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    "'{0}' が次のテキストを挿入したことを承認しています: {1}",
+    '候補をトリガー',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    '候補のウィジェットの背景色。',
+    '候補ウィジェットの境界線色。',
+    '候補ウィジェットの前景色。',
+    '候補ウィジェット内で選択済みエントリの背景色。',
+    '候補のウィジェット内で一致したハイライトの色。',
+    '詳細を表示...{0}',
+    '{0}、候補、詳細あり',
+    '{0}、候補',
+    '詳細を隠す...{0}',
+    '読み込んでいます...',
+    '候補はありません。',
+    '{0}、受け入れ済み',
+    '{0}、候補、詳細あり',
+    '{0}、候補',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': [
+    'Tab キーを切り替えるとフォーカスが移動します',
+  ],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    '変数の読み取りなど読み取りアクセス中のシンボルの背景色。',
+    '変数への書き込みなど書き込みアクセス中のシンボルの背景色。',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['閉じる'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    '既定の構成オーバーライド',
+    '{0} 言語に対して上書きされるエディター設定を構成します。',
+    '言語に対して上書きされるエディター設定を構成します。',
+    "'{0}' を登録できません。これは、言語固有のエディター設定を記述するプロパティ パターン '\\\\[.*\\\\]$' に一致しています。'configurationDefaults' コントリビューションを使用してください。",
+    "'{0}' を登録できません。このプロパティは既に登録されています。",
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    '({0}) が押されました。2 番目のキーを待っています...',
+    'キーの組み合わせ ({0}、{1}) はコマンドではありません。',
+  ],
+  'vs/platform/message/common/message': ['閉じる', '後続', 'キャンセル'],
+  'vs/platform/theme/common/colorRegistry': [
+    '無効な色形式です。 #RGB、#RGBA、#RRGGBB、#RRGGBBAA のいずれかを使用してください',
+    'ワークベンチで使用する色。',
+    '全体の前景色。この色は、コンポーネントによってオーバーライドされていない場合にのみ使用されます。',
+    'エラー メッセージ全体の前景色。この色は、コンポーネントによって上書きされていない場合にのみ使用されます。',
+    '追加情報を提供する説明文の前景色、例:ラベル。',
+    'フォーカスされた要素の境界線全体の色。この色はコンポーネントによって上書きされていない場合にのみ使用されます。',
+    'コントラストを強めるために、他の要素と隔てる追加の境界線。',
+    'コントラストを強めるために、アクティブな他要素と隔てる追加の境界線。',
+    'ワークベンチ内のテキスト選択の背景色 (例: 入力フィールドやテキストエリア)。エディター内の選択には適用されないことに注意してください。',
+    'テキストの区切り文字の色。',
+    'テキスト内のリンクの前景色。',
+    'テキスト内のアクティブなリンクの前景色。',
+    'フォーマット済みテキスト セグメントの前景色。',
+    'テキスト内のブロック引用の背景色。',
+    'テキスト内のブロック引用の境界線色。',
+    'テキスト内のコード ブロックの背景色。',
+    'エディター内の検索/置換窓など、エディター ウィジェットの影の色。',
+    '入力ボックスの背景。',
+    '入力ボックスの前景。',
+    '入力ボックスの境界線。',
+    '入力フィールドのアクティブ オプションの境界線の色。',
+    '入力ボックスのプレースホルダー テキストの前景色。',
+    '情報の重大度を示す入力検証の背景色。',
+    '情報の重大度を示す入力検証の境界線色。',
+    '警告の重大度を示す入力検証の背景色。',
+    '警告の重大度を示す入力検証の境界線色。',
+    'エラーの重大度を示す入力検証の背景色。',
+    'エラーの重大度を示す入力検証の境界線色。',
+    'ドロップダウンの背景。',
+    'ドロップダウンの前景。',
+    'ドロップダウンの境界線。',
+    'ツリーリストがアクティブのとき、フォーカスされた項目のツリーリスト背景色。アクティブなツリーリストはキーボード フォーカスがあり、非アクティブではこれがありません。',
+    'ツリーリストがアクティブのとき、フォーカスされた項目のツリーリスト前景色。アクティブなツリーリストはキーボード フォーカスがあり、非アクティブではこれがありません。',
+    'ツリーリストがアクティブのとき、選択された項目のツリーリスト背景色。アクティブなツリーリストはキーボード フォーカスがあり、非アクティブではこれがありません。',
+    'ツリーリストがアクティブのとき、選択された項目のツリーリスト前景色。アクティブなツリーリストはキーボード フォーカスがあり、非アクティブではこれがありません。',
+    'ツリーリストが非アクティブのとき、フォーカスされた項目のツリーリスト背景色。アクティブなツリーリストはキーボード フォーカスがあり、非アクティブではこれがありません。',
+    'ツリーリストが非アクティブのとき、選択された項目のツリーリスト前景色。アクティブなツリーリストはキーボード フォーカスがあり、非アクティブではこれがありません。',
+    'ツリーリストが非アクティブのとき、フォーカスされた項目のツリーリスト背景色。アクティブなツリーリストはキーボード フォーカスがあり、非アクティブではこれがありません。',
+    'ツリーリストが非アクティブのとき、選択された項目のツリーリスト前景色。アクティブなツリーリストはキーボード フォーカスがあり、非アクティブではこれがありません。',
+    'マウス操作で項目をホバーするときのツリーリスト背景。',
+    'マウス操作で項目をホバーするときのツリーリスト前景。',
+    'マウス操作で項目を移動するときのツリーリスト ドラッグ アンド ドロップの背景。',
+    'ツリーリスト内を検索しているとき、一致した強調のツリーリスト前景色。',
+    'ラベルをグループ化するためのクリック選択の色。',
+    '境界線をグループ化するためのクイック選択の色。',
+    'ボタンの前景色。',
+    'ボタンの背景色。',
+    'ホバー時のボタン背景色。',
+    'バッジの背景色。バッジとは小さな情報ラベルのことです。例:検索結果の数',
+    'バッジの前景色。バッジとは小さな情報ラベルのことです。例:検索結果の数',
+    'ビューがスクロールされたことを示すスクロール バーの影。',
+    'スクロール バーのスライダーの背景色。',
+    'ホバー時のスクロール バー スライダー背景色。',
+    'アクティブ時のスクロール バー スライダー背景色。',
+    '時間のかかる操作で表示するプログレス バーの背景色。',
+    'エディターの背景色。',
+    'エディターの既定の前景色。',
+    '検索/置換窓など、エディター ウィジェットの背景色。',
+    'エディター ウィジェットの境界線色。ウィジェットに境界線があり、ウィジェットによって配色を上書きされていない場合でのみこの配色は使用されます。',
+    'エディターの選択範囲の色。',
+    'ハイ コントラストの選択済みテキストの色。',
+    '非アクティブなエディターの選択範囲の色。',
+    '選択範囲と同じコンテンツの領域の色。',
+    '現在の検索一致項目の色。',
+    '他の検索一致項目の色。',
+    '検索を制限する範囲の色。',
+    'ホバーが表示されているワードの下を強調表示します。',
+    'エディター ホバーの背景色。',
+    'エディター ホバーの境界線の色。',
+    'アクティブなリンクの色。',
+    '挿入されたテキストの背景色。',
+    '削除されたテキストの背景色。',
+    '挿入されたテキストの輪郭の色。',
+    '削除されたテキストの輪郭の色。',
+    '行内マージ競合の現在のヘッダー背景色。',
+    '行内マージ競合の現在のコンテンツ背景色。',
+    '行内マージ競合の入力側ヘッダー背景色。',
+    '行内マージ競合の入力側コンテンツ背景色。',
+    '行内マージ競合の共通の祖先ヘッダー背景色。',
+    '行内マージ競合の共通の祖先コンテンツ背景色。',
+    '行内マージ競合のヘッダーとスプリッターの境界線の色。',
+    '行内マージ競合の現在の概要ルーラー前景色。',
+    '行内マージ競合の入力側の概要ルーラー前景色。',
+    '行内マージ競合の共通の祖先概要ルーラー前景色。',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.ja.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.js

@@ -0,0 +1,535 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (occurred again)'],
+  'vs/base/browser/ui/findinput/findInput': ['input'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    'Match Case',
+    'Match Whole Word',
+    'Use Regular Expression',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['Error: {0}', 'Warning: {0}', 'Info: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'Ctrl',
+    'Shift',
+    'Alt',
+    'Windows',
+    'Control',
+    'Shift',
+    'Alt',
+    'Command',
+    'Control',
+    'Shift',
+    'Alt',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['Error', 'Warning', 'Info'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}, picker', 'picker'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    'Quick picker. Type to narrow down results.',
+    'Quick Picker',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['Collapse'],
+  'vs/editor/browser/widget/diffEditorWidget': [
+    'Cannot compare files because one file is too large.',
+  ],
+  'vs/editor/browser/widget/diffReview': [
+    'Close',
+    'Difference {0} of {1}: original {2}, {3} lines, modified {4}, {5} lines',
+    'blank',
+    'original {0}, modified {1}: {2}',
+    '+ modified {0}: {1}',
+    '- original {0}: {1}',
+    'Go to Next Difference',
+    'Go to Previous Difference',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    'Editor',
+    'Controls the font family.',
+    'Controls the font weight.',
+    'Controls the font size in pixels.',
+    'Controls the line height. Use 0 to compute the lineHeight from the fontSize.',
+    'Controls the letter spacing in pixels.',
+    "Controls the display of line numbers. Possible values are 'on', 'off', and 'relative'. 'relative' shows the line count from the current cursor position.",
+    'Columns at which to show vertical rulers',
+    'Characters that will be used as word separators when doing word related navigations or operations',
+    'The number of spaces a tab is equal to. This setting is overriden based on the file contents when `editor.detectIndentation` is on.',
+    'Expected \'number\'. Note that the value "auto" has been replaced by the `editor.detectIndentation` setting.',
+    'Insert spaces when pressing Tab. This setting is overriden based on the file contents when `editor.detectIndentation` is on.',
+    'Expected \'boolean\'. Note that the value "auto" has been replaced by the `editor.detectIndentation` setting.',
+    'When opening a file, `editor.tabSize` and `editor.insertSpaces` will be detected based on the file contents.',
+    'Controls if selections have rounded corners',
+    'Controls if the editor will scroll beyond the last line',
+    'Controls if the minimap is shown',
+    'Controls whether the minimap slider is automatically hidden.',
+    'Render the actual characters on a line (as opposed to color blocks)',
+    'Limit the width of the minimap to render at most a certain number of columns',
+    'Controls if we seed the search string in Find Widget from editor selection',
+    'Controls if Find in Selection flag is turned on when multiple characters or lines of text are selected in the editor',
+    'Lines will never wrap.',
+    'Lines will wrap at the viewport width.',
+    'Lines will wrap at `editor.wordWrapColumn`.',
+    'Lines will wrap at the minimum of viewport and `editor.wordWrapColumn`.',
+    "Controls how lines should wrap. Can be:\n - 'off' (disable wrapping),\n - 'on' (viewport wrapping),\n - 'wordWrapColumn' (wrap at `editor.wordWrapColumn`) or\n - 'bounded' (wrap at minimum of viewport and `editor.wordWrapColumn`).",
+    "Controls the wrapping column of the editor when `editor.wordWrap` is 'wordWrapColumn' or 'bounded'.",
+    "Controls the indentation of wrapped lines. Can be one of 'none', 'same' or 'indent'.",
+    'A multiplier to be used on the `deltaX` and `deltaY` of mouse wheel scroll events',
+    'Maps to `Control` on Windows and Linux and to `Command` on OSX.',
+    'Maps to `Alt` on Windows and Linux and to `Option` on OSX.',
+    'The modifier to be used to add multiple cursors with the mouse. `ctrlCmd` maps to `Control` on Windows and Linux and to `Command` on OSX. The Go To Definition and Open Link mouse gestures will adapt such that they do not conflict with the multicursor modifier.',
+    'Enable quick suggestions inside strings.',
+    'Enable quick suggestions inside comments.',
+    'Enable quick suggestions outside of strings and comments.',
+    'Controls if suggestions should automatically show up while typing',
+    'Controls the delay in ms after which quick suggestions will show up',
+    'Enables pop-up that shows parameter documentation and type information as you type',
+    'Controls if the editor should automatically close brackets after opening them',
+    'Controls if the editor should automatically format the line after typing',
+    'Controls if the editor should automatically format the pasted content. A formatter must be available and the formatter should be able to format a range in a document.',
+    'Controls if the editor should automatically adjust the indentation when users type, paste or move lines. Indentation rules of the language must be available. ',
+    'Controls if suggestions should automatically show up when typing trigger characters',
+    "Controls if suggestions should be accepted on 'Enter' - in addition to 'Tab'. Helps to avoid ambiguity between inserting new lines or accepting suggestions. The value 'smart' means only accept a suggestion with Enter when it makes a textual change",
+    "Controls if suggestions should be accepted on commit characters. For instance in JavaScript the semi-colon (';') can be a commit character that accepts a suggestion and types that character.",
+    'Show snippet suggestions on top of other suggestions.',
+    'Show snippet suggestions below other suggestions.',
+    'Show snippets suggestions with other suggestions.',
+    'Do not show snippet suggestions.',
+    'Controls whether snippets are shown with other suggestions and how they are sorted.',
+    'Controls whether copying without a selection copies the current line.',
+    'Controls whether completions should be computed based on words in the document.',
+    'Font size for the suggest widget',
+    'Line height for the suggest widget',
+    'Controls whether the editor should highlight similar matches to the selection',
+    'Controls whether the editor should highlight semantic symbol occurrences',
+    'Controls the number of decorations that can show up at the same position in the overview ruler',
+    'Controls if a border should be drawn around the overview ruler.',
+    "Control the cursor animation style, possible values are 'blink', 'smooth', 'phase', 'expand' and 'solid'",
+    'Zoom the font of the editor when using mouse wheel and holding Ctrl',
+    "Controls the cursor style, accepted values are 'block', 'block-outline', 'line', 'line-thin', 'underline' and 'underline-thin'",
+    'Enables font ligatures',
+    'Controls if the cursor should be hidden in the overview ruler.',
+    "Controls how the editor should render whitespace characters, possibilities are 'none', 'boundary', and 'all'. The 'boundary' option does not render single spaces between words.",
+    'Controls whether the editor should render control characters',
+    'Controls whether the editor should render indent guides',
+    "Controls how the editor should render the current line highlight, possibilities are 'none', 'gutter', 'line', and 'all'.",
+    'Controls if the editor shows code lenses',
+    'Controls whether the editor has code folding enabled',
+    'Controls whether the fold controls on the gutter are automatically hidden.',
+    'Highlight matching brackets when one of them is selected.',
+    'Controls whether the editor should render the vertical glyph margin. Glyph margin is mostly used for debugging.',
+    'Inserting and deleting whitespace follows tab stops',
+    'Remove trailing auto inserted whitespace',
+    'Keep peek editors open even when double clicking their content or when hitting Escape.',
+    'Controls if the editor should allow to move selections via drag and drop.',
+    'The editor will use platform APIs to detect when a Screen Reader is attached.',
+    'The editor will be permanently optimized for usage with a Screen Reader.',
+    'The editor will never be optimized for usage with a Screen Reader.',
+    'Controls whether the editor should run in a mode where it is optimized for screen readers.',
+    'Controls whether the editor should detect links and make them clickable',
+    'Controls if the diff editor shows the diff side by side or inline',
+    'Controls if the diff editor shows changes in leading or trailing whitespace as diffs',
+    'Controls if the diff editor shows +/- indicators for added/removed changes',
+    'Controls if the Linux primary clipboard should be supported.',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    'The editor is not accessible at this time. Press Alt+F1 for options.',
+    'Editor content',
+  ],
+  'vs/editor/common/controller/cursor': ['Unexpected exception while executing command.'],
+  'vs/editor/common/model/textModelWithTokens': ['The mode has failed while tokenizing the input.'],
+  'vs/editor/common/modes/modesRegistry': ['Plain Text'],
+  'vs/editor/common/services/bulkEdit': [
+    'These files have changed in the meantime: {0}',
+    'Made no edits',
+    'Made {0} text edits in {1} files',
+    'Made {0} text edits in one file',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    'Background color for the highlight of line at the cursor position.',
+    'Background color for the border around the line at the cursor position.',
+    'Background color of highlighted ranges, like by quick open and find features.',
+    'Color of the editor cursor.',
+    'The background color of the editor cursor. Allows customizing the color of a character overlapped by a block cursor.',
+    'Color of whitespace characters in the editor.',
+    'Color of the editor indentation guides.',
+    'Color of editor line numbers.',
+    'Color of the editor rulers.',
+    'Foreground color of editor code lenses',
+    'Background color behind matching brackets',
+    'Color for matching brackets boxes',
+    'Color of the overview ruler border.',
+    'Background color of the editor gutter. The gutter contains the glyph margins and the line numbers.',
+    'Foreground color of error squigglies in the editor.',
+    'Border color of error squigglies in the editor.',
+    'Foreground color of warning squigglies in the editor.',
+    'Border color of warning squigglies in the editor.',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['Go to Bracket'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    'Move Caret Left',
+    'Move Caret Right',
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['Transpose Letters'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    'Cut',
+    'Copy',
+    'Paste',
+    'Copy With Syntax Highlighting',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    'Toggle Line Comment',
+    'Add Line Comment',
+    'Remove Line Comment',
+    'Toggle Block Comment',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['Show Editor Context Menu'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    'Find',
+    'Find',
+    'Previous match',
+    'Next match',
+    'Find in selection',
+    'Close',
+    'Replace',
+    'Replace',
+    'Replace',
+    'Replace All',
+    'Toggle Replace mode',
+    'Only the first 999 results are highlighted, but all find operations work on the entire text.',
+    '{0} of {1}',
+    'No Results',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    'Find',
+    'Find Next',
+    'Find Previous',
+    'Find Next Selection',
+    'Find Previous Selection',
+    'Replace',
+    'Add Selection To Next Find Match',
+    'Add Selection To Previous Find Match',
+    'Move Last Selection To Next Find Match',
+    'Move Last Selection To Previous Find Match',
+    'Select All Occurrences of Find Match',
+    'Change All Occurrences',
+    'Show Next Find Term',
+    'Show Previous Find Term',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    'Unfold',
+    'Unfold Recursively',
+    'Fold',
+    'Fold Recursively',
+    'Fold All',
+    'Unfold All',
+    'Fold Level {0}',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    'Made 1 formatting edit on line {0}',
+    'Made {0} formatting edits on line {1}',
+    'Made 1 formatting edit between lines {0} and {1}',
+    'Made {0} formatting edits between lines {1} and {2}',
+    'Format Document',
+    'Format Selection',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    "No definition found for '{0}'",
+    'No definition found',
+    ' – {0} definitions',
+    'Go to Definition',
+    'Open Definition to the Side',
+    'Peek Definition',
+    "No implementation found for '{0}'",
+    'No implementation found',
+    ' – {0} implementations',
+    'Go to Implementation',
+    'Peek Implementation',
+    "No type definition found for '{0}'",
+    'No type definition found',
+    ' – {0} type definitions',
+    'Go to Type Definition',
+    'Peek Type Definition',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    'Click to show {0} definitions.',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    'Go to Next Error or Warning',
+    'Go to Previous Error or Warning',
+    'Editor marker navigation widget error color.',
+    'Editor marker navigation widget warning color.',
+    'Editor marker navigation widget background.',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['Show Hover'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['Loading...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': [
+    'Replace with Previous Value',
+    'Replace with Next Value',
+  ],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    'Copy Line Up',
+    'Copy Line Down',
+    'Move Line Up',
+    'Move Line Down',
+    'Sort Lines Ascending',
+    'Sort Lines Descending',
+    'Trim Trailing Whitespace',
+    'Delete Line',
+    'Indent Line',
+    'Outdent Line',
+    'Insert Line Above',
+    'Insert Line Below',
+    'Delete All Left',
+    'Delete All Right',
+    'Join Lines',
+    'Transpose characters around the cursor',
+    'Transform to Uppercase',
+    'Transform to Lowercase',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'Cmd + click to follow link',
+    'Ctrl + click to follow link',
+    'Cmd + click to execute command',
+    'Ctrl + click to execute command',
+    'Alt + click to follow link',
+    'Alt + click to execute command',
+    'Sorry, failed to open this link because it is not well-formed: {0}',
+    'Sorry, failed to open this link because its target is missing.',
+    'Open Link',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    'Add Cursor Above',
+    'Add Cursor Below',
+    'Add Cursors to Line Ends',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['Trigger Parameter Hints'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}, hint'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    'Show Fixes ({0})',
+    'Show Fixes',
+    'Quick Fix',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [
+    ' – {0} references',
+    'Find All References',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['Loading...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    'symbol in {0} on line {1} at column {2}',
+    '1 symbol in {0}, full path {1}',
+    '{0} symbols in {1}, full path {2}',
+    'No results found',
+    'Found 1 symbol in {0}',
+    'Found {0} symbols in {1}',
+    'Found {0} symbols in {1} files',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    'Failed to resolve file.',
+    '{0} references',
+    '{0} reference',
+    'no preview available',
+    'References',
+    'No results',
+    'References',
+    'Background color of the peek view title area.',
+    'Color of the peek view title.',
+    'Color of the peek view title info.',
+    'Color of the peek view borders and arrow.',
+    'Background color of the peek view result list.',
+    'Foreground color for line nodes in the peek view result list.',
+    'Foreground color for file nodes in the peek view result list.',
+    'Background color of the selected entry in the peek view result list.',
+    'Foreground color of the selected entry in the peek view result list.',
+    'Background color of the peek view editor.',
+    'Background color of the gutter in the peek view editor.',
+    'Match highlight color in the peek view result list.',
+    'Match highlight color in the peek view editor.',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    'No result.',
+    "Successfully renamed '{0}' to '{1}'. Summary: {2}",
+    'Sorry, rename failed to execute.',
+    'Rename Symbol',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    'Rename input. Type new name and press Enter to commit.',
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['Expand Select', 'Shrink Select'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    "Accepting '{0}' did insert the following text: {1}",
+    'Trigger Suggest',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    'Background color of the suggest widget.',
+    'Border color of the suggest widget.',
+    'Foreground color of the suggest widget.',
+    'Background color of the selected entry in the suggest widget.',
+    'Color of the match highlights in the suggest widget.',
+    'Read More...{0}',
+    '{0}, suggestion, has details',
+    '{0}, suggestion',
+    'Read less...{0}',
+    'Loading...',
+    'No suggestions.',
+    '{0}, accepted',
+    '{0}, suggestion, has details',
+    '{0}, suggestion',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': ['Toggle Tab Key Moves Focus'],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    'Background color of a symbol during read-access, like reading a variable.',
+    'Background color of a symbol during write-access, like writing to a variable.',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['Close'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    'Default Configuration Overrides',
+    'Configure editor settings to be overridden for {0} language.',
+    'Configure editor settings to be overridden for a language.',
+    "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
+    "Cannot register '{0}'. This property is already registered.",
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    '({0}) was pressed. Waiting for second key of chord...',
+    'The key combination ({0}, {1}) is not a command.',
+  ],
+  'vs/platform/message/common/message': ['Close', 'Later', 'Cancel'],
+  'vs/platform/theme/common/colorRegistry': [
+    'Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA',
+    'Colors used in the workbench.',
+    'Overall foreground color. This color is only used if not overridden by a component.',
+    'Overall foreground color for error messages. This color is only used if not overridden by a component.',
+    'Foreground color for description text providing additional information, for example for a label.',
+    'Overall border color for focused elements. This color is only used if not overridden by a component.',
+    'An extra border around elements to separate them from others for greater contrast.',
+    'An extra border around active elements to separate them from others for greater contrast.',
+    'The background color of text selections in the workbench (e.g. for input fields or text areas). Note that this does not apply to selections within the editor.',
+    'Color for text separators.',
+    'Foreground color for links in text.',
+    'Foreground color for active links in text.',
+    'Foreground color for preformatted text segments.',
+    'Background color for block quotes in text.',
+    'Border color for block quotes in text.',
+    'Background color for code blocks in text.',
+    'Shadow color of widgets such as find/replace inside the editor.',
+    'Input box background.',
+    'Input box foreground.',
+    'Input box border.',
+    'Border color of activated options in input fields.',
+    'Input box foreground color for placeholder text.',
+    'Input validation background color for information severity.',
+    'Input validation border color for information severity.',
+    'Input validation background color for information warning.',
+    'Input validation border color for warning severity.',
+    'Input validation background color for error severity.',
+    'Input validation border color for error severity.',
+    'Dropdown background.',
+    'Dropdown foreground.',
+    'Dropdown border.',
+    'List/Tree background color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not.',
+    'List/Tree foreground color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not.',
+    'List/Tree background color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not.',
+    'List/Tree foreground color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not.',
+    'List/Tree background color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not.',
+    'List/Tree foreground color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not.',
+    'List/Tree background color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not.',
+    'List/Tree foreground color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not.',
+    'List/Tree background when hovering over items using the mouse.',
+    'List/Tree foreground when hovering over items using the mouse.',
+    'List/Tree drag and drop background when moving items around using the mouse.',
+    'List/Tree foreground color of the match highlights when searching inside the list/tree.',
+    'Quick picker color for grouping labels.',
+    'Quick picker color for grouping borders.',
+    'Button foreground color.',
+    'Button background color.',
+    'Button background color when hovering.',
+    'Badge background color. Badges are small information labels, e.g. for search results count.',
+    'Badge foreground color. Badges are small information labels, e.g. for search results count.',
+    'Scrollbar shadow to indicate that the view is scrolled.',
+    'Scrollbar slider background color.',
+    'Scrollbar slider background color when hovering.',
+    'Scrollbar slider background color when active.',
+    'Background color of the progress bar that can show for long running operations.',
+    'Editor background color.',
+    'Editor default foreground color.',
+    'Background color of editor widgets, such as find/replace.',
+    'Border color of editor widgets. The color is only used if the widget chooses to have a border and if the color is not overridden by a widget.',
+    'Color of the editor selection.',
+    'Color of the selected text for high contrast.',
+    'Color of the selection in an inactive editor.',
+    'Color for regions with the same content as the selection.',
+    'Color of the current search match.',
+    'Color of the other search matches.',
+    'Color the range limiting the search.',
+    'Highlight below the word for which a hover is shown.',
+    'Background color of the editor hover.',
+    'Border color of the editor hover.',
+    'Color of active links.',
+    'Background color for text that got inserted.',
+    'Background color for text that got removed.',
+    'Outline color for the text that got inserted.',
+    'Outline color for text that got removed.',
+    'Current header background in inline merge-conflicts.',
+    'Current content background in inline merge-conflicts.',
+    'Incoming header background in inline merge-conflicts.',
+    'Incoming content background in inline merge-conflicts.',
+    'Common ancestor header background in inline merge-conflicts.',
+    'Common ancester content background in inline merge-conflicts.',
+    'Border color on headers and the splitter in inline merge-conflicts.',
+    'Current overview ruler foreground for inline merge-conflicts.',
+    'Incoming overview ruler foreground for inline merge-conflicts.',
+    'Common ancestor overview ruler foreground for inline merge-conflicts.',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.ko.js

@@ -0,0 +1,534 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.ko', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0}({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0}(다시 발생함)'],
+  'vs/base/browser/ui/findinput/findInput': ['입력'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    '대/소문자 구분',
+    '단어 단위로',
+    '정규식 사용',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['오류: {0}', '경고: {0}', '정보: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'Ctrl',
+    '<Shift>',
+    'Alt',
+    'Windows',
+    '컨트롤',
+    '<Shift>',
+    'Alt',
+    '명령',
+    '컨트롤',
+    '<Shift>',
+    'Alt',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['오류', '경고', '정보'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}, 선택기', '선택기'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    '빠른 선택기입니다. 결과의 범위를 축소하려면 입력합니다.',
+    '빠른 선택기',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['축소'],
+  'vs/editor/browser/widget/diffEditorWidget': ['파일 1개가 너무 커서 파일을 비교할 수 없습니다.'],
+  'vs/editor/browser/widget/diffReview': [
+    '닫기',
+    '다른 항목 {0} / {1}: 원본 {2}, {3}행, 수정 {4}, {5}행',
+    '비어 있음',
+    '원본 {0}, 수정 {1}: {2}',
+    '+ 수정됨 {0}: {1}',
+    '- 원본 {0}: {1}',
+    '다음 다른 항목으로 이동',
+    '다음 다른 항목으로 이동',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    '편집기',
+    '글꼴 패밀리를 제어합니다.',
+    '글꼴 두께를 제어합니다.',
+    '글꼴 크기(픽셀)를 제어합니다.',
+    '줄 높이를 제어합니다. fontSize의 lineHeight를 계산하려면 0을 사용합니다.',
+    '글자 간격을 픽셀 단위로 조정합니다.',
+    "줄 번호의 표시 여부를 제어합니다. 가능한 값은 'on', 'off', 'relative'입니다. 'relative'는 현재 커서 위치에서 줄 수를 표시합니다.",
+    '세로 눈금자를 표시할 열',
+    '단어 관련 탐색 또는 작업을 수행할 때 단어 구분 기호로 사용되는 문자입니다.',
+    '탭 한 개에 해당하는 공백 수입니다. `editor.detectIndentation`이 켜져 있는 경우 이 설정은 파일 콘텐츠에 따라 재정의됩니다.',
+    '\'number\'가 필요합니다. 값 "auto"는 `editor.detectIndentation` 설정에 의해 바뀌었습니다.',
+    '<Tab> 키를 누를 때 공백을 삽입합니다. `editor.detectIndentation`이 켜져 있는 경우 이 설정은 파일 콘텐츠에 따라 재정의됩니다.',
+    '\'boolean\'이 필요합니다. 값 "auto"는 `editor.detectIndentation` 설정에 의해 바뀌었습니다.',
+    "파일을 열면 파일 콘텐츠를 기반으로 하여 'editor.tabSize'와 'editor.insertSpaces'가 검색됩니다.",
+    '선택 항목의 모서리를 둥글게 할지 여부를 제어합니다.',
+    '편집기에서 마지막 줄 이후로 스크롤할지 여부를 제어합니다.',
+    '미니맵 표시 여부를 제어합니다.',
+    '미니맵 슬라이더를 자동으로 숨길지 결정합니다.',
+    '줄의 실제 문자(색 블록 아님) 렌더링',
+    '최대 특정 수의 열을 렌더링하도록 미니맵의 너비를 제한합니다.',
+    '편집기 선택에서 Find Widget의 검색 문자열을 시딩할지 설정합니다.',
+    '편집기에서 여러 글자 또는 행을 선택했을 때 Find in Selection 플래그를 켤지 설정합니다.',
+    '줄이 바뀌지 않습니다.',
+    '뷰포트 너비에서 줄이 바뀝니다.',
+    '`editor.wordWrapColumn`에서 줄이 바뀝니다.',
+    '뷰포트의 최소값 및 `editor.wordWrapColumn`에서 줄이 바뀝니다.',
+    "줄 바꿈 여부를 제어합니다. 다음 중 하나일 수 있습니다.\n - 'off' (줄 바꿈 사용 안 함),\n - 'on' (뷰포트 줄 바꿈),\n - 'wordWrapColumn' (`editor.wordWrapColumn`에서 줄 바꿈) 또는\n - 'bounded' (뷰포트의 최소값 및 `editor.wordWrapColumn`에서 줄 바꿈).",
+    "`editor.wordWrap`이 'wordWrapColumn' 또는 'bounded'인 경우 편집기의 열 줄 바꿈을 제어합니다.",
+    "줄 바꿈 행의 들여쓰기를 제어합니다. 'none', 'same' 또는 'indent' 중 하나일 수 있습니다.",
+    '마우스 휠 스크롤 이벤트의 `deltaX` 및 `deltaY`에서 사용할 승수',
+    "Windows와 Linux의 'Control'을 OSX의 'Command'로 매핑합니다.",
+    "Windows와 Linux의 'Alt'를 OSX의 'Option'으로 매핑합니다.",
+    '마우스로 여러 커서를 추가할 때 사용할 수정자입니다. `ctrlCmd`는 Windows와 Linux에서 `Control`로 매핑되고 OSX에서 `Command`로 매핑됩니다. Go To Definition 및 Open Link 마우스 제스처가 멀티커서 수정자와 충돌하지 않도록 조정됩니다.',
+    '문자열 내에서 빠른 제안을 사용합니다.',
+    '주석 내에서 빠른 제안을 사용합니다.',
+    '문자열 및 주석 외부에서 빠른 제안을 사용합니다.',
+    '입력하는 동안 제안을 자동으로 표시할지 여부를 제어합니다.',
+    '빠른 제안을 표시할 지연 시간(ms)을 제어합니다.',
+    '입력과 동시에 매개변수 문서와 유형 정보를 표시하는 팝업을 사용',
+    '괄호를 연 다음에 편집기에서 괄호를 자동으로 닫을지 여부를 제어합니다.',
+    '입력 후 편집기에서 자동으로 줄의 서식을 지정할지 여부를 제어합니다.',
+    '붙여넣은 콘텐츠의 서식을 편집기에서 자동으로 지정할지 여부를 제어합니다. 포맷터는 반드시 사용할 수 있어야 하며 문서에서 범위의 서식을 지정할 수 있어야 합니다.',
+    '사용자가 입력을 하거나 행을 붙여넣기 또는 이동할 때 편집기가 자동으로 들여쓰기를 적용할지 결정합니다. 해당 언어의 들여쓰기 규칙이 있어야 합니다.',
+    '트리거 문자를 입력할 때 제안을 자동으로 표시할지 여부를 제어합니다.',
+    "'Tab' 키 외에 'Enter' 키에 대한 제안도 허용할지를 제어합니다. 새 줄을 삽입하는 동작과 제안을 허용하는 동작 간의 모호함을 없앨 수 있습니다.",
+    "커밋 문자에 대한 제안을 허용할지를 제어합니다. 예를 들어 JavaScript에서는 세미콜론(';')이 제안을 허용하고 해당 문자를 입력하는 커밋 문자일 수 있습니다.",
+    '다른 제안 위에 조각 제안을 표시합니다.',
+    '다른 제안 아래에 조각 제안을 표시합니다.',
+    '다른 제안과 함께 조각 제안을 표시합니다.',
+    '코드 조각 제안을 표시하지 않습니다.\n',
+    '코드 조각이 다른 추천과 함께 표시되는지 여부 및 정렬 방법을 제어합니다.',
+    '선택 영역 없이 현재 줄 복사 여부를 제어합니다.',
+    '문서 내 단어를 기반으로 완성을 계산할지 여부를 제어합니다.',
+    '제안 위젯의 글꼴 크기',
+    '제안 위젯의 줄 높이',
+    '편집기에서 선택 항목과 유사한 일치 항목을 강조 표시할지 여부를 제어합니다.',
+    '편집기에서 의미 체계 기호 항목을 강조 표시할지 여부를 제어합니다.',
+    '개요 눈금자에서 동일한 위치에 표시될 수 있는 장식 수를 제어합니다.',
+    '개요 눈금자 주위에 테두리를 그릴지 여부를 제어합니다.',
+    "커서 애니메이션 스타일을 제어합니다. 가능한 값은 'blink', 'smooth', 'phase', 'expand' 및 'solid'입니다.",
+    '마우스 휠을 사용할 때 Ctrl 키를 누르고 있으면 편집기의 글꼴 확대/축소',
+    "커서 스타일을 제어합니다. 허용되는 값은 '블록', '블록-윤곽', '줄', '줄-가늘게', '밑줄' 및 '밑줄-가늘게'입니다.",
+    '글꼴 합자 사용',
+    '커서가 개요 눈금자에서 가려져야 하는지 여부를 제어합니다.',
+    "편집기에서 공백 문자를 렌더링하는 방법을 제어합니다. 가능한 값은 'none', 'boundary' 및 'all'입니다. 'boundary' 옵션은 단어 사이의 한 칸 공백을 렌더링하지 않습니다.",
+    '편집기에서 제어 문자를 렌더링할지를 제어합니다.',
+    '편집기에서 들여쓰기 가이드를 렌더링할지를 제어합니다.',
+    "편집기가 현재 줄 강조 표시를 렌더링하는 방식을 제어합니다. 가능한 값은 'none', 'gutter', 'line' 및 'all'입니다.",
+    '편집기에서 코드 필터를 표시하는지 여부를 제어합니다.',
+    '편집기에서 코드 접기를 사용할지 여부를 제어합니다.',
+    '거터의 폴드 컨트롤을 자동으로 숨길지 결정합니다.',
+    '대괄호 중 하나를 선택할 때 일치하는 대괄호를 강조 표시합니다.',
+    '편집기에서 세로 문자 모양 여백을 렌더링할지 여부를 제어합니다. 문자 모양 여백은 주로 디버깅에 사용됩니다.',
+    '탭 정지 뒤에 공백 삽입 및 삭제',
+    '끝에 자동 삽입된 공백 제거',
+    '해당 콘텐츠를 두 번 클릭하거나 <Esc> 키를 누르더라도 Peek 편집기를 열린 상태로 유지합니다.',
+    '편집기에서 끌어서 놓기로 선택 영역을 이동할 수 있는지 여부를 제어합니다.',
+    '편집기가 스크린 리더가 연결되면 플랫폼 API를 사용하여 감지합니다.',
+    '편집기가 스크린 리더 사용을 위해 영구적으로 최적화됩니다.',
+    '편집기가 스크린 리더 사용을 위해 최적화되지 않습니다.',
+    '편집기를 스크린 리더를 위해 최적화된 모드로 실행할지 결정합니다.',
+    '편집기에서 링크를 감지하고 클릭할 수 있게 만들지 결정합니다.',
+    'diff 편집기에서 diff를 나란히 표시할지 인라인으로 표시할지 여부를 제어합니다.',
+    'diff 편집기에서 선행 공백 또는 후행 공백 변경을 diffs로 표시할지 여부를 제어합니다.',
+    'diff 편집기에서 추가/제거된 변경 내용에 대해 +/- 표시기를 표시하는지 여부를 제어합니다.',
+    'Linux 주 클립보드의 지원 여부를 제어합니다.',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    '지금은 편집기를 사용할 수 없습니다. Alt+F1을 눌러 옵션을 보세요.',
+    '편집기 콘텐츠',
+  ],
+  'vs/editor/common/controller/cursor': ['명령을 실행하는 동안 예기치 않은 예외가 발생했습니다.'],
+  'vs/editor/common/model/textModelWithTokens': [
+    '입력을 토큰화하는 동안 모드에서 오류가 발생했습니다.',
+  ],
+  'vs/editor/common/modes/modesRegistry': ['일반 텍스트'],
+  'vs/editor/common/services/bulkEdit': [
+    '이러한 파일이 동시에 변경되었습니다. {0}',
+    '편집하지 않음',
+    '{1}개 파일에서 {0}개 텍스트 편집을 수행함',
+    '1개 파일에서 {0}개 텍스트 편집을 수행함',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    '커서 위치의 줄 강조 표시에 대한 배경색입니다.',
+    '커서 위치의 줄 테두리에 대한 배경색입니다.',
+    '빠른 열기 및 찾기 기능 등을 통해 강조 표시된 영역의 배경색입니다.',
+    '편집기 커서 색입니다.',
+    '편집기 커서의 배경색입니다. 블록 커서와 겹치는 글자의 색상을 사용자 정의할 수 있습니다.',
+    '편집기의 공백 문자 색입니다.',
+    '편집기 들여쓰기 안내선 색입니다.',
+    '편집기 줄 번호 색입니다.',
+    '편집기 눈금의 색상입니다.',
+    '편집기 코드 렌즈의 전경색입니다.',
+    '일치하는 브래킷 뒤의 배경색입니다.',
+    '일치하는 브래킷 박스의 색상',
+    '개요 눈금 경계의 색상입니다.',
+    '편집기 거터의 배경색입니다. 거터에는 글리프 여백과 행 수가 있습니다.',
+    '편집기 내 오류 표시선의 전경색입니다.',
+    '편집기 내 오류 표시선의 테두리 색입니다.',
+    '편집기 내 경고 표시선의 전경색입니다.',
+    '편집기 내 경고 표시선의 테두리 색입니다.',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['대괄호로 이동'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    '캐럿을 왼쪽으로 이동',
+    '캐럿을 오른쪽으로 이동',
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['문자 바꾸기'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    '잘라내기',
+    '복사',
+    '붙여넣기',
+    '구문을 강조 표시하여 복사',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    '줄 주석 설정/해제',
+    '줄 주석 추가',
+    '줄 주석 제거',
+    '블록 주석 설정/해제',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['편집기 상황에 맞는 메뉴 표시'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    '찾기',
+    '찾기',
+    '이전 검색 결과',
+    '다음 검색 결과',
+    '선택 항목에서 찾기',
+    '닫기',
+    '바꾸기',
+    '바꾸기',
+    '바꾸기',
+    '모두 바꾸기',
+    '바꾸기 모드 설정/해제',
+    '처음 999개의 결과가 강조 표시되지만 모든 찾기 작업은 전체 텍스트에 대해 수행됩니다.',
+    '{0}/{1}',
+    '결과 없음',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    '찾기',
+    '다음 찾기',
+    '이전 찾기',
+    '다음 선택 찾기',
+    '이전 선택 찾기',
+    '바꾸기',
+    '다음 일치 항목 찾기에 선택 항목 추가',
+    '이전 일치 항목 찾기에 선택 항목 추가',
+    '다음 일치 항목 찾기로 마지막 선택 항목 이동',
+    '마지막 선택 항목을 이전 일치 항목 찾기로 이동',
+    '일치 항목 찾기의 모든 항목 선택',
+    '모든 항목 변경',
+    '다음 검색어 표시',
+    '이전 검색어 표시',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    '펼치기',
+    '재귀적으로 펼치기',
+    '접기',
+    '재귀적으로 접기',
+    '모두 접기',
+    '모두 펼치기',
+    '수준 {0} 접기',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    '줄 {0}에서 1개 서식 편집을 수행했습니다.',
+    '줄 {1}에서 {0}개 서식 편집을 수행했습니다.',
+    '줄 {0}과(와) {1} 사이에서 1개 서식 편집을 수행했습니다.',
+    '줄 {1}과(와) {2} 사이에서 {0}개 서식 편집을 수행했습니다.',
+    '문서 서식',
+    '선택 영역 서식',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    "'{0}'에 대한 정의를 찾을 수 없습니다.",
+    '정의를 찾을 수 없음',
+    '– {0} 정의',
+    '정의로 이동',
+    '측면에서 정의 열기',
+    '정의 피킹(Peeking)',
+    "'{0}'에 대한 구현을 찾을 수 없습니다.",
+    '구현을 찾을 수 없습니다.',
+    ' – {0} 개 구현',
+    '구현으로 이동',
+    '구현 미리 보기',
+    "'{0}'에 대한 형식 정의를 찾을 수 없습니다.",
+    '형식 정의를 찾을 수 없습니다.',
+    '– {0} 형식 정의',
+    '형식 정의로 이동',
+    '형식 정의 미리 보기',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    '{0}개 정의를 표시하려면 클릭하세요.',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    '다음 오류 또는 경고로 이동',
+    '이전 오류 또는 경고로 이동',
+    '편집기 표식 탐색 위젯 오류 색입니다.',
+    '편집기 표식 탐색 위젯 경고 색입니다.',
+    '편집기 표식 탐색 위젯 배경입니다.',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['가리키기 표시'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['로드 중...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': [
+    '이전 값으로 바꾸기',
+    '다음 값으로 바꾸기',
+  ],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    '위에 줄 복사',
+    '아래에 줄 복사',
+    '줄 위로 이동',
+    '줄 아래로 이동',
+    '줄을 오름차순 정렬',
+    '줄을 내림차순으로 정렬',
+    '후행 공백 자르기',
+    '줄 삭제',
+    '줄 들여쓰기',
+    '줄 내어쓰기',
+    '위에 줄 삽입',
+    '아래에 줄 삽입',
+    '왼쪽 모두 삭제',
+    '우측에 있는 항목 삭제',
+    '줄 연결',
+    '커서 주위 문자 바꾸기',
+    '대문자로 변환',
+    '소문자로 변환',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'Cmd 키를 누르고 클릭하여 링크로 이동',
+    'Ctrl 키를 누르고 클릭하여 링크로 이동',
+    '명령을 실행하려면 Cmd+클릭',
+    '명령을 실행하려면 Ctrl+클릭',
+    'Alt 키를 누르고 클릭하여 링크로 이동',
+    '명령을 실행하려면 Alt+클릭',
+    '죄송합니다. 이 링크는 형식이 올바르지 않으므로 열지 못했습니다. {0}',
+    '죄송합니다. 대상이 없으므로 이 링크를 열지 못했습니다.',
+    '링크 열기',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    '위에 커서 추가',
+    '아래에 커서 추가',
+    '줄 끝에 커서 추가',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['매개 변수 힌트 트리거'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}, 힌트'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    '수정 사항 표시({0})',
+    '수정 사항 표시',
+    '빠른 수정',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': ['–참조 {0}개', '모든 참조 찾기'],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['로드 중...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    '{2}열, {1}줄, {0}의 기호',
+    '{0}의 기호 1개, 전체 경로 {1}',
+    '{1}의 기호 {0}개, 전체 경로 {2}',
+    '결과 없음',
+    '{0}에서 기호 1개를 찾았습니다.',
+    '{1}에서 기호 {0}개를 찾았습니다.',
+    '{1}개 파일에서 기호 {0}개를 찾았습니다.',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    '파일을 확인하지 못했습니다.',
+    '참조 {0}개',
+    '참조 {0}개',
+    '미리 보기를 사용할 수 없음',
+    '참조',
+    '결과 없음',
+    '참조',
+    'Peek 뷰 제목 영역의 배경색입니다.',
+    'Peek 뷰 제목 색입니다.',
+    'Peek 뷰 제목 정보 색입니다.',
+    'Peek 뷰 테두리 및 화살표 색입니다.',
+    'Peek 뷰 결과 목록의 배경색입니다.',
+    'Peek 뷰 결과 목록에서 라인 노드의 전경색입니다.',
+    'Peek 뷰 결과 목록에서 파일 노드의 전경색입니다.',
+    'Peek 뷰 결과 목록에서 선택된 항목의 배경색입니다.',
+    'Peek 뷰 결과 목록에서 선택된 항목의 전경색입니다.',
+    'Peek 뷰 편집기의 배경색입니다.',
+    'Peek 뷰 편집기의 거터 배경색입니다.',
+    'Peek 뷰 결과 목록의 일치 항목 강조 표시 색입니다.',
+    'Peek 뷰 편집기의 일치 항목 강조 표시 색입니다.',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    '결과가 없습니다.',
+    "'{0}'을(를) '{1}'(으)로 이름을 변경했습니다. 요약: {2}",
+    '죄송합니다. 이름 바꾸기를 실행하지 못했습니다.',
+    '기호 이름 바꾸기',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    '입력 이름을 바꾸세요. 새 이름을 입력한 다음 [Enter] 키를 눌러 커밋하세요.',
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['선택 확장', '선택 축소'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    "'{0}'을(를) 적용하여 다음 텍스트가 삽입되었습니다.\n {1}",
+    '제안 항목 트리거',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    '제안 위젯의 배경색입니다.',
+    '제안 위젯의 테두리 색입니다.',
+    '제안 위젯의 전경색입니다.',
+    '제한 위젯에서 선택된 항목의 배경색입니다.',
+    '제안 위젯의 일치 항목 강조 표시 색입니다.',
+    '자세히 알아보기...{0}',
+    '{0}, 제안, 세부 정보 있음',
+    '{0}, 제안',
+    '간단히 보기...{0}',
+    '로드 중...',
+    '제안 항목이 없습니다.',
+    '{0}, 수락됨',
+    '{0}, 제안, 세부 정보 있음',
+    '{0}, 제안',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': [
+    '<Tab> 키로 포커스 이동 설정/해제',
+  ],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    '변수 읽기와 같은 읽기 액세스 중 기호의 배경색입니다.',
+    '변수에 쓰기와 같은 쓰기 액세스 중 기호의 배경색입니다.',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['닫기'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    '기본 구성 재정의',
+    '{0} 언어에 대해 재정의할 편집기 설정을 구성합니다.',
+    '언어에 대해 재정의할 편집기 설정을 구성합니다.',
+    "'{0}'을(를) 등록할 수 없습니다. 이는 언어별 편집기 설정을 설명하는 속성 패턴인 '\\\\[.*\\\\]$'과(와) 일치합니다. 'configurationDefaults' 기여를 사용하세요.",
+    "'{0}'을(를) 등록할 수 없습니다. 이 속성은 이미 등록되어 있습니다.",
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    '({0})을(를) 눌렀습니다. 둘째 키는 잠시 기다렸다가 누르세요.',
+    '키 조합({0}, {1})은 명령이 아닙니다.',
+  ],
+  'vs/platform/message/common/message': ['닫기', '나중에', '취소'],
+  'vs/platform/theme/common/colorRegistry': [
+    '잘못된 색 형식입니다. #RGB, #RGBA, #RRGGBB 또는 #RRGGBBAA를 사용하세요.',
+    '워크벤치에서 사용되는 색입니다.',
+    '전체 전경색입니다. 이 색은 구성 요소에서 재정의하지 않은 경우에만 사용됩니다.',
+    '오류 메시지에 대한 전체 전경색입니다. 이 색은 구성 요소에서 재정의하지 않은 경우에만 사용됩니다.',
+    '레이블과 같이 추가 정보를 제공하는 설명 텍스트의 전경색입니다.',
+    '포커스가 있는 요소의 전체 테두리 색입니다. 이 색은 구성 요소에서 재정의하지 않은 경우에만 사용됩니다.',
+    '더 뚜렷이 대비되도록 요소를 다른 요소와 구분하는 요소 주위의 추가 테두리입니다.',
+    '더 뚜렷이 대비되도록 요소를 다른 요소와 구분하는 활성 요소 주위의 추가 테두리입니다.',
+    '워크벤치의 텍스트 선택(예: 입력 필드 또는 텍스트 영역) 전경색입니다. 편집기 내의 선택에는 적용되지 않습니다.',
+    '텍스트 구분자 색상입니다.',
+    '텍스트 내 링크의 전경색입니다.',
+    '텍스트 내 활성 링크의 전경색입니다.',
+    '미리 서식이 지정된 텍스트 세그먼트의 전경색입니다.',
+    '텍스트 내 블록 인용의 전경색입니다.',
+    '텍스트 내 블록 인용의 테두리 색입니다.',
+    '텍스트 내 코드 블록의 전경색입니다.',
+    '편집기 내에서 찾기/바꾸기 같은 위젯의 그림자 색입니다.',
+    '입력 상자 배경입니다.',
+    '입력 상자 전경입니다.',
+    '입력 상자 테두리입니다.',
+    '입력 필드에서 활성화된 옵션의 테두리 색입니다.',
+    '위치 표시자 텍스트에 대한 입력 상자 전경색입니다.',
+    '정보 심각도의 입력 유효성 검사 배경색입니다.',
+    '정보 심각도의 입력 유효성 검사 테두리 색입니다.',
+    '정보 경고의 입력 유효성 검사 배경색입니다.',
+    '경고 심각도의 입력 유효성 검사 테두리 색입니다.',
+    '오류 심각도의 입력 유효성 검사 배경색입니다.',
+    '오류 심각도의 입력 유효성 검사 테두리 색입니다.',
+    '드롭다운 배경입니다.',
+    '드롭다운 전경입니다.',
+    '드롭다운 테두리입니다.',
+    '목록/트리가 활성 상태인 경우 포커스가 있는 항목의 목록/트리 배경색입니다. 목록/트리가 활성 상태이면 키보드 포커스를 가지며, 비활성 상태이면 포커스가 없습니다.',
+    '목록/트리가 활성 상태인 경우 포커스가 있는 항목의 목록/트리 전경색입니다. 목록/트리가 활성 상태이면 키보드 포커스를 가지며, 비활성 상태이면 포커스가 없습니다.',
+    '목록/트리가 활성 상태인 경우 선택한 항목의 목록/트리 배경색입니다. 목록/트리가 활성 상태이면 키보드 포커스를 가지며, 비활성 상태이면 포커스가 없습니다.',
+    '목록/트리가 활성 상태인 경우 선택한 항목의 목록/트리 전경색입니다. 목록/트리가 활성 상태이면 키보드 포커스를 가지며, 비활성 상태이면 포커스가 없습니다.',
+    '목록/트리가 비활성 상태인 경우 선택한 항목의 목록/트리 배경색입니다. 목록/트리가 활성 상태이면 키보드 포커스를 가지며, 비활성 상태이면 포커스가 없습니다.',
+    '목록/트리가 비활성 상태인 경우 선택한 항목의 목록/트리 전경색입니다. 목록/트리가 활성 상태이면 키보드 포커스를 가지며, 비활성 상태이면 포커스가 없습니다.',
+    '목록/트리가 비활성 상태인 경우 선택한 항목의 목록/트리 배경색입니다. 목록/트리가 활성 상태이면 키보드 포커스를 가지며, 비활성 상태이면 포커스가 없습니다.',
+    '목록/트리가 비활성 상태인 경우 선택한 항목의 목록/트리 전경색입니다. 목록/트리가 활성 상태이면 키보드 포커스를 가지며, 비활성 상태이면 포커스가 없습니다.',
+    '마우스로 항목을 가리킬 때 목록/트리 배경입니다.',
+    '마우스로 항목을 가리킬 때 목록/트리 전경입니다.',
+    '마우스로 항목을 이동할 때 목록/트리 끌어서 놓기 배경입니다.',
+    '목록/트리 내에서 검색할 때 일치 항목 강조 표시의 목록/트리 전경색입니다.',
+    '그룹화 레이블에 대한 빠른 선택기 색입니다.',
+    '그룹화 테두리에 대한 빠른 선택기 색입니다.',
+    '단추 기본 전경색입니다.',
+    '단추 배경색입니다.',
+    '마우스로 가리킬 때 단추 배경색입니다.',
+    '배지 배경색입니다. 배지는 검색 결과 수와 같은 소량의 정보 레이블입니다.',
+    '배지 전경색입니다. 배지는 검색 결과 수와 같은 소량의 정보 레이블입니다.',
+    '스크롤되는 보기를 나타내는 스크롤 막대 그림자입니다.',
+    '스크롤 막대 슬라이버 배경색입니다.',
+    '마우스로 가리킬 때 스크롤 막대 슬라이더 배경색입니다.',
+    '활성 상태일 때 스크롤 막대 슬라이더 배경색입니다.',
+    '오래 실행 중인 작업에 대해 표시되는 진행률 표시 막대의 배경색입니다.',
+    '편집기 배경색입니다.',
+    '편집기 기본 전경색입니다.',
+    '찾기/바꾸기 같은 편집기 위젯의 배경색입니다.',
+    '편집기 위젯의 테두리 색입니다. 위젯에 테두리가 있고 위젯이 색상을 무시하지 않을 때만 사용됩니다.',
+    '편집기 선택 영역의 색입니다.',
+    '고대비를 위한 선택 텍스트의 색입니다.',
+    '비활성 편집기 선택 영역의 색입니다.',
+    '선택 영역과 동일한 콘텐츠가 있는 영역의 색입니다.',
+    '현재 검색 일치 항목의 색입니다.',
+    '기타 검색 일치 항목의 색입니다.',
+    '검색을 제한하는 영역의 색을 지정합니다.',
+    '호버가 표시된 단어 아래를 강조 표시합니다.',
+    '편집기 호버의 배경색.',
+    '편집기 호버의 테두리 색입니다.',
+    '활성 링크의 색입니다.',
+    '삽입된 텍스트의 배경색입니다.',
+    '제거된 텍스트의 배경색입니다.',
+    '삽입된 텍스트의 윤곽선 색입니다.',
+    '제거된 텍스트의 윤곽선 색입니다.',
+    '인라인 병합 충돌의 현재 헤더 배경입니다.',
+    '인라인 병합 충돌의 현재 콘텐츠 배경입니다.',
+    '인라인 병합 충돌에서 수신 헤더 배경입니다.',
+    '인라인 병합 충돌에서 수신 콘텐츠 배경입니다.',
+    '인라인 병합 충돌의 공통 과거 헤더 배경입니다.',
+    '인라인 병합 충돌의 공통 과거 콘텐츠 배경입니다.',
+    '인라인 병합 충돌에서 헤더 및 스플리터의 테두리 색입니다.',
+    '인라인 병합 충돌에서 현재 개요 눈금 전경색입니다.',
+    '인라인 병합 충돌에서 수신 개요 눈금 전경색입니다.',
+    '인라인 병합 충돌에서 공통 과거 개요 눈금 전경색입니다.',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.ko.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.pt-br.js

@@ -0,0 +1,537 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.pt-br', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (ocorreu novamente)'],
+  'vs/base/browser/ui/findinput/findInput': ['entrada'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    'Diferenciar Maiúsculas de Minúsculas',
+    'Coincidir Palavra Inteira',
+    'Usar Expressão Regular',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['Erro: {0}', 'Aviso: {0}', 'Informações: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'Ctrl',
+    'Shift',
+    'Alt',
+    'Windows',
+    'Control',
+    'Shift',
+    'Alt',
+    'Comando',
+    'Control',
+    'Shift',
+    'Alt',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['Erro', 'Aviso', 'Informações'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}, seletor', 'seletor'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    'Seletor rápido. Digite para filtrar resultados.',
+    'Seletor rápido',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['Recolher'],
+  'vs/editor/browser/widget/diffEditorWidget': [
+    'Não é possível comparar os arquivos pois um deles é muito grande.',
+  ],
+  'vs/editor/browser/widget/diffReview': [
+    'Fechar',
+    'Diferença {0} de {1}: original {2}, {3} linhas, modificado {4}, {5} linhas',
+    'branco',
+    'original {0}, modificados {1}: {2}',
+    '+ modificado {0}: {1}',
+    '-original {0}: {1}',
+    'Ir para a próxima diferença',
+    'Ir para a diferença anterior',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    'Editor',
+    'Controla a família de fontes.',
+    'Controla o peso da fonte.',
+    'Controla o tamanho da fonte em pixels.',
+    'Controla a altura da linha. Use 0 para computar a altura da linha a partir do tamanho da fonte.',
+    'Controla o espaçamento da letra em pixels.',
+    "Controla a exibição de números de linha. Valores possíveis são 'on', 'off' e 'relative'. 'relative' mostra a contagem de linhas a partir da posição atual do cursor.",
+    'Colunas nas quais mostrar réguas verticais',
+    'Caracteres que serão usados como separadores de palavras ao fazer navegação relacionada a palavras ou operações',
+    'O número de espaços equivalentes a uma tabulação. Esta configuração é sobreposta no conteúdo do arquivo quando `editor.detectIndentation` está ligado.',
+    "Esperado 'número'. Note que o valor \"auto\" foi alterado pela configuração 'editor.detectIndentation'.",
+    "Insere espaços quanto pressionado Tab. Esta configuração é sobrescrita com base no conteúdo do arquivo quando 'editor.detectIndentation' está habilitado.",
+    "Esperado 'booleano'. Note que o valor \"auto\" foi alterado pela configuração 'editor.detectIndentation'.",
+    "Quando um arquivo está sendo aberto, 'editor.tabSize' e 'editor.insertSpace' será detectado com base no conteúdo do arquivo.",
+    'Controla se as seleções têm cantos arredondados',
+    'Controla se o editor rolará além da última linha',
+    'Controla se o mini mapa é exibido',
+    'Controla se o controle deslizante minimap é oculto automaticamente.',
+    'Renderizar os caracteres em uma linha (em oposição a blocos de caracteres)',
+    'Limitar o tamanho de um mini-mapa para renderizar no máximo um número determinado de colunas',
+    'Controla se nós inicializamos a string de pesquisa na Ferramenta de Pesquisa a partir da seleção do editor',
+    'Controla se a configuração Find in Selection deve estar ativada quando vários caracteres ou linhas de texto estão selecionados no editor',
+    'As linhas nunca serão quebradas.',
+    'As linhas serão quebradas na largura de visualização',
+    'As linhas serão quebradas em `editor.wordWrapColumn`.',
+    'As linhas serão quebradas no mínimo entre a largura de visualização e `editor.wordWrapColumn`.',
+    "Controla como as linhas devem ser quebradas automaticamente. Pode ser:\n- 'off' (quebra automática de linha desabilitada)\n- 'on' (quebra automática de linha na largura da janela)\n- 'wordWrapColumn' (quebra automática no numero de colunas definido em  `editor.wordWrapColumn`) ou\n- 'bounded' (quebra automática em uma dimensão minima da janela e na largura configurada)",
+    "Controla a coluna de quebra de linha do editor quando editor.wordWrap` é 'wordWrapColumn' ou 'bounded'.",
+    'Controla o recuo de linhas quebradas. Pode ser "none", "same" ou "indent".',
+    'Um multiplicador a ser usado em "deltaX" e "deltaY" dos eventos de rolagem do botão de rolagem do mouse',
+    "Mapeia para 'Control' no Windows e Linux e 'Command' no OSX.",
+    "Mapeia para 'Alt' em Windows e Linux e 'Option' em OSX.",
+    "O modificador a ser usado para adicionar vários cursores com o mouse. `ctrlCmd` mapeia 'Control' no Windows e Linux e 'Command' no OSX. Os gestos do mouse Ir para definição e Abrir Link irão adaptar-se tal maneira que eles não entrem em conflito com o modificador multicursor.",
+    'Habilitar sugestões rápidas dentro de strings.',
+    'Habilitar sugestões rápidas dentro de comentários.',
+    'Habilitar sugestões rápidas fora de strings e comentários.',
+    'Controlar se sugestões devem aparecer automaticamente ao digitar',
+    'Controla o atraso em ms após o qual sugestões rápidas serão exibidas',
+    'Habilita pop-up que mostra documentação de parâmetros e o tipo de informação conforme você digita',
+    'Controla se o editor deve fechar colchetes automaticamente depois de abri-los',
+    'Controla se o editor deve formatar automaticamente a linha após a digitação',
+    'Controla se o editor deve formatar automaticamente o conteúdo colado. Um formatador deve estar disponível e o formatador deve ser capaz de formatar apenas uma parte do documento.',
+    'Controles se o editor deve ajustar automaticamente o recuo, quando os usuários digitam, colam ou movem linhas. Regras de recuo da língua devem estar disponíveis. ',
+    'Controla se as sugestões devem aparecer automaticamente ao digitar caracteres de gatilho',
+    "Controla se as sugestões devem ser aceitas com 'Enter' - em adição a 'Tab'. Ajuda a evitar a ambiguidade entre a inserção de novas linhas ou aceitar sugestões. O valor 'smart' significa apenas aceitar uma sugestão com Enter quando ela fizer uma mudança textual",
+    "Controla se as sugestões devem ser aceitas em caracteres de confirmação. Por exemplo, em JavaScript, o ponto-e-vírgula (';') pode ser um caractere de confirmação que aceita uma sugestão e digita esse caractere.",
+    'Mostre sugestões de trecho acima de outras sugestões.',
+    'Mostre sugestões de trecho abaixo de outras sugestões.',
+    'Mostre sugestões de trechos com outras sugestões.',
+    'Não mostre sugestões de trecho.',
+    'Controla se os snippets são exibidos juntamente com as outras sugestões e como eles são ordenados.',
+    'Controla se a cópia sem nenhuma seleção copia a linha atual.',
+    'Controla se o auto-completar deve ser calculado baseado nas palavras no documento.',
+    'Tamanho da fonte para a ferramenta de sugestão',
+    'Altura de linha para a ferramenta de sugestão',
+    'Controla se o editor deve realçar correspondências semelhantes à seleção',
+    'Controla se o editor deve realçar ocorrências de símbolos semânticos.',
+    'Controla o número de decorações que podem ser exibidas na mesma posição na régua de visão geral',
+    'Controla se deve desenhar uma borda ao redor da régua de visão geral.',
+    "Controla o estilo de animação do cursor, os valores possíveis são 'blink', 'smooth', 'phase', 'expand' e 'solid'",
+    'Alterar o zoom da fonte editor quando utilizada a roda do mouse e pressionando Ctrl',
+    "Controla o estilo do cursor, os valores aceitos são 'block', 'block-outline', 'line', 'line-thin', 'underline' e 'underline-thin'",
+    'Habilita ligaduras de fontes',
+    'Controla se o cursor deve ficar oculto na régua de visão geral.',
+    "Controla como o editor deve rendenizar caracteres de espaços em branco, possibilidades são 'none', 'boundary' e 'all'. A opção 'boundary' não rendeniza espaços simples entre palavras.",
+    'Controla se o editor deve renderizar caracteres de controle',
+    'Controla se o editor deve renderizar guias de identação',
+    "Controla como o editor deve renderizar a linha atual, as possibilidades são 'none', 'gutter', 'line' e 'all'.",
+    'Controla se o editor exibirá a lente de códigos.',
+    'Controla se o editor tem codigo colapsível hablitado',
+    'Controla se os controles de desdobramento na divisão são ocultas automaticamente.',
+    'Realça colchetes correspondente quando um deles estiver selecionado.',
+    'Controla se o editor deve renderizar a margem vertical de ícones. A margem vertical de ícones é usada primordialmente na depuração',
+    'Inserção e deleção de espaço em branco seguem a tabulação',
+    'Remove espaços em branco inseridos automaticamente no fim da linha',
+    'Mantém os editores de visualização abertos mesmo quando clicando seu conteúdo ou teclando Escape.',
+    'Controla se o editor deve permitir mover seleções via arrastar e soltar.',
+    'O editor irá utilizar a plataforma da API para detectar quando um leitor de tela está conectado.',
+    'O editor será permanentemente otimizado para o uso de um leitor de tela.',
+    'O editor nunca será otimizado para o uso de um leitor de tela.',
+    'Controla quando o editor deve executar em modo otimizado para leitores de tela.',
+    'Controla se o editor deve detectar links e torná-los clicáveis',
+    'Controla se o editor de diff mostra as diff lado a lado ou inline.',
+    'Controla se o editor de diff mostra alterações nos espaços iniciais ou finais como diferenças',
+    'Controla se o editor de diff mostra indicadores +/- para alterações adicionadas/removidas',
+    'Controla se a área primária de transferência Linux deve ser suportada.',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    'O editor não está acessível neste momento. Por favor pressione Alt+F1 para opções.',
+    'Conteúdo do editor',
+  ],
+  'vs/editor/common/controller/cursor': ['Exceção inesperada ao executar o comando.'],
+  'vs/editor/common/model/textModelWithTokens': ['O modo falhou ao gerar token da entrada.'],
+  'vs/editor/common/modes/modesRegistry': ['Texto sem formatação'],
+  'vs/editor/common/services/bulkEdit': [
+    'Estes arquivos foram alterados nesse meio tempo: {0}',
+    'Não foram feitas edições',
+    'Feitas {0} edições de texto em {1} arquivos',
+    'Feitas {0} edições de texto em um arquivo',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}] {1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    'Cor de fundo para a posição do cursor  na seleção de linhas.',
+    'Cor de fundo para a borda em volta da linha na posição do cursor',
+    'Cor de fundo dos ranges selecionados, assim como abertura instantânea e descoberta de recursos ',
+    'Cor do cursor no editor.',
+    'A cor de fundo do cursor do editor. Permite customizar a cor de um caractere sobreposto pelo bloco do cursor.',
+    'Cor dos caracteres em branco no editor',
+    'Cor das guias de indentação do editor.',
+    'Cor dos números de linha do editor.',
+    'Cor das réguas do editor.',
+    'Cor do primeiro plano das lentes de código do editor',
+    'Cor de fundo atrás do colchetes correspondentes',
+    'Cor para as caixas de colchetes correspondentes',
+    'Cor da borda da régua de visão geral.',
+    'Cor de fundo da separação do editor.O separador contém os glifos das margens e os números de linha.',
+    'Cor do primeiro plano das linhas onduladas de erro no editor.',
+    'Cor da borda das linhas onduladas de erro no editor.',
+    'Cor do primeiro plano de linhas onduladas de aviso no editor.',
+    'Cor da borda das linhas onduladas de aviso no editor.',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['Ir para colchete'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    'Mover cursor para a esquerda',
+    'Mover cursor para a direita',
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['Transport letras'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    'Recortar',
+    'Copiar',
+    'Colar',
+    'Copiar com realce de sintaxe',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    'Alternar Comentário de Linha',
+    'Adicionar Comentário de Linha',
+    'Remover Comentário de Linha',
+    'Alternar Comentário de Bloco',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['Mostrar o menu de contexto do editor'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    'Localizar',
+    'Localizar',
+    'Correspondência anterior',
+    'Próxima correspondência',
+    'Localizar na seleção',
+    'Fechar',
+    'Substituir',
+    'Substituir',
+    'Substituir',
+    'Substituir Tudo',
+    'Ativar/desativar modo Substituir',
+    'Somente os primeiros 999 resultados são realçados, mas todas as operações de pesquisa funcionam em todo o texto.',
+    '{0} de {1}',
+    'Nenhum resultado',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    'Localizar',
+    'Localizar Próximo',
+    'Localizar anterior',
+    'Localizar Próxima Seleção',
+    'Localizar Seleção Anterior',
+    'Substituir',
+    'Adicionar Seleção ao Próximo Localizar Correspondência',
+    'Adicionar Seleção à Correspondência de Localização Anterior',
+    'Mover Última Seleção para Próximo Localizar Correspondência',
+    'Mover Última Seleção para Correspondência de Localização Anterior',
+    'Selecionar Todas as Ocorrências de Localizar Correspondência',
+    'Alterar todas as ocorrências',
+    'Mostrar Próximo Termo de Busca',
+    'Mostrar Termo de Busca Anterior',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    'Abrir',
+    'Abrir recursivamente',
+    'Colapsar',
+    'Colapsar recursivamente',
+    'Colapsar tudo',
+    'Abrir tudo',
+    'Nível de colapsamento {0}',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    '1 edição de formatação feita na linha {0}',
+    '{0} edições de formatação feitas na linha {1}',
+    'Feita 1 edição de formatação entre as linhas {0} e {1}',
+    'Feitas {0} edições de formatação entre as linhas {1} e {2}',
+    'Formatar Documento',
+    'Formatar Seleção',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    "Não foi encontrada definição para '{0}'",
+    'Nenhuma definição encontrada',
+    '- {0} definições',
+    'Ir para Definição',
+    'Abrir definição ao lado',
+    'Inspecionar definição',
+    "Nenhuma implementação encontrada para '{0}'",
+    'Nenhuma implementação encontrada',
+    '– {0} implementações',
+    'Ir para a implementação',
+    'Inspecionar implementação',
+    "Nenhuma definição encontrada para '{0}'",
+    'Nenhuma definição de tipo encontrada',
+    '– {0} definições de tipos',
+    'Ir para a definição de tipo',
+    'Inspecionar definição de tipo',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    'Clique para mostrar {0} definições.',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    'Ir para o Próximo Erro ou Aviso',
+    'Ir para o Erro ou Aviso Anterior',
+    'Ferramenta de marcação de edição apresentando error na cor ',
+    'Ferramenta de marcação de edição apresentando adventência na cor',
+    'Cor de fundo da ferramenta de marcação de navegação do editor.',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['Mostrar Item Flutuante'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['Carregando...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': [
+    'Substituir pelo valor anterior',
+    'Substituir pelo próximo valor',
+  ],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    'Copiar linha acima',
+    'Copiar linha abaixo',
+    'Mover linha para cima',
+    'Mover linha para baixo',
+    'Classificar Linhas Ascendentemente',
+    'Classificar Linhas Descendentemente',
+    'Cortar Espaço em Branco à Direita',
+    'Excluir linha',
+    'Recuar linha',
+    'Recuar linha para a esquerda',
+    'Inserir linha acima',
+    'Inserir linha abaixo',
+    'Excluir tudo à Esquerda',
+    'Excluir Tudo à Direita',
+    'Unir Linhas',
+    'Transpor caracteres ao redor do cursor',
+    'Transformar para maiúsculas',
+    'Transformar para minúsculas',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'Cmd + clique para seguir o link',
+    'Ctrl + clique para seguir o link',
+    'Cmd + clique para executar o comando',
+    'CTRL + clique para executar o comando',
+    'Alt + clique para seguir o link',
+    'Alt + clique para executar o comando',
+    'Desculpe, falha ao abrir este link porque ele não está bem formatado: {0}',
+    'Desculpe, falha ao abrir este link porque seu destino está faltando.',
+    'Abrir link',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    'Inserir cursor acima',
+    'Inserir cursor abaixo',
+    'Adicionar Cursores ao Final das Linhas',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['Dicas de parâmetro de gatilho'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}, dica'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    'Mostrar correções ({0})',
+    'Mostrar correções',
+    'Correção Rápida',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [
+    '- {0} referências',
+    'Localizar Todas as Referências',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['Carregando...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    'símbolo em {0} na linha {1} e coluna {2}',
+    '1 símbolo em {0}, caminho completo {1}',
+    '{0} símbolos em {1}, caminho completo {2}',
+    'Nenhum resultado encontrado',
+    'Encontrado 1 símbolo em {0}',
+    'Encontrados {0} símbolos em {1}',
+    'Encontrados {0} símbolos em {1} arquivos',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    'Falha ao resolver arquivo.',
+    '{0} referências',
+    '{0} referência',
+    'nenhuma visualização disponível',
+    'Referências',
+    'Nenhum resultado',
+    'Referências',
+    'Cor de fundo da área de visualização do título.',
+    'Cor de visualização do título.',
+    'Cor da visualização de informações do título.',
+    'Cor das bordas e seta da área de visualização',
+    'Cor de fundo da área de visualização da lista de resultados.',
+    'Cor de primeiro plano para nós de linha na lista de resultados visualizados.',
+    'Cor de primeiro plano para nós de arquivos na lista de resultados visualizados.',
+    'Cor de fundo da entrada selecionada na visualização da lista de resultados.',
+    'Cor da entrada selecionada na visualização da lista de resultados.',
+    'Cor de fundo da visualização do editor.',
+    'Cor de fundo da separação na visualização rápida do editor.',
+    'Corresponder cor de realce com visualização da lista de resultados.',
+    'Corresponder cor de realce com visualização do editor.',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    'Nenhum resultado.',
+    "Renomeado '{0}' para '{1}'com sucesso. Resumo: {2}",
+    'Desculpe, falha na execução de renomear.',
+    'Renomear Símbolo',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    'Renomear entrada. Digite o novo nome e tecle Enter para gravar.',
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['Expandir seleção', 'Reduzir seleção'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    "Ao aceitar '{0}' foi inserido o seguinte texto: {1}",
+    'Sugestão de gatilho',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    'Cor de fundo para a ferramenta de sugestão.',
+    'Cor da borda para a ferramenta de sugestão.',
+    'Cor de primeiro plano para a ferramenta de sugestão.',
+    'Cor de fundo da entrada selecionada da ferramenta de sugestões.',
+    'Cor de realce da correspondência na ferramenta de sugestão.',
+    'Ler Mais...{0}',
+    '{0}, sugestão, tem detalhes',
+    '{0}, sugestão',
+    'Ler menos... {0}',
+    'Carregando...',
+    'Nenhuma sugestão.',
+    '{0}, aceito',
+    '{0}, sugestão, tem detalhes',
+    '{0}, sugestão',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': [
+    'Alterne o uso da tecla Tab para mover o foco',
+  ],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    'Cor de fundo de um símbolo durante acesso de leitura, como ao ler uma variável.',
+    'Cor de fundo de um símbolo durante acesso de escrita, como ao escrever uma variável.',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['Fechar'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    'Sobreposições da Configuração Padrão',
+    'Definir que configurações do editor sejam substituídas para idioma {0}.',
+    'Definir que configurações do editor sejam substituídas para um idioma.',
+    "Não é possível registrar '{0}'. Isto corresponde a propriedade padrão '\\\\[.*\\\\]$' para descrever configurações do editor específico de linguagem. Use a contribuição 'configurationDefaults'.",
+    "Não é possível registrar '{0}'. Esta propriedade já está registrada.",
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    '({0}) foi pressionado. Aguardando segunda tecla de pressionamento simultâneo...',
+    'A combinação de chave ({0}, {1}) não é um comando.',
+  ],
+  'vs/platform/message/common/message': ['Fechar', 'Mais tarde', 'Cancelar'],
+  'vs/platform/theme/common/colorRegistry': [
+    'Formato inválido de cor. Use #RGB, #RGBA, #RRGGBB ou #RRGGBBAA',
+    'Cores usadas no workbench.',
+    'Cor de primeiro plano geral. Essa cor é só usada se não for substituída por um componente.',
+    'Cor de primeiro plano geral para mensagens de erro. Essa cor é só usada se não for substituída por um componente.',
+    'Cor de primeiro plano para a descrição do texto provendo informação adicional, por exemplo para uma etiqueta.',
+    'Cor geral da borda para elementos focalizados. Essa cor é usada somente se não for substituída por um componente.',
+    'Uma borda extra em torno de elementos para separá-los dos outros de maior contraste.',
+    'Uma borda extra em torno de elementos ativos para separá-los dos outros de maior contraste.',
+    'A cor de fundo das seleções de texto na área de trabalho (por exemplo, para campos de entrada ou áreas de texto). Note que isto não se aplica a seleções dentro do editor.',
+    'Cor para separadores de texto.',
+    'Cor de primeiro plano para links no texto.',
+    'Cor de primeiro plano para links ativos no texto.',
+    'Cor de primeiro plano para segmentos de texto pré-formatados.',
+    'Cor de fundo para blocos de citações no texto.',
+    'Cor da borda para blocos de citações no texto.',
+    'Cor de fundo para blocos de código no texto.',
+    'Cor de sombra ferramentas como localizar/substituir dentro do editor.',
+    'Cor de fundo da caixa de entrada.',
+    'Cor de primeiro plano da caixa de entrada.',
+    'Borda da caixa de entrada.',
+    'Cor da borda das opções ativas em campos de entrada.',
+    'Cor de primeiro plano da caixa de entrada para o texto de espaço reservado.',
+    'Cor de fundo de validação de entrada para a severidade de informações.',
+    'Cor da borda de validação de entrada para a severidade de informações.',
+    'Cor de fundo de validação de entrada para avisos.',
+    'Cor da borda de validação para a severidade de avisos.',
+    'Cor de fundo de validação de entrada para a severidade do erro.',
+    'Cor da borda de validação de entrada para a severidade do erro.',
+    'Cor de fundo do menu suspenso.',
+    'Cor de primeiro plano do menu suspenso.',
+    'Borda do menu suspenso.',
+    'Cor de fundo para o item focalizado de Lista/árvore quando a lista/árvore está ativa. Uma árvore/lista de ativa tem o foco do teclado, uma inativa não.',
+    'Cor de fundo da Lista/árvore para o item focalizado quando a lista/árvore está ativa. Uma árvore/lista ativa tem o foco do teclado, uma inativa não.',
+    'Cor de fundo para o item selecionado de Lista/árvore quando a lista/árvore está ativa. Uma lista/árvore ativa tem o foco do teclado, uma inativa não.',
+    'Cor de primeiro plano para o item selecionado de Lista/árvore quando a lista/árvore está ativa. Uma lista/árvore ativa tem o foco do teclado, uma inativa não.',
+    'Cor de fundo para o item selecionado de Lista/árvore quando a lista/árvore está inativa. Uma lista/árvore ativa tem o foco do teclado, uma inativa não.',
+    'Cor de primeiro plano para Lista/árvore para o item selecionado quando a lista/árvore está inativa. Uma árvore/lista ativa tem o foco do teclado, um inativo não.',
+    'Cor de fundo para o item selecionado de Lista/árvore quando a lista/árvore está inativa. Uma lista/árvore ativa tem o foco do teclado, uma inativa não.',
+    'Cor de primeiro plano para Lista/árvore para o item selecionado quando a lista/árvore está inativa. Uma árvore/lista ativa tem o foco do teclado, um inativo não.',
+    'Cor de fundo de Lista/árvore quando pairando sobre itens usando o mouse.',
+    'Primeiro plano da Lista/Árvoce quando passar sobre itens usando o mouse.',
+    'Cor de fundo ao arrastar e soltar de Lista/árvore quando movendo itens usando o mouse.',
+    'Cor de primeiro plano de Lista/árvore de destaques de correspondências ao pesquisar na  árvore/lista.',
+    'Seletor rápido de cor para rótulos de agrupamento.',
+    'Seletor rápido de cor para bordas de agrupamentos.',
+    'Cor de primeiro plano do botão.',
+    'Cor de fundo do botão.',
+    'Cor de fundo de botão quando flutuar sobre ele.',
+    'Cor de fundo do distintivo. Distintivos são rótulos de pequenas informações, por exemplo, para a contagem de resultados de pesquisa.',
+    'Cor de primeiro plano do distintivo. Distintivos são rótulos de pequenas informações, por exemplo, para a contagem de resultados de pesquisa.',
+    'Sombra da barra de rolagem para indicar que a visualização está sendo rolada.',
+    'Cor de fundo da barra de rolagem.',
+    'Cor de fundo da barra de rolagem quando o cursor do mouse estiver sobre ela.',
+    'Cor de fundo da barra de rolagem quando ativa.',
+    'Cor de fundo da barra de progresso que pode ser mostrada em operações de execução demorada.',
+    'Cor de plano de fundo do editor.',
+    'Cor de primeiro plano padrão do editor.',
+    'Cor de plano de fundo das ferramentas de edição, como pesquisar/substituir.',
+    'Cor da borda das ferramentas do editor. A cor é usada somente se a ferramenta escolhe ter uma borda e a cor não é substituída por uma ferramenta.',
+    'Cor de seleção do editor.',
+    'Cor do texto selecionado para alto contraste.',
+    'Cor de seleção em um editor inativo.',
+    'Cor de regiões com o mesmo conteúdo da seleção.',
+    'Cor da correspondência de pesquisa atual.',
+    'Cor dos outros resultados de pesquisa.',
+    'Cor da faixa que limita a pesquisa.',
+    'Realçar abaixo da palavra onde é mostrado item flutuante',
+    'Cor de fundo para o item flutuante do editor',
+    'Cor da borda para o item flutuante do editor.',
+    'Cor dos links ativos.',
+    'Cor de fundo para texto que foi inserido.',
+    'Cor de fundo para texto que foi removido.',
+    'Cor de contorno para o texto que foi inserido.',
+    'Cor de contorno para o texto que foi removido.',
+    'Cor de fundo de cabeçalho atual em conflito de mesclagem em linha.',
+    'Cor de fundo de conteúdo atual em conflito de mesclagem em linha.',
+    'Cor de fundo de cabeçalho de entrada em conflito de mesclagem em linha.',
+    'Cor de fundo de conteúdo de entrada em conflito de mesclagem em linha.',
+    'Ancestral comum da cor de fundo do cabeçalho em conflitos de mesclagem inline.',
+    'Ancestral comum da cor de fundo do conteúdo em conflitos de mesclagem inline. ',
+    'Cor da borda dos cabeçalhos e separadores estão em conflito de mesclagem em linha.',
+    'Cor de fundo de régua de visuaização atual em conflito de mesclagem em linha.',
+    'Cor de fundo de régua de visuaização de entrada em conflito de mesclagem em linha.',
+    'Ancestral comum da cor da régua de visão geral para conflitos de mesclagem inline.',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.pt-br.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.ru.js

@@ -0,0 +1,537 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.ru', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (произошло снова)'],
+  'vs/base/browser/ui/findinput/findInput': ['ввод'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    'С учетом регистра',
+    'Слово целиком',
+    'Использовать регулярное выражение',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['Ошибка: {0}', 'Предупреждение: {0}', 'Сведения: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'CTRL',
+    'SHIFT',
+    'ALT',
+    'Клавиша Windows',
+    'CTRL',
+    'SHIFT',
+    'ALT',
+    'Команда',
+    'CTRL',
+    'SHIFT',
+    'ALT',
+    'Клавиша Windows',
+  ],
+  'vs/base/common/severity': ['Ошибка', 'Предупреждение', 'Сведения'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}, средство выбора', 'средство выбора'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    'Средство быстрого выбора. Введите, чтобы сузить результаты.',
+    'Средство быстрого выбора',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['Свернуть'],
+  'vs/editor/browser/widget/diffEditorWidget': [
+    'Нельзя сравнить файлы, потому что один из файлов слишком большой.',
+  ],
+  'vs/editor/browser/widget/diffReview': [
+    'Закрыть',
+    'Различие {0} из {1}; исходная версия: {2}, строки: {3}, измененная версия: {4}, строки: {5}',
+    'пустой',
+    'Исходная версия: {0}, измененная версия: {1}: {2}',
+    '+ измененная версия: {0}: {1}',
+    '- исходная версия: {0}: {1}',
+    'Перейти к следующему различию',
+    'Перейти к предыдущему различию',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    'Редактор',
+    'Определяет семейство шрифтов.',
+    'Управляет насыщенностью шрифта.',
+    'Управляет размером шрифта в пикселях.',
+    'Управляет высотой строк. Укажите 0 для вычисления высоты строки по размеру шрифта.',
+    'Управляет интервалом между буквами в пикселях.',
+    'Управляет видимостью номеров строк. Возможные значения: "on", "off" и "relative". Значение "relative" показывает количество строк, начиная с текущего положения курсора.',
+    'Столбцы, в которых должны отображаться вертикальные линейки',
+    'Символы, которые будут использоваться как разделители слов при выполнении навигации или других операций, связанных со словами.',
+    'Число пробелов в табуляции. Эта настройка переопределяется на основании содержимого файла, когда включен параметр "editor.detectIndentation".',
+    'Ожидается число. Обратите внимание, что значение auto заменено параметром editor.detectIndentation.',
+    'Вставлять пробелы при нажатии клавиши TAB. Эта настройка переопределяется на основании содержимого файла, когда включен параметр "editor.detectIndentation".',
+    'Ожидается логическое значение. Обратите внимание, что значение auto заменено параметром editor.detectIndentation.',
+    'При открытии файла editor.tabSize и editor.insertSpaces будут определяться на основе содержимого файла.',
+    'Определяет, будут ли выделения иметь скругленные углы.',
+    'Определяет, будет ли содержимое редактора прокручиваться за последнюю строку.',
+    'Определяет, отображается ли мини-карта',
+    'Определяет, будет ли автоматически скрываться ползунок мини-карты',
+    'Отображает фактические символы в строке вместо цветных блоков.',
+    'Ограничивает ширину мини-карты для отображения числа столбцов не больше определенного.',
+    'Определяет, можно ли передать строку поиска в мини-приложение поиска из текста, выделенного в редакторе',
+    'Определяет, будет ли снят флажок "Поиск в выделенном", когда в редакторе выбрано несколько символов или строк текста',
+    'Строки не будут переноситься никогда.',
+    'Строки будут переноситься по ширине окна просмотра.',
+    'Строки будут переноситься по "editor.wordWrapColumn".',
+    'Строки будут перенесены по минимальному значению из двух: ширина окна просмотра и "editor.wordWrapColumn".',
+    'Определяет, как должны переноситься строки. Допустимые значения:\n - "off" (отключить перенос);\n - "on" (перенос окна просмотра);\n - "wordWrapColumn" (перенос в "editor.wordWrapColumn");\n - "bounded" (перенос при минимальной ширине окна просмотра и "editor.wordWrapColumn").',
+    'Определяет столбец переноса редактора, если значение "editor.wordWrap" — "wordWrapColumn" или "bounded".',
+    'Управляет отступом строк с переносом по словам. Допустимые значения: "none", "same" или "indent".',
+    'Множитель, используемый для параметров deltaX и deltaY событий прокрутки колесика мыши.',
+    'Соответствует клавише CTRL в Windows и Linux и клавише COMMAND в OS X.',
+    'Соответствует клавише ALT в Windows и Linux и клавише OPTION в OS X.',
+    'Модификатор, который будет использоваться для добавления нескольких курсоров с помощью мыши. "ctrlCmd" соответствует клавише CTRL в Windows и Linux и клавише COMMAND в OS X. Жесты мыши "Перейти к определению" и "Открыть ссылку" будут изменены так, чтобы они не конфликтовали с несколькими курсорами.',
+    'Разрешение кратких предложений в строках.',
+    'Разрешение кратких предложений в комментариях.',
+    'Разрешение кратких предложений вне строк и комментариев.',
+    'Определяет, должны ли при вводе текста автоматически отображаться предложения',
+    'Управляет длительностью задержки (в мс), перед отображением кратких предложений.',
+    'Включает всплывающее окно с документацией по параметру и сведениями о типе, которое отображается во время набора',
+    'Определяет, должен ли редактор автоматически закрывать скобки после открытия.',
+    'Управляет параметром, определяющим, должен ли редактор автоматически форматировать строку после ввода.',
+    'Определяет, будет ли редактор автоматически форматировать вставленное содержимое. Модуль форматирования должен быть доступен и иметь возможность форматировать диапазон в документе.',
+    'Определяет, должен ли редактор автоматически изменять отступ при вводе текста, вставке текста или перемещении строк. Для использования этого параметра должны быть доступны правила отступа.',
+    'Определяет, должны ли при вводе триггерных символов автоматически отображаться предложения.',
+    'Определяет, будут ли предложения приниматься клавишей ВВОД в дополнение к клавише TAB. Это помогает избежать неоднозначности между вставкой новых строк и принятием предложений. Значение "smart" означает, что при изменении текста предложения будут приниматься только при нажатии клавиши ВВОД.',
+    'Определяет, будут ли предложения приниматься символами фиксации. Например, в JavaScript точка с запятой (";") может быть символом фиксации, принимающим предложение и вводящим данный символ.',
+    'Отображать предложения фрагментов поверх других предложений.',
+    'Отображать предложения фрагментов под другими предложениями.',
+    'Отображать предложения фрагментов рядом с другими предложениями.',
+    'Не отображать предложения фрагментов.',
+    'Управляет отображением фрагментов вместе с другими предложениями и их сортировкой.',
+    'Управляет тем, копируется ли текущая строка при копировании без выделения.',
+    'Определяет, следует ли оценивать завершения на основе слов в документе.',
+    'Размер шрифта мини-приложения предложений',
+    'Высота строки мини-приложения с предложениями',
+    'Определяет, будет ли редактор выделять фрагменты, совпадающие с выделенным текстом.',
+    'Определяет, должен ли редактор выделять экземпляры семантических символов.',
+    'Определяет, сколько украшений могут отображаться на одном месте в обзорной линейке.',
+    'Определяет, следует ли рисовать границу на обзорной линейке.',
+    'Управляет стилем анимации курсора. Допустимые значения: "blink", "smooth", "phase", "expand" и "solid"',
+    'Изменение размера шрифта в редакторе при нажатой клавише CTRL и движении колесика мыши',
+    'Определяет стиль курсора. Допустимые значения: "block", "block-outline", "line", "line-thin", "underline" и "underline-thin"',
+    'Включает лигатуры шрифта.',
+    'Управляет скрытием курсора в обзорной линейке.',
+    'Определяет, должен ли редактор обрабатывать символы пробела; возможные значения: "none", "boundary" и "all". Параметр "boundary" не обрабатывает единичные пробелы между словами.',
+    'Определяет, должны ли в редакторе отображаться управляющие символы.',
+    'Определяет, должны ли в редакторе отображаться направляющие отступа.',
+    'Определяет, должен ли редактор выделять текущую строку. Возможные значения: none, gutter, line и all.',
+    'Управляет показом групп связанных элементов кода в редакторе',
+    'Определяет, включено ли сворачивание кода в редакторе.',
+    'Определяет, будут ли автоматически скрываться элементы управления свертыванием на полях.',
+    'Выделяет соответствующие скобки при выборе одной из них.',
+    'Управляет отображением вертикальных полей глифа в редакторе. Поля глифа в основном используются для отладки.',
+    'Вставка и удаление пробелов после позиции табуляции',
+    'Удалить автоматически вставляемый конечный пробел',
+    'Оставлять быстрые редакторы открытыми, даже если дважды щелкнуто их содержимое или нажата клавиша ESC.',
+    'Определяет, следует ли редактору разрешить перемещение выделенных элементов с помощью перетаскивания.',
+    'Редактор будет определять, подключено ли средство чтения с экрана, с помощью API-интерфейсов платформы.',
+    'Редактор будет оптимизирован для использования со средством чтения с экрана в постоянном режиме.',
+    'Редактор никогда не будет оптимизироваться для использования со средством чтения с экрана.',
+    'Определяет, следует ли запустить редактор в режиме оптимизации для средства чтения с экрана.',
+    'Определяет, должен ли редактор определять ссылки и делать их доступными для щелчка',
+    'Определяет, как редактор несовпадений отображает отличия: рядом или в тексте.',
+    'Определяет, должен ли редактор несовпадений трактовать несовпадения символов-разделителей как различия.',
+    'Определяет отображение редактором несовпадений индикаторов +/- для добавленных или удаленных изменений',
+    'Контролирует, следует ли поддерживать первичный буфер обмена Linux.',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    'Редактор сейчас недоступен. Чтобы открыть список действий, нажмите ALT+F1.',
+    'Содержимое редактора',
+  ],
+  'vs/editor/common/controller/cursor': ['Неожиданное исключение при выполнении команды.'],
+  'vs/editor/common/model/textModelWithTokens': ['Не удалось разметить входные данные.'],
+  'vs/editor/common/modes/modesRegistry': ['Обычный текст'],
+  'vs/editor/common/services/bulkEdit': [
+    'Следующие файлы были изменены: {0}',
+    'Нет изменений',
+    'Сделано изменений {0} в {1} файлах',
+    'Сделано изменений {0} в одном файле',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    'Цвет фона для выделения строки в позиции курсора.',
+    'Цвет фона границ вокруг строки в позиции курсора.',
+    'Цвет фона выделенных диапазонов, например в функциях быстрого открытия и поиска.',
+    'Цвет курсора редактора.',
+    'Цвет фона курсора редактора. Позволяет настраивать цвет символа, перекрываемого прямоугольным курсором.',
+    'Цвет пробелов в редакторе.',
+    'Цвет направляющих для отступов редактора.',
+    'Цвет номеров строк редактора.',
+    'Цвет линейки редактора.',
+    'Цвет переднего плана элемента CodeLens в редакторе',
+    'Цвет фона парных скобок',
+    'Цвет прямоугольников парных скобок',
+    'Цвет границы для линейки в окне просмотра.',
+    'Цвет фона поля в редакторе. В поле размещаются отступы глифов и номера строк.',
+    'Цвет волнистой линии для выделения ошибок в редакторе.',
+    'Цвет границ волнистой линии для выделения ошибок в редакторе.',
+    'Цвет волнистой линии для выделения предупреждений в редакторе.',
+    'Цвет границ волнистой линии для выделения предупреждений в редакторе.',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['Перейти к скобке'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    'Переместить курсор влево',
+    'Переместить курсор вправо',
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['Транспортировать буквы'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    'Вырезать',
+    'Копировать',
+    'Вставить',
+    'Копировать с выделением синтаксиса',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    'Закомментировать или раскомментировать строку',
+    'Закомментировать строку',
+    'Раскомментировать строку',
+    'Закомментировать или раскомментировать блок',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['Показать контекстное меню редактора'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    'Найти',
+    'Найти',
+    'Предыдущее соответствие',
+    'Следующее соответствие',
+    'Найти в выделении',
+    'Закрыть',
+    'Заменить',
+    'Заменить',
+    'Заменить',
+    'Заменить все',
+    'Режим "Переключение замены"',
+    'Отображаются только первые 999 результатов, но все операции поиска выполняются со всем текстом.',
+    '{0} из {1}',
+    'Нет результатов',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    'Найти',
+    'Найти далее',
+    'Найти ранее',
+    'Найти следующее выделение',
+    'Найти предыдущее выделение',
+    'Заменить',
+    'Добавить выделение в следующее найденное совпадение',
+    'Добавить выделенный фрагмент в предыдущее найденное совпадение',
+    'Переместить последнее выделение в следующее найденное совпадение',
+    'Переместить последний выделенный фрагмент в предыдущее найденное совпадение',
+    'Выбрать все вхождения найденных совпадений',
+    'Изменить все вхождения',
+    'Показать следующий найденный термин',
+    'Показать предыдущий найденный термин',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    'Развернуть',
+    'Развернуть рекурсивно',
+    'Свернуть',
+    'Свернуть рекурсивно',
+    'Свернуть все',
+    'Развернуть все',
+    'Уровень папки {0}',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    'Внесена одна правка форматирования в строке {0}.',
+    'Внесены правки форматирования ({0}) в строке {1}.',
+    'Внесена одна правка форматирования между строками {0} и {1}.',
+    'Внесены правки форматирования ({0}) между строками {1} и {2}.',
+    'Форматировать документ',
+    'Форматировать выбранный фрагмент',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    'Определение для "{0}" не найдено.',
+    'Определения не найдены.',
+    ' — определения {0}',
+    'Перейти к определению',
+    'Открыть определение сбоку',
+    'Показать определение',
+    'Не найдена реализация для "{0}".',
+    'Не найдена реализация.',
+    '— {0} реализаций',
+    'Перейти к реализации',
+    'Показать реализацию',
+    'Не найдено определение типа для "{0}".',
+    'Не найдено определение типа.',
+    '— {0} определений типов',
+    'Перейти к определению типа',
+    'Показать определение типа',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    'Щелкните, чтобы отобразить определения ({0}).',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    'Перейти к следующей ошибке или предупреждению',
+    'Перейти к предыдущей ошибке или предупреждению',
+    'Цвет ошибки в мини-приложении навигации по меткам редактора.',
+    'Цвет предупреждения в мини-приложении навигации по меткам редактора.',
+    'Фон мини-приложения навигации по меткам редактора.',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['Показать при наведении'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['Идет загрузка...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': [
+    'Заменить предыдущим значением',
+    'Заменить следующим значением',
+  ],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    'Копировать строку сверху',
+    'Копировать строку снизу',
+    'Переместить строку вверх',
+    'Переместить строку вниз',
+    'Сортировка строк по возрастанию',
+    'Сортировка строк по убыванию',
+    'Удалить конечные символы-разделители',
+    'Удалить строку',
+    'Увеличить отступ',
+    'Уменьшить отступ',
+    'Вставить строку выше',
+    'Вставить строку ниже',
+    'Удалить все слева',
+    'Удалить все справа',
+    '_Объединить строки',
+    'Транспонировать символы вокруг курсора',
+    'Преобразовать в верхний регистр',
+    'Преобразовать в нижний регистр',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'Щелкните с нажатой клавишей Cmd, чтобы перейти по ссылке',
+    'Щелкните с нажатой клавишей Ctrl, чтобы перейти по ссылке',
+    'Для выполнения команды щелкните ее, удерживая нажатой клавишу CMD',
+    'Для выполнения команды щелкните ее, удерживая нажатой клавишу CTRL',
+    'Щелкните с нажатой клавишей ALT, чтобы перейти по ссылке.',
+    'Для выполнения команды щелкните ее, удерживая нажатой клавишу ALT',
+    'Не удалось открыть ссылку, так как она имеет неправильный формат: {0}',
+    'Не удалось открыть ссылку, у нее отсутствует целевой объект.',
+    'Открыть ссылку',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    'Добавить курсор выше',
+    'Добавить курсор ниже',
+    'Добавить курсоры к окончаниям строк',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['Переключить подсказки к параметрам'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}, подсказка'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    'Показать исправления ({0})',
+    'Показать исправления',
+    'Быстрое исправление',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [
+    ' — ссылки {0}',
+    'Найти все ссылки',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['Идет загрузка...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    'ссылка в {0} в строке {1} и символе {2}',
+    '1 символ в {0}, полный путь: {1}',
+    '{0} символов в {1}, полный путь: {2} ',
+    'Результаты не найдены',
+    'Обнаружен 1 символ в {0}',
+    'Обнаружено {0} символов в {1}',
+    'Обнаружено {0} символов в {1} файлах',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    'Не удалось разрешить файл.',
+    'Ссылок: {0}',
+    '{0} ссылка',
+    'предварительный просмотр недоступен',
+    'Ссылки',
+    'Результаты отсутствуют',
+    'Ссылки',
+    'Цвет фона области заголовка быстрого редактора.',
+    'Цвет заголовка быстрого редактора.',
+    'Цвет сведений о заголовке быстрого редактора.',
+    'Цвет границ быстрого редактора и массива.',
+    'Цвет фона в списке результатов представления быстрого редактора.',
+    'Цвет переднего плана узлов строки в списке результатов быстрого редактора.',
+    'Цвет переднего плана узлов файла в списке результатов быстрого редактора.',
+    'Цвет фона выбранной записи в списке результатов быстрого редактора.',
+    'Цвет переднего плана выбранной записи в списке результатов быстрого редактора.',
+    'Цвет фона быстрого редактора.',
+    'Цвет фона поля в окне быстрого редактора.',
+    'Цвет выделения совпадений в списке результатов быстрого редактора.',
+    'Цвет выделения совпадений в быстром редакторе.',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    'Результаты отсутствуют.',
+    '«{0}» успешно переименован в «{1}». Сводка: {2}',
+    'Не удалось переименовать.',
+    'Переименовать символ',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    'Введите новое имя для входных данных и нажмите клавишу ВВОД для подтверждения.',
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['Развернуть выделение', 'Сжать выделение'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    'При принятии "{0}" был добавлен следующий текст: "{1}"',
+    'Переключить предложение',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    'Цвет фона виджета подсказок.',
+    'Цвет границ виджета подсказок.',
+    'Цвет переднего плана мини-приложения предложений.',
+    'Фоновый цвет выбранной записи в мини-приложении предложений.',
+    'Цвет выделения соответствия в мини-приложении предложений.',
+    'Подробнее...{0}',
+    '{0}, предложение, содержит данные',
+    '{0}, предложение',
+    'Кратко...{0}',
+    'Идет загрузка...',
+    'Предложения отсутствуют.',
+    '{0}, принято',
+    '{0}, предложение, содержит данные',
+    '{0}, предложение',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': [
+    'Переключение клавиши TAB перемещает фокус.',
+  ],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    'Цвет фона символа при доступе на чтение, например считывании переменной.',
+    'Цвет фона символа при доступе на запись, например записи переменной.',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['Закрыть'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    'Переопределения конфигурации по умолчанию',
+    'Настройка переопределяемых параметров редактора для языка {0}.',
+    'Настройка параметров редактора, переопределяемых для языка.',
+    'Невозможно зарегистрировать "{0}". Оно соответствует шаблону свойства \'\\\\[.*\\\\]$\' для описания параметров редактора, определяемых языком. Используйте участие configurationDefaults.',
+    'Невозможно зарегистрировать "{0}". Это свойство уже зарегистрировано.',
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    'Была нажата клавиша ({0}). Ожидание нажатия второй клавиши сочетания...',
+    'Сочетание клавиш ({0} и {1}) не является командой.',
+  ],
+  'vs/platform/message/common/message': ['Закрыть', 'Позже', 'Отмена'],
+  'vs/platform/theme/common/colorRegistry': [
+    'Недопустимый формат цвета. Используйте #RGB, #RGBA, #RRGGBB или #RRGGBBAA',
+    'Цвета, используемые на рабочем месте.',
+    'Общий цвет переднего плана. Этот цвет используется, только если его не переопределит компонент.',
+    'Общий цвет переднего плана для сообщений об ошибках. Этот цвет используется только если его не переопределяет компонент.',
+    'Цвет текста элемента, содержащего пояснения, например, для метки.',
+    'Общий цвет границ для элементов с фокусом. Этот цвет используется только в том случае, если не переопределен в компоненте.',
+    'Дополнительная граница вокруг элементов, которая отделяет их от других элементов для улучшения контраста.',
+    'Дополнительная граница вокруг активных элементов, которая отделяет их от других элементов для улучшения контраста.',
+    'Цвет фона выделенного текста в рабочей области (например, в полях ввода или в текстовых полях). Не применяется к выделенному тексту в редакторе.',
+    'Цвет для разделителей текста.',
+    'Цвет переднего плана для ссылок в тексте.',
+    'Цвет переднего фона для активных ссылок в тексте.',
+    'Цвет текста фиксированного формата.',
+    'Цвет фона для блоков с цитатами в тексте.',
+    'Цвет границ для блоков с цитатами в тексте.',
+    'Цвет фона для программного кода в тексте.',
+    'Цвет тени мини-приложений редактора, таких как "Найти/заменить".',
+    'Фон поля ввода.',
+    'Передний план поля ввода.',
+    'Граница поля ввода.',
+    'Цвет границ активированных параметров в полях ввода.',
+    'Цвет фона поясняющего текста в элементе ввода.',
+    'Фоновый цвет проверки ввода для уровня серьезности "Сведения".',
+    'Цвет границы проверки ввода для уровня серьезности "Сведения".',
+    'Фоновый цвет проверки ввода для уровня серьезности "Предупреждение".',
+    'Цвет границы проверки ввода для уровня серьезности "Предупреждение".',
+    'Фоновый цвет проверки ввода для уровня серьезности "Ошибка".',
+    'Цвет границы проверки ввода для уровня серьезности "Ошибка".',
+    'Фон раскрывающегося списка.',
+    'Передний план раскрывающегося списка.',
+    'Граница раскрывающегося списка.',
+    'Фоновый цвет находящегося в фокусе элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.',
+    'Цвет переднего плана находящегося в фокусе элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.',
+    'Фоновый цвет выбранного элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.',
+    'Цвет переднего плана выбранного элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.',
+    'Фоновый цвет выбранного элемента List/Tree, когда элемент List/Tree неактивен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.',
+    'Цвет текста выбранного элемента List/Tree, когда элемент List/Tree неактивен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.',
+    'Фоновый цвет выбранного элемента List/Tree, когда элемент List/Tree неактивен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.',
+    'Цвет текста выбранного элемента List/Tree, когда элемент List/Tree неактивен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.',
+    'Фоновый цвет элементов List/Tree при наведении курсора мыши.',
+    'Цвет переднего плана элементов List/Tree при наведении курсора мыши.',
+    'Фоновый цвет элементов List/Tree при перемещении с помощью мыши.',
+    'Цвет переднего плана для выделения соответствия при поиске по элементу List/Tree.',
+    'Цвет средства быстрого выбора для группировки меток.',
+    'Цвет средства быстрого выбора для группировки границ.',
+    'Цвет переднего плана кнопки.',
+    'Цвет фона кнопки.',
+    'Цвет фона кнопки при наведении.',
+    'Цвет фона бэджа. Бэджи - небольшие информационные элементы,  отображающие количество, например, результатов поиска.',
+    'Цвет текста бэджа. Бэджи - небольшие информационные элементы, отображающие количество, например, результатов поиска.',
+    'Цвет тени полосы прокрутки, которая свидетельствует о том, что содержимое прокручивается.',
+    'Цвет фона ползунка полосы прокрутки.',
+    'Цвет фона ползунка полосы прокрутки при наведении курсора.',
+    'Цвет фона активного ползунка полосы прокрутки.',
+    'Цвет фона индикатора выполнения, который может отображаться для длительных операций.',
+    'Цвет фона редактора.',
+    'Цвет переднего плана редактора по умолчанию.',
+    'Цвет фона виджетов редактора, таких как найти/заменить.',
+    'Цвет границы мини-приложений редактора. Этот цвет используется только в том случае, если у мини-приложения есть граница и если этот цвет не переопределен мини-приложением.',
+    'Цвет выделения редактора.',
+    'Цвет выделенного текста в режиме высокого контраста.',
+    'Цвет выделения в неактивном редакторе.',
+    'Цвет регионов с тем же содержимым, что и в выделении.',
+    'Цвет текущего поиска совпадений.',
+    'Цвет других совпадений поиска.',
+    'Цвет диапазона, ограничивающего поиск.',
+    'Выделение под словом, для которого показано наведение.',
+    'Цвет фона при наведении указателя на редактор.',
+    'Цвет границ при наведении указателя на редактор.',
+    'Цвет активных ссылок.',
+    'Цвет фона для добавленных строк.',
+    'Цвет фона для удаленных строк.',
+    'Цвет контура для добавленных строк.',
+    'Цвет контура для удаленных строк.',
+    'Цвет фона текущего заголовка во внутренних конфликтах слияния.',
+    'Цвет фона текущего содержимого во внутренних конфликтах слияния.',
+    'Цвет фона входящего заголовка во внутренних конфликтах слияния.',
+    'Цвет фона входящего содержимого во внутренних конфликтах слияния.',
+    'Цвет фона заголовка для общего предка во внутренних конфликтах слияния.',
+    'Цвет фона содержимого для общего предка во внутренних конфликтах слияния.',
+    'Цвет границы заголовков и разделителя во внутренних конфликтах слияния.',
+    'Цвет переднего плана линейки текущего окна во внутренних конфликтах слияния.',
+    'Цвет переднего плана линейки входящего окна во внутренних конфликтах слияния.',
+    'Цвет переднего плана для обзорной линейки для общего предка во внутренних конфликтах слияния. ',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.ru.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.tr.js

@@ -0,0 +1,539 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.tr', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (tekrar oluştu)'],
+  'vs/base/browser/ui/findinput/findInput': ['giriş'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    'Büyük/Küçük Harf Eşleştir',
+    'Sözcüğün Tamamını Eşleştir',
+    'Normal İfade Kullan',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['Hata: {0}', 'Uyarı: {0}', 'Bilgi: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'Ctrl',
+    'Shift',
+    'Alt',
+    'Windows',
+    'Control',
+    'Shift',
+    'Alt',
+    'Command',
+    'Control',
+    'Shift',
+    'Alt',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['Hata', 'Uyarı', 'Bilgi'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}, seçici', 'seçici'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    'Hızlı seçici. Sonuçları daraltmak için yazmaya başlayın.',
+    'Hızlı Seçici',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['Daralt'],
+  'vs/editor/browser/widget/diffEditorWidget': [
+    'Bir dosya çok büyük olduğu için dosyaları karşılaştıramazsınız.',
+  ],
+  'vs/editor/browser/widget/diffReview': [
+    'Kapat',
+    'Farklılık {0}/{1}: orijinal {2}, {3} satırları, değiştirilen {4}, {5} satırları',
+    'boş',
+    'orijinal {0}, değiştirilen {1}: {2}',
+    '+ değiştirilen {0}: {1}',
+    '- orijinal {0}: {1}',
+    'Sonraki Farka Git',
+    'Sonraki Farka Git',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    'Düzenleyici',
+    'Yazı tipi ailesini denetler.',
+    'Yazı tipi kalınlığını denetler.',
+    'Yazı tipi boyutunu piksel olarak denetler.',
+    'Satır yüksekliğini denetler. lineHeight değerini, fontSize değeri kullanarak hesaplamak için 0 girin.',
+    'Harfler arası boşluğu pixel olarak denetler.',
+    "Satır numaralarının görüntülenmesini denetler. Olası değerler 'on', 'off' ve 'relative'dir. 'relative' satırların geçerli imleç konumundan uzaklıklarını gösterir.",
+    'Dikey cetvellerin gösterileceği sütunlar',
+    'Sözcüklerle ilgili gezinti veya işlem yaparken kelime ayırıcı olarak kullanılacak karakterler',
+    'Bir sekmenin eşit olduğu boşluk sayısı. Bu ayar, `editor.detectIndentation` açıkken dosya içeriğine bağlı olarak geçersiz kılınır.',
+    '\'sayı\' bekleniyor. "auto" değerinin `editor.detectIndentation` ile değiştirildiğini unutmayın.',
+    'Tab tuşuna basınca boşluk ekle. Bu ayar, `editor.detectIndentation` açıkken dosya içeriğine bağlı olarak geçersiz kılınır.',
+    '\'boole\' bekleniyor. "auto" değerinin `editor.detectIndentation` ile değiştirildiğini unutmayın.',
+    'Bir dosyayı açarken, `editor.tabSize` ve `editor.insertSpaces` dosya içeriğine bağlı olarak algılanır.',
+    'Seçimlerin köşelerinin yuvarlak olup olmayacağını denetler',
+    'Düzenleyicinin son satırın ötesine ilerleyip ilerlemeyeceğini denetler',
+    'Mini haritanın gösterilip gösterilmeyeceğini denetler',
+    'Mini harita kaydıracının otomatik olarak gizlenip gizlenmeyeceğini denetler.',
+    '(Renk blokları yerine) Bir satırdaki gerçek harfleri göster',
+    'Hazırlanacak mini haritanın azami genişliğini belirli sayıda sütunla sınırla',
+    "Bulma Araç Çubuğu'ndaki arama metninin, düzenleyicideki seçili alandan beslenmesini denetler",
+    'Seçimde bul işaretçisinin, editördeki metnin birden çok karakteri veya satırı seçildiğinde açılmasını denetler.',
+    'Satırlar hiçbir zaman bir sonraki satıra kaydırılmayacak.',
+    'Satırlar görüntü alanı genişliğinde bir sonraki satıra kaydırılacak.',
+    'Satırlar `editor.wordWrapColumn` değerinde bir sonraki satıra kaydırılacak.',
+    'Satırlar en düşük görüntü alanı genişliğinde ve `editor.wordWrapColumn` değerinde bir sonraki satıra kaydırılacak.',
+    "Satırların bir sonraki satıra nasıl kaydırılacağını denetler. Seçenekler:\n - 'off' (kaydırmayı devre dışı bırak),\n - 'on' (görüntü alanında kaydır),\n - 'wordWrapColumn' (`editor.wordWrapColumn` değerinde kaydır) veya\n - 'bounded' (en düşük görüntü alanı genişliğinde ve `editor.wordWrapColumn` değerinde kaydır).",
+    "`editor.wordWrap` ögesi, 'wordWrapColumn' veya 'bounded' iken düzenleyicinin kaydırma sütununu denetler.",
+    "Kaydırılan satır girintisini denetler. 'none', 'same' veya 'indent' değerlerinden biri olabilir.",
+    'Fare tekerleği kaydırma olaylarında `deltaX` ve `deltaY` üzerinde kullanılan bir çarpan',
+    "Windows ve Linux'da `Control` ve OSX'de `Command` ile eşleşir.",
+    "Windows ve Linux'da `Alt` ve OSX'de `Option` ile eşleşir.",
+    "Fare ile birden çok imleç eklenmesinde kullanılacak değiştirici. `ctrlCmd` Windows ve Linux'da `Control` ve OSX'de `Command` ile eşleşir. Tanıma Git ve Bağlantıyı Aç fare hareketleri, birden çok imleç değiştiricisi ile çakışmayacak şekilde uyum sağlarlar.",
+    'Dizelerin içinde hızlı önerileri etkinleştir.',
+    'Yorumların içinde hızlı önerileri etkinleştir.',
+    'Dizeler ve yorumlar dışında hızlı önerileri etkinleştirin.',
+    'Yazarken önerilerin otomatik olarak gösterilip gösterilmeyeceğini denetler',
+    'Hızlı önerilerin gösterilmesinden önce kaç ms bekleneceğini denetler',
+    'Siz tuşlara bastıkça parametre belgelerini ve tür bilgisini gösteren açılır pencereyi etkinleştirir.',
+    'Düzenleyicinin köşeli ayracı açtıktan sonra otomatik olarak kapatıp kapatmayacağını denetler',
+    'Düzenleyicinin satırı yazıldıktan sonra otomatik biçimlendirip biçimlendirmeyeceğini denetler',
+    'Düzenleyicinin yapıştırılan içeriği otomatik olarak biçimlendirip biçimlendirmeyeceğini denetler. Bir biçimlendirici mevcut olmalı ve belgede bir aralığı biçimlendirebilmelidir.',
+    'Düzenleyicinin, kullanıcılar tuşlara bastığında, satırları yapıştırdığında veya taşıdığında girintiyi otomatik olarak ayarlayıp ayarlamayacağını denetler. Dilin girintileme kuralları mevcut olmalıdır.',
+    'Tetikleyici karakterler yazılırken otomatik olarak öneri gösterilip gösterilmeyeceğini denetler',
+    "'Tab' tuşuna ek olarak - önerilerin 'Enter' tuşuna basıldığında kabul edilmesini denetler. Yeni satır ekleme ya da öneri kabul etme arasındaki belirsizlikten kaçınmaya yardımcı olur. 'smart' değeri, bir öneri metinsel değişiklik yapıyorsa, onu sadece Enter tuşu ile kabul etmeyi ifade eder",
+    "Önerilerin tamamlama karakterlerinde kabul edilip edilmeyeceğini denetler. Örnek olarak; JavaScript'te noktalı virgül(';') öneri kabul eden ve o karakteri giren tamamlama karakteri olabilir.",
+    'Parçacık önerilerini diğer önerilerin üstünde göster.',
+    'Parçacık önerilerini diğer önerilerin altında göster.',
+    'Parçacık önerilerini diğer önerilerle birlikte göster.',
+    'Parçacık önerilerini gösterme.',
+    'Parçacıkların diğer önerilerle gösterilip gösterilmeyeceğini ve bunların nasıl sıralanacaklarını denetler.',
+    'Bir seçim olmadan geçerli satırı kopyalayıp kopyalamamayı denetler.',
+    'Tamamlamaların belgedeki sözcüklere dayalı olarak hesaplanıp hesaplanmayacağını denetler.',
+    'Öneri aracının yazı tipi boyutu',
+    'Öneri aracının satır yüksekliği',
+    'Düzenleyicinin seçime benzer eşleşmeleri vurgulayıp vurgulamayacağını denetler',
+    'Düzenleyicinin semantik sembol tekrarlamalarını vurgulayıp vurgulamayacağını denetler',
+    'Genel bakış cetvelinde aynı konumda gösterilebilecek süsleme sayısını denetler',
+    'Genel bakış cetvelinin etrafına bir kenarlık çizilmesi gerekip gerekmediğini denetler.',
+    "İmleç animasyon stilini denetler, olası değerler 'blink', 'smooth', 'phase', 'expand' ve 'solid'dir",
+    'Ctrl tuşuna basarken fare tekerleği ile düzenleyici yazı tipini yakınlaştırın',
+    "İmleç stilini denetler, kabul edilen değerler: 'block', 'block-outline', 'line', 'line-thin', 'underline' ve 'underline-thin'",
+    'Yazı tipi ligatürlerini etkinleştirir',
+    'İmlecin genel bakış cetvelinde gizlenip gizlenmeyeceğini denetler.',
+    "Düzenleyicinin boşluk karakterlerini nasıl göstereceğini denetler, seçenekler: 'none', 'boundary', ve 'all'. 'boundary' seçeneği sözcükler arasındaki tek boşlukları göstermez.",
+    'Düzenleyicinin kontrol karakterlerini gösterip göstermemesini denetler',
+    'Düzenleyicinin girinti kılavuzlarını gösterip göstermemesini denetler',
+    "Düzenleyicinin geçerli satır vurgusunu nasıl göstereceğini denetler, seçenekler: 'none', 'gutter', 'line', ve 'all'.",
+    'Düzenleyicinin kod objektiflerini gösterip göstermediğini denetler',
+    'Düzenleyicide kod katlamanın etkin olup olmadığını denetler',
+    'Oluktaki kat kontrollerinin otomatik olarak gizlenip gizlenmeyeceğini denetler.',
+    'Eşleşen ayraçları, onlardan biri seçildiğinde vurgula.',
+    'Düzenleyicinin dikey glif boşluğunu oluşturup oluşturmayacağını kontrol eder. Glif boşluğu çoğunlukla hata ayıklamak için kullanılır.',
+    'Boşluk ekleme ve silme sekme duraklarını izler',
+    'Sondaki otomatik eklenen boşluğu kaldır',
+    'Gözetleme düzenleyicilerini, içeriklerine çift tıklandığında veya Escape tuşuna basıldığında bile açık tut.',
+    'Düzenleyicinin seçimleri sürükleyip bırakarak taşımaya izin verip vermeyeceğini denetler.',
+    "Düzenleyici, bir Ekran Okuyucu'nun ne zaman bağlandığını algılamak için platform API'larını kullanacaktır.",
+    'Düzenleyici bir Ekran Okuyucu ile kullanılmak üzere kalıcı olarak optimize edilecektir.',
+    'Düzenleyici hiçbir zaman bir Ekran Okuyucu ile kullanılmak üzere optimize edilmeyecektir.',
+    'Düzenleyicinin ekran okuyucular için optimize edilmiş bir modda çalışıp çalışmayacağını denetler.',
+    'Düzenleyicinin bağlantıları otomatik algılayıp, onları tıklanabilir yapıp yapmayacağını denetler',
+    'Karşılaştırma düzenleyicisinin farklılıkları yan yana mı yoksa satır içinde mi göstereceğini denetler',
+    'Karşılaştırma düzenleyicisinin baştaki veya sondaki boşluklardaki değişmeleri farklılık olarak gösterip göstermemesini denetler',
+    'Karşılaştırma düzenleyicisinin ekleme/çıkarma değişiklikleri için +/- göstergeleri gösterip göstermemesini denetler.',
+    'Linux birincil panosunun desteklenip desteklenmeyeceğini denetler.',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    "Düzenleyici şu an erişilebilir değil. Seçenekler için lütfen Alt+F1'e basın.",
+    'Düzenleyici içeriği',
+  ],
+  'vs/editor/common/controller/cursor': ['Komut yürütülürken beklenmeyen özel durum oluştu.'],
+  'vs/editor/common/model/textModelWithTokens': [
+    'Mod, girdiyi belirteçlere ayırırken başarısız oldu.',
+  ],
+  'vs/editor/common/modes/modesRegistry': ['Düz Metin'],
+  'vs/editor/common/services/bulkEdit': [
+    'Bu dosyalar bu arada değiştirildi: {0}',
+    'Düzenleme yapılmadı',
+    '{1} dosyada {0} metin düzenlemesi yapıldı',
+    'Bir dosyada {0} metin düzenlemesi yapıldı',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    'İmlecin bulunduğu satırın vurgusunun arka plan rengi.',
+    'İmlecin bulunduğu satırın kenarlığının arka plan rengi.',
+    'Hızlı açma ve bulma özellikleri gibi vurgulanan alanların arka plan rengi.',
+    'Düzenleyici imlecinin rengi.',
+    'Düzenleyici imlecinin arka plan rengi. Bir blok imlecinin kapladığı bir karakterin rengini özelleştirmeyi sağlar.',
+    'Düzenleyicideki boşluk karakterlerinin rengi.',
+    'Düzenleyici girinti kılavuzlarının rengi.',
+    'Düzenleyici satır numaralarının rengi.',
+    'Düzenleyici cetvellerinin rengi.',
+    'Düzenleyici kod objektiflerinin ön plan rengi',
+    'Eşleşen parantezlerin arka plan rengi',
+    'Eşleşen parantez kutularının rengi',
+    'Genel bakış cetvelinin kenarlık rengi.',
+    'Düzenleyici oluğunun arka plan rengi. Oluk, glif boşluklarını ve satır numaralarını içerir.',
+    'Düzenleyicideki hata karalamalarının ön plan rengi.',
+    'Düzenleyicideki hata karalamalarının kenarlık rengi.',
+    'Düzenleyicideki uyarı karalamalarının ön plan rengi.',
+    'Düzenleyicideki uyarı karalamalarının kenarlık rengi.',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['Ayraca Git'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': [
+    'İmleci Sola Taşı',
+    'İmleci Sağa Taşı',
+  ],
+  'vs/editor/contrib/caretOperations/common/transpose': ['Harfleri Birbirleriyle Değiştir'],
+  'vs/editor/contrib/clipboard/browser/clipboard': [
+    'Kes',
+    'Kopyala',
+    'Yapıştır',
+    'Sentaks Vurgulaması İle Kopyala',
+  ],
+  'vs/editor/contrib/comment/common/comment': [
+    'Satır Yorumunu Aç/Kapat',
+    'Satır Açıklaması Ekle',
+    'Satır Açıklamasını Kaldır',
+    'Yorum Bloğunu Aç/Kapat',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['Düzenleyici Bağlam Menüsünü Göster'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    'Bul',
+    'Bul',
+    'Önceki eşleşme',
+    'Sonraki eşleşme',
+    'Seçimde bul',
+    'Kapat',
+    'Değiştir',
+    'Değiştir',
+    'Değiştir',
+    'Tümünü Değiştir',
+    'Değiştirme modunu değiştir',
+    'Yalnızca ilk 999 sonuç vurgulandı, ancak tüm bulma işlemleri metnin tamamı üzerinde çalışıyor.',
+    '{0}/{1}',
+    'Sonuç Yok',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    'Bul',
+    'Sonrakini Bul',
+    'Öncekini Bul',
+    'Sonraki Seçimi Bul',
+    'Önceki Seçimi Bul',
+    'Değiştir',
+    'Seçimi Sonraki Bulunan Eşleşmeye Ekle',
+    'Seçimi Önceki Bulunan Eşleşmeye Ekle',
+    'Son Seçimi Sonraki Bulunan Eşleşmeye Taşı',
+    'Son Seçimi Önceki Bulunan Eşleşmeye Taşı',
+    'Bulunan Eşleşmenin Tüm Tekrarlamalarını Seç',
+    'Tüm Tekrarlamaları Değiştir',
+    'Sonraki Arama Terimini Göster',
+    'Önceki Arama Terimini Göster',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    'Katlamayı Aç',
+    'Katlamaları Özyinelemeli Olarak Aç',
+    'Katla',
+    'Özyinelemeli Olarak Katla',
+    'Hepsini Katla',
+    'Tüm Katlamaları Aç',
+    '{0}. Düzeyi Katla',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    '{0}. satırda 1 biçimlendirme düzenlemesi yapıldı',
+    '{1}. satırda {0} biçimlendirme düzenlemesi yapıldı',
+    '{0} ve {1} satırları arasında 1 biçimlendirme düzenlemesi yapıldı',
+    '{1} ve {2} satırları arasında {0} biçimlendirme düzenlemesi yapıldı',
+    'Belgeyi Biçimlendir',
+    'Seçimi Biçimlendir',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    "'{0}' için tanım bulunamadı",
+    'Tanım bulunamadı',
+    ' – {0} tanım',
+    'Tanıma Git',
+    'Tanımı Yana Aç',
+    'Tanıma Göz At',
+    "'{0}' için uygulama bulunamadı",
+    'Uygulama bulunamadı',
+    ' – {0} uygulama',
+    'Uygulamaya Git',
+    'Uygulamaya Göz At',
+    "'{0}' için tür tanımı bulunamadı",
+    'Tür tanımı bulunamadı',
+    ' – {0} tür tanımı',
+    'Tür Tanımına Git',
+    'Tür Tanımına Göz At',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': [
+    '{0} tanımı göstermek için tıklayın.',
+  ],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    'Sonraki Hata veya Uyarıya Git',
+    'Önceki Hata veya Uyarıya Git',
+    'Düzenleyicinin işaretçi gezinti aracının hata rengi.',
+    'Düzenleyicinin işaretçi gezinti aracının uyarı rengi.',
+    'Düzenleyicinin işaretçi gezinti aracının arka planı.',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['Bağlantı Vurgusunu Göster'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['Yükleniyor...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': [
+    'Önceki Değerle Değiştir',
+    'Sonraki Değerle Değiştir',
+  ],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    'Satırı Yukarı Kopyala',
+    'Satırı Aşağı Kopyala',
+    'Satırı Yukarı Taşı',
+    'Satırı Aşağı Taşı',
+    'Satırları Artan Şekilde Sırala',
+    'Satırları Azalan Şekilde Sırala',
+    'Sondaki Boşluğu Kırp',
+    'Satırı Sil',
+    'Satırı Girintile',
+    'Satırın Girintisini Azalt',
+    'Üste Satır Ekle',
+    'Alta Satır Ekle',
+    'Soldaki Her Şeyi Sil',
+    'Sağdaki Her Şeyi Sil',
+    'Satırları Birleştir',
+    'İmlecin etrafındaki karakterleri birbirleriyle değiştir',
+    'Büyük Harfe Dönüştür',
+    'Küçük Harfe Dönüştür',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'Bağlantıyı izlemek için Cmd tuşuna basarak tıklayın',
+    'Bağlantıyı izlemek için Ctrl tuşuna basarak tıklayın',
+    'Komutu yürütmek için Cmd + tıklama yapın',
+    'Komutu yürütmek için Ctrl + tıklama yapın',
+    'Bağlantıyı izlemek için Alt tuşuna basarak tıklayın',
+    'Komutu yürütmek için Alt + tıklama yapın',
+    'Üzgünüz, bu bağlantı iyi oluşturulmamış olduğu için açılamadı: {0}',
+    'Üzgünüz; bu bağlantı, hedefi eksik olduğu için açılamadı.',
+    'Bağlantıyı Aç',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    'Yukarıya İmleç Ekle',
+    'Aşağıya İmleç Ekle',
+    'Satır Sonlarına İmleç Ekle',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['Parametre İpuçlarını Tetikle'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}, ipucu'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    'Düzeltmeleri Göster ({0})',
+    'Düzeltmeleri Göster',
+    'Hızlı Düzeltme',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [
+    '– {0} başvuru',
+    'Tüm Başvuruları Bul',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['Yükleniyor...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    '{0} yolunda, {1}. satır {2}. sütundaki sembol',
+    '{0} içinde 1 sembol, tam yol {1}',
+    '{1} içinde {0} sembol, tam yol {2}',
+    'Sonuç bulunamadı',
+    '{0} yolunda 1 sembol bulundu',
+    '{1} yolunda {0} sembol bulundu',
+    '{1} dosyada {0} sembol bulundu',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    'Dosya çözümlenemedi.',
+    '{0} başvuru',
+    '{0} başvuru',
+    'önizleme yok',
+    'Başvurular',
+    'Sonuç yok',
+    'Başvurular',
+    'Gözetleme görünümü başlık alanının arka plan rengi.',
+    'Gözetleme görünümü başlığının rengi.',
+    'Gözetleme görünümü başlık bilgisinin rengi.',
+    'Gözetleme görünümü kenarlıkları ve ok işaretinin rengi.',
+    'Gözetleme görünümü sonuç listesinin arka plan rengi.',
+    'Gözetleme görünümü sonuç listesindeki satır düğümlerinin ön plan rengi.',
+    'Gözetleme görünümü sonuç listesindeki dosya düğümlerinin ön plan rengi.',
+    'Gözetleme görünümü sonuç listesindeki seçilen girdinin arka plan rengi.',
+    'Gözetleme görünümü sonuç listesindeki seçilen girdinin ön plan rengi.',
+    'Gözetleme görünümü düzenleyicisinin arka plan rengi.',
+    'Gözetleme görünümü düzenleyicisindeki oluğun arka plan rengi.',
+    'Gözetleme görünümü sonuç listesindeki eşleşme vurgusu rengi.',
+    'Gözetleme görünümü düzenleyicisindeki eşleşme vurgusu rengi.',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    'Sonuç yok.',
+    "'{0}', '{1}' olarak başarıyla yeniden adlandırıldı. Özet: {2}",
+    'Üzgünüz, yeniden adlandırma işlemi başarısız oldu.',
+    'Sembolü Yeniden Adlandır',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    "Girdiyi yeniden adlandır. Yeni adı girin ve işlemek için Enter'a basın.",
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['Seçimi Genişlet', 'Seçimi Daralt'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    "'{0}' kabul edildiği için şu metin eklendi: {1}",
+    'Öneriyi Tetikle',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    'Öneri aracının arka plan rengi.',
+    'Öneri aracının kenarlık rengi.',
+    'Öneri aracının ön plan rengi.',
+    'Öneri aracındaki seçilen girdinin arka plan rengi.',
+    'Öneri aracındaki eşleşme vurgularının rengi.',
+    'Devamını Oku...{0}',
+    '{0}, öneri, detaylı',
+    '{0}, öneri',
+    'Daha azını oku...{0}',
+    'Yükleniyor...',
+    'Öneri yok.',
+    '{0}, kabul edildi',
+    '{0}, öneri, detaylı',
+    '{0}, öneri',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': [
+    'Tab Tuşu İle Odak Değiştirmeyi Aç/Kapat',
+  ],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    'Bir değişkeni okumak gibi, okuma-erişimi sırasındaki bir sembolün arka plan rengi.',
+    'Bir değişkene yazmak gibi, yazma-erişimi sırasındaki bir sembolün arka plan rengi.',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['Kapat'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    'Varsayılan Yapılandırma Geçersiz Kılmaları',
+    '{0} dili için geçersiz kılınacak düzenleyici ayarlarını yapılandırın.',
+    'Bir dil için geçersiz kılınacak düzenleyici ayarlarını yapılandırın.',
+    "'{0}' kaydedilemiyor. Bu, dile özgü düzenleyici ayarlarını tanımlamak için '\\\\[.*\\\\]$' özellik kalıbı ile eşleşir. 'configurationDefaults' ögesini kullanın.",
+    "'{0}' kaydedilemiyor. Bu özellik zaten kayıtlı.",
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    '({0}) öğesine basıldı. Akorun ikinci tuşu bekleniyor...',
+    '({0}, {1}) tuş bileşimi bir komut değil.',
+  ],
+  'vs/platform/message/common/message': ['Kapat', 'Daha Sonra', 'İptal'],
+  'vs/platform/theme/common/colorRegistry': [
+    'Geçersiz renk biçimi. #RGB, #RGBA, #RRGGBB veya #RRGGBBAA kullanın',
+    'Çalışma ekranında kullanılan renkler.',
+    'Genel ön plan rengi. Bu renk, bir bileşen tarafından geçersiz kılınmadıkça kullanılır.',
+    'Hata mesajları için genel ön plan rengi. Bu renk, bir bileşen tarafından geçersiz kılınmadıkça kullanılır.',
+    'Ek bilgi sağlayan açıklama metni(örneğin bir etiket) için ön plan rengi.',
+    'Odaklanılan ögeler için genel kenarlık rengi. Bu renk, bir bileşen tarafından geçersiz kılınmadıkça kullanılır.',
+    'Daha yüksek karşıtlık için, ögelerin etrafında onları diğerlerinden ayıracak ekstra bir kenarlık.',
+    'Daha yüksek karşıtlık için, aktif ögelerin etrafında onları diğerlerinden ayıracak ekstra bir kenarlık.',
+    'Çalışma ekranındaki metin seçimlerinin arka plan rengi(örneğin girdi alanları veya metin alanları). Bunun, düzenleyicideki seçimlere uygulanmayacağını unutmayın.',
+    'Metin ayırıcıların rengi.',
+    'Metindeki bağlantıların ön plan rengi.',
+    'Metindeki aktif bağlantıların ön plan rengi.',
+    'Önceden biçimlendirilmiş metin parçalarının ön plan rengi.',
+    'Metindeki alıntı bloklarının arka plan rengi.',
+    'Metindeki alıntı bloklarının kenarlık rengi.',
+    'Metindeki kod bloklarının arka plan rengi.',
+    'Bul/değiştir gibi düzenleyici içindeki araçların gölge rengi.',
+    'Giriş kutusu arka planı.',
+    'Giriş kutusu ön planı.',
+    'Giriş kutusu kenarlığı.',
+    'Girdi alanlarındaki aktif seçeneklerin kenarlık rengi.',
+    'Yer tutucu metin için girdi kutusu ön plan rengi.',
+    'Bilgi önem derecesi için girdi doğrulama arka plan rengi.',
+    'Bilgi önem derecesi için girdi doğrulama kenarlık rengi.',
+    'Bilgi uyarısı için girdi doğrulama arka plan rengi.',
+    'Uyarı önem derecesi için girdi doğrulama kenarlık rengi.',
+    'Hata önem derecesi için girdi doğrulama arka plan rengi.',
+    'Hata önem derecesi için girdi doğrulama kenarlık rengi.',
+    'Açılır kutu arka planı.',
+    'Açılır kutu ön planı.',
+    'Açılır kutu kenarlığı.',
+    'Liste/Ağaç aktifken odaklanılan ögenin Lise/Ağaç arka plan rengi. Bir aktif liste/ağaç, klavye odağındadır; pasif olan odakta değildir.',
+    'Liste/Ağaç aktifken odaklanılan ögenin Lise/Ağaç ön plan rengi. Bir aktif liste/ağaç, klavye odağındadır; pasif olan odakta değildir.',
+    'Liste/Ağaç aktifken seçilen ögenin Lise/Ağaç arka plan rengi. Bir aktif liste/ağaç, klavye odağındadır; pasif olan odakta değildir.',
+    'Liste/Ağaç aktifken seçilen ögenin Lise/Ağaç ön plan rengi. Bir aktif liste/ağaç, klavye odağındadır; pasif olan odakta değildir.',
+    'Liste/Ağaç pasifken seçilen ögenin Lise/Ağaç arka plan rengi. Bir aktif liste/ağaç, klavye odağındadır; pasif olan odakta değildir.',
+    'Liste/Ağaç pasifken seçilen ögenin Lise/Ağaç ön plan rengi. Bir aktif liste/ağaç, klavye odağındadır; pasif olan odakta değildir.',
+    'Liste/Ağaç pasifken seçilen ögenin Lise/Ağaç arka plan rengi. Bir aktif liste/ağaç, klavye odağındadır; pasif olan odakta değildir.',
+    'Liste/Ağaç pasifken seçilen ögenin Lise/Ağaç ön plan rengi. Bir aktif liste/ağaç, klavye odağındadır; pasif olan odakta değildir.',
+    'Fare ile ögelerin üzerine gelindiğinde Liste/Ağaç arka planı.',
+    'Fare ile ögelerin üzerine gelindiğinde Liste/Ağaç ön planı.',
+    'Fare ile ögeler taşınırken Liste/Ağaç sürükle ve bırak arka planı.',
+    'Liste/Ağaç içinde arama yaparken eşleşme vurgularının Liste/Ağaç ön plan rengi.',
+    'Gruplama etiketleri için hızlı seçici rengi.',
+    'Gruplama kenarlıkları için hızlı seçici rengi.',
+    'Buton ön plan rengi.',
+    'Buton arka plan rengi.',
+    'Fareyle üzerine gelindiğinde buton arka plan rengi.',
+    'Gösterge arka plan rengi. Göstergeler küçük bilgi etiketleridir, ör. arama sonucu sayısı için.',
+    'Gösterge ön plan rengi. Göstergeler küçük bilgi etiketleridir, ör. arama sonucu sayısı için.',
+    'Görünümün kaydırıldığını belirtmek için kaydırma çubuğu gölgesi.',
+    'Kaydırma çubuğu kaydıracının arka plan rengi.',
+    'Fareyle üzerine gelindiğinde kaydırma çubuğu kaydıracının arka plan rengi.',
+    'Kaydırma çubuğu kaydıracının aktif iken arka plan rengi.',
+    'Uzun süren işlemleri gösterebilen ilerleme çubuğunun arka plan rengi.',
+    'Düzenleyici arka plan rengi.',
+    'Düzenleyici varsayılan ön plan rengi.',
+    'Bul/değiştir gibi düzenleyici araçlarının arka plan rengi.',
+    'Editör araçlarının kenarlık rengi. Renk, araç bir kenarlığı olmasına karar verdiğinde ve renk hiçbir eklenti tarafından geçersiz kılınmadığında kullanılır.',
+    'Düzenleyici seçiminin rengi.',
+    'Yüksek karşıtlık için seçilen metnin rengi.',
+    'Bir pasif düzenleyicideki seçimin rengi.',
+    'Seçimle aynı içeriğe sahip bölgelerin rengi.',
+    'Geçerli arama eşleşmesinin rengi.',
+    'Diğer arama eşleşmelerinin rengi.',
+    'Aramayı sınırlayan aralığı renklendirin.',
+    'Bağlantı vurgusu gösterilen bir sözcüğün altını vurgulayın.',
+    'Düzenleyici bağlantı vurgusunun arka plan rengi.',
+    'Düzenleyici bağlantı vurgusunun kenarlık rengi.',
+    'Aktif bağlantıların rengi.',
+    'Eklenen metnin arka plan rengi.',
+    'Çıkarılan metnin arka plan rengi.',
+    'Eklenen metnin ana hat rengi.',
+    'Çıkarılan metnin ana hat rengi.',
+    'Satır içi birleştirme çakışmalarında geçerli üstbilgi arka planı.',
+    'Satır içi birleştirme çakışmalarında geçerli içerik arka planı.',
+    'Satır içi birleştirme çakışmalarında gelen üstbilgi arka planı.',
+    'Satır içi birleştirme çakışmalarında gelen içerik arka planı.',
+    'Satır içi birleştirme çakışmalarında ortak ata üstbilgisi arka planı.',
+    'Satır içi birleştirme çakışmalarında ortak ata içeriği arka planı.',
+    'Satır içi birleştirme çakışmalarında üst bilgi ve ayırıcıdaki kenarlık rengi.',
+    'Satır içi birleştirme çakışmalarında geçerli genel bakış cetveli ön planı.',
+    'Satır içi birleştirme çakışmalarında gelen genel bakış cetveli ön planı.',
+    'Satır içi birleştirme çakışmalarında ortak ata genel bakış cetveli ön planı.',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.tr.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.zh-cn.js

@@ -0,0 +1,510 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.zh-cn', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (已再次发生)'],
+  'vs/base/browser/ui/findinput/findInput': ['输入'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': ['区分大小写', '全字匹配', '使用正则表达式'],
+  'vs/base/browser/ui/inputbox/inputBox': ['错误: {0}', '警告: {0}', '信息: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'Ctrl',
+    'Shift',
+    'Alt',
+    'Windows',
+    'Control',
+    'Shift',
+    'Alt',
+    'Command',
+    'Control',
+    'Shift',
+    'Alt',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['错误', '警告', '信息'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}，选取器', '选取器'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    '快速选取器。键入以缩小结果范围。',
+    '快速选取器',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['折叠'],
+  'vs/editor/browser/widget/diffEditorWidget': ['文件过大，无法比较。'],
+  'vs/editor/browser/widget/diffReview': [
+    '关闭',
+    '第 {0} 个差异(共 {1} 个): 未修改 {2}, {3} 行，已修改 {4}, {5} 行',
+    '空白',
+    '未修改 {0}，已修改 {1}: {2}',
+    '+ 已修改 {0}: {1}',
+    '- 未修改 {0}: {1} ',
+    '转至下一个差异',
+    '转至上一个差异',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    '编辑器',
+    '控制字体系列。',
+    '控制字体粗细。',
+    '以像素为单位控制字号。',
+    '控制行高。使用 0 通过字号计算行高。',
+    '以像素为单位控制字符间距。',
+    '控制行号的显示。可能的值为“开”、“关”和“相对”。“相对”将显示从当前光标位置开始计数的行数。',
+    '显示垂直标尺的列',
+    '执行文字相关的导航或操作时将用作文字分隔符的字符',
+    '一个制表符等于的空格数。该设置在 `editor.detectIndentation` 启用时根据文件内容进行重写。',
+    '应为“number”。注意，值“auto”已由“editor.detectIndentation”设置替换。',
+    '按 "Tab" 时插入空格。该设置在 `editor.detectIndentation` 启用时根据文件内容进行重写。',
+    '应为 "boolean"。注意，值 "auto" 已由 "editor.detectIndentation" 设置替换。',
+    '当打开文件时，将基于文件内容检测 "editor.tabSize" 和 "editor.insertSpaces"。',
+    '控制选取范围是否有圆角',
+    '控制编辑器是否可以滚动到最后一行之后',
+    '控制是否显示 minimap',
+    '控制是否自动隐藏迷你地图滑块。 ',
+    '呈现某行上的实际字符(与颜色块相反)',
+    '限制最小映射的宽度，尽量多地呈现特定数量的列',
+    '控制是否将编辑器的选中内容作为搜索词填入到查找组件',
+    '控制当编辑器中选中多个字符或多行文字时是否开启“在选定内容中查找”选项 ',
+    '永不换行。',
+    '将在视区宽度处换行。',
+    '将在 "editor.wordWrapColumn" 处换行。',
+    '将在最小视区和 "editor.wordWrapColumn" 处换行。',
+    '控制折行方式。可以选择： - “off” （禁用折行）， - “on” （视区折行）， - “wordWrapColumn”（在“editor.wordWrapColumn”处折行）或 - “bounded”（在视区与“editor.wordWrapColumn”两者的较小者处折行）。',
+    '在 "editor.wordWrap" 为 "wordWrapColumn" 或 "bounded" 时控制编辑器列的换行。',
+    '控制折行的缩进。可以是“none”、“same”或“indent”。',
+    '要对鼠标滚轮滚动事件的 "deltaX" 和 "deltaY" 使用的乘数 ',
+    '映射到“Control”（Windows 和 Linux）或“Command”（OSX）。',
+    '映射到“Alt”（Windows 和 Linux）或“Option”（OSX）。',
+    '用鼠标添加多个光标时使用的修改键。“ctrlCmd”映射为“Control”（Windows 和 Linux）或“Command”（OSX）。“转到定义”和“打开链接”功能的鼠标手势将会相应调整，不与多光标修改键冲突。',
+    '在字符串内启用快速建议。',
+    '在注释内启用快速建议。',
+    '在字符串和注释外启用快速建议。',
+    '控制键入时是否应自动显示建议',
+    '控制延迟多少毫秒后将显示快速建议',
+    '启用在输入时显示含有参数文档和类型信息的小面板',
+    '控制编辑器是否应该在左括号后自动插入右括号',
+    '控制编辑器是否应在键入后自动设置行的格式',
+    '控制编辑器是否应自动设置粘贴内容的格式。格式化程序必须可用并且能设置文档中某一范围的格式。',
+    '控制编辑器是否应在用户键入、粘贴或移动行时自动调整缩进。语言的缩进规则必须可用。',
+    '控制键入触发器字符时是否应自动显示建议',
+    '控制按“Enter”键是否像按“Tab”键一样接受建议。这能帮助避免“插入新行”和“接受建议”之间的歧义。值为“smart”时表示，仅当文字改变时，按“Enter”键才能接受建议',
+    '控制是否应在遇到提交字符时接受建议。例如，在 JavaScript 中，分号(";")可以为提交字符，可接受建议并键入该字符。',
+    '在其他建议上方显示代码片段建议。',
+    '在其他建议下方显示代码片段建议。',
+    '在其他建议中穿插显示代码片段建议。',
+    '不显示代码片段建议。',
+    '控制是否将代码段与其他建议一起显示以及它们的排序方式。',
+    '控制没有选择内容的复制是否复制当前行。',
+    '控制是否应根据文档中的字数计算完成。',
+    '建议小组件的字号',
+    '建议小组件的行高',
+    '控制编辑器是否应突出显示选项的近似匹配',
+    '控制编辑器是否应该突出显示语义符号次数',
+    '控制可在概述标尺同一位置显示的效果数量',
+    '控制概述标尺周围是否要绘制边框。',
+    '控制光标动画样式，可能的值为 "blink"、"smooth"、"phase"、"expand" 和 "solid"',
+    '通过使用鼠标滚轮同时按住 Ctrl 可缩放编辑器的字体',
+    '控制光标样式，接受的值为 "block"、"block-outline"、"line"、"line-thin" 、"underline" 和 "underline-thin"',
+    '启用字体连字',
+    '控制光标是否应隐藏在概述标尺中。',
+    '控制编辑器中呈现空白字符的方式，可能为“无”、“边界”和“全部”。“边界”选项不会在单词之间呈现单空格。',
+    '控制编辑器是否应呈现控制字符',
+    '控制编辑器是否应呈现缩进参考线',
+    '控制编辑器应如何呈现当前行突出显示，可能为“无”、“装订线”、“线”和“全部”。',
+    '控制编辑器是否显示代码滤镜',
+    '控制编辑器是否启用代码折叠功能',
+    '控制是否自动隐藏导航线上的折叠控件。',
+    '当选择其中一项时，将突出显示匹配的括号。',
+    '控制编辑器是否应呈现垂直字形边距。字形边距最常用于调试。',
+    '在制表位后插入和删除空格',
+    '删除尾随自动插入的空格',
+    '即使在双击编辑器内容或按 Esc 键时，也要保持速览编辑器的打开状态。',
+    '控制编辑器是否应该允许通过拖放移动所选项。',
+    '编辑器将使用平台 API 以检测是否附加了屏幕阅读器。',
+    '编辑器将对屏幕阅读器的使用进行永久优化。',
+    '编辑器将不再对屏幕阅读器的使用进行优化。',
+    '控制编辑器是否应运行在对屏幕阅读器进行优化的模式。',
+    '控制编辑器是否应检测链接并使它们可被点击',
+    '控制 Diff 编辑器以并排或内联形式显示差异',
+    '控制差异编辑器是否将对前导空格或尾随空格的更改显示为差异',
+    '控制差异编辑器是否为已添加/删除的更改显示 +/- 指示符号',
+    '控制是否支持 Linux 主剪贴板。',
+  ],
+  'vs/editor/common/config/editorOptions': [
+    '现在无法访问编辑器。按 Alt+F1  显示选项。',
+    '编辑器内容',
+  ],
+  'vs/editor/common/controller/cursor': ['执行命令时出现意外异常。'],
+  'vs/editor/common/model/textModelWithTokens': ['标记输入时模式失败。'],
+  'vs/editor/common/modes/modesRegistry': ['纯文本'],
+  'vs/editor/common/services/bulkEdit': [
+    '这些文件也已同时更改: {0}',
+    '未做编辑',
+    '在 {1} 个文件中进行了 {0} 次编辑',
+    '在 1 个文件中进行了 {0} 次编辑',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    '光标所在行高亮内容的背景颜色。',
+    '光标所在行四周边框的背景颜色。',
+    '突出显示范围的背景颜色，例如 "Quick Open" 和“查找”功能。',
+    '编辑器光标颜色。',
+    '编辑器光标的背景色。可以自定义块型光标覆盖字符的颜色。',
+    '编辑器中空白字符颜色。',
+    '编辑器缩进参考线颜色。',
+    '编辑器行号颜色。',
+    '编辑器标尺的颜色。',
+    '编辑器 CodeLens 的前景色',
+    '匹配括号的背景色',
+    '匹配括号外框颜色',
+    '概览标尺边框的颜色。',
+    '编辑器导航线的背景色。导航线包括边缘符号和行号。',
+    '编辑器中错误波浪线的前景色。',
+    '编辑器中错误波浪线的边框颜色。',
+    '编辑器中警告波浪线的前景色。',
+    '编辑器中警告波浪线的边框颜色。',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['转到括号'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': ['将插入点左移', '将插入点右移'],
+  'vs/editor/contrib/caretOperations/common/transpose': ['转置字母'],
+  'vs/editor/contrib/clipboard/browser/clipboard': ['剪切', '复制', '粘贴', '复制并突出显示语法'],
+  'vs/editor/contrib/comment/common/comment': [
+    '切换行注释',
+    '添加行注释',
+    '删除行注释',
+    '切换块注释',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['显示编辑器上下文菜单'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    '查找',
+    '查找',
+    '上一个匹配',
+    '下一个匹配',
+    '在选定内容中查找',
+    '关闭',
+    '替换',
+    '替换',
+    '替换',
+    '全部替换',
+    '切换替换模式',
+    '仅前 999 个结果突出显示，但所有查找操作均针对整个文本。',
+    '第 {0} 个(共 {1} 个)',
+    '无结果',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    '查找',
+    '查找下一个',
+    '查找上一个',
+    '查找下一个选择',
+    '查找上一个选择',
+    '替换',
+    '将选择添加到下一个查找匹配项',
+    '将选择内容添加到上一查找匹配项',
+    '将上次选择移动到下一个查找匹配项',
+    '将上个选择内容移动到上一查找匹配项',
+    '选择所有找到的查找匹配项',
+    '更改所有匹配项',
+    '显示下一个搜索结果',
+    '显示上一个搜索结果',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    '展开',
+    '以递归方式展开',
+    '折叠',
+    '以递归方式折叠',
+    '全部折叠',
+    '全部展开',
+    '折叠级别 {0}',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    '在第 {0} 行进行了 1 次格式编辑',
+    '在第 {1} 行进行了 {0} 次格式编辑',
+    '第 {0} 行到第 {1} 行间进行了 1 次格式编辑',
+    '第 {1} 行到第 {2} 行间进行了 {0} 次格式编辑',
+    '格式化文件',
+    '格式化选定代码',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    '未找到“{0}”的任何定义',
+    '找不到定义',
+    ' – {0} 定义',
+    '转到定义',
+    '打开侧边的定义',
+    '查看定义',
+    '未找到“{0}”的实现',
+    '未找到实现',
+    '– {0} 个实现',
+    '转到实现',
+    '速览实现',
+    '未找到“{0}”的类型定义',
+    '未找到类型定义',
+    ' – {0} 个类型定义',
+    '转到类型定义',
+    '快速查看类型定义',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': ['单击显示 {0} 个定义。'],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    '转到下一个错误或警告',
+    '转到上一个错误或警告',
+    '编辑器标记导航小组件错误颜色。',
+    '编辑器标记导航小组件警告颜色。',
+    '编辑器标记导航小组件背景色。',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['显示悬停'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['正在加载...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': ['替换为上一个值', '替换为下一个值'],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    '向上复制行',
+    '向下复制行',
+    '向上移动行',
+    '向下移动行',
+    '按升序排列行',
+    '按降序排列行',
+    '裁剪尾随空格',
+    '删除行',
+    '行缩进',
+    '行减少缩进',
+    '在上面插入行',
+    '在下面插入行',
+    '删除左侧所有内容',
+    '删除右侧所有内容',
+    '合并行',
+    '转置游标处的字符',
+    '转换为大写',
+    '转换为小写',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    'Cmd + 单击以跟踪链接',
+    'Ctrl + 单击以跟踪链接',
+    'Cmd + 单击以执行命令',
+    'Ctrl + 单击以执行命令',
+    'Alt + 单击以访问链接',
+    'Alt + 单击以执行命令',
+    '抱歉，无法打开此链接，因为其格式不正确: {0}',
+    '抱歉，无法打开此链接，因为其目标丢失。',
+    '打开链接',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    '在上面添加光标',
+    '在下面添加光标',
+    '在行尾添加光标',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['触发参数提示'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}，提示'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    '显示修补程序({0})',
+    '显示修补程序',
+    '快速修复',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [' – {0} 个引用', '查找所有引用'],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['正在加载...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    '在文件 {0} 的 {1} 行 {2} 列的符号',
+    '{0}  中有 1 个符号，完整路径：{1}',
+    '{1} 中有 {0} 个符号，完整路径：{2}',
+    '未找到结果',
+    '在 {0} 中找到 1 个符号',
+    '在 {1} 中找到 {0} 个符号',
+    '在 {1} 个文件中找到 {0} 个符号',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    '解析文件失败。',
+    '{0} 个引用',
+    '{0} 个引用',
+    '无可用预览',
+    '引用',
+    '无结果',
+    '引用',
+    '速览视图标题区域背景颜色。',
+    '速览视图标题颜色。',
+    '速览视图标题信息颜色。',
+    '速览视图边框和箭头颜色。',
+    '速览视图结果列表背景颜色。',
+    '速览视图结果列表中行节点的前景色。',
+    '速览视图结果列表中文件节点的前景色。',
+    '速览视图结果列表中所选条目的背景颜色。',
+    '速览视图结果列表中所选条目的前景色。',
+    '速览视图编辑器背景颜色。',
+    '速览视图编辑器中导航线的背景颜色。',
+    '在速览视图结果列表中匹配突出显示颜色。',
+    '在速览视图编辑器中匹配突出显示颜色。',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    '无结果。',
+    '成功将“{0}”重命名为“{1}”。摘要：{2}',
+    '抱歉，重命名无法执行。',
+    '重命名符号',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    '重命名输入。键入新名称并按 "Enter" 提交。',
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['扩大选择', '缩小选择'],
+  'vs/editor/contrib/suggest/browser/suggestController': ['确认“{0}”插入以下文本：{1}', '触发建议'],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    '建议小组件的背景颜色',
+    '建议小组件的边框颜色',
+    '建议小组件的前景颜色。',
+    '建议小组件中被选择条目的背景颜色。',
+    '建议小组件中匹配内容的高亮颜色。',
+    '阅读详细信息...{0}',
+    '{0}(建议)具有详细信息',
+    '{0}，建议',
+    '阅读简略信息...{0}',
+    '正在加载...',
+    '无建议。',
+    '{0}，已接受',
+    '{0}(建议)具有详细信息',
+    '{0}，建议',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': ['切换 Tab 键是否移动焦点'],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    '读取访问时符号的背景颜色，例如读取变量时。',
+    '写入访问时符号的背景颜色，例如写入变量时。',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['关闭'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    '默认配置替代',
+    '针对 {0} 语言，配置替代编辑器设置。',
+    '针对某种语言，配置替代编辑器设置。',
+    '无法注册“{0}”。其符合描述特定语言编辑器设置的表达式 "\\\\[.*\\\\]$"。请使用 "configurationDefaults"。',
+    '无法注册“{0}”。此属性已注册。',
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    '已按下({0})。正在等待同时按下第二个键...',
+    '组合键({0}, {1})不是命令。',
+  ],
+  'vs/platform/message/common/message': ['关闭', '稍后', '取消'],
+  'vs/platform/theme/common/colorRegistry': [
+    '颜色格式无效。请使用 #RGB、#RGBA、#RRGGBB 或 #RRGGBBAA',
+    '工作台中使用的颜色。',
+    '整体前景色。此颜色仅在不被组件覆盖时适用。',
+    '错误信息的整体前景色。此颜色仅在不被组件覆盖时适用。',
+    '提供其他信息的说明文本的前景色，例如标签文本。',
+    '焦点元素的整体边框颜色。此颜色仅在不被其他组件覆盖时适用。',
+    '在元素周围额外的一层边框，用来提高对比度从而区别其他元素。',
+    '在活动元素周围额外的一层边框，用来提高对比度从而区别其他元素。',
+    '工作台所选文本的背景颜色（例如输入字段或文本区域）。注意，本设置不适用于编辑器。',
+    '文字分隔符的颜色。',
+    '文本中链接的前景色。',
+    '文本中活动链接的前景色。',
+    '预格式化文本段的前景色。',
+    '文本中块引用的背景颜色。',
+    '文本中块引用的边框颜色。',
+    '文本中代码块的背景颜色。',
+    '编辑器内小组件（如查找/替换）的阴影颜色。',
+    '输入框背景色。',
+    '输入框前景色。',
+    '输入框边框。',
+    '输入字段中已激活选项的边框颜色。',
+    '输入框中占位符的前景色。',
+    '严重性为信息时输入验证的背景颜色。',
+    '严重性为信息时输入验证的边框颜色。',
+    '严重性为警告时输入验证的背景颜色。',
+    '严重性为警告时输入验证的边框颜色。',
+    '严重性为错误时输入验证的背景颜色。',
+    '严重性为错误时输入验证的边框颜色。',
+    '下拉列表背景色。',
+    '下拉列表前景色。',
+    '下拉列表边框。',
+    '焦点项在列表或树活动时的背景颜色。活动的列表或树具有键盘焦点，非活动的没有。',
+    '焦点项在列表或树活动时的背景颜色。活动的列表或树具有键盘焦点，非活动的没有。',
+    '已选项在列表或树活动时的背景颜色。活动的列表或树具有键盘焦点，非活动的没有。',
+    '已选项在列表或树活动时的前景颜色。活动的列表或树具有键盘焦点，非活动的没有。',
+    '已选项在列表或树非活动时的背景颜色。活动的列表或树具有键盘焦点，非活动的没有。',
+    '已选项在列表或树非活动时的前景颜色。活动的列表或树具有键盘焦点，非活动的没有。',
+    '已选项在列表或树非活动时的背景颜色。活动的列表或树具有键盘焦点，非活动的没有。',
+    '已选项在列表或树非活动时的前景颜色。活动的列表或树具有键盘焦点，非活动的没有。',
+    '使用鼠标移动项目时，列表或树的背景颜色。',
+    '鼠标在项目上悬停时，列表或树的前景颜色。',
+    '使用鼠标移动项目时，列表或树进行拖放的背景颜色。',
+    '在列表或树中搜索时，其中匹配内容的高亮颜色。',
+    '快速选取器分组标签的颜色。',
+    '快速选取器分组边框的颜色。',
+    '按钮前景色。',
+    '按钮背景色。',
+    '按钮在悬停时的背景颜色。',
+    'Badge 背景色。Badge 是小型的信息标签，如表示搜索结果数量的标签。',
+    'Badge 前景色。Badge 是小型的信息标签，如表示搜索结果数量的标签。',
+    '表示视图被滚动的滚动条阴影。',
+    '滚动条滑块背景色',
+    '滚动条滑块在悬停时的背景色',
+    '滚动条滑块被激活时的背景色',
+    '表示长时间操作的进度条的背景色。',
+    '编辑器背景颜色。',
+    '编辑器默认前景色。',
+    '编辑器组件(如查找/替换)背景颜色。',
+    '编辑器小部件的边框颜色。此颜色仅在小部件有边框且不被小部件重写时适用。',
+    '编辑器所选内容的颜色。',
+    '用以彰显高对比度的所选文本的颜色。',
+    '非活动编辑器中所选内容的颜色。',
+    '与所选内容具有相同内容的区域颜色。',
+    '当前搜索匹配项的颜色。',
+    '其他搜索匹配项的颜色。',
+    '限制搜索的范围的颜色。',
+    '悬停提示显示时文本底下的高亮颜色。',
+    '编辑器悬停提示的背景颜色。',
+    '光标悬停时编辑器的边框颜色。',
+    '活动链接颜色。',
+    '已插入文本的背景颜色。',
+    '被删除文本的背景颜色。',
+    '插入的文本的轮廓颜色。',
+    '被删除文本的轮廓颜色。',
+    '内联合并冲突中当前版本区域的标头背景色。',
+    '内联合并冲突中当前版本区域的内容背景色。',
+    '内联合并冲突中传入的版本区域的标头背景色。',
+    '内联合并冲突中传入的版本区域的内容背景色。',
+    '内联合并冲突中共同祖先区域的标头背景色。',
+    '内联合并冲突中共同祖先区域的内容背景色。',
+    '内联合并冲突中标头和分割线的边框颜色。',
+    '内联合并冲突中当前版本区域的概览标尺前景色。',
+    '内联合并冲突中传入的版本区域的概览标尺前景色。',
+    '内联合并冲突中共同祖先区域的概览标尺前景色。',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.zh-cn.js.map

console/src/main/resources/static/console-fe/public/js/vs/editor/editor.main.nls.zh-tw.js

@@ -0,0 +1,514 @@
+/*
+ * Copyright 1999-2018 Alibaba Group Holding Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+define('vs/editor/editor.main.nls.zh-tw', {
+  'vs/base/browser/ui/actionbar/actionbar': ['{0} ({1})'],
+  'vs/base/browser/ui/aria/aria': ['{0} (再次出現)'],
+  'vs/base/browser/ui/findinput/findInput': ['輸入'],
+  'vs/base/browser/ui/findinput/findInputCheckboxes': [
+    '大小寫須相符',
+    '全字拼寫須相符',
+    '使用規則運算式',
+  ],
+  'vs/base/browser/ui/inputbox/inputBox': ['錯誤: {0}', '警告: {0}', '資訊: {0}'],
+  'vs/base/common/keybindingLabels': [
+    'Ctrl',
+    'Shift',
+    'Alt',
+    'Windows',
+    'Control',
+    'Shift',
+    'Alt',
+    'Command',
+    'Control',
+    'Shift',
+    'Alt',
+    'Windows',
+  ],
+  'vs/base/common/severity': ['錯誤', '警告', '資訊'],
+  'vs/base/parts/quickopen/browser/quickOpenModel': ['{0}，選擇器', '選擇器'],
+  'vs/base/parts/quickopen/browser/quickOpenWidget': [
+    '快速選擇器。輸入以縮小結果範圍。',
+    '快速選擇器',
+  ],
+  'vs/base/parts/tree/browser/treeDefaults': ['摺疊'],
+  'vs/editor/browser/widget/diffEditorWidget': ['因其中一個檔案過大而無法比較。'],
+  'vs/editor/browser/widget/diffReview': [
+    '關閉',
+    '差異 {0} / {1}: 原始 {2}，{3} 行，修改後 {4}，{5} 行',
+    '空白',
+    '原始 {0},修改後{1}: {2',
+    '+ 修改後 {0}: {1}',
+    '- 原始 {0}: {1}',
+    '移至下一個差異',
+    '移至上一個差異',
+  ],
+  'vs/editor/common/config/commonEditorConfig': [
+    '編輯器',
+    '控制字型家族。',
+    '控制字型寬度。',
+    '控制字型大小 (以像素為單位)。',
+    '控制行高。使用 0 會從 fontSize 計算 lineHeight。',
+    '控制字元間距 (以像素為單位)',
+    "控制行號顯示。可能的值有 'on'、'off' 及 'relative'。'relative' 會從目前的資料指標位置顯示行數。",
+    '要在其中顯示垂直尺規的資料行',
+    '執行文字相關導覽或作業時將作為文字分隔符號的字元',
+    '與 Tab 相等的空格數量。當 `editor.detectIndentation` 已開啟時，會根據檔案內容覆寫此設定。',
+    '必須是 \'number\'。請注意，值 "auto" 已由 `editor.detectIndentation` 設定取代。',
+    '在按 Tab 時插入空格。當 `editor.detectIndentation` 已開啟時，會根據檔案內容覆寫此設定。',
+    '必須是 \'boolean\'。請注意，值 "auto" 已由 `editor.detect Indentation` 設定取代。',
+    '開啟檔案時，會依據檔案內容來偵測 `editor.tabSize` 及 `editor.insertSpaces`。',
+    '控制選取範圍是否有圓角',
+    '控制編輯器是否會捲動到最後一行之後',
+    '控制是否會顯示迷你地圖',
+    '自動隱藏迷你地圖滑桿',
+    '呈現行內的實際字元 (而不是彩色區塊)',
+    '限制迷你地圖的寬度，以呈現最多的資料行',
+    '控制編譯器選取範圍是否預設為尋找工具的搜尋字串',
+    '控制編譯器內選取多字元或多行內文是否開啟選取範圍尋找功能',
+    '一律不換行。',
+    '依檢視區寬度換行。',
+    "於 'editor.wordWrapColumn' 換行。",
+    "當檢視區縮至最小並設定 'editor.wordWrapColumn' 時換行。",
+    "控制是否自動換行。可以是:\n - 'off' (停用換行),\n - 'on' (檢視區換行),\n - 'wordWrapColumn' (於 'editor.wordWrapColumn' 換行`) 或\n - 'bounded' (當檢視區縮至最小並設定 'editor.wordWrapColumn' 時換行).",
+    '當 `editor.wordWrap` 為 [wordWrapColumn] 或 [bounded] 時，控制編輯器中的資料行換行。',
+    '控制換行的縮排。可以是 [無]、[相同] 或 [縮排]。',
+    "滑鼠滾輪捲動事件的 'deltaX' 與 'deltaY' 所使用的乘數",
+    "對應Windows和Linux的'Control'與對應OSX的'Command'",
+    "對應Windows和Linux的'Alt'與對應OSX的'Option'",
+    '用於新增多個滑鼠游標的修改程式。`ctrlCmd` 會對應到 Windows 及 Linux 上的 `Control` 以及 OSX 上的 `Command`。[移至定義] 及 [開啟連結] 滑鼠手勢將會適應以避免和 multicursor 修改程式衝突。',
+    '允許在字串內顯示即時建議。',
+    '允許在註解中顯示即時建議。',
+    '允許在字串與註解以外之處顯示即時建議。',
+    '控制是否應在輸入時自動顯示建議',
+    '控制延遲顯示快速建議的毫秒數',
+    '當您輸入時啟用彈出視窗，顯示參數文件與類型資訊',
+    '控制編輯器是否應在左括號後自動插入右括號',
+    '控制編輯器是否應在輸入一行後自動格式化',
+    '控制編輯器是否應自動設定貼上的內容格式。格式器必須可供使用，而且格式器應該能夠設定文件中一個範圍的格式。',
+    '控制當使用者輸入, 貼上或移行時，編輯器必須自動調整縮排\n語言的縮排規則必須可用',
+    '控制輸入觸發字元時，是否應自動顯示建議',
+    "控制除了 'Tab' 外，是否也藉由按下 'Enter' 接受建議。如此可避免混淆要插入新行或接受建議。設定值'smart'表示在文字變更同時，只透過Enter接受建議。",
+    "控制認可字元是否應接受建議。例如在 JavaScript 中，分號 (';') 可以是接受建議並鍵入該字元的認可字元。",
+    '將程式碼片段建議顯示於其他建議的頂端。',
+    '將程式碼片段建議顯示於其他建議的下方。',
+    '將程式碼片段建議與其他建議一同顯示。',
+    '不顯示程式碼片段建議。',
+    '控制程式碼片段是否隨其他建議顯示，以及其排序方式。',
+    '控制複製時不選取任何項目是否會複製目前程式行。',
+    '控制是否應根據文件中的單字計算自動完成。',
+    '建議小工具的字型大小',
+    '建議小工具的行高',
+    '控制編輯器是否應反白顯示與選取範圍相似的符合項',
+    '控制編輯器是否應反白顯示出現的語意符號',
+    '控制可在概觀尺規中相同位置顯示的裝飾項目數',
+    '控制是否應在概觀尺規周圍繪製邊框。',
+    "控制游標動畫樣式，可能的值為 'blink'、'smooth'、'phase'、'expand' 和 'solid'",
+    '使用滑鼠滾輪並按住 Ctrl 時，縮放編輯器的字型',
+    "控制游標樣式。接受的值為 'block'、'block-outline'、'line'、'line-thin'、'underline' 及 'underline-thin'",
+    '啟用連字字型',
+    '控制游標是否應隱藏在概觀尺規中。',
+    "控制編輯器轉譯空白字元的方式，可能為 'none'、'boundary' 及 'all'。'boundary' 選項不會轉譯字組間的單一空格。",
+    '控制編輯器是否應顯示控制字元',
+    '控制編輯器是否應顯示縮排輔助線',
+    "控制編輯器應如何轉譯目前反白的行，可能的值有 'none'、'gutter'、'line' 和 'all'。",
+    '控制編輯器是否顯示程式碼濾鏡',
+    '控制編輯器是否已啟用程式碼摺疊功能',
+    '自動隱藏摺疊控制向',
+    '當選取某側的括號時，強調顯示另一側的配對括號。',
+    '控制編輯器是否應轉譯垂直字符邊界。字符邊界最常用來進行偵錯。',
+    '插入和刪除接在定位停駐點後的空白字元',
+    '移除尾端自動插入的空白字元',
+    '讓預覽編輯器在使用者按兩下其內容或點擊 Escape 時保持開啟。',
+    '控制編輯器是否允許透過拖放動作移動選取範圍。',
+    '編輯器將使用平台 API 以偵測螢幕助讀程式附加。',
+    '編輯器將會為螢幕助讀程式的使用方式永久地最佳化。',
+    '編輯器不會為螢幕助讀程式的使用方式進行最佳化。',
+    '控制編輯器是否應於已為螢幕助讀程式最佳化的模式中執行。',
+    '控制編輯器是否應偵測連結且讓它可點擊',
+    '控制 Diff 編輯器要並排或內嵌顯示差異',
+    '控制 Diff 編輯器是否將開頭或尾端空白字元的變更顯示為差異',
+    '控制 Diff 編輯器是否要為新增的/移除的變更顯示 +/- 標記',
+    '控制是否應支援 Linux 主要剪貼簿。',
+  ],
+  'vs/editor/common/config/editorOptions': ['編輯器現在無法存取。按Alt+F1尋求選項', '編輯器內容'],
+  'vs/editor/common/controller/cursor': ['執行命令時發生未預期的例外狀況。'],
+  'vs/editor/common/model/textModelWithTokens': ['將輸入語彙基元化時，模式失敗。'],
+  'vs/editor/common/modes/modesRegistry': ['純文字'],
+  'vs/editor/common/services/bulkEdit': [
+    '這些檔案已同時變更: {0}',
+    '未進行任何編輯',
+    '在 {1} 個檔案中進行了 {0} 項文字編輯',
+    '在一個檔案中進行了 {0} 項文字編輯',
+  ],
+  'vs/editor/common/services/modelServiceImpl': ['[{0}]\n{1}', '[{0}] {1}'],
+  'vs/editor/common/view/editorColorRegistry': [
+    '目前游標位置行的反白顯示背景色彩。',
+    '目前游標位置行之周圍框線的背景色彩。',
+    '反白顯示範圍的背景色彩，例如 Quick Open 與尋找功能。',
+    '編輯器游標的色彩。',
+    '編輯器游標的背景色彩。允許自訂區塊游標重疊的字元色彩。',
+    '編輯器中空白字元的色彩。',
+    '編輯器縮排輔助線的色彩。',
+    '編輯器行號的色彩。',
+    '編輯器尺規的色彩',
+    '編輯器程式碼濾鏡的前景色彩',
+    '成對括號背景色彩',
+    '成對括號邊框色彩',
+    '預覽檢視編輯器尺規的邊框色彩.',
+    '編輯器邊框的背景顏色,包含行號與字形圖示的邊框.',
+    '編輯器內錯誤提示線的前景色彩.',
+    '編輯器內錯誤提示線的邊框色彩.',
+    '編輯器內警告提示線的前景色彩.',
+    '編輯器內警告提示線的邊框色彩.',
+  ],
+  'vs/editor/contrib/bracketMatching/common/bracketMatching': ['移至方括弧'],
+  'vs/editor/contrib/caretOperations/common/caretOperations': ['將插入點左移', '將插入點右移'],
+  'vs/editor/contrib/caretOperations/common/transpose': ['調換字母'],
+  'vs/editor/contrib/clipboard/browser/clipboard': ['剪下', '複製', '貼上', '隨語法醒目提示複製'],
+  'vs/editor/contrib/comment/common/comment': [
+    '切換行註解',
+    '加入行註解',
+    '移除行註解',
+    '切換區塊註解',
+  ],
+  'vs/editor/contrib/contextmenu/browser/contextmenu': ['顯示編輯器內容功能表'],
+  'vs/editor/contrib/find/browser/findWidget': [
+    '尋找',
+    '尋找',
+    '上一個符合項',
+    '下一個相符項',
+    '在選取範圍中尋找',
+    '關閉',
+    '取代',
+    '取代',
+    '取代',
+    '全部取代',
+    '切換取代模式',
+    '只會將前 999 筆結果醒目提示，但所有尋找作業會在完整文字上執行。',
+    '{0} / {1}',
+    '沒有結果',
+  ],
+  'vs/editor/contrib/find/common/findController': [
+    '尋找',
+    '尋找下一個',
+    '尋找上一個',
+    '尋找下一個選取項目',
+    '尋找上一個選取項目',
+    '取代',
+    '將選取項目加入下一個找到的相符項',
+    '將選取項目加入前一個找到的相符項中',
+    '將最後一個選擇項目移至下一個找到的相符項',
+    '將最後一個選擇項目移至前一個找到的相符項',
+    '選取所有找到的相符項目',
+    '變更所有發生次數',
+    '顯示下一個尋找字詞',
+    '顯示上一個尋找字詞',
+  ],
+  'vs/editor/contrib/folding/browser/folding': [
+    '展開',
+    '以遞迴方式展開',
+    '摺疊',
+    '以遞迴方式摺疊',
+    '全部摺疊',
+    '全部展開',
+    '摺疊層級 {0}',
+  ],
+  'vs/editor/contrib/format/browser/formatActions': [
+    '在行 {0} 編輯了 1 項格式',
+    '在行 {1} 編輯了 {0} 項格式',
+    '在行 {0} 與行 {1} 之間編輯了 1 項格式',
+    '在行 {1} 與行 {2} 之間編輯了 {0} 項格式',
+    '將文件格式化',
+    '將選取項目格式化',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationCommands': [
+    "找不到 '{0}' 的定義",
+    '找不到任何定義',
+    ' - {0} 個定義',
+    '移至定義',
+    '在一側開啟定義',
+    '預覽定義',
+    "找不到 '{0}' 的任何實作",
+    '找不到任何實作',
+    ' – {0} 個實作',
+    '前往實作',
+    '預覽實作',
+    "找不到 '{0}' 的任何類型定義",
+    '找不到任何類型定義',
+    ' – {0} 個定義',
+    '移至類型定義',
+    '預覽類型定義',
+  ],
+  'vs/editor/contrib/goToDeclaration/browser/goToDeclarationMouse': ['按一下以顯示 {0} 項定義。'],
+  'vs/editor/contrib/gotoError/browser/gotoError': [
+    '({0}/{1})',
+    '移至下一個錯誤或警告',
+    '移至上一個錯誤或警告',
+    '編輯器標記導覽小工具錯誤的色彩。',
+    '編輯器標記導覽小工具警告的色彩。',
+    '編輯器標記導覽小工具的背景。',
+  ],
+  'vs/editor/contrib/hover/browser/hover': ['動態顯示'],
+  'vs/editor/contrib/hover/browser/modesContentHover': ['正在載入...'],
+  'vs/editor/contrib/inPlaceReplace/common/inPlaceReplace': ['以上一個值取代', '以下一個值取代'],
+  'vs/editor/contrib/linesOperations/common/linesOperations': [
+    '將行向上複製',
+    '將行向下複製',
+    '上移一行',
+    '下移一行',
+    '遞增排序行',
+    '遞減排序行',
+    '修剪尾端空白',
+    '刪除行',
+    '縮排行',
+    '凸排行',
+    '在上方插入行',
+    '在下方插入行',
+    '左邊全部刪除',
+    '刪除所有右方項目',
+    '連接線',
+    '轉置游標周圍的字元數',
+    '轉換到大寫',
+    '轉換到小寫',
+  ],
+  'vs/editor/contrib/links/browser/links': [
+    '按住 Cmd 並按一下按鍵以追蹤連結',
+    '按住 Ctrl 並按一下滑鼠按鈕可連入連結',
+    '按住 Cmd 並按一下滑鼠以執行命令',
+    '按住 Ctrl 並按一下滑鼠以執行命令',
+    '按住Alt並點擊以追蹤連結',
+    '按住 Alt 並按一下滑鼠以執行命令',
+    '抱歉，因為此連結的語式不正確，所以無法加以開啟: {0}',
+    '抱歉，因為此連結遺失目標，所以無法加以開啟。',
+    '開啟連結',
+  ],
+  'vs/editor/contrib/multicursor/common/multicursor': [
+    '在上方加入游標',
+    '在下方加入游標',
+    '在行尾新增游標',
+  ],
+  'vs/editor/contrib/parameterHints/browser/parameterHints': ['觸發參數提示'],
+  'vs/editor/contrib/parameterHints/browser/parameterHintsWidget': ['{0}，提示'],
+  'vs/editor/contrib/quickFix/browser/quickFixCommands': [
+    '顯示修正 ({0})',
+    '顯示修正',
+    'Quick Fix',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referenceSearch': [' - {0} 個參考', '尋找所有參考'],
+  'vs/editor/contrib/referenceSearch/browser/referencesController': ['正在載入...'],
+  'vs/editor/contrib/referenceSearch/browser/referencesModel': [
+    '個符號位於 {0} 中的第 {1} 行第 {2} 欄',
+    '1 個符號位於 {0}, 完整路徑 {1}',
+    '{0} 個符號位於 {1}, 完整路徑 {2}',
+    '找不到結果',
+    '在 {0} 中找到 1 個符號',
+    '在 {1} 中找到 {0} 個符號',
+    '在 {1} 個檔案中找到 {0} 個符號',
+  ],
+  'vs/editor/contrib/referenceSearch/browser/referencesWidget': [
+    '無法解析檔案。',
+    '{0} 個參考',
+    '{0} 個參考',
+    '無法預覽',
+    '參考',
+    '沒有結果',
+    '參考',
+    '預覽檢視標題區域的背景色彩。',
+    '預覽檢視標題的色彩。',
+    '預覽檢視標題資訊的色彩。',
+    '預覽檢視之框線與箭頭的色彩。',
+    '預覽檢視中結果清單的背景色彩。',
+    '預覽檢視結果列表中行節點的前景色彩',
+    '預覽檢視結果列表中檔案節點的前景色彩',
+    '在預覽檢視之結果清單中選取項目時的背景色彩。',
+    '在預覽檢視之結果清單中選取項目時的前景色彩。',
+    '預覽檢視編輯器的背景色彩。',
+    '預覽檢視編輯器邊框(含行號或字形圖示)的背景色彩。',
+    '在預覽檢視編輯器中比對時的反白顯示色彩。',
+    '預覽檢視編輯器中比對時的反白顯示色彩。',
+  ],
+  'vs/editor/contrib/rename/browser/rename': [
+    '沒有結果。',
+    "已成功將 '{0}' 重新命名為 '{1}'。摘要: {2}",
+    '抱歉，無法執行重新命名。',
+    '重新命名符號',
+  ],
+  'vs/editor/contrib/rename/browser/renameInputField': [
+    '為輸入重新命名。請鍵入新名稱，然後按 Enter 以認可。',
+  ],
+  'vs/editor/contrib/smartSelect/common/smartSelect': ['展開選取', '縮小選取'],
+  'vs/editor/contrib/suggest/browser/suggestController': [
+    "接受 '{0}' 時接受了插入下列文字: {1}",
+    '觸發建議',
+  ],
+  'vs/editor/contrib/suggest/browser/suggestWidget': [
+    '建議小工具的背景色彩。',
+    '建議小工具的邊界色彩。',
+    '建議小工具的前景色彩。',
+    '建議小工具中所選項目的背景色彩。',
+    '建議小工具中相符醒目提示的色彩。',
+    '進一步了解...{0}',
+    '{0}，建議，有詳細資料',
+    '{0}，建議',
+    '簡易說明...{0}',
+    '正在載入...',
+    '無建議。',
+    '{0}，接受',
+    '{0}，建議，有詳細資料',
+    '{0}，建議',
+  ],
+  'vs/editor/contrib/toggleTabFocusMode/common/toggleTabFocusMode': ['切換 TAB 鍵移動焦點'],
+  'vs/editor/contrib/wordHighlighter/common/wordHighlighter': [
+    '讀取存取期間 (例如讀取變數時) 符號的背景色彩。',
+    '寫入存取期間 (例如寫入變數時) 符號的背景色彩。',
+  ],
+  'vs/editor/contrib/zoneWidget/browser/peekViewWidget': ['關閉'],
+  'vs/editor/standalone/browser/inspectTokens/inspectTokens': ['Developer: Inspect Tokens'],
+  'vs/editor/standalone/browser/quickOpen/gotoLine': [
+    'Go to line {0} and character {1}',
+    'Go to line {0}',
+    'Type a line number between 1 and {0} to navigate to',
+    'Type a character between 1 and {0} to navigate to',
+    'Go to line {0}',
+    'Type a line number, followed by an optional colon and a character number to navigate to',
+    'Go to Line...',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickCommand': [
+    '{0}, commands',
+    'Type the name of an action you want to execute',
+    'Command Palette',
+  ],
+  'vs/editor/standalone/browser/quickOpen/quickOutline': [
+    '{0}, symbols',
+    'Type the name of an identifier you wish to navigate to',
+    'Go to Symbol...',
+    'symbols ({0})',
+    'modules ({0})',
+    'classes ({0})',
+    'interfaces ({0})',
+    'methods ({0})',
+    'functions ({0})',
+    'properties ({0})',
+    'variables ({0})',
+    'variables ({0})',
+    'constructors ({0})',
+    'calls ({0})',
+  ],
+  'vs/editor/standalone/browser/standaloneCodeEditor': [
+    'Editor content',
+    'Press Ctrl+F1 for Accessibility Options.',
+    'Press Alt+F1 for Accessibility Options.',
+  ],
+  'vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast': [
+    'Toggle High Contrast Theme',
+  ],
+  'vs/platform/configuration/common/configurationRegistry': [
+    '預設組態覆寫',
+    '設定要針對 {0} 語言覆寫的編輯器設定。',
+    '設定要針對語言覆寫的編輯器設定。',
+    "無法註冊 '{0}'。這符合用於描述語言專用編輯器設定的屬性模式 '\\\\[.*\\\\]$'。請使用 'configurationDefaults' 貢獻。",
+    "無法註冊 '{0}'。此屬性已經註冊。",
+  ],
+  'vs/platform/keybinding/common/abstractKeybindingService': [
+    '已按下 ({0})。請等待第二個套索鍵...',
+    '按鍵組合 ({0}, {1}) 不是命令。',
+  ],
+  'vs/platform/message/common/message': ['關閉', '稍後', '取消'],
+  'vs/platform/theme/common/colorRegistry': [
+    '色彩格式無效。請使用 #RGB、#RGBA、#RRGGBB 或 #RRGGBBAA',
+    '工作台中使用的色彩。',
+    '整體的前景色彩。僅當未被任何元件覆疊時，才會使用此色彩。',
+    '整體錯誤訊息的前景色彩。僅當未被任何元件覆蓋時，才會使用此色彩。',
+    '提供附加訊息的前景顏色,例如標籤',
+    '焦點項目的整體框線色彩。只在沒有任何元件覆寫此色彩時，才會加以使用。',
+    '項目周圍的額外框線，可將項目從其他項目中區隔出來以提高對比。',
+    '使用中項目周圍的額外邊界，可將項目從其他項目中區隔出來以提高對比。',
+    '作業區域選取的背景顏色(例如輸入或文字區域)。請注意，這不適用於編輯器中的選取。',
+    '文字分隔符號的顏色。',
+    '內文連結的前景色彩',
+    '內文使用連結的前景色彩',
+    '提示及建議文字的前景色彩。',
+    '文內引用區塊背景色彩。',
+    '引用文字的框線顏色。',
+    '文字區塊的背景顏色。',
+    '小工具的陰影色彩，例如編輯器中的尋找/取代。',
+    '輸入方塊的背景。',
+    '輸入方塊的前景。',
+    '輸入方塊的框線。',
+    '輸入欄位中可使用之項目的框線色彩。',
+    '文字輸入替代字符的前景顏色。',
+    '資訊嚴重性的輸入驗證背景色彩。',
+    '資訊嚴重性的輸入驗證邊界色彩。',
+    '資訊警告的輸入驗證背景色彩。',
+    '警告嚴重性的輸入驗證邊界色彩。',
+    '錯誤嚴重性的輸入驗證背景色彩。',
+    '錯誤嚴重性的輸入驗證邊界色彩。',
+    '下拉式清單的背景。',
+    '下拉式清單的前景。',
+    '下拉式清單的框線。',
+    '當清單/樹狀為使用中狀態時，焦點項目的清單/樹狀背景色彩。使用中的清單/樹狀有鍵盤焦點，非使用中者則沒有。',
+    '當清單/樹狀為使用中狀態時，焦點項目的清單/樹狀前景色彩。使用中的清單/樹狀有鍵盤焦點，非使用中者則沒有。',
+    '當清單/樹狀為使用中狀態時，所選項目的清單/樹狀背景色彩。使用中的清單/樹狀有鍵盤焦點，非使用中者則沒有。',
+    '當清單/樹狀為使用中狀態時，所選項目的清單/樹狀前景色彩。使用中的清單/樹狀有鍵盤焦點，非使用中者則沒有。',
+    '當清單/樹狀為非使用中狀態時，所選項目的清單/樹狀背景色彩。使用中的清單/樹狀有鍵盤焦點，非使用中者則沒有。',
+    '當清單/樹狀為使用中狀態時，所選項目的清單/樹狀前景色彩。使用中的清單/樹狀有鍵盤焦點，非使用中則沒有。',
+    '當清單/樹狀為非使用中狀態時，所選項目的清單/樹狀背景色彩。使用中的清單/樹狀有鍵盤焦點，非使用中者則沒有。',
+    '當清單/樹狀為使用中狀態時，所選項目的清單/樹狀前景色彩。使用中的清單/樹狀有鍵盤焦點，非使用中則沒有。',
+    '使用滑鼠暫留在項目時的清單/樹狀背景。',
+    '滑鼠暫留在項目時的清單/樹狀前景。',
+    '使用滑鼠四處移動項目時的清單/樹狀拖放背景。',
+    '在清單/樹狀內搜尋時，相符醒目提示的清單/樹狀前景色彩。',
+    '分組標籤的快速選擇器色彩。',
+    '分組邊界的快速選擇器色彩。',
+    '按鈕前景色彩。',
+    '按鈕背景色彩。',
+    '暫留時的按鈕背景色彩。',
+    '標記的背景顏色。標記為小型的訊息標籤,例如搜尋結果的數量。',
+    '標記的前景顏色。標記為小型的訊息標籤,例如搜尋結果的數量。',
+    '指出在捲動該檢視的捲軸陰影。',
+    '捲軸滑桿的背景顏色。',
+    '動態顯示時捲軸滑桿的背景顏色。',
+    '使用中狀態下捲軸滑桿的背景顏色。',
+    '長時間運行進度條的背景色彩.',
+    '編輯器的背景色彩。',
+    '編輯器的預設前景色彩。',
+    '編輯器小工具的背景色彩，例如尋找/取代。',
+    '編輯器小工具的邊界色彩。小工具選擇擁有邊界或色彩未被小工具覆寫時，才會使用色彩。',
+    '編輯器選取範圍的色彩。',
+    '為選取的文字顏色高對比化',
+    '非使用中之編輯器選取範圍的色彩。',
+    '選取時，內容相同之區域的色彩。',
+    '符合目前搜尋的色彩。',
+    '符合其他搜尋的色彩。',
+    '限制搜尋之範圍的色彩。',
+    '在顯示了動態顯示的單字下方醒目提示。',
+    '編輯器動態顯示的背景色彩。',
+    '編輯器動態顯示的框線色彩。',
+    '使用中之連結的色彩。',
+    '插入文字的背景色彩。',
+    '移除文字的背景色彩。',
+    '插入的文字外框色彩。',
+    '移除的文字外框色彩。',
+    '目前內嵌合併衝突中的深色標題背景。',
+    '目前內嵌合併衝突中的內容背景。',
+    '傳入內嵌合併衝突中的深色標題背景。',
+    '傳入內嵌合併衝突中的內容背景。',
+    '內嵌合併衝突中的共同始祖標題背景',
+    '內嵌合併衝突中的共同始祖內容背景。',
+    '內嵌合併衝突中標頭及分隔器的邊界色彩。',
+    '目前內嵌合併衝突的概觀尺規前景。',
+    '傳入內嵌合併衝突的概觀尺規前景。',
+    '內嵌合併衝突中的共同上階概觀尺規前景。',
+  ],
+});
+//# sourceMappingURL=../../../min-maps/vs/editor/editor.main.nls.zh-tw.js.map