BREAKING(unstable): remove WebGPU (#18094)

This PR _**temporarily**_ removes WebGPU (which has behind the
`--unstable` flag in Deno), due to performance complications due to its
presence.

It will be brought back in the future; as a point of reference, Chrome
will ship WebGPU to stable on 26/04/2023.

---------

Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>

1 files changed, 0 insertions, 1168 deletions

diff --git a/ext/webgpu/webgpu.idl b/ext/webgpu/webgpu.idl
deleted file mode 100644
index 4b8865e30..000000000
--- a/ext/webgpu/webgpu.idl
+++ /dev/null
@@ -1,1168 +0,0 @@
-interface mixin GPUObjectBase {
-    attribute USVString label;
-};
-
-dictionary GPUObjectDescriptorBase {
-    USVString label;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUSupportedLimits {
-    readonly attribute unsigned long maxTextureDimension1D;
-    readonly attribute unsigned long maxTextureDimension2D;
-    readonly attribute unsigned long maxTextureDimension3D;
-    readonly attribute unsigned long maxTextureArrayLayers;
-    readonly attribute unsigned long maxBindGroups;
-    readonly attribute unsigned long maxBindingsPerBindGroup;
-    readonly attribute unsigned long maxDynamicUniformBuffersPerPipelineLayout;
-    readonly attribute unsigned long maxDynamicStorageBuffersPerPipelineLayout;
-    readonly attribute unsigned long maxSampledTexturesPerShaderStage;
-    readonly attribute unsigned long maxSamplersPerShaderStage;
-    readonly attribute unsigned long maxStorageBuffersPerShaderStage;
-    readonly attribute unsigned long maxStorageTexturesPerShaderStage;
-    readonly attribute unsigned long maxUniformBuffersPerShaderStage;
-    readonly attribute unsigned long long maxUniformBufferBindingSize;
-    readonly attribute unsigned long long maxStorageBufferBindingSize;
-    readonly attribute unsigned long minUniformBufferOffsetAlignment;
-    readonly attribute unsigned long minStorageBufferOffsetAlignment;
-    readonly attribute unsigned long maxVertexBuffers;
-    readonly attribute unsigned long long maxBufferSize;
-    readonly attribute unsigned long maxVertexAttributes;
-    readonly attribute unsigned long maxVertexBufferArrayStride;
-    readonly attribute unsigned long maxInterStageShaderComponents;
-    readonly attribute unsigned long maxComputeWorkgroupStorageSize;
-    readonly attribute unsigned long maxComputeInvocationsPerWorkgroup;
-    readonly attribute unsigned long maxComputeWorkgroupSizeX;
-    readonly attribute unsigned long maxComputeWorkgroupSizeY;
-    readonly attribute unsigned long maxComputeWorkgroupSizeZ;
-    readonly attribute unsigned long maxComputeWorkgroupsPerDimension;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUSupportedFeatures {
-    readonly setlike<DOMString>;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUAdapterInfo {
-    readonly attribute DOMString vendor;
-    readonly attribute DOMString architecture;
-    readonly attribute DOMString device;
-    readonly attribute DOMString description;
-};
-
-interface mixin NavigatorGPU {
-    [SameObject, SecureContext] readonly attribute GPU gpu;
-};
-Navigator includes NavigatorGPU;
-WorkerNavigator includes NavigatorGPU;
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPU {
-    Promise<GPUAdapter?> requestAdapter(optional GPURequestAdapterOptions options = {});
-};
-
-dictionary GPURequestAdapterOptions {
-    GPUPowerPreference powerPreference;
-    boolean forceFallbackAdapter = false;
-};
-
-enum GPUPowerPreference {
-    "low-power",
-    "high-performance"
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUAdapter {
-    [SameObject] readonly attribute GPUSupportedFeatures features;
-    [SameObject] readonly attribute GPUSupportedLimits limits;
-    readonly attribute boolean isFallbackAdapter;
-
-    Promise<GPUDevice> requestDevice(optional GPUDeviceDescriptor descriptor = {});
-    Promise<GPUAdapterInfo> requestAdapterInfo(optional sequence<DOMString> unmaskHints = []);
-};
-
-dictionary GPUDeviceDescriptor : GPUObjectDescriptorBase {
-    sequence<GPUFeatureName> requiredFeatures = [];
-    record<DOMString, GPUSize64> requiredLimits = {};
-};
-
-enum GPUFeatureName {
-    "depth-clip-control",
-    "depth32float-stencil8",
-    "texture-compression-bc",
-    "texture-compression-etc2",
-    "texture-compression-astc",
-    "timestamp-query",
-    "indirect-first-instance",
-    "shader-f16",
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUDevice : EventTarget {
-    [SameObject] readonly attribute GPUSupportedFeatures features;
-    [SameObject] readonly attribute GPUSupportedLimits limits;
-
-    [SameObject] readonly attribute GPUQueue queue;
-
-    undefined destroy();
-
-    GPUBuffer createBuffer(GPUBufferDescriptor descriptor);
-    GPUTexture createTexture(GPUTextureDescriptor descriptor);
-    GPUSampler createSampler(optional GPUSamplerDescriptor descriptor = {});
-
-    GPUBindGroupLayout createBindGroupLayout(GPUBindGroupLayoutDescriptor descriptor);
-    GPUPipelineLayout createPipelineLayout(GPUPipelineLayoutDescriptor descriptor);
-    GPUBindGroup createBindGroup(GPUBindGroupDescriptor descriptor);
-
-    GPUShaderModule createShaderModule(GPUShaderModuleDescriptor descriptor);
-    GPUComputePipeline createComputePipeline(GPUComputePipelineDescriptor descriptor);
-    GPURenderPipeline createRenderPipeline(GPURenderPipelineDescriptor descriptor);
-    Promise<GPUComputePipeline> createComputePipelineAsync(GPUComputePipelineDescriptor descriptor);
-    Promise<GPURenderPipeline> createRenderPipelineAsync(GPURenderPipelineDescriptor descriptor);
-
-    GPUCommandEncoder createCommandEncoder(optional GPUCommandEncoderDescriptor descriptor = {});
-    GPURenderBundleEncoder createRenderBundleEncoder(GPURenderBundleEncoderDescriptor descriptor);
-
-    GPUQuerySet createQuerySet(GPUQuerySetDescriptor descriptor);
-};
-GPUDevice includes GPUObjectBase;
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUBuffer {
-    readonly attribute GPUSize64 size;
-    readonly attribute GPUBufferUsageFlags usage;
-
-    readonly attribute GPUBufferMapState mapState;
-
-    Promise<undefined> mapAsync(GPUMapModeFlags mode, optional GPUSize64 offset = 0, optional GPUSize64 size);
-    ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size);
-    undefined unmap();
-
-    undefined destroy();
-};
-GPUBuffer includes GPUObjectBase;
-
-enum GPUBufferMapState {
-    "unmapped",
-    "pending",
-    "mapped"
-};
-
-dictionary GPUBufferDescriptor : GPUObjectDescriptorBase {
-    required GPUSize64 size;
-    required GPUBufferUsageFlags usage;
-    boolean mappedAtCreation = false;
-};
-
-typedef [EnforceRange] unsigned long GPUBufferUsageFlags;
-[Exposed=(Window, DedicatedWorker)]
-namespace GPUBufferUsage {
-    const GPUFlagsConstant MAP_READ      = 0x0001;
-    const GPUFlagsConstant MAP_WRITE     = 0x0002;
-    const GPUFlagsConstant COPY_SRC      = 0x0004;
-    const GPUFlagsConstant COPY_DST      = 0x0008;
-    const GPUFlagsConstant INDEX         = 0x0010;
-    const GPUFlagsConstant VERTEX        = 0x0020;
-    const GPUFlagsConstant UNIFORM       = 0x0040;
-    const GPUFlagsConstant STORAGE       = 0x0080;
-    const GPUFlagsConstant INDIRECT      = 0x0100;
-    const GPUFlagsConstant QUERY_RESOLVE = 0x0200;
-};
-
-typedef [EnforceRange] unsigned long GPUMapModeFlags;
-[Exposed=(Window, DedicatedWorker)]
-namespace GPUMapMode {
-    const GPUFlagsConstant READ  = 0x0001;
-    const GPUFlagsConstant WRITE = 0x0002;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUTexture {
-    GPUTextureView createView(optional GPUTextureViewDescriptor descriptor = {});
-
-    undefined destroy();
-
-    readonly attribute GPUIntegerCoordinate width;
-    readonly attribute GPUIntegerCoordinate height;
-    readonly attribute GPUIntegerCoordinate depthOrArrayLayers;
-    readonly attribute GPUIntegerCoordinate mipLevelCount;
-    readonly attribute GPUSize32 sampleCount;
-    readonly attribute GPUTextureDimension dimension;
-    readonly attribute GPUTextureFormat format;
-    readonly attribute GPUTextureUsageFlags usage;
-};
-GPUTexture includes GPUObjectBase;
-
-dictionary GPUTextureDescriptor : GPUObjectDescriptorBase {
-    required GPUExtent3D size;
-    GPUIntegerCoordinate mipLevelCount = 1;
-    GPUSize32 sampleCount = 1;
-    GPUTextureDimension dimension = "2d";
-    required GPUTextureFormat format;
-    required GPUTextureUsageFlags usage;
-    sequence<GPUTextureFormat> viewFormats = [];
-};
-
-enum GPUTextureDimension {
-    "1d",
-    "2d",
-    "3d"
-};
-
-typedef [EnforceRange] unsigned long GPUTextureUsageFlags;
-[Exposed=(Window, DedicatedWorker)]
-namespace GPUTextureUsage {
-    const GPUFlagsConstant COPY_SRC          = 0x01;
-    const GPUFlagsConstant COPY_DST          = 0x02;
-    const GPUFlagsConstant TEXTURE_BINDING   = 0x04;
-    const GPUFlagsConstant STORAGE_BINDING   = 0x08;
-    const GPUFlagsConstant RENDER_ATTACHMENT = 0x10;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUTextureView {
-};
-GPUTextureView includes GPUObjectBase;
-
-dictionary GPUTextureViewDescriptor : GPUObjectDescriptorBase {
-    GPUTextureFormat format;
-    GPUTextureViewDimension dimension;
-    GPUTextureAspect aspect = "all";
-    GPUIntegerCoordinate baseMipLevel = 0;
-    GPUIntegerCoordinate mipLevelCount;
-    GPUIntegerCoordinate baseArrayLayer = 0;
-    GPUIntegerCoordinate arrayLayerCount;
-};
-
-enum GPUTextureViewDimension {
-    "1d",
-    "2d",
-    "2d-array",
-    "cube",
-    "cube-array",
-    "3d"
-};
-
-enum GPUTextureAspect {
-    "all",
-    "stencil-only",
-    "depth-only"
-};
-
-enum GPUTextureFormat {
-    // 8-bit formats
-    "r8unorm",
-    "r8snorm",
-    "r8uint",
-    "r8sint",
-
-    // 16-bit formats
-    "r16uint",
-    "r16sint",
-    "r16float",
-    "rg8unorm",
-    "rg8snorm",
-    "rg8uint",
-    "rg8sint",
-
-    // 32-bit formats
-    "r32uint",
-    "r32sint",
-    "r32float",
-    "rg16uint",
-    "rg16sint",
-    "rg16float",
-    "rgba8unorm",
-    "rgba8unorm-srgb",
-    "rgba8snorm",
-    "rgba8uint",
-    "rgba8sint",
-    "bgra8unorm",
-    "bgra8unorm-srgb",
-    // Packed 32-bit formats
-    "rgb9e5ufloat",
-    "rgb10a2unorm",
-    "rg11b10ufloat",
-
-    // 64-bit formats
-    "rg32uint",
-    "rg32sint",
-    "rg32float",
-    "rgba16uint",
-    "rgba16sint",
-    "rgba16float",
-
-    // 128-bit formats
-    "rgba32uint",
-    "rgba32sint",
-    "rgba32float",
-
-    // Depth/stencil formats
-    "stencil8",
-    "depth16unorm",
-    "depth24plus",
-    "depth24plus-stencil8",
-    "depth32float",
-
-    // "depth32float-stencil8" feature
-    "depth32float-stencil8",
-
-    // BC compressed formats usable if "texture-compression-bc" is both
-    // supported by the device/user agent and enabled in requestDevice.
-    "bc1-rgba-unorm",
-    "bc1-rgba-unorm-srgb",
-    "bc2-rgba-unorm",
-    "bc2-rgba-unorm-srgb",
-    "bc3-rgba-unorm",
-    "bc3-rgba-unorm-srgb",
-    "bc4-r-unorm",
-    "bc4-r-snorm",
-    "bc5-rg-unorm",
-    "bc5-rg-snorm",
-    "bc6h-rgb-ufloat",
-    "bc6h-rgb-float",
-    "bc7-rgba-unorm",
-    "bc7-rgba-unorm-srgb",
-
-    // ETC2 compressed formats usable if "texture-compression-etc2" is both
-    // supported by the device/user agent and enabled in requestDevice.
-    "etc2-rgb8unorm",
-    "etc2-rgb8unorm-srgb",
-    "etc2-rgb8a1unorm",
-    "etc2-rgb8a1unorm-srgb",
-    "etc2-rgba8unorm",
-    "etc2-rgba8unorm-srgb",
-    "eac-r11unorm",
-    "eac-r11snorm",
-    "eac-rg11unorm",
-    "eac-rg11snorm",
-
-    // ASTC compressed formats usable if "texture-compression-astc" is both
-    // supported by the device/user agent and enabled in requestDevice.
-    "astc-4x4-unorm",
-    "astc-4x4-unorm-srgb",
-    "astc-5x4-unorm",
-    "astc-5x4-unorm-srgb",
-    "astc-5x5-unorm",
-    "astc-5x5-unorm-srgb",
-    "astc-6x5-unorm",
-    "astc-6x5-unorm-srgb",
-    "astc-6x6-unorm",
-    "astc-6x6-unorm-srgb",
-    "astc-8x5-unorm",
-    "astc-8x5-unorm-srgb",
-    "astc-8x6-unorm",
-    "astc-8x6-unorm-srgb",
-    "astc-8x8-unorm",
-    "astc-8x8-unorm-srgb",
-    "astc-10x5-unorm",
-    "astc-10x5-unorm-srgb",
-    "astc-10x6-unorm",
-    "astc-10x6-unorm-srgb",
-    "astc-10x8-unorm",
-    "astc-10x8-unorm-srgb",
-    "astc-10x10-unorm",
-    "astc-10x10-unorm-srgb",
-    "astc-12x10-unorm",
-    "astc-12x10-unorm-srgb",
-    "astc-12x12-unorm",
-    "astc-12x12-unorm-srgb"
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUSampler {
-};
-GPUSampler includes GPUObjectBase;
-
-dictionary GPUSamplerDescriptor : GPUObjectDescriptorBase {
-    GPUAddressMode addressModeU = "clamp-to-edge";
-    GPUAddressMode addressModeV = "clamp-to-edge";
-    GPUAddressMode addressModeW = "clamp-to-edge";
-    GPUFilterMode magFilter = "nearest";
-    GPUFilterMode minFilter = "nearest";
-    GPUMipmapFilterMode mipmapFilter = "nearest";
-    float lodMinClamp = 0;
-    float lodMaxClamp = 32;
-    GPUCompareFunction compare;
-    [Clamp] unsigned short maxAnisotropy = 1;
-};
-
-enum GPUAddressMode {
-    "clamp-to-edge",
-    "repeat",
-    "mirror-repeat"
-};
-
-enum GPUFilterMode {
-    "nearest",
-    "linear"
-};
-
-enum GPUMipmapFilterMode {
-    "nearest",
-    "linear"
-};
-
-enum GPUCompareFunction {
-    "never",
-    "less",
-    "equal",
-    "less-equal",
-    "greater",
-    "not-equal",
-    "greater-equal",
-    "always"
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUBindGroupLayout {
-};
-GPUBindGroupLayout includes GPUObjectBase;
-
-dictionary GPUBindGroupLayoutDescriptor : GPUObjectDescriptorBase {
-    required sequence<GPUBindGroupLayoutEntry> entries;
-};
-
-dictionary GPUBindGroupLayoutEntry {
-    required GPUIndex32 binding;
-    required GPUShaderStageFlags visibility;
-
-    GPUBufferBindingLayout buffer;
-    GPUSamplerBindingLayout sampler;
-    GPUTextureBindingLayout texture;
-    GPUStorageTextureBindingLayout storageTexture;
-};
-
-typedef [EnforceRange] unsigned long GPUShaderStageFlags;
-[Exposed=(Window, DedicatedWorker)]
-namespace GPUShaderStage {
-    const GPUFlagsConstant VERTEX   = 0x1;
-    const GPUFlagsConstant FRAGMENT = 0x2;
-    const GPUFlagsConstant COMPUTE  = 0x4;
-};
-
-enum GPUBufferBindingType {
-    "uniform",
-    "storage",
-    "read-only-storage"
-};
-
-dictionary GPUBufferBindingLayout {
-    GPUBufferBindingType type = "uniform";
-    boolean hasDynamicOffset = false;
-    GPUSize64 minBindingSize = 0;
-};
-
-enum GPUSamplerBindingType {
-    "filtering",
-    "non-filtering",
-    "comparison"
-};
-
-dictionary GPUSamplerBindingLayout {
-    GPUSamplerBindingType type = "filtering";
-};
-
-enum GPUTextureSampleType {
-    "float",
-    "unfilterable-float",
-    "depth",
-    "sint",
-    "uint"
-};
-
-dictionary GPUTextureBindingLayout {
-    GPUTextureSampleType sampleType = "float";
-    GPUTextureViewDimension viewDimension = "2d";
-    boolean multisampled = false;
-};
-
-enum GPUStorageTextureAccess {
-    "write-only"
-};
-
-dictionary GPUStorageTextureBindingLayout {
-    GPUStorageTextureAccess access = "write-only";
-    required GPUTextureFormat format;
-    GPUTextureViewDimension viewDimension = "2d";
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUBindGroup {
-};
-GPUBindGroup includes GPUObjectBase;
-
-dictionary GPUBindGroupDescriptor : GPUObjectDescriptorBase {
-    required GPUBindGroupLayout layout;
-    required sequence<GPUBindGroupEntry> entries;
-};
-
-typedef (GPUSampler or GPUTextureView or GPUBufferBinding) GPUBindingResource;
-
-dictionary GPUBindGroupEntry {
-    required GPUIndex32 binding;
-    required GPUBindingResource resource;
-};
-
-dictionary GPUBufferBinding {
-    required GPUBuffer buffer;
-    GPUSize64 offset = 0;
-    GPUSize64 size;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUPipelineLayout {
-};
-GPUPipelineLayout includes GPUObjectBase;
-
-dictionary GPUPipelineLayoutDescriptor : GPUObjectDescriptorBase {
-    required sequence<GPUBindGroupLayout> bindGroupLayouts;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUShaderModule {
-    Promise<GPUCompilationInfo> compilationInfo();
-};
-GPUShaderModule includes GPUObjectBase;
-
-dictionary GPUShaderModuleDescriptor : GPUObjectDescriptorBase {
-    required USVString code;
-};
-
-enum GPUCompilationMessageType {
-    "error",
-    "warning",
-    "info"
-};
-
-[Exposed=(Window, DedicatedWorker), Serializable, SecureContext]
-interface GPUCompilationMessage {
-    readonly attribute DOMString message;
-    readonly attribute GPUCompilationMessageType type;
-    readonly attribute unsigned long long lineNum;
-    readonly attribute unsigned long long linePos;
-    readonly attribute unsigned long long offset;
-    readonly attribute unsigned long long length;
-};
-
-[Exposed=(Window, DedicatedWorker), Serializable, SecureContext]
-interface GPUCompilationInfo {
-    readonly attribute FrozenArray<GPUCompilationMessage> messages;
-};
-
-enum GPUAutoLayoutMode {
-    "auto"
-};
-
-dictionary GPUPipelineDescriptorBase : GPUObjectDescriptorBase {
-    required (GPUPipelineLayout or GPUAutoLayoutMode) layout;
-};
-
-interface mixin GPUPipelineBase {
-    [NewObject] GPUBindGroupLayout getBindGroupLayout(unsigned long index);
-};
-
-dictionary GPUProgrammableStage {
-    required GPUShaderModule module;
-    required USVString entryPoint;
-    record<USVString, GPUPipelineConstantValue> constants;
-};
-
-typedef double GPUPipelineConstantValue; // May represent WGSL’s bool, f32, i32, u32, and f16 if enabled.
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUComputePipeline {
-};
-GPUComputePipeline includes GPUObjectBase;
-GPUComputePipeline includes GPUPipelineBase;
-
-dictionary GPUComputePipelineDescriptor : GPUPipelineDescriptorBase {
-    required GPUProgrammableStage compute;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPURenderPipeline {
-};
-GPURenderPipeline includes GPUObjectBase;
-GPURenderPipeline includes GPUPipelineBase;
-
-dictionary GPURenderPipelineDescriptor : GPUPipelineDescriptorBase {
-    required GPUVertexState vertex;
-    GPUPrimitiveState primitive = {};
-    GPUDepthStencilState depthStencil;
-    GPUMultisampleState multisample = {};
-    GPUFragmentState fragment;
-};
-
-dictionary GPUPrimitiveState {
-    GPUPrimitiveTopology topology = "triangle-list";
-    GPUIndexFormat stripIndexFormat;
-    GPUFrontFace frontFace = "ccw";
-    GPUCullMode cullMode = "none";
-
-    // Requires "depth-clip-control" feature.
-    boolean unclippedDepth = false;
-};
-
-enum GPUPrimitiveTopology {
-    "point-list",
-    "line-list",
-    "line-strip",
-    "triangle-list",
-    "triangle-strip"
-};
-
-enum GPUFrontFace {
-    "ccw",
-    "cw"
-};
-
-enum GPUCullMode {
-    "none",
-    "front",
-    "back"
-};
-
-dictionary GPUMultisampleState {
-    GPUSize32 count = 1;
-    GPUSampleMask mask = 0xFFFFFFFF;
-    boolean alphaToCoverageEnabled = false;
-};
-
-dictionary GPUFragmentState : GPUProgrammableStage {
-    required sequence<GPUColorTargetState?> targets;
-};
-
-dictionary GPUColorTargetState {
-    required GPUTextureFormat format;
-
-    GPUBlendState blend;
-    GPUColorWriteFlags writeMask = 0xF;  // GPUColorWrite.ALL
-};
-
-dictionary GPUBlendState {
-    required GPUBlendComponent color;
-    required GPUBlendComponent alpha;
-};
-
-typedef [EnforceRange] unsigned long GPUColorWriteFlags;
-[Exposed=(Window, DedicatedWorker)]
-namespace GPUColorWrite {
-    const GPUFlagsConstant RED   = 0x1;
-    const GPUFlagsConstant GREEN = 0x2;
-    const GPUFlagsConstant BLUE  = 0x4;
-    const GPUFlagsConstant ALPHA = 0x8;
-    const GPUFlagsConstant ALL   = 0xF;
-};
-
-dictionary GPUBlendComponent {
-    GPUBlendOperation operation = "add";
-    GPUBlendFactor srcFactor = "one";
-    GPUBlendFactor dstFactor = "zero";
-};
-
-enum GPUBlendFactor {
-    "zero",
-    "one",
-    "src",
-    "one-minus-src",
-    "src-alpha",
-    "one-minus-src-alpha",
-    "dst",
-    "one-minus-dst",
-    "dst-alpha",
-    "one-minus-dst-alpha",
-    "src-alpha-saturated",
-    "constant",
-    "one-minus-constant"
-};
-
-enum GPUBlendOperation {
-    "add",
-    "subtract",
-    "reverse-subtract",
-    "min",
-    "max"
-};
-
-dictionary GPUDepthStencilState {
-    required GPUTextureFormat format;
-
-    boolean depthWriteEnabled = false;
-    GPUCompareFunction depthCompare = "always";
-
-    GPUStencilFaceState stencilFront = {};
-    GPUStencilFaceState stencilBack = {};
-
-    GPUStencilValue stencilReadMask = 0xFFFFFFFF;
-    GPUStencilValue stencilWriteMask = 0xFFFFFFFF;
-
-    GPUDepthBias depthBias = 0;
-    float depthBiasSlopeScale = 0;
-    float depthBiasClamp = 0;
-};
-
-dictionary GPUStencilFaceState {
-    GPUCompareFunction compare = "always";
-    GPUStencilOperation failOp = "keep";
-    GPUStencilOperation depthFailOp = "keep";
-    GPUStencilOperation passOp = "keep";
-};
-
-enum GPUStencilOperation {
-    "keep",
-    "zero",
-    "replace",
-    "invert",
-    "increment-clamp",
-    "decrement-clamp",
-    "increment-wrap",
-    "decrement-wrap"
-};
-
-enum GPUIndexFormat {
-    "uint16",
-    "uint32"
-};
-
-enum GPUVertexFormat {
-    "uint8x2",
-    "uint8x4",
-    "sint8x2",
-    "sint8x4",
-    "unorm8x2",
-    "unorm8x4",
-    "snorm8x2",
-    "snorm8x4",
-    "uint16x2",
-    "uint16x4",
-    "sint16x2",
-    "sint16x4",
-    "unorm16x2",
-    "unorm16x4",
-    "snorm16x2",
-    "snorm16x4",
-    "float16x2",
-    "float16x4",
-    "float32",
-    "float32x2",
-    "float32x3",
-    "float32x4",
-    "uint32",
-    "uint32x2",
-    "uint32x3",
-    "uint32x4",
-    "sint32",
-    "sint32x2",
-    "sint32x3",
-    "sint32x4"
-};
-
-enum GPUVertexStepMode {
-    "vertex",
-    "instance"
-};
-
-dictionary GPUVertexState : GPUProgrammableStage {
-    sequence<GPUVertexBufferLayout?> buffers = [];
-};
-
-dictionary GPUVertexBufferLayout {
-    required GPUSize64 arrayStride;
-    GPUVertexStepMode stepMode = "vertex";
-    required sequence<GPUVertexAttribute> attributes;
-};
-
-dictionary GPUVertexAttribute {
-    required GPUVertexFormat format;
-    required GPUSize64 offset;
-
-    required GPUIndex32 shaderLocation;
-};
-
-dictionary GPUImageDataLayout {
-    GPUSize64 offset = 0;
-    GPUSize32 bytesPerRow;
-    GPUSize32 rowsPerImage;
-};
-
-dictionary GPUImageCopyBuffer : GPUImageDataLayout {
-    required GPUBuffer buffer;
-};
-
-dictionary GPUImageCopyTexture {
-    required GPUTexture texture;
-    GPUIntegerCoordinate mipLevel = 0;
-    GPUOrigin3D origin = {};
-    GPUTextureAspect aspect = "all";
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUCommandBuffer {
-};
-GPUCommandBuffer includes GPUObjectBase;
-
-dictionary GPUCommandBufferDescriptor : GPUObjectDescriptorBase {
-};
-
-interface mixin GPUCommandsMixin {
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUCommandEncoder {
-    GPURenderPassEncoder beginRenderPass(GPURenderPassDescriptor descriptor);
-    GPUComputePassEncoder beginComputePass(optional GPUComputePassDescriptor descriptor = {});
-
-    undefined copyBufferToBuffer(
-        GPUBuffer source,
-        GPUSize64 sourceOffset,
-        GPUBuffer destination,
-        GPUSize64 destinationOffset,
-        GPUSize64 size);
-
-    undefined copyBufferToTexture(
-        GPUImageCopyBuffer source,
-        GPUImageCopyTexture destination,
-        GPUExtent3D copySize);
-
-    undefined copyTextureToBuffer(
-        GPUImageCopyTexture source,
-        GPUImageCopyBuffer destination,
-        GPUExtent3D copySize);
-
-    undefined copyTextureToTexture(
-        GPUImageCopyTexture source,
-        GPUImageCopyTexture destination,
-        GPUExtent3D copySize);
-
-    undefined clearBuffer(
-        GPUBuffer buffer,
-        optional GPUSize64 offset = 0,
-        optional GPUSize64 size);
-
-    undefined writeTimestamp(GPUQuerySet querySet, GPUSize32 queryIndex);
-
-    undefined resolveQuerySet(
-        GPUQuerySet querySet,
-        GPUSize32 firstQuery,
-        GPUSize32 queryCount,
-        GPUBuffer destination,
-        GPUSize64 destinationOffset);
-
-    GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {});
-};
-GPUCommandEncoder includes GPUObjectBase;
-GPUCommandEncoder includes GPUCommandsMixin;
-GPUCommandEncoder includes GPUDebugCommandsMixin;
-
-dictionary GPUCommandEncoderDescriptor : GPUObjectDescriptorBase {
-};
-
-interface mixin GPUBindingCommandsMixin {
-    undefined setBindGroup(GPUIndex32 index, GPUBindGroup bindGroup,
-        optional sequence<GPUBufferDynamicOffset> dynamicOffsets = []);
-
-    undefined setBindGroup(GPUIndex32 index, GPUBindGroup bindGroup,
-        Uint32Array dynamicOffsetsData,
-        GPUSize64 dynamicOffsetsDataStart,
-        GPUSize32 dynamicOffsetsDataLength);
-};
-
-interface mixin GPUDebugCommandsMixin {
-    undefined pushDebugGroup(USVString groupLabel);
-    undefined popDebugGroup();
-    undefined insertDebugMarker(USVString markerLabel);
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUComputePassEncoder {
-    undefined setPipeline(GPUComputePipeline pipeline);
-    undefined dispatchWorkgroups(GPUSize32 workgroupCountX, optional GPUSize32 workgroupCountY = 1, optional GPUSize32 workgroupCountZ = 1);
-    undefined dispatchWorkgroupsIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
-
-    undefined beginPipelineStatisticsQuery(GPUQuerySet querySet, GPUSize32 queryIndex);
-    undefined endPipelineStatisticsQuery();
-
-    undefined writeTimestamp(GPUQuerySet querySet, GPUSize32 queryIndex);
-
-    undefined end();
-};
-GPUComputePassEncoder includes GPUObjectBase;
-GPUComputePassEncoder includes GPUCommandsMixin;
-GPUComputePassEncoder includes GPUDebugCommandsMixin;
-GPUComputePassEncoder includes GPUBindingCommandsMixin;
-
-dictionary GPUComputePassDescriptor : GPUObjectDescriptorBase {
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPURenderPassEncoder {
-    undefined setViewport(float x, float y,
-        float width, float height,
-        float minDepth, float maxDepth);
-
-    undefined setScissorRect(GPUIntegerCoordinate x, GPUIntegerCoordinate y,
-                        GPUIntegerCoordinate width, GPUIntegerCoordinate height);
-
-    undefined setBlendConstant(GPUColor color);
-    undefined setStencilReference(GPUStencilValue reference);
-
-    undefined beginOcclusionQuery(GPUSize32 queryIndex);
-    undefined endOcclusionQuery();
-
-    undefined beginPipelineStatisticsQuery(GPUQuerySet querySet, GPUSize32 queryIndex);
-    undefined endPipelineStatisticsQuery();
-
-    undefined writeTimestamp(GPUQuerySet querySet, GPUSize32 queryIndex);
-
-    undefined executeBundles(sequence<GPURenderBundle> bundles);
-    undefined end();
-};
-GPURenderPassEncoder includes GPUObjectBase;
-GPURenderPassEncoder includes GPUCommandsMixin;
-GPURenderPassEncoder includes GPUDebugCommandsMixin;
-GPURenderPassEncoder includes GPUBindingCommandsMixin;
-GPURenderPassEncoder includes GPURenderCommandsMixin;
-
-dictionary GPURenderPassDescriptor : GPUObjectDescriptorBase {
-    required sequence<GPURenderPassColorAttachment?> colorAttachments;
-    GPURenderPassDepthStencilAttachment depthStencilAttachment;
-};
-
-dictionary GPURenderPassColorAttachment {
-    required GPUTextureView view;
-    GPUTextureView resolveTarget;
-
-    GPUColor clearValue;
-    required GPULoadOp loadOp;
-    required GPUStoreOp storeOp;
-};
-
-dictionary GPURenderPassDepthStencilAttachment {
-    required GPUTextureView view;
-
-    float depthClearValue = 0;
-    GPULoadOp depthLoadOp;
-    GPUStoreOp depthStoreOp;
-    boolean depthReadOnly = false;
-
-    GPUStencilValue stencilClearValue = 0;
-    GPULoadOp stencilLoadOp;
-    GPUStoreOp stencilStoreOp;
-    boolean stencilReadOnly = false;
-};
-
-enum GPULoadOp {
-    "load",
-    "clear"
-};
-
-enum GPUStoreOp {
-    "store",
-    "discard"
-};
-
-dictionary GPURenderPassLayout : GPUObjectDescriptorBase {
-    required sequence<GPUTextureFormat?> colorFormats;
-    GPUTextureFormat depthStencilFormat;
-    GPUSize32 sampleCount = 1;
-};
-
-interface mixin GPURenderCommandsMixin {
-    undefined setPipeline(GPURenderPipeline pipeline);
-
-    undefined setIndexBuffer(GPUBuffer buffer, GPUIndexFormat indexFormat, optional GPUSize64 offset = 0, optional GPUSize64 size);
-    undefined setVertexBuffer(GPUIndex32 slot, GPUBuffer buffer, optional GPUSize64 offset = 0, optional GPUSize64 size);
-
-    undefined draw(GPUSize32 vertexCount, optional GPUSize32 instanceCount = 1,
-        optional GPUSize32 firstVertex = 0, optional GPUSize32 firstInstance = 0);
-    undefined drawIndexed(GPUSize32 indexCount, optional GPUSize32 instanceCount = 1,
-        optional GPUSize32 firstIndex = 0,
-        optional GPUSignedOffset32 baseVertex = 0,
-        optional GPUSize32 firstInstance = 0);
-
-    undefined drawIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
-    undefined drawIndexedIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPURenderBundle {
-};
-GPURenderBundle includes GPUObjectBase;
-
-dictionary GPURenderBundleDescriptor : GPUObjectDescriptorBase {
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPURenderBundleEncoder {
-    GPURenderBundle finish(optional GPURenderBundleDescriptor descriptor = {});
-};
-GPURenderBundleEncoder includes GPUObjectBase;
-GPURenderBundleEncoder includes GPUCommandsMixin;
-GPURenderBundleEncoder includes GPUDebugCommandsMixin;
-GPURenderBundleEncoder includes GPUBindingCommandsMixin;
-GPURenderBundleEncoder includes GPURenderCommandsMixin;
-
-dictionary GPURenderBundleEncoderDescriptor : GPURenderPassLayout {
-    boolean depthReadOnly = false;
-    boolean stencilReadOnly = false;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUQueue {
-    undefined submit(sequence<GPUCommandBuffer> commandBuffers);
-
-    Promise<undefined> onSubmittedWorkDone();
-
-    undefined writeBuffer(
-        GPUBuffer buffer,
-        GPUSize64 bufferOffset,
-        [AllowShared] BufferSource data,
-        optional GPUSize64 dataOffset = 0,
-        optional GPUSize64 size);
-
-    undefined writeTexture(
-        GPUImageCopyTexture destination,
-        [AllowShared] BufferSource data,
-        GPUImageDataLayout dataLayout,
-        GPUExtent3D size);
-};
-GPUQueue includes GPUObjectBase;
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUQuerySet {
-    undefined destroy();
-
-    readonly attribute GPUQueryType type;
-    readonly attribute GPUSize32 count;
-};
-GPUQuerySet includes GPUObjectBase;
-
-dictionary GPUQuerySetDescriptor : GPUObjectDescriptorBase {
-    required GPUQueryType type;
-    required GPUSize32 count;
-    sequence<GPUPipelineStatisticName> pipelineStatistics = [];
-};
-
-enum GPUQueryType {
-    "occlusion",
-    "pipeline-statistics",
-    "timestamp"
-};
-
-enum GPUPipelineStatisticName {
-    "vertex-shader-invocations",
-    "clipper-invocations",
-    "clipper-primitives-out",
-    "fragment-shader-invocations",
-    "compute-shader-invocations",
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUCanvasContext {
-    readonly attribute (HTMLCanvasElement or OffscreenCanvas) canvas;
-
-    undefined configure(GPUCanvasConfiguration configuration);
-    undefined unconfigure();
-
-    GPUTexture getCurrentTexture();
-};
-
-enum GPUCanvasAlphaMode {
-    "opaque",
-    "premultiplied"
-};
-
-dictionary GPUCanvasConfiguration {
-    required GPUDevice device;
-    required GPUTextureFormat format;
-    GPUTextureUsageFlags usage = 0x10;  // GPUTextureUsage.RENDER_ATTACHMENT
-    GPUCanvasAlphaMode alphaMode = "opaque";
-    sequence<GPUTextureFormat> viewFormats = [];
-};
-
-enum GPUDeviceLostReason {
-    "destroyed"
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUDeviceLostInfo {
-    readonly attribute (GPUDeviceLostReason or undefined) reason;
-    readonly attribute DOMString message;
-};
-
-partial interface GPUDevice {
-    readonly attribute Promise<GPUDeviceLostInfo> lost;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUError {
-    readonly attribute DOMString message;
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUValidationError : GPUError {
-    constructor(DOMString message);
-};
-
-[Exposed=(Window, DedicatedWorker), SecureContext]
-interface GPUOutOfMemoryError : GPUError {
-    constructor(DOMString message);
-};
-
-enum GPUErrorFilter {
-    "validation",
-    "out-of-memory"
-};
-
-partial interface GPUDevice {
-    undefined pushErrorScope(GPUErrorFilter filter);
-    Promise<GPUError?> popErrorScope();
-};
-
-partial interface GPUDevice {
-    [Exposed=(Window, DedicatedWorker)]
-    attribute EventHandler onuncapturederror;
-};
-
-typedef [EnforceRange] unsigned long GPUBufferDynamicOffset;
-typedef [EnforceRange] unsigned long GPUStencilValue;
-typedef [EnforceRange] unsigned long GPUSampleMask;
-typedef [EnforceRange] long GPUDepthBias;
-
-typedef [EnforceRange] unsigned long long GPUSize64;
-typedef [EnforceRange] unsigned long GPUIntegerCoordinate;
-typedef [EnforceRange] unsigned long GPUIndex32;
-typedef [EnforceRange] unsigned long GPUSize32;
-typedef [EnforceRange] long GPUSignedOffset32;
-
-typedef unsigned long GPUFlagsConstant;
-
-dictionary GPUColorDict {
-    required double r;
-    required double g;
-    required double b;
-    required double a;
-};
-typedef (sequence<double> or GPUColorDict) GPUColor;
-
-dictionary GPUOrigin2DDict {
-    GPUIntegerCoordinate x = 0;
-    GPUIntegerCoordinate y = 0;
-};
-typedef (sequence<GPUIntegerCoordinate> or GPUOrigin2DDict) GPUOrigin2D;
-
-dictionary GPUOrigin3DDict {
-    GPUIntegerCoordinate x = 0;
-    GPUIntegerCoordinate y = 0;
-    GPUIntegerCoordinate z = 0;
-};
-typedef (sequence<GPUIntegerCoordinate> or GPUOrigin3DDict) GPUOrigin3D;
-
-dictionary GPUExtent3DDict {
-    required GPUIntegerCoordinate width;
-    GPUIntegerCoordinate height = 1;
-    GPUIntegerCoordinate depthOrArrayLayers = 1;
-};
-typedef (sequence<GPUIntegerCoordinate> or GPUExtent3DDict) GPUExtent3D;