@codingame/monaco-vscode-api 2.0.3 → 2.1.0

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

@@ -1,39 +1,47 @@
-import { $window } from './window.js';
+import { mainWindow, $window } from './window.js';
 import { Emitter } from '../common/event.js';
 import { markAsSingleton, Disposable } from '../common/lifecycle.js';
 class WindowManager {
     constructor() {
-        this._zoomLevel = 0;
-        this._zoomFactor = 1;
-        this._fullscreen = false;
+        this.mapWindowIdToZoomLevel = ( new Map());
+        this._onDidChangeZoomLevel = ( new Emitter());
+        this.onDidChangeZoomLevel = this._onDidChangeZoomLevel.event;
+        this.mapWindowIdToZoomFactor = ( new Map());
         this._onDidChangeFullscreen = ( new Emitter());
         this.onDidChangeFullscreen = this._onDidChangeFullscreen.event;
+        this.mapWindowIdToFullScreen = ( new Map());
     }
     static { this.INSTANCE = ( new WindowManager()); }
-    getZoomLevel() {
-        return this._zoomLevel;
+    getZoomLevel(targetWindow) {
+        return this.mapWindowIdToZoomLevel.get(this.getWindowId(targetWindow)) ?? 0;
     }
-    setZoomLevel(zoomLevel) {
-        if (this._zoomLevel === zoomLevel) {
+    setZoomLevel(zoomLevel, targetWindow) {
+        if (this.getZoomLevel(targetWindow) === zoomLevel) {
             return;
         }
-        this._zoomLevel = zoomLevel;
+        const targetWindowId = this.getWindowId(targetWindow);
+        this.mapWindowIdToZoomLevel.set(targetWindowId, zoomLevel);
+        this._onDidChangeZoomLevel.fire(targetWindowId);
     }
-    getZoomFactor() {
-        return this._zoomFactor;
+    getZoomFactor(targetWindow) {
+        return this.mapWindowIdToZoomFactor.get(this.getWindowId(targetWindow)) ?? 1;
     }
-    setZoomFactor(zoomFactor) {
-        this._zoomFactor = zoomFactor;
+    setZoomFactor(zoomFactor, targetWindow) {
+        this.mapWindowIdToZoomFactor.set(this.getWindowId(targetWindow), zoomFactor);
     }
-    setFullscreen(fullscreen) {
-        if (this._fullscreen === fullscreen) {
+    setFullscreen(fullscreen, targetWindow) {
+        if (this.isFullscreen(targetWindow) === fullscreen) {
             return;
         }
-        this._fullscreen = fullscreen;
-        this._onDidChangeFullscreen.fire();
+        const windowId = this.getWindowId(targetWindow);
+        this.mapWindowIdToFullScreen.set(windowId, fullscreen);
+        this._onDidChangeFullscreen.fire(windowId);
     }
-    isFullscreen() {
-        return this._fullscreen;
+    isFullscreen(targetWindow) {
+        return !!this.mapWindowIdToFullScreen.get(this.getWindowId(targetWindow));
+    }
+    getWindowId(targetWindow) {
+        return targetWindow.vscodeWindowId;
     }
 }
 class DevicePixelRatioMonitor extends Disposable {
@@ -97,18 +105,25 @@ class PixelRatioFacade {
         return this._getOrCreatePixelRatioMonitor().onDidChange;
     }
 }
-function addMatchMediaChangeListener(query, callback) {
+function addMatchMediaChangeListener(targetWindow, query, callback) {
     if (typeof query === 'string') {
-        query = $window.matchMedia(query);
+        query = targetWindow.matchMedia(query);
     }
     query.addEventListener('change', callback);
 }
 const PixelRatio = ( new PixelRatioFacade());
-function getZoomFactor() {
-    return WindowManager.INSTANCE.getZoomFactor();
+function getZoomLevel(targetWindow) {
+    return WindowManager.INSTANCE.getZoomLevel(targetWindow);
+}
+const onDidChangeZoomLevel = WindowManager.INSTANCE.onDidChangeZoomLevel;
+function getZoomFactor(targetWindow) {
+    return WindowManager.INSTANCE.getZoomFactor(targetWindow);
+}
+function setFullscreen(fullscreen, targetWindow) {
+    WindowManager.INSTANCE.setFullscreen(fullscreen, targetWindow);
 }
-function isFullscreen() {
-    return WindowManager.INSTANCE.isFullscreen();
+function isFullscreen(targetWindow) {
+    return WindowManager.INSTANCE.isFullscreen(targetWindow);
 }
 const onDidChangeFullscreen = WindowManager.INSTANCE.onDidChangeFullscreen;
 const userAgent = navigator.userAgent;
@@ -120,11 +135,11 @@ const isWebkitWebView = (!isChrome && !isSafari && isWebKit);
 (userAgent.indexOf('Electron/') >= 0);
 const isAndroid = (userAgent.indexOf('Android') >= 0);
 let standalone = false;
-if ($window.matchMedia) {
-    const standaloneMatchMedia = $window.matchMedia('(display-mode: standalone) or (display-mode: window-controls-overlay)');
-    const fullScreenMatchMedia = $window.matchMedia('(display-mode: fullscreen)');
+if (typeof mainWindow.matchMedia === 'function') {
+    const standaloneMatchMedia = mainWindow.matchMedia('(display-mode: standalone) or (display-mode: window-controls-overlay)');
+    const fullScreenMatchMedia = mainWindow.matchMedia('(display-mode: fullscreen)');
     standalone = standaloneMatchMedia.matches;
-    addMatchMediaChangeListener(standaloneMatchMedia, ({ matches }) => {
+    addMatchMediaChangeListener(mainWindow, standaloneMatchMedia, ({ matches }) => {
         if (standalone && fullScreenMatchMedia.matches) {
             return;
         }
@@ -137,4 +152,4 @@ function isStandalone() {
 function isWCOEnabled() {
     return navigator?.windowControlsOverlay?.visible;
 }
-export { PixelRatio, addMatchMediaChangeListener, getZoomFactor, isAndroid, isChrome, isFirefox, isFullscreen, isSafari, isStandalone, isWCOEnabled, isWebKit, isWebkitWebView, onDidChangeFullscreen };
+export { PixelRatio, addMatchMediaChangeListener, getZoomFactor, getZoomLevel, isAndroid, isChrome, isFirefox, isFullscreen, isSafari, isStandalone, isWCOEnabled, isWebKit, isWebkitWebView, onDidChangeFullscreen, onDidChangeZoomLevel, setFullscreen };

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

@@ -19,6 +19,6 @@ const BrowserFeatures = {
         return 2 ;
     })(),
     touch: 'ontouchstart' in mainWindow || navigator.maxTouchPoints > 0,
-    pointerEvents: mainWindow.PointerEvent && ('ontouchstart' in mainWindow || navigator.maxTouchPoints > 0 || navigator.maxTouchPoints > 0)
+    pointerEvents: mainWindow.PointerEvent && ('ontouchstart' in mainWindow || navigator.maxTouchPoints > 0)
 };
 export { BrowserFeatures };

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

@@ -1,6 +1,7 @@
 import { createTrustedTypesPolicy } from './trustedTypes.js';
 import { onUnexpectedError } from '../common/errors.js';
 import { logOnceWebWorkerWarning } from '../common/worker/simpleWorker.js';
+import { Disposable, toDisposable } from '../common/lifecycle.js';
 const ttPolicy = createTrustedTypesPolicy('defaultWorkerFactory', { createScriptURL: value => value });
 function createBlobWorker(blobUrl, options) {
     if (!blobUrl.startsWith('blob:')) {
@@ -30,8 +31,9 @@ function isPromiseLike(obj) {
     }
     return false;
 }
-class WebWorker {
+class WebWorker extends Disposable {
     constructor(moduleId, id, label, onMessageCallback, onErrorCallback) {
+        super();
         this.id = id;
         this.label = label;
         const workerOrPromise = getWorker(label);
@@ -51,6 +53,15 @@ class WebWorker {
                 w.addEventListener('error', onErrorCallback);
             }
         });
+        this._register(toDisposable(() => {
+            this.worker?.then(w => {
+                w.onmessage = null;
+                w.onmessageerror = null;
+                w.removeEventListener('error', onErrorCallback);
+                w.terminate();
+            });
+            this.worker = null;
+        }));
     }
     getId() {
         return this.id;
@@ -66,10 +77,6 @@ class WebWorker {
             }
         });
     }
-    dispose() {
-        this.worker?.then(w => w.terminate());
-        this.worker = null;
-    }
 }
 class DefaultWorkerFactory {
     static { this.LAST_WORKER_ID = 0; }

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

@@ -2,13 +2,13 @@ import { isWebKit } from './browser.js';
 import { BrowserFeatures } from './canIUse.js';
 import { StandardKeyboardEvent } from './keyboardEvent.js';
 import { StandardMouseEvent } from './mouseEvent.js';
-import { _runWhenIdle, AbstractIdleValue, IntervalTimer } from '../common/async.js';
+import { _runWhenIdle, AbstractIdleValue, IntervalTimer, TimeoutTimer } from '../common/async.js';
 import { onUnexpectedError } from '../common/errors.js';
 import { Emitter, Event } from '../common/event.js';
 import { sanitize, addHook, removeHook } from './dompurify/dompurify.js';
 import { DisposableStore, Disposable, toDisposable } from '../common/lifecycle.js';
 import { RemoteAuthorities, FileAccess, Schemas } from '../common/network.js';
-import { isIOS } from '../common/platform.js';
+import { isIOS, isMacintosh, isLinux } from '../common/platform.js';
 import { URI } from '../common/uri.js';
 import { hash } from '../common/hash.js';
 import { mainWindow, ensureCodeWindow } from './window.js';
@@ -158,8 +158,12 @@ function disposableWindowInterval(targetWindow, handler, interval, iterations) {
     return disposable;
 }
 class WindowIntervalTimer extends IntervalTimer {
+    constructor(node) {
+        super();
+        this.defaultTarget = node && getWindow(node);
+    }
     cancelAndSet(runner, interval, targetWindow) {
-        return super.cancelAndSet(runner, interval, targetWindow);
+        return super.cancelAndSet(runner, interval, targetWindow ?? this.defaultTarget);
     }
 }
 class AnimationFrameQueueItem {
@@ -242,6 +246,37 @@ function measure(targetWindow, callback) {
 function modify(targetWindow, callback) {
     return scheduleAtNextAnimationFrame(targetWindow, callback, -10000 );
 }
+const MINIMUM_TIME_MS = 8;
+const DEFAULT_EVENT_MERGER = function (lastEvent, currentEvent) {
+    return currentEvent;
+};
+class TimeoutThrottledDomListener extends Disposable {
+    constructor(node, type, handler, eventMerger = DEFAULT_EVENT_MERGER, minimumTimeMs = MINIMUM_TIME_MS) {
+        super();
+        let lastEvent = null;
+        let lastHandlerTime = 0;
+        const timeout = this._register(( new TimeoutTimer()));
+        const invokeHandler = () => {
+            lastHandlerTime = (( new Date())).getTime();
+            handler(lastEvent);
+            lastEvent = null;
+        };
+        this._register(addDisposableListener(node, type, (e) => {
+            lastEvent = eventMerger(lastEvent, e);
+            const elapsedTime = (( new Date())).getTime() - lastHandlerTime;
+            if (elapsedTime >= minimumTimeMs) {
+                timeout.cancel();
+                invokeHandler();
+            }
+            else {
+                timeout.setIfNotSet(invokeHandler, minimumTimeMs - elapsedTime);
+            }
+        }));
+    }
+}
+function addDisposableThrottledListener(node, type, handler, eventMerger, minimumTimeMs) {
+    return ( new TimeoutThrottledDomListener(node, type, handler, eventMerger, minimumTimeMs));
+}
 function getComputedStyle(el) {
     return getWindow(el).getComputedStyle(el, null);
 }
@@ -537,20 +572,20 @@ function getActiveElement() {
     return result;
 }
 function isActiveElement(element) {
-    return element.ownerDocument.activeElement === element;
+    return getActiveElement() === element;
 }
 function isAncestorOfActiveElement(ancestor) {
-    return isAncestor(ancestor.ownerDocument.activeElement, ancestor);
+    return isAncestor(getActiveElement(), ancestor);
 }
 function isActiveDocument(element) {
     return element.ownerDocument === getActiveDocument();
 }
 function getActiveDocument() {
     if (getWindowsCount() <= 1) {
-        return document;
+        return mainWindow.document;
     }
     const documents = ( Array.from(getWindows()).map(({ window }) => window.document));
-    return documents.find(doc => doc.hasFocus()) ?? document;
+    return documents.find(doc => doc.hasFocus()) ?? mainWindow.document;
 }
 function getActiveWindow() {
     const document = getActiveDocument();
@@ -566,6 +601,33 @@ const globalStylesheets = ( new Map());
 function isGlobalStylesheet(node) {
     return ( globalStylesheets.has(node));
 }
+function createStyleSheet2() {
+    return ( new WrappedStyleElement());
+}
+class WrappedStyleElement {
+    constructor() {
+        this._currentCssStyle = '';
+        this._styleSheet = undefined;
+    }
+    setStyle(cssStyle) {
+        if (cssStyle === this._currentCssStyle) {
+            return;
+        }
+        this._currentCssStyle = cssStyle;
+        if (!this._styleSheet) {
+            this._styleSheet = createStyleSheet(mainWindow.document.head, (s) => s.innerText = cssStyle);
+        }
+        else {
+            this._styleSheet.innerText = cssStyle;
+        }
+    }
+    dispose() {
+        if (this._styleSheet) {
+            clearNode(this._styleSheet);
+            this._styleSheet = undefined;
+        }
+    }
+}
 function createStyleSheet(container = mainWindow.document.head, beforeAppend, disposableStore) {
     const style = document.createElement('style');
     style.type = 'text/css';
@@ -651,9 +713,15 @@ const sharedMutationObserver = new (class {
     }
 });
 function createMetaElement(container = mainWindow.document.head) {
-    const meta = document.createElement('meta');
-    container.appendChild(meta);
-    return meta;
+    return createHeadElement('meta', container);
+}
+function createLinkElement(container = mainWindow.document.head) {
+    return createHeadElement('link', container);
+}
+function createHeadElement(tagName, container = mainWindow.document.head) {
+    const element = document.createElement(tagName);
+    container.appendChild(element);
+    return element;
 }
 let _sharedStyleSheet = null;
 function getSharedStyleSheet() {
@@ -1044,6 +1112,25 @@ function triggerUpload() {
         setTimeout(() => activeWindow.document.body.removeChild(input));
     }));
 }
+var DetectedFullscreenMode;
+( (function(DetectedFullscreenMode) {
+    DetectedFullscreenMode[DetectedFullscreenMode["DOCUMENT"] = 1] = "DOCUMENT";
+    DetectedFullscreenMode[DetectedFullscreenMode["BROWSER"] = 2] = "BROWSER";
+})(DetectedFullscreenMode || (DetectedFullscreenMode = {})));
+function detectFullscreen(targetWindow) {
+    if (targetWindow.document.fullscreenElement || targetWindow.document.webkitFullscreenElement || targetWindow.document.webkitIsFullScreen) {
+        return { mode: DetectedFullscreenMode.DOCUMENT, guess: false };
+    }
+    if (targetWindow.innerHeight === targetWindow.screen.height) {
+        return { mode: DetectedFullscreenMode.BROWSER, guess: false };
+    }
+    if (isMacintosh || isLinux) {
+        if (targetWindow.outerHeight === targetWindow.screen.height && targetWindow.outerWidth === targetWindow.screen.width) {
+            return { mode: DetectedFullscreenMode.BROWSER, guess: true };
+        }
+    }
+    return null;
+}
 function hookDomPurifyHrefAndSrcSanitizer(allowedProtocols, allowDataImages = false) {
     const anchor = document.createElement('a');
     addHook('afterSanitizeAttributes', (node) => {
@@ -1103,6 +1190,7 @@ const basicMarkupHtmlTags = ( Object.freeze([
     'hr',
     'i',
     'img',
+    'input',
     'ins',
     'kbd',
     'label',
@@ -1422,9 +1510,11 @@ function h(tag, ...args) {
 function camelCaseToHyphenCase(str) {
     return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
 }
-function copyAttributes(from, to) {
+function copyAttributes(from, to, filter) {
     for (const { name, value } of from.attributes) {
-        to.setAttribute(name, value);
+        if (!filter || filter.includes(name)) {
+            to.setAttribute(name, value);
+        }
     }
 }
 function copyAttribute(from, to, name) {
@@ -1437,7 +1527,7 @@ function copyAttribute(from, to, name) {
     }
 }
 function trackAttributes(from, to, filter) {
-    copyAttributes(from, to);
+    copyAttributes(from, to, filter);
     const disposables = ( new DisposableStore());
     disposables.add(sharedMutationObserver.observe(from, disposables, { attributes: true, attributeFilter: filter })(mutations => {
         for (const mutation of mutations) {
@@ -1448,4 +1538,4 @@ function trackAttributes(from, to, filter) {
     }));
     return disposables;
 }
-export { $, Dimension, DragAndDropObserver, EventHelper, EventType, ModifierKeyEmitter, Namespace, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseUpListener, addDisposableListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, asCSSPropertyValue, asCSSUrl, asCssValueWithDefault, basicMarkupHtmlTags, clearNode, cloneGlobalStylesheets, computeScreenAwareSize, copyAttributes, createCSSRule, createMetaElement, createStyleSheet, disposableWindowInterval, finalHandler, findParentWithClass, focusWindow, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getLargestChildWidth, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasParentWithClass, hasWindow, hide, hookDomPurifyHrefAndSrcSanitizer, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEventLike, isGlobalStylesheet, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isShadowRoot, join, measure, modify, multibyteAwareBtoa, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, removeCSSRulesContainingSelector, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, safeInnerHtml, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, trackAttributes, trackFocus, triggerDownload, triggerUpload, windowOpenNoOpener };
+export { $, DetectedFullscreenMode, Dimension, DragAndDropObserver, EventHelper, EventType, ModifierKeyEmitter, Namespace, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseUpListener, addDisposableListener, addDisposableThrottledListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, asCSSPropertyValue, asCSSUrl, asCssValueWithDefault, basicMarkupHtmlTags, clearNode, cloneGlobalStylesheets, computeScreenAwareSize, copyAttributes, createCSSRule, createLinkElement, createMetaElement, createStyleSheet, createStyleSheet2, detectFullscreen, disposableWindowInterval, finalHandler, findParentWithClass, focusWindow, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getLargestChildWidth, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasParentWithClass, hasWindow, hide, hookDomPurifyHrefAndSrcSanitizer, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEventLike, isGlobalStylesheet, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isShadowRoot, join, measure, modify, multibyteAwareBtoa, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, removeCSSRulesContainingSelector, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, safeInnerHtml, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, trackAttributes, trackFocus, triggerDownload, triggerUpload, windowOpenNoOpener };

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

@@ -1,5 +1,5 @@
 import { toErrorMessage } from '../common/errorMessage.js';
-import { getErrorMessage } from '../common/errors.js';
+import { getErrorMessage, ErrorNoTelemetry } from '../common/errors.js';
 import { mark } from '../common/performance.js';
 class MissingStoresError extends Error {
     constructor(db) {
@@ -105,8 +105,8 @@ class IndexedDB {
                     c(request.result);
                 }
             };
-            transaction.onerror = () => e(transaction.error);
-            transaction.onabort = () => e(transaction.error);
+            transaction.onerror = () => e(transaction.error ? ErrorNoTelemetry.fromError(transaction.error) : ( new ErrorNoTelemetry('unknown error')));
+            transaction.onabort = () => e(transaction.error ? ErrorNoTelemetry.fromError(transaction.error) : ( new ErrorNoTelemetry('unknown error')));
             const request = dbRequestFn(transaction.objectStore(store));
         })).finally(() => this.pendingTransactions.splice(this.pendingTransactions.indexOf(transaction), 1));
     }

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

@@ -318,6 +318,23 @@ function sanitizeRenderedMarkdown(options, renderedMarkdown) {
             e.keepAttr = false;
             return;
         }
+        else if (element.tagName === 'INPUT' && element.attributes.getNamedItem('type')?.value === 'checkbox') {
+            if ((e.attrName === 'type' && e.attrValue === 'checkbox') || e.attrName === 'disabled' || e.attrName === 'checked') {
+                e.keepAttr = true;
+                return;
+            }
+            e.keepAttr = false;
+        }
+    });
+    addHook('uponSanitizeElement', (element, e) => {
+        if (e.tagName === 'input') {
+            if (element.attributes.getNamedItem('type')?.value === 'checkbox') {
+                element.setAttribute('disabled', '');
+            }
+            else {
+                element.parentElement?.removeChild(element);
+            }
+        }
     });
     const hook = hookDomPurifyHrefAndSrcSanitizer(allowedSchemes);
     try {
@@ -332,10 +349,12 @@ const allowedMarkdownAttr = [
     'align',
     'autoplay',
     'alt',
+    'checked',
     'class',
     'controls',
     'data-code',
     'data-href',
+    'disabled',
     'draggable',
     'height',
     'href',
@@ -347,6 +366,7 @@ const allowedMarkdownAttr = [
     'style',
     'target',
     'title',
+    'type',
     'width',
     'start',
 ];
@@ -461,7 +481,8 @@ function mergeRawTokenText(tokens) {
     return mergedTokenText;
 }
 function completeSingleLinePattern(token) {
-    for (const subtoken of token.tokens) {
+    for (let i = 0; i < token.tokens.length; i++) {
+        const subtoken = token.tokens[i];
         if (subtoken.type === 'text') {
             const lines = subtoken.raw.split('\n');
             const lastLine = lines[lines.length - 1];
@@ -481,6 +502,10 @@ function completeSingleLinePattern(token) {
                 return completeUnderscore(token);
             }
             else if (lastLine.match(/(^|\s)\[.*\]\(\w*/)) {
+                const nextTwoSubTokens = token.tokens.slice(i + 1);
+                if (nextTwoSubTokens[0]?.type === 'link' && nextTwoSubTokens[1]?.type === 'text' && nextTwoSubTokens[1].raw.match(/^ *"[^"]*$/)) {
+                    return completeLinkTargetArg(token);
+                }
                 return completeLinkTarget(token);
             }
             else if (lastLine.match(/(^|\s)\[\w/)) {
@@ -537,6 +562,9 @@ function completeUnderscore(tokens) {
 function completeLinkTarget(tokens) {
     return completeWithString(tokens, ')');
 }
+function completeLinkTargetArg(tokens) {
+    return completeWithString(tokens, '")');
+}
 function completeLinkText(tokens) {
     return completeWithString(tokens, '](about:blank)');
 }

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

@@ -1,4 +1,4 @@
-import { isFirefox, isSafari } from './browser.js';
+import { isChrome, isFirefox, isSafari } from './browser.js';
 import { IframeUtils } from './iframe.js';
 import { isMacintosh, isWindows } from '../common/platform.js';
 class StandardMouseEvent {
@@ -46,8 +46,14 @@ class StandardWheelEvent {
         if (e) {
             const e1 = e;
             const e2 = e;
+            const devicePixelRatio = e.view?.devicePixelRatio || 1;
             if (typeof e1.wheelDeltaY !== 'undefined') {
-                this.deltaY = e1.wheelDeltaY / 120;
+                if (isChrome) {
+                    this.deltaY = e1.wheelDeltaY / (120 * devicePixelRatio);
+                }
+                else {
+                    this.deltaY = e1.wheelDeltaY / 120;
+                }
             }
             else if (typeof e2.VERTICAL_AXIS !== 'undefined' && e2.axis === e2.VERTICAL_AXIS) {
                 this.deltaY = -e2.detail / 3;
@@ -70,6 +76,9 @@ class StandardWheelEvent {
                 if (isSafari && isWindows) {
                     this.deltaX = -(e1.wheelDeltaX / 120);
                 }
+                else if (isChrome) {
+                    this.deltaX = e1.wheelDeltaX / (120 * devicePixelRatio);
+                }
                 else {
                     this.deltaX = e1.wheelDeltaX / 120;
                 }
@@ -92,7 +101,12 @@ class StandardWheelEvent {
                 }
             }
             if (this.deltaY === 0 && this.deltaX === 0 && e.wheelDelta) {
-                this.deltaY = e.wheelDelta / 120;
+                if (isChrome) {
+                    this.deltaY = e.wheelDelta / (120 * devicePixelRatio);
+                }
+                else {
+                    this.deltaY = e.wheelDelta / 120;
+                }
             }
         }
     }

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

@@ -399,9 +399,6 @@ class ActionBar extends Disposable {
             if (actionViewItem.action.id === Separator.ID) {
                 focusItem = false;
             }
-            if (focusItem) {
-                actionViewItem.showHover?.();
-            }
             if (!focusItem) {
                 this.actionsList.focus({ preventScroll });
                 this.previouslyFocusedItem = undefined;
@@ -410,6 +407,9 @@ class ActionBar extends Disposable {
                 actionViewItem.focus(fromRight);
                 this.previouslyFocusedItem = this.focusedItem;
             }
+            if (focusItem) {
+                actionViewItem.showHover?.();
+            }
         }
     }
     doTrigger(event) {

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-breadcrumbs{display:flex;flex-direction:row;flex-wrap:nowrap;justify-content:flex-start;outline-style:none;user-select:none;-webkit-user-select:none}.monaco-breadcrumbs .monaco-breadcrumb-item{align-items:center;align-self:center;cursor:pointer;display:flex;flex:0 1 auto;height:100%;outline:none;white-space:nowrap}.monaco-breadcrumbs.disabled .monaco-breadcrumb-item{cursor:default}.monaco-breadcrumbs .monaco-breadcrumb-item .codicon-breadcrumb-separator{color:inherit}.monaco-breadcrumbs .monaco-breadcrumb-item:first-of-type:before{content:\" \"}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/base/browser/ui/breadcrumbs/breadcrumbsWidget.d.ts

@@ -3,7 +3,7 @@ import { ThemeIcon } from '../../../common/themables.js';
 import { Event } from '../../../common/event.js';
 
 declare abstract class BreadcrumbsItem {
-    dispose(): void;
+    abstract dispose(): void;
     abstract equals(other: BreadcrumbsItem): boolean;
     abstract render(container: HTMLElement): void;
 }