monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/gotoSymbolQuickAccess.js

@@ -0,0 +1,395 @@
+import { DeferredPromise } from '../../../../base/common/async.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { pieceToQuery, scoreFuzzy2, prepareQuery } from '../../../../base/common/fuzzyScorer.js';
+import { Disposable, DisposableStore, toDisposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { trim, format } from '../../../../base/common/strings.js';
+import { Range } from '../../../common/core/range.js';
+import { SymbolKinds, getAriaLabelForSymbol } from '../../../common/languages.js';
+import { IOutlineModelService } from '../../documentSymbols/browser/outlineModel.js';
+import { AbstractEditorNavigationQuickAccessProvider } from './editorNavigationQuickAccess.js';
+import { localize } from '../../../../nls.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { findLast } from '../../../../base/common/arraysFind.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var AbstractGotoSymbolQuickAccessProvider_1;
+let AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessProvider extends AbstractEditorNavigationQuickAccessProvider {
+    static { AbstractGotoSymbolQuickAccessProvider_1 = this; }
+    static { this.PREFIX = '@'; }
+    static { this.SCOPE_PREFIX = ':'; }
+    static { this.PREFIX_BY_CATEGORY = `${this.PREFIX}${this.SCOPE_PREFIX}`; }
+    constructor(_languageFeaturesService, _outlineModelService, options = Object.create(null)) {
+        super(options);
+        this._languageFeaturesService = _languageFeaturesService;
+        this._outlineModelService = _outlineModelService;
+        this.options = options;
+        this.options.canAcceptInBackground = true;
+    }
+    provideWithoutTextEditor(picker) {
+        this.provideLabelPick(picker, localize(1345, "To go to a symbol, first open a text editor with symbol information."));
+        return Disposable.None;
+    }
+    provideWithTextEditor(context, picker, token, runOptions) {
+        const editor = context.editor;
+        const model = this.getModel(editor);
+        if (!model) {
+            return Disposable.None;
+        }
+        // Provide symbols from model if available in registry
+        if (this._languageFeaturesService.documentSymbolProvider.has(model)) {
+            return this.doProvideWithEditorSymbols(context, model, picker, token, runOptions);
+        }
+        // Otherwise show an entry for a model without registry
+        // But give a chance to resolve the symbols at a later
+        // point if possible
+        return this.doProvideWithoutEditorSymbols(context, model, picker, token);
+    }
+    doProvideWithoutEditorSymbols(context, model, picker, token) {
+        const disposables = new DisposableStore();
+        // Generic pick for not having any symbol information
+        this.provideLabelPick(picker, localize(1346, "The active text editor does not provide symbol information."));
+        // Wait for changes to the registry and see if eventually
+        // we do get symbols. This can happen if the picker is opened
+        // very early after the model has loaded but before the
+        // language registry is ready.
+        // https://github.com/microsoft/vscode/issues/70607
+        (async () => {
+            const result = await this.waitForLanguageSymbolRegistry(model, disposables);
+            if (!result || token.isCancellationRequested) {
+                return;
+            }
+            disposables.add(this.doProvideWithEditorSymbols(context, model, picker, token));
+        })();
+        return disposables;
+    }
+    provideLabelPick(picker, label) {
+        picker.items = [{ label, index: 0, kind: 14 /* SymbolKind.String */ }];
+        picker.ariaLabel = label;
+    }
+    async waitForLanguageSymbolRegistry(model, disposables) {
+        if (this._languageFeaturesService.documentSymbolProvider.has(model)) {
+            return true;
+        }
+        const symbolProviderRegistryPromise = new DeferredPromise();
+        // Resolve promise when registry knows model
+        const symbolProviderListener = disposables.add(this._languageFeaturesService.documentSymbolProvider.onDidChange(() => {
+            if (this._languageFeaturesService.documentSymbolProvider.has(model)) {
+                symbolProviderListener.dispose();
+                symbolProviderRegistryPromise.complete(true);
+            }
+        }));
+        // Resolve promise when we get disposed too
+        disposables.add(toDisposable(() => symbolProviderRegistryPromise.complete(false)));
+        return symbolProviderRegistryPromise.p;
+    }
+    doProvideWithEditorSymbols(context, model, picker, token, runOptions) {
+        const editor = context.editor;
+        const disposables = new DisposableStore();
+        // Goto symbol once picked
+        disposables.add(picker.onDidAccept(event => {
+            const [item] = picker.selectedItems;
+            if (item && item.range) {
+                this.gotoLocation(context, { range: item.range.selection, keyMods: picker.keyMods, preserveFocus: event.inBackground });
+                runOptions?.handleAccept?.(item, event.inBackground);
+                if (!event.inBackground) {
+                    picker.hide();
+                }
+            }
+        }));
+        // Goto symbol side by side if enabled
+        disposables.add(picker.onDidTriggerItemButton(({ item }) => {
+            if (item && item.range) {
+                this.gotoLocation(context, { range: item.range.selection, keyMods: picker.keyMods, forceSideBySide: true });
+                picker.hide();
+            }
+        }));
+        // Resolve symbols from document once and reuse this
+        // request for all filtering and typing then on
+        const symbolsPromise = this.getDocumentSymbols(model, token);
+        // Set initial picks and update on type
+        const picksCts = disposables.add(new MutableDisposable());
+        const updatePickerItems = async (positionToEnclose) => {
+            // Cancel any previous ask for picks and busy
+            picksCts?.value?.cancel();
+            picker.busy = false;
+            // Create new cancellation source for this run
+            picksCts.value = new CancellationTokenSource();
+            // Collect symbol picks
+            picker.busy = true;
+            try {
+                const query = prepareQuery(picker.value.substr(AbstractGotoSymbolQuickAccessProvider_1.PREFIX.length).trim());
+                const items = await this.doGetSymbolPicks(symbolsPromise, query, undefined, picksCts.value.token, model);
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                if (items.length > 0) {
+                    picker.items = items;
+                    if (positionToEnclose && query.original.length === 0) {
+                        const candidate = findLast(items, item => Boolean(item.type !== 'separator' && item.range && Range.containsPosition(item.range.decoration, positionToEnclose)));
+                        if (candidate) {
+                            picker.activeItems = [candidate];
+                        }
+                    }
+                }
+                else {
+                    if (query.original.length > 0) {
+                        this.provideLabelPick(picker, localize(1347, "No matching editor symbols"));
+                    }
+                    else {
+                        this.provideLabelPick(picker, localize(1348, "No editor symbols"));
+                    }
+                }
+            }
+            finally {
+                if (!token.isCancellationRequested) {
+                    picker.busy = false;
+                }
+            }
+        };
+        disposables.add(picker.onDidChangeValue(() => updatePickerItems(undefined)));
+        updatePickerItems(editor.getSelection()?.getPosition());
+        // Reveal and decorate when active item changes
+        disposables.add(picker.onDidChangeActive(() => {
+            const [item] = picker.activeItems;
+            if (item && item.range) {
+                // Reveal
+                editor.revealRangeInCenter(item.range.selection, 0 /* ScrollType.Smooth */);
+                // Decorate
+                this.addDecorations(editor, item.range.decoration);
+            }
+        }));
+        return disposables;
+    }
+    async doGetSymbolPicks(symbolsPromise, query, options, token, model) {
+        const symbols = await symbolsPromise;
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const filterBySymbolKind = query.original.indexOf(AbstractGotoSymbolQuickAccessProvider_1.SCOPE_PREFIX) === 0;
+        const filterPos = filterBySymbolKind ? 1 : 0;
+        // Split between symbol and container query
+        let symbolQuery;
+        let containerQuery;
+        if (query.values && query.values.length > 1) {
+            symbolQuery = pieceToQuery(query.values[0]); // symbol: only match on first part
+            containerQuery = pieceToQuery(query.values.slice(1)); // container: match on all but first parts
+        }
+        else {
+            symbolQuery = query;
+        }
+        // Convert to symbol picks and apply filtering
+        let buttons;
+        const openSideBySideDirection = this.options?.openSideBySideDirection?.();
+        if (openSideBySideDirection) {
+            buttons = [{
+                    iconClass: openSideBySideDirection === 'right' ? ThemeIcon.asClassName(Codicon.splitHorizontal) : ThemeIcon.asClassName(Codicon.splitVertical),
+                    tooltip: openSideBySideDirection === 'right' ? localize(1349, "Open to the Side") : localize(1350, "Open to the Bottom")
+                }];
+        }
+        const filteredSymbolPicks = [];
+        for (let index = 0; index < symbols.length; index++) {
+            const symbol = symbols[index];
+            const symbolLabel = trim(symbol.name);
+            const symbolLabelWithIcon = `$(${SymbolKinds.toIcon(symbol.kind).id}) ${symbolLabel}`;
+            const symbolLabelIconOffset = symbolLabelWithIcon.length - symbolLabel.length;
+            let containerLabel = symbol.containerName;
+            if (options?.extraContainerLabel) {
+                if (containerLabel) {
+                    containerLabel = `${options.extraContainerLabel} • ${containerLabel}`;
+                }
+                else {
+                    containerLabel = options.extraContainerLabel;
+                }
+            }
+            let symbolScore = undefined;
+            let symbolMatches = undefined;
+            let containerScore = undefined;
+            let containerMatches = undefined;
+            if (query.original.length > filterPos) {
+                // First: try to score on the entire query, it is possible that
+                // the symbol matches perfectly (e.g. searching for "change log"
+                // can be a match on a markdown symbol "change log"). In that
+                // case we want to skip the container query altogether.
+                let skipContainerQuery = false;
+                if (symbolQuery !== query) {
+                    [symbolScore, symbolMatches] = scoreFuzzy2(symbolLabelWithIcon, { ...query, values: undefined /* disable multi-query support */ }, filterPos, symbolLabelIconOffset);
+                    if (typeof symbolScore === 'number') {
+                        skipContainerQuery = true; // since we consumed the query, skip any container matching
+                    }
+                }
+                // Otherwise: score on the symbol query and match on the container later
+                if (typeof symbolScore !== 'number') {
+                    [symbolScore, symbolMatches] = scoreFuzzy2(symbolLabelWithIcon, symbolQuery, filterPos, symbolLabelIconOffset);
+                    if (typeof symbolScore !== 'number') {
+                        continue;
+                    }
+                }
+                // Score by container if specified
+                if (!skipContainerQuery && containerQuery) {
+                    if (containerLabel && containerQuery.original.length > 0) {
+                        [containerScore, containerMatches] = scoreFuzzy2(containerLabel, containerQuery);
+                    }
+                    if (typeof containerScore !== 'number') {
+                        continue;
+                    }
+                    if (typeof symbolScore === 'number') {
+                        symbolScore += containerScore; // boost symbolScore by containerScore
+                    }
+                }
+            }
+            const deprecated = symbol.tags && symbol.tags.indexOf(1 /* SymbolTag.Deprecated */) >= 0;
+            filteredSymbolPicks.push({
+                index,
+                kind: symbol.kind,
+                score: symbolScore,
+                label: symbolLabelWithIcon,
+                ariaLabel: getAriaLabelForSymbol(symbol.name, symbol.kind),
+                description: containerLabel,
+                highlights: deprecated ? undefined : {
+                    label: symbolMatches,
+                    description: containerMatches
+                },
+                range: {
+                    selection: Range.collapseToStart(symbol.selectionRange),
+                    decoration: symbol.range
+                },
+                uri: model.uri,
+                symbolName: symbolLabel,
+                strikethrough: deprecated,
+                buttons
+            });
+        }
+        // Sort by score
+        const sortedFilteredSymbolPicks = filteredSymbolPicks.sort((symbolA, symbolB) => filterBySymbolKind ?
+            this.compareByKindAndScore(symbolA, symbolB) :
+            this.compareByScore(symbolA, symbolB));
+        // Add separator for types
+        // - @  only total number of symbols
+        // - @: grouped by symbol kind
+        let symbolPicks = [];
+        if (filterBySymbolKind) {
+            let lastSymbolKind = undefined;
+            let lastSeparator = undefined;
+            let lastSymbolKindCounter = 0;
+            function updateLastSeparatorLabel() {
+                if (lastSeparator && typeof lastSymbolKind === 'number' && lastSymbolKindCounter > 0) {
+                    lastSeparator.label = format(NLS_SYMBOL_KIND_CACHE[lastSymbolKind] || FALLBACK_NLS_SYMBOL_KIND, lastSymbolKindCounter);
+                }
+            }
+            for (const symbolPick of sortedFilteredSymbolPicks) {
+                // Found new kind
+                if (lastSymbolKind !== symbolPick.kind) {
+                    // Update last separator with number of symbols we found for kind
+                    updateLastSeparatorLabel();
+                    lastSymbolKind = symbolPick.kind;
+                    lastSymbolKindCounter = 1;
+                    // Add new separator for new kind
+                    lastSeparator = { type: 'separator' };
+                    symbolPicks.push(lastSeparator);
+                }
+                // Existing kind, keep counting
+                else {
+                    lastSymbolKindCounter++;
+                }
+                // Add to final result
+                symbolPicks.push(symbolPick);
+            }
+            // Update last separator with number of symbols we found for kind
+            updateLastSeparatorLabel();
+        }
+        else if (sortedFilteredSymbolPicks.length > 0) {
+            symbolPicks = [
+                { label: localize(1351, "symbols ({0})", filteredSymbolPicks.length), type: 'separator' },
+                ...sortedFilteredSymbolPicks
+            ];
+        }
+        return symbolPicks;
+    }
+    compareByScore(symbolA, symbolB) {
+        if (typeof symbolA.score !== 'number' && typeof symbolB.score === 'number') {
+            return 1;
+        }
+        else if (typeof symbolA.score === 'number' && typeof symbolB.score !== 'number') {
+            return -1;
+        }
+        if (typeof symbolA.score === 'number' && typeof symbolB.score === 'number') {
+            if (symbolA.score > symbolB.score) {
+                return -1;
+            }
+            else if (symbolA.score < symbolB.score) {
+                return 1;
+            }
+        }
+        if (symbolA.index < symbolB.index) {
+            return -1;
+        }
+        else if (symbolA.index > symbolB.index) {
+            return 1;
+        }
+        return 0;
+    }
+    compareByKindAndScore(symbolA, symbolB) {
+        const kindA = NLS_SYMBOL_KIND_CACHE[symbolA.kind] || FALLBACK_NLS_SYMBOL_KIND;
+        const kindB = NLS_SYMBOL_KIND_CACHE[symbolB.kind] || FALLBACK_NLS_SYMBOL_KIND;
+        // Sort by type first if scoped search
+        const result = kindA.localeCompare(kindB);
+        if (result === 0) {
+            return this.compareByScore(symbolA, symbolB);
+        }
+        return result;
+    }
+    async getDocumentSymbols(document, token) {
+        const model = await this._outlineModelService.getOrCreate(document, token);
+        return token.isCancellationRequested ? [] : model.asListOfDocumentSymbols();
+    }
+};
+AbstractGotoSymbolQuickAccessProvider = AbstractGotoSymbolQuickAccessProvider_1 = __decorate([
+    __param(0, ILanguageFeaturesService),
+    __param(1, IOutlineModelService)
+], AbstractGotoSymbolQuickAccessProvider);
+// #region NLS Helpers
+const FALLBACK_NLS_SYMBOL_KIND = localize(1352, "properties ({0})");
+const NLS_SYMBOL_KIND_CACHE = {
+    [5 /* SymbolKind.Method */]: localize(1353, "methods ({0})"),
+    [11 /* SymbolKind.Function */]: localize(1354, "functions ({0})"),
+    [8 /* SymbolKind.Constructor */]: localize(1355, "constructors ({0})"),
+    [12 /* SymbolKind.Variable */]: localize(1356, "variables ({0})"),
+    [4 /* SymbolKind.Class */]: localize(1357, "classes ({0})"),
+    [22 /* SymbolKind.Struct */]: localize(1358, "structs ({0})"),
+    [23 /* SymbolKind.Event */]: localize(1359, "events ({0})"),
+    [24 /* SymbolKind.Operator */]: localize(1360, "operators ({0})"),
+    [10 /* SymbolKind.Interface */]: localize(1361, "interfaces ({0})"),
+    [2 /* SymbolKind.Namespace */]: localize(1362, "namespaces ({0})"),
+    [3 /* SymbolKind.Package */]: localize(1363, "packages ({0})"),
+    [25 /* SymbolKind.TypeParameter */]: localize(1364, "type parameters ({0})"),
+    [1 /* SymbolKind.Module */]: localize(1365, "modules ({0})"),
+    [6 /* SymbolKind.Property */]: localize(1366, "properties ({0})"),
+    [9 /* SymbolKind.Enum */]: localize(1367, "enumerations ({0})"),
+    [21 /* SymbolKind.EnumMember */]: localize(1368, "enumeration members ({0})"),
+    [14 /* SymbolKind.String */]: localize(1369, "strings ({0})"),
+    [0 /* SymbolKind.File */]: localize(1370, "files ({0})"),
+    [17 /* SymbolKind.Array */]: localize(1371, "arrays ({0})"),
+    [15 /* SymbolKind.Number */]: localize(1372, "numbers ({0})"),
+    [16 /* SymbolKind.Boolean */]: localize(1373, "booleans ({0})"),
+    [18 /* SymbolKind.Object */]: localize(1374, "objects ({0})"),
+    [19 /* SymbolKind.Key */]: localize(1375, "keys ({0})"),
+    [7 /* SymbolKind.Field */]: localize(1376, "fields ({0})"),
+    [13 /* SymbolKind.Constant */]: localize(1377, "constants ({0})")
+};
+//#endregion
+
+export { AbstractGotoSymbolQuickAccessProvider };

package/dist/workers/gpuActions.js

@@ -0,0 +1,126 @@
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { VSBuffer } from '../../../../base/common/buffer.js';
+import { URI } from '../../../../base/common/uri.js';
+import { localize2, localize } from '../../../../nls.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { registerEditorAction, EditorAction } from '../../../browser/editorExtensions.js';
+import { ensureNonNullable } from '../../../browser/gpu/gpuUtils.js';
+import { GlyphRasterizer } from '../../../browser/gpu/raster/glyphRasterizer.js';
+import { ViewGpuContext } from '../../../browser/gpu/viewGpuContext.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class DebugEditorGpuRendererAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.debugEditorGpuRenderer',
+            label: localize2(1101, "Developer: Debug Editor GPU Renderer"),
+            // TODO: Why doesn't `ContextKeyExpr.equals('config:editor.experimentalGpuAcceleration', 'on')` work?
+            precondition: ContextKeyExpr.true(),
+        });
+    }
+    async run(accessor, editor) {
+        const instantiationService = accessor.get(IInstantiationService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const choice = await quickInputService.pick([
+            {
+                label: localize(1098, "Log Texture Atlas Stats"),
+                id: 'logTextureAtlasStats',
+            },
+            {
+                label: localize(1099, "Save Texture Atlas"),
+                id: 'saveTextureAtlas',
+            },
+            {
+                label: localize(1100, "Draw Glyph"),
+                id: 'drawGlyph',
+            },
+        ], { canPickMany: false });
+        if (!choice) {
+            return;
+        }
+        switch (choice.id) {
+            case 'logTextureAtlasStats':
+                instantiationService.invokeFunction(accessor => {
+                    const logService = accessor.get(ILogService);
+                    const atlas = ViewGpuContext.atlas;
+                    if (!ViewGpuContext.atlas) {
+                        logService.error('No texture atlas found');
+                        return;
+                    }
+                    const stats = atlas.getStats();
+                    logService.info(['Texture atlas stats', ...stats].join('\n\n'));
+                });
+                break;
+            case 'saveTextureAtlas':
+                instantiationService.invokeFunction(async (accessor) => {
+                    const workspaceContextService = accessor.get(IWorkspaceContextService);
+                    const fileService = accessor.get(IFileService);
+                    const folders = workspaceContextService.getWorkspace().folders;
+                    if (folders.length > 0) {
+                        const atlas = ViewGpuContext.atlas;
+                        const promises = [];
+                        for (const [layerIndex, page] of atlas.pages.entries()) {
+                            promises.push(...[
+                                fileService.writeFile(URI.joinPath(folders[0].uri, `textureAtlasPage${layerIndex}_actual.png`), VSBuffer.wrap(new Uint8Array(await (await page.source.convertToBlob()).arrayBuffer()))),
+                                fileService.writeFile(URI.joinPath(folders[0].uri, `textureAtlasPage${layerIndex}_usage.png`), VSBuffer.wrap(new Uint8Array(await (await page.getUsagePreview()).arrayBuffer()))),
+                            ]);
+                        }
+                        await Promise.all(promises);
+                    }
+                });
+                break;
+            case 'drawGlyph':
+                instantiationService.invokeFunction(async (accessor) => {
+                    const configurationService = accessor.get(IConfigurationService);
+                    const fileService = accessor.get(IFileService);
+                    const quickInputService = accessor.get(IQuickInputService);
+                    const workspaceContextService = accessor.get(IWorkspaceContextService);
+                    const folders = workspaceContextService.getWorkspace().folders;
+                    if (folders.length === 0) {
+                        return;
+                    }
+                    const atlas = ViewGpuContext.atlas;
+                    const fontFamily = configurationService.getValue('editor.fontFamily');
+                    const fontSize = configurationService.getValue('editor.fontSize');
+                    const rasterizer = new GlyphRasterizer(fontSize, fontFamily, getActiveWindow().devicePixelRatio, ViewGpuContext.decorationStyleCache);
+                    let chars = await quickInputService.input({
+                        prompt: 'Enter a character to draw (prefix with 0x for code point))'
+                    });
+                    if (!chars) {
+                        return;
+                    }
+                    const codePoint = chars.match(/0x(?<codePoint>[0-9a-f]+)/i)?.groups?.codePoint;
+                    if (codePoint !== undefined) {
+                        chars = String.fromCodePoint(parseInt(codePoint, 16));
+                    }
+                    const tokenMetadata = 0;
+                    const charMetadata = 0;
+                    const rasterizedGlyph = atlas.getGlyph(rasterizer, chars, tokenMetadata, charMetadata, 0);
+                    if (!rasterizedGlyph) {
+                        return;
+                    }
+                    const imageData = atlas.pages[rasterizedGlyph.pageIndex].source.getContext('2d')?.getImageData(rasterizedGlyph.x, rasterizedGlyph.y, rasterizedGlyph.w, rasterizedGlyph.h);
+                    if (!imageData) {
+                        return;
+                    }
+                    const canvas = new OffscreenCanvas(imageData.width, imageData.height);
+                    const ctx = ensureNonNullable(canvas.getContext('2d'));
+                    ctx.putImageData(imageData, 0, 0);
+                    const blob = await canvas.convertToBlob({ type: 'image/png' });
+                    const resource = URI.joinPath(folders[0].uri, `glyph_${chars}_${tokenMetadata}_${fontSize}px_${fontFamily.replaceAll(/[,\\\/\.'\s]/g, '_')}.png`);
+                    await fileService.writeFile(resource, VSBuffer.wrap(new Uint8Array(await blob.arrayBuffer())));
+                });
+                break;
+        }
+    }
+}
+registerEditorAction(DebugEditorGpuRendererAction);

package/dist/workers/gpuDisposable.js

@@ -0,0 +1,48 @@
+import { isFunction } from '../../../base/common/types.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var GPULifecycle;
+(function (GPULifecycle) {
+    async function requestDevice(fallback) {
+        try {
+            if (!navigator.gpu) {
+                throw new Error('This browser does not support WebGPU');
+            }
+            const adapter = (await navigator.gpu.requestAdapter());
+            if (!adapter) {
+                throw new Error('This browser supports WebGPU but it appears to be disabled');
+            }
+            return wrapDestroyableInDisposable(await adapter.requestDevice());
+        }
+        catch (e) {
+            if (fallback) {
+                fallback(e.message);
+            }
+            throw e;
+        }
+    }
+    GPULifecycle.requestDevice = requestDevice;
+    function createBuffer(device, descriptor, initialValues) {
+        const buffer = device.createBuffer(descriptor);
+        if (initialValues) {
+            device.queue.writeBuffer(buffer, 0, (isFunction(initialValues) ? initialValues() : initialValues));
+        }
+        return wrapDestroyableInDisposable(buffer);
+    }
+    GPULifecycle.createBuffer = createBuffer;
+    function createTexture(device, descriptor) {
+        return wrapDestroyableInDisposable(device.createTexture(descriptor));
+    }
+    GPULifecycle.createTexture = createTexture;
+})(GPULifecycle || (GPULifecycle = {}));
+function wrapDestroyableInDisposable(value) {
+    return {
+        object: value,
+        dispose: () => value.destroy()
+    };
+}
+
+export { GPULifecycle };

package/dist/workers/gpuMark.js

@@ -0,0 +1,80 @@
+import { DynamicViewOverlay } from '../../view/dynamicViewOverlay.js';
+import { ViewLineOptions } from '../viewLines/viewLineOptions.js';
+import './gpuMark.css';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * A mark on lines to make identification of GPU-rendered lines vs DOM easier.
+ */
+class GpuMarkOverlay extends DynamicViewOverlay {
+    static { this.CLASS_NAME = 'gpu-mark'; }
+    constructor(context, _viewGpuContext) {
+        super();
+        this._viewGpuContext = _viewGpuContext;
+        this._context = context;
+        this._renderResult = null;
+        this._context.addEventHandler(this);
+    }
+    dispose() {
+        this._context.removeEventHandler(this);
+        this._renderResult = null;
+        super.dispose();
+    }
+    // --- begin event handlers
+    onConfigurationChanged(e) {
+        return true;
+    }
+    onCursorStateChanged(e) {
+        return true;
+    }
+    onFlushed(e) {
+        return true;
+    }
+    onLinesChanged(e) {
+        return true;
+    }
+    onLinesDeleted(e) {
+        return true;
+    }
+    onLinesInserted(e) {
+        return true;
+    }
+    onScrollChanged(e) {
+        return e.scrollTopChanged;
+    }
+    onZonesChanged(e) {
+        return true;
+    }
+    onDecorationsChanged(e) {
+        return true;
+    }
+    // --- end event handlers
+    prepareRender(ctx) {
+        const visibleStartLineNumber = ctx.visibleRange.startLineNumber;
+        const visibleEndLineNumber = ctx.visibleRange.endLineNumber;
+        const viewportData = ctx.viewportData;
+        const options = new ViewLineOptions(this._context.configuration, this._context.theme.type);
+        const output = [];
+        for (let lineNumber = visibleStartLineNumber; lineNumber <= visibleEndLineNumber; lineNumber++) {
+            const lineIndex = lineNumber - visibleStartLineNumber;
+            const cannotRenderReasons = this._viewGpuContext.canRenderDetailed(options, viewportData, lineNumber);
+            output[lineIndex] = cannotRenderReasons.length ? `<div class="${GpuMarkOverlay.CLASS_NAME}" title="Cannot render on GPU: ${cannotRenderReasons.join(', ')}"></div>` : '';
+        }
+        this._renderResult = output;
+    }
+    render(startLineNumber, lineNumber) {
+        if (!this._renderResult) {
+            return '';
+        }
+        const lineIndex = lineNumber - startLineNumber;
+        if (lineIndex < 0 || lineIndex >= this._renderResult.length) {
+            return '';
+        }
+        return this._renderResult[lineIndex];
+    }
+}
+
+export { GpuMarkOverlay };