@luma.gl/webgl 9.0.0-alpha.24 → 9.0.0-alpha.25

package/dist/index.cjs

@@ -1,11 +1,9 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -33,14 +31,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -67,8 +57,7 @@ var __async = (__this, __arguments, generator) => {
 var src_exports = {};
 __export(src_exports, {
   Accessor: () => Accessor,
-  Buffer: () => ClassicBuffer,
-  ClassicBuffer: () => ClassicBuffer,
+  BufferWithAccessor: () => BufferWithAccessor,
   WEBGLBuffer: () => WEBGLBuffer,
   WEBGLCommandEncoder: () => WEBGLCommandEncoder,
   WEBGLFramebuffer: () => WEBGLFramebuffer,
@@ -432,7 +421,7 @@ function polyfillVertexArrayObject(gl) {
 
 // src/context/polyfill/polyfill-table.ts
 var import_api2 = require("@luma.gl/api");
-var import_constants2 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants2 = require("@luma.gl/constants");
 
 // src/context/context/webgl-checks.ts
 var import_api = require("@luma.gl/api");
@@ -466,7 +455,7 @@ function assertWebGL2Context(gl) {
 }
 
 // src/context/polyfill/get-parameter-polyfill.ts
-var import_constants = __toESM(require("@luma.gl/constants"), 1);
+var import_constants = require("@luma.gl/constants");
 var OES_element_index = "OES_element_index";
 var WEBGL_draw_buffers = "WEBGL_draw_buffers";
 var EXT_disjoint_timer_query = "EXT_disjoint_timer_query";
@@ -481,11 +470,11 @@ var GL_UNMASKED_VENDOR_WEBGL = 37445;
 var GL_UNMASKED_RENDERER_WEBGL = 37446;
 var getWebGL2ValueOrZero = (gl) => !isWebGL2(gl) ? 0 : void 0;
 var WEBGL_PARAMETERS = {
-  [import_constants.default.READ_BUFFER]: (gl) => !isWebGL2(gl) ? import_constants.default.COLOR_ATTACHMENT0 : void 0,
+  [import_constants.GL.READ_BUFFER]: (gl) => !isWebGL2(gl) ? import_constants.GL.COLOR_ATTACHMENT0 : void 0,
   // WebGL2 context parameters
   [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl) => !isWebGL2(gl) ? GL_DONT_CARE : void 0,
-  [import_constants.default.RASTERIZER_DISCARD]: getWebGL2ValueOrZero,
-  [import_constants.default.SAMPLES]: getWebGL2ValueOrZero,
+  [import_constants.GL.RASTERIZER_DISCARD]: getWebGL2ValueOrZero,
+  [import_constants.GL.SAMPLES]: getWebGL2ValueOrZero,
   // WebGL2 extension context parameters
   [GL_GPU_DISJOINT_EXT]: (gl, getParameter) => {
     const ext = isWebGL2(gl) ? gl.getExtension(EXT_disjoint_timer_query_webgl2) : gl.getExtension(EXT_disjoint_timer_query);
@@ -494,11 +483,11 @@ var WEBGL_PARAMETERS = {
   // Extension fixed values
   [GL_UNMASKED_VENDOR_WEBGL]: (gl, getParameter) => {
     const ext = gl.getExtension(WEBGL_debug_renderer_info);
-    return getParameter(ext && ext.UNMASKED_VENDOR_WEBGL || import_constants.default.VENDOR);
+    return getParameter(ext && ext.UNMASKED_VENDOR_WEBGL || import_constants.GL.VENDOR);
   },
   [GL_UNMASKED_RENDERER_WEBGL]: (gl, getParameter) => {
     const ext = gl.getExtension(WEBGL_debug_renderer_info);
-    return getParameter(ext && ext.UNMASKED_RENDERER_WEBGL || import_constants.default.RENDERER);
+    return getParameter(ext && ext.UNMASKED_RENDERER_WEBGL || import_constants.GL.RENDERER);
   },
   // Extension LIMITS
   [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => {
@@ -507,56 +496,56 @@ var WEBGL_PARAMETERS = {
     return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1;
   },
   // WebGL2 Limits
-  [import_constants.default.MAX_3D_TEXTURE_SIZE]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_ARRAY_TEXTURE_LAYERS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_COLOR_ATTACHMENTS]: (gl, getParameter) => {
+  [import_constants.GL.MAX_3D_TEXTURE_SIZE]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_ARRAY_TEXTURE_LAYERS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_COLOR_ATTACHMENTS]: (gl, getParameter) => {
     if (!isWebGL2(gl)) {
       const ext = gl.getExtension(WEBGL_draw_buffers);
       return ext ? getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 0;
     }
     return void 0;
   },
-  [import_constants.default.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_COMBINED_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_DRAW_BUFFERS]: (gl) => {
+  [import_constants.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_COMBINED_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_DRAW_BUFFERS]: (gl) => {
     if (!isWebGL2(gl)) {
       const ext = gl.getExtension(WEBGL_draw_buffers);
       return ext ? ext.MAX_DRAW_BUFFERS_WEBGL : 0;
     }
     return void 0;
   },
-  [import_constants.default.MAX_ELEMENT_INDEX]: (
+  [import_constants.GL.MAX_ELEMENT_INDEX]: (
     // Guess: per webglstats.com 99.6% of webgl2 supports 2147483647
     (gl) => gl.getExtension(OES_element_index) ? 2147483647 : 65535
   ),
-  [import_constants.default.MAX_ELEMENTS_INDICES]: (
+  [import_constants.GL.MAX_ELEMENTS_INDICES]: (
     // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
     (gl) => gl.getExtension(OES_element_index) ? 16777216 : 65535
   ),
-  [import_constants.default.MAX_ELEMENTS_VERTICES]: (
+  [import_constants.GL.MAX_ELEMENTS_VERTICES]: (
     // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
     (gl) => 16777216
   ),
-  [import_constants.default.MAX_FRAGMENT_INPUT_COMPONENTS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_FRAGMENT_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_SAMPLES]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_SERVER_WAIT_TIMEOUT]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_TEXTURE_LOD_BIAS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_UNIFORM_BLOCK_SIZE]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_UNIFORM_BUFFER_BINDINGS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_VARYING_COMPONENTS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_VERTEX_OUTPUT_COMPONENTS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_VERTEX_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [import_constants.default.MIN_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
-  [import_constants.default.MAX_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
-  [import_constants.default.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: getWebGL2ValueOrZero
+  [import_constants.GL.MAX_FRAGMENT_INPUT_COMPONENTS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_SAMPLES]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_SERVER_WAIT_TIMEOUT]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_TEXTURE_LOD_BIAS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_UNIFORM_BLOCK_SIZE]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_UNIFORM_BUFFER_BINDINGS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_VARYING_COMPONENTS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_VERTEX_OUTPUT_COMPONENTS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_VERTEX_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
+  [import_constants.GL.MIN_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
+  [import_constants.GL.MAX_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
+  [import_constants.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: getWebGL2ValueOrZero
 };
 function getParameterPolyfill(gl, originalGetParameter, pname) {
   const limit = WEBGL_PARAMETERS[pname];
@@ -666,10 +655,10 @@ var WEBGL2_CONTEXT_OVERRIDES = {
     const { webgl2, ext } = getExtensionData(gl, ANGLE_instanced_arrays);
     let result;
     switch (pname) {
-      case import_constants2.default.VERTEX_ATTRIB_ARRAY_INTEGER:
+      case import_constants2.GL.VERTEX_ATTRIB_ARRAY_INTEGER:
         result = !webgl2 ? false : void 0;
         break;
-      case import_constants2.default.VERTEX_ATTRIB_ARRAY_DIVISOR:
+      case import_constants2.GL.VERTEX_ATTRIB_ARRAY_DIVISOR:
         result = !webgl2 && !ext ? 0 : void 0;
         break;
       default:
@@ -680,11 +669,11 @@ var WEBGL2_CONTEXT_OVERRIDES = {
   getProgramParameter: (gl, originalFunc, program, pname) => {
     if (!isWebGL2(gl)) {
       switch (pname) {
-        case import_constants2.default.TRANSFORM_FEEDBACK_BUFFER_MODE:
-          return import_constants2.default.SEPARATE_ATTRIBS;
-        case import_constants2.default.TRANSFORM_FEEDBACK_VARYINGS:
+        case import_constants2.GL.TRANSFORM_FEEDBACK_BUFFER_MODE:
+          return import_constants2.GL.SEPARATE_ATTRIBS;
+        case import_constants2.GL.TRANSFORM_FEEDBACK_VARYINGS:
           return 0;
-        case import_constants2.default.ACTIVE_UNIFORM_BLOCKS:
+        case import_constants2.GL.ACTIVE_UNIFORM_BLOCKS:
           return 0;
         default:
       }
@@ -694,7 +683,7 @@ var WEBGL2_CONTEXT_OVERRIDES = {
   getInternalformatParameter: (gl, originalFunc, target, format, pname) => {
     if (!isWebGL2(gl)) {
       switch (pname) {
-        case import_constants2.default.SAMPLES:
+        case import_constants2.GL.SAMPLES:
           return new Int32Array([0]);
         default:
       }
@@ -704,11 +693,11 @@ var WEBGL2_CONTEXT_OVERRIDES = {
   },
   getTexParameter(gl, originalFunc, target, pname) {
     switch (pname) {
-      case import_constants2.default.TEXTURE_MAX_ANISOTROPY_EXT:
+      case import_constants2.GL.TEXTURE_MAX_ANISOTROPY_EXT:
         const contextData = getContextData(gl);
         const { _extensions } = contextData;
         const ext = _extensions[EXT_texture_filter_anisotropic2];
-        pname = ext && ext.TEXTURE_MAX_ANISOTROPY_EXT || import_constants2.default.TEXTURE_MAX_ANISOTROPY_EXT;
+        pname = ext && ext.TEXTURE_MAX_ANISOTROPY_EXT || import_constants2.GL.TEXTURE_MAX_ANISOTROPY_EXT;
         break;
       default:
     }
@@ -1554,13 +1543,13 @@ function createBrowserContext(canvas, props) {
 }
 
 // src/adapter/device-helpers/get-device-info.ts
-var import_constants4 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants4 = require("@luma.gl/constants");
 function getDeviceInfo(gl) {
-  const vendorMasked = gl.getParameter(import_constants4.default.VENDOR);
-  const rendererMasked = gl.getParameter(import_constants4.default.RENDERER);
+  const vendorMasked = gl.getParameter(import_constants4.GL.VENDOR);
+  const rendererMasked = gl.getParameter(import_constants4.GL.RENDERER);
   const ext = gl.getExtension("WEBGL_debug_renderer_info");
-  const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : import_constants4.default.VENDOR);
-  const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : import_constants4.default.RENDERER);
+  const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : import_constants4.GL.VENDOR);
+  const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : import_constants4.GL.RENDERER);
   const vendor = vendorUnmasked || vendorMasked;
   const renderer = rendererUnmasked || rendererMasked;
   const gpu = identifyGPUVendor(vendor, renderer);
@@ -1569,10 +1558,10 @@ function getDeviceInfo(gl) {
     gpu,
     vendor: vendorUnmasked || vendorMasked,
     renderer: rendererUnmasked || rendererMasked,
-    version: gl.getParameter(import_constants4.default.VERSION),
+    version: gl.getParameter(import_constants4.GL.VERSION),
     shadingLanguages: ["glsl"],
     shadingLanguageVersions: {
-      "glsl": gl.getParameter(import_constants4.default.SHADING_LANGUAGE_VERSION)
+      "glsl": gl.getParameter(import_constants4.GL.SHADING_LANGUAGE_VERSION)
     }
   };
 }
@@ -1606,7 +1595,7 @@ function isOldIE(opts = {}) {
 
 // src/adapter/converters/texture-formats.ts
 var import_api5 = require("@luma.gl/api");
-var import_constants5 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants5 = require("@luma.gl/constants");
 var texture_compression_bc = "texture-compression-bc";
 var texture_compression_astc = "texture-compression-astc";
 var texture_compression_etc2 = "texture-compression-etc2";
@@ -1665,206 +1654,206 @@ var TEXTURE_FORMATS = {
   // TODO - Fix bpp constants
   // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
   "rgb8unorm-unsized": {
-    gl: import_constants5.default.RGB,
-    gl1: import_constants5.default.RGB,
+    gl: import_constants5.GL.RGB,
+    gl1: import_constants5.GL.RGB,
     b: 4,
     c: 2,
     bpp: 4,
-    dataFormat: import_constants5.default.RGB,
-    types: [import_constants5.default.UNSIGNED_BYTE, import_constants5.default.UNSIGNED_SHORT_5_6_5]
+    dataFormat: import_constants5.GL.RGB,
+    types: [import_constants5.GL.UNSIGNED_BYTE, import_constants5.GL.UNSIGNED_SHORT_5_6_5]
   },
   "rgba8unorm-unsized": {
-    gl: import_constants5.default.RGBA,
-    gl1: import_constants5.default.RGBA,
+    gl: import_constants5.GL.RGBA,
+    gl1: import_constants5.GL.RGBA,
     b: 4,
     c: 2,
     bpp: 4,
-    dataFormat: import_constants5.default.RGBA,
-    types: [import_constants5.default.UNSIGNED_BYTE, import_constants5.default.UNSIGNED_SHORT_4_4_4_4, import_constants5.default.UNSIGNED_SHORT_5_5_5_1]
+    dataFormat: import_constants5.GL.RGBA,
+    types: [import_constants5.GL.UNSIGNED_BYTE, import_constants5.GL.UNSIGNED_SHORT_4_4_4_4, import_constants5.GL.UNSIGNED_SHORT_5_5_5_1]
   },
   // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 8-bit formats
-  "r8unorm": { gl: import_constants5.default.R8, b: 1, c: 1, renderbuffer: true },
-  "r8snorm": { gl: import_constants5.default.R8_SNORM, b: 1, c: 1 },
-  "r8uint": { gl: import_constants5.default.R8UI, b: 1, c: 1, renderbuffer: true },
-  "r8sint": { gl: import_constants5.default.R8I, b: 1, c: 1, renderbuffer: true },
+  "r8unorm": { gl: import_constants5.GL.R8, b: 1, c: 1, renderbuffer: true },
+  "r8snorm": { gl: import_constants5.GL.R8_SNORM, b: 1, c: 1 },
+  "r8uint": { gl: import_constants5.GL.R8UI, b: 1, c: 1, renderbuffer: true },
+  "r8sint": { gl: import_constants5.GL.R8I, b: 1, c: 1, renderbuffer: true },
   // 16-bit formats
-  "rg8unorm": { gl: import_constants5.default.RG8, b: 2, c: 2, renderbuffer: true },
-  "rg8snorm": { gl: import_constants5.default.RG8_SNORM, b: 2, c: 2 },
-  "rg8uint": { gl: import_constants5.default.RG8UI, b: 2, c: 2, renderbuffer: true },
-  "rg8sint": { gl: import_constants5.default.RG8I, b: 2, c: 2, renderbuffer: true },
-  "r16uint": { gl: import_constants5.default.R16UI, b: 2, c: 1, renderbuffer: true },
-  "r16sint": { gl: import_constants5.default.R16I, b: 2, c: 1, renderbuffer: true },
-  "r16float": { gl: import_constants5.default.R16F, b: 2, c: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl", renderbuffer: true },
-  "r16unorm-webgl": { gl: import_constants5.default.R16_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-  "r16snorm-webgl": { gl: import_constants5.default.R16_SNORM_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rg8unorm": { gl: import_constants5.GL.RG8, b: 2, c: 2, renderbuffer: true },
+  "rg8snorm": { gl: import_constants5.GL.RG8_SNORM, b: 2, c: 2 },
+  "rg8uint": { gl: import_constants5.GL.RG8UI, b: 2, c: 2, renderbuffer: true },
+  "rg8sint": { gl: import_constants5.GL.RG8I, b: 2, c: 2, renderbuffer: true },
+  "r16uint": { gl: import_constants5.GL.R16UI, b: 2, c: 1, renderbuffer: true },
+  "r16sint": { gl: import_constants5.GL.R16I, b: 2, c: 1, renderbuffer: true },
+  "r16float": { gl: import_constants5.GL.R16F, b: 2, c: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl", renderbuffer: true },
+  "r16unorm-webgl": { gl: import_constants5.GL.R16_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
+  "r16snorm-webgl": { gl: import_constants5.GL.R16_SNORM_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
   // Packed 16-bit formats
-  "rgba4unorm-webgl": { gl: import_constants5.default.RGBA4, b: 2, c: 4, wgpu: false, renderbuffer: true },
-  "rgb565unorm-webgl": { gl: import_constants5.default.RGB565, b: 2, c: 4, wgpu: false, renderbuffer: true },
-  "rgb5a1unorm-webgl": { gl: import_constants5.default.RGB5_A1, b: 2, c: 4, wgpu: false, renderbuffer: true },
+  "rgba4unorm-webgl": { gl: import_constants5.GL.RGBA4, b: 2, c: 4, wgpu: false, renderbuffer: true },
+  "rgb565unorm-webgl": { gl: import_constants5.GL.RGB565, b: 2, c: 4, wgpu: false, renderbuffer: true },
+  "rgb5a1unorm-webgl": { gl: import_constants5.GL.RGB5_A1, b: 2, c: 4, wgpu: false, renderbuffer: true },
   // 24-bit formats
-  "rgb8unorm-webgl": { gl: import_constants5.default.RGB8, b: 3, c: 3, wgpu: false },
-  "rgb8snorm-webgl": { gl: import_constants5.default.RGB8_SNORM, b: 3, c: 3, wgpu: false },
+  "rgb8unorm-webgl": { gl: import_constants5.GL.RGB8, b: 3, c: 3, wgpu: false },
+  "rgb8snorm-webgl": { gl: import_constants5.GL.RGB8_SNORM, b: 3, c: 3, wgpu: false },
   // 32-bit formats  
-  "rgba8unorm": { gl: import_constants5.default.RGBA8, gl1: import_constants5.default.RGBA, b: 4, c: 2, bpp: 4 },
-  "rgba8unorm-srgb": { gl: import_constants5.default.SRGB8_ALPHA8, gl1: import_constants5.default.SRGB_ALPHA_EXT, b: 4, c: 4, gl1ext: EXT_SRGB, bpp: 4 },
-  "rgba8snorm": { gl: import_constants5.default.RGBA8_SNORM, b: 4, c: 4 },
-  "rgba8uint": { gl: import_constants5.default.RGBA8UI, b: 4, c: 4, bpp: 4 },
-  "rgba8sint": { gl: import_constants5.default.RGBA8I, b: 4, c: 4, bpp: 4 },
+  "rgba8unorm": { gl: import_constants5.GL.RGBA8, gl1: import_constants5.GL.RGBA, b: 4, c: 2, bpp: 4 },
+  "rgba8unorm-srgb": { gl: import_constants5.GL.SRGB8_ALPHA8, gl1: import_constants5.GL.SRGB_ALPHA_EXT, b: 4, c: 4, gl1ext: EXT_SRGB, bpp: 4 },
+  "rgba8snorm": { gl: import_constants5.GL.RGBA8_SNORM, b: 4, c: 4 },
+  "rgba8uint": { gl: import_constants5.GL.RGBA8UI, b: 4, c: 4, bpp: 4 },
+  "rgba8sint": { gl: import_constants5.GL.RGBA8I, b: 4, c: 4, bpp: 4 },
   // reverse colors, webgpu only
   "bgra8unorm": { b: 4, c: 4 },
   "bgra8unorm-srgb": { b: 4, c: 4 },
-  "rg16uint": { gl: import_constants5.default.RG16UI, b: 4, c: 1, bpp: 4 },
-  "rg16sint": { gl: import_constants5.default.RG16I, b: 4, c: 2, bpp: 4 },
+  "rg16uint": { gl: import_constants5.GL.RG16UI, b: 4, c: 1, bpp: 4 },
+  "rg16sint": { gl: import_constants5.GL.RG16I, b: 4, c: 2, bpp: 4 },
   // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
-  "rg16float": { gl: import_constants5.default.RG16F, bpp: 4, b: 4, c: 2, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl", renderbuffer: true },
-  "rg16unorm-webgl": { gl: import_constants5.default.RG16_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
-  "rg16snorm-webgl": { gl: import_constants5.default.RG16_SNORM_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
-  "r32uint": { gl: import_constants5.default.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true },
-  "r32sint": { gl: import_constants5.default.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true },
-  "r32float": { gl: import_constants5.default.R32F, bpp: 4, b: 4, c: 1, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl" },
+  "rg16float": { gl: import_constants5.GL.RG16F, bpp: 4, b: 4, c: 2, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl", renderbuffer: true },
+  "rg16unorm-webgl": { gl: import_constants5.GL.RG16_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rg16snorm-webgl": { gl: import_constants5.GL.RG16_SNORM_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "r32uint": { gl: import_constants5.GL.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true },
+  "r32sint": { gl: import_constants5.GL.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true },
+  "r32float": { gl: import_constants5.GL.R32F, bpp: 4, b: 4, c: 1, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl" },
   // Packed 32-bit formats
-  "rgb9e5ufloat": { gl: import_constants5.default.RGB9_E5, b: 4, c: 3, p: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
-  "rg11b10ufloat": { gl: import_constants5.default.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: "texture-renderable-float32-webgl", renderbuffer: true },
-  "rgb10a2unorm": { gl: import_constants5.default.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
+  "rgb9e5ufloat": { gl: import_constants5.GL.RGB9_E5, b: 4, c: 3, p: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
+  "rg11b10ufloat": { gl: import_constants5.GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: "texture-renderable-float32-webgl", renderbuffer: true },
+  "rgb10a2unorm": { gl: import_constants5.GL.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
   // webgl2 only
-  "rgb10a2unorm-webgl": { b: 4, c: 4, gl: import_constants5.default.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
+  "rgb10a2unorm-webgl": { b: 4, c: 4, gl: import_constants5.GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
   // 48-bit formats
-  "rgb16unorm-webgl": { gl: import_constants5.default.RGB16_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
-  "rgb16snorm-webgl": { gl: import_constants5.default.RGB16_SNORM_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rgb16unorm-webgl": { gl: import_constants5.GL.RGB16_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rgb16snorm-webgl": { gl: import_constants5.GL.RGB16_SNORM_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
   // 64-bit formats
-  "rg32uint": { gl: import_constants5.default.RG32UI, b: 8, c: 2, renderbuffer: true },
-  "rg32sint": { gl: import_constants5.default.RG32I, b: 8, c: 2, renderbuffer: true },
-  "rg32float": { gl: import_constants5.default.RG32F, b: 8, c: 2, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl", renderbuffer: true },
-  "rgba16uint": { gl: import_constants5.default.RGBA16UI, b: 8, c: 4, renderbuffer: true },
-  "rgba16sint": { gl: import_constants5.default.RGBA16I, b: 8, c: 4, renderbuffer: true },
-  "rgba16float": { gl: import_constants5.default.RGBA16F, gl1: import_constants5.default.RGBA, b: 8, c: 4, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
-  "rgba16unorm-webgl": { gl: import_constants5.default.RGBA16_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-  "rgba16snorm-webgl": { gl: import_constants5.default.RGBA16_SNORM_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rg32uint": { gl: import_constants5.GL.RG32UI, b: 8, c: 2, renderbuffer: true },
+  "rg32sint": { gl: import_constants5.GL.RG32I, b: 8, c: 2, renderbuffer: true },
+  "rg32float": { gl: import_constants5.GL.RG32F, b: 8, c: 2, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl", renderbuffer: true },
+  "rgba16uint": { gl: import_constants5.GL.RGBA16UI, b: 8, c: 4, renderbuffer: true },
+  "rgba16sint": { gl: import_constants5.GL.RGBA16I, b: 8, c: 4, renderbuffer: true },
+  "rgba16float": { gl: import_constants5.GL.RGBA16F, gl1: import_constants5.GL.RGBA, b: 8, c: 4, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
+  "rgba16unorm-webgl": { gl: import_constants5.GL.RGBA16_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
+  "rgba16snorm-webgl": { gl: import_constants5.GL.RGBA16_SNORM_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
   // 96-bit formats (deprecated!)
   "rgb32float-webgl": {
-    gl: import_constants5.default.RGB32F,
-    gl1: import_constants5.default.RGB,
+    gl: import_constants5.GL.RGB32F,
+    gl1: import_constants5.GL.RGB,
     render: "texture-renderable-float32-webgl",
     filter: "texture-filter-linear-float32-webgl",
     gl2ext: EXT_FLOAT_RENDER_WEBGL2,
     gl1ext: EXT_FLOAT_WEBGL1,
     // WebGL1 render buffers are supported with GL.RGB32F
-    dataFormat: import_constants5.default.RGB,
-    types: [import_constants5.default.FLOAT]
+    dataFormat: import_constants5.GL.RGB,
+    types: [import_constants5.GL.FLOAT]
   },
   // 128-bit formats
-  "rgba32uint": { gl: import_constants5.default.RGBA32UI, b: 16, c: 4, renderbuffer: true },
-  "rgba32sint": { gl: import_constants5.default.RGBA32I, b: 16, c: 4, renderbuffer: true },
-  "rgba32float": { gl: import_constants5.default.RGBA32F, b: 16, c: 4, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl", renderbuffer: true },
+  "rgba32uint": { gl: import_constants5.GL.RGBA32UI, b: 16, c: 4, renderbuffer: true },
+  "rgba32sint": { gl: import_constants5.GL.RGBA32I, b: 16, c: 4, renderbuffer: true },
+  "rgba32float": { gl: import_constants5.GL.RGBA32F, b: 16, c: 4, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl", renderbuffer: true },
   // Depth and stencil formats
-  "stencil8": { gl: import_constants5.default.STENCIL_INDEX8, gl1: import_constants5.default.STENCIL_INDEX8, b: 1, c: 1, attachment: import_constants5.default.STENCIL_ATTACHMENT, renderbuffer: true },
+  "stencil8": { gl: import_constants5.GL.STENCIL_INDEX8, gl1: import_constants5.GL.STENCIL_INDEX8, b: 1, c: 1, attachment: import_constants5.GL.STENCIL_ATTACHMENT, renderbuffer: true },
   // 8 stencil bits
-  "depth16unorm": { gl: import_constants5.default.DEPTH_COMPONENT16, gl1: import_constants5.default.DEPTH_COMPONENT16, b: 2, c: 1, attachment: import_constants5.default.DEPTH_ATTACHMENT, renderbuffer: true },
+  "depth16unorm": { gl: import_constants5.GL.DEPTH_COMPONENT16, gl1: import_constants5.GL.DEPTH_COMPONENT16, b: 2, c: 1, attachment: import_constants5.GL.DEPTH_ATTACHMENT, renderbuffer: true },
   // 16 depth bits
-  "depth24plus": { gl: import_constants5.default.DEPTH_COMPONENT24, b: 3, c: 1, attachment: import_constants5.default.DEPTH_ATTACHMENT },
-  "depth32float": { gl: import_constants5.default.DEPTH_COMPONENT32F, b: 4, c: 1, attachment: import_constants5.default.DEPTH_ATTACHMENT, renderbuffer: true },
+  "depth24plus": { gl: import_constants5.GL.DEPTH_COMPONENT24, b: 3, c: 1, attachment: import_constants5.GL.DEPTH_ATTACHMENT },
+  "depth32float": { gl: import_constants5.GL.DEPTH_COMPONENT32F, b: 4, c: 1, attachment: import_constants5.GL.DEPTH_ATTACHMENT, renderbuffer: true },
   // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value.
-  "depth24plus-stencil8": { gl: import_constants5.default.DEPTH_STENCIL, gl1: import_constants5.default.DEPTH_STENCIL, b: 4, c: 2, p: 1, attachment: import_constants5.default.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true, depthTexture: true },
+  "depth24plus-stencil8": { gl: import_constants5.GL.DEPTH_STENCIL, gl1: import_constants5.GL.DEPTH_STENCIL, b: 4, c: 2, p: 1, attachment: import_constants5.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true, depthTexture: true },
   // "depth24unorm-stencil8" feature
-  "depth24unorm-stencil8": { gl: import_constants5.default.DEPTH24_STENCIL8, b: 4, c: 2, p: 1, attachment: import_constants5.default.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
+  "depth24unorm-stencil8": { gl: import_constants5.GL.DEPTH24_STENCIL8, b: 4, c: 2, p: 1, attachment: import_constants5.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
   // "depth32float-stencil8" feature
-  "depth32float-stencil8": { gl: import_constants5.default.DEPTH32F_STENCIL8, b: 5, c: 2, p: 1, attachment: import_constants5.default.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
+  "depth32float-stencil8": { gl: import_constants5.GL.DEPTH32F_STENCIL8, b: 5, c: 2, p: 1, attachment: import_constants5.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
   // BC compressed formats: check device.features.has("texture-compression-bc");
-  "bc1-rgb-unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGB_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc1-rgb-unorm-srgb-webgl": { gl: import_constants5.default.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc1-rgba-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc1-rgba-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc2-rgba-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_S3TC_DXT3_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc2-rgba-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc3-rgba-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_S3TC_DXT5_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc3-rgba-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc4-r-unorm": { gl: import_constants5.default.COMPRESSED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc4-r-snorm": { gl: import_constants5.default.COMPRESSED_SIGNED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc5-rg-unorm": { gl: import_constants5.default.COMPRESSED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc5-rg-snorm": { gl: import_constants5.default.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc6h-rgb-ufloat": { gl: import_constants5.default.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc6h-rgb-float": { gl: import_constants5.default.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc7-rgba-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc7-rgba-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
+  "bc1-rgb-unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGB_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
+  "bc1-rgb-unorm-srgb-webgl": { gl: import_constants5.GL.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc1-rgba-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
+  "bc1-rgba-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc2-rgba-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_S3TC_DXT3_EXT, x: X_S3TC, f: texture_compression_bc },
+  "bc2-rgba-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc3-rgba-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_S3TC_DXT5_EXT, x: X_S3TC, f: texture_compression_bc },
+  "bc3-rgba-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc4-r-unorm": { gl: import_constants5.GL.COMPRESSED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
+  "bc4-r-snorm": { gl: import_constants5.GL.COMPRESSED_SIGNED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
+  "bc5-rg-unorm": { gl: import_constants5.GL.COMPRESSED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
+  "bc5-rg-snorm": { gl: import_constants5.GL.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
+  "bc6h-rgb-ufloat": { gl: import_constants5.GL.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
+  "bc6h-rgb-float": { gl: import_constants5.GL.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
+  "bc7-rgba-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
+  "bc7-rgba-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
   // WEBGL_compressed_texture_etc: device.features.has("texture-compression-etc2")
   // Note: Supposedly guaranteed availability compressed formats in WebGL2, but through CPU decompression
-  "etc2-rgb8unorm": { gl: import_constants5.default.COMPRESSED_RGB8_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8a1unorm": { gl: import_constants5.default.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8a1unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
-  "etc2-rgba8unorm": { gl: import_constants5.default.COMPRESSED_RGBA8_ETC2_EAC, f: texture_compression_etc2 },
-  "etc2-rgba8unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, f: texture_compression_etc2 },
-  "eac-r11unorm": { gl: import_constants5.default.COMPRESSED_R11_EAC, f: texture_compression_etc2 },
-  "eac-r11snorm": { gl: import_constants5.default.COMPRESSED_SIGNED_R11_EAC, f: texture_compression_etc2 },
-  "eac-rg11unorm": { gl: import_constants5.default.COMPRESSED_RG11_EAC, f: texture_compression_etc2 },
-  "eac-rg11snorm": { gl: import_constants5.default.COMPRESSED_SIGNED_RG11_EAC, f: texture_compression_etc2 },
+  "etc2-rgb8unorm": { gl: import_constants5.GL.COMPRESSED_RGB8_ETC2, f: texture_compression_etc2 },
+  "etc2-rgb8unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ETC2, f: texture_compression_etc2 },
+  "etc2-rgb8a1unorm": { gl: import_constants5.GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
+  "etc2-rgb8a1unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
+  "etc2-rgba8unorm": { gl: import_constants5.GL.COMPRESSED_RGBA8_ETC2_EAC, f: texture_compression_etc2 },
+  "etc2-rgba8unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, f: texture_compression_etc2 },
+  "eac-r11unorm": { gl: import_constants5.GL.COMPRESSED_R11_EAC, f: texture_compression_etc2 },
+  "eac-r11snorm": { gl: import_constants5.GL.COMPRESSED_SIGNED_R11_EAC, f: texture_compression_etc2 },
+  "eac-rg11unorm": { gl: import_constants5.GL.COMPRESSED_RG11_EAC, f: texture_compression_etc2 },
+  "eac-rg11snorm": { gl: import_constants5.GL.COMPRESSED_SIGNED_RG11_EAC, f: texture_compression_etc2 },
   // X_ASTC compressed formats: device.features.has("texture-compression-astc")
-  "astc-4x4-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_4x4_KHR, f: texture_compression_astc },
-  "astc-4x4-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, f: texture_compression_astc },
-  "astc-5x4-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_5x4_KHR, f: texture_compression_astc },
-  "astc-5x4-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, f: texture_compression_astc },
-  "astc-5x5-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_5x5_KHR, f: texture_compression_astc },
-  "astc-5x5-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, f: texture_compression_astc },
-  "astc-6x5-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_6x5_KHR, f: texture_compression_astc },
-  "astc-6x5-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, f: texture_compression_astc },
-  "astc-6x6-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_6x6_KHR, f: texture_compression_astc },
-  "astc-6x6-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, f: texture_compression_astc },
-  "astc-8x5-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_8x5_KHR, f: texture_compression_astc },
-  "astc-8x5-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, f: texture_compression_astc },
-  "astc-8x6-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_8x6_KHR, f: texture_compression_astc },
-  "astc-8x6-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, f: texture_compression_astc },
-  "astc-8x8-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_8x8_KHR, f: texture_compression_astc },
-  "astc-8x8-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, f: texture_compression_astc },
-  "astc-10x5-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x5-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x6-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_10x6_KHR, f: texture_compression_astc },
-  "astc-10x6-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, f: texture_compression_astc },
-  "astc-10x8-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_10x8_KHR, f: texture_compression_astc },
-  "astc-10x8-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, f: texture_compression_astc },
-  "astc-10x10-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x10-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-12x10-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_12x10_KHR, f: texture_compression_astc },
-  "astc-12x10-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, f: texture_compression_astc },
-  "astc-12x12-unorm": { gl: import_constants5.default.COMPRESSED_RGBA_ASTC_12x12_KHR, f: texture_compression_astc },
-  "astc-12x12-unorm-srgb": { gl: import_constants5.default.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, f: texture_compression_astc },
+  "astc-4x4-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_4x4_KHR, f: texture_compression_astc },
+  "astc-4x4-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, f: texture_compression_astc },
+  "astc-5x4-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_5x4_KHR, f: texture_compression_astc },
+  "astc-5x4-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, f: texture_compression_astc },
+  "astc-5x5-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_5x5_KHR, f: texture_compression_astc },
+  "astc-5x5-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, f: texture_compression_astc },
+  "astc-6x5-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_6x5_KHR, f: texture_compression_astc },
+  "astc-6x5-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, f: texture_compression_astc },
+  "astc-6x6-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_6x6_KHR, f: texture_compression_astc },
+  "astc-6x6-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, f: texture_compression_astc },
+  "astc-8x5-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_8x5_KHR, f: texture_compression_astc },
+  "astc-8x5-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, f: texture_compression_astc },
+  "astc-8x6-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_8x6_KHR, f: texture_compression_astc },
+  "astc-8x6-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, f: texture_compression_astc },
+  "astc-8x8-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_8x8_KHR, f: texture_compression_astc },
+  "astc-8x8-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, f: texture_compression_astc },
+  "astc-10x5-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
+  "astc-10x5-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
+  "astc-10x6-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_10x6_KHR, f: texture_compression_astc },
+  "astc-10x6-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, f: texture_compression_astc },
+  "astc-10x8-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_10x8_KHR, f: texture_compression_astc },
+  "astc-10x8-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, f: texture_compression_astc },
+  "astc-10x10-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
+  "astc-10x10-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
+  "astc-12x10-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_12x10_KHR, f: texture_compression_astc },
+  "astc-12x10-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, f: texture_compression_astc },
+  "astc-12x12-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_12x12_KHR, f: texture_compression_astc },
+  "astc-12x12-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, f: texture_compression_astc },
   // WEBGL_compressed_texture_pvrtc
-  "pvrtc-rgb4unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGB_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rgba4unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rbg2unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGB_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rgba2unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgb4unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgba4unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rbg2unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgba2unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
   // WEBGL_compressed_texture_etc1
-  "etc1-rbg-unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGB_ETC1_WEBGL, f: texture_compression_etc1_webgl },
+  "etc1-rbg-unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGB_ETC1_WEBGL, f: texture_compression_etc1_webgl },
   // WEBGL_compressed_texture_atc
-  "atc-rgb-unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGB_ATC_WEBGL, f: texture_compression_atc_webgl },
-  "atc-rgba-unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL, f: texture_compression_atc_webgl },
-  "atc-rgbai-unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, f: texture_compression_atc_webgl }
+  "atc-rgb-unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGB_ATC_WEBGL, f: texture_compression_atc_webgl },
+  "atc-rgba-unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL, f: texture_compression_atc_webgl },
+  "atc-rgbai-unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, f: texture_compression_atc_webgl }
 };
 var DATA_FORMAT_CHANNELS = {
-  [import_constants5.default.RED]: 1,
-  [import_constants5.default.RED_INTEGER]: 1,
-  [import_constants5.default.RG]: 2,
-  [import_constants5.default.RG_INTEGER]: 2,
-  [import_constants5.default.RGB]: 3,
-  [import_constants5.default.RGB_INTEGER]: 3,
-  [import_constants5.default.RGBA]: 4,
-  [import_constants5.default.RGBA_INTEGER]: 4,
-  [import_constants5.default.DEPTH_COMPONENT]: 1,
-  [import_constants5.default.DEPTH_STENCIL]: 1,
-  [import_constants5.default.ALPHA]: 1,
-  [import_constants5.default.LUMINANCE]: 1,
-  [import_constants5.default.LUMINANCE_ALPHA]: 2
+  [import_constants5.GL.RED]: 1,
+  [import_constants5.GL.RED_INTEGER]: 1,
+  [import_constants5.GL.RG]: 2,
+  [import_constants5.GL.RG_INTEGER]: 2,
+  [import_constants5.GL.RGB]: 3,
+  [import_constants5.GL.RGB_INTEGER]: 3,
+  [import_constants5.GL.RGBA]: 4,
+  [import_constants5.GL.RGBA_INTEGER]: 4,
+  [import_constants5.GL.DEPTH_COMPONENT]: 1,
+  [import_constants5.GL.DEPTH_STENCIL]: 1,
+  [import_constants5.GL.ALPHA]: 1,
+  [import_constants5.GL.LUMINANCE]: 1,
+  [import_constants5.GL.LUMINANCE_ALPHA]: 2
 };
 var TYPE_SIZES = {
-  [import_constants5.default.FLOAT]: 4,
-  [import_constants5.default.UNSIGNED_INT]: 4,
-  [import_constants5.default.INT]: 4,
-  [import_constants5.default.UNSIGNED_SHORT]: 2,
-  [import_constants5.default.SHORT]: 2,
-  [import_constants5.default.HALF_FLOAT]: 2,
-  [import_constants5.default.BYTE]: 1,
-  [import_constants5.default.UNSIGNED_BYTE]: 1
+  [import_constants5.GL.FLOAT]: 4,
+  [import_constants5.GL.UNSIGNED_INT]: 4,
+  [import_constants5.GL.INT]: 4,
+  [import_constants5.GL.UNSIGNED_SHORT]: 2,
+  [import_constants5.GL.SHORT]: 2,
+  [import_constants5.GL.HALF_FLOAT]: 2,
+  [import_constants5.GL.BYTE]: 1,
+  [import_constants5.GL.UNSIGNED_BYTE]: 1
 };
 function isTextureFormatSupported(gl, formatOrGL) {
   const format = convertGLToTextureFormat(formatOrGL);
@@ -1960,12 +1949,12 @@ function getDepthStencilAttachmentWebGL(format) {
   }
   return info.attachment;
 }
-function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat = import_constants5.default.RGBA, srcType = import_constants5.default.UNSIGNED_BYTE) {
+function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat = import_constants5.GL.RGBA, srcType = import_constants5.GL.UNSIGNED_BYTE) {
   let texture = null;
   let framebuffer = null;
   try {
     texture = gl.createTexture();
-    gl.bindTexture(import_constants5.default.TEXTURE_2D, texture);
+    gl.bindTexture(import_constants5.GL.TEXTURE_2D, texture);
     const level = 0;
     const width = 1;
     const height = 1;
@@ -1983,10 +1972,10 @@ function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat =
       pixel
     );
     framebuffer = gl.createFramebuffer();
-    gl.bindFramebuffer(import_constants5.default.FRAMEBUFFER, framebuffer);
-    gl.framebufferTexture2D(import_constants5.default.FRAMEBUFFER, import_constants5.default.COLOR_ATTACHMENT0, import_constants5.default.TEXTURE_2D, texture, 0);
-    const status = gl.checkFramebufferStatus(import_constants5.default.FRAMEBUFFER) === import_constants5.default.FRAMEBUFFER_COMPLETE;
-    gl.bindTexture(import_constants5.default.TEXTURE_2D, null);
+    gl.bindFramebuffer(import_constants5.GL.FRAMEBUFFER, framebuffer);
+    gl.framebufferTexture2D(import_constants5.GL.FRAMEBUFFER, import_constants5.GL.COLOR_ATTACHMENT0, import_constants5.GL.TEXTURE_2D, texture, 0);
+    const status = gl.checkFramebufferStatus(import_constants5.GL.FRAMEBUFFER) === import_constants5.GL.FRAMEBUFFER_COMPLETE;
+    gl.bindTexture(import_constants5.GL.TEXTURE_2D, null);
     return status;
   } finally {
     gl.deleteTexture(texture);
@@ -2001,42 +1990,42 @@ function getTextureFormatBytesPerPixel(formatOrGL, isWebGL23) {
   return channels * channelSize;
 }
 function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
-  if (format === import_constants5.default.RGBA || format === import_constants5.default.RGB) {
+  if (format === import_constants5.GL.RGBA || format === import_constants5.GL.RGB) {
     return format;
   }
   switch (dataFormat) {
     case "r":
-      return integer && !normalized ? import_constants5.default.RED_INTEGER : import_constants5.default.RED;
+      return integer && !normalized ? import_constants5.GL.RED_INTEGER : import_constants5.GL.RED;
     case "rg":
-      return integer && !normalized ? import_constants5.default.RG_INTEGER : import_constants5.default.RG;
+      return integer && !normalized ? import_constants5.GL.RG_INTEGER : import_constants5.GL.RG;
     case "rgb":
-      return integer && !normalized ? import_constants5.default.RGB_INTEGER : import_constants5.default.RGB;
+      return integer && !normalized ? import_constants5.GL.RGB_INTEGER : import_constants5.GL.RGB;
     case "rgba":
-      return integer && !normalized ? import_constants5.default.RGBA_INTEGER : import_constants5.default.RGBA;
+      return integer && !normalized ? import_constants5.GL.RGBA_INTEGER : import_constants5.GL.RGBA;
     default:
-      return import_constants5.default.RGBA;
+      return import_constants5.GL.RGBA;
   }
 }
 function getWebGLDataType(dataType) {
   switch (dataType) {
     case "uint8":
-      return import_constants5.default.UNSIGNED_BYTE;
+      return import_constants5.GL.UNSIGNED_BYTE;
     case "sint8":
-      return import_constants5.default.BYTE;
+      return import_constants5.GL.BYTE;
     case "uint16":
-      return import_constants5.default.UNSIGNED_SHORT;
+      return import_constants5.GL.UNSIGNED_SHORT;
     case "sint16":
-      return import_constants5.default.SHORT;
+      return import_constants5.GL.SHORT;
     case "uint32":
-      return import_constants5.default.UNSIGNED_INT;
+      return import_constants5.GL.UNSIGNED_INT;
     case "sint32":
-      return import_constants5.default.INT;
+      return import_constants5.GL.INT;
     case "float16":
-      return import_constants5.default.HALF_FLOAT;
+      return import_constants5.GL.HALF_FLOAT;
     case "float32":
-      return import_constants5.default.FLOAT;
+      return import_constants5.GL.FLOAT;
     default:
-      return import_constants5.default.UNSIGNED_BYTE;
+      return import_constants5.GL.UNSIGNED_BYTE;
   }
 }
 
@@ -2138,39 +2127,39 @@ var WEBGL_FEATURES = {
 };
 
 // src/adapter/device-helpers/device-limits.ts
-var import_constants6 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants6 = require("@luma.gl/constants");
 function getDeviceLimits(gl) {
   const gl2 = getWebGL2Context(gl);
   return {
     maxTextureDimension1D: 0,
     // WebGL does not support 1D textures
-    maxTextureDimension2D: gl.getParameter(import_constants6.default.MAX_TEXTURE_SIZE),
-    maxTextureDimension3D: gl2 ? gl2.getParameter(import_constants6.default.MAX_3D_TEXTURE_SIZE) : 0,
-    maxTextureArrayLayers: gl2 ? gl2.getParameter(import_constants6.default.MAX_ARRAY_TEXTURE_LAYERS) : 0,
+    maxTextureDimension2D: gl.getParameter(import_constants6.GL.MAX_TEXTURE_SIZE),
+    maxTextureDimension3D: gl2 ? gl2.getParameter(import_constants6.GL.MAX_3D_TEXTURE_SIZE) : 0,
+    maxTextureArrayLayers: gl2 ? gl2.getParameter(import_constants6.GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
     maxBindGroups: 1,
     // TBD
     maxDynamicUniformBuffersPerPipelineLayout: 0,
     // TBD
     maxDynamicStorageBuffersPerPipelineLayout: 0,
     // TBD
-    maxSampledTexturesPerShaderStage: gl.getParameter(import_constants6.default.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+    maxSampledTexturesPerShaderStage: gl.getParameter(import_constants6.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
     // TBD
-    maxSamplersPerShaderStage: gl.getParameter(import_constants6.default.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+    maxSamplersPerShaderStage: gl.getParameter(import_constants6.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
     maxStorageBuffersPerShaderStage: 0,
     // TBD
     maxStorageTexturesPerShaderStage: 0,
     // TBD
-    maxUniformBuffersPerShaderStage: gl2 ? gl2.getParameter(import_constants6.default.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
-    maxUniformBufferBindingSize: gl2 ? gl2.getParameter(import_constants6.default.MAX_UNIFORM_BLOCK_SIZE) : 0,
+    maxUniformBuffersPerShaderStage: gl2 ? gl2.getParameter(import_constants6.GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
+    maxUniformBufferBindingSize: gl2 ? gl2.getParameter(import_constants6.GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
     maxStorageBufferBindingSize: 0,
-    minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(import_constants6.default.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
+    minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(import_constants6.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
     minStorageBufferOffsetAlignment: 0,
     // TBD
     maxVertexBuffers: 0,
-    maxVertexAttributes: gl.getParameter(import_constants6.default.MAX_VERTEX_ATTRIBS),
+    maxVertexAttributes: gl.getParameter(import_constants6.GL.MAX_VERTEX_ATTRIBS),
     maxVertexBufferArrayStride: 2048,
     // TBD, this is just the default value from WebGPU
-    maxInterStageShaderComponents: gl2 ? gl2.getParameter(import_constants6.default.MAX_VARYING_COMPONENTS) : 0,
+    maxInterStageShaderComponents: gl2 ? gl2.getParameter(import_constants6.GL.MAX_VARYING_COMPONENTS) : 0,
     maxComputeWorkgroupStorageSize: 0,
     // WebGL does not support compute shaders
     maxComputeInvocationsPerWorkgroup: 0,
@@ -2194,89 +2183,89 @@ function getWebGLLimits(gl) {
     return gl2 ? gl2.getParameter(pname) : defaultValue || 0;
   }
   return {
-    [import_constants6.default.ALIASED_LINE_WIDTH_RANGE]: get(import_constants6.default.ALIASED_LINE_WIDTH_RANGE),
-    [import_constants6.default.ALIASED_POINT_SIZE_RANGE]: get(import_constants6.default.ALIASED_POINT_SIZE_RANGE),
-    [import_constants6.default.MAX_TEXTURE_SIZE]: get(import_constants6.default.MAX_TEXTURE_SIZE),
-    [import_constants6.default.MAX_CUBE_MAP_TEXTURE_SIZE]: get(import_constants6.default.MAX_CUBE_MAP_TEXTURE_SIZE),
+    [import_constants6.GL.ALIASED_LINE_WIDTH_RANGE]: get(import_constants6.GL.ALIASED_LINE_WIDTH_RANGE),
+    [import_constants6.GL.ALIASED_POINT_SIZE_RANGE]: get(import_constants6.GL.ALIASED_POINT_SIZE_RANGE),
+    [import_constants6.GL.MAX_TEXTURE_SIZE]: get(import_constants6.GL.MAX_TEXTURE_SIZE),
+    [import_constants6.GL.MAX_CUBE_MAP_TEXTURE_SIZE]: get(import_constants6.GL.MAX_CUBE_MAP_TEXTURE_SIZE),
     // GLint
-    [import_constants6.default.MAX_TEXTURE_IMAGE_UNITS]: get(import_constants6.default.MAX_TEXTURE_IMAGE_UNITS),
+    [import_constants6.GL.MAX_TEXTURE_IMAGE_UNITS]: get(import_constants6.GL.MAX_TEXTURE_IMAGE_UNITS),
     // GLint
-    [import_constants6.default.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(import_constants6.default.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+    [import_constants6.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(import_constants6.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
     // GLint
-    [import_constants6.default.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(import_constants6.default.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+    [import_constants6.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(import_constants6.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
     // GLint
-    [import_constants6.default.MAX_RENDERBUFFER_SIZE]: get(import_constants6.default.MAX_RENDERBUFFER_SIZE),
+    [import_constants6.GL.MAX_RENDERBUFFER_SIZE]: get(import_constants6.GL.MAX_RENDERBUFFER_SIZE),
     // GLint
-    [import_constants6.default.MAX_VARYING_VECTORS]: get(import_constants6.default.MAX_VARYING_VECTORS),
+    [import_constants6.GL.MAX_VARYING_VECTORS]: get(import_constants6.GL.MAX_VARYING_VECTORS),
     // GLint
-    [import_constants6.default.MAX_VERTEX_ATTRIBS]: get(import_constants6.default.MAX_VERTEX_ATTRIBS),
+    [import_constants6.GL.MAX_VERTEX_ATTRIBS]: get(import_constants6.GL.MAX_VERTEX_ATTRIBS),
     // GLint
-    [import_constants6.default.MAX_VERTEX_UNIFORM_VECTORS]: get(import_constants6.default.MAX_VERTEX_UNIFORM_VECTORS),
+    [import_constants6.GL.MAX_VERTEX_UNIFORM_VECTORS]: get(import_constants6.GL.MAX_VERTEX_UNIFORM_VECTORS),
     // GLint
-    [import_constants6.default.MAX_FRAGMENT_UNIFORM_VECTORS]: get(import_constants6.default.MAX_FRAGMENT_UNIFORM_VECTORS),
+    [import_constants6.GL.MAX_FRAGMENT_UNIFORM_VECTORS]: get(import_constants6.GL.MAX_FRAGMENT_UNIFORM_VECTORS),
     // GLint
-    [import_constants6.default.MAX_VIEWPORT_DIMS]: get(import_constants6.default.MAX_VIEWPORT_DIMS),
+    [import_constants6.GL.MAX_VIEWPORT_DIMS]: get(import_constants6.GL.MAX_VIEWPORT_DIMS),
     // Extensions
-    [import_constants6.default.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: get(import_constants6.default.MAX_TEXTURE_MAX_ANISOTROPY_EXT),
+    [import_constants6.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: get(import_constants6.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT),
     // getMaxAnistropy(),
     // WebGL2 Limits
-    [import_constants6.default.MAX_3D_TEXTURE_SIZE]: get2(import_constants6.default.MAX_3D_TEXTURE_SIZE),
+    [import_constants6.GL.MAX_3D_TEXTURE_SIZE]: get2(import_constants6.GL.MAX_3D_TEXTURE_SIZE),
     //  GLint
-    [import_constants6.default.MAX_ARRAY_TEXTURE_LAYERS]: get2(import_constants6.default.MAX_ARRAY_TEXTURE_LAYERS),
+    [import_constants6.GL.MAX_ARRAY_TEXTURE_LAYERS]: get2(import_constants6.GL.MAX_ARRAY_TEXTURE_LAYERS),
     // GLint
-    [import_constants6.default.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(import_constants6.default.MAX_CLIENT_WAIT_TIMEOUT_WEBGL),
+    [import_constants6.GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(import_constants6.GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL),
     //  GLint64
-    [import_constants6.default.MAX_COLOR_ATTACHMENTS]: get2(import_constants6.default.MAX_COLOR_ATTACHMENTS),
+    [import_constants6.GL.MAX_COLOR_ATTACHMENTS]: get2(import_constants6.GL.MAX_COLOR_ATTACHMENTS),
     //  GLint
-    [import_constants6.default.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants6.default.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS),
+    [import_constants6.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants6.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS),
     // GLint64
-    [import_constants6.default.MAX_COMBINED_UNIFORM_BLOCKS]: get2(import_constants6.default.MAX_COMBINED_UNIFORM_BLOCKS),
+    [import_constants6.GL.MAX_COMBINED_UNIFORM_BLOCKS]: get2(import_constants6.GL.MAX_COMBINED_UNIFORM_BLOCKS),
     //  GLint
-    [import_constants6.default.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants6.default.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS),
+    [import_constants6.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants6.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS),
     // GLint64
-    [import_constants6.default.MAX_DRAW_BUFFERS]: get2(import_constants6.default.MAX_DRAW_BUFFERS),
+    [import_constants6.GL.MAX_DRAW_BUFFERS]: get2(import_constants6.GL.MAX_DRAW_BUFFERS),
     // GLint
-    [import_constants6.default.MAX_ELEMENT_INDEX]: get2(import_constants6.default.MAX_ELEMENT_INDEX),
+    [import_constants6.GL.MAX_ELEMENT_INDEX]: get2(import_constants6.GL.MAX_ELEMENT_INDEX),
     //  GLint64
-    [import_constants6.default.MAX_ELEMENTS_INDICES]: get2(import_constants6.default.MAX_ELEMENTS_INDICES),
+    [import_constants6.GL.MAX_ELEMENTS_INDICES]: get2(import_constants6.GL.MAX_ELEMENTS_INDICES),
     // GLint
-    [import_constants6.default.MAX_ELEMENTS_VERTICES]: get2(import_constants6.default.MAX_ELEMENTS_VERTICES),
+    [import_constants6.GL.MAX_ELEMENTS_VERTICES]: get2(import_constants6.GL.MAX_ELEMENTS_VERTICES),
     //  GLint
-    [import_constants6.default.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(import_constants6.default.MAX_FRAGMENT_INPUT_COMPONENTS),
+    [import_constants6.GL.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(import_constants6.GL.MAX_FRAGMENT_INPUT_COMPONENTS),
     //  GLint
-    [import_constants6.default.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(import_constants6.default.MAX_FRAGMENT_UNIFORM_BLOCKS),
+    [import_constants6.GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(import_constants6.GL.MAX_FRAGMENT_UNIFORM_BLOCKS),
     //  GLint
-    [import_constants6.default.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants6.default.MAX_FRAGMENT_UNIFORM_COMPONENTS),
+    [import_constants6.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants6.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS),
     //  GLint
-    [import_constants6.default.MAX_SAMPLES]: get2(import_constants6.default.MAX_SAMPLES),
+    [import_constants6.GL.MAX_SAMPLES]: get2(import_constants6.GL.MAX_SAMPLES),
     //  GLint
-    [import_constants6.default.MAX_SERVER_WAIT_TIMEOUT]: get2(import_constants6.default.MAX_SERVER_WAIT_TIMEOUT),
+    [import_constants6.GL.MAX_SERVER_WAIT_TIMEOUT]: get2(import_constants6.GL.MAX_SERVER_WAIT_TIMEOUT),
     //  GLint64
-    [import_constants6.default.MAX_TEXTURE_LOD_BIAS]: get2(import_constants6.default.MAX_TEXTURE_LOD_BIAS),
+    [import_constants6.GL.MAX_TEXTURE_LOD_BIAS]: get2(import_constants6.GL.MAX_TEXTURE_LOD_BIAS),
     // GLfloat
-    [import_constants6.default.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(import_constants6.default.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS),
+    [import_constants6.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(import_constants6.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS),
     //  GLint
-    [import_constants6.default.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(import_constants6.default.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS),
+    [import_constants6.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(import_constants6.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS),
     //  GLint
-    [import_constants6.default.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(import_constants6.default.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS),
+    [import_constants6.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(import_constants6.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS),
     // GLint
-    [import_constants6.default.MAX_UNIFORM_BLOCK_SIZE]: get2(import_constants6.default.MAX_UNIFORM_BLOCK_SIZE),
+    [import_constants6.GL.MAX_UNIFORM_BLOCK_SIZE]: get2(import_constants6.GL.MAX_UNIFORM_BLOCK_SIZE),
     // GLint64
-    [import_constants6.default.MAX_UNIFORM_BUFFER_BINDINGS]: get2(import_constants6.default.MAX_UNIFORM_BUFFER_BINDINGS),
+    [import_constants6.GL.MAX_UNIFORM_BUFFER_BINDINGS]: get2(import_constants6.GL.MAX_UNIFORM_BUFFER_BINDINGS),
     //  GLint
-    [import_constants6.default.MAX_VARYING_COMPONENTS]: get2(import_constants6.default.MAX_VARYING_COMPONENTS),
+    [import_constants6.GL.MAX_VARYING_COMPONENTS]: get2(import_constants6.GL.MAX_VARYING_COMPONENTS),
     // GLint
-    [import_constants6.default.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(import_constants6.default.MAX_VERTEX_OUTPUT_COMPONENTS),
+    [import_constants6.GL.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(import_constants6.GL.MAX_VERTEX_OUTPUT_COMPONENTS),
     // GLint
-    [import_constants6.default.MAX_VERTEX_UNIFORM_BLOCKS]: get2(import_constants6.default.MAX_VERTEX_UNIFORM_BLOCKS),
+    [import_constants6.GL.MAX_VERTEX_UNIFORM_BLOCKS]: get2(import_constants6.GL.MAX_VERTEX_UNIFORM_BLOCKS),
     //  GLint
-    [import_constants6.default.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants6.default.MAX_VERTEX_UNIFORM_COMPONENTS),
+    [import_constants6.GL.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants6.GL.MAX_VERTEX_UNIFORM_COMPONENTS),
     //  GLint
-    [import_constants6.default.MIN_PROGRAM_TEXEL_OFFSET]: get2(import_constants6.default.MIN_PROGRAM_TEXEL_OFFSET),
+    [import_constants6.GL.MIN_PROGRAM_TEXEL_OFFSET]: get2(import_constants6.GL.MIN_PROGRAM_TEXEL_OFFSET),
     // GLint
-    [import_constants6.default.MAX_PROGRAM_TEXEL_OFFSET]: get2(import_constants6.default.MAX_PROGRAM_TEXEL_OFFSET),
+    [import_constants6.GL.MAX_PROGRAM_TEXEL_OFFSET]: get2(import_constants6.GL.MAX_PROGRAM_TEXEL_OFFSET),
     // GLint
-    [import_constants6.default.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(import_constants6.default.UNIFORM_BUFFER_OFFSET_ALIGNMENT)
+    [import_constants6.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(import_constants6.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT)
     // GLint
   };
 }
@@ -2286,7 +2275,7 @@ var import_api15 = require("@luma.gl/api");
 
 // src/adapter/resources/webgl-framebuffer.ts
 var import_api14 = require("@luma.gl/api");
-var import_constants13 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants13 = require("@luma.gl/constants");
 
 // src/adapter/resources/webgl-texture.ts
 var import_api9 = require("@luma.gl/api");
@@ -2328,7 +2317,7 @@ var import_constants8 = require("@luma.gl/constants");
 
 // src/adapter/converters/device-parameters.ts
 var import_api6 = require("@luma.gl/api");
-var import_constants7 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants7 = require("@luma.gl/constants");
 function withGLParameters(device, parameters, func) {
   if ((0, import_api6.isObjectEmpty)(parameters)) {
     return func(device);
@@ -2359,23 +2348,23 @@ function setDeviceParameters(device, parameters) {
   if (parameters.cullMode) {
     switch (parameters.cullMode) {
       case "none":
-        gl.disable(import_constants7.default.CULL_FACE);
+        gl.disable(import_constants7.GL.CULL_FACE);
         break;
       case "front":
-        gl.enable(import_constants7.default.CULL_FACE);
-        gl.cullFace(import_constants7.default.FRONT);
+        gl.enable(import_constants7.GL.CULL_FACE);
+        gl.cullFace(import_constants7.GL.FRONT);
         break;
       case "back":
-        gl.enable(import_constants7.default.CULL_FACE);
-        gl.cullFace(import_constants7.default.BACK);
+        gl.enable(import_constants7.GL.CULL_FACE);
+        gl.cullFace(import_constants7.GL.BACK);
         break;
     }
   }
   if (parameters.frontFace) {
     gl.frontFace(
       map("frontFace", parameters.frontFace, {
-        ccw: import_constants7.default.CCW,
-        cw: import_constants7.default.CW
+        ccw: import_constants7.GL.CCW,
+        cw: import_constants7.GL.CW
       })
     );
   }
@@ -2386,13 +2375,13 @@ function setDeviceParameters(device, parameters) {
     gl.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
   }
   if (parameters.depthCompare) {
-    parameters.depthCompare !== "always" ? gl.enable(import_constants7.default.DEPTH_TEST) : gl.disable(import_constants7.default.DEPTH_TEST);
+    parameters.depthCompare !== "always" ? gl.enable(import_constants7.GL.DEPTH_TEST) : gl.disable(import_constants7.GL.DEPTH_TEST);
     gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
   }
   if (parameters.stencilWriteMask) {
     const mask = parameters.stencilWriteMask;
-    gl.stencilMaskSeparate(import_constants7.default.FRONT, mask);
-    gl.stencilMaskSeparate(import_constants7.default.BACK, mask);
+    gl.stencilMaskSeparate(import_constants7.GL.FRONT, mask);
+    gl.stencilMaskSeparate(import_constants7.GL.BACK, mask);
   }
   if (parameters.stencilReadMask) {
     import_api6.log.warn("stencilReadMask not supported under WebGL");
@@ -2400,9 +2389,9 @@ function setDeviceParameters(device, parameters) {
   if (parameters.stencilCompare) {
     const mask = parameters.stencilReadMask || 4294967295;
     const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare);
-    parameters.stencilCompare !== "always" ? gl.enable(import_constants7.default.STENCIL_TEST) : gl.disable(import_constants7.default.STENCIL_TEST);
-    gl.stencilFuncSeparate(import_constants7.default.FRONT, glValue, 0, mask);
-    gl.stencilFuncSeparate(import_constants7.default.BACK, glValue, 0, mask);
+    parameters.stencilCompare !== "always" ? gl.enable(import_constants7.GL.STENCIL_TEST) : gl.disable(import_constants7.GL.STENCIL_TEST);
+    gl.stencilFuncSeparate(import_constants7.GL.FRONT, glValue, 0, mask);
+    gl.stencilFuncSeparate(import_constants7.GL.BACK, glValue, 0, mask);
   }
   if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
     const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation);
@@ -2411,32 +2400,32 @@ function setDeviceParameters(device, parameters) {
       "stencilDepthFailOperation",
       parameters.stencilDepthFailOperation
     );
-    gl.stencilOpSeparate(import_constants7.default.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(import_constants7.default.BACK, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(import_constants7.GL.FRONT, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(import_constants7.GL.BACK, sfail, dpfail, dppass);
   }
 }
 function convertCompareFunction(parameter, value) {
   return map(parameter, value, {
-    never: import_constants7.default.NEVER,
-    less: import_constants7.default.LESS,
-    equal: import_constants7.default.EQUAL,
-    "less-equal": import_constants7.default.LEQUAL,
-    greater: import_constants7.default.GREATER,
-    "not-equal": import_constants7.default.NOTEQUAL,
-    "greater-equal": import_constants7.default.GEQUAL,
-    always: import_constants7.default.ALWAYS
+    never: import_constants7.GL.NEVER,
+    less: import_constants7.GL.LESS,
+    equal: import_constants7.GL.EQUAL,
+    "less-equal": import_constants7.GL.LEQUAL,
+    greater: import_constants7.GL.GREATER,
+    "not-equal": import_constants7.GL.NOTEQUAL,
+    "greater-equal": import_constants7.GL.GEQUAL,
+    always: import_constants7.GL.ALWAYS
   });
 }
 function convertStencilOperation(parameter, value) {
   return map(parameter, value, {
-    keep: import_constants7.default.KEEP,
-    zero: import_constants7.default.ZERO,
-    replace: import_constants7.default.REPLACE,
-    invert: import_constants7.default.INVERT,
-    "increment-clamp": import_constants7.default.INCR,
-    "decrement-clamp": import_constants7.default.DECR,
-    "increment-wrap": import_constants7.default.INCR_WRAP,
-    "decrement-wrap": import_constants7.default.DECR_WRAP
+    keep: import_constants7.GL.KEEP,
+    zero: import_constants7.GL.ZERO,
+    replace: import_constants7.GL.REPLACE,
+    invert: import_constants7.GL.INVERT,
+    "increment-clamp": import_constants7.GL.INCR,
+    "decrement-clamp": import_constants7.GL.DECR,
+    "increment-wrap": import_constants7.GL.INCR_WRAP,
+    "decrement-wrap": import_constants7.GL.DECR_WRAP
   });
 }
 function message(parameter, value) {
@@ -2528,7 +2517,7 @@ function updateSamplerParametersForNPOT(parameters) {
 
 // src/adapter/resources/webgl-buffer.ts
 var import_api7 = require("@luma.gl/api");
-var import_constants9 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants9 = require("@luma.gl/constants");
 var DEBUG_DATA_LENGTH = 10;
 var WEBGLBuffer = class extends import_api7.Buffer {
   // accessor: {};
@@ -2593,7 +2582,7 @@ var WEBGLBuffer = class extends import_api7.Buffer {
   write(data, byteOffset = 0) {
     const srcOffset = 0;
     const byteLength = void 0;
-    const target = this.device.isWebGL2 ? import_constants9.default.COPY_WRITE_BUFFER : this.target;
+    const target = this.device.isWebGL2 ? import_constants9.GL.COPY_WRITE_BUFFER : this.target;
     this.gl.bindBuffer(target, this.handle);
     if (srcOffset !== 0 || byteLength !== void 0) {
       this.device.assertWebGL2();
@@ -2609,9 +2598,9 @@ var WEBGLBuffer = class extends import_api7.Buffer {
       this.device.assertWebGL2();
       const data = new Uint8Array(byteLength);
       const dstOffset = 0;
-      this.gl.bindBuffer(import_constants9.default.COPY_READ_BUFFER, this.handle);
-      this.gl2.getBufferSubData(import_constants9.default.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
-      this.gl.bindBuffer(import_constants9.default.COPY_READ_BUFFER, null);
+      this.gl.bindBuffer(import_constants9.GL.COPY_READ_BUFFER, this.handle);
+      this.gl2.getBufferSubData(import_constants9.GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
+      this.gl.bindBuffer(import_constants9.GL.COPY_READ_BUFFER, null);
       return data;
     });
   }
@@ -2628,27 +2617,27 @@ var WEBGLBuffer = class extends import_api7.Buffer {
 };
 function getWebGLTarget(usage) {
   if (usage & import_api7.Buffer.INDEX) {
-    return import_constants9.default.ELEMENT_ARRAY_BUFFER;
+    return import_constants9.GL.ELEMENT_ARRAY_BUFFER;
   }
   if (usage & import_api7.Buffer.VERTEX) {
-    return import_constants9.default.ARRAY_BUFFER;
+    return import_constants9.GL.ARRAY_BUFFER;
   }
   if (usage & import_api7.Buffer.UNIFORM) {
-    return import_constants9.default.UNIFORM_BUFFER;
+    return import_constants9.GL.UNIFORM_BUFFER;
   }
-  return import_constants9.default.ARRAY_BUFFER;
+  return import_constants9.GL.ARRAY_BUFFER;
 }
 function getWebGLUsage(usage) {
   if (usage & import_api7.Buffer.INDEX) {
-    return import_constants9.default.STATIC_DRAW;
+    return import_constants9.GL.STATIC_DRAW;
   }
   if (usage & import_api7.Buffer.VERTEX) {
-    return import_constants9.default.STATIC_DRAW;
+    return import_constants9.GL.STATIC_DRAW;
   }
   if (usage & import_api7.Buffer.UNIFORM) {
-    return import_constants9.default.DYNAMIC_DRAW;
+    return import_constants9.GL.DYNAMIC_DRAW;
   }
-  return import_constants9.default.DYNAMIC_DRAW;
+  return import_constants9.GL.DYNAMIC_DRAW;
 }
 
 // src/adapter/resources/webgl-sampler.ts
@@ -3410,7 +3399,7 @@ function logParameters(parameters) {
 
 // src/adapter/objects/webgl-renderbuffer.ts
 var import_api13 = require("@luma.gl/api");
-var import_constants12 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants12 = require("@luma.gl/constants");
 
 // src/adapter/objects/webgl-resource.ts
 var import_api12 = require("@luma.gl/api");
@@ -3676,13 +3665,13 @@ var _WEBGLRenderbuffer = class extends WebGLResource {
     const { format, width, height, samples } = props;
     (0, import_api13.assert)(format, "Needs format");
     this.trackDeallocatedMemory();
-    this.gl.bindRenderbuffer(import_constants12.default.RENDERBUFFER, this.handle);
+    this.gl.bindRenderbuffer(import_constants12.GL.RENDERBUFFER, this.handle);
     if (samples !== 0 && this.device.isWebGL2) {
-      this.gl2.renderbufferStorageMultisample(import_constants12.default.RENDERBUFFER, samples, this.glFormat, width, height);
+      this.gl2.renderbufferStorageMultisample(import_constants12.GL.RENDERBUFFER, samples, this.glFormat, width, height);
     } else {
-      this.gl.renderbufferStorage(import_constants12.default.RENDERBUFFER, this.glFormat, width, height);
+      this.gl.renderbufferStorage(import_constants12.GL.RENDERBUFFER, this.glFormat, width, height);
     }
-    this.gl.bindRenderbuffer(import_constants12.default.RENDERBUFFER, null);
+    this.gl.bindRenderbuffer(import_constants12.GL.RENDERBUFFER, null);
     this.trackAllocatedMemory(
       width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat, this.device.isWebGL2)
     );
@@ -3696,7 +3685,7 @@ var _WEBGLRenderbuffer = class extends WebGLResource {
     this.trackDeallocatedMemory();
   }
   _bindHandle(handle) {
-    this.gl.bindRenderbuffer(import_constants12.default.RENDERBUFFER, handle);
+    this.gl.bindRenderbuffer(import_constants12.GL.RENDERBUFFER, handle);
   }
 };
 var WEBGLRenderbuffer = _WEBGLRenderbuffer;
@@ -3722,10 +3711,10 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
     if (!isDefaultFramebuffer) {
       device.setSpectorMetadata(this.handle, { id: this.props.id, props: this.props });
       this.autoCreateAttachmentTextures();
-      this.gl.bindFramebuffer(import_constants13.default.FRAMEBUFFER, this.handle);
+      this.gl.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, this.handle);
       for (let i = 0; i < this.colorAttachments.length; ++i) {
         const attachment = this.colorAttachments[i];
-        const attachmentPoint = import_constants13.default.COLOR_ATTACHMENT0 + i;
+        const attachmentPoint = import_constants13.GL.COLOR_ATTACHMENT0 + i;
         if (attachment) {
           this._attachOne(attachmentPoint, attachment);
         }
@@ -3736,7 +3725,7 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
           this.depthStencilAttachment
         );
       }
-      this.gl.bindFramebuffer(import_constants13.default.FRAMEBUFFER, null);
+      this.gl.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, null);
     }
     if (props.check !== false) {
       this._checkStatus();
@@ -3756,9 +3745,9 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
   /** Check the status */
   _checkStatus() {
     const { gl } = this;
-    const prevHandle2 = gl.bindFramebuffer(import_constants13.default.FRAMEBUFFER, this.handle);
-    const status = gl.checkFramebufferStatus(import_constants13.default.FRAMEBUFFER);
-    gl.bindFramebuffer(import_constants13.default.FRAMEBUFFER, prevHandle2 || null);
+    const prevHandle2 = gl.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, this.handle);
+    const status = gl.checkFramebufferStatus(import_constants13.GL.FRAMEBUFFER);
+    gl.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, prevHandle2 || null);
     if (status !== gl.FRAMEBUFFER_COMPLETE) {
       throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
     }
@@ -3815,9 +3804,9 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
   }
   _attachWEBGLRenderbuffer(attachment, renderbuffer) {
     this.gl.framebufferRenderbuffer(
-      import_constants13.default.FRAMEBUFFER,
+      import_constants13.GL.FRAMEBUFFER,
       attachment,
-      import_constants13.default.RENDERBUFFER,
+      import_constants13.GL.RENDERBUFFER,
       renderbuffer.handle
     );
   }
@@ -3831,17 +3820,17 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
     const { gl, gl2 } = this.device;
     gl.bindTexture(texture.target, texture.handle);
     switch (texture.target) {
-      case import_constants13.default.TEXTURE_2D_ARRAY:
-      case import_constants13.default.TEXTURE_3D:
+      case import_constants13.GL.TEXTURE_2D_ARRAY:
+      case import_constants13.GL.TEXTURE_3D:
         this.device.assertWebGL2();
-        gl2 == null ? void 0 : gl2.framebufferTextureLayer(import_constants13.default.FRAMEBUFFER, attachment, texture.target, level, layer);
+        gl2 == null ? void 0 : gl2.framebufferTextureLayer(import_constants13.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
         break;
-      case import_constants13.default.TEXTURE_CUBE_MAP:
+      case import_constants13.GL.TEXTURE_CUBE_MAP:
         const face = mapIndexToCubeMapFace(layer);
-        gl.framebufferTexture2D(import_constants13.default.FRAMEBUFFER, attachment, face, texture.handle, level);
+        gl.framebufferTexture2D(import_constants13.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
         break;
-      case import_constants13.default.TEXTURE_2D:
-        gl.framebufferTexture2D(import_constants13.default.FRAMEBUFFER, attachment, import_constants13.default.TEXTURE_2D, texture.handle, level);
+      case import_constants13.GL.TEXTURE_2D:
+        gl.framebufferTexture2D(import_constants13.GL.FRAMEBUFFER, attachment, import_constants13.GL.TEXTURE_2D, texture.handle, level);
         break;
       default:
         (0, import_api14.assert)(false, "Illegal texture type");
@@ -3850,21 +3839,21 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
   }
 };
 function mapIndexToCubeMapFace(layer) {
-  return layer < import_constants13.default.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants13.default.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
+  return layer < import_constants13.GL.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants13.GL.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
 }
 function _getFrameBufferStatus(status) {
   switch (status) {
-    case import_constants13.default.FRAMEBUFFER_COMPLETE:
+    case import_constants13.GL.FRAMEBUFFER_COMPLETE:
       return "success";
-    case import_constants13.default.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+    case import_constants13.GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
       return "Mismatched attachments";
-    case import_constants13.default.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+    case import_constants13.GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
       return "No attachments";
-    case import_constants13.default.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+    case import_constants13.GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
       return "Height/width mismatch";
-    case import_constants13.default.FRAMEBUFFER_UNSUPPORTED:
+    case import_constants13.GL.FRAMEBUFFER_UNSUPPORTED:
       return "Unsupported or split attachments";
-    case import_constants13.default.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
+    case import_constants13.GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
       return "Samples mismatch";
     default:
       return `${status}`;
@@ -3981,7 +3970,7 @@ function initializeSpectorJS(props) {
 
 // src/context/debug/webgl-developer-tools.ts
 var import_api17 = require("@luma.gl/api");
-var import_constants14 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants14 = require("@luma.gl/constants");
 var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
 function getContextData2(gl) {
   gl.luma = gl.luma || {};
@@ -4015,15 +4004,15 @@ function getDebugContext(gl, props) {
   if (data.debugContext) {
     return data.debugContext;
   }
-  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants14.default), gl));
+  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants14.GL), gl));
   const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(
     gl,
     onGLError.bind(null, props),
     onValidateGLFunc.bind(null, props)
   );
-  for (const key in import_constants14.default) {
-    if (!(key in glDebug) && typeof import_constants14.default[key] === "number") {
-      glDebug[key] = import_constants14.default[key];
+  for (const key in import_constants14.GL) {
+    if (!(key in glDebug) && typeof import_constants14.GL[key] === "number") {
+      glDebug[key] = import_constants14.GL[key];
     }
   }
   class WebGLDebugContext {
@@ -4080,13 +4069,13 @@ function onValidateGLFunc(props, functionName, functionArgs) {
   }
 }
 
-// src/classic/buffer.ts
+// src/classic/buffer-with-accessor.ts
 var import_api19 = require("@luma.gl/api");
-var import_constants17 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants17 = require("@luma.gl/constants");
 
 // src/classic/accessor.ts
 var import_api18 = require("@luma.gl/api");
-var import_constants16 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants16 = require("@luma.gl/constants");
 
 // src/classic/typed-array-utils.ts
 var import_constants15 = require("@luma.gl/constants");
@@ -4143,7 +4132,7 @@ function getTypedArrayFromGLType(glType, options) {
 var DEFAULT_ACCESSOR_VALUES = {
   offset: 0,
   stride: 0,
-  type: import_constants16.default.FLOAT,
+  type: import_constants16.GL.FLOAT,
   size: 1,
   divisor: 0,
   normalized: false,
@@ -4157,12 +4146,12 @@ var PROP_CHECKS = {
 };
 var Accessor = class {
   static getBytesPerElement(accessor) {
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants16.default.FLOAT);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants16.GL.FLOAT);
     return ArrayType.BYTES_PER_ELEMENT;
   }
   static getBytesPerVertex(accessor) {
     (0, import_api18.assert)(accessor.size);
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants16.default.FLOAT);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants16.GL.FLOAT);
     return ArrayType.BYTES_PER_ELEMENT * accessor.size;
   }
   // Combines (merges) a list of accessors. On top of default values
@@ -4193,7 +4182,7 @@ var Accessor = class {
     props = (0, import_api18.checkProps)("Accessor", props, PROP_CHECKS);
     if (props.type !== void 0) {
       this.type = props.type;
-      if (props.type === import_constants16.default.INT || props.type === import_constants16.default.UNSIGNED_INT) {
+      if (props.type === import_constants16.GL.INT || props.type === import_constants16.GL.UNSIGNED_INT) {
         this.integer = true;
       }
     }
@@ -4256,7 +4245,7 @@ var Accessor = class {
   }
 };
 
-// src/classic/buffer.ts
+// src/classic/buffer-with-accessor.ts
 var DEBUG_DATA_LENGTH2 = 10;
 var DEPRECATED_PROPS = {
   offset: "accessor.offset",
@@ -4294,7 +4283,7 @@ function getWEBGLBufferProps(props) {
   }
   return bufferProps;
 }
-var ClassicBuffer = class extends WEBGLBuffer {
+var BufferWithAccessor = class extends WEBGLBuffer {
   constructor(device, props = {}) {
     super(WebGLDevice.attach(device), getWEBGLBufferProps(props));
     this.setAccessor(Object.assign({}, props, props.accessor));
@@ -4328,7 +4317,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
       props = { byteLength: props };
     }
     props = (0, import_api19.checkProps)("Buffer", props, PROP_CHECKS_INITIALIZE);
-    this.webglUsage = props.webglUsage || import_constants17.default.STATIC_DRAW;
+    this.webglUsage = props.webglUsage || import_constants17.GL.STATIC_DRAW;
     this.debugData = null;
     this.setAccessor(Object.assign({}, props, props.accessor));
     if (props.data) {
@@ -4382,7 +4371,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
     const { data, offset = 0, srcOffset = 0 } = options;
     const byteLength = options.byteLength || options.length;
     (0, import_api19.assert)(data);
-    const target = this.gl.webgl2 ? import_constants17.default.COPY_WRITE_BUFFER : this.target;
+    const target = this.gl.webgl2 ? import_constants17.GL.COPY_WRITE_BUFFER : this.target;
     this.gl.bindBuffer(target, this.handle);
     if (srcOffset !== 0 || byteLength !== void 0) {
       assertWebGL2Context(this.gl);
@@ -4403,11 +4392,11 @@ var ClassicBuffer = class extends WEBGLBuffer {
     const { sourceBuffer, readOffset = 0, writeOffset = 0, size } = options;
     const { gl, gl2 } = this;
     assertWebGL2Context(gl);
-    gl.bindBuffer(import_constants17.default.COPY_READ_BUFFER, sourceBuffer.handle);
-    gl.bindBuffer(import_constants17.default.COPY_WRITE_BUFFER, this.handle);
-    gl2 == null ? void 0 : gl2.copyBufferSubData(import_constants17.default.COPY_READ_BUFFER, import_constants17.default.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
-    gl.bindBuffer(import_constants17.default.COPY_READ_BUFFER, null);
-    gl.bindBuffer(import_constants17.default.COPY_WRITE_BUFFER, null);
+    gl.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, sourceBuffer.handle);
+    gl.bindBuffer(import_constants17.GL.COPY_WRITE_BUFFER, this.handle);
+    gl2 == null ? void 0 : gl2.copyBufferSubData(import_constants17.GL.COPY_READ_BUFFER, import_constants17.GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+    gl.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, null);
+    gl.bindBuffer(import_constants17.GL.COPY_WRITE_BUFFER, null);
     this.debugData = null;
     return this;
   }
@@ -4420,7 +4409,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
     let { dstData = null, length = 0 } = options || {};
     const { srcByteOffset = 0, dstOffset = 0 } = options || {};
     assertWebGL2Context(this.gl);
-    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants17.default.FLOAT, { clamped: false });
+    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants17.GL.FLOAT, { clamped: false });
     const sourceAvailableElementCount = this._getAvailableElementCount(srcByteOffset);
     const dstElementOffset = dstOffset;
     let dstAvailableElementCount;
@@ -4439,9 +4428,9 @@ var ClassicBuffer = class extends WEBGLBuffer {
     length = length || copyElementCount;
     (0, import_api19.assert)(length <= copyElementCount);
     dstData = dstData || new ArrayType(dstElementCount);
-    this.gl.bindBuffer(import_constants17.default.COPY_READ_BUFFER, this.handle);
-    (_a = this.gl2) == null ? void 0 : _a.getBufferSubData(import_constants17.default.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
-    this.gl.bindBuffer(import_constants17.default.COPY_READ_BUFFER, null);
+    this.gl.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, this.handle);
+    (_a = this.gl2) == null ? void 0 : _a.getBufferSubData(import_constants17.GL.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
+    this.gl.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, null);
     return dstData;
   }
   /**
@@ -4461,7 +4450,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
       offset = 0,
       size
     } = options || {};
-    if (target === import_constants17.default.UNIFORM_BUFFER || target === import_constants17.default.TRANSFORM_FEEDBACK_BUFFER) {
+    if (target === import_constants17.GL.UNIFORM_BUFFER || target === import_constants17.GL.TRANSFORM_FEEDBACK_BUFFER) {
       if (size !== void 0) {
         (_a = this.gl2) == null ? void 0 : _a.bindBufferRange(target, index, this.handle, offset, size);
       } else {
@@ -4476,7 +4465,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
   unbind(options) {
     var _a;
     const { target = this.target, index = this.accessor && this.accessor.index } = options || {};
-    const isIndexedBuffer = target === import_constants17.default.UNIFORM_BUFFER || target === import_constants17.default.TRANSFORM_FEEDBACK_BUFFER;
+    const isIndexedBuffer = target === import_constants17.GL.UNIFORM_BUFFER || target === import_constants17.GL.TRANSFORM_FEEDBACK_BUFFER;
     if (isIndexedBuffer) {
       (_a = this.gl2) == null ? void 0 : _a.bindBufferBase(target, index, null);
     } else {
@@ -4537,10 +4526,10 @@ var ClassicBuffer = class extends WEBGLBuffer {
   // Binding a buffer for the first time locks the type
   // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type
   _getTarget() {
-    return this.gl.webgl2 ? import_constants17.default.COPY_WRITE_BUFFER : this.target;
+    return this.gl.webgl2 ? import_constants17.GL.COPY_WRITE_BUFFER : this.target;
   }
   _getAvailableElementCount(srcByteOffset) {
-    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants17.default.FLOAT, { clamped: false });
+    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants17.GL.FLOAT, { clamped: false });
     const sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT;
     return this.getElementCount() - sourceElementOffset;
   }
@@ -4567,7 +4556,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
 
 // src/adapter/resources/webgl-shader.ts
 var import_api20 = require("@luma.gl/api");
-var import_constants18 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants18 = require("@luma.gl/constants");
 
 // src/adapter/helpers/get-shader-info.ts
 function getShaderInfo(source, defaultName) {
@@ -4633,10 +4622,10 @@ var WEBGLShader = class extends import_api20.Shader {
     this.device = device;
     switch (this.props.stage) {
       case "vertex":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants18.default.VERTEX_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(import_constants18.GL.VERTEX_SHADER);
         break;
       case "fragment":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants18.default.FRAGMENT_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(import_constants18.GL.FRAGMENT_SHADER);
         break;
       default:
         throw new Error(this.props.stage);
@@ -4664,7 +4653,7 @@ ${source2}`;
     const { gl } = this.device;
     gl.shaderSource(this.handle, source);
     gl.compileShader(this.handle);
-    const compileStatus = gl.getShaderParameter(this.handle, import_constants18.default.COMPILE_STATUS);
+    const compileStatus = gl.getShaderParameter(this.handle, import_constants18.GL.COMPILE_STATUS);
     if (!compileStatus) {
       const shaderLog = gl.getShaderInfoLog(this.handle);
       const parsedLog = shaderLog ? parseShaderCompilerLog(shaderLog) : [];
@@ -4804,10 +4793,10 @@ var WEBGLRenderPass = class extends import_api21.RenderPass {
 
 // src/adapter/resources/webgl-render-pipeline.ts
 var import_api23 = require("@luma.gl/api");
-var import_constants25 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants25 = require("@luma.gl/constants");
 
 // src/adapter/helpers/get-shader-layout.ts
-var import_constants22 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants22 = require("@luma.gl/constants");
 
 // src/adapter/helpers/uniforms.ts
 var import_constants20 = require("@luma.gl/constants");
@@ -4885,7 +4874,7 @@ function decodeAttributeType(attributeType) {
 }
 
 // src/adapter/converters/vertex-formats.ts
-var import_constants21 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants21 = require("@luma.gl/constants");
 function getVertexFormat(type, components) {
   const base = getDataFormat(type);
   switch (components) {
@@ -4903,11 +4892,11 @@ function getVertexFormat(type, components) {
 }
 function getDataFormat(type) {
   switch (type) {
-    case import_constants21.default.INT:
+    case import_constants21.GL.INT:
       return "sint32";
-    case import_constants21.default.UNSIGNED_INT:
+    case import_constants21.GL.UNSIGNED_INT:
       return "uint32";
-    case import_constants21.default.FLOAT:
+    case import_constants21.GL.FLOAT:
       return "float32";
     default:
       throw new Error(String(type));
@@ -4926,7 +4915,7 @@ function getShaderLayout(gl, program) {
     const size = Math.min(attribute.accessor.size, 4);
     const format = (
       // attribute.accessor.format ||
-      getVertexFormat(attribute.accessor.type || import_constants22.default.FLOAT, size)
+      getVertexFormat(attribute.accessor.type || import_constants22.GL.FLOAT, size)
     );
     shaderLayout.attributes.push({
       name: attribute.name,
@@ -5015,7 +5004,7 @@ function readVaryings(gl, program) {
   }
   const gl2 = gl;
   const varyings = [];
-  const count = gl.getProgramParameter(program, import_constants22.default.TRANSFORM_FEEDBACK_VARYINGS);
+  const count = gl.getProgramParameter(program, import_constants22.GL.TRANSFORM_FEEDBACK_VARYINGS);
   for (let location = 0; location < count; location++) {
     const activeInfo = gl2.getTransformFeedbackVarying(program, location);
     if (!activeInfo) {
@@ -5032,7 +5021,7 @@ function readVaryings(gl, program) {
 }
 function readUniformBindings(gl, program) {
   const uniforms = [];
-  const uniformCount = gl.getProgramParameter(program, import_constants22.default.ACTIVE_UNIFORMS);
+  const uniformCount = gl.getProgramParameter(program, import_constants22.GL.ACTIVE_UNIFORMS);
   for (let i = 0; i < uniformCount; i++) {
     const activeInfo = gl.getActiveUniform(program, i);
     if (!activeInfo) {
@@ -5071,22 +5060,22 @@ function readUniformBlocks(gl, program) {
   const gl2 = gl;
   const getBlockParameter = (blockIndex, pname) => gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
   const uniformBlocks = [];
-  const blockCount = gl2.getProgramParameter(program, import_constants22.default.ACTIVE_UNIFORM_BLOCKS);
+  const blockCount = gl2.getProgramParameter(program, import_constants22.GL.ACTIVE_UNIFORM_BLOCKS);
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
     const blockInfo = {
       name: gl2.getActiveUniformBlockName(program, blockIndex) || "",
-      location: getBlockParameter(blockIndex, import_constants22.default.UNIFORM_BLOCK_BINDING),
-      byteLength: getBlockParameter(blockIndex, import_constants22.default.UNIFORM_BLOCK_DATA_SIZE),
-      vertex: getBlockParameter(blockIndex, import_constants22.default.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
-      fragment: getBlockParameter(blockIndex, import_constants22.default.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
-      uniformCount: getBlockParameter(blockIndex, import_constants22.default.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
+      location: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_BINDING),
+      byteLength: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_DATA_SIZE),
+      vertex: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
+      fragment: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
+      uniformCount: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
       uniforms: []
     };
-    const uniformIndices = getBlockParameter(blockIndex, import_constants22.default.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
-    const uniformType = gl2.getActiveUniforms(program, uniformIndices, import_constants22.default.UNIFORM_TYPE);
-    const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, import_constants22.default.UNIFORM_SIZE);
-    const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, import_constants22.default.UNIFORM_OFFSET);
-    const uniformStride = gl2.getActiveUniforms(program, uniformIndices, import_constants22.default.UNIFORM_ARRAY_STRIDE);
+    const uniformIndices = getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
+    const uniformType = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_TYPE);
+    const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_SIZE);
+    const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_OFFSET);
+    const uniformStride = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_ARRAY_STRIDE);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
       const activeInfo = gl2.getActiveUniform(program, uniformIndices[i]);
       if (!activeInfo) {
@@ -5109,21 +5098,21 @@ function readUniformBlocks(gl, program) {
   return uniformBlocks;
 }
 var SAMPLER_UNIFORMS_GL_TO_GPU = {
-  [import_constants22.default.SAMPLER_2D]: ["2d", "float"],
-  [import_constants22.default.SAMPLER_CUBE]: ["cube", "float"],
-  [import_constants22.default.SAMPLER_3D]: ["3d", "float"],
-  [import_constants22.default.SAMPLER_2D_SHADOW]: ["3d", "depth"],
-  [import_constants22.default.SAMPLER_2D_ARRAY]: ["2d-array", "float"],
-  [import_constants22.default.SAMPLER_2D_ARRAY_SHADOW]: ["2d-array", "depth"],
-  [import_constants22.default.SAMPLER_CUBE_SHADOW]: ["cube", "float"],
-  [import_constants22.default.INT_SAMPLER_2D]: ["2d", "sint"],
-  [import_constants22.default.INT_SAMPLER_3D]: ["3d", "sint"],
-  [import_constants22.default.INT_SAMPLER_CUBE]: ["cube", "sint"],
-  [import_constants22.default.INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"],
-  [import_constants22.default.UNSIGNED_INT_SAMPLER_2D]: ["2d", "uint"],
-  [import_constants22.default.UNSIGNED_INT_SAMPLER_3D]: ["3d", "uint"],
-  [import_constants22.default.UNSIGNED_INT_SAMPLER_CUBE]: ["cube", "uint"],
-  [import_constants22.default.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"]
+  [import_constants22.GL.SAMPLER_2D]: ["2d", "float"],
+  [import_constants22.GL.SAMPLER_CUBE]: ["cube", "float"],
+  [import_constants22.GL.SAMPLER_3D]: ["3d", "float"],
+  [import_constants22.GL.SAMPLER_2D_SHADOW]: ["3d", "depth"],
+  [import_constants22.GL.SAMPLER_2D_ARRAY]: ["2d-array", "float"],
+  [import_constants22.GL.SAMPLER_2D_ARRAY_SHADOW]: ["2d-array", "depth"],
+  [import_constants22.GL.SAMPLER_CUBE_SHADOW]: ["cube", "float"],
+  [import_constants22.GL.INT_SAMPLER_2D]: ["2d", "sint"],
+  [import_constants22.GL.INT_SAMPLER_3D]: ["3d", "sint"],
+  [import_constants22.GL.INT_SAMPLER_CUBE]: ["cube", "sint"],
+  [import_constants22.GL.INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"],
+  [import_constants22.GL.UNSIGNED_INT_SAMPLER_2D]: ["2d", "uint"],
+  [import_constants22.GL.UNSIGNED_INT_SAMPLER_3D]: ["3d", "uint"],
+  [import_constants22.GL.UNSIGNED_INT_SAMPLER_CUBE]: ["cube", "uint"],
+  [import_constants22.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"]
 };
 function getSamplerInfo(type) {
   const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
@@ -5154,26 +5143,26 @@ function parseUniformName(name) {
 }
 
 // src/adapter/helpers/set-uniform.ts
-var import_constants23 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants23 = require("@luma.gl/constants");
 function setUniform(gl, location, type, value) {
   const gl2 = gl;
   if (typeof value === "number") {
     switch (type) {
-      case import_constants23.default.SAMPLER_2D:
-      case import_constants23.default.SAMPLER_CUBE:
-      case import_constants23.default.SAMPLER_3D:
-      case import_constants23.default.SAMPLER_2D_SHADOW:
-      case import_constants23.default.SAMPLER_2D_ARRAY:
-      case import_constants23.default.SAMPLER_2D_ARRAY_SHADOW:
-      case import_constants23.default.SAMPLER_CUBE_SHADOW:
-      case import_constants23.default.INT_SAMPLER_2D:
-      case import_constants23.default.INT_SAMPLER_3D:
-      case import_constants23.default.INT_SAMPLER_CUBE:
-      case import_constants23.default.INT_SAMPLER_2D_ARRAY:
-      case import_constants23.default.UNSIGNED_INT_SAMPLER_2D:
-      case import_constants23.default.UNSIGNED_INT_SAMPLER_3D:
-      case import_constants23.default.UNSIGNED_INT_SAMPLER_CUBE:
-      case import_constants23.default.UNSIGNED_INT_SAMPLER_2D_ARRAY:
+      case import_constants23.GL.SAMPLER_2D:
+      case import_constants23.GL.SAMPLER_CUBE:
+      case import_constants23.GL.SAMPLER_3D:
+      case import_constants23.GL.SAMPLER_2D_SHADOW:
+      case import_constants23.GL.SAMPLER_2D_ARRAY:
+      case import_constants23.GL.SAMPLER_2D_ARRAY_SHADOW:
+      case import_constants23.GL.SAMPLER_CUBE_SHADOW:
+      case import_constants23.GL.INT_SAMPLER_2D:
+      case import_constants23.GL.INT_SAMPLER_3D:
+      case import_constants23.GL.INT_SAMPLER_CUBE:
+      case import_constants23.GL.INT_SAMPLER_2D_ARRAY:
+      case import_constants23.GL.UNSIGNED_INT_SAMPLER_2D:
+      case import_constants23.GL.UNSIGNED_INT_SAMPLER_3D:
+      case import_constants23.GL.UNSIGNED_INT_SAMPLER_CUBE:
+      case import_constants23.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
         return gl.uniform1i(location, value);
     }
   }
@@ -5185,55 +5174,55 @@ function setUniform(gl, location, type, value) {
   }
   const arrayValue = typeof value === "number" ? [value] : value;
   switch (type) {
-    case import_constants23.default.FLOAT:
+    case import_constants23.GL.FLOAT:
       return gl.uniform1fv(location, arrayValue);
-    case import_constants23.default.FLOAT_VEC2:
+    case import_constants23.GL.FLOAT_VEC2:
       return gl.uniform2fv(location, arrayValue);
-    case import_constants23.default.FLOAT_VEC3:
+    case import_constants23.GL.FLOAT_VEC3:
       return gl.uniform3fv(location, arrayValue);
-    case import_constants23.default.FLOAT_VEC4:
+    case import_constants23.GL.FLOAT_VEC4:
       return gl.uniform4fv(location, arrayValue);
-    case import_constants23.default.INT:
+    case import_constants23.GL.INT:
       return gl.uniform1iv(location, arrayValue);
-    case import_constants23.default.INT_VEC2:
+    case import_constants23.GL.INT_VEC2:
       return gl.uniform2iv(location, arrayValue);
-    case import_constants23.default.INT_VEC3:
+    case import_constants23.GL.INT_VEC3:
       return gl.uniform3iv(location, arrayValue);
-    case import_constants23.default.INT_VEC4:
+    case import_constants23.GL.INT_VEC4:
       return gl.uniform4iv(location, arrayValue);
-    case import_constants23.default.BOOL:
+    case import_constants23.GL.BOOL:
       return gl.uniform1iv(location, arrayValue);
-    case import_constants23.default.BOOL_VEC2:
+    case import_constants23.GL.BOOL_VEC2:
       return gl.uniform2iv(location, arrayValue);
-    case import_constants23.default.BOOL_VEC3:
+    case import_constants23.GL.BOOL_VEC3:
       return gl.uniform3iv(location, arrayValue);
-    case import_constants23.default.BOOL_VEC4:
+    case import_constants23.GL.BOOL_VEC4:
       return gl.uniform4iv(location, arrayValue);
-    case import_constants23.default.UNSIGNED_INT:
+    case import_constants23.GL.UNSIGNED_INT:
       return gl2.uniform1uiv(location, arrayValue, 1);
-    case import_constants23.default.UNSIGNED_INT_VEC2:
+    case import_constants23.GL.UNSIGNED_INT_VEC2:
       return gl2.uniform2uiv(location, arrayValue, 2);
-    case import_constants23.default.UNSIGNED_INT_VEC3:
+    case import_constants23.GL.UNSIGNED_INT_VEC3:
       return gl2.uniform3uiv(location, arrayValue, 3);
-    case import_constants23.default.UNSIGNED_INT_VEC4:
+    case import_constants23.GL.UNSIGNED_INT_VEC4:
       return gl2.uniform4uiv(location, arrayValue, 4);
-    case import_constants23.default.FLOAT_MAT2:
+    case import_constants23.GL.FLOAT_MAT2:
       return gl.uniformMatrix2fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT3:
+    case import_constants23.GL.FLOAT_MAT3:
       return gl.uniformMatrix3fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT4:
+    case import_constants23.GL.FLOAT_MAT4:
       return gl.uniformMatrix4fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT2x3:
+    case import_constants23.GL.FLOAT_MAT2x3:
       return gl2.uniformMatrix2x3fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT2x4:
+    case import_constants23.GL.FLOAT_MAT2x4:
       return gl2.uniformMatrix2x4fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT3x2:
+    case import_constants23.GL.FLOAT_MAT3x2:
       return gl2.uniformMatrix3x2fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT3x4:
+    case import_constants23.GL.FLOAT_MAT3x4:
       return gl2.uniformMatrix3x4fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT4x2:
+    case import_constants23.GL.FLOAT_MAT4x2:
       return gl2.uniformMatrix4x2fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT4x3:
+    case import_constants23.GL.FLOAT_MAT4x3:
       return gl2.uniformMatrix4x3fv(location, false, arrayValue);
   }
   throw new Error("Illegal uniform");
@@ -5241,7 +5230,7 @@ function setUniform(gl, location, type, value) {
 
 // src/adapter/objects/webgl-vertex-array-object.ts
 var import_api22 = require("@luma.gl/api");
-var import_constants24 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants24 = require("@luma.gl/constants");
 var import_env = require("@probe.gl/env");
 var ERR_ELEMENTS = "elements must be GL.ELEMENT_ARRAY_BUFFER";
 var WEBGLVertexArrayObject = class extends WebGLResource {
@@ -5264,15 +5253,15 @@ var WEBGLVertexArrayObject = class extends WebGLResource {
   // Set (bind) an elements buffer, for indexed rendering.
   // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
   setElementBuffer(elementBuffer = null, opts = {}) {
-    (0, import_api22.assert)(!elementBuffer || elementBuffer.target === import_constants24.default.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
+    (0, import_api22.assert)(!elementBuffer || elementBuffer.target === import_constants24.GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
     this.bind(() => {
-      this.gl.bindBuffer(import_constants24.default.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
+      this.gl.bindBuffer(import_constants24.GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
     });
     return this;
   }
   /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
   setBuffer(location, buffer, accessor) {
-    if (buffer.target === import_constants24.default.ELEMENT_ARRAY_BUFFER) {
+    if (buffer.target === import_constants24.GL.ELEMENT_ARRAY_BUFFER) {
       return this.setElementBuffer(buffer, accessor);
     }
     const { size, type, stride, offset, normalized, integer, divisor } = accessor;
@@ -5331,7 +5320,7 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
     this.device.setSpectorMetadata(this.handle, { id: this.props.id });
     this.vs = (0, import_api23.cast)(props.vs);
     this.fs = (0, import_api23.cast)(props.fs);
-    const { varyings, bufferMode = import_constants25.default.SEPARATE_ATTRIBS } = props;
+    const { varyings, bufferMode = import_constants25.GL.SEPARATE_ATTRIBS } = props;
     if (varyings && varyings.length > 0) {
       this.device.assertWebGL2();
       this.varyings = varyings;
@@ -5428,7 +5417,7 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
     } = options;
     const drawMode = getDrawMode(this.props.topology);
     const isIndexed = Boolean(this._indexBuffer);
-    const indexType = ((_a = this._indexBuffer) == null ? void 0 : _a.props.indexType) === "uint16" ? import_constants25.default.UNSIGNED_SHORT : import_constants25.default.UNSIGNED_INT;
+    const indexType = ((_a = this._indexBuffer) == null ? void 0 : _a.props.indexType) === "uint16" ? import_constants25.GL.UNSIGNED_SHORT : import_constants25.GL.UNSIGNED_INT;
     const isInstanced = Number(options.instanceCount) > 0;
     if (!this._areTexturesRenderable() || options.vertexCount === 0) {
       return false;
@@ -5528,15 +5517,15 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
         case "uniform":
           const { name } = binding;
           const location = gl2.getUniformBlockIndex(this.handle, name);
-          if (location === import_constants25.default.INVALID_INDEX) {
+          if (location === import_constants25.GL.INVALID_INDEX) {
             throw new Error(`Invalid uniform block name ${name}`);
           }
           gl2.uniformBlockBinding(this.handle, uniformBufferIndex, location);
           if (value instanceof WEBGLBuffer) {
-            gl2.bindBufferBase(import_constants25.default.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
+            gl2.bindBufferBase(import_constants25.GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
           } else {
             gl2.bindBufferRange(
-              import_constants25.default.UNIFORM_BUFFER,
+              import_constants25.GL.UNIFORM_BUFFER,
               uniformBufferIndex,
               value.buffer.handle,
               value.offset || 0,
@@ -5550,7 +5539,7 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
             throw new Error("texture");
           }
           const texture = value;
-          gl2.activeTexture(import_constants25.default.TEXTURE0 + textureUnit);
+          gl2.activeTexture(import_constants25.GL.TEXTURE0 + textureUnit);
           gl2.bindTexture(texture.target, texture.handle);
           textureUnit += 1;
           break;
@@ -5576,19 +5565,19 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
 function getDrawMode(topology) {
   switch (topology) {
     case "point-list":
-      return import_constants25.default.POINTS;
+      return import_constants25.GL.POINTS;
     case "line-list":
-      return import_constants25.default.LINES;
+      return import_constants25.GL.LINES;
     case "line-strip":
-      return import_constants25.default.LINE_STRIP;
+      return import_constants25.GL.LINE_STRIP;
     case "line-loop":
-      return import_constants25.default.LINE_LOOP;
+      return import_constants25.GL.LINE_LOOP;
     case "triangle-list":
-      return import_constants25.default.TRIANGLES;
+      return import_constants25.GL.TRIANGLES;
     case "triangle-strip":
-      return import_constants25.default.TRIANGLE_STRIP;
+      return import_constants25.GL.TRIANGLE_STRIP;
     case "triangle-fan":
-      return import_constants25.default.TRIANGLE_FAN;
+      return import_constants25.GL.TRIANGLE_FAN;
     default:
       throw new Error(topology);
   }
@@ -5596,19 +5585,19 @@ function getDrawMode(topology) {
 function getGLPrimitive(topology) {
   switch (topology) {
     case "point-list":
-      return import_constants25.default.POINTS;
+      return import_constants25.GL.POINTS;
     case "line-list":
-      return import_constants25.default.LINES;
+      return import_constants25.GL.LINES;
     case "line-strip":
-      return import_constants25.default.LINES;
+      return import_constants25.GL.LINES;
     case "line-loop":
-      return import_constants25.default.LINES;
+      return import_constants25.GL.LINES;
     case "triangle-list":
-      return import_constants25.default.TRIANGLES;
+      return import_constants25.GL.TRIANGLES;
     case "triangle-strip":
-      return import_constants25.default.TRIANGLES;
+      return import_constants25.GL.TRIANGLES;
     case "triangle-fan":
-      return import_constants25.default.TRIANGLES;
+      return import_constants25.GL.TRIANGLES;
     default:
       throw new Error(topology);
   }
@@ -5622,7 +5611,7 @@ var import_api25 = require("@luma.gl/api");
 
 // src/adapter/resources/webgl-command-buffer.ts
 var import_api24 = require("@luma.gl/api");
-var import_constants26 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants26 = require("@luma.gl/constants");
 function cast3(value) {
   return value;
 }
@@ -5657,17 +5646,17 @@ function _copyBufferToBuffer(device, options) {
   const destination = cast3(options.destination);
   const gl2 = device.assertWebGL2();
   if (gl2) {
-    gl2.bindBuffer(import_constants26.default.COPY_READ_BUFFER, source.handle);
-    gl2.bindBuffer(import_constants26.default.COPY_WRITE_BUFFER, destination.handle);
+    gl2.bindBuffer(import_constants26.GL.COPY_READ_BUFFER, source.handle);
+    gl2.bindBuffer(import_constants26.GL.COPY_WRITE_BUFFER, destination.handle);
     gl2.copyBufferSubData(
-      import_constants26.default.COPY_READ_BUFFER,
-      import_constants26.default.COPY_WRITE_BUFFER,
+      import_constants26.GL.COPY_READ_BUFFER,
+      import_constants26.GL.COPY_WRITE_BUFFER,
       (_a = options.sourceOffset) != null ? _a : 0,
       (_b = options.destinationOffset) != null ? _b : 0,
       options.size
     );
-    gl2.bindBuffer(import_constants26.default.COPY_READ_BUFFER, null);
-    gl2.bindBuffer(import_constants26.default.COPY_WRITE_BUFFER, null);
+    gl2.bindBuffer(import_constants26.GL.COPY_READ_BUFFER, null);
+    gl2.bindBuffer(import_constants26.GL.COPY_WRITE_BUFFER, null);
   } else {
     throw new Error("copyBufferToBuffer not implemented in WebGL1");
   }
@@ -5718,10 +5707,10 @@ function _copyTextureToBuffer(device, options) {
     const webglBuffer = destination;
     const sourceWidth = width || framebuffer.width;
     const sourceHeight = height || framebuffer.height;
-    const sourceFormat = import_constants26.default.RGBA;
-    const sourceType = import_constants26.default.UNSIGNED_BYTE;
-    gl2.bindBuffer(import_constants26.default.PIXEL_PACK_BUFFER, webglBuffer.handle);
-    gl2.bindFramebuffer(import_constants26.default.FRAMEBUFFER, framebuffer.handle);
+    const sourceFormat = import_constants26.GL.RGBA;
+    const sourceType = import_constants26.GL.UNSIGNED_BYTE;
+    gl2.bindBuffer(import_constants26.GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
+    gl2.bindFramebuffer(import_constants26.GL.FRAMEBUFFER, framebuffer.handle);
     gl2.readPixels(
       origin[0],
       origin[1],
@@ -5732,8 +5721,8 @@ function _copyTextureToBuffer(device, options) {
       byteOffset
     );
   } finally {
-    gl2.bindBuffer(import_constants26.default.PIXEL_PACK_BUFFER, null);
-    gl2.bindFramebuffer(import_constants26.default.FRAMEBUFFER, null);
+    gl2.bindBuffer(import_constants26.GL.PIXEL_PACK_BUFFER, null);
+    gl2.bindFramebuffer(import_constants26.GL.FRAMEBUFFER, null);
     if (destroyFramebuffer) {
       framebuffer.destroy();
     }
@@ -5764,11 +5753,11 @@ function _copyTextureToTexture(device, options) {
     // depthOrArrayLayers = 0
   } = options;
   const destinationMipmaplevel = 0;
-  const destinationInternalFormat = import_constants26.default.RGBA;
+  const destinationInternalFormat = import_constants26.GL.RGBA;
   const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
   const [sourceX, sourceY] = origin;
   const isSubCopy = false;
-  device.gl.bindFramebuffer(import_constants26.default.FRAMEBUFFER, framebuffer.handle);
+  device.gl.bindFramebuffer(import_constants26.GL.FRAMEBUFFER, framebuffer.handle);
   let texture = null;
   let textureTarget;
   if (destination instanceof WEBGLTexture) {
@@ -5797,7 +5786,7 @@ function _copyTextureToTexture(device, options) {
   if (texture) {
     texture.unbind();
   }
-  device.gl.bindFramebuffer(import_constants26.default.FRAMEBUFFER, prevHandle || null);
+  device.gl.bindFramebuffer(import_constants26.GL.FRAMEBUFFER, prevHandle || null);
   if (destroyFramebuffer) {
     framebuffer.destroy();
   }
@@ -6019,7 +6008,7 @@ var _WebGLDevice = class extends import_api26.Device {
   }
   createBuffer(props) {
     const newProps = this._getBufferProps(props);
-    return new ClassicBuffer(this, newProps);
+    return new BufferWithAccessor(this, newProps);
   }
   _createTexture(props) {
     return new WEBGLTexture(this, props);
@@ -6182,25 +6171,25 @@ function clear(gl, options) {
 
 // src/classic/copy-and-blit.ts
 var import_api29 = require("@luma.gl/api");
-var import_constants28 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants28 = require("@luma.gl/constants");
 
 // src/classic/format-utils.ts
 var import_api28 = require("@luma.gl/api");
-var import_constants27 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants27 = require("@luma.gl/constants");
 function glFormatToComponents(format) {
   switch (format) {
-    case import_constants27.default.ALPHA:
-    case import_constants27.default.R32F:
-    case import_constants27.default.RED:
+    case import_constants27.GL.ALPHA:
+    case import_constants27.GL.R32F:
+    case import_constants27.GL.RED:
       return 1;
-    case import_constants27.default.RG32F:
-    case import_constants27.default.RG:
+    case import_constants27.GL.RG32F:
+    case import_constants27.GL.RG:
       return 2;
-    case import_constants27.default.RGB:
-    case import_constants27.default.RGB32F:
+    case import_constants27.GL.RGB:
+    case import_constants27.GL.RGB32F:
       return 3;
-    case import_constants27.default.RGBA:
-    case import_constants27.default.RGBA32F:
+    case import_constants27.GL.RGBA:
+    case import_constants27.GL.RGBA32F:
       return 4;
     default:
       (0, import_api28.assert)(false);
@@ -6209,13 +6198,13 @@ function glFormatToComponents(format) {
 }
 function glTypeToBytes(type) {
   switch (type) {
-    case import_constants27.default.UNSIGNED_BYTE:
+    case import_constants27.GL.UNSIGNED_BYTE:
       return 1;
-    case import_constants27.default.UNSIGNED_SHORT_5_6_5:
-    case import_constants27.default.UNSIGNED_SHORT_4_4_4_4:
-    case import_constants27.default.UNSIGNED_SHORT_5_5_5_1:
+    case import_constants27.GL.UNSIGNED_SHORT_5_6_5:
+    case import_constants27.GL.UNSIGNED_SHORT_4_4_4_4:
+    case import_constants27.GL.UNSIGNED_SHORT_5_5_5_1:
       return 2;
-    case import_constants27.default.FLOAT:
+    case import_constants27.GL.FLOAT:
       return 4;
     default:
       (0, import_api28.assert)(false);
@@ -6225,9 +6214,9 @@ function glTypeToBytes(type) {
 
 // src/classic/copy-and-blit.ts
 function readPixelsToArray(source, options) {
-  const { sourceX = 0, sourceY = 0, sourceFormat = import_constants28.default.RGBA } = options || {};
+  const { sourceX = 0, sourceY = 0, sourceFormat = import_constants28.GL.RGBA } = options || {};
   let {
-    sourceAttachment = import_constants28.default.COLOR_ATTACHMENT0,
+    sourceAttachment = import_constants28.GL.COLOR_ATTACHMENT0,
     // TODO - support gl.readBuffer
     target = null,
     // following parameters are auto deduced if not provided
@@ -6240,23 +6229,23 @@ function readPixelsToArray(source, options) {
   const { gl, handle } = framebuffer;
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
-  if (sourceAttachment === import_constants28.default.COLOR_ATTACHMENT0 && handle === null) {
-    sourceAttachment = import_constants28.default.FRONT;
+  if (sourceAttachment === import_constants28.GL.COLOR_ATTACHMENT0 && handle === null) {
+    sourceAttachment = import_constants28.GL.FRONT;
   }
-  const attachment = sourceAttachment - import_constants28.default.COLOR_ATTACHMENT0;
+  const attachment = sourceAttachment - import_constants28.GL.COLOR_ATTACHMENT0;
   sourceType = sourceType || framebuffer.colorAttachments[attachment].type;
   target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
   sourceType = sourceType || getGLTypeFromTypedArray(target);
-  const prevHandle2 = gl.bindFramebuffer(import_constants28.default.FRAMEBUFFER, handle);
+  const prevHandle2 = gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
   gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-  gl.bindFramebuffer(import_constants28.default.FRAMEBUFFER, prevHandle2 || null);
+  gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle2 || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
   return target;
 }
 function readPixelsToBuffer(source, options) {
-  const { sourceX = 0, sourceY = 0, sourceFormat = import_constants28.default.RGBA, targetByteOffset = 0 } = options || {};
+  const { sourceX = 0, sourceY = 0, sourceFormat = import_constants28.GL.RGBA, targetByteOffset = 0 } = options || {};
   let { target, sourceWidth, sourceHeight, sourceType } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
   (0, import_api29.assert)(framebuffer);
@@ -6264,14 +6253,14 @@ function readPixelsToBuffer(source, options) {
   sourceHeight = sourceHeight || framebuffer.height;
   const webglFramebuffer = framebuffer;
   const gl2 = webglFramebuffer.device.assertWebGL2();
-  sourceType = sourceType || (target ? target.type : import_constants28.default.UNSIGNED_BYTE);
+  sourceType = sourceType || (target ? target.type : import_constants28.GL.UNSIGNED_BYTE);
   if (!target) {
     const components = glFormatToComponents(sourceFormat);
     const byteCount = glTypeToBytes(sourceType);
     const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
-    target = new ClassicBuffer(gl2, { byteLength, accessor: { type: sourceType, size: components } });
+    target = new BufferWithAccessor(gl2, { byteLength, accessor: { type: sourceType, size: components } });
   }
-  target.bind({ target: import_constants28.default.PIXEL_PACK_BUFFER });
+  target.bind({ target: import_constants28.GL.PIXEL_PACK_BUFFER });
   withParameters(gl2, { framebuffer }, () => {
     gl2.readPixels(
       sourceX,
@@ -6283,7 +6272,7 @@ function readPixelsToBuffer(source, options) {
       targetByteOffset
     );
   });
-  target.unbind({ target: import_constants28.default.PIXEL_PACK_BUFFER });
+  target.unbind({ target: import_constants28.GL.PIXEL_PACK_BUFFER });
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
@@ -6313,7 +6302,7 @@ function getPixelArray(pixelArray, type, format, width, height) {
   if (pixelArray) {
     return pixelArray;
   }
-  type = type || import_constants28.default.UNSIGNED_BYTE;
+  type = type || import_constants28.GL.UNSIGNED_BYTE;
   const ArrayType = getTypedArrayFromGLType(type, { clamped: false });
   const components = glFormatToComponents(format);
   return new ArrayType(width * height * components);