@deck.gl/extensions 8.9.1 → 8.9.3

package/dist/dist.dev.js

@@ -13,14 +13,7 @@ var __exports__ = (() => {
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-  }) : x)(function(x) {
-    if (typeof require !== "undefined")
-      return require.apply(this, arguments);
-    throw new Error('Dynamic require of "' + x + '" is not supported');
-  });
-  var __commonJS = (cb, mod) => function __require2() {
+  var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
@@ -49,28 +42,14 @@ var __exports__ = (() => {
   // external-global-plugin:@deck.gl/core
   var require_core = __commonJS({
     "external-global-plugin:@deck.gl/core"(exports, module) {
-      module.exports = typeof __require === "function" ? require_core() : null;
+      module.exports = globalThis.deck;
     }
   });
 
   // external-global-plugin:@luma.gl/core
   var require_core2 = __commonJS({
     "external-global-plugin:@luma.gl/core"(exports, module) {
-      module.exports = typeof __require === "function" ? require_core2() : null;
-    }
-  });
-
-  // external-global-plugin:@luma.gl/constants
-  var require_constants = __commonJS({
-    "external-global-plugin:@luma.gl/constants"(exports, module) {
-      module.exports = typeof __require === "function" ? require_constants() : null;
-    }
-  });
-
-  // external-global-plugin:@math.gl/core
-  var require_core3 = __commonJS({
-    "external-global-plugin:@math.gl/core"(exports, module) {
-      module.exports = typeof __require === "function" ? require_core3() : null;
+      module.exports = globalThis.luma;
     }
   });
 
@@ -426,7 +405,626 @@ varying float dataFilter_value;
 
   // src/data-filter/aggregator.ts
   var import_core4 = __toESM(require_core2());
-  var import_constants = __toESM(require_constants());
+
+  // ../../node_modules/@luma.gl/constants/dist/esm/index.js
+  var esm_default = {
+    DEPTH_BUFFER_BIT: 256,
+    STENCIL_BUFFER_BIT: 1024,
+    COLOR_BUFFER_BIT: 16384,
+    POINTS: 0,
+    LINES: 1,
+    LINE_LOOP: 2,
+    LINE_STRIP: 3,
+    TRIANGLES: 4,
+    TRIANGLE_STRIP: 5,
+    TRIANGLE_FAN: 6,
+    ZERO: 0,
+    ONE: 1,
+    SRC_COLOR: 768,
+    ONE_MINUS_SRC_COLOR: 769,
+    SRC_ALPHA: 770,
+    ONE_MINUS_SRC_ALPHA: 771,
+    DST_ALPHA: 772,
+    ONE_MINUS_DST_ALPHA: 773,
+    DST_COLOR: 774,
+    ONE_MINUS_DST_COLOR: 775,
+    SRC_ALPHA_SATURATE: 776,
+    CONSTANT_COLOR: 32769,
+    ONE_MINUS_CONSTANT_COLOR: 32770,
+    CONSTANT_ALPHA: 32771,
+    ONE_MINUS_CONSTANT_ALPHA: 32772,
+    FUNC_ADD: 32774,
+    FUNC_SUBTRACT: 32778,
+    FUNC_REVERSE_SUBTRACT: 32779,
+    BLEND_EQUATION: 32777,
+    BLEND_EQUATION_RGB: 32777,
+    BLEND_EQUATION_ALPHA: 34877,
+    BLEND_DST_RGB: 32968,
+    BLEND_SRC_RGB: 32969,
+    BLEND_DST_ALPHA: 32970,
+    BLEND_SRC_ALPHA: 32971,
+    BLEND_COLOR: 32773,
+    ARRAY_BUFFER_BINDING: 34964,
+    ELEMENT_ARRAY_BUFFER_BINDING: 34965,
+    LINE_WIDTH: 2849,
+    ALIASED_POINT_SIZE_RANGE: 33901,
+    ALIASED_LINE_WIDTH_RANGE: 33902,
+    CULL_FACE_MODE: 2885,
+    FRONT_FACE: 2886,
+    DEPTH_RANGE: 2928,
+    DEPTH_WRITEMASK: 2930,
+    DEPTH_CLEAR_VALUE: 2931,
+    DEPTH_FUNC: 2932,
+    STENCIL_CLEAR_VALUE: 2961,
+    STENCIL_FUNC: 2962,
+    STENCIL_FAIL: 2964,
+    STENCIL_PASS_DEPTH_FAIL: 2965,
+    STENCIL_PASS_DEPTH_PASS: 2966,
+    STENCIL_REF: 2967,
+    STENCIL_VALUE_MASK: 2963,
+    STENCIL_WRITEMASK: 2968,
+    STENCIL_BACK_FUNC: 34816,
+    STENCIL_BACK_FAIL: 34817,
+    STENCIL_BACK_PASS_DEPTH_FAIL: 34818,
+    STENCIL_BACK_PASS_DEPTH_PASS: 34819,
+    STENCIL_BACK_REF: 36003,
+    STENCIL_BACK_VALUE_MASK: 36004,
+    STENCIL_BACK_WRITEMASK: 36005,
+    VIEWPORT: 2978,
+    SCISSOR_BOX: 3088,
+    COLOR_CLEAR_VALUE: 3106,
+    COLOR_WRITEMASK: 3107,
+    UNPACK_ALIGNMENT: 3317,
+    PACK_ALIGNMENT: 3333,
+    MAX_TEXTURE_SIZE: 3379,
+    MAX_VIEWPORT_DIMS: 3386,
+    SUBPIXEL_BITS: 3408,
+    RED_BITS: 3410,
+    GREEN_BITS: 3411,
+    BLUE_BITS: 3412,
+    ALPHA_BITS: 3413,
+    DEPTH_BITS: 3414,
+    STENCIL_BITS: 3415,
+    POLYGON_OFFSET_UNITS: 10752,
+    POLYGON_OFFSET_FACTOR: 32824,
+    TEXTURE_BINDING_2D: 32873,
+    SAMPLE_BUFFERS: 32936,
+    SAMPLES: 32937,
+    SAMPLE_COVERAGE_VALUE: 32938,
+    SAMPLE_COVERAGE_INVERT: 32939,
+    COMPRESSED_TEXTURE_FORMATS: 34467,
+    VENDOR: 7936,
+    RENDERER: 7937,
+    VERSION: 7938,
+    IMPLEMENTATION_COLOR_READ_TYPE: 35738,
+    IMPLEMENTATION_COLOR_READ_FORMAT: 35739,
+    BROWSER_DEFAULT_WEBGL: 37444,
+    STATIC_DRAW: 35044,
+    STREAM_DRAW: 35040,
+    DYNAMIC_DRAW: 35048,
+    ARRAY_BUFFER: 34962,
+    ELEMENT_ARRAY_BUFFER: 34963,
+    BUFFER_SIZE: 34660,
+    BUFFER_USAGE: 34661,
+    CURRENT_VERTEX_ATTRIB: 34342,
+    VERTEX_ATTRIB_ARRAY_ENABLED: 34338,
+    VERTEX_ATTRIB_ARRAY_SIZE: 34339,
+    VERTEX_ATTRIB_ARRAY_STRIDE: 34340,
+    VERTEX_ATTRIB_ARRAY_TYPE: 34341,
+    VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922,
+    VERTEX_ATTRIB_ARRAY_POINTER: 34373,
+    VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975,
+    CULL_FACE: 2884,
+    FRONT: 1028,
+    BACK: 1029,
+    FRONT_AND_BACK: 1032,
+    BLEND: 3042,
+    DEPTH_TEST: 2929,
+    DITHER: 3024,
+    POLYGON_OFFSET_FILL: 32823,
+    SAMPLE_ALPHA_TO_COVERAGE: 32926,
+    SAMPLE_COVERAGE: 32928,
+    SCISSOR_TEST: 3089,
+    STENCIL_TEST: 2960,
+    NO_ERROR: 0,
+    INVALID_ENUM: 1280,
+    INVALID_VALUE: 1281,
+    INVALID_OPERATION: 1282,
+    OUT_OF_MEMORY: 1285,
+    CONTEXT_LOST_WEBGL: 37442,
+    CW: 2304,
+    CCW: 2305,
+    DONT_CARE: 4352,
+    FASTEST: 4353,
+    NICEST: 4354,
+    GENERATE_MIPMAP_HINT: 33170,
+    BYTE: 5120,
+    UNSIGNED_BYTE: 5121,
+    SHORT: 5122,
+    UNSIGNED_SHORT: 5123,
+    INT: 5124,
+    UNSIGNED_INT: 5125,
+    FLOAT: 5126,
+    DOUBLE: 5130,
+    DEPTH_COMPONENT: 6402,
+    ALPHA: 6406,
+    RGB: 6407,
+    RGBA: 6408,
+    LUMINANCE: 6409,
+    LUMINANCE_ALPHA: 6410,
+    UNSIGNED_SHORT_4_4_4_4: 32819,
+    UNSIGNED_SHORT_5_5_5_1: 32820,
+    UNSIGNED_SHORT_5_6_5: 33635,
+    FRAGMENT_SHADER: 35632,
+    VERTEX_SHADER: 35633,
+    COMPILE_STATUS: 35713,
+    DELETE_STATUS: 35712,
+    LINK_STATUS: 35714,
+    VALIDATE_STATUS: 35715,
+    ATTACHED_SHADERS: 35717,
+    ACTIVE_ATTRIBUTES: 35721,
+    ACTIVE_UNIFORMS: 35718,
+    MAX_VERTEX_ATTRIBS: 34921,
+    MAX_VERTEX_UNIFORM_VECTORS: 36347,
+    MAX_VARYING_VECTORS: 36348,
+    MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661,
+    MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660,
+    MAX_TEXTURE_IMAGE_UNITS: 34930,
+    MAX_FRAGMENT_UNIFORM_VECTORS: 36349,
+    SHADER_TYPE: 35663,
+    SHADING_LANGUAGE_VERSION: 35724,
+    CURRENT_PROGRAM: 35725,
+    NEVER: 512,
+    ALWAYS: 519,
+    LESS: 513,
+    EQUAL: 514,
+    LEQUAL: 515,
+    GREATER: 516,
+    GEQUAL: 518,
+    NOTEQUAL: 517,
+    KEEP: 7680,
+    REPLACE: 7681,
+    INCR: 7682,
+    DECR: 7683,
+    INVERT: 5386,
+    INCR_WRAP: 34055,
+    DECR_WRAP: 34056,
+    NEAREST: 9728,
+    LINEAR: 9729,
+    NEAREST_MIPMAP_NEAREST: 9984,
+    LINEAR_MIPMAP_NEAREST: 9985,
+    NEAREST_MIPMAP_LINEAR: 9986,
+    LINEAR_MIPMAP_LINEAR: 9987,
+    TEXTURE_MAG_FILTER: 10240,
+    TEXTURE_MIN_FILTER: 10241,
+    TEXTURE_WRAP_S: 10242,
+    TEXTURE_WRAP_T: 10243,
+    TEXTURE_2D: 3553,
+    TEXTURE: 5890,
+    TEXTURE_CUBE_MAP: 34067,
+    TEXTURE_BINDING_CUBE_MAP: 34068,
+    TEXTURE_CUBE_MAP_POSITIVE_X: 34069,
+    TEXTURE_CUBE_MAP_NEGATIVE_X: 34070,
+    TEXTURE_CUBE_MAP_POSITIVE_Y: 34071,
+    TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072,
+    TEXTURE_CUBE_MAP_POSITIVE_Z: 34073,
+    TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074,
+    MAX_CUBE_MAP_TEXTURE_SIZE: 34076,
+    TEXTURE0: 33984,
+    ACTIVE_TEXTURE: 34016,
+    REPEAT: 10497,
+    CLAMP_TO_EDGE: 33071,
+    MIRRORED_REPEAT: 33648,
+    TEXTURE_WIDTH: 4096,
+    TEXTURE_HEIGHT: 4097,
+    FLOAT_VEC2: 35664,
+    FLOAT_VEC3: 35665,
+    FLOAT_VEC4: 35666,
+    INT_VEC2: 35667,
+    INT_VEC3: 35668,
+    INT_VEC4: 35669,
+    BOOL: 35670,
+    BOOL_VEC2: 35671,
+    BOOL_VEC3: 35672,
+    BOOL_VEC4: 35673,
+    FLOAT_MAT2: 35674,
+    FLOAT_MAT3: 35675,
+    FLOAT_MAT4: 35676,
+    SAMPLER_2D: 35678,
+    SAMPLER_CUBE: 35680,
+    LOW_FLOAT: 36336,
+    MEDIUM_FLOAT: 36337,
+    HIGH_FLOAT: 36338,
+    LOW_INT: 36339,
+    MEDIUM_INT: 36340,
+    HIGH_INT: 36341,
+    FRAMEBUFFER: 36160,
+    RENDERBUFFER: 36161,
+    RGBA4: 32854,
+    RGB5_A1: 32855,
+    RGB565: 36194,
+    DEPTH_COMPONENT16: 33189,
+    STENCIL_INDEX: 6401,
+    STENCIL_INDEX8: 36168,
+    DEPTH_STENCIL: 34041,
+    RENDERBUFFER_WIDTH: 36162,
+    RENDERBUFFER_HEIGHT: 36163,
+    RENDERBUFFER_INTERNAL_FORMAT: 36164,
+    RENDERBUFFER_RED_SIZE: 36176,
+    RENDERBUFFER_GREEN_SIZE: 36177,
+    RENDERBUFFER_BLUE_SIZE: 36178,
+    RENDERBUFFER_ALPHA_SIZE: 36179,
+    RENDERBUFFER_DEPTH_SIZE: 36180,
+    RENDERBUFFER_STENCIL_SIZE: 36181,
+    FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048,
+    FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049,
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050,
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051,
+    COLOR_ATTACHMENT0: 36064,
+    DEPTH_ATTACHMENT: 36096,
+    STENCIL_ATTACHMENT: 36128,
+    DEPTH_STENCIL_ATTACHMENT: 33306,
+    NONE: 0,
+    FRAMEBUFFER_COMPLETE: 36053,
+    FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054,
+    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055,
+    FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057,
+    FRAMEBUFFER_UNSUPPORTED: 36061,
+    FRAMEBUFFER_BINDING: 36006,
+    RENDERBUFFER_BINDING: 36007,
+    READ_FRAMEBUFFER: 36008,
+    DRAW_FRAMEBUFFER: 36009,
+    MAX_RENDERBUFFER_SIZE: 34024,
+    INVALID_FRAMEBUFFER_OPERATION: 1286,
+    UNPACK_FLIP_Y_WEBGL: 37440,
+    UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441,
+    UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443,
+    READ_BUFFER: 3074,
+    UNPACK_ROW_LENGTH: 3314,
+    UNPACK_SKIP_ROWS: 3315,
+    UNPACK_SKIP_PIXELS: 3316,
+    PACK_ROW_LENGTH: 3330,
+    PACK_SKIP_ROWS: 3331,
+    PACK_SKIP_PIXELS: 3332,
+    TEXTURE_BINDING_3D: 32874,
+    UNPACK_SKIP_IMAGES: 32877,
+    UNPACK_IMAGE_HEIGHT: 32878,
+    MAX_3D_TEXTURE_SIZE: 32883,
+    MAX_ELEMENTS_VERTICES: 33e3,
+    MAX_ELEMENTS_INDICES: 33001,
+    MAX_TEXTURE_LOD_BIAS: 34045,
+    MAX_FRAGMENT_UNIFORM_COMPONENTS: 35657,
+    MAX_VERTEX_UNIFORM_COMPONENTS: 35658,
+    MAX_ARRAY_TEXTURE_LAYERS: 35071,
+    MIN_PROGRAM_TEXEL_OFFSET: 35076,
+    MAX_PROGRAM_TEXEL_OFFSET: 35077,
+    MAX_VARYING_COMPONENTS: 35659,
+    FRAGMENT_SHADER_DERIVATIVE_HINT: 35723,
+    RASTERIZER_DISCARD: 35977,
+    VERTEX_ARRAY_BINDING: 34229,
+    MAX_VERTEX_OUTPUT_COMPONENTS: 37154,
+    MAX_FRAGMENT_INPUT_COMPONENTS: 37157,
+    MAX_SERVER_WAIT_TIMEOUT: 37137,
+    MAX_ELEMENT_INDEX: 36203,
+    RED: 6403,
+    RGB8: 32849,
+    RGBA8: 32856,
+    RGB10_A2: 32857,
+    TEXTURE_3D: 32879,
+    TEXTURE_WRAP_R: 32882,
+    TEXTURE_MIN_LOD: 33082,
+    TEXTURE_MAX_LOD: 33083,
+    TEXTURE_BASE_LEVEL: 33084,
+    TEXTURE_MAX_LEVEL: 33085,
+    TEXTURE_COMPARE_MODE: 34892,
+    TEXTURE_COMPARE_FUNC: 34893,
+    SRGB: 35904,
+    SRGB8: 35905,
+    SRGB8_ALPHA8: 35907,
+    COMPARE_REF_TO_TEXTURE: 34894,
+    RGBA32F: 34836,
+    RGB32F: 34837,
+    RGBA16F: 34842,
+    RGB16F: 34843,
+    TEXTURE_2D_ARRAY: 35866,
+    TEXTURE_BINDING_2D_ARRAY: 35869,
+    R11F_G11F_B10F: 35898,
+    RGB9_E5: 35901,
+    RGBA32UI: 36208,
+    RGB32UI: 36209,
+    RGBA16UI: 36214,
+    RGB16UI: 36215,
+    RGBA8UI: 36220,
+    RGB8UI: 36221,
+    RGBA32I: 36226,
+    RGB32I: 36227,
+    RGBA16I: 36232,
+    RGB16I: 36233,
+    RGBA8I: 36238,
+    RGB8I: 36239,
+    RED_INTEGER: 36244,
+    RGB_INTEGER: 36248,
+    RGBA_INTEGER: 36249,
+    R8: 33321,
+    RG8: 33323,
+    R16F: 33325,
+    R32F: 33326,
+    RG16F: 33327,
+    RG32F: 33328,
+    R8I: 33329,
+    R8UI: 33330,
+    R16I: 33331,
+    R16UI: 33332,
+    R32I: 33333,
+    R32UI: 33334,
+    RG8I: 33335,
+    RG8UI: 33336,
+    RG16I: 33337,
+    RG16UI: 33338,
+    RG32I: 33339,
+    RG32UI: 33340,
+    R8_SNORM: 36756,
+    RG8_SNORM: 36757,
+    RGB8_SNORM: 36758,
+    RGBA8_SNORM: 36759,
+    RGB10_A2UI: 36975,
+    TEXTURE_IMMUTABLE_FORMAT: 37167,
+    TEXTURE_IMMUTABLE_LEVELS: 33503,
+    UNSIGNED_INT_2_10_10_10_REV: 33640,
+    UNSIGNED_INT_10F_11F_11F_REV: 35899,
+    UNSIGNED_INT_5_9_9_9_REV: 35902,
+    FLOAT_32_UNSIGNED_INT_24_8_REV: 36269,
+    UNSIGNED_INT_24_8: 34042,
+    HALF_FLOAT: 5131,
+    RG: 33319,
+    RG_INTEGER: 33320,
+    INT_2_10_10_10_REV: 36255,
+    CURRENT_QUERY: 34917,
+    QUERY_RESULT: 34918,
+    QUERY_RESULT_AVAILABLE: 34919,
+    ANY_SAMPLES_PASSED: 35887,
+    ANY_SAMPLES_PASSED_CONSERVATIVE: 36202,
+    MAX_DRAW_BUFFERS: 34852,
+    DRAW_BUFFER0: 34853,
+    DRAW_BUFFER1: 34854,
+    DRAW_BUFFER2: 34855,
+    DRAW_BUFFER3: 34856,
+    DRAW_BUFFER4: 34857,
+    DRAW_BUFFER5: 34858,
+    DRAW_BUFFER6: 34859,
+    DRAW_BUFFER7: 34860,
+    DRAW_BUFFER8: 34861,
+    DRAW_BUFFER9: 34862,
+    DRAW_BUFFER10: 34863,
+    DRAW_BUFFER11: 34864,
+    DRAW_BUFFER12: 34865,
+    DRAW_BUFFER13: 34866,
+    DRAW_BUFFER14: 34867,
+    DRAW_BUFFER15: 34868,
+    MAX_COLOR_ATTACHMENTS: 36063,
+    COLOR_ATTACHMENT1: 36065,
+    COLOR_ATTACHMENT2: 36066,
+    COLOR_ATTACHMENT3: 36067,
+    COLOR_ATTACHMENT4: 36068,
+    COLOR_ATTACHMENT5: 36069,
+    COLOR_ATTACHMENT6: 36070,
+    COLOR_ATTACHMENT7: 36071,
+    COLOR_ATTACHMENT8: 36072,
+    COLOR_ATTACHMENT9: 36073,
+    COLOR_ATTACHMENT10: 36074,
+    COLOR_ATTACHMENT11: 36075,
+    COLOR_ATTACHMENT12: 36076,
+    COLOR_ATTACHMENT13: 36077,
+    COLOR_ATTACHMENT14: 36078,
+    COLOR_ATTACHMENT15: 36079,
+    SAMPLER_3D: 35679,
+    SAMPLER_2D_SHADOW: 35682,
+    SAMPLER_2D_ARRAY: 36289,
+    SAMPLER_2D_ARRAY_SHADOW: 36292,
+    SAMPLER_CUBE_SHADOW: 36293,
+    INT_SAMPLER_2D: 36298,
+    INT_SAMPLER_3D: 36299,
+    INT_SAMPLER_CUBE: 36300,
+    INT_SAMPLER_2D_ARRAY: 36303,
+    UNSIGNED_INT_SAMPLER_2D: 36306,
+    UNSIGNED_INT_SAMPLER_3D: 36307,
+    UNSIGNED_INT_SAMPLER_CUBE: 36308,
+    UNSIGNED_INT_SAMPLER_2D_ARRAY: 36311,
+    MAX_SAMPLES: 36183,
+    SAMPLER_BINDING: 35097,
+    PIXEL_PACK_BUFFER: 35051,
+    PIXEL_UNPACK_BUFFER: 35052,
+    PIXEL_PACK_BUFFER_BINDING: 35053,
+    PIXEL_UNPACK_BUFFER_BINDING: 35055,
+    COPY_READ_BUFFER: 36662,
+    COPY_WRITE_BUFFER: 36663,
+    COPY_READ_BUFFER_BINDING: 36662,
+    COPY_WRITE_BUFFER_BINDING: 36663,
+    FLOAT_MAT2x3: 35685,
+    FLOAT_MAT2x4: 35686,
+    FLOAT_MAT3x2: 35687,
+    FLOAT_MAT3x4: 35688,
+    FLOAT_MAT4x2: 35689,
+    FLOAT_MAT4x3: 35690,
+    UNSIGNED_INT_VEC2: 36294,
+    UNSIGNED_INT_VEC3: 36295,
+    UNSIGNED_INT_VEC4: 36296,
+    UNSIGNED_NORMALIZED: 35863,
+    SIGNED_NORMALIZED: 36764,
+    VERTEX_ATTRIB_ARRAY_INTEGER: 35069,
+    VERTEX_ATTRIB_ARRAY_DIVISOR: 35070,
+    TRANSFORM_FEEDBACK_BUFFER_MODE: 35967,
+    MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 35968,
+    TRANSFORM_FEEDBACK_VARYINGS: 35971,
+    TRANSFORM_FEEDBACK_BUFFER_START: 35972,
+    TRANSFORM_FEEDBACK_BUFFER_SIZE: 35973,
+    TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 35976,
+    MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 35978,
+    MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 35979,
+    INTERLEAVED_ATTRIBS: 35980,
+    SEPARATE_ATTRIBS: 35981,
+    TRANSFORM_FEEDBACK_BUFFER: 35982,
+    TRANSFORM_FEEDBACK_BUFFER_BINDING: 35983,
+    TRANSFORM_FEEDBACK: 36386,
+    TRANSFORM_FEEDBACK_PAUSED: 36387,
+    TRANSFORM_FEEDBACK_ACTIVE: 36388,
+    TRANSFORM_FEEDBACK_BINDING: 36389,
+    FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: 33296,
+    FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: 33297,
+    FRAMEBUFFER_ATTACHMENT_RED_SIZE: 33298,
+    FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 33299,
+    FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 33300,
+    FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 33301,
+    FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 33302,
+    FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 33303,
+    FRAMEBUFFER_DEFAULT: 33304,
+    DEPTH24_STENCIL8: 35056,
+    DRAW_FRAMEBUFFER_BINDING: 36006,
+    READ_FRAMEBUFFER_BINDING: 36010,
+    RENDERBUFFER_SAMPLES: 36011,
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: 36052,
+    FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: 36182,
+    UNIFORM_BUFFER: 35345,
+    UNIFORM_BUFFER_BINDING: 35368,
+    UNIFORM_BUFFER_START: 35369,
+    UNIFORM_BUFFER_SIZE: 35370,
+    MAX_VERTEX_UNIFORM_BLOCKS: 35371,
+    MAX_FRAGMENT_UNIFORM_BLOCKS: 35373,
+    MAX_COMBINED_UNIFORM_BLOCKS: 35374,
+    MAX_UNIFORM_BUFFER_BINDINGS: 35375,
+    MAX_UNIFORM_BLOCK_SIZE: 35376,
+    MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 35377,
+    MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 35379,
+    UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380,
+    ACTIVE_UNIFORM_BLOCKS: 35382,
+    UNIFORM_TYPE: 35383,
+    UNIFORM_SIZE: 35384,
+    UNIFORM_BLOCK_INDEX: 35386,
+    UNIFORM_OFFSET: 35387,
+    UNIFORM_ARRAY_STRIDE: 35388,
+    UNIFORM_MATRIX_STRIDE: 35389,
+    UNIFORM_IS_ROW_MAJOR: 35390,
+    UNIFORM_BLOCK_BINDING: 35391,
+    UNIFORM_BLOCK_DATA_SIZE: 35392,
+    UNIFORM_BLOCK_ACTIVE_UNIFORMS: 35394,
+    UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 35395,
+    UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 35396,
+    UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 35398,
+    OBJECT_TYPE: 37138,
+    SYNC_CONDITION: 37139,
+    SYNC_STATUS: 37140,
+    SYNC_FLAGS: 37141,
+    SYNC_FENCE: 37142,
+    SYNC_GPU_COMMANDS_COMPLETE: 37143,
+    UNSIGNALED: 37144,
+    SIGNALED: 37145,
+    ALREADY_SIGNALED: 37146,
+    TIMEOUT_EXPIRED: 37147,
+    CONDITION_SATISFIED: 37148,
+    WAIT_FAILED: 37149,
+    SYNC_FLUSH_COMMANDS_BIT: 1,
+    COLOR: 6144,
+    DEPTH: 6145,
+    STENCIL: 6146,
+    MIN: 32775,
+    MAX: 32776,
+    DEPTH_COMPONENT24: 33190,
+    STREAM_READ: 35041,
+    STREAM_COPY: 35042,
+    STATIC_READ: 35045,
+    STATIC_COPY: 35046,
+    DYNAMIC_READ: 35049,
+    DYNAMIC_COPY: 35050,
+    DEPTH_COMPONENT32F: 36012,
+    DEPTH32F_STENCIL8: 36013,
+    INVALID_INDEX: 4294967295,
+    TIMEOUT_IGNORED: -1,
+    MAX_CLIENT_WAIT_TIMEOUT_WEBGL: 37447,
+    VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 35070,
+    UNMASKED_VENDOR_WEBGL: 37445,
+    UNMASKED_RENDERER_WEBGL: 37446,
+    MAX_TEXTURE_MAX_ANISOTROPY_EXT: 34047,
+    TEXTURE_MAX_ANISOTROPY_EXT: 34046,
+    COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
+    COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
+    COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
+    COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
+    COMPRESSED_R11_EAC: 37488,
+    COMPRESSED_SIGNED_R11_EAC: 37489,
+    COMPRESSED_RG11_EAC: 37490,
+    COMPRESSED_SIGNED_RG11_EAC: 37491,
+    COMPRESSED_RGB8_ETC2: 37492,
+    COMPRESSED_RGBA8_ETC2_EAC: 37493,
+    COMPRESSED_SRGB8_ETC2: 37494,
+    COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495,
+    COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496,
+    COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497,
+    COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
+    COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
+    COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
+    COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
+    COMPRESSED_RGB_ETC1_WEBGL: 36196,
+    COMPRESSED_RGB_ATC_WEBGL: 35986,
+    COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35986,
+    COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
+    UNSIGNED_INT_24_8_WEBGL: 34042,
+    HALF_FLOAT_OES: 36193,
+    RGBA32F_EXT: 34836,
+    RGB32F_EXT: 34837,
+    FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: 33297,
+    UNSIGNED_NORMALIZED_EXT: 35863,
+    MIN_EXT: 32775,
+    MAX_EXT: 32776,
+    SRGB_EXT: 35904,
+    SRGB_ALPHA_EXT: 35906,
+    SRGB8_ALPHA8_EXT: 35907,
+    FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: 33296,
+    FRAGMENT_SHADER_DERIVATIVE_HINT_OES: 35723,
+    COLOR_ATTACHMENT0_WEBGL: 36064,
+    COLOR_ATTACHMENT1_WEBGL: 36065,
+    COLOR_ATTACHMENT2_WEBGL: 36066,
+    COLOR_ATTACHMENT3_WEBGL: 36067,
+    COLOR_ATTACHMENT4_WEBGL: 36068,
+    COLOR_ATTACHMENT5_WEBGL: 36069,
+    COLOR_ATTACHMENT6_WEBGL: 36070,
+    COLOR_ATTACHMENT7_WEBGL: 36071,
+    COLOR_ATTACHMENT8_WEBGL: 36072,
+    COLOR_ATTACHMENT9_WEBGL: 36073,
+    COLOR_ATTACHMENT10_WEBGL: 36074,
+    COLOR_ATTACHMENT11_WEBGL: 36075,
+    COLOR_ATTACHMENT12_WEBGL: 36076,
+    COLOR_ATTACHMENT13_WEBGL: 36077,
+    COLOR_ATTACHMENT14_WEBGL: 36078,
+    COLOR_ATTACHMENT15_WEBGL: 36079,
+    DRAW_BUFFER0_WEBGL: 34853,
+    DRAW_BUFFER1_WEBGL: 34854,
+    DRAW_BUFFER2_WEBGL: 34855,
+    DRAW_BUFFER3_WEBGL: 34856,
+    DRAW_BUFFER4_WEBGL: 34857,
+    DRAW_BUFFER5_WEBGL: 34858,
+    DRAW_BUFFER6_WEBGL: 34859,
+    DRAW_BUFFER7_WEBGL: 34860,
+    DRAW_BUFFER8_WEBGL: 34861,
+    DRAW_BUFFER9_WEBGL: 34862,
+    DRAW_BUFFER10_WEBGL: 34863,
+    DRAW_BUFFER11_WEBGL: 34864,
+    DRAW_BUFFER12_WEBGL: 34865,
+    DRAW_BUFFER13_WEBGL: 34866,
+    DRAW_BUFFER14_WEBGL: 34867,
+    DRAW_BUFFER15_WEBGL: 34868,
+    MAX_COLOR_ATTACHMENTS_WEBGL: 36063,
+    MAX_DRAW_BUFFERS_WEBGL: 34852,
+    VERTEX_ARRAY_BINDING_OES: 34229,
+    QUERY_COUNTER_BITS_EXT: 34916,
+    CURRENT_QUERY_EXT: 34917,
+    QUERY_RESULT_EXT: 34918,
+    QUERY_RESULT_AVAILABLE_EXT: 34919,
+    TIME_ELAPSED_EXT: 35007,
+    TIMESTAMP_EXT: 36392,
+    GPU_DISJOINT_EXT: 36795
+  };
+
+  // src/data-filter/aggregator.ts
   var AGGREGATE_VS = `#define SHADER_NAME data-filter-vertex-shader
 
 #ifdef FLOAT_TARGET
@@ -479,9 +1077,9 @@ void main() {
         width: 1,
         height: 1,
         attachments: {
-          [import_constants.default.COLOR_ATTACHMENT0]: new import_core4.Texture2D(gl, {
-            format: (0, import_core4.isWebGL2)(gl) ? import_constants.default.RGBA32F : import_constants.default.RGBA,
-            type: import_constants.default.FLOAT,
+          [esm_default.COLOR_ATTACHMENT0]: new import_core4.Texture2D(gl, {
+            format: (0, import_core4.isWebGL2)(gl) ? esm_default.RGBA32F : esm_default.RGBA,
+            type: esm_default.FLOAT,
             mipmaps: false
           })
         }
@@ -502,7 +1100,7 @@ void main() {
       id: "data-filter-aggregation-model",
       vertexCount: 1,
       isInstanced: false,
-      drawMode: import_constants.default.POINTS,
+      drawMode: esm_default.POINTS,
       vs: AGGREGATE_VS,
       fs: AGGREGATE_FS,
       ...shaderOptions
@@ -510,14 +1108,13 @@ void main() {
   }
   var parameters = {
     blend: true,
-    blendFunc: [import_constants.default.ONE, import_constants.default.ONE, import_constants.default.ONE, import_constants.default.ONE],
-    blendEquation: [import_constants.default.FUNC_ADD, import_constants.default.FUNC_ADD],
+    blendFunc: [esm_default.ONE, esm_default.ONE, esm_default.ONE, esm_default.ONE],
+    blendEquation: [esm_default.FUNC_ADD, esm_default.FUNC_ADD],
     depthTest: false
   };
 
   // src/data-filter/data-filter.ts
   var import_core6 = __toESM(require_core2());
-  var import_constants2 = __toESM(require_constants());
   var defaultProps2 = {
     getFilterValue: {
       type: "accessor",
@@ -574,7 +1171,7 @@ void main() {
         attributeManager.add({
           filterValues: {
             size: extension.opts.filterSize,
-            type: extension.opts.fp64 ? import_constants2.default.DOUBLE : import_constants2.default.FLOAT,
+            type: extension.opts.fp64 ? esm_default.DOUBLE : esm_default.FLOAT,
             accessor: "getFilterValue",
             shaderAttributes: {
               filterValues: {
@@ -596,7 +1193,7 @@ void main() {
           filterIndices: {
             size: useFloatTarget ? 1 : 2,
             vertexOffset: 1,
-            type: import_constants2.default.UNSIGNED_BYTE,
+            type: esm_default.UNSIGNED_BYTE,
             normalized: true,
             accessor: (object, {
               index
@@ -756,6 +1353,112 @@ void main() {
     fp64ifyMatrix4
   };
 
+  // ../../node_modules/@math.gl/core/dist/esm/lib/common.js
+  var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
+  var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
+  var config = {
+    EPSILON: 1e-12,
+    debug: false,
+    precision: 4,
+    printTypes: false,
+    printDegrees: false,
+    printRowMajor: true
+  };
+  function isArray(value) {
+    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  function equals(a, b, epsilon) {
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+      config.EPSILON = epsilon;
+    }
+    try {
+      if (a === b) {
+        return true;
+      }
+      if (isArray(a) && isArray(b)) {
+        if (a.length !== b.length) {
+          return false;
+        }
+        for (let i = 0; i < a.length; ++i) {
+          if (!equals(a[i], b[i])) {
+            return false;
+          }
+        }
+        return true;
+      }
+      if (a && a.equals) {
+        return a.equals(b);
+      }
+      if (b && b.equals) {
+        return b.equals(a);
+      }
+      if (typeof a === "number" && typeof b === "number") {
+        return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
+      }
+      return false;
+    } finally {
+      config.EPSILON = oldEpsilon;
+    }
+  }
+
+  // ../../node_modules/gl-matrix/esm/common.js
+  var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+  var degree = Math.PI / 180;
+  if (!Math.hypot)
+    Math.hypot = function() {
+      var y = 0, i = arguments.length;
+      while (i--) {
+        y += arguments[i] * arguments[i];
+      }
+      return Math.sqrt(y);
+    };
+
+  // ../../node_modules/gl-matrix/esm/vec3.js
+  function create() {
+    var out = new ARRAY_TYPE(3);
+    if (ARRAY_TYPE != Float32Array) {
+      out[0] = 0;
+      out[1] = 0;
+      out[2] = 0;
+    }
+    return out;
+  }
+  function distance(a, b) {
+    var x = b[0] - a[0];
+    var y = b[1] - a[1];
+    var z = b[2] - a[2];
+    return Math.hypot(x, y, z);
+  }
+  var dist = distance;
+  var forEach = function() {
+    var vec = create();
+    return function(a, stride, offset, count, fn, arg) {
+      var i, l;
+      if (!stride) {
+        stride = 3;
+      }
+      if (!offset) {
+        offset = 0;
+      }
+      if (count) {
+        l = Math.min(count * stride + offset, a.length);
+      } else {
+        l = a.length;
+      }
+      for (i = offset; i < l; i += stride) {
+        vec[0] = a[i];
+        vec[1] = a[i + 1];
+        vec[2] = a[i + 2];
+        fn(vec, vec, arg);
+        a[i] = vec[0];
+        a[i + 1] = vec[1];
+        a[i + 2] = vec[2];
+      }
+      return a;
+    };
+  }();
+
   // src/fp64/project64.ts
   var import_core7 = __toESM(require_core());
 
@@ -985,63 +1688,6 @@ attribute float instanceOffsets;
     }
   };
 
-  // ../../node_modules/gl-matrix/esm/common.js
-  var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
-  var degree = Math.PI / 180;
-  if (!Math.hypot)
-    Math.hypot = function() {
-      var y = 0, i = arguments.length;
-      while (i--) {
-        y += arguments[i] * arguments[i];
-      }
-      return Math.sqrt(y);
-    };
-
-  // ../../node_modules/gl-matrix/esm/vec3.js
-  function create() {
-    var out = new ARRAY_TYPE(3);
-    if (ARRAY_TYPE != Float32Array) {
-      out[0] = 0;
-      out[1] = 0;
-      out[2] = 0;
-    }
-    return out;
-  }
-  function distance(a, b) {
-    var x = b[0] - a[0];
-    var y = b[1] - a[1];
-    var z = b[2] - a[2];
-    return Math.hypot(x, y, z);
-  }
-  var dist = distance;
-  var forEach = function() {
-    var vec = create();
-    return function(a, stride, offset, count, fn, arg) {
-      var i, l;
-      if (!stride) {
-        stride = 3;
-      }
-      if (!offset) {
-        offset = 0;
-      }
-      if (count) {
-        l = Math.min(count * stride + offset, a.length);
-      } else {
-        l = a.length;
-      }
-      for (i = offset; i < l; i += stride) {
-        vec[0] = a[i];
-        vec[1] = a[i + 1];
-        vec[2] = a[i + 2];
-        fn(vec, vec, arg);
-        a[i] = vec[0];
-        a[i + 1] = vec[1];
-        a[i + 2] = vec[2];
-      }
-      return a;
-    };
-  }();
-
   // src/path-style/path-style.ts
   var defaultProps3 = {
     getDashArray: {
@@ -1149,7 +1795,6 @@ attribute float instanceOffsets;
   // src/fill-style/fill-style.ts
   var import_core11 = __toESM(require_core());
   var import_core12 = __toESM(require_core2());
-  var import_constants3 = __toESM(require_constants());
 
   // src/fill-style/shaders.glsl.ts
   var import_core10 = __toESM(require_core());
@@ -1263,7 +1908,7 @@ const float FILL_UV_SCALE = 512.0 / 40000000.0;
       value: null,
       async: true,
       parameters: {
-        [import_constants3.default.TEXTURE_MIN_FILTER]: import_constants3.default.LINEAR
+        [esm_default.TEXTURE_MIN_FILTER]: esm_default.LINEAR
       }
     },
     fillPatternMapping: {
@@ -1588,7 +2233,6 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
 
   // src/collision-filter/collision-filter-effect.ts
   var import_core23 = __toESM(require_core2());
-  var import_core24 = __toESM(require_core3());
   var import_core25 = __toESM(require_core());
 
   // src/collision-filter/collision-filter-pass.ts
@@ -1624,7 +2268,6 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
   // src/mask/mask-effect.ts
   var import_core20 = __toESM(require_core());
   var import_core21 = __toESM(require_core2());
-  var import_core22 = __toESM(require_core3());
 
   // src/mask/mask-pass.ts
   var import_core17 = __toESM(require_core2());
@@ -1884,7 +2527,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
         this.lastViewport = viewport;
         const layerBounds = joinLayerBounds(channelInfo.layers, viewport);
         channelInfo.bounds = layerBounds && getRenderBounds(layerBounds, viewport);
-        if (maskChanged || !(0, import_core22.equals)(channelInfo.bounds, oldChannelInfo.bounds)) {
+        if (maskChanged || !equals(channelInfo.bounds, oldChannelInfo.bounds)) {
           const {
             maskPass,
             maskMap
@@ -2065,7 +2708,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
       if (!oldRenderInfo) {
         return;
       }
-      const needsRender = viewportChanged || renderInfo === oldRenderInfo || !(0, import_core25._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 1) || renderInfo.layerBounds.some((b, i) => !(0, import_core24.equals)(b, oldRenderInfo.layerBounds[i])) || renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || renderInfo.layers.some((layer) => layer.props.transitions);
+      const needsRender = viewportChanged || renderInfo === oldRenderInfo || !(0, import_core25._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 1) || renderInfo.layerBounds.some((b, i) => !equals(b, oldRenderInfo.layerBounds[i])) || renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || renderInfo.layers.some((layer) => layer.props.transitions);
       this.channels[collisionGroup] = renderInfo;
       if (needsRender) {
         this.lastViewport = viewport;
@@ -2537,15 +3180,14 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
 
   // src/terrain/utils.ts
   var import_core30 = __toESM(require_core2());
-  var import_constants4 = __toESM(require_constants());
   function createRenderTarget(gl, opts) {
     return new import_core30.Framebuffer(gl, {
       id: opts.id,
       attachments: {
         [gl.COLOR_ATTACHMENT0]: new import_core30.Texture2D(gl, {
           ...opts.float && {
-            format: (0, import_core30.isWebGL2)(gl) ? import_constants4.default.RGBA32F : import_constants4.default.RGBA,
-            type: import_constants4.default.FLOAT
+            format: (0, import_core30.isWebGL2)(gl) ? esm_default.RGBA32F : esm_default.RGBA,
+            type: esm_default.FLOAT
           },
           mipmaps: false,
           parameters: {
@@ -2724,7 +3366,6 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
   // src/terrain/terrain-pass.ts
   var import_core31 = __toESM(require_core2());
   var import_core32 = __toESM(require_core());
-  var import_constants5 = __toESM(require_constants());
   var TerrainPass = class extends import_core32._LayersPass {
     getRenderableLayers(viewport, opts) {
       const {
@@ -2750,8 +3391,8 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       (0, import_core31.withParameters)(this.gl, {
         clearColor: [0, 0, 0, 0],
         blend: true,
-        blendFunc: [import_constants5.default.ONE, import_constants5.default.ONE],
-        blendEquation: import_constants5.default.MAX,
+        blendFunc: [esm_default.ONE, esm_default.ONE],
+        blendEquation: esm_default.MAX,
         depthTest: false
       }, () => this.render({
         ...opts,