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

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,
@@ -89,6 +78,7 @@ __export(src_exports, {
   assertWebGLContext: () => assertWebGLContext,
   clear: () => clear,
   convertGLToTextureFormat: () => convertGLToTextureFormat,
+  copyToTexture: () => copyToTexture,
   getParameters: () => getParameters,
   getProgramBindings: () => getProgramBindings,
   getShaderLayout: () => getShaderLayout,
@@ -135,11 +125,11 @@ function createHeadlessContext(options) {
   if (!headlessGL) {
     throw new Error(ERR_HEADLESSGL_LOAD);
   }
-  const gl = headlessGL(width, height, options);
-  if (!gl) {
+  const gl2 = headlessGL(width, height, options);
+  if (!gl2) {
     throw new Error(ERR_HEADLESSGL_FAILED);
   }
-  return gl;
+  return gl2;
 }
 
 // src/adapter/webgl-device.ts
@@ -167,43 +157,43 @@ function synthesizeGLError(err, opt_msg) {
     error(opt_msg);
   }
 }
-function wrapGLError(gl) {
-  const f = gl.getError;
-  gl.getError = function getError() {
+function wrapGLError(gl2) {
+  const f = gl2.getError;
+  gl2.getError = function getError() {
     let err;
     do {
-      err = f.apply(gl);
-      if (err !== gl.NO_ERROR) {
+      err = f.apply(gl2);
+      if (err !== gl2.NO_ERROR) {
         glErrorShadow[err] = true;
       }
-    } while (err !== gl.NO_ERROR);
+    } while (err !== gl2.NO_ERROR);
     for (err in glErrorShadow) {
       if (glErrorShadow[err]) {
         delete glErrorShadow[err];
         return parseInt(err, 10);
       }
     }
-    return gl.NO_ERROR;
+    return gl2.NO_ERROR;
   };
 }
 var WebGLVertexArrayObjectOES = function WebGLVertexArrayObjectOES2(ext) {
-  const gl = ext.gl;
+  const gl2 = ext.gl;
   this.ext = ext;
   this.isAlive = true;
   this.hasBeenBound = false;
   this.elementArrayBuffer = null;
   this.attribs = new Array(ext.maxVertexAttribs);
   for (let n = 0; n < this.attribs.length; n++) {
-    const attrib = new WebGLVertexArrayObjectOES2.VertexAttrib(gl);
+    const attrib = new WebGLVertexArrayObjectOES2.VertexAttrib(gl2);
     this.attribs[n] = attrib;
   }
   this.maxAttrib = 0;
 };
-WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl) {
+WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl2) {
   this.enabled = false;
   this.buffer = null;
   this.size = 4;
-  this.type = gl.FLOAT;
+  this.type = gl2.FLOAT;
   this.normalized = false;
   this.stride = 16;
   this.offset = 0;
@@ -213,19 +203,19 @@ WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl) {
 WebGLVertexArrayObjectOES.VertexAttrib.prototype.recache = function recache() {
   this.cached = [this.size, this.type, this.normalized, this.stride, this.offset].join(":");
 };
-var OESVertexArrayObject = function OESVertexArrayObject2(gl) {
+var OESVertexArrayObject = function OESVertexArrayObject2(gl2) {
   const self = this;
-  this.gl = gl;
-  wrapGLError(gl);
+  this.gl = gl2;
+  wrapGLError(gl2);
   const original = this.original = {
-    getParameter: gl.getParameter,
-    enableVertexAttribArray: gl.enableVertexAttribArray,
-    disableVertexAttribArray: gl.disableVertexAttribArray,
-    bindBuffer: gl.bindBuffer,
-    getVertexAttrib: gl.getVertexAttrib,
-    vertexAttribPointer: gl.vertexAttribPointer
+    getParameter: gl2.getParameter,
+    enableVertexAttribArray: gl2.enableVertexAttribArray,
+    disableVertexAttribArray: gl2.disableVertexAttribArray,
+    bindBuffer: gl2.bindBuffer,
+    getVertexAttrib: gl2.getVertexAttrib,
+    vertexAttribPointer: gl2.vertexAttribPointer
   };
-  gl.getParameter = function getParameter(pname) {
+  gl2.getParameter = function getParameter(pname) {
     if (pname === self.VERTEX_ARRAY_BINDING_OES) {
       if (self.currentVertexArrayObject === self.defaultVertexArrayObject) {
         return null;
@@ -234,53 +224,53 @@ var OESVertexArrayObject = function OESVertexArrayObject2(gl) {
     }
     return original.getParameter.apply(this, arguments);
   };
-  gl.enableVertexAttribArray = function enableVertexAttribArray(index) {
+  gl2.enableVertexAttribArray = function enableVertexAttribArray(index) {
     const vao = self.currentVertexArrayObject;
     vao.maxAttrib = Math.max(vao.maxAttrib, index);
     const attrib = vao.attribs[index];
     attrib.enabled = true;
     return original.enableVertexAttribArray.apply(this, arguments);
   };
-  gl.disableVertexAttribArray = function disableVertexAttribArray(index) {
+  gl2.disableVertexAttribArray = function disableVertexAttribArray(index) {
     const vao = self.currentVertexArrayObject;
     vao.maxAttrib = Math.max(vao.maxAttrib, index);
     const attrib = vao.attribs[index];
     attrib.enabled = false;
     return original.disableVertexAttribArray.apply(this, arguments);
   };
-  gl.bindBuffer = function bindBuffer2(target, buffer) {
+  gl2.bindBuffer = function bindBuffer2(target, buffer) {
     switch (target) {
-      case gl.ARRAY_BUFFER:
+      case gl2.ARRAY_BUFFER:
         self.currentArrayBuffer = buffer;
         break;
-      case gl.ELEMENT_ARRAY_BUFFER:
+      case gl2.ELEMENT_ARRAY_BUFFER:
         self.currentVertexArrayObject.elementArrayBuffer = buffer;
         break;
       default:
     }
     return original.bindBuffer.apply(this, arguments);
   };
-  gl.getVertexAttrib = function getVertexAttrib(index, pname) {
+  gl2.getVertexAttrib = function getVertexAttrib(index, pname) {
     const vao = self.currentVertexArrayObject;
     const attrib = vao.attribs[index];
     switch (pname) {
-      case gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
+      case gl2.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
         return attrib.buffer;
-      case gl.VERTEX_ATTRIB_ARRAY_ENABLED:
+      case gl2.VERTEX_ATTRIB_ARRAY_ENABLED:
         return attrib.enabled;
-      case gl.VERTEX_ATTRIB_ARRAY_SIZE:
+      case gl2.VERTEX_ATTRIB_ARRAY_SIZE:
         return attrib.size;
-      case gl.VERTEX_ATTRIB_ARRAY_STRIDE:
+      case gl2.VERTEX_ATTRIB_ARRAY_STRIDE:
         return attrib.stride;
-      case gl.VERTEX_ATTRIB_ARRAY_TYPE:
+      case gl2.VERTEX_ATTRIB_ARRAY_TYPE:
         return attrib.type;
-      case gl.VERTEX_ATTRIB_ARRAY_NORMALIZED:
+      case gl2.VERTEX_ATTRIB_ARRAY_NORMALIZED:
         return attrib.normalized;
       default:
         return original.getVertexAttrib.apply(this, arguments);
     }
   };
-  gl.vertexAttribPointer = function vertexAttribPointer(indx, size, type, normalized, stride, offset) {
+  gl2.vertexAttribPointer = function vertexAttribPointer(indx, size, type, normalized, stride, offset) {
     const vao = self.currentVertexArrayObject;
     vao.maxAttrib = Math.max(vao.maxAttrib, indx);
     const attrib = vao.attribs[indx];
@@ -293,11 +283,11 @@ var OESVertexArrayObject = function OESVertexArrayObject2(gl) {
     attrib.recache();
     return original.vertexAttribPointer.apply(this, arguments);
   };
-  if (gl.instrumentExtension) {
-    gl.instrumentExtension(this, "OES_vertex_array_object");
+  if (gl2.instrumentExtension) {
+    gl2.instrumentExtension(this, "OES_vertex_array_object");
   }
-  if (gl.canvas) {
-    gl.canvas.addEventListener(
+  if (gl2.canvas) {
+    gl2.canvas.addEventListener(
       "webglcontextrestored",
       () => {
         log("OESVertexArrayObject emulation library context restored");
@@ -316,8 +306,8 @@ OESVertexArrayObject.prototype.reset_ = function reset_() {
       this.vertexArrayObjects.isAlive = false;
     }
   }
-  const gl = this.gl;
-  this.maxVertexAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
+  const gl2 = this.gl;
+  this.maxVertexAttribs = gl2.getParameter(gl2.MAX_VERTEX_ATTRIBS);
   this.defaultVertexArrayObject = new WebGLVertexArrayObjectOES(this);
   this.currentVertexArrayObject = null;
   this.currentArrayBuffer = null;
@@ -345,10 +335,10 @@ OESVertexArrayObject.prototype.isVertexArrayOES = function isVertexArrayOES(arra
   return false;
 };
 OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(arrayObject) {
-  const gl = this.gl;
+  const gl2 = this.gl;
   if (arrayObject && !arrayObject.isAlive) {
     synthesizeGLError(
-      gl.INVALID_OPERATION,
+      gl2.INVALID_OPERATION,
       "bindVertexArrayOES: attempt to bind deleted arrayObject"
     );
     return;
@@ -362,7 +352,7 @@ OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(
     return;
   }
   if (!oldVAO || newVAO.elementArrayBuffer !== oldVAO.elementArrayBuffer) {
-    original.bindBuffer.call(gl, gl.ELEMENT_ARRAY_BUFFER, newVAO.elementArrayBuffer);
+    original.bindBuffer.call(gl2, gl2.ELEMENT_ARRAY_BUFFER, newVAO.elementArrayBuffer);
   }
   let currentBinding = this.currentArrayBuffer;
   const maxAttrib = Math.max(oldVAO ? oldVAO.maxAttrib : 0, newVAO.maxAttrib);
@@ -371,23 +361,23 @@ OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(
     const oldAttrib = oldVAO ? oldVAO.attribs[n] : null;
     if (!oldVAO || attrib.enabled !== oldAttrib.enabled) {
       if (attrib.enabled) {
-        original.enableVertexAttribArray.call(gl, n);
+        original.enableVertexAttribArray.call(gl2, n);
       } else {
-        original.disableVertexAttribArray.call(gl, n);
+        original.disableVertexAttribArray.call(gl2, n);
       }
     }
     if (attrib.enabled) {
       let bufferChanged = false;
       if (!oldVAO || attrib.buffer !== oldAttrib.buffer) {
         if (currentBinding !== attrib.buffer) {
-          original.bindBuffer.call(gl, gl.ARRAY_BUFFER, attrib.buffer);
+          original.bindBuffer.call(gl2, gl2.ARRAY_BUFFER, attrib.buffer);
           currentBinding = attrib.buffer;
         }
         bufferChanged = true;
       }
       if (bufferChanged || attrib.cached !== oldAttrib.cached) {
         original.vertexAttribPointer.call(
-          gl,
+          gl2,
           n,
           attrib.size,
           attrib.type,
@@ -399,23 +389,23 @@ OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(
     }
   }
   if (this.currentArrayBuffer !== currentBinding) {
-    original.bindBuffer.call(gl, gl.ARRAY_BUFFER, this.currentArrayBuffer);
+    original.bindBuffer.call(gl2, gl2.ARRAY_BUFFER, this.currentArrayBuffer);
   }
 };
-function polyfillVertexArrayObject(gl) {
-  if (typeof gl.createVertexArray === "function") {
+function polyfillVertexArrayObject(gl2) {
+  if (typeof gl2.createVertexArray === "function") {
     return;
   }
-  const original_getSupportedExtensions = gl.getSupportedExtensions;
-  gl.getSupportedExtensions = function getSupportedExtensions() {
+  const original_getSupportedExtensions = gl2.getSupportedExtensions;
+  gl2.getSupportedExtensions = function getSupportedExtensions() {
     const list = original_getSupportedExtensions.call(this) || [];
     if (list.indexOf("OES_vertex_array_object") < 0) {
       list.push("OES_vertex_array_object");
     }
     return list;
   };
-  const original_getExtension = gl.getExtension;
-  gl.getExtension = function getExtension(name) {
+  const original_getExtension = gl2.getExtension;
+  gl2.getExtension = function getExtension(name) {
     const ext = original_getExtension.call(this, name);
     if (ext) {
       return ext;
@@ -423,7 +413,7 @@ function polyfillVertexArrayObject(gl) {
     if (name !== "OES_vertex_array_object") {
       return null;
     }
-    if (!gl.__OESVertexArrayObject) {
+    if (!gl2.__OESVertexArrayObject) {
       this.__OESVertexArrayObject = new OESVertexArrayObject(this);
     }
     return this.__OESVertexArrayObject;
@@ -432,41 +422,41 @@ 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");
 var ERR_CONTEXT = "Invalid WebGLRenderingContext";
 var ERR_WEBGL2 = "Requires WebGL2";
-function isWebGL(gl) {
-  if (typeof WebGLRenderingContext !== "undefined" && gl instanceof WebGLRenderingContext) {
+function isWebGL(gl2) {
+  if (typeof WebGLRenderingContext !== "undefined" && gl2 instanceof WebGLRenderingContext) {
     return true;
   }
-  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
     return true;
   }
-  return Boolean(gl && Number.isFinite(gl._version));
+  return Boolean(gl2 && Number.isFinite(gl2._version));
 }
-function isWebGL2(gl) {
-  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+function isWebGL2(gl2) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
     return true;
   }
-  return Boolean(gl && gl._version === 2);
+  return Boolean(gl2 && gl2._version === 2);
 }
-function getWebGL2Context(gl) {
-  return isWebGL2(gl) ? gl : null;
+function getWebGL2Context(gl2) {
+  return isWebGL2(gl2) ? gl2 : null;
 }
-function assertWebGLContext(gl) {
-  (0, import_api.assert)(isWebGL(gl), ERR_CONTEXT);
-  return gl;
+function assertWebGLContext(gl2) {
+  (0, import_api.assert)(isWebGL(gl2), ERR_CONTEXT);
+  return gl2;
 }
-function assertWebGL2Context(gl) {
-  (0, import_api.assert)(isWebGL2(gl), ERR_WEBGL2);
-  return gl;
+function assertWebGL2Context(gl2) {
+  (0, import_api.assert)(isWebGL2(gl2), ERR_WEBGL2);
+  return gl2;
 }
 
 // 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";
@@ -479,103 +469,103 @@ var GL_GPU_DISJOINT_EXT = 36795;
 var GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047;
 var GL_UNMASKED_VENDOR_WEBGL = 37445;
 var GL_UNMASKED_RENDERER_WEBGL = 37446;
-var getWebGL2ValueOrZero = (gl) => !isWebGL2(gl) ? 0 : void 0;
+var getWebGL2ValueOrZero = (gl2) => !isWebGL2(gl2) ? 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]: (gl2) => !isWebGL2(gl2) ? 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,
+  [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl2) => !isWebGL2(gl2) ? GL_DONT_CARE : void 0,
+  [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);
+  [GL_GPU_DISJOINT_EXT]: (gl2, getParameter) => {
+    const ext = isWebGL2(gl2) ? gl2.getExtension(EXT_disjoint_timer_query_webgl2) : gl2.getExtension(EXT_disjoint_timer_query);
     return ext && ext.GPU_DISJOINT_EXT ? getParameter(ext.GPU_DISJOINT_EXT) : 0;
   },
   // 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);
+  [GL_UNMASKED_VENDOR_WEBGL]: (gl2, getParameter) => {
+    const ext = gl2.getExtension(WEBGL_debug_renderer_info);
+    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);
+  [GL_UNMASKED_RENDERER_WEBGL]: (gl2, getParameter) => {
+    const ext = gl2.getExtension(WEBGL_debug_renderer_info);
+    return getParameter(ext && ext.UNMASKED_RENDERER_WEBGL || import_constants.GL.RENDERER);
   },
   // Extension LIMITS
-  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => {
+  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl2, getParameter) => {
     var _a, _b;
-    const ext = ((_b = (_a = gl.luma) == null ? void 0 : _a.extensions) == null ? void 0 : _b[EXT_texture_filter_anisotropic]) || gl.getExtension("EXT_texture_filter_anisotropic");
+    const ext = ((_b = (_a = gl2.luma) == null ? void 0 : _a.extensions) == null ? void 0 : _b[EXT_texture_filter_anisotropic]) || gl2.getExtension("EXT_texture_filter_anisotropic");
     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) => {
-    if (!isWebGL2(gl)) {
-      const ext = gl.getExtension(WEBGL_draw_buffers);
+  [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]: (gl2, getParameter) => {
+    if (!isWebGL2(gl2)) {
+      const ext = gl2.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) => {
-    if (!isWebGL2(gl)) {
-      const ext = gl.getExtension(WEBGL_draw_buffers);
+  [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]: (gl2) => {
+    if (!isWebGL2(gl2)) {
+      const ext = gl2.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
+    (gl2) => gl2.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
+    (gl2) => gl2.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
+    (gl2) => 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) {
+function getParameterPolyfill(gl2, originalGetParameter, pname) {
   const limit = WEBGL_PARAMETERS[pname];
-  const value = typeof limit === "function" ? limit(gl, originalGetParameter, pname) : limit;
+  const value = typeof limit === "function" ? limit(gl2, originalGetParameter, pname) : limit;
   const result = value !== void 0 ? value : originalGetParameter(pname);
   return result;
 }
 
 // src/context/polyfill/context-data.ts
-function getContextData(gl) {
-  const luma = gl.luma;
+function getContextData(gl2) {
+  const luma = gl2.luma;
   if (!luma) {
     const contextState = {
       _polyfilled: false,
       _extensions: {}
     };
-    gl.luma = contextState;
+    gl2.luma = contextState;
   }
-  return gl.luma;
+  return gl2.luma;
 }
 
 // src/context/polyfill/polyfill-table.ts
@@ -585,10 +575,10 @@ var WEBGL_draw_buffers2 = "WEBGL_draw_buffers";
 var EXT_disjoint_timer_query2 = "EXT_disjoint_timer_query";
 var EXT_texture_filter_anisotropic2 = "EXT_texture_filter_anisotropic";
 var ERR_VAO_NOT_SUPPORTED = "VertexArray requires WebGL2 or OES_vertex_array_object extension";
-function getExtensionData(gl, extension) {
+function getExtensionData(gl2, extension) {
   return {
-    webgl2: isWebGL2(gl),
-    ext: gl.getExtension(extension)
+    webgl2: isWebGL2(gl2),
+    ext: gl2.getExtension(extension)
   };
 }
 var WEBGL2_CONTEXT_POLYFILLS = {
@@ -655,21 +645,21 @@ var WEBGL2_CONTEXT_POLYFILLS = {
 };
 var WEBGL2_CONTEXT_OVERRIDES = {
   // Ensure readBuffer is a no-op
-  readBuffer: (gl, originalFunc, attachment) => {
-    if (isWebGL2(gl)) {
+  readBuffer: (gl2, originalFunc, attachment) => {
+    if (isWebGL2(gl2)) {
       originalFunc(attachment);
     } else {
     }
   },
   // Override for getVertexAttrib that returns sane values for non-WebGL1 constants
-  getVertexAttrib: (gl, originalFunc, location, pname) => {
-    const { webgl2, ext } = getExtensionData(gl, ANGLE_instanced_arrays);
+  getVertexAttrib: (gl2, originalFunc, location, pname) => {
+    const { webgl2, ext } = getExtensionData(gl2, 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:
@@ -677,88 +667,88 @@ var WEBGL2_CONTEXT_OVERRIDES = {
     return result !== void 0 ? result : originalFunc(location, pname);
   },
   // Handle transform feedback and uniform block queries in WebGL1
-  getProgramParameter: (gl, originalFunc, program, pname) => {
-    if (!isWebGL2(gl)) {
+  getProgramParameter: (gl2, originalFunc, program, pname) => {
+    if (!isWebGL2(gl2)) {
       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:
       }
     }
     return originalFunc(program, pname);
   },
-  getInternalformatParameter: (gl, originalFunc, target, format, pname) => {
-    if (!isWebGL2(gl)) {
+  getInternalformatParameter: (gl2, originalFunc, target, format, pname) => {
+    if (!isWebGL2(gl2)) {
       switch (pname) {
-        case import_constants2.default.SAMPLES:
+        case import_constants2.GL.SAMPLES:
           return new Int32Array([0]);
         default:
       }
     }
-    const gl2 = gl;
-    return gl2.getInternalformatParameter(target, format, pname);
+    const gl22 = gl2;
+    return gl22.getInternalformatParameter(target, format, pname);
   },
-  getTexParameter(gl, originalFunc, target, pname) {
+  getTexParameter(gl2, originalFunc, target, pname) {
     switch (pname) {
-      case import_constants2.default.TEXTURE_MAX_ANISOTROPY_EXT:
-        const contextData = getContextData(gl);
+      case import_constants2.GL.TEXTURE_MAX_ANISOTROPY_EXT:
+        const contextData = getContextData(gl2);
         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:
     }
     return originalFunc(target, pname);
   },
   getParameter: getParameterPolyfill,
-  hint(gl, originalFunc, pname, value) {
+  hint(gl2, originalFunc, pname, value) {
     return originalFunc(pname, value);
   }
 };
 
 // src/context/polyfill/polyfill-context.ts
-function polyfillContext(gl) {
-  const contextState = getContextData(gl);
+function polyfillContext(gl2) {
+  const contextState = getContextData(gl2);
   if (!contextState._polyfilled) {
-    polyfillVertexArrayObject(gl);
-    initializeExtensions(gl);
-    installPolyfills(gl, WEBGL2_CONTEXT_POLYFILLS);
-    installOverrides(gl, { target: contextState, target2: gl });
+    polyfillVertexArrayObject(gl2);
+    initializeExtensions(gl2);
+    installPolyfills(gl2, WEBGL2_CONTEXT_POLYFILLS);
+    installOverrides(gl2, { target: contextState, target2: gl2 });
     contextState._polyfilled = true;
   }
-  return gl;
+  return gl2;
 }
-function initializeExtensions(gl) {
-  const contextState = getContextData(gl);
-  const EXTENSIONS = gl.getSupportedExtensions() || [];
+function initializeExtensions(gl2) {
+  const contextState = getContextData(gl2);
+  const EXTENSIONS = gl2.getSupportedExtensions() || [];
   for (const extensionName of EXTENSIONS) {
-    const extension = gl.getExtension(extensionName);
+    const extension = gl2.getExtension(extensionName);
     contextState._extensions[extensionName] = extension;
   }
 }
-function installPolyfills(gl, polyfills) {
-  const contextState = getContextData(gl);
+function installPolyfills(gl2, polyfills) {
+  const contextState = getContextData(gl2);
   for (const extension of Object.getOwnPropertyNames(polyfills)) {
     if (extension !== "overrides") {
-      polyfillExtension(gl, { extension, target: contextState, target2: gl });
+      polyfillExtension(gl2, { extension, target: contextState, target2: gl2 });
     }
   }
 }
-function polyfillExtension(gl, { extension, target, target2 }) {
+function polyfillExtension(gl2, { extension, target, target2 }) {
   const defaults = WEBGL2_CONTEXT_POLYFILLS[extension];
   (0, import_api3.assert)(defaults);
   const { meta = {} } = defaults;
   const { suffix = "" } = meta;
-  const ext = gl.getExtension(extension);
+  const ext = gl2.getExtension(extension);
   for (const key of Object.keys(defaults)) {
     const extKey = `${key}${suffix}`;
     let polyfill = null;
     if (key === "meta") {
-    } else if (typeof gl[key] === "function") {
+    } else if (typeof gl2[key] === "function") {
     } else if (ext && typeof ext[extKey] === "function") {
       polyfill = (...args) => ext[extKey](...args);
     } else if (typeof defaults[key] === "function") {
@@ -770,12 +760,12 @@ function polyfillExtension(gl, { extension, target, target2 }) {
     }
   }
 }
-function installOverrides(gl, { target, target2 }) {
+function installOverrides(gl2, { target, target2 }) {
   Object.keys(WEBGL2_CONTEXT_OVERRIDES).forEach((key) => {
     if (typeof WEBGL2_CONTEXT_OVERRIDES[key] === "function") {
-      const originalFunc = gl[key] ? gl[key].bind(gl) : () => {
+      const originalFunc = gl2[key] ? gl2[key].bind(gl2) : () => {
       };
-      const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl, originalFunc);
+      const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl2, originalFunc);
       target[key] = polyfill;
       target2[key] = polyfill;
     }
@@ -870,19 +860,19 @@ var GL_PARAMETER_DEFAULTS = {
   [import_constants3.GL.UNPACK_SKIP_ROWS]: 0,
   [import_constants3.GL.UNPACK_SKIP_IMAGES]: 0
 };
-var enable = (gl, value, key) => value ? gl.enable(key) : gl.disable(key);
-var hint = (gl, value, key) => gl.hint(key, value);
-var pixelStorei = (gl, value, key) => gl.pixelStorei(key, value);
-var bindFramebuffer = (gl, value, key) => {
+var enable = (gl2, value, key) => value ? gl2.enable(key) : gl2.disable(key);
+var hint = (gl2, value, key) => gl2.hint(key, value);
+var pixelStorei = (gl2, value, key) => gl2.pixelStorei(key, value);
+var bindFramebuffer = (gl2, value, key) => {
   let target;
   if (key === import_constants3.GL.FRAMEBUFFER_BINDING) {
-    target = isWebGL2(gl) ? import_constants3.GL.DRAW_FRAMEBUFFER : import_constants3.GL.FRAMEBUFFER;
+    target = isWebGL2(gl2) ? import_constants3.GL.DRAW_FRAMEBUFFER : import_constants3.GL.FRAMEBUFFER;
   } else {
     target = import_constants3.GL.READ_FRAMEBUFFER;
   }
-  return gl.bindFramebuffer(target, value);
+  return gl2.bindFramebuffer(target, value);
 };
-var bindBuffer = (gl, value, key) => {
+var bindBuffer = (gl2, value, key) => {
   const bindingMap = {
     [import_constants3.GL.ARRAY_BUFFER_BINDING]: import_constants3.GL.ARRAY_BUFFER,
     [import_constants3.GL.COPY_READ_BUFFER_BINDING]: import_constants3.GL.COPY_READ_BUFFER,
@@ -891,38 +881,38 @@ var bindBuffer = (gl, value, key) => {
     [import_constants3.GL.PIXEL_UNPACK_BUFFER_BINDING]: import_constants3.GL.PIXEL_UNPACK_BUFFER
   };
   const target = bindingMap[key];
-  gl.bindBuffer(target, value);
+  gl2.bindBuffer(target, value);
 };
 function isArray(array) {
   return Array.isArray(array) || ArrayBuffer.isView(array) && !(array instanceof DataView);
 }
 var GL_PARAMETER_SETTERS = {
   [import_constants3.GL.BLEND]: enable,
-  [import_constants3.GL.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),
+  [import_constants3.GL.BLEND_COLOR]: (gl2, value) => gl2.blendColor(...value),
   [import_constants3.GL.BLEND_EQUATION_RGB]: "blendEquation",
   [import_constants3.GL.BLEND_EQUATION_ALPHA]: "blendEquation",
   [import_constants3.GL.BLEND_SRC_RGB]: "blendFunc",
   [import_constants3.GL.BLEND_DST_RGB]: "blendFunc",
   [import_constants3.GL.BLEND_SRC_ALPHA]: "blendFunc",
   [import_constants3.GL.BLEND_DST_ALPHA]: "blendFunc",
-  [import_constants3.GL.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),
-  [import_constants3.GL.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),
+  [import_constants3.GL.COLOR_CLEAR_VALUE]: (gl2, value) => gl2.clearColor(...value),
+  [import_constants3.GL.COLOR_WRITEMASK]: (gl2, value) => gl2.colorMask(...value),
   [import_constants3.GL.CULL_FACE]: enable,
-  [import_constants3.GL.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),
+  [import_constants3.GL.CULL_FACE_MODE]: (gl2, value) => gl2.cullFace(value),
   [import_constants3.GL.DEPTH_TEST]: enable,
-  [import_constants3.GL.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),
-  [import_constants3.GL.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),
-  [import_constants3.GL.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),
-  [import_constants3.GL.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),
+  [import_constants3.GL.DEPTH_CLEAR_VALUE]: (gl2, value) => gl2.clearDepth(value),
+  [import_constants3.GL.DEPTH_FUNC]: (gl2, value) => gl2.depthFunc(value),
+  [import_constants3.GL.DEPTH_RANGE]: (gl2, value) => gl2.depthRange(...value),
+  [import_constants3.GL.DEPTH_WRITEMASK]: (gl2, value) => gl2.depthMask(value),
   [import_constants3.GL.DITHER]: enable,
   [import_constants3.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
-  [import_constants3.GL.CURRENT_PROGRAM]: (gl, value) => gl.useProgram(value),
-  [import_constants3.GL.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(import_constants3.GL.RENDERBUFFER, value),
-  [import_constants3.GL.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => {
+  [import_constants3.GL.CURRENT_PROGRAM]: (gl2, value) => gl2.useProgram(value),
+  [import_constants3.GL.RENDERBUFFER_BINDING]: (gl2, value) => gl2.bindRenderbuffer(import_constants3.GL.RENDERBUFFER, value),
+  [import_constants3.GL.TRANSFORM_FEEDBACK_BINDING]: (gl2, value) => {
     var _a;
-    return (_a = gl.bindTransformFeedback) == null ? void 0 : _a.call(gl, import_constants3.GL.TRANSFORM_FEEDBACK, value);
+    return (_a = gl2.bindTransformFeedback) == null ? void 0 : _a.call(gl2, import_constants3.GL.TRANSFORM_FEEDBACK, value);
   },
-  [import_constants3.GL.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
+  [import_constants3.GL.VERTEX_ARRAY_BINDING]: (gl2, value) => gl2.bindVertexArray(value),
   // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
   [import_constants3.GL.FRAMEBUFFER_BINDING]: bindFramebuffer,
   [import_constants3.GL.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
@@ -932,9 +922,9 @@ var GL_PARAMETER_SETTERS = {
   [import_constants3.GL.COPY_WRITE_BUFFER_BINDING]: bindBuffer,
   [import_constants3.GL.PIXEL_PACK_BUFFER_BINDING]: bindBuffer,
   [import_constants3.GL.PIXEL_UNPACK_BUFFER_BINDING]: bindBuffer,
-  [import_constants3.GL.FRONT_FACE]: (gl, value) => gl.frontFace(value),
+  [import_constants3.GL.FRONT_FACE]: (gl2, value) => gl2.frontFace(value),
   [import_constants3.GL.GENERATE_MIPMAP_HINT]: hint,
-  [import_constants3.GL.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),
+  [import_constants3.GL.LINE_WIDTH]: (gl2, value) => gl2.lineWidth(value),
   [import_constants3.GL.POLYGON_OFFSET_FILL]: enable,
   [import_constants3.GL.POLYGON_OFFSET_FACTOR]: "polygonOffset",
   [import_constants3.GL.POLYGON_OFFSET_UNITS]: "polygonOffset",
@@ -944,11 +934,11 @@ var GL_PARAMETER_SETTERS = {
   [import_constants3.GL.SAMPLE_COVERAGE_VALUE]: "sampleCoverage",
   [import_constants3.GL.SAMPLE_COVERAGE_INVERT]: "sampleCoverage",
   [import_constants3.GL.SCISSOR_TEST]: enable,
-  [import_constants3.GL.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),
+  [import_constants3.GL.SCISSOR_BOX]: (gl2, value) => gl2.scissor(...value),
   [import_constants3.GL.STENCIL_TEST]: enable,
-  [import_constants3.GL.STENCIL_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),
-  [import_constants3.GL.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants3.GL.FRONT, value),
-  [import_constants3.GL.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants3.GL.BACK, value),
+  [import_constants3.GL.STENCIL_CLEAR_VALUE]: (gl2, value) => gl2.clearStencil(value),
+  [import_constants3.GL.STENCIL_WRITEMASK]: (gl2, value) => gl2.stencilMaskSeparate(import_constants3.GL.FRONT, value),
+  [import_constants3.GL.STENCIL_BACK_WRITEMASK]: (gl2, value) => gl2.stencilMaskSeparate(import_constants3.GL.BACK, value),
   [import_constants3.GL.STENCIL_FUNC]: "stencilFuncFront",
   [import_constants3.GL.STENCIL_REF]: "stencilFuncFront",
   [import_constants3.GL.STENCIL_VALUE_MASK]: "stencilFuncFront",
@@ -961,7 +951,7 @@ var GL_PARAMETER_SETTERS = {
   [import_constants3.GL.STENCIL_BACK_FAIL]: "stencilOpBack",
   [import_constants3.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
   [import_constants3.GL.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
-  [import_constants3.GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
+  [import_constants3.GL.VIEWPORT]: (gl2, value) => gl2.viewport(...value),
   // WEBGL1 PIXEL PACK/UNPACK MODES
   [import_constants3.GL.PACK_ALIGNMENT]: pixelStorei,
   [import_constants3.GL.UNPACK_ALIGNMENT]: pixelStorei,
@@ -979,104 +969,104 @@ var GL_PARAMETER_SETTERS = {
   [import_constants3.GL.UNPACK_SKIP_ROWS]: pixelStorei,
   [import_constants3.GL.UNPACK_SKIP_IMAGES]: pixelStorei,
   // Function-style setters
-  framebuffer: (gl, framebuffer) => {
+  framebuffer: (gl2, framebuffer) => {
     const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer;
-    return gl.bindFramebuffer(import_constants3.GL.FRAMEBUFFER, handle);
+    return gl2.bindFramebuffer(import_constants3.GL.FRAMEBUFFER, handle);
   },
-  blend: (gl, value) => value ? gl.enable(import_constants3.GL.BLEND) : gl.disable(import_constants3.GL.BLEND),
-  blendColor: (gl, value) => gl.blendColor(...value),
-  blendEquation: (gl, args) => {
+  blend: (gl2, value) => value ? gl2.enable(import_constants3.GL.BLEND) : gl2.disable(import_constants3.GL.BLEND),
+  blendColor: (gl2, value) => gl2.blendColor(...value),
+  blendEquation: (gl2, args) => {
     const separateModes = typeof args === "number" ? [args, args] : args;
-    gl.blendEquationSeparate(...separateModes);
+    gl2.blendEquationSeparate(...separateModes);
   },
-  blendFunc: (gl, args) => {
+  blendFunc: (gl2, args) => {
     const separateFuncs = (args == null ? void 0 : args.length) === 2 ? [...args, ...args] : args;
-    gl.blendFuncSeparate(...separateFuncs);
+    gl2.blendFuncSeparate(...separateFuncs);
   },
-  clearColor: (gl, value) => gl.clearColor(...value),
-  clearDepth: (gl, value) => gl.clearDepth(value),
-  clearStencil: (gl, value) => gl.clearStencil(value),
-  colorMask: (gl, value) => gl.colorMask(...value),
-  cull: (gl, value) => value ? gl.enable(import_constants3.GL.CULL_FACE) : gl.disable(import_constants3.GL.CULL_FACE),
-  cullFace: (gl, value) => gl.cullFace(value),
-  depthTest: (gl, value) => value ? gl.enable(import_constants3.GL.DEPTH_TEST) : gl.disable(import_constants3.GL.DEPTH_TEST),
-  depthFunc: (gl, value) => gl.depthFunc(value),
-  depthMask: (gl, value) => gl.depthMask(value),
-  depthRange: (gl, value) => gl.depthRange(...value),
-  dither: (gl, value) => value ? gl.enable(import_constants3.GL.DITHER) : gl.disable(import_constants3.GL.DITHER),
-  derivativeHint: (gl, value) => {
-    gl.hint(import_constants3.GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
+  clearColor: (gl2, value) => gl2.clearColor(...value),
+  clearDepth: (gl2, value) => gl2.clearDepth(value),
+  clearStencil: (gl2, value) => gl2.clearStencil(value),
+  colorMask: (gl2, value) => gl2.colorMask(...value),
+  cull: (gl2, value) => value ? gl2.enable(import_constants3.GL.CULL_FACE) : gl2.disable(import_constants3.GL.CULL_FACE),
+  cullFace: (gl2, value) => gl2.cullFace(value),
+  depthTest: (gl2, value) => value ? gl2.enable(import_constants3.GL.DEPTH_TEST) : gl2.disable(import_constants3.GL.DEPTH_TEST),
+  depthFunc: (gl2, value) => gl2.depthFunc(value),
+  depthMask: (gl2, value) => gl2.depthMask(value),
+  depthRange: (gl2, value) => gl2.depthRange(...value),
+  dither: (gl2, value) => value ? gl2.enable(import_constants3.GL.DITHER) : gl2.disable(import_constants3.GL.DITHER),
+  derivativeHint: (gl2, value) => {
+    gl2.hint(import_constants3.GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
   },
-  frontFace: (gl, value) => gl.frontFace(value),
-  mipmapHint: (gl, value) => gl.hint(import_constants3.GL.GENERATE_MIPMAP_HINT, value),
-  lineWidth: (gl, value) => gl.lineWidth(value),
-  polygonOffsetFill: (gl, value) => value ? gl.enable(import_constants3.GL.POLYGON_OFFSET_FILL) : gl.disable(import_constants3.GL.POLYGON_OFFSET_FILL),
-  polygonOffset: (gl, value) => gl.polygonOffset(...value),
-  sampleCoverage: (gl, value) => gl.sampleCoverage(...value),
-  scissorTest: (gl, value) => value ? gl.enable(import_constants3.GL.SCISSOR_TEST) : gl.disable(import_constants3.GL.SCISSOR_TEST),
-  scissor: (gl, value) => gl.scissor(...value),
-  stencilTest: (gl, value) => value ? gl.enable(import_constants3.GL.STENCIL_TEST) : gl.disable(import_constants3.GL.STENCIL_TEST),
-  stencilMask: (gl, value) => {
+  frontFace: (gl2, value) => gl2.frontFace(value),
+  mipmapHint: (gl2, value) => gl2.hint(import_constants3.GL.GENERATE_MIPMAP_HINT, value),
+  lineWidth: (gl2, value) => gl2.lineWidth(value),
+  polygonOffsetFill: (gl2, value) => value ? gl2.enable(import_constants3.GL.POLYGON_OFFSET_FILL) : gl2.disable(import_constants3.GL.POLYGON_OFFSET_FILL),
+  polygonOffset: (gl2, value) => gl2.polygonOffset(...value),
+  sampleCoverage: (gl2, value) => gl2.sampleCoverage(...value),
+  scissorTest: (gl2, value) => value ? gl2.enable(import_constants3.GL.SCISSOR_TEST) : gl2.disable(import_constants3.GL.SCISSOR_TEST),
+  scissor: (gl2, value) => gl2.scissor(...value),
+  stencilTest: (gl2, value) => value ? gl2.enable(import_constants3.GL.STENCIL_TEST) : gl2.disable(import_constants3.GL.STENCIL_TEST),
+  stencilMask: (gl2, value) => {
     value = isArray(value) ? value : [value, value];
     const [mask, backMask] = value;
-    gl.stencilMaskSeparate(import_constants3.GL.FRONT, mask);
-    gl.stencilMaskSeparate(import_constants3.GL.BACK, backMask);
+    gl2.stencilMaskSeparate(import_constants3.GL.FRONT, mask);
+    gl2.stencilMaskSeparate(import_constants3.GL.BACK, backMask);
   },
-  stencilFunc: (gl, args) => {
+  stencilFunc: (gl2, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [func, ref, mask, backFunc, backRef, backMask] = args;
-    gl.stencilFuncSeparate(import_constants3.GL.FRONT, func, ref, mask);
-    gl.stencilFuncSeparate(import_constants3.GL.BACK, backFunc, backRef, backMask);
+    gl2.stencilFuncSeparate(import_constants3.GL.FRONT, func, ref, mask);
+    gl2.stencilFuncSeparate(import_constants3.GL.BACK, backFunc, backRef, backMask);
   },
-  stencilOp: (gl, args) => {
+  stencilOp: (gl2, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args;
-    gl.stencilOpSeparate(import_constants3.GL.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(import_constants3.GL.BACK, backSfail, backDpfail, backDppass);
+    gl2.stencilOpSeparate(import_constants3.GL.FRONT, sfail, dpfail, dppass);
+    gl2.stencilOpSeparate(import_constants3.GL.BACK, backSfail, backDpfail, backDppass);
   },
-  viewport: (gl, value) => gl.viewport(...value)
+  viewport: (gl2, value) => gl2.viewport(...value)
 };
 function getValue(glEnum, values, cache) {
   return values[glEnum] !== void 0 ? values[glEnum] : cache[glEnum];
 }
 var GL_COMPOSITE_PARAMETER_SETTERS = {
-  blendEquation: (gl, values, cache) => gl.blendEquationSeparate(
+  blendEquation: (gl2, values, cache) => gl2.blendEquationSeparate(
     getValue(import_constants3.GL.BLEND_EQUATION_RGB, values, cache),
     getValue(import_constants3.GL.BLEND_EQUATION_ALPHA, values, cache)
   ),
-  blendFunc: (gl, values, cache) => gl.blendFuncSeparate(
+  blendFunc: (gl2, values, cache) => gl2.blendFuncSeparate(
     getValue(import_constants3.GL.BLEND_SRC_RGB, values, cache),
     getValue(import_constants3.GL.BLEND_DST_RGB, values, cache),
     getValue(import_constants3.GL.BLEND_SRC_ALPHA, values, cache),
     getValue(import_constants3.GL.BLEND_DST_ALPHA, values, cache)
   ),
-  polygonOffset: (gl, values, cache) => gl.polygonOffset(
+  polygonOffset: (gl2, values, cache) => gl2.polygonOffset(
     getValue(import_constants3.GL.POLYGON_OFFSET_FACTOR, values, cache),
     getValue(import_constants3.GL.POLYGON_OFFSET_UNITS, values, cache)
   ),
-  sampleCoverage: (gl, values, cache) => gl.sampleCoverage(
+  sampleCoverage: (gl2, values, cache) => gl2.sampleCoverage(
     getValue(import_constants3.GL.SAMPLE_COVERAGE_VALUE, values, cache),
     getValue(import_constants3.GL.SAMPLE_COVERAGE_INVERT, values, cache)
   ),
-  stencilFuncFront: (gl, values, cache) => gl.stencilFuncSeparate(
+  stencilFuncFront: (gl2, values, cache) => gl2.stencilFuncSeparate(
     import_constants3.GL.FRONT,
     getValue(import_constants3.GL.STENCIL_FUNC, values, cache),
     getValue(import_constants3.GL.STENCIL_REF, values, cache),
     getValue(import_constants3.GL.STENCIL_VALUE_MASK, values, cache)
   ),
-  stencilFuncBack: (gl, values, cache) => gl.stencilFuncSeparate(
+  stencilFuncBack: (gl2, values, cache) => gl2.stencilFuncSeparate(
     import_constants3.GL.BACK,
     getValue(import_constants3.GL.STENCIL_BACK_FUNC, values, cache),
     getValue(import_constants3.GL.STENCIL_BACK_REF, values, cache),
     getValue(import_constants3.GL.STENCIL_BACK_VALUE_MASK, values, cache)
   ),
-  stencilOpFront: (gl, values, cache) => gl.stencilOpSeparate(
+  stencilOpFront: (gl2, values, cache) => gl2.stencilOpSeparate(
     import_constants3.GL.FRONT,
     getValue(import_constants3.GL.STENCIL_FAIL, values, cache),
     getValue(import_constants3.GL.STENCIL_PASS_DEPTH_FAIL, values, cache),
     getValue(import_constants3.GL.STENCIL_PASS_DEPTH_PASS, values, cache)
   ),
-  stencilOpBack: (gl, values, cache) => gl.stencilOpSeparate(
+  stencilOpBack: (gl2, values, cache) => gl2.stencilOpSeparate(
     import_constants3.GL.BACK,
     getValue(import_constants3.GL.STENCIL_BACK_FAIL, values, cache),
     getValue(import_constants3.GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache),
@@ -1239,7 +1229,7 @@ var GL_HOOKED_SETTERS = {
     [import_constants3.GL.VIEWPORT]: [x, y, width, height]
   })
 };
-var isEnabled = (gl, key) => gl.isEnabled(key);
+var isEnabled = (gl2, key) => gl2.isEnabled(key);
 var GL_PARAMETER_GETTERS = {
   [import_constants3.GL.BLEND]: isEnabled,
   [import_constants3.GL.CULL_FACE]: isEnabled,
@@ -1295,7 +1285,7 @@ var NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([
 // src/context/parameters/unified-parameter-api.ts
 function setParameters(device, parameters) {
   const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
+  const gl2 = webglDevice.gl;
   if (isObjectEmpty(parameters)) {
     return;
   }
@@ -1307,31 +1297,31 @@ function setParameters(device, parameters) {
       if (typeof setter === "string") {
         compositeSetters[setter] = true;
       } else {
-        setter(gl, parameters[key], glConstant);
+        setter(gl2, parameters[key], glConstant);
       }
     }
   }
-  const cache = gl.state && gl.state.cache;
+  const cache = gl2.state && gl2.state.cache;
   if (cache) {
     for (const key in compositeSetters) {
       const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key];
-      compositeSetter(gl, parameters, cache);
+      compositeSetter(gl2, parameters, cache);
     }
   }
 }
 function getParameters(device, parameters = GL_PARAMETER_DEFAULTS) {
   const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
+  const gl2 = webglDevice.gl;
   if (typeof parameters === "number") {
     const key = parameters;
     const getter = GL_PARAMETER_GETTERS[key];
-    return getter ? getter(gl, key) : gl.getParameter(key);
+    return getter ? getter(gl2, key) : gl2.getParameter(key);
   }
   const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters);
   const state = {};
   for (const key of parameterKeys) {
     const getter = GL_PARAMETER_GETTERS[key];
-    state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key));
+    state[key] = getter ? getter(gl2, Number(key)) : gl2.getParameter(Number(key));
   }
   return state;
 }
@@ -1365,7 +1355,7 @@ function deepArrayEqual(x, y) {
 
 // src/context/state-tracker/track-context-state.ts
 var GLState = class {
-  constructor(gl, {
+  constructor(gl2, {
     copyState = false,
     // Copy cache from params (slow) or initialize from WebGL defaults (fast)
     log: log9 = () => {
@@ -1375,8 +1365,8 @@ var GLState = class {
     this.program = null;
     this.stateStack = [];
     this.enable = true;
-    this.gl = gl;
-    this.cache = copyState ? getParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
+    this.gl = gl2;
+    this.cache = copyState ? getParameters(gl2) : Object.assign({}, GL_PARAMETER_DEFAULTS);
     this.log = log9;
     this._updateCache = this._updateCache.bind(this);
     Object.seal(this);
@@ -1416,46 +1406,46 @@ var GLState = class {
     return { valueChanged, oldValue };
   }
 };
-function getContextState(gl) {
-  return gl.state;
+function getContextState(gl2) {
+  return gl2.state;
 }
-function trackContextState(gl, options) {
+function trackContextState(gl2, options) {
   const { enable: enable2 = true, copyState } = options;
   (0, import_api4.assert)(copyState !== void 0);
-  if (!gl.state) {
-    gl.state = new GLState(gl, { copyState });
-    installProgramSpy(gl);
+  if (!gl2.state) {
+    gl2.state = new GLState(gl2, { copyState });
+    installProgramSpy(gl2);
     for (const key in GL_HOOKED_SETTERS) {
       const setter = GL_HOOKED_SETTERS[key];
-      installSetterSpy(gl, key, setter);
+      installSetterSpy(gl2, key, setter);
     }
-    installGetterOverride(gl, "getParameter");
-    installGetterOverride(gl, "isEnabled");
+    installGetterOverride(gl2, "getParameter");
+    installGetterOverride(gl2, "isEnabled");
   }
-  const glState = getContextState(gl);
+  const glState = getContextState(gl2);
   glState.enable = enable2;
-  return gl;
+  return gl2;
 }
-function pushContextState(gl) {
-  let glState = getContextState(gl);
+function pushContextState(gl2) {
+  let glState = getContextState(gl2);
   if (!glState) {
-    trackContextState(gl, { copyState: false });
-    glState = getContextState(gl);
+    trackContextState(gl2, { copyState: false });
+    glState = getContextState(gl2);
   }
   glState.push();
 }
-function popContextState(gl) {
-  const glState = getContextState(gl);
+function popContextState(gl2) {
+  const glState = getContextState(gl2);
   (0, import_api4.assert)(glState);
   glState.pop();
 }
-function installGetterOverride(gl, functionName) {
-  const originalGetterFunc = gl[functionName].bind(gl);
-  gl[functionName] = function get(pname) {
+function installGetterOverride(gl2, functionName) {
+  const originalGetterFunc = gl2[functionName].bind(gl2);
+  gl2[functionName] = function get(pname) {
     if (pname === void 0 || NON_CACHE_PARAMETERS.has(pname)) {
       return originalGetterFunc(pname);
     }
-    const glState = getContextState(gl);
+    const glState = getContextState(gl2);
     if (!(pname in glState.cache)) {
       glState.cache[pname] = originalGetterFunc(pname);
     }
@@ -1467,33 +1457,33 @@ function installGetterOverride(gl, functionName) {
       originalGetterFunc(pname)
     );
   };
-  Object.defineProperty(gl[functionName], "name", {
+  Object.defineProperty(gl2[functionName], "name", {
     value: `${functionName}-from-cache`,
     configurable: false
   });
 }
-function installSetterSpy(gl, functionName, setter) {
-  if (!gl[functionName]) {
+function installSetterSpy(gl2, functionName, setter) {
+  if (!gl2[functionName]) {
     return;
   }
-  const originalSetterFunc = gl[functionName].bind(gl);
-  gl[functionName] = function set(...params) {
-    const glState = getContextState(gl);
+  const originalSetterFunc = gl2[functionName].bind(gl2);
+  gl2[functionName] = function set(...params) {
+    const glState = getContextState(gl2);
     const { valueChanged, oldValue } = setter(glState._updateCache, ...params);
     if (valueChanged) {
       originalSetterFunc(...params);
     }
     return oldValue;
   };
-  Object.defineProperty(gl[functionName], "name", {
+  Object.defineProperty(gl2[functionName], "name", {
     value: `${functionName}-to-cache`,
     configurable: false
   });
 }
-function installProgramSpy(gl) {
-  const originalUseProgram = gl.useProgram.bind(gl);
-  gl.useProgram = function useProgramLuma(handle) {
-    const glState = getContextState(gl);
+function installProgramSpy(gl2) {
+  const originalUseProgram = gl2.useProgram.bind(gl2);
+  gl2.useProgram = function useProgramLuma(handle) {
+    const glState = getContextState(gl2);
     if (glState.program !== handle) {
       originalUseProgram(handle);
       glState.program = handle;
@@ -1519,21 +1509,21 @@ function createBrowserContext(canvas, props) {
   let errorMessage = null;
   const onCreateError = (error2) => errorMessage = error2.statusMessage || errorMessage;
   canvas.addEventListener("webglcontextcreationerror", onCreateError, false);
-  let gl = null;
+  let gl2 = null;
   if (props.type === "webgl2") {
     props = __spreadProps(__spreadValues({}, props), { webgl1: false });
   }
   if (props.type === "webgl1") {
     props = __spreadProps(__spreadValues({}, props), { webgl2: false });
   }
-  if (!gl && props.webgl2) {
-    gl = canvas.getContext("webgl2", props);
+  if (!gl2 && props.webgl2) {
+    gl2 = canvas.getContext("webgl2", props);
   }
-  if (!gl && props.webgl1) {
-    gl = canvas.getContext("webgl", props);
+  if (!gl2 && props.webgl1) {
+    gl2 = canvas.getContext("webgl", props);
   }
   canvas.removeEventListener("webglcontextcreationerror", onCreateError, false);
-  if (!gl) {
+  if (!gl2) {
     throw new Error(
       `Failed to create ${props.webgl2 && !props.webgl1 ? "WebGL2" : "WebGL"} context: ${errorMessage || "Unknown error"}`
     );
@@ -1550,29 +1540,29 @@ function createBrowserContext(canvas, props) {
       false
     );
   }
-  return gl;
+  return gl2;
 }
 
 // src/adapter/device-helpers/get-device-info.ts
-var import_constants4 = __toESM(require("@luma.gl/constants"), 1);
-function getDeviceInfo(gl) {
-  const vendorMasked = gl.getParameter(import_constants4.default.VENDOR);
-  const rendererMasked = gl.getParameter(import_constants4.default.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);
+var import_constants4 = require("@luma.gl/constants");
+function getDeviceInfo(gl2) {
+  const vendorMasked = gl2.getParameter(import_constants4.GL.VENDOR);
+  const rendererMasked = gl2.getParameter(import_constants4.GL.RENDERER);
+  const ext = gl2.getExtension("WEBGL_debug_renderer_info");
+  const vendorUnmasked = gl2.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : import_constants4.GL.VENDOR);
+  const rendererUnmasked = gl2.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : import_constants4.GL.RENDERER);
   const vendor = vendorUnmasked || vendorMasked;
   const renderer = rendererUnmasked || rendererMasked;
   const gpu = identifyGPUVendor(vendor, renderer);
   return {
-    type: isWebGL2(gl) ? "webgl2" : "webgl",
+    type: isWebGL2(gl2) ? "webgl2" : "webgl",
     gpu,
     vendor: vendorUnmasked || vendorMasked,
     renderer: rendererUnmasked || rendererMasked,
-    version: gl.getParameter(import_constants4.default.VERSION),
+    version: gl2.getParameter(import_constants4.GL.VERSION),
     shadingLanguages: ["glsl"],
     shadingLanguageVersions: {
-      "glsl": gl.getParameter(import_constants4.default.SHADING_LANGUAGE_VERSION)
+      "glsl": gl2.getParameter(import_constants4.GL.SHADING_LANGUAGE_VERSION)
     }
   };
 }
@@ -1606,7 +1596,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";
@@ -1626,264 +1616,264 @@ var EXT_SRGB = "EXT_sRGB";
 var EXT_TEXTURE_NORM16 = "EXT_texture_norm16";
 var EXT_FLOAT_WEBGL1 = "WEBGL_color_buffer_float";
 var EXT_FLOAT_RENDER_WEBGL2 = "EXT_color_buffer_float";
-var checkExtension = (gl, extension) => gl.getExtension(extension);
-var checkExtensions = (gl, extensions) => extensions.every((extension) => gl.getExtension(extension));
+var checkExtension = (gl2, extension) => gl2.getExtension(extension);
+var checkExtensions = (gl2, extensions) => extensions.every((extension) => gl2.getExtension(extension));
 var TEXTURE_FEATURE_CHECKS = {
-  "texture-blend-float-webgl1": (gl) => isWebGL2(gl) ? true : checkExtension(gl, "EXT_float_blend"),
-  "texture-formats-srgb-webgl1": (gl) => isWebGL2(gl) ? true : checkExtension(gl, EXT_SRGB),
-  "texture-formats-depth-webgl1": (gl) => isWebGL2(gl) ? true : checkExtension(gl, "WEBGL_depth_texture"),
-  "texture-formats-float32-webgl1": (gl) => isWebGL2(gl) ? true : checkExtension(gl, "OES_texture_float"),
-  "texture-formats-float16-webgl1": (gl) => isWebGL2(gl) ? true : checkExtension(gl, "OES_texture_half_float"),
-  "texture-formats-norm16-webgl": (gl) => isWebGL2(gl) ? checkExtension(gl, EXT_TEXTURE_NORM16) : false,
-  "texture-filter-linear-float32-webgl": (gl) => checkExtension(gl, "OES_texture_float_linear"),
-  "texture-filter-linear-float16-webgl": (gl) => checkExtension(gl, "OES_texture_half_float_linear"),
-  "texture-filter-anisotropic-webgl": (gl) => checkExtension(gl, "EXT_texture_filter_anisotropic"),
-  "texture-renderable-float32-webgl": (gl) => checkExtension(gl, "EXT_color_buffer_float"),
+  "texture-blend-float-webgl1": (gl2) => isWebGL2(gl2) ? true : checkExtension(gl2, "EXT_float_blend"),
+  "texture-formats-srgb-webgl1": (gl2) => isWebGL2(gl2) ? true : checkExtension(gl2, EXT_SRGB),
+  "texture-formats-depth-webgl1": (gl2) => isWebGL2(gl2) ? true : checkExtension(gl2, "WEBGL_depth_texture"),
+  "texture-formats-float32-webgl1": (gl2) => isWebGL2(gl2) ? true : checkExtension(gl2, "OES_texture_float"),
+  "texture-formats-float16-webgl1": (gl2) => isWebGL2(gl2) ? true : checkExtension(gl2, "OES_texture_half_float"),
+  "texture-formats-norm16-webgl": (gl2) => isWebGL2(gl2) ? checkExtension(gl2, EXT_TEXTURE_NORM16) : false,
+  "texture-filter-linear-float32-webgl": (gl2) => checkExtension(gl2, "OES_texture_float_linear"),
+  "texture-filter-linear-float16-webgl": (gl2) => checkExtension(gl2, "OES_texture_half_float_linear"),
+  "texture-filter-anisotropic-webgl": (gl2) => checkExtension(gl2, "EXT_texture_filter_anisotropic"),
+  "texture-renderable-float32-webgl": (gl2) => checkExtension(gl2, "EXT_color_buffer_float"),
   // [false, 'EXT_color_buffer_float'],
-  "texture-renderable-float16-webgl": (gl) => checkExtension(gl, "EXT_color_buffer_half_float"),
-  "texture-compression-bc": (gl) => checkExtensions(gl, [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC]),
-  "texture-compression-bc5-webgl": (gl) => checkExtensions(gl, [X_RGTC]),
+  "texture-renderable-float16-webgl": (gl2) => checkExtension(gl2, "EXT_color_buffer_half_float"),
+  "texture-compression-bc": (gl2) => checkExtensions(gl2, [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC]),
+  "texture-compression-bc5-webgl": (gl2) => checkExtensions(gl2, [X_RGTC]),
   // 'texture-compression-bc7-webgl': gl => checkExtensions(gl, [X_BPTC]),
   // 'texture-compression-bc3-srgb-webgl': gl => checkExtensions(gl, [X_S3TC_SRGB]),
   // 'texture-compression-bc3-webgl': gl => checkExtensions(gl, [X_S3TC]),
-  "texture-compression-etc2": (gl) => checkExtensions(gl, [X_ETC2]),
-  "texture-compression-astc": (gl) => checkExtensions(gl, [X_ASTC]),
-  "texture-compression-etc1-webgl": (gl) => checkExtensions(gl, [X_ETC1]),
-  "texture-compression-pvrtc-webgl": (gl) => checkExtensions(gl, [X_PVRTC]),
-  "texture-compression-atc-webgl": (gl) => checkExtensions(gl, [X_ATC])
+  "texture-compression-etc2": (gl2) => checkExtensions(gl2, [X_ETC2]),
+  "texture-compression-astc": (gl2) => checkExtensions(gl2, [X_ASTC]),
+  "texture-compression-etc1-webgl": (gl2) => checkExtensions(gl2, [X_ETC1]),
+  "texture-compression-pvrtc-webgl": (gl2) => checkExtensions(gl2, [X_PVRTC]),
+  "texture-compression-atc-webgl": (gl2) => checkExtensions(gl2, [X_ATC])
 };
-function checkTextureFeature(gl, feature) {
+function checkTextureFeature(gl2, feature) {
   var _a;
-  return ((_a = TEXTURE_FEATURE_CHECKS[feature]) == null ? void 0 : _a.call(TEXTURE_FEATURE_CHECKS, gl)) || false;
+  return ((_a = TEXTURE_FEATURE_CHECKS[feature]) == null ? void 0 : _a.call(TEXTURE_FEATURE_CHECKS, gl2)) || false;
 }
-function getTextureFeatures(gl) {
+function getTextureFeatures(gl2) {
   const textureFeatures = Object.keys(TEXTURE_FEATURE_CHECKS);
-  return textureFeatures.filter((feature) => checkTextureFeature(gl, feature));
+  return textureFeatures.filter((feature) => checkTextureFeature(gl2, feature));
 }
 var TEXTURE_FORMATS = {
   // Unsized formats that leave the precision up to the driver.
   // 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) {
+function isTextureFormatSupported(gl2, formatOrGL) {
   const format = convertGLToTextureFormat(formatOrGL);
   const info = TEXTURE_FORMATS[format];
   if (!info) {
     return false;
   }
-  if (isWebGL2(gl) ? info.gl === void 0 : info.gl1 === void 0) {
+  if (isWebGL2(gl2) ? info.gl === void 0 : info.gl1 === void 0) {
     return false;
   }
-  const extension = info.x || (isWebGL2(gl) ? info.gl2ext || info.gl1ext : info.gl1ext);
+  const extension = info.x || (isWebGL2(gl2) ? info.gl2ext || info.gl1ext : info.gl1ext);
   if (extension) {
-    return Boolean(gl.getExtension(extension));
+    return Boolean(gl2.getExtension(extension));
   }
   return true;
 }
-function isRenderbufferFormatSupported(gl, format) {
+function isRenderbufferFormatSupported(gl2, format) {
   var _a;
-  return isTextureFormatSupported(gl, format) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
+  return isTextureFormatSupported(gl2, format) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
 }
 function convertGLToTextureFormat(format) {
   if (typeof format === "string") {
@@ -1905,9 +1895,9 @@ function convertTextureFormatToGL(format, isWebGL23) {
   }
   return webglFormat;
 }
-function isTextureFormatFilterable(gl, formatOrGL) {
+function isTextureFormatFilterable(gl2, formatOrGL) {
   const format = convertGLToTextureFormat(formatOrGL);
-  if (!isTextureFormatSupported(gl, format)) {
+  if (!isTextureFormatSupported(gl2, format)) {
     return false;
   }
   try {
@@ -1919,16 +1909,16 @@ function isTextureFormatFilterable(gl, formatOrGL) {
     return false;
   }
   if (format.endsWith("32float")) {
-    return Boolean(gl.getExtension("OES_texture_float_linear"));
+    return Boolean(gl2.getExtension("OES_texture_float_linear"));
   }
   if (format.endsWith("16float")) {
-    return Boolean(gl.getExtension("OES_texture_half_float_linear"));
+    return Boolean(gl2.getExtension("OES_texture_half_float_linear"));
   }
   return true;
 }
-function isTextureFormatRenderable(gl, formatOrGL) {
+function isTextureFormatRenderable(gl2, formatOrGL) {
   const format = convertGLToTextureFormat(formatOrGL);
-  if (!isTextureFormatSupported(gl, format)) {
+  if (!isTextureFormatSupported(gl2, format)) {
     return false;
   }
   if (typeof format === "number") {
@@ -1960,19 +1950,19 @@ 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(gl2, internalFormat = gl2.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);
+    texture = gl2.createTexture();
+    gl2.bindTexture(import_constants5.GL.TEXTURE_2D, texture);
     const level = 0;
     const width = 1;
     const height = 1;
     const border = 0;
     const pixel = new Uint8Array([0, 0, 255, 255]);
-    gl.texImage2D(
-      gl.TEXTURE_2D,
+    gl2.texImage2D(
+      gl2.TEXTURE_2D,
       level,
       internalFormat,
       width,
@@ -1982,15 +1972,15 @@ function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat =
       srcType,
       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);
+    framebuffer = gl2.createFramebuffer();
+    gl2.bindFramebuffer(import_constants5.GL.FRAMEBUFFER, framebuffer);
+    gl2.framebufferTexture2D(import_constants5.GL.FRAMEBUFFER, import_constants5.GL.COLOR_ATTACHMENT0, import_constants5.GL.TEXTURE_2D, texture, 0);
+    const status = gl2.checkFramebufferStatus(import_constants5.GL.FRAMEBUFFER) === import_constants5.GL.FRAMEBUFFER_COMPLETE;
+    gl2.bindTexture(import_constants5.GL.TEXTURE_2D, null);
     return status;
   } finally {
-    gl.deleteTexture(texture);
-    gl.deleteFramebuffer(framebuffer);
+    gl2.deleteTexture(texture);
+    gl2.deleteFramebuffer(framebuffer);
   }
 }
 function getTextureFormatBytesPerPixel(formatOrGL, isWebGL23) {
@@ -2001,90 +1991,90 @@ 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;
   }
 }
 
 // src/adapter/device-helpers/device-features.ts
-function getDeviceFeatures(gl) {
-  const features = getWebGLFeatures(gl);
-  for (const textureFeature of getTextureFeatures(gl)) {
+function getDeviceFeatures(gl2) {
+  const features = getWebGLFeatures(gl2);
+  for (const textureFeature of getTextureFeatures(gl2)) {
     features.add(textureFeature);
   }
   return features;
 }
-function getWebGLFeatures(gl) {
-  gl.getExtension("EXT_color_buffer_float");
-  gl.getExtension("WEBGL_color_buffer_float");
-  gl.getExtension("EXT_float_blend");
+function getWebGLFeatures(gl2) {
+  gl2.getExtension("EXT_color_buffer_float");
+  gl2.getExtension("WEBGL_color_buffer_float");
+  gl2.getExtension("EXT_float_blend");
   const features = /* @__PURE__ */ new Set();
   for (const feature of Object.keys(WEBGL_FEATURES)) {
-    if (isFeatureSupported(gl, feature)) {
+    if (isFeatureSupported(gl2, feature)) {
       features.add(feature);
     }
   }
   return features;
 }
-function isFeatureSupported(gl, feature) {
+function isFeatureSupported(gl2, feature) {
   const featureInfo = WEBGL_FEATURES[feature];
   if (!featureInfo) {
     return false;
   }
   const [webgl1Feature, webgl2Feature] = featureInfo || [];
-  const featureDefinition = isWebGL2(gl) ? webgl2Feature : webgl1Feature;
+  const featureDefinition = isWebGL2(gl2) ? webgl2Feature : webgl1Feature;
   if (typeof featureDefinition === "boolean") {
     return featureDefinition;
   }
   switch (feature) {
     case "texture-renderable-rgba32float-webgl":
-      return isWebGL2(gl) ? Boolean(gl.getExtension(featureDefinition)) : _checkFloat32ColorAttachment(gl);
+      return isWebGL2(gl2) ? Boolean(gl2.getExtension(featureDefinition)) : _checkFloat32ColorAttachment(gl2);
     case "glsl-derivatives":
-      return canCompileGLSLExtension(gl, featureDefinition);
+      return canCompileGLSLExtension(gl2, featureDefinition);
     case "glsl-frag-data":
-      return canCompileGLSLExtension(gl, featureDefinition, { behavior: "require" });
+      return canCompileGLSLExtension(gl2, featureDefinition, { behavior: "require" });
     case "glsl-frag-depth":
-      return canCompileGLSLExtension(gl, featureDefinition);
+      return canCompileGLSLExtension(gl2, featureDefinition);
     default:
-      return Boolean(gl.getExtension(featureDefinition));
+      return Boolean(gl2.getExtension(featureDefinition));
   }
 }
 var compiledGLSLExtensions = {};
-function canCompileGLSLExtension(gl, extensionName, opts = {}) {
+function canCompileGLSLExtension(gl2, extensionName, opts = {}) {
   if (!isOldIE(opts)) {
     return true;
   }
@@ -2094,14 +2084,14 @@ function canCompileGLSLExtension(gl, extensionName, opts = {}) {
   const behavior = opts.behavior || "enable";
   const source = `#extension GL_${extensionName} : ${behavior}
 void main(void) {}`;
-  const shader = gl.createShader(gl.VERTEX_SHADER);
+  const shader = gl2.createShader(gl2.VERTEX_SHADER);
   if (!shader) {
     throw new Error("shader");
   }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  const canCompile = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
-  gl.deleteShader(shader);
+  gl2.shaderSource(shader, source);
+  gl2.compileShader(shader);
+  const canCompile = gl2.getShaderParameter(shader, gl2.COMPILE_STATUS);
+  gl2.deleteShader(shader);
   compiledGLSLExtensions[extensionName] = canCompile;
   return canCompile;
 }
@@ -2138,39 +2128,39 @@ var WEBGL_FEATURES = {
 };
 
 // src/adapter/device-helpers/device-limits.ts
-var import_constants6 = __toESM(require("@luma.gl/constants"), 1);
-function getDeviceLimits(gl) {
-  const gl2 = getWebGL2Context(gl);
+var import_constants6 = require("@luma.gl/constants");
+function getDeviceLimits(gl2) {
+  const gl22 = getWebGL2Context(gl2);
   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: gl2.getParameter(import_constants6.GL.MAX_TEXTURE_SIZE),
+    maxTextureDimension3D: gl22 ? gl22.getParameter(import_constants6.GL.MAX_3D_TEXTURE_SIZE) : 0,
+    maxTextureArrayLayers: gl22 ? gl22.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: gl2.getParameter(import_constants6.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
     // TBD
-    maxSamplersPerShaderStage: gl.getParameter(import_constants6.default.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+    maxSamplersPerShaderStage: gl2.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: gl22 ? gl22.getParameter(import_constants6.GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
+    maxUniformBufferBindingSize: gl22 ? gl22.getParameter(import_constants6.GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
     maxStorageBufferBindingSize: 0,
-    minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(import_constants6.default.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
+    minUniformBufferOffsetAlignment: gl22 ? gl22.getParameter(import_constants6.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
     minStorageBufferOffsetAlignment: 0,
     // TBD
     maxVertexBuffers: 0,
-    maxVertexAttributes: gl.getParameter(import_constants6.default.MAX_VERTEX_ATTRIBS),
+    maxVertexAttributes: gl2.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: gl22 ? gl22.getParameter(import_constants6.GL.MAX_VARYING_COMPONENTS) : 0,
     maxComputeWorkgroupStorageSize: 0,
     // WebGL does not support compute shaders
     maxComputeInvocationsPerWorkgroup: 0,
@@ -2185,98 +2175,98 @@ function getDeviceLimits(gl) {
     // WebGL does not support compute shaders
   };
 }
-function getWebGLLimits(gl) {
-  const gl2 = getWebGL2Context(gl);
+function getWebGLLimits(gl2) {
+  const gl22 = getWebGL2Context(gl2);
   function get(pname) {
-    return gl.getParameter(pname);
+    return gl2.getParameter(pname);
   }
   function get2(pname, defaultValue) {
-    return gl2 ? gl2.getParameter(pname) : defaultValue || 0;
+    return gl22 ? gl22.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 +2276,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");
@@ -2296,22 +2286,22 @@ var import_constants11 = require("@luma.gl/constants");
 // src/context/state-tracker/with-parameters.ts
 function withParameters(device, parameters, func) {
   const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
+  const gl2 = webglDevice.gl;
   if (isObjectEmpty2(parameters)) {
     return func(device);
   }
   const { nocatch = true } = parameters;
-  pushContextState(gl);
-  setParameters(gl, parameters);
+  pushContextState(gl2);
+  setParameters(gl2, parameters);
   let value;
   if (nocatch) {
-    value = func(gl);
-    popContextState(gl);
+    value = func(gl2);
+    popContextState(gl2);
   } else {
     try {
-      value = func(gl);
+      value = func(gl2);
     } finally {
-      popContextState(gl);
+      popContextState(gl2);
     }
   }
   return value;
@@ -2328,7 +2318,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);
@@ -2355,44 +2345,44 @@ function withDeviceParameters(device, parameters, func) {
 }
 function setDeviceParameters(device, parameters) {
   const webglDevice = WebGLDevice.attach(device);
-  const { gl } = webglDevice;
+  const { gl: gl2 } = webglDevice;
   if (parameters.cullMode) {
     switch (parameters.cullMode) {
       case "none":
-        gl.disable(import_constants7.default.CULL_FACE);
+        gl2.disable(import_constants7.GL.CULL_FACE);
         break;
       case "front":
-        gl.enable(import_constants7.default.CULL_FACE);
-        gl.cullFace(import_constants7.default.FRONT);
+        gl2.enable(import_constants7.GL.CULL_FACE);
+        gl2.cullFace(import_constants7.GL.FRONT);
         break;
       case "back":
-        gl.enable(import_constants7.default.CULL_FACE);
-        gl.cullFace(import_constants7.default.BACK);
+        gl2.enable(import_constants7.GL.CULL_FACE);
+        gl2.cullFace(import_constants7.GL.BACK);
         break;
     }
   }
   if (parameters.frontFace) {
-    gl.frontFace(
+    gl2.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
       })
     );
   }
   if (parameters.depthBias !== void 0) {
-    gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
+    gl2.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
   }
   if (parameters.depthWriteEnabled !== void 0) {
-    gl.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
+    gl2.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);
-    gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
+    parameters.depthCompare !== "always" ? gl2.enable(import_constants7.GL.DEPTH_TEST) : gl2.disable(import_constants7.GL.DEPTH_TEST);
+    gl2.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);
+    gl2.stencilMaskSeparate(import_constants7.GL.FRONT, mask);
+    gl2.stencilMaskSeparate(import_constants7.GL.BACK, mask);
   }
   if (parameters.stencilReadMask) {
     import_api6.log.warn("stencilReadMask not supported under WebGL");
@@ -2400,9 +2390,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" ? gl2.enable(import_constants7.GL.STENCIL_TEST) : gl2.disable(import_constants7.GL.STENCIL_TEST);
+    gl2.stencilFuncSeparate(import_constants7.GL.FRONT, glValue, 0, mask);
+    gl2.stencilFuncSeparate(import_constants7.GL.BACK, glValue, 0, mask);
   }
   if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
     const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation);
@@ -2411,32 +2401,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);
+    gl2.stencilOpSeparate(import_constants7.GL.FRONT, sfail, dpfail, dppass);
+    gl2.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 +2518,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 +2583,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 +2599,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 +2618,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
@@ -2958,18 +2948,18 @@ var _WEBGLTexture = class extends import_api10.Texture {
       width,
       height
     }));
-    const { gl } = this;
-    gl.bindTexture(this.target, this.handle);
+    const { gl: gl2 } = this;
+    gl2.bindTexture(this.target, this.handle);
     let dataType = null;
     ({ data, dataType } = this._getDataType({ data, compressed }));
-    let gl2;
+    let gl22;
     withParameters(this.gl, parameters, () => {
       switch (dataType) {
         case "null":
-          gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
+          gl2.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
           break;
         case "typed-array":
-          gl.texImage2D(
+          gl2.texImage2D(
             target,
             level,
             glFormat,
@@ -2985,9 +2975,9 @@ var _WEBGLTexture = class extends import_api10.Texture {
           );
           break;
         case "buffer":
-          gl2 = this.device.assertWebGL2();
-          gl2.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
-          gl2.texImage2D(
+          gl22 = this.device.assertWebGL2();
+          gl22.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
+          gl22.texImage2D(
             target,
             level,
             glFormat,
@@ -2998,11 +2988,11 @@ var _WEBGLTexture = class extends import_api10.Texture {
             type,
             offset
           );
-          gl2.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, null);
+          gl22.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, null);
           break;
         case "browser-object":
           if (this.device.isWebGL2) {
-            gl.texImage2D(
+            gl2.texImage2D(
               target,
               level,
               glFormat,
@@ -3014,12 +3004,12 @@ var _WEBGLTexture = class extends import_api10.Texture {
               data
             );
           } else {
-            gl.texImage2D(target, level, glFormat, dataFormat, type, data);
+            gl2.texImage2D(target, level, glFormat, dataFormat, type, data);
           }
           break;
         case "compressed":
           for (const [levelIndex, levelData] of data.entries()) {
-            gl.compressedTexImage2D(
+            gl2.compressedTexImage2D(
               target,
               levelIndex,
               levelData.format,
@@ -3126,21 +3116,21 @@ var _WEBGLTexture = class extends import_api10.Texture {
     return this.gl.getParameter(import_constants11.GL.ACTIVE_TEXTURE) - import_constants11.GL.TEXTURE0;
   }
   bind(textureUnit = this.textureUnit) {
-    const { gl } = this;
+    const { gl: gl2 } = this;
     if (textureUnit !== void 0) {
       this.textureUnit = textureUnit;
-      gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      gl2.activeTexture(gl2.TEXTURE0 + textureUnit);
     }
-    gl.bindTexture(this.target, this.handle);
+    gl2.bindTexture(this.target, this.handle);
     return textureUnit;
   }
   unbind(textureUnit = this.textureUnit) {
-    const { gl } = this;
+    const { gl: gl2 } = this;
     if (textureUnit !== void 0) {
       this.textureUnit = textureUnit;
-      gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      gl2.activeTexture(gl2.TEXTURE0 + textureUnit);
     }
-    gl.bindTexture(this.target, null);
+    gl2.bindTexture(this.target, null);
     return textureUnit;
   }
   // PRIVATE METHODS
@@ -3206,7 +3196,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
   /* eslint-disable max-statements, max-len */
   setCubeMapImageData(options) {
     return __async(this, null, function* () {
-      const { gl } = this;
+      const { gl: gl2 } = this;
       const { width, height, pixels, data, format = import_constants11.GL.RGBA, type = import_constants11.GL.UNSIGNED_BYTE } = options;
       const imageDataMap = pixels || data;
       const resolvedFaces = yield Promise.all(
@@ -3222,9 +3212,9 @@ var _WEBGLTexture = class extends import_api10.Texture {
         }
         resolvedFaces[index].forEach((image, lodLevel) => {
           if (width && height) {
-            gl.texImage2D(face, lodLevel, format, width, height, 0, format, type, image);
+            gl2.texImage2D(face, lodLevel, format, width, height, 0, format, type, image);
           } else {
-            gl.texImage2D(face, lodLevel, format, format, type, image);
+            gl2.texImage2D(face, lodLevel, format, format, type, image);
           }
         });
       });
@@ -3243,7 +3233,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
       type = import_constants11.GL.UNSIGNED_BYTE
       // generateMipmap = false // TODO
     } = options;
-    const { gl } = this;
+    const { gl: gl2 } = this;
     const imageData = pixels || data;
     this.bind();
     if (imageData instanceof Promise) {
@@ -3257,9 +3247,9 @@ var _WEBGLTexture = class extends import_api10.Texture {
         )
       );
     } else if (this.width || this.height) {
-      gl.texImage2D(face, 0, format, width, height, 0, format, type, imageData);
+      gl2.texImage2D(face, 0, format, width, height, 0, format, type, imageData);
     } else {
-      gl.texImage2D(face, 0, format, format, type, imageData);
+      gl2.texImage2D(face, 0, format, format, type, imageData);
     }
     return this;
   }
@@ -3410,14 +3400,14 @@ 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");
 
 // src/adapter/objects/constants-to-keys.ts
 var import_api11 = require("@luma.gl/api");
-function getKeyValue(gl, name) {
+function getKeyValue(gl2, name) {
   if (typeof name !== "string") {
     return name;
   }
@@ -3426,7 +3416,7 @@ function getKeyValue(gl, name) {
     return number;
   }
   name = name.replace(/^.*\./, "");
-  const value = gl[name];
+  const value = gl2[name];
   (0, import_api11.assert)(value !== void 0, `Accessing undefined constant GL.${name}`);
   return value;
 }
@@ -3440,11 +3430,11 @@ var WebGLResource = class extends import_api12.Resource {
     // Only meaningful for resources that allocate GPU memory
     this.byteLength = 0;
     this.device = WebGLDevice.attach(device);
-    const gl = this.device.gl;
-    assertWebGLContext(gl);
+    const gl2 = this.device.gl;
+    assertWebGLContext(gl2);
     const { id } = props || {};
-    this.gl = gl;
-    this.gl2 = gl;
+    this.gl = gl2;
+    this.gl2 = gl2;
     this.id = id || (0, import_api12.uid)(this.constructor.name);
     this._handle = props == null ? void 0 : props.handle;
     if (this._handle === void 0) {
@@ -3676,13 +3666,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 +3686,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 +3712,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 +3726,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();
@@ -3755,11 +3745,11 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
   // PRIVATE
   /** 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);
-    if (status !== gl.FRAMEBUFFER_COMPLETE) {
+    const { gl: gl2 } = this;
+    const prevHandle2 = gl2.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, this.handle);
+    const status = gl2.checkFramebufferStatus(import_constants13.GL.FRAMEBUFFER);
+    gl2.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, prevHandle2 || null);
+    if (status !== gl2.FRAMEBUFFER_COMPLETE) {
       throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
     }
   }
@@ -3815,9 +3805,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
     );
   }
@@ -3828,43 +3818,43 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
    * @param level  = 0 - mipmapLevel (must be 0 in WebGL1)
    */
   _attachTexture(attachment, texture, layer, level) {
-    const { gl, gl2 } = this.device;
-    gl.bindTexture(texture.target, texture.handle);
+    const { gl: gl2, gl2: gl22 } = this.device;
+    gl2.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);
+        gl22 == null ? void 0 : gl22.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);
+        gl2.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:
+        gl2.framebufferTexture2D(import_constants13.GL.FRAMEBUFFER, attachment, import_constants13.GL.TEXTURE_2D, texture.handle, level);
         break;
       default:
         (0, import_api14.assert)(false, "Illegal texture type");
     }
-    gl.bindTexture(texture.target, null);
+    gl2.bindTexture(texture.target, null);
   }
 };
 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}`;
@@ -3908,6 +3898,7 @@ var WebGLCanvasContext = class extends import_api15.CanvasContext {
    */
   resize(options) {
     if (this.canvas) {
+      const devicePixelRatio = this.getDevicePixelRatio(options == null ? void 0 : options.useDevicePixels);
       this.setDevicePixelRatio(devicePixelRatio, options);
       return;
     }
@@ -3981,11 +3972,11 @@ 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 || {};
-  return gl.luma;
+function getContextData2(gl2) {
+  gl2.luma = gl2.luma || {};
+  return gl2.luma;
 }
 function loadWebGLDeveloperTools() {
   return __async(this, null, function* () {
@@ -3996,42 +3987,42 @@ function loadWebGLDeveloperTools() {
     }
   });
 }
-function makeDebugContext(gl, props = {}) {
-  if (!gl) {
+function makeDebugContext(gl2, props = {}) {
+  if (!gl2) {
     return null;
   }
-  return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
+  return props.debug ? getDebugContext(gl2, props) : getRealContext(gl2);
 }
-function getRealContext(gl) {
-  const data = getContextData2(gl);
-  return data.realContext ? data.realContext : gl;
+function getRealContext(gl2) {
+  const data = getContextData2(gl2);
+  return data.realContext ? data.realContext : gl2;
 }
-function getDebugContext(gl, props) {
+function getDebugContext(gl2, props) {
   if (!globalThis.WebGLDebugUtils) {
     import_api17.log.warn("webgl-debug not loaded")();
-    return gl;
+    return gl2;
   }
-  const data = getContextData2(gl);
+  const data = getContextData2(gl2);
   if (data.debugContext) {
     return data.debugContext;
   }
-  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants14.default), gl));
+  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants14.GL), gl2));
   const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(
-    gl,
+    gl2,
     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 {
   }
-  Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl));
+  Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl2));
   Object.setPrototypeOf(WebGLDebugContext, glDebug);
   const debugContext = Object.create(WebGLDebugContext);
-  data.realContext = gl;
+  data.realContext = gl2;
   data.debugContext = debugContext;
   debugContext.debug = true;
   return debugContext;
@@ -4080,13 +4071,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 +4134,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 +4148,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 +4184,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 +4247,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 +4285,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 +4319,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 +4373,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);
@@ -4401,13 +4392,13 @@ var ClassicBuffer = class extends WEBGLBuffer {
    */
   copyData(options) {
     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);
+    const { gl: gl2, gl2: gl22 } = this;
+    assertWebGL2Context(gl2);
+    gl2.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, sourceBuffer.handle);
+    gl2.bindBuffer(import_constants17.GL.COPY_WRITE_BUFFER, this.handle);
+    gl22 == null ? void 0 : gl22.copyBufferSubData(import_constants17.GL.COPY_READ_BUFFER, import_constants17.GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+    gl2.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, null);
+    gl2.bindBuffer(import_constants17.GL.COPY_WRITE_BUFFER, null);
     this.debugData = null;
     return this;
   }
@@ -4420,7 +4411,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 +4430,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 +4452,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 +4467,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 +4528,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 +4558,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 +4624,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);
@@ -4661,12 +4652,12 @@ var WEBGLShader = class extends import_api20.Shader {
     const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 100
 ${source2}`;
     source = addGLSLVersion(source);
-    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 { gl: gl2 } = this.device;
+    gl2.shaderSource(this.handle, source);
+    gl2.compileShader(this.handle);
+    const compileStatus = gl2.getShaderParameter(this.handle, import_constants18.GL.COMPILE_STATUS);
     if (!compileStatus) {
-      const shaderLog = gl.getShaderInfoLog(this.handle);
+      const shaderLog = gl2.getShaderInfoLog(this.handle);
       const parsedLog = shaderLog ? parseShaderCompilerLog(shaderLog) : [];
       const messages = parsedLog.filter((message2) => message2.type === "error");
       const formattedLog = (0, import_api20.formatCompilerLog)(messages, source);
@@ -4804,10 +4795,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 +4876,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 +4894,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));
@@ -4915,9 +4906,9 @@ function getDataFormat(type) {
 }
 
 // src/adapter/helpers/get-shader-layout.ts
-function getShaderLayout(gl, program) {
+function getShaderLayout(gl2, program) {
   var _a, _b;
-  const programBindings = getProgramBindings(gl, program);
+  const programBindings = getProgramBindings(gl2, program);
   const shaderLayout = {
     attributes: [],
     bindings: []
@@ -4926,7 +4917,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,
@@ -4976,26 +4967,26 @@ function getShaderLayout(gl, program) {
   }
   return shaderLayout;
 }
-function getProgramBindings(gl, program) {
+function getProgramBindings(gl2, program) {
   const config = {
-    attributes: readAttributeBindings(gl, program),
-    uniforms: readUniformBindings(gl, program),
-    uniformBlocks: readUniformBlocks(gl, program),
-    varyings: readVaryings(gl, program)
+    attributes: readAttributeBindings(gl2, program),
+    uniforms: readUniformBindings(gl2, program),
+    uniformBlocks: readUniformBlocks(gl2, program),
+    varyings: readVaryings(gl2, program)
   };
   Object.seal(config);
   return config;
 }
-function readAttributeBindings(gl, program) {
+function readAttributeBindings(gl2, program) {
   const attributes = [];
-  const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+  const count = gl2.getProgramParameter(program, gl2.ACTIVE_ATTRIBUTES);
   for (let index = 0; index < count; index++) {
-    const activeInfo = gl.getActiveAttrib(program, index);
+    const activeInfo = gl2.getActiveAttrib(program, index);
     if (!activeInfo) {
       throw new Error("activeInfo");
     }
     const { name, type: compositeType, size } = activeInfo;
-    const location = gl.getAttribLocation(program, name);
+    const location = gl2.getAttribLocation(program, name);
     if (location >= 0) {
       const { glType, components } = decodeAttributeType(compositeType);
       const accessor = { type: glType, size: size * components };
@@ -5009,15 +5000,15 @@ function readAttributeBindings(gl, program) {
   attributes.sort((a, b) => a.location - b.location);
   return attributes;
 }
-function readVaryings(gl, program) {
-  if (!isWebGL2(gl)) {
+function readVaryings(gl2, program) {
+  if (!isWebGL2(gl2)) {
     return [];
   }
-  const gl2 = gl;
+  const gl22 = gl2;
   const varyings = [];
-  const count = gl.getProgramParameter(program, import_constants22.default.TRANSFORM_FEEDBACK_VARYINGS);
+  const count = gl2.getProgramParameter(program, import_constants22.GL.TRANSFORM_FEEDBACK_VARYINGS);
   for (let location = 0; location < count; location++) {
-    const activeInfo = gl2.getTransformFeedbackVarying(program, location);
+    const activeInfo = gl22.getTransformFeedbackVarying(program, location);
     if (!activeInfo) {
       throw new Error("activeInfo");
     }
@@ -5030,17 +5021,17 @@ function readVaryings(gl, program) {
   varyings.sort((a, b) => a.location - b.location);
   return varyings;
 }
-function readUniformBindings(gl, program) {
+function readUniformBindings(gl2, program) {
   const uniforms = [];
-  const uniformCount = gl.getProgramParameter(program, import_constants22.default.ACTIVE_UNIFORMS);
+  const uniformCount = gl2.getProgramParameter(program, import_constants22.GL.ACTIVE_UNIFORMS);
   for (let i = 0; i < uniformCount; i++) {
-    const activeInfo = gl.getActiveUniform(program, i);
+    const activeInfo = gl2.getActiveUniform(program, i);
     if (!activeInfo) {
       throw new Error("activeInfo");
     }
     const { name: rawName, size, type } = activeInfo;
     const { name, isArray: isArray2 } = parseUniformName(rawName);
-    let webglLocation = gl.getUniformLocation(program, name);
+    let webglLocation = gl2.getUniformLocation(program, name);
     const uniformInfo = {
       // WebGL locations are uniquely typed but just numbers
       location: webglLocation,
@@ -5053,7 +5044,7 @@ function readUniformBindings(gl, program) {
     if (uniformInfo.size > 1) {
       for (let j = 0; j < uniformInfo.size; j++) {
         const elementName = `${name}[${j}]`;
-        webglLocation = gl.getUniformLocation(program, elementName);
+        webglLocation = gl2.getUniformLocation(program, elementName);
         const arrayElementUniformInfo = __spreadProps(__spreadValues({}, uniformInfo), {
           name: elementName,
           location: webglLocation
@@ -5064,31 +5055,31 @@ function readUniformBindings(gl, program) {
   }
   return uniforms;
 }
-function readUniformBlocks(gl, program) {
-  if (!isWebGL2(gl)) {
+function readUniformBlocks(gl2, program) {
+  if (!isWebGL2(gl2)) {
     return [];
   }
-  const gl2 = gl;
-  const getBlockParameter = (blockIndex, pname) => gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
+  const gl22 = gl2;
+  const getBlockParameter = (blockIndex, pname) => gl22.getActiveUniformBlockParameter(program, blockIndex, pname);
   const uniformBlocks = [];
-  const blockCount = gl2.getProgramParameter(program, import_constants22.default.ACTIVE_UNIFORM_BLOCKS);
+  const blockCount = gl22.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),
+      name: gl22.getActiveUniformBlockName(program, blockIndex) || "",
+      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 = gl22.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_TYPE);
+    const uniformArrayLength = gl22.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_SIZE);
+    const uniformOffset = gl22.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_OFFSET);
+    const uniformStride = gl22.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_ARRAY_STRIDE);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
-      const activeInfo = gl2.getActiveUniform(program, uniformIndices[i]);
+      const activeInfo = gl22.getActiveUniform(program, uniformIndices[i]);
       if (!activeInfo) {
         throw new Error("activeInfo");
       }
@@ -5109,21 +5100,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,27 +5145,27 @@ function parseUniformName(name) {
 }
 
 // src/adapter/helpers/set-uniform.ts
-var import_constants23 = __toESM(require("@luma.gl/constants"), 1);
-function setUniform(gl, location, type, value) {
-  const gl2 = gl;
+var import_constants23 = require("@luma.gl/constants");
+function setUniform(gl2, location, type, value) {
+  const gl22 = gl2;
   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:
-        return gl.uniform1i(location, value);
+      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 gl2.uniform1i(location, value);
     }
   }
   if (value === true) {
@@ -5185,63 +5176,63 @@ function setUniform(gl, location, type, value) {
   }
   const arrayValue = typeof value === "number" ? [value] : value;
   switch (type) {
-    case import_constants23.default.FLOAT:
-      return gl.uniform1fv(location, arrayValue);
-    case import_constants23.default.FLOAT_VEC2:
-      return gl.uniform2fv(location, arrayValue);
-    case import_constants23.default.FLOAT_VEC3:
-      return gl.uniform3fv(location, arrayValue);
-    case import_constants23.default.FLOAT_VEC4:
-      return gl.uniform4fv(location, arrayValue);
-    case import_constants23.default.INT:
-      return gl.uniform1iv(location, arrayValue);
-    case import_constants23.default.INT_VEC2:
-      return gl.uniform2iv(location, arrayValue);
-    case import_constants23.default.INT_VEC3:
-      return gl.uniform3iv(location, arrayValue);
-    case import_constants23.default.INT_VEC4:
-      return gl.uniform4iv(location, arrayValue);
-    case import_constants23.default.BOOL:
-      return gl.uniform1iv(location, arrayValue);
-    case import_constants23.default.BOOL_VEC2:
-      return gl.uniform2iv(location, arrayValue);
-    case import_constants23.default.BOOL_VEC3:
-      return gl.uniform3iv(location, arrayValue);
-    case import_constants23.default.BOOL_VEC4:
-      return gl.uniform4iv(location, arrayValue);
-    case import_constants23.default.UNSIGNED_INT:
-      return gl2.uniform1uiv(location, arrayValue, 1);
-    case import_constants23.default.UNSIGNED_INT_VEC2:
-      return gl2.uniform2uiv(location, arrayValue, 2);
-    case import_constants23.default.UNSIGNED_INT_VEC3:
-      return gl2.uniform3uiv(location, arrayValue, 3);
-    case import_constants23.default.UNSIGNED_INT_VEC4:
-      return gl2.uniform4uiv(location, arrayValue, 4);
-    case import_constants23.default.FLOAT_MAT2:
-      return gl.uniformMatrix2fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT3:
-      return gl.uniformMatrix3fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT4:
-      return gl.uniformMatrix4fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT2x3:
-      return gl2.uniformMatrix2x3fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT2x4:
-      return gl2.uniformMatrix2x4fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT3x2:
-      return gl2.uniformMatrix3x2fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT3x4:
-      return gl2.uniformMatrix3x4fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT4x2:
-      return gl2.uniformMatrix4x2fv(location, false, arrayValue);
-    case import_constants23.default.FLOAT_MAT4x3:
-      return gl2.uniformMatrix4x3fv(location, false, arrayValue);
+    case import_constants23.GL.FLOAT:
+      return gl2.uniform1fv(location, arrayValue);
+    case import_constants23.GL.FLOAT_VEC2:
+      return gl2.uniform2fv(location, arrayValue);
+    case import_constants23.GL.FLOAT_VEC3:
+      return gl2.uniform3fv(location, arrayValue);
+    case import_constants23.GL.FLOAT_VEC4:
+      return gl2.uniform4fv(location, arrayValue);
+    case import_constants23.GL.INT:
+      return gl2.uniform1iv(location, arrayValue);
+    case import_constants23.GL.INT_VEC2:
+      return gl2.uniform2iv(location, arrayValue);
+    case import_constants23.GL.INT_VEC3:
+      return gl2.uniform3iv(location, arrayValue);
+    case import_constants23.GL.INT_VEC4:
+      return gl2.uniform4iv(location, arrayValue);
+    case import_constants23.GL.BOOL:
+      return gl2.uniform1iv(location, arrayValue);
+    case import_constants23.GL.BOOL_VEC2:
+      return gl2.uniform2iv(location, arrayValue);
+    case import_constants23.GL.BOOL_VEC3:
+      return gl2.uniform3iv(location, arrayValue);
+    case import_constants23.GL.BOOL_VEC4:
+      return gl2.uniform4iv(location, arrayValue);
+    case import_constants23.GL.UNSIGNED_INT:
+      return gl22.uniform1uiv(location, arrayValue, 1);
+    case import_constants23.GL.UNSIGNED_INT_VEC2:
+      return gl22.uniform2uiv(location, arrayValue, 2);
+    case import_constants23.GL.UNSIGNED_INT_VEC3:
+      return gl22.uniform3uiv(location, arrayValue, 3);
+    case import_constants23.GL.UNSIGNED_INT_VEC4:
+      return gl22.uniform4uiv(location, arrayValue, 4);
+    case import_constants23.GL.FLOAT_MAT2:
+      return gl2.uniformMatrix2fv(location, false, arrayValue);
+    case import_constants23.GL.FLOAT_MAT3:
+      return gl2.uniformMatrix3fv(location, false, arrayValue);
+    case import_constants23.GL.FLOAT_MAT4:
+      return gl2.uniformMatrix4fv(location, false, arrayValue);
+    case import_constants23.GL.FLOAT_MAT2x3:
+      return gl22.uniformMatrix2x3fv(location, false, arrayValue);
+    case import_constants23.GL.FLOAT_MAT2x4:
+      return gl22.uniformMatrix2x4fv(location, false, arrayValue);
+    case import_constants23.GL.FLOAT_MAT3x2:
+      return gl22.uniformMatrix3x2fv(location, false, arrayValue);
+    case import_constants23.GL.FLOAT_MAT3x4:
+      return gl22.uniformMatrix3x4fv(location, false, arrayValue);
+    case import_constants23.GL.FLOAT_MAT4x2:
+      return gl22.uniformMatrix4x2fv(location, false, arrayValue);
+    case import_constants23.GL.FLOAT_MAT4x3:
+      return gl22.uniformMatrix4x3fv(location, false, arrayValue);
   }
   throw new Error("Illegal uniform");
 }
 
 // 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,30 +5255,30 @@ 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;
-    const { gl, gl2 } = this;
+    const { gl: gl2, gl2: gl22 } = this;
     location = Number(location);
     this.bind(() => {
-      gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);
+      gl2.bindBuffer(gl2.ARRAY_BUFFER, buffer.handle);
       if (integer) {
         this.device.assertWebGL2();
-        gl2.vertexAttribIPointer(location, size, type, stride, offset);
+        gl22.vertexAttribIPointer(location, size, type, stride, offset);
       } else {
-        gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+        gl2.vertexAttribPointer(location, size, type, normalized, stride, offset);
       }
-      gl.enableVertexAttribArray(location);
-      gl2.vertexAttribDivisor(location, divisor || 0);
+      gl2.enableVertexAttribArray(location);
+      gl22.vertexAttribDivisor(location, divisor || 0);
     });
     return this;
   }
@@ -5331,7 +5322,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 +5419,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;
@@ -5473,21 +5464,21 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
   // setAttributes(attributes: Record<string, Buffer>): void {}
   // setBindings(bindings: Record<string, Binding>): void {}
   _compileAndLink() {
-    const { gl } = this.device;
-    gl.attachShader(this.handle, this.vs.handle);
-    gl.attachShader(this.handle, this.fs.handle);
+    const { gl: gl2 } = this.device;
+    gl2.attachShader(this.handle, this.vs.handle);
+    gl2.attachShader(this.handle, this.fs.handle);
     import_api23.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    gl.linkProgram(this.handle);
+    gl2.linkProgram(this.handle);
     import_api23.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    if (gl.debug || import_api23.log.level > 0) {
-      const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
+    if (gl2.debug || import_api23.log.level > 0) {
+      const linked = gl2.getProgramParameter(this.handle, gl2.LINK_STATUS);
       if (!linked) {
-        throw new Error(`Error linking: ${gl.getProgramInfoLog(this.handle)}`);
+        throw new Error(`Error linking: ${gl2.getProgramInfoLog(this.handle)}`);
       }
-      gl.validateProgram(this.handle);
-      const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
+      gl2.validateProgram(this.handle);
+      const validated = gl2.getProgramParameter(this.handle, gl2.VALIDATE_STATUS);
       if (!validated) {
-        throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);
+        throw new Error(`Error validating: ${gl2.getProgramInfoLog(this.handle)}`);
       }
     }
   }
@@ -5528,15 +5519,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 +5541,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 +5567,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 +5587,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 +5613,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 +5648,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 +5709,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 +5723,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 +5755,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 +5788,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();
   }
@@ -5893,13 +5884,13 @@ var _WebGLDevice = class extends import_api26.Device {
         message: "Computer entered sleep mode, or too many apps or browser tabs are using the GPU."
       });
     };
-    let gl = props.gl || null;
-    gl = gl || ((0, import_env2.isBrowser)() ? createBrowserContext(this.canvasContext.canvas, __spreadProps(__spreadValues({}, props), { onContextLost })) : null);
-    gl = gl || (!(0, import_env2.isBrowser)() ? createHeadlessContext(__spreadProps(__spreadValues({}, props), { onContextLost })) : null);
-    if (!gl) {
+    let gl2 = props.gl || null;
+    gl2 = gl2 || ((0, import_env2.isBrowser)() ? createBrowserContext(this.canvasContext.canvas, __spreadProps(__spreadValues({}, props), { onContextLost })) : null);
+    gl2 = gl2 || (!(0, import_env2.isBrowser)() ? createHeadlessContext(__spreadProps(__spreadValues({}, props), { onContextLost })) : null);
+    if (!gl2) {
       throw new Error("WebGL context creation failed");
     }
-    this.handle = gl;
+    this.handle = gl2;
     this.gl = this.handle;
     this.gl2 = this.gl;
     this.isWebGL2 = isWebGL22(this.gl);
@@ -5949,17 +5940,17 @@ var _WebGLDevice = class extends import_api26.Device {
    * @param gl
    * @returns
    */
-  static attach(gl) {
-    if (gl instanceof _WebGLDevice) {
-      return gl;
+  static attach(gl2) {
+    if (gl2 instanceof _WebGLDevice) {
+      return gl2;
     }
-    if ((gl == null ? void 0 : gl.device) instanceof import_api26.Device) {
-      return gl.device;
+    if ((gl2 == null ? void 0 : gl2.device) instanceof import_api26.Device) {
+      return gl2.device;
     }
-    if (!isWebGL3(gl)) {
+    if (!isWebGL3(gl2)) {
       throw new Error("Invalid WebGLRenderingContext");
     }
-    return new _WebGLDevice({ gl });
+    return new _WebGLDevice({ gl: gl2 });
   }
   static create() {
     return __async(this, arguments, function* (props = {}) {
@@ -6019,7 +6010,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);
@@ -6110,11 +6101,11 @@ var _WebGLDevice = class extends import_api26.Device {
    * Be aware that there are some duplicates especially for constants that are 0,
    * so this isn't guaranteed to return the right key in all cases.
    */
-  getGLKey(value, gl) {
-    gl = gl || this.gl2 || this.gl;
+  getGLKey(value, gl2) {
+    gl2 = gl2 || this.gl2 || this.gl;
     const number = Number(value);
-    for (const key in gl) {
-      if (gl[key] === number) {
+    for (const key in gl2) {
+      if (gl2[key] === number) {
         return `GL.${key}`;
       }
     }
@@ -6126,20 +6117,20 @@ var WebGLDevice = _WebGLDevice;
 // Public `Device` API
 //
 WebGLDevice.type = "webgl";
-function isWebGL3(gl) {
-  if (typeof WebGLRenderingContext !== "undefined" && gl instanceof WebGLRenderingContext) {
+function isWebGL3(gl2) {
+  if (typeof WebGLRenderingContext !== "undefined" && gl2 instanceof WebGLRenderingContext) {
     return true;
   }
-  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
     return true;
   }
-  return Boolean(gl && Number.isFinite(gl._version));
+  return Boolean(gl2 && Number.isFinite(gl2._version));
 }
-function isWebGL22(gl) {
-  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+function isWebGL22(gl2) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
     return true;
   }
-  return Boolean(gl && gl._version === 2);
+  return Boolean(gl2 && gl2._version === 2);
 }
 
 // src/classic/clear.ts
@@ -6148,8 +6139,8 @@ var GL_DEPTH_BUFFER_BIT2 = 256;
 var GL_STENCIL_BUFFER_BIT2 = 1024;
 var GL_COLOR_BUFFER_BIT2 = 16384;
 var ERR_ARGUMENTS = "clear: bad arguments";
-function clear(gl, options) {
-  const device = WebGLDevice.attach(gl);
+function clear(gl2, options) {
+  const device = WebGLDevice.attach(gl2);
   const { framebuffer = null, color = null, depth = null, stencil = null } = options || {};
   const parameters = {};
   if (framebuffer) {
@@ -6182,25 +6173,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 +6200,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 +6216,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
@@ -6237,26 +6228,26 @@ function readPixelsToArray(source, options) {
   } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
   (0, import_api29.assert)(framebuffer);
-  const { gl, handle } = framebuffer;
+  const { gl: gl2, 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);
-  gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-  gl.bindFramebuffer(import_constants28.default.FRAMEBUFFER, prevHandle2 || null);
+  const prevHandle2 = gl2.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
+  gl2.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+  gl2.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 +6255,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,12 +6274,104 @@ 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();
   }
   return target;
 }
+function copyToTexture(source, target, options) {
+  const {
+    sourceX = 0,
+    sourceY = 0,
+    // attachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer
+    targetMipmaplevel = 0,
+    targetInternalFormat = import_constants28.GL.RGBA
+  } = options || {};
+  let {
+    targetX,
+    targetY,
+    targetZ,
+    width,
+    // defaults to target width
+    height
+    // defaults to target height
+  } = options || {};
+  const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
+  (0, import_api29.assert)(framebuffer);
+  const webglFramebuffer = framebuffer;
+  const { device, handle } = webglFramebuffer;
+  const isSubCopy = typeof targetX !== "undefined" || typeof targetY !== "undefined" || typeof targetZ !== "undefined";
+  targetX = targetX || 0;
+  targetY = targetY || 0;
+  targetZ = targetZ || 0;
+  const prevHandle2 = device.gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
+  (0, import_api29.assert)(target);
+  let texture = null;
+  let textureTarget;
+  if (target instanceof import_api29.Texture) {
+    texture = target;
+    width = Number.isFinite(width) ? width : texture.width;
+    height = Number.isFinite(height) ? height : texture.height;
+    texture.bind(0);
+    textureTarget = texture.target;
+  } else {
+    textureTarget = target;
+  }
+  if (!isSubCopy) {
+    device.gl.copyTexImage2D(
+      textureTarget,
+      targetMipmaplevel,
+      targetInternalFormat,
+      sourceX,
+      sourceY,
+      width,
+      height,
+      0
+      /* border must be 0 */
+    );
+  } else {
+    switch (textureTarget) {
+      case import_constants28.GL.TEXTURE_2D:
+      case import_constants28.GL.TEXTURE_CUBE_MAP:
+        device.gl.copyTexSubImage2D(
+          textureTarget,
+          targetMipmaplevel,
+          targetX,
+          targetY,
+          sourceX,
+          sourceY,
+          width,
+          height
+        );
+        break;
+      case import_constants28.GL.TEXTURE_2D_ARRAY:
+      case import_constants28.GL.TEXTURE_3D:
+        device.assertWebGL2();
+        device.gl2.copyTexSubImage3D(
+          textureTarget,
+          targetMipmaplevel,
+          targetX,
+          targetY,
+          targetZ,
+          sourceX,
+          sourceY,
+          width,
+          height
+        );
+        break;
+      default:
+    }
+  }
+  if (texture) {
+    texture.unbind();
+  }
+  gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle2 || null);
+  if (deleteFramebuffer) {
+    framebuffer.destroy();
+  }
+  return texture;
+}
 function getFramebuffer2(source) {
   if (!(source instanceof import_api29.Framebuffer)) {
     return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
@@ -6313,7 +6396,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);