@luma.gl/webgl 9.0.0-beta.5 → 9.0.0-beta.6

package/dist/adapter/converters/device-parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/device-parameters.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,MAAM,EACN,UAAU,EACV,eAAe,EAMhB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,KAAK,EAAmC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAOvF;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,OAAO,EACnD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAiBH;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAC1C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,OAAO,EAC9C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,QA6GzE;AAyBD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,EAAE,CAWpF;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,eAAe,CAWtF"}
+{"version":3,"file":"device-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/device-parameters.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,MAAM,EACN,UAAU,EACV,eAAe,EAMhB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,KAAK,EAAmC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAOvF;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,OAAO,EACnD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAiBH;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAC1C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,OAAO,EAC9C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,QAkMzE;AAyBD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,EAAE,CAWpF;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,eAAe,CAWtF"}

package/dist/adapter/converters/device-parameters.js

@@ -1,10 +1,11 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { log, isObjectEmpty } from '@luma.gl/core';
 import { GL } from '@luma.gl/constants';
-import { pushContextState, popContextState } from '../../context/state-tracker/track-context-state';
-import { setGLParameters } from '../../context/parameters/unified-parameter-api';
-import { WebGLDevice } from '../webgl-device';
+import { pushContextState, popContextState } from "../../context/state-tracker/track-context-state.js";
+import { setGLParameters } from "../../context/parameters/unified-parameter-api.js";
+import { WebGLDevice } from "../webgl-device.js";
 /* eslint-disable no-unused-expressions */ // For expression ? gl.enable() : gl.disable()
 /**
  * Execute a function with a set of temporary WebGL parameter overrides
@@ -109,12 +110,71 @@ export function setDeviceParameters(device, parameters) {
             cw: GL.CW
         }));
     }
+    if (parameters.unclippedDepth) {
+        if (device.features.has('depth-clip-control')) {
+            // EXT_depth_clamp
+            gl.enable(GL.DEPTH_CLAMP_EXT);
+        }
+    }
     if (parameters.depthBias !== undefined) {
         gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
     }
     // depthBiasSlopeScale: {
     //   // Handled by depthBias
     // },
+    // WEBGL EXTENSIONS
+    if (device.features.has('provoking-vertex-webgl')) {
+        const extensions = webglDevice.getExtension('WEBGL_provoking_vertex');
+        const ext = extensions.WEBGL_provoking_vertex;
+        if (parameters.provokingVertex) {
+            const vertex = map('provokingVertex', parameters.provokingVertex, {
+                first: GL.FIRST_VERTEX_CONVENTION_WEBGL,
+                last: GL.LAST_VERTEX_CONVENTION_WEBGL
+            });
+            ext?.provokingVertexWEBGL(vertex);
+        }
+    }
+    if (device.features.has('polygon-mode-webgl')) {
+        const extensions = webglDevice.getExtension('WEBGL_polygon_mode');
+        const ext = extensions.WEBGL_polygon_mode;
+        if (parameters.polygonMode) {
+            const mode = map('polygonMode', parameters.provokingVertex, {
+                fill: GL.FILL_WEBGL,
+                lint: GL.LINE_WEBGL
+            });
+            ext?.polygonModeWEBGL(GL.FRONT, mode);
+            ext?.polygonModeWEBGL(GL.BACK, mode);
+        }
+        if (parameters.polygonOffsetLine) {
+            gl.enable(GL.POLYGON_OFFSET_LINE_WEBGL);
+        }
+    }
+    if (device.features.has('shader-clip-cull-distance-webgl')) {
+        if (parameters.clipDistance0) {
+            gl.enable(GL.CLIP_DISTANCE0_WEBGL);
+        }
+        if (parameters.clipDistance1) {
+            gl.enable(GL.CLIP_DISTANCE1_WEBGL);
+        }
+        if (parameters.clipDistance2) {
+            gl.enable(GL.CLIP_DISTANCE2_WEBGL);
+        }
+        if (parameters.clipDistance3) {
+            gl.enable(GL.CLIP_DISTANCE3_WEBGL);
+        }
+        if (parameters.clipDistance4) {
+            gl.enable(GL.CLIP_DISTANCE4_WEBGL);
+        }
+        if (parameters.clipDistance5) {
+            gl.enable(GL.CLIP_DISTANCE5_WEBGL);
+        }
+        if (parameters.clipDistance6) {
+            gl.enable(GL.CLIP_DISTANCE6_WEBGL);
+        }
+        if (parameters.clipDistance7) {
+            gl.enable(GL.CLIP_DISTANCE7_WEBGL);
+        }
+    }
     // DEPTH STENCIL
     if (parameters.depthWriteEnabled !== undefined) {
         gl.depthMask(mapBoolean('depthWriteEnabled', parameters.depthWriteEnabled));
@@ -230,17 +290,17 @@ function convertStencilOperation(parameter, value) {
 }
 function convertBlendOperationToEquation(parameter, value) {
     return map(parameter, value, {
-        'add': GL.FUNC_ADD,
-        'subtract': GL.FUNC_SUBTRACT,
+        add: GL.FUNC_ADD,
+        subtract: GL.FUNC_SUBTRACT,
         'reverse-subtract': GL.FUNC_REVERSE_SUBTRACT,
-        'min': GL.MIN,
-        'max': GL.MAX
+        min: GL.MIN,
+        max: GL.MAX
     });
 }
 function convertBlendFactorToFunction(parameter, value) {
     return map(parameter, value, {
-        'one': GL.ONE,
-        'zero': GL.ZERO,
+        one: GL.ONE,
+        zero: GL.ZERO,
         'src-color': GL.SRC_COLOR,
         'one-minus-src-color': GL.ONE_MINUS_SRC_COLOR,
         'dst-color': GL.DST_COLOR,
@@ -248,7 +308,7 @@ function convertBlendFactorToFunction(parameter, value) {
         'src-alpha': GL.SRC_ALPHA,
         'one-minus-src-alpha': GL.ONE_MINUS_SRC_ALPHA,
         'dst-alpha': GL.DST_ALPHA,
-        'one-minus-dst-alpha': GL.ONE_MINUS_DST_ALPHA,
+        'one-minus-dst-alpha': GL.ONE_MINUS_DST_ALPHA
     });
 }
 function message(parameter, value) {

package/dist/adapter/converters/sampler-parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/sampler-parameters.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAK,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAG3D;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,YAAY,GAAG,mBAAmB,CAuCxF"}
+{"version":3,"file":"sampler-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/sampler-parameters.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAK,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAG3D;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,YAAY,GAAG,mBAAmB,CAuCxF"}

package/dist/adapter/converters/sampler-parameters.js

@@ -1,7 +1,8 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { GL } from '@luma.gl/constants';
-import { convertCompareFunction } from './device-parameters';
+import { convertCompareFunction } from "./device-parameters.js";
 /**
  * Convert WebGPU-style sampler props to WebGL
  * @param props

package/dist/adapter/converters/shader-formats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/shader-formats.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,EAAC,mBAAmB,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAElE,kDAAkD;AAClD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,mBAAmB,CASrG;AAED,6CAA6C;AAC7C,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,EAAE,GAAG,cAAc,CAYhE;AAED,2CAA2C;AAC3C,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,cAAc,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,YAAY,GAAG,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,UAAU,CASjH"}
+{"version":3,"file":"shader-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/shader-formats.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,EAAC,mBAAmB,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAElE,kDAAkD;AAClD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,EAAE,EACR,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GACxB,mBAAmB,CAcrB;AAED,6CAA6C;AAC7C,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,EAAE,GAAG,cAAc,CAqBhE;AAED,2CAA2C;AAC3C,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,cAAc,GACnB,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,YAAY,GAAG,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,UAAU,CAcrD"}

package/dist/adapter/converters/shader-formats.js

@@ -1,39 +1,59 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { GL } from '@luma.gl/constants';
 /** Get shader attribute type from GL constants */
 export function getShaderAttributeTypeFromGL(type, components) {
     const dataType = getShaderDataTypeFromGL(type);
     switch (components) {
-        case 1: return dataType;
-        case 2: return `vec2<${dataType}>`;
-        case 3: return `vec2<${dataType}>`;
-        case 4: return `vec2<${dataType}>`;
-        default: throw new Error(String(components));
+        case 1:
+            return dataType;
+        case 2:
+            return `vec2<${dataType}>`;
+        case 3:
+            return `vec2<${dataType}>`;
+        case 4:
+            return `vec2<${dataType}>`;
+        default:
+            throw new Error(String(components));
     }
 }
 /** Get shader data type from GL constants */
 export function getShaderDataTypeFromGL(type) {
     switch (type) {
-        case GL.INT: return 'i32';
-        case GL.UNSIGNED_INT: return 'u32';
-        case GL.SHORT: return 'i32';
-        case GL.UNSIGNED_SHORT: return 'u32';
-        case GL.BYTE: return 'i32';
-        case GL.UNSIGNED_BYTE: return 'u32';
-        case GL.FLOAT: return 'f32';
-        case GL.HALF_FLOAT: return 'f16';
-        default: throw new Error(String(type));
+        case GL.INT:
+            return 'i32';
+        case GL.UNSIGNED_INT:
+            return 'u32';
+        case GL.SHORT:
+            return 'i32';
+        case GL.UNSIGNED_SHORT:
+            return 'u32';
+        case GL.BYTE:
+            return 'i32';
+        case GL.UNSIGNED_BYTE:
+            return 'u32';
+        case GL.FLOAT:
+            return 'f32';
+        case GL.HALF_FLOAT:
+            return 'f16';
+        default:
+            throw new Error(String(type));
     }
 }
 /** GetGL constant from shader data type */
 export function getGLFromShaderDataType(type) {
     switch (type) {
         // TODO
-        case 'i32': return GL.INT;
-        case 'u32': return GL.UNSIGNED_INT;
-        case 'f32': return GL.FLOAT;
-        case 'f16': return GL.HALF_FLOAT;
-        default: throw new Error(String(type));
+        case 'i32':
+            return GL.INT;
+        case 'u32':
+            return GL.UNSIGNED_INT;
+        case 'f32':
+            return GL.FLOAT;
+        case 'f16':
+            return GL.HALF_FLOAT;
+        default:
+            throw new Error(String(type));
     }
 }

package/dist/adapter/converters/texture-formats.d.ts

@@ -1,7 +1,10 @@
 import type { TextureFormat, DeviceFeature } from '@luma.gl/core';
-import { GL } from '@luma.gl/constants';
+import { GL, GLExtensions } from '@luma.gl/constants';
+export declare const TEXTURE_FEATURES: Partial<Record<DeviceFeature, string[]>>;
 /** Return a list of texture feature strings (for Device.features). Mainly compressed texture support */
-export declare function getTextureFeatures(gl: WebGL2RenderingContext): DeviceFeature[];
+export declare function isTextureFeature(feature: DeviceFeature): boolean;
+/** Checks a texture feature (for Device.features). Mainly compressed texture support */
+export declare function checkTextureFeature(gl: WebGL2RenderingContext, feature: DeviceFeature, extensions: GLExtensions): boolean;
 /** Map a format to webgl and constants */
 type Format = {
     gl?: GL;
@@ -38,8 +41,8 @@ type Format = {
  */
 export declare const TEXTURE_FORMATS: Record<TextureFormat, Format>;
 /** Checks if a texture format is supported */
-export declare function isTextureFormatSupported(gl: WebGL2RenderingContext, formatOrGL: TextureFormat | GL): boolean;
-export declare function isRenderbufferFormatSupported(gl: WebGL2RenderingContext, format: TextureFormat): boolean;
+export declare function isTextureFormatSupported(gl: WebGL2RenderingContext, formatOrGL: TextureFormat | GL, extensions: GLExtensions): boolean;
+export declare function isRenderbufferFormatSupported(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
 /**
  * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
  */
@@ -49,7 +52,7 @@ export declare function convertGLToTextureFormat(format: GL | TextureFormat): Te
  */
 export declare function convertTextureFormatToGL(format: TextureFormat): GL | undefined;
 /** Checks if a texture format is supported */
-export declare function getTextureFormatSupport(gl: WebGL2RenderingContext, formatOrGL: TextureFormat | GL): {
+export declare function getTextureFormatSupport(gl: WebGL2RenderingContext, formatOrGL: TextureFormat | GL, extensions: GLExtensions): {
     supported: boolean;
     filterable?: boolean;
     renderable?: boolean;
@@ -57,8 +60,8 @@ export declare function getTextureFormatSupport(gl: WebGL2RenderingContext, form
     storable?: boolean;
 };
 /** Checks whether linear filtering (interpolated sampling) is available for floating point textures */
-export declare function isTextureFormatFilterable(gl: WebGL2RenderingContext, formatOrGL: TextureFormat | GL): boolean;
-export declare function isTextureFormatRenderable(gl: WebGL2RenderingContext, formatOrGL: TextureFormat | GL): boolean;
+export declare function isTextureFormatFilterable(gl: WebGL2RenderingContext, formatOrGL: TextureFormat | GL, extensions: GLExtensions): boolean;
+export declare function isTextureFormatRenderable(gl: WebGL2RenderingContext, formatOrGL: TextureFormat | GL, extensions: GLExtensions): boolean;
 export declare function getWebGLTextureParameters(formatOrGL: TextureFormat | GL): {
     format: GL;
     dataFormat: GL;

package/dist/adapter/converters/texture-formats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/texture-formats.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"texture-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/texture-formats.ts"],"names":[],"mappings":"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"}

package/dist/adapter/converters/texture-formats.js

@@ -1,8 +1,10 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { decodeTextureFormat } from '@luma.gl/core';
 import { GL } from '@luma.gl/constants';
-import { getGLFromVertexType } from './vertex-formats';
+import { getWebGLExtension } from "../../context/helpers/webgl-extensions.js";
+import { getGLFromVertexType } from "./vertex-formats.js";
 /* eslint-disable camelcase */
 // TEXTURE FEATURES
 // Define local device feature strings to optimize minification
@@ -12,8 +14,14 @@ const texture_compression_etc2 = 'texture-compression-etc2';
 const texture_compression_etc1_webgl = 'texture-compression-etc1-webgl';
 const texture_compression_pvrtc_webgl = 'texture-compression-pvrtc-webgl';
 const texture_compression_atc_webgl = 'texture-compression-atc-webgl';
-// const float32_renderable_webgl: DeviceFeature = 'float32-renderable-webgl';
-// const float16_renderable_webgl: DeviceFeature = 'float16-renderable-webgl';
+const float32_renderable = 'float32-renderable-webgl';
+const float16_renderable = 'float16-renderable-webgl';
+const rgb9e5ufloat_renderable = 'rgb9e5ufloat_renderable-webgl';
+const snorm8_renderable = 'snorm8-renderable-webgl';
+const norm16_renderable = 'norm16-renderable-webgl';
+const snorm16_renderable = 'snorm16-renderable-webgl';
+const float32_filterable = 'float32-filterable';
+const float16_filterable = 'float16-filterable-webgl';
 // Define local webgl extension strings to optimize minification
 const X_S3TC = 'WEBGL_compressed_texture_s3tc'; // BC1, BC2, BC3
 const X_S3TC_SRGB = 'WEBGL_compressed_texture_s3tc_srgb'; // BC1, BC2, BC3
@@ -25,19 +33,19 @@ const X_ETC1 = 'WEBGL_compressed_texture_etc1';
 const X_PVRTC = 'WEBGL_compressed_texture_pvrtc';
 const X_ATC = 'WEBGL_compressed_texture_atc';
 // Define local webgl extension strings to optimize minification
-const EXT_TEXTURE_NORM16 = 'EXT_texture_norm16';
-const EXT_FLOAT_RENDER_WEBGL2 = 'EXT_color_buffer_float';
-// const EXT_HALF_FLOAT_WEBGL1 = 'EXT_color_buffer_half_float';
-// const DEPTH = 'WEBGL_depth_texture';
-// WebGL1-only extensions
-// const EXT_SRGB = 'EXT_sRGB'; // https://developer.mozilla.org/en-US/docs/Web/API/EXT_sRGB
+const EXT_texture_norm16 = 'EXT_texture_norm16';
+const EXT_render_snorm = 'EXT_render_snorm';
+const EXT_color_buffer_float = 'EXT_color_buffer_float';
 // prettier-ignore
-const TEXTURE_FEATURE_CHECKS = {
-    'float32-renderable-webgl': ['EXT_color_buffer_float'], // [false, 'EXT_color_buffer_float'],
+export const TEXTURE_FEATURES = {
+    'float32-renderable-webgl': ['EXT_color_buffer_float'],
     'float16-renderable-webgl': ['EXT_color_buffer_half_float'],
-    'norm16-renderable-webgl': [EXT_TEXTURE_NORM16],
-    'float32-filterable-linear-webgl': ['OES_texture_float_linear'],
-    'float16-filterable-linear-webgl': ['OES_texture_half_float_linear'],
+    'rgb9e5ufloat_renderable-webgl': ['WEBGL_render_shared_exponent'],
+    'snorm8-renderable-webgl': [EXT_render_snorm],
+    'norm16-renderable-webgl': [EXT_texture_norm16],
+    'snorm16-renderable-webgl': [EXT_texture_norm16, EXT_render_snorm],
+    'float32-filterable': ['OES_texture_float_linear'],
+    'float16-filterable-webgl': ['OES_texture_half_float_linear'],
     'texture-filterable-anisotropic-webgl': ['EXT_texture_filter_anisotropic'],
     'texture-blend-float-webgl': ['EXT_float_blend'],
     'texture-compression-bc': [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC],
@@ -51,17 +59,21 @@ const TEXTURE_FEATURE_CHECKS = {
     'texture-compression-pvrtc-webgl': [X_PVRTC],
     'texture-compression-atc-webgl': [X_ATC]
 };
-function checkTextureFeature(gl, feature) {
-    const extensions = TEXTURE_FEATURE_CHECKS[feature] || [];
-    return extensions.every(extension => gl.getExtension(extension));
-}
-function checkTextureFeatures(gl, features) {
-    return features.every(feature => checkTextureFeature(gl, feature));
-}
 /** Return a list of texture feature strings (for Device.features). Mainly compressed texture support */
-export function getTextureFeatures(gl) {
-    const textureFeatures = Object.keys(TEXTURE_FEATURE_CHECKS);
-    return textureFeatures.filter(feature => checkTextureFeature(gl, feature));
+// export function getTextureFeatures(
+//   gl: WebGL2RenderingContext,
+//   extensions: GLExtensions
+// ): DeviceFeature[] {
+//   const textureFeatures = Object.keys(TEXTURE_FEATURES) as DeviceFeature[];
+//   return textureFeatures.filter(feature => checkTextureFeature(gl, feature, extensions));
+// }
+export function isTextureFeature(feature) {
+    return feature in TEXTURE_FEATURES;
+}
+/** Checks a texture feature (for Device.features). Mainly compressed texture support */
+export function checkTextureFeature(gl, feature, extensions) {
+    const textureExtensions = TEXTURE_FEATURES[feature] || [];
+    return textureExtensions.every(extension => getWebGLExtension(gl, extension, extensions));
 }
 // TABLES
 /**
@@ -81,19 +93,19 @@ export const TEXTURE_FORMATS = {
     // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
     // 8-bit formats
     'r8unorm': { gl: GL.R8, b: 1, c: 1, renderbuffer: true },
-    'r8snorm': { gl: GL.R8_SNORM, b: 1, c: 1 },
+    'r8snorm': { gl: GL.R8_SNORM, b: 1, c: 1, render: snorm8_renderable },
     'r8uint': { gl: GL.R8UI, b: 1, c: 1, renderbuffer: true },
     'r8sint': { gl: GL.R8I, b: 1, c: 1, renderbuffer: true },
     // 16-bit formats
     'rg8unorm': { gl: GL.RG8, b: 2, c: 2, renderbuffer: true },
-    'rg8snorm': { gl: GL.RG8_SNORM, b: 2, c: 2 },
+    'rg8snorm': { gl: GL.RG8_SNORM, b: 2, c: 2, render: snorm8_renderable },
     'rg8uint': { gl: GL.RG8UI, b: 2, c: 2, renderbuffer: true },
     'rg8sint': { gl: GL.RG8I, b: 2, c: 2, renderbuffer: true },
     'r16uint': { gl: GL.R16UI, b: 2, c: 1, renderbuffer: true },
     'r16sint': { gl: GL.R16I, b: 2, c: 1, renderbuffer: true },
-    'r16float': { gl: GL.R16F, b: 2, c: 1, render: 'float16-renderable-webgl', filter: 'float16-filterable-linear-webgl', renderbuffer: true },
-    'r16unorm-webgl': { gl: GL.R16_EXT, b: 2, c: 1, f: 'norm16-renderable-webgl', renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-    'r16snorm-webgl': { gl: GL.R16_SNORM_EXT, b: 2, c: 1, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16 },
+    'r16float': { gl: GL.R16F, b: 2, c: 1, render: float16_renderable, filter: 'float16-filterable-webgl', renderbuffer: true },
+    'r16unorm-webgl': { gl: GL.R16_EXT, b: 2, c: 1, f: norm16_renderable, renderbuffer: true },
+    'r16snorm-webgl': { gl: GL.R16_SNORM_EXT, b: 2, c: 1, f: snorm16_renderable },
     // Packed 16-bit formats
     'rgba4unorm-webgl': { gl: GL.RGBA4, b: 2, c: 4, wgpu: false, renderbuffer: true },
     'rgb565unorm-webgl': { gl: GL.RGB565, b: 2, c: 4, wgpu: false, renderbuffer: true },
@@ -104,7 +116,7 @@ export const TEXTURE_FORMATS = {
     // 32-bit formats  
     'rgba8unorm': { gl: GL.RGBA8, b: 4, c: 2, bpp: 4 },
     'rgba8unorm-srgb': { gl: GL.SRGB8_ALPHA8, b: 4, c: 4, bpp: 4 },
-    'rgba8snorm': { gl: GL.RGBA8_SNORM, b: 4, c: 4 },
+    'rgba8snorm': { gl: GL.RGBA8_SNORM, b: 4, c: 4, render: snorm8_renderable },
     'rgba8uint': { gl: GL.RGBA8UI, b: 4, c: 4, bpp: 4 },
     'rgba8sint': { gl: GL.RGBA8I, b: 4, c: 4, bpp: 4 },
     // reverse colors, webgpu only
@@ -113,36 +125,36 @@ export const TEXTURE_FORMATS = {
     'rg16uint': { gl: GL.RG16UI, b: 4, c: 1, bpp: 4 },
     'rg16sint': { gl: GL.RG16I, b: 4, c: 2, bpp: 4 },
     // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
-    'rg16float': { gl: GL.RG16F, bpp: 4, b: 4, c: 2, render: 'float16-renderable-webgl', filter: 'float16-filterable-linear-webgl', renderbuffer: true },
-    'rg16unorm-webgl': { gl: GL.RG16_EXT, b: 2, c: 2, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16 },
-    'rg16snorm-webgl': { gl: GL.RG16_SNORM_EXT, b: 2, c: 2, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16 },
+    'rg16float': { gl: GL.RG16F, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, renderbuffer: true },
+    'rg16unorm-webgl': { gl: GL.RG16_EXT, b: 2, c: 2, render: norm16_renderable },
+    'rg16snorm-webgl': { gl: GL.RG16_SNORM_EXT, b: 2, c: 2, render: snorm16_renderable },
     'r32uint': { gl: GL.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true },
     'r32sint': { gl: GL.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true },
-    'r32float': { gl: GL.R32F, bpp: 4, b: 4, c: 1, render: 'float32-renderable-webgl', filter: 'float32-filterable-linear-webgl' },
+    'r32float': { gl: GL.R32F, bpp: 4, b: 4, c: 1, render: float32_renderable, filter: float32_filterable },
     // Packed 32-bit formats
-    'rgb9e5ufloat': { gl: GL.RGB9_E5, b: 4, c: 3, p: 1, render: 'float16-renderable-webgl', filter: 'float16-filterable-linear-webgl' },
-    'rg11b10ufloat': { gl: GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: 'float32-renderable-webgl', renderbuffer: true },
+    'rgb9e5ufloat': { gl: GL.RGB9_E5, b: 4, c: 3, p: 1, render: rgb9e5ufloat_renderable }, // , filter: true},
+    'rg11b10ufloat': { gl: GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: float32_renderable, renderbuffer: true },
     'rgb10a2unorm': { gl: GL.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
-    'rgb10a2unorm-webgl': { b: 4, c: 4, gl: GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
+    'rgb10a2uint-webgl': { b: 4, c: 4, gl: GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
     // 48-bit formats
-    'rgb16unorm-webgl': { gl: GL.RGB16_EXT, b: 2, c: 3, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16 },
-    'rgb16snorm-webgl': { gl: GL.RGB16_SNORM_EXT, b: 2, c: 3, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16 },
+    'rgb16unorm-webgl': { gl: GL.RGB16_EXT, b: 2, c: 3, f: norm16_renderable }, // rgb not renderable
+    'rgb16snorm-webgl': { gl: GL.RGB16_SNORM_EXT, b: 2, c: 3, f: norm16_renderable }, // rgb not renderable
     // 64-bit formats
     'rg32uint': { gl: GL.RG32UI, b: 8, c: 2, renderbuffer: true },
     'rg32sint': { gl: GL.RG32I, b: 8, c: 2, renderbuffer: true },
-    'rg32float': { gl: GL.RG32F, b: 8, c: 2, render: 'float32-renderable-webgl', filter: 'float32-filterable-linear-webgl', renderbuffer: true },
+    'rg32float': { gl: GL.RG32F, b: 8, c: 2, render: float32_renderable, filter: float32_filterable, renderbuffer: true },
     'rgba16uint': { gl: GL.RGBA16UI, b: 8, c: 4, renderbuffer: true },
     'rgba16sint': { gl: GL.RGBA16I, b: 8, c: 4, renderbuffer: true },
-    'rgba16float': { gl: GL.RGBA16F, b: 8, c: 4, render: 'float16-renderable-webgl', filter: 'float16-filterable-linear-webgl' },
-    'rgba16unorm-webgl': { gl: GL.RGBA16_EXT, b: 2, c: 4, f: 'norm16-renderable-webgl', renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-    'rgba16snorm-webgl': { gl: GL.RGBA16_SNORM_EXT, b: 2, c: 4, f: 'norm16-renderable-webgl', x: EXT_TEXTURE_NORM16 },
+    'rgba16float': { gl: GL.RGBA16F, b: 8, c: 4, render: float16_renderable, filter: float16_filterable },
+    'rgba16unorm-webgl': { gl: GL.RGBA16_EXT, b: 2, c: 4, render: norm16_renderable, renderbuffer: true },
+    'rgba16snorm-webgl': { gl: GL.RGBA16_SNORM_EXT, b: 2, c: 4, render: snorm16_renderable },
     // 96-bit formats (deprecated!)
-    'rgb32float-webgl': { gl: GL.RGB32F, render: 'float32-renderable-webgl', filter: 'float32-filterable-linear-webgl',
-        gl2ext: EXT_FLOAT_RENDER_WEBGL2, dataFormat: GL.RGB, types: [GL.FLOAT] },
+    'rgb32float-webgl': { gl: GL.RGB32F, render: float32_renderable, filter: float32_filterable,
+        gl2ext: EXT_color_buffer_float, dataFormat: GL.RGB, types: [GL.FLOAT] },
     // 128-bit formats
     'rgba32uint': { gl: GL.RGBA32UI, b: 16, c: 4, renderbuffer: true },
     'rgba32sint': { gl: GL.RGBA32I, b: 16, c: 4, renderbuffer: true },
-    'rgba32float': { gl: GL.RGBA32F, b: 16, c: 4, render: 'float32-renderable-webgl', filter: 'float32-filterable-linear-webgl', renderbuffer: true },
+    'rgba32float': { gl: GL.RGBA32F, b: 16, c: 4, render: float32_renderable, filter: float32_filterable, renderbuffer: true },
     // Depth and stencil formats
     'stencil8': { gl: GL.STENCIL_INDEX8, b: 1, c: 1, attachment: GL.STENCIL_ATTACHMENT, renderbuffer: true }, // 8 stencil bits
     'depth16unorm': { gl: GL.DEPTH_COMPONENT16, b: 2, c: 1, attachment: GL.DEPTH_ATTACHMENT, renderbuffer: true }, // 16 depth bits
@@ -312,7 +324,7 @@ export const RENDERBUFFER_FORMATS: Record<string, RenderbufferFormat> = {
   [GL.RG32F]: {ext: EXT_FLOAT_WEBGL2, bpp: 8},
   // TODO - can't get WEBGL_color_buffer_float to work on renderbuffers
   [GL.RGBA32F]: {ext: EXT_FLOAT_WEBGL2, bpp: 16},
-  // [GL.RGBA32F]: {ext: EXT_FLOAT_WEBGL2, gl1: EXT_FLOAT_WEBGL1},
+  // [GL.RGBA32F]: {ext: EXT_FLOAT_WEBGL2},
   [GL.R11F_G11F_B10F]: {ext: EXT_FLOAT_WEBGL2, bpp: 4}
 };
 */
@@ -345,7 +357,7 @@ const TYPE_SIZES = {
 };
 // FUNCTIONS
 /** Checks if a texture format is supported */
-export function isTextureFormatSupported(gl, formatOrGL) {
+export function isTextureFormatSupported(gl, formatOrGL, extensions) {
     const format = convertGLToTextureFormat(formatOrGL);
     const info = TEXTURE_FORMATS[format];
     if (!info) {
@@ -358,13 +370,13 @@ export function isTextureFormatSupported(gl, formatOrGL) {
     // Check extensions
     const extension = info.x || info.gl2ext;
     if (extension) {
-        return Boolean(gl.getExtension(extension));
+        return Boolean(getWebGLExtension(gl, extension, extensions));
     }
     return true;
 }
-export function isRenderbufferFormatSupported(gl, format) {
+export function isRenderbufferFormatSupported(gl, format, extensions) {
     // Note: Order is important since the function call initializes extensions.
-    return isTextureFormatSupported(gl, format) && TEXTURE_FORMATS[format]?.renderbuffer;
+    return isTextureFormatSupported(gl, format, extensions) && TEXTURE_FORMATS[format]?.renderbuffer;
 }
 /**
  * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
@@ -391,7 +403,7 @@ export function convertTextureFormatToGL(format) {
     return webglFormat;
 }
 /** Checks if a texture format is supported */
-export function getTextureFormatSupport(gl, formatOrGL) {
+export function getTextureFormatSupport(gl, formatOrGL, extensions) {
     const format = convertGLToTextureFormat(formatOrGL);
     const info = TEXTURE_FORMATS[format];
     if (!info) {
@@ -403,26 +415,26 @@ export function getTextureFormatSupport(gl, formatOrGL) {
     // } catch {}
     // Support Check that we have a GL constant
     let supported = info.gl === undefined;
-    supported = supported && checkTextureFeatures(gl, [info.f]);
+    supported = supported && checkTextureFeature(gl, info.f, extensions);
     // Filtering
     // const filterable = info.filter
-    //   ? checkTextureFeatures(gl, [info.filter])
+    //   ? checkTextureFeature(gl, infofilter])
     //   : decoded && !decoded.signed;
     // const renderable = info.filter
-    //   ? checkTextureFeatures(gl, [info.render])
+    //   ? checkTextureFeature(gl, inforender])
     //   : decoded && !decoded.signed;
     return {
         supported,
-        renderable: supported && checkTextureFeatures(gl, [info.render]),
-        filterable: supported && checkTextureFeatures(gl, [info.filter]),
+        renderable: supported && checkTextureFeature(gl, info.render, extensions),
+        filterable: supported && checkTextureFeature(gl, info.filter, extensions),
         blendable: false, // tod,
         storable: false
     };
 }
 /** Checks whether linear filtering (interpolated sampling) is available for floating point textures */
-export function isTextureFormatFilterable(gl, formatOrGL) {
+export function isTextureFormatFilterable(gl, formatOrGL, extensions) {
     const format = convertGLToTextureFormat(formatOrGL);
-    if (!isTextureFormatSupported(gl, format)) {
+    if (!isTextureFormatSupported(gl, format, extensions)) {
         return false;
     }
     try {
@@ -435,16 +447,16 @@ export function isTextureFormatFilterable(gl, formatOrGL) {
         return false;
     }
     if (format.endsWith('32float')) {
-        return Boolean(gl.getExtension('OES_texture_float_linear'));
+        return Boolean(getWebGLExtension(gl, 'OES_texture_float_linear, extensions', extensions));
     }
     if (format.endsWith('16float')) {
-        return Boolean(gl.getExtension('OES_texture_half_float_linear'));
+        return Boolean(getWebGLExtension(gl, 'OES_texture_half_float_linear, extensions', extensions));
     }
     return true;
 }
-export function isTextureFormatRenderable(gl, formatOrGL) {
+export function isTextureFormatRenderable(gl, formatOrGL, extensions) {
     const format = convertGLToTextureFormat(formatOrGL);
-    if (!isTextureFormatSupported(gl, format)) {
+    if (!isTextureFormatSupported(gl, format, extensions)) {
         return false;
     }
     if (typeof format === 'number') {

package/dist/adapter/converters/vertex-formats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertex-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/vertex-formats.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,EAAC,YAAY,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AAEvD,KAAK,UAAU,GACX,EAAE,CAAC,aAAa,GAChB,EAAE,CAAC,IAAI,GACP,EAAE,CAAC,cAAc,GACjB,EAAE,CAAC,KAAK,GACR,EAAE,CAAC,YAAY,GACf,EAAE,CAAC,GAAG,GACN,EAAE,CAAC,UAAU,GACb,EAAE,CAAC,KAAK,CAAC;AAGb,0CAA0C;AAC1C,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,YAAY,CAa/F;AAED,sCAAsC;AACtC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,UAAQ,GAAG,UAAU,CAepF;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,UAAU,GAElB,EAAE,CAAC,aAAa,GAChB,EAAE,CAAC,IAAI,GACP,EAAE,CAAC,cAAc,GACjB,EAAE,CAAC,KAAK,GACR,EAAE,CAAC,YAAY,GACf,EAAE,CAAC,GAAG,GACN,EAAE,CAAC,UAAU,GACb,EAAE,CAAC,KAAK,CAqBX"}
+{"version":3,"file":"vertex-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/vertex-formats.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,EAAC,YAAY,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AAEvD,KAAK,UAAU,GACX,EAAE,CAAC,aAAa,GAChB,EAAE,CAAC,IAAI,GACP,EAAE,CAAC,cAAc,GACjB,EAAE,CAAC,KAAK,GACR,EAAE,CAAC,YAAY,GACf,EAAE,CAAC,GAAG,GACN,EAAE,CAAC,UAAU,GACb,EAAE,CAAC,KAAK,CAAC;AAEb,0CAA0C;AAC1C,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,YAAY,CAa/F;AAED,sCAAsC;AACtC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,UAAQ,GAAG,UAAU,CAepF;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,UAAU,GAElB,EAAE,CAAC,aAAa,GAChB,EAAE,CAAC,IAAI,GACP,EAAE,CAAC,cAAc,GACjB,EAAE,CAAC,KAAK,GACR,EAAE,CAAC,YAAY,GACf,EAAE,CAAC,GAAG,GACN,EAAE,CAAC,UAAU,GACb,EAAE,CAAC,KAAK,CAqBX"}

package/dist/adapter/converters/vertex-formats.js

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { GL } from '@luma.gl/constants';
 /** Get vertex format from GL constants */

package/dist/adapter/device-helpers/webgl-device-features.d.ts

@@ -1,6 +1,19 @@
-import { DeviceFeature } from '@luma.gl/core';
-/** Get WebGPU style feature strings */
-export declare function getDeviceFeatures(gl: WebGL2RenderingContext): Set<DeviceFeature>;
-/** Extract all WebGL features */
-export declare function getWebGLFeatures(gl: WebGL2RenderingContext): Set<DeviceFeature>;
+import { DeviceFeature, DeviceFeatures } from '@luma.gl/core';
+import { GLExtensions } from '@luma.gl/constants';
+/**
+ * WebGL extensions exposed as luma.gl features
+ * To minimize GL log noise and improve performance, this class ensures that
+ * - WebGL extensions are not queried until the corresponding feature is checked.
+ * - WebGL extensions are only queried once.
+ */
+export declare class WebGLDeviceFeatures extends DeviceFeatures {
+    protected gl: WebGL2RenderingContext;
+    protected extensions: GLExtensions;
+    protected testedFeatures: Set<DeviceFeature>;
+    constructor(gl: WebGL2RenderingContext, extensions: GLExtensions);
+    [Symbol.iterator](): IterableIterator<DeviceFeature>;
+    has(feature: DeviceFeature): boolean;
+    /** Extract all WebGL features */
+    protected getWebGLFeature(feature: DeviceFeature): boolean;
+}
 //# sourceMappingURL=webgl-device-features.d.ts.map

package/dist/adapter/device-helpers/webgl-device-features.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgl-device-features.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/webgl-device-features.ts"],"names":[],"mappings":"AAMA,OAAO,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AAG5C,uCAAuC;AACvC,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,sBAAsB,GAAG,GAAG,CAAC,aAAa,CAAC,CAiBhF;AAED,iCAAiC;AACjC,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,sBAAsB,GAAG,GAAG,CAAC,aAAa,CAAC,CAW/E"}
+{"version":3,"file":"webgl-device-features.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/webgl-device-features.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AA8BhD;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,SAAS,CAAC,EAAE,EAAE,sBAAsB,CAAC;IACrC,SAAS,CAAC,UAAU,EAAE,YAAY,CAAC;IACnC,SAAS,CAAC,cAAc,qBAA4B;gBAExC,EAAE,EAAE,sBAAsB,EAAE,UAAU,EAAE,YAAY;IAS/D,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAc5C,GAAG,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAiB7C,iCAAiC;IACjC,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;CAU3D"}