@codingame/monaco-vscode-api 2.2.1 → 3.0.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/scrollable.d.ts

@@ -1,3 +1,6 @@
+import { Event } from './event.js';
+import { Disposable, IDisposable } from './lifecycle.js';
+
 declare const enum ScrollbarVisibility {
     Auto = 1,
     Hidden = 2,
@@ -24,5 +27,69 @@ interface ScrollEvent {
     scrollHeightChanged: boolean;
     scrollTopChanged: boolean;
 }
+interface IScrollDimensions {
+    readonly width: number;
+    readonly scrollWidth: number;
+    readonly height: number;
+    readonly scrollHeight: number;
+}
+interface INewScrollDimensions {
+    width?: number;
+    scrollWidth?: number;
+    height?: number;
+    scrollHeight?: number;
+}
+interface IScrollPosition {
+    readonly scrollLeft: number;
+    readonly scrollTop: number;
+}
+interface INewScrollPosition {
+    scrollLeft?: number;
+    scrollTop?: number;
+}
+interface IScrollableOptions {
+    /**
+     * Define if the scroll values should always be integers.
+     */
+    forceIntegerValues: boolean;
+    /**
+     * Set the duration (ms) used for smooth scroll animations.
+     */
+    smoothScrollDuration: number;
+    /**
+     * A function to schedule an update at the next frame (used for smooth scroll animations).
+     */
+    scheduleAtNextAnimationFrame: (callback: () => void) => IDisposable;
+}
+declare class Scrollable extends Disposable {
+    _scrollableBrand: void;
+    private _smoothScrollDuration;
+    private readonly _scheduleAtNextAnimationFrame;
+    private _state;
+    private _smoothScrolling;
+    private _onScroll;
+    readonly onScroll: Event<ScrollEvent>;
+    constructor(options: IScrollableOptions);
+    dispose(): void;
+    setSmoothScrollDuration(smoothScrollDuration: number): void;
+    validateScrollPosition(scrollPosition: INewScrollPosition): IScrollPosition;
+    getScrollDimensions(): IScrollDimensions;
+    setScrollDimensions(dimensions: INewScrollDimensions, useRawScrollPositions: boolean): void;
+    /**
+     * Returns the final scroll position that the instance will have once the smooth scroll animation concludes.
+     * If no scroll animation is occurring, it will return the current scroll position instead.
+     */
+    getFutureScrollPosition(): IScrollPosition;
+    /**
+     * Returns the current scroll position.
+     * Note: This result might be an intermediate scroll position, as there might be an ongoing smooth scroll animation.
+     */
+    getCurrentScrollPosition(): IScrollPosition;
+    setScrollPositionNow(update: INewScrollPosition): void;
+    setScrollPositionSmooth(update: INewScrollPosition, reuseAnimation?: boolean): void;
+    hasPendingScrollAnimation(): boolean;
+    private _performSmoothScrolling;
+    private _setState;
+}
 
-export { type ScrollEvent, ScrollbarVisibility };
+export { type INewScrollDimensions, type INewScrollPosition, type IScrollDimensions, type IScrollPosition, type IScrollableOptions, type ScrollEvent, Scrollable, ScrollbarVisibility };

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,8 +13,10 @@ 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, options, container, _accessibilityService) {
+    constructor(isSimpleWidget, isStandaloneEditor, options, container, _accessibilityService) {
         super();
         this._accessibilityService = _accessibilityService;
         this._onDidChange = this._register(( new Emitter()));
@@ -28,7 +30,9 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
         this._glyphMarginDecorationLaneCount = 1;
         this._computeOptionsMemory = ( new ComputeOptionsMemory());
         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();
@@ -39,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() {
@@ -75,18 +79,18 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
     }
     _readEnvConfiguration() {
         return {
-            extraEditorClassName: getExtraEditorClassName(),
+            extraEditorClassName: getExtraEditorClassName(this.isStandaloneEditor),
             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;
@@ -141,7 +145,7 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
     }
 };
 EditorConfiguration = ( __decorate([
-    ( __param(3, IAccessibilityService))
+    ( __param(4, IAccessibilityService))
 ], EditorConfiguration));
 function digitCount(n) {
     let r = 0;
@@ -151,7 +155,7 @@ function digitCount(n) {
     }
     return r ? r : 1;
 }
-function getExtraEditorClassName() {
+function getExtraEditorClassName(isStandaloneEditor) {
     let extra = '';
     if (!isSafari && !isWebkitWebView) {
         extra += 'no-user-select ';
@@ -163,6 +167,9 @@ function getExtraEditorClassName() {
     if (isMacintosh) {
         extra += 'mac ';
     }
+    if (isStandaloneEditor) {
+        extra += 'standalone ';
+    }
     return extra;
 }
 class ValidatedEditorOptions {

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,