@codingame/monaco-vscode-api 5.3.0 → 6.0.1

package/vscode/src/vs/base/browser/markdownRenderer.js

@@ -1,5 +1,5 @@
 import { getWindow, addDisposableListener, $, reset, hookDomPurifyHrefAndSrcSanitizer, basicMarkupHtmlTags } from './dom.js';
-import { addHook, sanitize, removeHook } from './dompurify/dompurify.js';
+import { sanitize, addHook, removeHook } from './dompurify/dompurify.js';
 import { DomEmitter } from './event.js';
 import { createElement } from './formattedTextRenderer.js';
 import { StandardKeyboardEvent } from './keyboardEvent.js';
@@ -10,8 +10,9 @@ import { Event } from '../common/event.js';
 import { parseHrefAndDimensions, escapeDoubleQuotes, removeMarkdownEscapes } from '../common/htmlContent.js';
 import { markdownEscapeEscapedIcons } from '../common/iconLabels.js';
 import { defaultGenerator } from '../common/idGenerator.js';
+import { KeyCode } from '../common/keyCodes.js';
 import { Lazy } from '../common/lazy.js';
-import { DisposableStore } from '../common/lifecycle.js';
+import { toDisposable, DisposableStore } from '../common/lifecycle.js';
 import marked_1 from '../../../../../external/vscode-marked/lib/marked.esm.js';
 import { parse } from '../common/marshalling.js';
 import { Schemas, FileAccess } from '../common/network.js';
@@ -163,7 +164,7 @@ function renderMarkdown(markdown, options = {}, markedOptions = {}) {
         }));
         options.actionHandler.disposables.add(addDisposableListener(element, 'keydown', (e) => {
             const keyboardEvent = ( new StandardKeyboardEvent(e));
-            if (!keyboardEvent.equals(10 ) && !keyboardEvent.equals(3 )) {
+            if (!keyboardEvent.equals(KeyCode.Space) && !keyboardEvent.equals(KeyCode.Enter)) {
                 return;
             }
             _activateLink(keyboardEvent);
@@ -171,6 +172,9 @@ function renderMarkdown(markdown, options = {}, markedOptions = {}) {
     }
     if (!markdown.supportHtml) {
         markedOptions.sanitizer = (html) => {
+            if (options.sanitizerOptions?.replaceWithPlaintext) {
+                return escape(html);
+            }
             const match = markdown.isTrusted ? html.match(/^(<span[^>]+>)|(<\/\s*span>)$/) : undefined;
             return match ? html : '';
         };
@@ -203,7 +207,7 @@ function renderMarkdown(markdown, options = {}, markedOptions = {}) {
         renderedMarkdown = ( elements.map(e => typeof e === 'string' ? e : e.outerHTML)).join('');
     }
     const htmlParser = ( new DOMParser());
-    const markdownHtmlDoc = htmlParser.parseFromString(sanitizeRenderedMarkdown(markdown, renderedMarkdown), 'text/html');
+    const markdownHtmlDoc = htmlParser.parseFromString(sanitizeRenderedMarkdown({ isTrusted: markdown.isTrusted, ...options.sanitizerOptions }, renderedMarkdown), 'text/html');
     markdownHtmlDoc.body.querySelectorAll('img, audio, video, source')
         .forEach(img => {
         const src = img.getAttribute('src');
@@ -216,9 +220,9 @@ function renderMarkdown(markdown, options = {}, markedOptions = {}) {
             }
             catch (err) { }
             img.setAttribute('src', _href(href, true));
-            if (options.disallowRemoteImages) {
-                const uriScheme = ( URI.parse(href)).scheme;
-                if (uriScheme !== Schemas.file && uriScheme !== Schemas.data) {
+            if (options.remoteImageIsAllowed) {
+                const uri = ( URI.parse(href));
+                if (uri.scheme !== Schemas.file && uri.scheme !== Schemas.data && !options.remoteImageIsAllowed(uri)) {
                     img.replaceWith($('', undefined, img.outerHTML));
                 }
             }
@@ -242,7 +246,7 @@ function renderMarkdown(markdown, options = {}, markedOptions = {}) {
             a.dataset.href = resolvedHref;
         }
     });
-    element.innerHTML = sanitizeRenderedMarkdown(markdown, markdownHtmlDoc.body.innerHTML);
+    element.innerHTML = sanitizeRenderedMarkdown({ isTrusted: markdown.isTrusted, ...options.sanitizerOptions }, markdownHtmlDoc.body.innerHTML);
     if (codeBlocks.length > 0) {
         Promise.all(codeBlocks).then((tuples) => {
             if (isDisposed) {
@@ -307,9 +311,11 @@ function resolveWithBaseUri(baseUri, href) {
         return ( resolvePath(dirname(baseUri), href).toString());
     }
 }
+const selfClosingTags = ['area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
 function sanitizeRenderedMarkdown(options, renderedMarkdown) {
     const { config, allowedSchemes } = getSanitizerOptions(options);
-    addHook('uponSanitizeAttribute', (element, e) => {
+    const store = ( new DisposableStore());
+    store.add(addDompurifyHook('uponSanitizeAttribute', (element, e) => {
         if (e.attrName === 'style' || e.attrName === 'class') {
             if (element.tagName === 'SPAN') {
                 if (e.attrName === 'style') {
@@ -331,24 +337,55 @@ function sanitizeRenderedMarkdown(options, renderedMarkdown) {
             }
             e.keepAttr = false;
         }
-    });
-    addHook('uponSanitizeElement', (element, e) => {
+    }));
+    store.add(addDompurifyHook('uponSanitizeElement', (element, e) => {
         if (e.tagName === 'input') {
             if (element.attributes.getNamedItem('type')?.value === 'checkbox') {
                 element.setAttribute('disabled', '');
             }
-            else {
+            else if (!options.replaceWithPlaintext) {
                 element.parentElement?.removeChild(element);
             }
         }
-    });
-    const hook = hookDomPurifyHrefAndSrcSanitizer(allowedSchemes);
+        if (options.replaceWithPlaintext && !e.allowedTags[e.tagName] && e.tagName !== 'body') {
+            if (element.parentElement) {
+                let startTagText;
+                let endTagText;
+                if (e.tagName === '#comment') {
+                    startTagText = `<!--${element.textContent}-->`;
+                }
+                else {
+                    const isSelfClosing = selfClosingTags.includes(e.tagName);
+                    const attrString = element.attributes.length ?
+                        ' ' + ( Array.from(element.attributes)
+                            .map(attr => `${attr.name}="${attr.value}"`))
+                            .join(' ')
+                        : '';
+                    startTagText = `<${e.tagName}${attrString}>`;
+                    if (!isSelfClosing) {
+                        endTagText = `</${e.tagName}>`;
+                    }
+                }
+                const fragment = document.createDocumentFragment();
+                const textNode = element.parentElement.ownerDocument.createTextNode(startTagText);
+                fragment.appendChild(textNode);
+                const endTagTextNode = endTagText ? element.parentElement.ownerDocument.createTextNode(endTagText) : undefined;
+                while (element.firstChild) {
+                    fragment.appendChild(element.firstChild);
+                }
+                if (endTagTextNode) {
+                    fragment.appendChild(endTagTextNode);
+                }
+                element.parentElement.replaceChild(fragment, element);
+            }
+        }
+    }));
+    store.add(hookDomPurifyHrefAndSrcSanitizer(allowedSchemes));
     try {
         return sanitize(renderedMarkdown, { ...config, RETURN_TRUSTED_TYPE: true });
     }
     finally {
-        removeHook('uponSanitizeAttribute');
-        hook.dispose();
+        store.dispose();
     }
 }
 const allowedMarkdownAttr = [
@@ -392,7 +429,7 @@ function getSanitizerOptions(options) {
     }
     return {
         config: {
-            ALLOWED_TAGS: [...basicMarkupHtmlTags],
+            ALLOWED_TAGS: options.allowedTags ?? [...basicMarkupHtmlTags],
             ALLOWED_ATTR: allowedMarkdownAttr,
             ALLOW_UNKNOWN_PROTOCOLS: true,
         },
@@ -402,12 +439,12 @@ function getSanitizerOptions(options) {
 function renderStringAsPlaintext(string) {
     return typeof string === 'string' ? string : renderMarkdownAsPlaintext(string);
 }
-function renderMarkdownAsPlaintext(markdown) {
+function renderMarkdownAsPlaintext(markdown, withCodeBlocks) {
     let value = markdown.value ?? '';
     if (value.length > 100_000) {
         value = `${value.substr(0, 100_000)}…`;
     }
-    const html = marked_1.parse(value, { renderer: plainTextRenderer.value }).replace(/&(#\d+|[a-zA-Z]+);/g, m => unescapeInfo.get(m) ?? m);
+    const html = marked_1.parse(value, { renderer: withCodeBlocks ? plainTextWithCodeBlocksRenderer.value : plainTextRenderer.value }).replace(/&(#\d+|[a-zA-Z]+);/g, m => unescapeInfo.get(m) ?? m);
     return ( sanitizeRenderedMarkdown({ isTrusted: false }, html).toString());
 }
 const unescapeInfo = ( new Map([
@@ -418,7 +455,7 @@ const unescapeInfo = ( new Map([
     ['&lt;', '<'],
     ['&gt;', '>'],
 ]));
-const plainTextRenderer = ( new Lazy(() => {
+function createRenderer() {
     const renderer = new marked_1.Renderer();
     renderer.code = (code) => {
         return code;
@@ -478,6 +515,14 @@ const plainTextRenderer = ( new Lazy(() => {
         return text;
     };
     return renderer;
+}
+const plainTextRenderer = ( new Lazy((withCodeBlocks) => createRenderer()));
+const plainTextWithCodeBlocksRenderer = ( new Lazy(() => {
+    const renderer = createRenderer();
+    renderer.code = (code) => {
+        return '\n' + '```' + code + '```' + '\n';
+    };
+    return renderer;
 }));
 function mergeRawTokenText(tokens) {
     let mergedTokenText = '';
@@ -487,7 +532,10 @@ function mergeRawTokenText(tokens) {
     return mergedTokenText;
 }
 function completeSingleLinePattern(token) {
-    for (let i = 0; i < token.tokens.length; i++) {
+    if (!token.tokens) {
+        return undefined;
+    }
+    for (let i = token.tokens.length - 1; i >= 0; i--) {
         const subtoken = token.tokens[i];
         if (subtoken.type === 'text') {
             const lines = subtoken.raw.split('\n');
@@ -507,27 +555,68 @@ function completeSingleLinePattern(token) {
             else if (lastLine.match(/(^|\s)_\w/)) {
                 return completeUnderscore(token);
             }
-            else if (lastLine.match(/(^|\s)\[.*\]\(\w*/)) {
+            else if (
+            hasLinkTextAndStartOfLinkTarget(lastLine) ||
+                hasStartOfLinkTargetAndNoLinkText(lastLine) && ( token.tokens.slice(0, i).some(t => t.type === 'text' && t.raw.match(/\[[^\]]*$/)))) {
                 const nextTwoSubTokens = token.tokens.slice(i + 1);
-                if (nextTwoSubTokens[0]?.type === 'link' && nextTwoSubTokens[1]?.type === 'text' && nextTwoSubTokens[1].raw.match(/^ *"[^"]*$/)) {
+                if (
+                nextTwoSubTokens[0]?.type === 'link' && nextTwoSubTokens[1]?.type === 'text' && nextTwoSubTokens[1].raw.match(/^ *"[^"]*$/) ||
+                    lastLine.match(/^[^"]* +"[^"]*$/)) {
                     return completeLinkTargetArg(token);
                 }
                 return completeLinkTarget(token);
             }
-            else if (hasStartOfLinkTarget(lastLine)) {
-                return completeLinkTarget(token);
-            }
-            else if (lastLine.match(/(^|\s)\[\w/) && !( token.tokens.slice(i + 1).some(t => hasStartOfLinkTarget(t.raw)))) {
+            else if (lastLine.match(/(^|\s)\[\w*/)) {
                 return completeLinkText(token);
             }
         }
     }
     return undefined;
 }
-function hasStartOfLinkTarget(str) {
+function hasLinkTextAndStartOfLinkTarget(str) {
+    return !!str.match(/(^|\s)\[.*\]\(\w*/);
+}
+function hasStartOfLinkTargetAndNoLinkText(str) {
     return !!str.match(/^[^\[]*\]\([^\)]*$/);
 }
+function completeListItemPattern(list) {
+    const lastListItem = list.items[list.items.length - 1];
+    const lastListSubToken = lastListItem.tokens ? lastListItem.tokens[lastListItem.tokens.length - 1] : undefined;
+    let newToken;
+    if (lastListSubToken?.type === 'text' && !('inRawBlock' in lastListItem)) {
+        newToken = completeSingleLinePattern(lastListSubToken);
+    }
+    if (!newToken || newToken.type !== 'paragraph') {
+        return;
+    }
+    const previousListItemsText = mergeRawTokenText(list.items.slice(0, -1));
+    const lastListItemLead = lastListItem.raw.match(/^(\s*(-|\d+\.) +)/)?.[0];
+    if (!lastListItemLead) {
+        return;
+    }
+    const newListItemText = lastListItemLead +
+        mergeRawTokenText(lastListItem.tokens.slice(0, -1)) +
+        newToken.raw;
+    const newList = marked_1.lexer(previousListItemsText + newListItemText)[0];
+    if (newList.type !== 'list') {
+        return;
+    }
+    return newList;
+}
+const maxIncompleteTokensFixRounds = 3;
 function fillInIncompleteTokens(tokens) {
+    for (let i = 0; i < maxIncompleteTokensFixRounds; i++) {
+        const newTokens = fillInIncompleteTokensOnce(tokens);
+        if (newTokens) {
+            tokens = newTokens;
+        }
+        else {
+            break;
+        }
+    }
+    return tokens;
+}
+function fillInIncompleteTokensOnce(tokens) {
     let i;
     let newTokens;
     for (i = 0; i < tokens.length; i++) {
@@ -542,6 +631,13 @@ function fillInIncompleteTokens(tokens) {
             newTokens = completeTable(tokens.slice(i));
             break;
         }
+        if (i === tokens.length - 1 && token.type === 'list') {
+            const newListToken = completeListItemPattern(token);
+            if (newListToken) {
+                newTokens = [newListToken];
+                break;
+            }
+        }
         if (i === tokens.length - 1 && token.type === 'paragraph') {
             const newToken = completeSingleLinePattern(token);
             if (newToken) {
@@ -558,7 +654,7 @@ function fillInIncompleteTokens(tokens) {
         newTokensList.links = tokens.links;
         return newTokensList;
     }
-    return tokens;
+    return null;
 }
 function completeCodeBlock(tokens, leader) {
     const mergedRawText = mergeRawTokenText(tokens);
@@ -580,7 +676,7 @@ function completeLinkTargetArg(tokens) {
     return completeWithString(tokens, '")');
 }
 function completeLinkText(tokens) {
-    return completeWithString(tokens, '](about:blank)');
+    return completeWithString(tokens, '](https://microsoft.com)');
 }
 function completeDoublestar(tokens) {
     return completeWithString(tokens, '**');
@@ -625,4 +721,8 @@ function completeTable(tokens) {
     }
     return undefined;
 }
+function addDompurifyHook(hook, cb) {
+    addHook(hook, cb);
+    return toDisposable(() => removeHook(hook));
+}
 export { allowedMarkdownAttr, fillInIncompleteTokens, renderMarkdown, renderMarkdownAsPlaintext, renderStringAsPlaintext };

package/vscode/src/vs/base/browser/performance.js

@@ -5,42 +5,48 @@ var inputLatency;
     const totalRenderTime = { ...totalKeydownTime };
     const totalInputLatencyTime = { ...totalKeydownTime };
     let measurementsCount = 0;
+    let EventPhase;
+    ( (function(EventPhase) {
+        EventPhase[EventPhase["Before"] = 0] = "Before";
+        EventPhase[EventPhase["InProgress"] = 1] = "InProgress";
+        EventPhase[EventPhase["Finished"] = 2] = "Finished";
+    })(EventPhase || (EventPhase = {})));
     const state = {
-        keydown: 0 ,
-        input: 0 ,
-        render: 0 ,
+        keydown: EventPhase.Before,
+        input: EventPhase.Before,
+        render: EventPhase.Before,
     };
     function onKeyDown() {
         recordIfFinished();
         performance.mark('inputlatency/start');
         performance.mark('keydown/start');
-        state.keydown = 1 ;
+        state.keydown = EventPhase.InProgress;
         queueMicrotask(markKeyDownEnd);
     }
     inputLatency.onKeyDown = onKeyDown;
     function markKeyDownEnd() {
-        if (state.keydown === 1 ) {
+        if (state.keydown === EventPhase.InProgress) {
             performance.mark('keydown/end');
-            state.keydown = 2 ;
+            state.keydown = EventPhase.Finished;
         }
     }
     function onBeforeInput() {
         performance.mark('input/start');
-        state.input = 1 ;
+        state.input = EventPhase.InProgress;
         scheduleRecordIfFinishedTask();
     }
     inputLatency.onBeforeInput = onBeforeInput;
     function onInput() {
-        if (state.input === 0 ) {
+        if (state.input === EventPhase.Before) {
             onBeforeInput();
         }
         queueMicrotask(markInputEnd);
     }
     inputLatency.onInput = onInput;
     function markInputEnd() {
-        if (state.input === 1 ) {
+        if (state.input === EventPhase.InProgress) {
             performance.mark('input/end');
-            state.input = 2 ;
+            state.input = EventPhase.Finished;
         }
     }
     function onKeyUp() {
@@ -52,25 +58,25 @@ var inputLatency;
     }
     inputLatency.onSelectionChange = onSelectionChange;
     function onRenderStart() {
-        if (state.keydown === 2  && state.input === 2  && state.render === 0 ) {
+        if (state.keydown === EventPhase.Finished && state.input === EventPhase.Finished && state.render === EventPhase.Before) {
             performance.mark('render/start');
-            state.render = 1 ;
+            state.render = EventPhase.InProgress;
             queueMicrotask(markRenderEnd);
             scheduleRecordIfFinishedTask();
         }
     }
     inputLatency.onRenderStart = onRenderStart;
     function markRenderEnd() {
-        if (state.render === 1 ) {
+        if (state.render === EventPhase.InProgress) {
             performance.mark('render/end');
-            state.render = 2 ;
+            state.render = EventPhase.Finished;
         }
     }
     function scheduleRecordIfFinishedTask() {
         setTimeout(recordIfFinished);
     }
     function recordIfFinished() {
-        if (state.keydown === 2  && state.input === 2  && state.render === 2 ) {
+        if (state.keydown === EventPhase.Finished && state.input === EventPhase.Finished && state.render === EventPhase.Finished) {
             performance.mark('inputlatency/end');
             performance.measure('keydown', 'keydown/start', 'keydown/end');
             performance.measure('input', 'input/start', 'input/end');
@@ -103,9 +109,9 @@ var inputLatency;
         performance.clearMeasures('input');
         performance.clearMeasures('render');
         performance.clearMeasures('inputlatency');
-        state.keydown = 0 ;
-        state.input = 0 ;
-        state.render = 0 ;
+        state.keydown = EventPhase.Before;
+        state.input = EventPhase.Before;
+        state.render = EventPhase.Before;
     }
     function getAndClearMeasurements() {
         if (measurementsCount === 0) {

package/vscode/src/vs/base/browser/ui/actionbar/actionbar.js

@@ -1,12 +1,18 @@
-import { addDisposableListener, EventType, trackFocus, getActiveElement, isAncestor, EventHelper, clearNode } from '../../dom.js';
+import { addDisposableListener, EventType, trackFocus, getActiveElement, isAncestor, isHTMLElement, EventHelper, clearNode } from '../../dom.js';
 import { StandardKeyboardEvent } from '../../keyboardEvent.js';
 import { BaseActionViewItem, ActionViewItem } from './actionViewItems.js';
 import { createInstantHoverDelegate } from '../hover/hoverDelegateFactory.js';
 import { ActionRunner, Separator } from '../../../common/actions.js';
 import { Emitter } from '../../../common/event.js';
+import { KeyCode, KeyMod as KeyMod$1 } from '../../../common/keyCodes.js';
 import { Disposable, DisposableStore, DisposableMap, dispose } from '../../../common/lifecycle.js';
 import { isFunction, isNumber } from '../../../common/types.js';
 import './actionbar.css.js';
+var ActionsOrientation;
+( (function(ActionsOrientation) {
+    ActionsOrientation[ActionsOrientation["HORIZONTAL"] = 0] = "HORIZONTAL";
+    ActionsOrientation[ActionsOrientation["VERTICAL"] = 1] = "VERTICAL";
+})(ActionsOrientation || (ActionsOrientation = {})));
 class ActionBar extends Disposable {
     constructor(container, options = {}) {
         super();
@@ -25,10 +31,10 @@ class ActionBar extends Disposable {
         this.onWillRun = this._onWillRun.event;
         this.options = options;
         this._context = options.context ?? null;
-        this._orientation = this.options.orientation ?? 0 ;
+        this._orientation = this.options.orientation ?? ActionsOrientation.HORIZONTAL;
         this._triggerKeys = {
             keyDown: this.options.triggerKeys?.keyDown ?? false,
-            keys: this.options.triggerKeys?.keys ?? [3 , 10 ]
+            keys: this.options.triggerKeys?.keys ?? [KeyCode.Enter, KeyCode.Space]
         };
         this._hoverDelegate = options.hoverDelegate ?? this._register(createInstantHoverDelegate());
         if (this.options.actionRunner) {
@@ -47,13 +53,13 @@ class ActionBar extends Disposable {
         let previousKeys;
         let nextKeys;
         switch (this._orientation) {
-            case 0 :
-                previousKeys = [15 ];
-                nextKeys = [17 ];
+            case ActionsOrientation.HORIZONTAL:
+                previousKeys = [KeyCode.LeftArrow];
+                nextKeys = [KeyCode.RightArrow];
                 break;
-            case 1 :
-                previousKeys = [16 ];
-                nextKeys = [18 ];
+            case ActionsOrientation.VERTICAL:
+                previousKeys = [KeyCode.UpArrow];
+                nextKeys = [KeyCode.DownArrow];
                 this.domNode.className += ' vertical';
                 break;
         }
@@ -67,16 +73,16 @@ class ActionBar extends Disposable {
             else if (nextKeys && (event.equals(nextKeys[0]) || event.equals(nextKeys[1]))) {
                 eventHandled = this.focusNext();
             }
-            else if (event.equals(9 ) && this.cancelHasListener) {
+            else if (event.equals(KeyCode.Escape) && this.cancelHasListener) {
                 this._onDidCancel.fire();
             }
-            else if (event.equals(14 )) {
+            else if (event.equals(KeyCode.Home)) {
                 eventHandled = this.focusFirst();
             }
-            else if (event.equals(13 )) {
+            else if (event.equals(KeyCode.End)) {
                 eventHandled = this.focusLast();
             }
-            else if (event.equals(2 ) && focusedItem instanceof BaseActionViewItem && focusedItem.trapsArrowNavigation) {
+            else if (event.equals(KeyCode.Tab) && focusedItem instanceof BaseActionViewItem && focusedItem.trapsArrowNavigation) {
                 eventHandled = this.focusNext();
             }
             else if (this.isTriggerKeyEvent(event)) {
@@ -105,7 +111,7 @@ class ActionBar extends Disposable {
                 event.preventDefault();
                 event.stopPropagation();
             }
-            else if (event.equals(2 ) || event.equals(1024  | 2 ) || event.equals(16 ) || event.equals(18 ) || event.equals(15 ) || event.equals(17 )) {
+            else if (event.equals(KeyCode.Tab) || event.equals(KeyMod$1.Shift | KeyCode.Tab) || event.equals(KeyCode.UpArrow) || event.equals(KeyCode.DownArrow) || event.equals(KeyCode.LeftArrow) || event.equals(KeyCode.RightArrow)) {
                 this.updateFocusedItem();
             }
         }));
@@ -207,7 +213,7 @@ class ActionBar extends Disposable {
         if (typeof indexOrElement === 'number') {
             return this.viewItems[indexOrElement]?.action;
         }
-        if (indexOrElement instanceof HTMLElement) {
+        if (isHTMLElement(indexOrElement)) {
             while (indexOrElement.parentElement !== this.actionsList) {
                 if (!indexOrElement.parentElement) {
                     return undefined;
@@ -471,4 +477,4 @@ function prepareActions(actions) {
     }
     return actions;
 }
-export { ActionBar, prepareActions };
+export { ActionBar, ActionsOrientation, prepareActions };

package/vscode/src/vs/base/browser/ui/breadcrumbs/breadcrumbsWidget.js

@@ -4,6 +4,7 @@ import { commonPrefixLength } from '../../../common/arrays.js';
 import { ThemeIcon } from '../../../common/themables.js';
 import { Emitter } from '../../../common/event.js';
 import { DisposableStore, dispose } from '../../../common/lifecycle.js';
+import { ScrollbarVisibility } from '../../../common/scrollable.js';
 import './breadcrumbsWidget.css.js';
 class BreadcrumbsItem {
 }
@@ -27,8 +28,8 @@ class BreadcrumbsWidget {
         this._domNode.tabIndex = 0;
         this._domNode.setAttribute('role', 'list');
         this._scrollable = ( new DomScrollableElement(this._domNode, {
-            vertical: 2 ,
-            horizontal: 1 ,
+            vertical: ScrollbarVisibility.Hidden,
+            horizontal: ScrollbarVisibility.Auto,
             horizontalScrollbarSize,
             useShadows: false,
             scrollYToX: true

package/vscode/src/vs/base/browser/ui/button/button.js

@@ -7,15 +7,26 @@ import { getDefaultHoverDelegate } from '../hover/hoverDelegateFactory.js';
 import { renderLabelWithIcons } from '../iconLabel/iconLabels.js';
 import { Action } from '../../../common/actions.js';
 import { Codicon } from '../../../common/codicons.js';
-import '../../../common/color.js';
+import { Color } from '../../../common/color.js';
 import { Emitter } from '../../../common/event.js';
 import { isMarkdownString, markdownStringEqual } from '../../../common/htmlContent.js';
+import { KeyCode } from '../../../common/keyCodes.js';
 import { Disposable, DisposableStore } from '../../../common/lifecycle.js';
 import { ThemeIcon } from '../../../common/themables.js';
 import './button.css.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { getBaseLayerHoverDelegate } from '../hover/hoverDelegate2.js';
 const _moduleId = "vs/base/browser/ui/button/button";
+const unthemedButtonStyles = {
+    buttonBackground: '#0E639C',
+    buttonHoverBackground: '#006BB3',
+    buttonSeparator: ( (Color.white.toString())),
+    buttonForeground: ( (Color.white.toString())),
+    buttonBorder: undefined,
+    buttonSecondaryBackground: undefined,
+    buttonSecondaryForeground: undefined,
+    buttonSecondaryHoverBackground: undefined
+};
 class Button extends Disposable {
     get onDidClick() { return this._onDidClick.event; }
     get onDidEscape() { return this._onDidEscape.event; }
@@ -63,11 +74,11 @@ class Button extends Disposable {
         this._register(addDisposableListener(this._element, EventType.KEY_DOWN, e => {
             const event = ( (new StandardKeyboardEvent(e)));
             let eventHandled = false;
-            if (this.enabled && (event.equals(3 ) || event.equals(10 ))) {
+            if (this.enabled && (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space))) {
                 this._onDidClick.fire(e);
                 eventHandled = true;
             }
-            else if (event.equals(9 )) {
+            else if (event.equals(KeyCode.Escape)) {
                 this._onDidEscape.fire(e);
                 this._element.blur();
                 eventHandled = true;
@@ -257,9 +268,10 @@ class ButtonWithDropdown extends Disposable {
         this.dropdownButton.element.classList.add('monaco-dropdown-button');
         this.dropdownButton.icon = Codicon.dropDownButton;
         this._register(this.dropdownButton.onDidClick(e => {
+            const actions = Array.isArray(options.actions) ? options.actions : options.actions.getActions();
             options.contextMenuProvider.showContextMenu({
                 getAnchor: () => this.dropdownButton.element,
-                getActions: () => options.addPrimaryActionToDropdown === false ? [...options.actions] : [this.action, ...options.actions],
+                getActions: () => options.addPrimaryActionToDropdown === false ? [...actions] : [this.action, ...actions],
                 actionRunner: options.actionRunner,
                 onHide: () => this.dropdownButton.element.setAttribute('aria-expanded', 'false')
             });
@@ -377,10 +389,10 @@ class ButtonBar {
             const event = ( (new StandardKeyboardEvent(e)));
             let eventHandled = true;
             let buttonIndexToFocus;
-            if (event.equals(15 )) {
+            if (event.equals(KeyCode.LeftArrow)) {
                 buttonIndexToFocus = index > 0 ? index - 1 : this._buttons.length - 1;
             }
-            else if (event.equals(17 )) {
+            else if (event.equals(KeyCode.RightArrow)) {
                 buttonIndexToFocus = index === this._buttons.length - 1 ? 0 : index + 1;
             }
             else {
@@ -393,4 +405,4 @@ class ButtonBar {
         }));
     }
 }
-export { Button, ButtonBar, ButtonWithDescription, ButtonWithDropdown };
+export { Button, ButtonBar, ButtonWithDescription, ButtonWithDropdown, unthemedButtonStyles };