@codingame/monaco-vscode-api 9.0.3 → 10.0.0

package/vscode/src/vs/editor/browser/gpu/objectCollectionBuffer.js

@@ -0,0 +1,117 @@
+import { Emitter, Event } from '../../../base/common/event.js';
+import { Disposable, toDisposable, dispose } from '../../../base/common/lifecycle.js';
+import { LinkedList } from '../../../base/common/linkedList.js';
+import { BufferDirtyTracker } from './bufferDirtyTracker.js';
+function createObjectCollectionBuffer(propertySpecs, capacity) {
+    return ( new ObjectCollectionBuffer(propertySpecs, capacity));
+}
+class ObjectCollectionBuffer extends Disposable {
+    get bufferUsedSize() {
+        return this.viewUsedSize * Float32Array.BYTES_PER_ELEMENT;
+    }
+    get viewUsedSize() {
+        return this._entries.size * this._entrySize;
+    }
+    get entryCount() {
+        return this._entries.size;
+    }
+    get dirtyTracker() { return this._dirtyTracker; }
+    constructor(propertySpecs, capacity) {
+        super();
+        this.propertySpecs = propertySpecs;
+        this.capacity = capacity;
+        this._dirtyTracker = ( new BufferDirtyTracker());
+        this._propertySpecsMap = ( new Map());
+        this._entries = ( new LinkedList());
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onDidChangeBuffer = this._register(( new Emitter()));
+        this.onDidChangeBuffer = this._onDidChangeBuffer.event;
+        this.view = ( new Float32Array(capacity * propertySpecs.length));
+        this.buffer = this.view.buffer;
+        this._entrySize = propertySpecs.length;
+        for (let i = 0; i < propertySpecs.length; i++) {
+            const spec = {
+                offset: i,
+                ...propertySpecs[i]
+            };
+            this._propertySpecsMap.set(spec.name, spec);
+        }
+        this._register(toDisposable(() => dispose(this._entries)));
+    }
+    createEntry(data) {
+        if (this._entries.size === this.capacity) {
+            this._expandBuffer();
+            this._onDidChangeBuffer.fire();
+        }
+        const value = ( new ObjectCollectionBufferEntry(
+            this.view,
+            this._propertySpecsMap,
+            this._dirtyTracker,
+            this._entries.size,
+            data
+        ));
+        const removeFromEntries = this._entries.push(value);
+        const listeners = [];
+        listeners.push(Event.forward(value.onDidChange, this._onDidChange));
+        listeners.push(value.onWillDispose(() => {
+            const deletedEntryIndex = value.i;
+            removeFromEntries();
+            this.view.set(this.view.subarray(deletedEntryIndex * this._entrySize + 2, this._entries.size * this._entrySize + 2), deletedEntryIndex * this._entrySize);
+            for (const entry of this._entries) {
+                if (entry.i > deletedEntryIndex) {
+                    entry.i--;
+                }
+            }
+            this._dirtyTracker.flag(deletedEntryIndex, (this._entries.size - deletedEntryIndex) * this._entrySize);
+            dispose(listeners);
+        }));
+        return value;
+    }
+    _expandBuffer() {
+        this.capacity *= 2;
+        const newView = ( new Float32Array(this.capacity * this._entrySize));
+        newView.set(this.view);
+        this.view = newView;
+        this.buffer = this.view.buffer;
+    }
+}
+class ObjectCollectionBufferEntry extends Disposable {
+    constructor(_view, _propertySpecsMap, _dirtyTracker, i, data) {
+        super();
+        this._view = _view;
+        this._propertySpecsMap = _propertySpecsMap;
+        this._dirtyTracker = _dirtyTracker;
+        this.i = i;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        for (const propertySpec of ( this._propertySpecsMap.values())) {
+            this._view[this.i * this._propertySpecsMap.size + propertySpec.offset] = data[propertySpec.name];
+        }
+        this._dirtyTracker.flag(this.i * this._propertySpecsMap.size, this._propertySpecsMap.size);
+    }
+    dispose() {
+        this._onWillDispose.fire();
+        super.dispose();
+    }
+    set(propertyName, value) {
+        const i = this.i * this._propertySpecsMap.size + this._propertySpecsMap.get(propertyName).offset;
+        this._view[this._dirtyTracker.flag(i)] = value;
+        this._onDidChange.fire();
+    }
+    get(propertyName) {
+        return this._view[this.i * this._propertySpecsMap.size + this._propertySpecsMap.get(propertyName).offset];
+    }
+    setRaw(data) {
+        if (data.length !== this._propertySpecsMap.size) {
+            throw ( new Error(
+                `Data length ${data.length} does not match the number of properties in the collection (${this._propertySpecsMap.size})`
+            ));
+        }
+        this._view.set(data, this.i * this._propertySpecsMap.size);
+        this._dirtyTracker.flag(this.i * this._propertySpecsMap.size, this._propertySpecsMap.size);
+    }
+}
+export { createObjectCollectionBuffer };

package/vscode/src/vs/editor/browser/gpu/raster/glyphRasterizer.js

@@ -0,0 +1,152 @@
+import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { memoize } from '../../../../base/common/decorators.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { StringBuilder } from '../../../common/core/stringBuilder.js';
+import { TokenMetadata } from '../../../common/encodedTokenAttributes.js';
+import { ensureNonNullable } from '../gpuUtils.js';
+let nextId = 0;
+class GlyphRasterizer extends Disposable {
+    get cacheKey() {
+        return `${this._fontFamily}_${this._fontSize}px`;
+    }
+    constructor(_fontSize, _fontFamily) {
+        super();
+        this._fontSize = _fontSize;
+        this._fontFamily = _fontFamily;
+        this.id = nextId++;
+        this._workGlyph = {
+            source: null,
+            boundingBox: {
+                left: 0,
+                bottom: 0,
+                right: 0,
+                top: 0,
+            },
+            originOffset: {
+                x: 0,
+                y: 0,
+            }
+        };
+        this._workGlyphConfig = { chars: undefined, metadata: 0 };
+        const devicePixelFontSize = Math.ceil(this._fontSize * getActiveWindow().devicePixelRatio);
+        this._canvas = ( new OffscreenCanvas(devicePixelFontSize * 3, devicePixelFontSize * 3));
+        this._ctx = ensureNonNullable(this._canvas.getContext('2d', {
+            willReadFrequently: true
+        }));
+        this._ctx.textBaseline = 'top';
+        this._ctx.fillStyle = '#FFFFFF';
+    }
+    rasterizeGlyph(chars, metadata, colorMap) {
+        if (chars === '') {
+            return {
+                source: this._canvas,
+                boundingBox: { top: 0, left: 0, bottom: -1, right: -1 },
+                originOffset: { x: 0, y: 0 }
+            };
+        }
+        if (this._workGlyphConfig.chars === chars && this._workGlyphConfig.metadata === metadata) {
+            return this._workGlyph;
+        }
+        this._workGlyphConfig.chars = chars;
+        this._workGlyphConfig.metadata = metadata;
+        return this._rasterizeGlyph(chars, metadata, colorMap);
+    }
+    _rasterizeGlyph(chars, metadata, colorMap) {
+        const devicePixelFontSize = Math.ceil(this._fontSize * getActiveWindow().devicePixelRatio);
+        const canvasDim = devicePixelFontSize * 3;
+        if (this._canvas.width !== canvasDim) {
+            this._canvas.width = canvasDim;
+            this._canvas.height = canvasDim;
+        }
+        this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
+        const fontSb = ( new StringBuilder(200));
+        const fontStyle = TokenMetadata.getFontStyle(metadata);
+        if (fontStyle & 1 ) {
+            fontSb.appendString('italic ');
+        }
+        if (fontStyle & 2 ) {
+            fontSb.appendString('bold ');
+        }
+        fontSb.appendString(`${devicePixelFontSize}px ${this._fontFamily}`);
+        this._ctx.font = fontSb.build();
+        const originX = devicePixelFontSize;
+        const originY = devicePixelFontSize;
+        this._ctx.fillStyle = colorMap[TokenMetadata.getForeground(metadata)];
+        this._ctx.textBaseline = 'top';
+        this._ctx.fillText(chars, originX, originY);
+        const imageData = this._ctx.getImageData(0, 0, this._canvas.width, this._canvas.height);
+        this._findGlyphBoundingBox(imageData, this._workGlyph.boundingBox);
+        this._workGlyph.source = this._canvas;
+        this._workGlyph.originOffset.x = this._workGlyph.boundingBox.left - originX;
+        this._workGlyph.originOffset.y = this._workGlyph.boundingBox.top - originY;
+        return this._workGlyph;
+    }
+    _findGlyphBoundingBox(imageData, outBoundingBox) {
+        const height = this._canvas.height;
+        const width = this._canvas.width;
+        let found = false;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const alphaOffset = y * width * 4 + x * 4 + 3;
+                if (imageData.data[alphaOffset] !== 0) {
+                    outBoundingBox.top = y;
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                break;
+            }
+        }
+        outBoundingBox.left = 0;
+        found = false;
+        for (let x = 0; x < width; x++) {
+            for (let y = 0; y < height; y++) {
+                const alphaOffset = y * width * 4 + x * 4 + 3;
+                if (imageData.data[alphaOffset] !== 0) {
+                    outBoundingBox.left = x;
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                break;
+            }
+        }
+        outBoundingBox.right = width;
+        found = false;
+        for (let x = width - 1; x >= outBoundingBox.left; x--) {
+            for (let y = 0; y < height; y++) {
+                const alphaOffset = y * width * 4 + x * 4 + 3;
+                if (imageData.data[alphaOffset] !== 0) {
+                    outBoundingBox.right = x;
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                break;
+            }
+        }
+        outBoundingBox.bottom = outBoundingBox.top;
+        found = false;
+        for (let y = height - 1; y >= 0; y--) {
+            for (let x = 0; x < width; x++) {
+                const alphaOffset = y * width * 4 + x * 4 + 3;
+                if (imageData.data[alphaOffset] !== 0) {
+                    outBoundingBox.bottom = y;
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                break;
+            }
+        }
+    }
+}
+GlyphRasterizer.__decorator = ( __decorate([
+    memoize
+], GlyphRasterizer.prototype, "cacheKey", null));
+export { GlyphRasterizer };

package/vscode/src/vs/editor/browser/gpu/rectangleRenderer.js

@@ -0,0 +1,186 @@
+import { getActiveWindow } from '../../../base/browser/dom.js';
+import { Event } from '../../../base/common/event.js';
+import { MutableDisposable } from '../../../base/common/lifecycle.js';
+import { ViewEventHandler } from '../../common/viewEventHandler.js';
+import { GPULifecycle } from './gpuDisposable.js';
+import { observeDevicePixelDimensions, quadVertices } from './gpuUtils.js';
+import { createObjectCollectionBuffer } from './objectCollectionBuffer.js';
+import { rectangleRendererWgsl } from './rectangleRenderer.wgsl.js';
+class RectangleRenderer extends ViewEventHandler {
+    constructor(_context, _canvas, _ctx, device) {
+        super();
+        this._context = _context;
+        this._canvas = _canvas;
+        this._ctx = _ctx;
+        this._shapeBindBuffer = this._register(( new MutableDisposable()));
+        this._initialized = false;
+        this._scrollChanged = true;
+        this._shapeCollection = this._register(createObjectCollectionBuffer([
+            { name: 'x' },
+            { name: 'y' },
+            { name: 'width' },
+            { name: 'height' },
+            { name: 'red' },
+            { name: 'green' },
+            { name: 'blue' },
+            { name: 'alpha' },
+        ], 32));
+        this._context.addEventHandler(this);
+        this._initWebgpu(device);
+    }
+    async _initWebgpu(device) {
+        this._device = await device;
+        if (this._store.isDisposed) {
+            return;
+        }
+        const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
+        this._ctx.configure({
+            device: this._device,
+            format: presentationFormat,
+            alphaMode: 'premultiplied',
+        });
+        this._renderPassColorAttachment = {
+            view: null,
+            loadOp: 'load',
+            storeOp: 'store',
+        };
+        this._renderPassDescriptor = {
+            label: 'Monaco rectangle renderer render pass',
+            colorAttachments: [this._renderPassColorAttachment],
+        };
+        let layoutInfoUniformBuffer;
+        {
+            const bufferValues = ( new Float32Array(6 ));
+            const updateBufferValues = (canvasDevicePixelWidth = this._canvas.width, canvasDevicePixelHeight = this._canvas.height) => {
+                bufferValues[0 ] = canvasDevicePixelWidth;
+                bufferValues[1 ] = canvasDevicePixelHeight;
+                bufferValues[2 ] = Math.ceil(this._context.configuration.options.get(148 ).contentLeft * getActiveWindow().devicePixelRatio);
+                bufferValues[3 ] = 0;
+                bufferValues[4 ] = bufferValues[0 ] - bufferValues[2 ];
+                bufferValues[5 ] = bufferValues[1 ] - bufferValues[3 ];
+                return bufferValues;
+            };
+            layoutInfoUniformBuffer = this._register(GPULifecycle.createBuffer(this._device, {
+                label: 'Monaco rectangle renderer uniform buffer',
+                size: 24 ,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            }, () => updateBufferValues())).object;
+            this._register(observeDevicePixelDimensions(this._canvas, getActiveWindow(), (w, h) => {
+                this._device.queue.writeBuffer(layoutInfoUniformBuffer, 0, updateBufferValues(w, h));
+            }));
+        }
+        const scrollOffsetBufferSize = 2;
+        this._scrollOffsetBindBuffer = this._register(GPULifecycle.createBuffer(this._device, {
+            label: 'Monaco rectangle renderer scroll offset buffer',
+            size: scrollOffsetBufferSize * Float32Array.BYTES_PER_ELEMENT,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        })).object;
+        this._scrollOffsetValueBuffer = ( new Float32Array(scrollOffsetBufferSize));
+        const createShapeBindBuffer = () => {
+            return GPULifecycle.createBuffer(this._device, {
+                label: 'Monaco rectangle renderer shape buffer',
+                size: this._shapeCollection.buffer.byteLength,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            });
+        };
+        this._shapeBindBuffer.value = createShapeBindBuffer();
+        this._register(Event.runAndSubscribe(this._shapeCollection.onDidChangeBuffer, () => {
+            this._shapeBindBuffer.value = createShapeBindBuffer();
+            if (this._pipeline) {
+                this._updateBindGroup(this._pipeline, layoutInfoUniformBuffer);
+            }
+        }));
+        this._vertexBuffer = this._register(GPULifecycle.createBuffer(this._device, {
+            label: 'Monaco rectangle renderer vertex buffer',
+            size: quadVertices.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        }, quadVertices)).object;
+        const module = this._device.createShaderModule({
+            label: 'Monaco rectangle renderer shader module',
+            code: rectangleRendererWgsl,
+        });
+        this._pipeline = this._device.createRenderPipeline({
+            label: 'Monaco rectangle renderer render pipeline',
+            layout: 'auto',
+            vertex: {
+                module,
+                buffers: [
+                    {
+                        arrayStride: 2 * Float32Array.BYTES_PER_ELEMENT,
+                        attributes: [
+                            { shaderLocation: 0, offset: 0, format: 'float32x2' },
+                        ],
+                    }
+                ]
+            },
+            fragment: {
+                module,
+                targets: [
+                    {
+                        format: presentationFormat,
+                        blend: {
+                            color: {
+                                srcFactor: 'src-alpha',
+                                dstFactor: 'one-minus-src-alpha'
+                            },
+                            alpha: {
+                                srcFactor: 'src-alpha',
+                                dstFactor: 'one-minus-src-alpha'
+                            },
+                        },
+                    }
+                ],
+            },
+        });
+        this._updateBindGroup(this._pipeline, layoutInfoUniformBuffer);
+        this._initialized = true;
+    }
+    _updateBindGroup(pipeline, layoutInfoUniformBuffer) {
+        this._bindGroup = this._device.createBindGroup({
+            label: 'Monaco rectangle renderer bind group',
+            layout: pipeline.getBindGroupLayout(0),
+            entries: [
+                { binding: 0 , resource: { buffer: this._shapeBindBuffer.value.object } },
+                { binding: 1 , resource: { buffer: layoutInfoUniformBuffer } },
+                { binding: 2 , resource: { buffer: this._scrollOffsetBindBuffer } },
+            ],
+        });
+    }
+    register(x, y, width, height, red, green, blue, alpha) {
+        return this._shapeCollection.createEntry({ x, y, width, height, red, green, blue, alpha });
+    }
+    onScrollChanged(e) {
+        this._scrollChanged = true;
+        return super.onScrollChanged(e);
+    }
+    _update() {
+        const shapes = this._shapeCollection;
+        if (shapes.dirtyTracker.isDirty) {
+            this._device.queue.writeBuffer(this._shapeBindBuffer.value.object, 0, shapes.buffer, shapes.dirtyTracker.dataOffset, shapes.dirtyTracker.dirtySize * shapes.view.BYTES_PER_ELEMENT);
+            shapes.dirtyTracker.clear();
+        }
+        if (this._scrollChanged) {
+            const dpr = getActiveWindow().devicePixelRatio;
+            this._scrollOffsetValueBuffer[0] = this._context.viewLayout.getCurrentScrollLeft() * dpr;
+            this._scrollOffsetValueBuffer[1] = this._context.viewLayout.getCurrentScrollTop() * dpr;
+            this._device.queue.writeBuffer(this._scrollOffsetBindBuffer, 0, this._scrollOffsetValueBuffer);
+        }
+    }
+    draw(viewportData) {
+        if (!this._initialized) {
+            return;
+        }
+        this._update();
+        const encoder = this._device.createCommandEncoder({ label: 'Monaco rectangle renderer command encoder' });
+        this._renderPassColorAttachment.view = this._ctx.getCurrentTexture().createView();
+        const pass = encoder.beginRenderPass(this._renderPassDescriptor);
+        pass.setPipeline(this._pipeline);
+        pass.setVertexBuffer(0, this._vertexBuffer);
+        pass.setBindGroup(0, this._bindGroup);
+        pass.draw(quadVertices.length / 2, this._shapeCollection.entryCount);
+        pass.end();
+        const commandBuffer = encoder.finish();
+        this._device.queue.submit([commandBuffer]);
+    }
+}
+export { RectangleRenderer };

package/vscode/src/vs/editor/browser/gpu/rectangleRenderer.wgsl.js

@@ -0,0 +1,63 @@
+const rectangleRendererWgsl =  `
+
+struct Vertex {
+	@location(0) position: vec2f,
+};
+
+struct LayoutInfo {
+	canvasDims: vec2f,
+	viewportOffset: vec2f,
+	viewportDims: vec2f,
+}
+
+struct ScrollOffset {
+	offset: vec2f,
+}
+
+struct Shape {
+	position: vec2f,
+	size: vec2f,
+	color: vec4f,
+};
+
+struct VSOutput {
+	@builtin(position) position: vec4f,
+	@location(1)       color:    vec4f,
+};
+
+// Uniforms
+@group(0) @binding(${1 }) var<uniform>       layoutInfo:      LayoutInfo;
+
+// Storage buffers
+@group(0) @binding(${0 })            var<storage, read> shapes:          array<Shape>;
+@group(0) @binding(${2 })      var<uniform>       scrollOffset:    ScrollOffset;
+
+@vertex fn vs(
+	vert: Vertex,
+	@builtin(instance_index) instanceIndex: u32,
+	@builtin(vertex_index) vertexIndex : u32
+) -> VSOutput {
+	let shape = shapes[instanceIndex];
+
+	var vsOut: VSOutput;
+	vsOut.position = vec4f(
+		(
+			// Top left corner
+			vec2f(-1,  1) +
+			// Convert pixel position to clipspace
+			vec2f( 2, -2) / layoutInfo.canvasDims *
+			// Shape position and size
+			(layoutInfo.viewportOffset - scrollOffset.offset + shape.position + vert.position * shape.size)
+		),
+		0.0,
+		1.0
+	);
+	vsOut.color = shape.color;
+	return vsOut;
+}
+
+@fragment fn fs(vsOut: VSOutput) -> @location(0) vec4f {
+	return vsOut.color;
+}
+`;
+export { rectangleRendererWgsl };

package/vscode/src/vs/editor/browser/gpu/taskQueue.js

@@ -0,0 +1,69 @@
+import { getActiveWindow } from '../../../base/browser/dom.js';
+import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+class TaskQueue extends Disposable {
+    constructor() {
+        super();
+        this._tasks = [];
+        this._i = 0;
+        this._register(toDisposable(() => this.clear()));
+    }
+    enqueue(task) {
+        this._tasks.push(task);
+        this._start();
+    }
+    flush() {
+        while (this._i < this._tasks.length) {
+            if (!this._tasks[this._i]()) {
+                this._i++;
+            }
+        }
+        this.clear();
+    }
+    clear() {
+        if (this._idleCallback) {
+            this._cancelCallback(this._idleCallback);
+            this._idleCallback = undefined;
+        }
+        this._i = 0;
+        this._tasks.length = 0;
+    }
+    _start() {
+        if (!this._idleCallback) {
+            this._idleCallback = this._requestCallback(this._process.bind(this));
+        }
+    }
+    _process(deadline) {
+        this._idleCallback = undefined;
+        let taskDuration = 0;
+        let longestTask = 0;
+        let lastDeadlineRemaining = deadline.timeRemaining();
+        let deadlineRemaining = 0;
+        while (this._i < this._tasks.length) {
+            taskDuration = Date.now();
+            if (!this._tasks[this._i]()) {
+                this._i++;
+            }
+            taskDuration = Math.max(1, Date.now() - taskDuration);
+            longestTask = Math.max(taskDuration, longestTask);
+            deadlineRemaining = deadline.timeRemaining();
+            if (longestTask * 1.5 > deadlineRemaining) {
+                if (lastDeadlineRemaining - taskDuration < -20) {
+                    console.warn(`task queue exceeded allotted deadline by ${Math.abs(Math.round(lastDeadlineRemaining - taskDuration))}ms`);
+                }
+                this._start();
+                return;
+            }
+            lastDeadlineRemaining = deadlineRemaining;
+        }
+        this.clear();
+    }
+}
+class IdleTaskQueue extends TaskQueue {
+    _requestCallback(callback) {
+        return getActiveWindow().requestIdleCallback(callback);
+    }
+    _cancelCallback(identifier) {
+        getActiveWindow().cancelIdleCallback(identifier);
+    }
+}
+export { IdleTaskQueue };

package/vscode/src/vs/editor/browser/gpu/viewGpuContext.js

@@ -0,0 +1,86 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { localize } from '../../../nls.js';
+import { getActiveWindow, addDisposableListener } from '../../../base/browser/dom.js';
+import { createFastDomNode } from '../../../base/browser/fastDomNode.js';
+import { BugIndicatingError } from '../../../base/common/errors.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { observableValue } from '../../../base/common/observableInternal/base.js';
+import '../../../base/common/arrays.js';
+import '../../../base/common/event.js';
+import '../../../base/common/observableInternal/autorun.js';
+import '../../../base/common/observableInternal/derived.js';
+import '../../../base/common/cancellation.js';
+import { runOnChange } from '../../../base/common/observableInternal/utils.js';
+import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
+import { TextureAtlas } from './atlas/textureAtlas.js';
+import { IConfigurationService } from '../../../platform/configuration/common/configuration.service.js';
+import '../../../platform/notification/common/notification.js';
+import { INotificationService } from '../../../platform/notification/common/notification.service.js';
+import { GPULifecycle } from './gpuDisposable.js';
+import { ensureNonNullable, observeDevicePixelDimensions } from './gpuUtils.js';
+import { RectangleRenderer } from './rectangleRenderer.js';
+import Severity$1 from '../../../base/common/severity.js';
+var ViewGpuContext_1;
+let ViewGpuContext = class ViewGpuContext extends Disposable {
+    static { ViewGpuContext_1 = this; }
+    static get atlas() {
+        if (!ViewGpuContext_1._atlas) {
+            throw ( (new BugIndicatingError('Cannot call ViewGpuContext.textureAtlas before device is resolved')));
+        }
+        return ViewGpuContext_1._atlas;
+    }
+    get atlas() {
+        return ViewGpuContext_1.atlas;
+    }
+    constructor(context, _instantiationService, _notificationService, configurationService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._notificationService = _notificationService;
+        this.configurationService = configurationService;
+        this.canvas = createFastDomNode(document.createElement('canvas'));
+        this.canvas.setClassName('editorCanvas');
+        this.ctx = ensureNonNullable(this.canvas.domNode.getContext('webgpu'));
+        this.device = GPULifecycle.requestDevice((message) => {
+            const choices = [{
+                    label: ( localize(5157, "Use DOM-based rendering")),
+                    run: () => this.configurationService.updateValue('editor.experimentalGpuAcceleration', 'off'),
+                }];
+            this._notificationService.prompt(Severity$1.Warning, message, choices);
+        }).then(ref => this._register(ref).object);
+        this.device.then(device => {
+            if (!ViewGpuContext_1._atlas) {
+                ViewGpuContext_1._atlas = this._instantiationService.createInstance(TextureAtlas, device.limits.maxTextureDimension2D, undefined);
+                runOnChange(this.devicePixelRatio, () => ViewGpuContext_1.atlas.clear());
+            }
+        });
+        this.rectangleRenderer = this._instantiationService.createInstance(RectangleRenderer, context, this.canvas.domNode, this.ctx, this.device);
+        const dprObs = observableValue(this, getActiveWindow().devicePixelRatio);
+        this._register(addDisposableListener(getActiveWindow(), 'resize', () => {
+            dprObs.set(getActiveWindow().devicePixelRatio, undefined);
+        }));
+        this.devicePixelRatio = dprObs;
+        const canvasDevicePixelDimensions = observableValue(this, { width: this.canvas.domNode.width, height: this.canvas.domNode.height });
+        this._register(observeDevicePixelDimensions(this.canvas.domNode, getActiveWindow(), (width, height) => {
+            this.canvas.domNode.width = width;
+            this.canvas.domNode.height = height;
+            canvasDevicePixelDimensions.set({ width, height }, undefined);
+        }));
+        this.canvasDevicePixelDimensions = canvasDevicePixelDimensions;
+    }
+    static canRender(options, viewportData, lineNumber) {
+        const data = viewportData.getViewLineRenderingData(lineNumber);
+        if (data.containsRTL ||
+            data.maxColumn > 200 ||
+            data.continuesWithWrappedLine ||
+            data.inlineDecorations.length > 0) {
+            return false;
+        }
+        return true;
+    }
+};
+ViewGpuContext = ViewGpuContext_1 = ( (__decorate([
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, INotificationService))),
+    ( (__param(3, IConfigurationService)))
+], ViewGpuContext)));
+export { ViewGpuContext };