@mapbox-vue3/env-layers
Version:
Mapbox Vue3 Component Library Env Layers
1,758 lines • 2.04 MB
JavaScript
import { defineComponent as xd, onBeforeUnmount as Ed, openBlock as Id, createElementBlock as bd, watch as bx } from "vue";
import { useMapCreated as Cd } from "@mapbox-vue3/core";
function wb(r, t) {
for (var i = 0; i < t.length; i++) {
const o = t[i];
if (typeof o != "string" && !Array.isArray(o)) {
for (const l in o)
if (l !== "default" && !(l in r)) {
const p = Object.getOwnPropertyDescriptor(o, l);
p && Object.defineProperty(r, l, p.get ? p : {
enumerable: !0,
get: () => o[l]
});
}
}
}
return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
}
const wd = (r, t) => (r.install = (i) => {
for (const o of [r, ...Object.values({})])
i.component(o.name, o);
}, r), Qt = {
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
};
function qh(r) {
"@babel/helpers - typeof";
return qh = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
return typeof t;
} : function(t) {
return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
}, qh(r);
}
function Tb(r, t) {
if (qh(r) != "object" || !r) return r;
var i = r[Symbol.toPrimitive];
if (i !== void 0) {
var o = i.call(r, t || "default");
if (qh(o) != "object") return o;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (t === "string" ? String : Number)(r);
}
function Mb(r) {
var t = Tb(r, "string");
return qh(t) == "symbol" ? t : t + "";
}
function Z(r, t, i) {
return (t = Mb(t)) in r ? Object.defineProperty(r, t, {
value: i,
enumerable: !0,
configurable: !0,
writable: !0
}) : r[t] = i, r;
}
function Cx(r) {
if (typeof window < "u" && typeof window.process == "object" && window.process.type === "renderer" || typeof process < "u" && typeof process.versions == "object" && process.versions.electron)
return !0;
const i = typeof navigator == "object" && typeof navigator.userAgent == "string" && navigator.userAgent;
return !!(i && i.indexOf("Electron") >= 0);
}
function za() {
return !(typeof process == "object" && String(process) === "[object process]" && !process.browser) || Cx();
}
const Zp = {
self: typeof self < "u" && self,
window: typeof window < "u" && window,
global: typeof global < "u" && global,
document: typeof document < "u" && document,
process: typeof process == "object" && process
}, Sp = Zp.window || Zp.self || Zp.global, Fh = Zp.process || {}, wx = typeof __VERSION__ < "u" ? __VERSION__ : "untranspiled source";
za();
const $g = globalThis;
function Tx(r) {
if (!za())
return "Node";
if (Cx())
return "Electron";
const i = (typeof navigator < "u" ? navigator : {}).userAgent || "";
if (i.indexOf("Edge") > -1)
return "Edge";
const o = i.indexOf("MSIE ") !== -1, l = i.indexOf("Trident/") !== -1;
return o || l ? "IE" : $g.chrome ? "Chrome" : $g.safari ? "Safari" : $g.mozInnerScreenX ? "Firefox" : "Unknown";
}
function Sb(r) {
try {
const t = window[r], i = "__storage_test__";
return t.setItem(i, i), t.removeItem(i), t;
} catch {
return null;
}
}
class Bb {
constructor(t, i) {
let o = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
Z(this, "storage", void 0), Z(this, "id", void 0), Z(this, "config", void 0), this.storage = Sb(o), this.id = t, this.config = i, this._loadConfiguration();
}
getConfiguration() {
return this.config;
}
setConfiguration(t) {
if (Object.assign(this.config, t), this.storage) {
const i = JSON.stringify(this.config);
this.storage.setItem(this.id, i);
}
}
_loadConfiguration() {
let t = {};
if (this.storage) {
const i = this.storage.getItem(this.id);
t = i ? JSON.parse(i) : {};
}
return Object.assign(this.config, t), this;
}
}
function Rb(r) {
let t;
return r < 10 ? t = "".concat(r.toFixed(2), "ms") : r < 100 ? t = "".concat(r.toFixed(1), "ms") : r < 1e3 ? t = "".concat(r.toFixed(0), "ms") : t = "".concat((r / 1e3).toFixed(2), "s"), t;
}
function Pb(r) {
let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8;
const i = Math.max(t - r.length, 0);
return "".concat(" ".repeat(i)).concat(r);
}
function tA(r, t, i) {
let o = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600;
const l = r.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
r.width > o && (i = Math.min(i, o / r.width));
const p = r.width * i, a = r.height * i, E = ["font-size:1px;", "padding:".concat(Math.floor(a / 2), "px ").concat(Math.floor(p / 2), "px;"), "line-height:".concat(a, "px;"), "background:url(".concat(l, ");"), "background-size:".concat(p, "px ").concat(a, "px;"), "color:transparent;"].join("");
return ["".concat(t, " %c+"), E];
}
let ad;
(function(r) {
r[r.BLACK = 30] = "BLACK", r[r.RED = 31] = "RED", r[r.GREEN = 32] = "GREEN", r[r.YELLOW = 33] = "YELLOW", r[r.BLUE = 34] = "BLUE", r[r.MAGENTA = 35] = "MAGENTA", r[r.CYAN = 36] = "CYAN", r[r.WHITE = 37] = "WHITE", r[r.BRIGHT_BLACK = 90] = "BRIGHT_BLACK", r[r.BRIGHT_RED = 91] = "BRIGHT_RED", r[r.BRIGHT_GREEN = 92] = "BRIGHT_GREEN", r[r.BRIGHT_YELLOW = 93] = "BRIGHT_YELLOW", r[r.BRIGHT_BLUE = 94] = "BRIGHT_BLUE", r[r.BRIGHT_MAGENTA = 95] = "BRIGHT_MAGENTA", r[r.BRIGHT_CYAN = 96] = "BRIGHT_CYAN", r[r.BRIGHT_WHITE = 97] = "BRIGHT_WHITE";
})(ad || (ad = {}));
function u_(r) {
return typeof r == "string" ? ad[r.toUpperCase()] || ad.WHITE : r;
}
function Db(r, t, i) {
return !za && typeof r == "string" && (t && (t = u_(t), r = "\x1B[".concat(t, "m").concat(r, "\x1B[39m")), i && (t = u_(i), r = "\x1B[".concat(i + 10, "m").concat(r, "\x1B[49m"))), r;
}
function Lb(r) {
let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
const i = Object.getPrototypeOf(r), o = Object.getOwnPropertyNames(i);
for (const l of o)
typeof r[l] == "function" && (t.find((p) => l === p) || (r[l] = r[l].bind(r)));
}
function ld(r, t) {
if (!r)
throw new Error(t || "Assertion failed");
}
function cu() {
let r;
if (za && "performance" in Sp) {
var t, i;
r = Sp == null || (t = Sp.performance) === null || t === void 0 || (i = t.now) === null || i === void 0 ? void 0 : i.call(t);
} else if ("hrtime" in Fh) {
var o;
const l = Fh == null || (o = Fh.hrtime) === null || o === void 0 ? void 0 : o.call(Fh);
r = l[0] * 1e3 + l[1] / 1e6;
} else
r = Date.now();
return r;
}
const uu = {
debug: za && console.debug || console.log,
log: console.log,
info: console.info,
warn: console.warn,
error: console.error
}, Fb = {
enabled: !0,
level: 0
};
function es() {
}
const h_ = {}, f_ = {
once: !0
};
class uf {
constructor() {
let {
id: t
} = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
id: ""
};
Z(this, "id", void 0), Z(this, "VERSION", wx), Z(this, "_startTs", cu()), Z(this, "_deltaTs", cu()), Z(this, "_storage", void 0), Z(this, "userData", {}), Z(this, "LOG_THROTTLE_TIMEOUT", 0), this.id = t, this.userData = {}, this._storage = new Bb("__probe-".concat(this.id, "__"), Fb), this.timeStamp("".concat(this.id, " started")), Lb(this), Object.seal(this);
}
set level(t) {
this.setLevel(t);
}
get level() {
return this.getLevel();
}
isEnabled() {
return this._storage.config.enabled;
}
getLevel() {
return this._storage.config.level;
}
getTotal() {
return Number((cu() - this._startTs).toPrecision(10));
}
getDelta() {
return Number((cu() - this._deltaTs).toPrecision(10));
}
set priority(t) {
this.level = t;
}
get priority() {
return this.level;
}
getPriority() {
return this.level;
}
enable() {
let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !0;
return this._storage.setConfiguration({
enabled: t
}), this;
}
setLevel(t) {
return this._storage.setConfiguration({
level: t
}), this;
}
get(t) {
return this._storage.config[t];
}
set(t, i) {
this._storage.setConfiguration({
[t]: i
});
}
settings() {
console.table ? console.table(this._storage.config) : console.log(this._storage.config);
}
assert(t, i) {
ld(t, i);
}
warn(t) {
return this._getLogFunction(0, t, uu.warn, arguments, f_);
}
error(t) {
return this._getLogFunction(0, t, uu.error, arguments);
}
deprecated(t, i) {
return this.warn("`".concat(t, "` is deprecated and will be removed in a later version. Use `").concat(i, "` instead"));
}
removed(t, i) {
return this.error("`".concat(t, "` has been removed. Use `").concat(i, "` instead"));
}
probe(t, i) {
return this._getLogFunction(t, i, uu.log, arguments, {
time: !0,
once: !0
});
}
log(t, i) {
return this._getLogFunction(t, i, uu.debug, arguments);
}
info(t, i) {
return this._getLogFunction(t, i, console.info, arguments);
}
once(t, i) {
for (var o = arguments.length, l = new Array(o > 2 ? o - 2 : 0), p = 2; p < o; p++)
l[p - 2] = arguments[p];
return this._getLogFunction(t, i, uu.debug || uu.info, arguments, f_);
}
table(t, i, o) {
return i ? this._getLogFunction(t, i, console.table || es, o && [o], {
tag: zb(i)
}) : es;
}
image(t) {
let {
logLevel: i,
priority: o,
image: l,
message: p = "",
scale: a = 1
} = t;
return this._shouldLog(i || o) ? za ? kb({
image: l,
message: p,
scale: a
}) : Ob() : es;
}
time(t, i) {
return this._getLogFunction(t, i, console.time ? console.time : console.info);
}
timeEnd(t, i) {
return this._getLogFunction(t, i, console.timeEnd ? console.timeEnd : console.info);
}
timeStamp(t, i) {
return this._getLogFunction(t, i, console.timeStamp || es);
}
group(t, i) {
let o = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
collapsed: !1
};
const l = p_({
logLevel: t,
message: i,
opts: o
}), {
collapsed: p
} = o;
return l.method = (p ? console.groupCollapsed : console.group) || console.info, this._getLogFunction(l);
}
groupCollapsed(t, i) {
let o = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
return this.group(t, i, Object.assign({}, o, {
collapsed: !0
}));
}
groupEnd(t) {
return this._getLogFunction(t, "", console.groupEnd || es);
}
withGroup(t, i, o) {
this.group(t, i)();
try {
o();
} finally {
this.groupEnd(t)();
}
}
trace() {
console.trace && console.trace();
}
_shouldLog(t) {
return this.isEnabled() && this.getLevel() >= Mx(t);
}
_getLogFunction(t, i, o, l, p) {
if (this._shouldLog(t)) {
p = p_({
logLevel: t,
message: i,
args: l,
opts: p
}), o = o || p.method, ld(o), p.total = this.getTotal(), p.delta = this.getDelta(), this._deltaTs = cu();
const a = p.tag || p.message;
if (p.once)
if (!h_[a])
h_[a] = cu();
else
return es;
return i = Nb(this.id, p.message, p), o.bind(console, i, ...p.args);
}
return es;
}
}
Z(uf, "VERSION", wx);
function Mx(r) {
if (!r)
return 0;
let t;
switch (typeof r) {
case "number":
t = r;
break;
case "object":
t = r.logLevel || r.priority || 0;
break;
default:
return 0;
}
return ld(Number.isFinite(t) && t >= 0), t;
}
function p_(r) {
const {
logLevel: t,
message: i
} = r;
r.logLevel = Mx(t);
const o = r.args ? Array.from(r.args) : [];
for (; o.length && o.shift() !== i; )
;
switch (typeof t) {
case "string":
case "function":
i !== void 0 && o.unshift(i), r.message = t;
break;
case "object":
Object.assign(r, t);
break;
}
typeof r.message == "function" && (r.message = r.message());
const l = typeof r.message;
return ld(l === "string" || l === "object"), Object.assign(r, {
args: o
}, r.opts);
}
function Nb(r, t, i) {
if (typeof t == "string") {
const o = i.time ? Pb(Rb(i.total)) : "";
t = i.time ? "".concat(r, ": ").concat(o, " ").concat(t) : "".concat(r, ": ").concat(t), t = Db(t, i.color, i.background);
}
return t;
}
function Ob(r) {
return console.warn("removed"), es;
}
function kb(r) {
let {
image: t,
message: i = "",
scale: o = 1
} = r;
if (typeof t == "string") {
const p = new Image();
return p.onload = () => {
const a = tA(p, i, o);
console.log(...a);
}, p.src = t, es;
}
const l = t.nodeName || "";
if (l.toLowerCase() === "img")
return console.log(...tA(t, i, o)), es;
if (l.toLowerCase() === "canvas") {
const p = new Image();
return p.onload = () => console.log(...tA(p, i, o)), p.src = t.toDataURL(), es;
}
return es;
}
function zb(r) {
for (const t in r)
for (const i in r[t])
return i || "untitled";
return "empty";
}
const be = new uf({
id: "luma.gl"
});
function Vr(r, t) {
if (!r)
throw new Error(t || "luma.gl: assertion failed.");
}
const Qb = "Invalid WebGLRenderingContext", Ub = "Requires WebGL2";
function Td(r) {
return typeof WebGLRenderingContext < "u" && r instanceof WebGLRenderingContext || typeof WebGL2RenderingContext < "u" && r instanceof WebGL2RenderingContext ? !0 : !!(r && Number.isFinite(r._version));
}
function oi(r) {
return typeof WebGL2RenderingContext < "u" && r instanceof WebGL2RenderingContext ? !0 : !!(r && r._version === 2);
}
function Gb(r) {
return oi(r) ? r : null;
}
function Md(r) {
return Vr(Td(r), Qb), r;
}
function jr(r) {
return Vr(oi(r), Ub), r;
}
const Gh = {};
function Vb(r) {
globalThis.console && globalThis.console.error && globalThis.console.error(r);
}
function jb(r) {
globalThis.console && globalThis.console.log && globalThis.console.log(r);
}
function Hb(r, t) {
Gh[r] = !0, Vb(t);
}
function Kb(r) {
const t = r.getError;
r.getError = function() {
let o;
do
o = t.apply(r), o !== 0 && (Gh[o] = !0);
while (o !== 0);
for (o in Gh)
if (Gh[o])
return delete Gh[o], parseInt(o, 10);
return 0;
};
}
const hf = function r(t) {
const i = t.gl;
this.ext = t, this.isAlive = !0, this.hasBeenBound = !1, this.elementArrayBuffer = null, this.attribs = new Array(t.maxVertexAttribs);
for (let o = 0; o < this.attribs.length; o++) {
const l = new r.VertexAttrib(i);
this.attribs[o] = l;
}
this.maxAttrib = 0;
};
hf.VertexAttrib = function(t) {
this.enabled = !1, this.buffer = null, this.size = 4, this.type = 5126, this.normalized = !1, this.stride = 16, this.offset = 0, this.cached = "", this.recache();
};
hf.VertexAttrib.prototype.recache = function() {
this.cached = [this.size, this.type, this.normalized, this.stride, this.offset].join(":");
};
const _c = function(t) {
const i = this;
this.gl = t, Kb(t);
const o = this.original = {
getParameter: t.getParameter,
enableVertexAttribArray: t.enableVertexAttribArray,
disableVertexAttribArray: t.disableVertexAttribArray,
bindBuffer: t.bindBuffer,
getVertexAttrib: t.getVertexAttrib,
vertexAttribPointer: t.vertexAttribPointer
};
t.getParameter = function(p) {
return p === i.VERTEX_ARRAY_BINDING_OES ? i.currentVertexArrayObject === i.defaultVertexArrayObject ? null : i.currentVertexArrayObject : o.getParameter.apply(this, arguments);
}, t.enableVertexAttribArray = function(p) {
const a = i.currentVertexArrayObject;
a.maxAttrib = Math.max(a.maxAttrib, p);
const E = a.attribs[p];
return E.enabled = !0, o.enableVertexAttribArray.apply(this, arguments);
}, t.disableVertexAttribArray = function(p) {
const a = i.currentVertexArrayObject;
a.maxAttrib = Math.max(a.maxAttrib, p);
const E = a.attribs[p];
return E.enabled = !1, o.disableVertexAttribArray.apply(this, arguments);
}, t.bindBuffer = function(p, a) {
switch (p) {
case 34962:
i.currentArrayBuffer = a;
break;
case 34963:
i.currentVertexArrayObject.elementArrayBuffer = a;
break;
}
return o.bindBuffer.apply(this, arguments);
}, t.getVertexAttrib = function(p, a) {
const I = i.currentVertexArrayObject.attribs[p];
switch (a) {
case 34975:
return I.buffer;
case 34338:
return I.enabled;
case 34339:
return I.size;
case 34340:
return I.stride;
case 34341:
return I.type;
case 34922:
return I.normalized;
default:
return o.getVertexAttrib.apply(this, arguments);
}
}, t.vertexAttribPointer = function(p, a, E, I, M, P) {
const O = i.currentVertexArrayObject;
O.maxAttrib = Math.max(O.maxAttrib, p);
const Q = O.attribs[p];
return Q.buffer = i.currentArrayBuffer, Q.size = a, Q.type = E, Q.normalized = I, Q.stride = M, Q.offset = P, Q.recache(), o.vertexAttribPointer.apply(this, arguments);
}, t.instrumentExtension && t.instrumentExtension(this, "OES_vertex_array_object"), t.canvas && t.canvas.addEventListener("webglcontextrestored", () => {
jb("OESVertexArrayObject emulation library context restored"), i.reset_();
}, !0), this.reset_();
};
_c.prototype.VERTEX_ARRAY_BINDING_OES = 34229;
_c.prototype.reset_ = function() {
if (this.vertexArrayObjects !== void 0)
for (let o = 0; o < this.vertexArrayObjects.length; ++o)
this.vertexArrayObjects.isAlive = !1;
const i = this.gl;
this.maxVertexAttribs = i.getParameter(34921), this.defaultVertexArrayObject = new hf(this), this.currentVertexArrayObject = null, this.currentArrayBuffer = null, this.vertexArrayObjects = [this.defaultVertexArrayObject], this.bindVertexArrayOES(null);
};
_c.prototype.createVertexArrayOES = function() {
const t = new hf(this);
return this.vertexArrayObjects.push(t), t;
};
_c.prototype.deleteVertexArrayOES = function(t) {
t.isAlive = !1, this.vertexArrayObjects.splice(this.vertexArrayObjects.indexOf(t), 1), this.currentVertexArrayObject === t && this.bindVertexArrayOES(null);
};
_c.prototype.isVertexArrayOES = function(t) {
return !!(t && t instanceof hf && t.hasBeenBound && t.ext === this);
};
_c.prototype.bindVertexArrayOES = function(t) {
const i = this.gl;
if (t && !t.isAlive) {
Hb(1282, "bindVertexArrayOES: attempt to bind deleted arrayObject");
return;
}
const o = this.original, l = this.currentVertexArrayObject;
this.currentVertexArrayObject = t || this.defaultVertexArrayObject, this.currentVertexArrayObject.hasBeenBound = !0;
const p = this.currentVertexArrayObject;
if (l === p)
return;
(!l || p.elementArrayBuffer !== l.elementArrayBuffer) && o.bindBuffer.call(i, 34963, p.elementArrayBuffer);
let a = this.currentArrayBuffer;
const E = Math.max(l ? l.maxAttrib : 0, p.maxAttrib);
for (let I = 0; I <= E; I++) {
const M = p.attribs[I], P = l ? l.attribs[I] : null;
if ((!l || M.enabled !== P.enabled) && (M.enabled ? o.enableVertexAttribArray.call(i, I) : o.disableVertexAttribArray.call(i, I)), M.enabled) {
let O = !1;
(!l || M.buffer !== P.buffer) && (a !== M.buffer && (o.bindBuffer.call(i, 34962, M.buffer), a = M.buffer), O = !0), (O || M.cached !== P.cached) && o.vertexAttribPointer.call(i, I, M.size, M.type, M.normalized, M.stride, M.offset);
}
}
this.currentArrayBuffer !== a && o.bindBuffer.call(i, 34962, this.currentArrayBuffer);
};
function Yb(r) {
if (typeof r.createVertexArray == "function")
return;
const t = r.getSupportedExtensions;
r.getSupportedExtensions = function() {
const l = t.call(this) || [];
return l.indexOf("OES_vertex_array_object") < 0 && l.push("OES_vertex_array_object"), l;
};
const i = r.getExtension;
r.getExtension = function(l) {
const p = i.call(this, l);
return p || (l !== "OES_vertex_array_object" ? null : (r.__OESVertexArrayObject || (this.__OESVertexArrayObject = new _c(this)), this.__OESVertexArrayObject));
};
}
const d_ = "OES_element_index", g_ = "WEBGL_draw_buffers", Xb = "EXT_disjoint_timer_query", qb = "EXT_disjoint_timer_query_webgl2", Wb = "EXT_texture_filter_anisotropic", A_ = "WEBGL_debug_renderer_info", Zb = 35723, Jb = 4352, $b = 36795, tC = 34047, eC = 37445, iC = 37446, qi = (r) => oi(r) ? void 0 : 0, nC = {
3074: (r) => oi(r) ? void 0 : 36064,
[Zb]: (r) => oi(r) ? void 0 : Jb,
35977: qi,
32937: qi,
[$b]: (r, t) => {
const i = oi(r) ? r.getExtension(qb) : r.getExtension(Xb);
return i && i.GPU_DISJOINT_EXT ? t(i.GPU_DISJOINT_EXT) : 0;
},
[eC]: (r, t) => {
const i = r.getExtension(A_);
return t(i && i.UNMASKED_VENDOR_WEBGL || 7936);
},
[iC]: (r, t) => {
const i = r.getExtension(A_);
return t(i && i.UNMASKED_RENDERER_WEBGL || 7937);
},
[tC]: (r, t) => {
const i = r.luma.extensions[Wb];
return i ? t(i.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1;
},
32883: qi,
35071: qi,
37447: qi,
36063: (r, t) => {
if (!oi(r)) {
const i = r.getExtension(g_);
return i ? t(i.MAX_COLOR_ATTACHMENTS_WEBGL) : 0;
}
},
35379: qi,
35374: qi,
35377: qi,
34852: (r) => {
if (!oi(r)) {
const t = r.getExtension(g_);
return t ? t.MAX_DRAW_BUFFERS_WEBGL : 0;
}
},
36203: (r) => r.getExtension(d_) ? 2147483647 : 65535,
33001: (r) => r.getExtension(d_) ? 16777216 : 65535,
33e3: (r) => 16777216,
37157: qi,
35373: qi,
35657: qi,
36183: qi,
37137: qi,
34045: qi,
35978: qi,
35979: qi,
35968: qi,
35376: qi,
35375: qi,
35659: qi,
37154: qi,
35371: qi,
35658: qi,
35076: qi,
35077: qi,
35380: qi
};
function rC(r, t, i) {
const o = nC[i], l = typeof o == "function" ? o(r, t, i) : o;
return l !== void 0 ? l : t(i);
}
const oC = "OES_vertex_array_object", Sx = "ANGLE_instanced_arrays", sC = "WEBGL_draw_buffers", aC = "EXT_disjoint_timer_query", lC = "EXT_texture_filter_anisotropic", cC = "VertexArray requires WebGL2 or OES_vertex_array_object extension";
function uC(r, t) {
return {
webgl2: oi(r),
ext: r.getExtension(t)
};
}
const Bx = {
[oC]: {
meta: {
suffix: "OES"
},
createVertexArray: () => {
Vr(!1, cC);
},
deleteVertexArray: () => {
},
bindVertexArray: () => {
},
isVertexArray: () => !1
},
[Sx]: {
meta: {
suffix: "ANGLE"
},
vertexAttribDivisor(r, t) {
Vr(t === 0, "WebGL instanced rendering not supported");
},
drawElementsInstanced: () => {
},
drawArraysInstanced: () => {
}
},
[sC]: {
meta: {
suffix: "WEBGL"
},
drawBuffers: () => {
Vr(!1);
}
},
[aC]: {
meta: {
suffix: "EXT"
},
createQuery: () => {
Vr(!1);
},
deleteQuery: () => {
Vr(!1);
},
beginQuery: () => {
Vr(!1);
},
endQuery: () => {
},
getQuery(r, t) {
return this.getQueryObject(r, t);
},
getQueryParameter(r, t) {
return this.getQueryObject(r, t);
},
getQueryObject: () => {
}
}
}, eA = {
readBuffer: (r, t, i) => {
oi(r) && t(i);
},
getVertexAttrib: (r, t, i, o) => {
const {
webgl2: l,
ext: p
} = uC(r, Sx);
let a;
switch (o) {
case 35069:
a = l ? void 0 : !1;
break;
case 35070:
a = !l && !p ? 0 : void 0;
break;
}
return a !== void 0 ? a : t(i, o);
},
getProgramParameter: (r, t, i, o) => {
if (!oi(r))
switch (o) {
case 35967:
return 35981;
case 35971:
return 0;
case 35382:
return 0;
}
return t(i, o);
},
getInternalformatParameter: (r, t, i, o, l) => {
if (!oi(r))
switch (l) {
case 32937:
return new Int32Array([0]);
}
return r.getInternalformatParameter(i, o, l);
},
getTexParameter(r, t, i, o) {
switch (o) {
case 34046:
const {
extensions: l
} = r.luma, p = l[lC];
o = p && p.TEXTURE_MAX_ANISOTROPY_EXT || 34046;
break;
}
return t(i, o);
},
getParameter: rC,
hint(r, t, i, o) {
return t(i, o);
}
};
function Wh(r) {
r.luma = r.luma || {};
const {
luma: t
} = r;
return t.polyfilled || (Yb(r), hC(r), pC(r, Bx), fC(r, {
target: t,
target2: r
}), t.polyfilled = !0), r;
}
globalThis.polyfillContext = Wh;
function hC(r) {
r.luma.extensions = {};
const t = r.getSupportedExtensions() || [];
for (const i of t)
r.luma[i] = r.getExtension(i);
}
function fC(r, t) {
let {
target: i,
target2: o
} = t;
Object.keys(eA).forEach((l) => {
if (typeof eA[l] == "function") {
const p = r[l] ? r[l].bind(r) : () => {
}, a = eA[l].bind(null, r, p);
i[l] = a, o[l] = a;
}
});
}
function pC(r, t) {
for (const i of Object.getOwnPropertyNames(t))
i !== "overrides" && dC(r, {
extension: i,
target: r.luma,
target2: r
});
}
function dC(r, t) {
let {
extension: i,
target: o,
target2: l
} = t;
const p = Bx[i];
Vr(p);
const {
meta: a = {}
} = p, {
suffix: E = ""
} = a, I = r.getExtension(i);
for (const M of Object.keys(p)) {
const P = "".concat(M).concat(E);
let O = null;
M === "meta" || typeof r[M] == "function" || (I && typeof I[P] == "function" ? O = function() {
return I[P](...arguments);
} : typeof p[M] == "function" && (O = p[M].bind(o))), O && (o[M] = O, l[M] = O);
}
}
const Pm = {
3042: !1,
32773: new Float32Array([0, 0, 0, 0]),
32777: 32774,
34877: 32774,
32969: 1,
32968: 0,
32971: 1,
32970: 0,
3106: new Float32Array([0, 0, 0, 0]),
3107: [!0, !0, !0, !0],
2884: !1,
2885: 1029,
2929: !1,
2931: 1,
2932: 513,
2928: new Float32Array([0, 1]),
2930: !0,
3024: !0,
36006: null,
2886: 2305,
33170: 4352,
2849: 1,
32823: !1,
32824: 0,
10752: 0,
32938: 1,
32939: !1,
3089: !1,
3088: new Int32Array([0, 0, 1024, 1024]),
2960: !1,
2961: 0,
2968: 4294967295,
36005: 4294967295,
2962: 519,
2967: 0,
2963: 4294967295,
34816: 519,
36003: 0,
36004: 4294967295,
2964: 7680,
2965: 7680,
2966: 7680,
34817: 7680,
34818: 7680,
34819: 7680,
2978: [0, 0, 1024, 1024],
3333: 4,
3317: 4,
37440: !1,
37441: !1,
37443: 37444,
35723: 4352,
36010: null,
35977: !1,
3330: 0,
3332: 0,
3331: 0,
3314: 0,
32878: 0,
3316: 0,
3315: 0,
32877: 0
}, gl = (r, t, i) => t ? r.enable(i) : r.disable(i), m_ = (r, t, i) => r.hint(i, t), Mo = (r, t, i) => r.pixelStorei(i, t), gC = (r, t) => {
const i = oi(r) ? 36009 : 36160;
return r.bindFramebuffer(i, t);
}, AC = (r, t) => r.bindFramebuffer(36008, t);
function Nh(r) {
return Array.isArray(r) || ArrayBuffer.isView(r);
}
const mC = {
3042: gl,
32773: (r, t) => r.blendColor(...t),
32777: "blendEquation",
34877: "blendEquation",
32969: "blendFunc",
32968: "blendFunc",
32971: "blendFunc",
32970: "blendFunc",
3106: (r, t) => r.clearColor(...t),
3107: (r, t) => r.colorMask(...t),
2884: gl,
2885: (r, t) => r.cullFace(t),
2929: gl,
2931: (r, t) => r.clearDepth(t),
2932: (r, t) => r.depthFunc(t),
2928: (r, t) => r.depthRange(...t),
2930: (r, t) => r.depthMask(t),
3024: gl,
35723: m_,
36006: gC,
2886: (r, t) => r.frontFace(t),
33170: m_,
2849: (r, t) => r.lineWidth(t),
32823: gl,
32824: "polygonOffset",
10752: "polygonOffset",
35977: gl,
32938: "sampleCoverage",
32939: "sampleCoverage",
3089: gl,
3088: (r, t) => r.scissor(...t),
2960: gl,
2961: (r, t) => r.clearStencil(t),
2968: (r, t) => r.stencilMaskSeparate(1028, t),
36005: (r, t) => r.stencilMaskSeparate(1029, t),
2962: "stencilFuncFront",
2967: "stencilFuncFront",
2963: "stencilFuncFront",
34816: "stencilFuncBack",
36003: "stencilFuncBack",
36004: "stencilFuncBack",
2964: "stencilOpFront",
2965: "stencilOpFront",
2966: "stencilOpFront",
34817: "stencilOpBack",
34818: "stencilOpBack",
34819: "stencilOpBack",
2978: (r, t) => r.viewport(...t),
3333: Mo,
3317: Mo,
37440: Mo,
37441: Mo,
37443: Mo,
3330: Mo,
3332: Mo,
3331: Mo,
36010: AC,
3314: Mo,
32878: Mo,
3316: Mo,
3315: Mo,
32877: Mo,
framebuffer: (r, t) => {
const i = t && "handle" in t ? t.handle : t;
return r.bindFramebuffer(36160, i);
},
blend: (r, t) => t ? r.enable(3042) : r.disable(3042),
blendColor: (r, t) => r.blendColor(...t),
blendEquation: (r, t) => {
t = Nh(t) ? t : [t, t], r.blendEquationSeparate(...t);
},
blendFunc: (r, t) => {
t = Nh(t) && t.length === 2 ? [...t, ...t] : t, r.blendFuncSeparate(...t);
},
clearColor: (r, t) => r.clearColor(...t),
clearDepth: (r, t) => r.clearDepth(t),
clearStencil: (r, t) => r.clearStencil(t),
colorMask: (r, t) => r.colorMask(...t),
cull: (r, t) => t ? r.enable(2884) : r.disable(2884),
cullFace: (r, t) => r.cullFace(t),
depthTest: (r, t) => t ? r.enable(2929) : r.disable(2929),
depthFunc: (r, t) => r.depthFunc(t),
depthMask: (r, t) => r.depthMask(t),
depthRange: (r, t) => r.depthRange(...t),
dither: (r, t) => t ? r.enable(3024) : r.disable(3024),
derivativeHint: (r, t) => {
r.hint(35723, t);
},
frontFace: (r, t) => r.frontFace(t),
mipmapHint: (r, t) => r.hint(33170, t),
lineWidth: (r, t) => r.lineWidth(t),
polygonOffsetFill: (r, t) => t ? r.enable(32823) : r.disable(32823),
polygonOffset: (r, t) => r.polygonOffset(...t),
sampleCoverage: (r, t) => r.sampleCoverage(...t),
scissorTest: (r, t) => t ? r.enable(3089) : r.disable(3089),
scissor: (r, t) => r.scissor(...t),
stencilTest: (r, t) => t ? r.enable(2960) : r.disable(2960),
stencilMask: (r, t) => {
t = Nh(t) ? t : [t, t];
const [i, o] = t;
r.stencilMaskSeparate(1028, i), r.stencilMaskSeparate(1029, o);
},
stencilFunc: (r, t) => {
t = Nh(t) && t.length === 3 ? [...t, ...t] : t;
const [i, o, l, p, a, E] = t;
r.stencilFuncSeparate(1028, i, o, l), r.stencilFuncSeparate(1029, p, a, E);
},
stencilOp: (r, t) => {
t = Nh(t) && t.length === 3 ? [...t, ...t] : t;
const [i, o, l, p, a, E] = t;
r.stencilOpSeparate(1028, i, o, l), r.stencilOpSeparate(1029, p, a, E);
},
viewport: (r, t) => r.viewport(...t)
};
function En(r, t, i) {
return t[r] !== void 0 ? t[r] : i[r];
}
const yC = {
blendEquation: (r, t, i) => r.blendEquationSeparate(En(32777, t, i), En(34877, t, i)),
blendFunc: (r, t, i) => r.blendFuncSeparate(En(32969, t, i), En(32968, t, i), En(32971, t, i), En(32970, t, i)),
polygonOffset: (r, t, i) => r.polygonOffset(En(32824, t, i), En(10752, t, i)),
sampleCoverage: (r, t, i) => r.sampleCoverage(En(32938, t, i), En(32939, t, i)),
stencilFuncFront: (r, t, i) => r.stencilFuncSeparate(1028, En(2962, t, i), En(2967, t, i), En(2963, t, i)),
stencilFuncBack: (r, t, i) => r.stencilFuncSeparate(1029, En(34816, t, i), En(36003, t, i), En(36004, t, i)),
stencilOpFront: (r, t, i) => r.stencilOpSeparate(1028, En(2964, t, i), En(2965, t, i), En(2966, t, i)),
stencilOpBack: (r, t, i) => r.stencilOpSeparate(1029, En(34817, t, i), En(34818, t, i), En(34819, t, i))
}, y_ = {
enable: (r, t) => r({
[t]: !0
}),
disable: (r, t) => r({
[t]: !1
}),
pixelStorei: (r, t, i) => r({
[t]: i
}),
hint: (r, t, i) => r({
[t]: i
}),
bindFramebuffer: (r, t, i) => {
switch (t) {
case 36160:
return r({
36006: i,
36010: i
});
case 36009:
return r({
36006: i
});
case 36008:
return r({
36010: i
});
default:
return null;
}
},
blendColor: (r, t, i, o, l) => r({
32773: new Float32Array([t, i, o, l])
}),
blendEquation: (r, t) => r({
32777: t,
34877: t
}),
blendEquationSeparate: (r, t, i) => r({
32777: t,
34877: i
}),
blendFunc: (r, t, i) => r({
32969: t,
32968: i,
32971: t,
32970: i
}),
blendFuncSeparate: (r, t, i, o, l) => r({
32969: t,
32968: i,
32971: o,
32970: l
}),
clearColor: (r, t, i, o, l) => r({
3106: new Float32Array([t, i, o, l])
}),
clearDepth: (r, t) => r({
2931: t
}),
clearStencil: (r, t) => r({
2961: t
}),
colorMask: (r, t, i, o, l) => r({
3107: [t, i, o, l]
}),
cullFace: (r, t) => r({
2885: t
}),
depthFunc: (r, t) => r({
2932: t
}),
depthRange: (r, t, i) => r({
2928: new Float32Array([t, i])
}),
depthMask: (r, t) => r({
2930: t
}),
frontFace: (r, t) => r({
2886: t
}),
lineWidth: (r, t) => r({
2849: t
}),
polygonOffset: (r, t, i) => r({
32824: t,
10752: i
}),
sampleCoverage: (r, t, i) => r({
32938: t,
32939: i
}),
scissor: (r, t, i, o, l) => r({
3088: new Int32Array([t, i, o, l])
}),
stencilMask: (