@codingame/monaco-vscode-api 2.2.2 → 3.1.0

package/vscode/src/vs/base/common/observableInternal/promise.js

@@ -0,0 +1,94 @@
+import { autorun } from './autorun.js';
+import { observableValue, transaction } from './base.js';
+import { derived } from './derived.js';
+class ObservableLazy {
+    get cachedValue() { return this._value; }
+    constructor(_computeValue) {
+        this._computeValue = _computeValue;
+        this._value = observableValue(this, undefined);
+    }
+    getValue() {
+        let v = this._value.get();
+        if (!v) {
+            v = this._computeValue();
+            this._value.set(v, undefined);
+        }
+        return v;
+    }
+}
+class ObservablePromise {
+    constructor(promise) {
+        this._value = observableValue(this, undefined);
+        this.promiseResult = this._value;
+        this.promise = promise.then(value => {
+            transaction(tx => {
+                this._value.set(( new PromiseResult(value, undefined)), tx);
+            });
+            return value;
+        }, error => {
+            transaction(tx => {
+                this._value.set(( new PromiseResult(undefined, error)), tx);
+            });
+            throw error;
+        });
+    }
+}
+class PromiseResult {
+    constructor(
+    data,
+    error) {
+        this.data = data;
+        this.error = error;
+    }
+    getDataOrThrow() {
+        if (this.error) {
+            throw this.error;
+        }
+        return this.data;
+    }
+}
+class ObservableLazyPromise {
+    constructor(_computePromise) {
+        this._computePromise = _computePromise;
+        this._lazyValue = ( new ObservableLazy(() => ( new ObservablePromise(this._computePromise()))));
+        this.cachedPromiseResult = derived(this, reader => this._lazyValue.cachedValue.read(reader)?.promiseResult.read(reader));
+    }
+    getPromise() {
+        return this._lazyValue.getValue().promise;
+    }
+}
+function waitForState(observable, predicate, isError) {
+    return ( new Promise((resolve, reject) => {
+        let isImmediateRun = true;
+        let shouldDispose = false;
+        const stateObs = ( observable.map(state => {
+            return {
+                isFinished: predicate(state),
+                error: isError ? isError(state) : false,
+                state
+            };
+        }));
+        const d = autorun(reader => {
+            const { isFinished, error, state } = stateObs.read(reader);
+            if (isFinished || error) {
+                if (isImmediateRun) {
+                    shouldDispose = true;
+                }
+                else {
+                    d.dispose();
+                }
+                if (error) {
+                    reject(error === true ? state : error);
+                }
+                else {
+                    resolve(state);
+                }
+            }
+        });
+        isImmediateRun = false;
+        if (shouldDispose) {
+            d.dispose();
+        }
+    }));
+}
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, waitForState };

package/vscode/src/vs/base/common/observableInternal/utils.js

@@ -1,6 +1,7 @@
 import { toDisposable, DisposableStore } from '../lifecycle.js';
 import { autorun } from './autorun.js';
-import { ConvenientObservable, BaseObservable, subtransaction, getFunctionName, transaction, getDebugName, _setKeepObserved, _setRecomputeInitiallyAndOnChange, observableValue } from './base.js';
+import { ConvenientObservable, BaseObservable, subtransaction, transaction, _setKeepObserved, _setRecomputeInitiallyAndOnChange, observableValue } from './base.js';
+import { getFunctionName, DebugNameData } from './debugName.js';
 import { derivedOpts, derived } from './derived.js';
 function constObservable(value) {
     return ( new ConstObservable(value));
@@ -31,29 +32,6 @@ function observableFromPromise(promise) {
     });
     return observable;
 }
-function waitForState(observable, predicate) {
-    return ( new Promise(resolve => {
-        let didRun = false;
-        let shouldDispose = false;
-        const stateObs = ( observable.map(state => ({ isFinished: predicate(state), state })));
-        const d = autorun(reader => {
-            const { isFinished, state } = stateObs.read(reader);
-            if (isFinished) {
-                if (!didRun) {
-                    shouldDispose = true;
-                }
-                else {
-                    d.dispose();
-                }
-                resolve(state);
-            }
-        });
-        didRun = true;
-        if (shouldDispose) {
-            d.dispose();
-        }
-    }));
-}
 function observableFromEvent(event, getValue) {
     return ( new FromEventObservable(event, getValue));
 }
@@ -168,7 +146,7 @@ function observableSignal(debugNameOrOwner) {
 }
 class ObservableSignal extends BaseObservable {
     get debugName() {
-        return getDebugName(this, this._debugName, undefined, this._owner) ?? 'Observable Signal';
+        return ( new DebugNameData(this._owner, this._debugName, undefined)).getDebugName(this) ?? 'Observable Signal';
     }
     constructor(_debugName, _owner) {
         super();
@@ -293,7 +271,7 @@ function derivedObservableWithWritableCache(owner, computeFn) {
 function mapObservableArrayCached(owner, items, map, keySelector) {
     let m = ( new ArrayMap(map, keySelector));
     const self = derivedOpts({
-        debugName: () => getDebugName(m, undefined, map, owner),
+        debugReferenceFn: map,
         owner,
         onLastObserverRemoved: () => {
             m.dispose();
@@ -344,4 +322,4 @@ class ArrayMap {
         return this._items;
     }
 }
-export { FromEventObservable, constObservable, debouncedObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromEvent, observableFromPromise, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, waitForState, wasEventTriggeredRecently };
+export { FromEventObservable, KeepAliveObserver, constObservable, debouncedObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromEvent, observableFromPromise, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, wasEventTriggeredRecently };

package/vscode/src/vs/base/common/prefixTree.js

@@ -18,29 +18,45 @@ class WellDefinedPrefixTree {
         this.opNode(key, n => n._value = mutate(n._value === unset ? undefined : n._value));
     }
     delete(key) {
-        const path = [{ part: '', node: this.root }];
-        let i = 0;
-        for (const part of key) {
-            const node = path[i].node.children?.get(part);
-            if (!node) {
-                return undefined;
-            }
-            path.push({ part, node });
-            i++;
+        const path = this.getPathToKey(key);
+        if (!path) {
+            return;
         }
+        let i = path.length - 1;
         const value = path[i].node._value;
         if (value === unset) {
             return;
         }
         this._size--;
+        path[i].node._value = unset;
         for (; i > 0; i--) {
+            const { node, part } = path[i];
+            if (node.children?.size || node._value !== unset) {
+                break;
+            }
+            path[i - 1].node.children.delete(part);
+        }
+        return value;
+    }
+    *deleteRecursive(key) {
+        const path = this.getPathToKey(key);
+        if (!path) {
+            return;
+        }
+        const subtree = path[path.length - 1].node;
+        for (let i = path.length - 1; i > 0; i--) {
             const parent = path[i - 1];
             parent.node.children.delete(path[i].part);
             if (parent.node.children.size > 0 || parent.node._value !== unset) {
                 break;
             }
         }
-        return value;
+        for (const node of bfsIterate(subtree)) {
+            if (node._value !== unset) {
+                this._size--;
+                yield node._value;
+            }
+        }
     }
     find(key) {
         let node = this.root;
@@ -89,6 +105,19 @@ class WellDefinedPrefixTree {
         }
         return node._value !== unset;
     }
+    getPathToKey(key) {
+        const path = [{ part: '', node: this.root }];
+        let i = 0;
+        for (const part of key) {
+            const node = path[i].node.children?.get(part);
+            if (!node) {
+                return;
+            }
+            path.push({ part, node });
+            i++;
+        }
+        return path;
+    }
     opNode(key, fn, onDescend) {
         let node = this.root;
         for (const part of key) {
@@ -107,22 +136,27 @@ class WellDefinedPrefixTree {
             }
             onDescend?.(node);
         }
-        if (node._value === unset) {
-            this._size++;
-        }
+        const sizeBefore = node._value === unset ? 0 : 1;
         fn(node);
+        const sizeAfter = node._value === unset ? 0 : 1;
+        this._size += sizeAfter - sizeBefore;
     }
     *values() {
-        const stack = [this.root];
-        while (stack.length > 0) {
-            const node = stack.pop();
-            if (node._value !== unset) {
-                yield node._value;
+        for (const { _value } of bfsIterate(this.root)) {
+            if (_value !== unset) {
+                yield _value;
             }
-            if (node.children) {
-                for (const child of ( node.children.values())) {
-                    stack.push(child);
-                }
+        }
+    }
+}
+function* bfsIterate(root) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        yield node;
+        if (node.children) {
+            for (const child of ( node.children.values())) {
+                stack.push(child);
             }
         }
     }

package/vscode/src/vs/base/common/product.d.ts

@@ -107,7 +107,7 @@ interface IProductConfiguration {
     readonly webExtensionTips?: readonly string[];
     readonly languageExtensionTips?: readonly string[];
     readonly trustedExtensionUrlPublicKeys?: IStringDictionary<string[]>;
-    readonly trustedExtensionAuthAccess?: readonly string[];
+    readonly trustedExtensionAuthAccess?: string[] | IStringDictionary<string[]>;
     readonly trustedExtensionProtocolHandlers?: readonly string[];
     readonly commandPaletteSuggestedCommandIds?: string[];
     readonly crashReporter?: {

package/vscode/src/vs/base/common/strings.js

@@ -159,6 +159,14 @@ function regExpLeadsToEndlessLoop(regexp) {
 function splitLines(str) {
     return str.split(/\r\n|\r|\n/);
 }
+function splitLinesIncludeSeparators(str) {
+    const linesWithSeparators = [];
+    const splitLinesAndSeparators = str.split(/(\r\n|\r|\n)/);
+    for (let i = 0; i < Math.ceil(splitLinesAndSeparators.length / 2); i++) {
+        linesWithSeparators.push(splitLinesAndSeparators[2 * i] + (splitLinesAndSeparators[2 * i + 1] ?? ''));
+    }
+    return linesWithSeparators;
+}
 function firstNonWhitespaceIndex(str) {
     for (let i = 0, len = str.length; i < len; i++) {
         const chCode = str.charCodeAt(i);
@@ -752,4 +760,4 @@ class InvisibleCharacters {
         return InvisibleCharacters.getData();
     }
 }
-export { AmbiguousCharacters, CodePointIterator, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, format, format2, fuzzyContains, getCharContainingOffset, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, lastNonWhitespaceIndex, lcut, ltrim, nextCharLength, noBreakWhitespace, prevCharLength, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, replaceAsync, rtrim, singleLetterHash, splitLines, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };
+export { AmbiguousCharacters, CodePointIterator, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, format, format2, fuzzyContains, getCharContainingOffset, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, lastNonWhitespaceIndex, lcut, ltrim, nextCharLength, noBreakWhitespace, prevCharLength, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, replaceAsync, rtrim, singleLetterHash, splitLines, splitLinesIncludeSeparators, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };

package/vscode/src/vs/editor/browser/config/charWidthReader.js

@@ -1,4 +1,3 @@
-import { $window } from '../../../base/browser/window.js';
 import { applyFontInfo } from './domFontInfo.js';
 class CharWidthRequest {
     constructor(chr, type) {
@@ -17,11 +16,11 @@ class DomCharWidthReader {
         this._container = null;
         this._testElements = null;
     }
-    read() {
+    read(targetWindow) {
         this._createDomElements();
-        $window.document.body.appendChild(this._container);
+        targetWindow.document.body.appendChild(this._container);
         this._readFromDomElements();
-        $window.document.body.removeChild(this._container);
+        targetWindow.document.body.removeChild(this._container);
         this._container = null;
         this._testElements = null;
     }
@@ -86,8 +85,8 @@ class DomCharWidthReader {
         }
     }
 }
-function readCharWidths(bareFontInfo, requests) {
+function readCharWidths(targetWindow, bareFontInfo, requests) {
     const reader = ( new DomCharWidthReader(bareFontInfo, requests));
-    reader.read();
+    reader.read(targetWindow);
 }
 export { CharWidthRequest, readCharWidths };

package/vscode/src/vs/editor/browser/config/editorConfiguration.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { PixelRatio, isWebKit, isFirefox, isSafari, isWebkitWebView } from '../../../base/browser/browser.js';
+import { isWebKit, isFirefox, isSafari, isWebkitWebView } from '../../../base/browser/browser.js';
 import { equals } from '../../../base/common/arrays.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
@@ -13,6 +13,8 @@ import { ComputeOptionsMemory, editorOptionsRegistry, ConfigurationChangedEvent
 import { EditorZoom } from '../../common/config/editorZoom.js';
 import { BareFontInfo } from '../../common/config/fontInfo.js';
 import { IAccessibilityService } from '../../../platform/accessibility/common/accessibility.js';
+import { getWindow, getWindowById } from '../../../base/browser/dom.js';
+import { PixelRatio } from '../../../base/browser/pixelRatio.js';
 let EditorConfiguration = class EditorConfiguration extends Disposable {
     constructor(isSimpleWidget, isStandaloneEditor, options, container, _accessibilityService) {
         super();
@@ -30,6 +32,7 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
         this.isSimpleWidget = isSimpleWidget;
         this.isStandaloneEditor = isStandaloneEditor;
         this._containerObserver = this._register(( new ElementSizeObserver(container, options.dimension)));
+        this._targetWindowId = getWindow(container).vscodeWindowId;
         this._rawOptions = deepCloneAndMigrateOptions(options);
         this._validatedOptions = EditorOptionsUtil.validateOptions(this._rawOptions);
         this.options = this._computeOptions();
@@ -40,7 +43,7 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
         this._register(TabFocus.onDidChangeTabFocus(() => this._recomputeOptions()));
         this._register(this._containerObserver.onDidChange(() => this._recomputeOptions()));
         this._register(FontMeasurements.onDidChange(() => this._recomputeOptions()));
-        this._register(PixelRatio.onDidChange(() => this._recomputeOptions()));
+        this._register(PixelRatio.getInstance(getWindow(container)).onDidChange(() => this._recomputeOptions()));
         this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => this._recomputeOptions()));
     }
     _recomputeOptions() {
@@ -80,14 +83,14 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
             outerWidth: this._containerObserver.getWidth(),
             outerHeight: this._containerObserver.getHeight(),
             emptySelectionClipboard: isWebKit || isFirefox,
-            pixelRatio: PixelRatio.value,
+            pixelRatio: PixelRatio.getInstance(getWindowById(this._targetWindowId, true).window).value,
             accessibilitySupport: (this._accessibilityService.isScreenReaderOptimized()
                 ? 2
                 : this._accessibilityService.getAccessibilitySupport())
         };
     }
     _readFontInfo(bareFontInfo) {
-        return FontMeasurements.readFontInfo(bareFontInfo);
+        return FontMeasurements.readFontInfo(getWindowById(this._targetWindowId, true).window, bareFontInfo);
     }
     getRawOptions() {
         return this._rawOptions;

package/vscode/src/vs/editor/browser/config/fontMeasurements.js

@@ -1,5 +1,5 @@
-import { PixelRatio } from '../../../base/browser/browser.js';
-import { mainWindow } from '../../../base/browser/window.js';
+import { getWindowId } from '../../../base/browser/dom.js';
+import { PixelRatio } from '../../../base/browser/pixelRatio.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { readCharWidths, CharWidthRequest } from './charWidthReader.js';
@@ -7,11 +7,11 @@ import { EditorFontLigatures } from '../../common/config/editorOptions.js';
 import { SERIALIZED_FONT_INFO_VERSION, FontInfo } from '../../common/config/fontInfo.js';
 class FontMeasurementsImpl extends Disposable {
     constructor() {
-        super();
+        super(...arguments);
+        this._cache = ( new Map());
+        this._evictUntrustedReadingsTimeout = -1;
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
-        this._cache = ( new FontMeasurementsCache());
-        this._evictUntrustedReadingsTimeout = -1;
     }
     dispose() {
         if (this._evictUntrustedReadingsTimeout !== -1) {
@@ -21,49 +21,62 @@ class FontMeasurementsImpl extends Disposable {
         super.dispose();
     }
     clearAllFontInfos() {
-        this._cache = ( new FontMeasurementsCache());
+        this._cache.clear();
         this._onDidChange.fire();
     }
-    _writeToCache(item, value) {
-        this._cache.put(item, value);
+    _ensureCache(targetWindow) {
+        const windowId = getWindowId(targetWindow);
+        let cache = this._cache.get(windowId);
+        if (!cache) {
+            cache = ( new FontMeasurementsCache());
+            this._cache.set(windowId, cache);
+        }
+        return cache;
+    }
+    _writeToCache(targetWindow, item, value) {
+        const cache = this._ensureCache(targetWindow);
+        cache.put(item, value);
         if (!value.isTrusted && this._evictUntrustedReadingsTimeout === -1) {
-            this._evictUntrustedReadingsTimeout = mainWindow.setTimeout(() => {
+            this._evictUntrustedReadingsTimeout = targetWindow.setTimeout(() => {
                 this._evictUntrustedReadingsTimeout = -1;
-                this._evictUntrustedReadings();
+                this._evictUntrustedReadings(targetWindow);
             }, 5000);
         }
     }
-    _evictUntrustedReadings() {
-        const values = this._cache.getValues();
+    _evictUntrustedReadings(targetWindow) {
+        const cache = this._ensureCache(targetWindow);
+        const values = cache.getValues();
         let somethingRemoved = false;
         for (const item of values) {
             if (!item.isTrusted) {
                 somethingRemoved = true;
-                this._cache.remove(item);
+                cache.remove(item);
             }
         }
         if (somethingRemoved) {
             this._onDidChange.fire();
         }
     }
-    serializeFontInfo() {
-        return this._cache.getValues().filter(item => item.isTrusted);
+    serializeFontInfo(targetWindow) {
+        const cache = this._ensureCache(targetWindow);
+        return cache.getValues().filter(item => item.isTrusted);
     }
-    restoreFontInfo(savedFontInfos) {
+    restoreFontInfo(targetWindow, savedFontInfos) {
         for (const savedFontInfo of savedFontInfos) {
             if (savedFontInfo.version !== SERIALIZED_FONT_INFO_VERSION) {
                 continue;
             }
             const fontInfo = ( new FontInfo(savedFontInfo, false));
-            this._writeToCache(fontInfo, fontInfo);
+            this._writeToCache(targetWindow, fontInfo, fontInfo);
         }
     }
-    readFontInfo(bareFontInfo) {
-        if (!( this._cache.has(bareFontInfo))) {
-            let readConfig = this._actualReadFontInfo(bareFontInfo);
+    readFontInfo(targetWindow, bareFontInfo) {
+        const cache = this._ensureCache(targetWindow);
+        if (!( cache.has(bareFontInfo))) {
+            let readConfig = this._actualReadFontInfo(targetWindow, bareFontInfo);
             if (readConfig.typicalHalfwidthCharacterWidth <= 2 || readConfig.typicalFullwidthCharacterWidth <= 2 || readConfig.spaceWidth <= 2 || readConfig.maxDigitWidth <= 2) {
                 readConfig = ( new FontInfo({
-                    pixelRatio: PixelRatio.value,
+                    pixelRatio: PixelRatio.getInstance(targetWindow).value,
                     fontFamily: readConfig.fontFamily,
                     fontWeight: readConfig.fontWeight,
                     fontSize: readConfig.fontSize,
@@ -81,9 +94,9 @@ class FontMeasurementsImpl extends Disposable {
                     maxDigitWidth: Math.max(readConfig.maxDigitWidth, 5),
                 }, false));
             }
-            this._writeToCache(bareFontInfo, readConfig);
+            this._writeToCache(targetWindow, bareFontInfo, readConfig);
         }
-        return this._cache.get(bareFontInfo);
+        return cache.get(bareFontInfo);
     }
     _createRequest(chr, type, all, monospace) {
         const result = ( new CharWidthRequest(chr, type));
@@ -91,7 +104,7 @@ class FontMeasurementsImpl extends Disposable {
         monospace?.push(result);
         return result;
     }
-    _actualReadFontInfo(bareFontInfo) {
+    _actualReadFontInfo(targetWindow, bareFontInfo) {
         const all = [];
         const monospace = [];
         const typicalHalfwidthCharacter = this._createRequest('n', 0 , all, monospace);
@@ -117,7 +130,7 @@ class FontMeasurementsImpl extends Disposable {
             this._createRequest(monospaceTestChars.charAt(i), 1 , all, monospace);
             this._createRequest(monospaceTestChars.charAt(i), 2 , all, monospace);
         }
-        readCharWidths(bareFontInfo, all);
+        readCharWidths(targetWindow, bareFontInfo, all);
         const maxDigitWidth = Math.max(digit0.width, digit1.width, digit2.width, digit3.width, digit4.width, digit5.width, digit6.width, digit7.width, digit8.width, digit9.width);
         let isMonospace = (bareFontInfo.fontFeatureSettings === EditorFontLigatures.OFF);
         const referenceWidth = monospace[0].width;
@@ -136,7 +149,7 @@ class FontMeasurementsImpl extends Disposable {
             canUseHalfwidthRightwardsArrow = false;
         }
         return ( new FontInfo({
-            pixelRatio: PixelRatio.value,
+            pixelRatio: PixelRatio.getInstance(targetWindow).value,
             fontFamily: bareFontInfo.fontFamily,
             fontWeight: bareFontInfo.fontWeight,
             fontSize: bareFontInfo.fontSize,

package/vscode/src/vs/editor/browser/controller/mouseHandler.js

@@ -26,7 +26,7 @@ class MouseHandler extends ViewEventHandler {
             (e) => this._getMouseColumn(e)
         )));
         this.lastMouseLeaveTime = -1;
-        this._height = this._context.configuration.options.get(143 ).height;
+        this._height = this._context.configuration.options.get(144 ).height;
         const mouseEvents = ( new EditorMouseEventFactory(this.viewHelper.viewDomNode));
         this._register(mouseEvents.onContextMenu(this.viewHelper.viewDomNode, (e) => this._onContextMenu(e, true)));
         this._register(mouseEvents.onMouseMove(this.viewHelper.viewDomNode, (e) => {
@@ -60,7 +60,7 @@ class MouseHandler extends ViewEventHandler {
         let gestureAccumulatedDelta = 0;
         const onMouseWheel = (browserEvent) => {
             this.viewController.emitMouseWheel(browserEvent);
-            if (!this._context.configuration.options.get(75 )) {
+            if (!this._context.configuration.options.get(76 )) {
                 return;
             }
             const e = ( new StandardWheelEvent(browserEvent));
@@ -105,8 +105,8 @@ class MouseHandler extends ViewEventHandler {
         super.dispose();
     }
     onConfigurationChanged(e) {
-        if (e.hasChanged(143 )) {
-            const height = this._context.configuration.options.get(143 ).height;
+        if (e.hasChanged(144 )) {
+            const height = this._context.configuration.options.get(144 ).height;
             if (this._height !== height) {
                 this._height = height;
                 this._mouseDownOperation.onHeightChanged();
@@ -189,7 +189,7 @@ class MouseHandler extends ViewEventHandler {
         const targetIsContent = ((t.type === 6  || t.type === 7) );
         const targetIsGutter = ((t.type === 2  || t.type === 3  || t.type === 4) );
         const targetIsLineNumbers = ((t.type === 3) );
-        const selectOnLineNumbers = this._context.configuration.options.get(108 );
+        const selectOnLineNumbers = this._context.configuration.options.get(109 );
         const targetIsViewZone = ((t.type === 8  || t.type === 5) );
         const targetIsWidget = ((t.type === 9) );
         let shouldHandle = e.leftButton || e.middleButton;
@@ -290,7 +290,7 @@ class MouseDownOperation extends Disposable {
         this._mouseState.trySetCount(e.detail, position.position);
         e.detail = this._mouseState.count;
         const options = this._context.configuration.options;
-        if (!options.get(90 )
+        if (!options.get(91 )
             && options.get(35 )
             && !options.get(22 )
             && !this._mouseState.altKey
@@ -497,8 +497,8 @@ class TopBottomDragScrollingOperation extends Disposable {
         return elapsed;
     }
     _getScrollSpeed() {
-        const lineHeight = this._context.configuration.options.get(66 );
-        const viewportInLines = this._context.configuration.options.get(143 ).height / lineHeight;
+        const lineHeight = this._context.configuration.options.get(67 );
+        const viewportInLines = this._context.configuration.options.get(144 ).height / lineHeight;
         const outsideDistanceInLines = this._position.outsideDistance / lineHeight;
         if (outsideDistanceInLines <= 1.5) {
             return Math.max(30, viewportInLines * (1 + outsideDistanceInLines));
@@ -509,7 +509,7 @@ class TopBottomDragScrollingOperation extends Disposable {
         return Math.max(200, viewportInLines * (7 + outsideDistanceInLines));
     }
     _execute() {
-        const lineHeight = this._context.configuration.options.get(66 );
+        const lineHeight = this._context.configuration.options.get(67 );
         const scrollSpeedInLines = this._getScrollSpeed();
         const elapsed = this._tick();
         const scrollInPixels = scrollSpeedInLines * (elapsed / 1000) * lineHeight;
@@ -521,7 +521,7 @@ class TopBottomDragScrollingOperation extends Disposable {
         let mouseTarget;
         {
             const editorPos = createEditorPagePosition(this._viewHelper.viewDomNode);
-            const horizontalScrollbarHeight = this._context.configuration.options.get(143 ).horizontalScrollbarHeight;
+            const horizontalScrollbarHeight = this._context.configuration.options.get(144 ).horizontalScrollbarHeight;
             const pos = ( new PageCoordinates(
                 this._mouseEvent.pos.x,
                 editorPos.y + editorPos.height - horizontalScrollbarHeight - 0.1

package/vscode/src/vs/editor/browser/controller/mouseTarget.js

@@ -160,10 +160,10 @@ class HitTestContext {
     constructor(context, viewHelper, lastRenderData) {
         this.viewModel = context.viewModel;
         const options = context.configuration.options;
-        this.layoutInfo = options.get(143 );
+        this.layoutInfo = options.get(144 );
         this.viewDomNode = viewHelper.viewDomNode;
-        this.lineHeight = options.get(66 );
-        this.stickyTabStops = options.get(115 );
+        this.lineHeight = options.get(67 );
+        this.stickyTabStops = options.get(116 );
         this.typicalHalfwidthCharacterWidth = options.get(50 ).typicalHalfwidthCharacterWidth;
         this.lastRenderData = lastRenderData;
         this._context = context;
@@ -571,7 +571,7 @@ class MouseTargetFactory {
     }
     getMouseColumn(relativePos) {
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(143 );
+        const layoutInfo = options.get(144 );
         const mouseContentHorizontalOffset = this._context.viewLayout.getCurrentScrollLeft() + relativePos.x - layoutInfo.contentLeft;
         return MouseTargetFactory._getMouseColumn(mouseContentHorizontalOffset, options.get(50 ).typicalHalfwidthCharacterWidth);
     }