@loaders.gl/i3s 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/dist.dev.js

@@ -37,13 +37,6 @@ var __exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // external-global-plugin:@loaders.gl/core
-  var require_core = __commonJS({
-    "external-global-plugin:@loaders.gl/core"(exports, module) {
-      module.exports = globalThis.loaders;
-    }
-  });
-
   // (disabled):../worker-utils/src/lib/node/require-utils.node
   var require_require_utils = __commonJS({
     "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
@@ -51,6 +44,13 @@ var __exports__ = (() => {
     }
   });
 
+  // external-global-plugin:@loaders.gl/core
+  var require_core = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports, module) {
+      module.exports = globalThis.loaders;
+    }
+  });
+
   // ../../node_modules/pako/lib/utils/common.js
   var require_common = __commonJS({
     "../../node_modules/pako/lib/utils/common.js"(exports) {
@@ -4270,142 +4270,22 @@ var __exports__ = (() => {
     I3SLoader: () => I3SLoader,
     I3SNodePageLoader: () => I3SNodePageLoader,
     SLPKLoader: () => SLPKLoader,
+    customizeColors: () => customizeColors,
     loadFeatureAttributes: () => loadFeatureAttributes,
     parseSLPKArchive: () => parseSLPKArchive
   });
 
-  // ../../node_modules/@luma.gl/constants/dist/esm/index.js
-  var esm_default = {
-    DEPTH_BUFFER_BIT: 256,
-    STENCIL_BUFFER_BIT: 1024,
-    COLOR_BUFFER_BIT: 16384,
+  // ../math/src/geometry/constants.ts
+  var GL_PRIMITIVE_MODE = {
     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,
+    TRIANGLE_FAN: 6
+  };
+  var GL_TYPE = {
     BYTE: 5120,
     UNSIGNED_BYTE: 5121,
     SHORT: 5122,
@@ -4413,749 +4293,517 @@ var __exports__ = (() => {
     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
+    DOUBLE: 5130
+  };
+  var GL = {
+    ...GL_PRIMITIVE_MODE,
+    ...GL_TYPE
   };
 
-  // src/lib/parsers/constants.ts
-  function getConstructorForDataFormat(dataType) {
-    switch (dataType) {
-      case "UInt8":
-        return Uint8Array;
-      case "UInt16":
-        return Uint16Array;
-      case "UInt32":
-        return Uint32Array;
-      case "Float32":
-        return Float32Array;
-      case "UInt64":
-        return Float64Array;
-      default:
-        throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
+  // ../loader-utils/src/loader-types.ts
+  async function parseFromContext(data, loaders, options, context) {
+    return context._parse(data, loaders, options, context);
+  }
+
+  // ../loader-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loader assertion failed.");
     }
   }
-  var GL_TYPE_MAP = {
-    UInt8: esm_default.UNSIGNED_BYTE,
-    UInt16: esm_default.UNSIGNED_SHORT,
-    Float32: esm_default.FLOAT,
-    UInt32: esm_default.UNSIGNED_INT,
-    UInt64: esm_default.DOUBLE
+
+  // ../loader-utils/src/lib/env-utils/globals.ts
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
   };
-  function sizeOf(dataType) {
-    switch (dataType) {
-      case "UInt8":
-        return 1;
-      case "UInt16":
-      case "Int16":
-        return 2;
-      case "UInt32":
-      case "Int32":
-      case "Float32":
-        return 4;
-      case "UInt64":
-      case "Int64":
-      case "Float64":
-        return 8;
-      default:
-        throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+  // ../worker-utils/src/lib/env-utils/version.ts
+  var NPM_TAG = "beta";
+  function getVersion() {
+    if (!globalThis._loadersgl_?.version) {
+      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+      if (typeof __VERSION__ === "undefined") {
+        console.warn("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+        globalThis._loadersgl_.version = NPM_TAG;
+      } else {
+        globalThis._loadersgl_.version = __VERSION__;
+      }
     }
+    return globalThis._loadersgl_.version;
   }
-  var STRING_ATTRIBUTE_TYPE = "String";
-  var OBJECT_ID_ATTRIBUTE_TYPE = "Oid32";
-  var FLOAT_64_TYPE = "Float64";
-  var INT_16_ATTRIBUTE_TYPE = "Int16";
-  var COORDINATE_SYSTEM = function(COORDINATE_SYSTEM2) {
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["DEFAULT"] = -1] = "DEFAULT";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["LNGLAT"] = 1] = "LNGLAT";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["METER_OFFSETS"] = 2] = "METER_OFFSETS";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["LNGLAT_OFFSETS"] = 3] = "LNGLAT_OFFSETS";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["CARTESIAN"] = 0] = "CARTESIAN";
-    return COORDINATE_SYSTEM2;
-  }({});
-
-  // src/i3s-loader.ts
-  var import_core20 = __toESM(require_core(), 1);
+  var VERSION = getVersion();
 
-  // src/lib/parsers/parse-i3s-tile-content.ts
-  var import_core7 = __toESM(require_core(), 1);
+  // ../worker-utils/src/lib/env-utils/assert.ts
+  function assert2(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loaders.gl assertion failed.");
+    }
+  }
 
-  // ../../node_modules/@math.gl/core/dist/lib/common.js
-  var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
-  var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-  var DEFAULT_CONFIG = {
-    EPSILON: 1e-12,
-    debug: false,
-    precision: 4,
-    printTypes: false,
-    printDegrees: false,
-    printRowMajor: true,
-    _cartographicRadians: false
+  // ../worker-utils/src/lib/env-utils/globals.ts
+  var globals2 = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
   };
-  globalThis.mathgl = globalThis.mathgl || {
-    config: {
-      ...DEFAULT_CONFIG
+  var self_2 = globals2.self || globals2.window || globals2.global || {};
+  var window_2 = globals2.window || globals2.self || globals2.global || {};
+  var global_2 = globals2.global || globals2.self || globals2.window || {};
+  var document_2 = globals2.document || {};
+  var isBrowser2 = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+  var isWorker = typeof importScripts === "function";
+  var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+  var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
+
+  // ../worker-utils/src/lib/library-utils/library-utils.ts
+  var node = __toESM(require_require_utils(), 1);
+  var loadLibraryPromises = {};
+  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
+    if (moduleName) {
+      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
     }
-  };
-  var config = globalThis.mathgl.config;
-  function formatValue(value, {
-    precision = config.precision
-  } = {}) {
-    value = round(value);
-    return "".concat(parseFloat(value.toPrecision(precision)));
-  }
-  function isArray(value) {
-    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
-  }
-  function toRadians(degrees2) {
-    return radians(degrees2);
-  }
-  function toDegrees(radians2) {
-    return degrees(radians2);
-  }
-  function radians(degrees2, result) {
-    return map(degrees2, (degrees3) => degrees3 * DEGREES_TO_RADIANS, result);
+    loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+    return await loadLibraryPromises[libraryUrl];
   }
-  function degrees(radians2, result) {
-    return map(radians2, (radians3) => radians3 * RADIANS_TO_DEGREES, result);
+  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    if (!options.useLocalLibraries && library.startsWith("http")) {
+      return library;
+    }
+    libraryName = libraryName || library;
+    const modules = options.modules || {};
+    if (modules[libraryName]) {
+      return modules[libraryName];
+    }
+    if (!isBrowser2) {
+      return `modules/${moduleName}/dist/libs/${libraryName}`;
+    }
+    if (options.CDN) {
+      assert2(options.CDN.startsWith("http"));
+      return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
+    }
+    if (isWorker) {
+      return `../src/libs/${libraryName}`;
+    }
+    return `modules/${moduleName}/src/libs/${libraryName}`;
   }
-  function equals(a2, b, epsilon) {
-    const oldEpsilon = config.EPSILON;
-    if (epsilon) {
-      config.EPSILON = epsilon;
+  async function loadLibraryFromFile(libraryUrl) {
+    if (libraryUrl.endsWith("wasm")) {
+      return await loadAsArrayBuffer(libraryUrl);
     }
-    try {
-      if (a2 === b) {
-        return true;
-      }
-      if (isArray(a2) && isArray(b)) {
-        if (a2.length !== b.length) {
-          return false;
-        }
-        for (let i2 = 0; i2 < a2.length; ++i2) {
-          if (!equals(a2[i2], b[i2])) {
-            return false;
-          }
-        }
-        return true;
-      }
-      if (a2 && a2.equals) {
-        return a2.equals(b);
-      }
-      if (b && b.equals) {
-        return b.equals(a2);
-      }
-      if (typeof a2 === "number" && typeof b === "number") {
-        return Math.abs(a2 - b) <= config.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b));
+    if (!isBrowser2) {
+      try {
+        return node && void 0 && await (void 0)(libraryUrl);
+      } catch (error) {
+        console.error(error);
+        return null;
       }
-      return false;
-    } finally {
-      config.EPSILON = oldEpsilon;
     }
+    if (isWorker) {
+      return importScripts(libraryUrl);
+    }
+    const scriptSource = await loadAsText(libraryUrl);
+    return loadLibraryFromString(scriptSource, libraryUrl);
   }
-  function round(value) {
-    return Math.round(value / config.EPSILON) * config.EPSILON;
-  }
-  function duplicateArray(array) {
-    return array.clone ? array.clone() : new Array(array.length);
-  }
-  function map(value, func, result) {
-    if (isArray(value)) {
-      const array = value;
-      result = result || duplicateArray(array);
-      for (let i2 = 0; i2 < result.length && i2 < array.length; ++i2) {
-        const val = typeof value === "number" ? value : value[i2];
-        result[i2] = func(val, i2, result);
-      }
-      return result;
+  function loadLibraryFromString(scriptSource, id) {
+    if (!isBrowser2) {
+      return void 0 && (void 0)(scriptSource, id);
     }
-    return func(value);
+    if (isWorker) {
+      eval.call(globalThis, scriptSource);
+      return null;
+    }
+    const script = document.createElement("script");
+    script.id = id;
+    try {
+      script.appendChild(document.createTextNode(scriptSource));
+    } catch (e2) {
+      script.text = scriptSource;
+    }
+    document.body.appendChild(script);
+    return null;
+  }
+  async function loadAsArrayBuffer(url) {
+    if (!void 0 || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.arrayBuffer();
+    }
+    return await (void 0)(url);
+  }
+  async function loadAsText(url) {
+    if (!void 0 || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.text();
+    }
+    return await (void 0)(url);
   }
 
-  // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  function _extendableBuiltin(cls) {
-    function ExtendableBuiltin() {
-      var instance = Reflect.construct(cls, Array.from(arguments));
-      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-      return instance;
+  // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
+  function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
+    byteLength = byteLength || arrayBuffer1.byteLength;
+    if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
+      return false;
     }
-    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-      constructor: {
-        value: cls,
-        enumerable: false,
-        writable: true,
-        configurable: true
+    const array1 = new Uint8Array(arrayBuffer1);
+    const array2 = new Uint8Array(arrayBuffer2);
+    for (let i2 = 0; i2 < array1.length; ++i2) {
+      if (array1[i2] !== array2[i2]) {
+        return false;
       }
-    });
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(ExtendableBuiltin, cls);
-    } else {
-      ExtendableBuiltin.__proto__ = cls;
     }
-    return ExtendableBuiltin;
+    return true;
   }
-  var MathArray = class extends _extendableBuiltin(Array) {
-    clone() {
-      return new this.constructor().copy(this);
+  function concatenateArrayBuffers(...sources) {
+    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+    const byteLength = sourceArrays.reduce((length4, typedArray) => length4 + typedArray.byteLength, 0);
+    const result = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const sourceArray of sourceArrays) {
+      result.set(sourceArray, offset);
+      offset += sourceArray.byteLength;
     }
-    fromArray(array, offset = 0) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] = array[i2 + offset];
-      }
-      return this.check();
+    return result.buffer;
+  }
+
+  // ../loader-utils/src/lib/iterators/async-iteration.ts
+  async function concatenateArrayBuffersAsync(asyncIterator) {
+    const arrayBuffers = [];
+    for await (const chunk of asyncIterator) {
+      arrayBuffers.push(chunk);
     }
-    toArray(targetArray = [], offset = 0) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        targetArray[offset + i2] = this[i2];
-      }
-      return targetArray;
+    return concatenateArrayBuffers(...arrayBuffers);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
     }
-    toObject(targetObject) {
-      return targetObject;
+    return (hint === "string" ? String : Number)(input);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
     }
-    from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+    return obj;
+  }
+
+  // ../loader-utils/src/lib/node/buffer.browser.ts
+  function toArrayBuffer(buffer) {
+    return buffer;
+  }
+
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function isBuffer(value) {
+    return value && typeof value === "object" && value.isBuffer;
+  }
+  function toArrayBuffer2(data) {
+    if (isBuffer(data)) {
+      return toArrayBuffer(data);
     }
-    to(arrayOrObject) {
-      if (arrayOrObject === this) {
-        return this;
+    if (data instanceof ArrayBuffer) {
+      return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return data.buffer;
       }
-      return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
+      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
     }
-    toTarget(target) {
-      return target ? this.to(target) : this;
+    if (typeof data === "string") {
+      const text = data;
+      const uint8Array = new TextEncoder().encode(text);
+      return uint8Array.buffer;
     }
-    toFloat32Array() {
-      return new Float32Array(this);
+    if (data && typeof data === "object" && data._toArrayBuffer) {
+      return data._toArrayBuffer();
     }
-    toString() {
-      return this.formatString(config);
+    throw new Error("toArrayBuffer");
+  }
+
+  // ../loader-utils/src/lib/node/promisify.ts
+  function promisify1(fn) {
+    return (args) => new Promise((resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
+  }
+
+  // ../loader-utils/src/lib/file-provider/data-view-file.ts
+  var toNumber = (bigint) => {
+    if (bigint > Number.MAX_SAFE_INTEGER) {
+      throw new Error("Offset is out of bounds");
     }
-    formatString(opts) {
-      let string = "";
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        string += (i2 > 0 ? ", " : "") + formatValue(this[i2], opts);
-      }
-      return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
+    return Number(bigint);
+  };
+  var DataViewFile = class {
+    constructor(file) {
+      this.file = file;
     }
-    equals(array) {
-      if (!array || this.length !== array.length) {
-        return false;
-      }
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        if (!equals(this[i2], array[i2])) {
-          return false;
-        }
-      }
-      return true;
+    async destroy() {
     }
-    exactEquals(array) {
-      if (!array || this.length !== array.length) {
-        return false;
-      }
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        if (this[i2] !== array[i2]) {
-          return false;
-        }
-      }
-      return true;
+    async getUint8(offset) {
+      return this.file.getUint8(toNumber(offset));
     }
-    negate() {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] = -this[i2];
-      }
-      return this.check();
+    async getUint16(offset) {
+      return this.file.getUint16(toNumber(offset), true);
     }
-    lerp(a2, b, t2) {
-      if (t2 === void 0) {
-        return this.lerp(this, a2, b);
-      }
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        const ai = a2[i2];
-        const endValue = typeof b === "number" ? b : b[i2];
-        this[i2] = ai + t2 * (endValue - ai);
-      }
-      return this.check();
+    async getUint32(offset) {
+      return this.file.getUint32(toNumber(offset), true);
     }
-    min(vector) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] = Math.min(vector[i2], this[i2]);
-      }
-      return this.check();
+    async getBigUint64(offset) {
+      return this.file.getBigUint64(toNumber(offset), true);
+    }
+    async slice(startOffset, endOffset) {
+      return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
+    }
+    get length() {
+      return BigInt(this.file.byteLength);
+    }
+  };
+
+  // ../../node_modules/@math.gl/core/dist/lib/common.js
+  var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
+  var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
+  var DEFAULT_CONFIG = {
+    EPSILON: 1e-12,
+    debug: false,
+    precision: 4,
+    printTypes: false,
+    printDegrees: false,
+    printRowMajor: true,
+    _cartographicRadians: false
+  };
+  globalThis.mathgl = globalThis.mathgl || {
+    config: {
+      ...DEFAULT_CONFIG
+    }
+  };
+  var config = globalThis.mathgl.config;
+  function formatValue(value, {
+    precision = config.precision
+  } = {}) {
+    value = round(value);
+    return "".concat(parseFloat(value.toPrecision(precision)));
+  }
+  function isArray(value) {
+    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  function toRadians(degrees2) {
+    return radians(degrees2);
+  }
+  function toDegrees(radians2) {
+    return degrees(radians2);
+  }
+  function radians(degrees2, result) {
+    return map(degrees2, (degrees3) => degrees3 * DEGREES_TO_RADIANS, result);
+  }
+  function degrees(radians2, result) {
+    return map(radians2, (radians3) => radians3 * RADIANS_TO_DEGREES, result);
+  }
+  function equals(a2, b, epsilon) {
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+      config.EPSILON = epsilon;
+    }
+    try {
+      if (a2 === b) {
+        return true;
+      }
+      if (isArray(a2) && isArray(b)) {
+        if (a2.length !== b.length) {
+          return false;
+        }
+        for (let i2 = 0; i2 < a2.length; ++i2) {
+          if (!equals(a2[i2], b[i2])) {
+            return false;
+          }
+        }
+        return true;
+      }
+      if (a2 && a2.equals) {
+        return a2.equals(b);
+      }
+      if (b && b.equals) {
+        return b.equals(a2);
+      }
+      if (typeof a2 === "number" && typeof b === "number") {
+        return Math.abs(a2 - b) <= config.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b));
+      }
+      return false;
+    } finally {
+      config.EPSILON = oldEpsilon;
+    }
+  }
+  function round(value) {
+    return Math.round(value / config.EPSILON) * config.EPSILON;
+  }
+  function duplicateArray(array) {
+    return array.clone ? array.clone() : new Array(array.length);
+  }
+  function map(value, func, result) {
+    if (isArray(value)) {
+      const array = value;
+      result = result || duplicateArray(array);
+      for (let i2 = 0; i2 < result.length && i2 < array.length; ++i2) {
+        const val = typeof value === "number" ? value : value[i2];
+        result[i2] = func(val, i2, result);
+      }
+      return result;
+    }
+    return func(value);
+  }
+
+  // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
+  function _extendableBuiltin(cls) {
+    function ExtendableBuiltin() {
+      var instance = Reflect.construct(cls, Array.from(arguments));
+      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+      return instance;
+    }
+    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+      constructor: {
+        value: cls,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(ExtendableBuiltin, cls);
+    } else {
+      ExtendableBuiltin.__proto__ = cls;
+    }
+    return ExtendableBuiltin;
+  }
+  var MathArray = class extends _extendableBuiltin(Array) {
+    clone() {
+      return new this.constructor().copy(this);
+    }
+    fromArray(array, offset = 0) {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        this[i2] = array[i2 + offset];
+      }
+      return this.check();
+    }
+    toArray(targetArray = [], offset = 0) {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        targetArray[offset + i2] = this[i2];
+      }
+      return targetArray;
+    }
+    toObject(targetObject) {
+      return targetObject;
+    }
+    from(arrayOrObject) {
+      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+    }
+    to(arrayOrObject) {
+      if (arrayOrObject === this) {
+        return this;
+      }
+      return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
+    }
+    toTarget(target) {
+      return target ? this.to(target) : this;
+    }
+    toFloat32Array() {
+      return new Float32Array(this);
+    }
+    toString() {
+      return this.formatString(config);
+    }
+    formatString(opts) {
+      let string = "";
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        string += (i2 > 0 ? ", " : "") + formatValue(this[i2], opts);
+      }
+      return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
+    }
+    equals(array) {
+      if (!array || this.length !== array.length) {
+        return false;
+      }
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        if (!equals(this[i2], array[i2])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    exactEquals(array) {
+      if (!array || this.length !== array.length) {
+        return false;
+      }
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        if (this[i2] !== array[i2]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    negate() {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        this[i2] = -this[i2];
+      }
+      return this.check();
+    }
+    lerp(a2, b, t2) {
+      if (t2 === void 0) {
+        return this.lerp(this, a2, b);
+      }
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        const ai = a2[i2];
+        const endValue = typeof b === "number" ? b : b[i2];
+        this[i2] = ai + t2 * (endValue - ai);
+      }
+      return this.check();
+    }
+    min(vector) {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        this[i2] = Math.min(vector[i2], this[i2]);
+      }
+      return this.check();
     }
     max(vector) {
       for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
@@ -5280,7 +4928,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
-  function assert(condition, message) {
+  function assert3(condition, message) {
     if (!condition) {
       throw new Error("math.gl assertion ".concat(message));
     }
@@ -5369,11 +5017,11 @@ var __exports__ = (() => {
       return this.distanceSquared(vector);
     }
     getComponent(i2) {
-      assert(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+      assert3(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
       return checkNumber(this[i2]);
     }
     setComponent(i2, value) {
-      assert(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+      assert3(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
       this[i2] = value;
       return this.check();
     }
@@ -5425,7 +5073,7 @@ var __exports__ = (() => {
     out[1] = m[1] * x + m[5] * y + m[13];
     return out;
   }
-  var forEach = function() {
+  var forEach2 = function() {
     const vec = create();
     return function(a2, stride, offset, count, fn, arg) {
       let i2;
@@ -5518,7 +5166,7 @@ var __exports__ = (() => {
     equals: () => equals2,
     exactEquals: () => exactEquals,
     floor: () => floor,
-    forEach: () => forEach2,
+    forEach: () => forEach3,
     fromValues: () => fromValues,
     hermite: () => hermite,
     inverse: () => inverse,
@@ -5897,7 +5545,7 @@ var __exports__ = (() => {
   var sqrDist = squaredDistance;
   var len = length;
   var sqrLen = squaredLength;
-  var forEach2 = function() {
+  var forEach3 = function() {
     const vec = create2();
     return function(a2, stride, offset, count, fn, arg) {
       let i2;
@@ -8121,7 +7769,7 @@ var __exports__ = (() => {
     out[3] = a2[3];
     return out;
   }
-  var forEach3 = function() {
+  var forEach4 = function() {
     const vec = create5();
     return function(a2, stride, offset, count, fn, arg) {
       let i2;
@@ -8990,52 +8638,6 @@ var __exports__ = (() => {
     }
   };
 
-  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
-  function _typeof(obj) {
-    "@babel/helpers - typeof";
-    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
-      return typeof obj2;
-    } : function(obj2) {
-      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-    }, _typeof(obj);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
-  function _toPrimitive(input, hint) {
-    if (_typeof(input) !== "object" || input === null)
-      return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== void 0) {
-      var res = prim.call(input, hint || "default");
-      if (_typeof(res) !== "object")
-        return res;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
-    }
-    return (hint === "string" ? String : Number)(input);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
-  function _toPropertyKey(arg) {
-    var key = _toPrimitive(arg, "string");
-    return _typeof(key) === "symbol" ? key : String(key);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
-  function _defineProperty(obj, key, value) {
-    key = _toPropertyKey(key);
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-    return obj;
-  }
-
   // ../../node_modules/@math.gl/core/dist/lib/math-utils.js
   var math_utils_exports = {};
   __export(math_utils_exports, {
@@ -9089,6 +8691,68 @@ var __exports__ = (() => {
   var PI_OVER_SIX = Math.PI / 6;
   var TWO_PI = Math.PI * 2;
 
+  // src/lib/parsers/constants.ts
+  function getConstructorForDataFormat(dataType) {
+    switch (dataType) {
+      case "UInt8":
+        return Uint8Array;
+      case "UInt16":
+        return Uint16Array;
+      case "UInt32":
+        return Uint32Array;
+      case "Float32":
+        return Float32Array;
+      case "UInt64":
+        return Float64Array;
+      default:
+        throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
+    }
+  }
+  var GL_TYPE_MAP = {
+    UInt8: GL.UNSIGNED_BYTE,
+    UInt16: GL.UNSIGNED_SHORT,
+    Float32: GL.FLOAT,
+    UInt32: GL.UNSIGNED_INT,
+    UInt64: GL.DOUBLE
+  };
+  function sizeOf(dataType) {
+    switch (dataType) {
+      case "UInt8":
+        return 1;
+      case "UInt16":
+      case "Int16":
+        return 2;
+      case "UInt32":
+      case "Int32":
+      case "Float32":
+        return 4;
+      case "UInt64":
+      case "Int64":
+      case "Float64":
+        return 8;
+      default:
+        throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
+    }
+  }
+  var STRING_ATTRIBUTE_TYPE = "String";
+  var OBJECT_ID_ATTRIBUTE_TYPE = "Oid32";
+  var FLOAT_64_TYPE = "Float64";
+  var INT_16_ATTRIBUTE_TYPE = "Int16";
+  var COORDINATE_SYSTEM = function(COORDINATE_SYSTEM2) {
+    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["DEFAULT"] = -1] = "DEFAULT";
+    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["LNGLAT"] = 1] = "LNGLAT";
+    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["METER_OFFSETS"] = 2] = "METER_OFFSETS";
+    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["LNGLAT_OFFSETS"] = 3] = "LNGLAT_OFFSETS";
+    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["CARTESIAN"] = 0] = "CARTESIAN";
+    return COORDINATE_SYSTEM2;
+  }({});
+
+  // src/i3s-loader.ts
+  var import_core18 = __toESM(require_core(), 1);
+
+  // src/lib/parsers/parse-i3s-tile-content.ts
+  var import_core5 = __toESM(require_core(), 1);
+
   // ../../node_modules/@math.gl/geospatial/dist/constants.js
   var WGS84_RADIUS_X = 6378137;
   var WGS84_RADIUS_Y = 6378137;
@@ -9208,7 +8872,7 @@ var __exports__ = (() => {
   var scratchVector3 = new Vector3();
   function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
     const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
-    assert(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
+    assert3(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
     let firstAxisVector;
     let secondAxisVector;
     let thirdAxisVector;
@@ -9346,9 +9010,9 @@ var __exports__ = (() => {
       _defineProperty(this, "maximumRadius", void 0);
       _defineProperty(this, "centerToleranceSquared", math_utils_exports.EPSILON1);
       _defineProperty(this, "squaredXOverSquaredZ", void 0);
-      assert(x >= 0);
-      assert(y >= 0);
-      assert(z >= 0);
+      assert3(x >= 0);
+      assert3(y >= 0);
+      assert3(z >= 0);
       this.radii = new Vector3(x, y, z);
       this.radiiSquared = new Vector3(x * x, y * y, z * z);
       this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
@@ -9425,280 +9089,24 @@ var __exports__ = (() => {
       const beta = 1 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);
       return scratchPosition.multiplyScalar(beta).to(result);
     }
-    transformPositionToScaledSpace(position, result = [0, 0, 0]) {
-      return scratchPosition.from(position).scale(this.oneOverRadii).to(result);
-    }
-    transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
-      return scratchPosition.from(position).scale(this.radii).to(result);
-    }
-    getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
-      assert(equals(this.radii.x, this.radii.y, math_utils_exports.EPSILON15));
-      assert(this.radii.z > 0);
-      scratchPosition.from(position);
-      const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
-      if (Math.abs(z) >= this.radii.z - buffer) {
-        return void 0;
-      }
-      return scratchPosition.set(0, 0, z).to(result);
-    }
-  };
-  _defineProperty(Ellipsoid, "WGS84", new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z));
-
-  // ../loader-utils/src/loader-types.ts
-  async function parseFromContext(data, loaders, options, context) {
-    return context._parse(data, loaders, options, context);
-  }
-
-  // ../loader-utils/src/lib/env-utils/assert.ts
-  function assert2(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
-  }
-
-  // ../loader-utils/src/lib/env-utils/globals.ts
-  var globals = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global,
-    document: typeof document !== "undefined" && document
-  };
-  var self_ = globals.self || globals.window || globals.global || {};
-  var window_ = globals.window || globals.self || globals.global || {};
-  var global_ = globals.global || globals.self || globals.window || {};
-  var document_ = globals.document || {};
-  var isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
-  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-  var nodeVersion = matches && parseFloat(matches[1]) || 0;
-
-  // ../worker-utils/src/lib/env-utils/version.ts
-  var NPM_TAG = "beta";
-  function getVersion() {
-    if (!globalThis._loadersgl_?.version) {
-      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-      if (typeof __VERSION__ === "undefined") {
-        console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
-        globalThis._loadersgl_.version = NPM_TAG;
-      } else {
-        globalThis._loadersgl_.version = __VERSION__;
-      }
-    }
-    return globalThis._loadersgl_.version;
-  }
-  var VERSION = getVersion();
-
-  // ../worker-utils/src/lib/env-utils/assert.ts
-  function assert3(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loaders.gl assertion failed.");
-    }
-  }
-
-  // ../worker-utils/src/lib/env-utils/globals.ts
-  var globals2 = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global,
-    document: typeof document !== "undefined" && document
-  };
-  var self_2 = globals2.self || globals2.window || globals2.global || {};
-  var window_2 = globals2.window || globals2.self || globals2.global || {};
-  var global_2 = globals2.global || globals2.self || globals2.window || {};
-  var document_2 = globals2.document || {};
-  var isBrowser2 = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
-  var isWorker = typeof importScripts === "function";
-  var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
-  var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-  var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
-
-  // ../worker-utils/src/lib/library-utils/library-utils.ts
-  var node = __toESM(require_require_utils(), 1);
-  var loadLibraryPromises = {};
-  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
-    if (moduleName) {
-      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
-    }
-    loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
-    return await loadLibraryPromises[libraryUrl];
-  }
-  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
-    if (!options.useLocalLibraries && library.startsWith("http")) {
-      return library;
-    }
-    libraryName = libraryName || library;
-    const modules = options.modules || {};
-    if (modules[libraryName]) {
-      return modules[libraryName];
-    }
-    if (!isBrowser2) {
-      return `modules/${moduleName}/dist/libs/${libraryName}`;
-    }
-    if (options.CDN) {
-      assert3(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
-    }
-    if (isWorker) {
-      return `../src/libs/${libraryName}`;
-    }
-    return `modules/${moduleName}/src/libs/${libraryName}`;
-  }
-  async function loadLibraryFromFile(libraryUrl) {
-    if (libraryUrl.endsWith("wasm")) {
-      return await loadAsArrayBuffer(libraryUrl);
-    }
-    if (!isBrowser2) {
-      try {
-        return node && void 0 && await (void 0)(libraryUrl);
-      } catch (error) {
-        console.error(error);
-        return null;
-      }
-    }
-    if (isWorker) {
-      return importScripts(libraryUrl);
-    }
-    const scriptSource = await loadAsText(libraryUrl);
-    return loadLibraryFromString(scriptSource, libraryUrl);
-  }
-  function loadLibraryFromString(scriptSource, id) {
-    if (!isBrowser2) {
-      return void 0 && (void 0)(scriptSource, id);
-    }
-    if (isWorker) {
-      eval.call(globalThis, scriptSource);
-      return null;
-    }
-    const script = document.createElement("script");
-    script.id = id;
-    try {
-      script.appendChild(document.createTextNode(scriptSource));
-    } catch (e2) {
-      script.text = scriptSource;
-    }
-    document.body.appendChild(script);
-    return null;
-  }
-  async function loadAsArrayBuffer(url) {
-    if (!void 0 || url.startsWith("http")) {
-      const response = await fetch(url);
-      return await response.arrayBuffer();
-    }
-    return await (void 0)(url);
-  }
-  async function loadAsText(url) {
-    if (!void 0 || url.startsWith("http")) {
-      const response = await fetch(url);
-      return await response.text();
-    }
-    return await (void 0)(url);
-  }
-
-  // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
-  function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
-    byteLength = byteLength || arrayBuffer1.byteLength;
-    if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
-      return false;
-    }
-    const array1 = new Uint8Array(arrayBuffer1);
-    const array2 = new Uint8Array(arrayBuffer2);
-    for (let i2 = 0; i2 < array1.length; ++i2) {
-      if (array1[i2] !== array2[i2]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  function concatenateArrayBuffers(...sources) {
-    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
-    const byteLength = sourceArrays.reduce((length4, typedArray) => length4 + typedArray.byteLength, 0);
-    const result = new Uint8Array(byteLength);
-    let offset = 0;
-    for (const sourceArray of sourceArrays) {
-      result.set(sourceArray, offset);
-      offset += sourceArray.byteLength;
-    }
-    return result.buffer;
-  }
-
-  // ../loader-utils/src/lib/iterators/async-iteration.ts
-  async function concatenateArrayBuffersAsync(asyncIterator) {
-    const arrayBuffers = [];
-    for await (const chunk of asyncIterator) {
-      arrayBuffers.push(chunk);
-    }
-    return concatenateArrayBuffers(...arrayBuffers);
-  }
-
-  // ../loader-utils/src/lib/node/buffer.browser.ts
-  function toArrayBuffer(buffer) {
-    return buffer;
-  }
-
-  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
-  function isBuffer(value) {
-    return value && typeof value === "object" && value.isBuffer;
-  }
-  function toArrayBuffer2(data) {
-    if (isBuffer(data)) {
-      return toArrayBuffer(data);
-    }
-    if (data instanceof ArrayBuffer) {
-      return data;
-    }
-    if (ArrayBuffer.isView(data)) {
-      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-        return data.buffer;
-      }
-      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-    }
-    if (typeof data === "string") {
-      const text = data;
-      const uint8Array = new TextEncoder().encode(text);
-      return uint8Array.buffer;
-    }
-    if (data && typeof data === "object" && data._toArrayBuffer) {
-      return data._toArrayBuffer();
-    }
-    throw new Error("toArrayBuffer");
-  }
-
-  // ../loader-utils/src/lib/node/promisify.ts
-  function promisify1(fn) {
-    return (args) => new Promise((resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
-  }
-
-  // ../loader-utils/src/lib/file-provider/data-view-file.ts
-  var toNumber = (bigint) => {
-    if (bigint > Number.MAX_SAFE_INTEGER) {
-      throw new Error("Offset is out of bounds");
-    }
-    return Number(bigint);
-  };
-  var DataViewFile = class {
-    constructor(file) {
-      this.file = file;
-    }
-    async destroy() {
-    }
-    async getUint8(offset) {
-      return this.file.getUint8(toNumber(offset));
-    }
-    async getUint16(offset) {
-      return this.file.getUint16(toNumber(offset), true);
-    }
-    async getUint32(offset) {
-      return this.file.getUint32(toNumber(offset), true);
-    }
-    async getBigUint64(offset) {
-      return this.file.getBigUint64(toNumber(offset), true);
+    transformPositionToScaledSpace(position, result = [0, 0, 0]) {
+      return scratchPosition.from(position).scale(this.oneOverRadii).to(result);
     }
-    async slice(startOffset, endOffset) {
-      return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
+    transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
+      return scratchPosition.from(position).scale(this.radii).to(result);
     }
-    get length() {
-      return BigInt(this.file.byteLength);
+    getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
+      assert3(equals(this.radii.x, this.radii.y, math_utils_exports.EPSILON15));
+      assert3(this.radii.z > 0);
+      scratchPosition.from(position);
+      const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
+      if (Math.abs(z) >= this.radii.z - buffer) {
+        return void 0;
+      }
+      return scratchPosition.set(0, 0, z).to(result);
     }
   };
+  _defineProperty(Ellipsoid, "WGS84", new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z));
 
   // ../images/src/lib/utils/version.ts
   var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
@@ -10022,7 +9430,7 @@ var __exports__ = (() => {
       mimeType
     } = getBinaryImageMetadata(arrayBuffer) || {};
     const parseImageNode2 = globalThis.loaders?.parseImageNode;
-    assert2(parseImageNode2);
+    assert(parseImageNode2);
     return await parseImageNode2(arrayBuffer, mimeType);
   }
 
@@ -10047,7 +9455,7 @@ var __exports__ = (() => {
         image = await parseToNodeImage(arrayBuffer, options);
         break;
       default:
-        assert2(false);
+        assert(false);
     }
     if (imageType === "data") {
       image = getImageData(image);
@@ -11367,11 +10775,11 @@ var __exports__ = (() => {
   function parseDDS(data) {
     const header = new Int32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
     const pixelFormatNumber = header[DDS_CONSTANTS.HEADER_PF_FOURCC_INDEX];
-    assert2(Boolean(header[DDS_CONSTANTS.HEADER_PF_FLAGS_INDEX] & DDS_CONSTANTS.DDPF_FOURCC), "DDS: Unsupported format, must contain a FourCC code");
+    assert(Boolean(header[DDS_CONSTANTS.HEADER_PF_FLAGS_INDEX] & DDS_CONSTANTS.DDPF_FOURCC), "DDS: Unsupported format, must contain a FourCC code");
     const fourCC = int32ToFourCC(pixelFormatNumber);
     const internalFormat = DDS_PIXEL_FORMATS[fourCC];
     const sizeFunction = DDS_SIZE_FUNCTIONS[fourCC];
-    assert2(internalFormat && sizeFunction, `DDS: Unknown pixel format ${pixelFormatNumber}`);
+    assert(internalFormat && sizeFunction, `DDS: Unknown pixel format ${pixelFormatNumber}`);
     let mipMapLevels = 1;
     if (header[DDS_CONSTANTS.HEADER_FLAGS_INDEX] & DDS_CONSTANTS.DDSD_MIPMAPCOUNT) {
       mipMapLevels = Math.max(1, header[DDS_CONSTANTS.MIPMAPCOUNT_INDEX]);
@@ -11638,272 +11046,11 @@ var __exports__ = (() => {
     const {
       attributeStorageInfo = []
     } = tileset;
-    for (let index = 0; index < attributeStorageInfo.length; index++) {
-      const fileName = attributeStorageInfo[index].key;
-      attributeUrls.push(`${url}/nodes/${resource}/attributes/${fileName}/0`);
-    }
-    return attributeUrls;
-  }
-
-  // src/lib/utils/customize-сolors.ts
-  var import_core6 = __toESM(require_core(), 1);
-
-  // src/i3s-attribute-loader.ts
-  var import_core5 = __toESM(require_core(), 1);
-
-  // src/lib/parsers/parse-i3s-attribute.ts
-  function parseI3STileAttribute(arrayBuffer, options) {
-    const {
-      attributeName,
-      attributeType
-    } = options;
-    if (!attributeName) {
-      return {};
-    }
-    return {
-      [attributeName]: attributeType ? parseAttribute(attributeType, arrayBuffer) : null
-    };
-  }
-  function parseAttribute(attributeType, arrayBuffer) {
-    switch (attributeType) {
-      case STRING_ATTRIBUTE_TYPE:
-        return parseStringsAttribute(arrayBuffer);
-      case OBJECT_ID_ATTRIBUTE_TYPE:
-        return parseShortNumberAttribute(arrayBuffer);
-      case FLOAT_64_TYPE:
-        return parseFloatAttribute(arrayBuffer);
-      case INT_16_ATTRIBUTE_TYPE:
-        return parseInt16ShortNumberAttribute(arrayBuffer);
-      default:
-        return parseShortNumberAttribute(arrayBuffer);
-    }
-  }
-  function parseShortNumberAttribute(arrayBuffer) {
-    const countOffset = 4;
-    return new Uint32Array(arrayBuffer, countOffset);
-  }
-  function parseInt16ShortNumberAttribute(arrayBuffer) {
-    const countOffset = 4;
-    return new Int16Array(arrayBuffer, countOffset);
-  }
-  function parseFloatAttribute(arrayBuffer) {
-    const countOffset = 8;
-    return new Float64Array(arrayBuffer, countOffset);
-  }
-  function parseStringsAttribute(arrayBuffer) {
-    const stringsCountOffset = 0;
-    const dataOffset = 8;
-    const bytesPerStringSize = 4;
-    const stringsArray = [];
-    try {
-      const stringsCount = new DataView(arrayBuffer, stringsCountOffset, bytesPerStringSize).getUint32(stringsCountOffset, true);
-      const stringSizes = new Uint32Array(arrayBuffer, dataOffset, stringsCount);
-      let stringOffset = dataOffset + stringsCount * bytesPerStringSize;
-      for (const stringByteSize of stringSizes) {
-        const textDecoder = new TextDecoder("utf-8");
-        const stringAttribute = new Uint8Array(arrayBuffer, stringOffset, stringByteSize);
-        stringsArray.push(textDecoder.decode(stringAttribute));
-        stringOffset += stringByteSize;
-      }
-    } catch (error) {
-      console.error("Parse string attribute error: ", error.message);
-    }
-    return stringsArray;
-  }
-
-  // src/i3s-attribute-loader.ts
-  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var EMPTY_VALUE = "";
-  var REJECTED_STATUS = "rejected";
-  var I3SAttributeLoader = {
-    name: "I3S Attribute",
-    id: "i3s-attribute",
-    module: "i3s",
-    version: VERSION5,
-    mimeTypes: ["application/binary"],
-    parse: async (arrayBuffer, options) => parseI3STileAttribute(arrayBuffer, options),
-    extensions: ["bin"],
-    options: {},
-    binary: true
-  };
-  async function loadFeatureAttributes(tile, featureId, options = {}) {
-    const {
-      attributeStorageInfo,
-      attributeUrls,
-      tilesetFields
-    } = getAttributesData(tile);
-    if (!attributeStorageInfo || !attributeUrls || featureId < 0) {
-      return null;
-    }
-    let attributes = [];
-    const attributeLoadPromises = [];
-    for (let index = 0; index < attributeStorageInfo.length; index++) {
-      const url = getUrlWithToken(attributeUrls[index], options.i3s?.token);
-      const attributeName = attributeStorageInfo[index].name;
-      const attributeType = getAttributeValueType(attributeStorageInfo[index]);
-      const loadOptions = {
-        ...options,
-        attributeName,
-        attributeType
-      };
-      const promise = (0, import_core5.load)(url, I3SAttributeLoader, loadOptions);
-      attributeLoadPromises.push(promise);
-    }
-    try {
-      attributes = await Promise.allSettled(attributeLoadPromises);
-    } catch (error) {
-    }
-    if (!attributes.length) {
-      return null;
-    }
-    return generateAttributesByFeatureId(attributes, attributeStorageInfo, featureId, tilesetFields);
-  }
-  function getAttributesData(tile) {
-    const attributeStorageInfo = tile.tileset?.tileset?.attributeStorageInfo;
-    const attributeUrls = tile.header?.attributeUrls;
-    const tilesetFields = tile.tileset?.tileset?.fields || [];
-    return {
-      attributeStorageInfo,
-      attributeUrls,
-      tilesetFields
-    };
-  }
-  function getAttributeValueType(attribute) {
-    if (attribute.hasOwnProperty("objectIds")) {
-      return "Oid32";
-    } else if (attribute.hasOwnProperty("attributeValues")) {
-      return attribute.attributeValues.valueType;
-    }
-    return "";
-  }
-  function getFeatureIdsAttributeName(attributeStorageInfo) {
-    const objectIdsAttribute = attributeStorageInfo.find((attribute) => attribute.name.includes("OBJECTID"));
-    return objectIdsAttribute?.name;
-  }
-  function generateAttributesByFeatureId(attributes, attributeStorageInfo, featureId, tilesetFields) {
-    const objectIdsAttributeName = getFeatureIdsAttributeName(attributeStorageInfo);
-    const objectIds = attributes.find((attribute) => attribute.value[objectIdsAttributeName]);
-    if (!objectIds) {
-      return null;
-    }
-    const attributeIndex = objectIds.value[objectIdsAttributeName].indexOf(featureId);
-    if (attributeIndex < 0) {
-      return null;
-    }
-    return getFeatureAttributesByIndex(attributes, attributeIndex, attributeStorageInfo, tilesetFields);
-  }
-  function getFeatureAttributesByIndex(attributes, featureIdIndex, attributeStorageInfo, tilesetFields) {
-    const attributesObject = {};
-    for (let index = 0; index < attributeStorageInfo.length; index++) {
-      const attributeName = attributeStorageInfo[index].name;
-      const codedValues = getAttributeCodedValues(attributeName, tilesetFields);
-      const attribute = getAttributeByIndexAndAttributeName(attributes, index, attributeName);
-      attributesObject[attributeName] = formatAttributeValue(attribute, featureIdIndex, codedValues);
-    }
-    return attributesObject;
-  }
-  function getAttributeCodedValues(attributeName, tilesetFields) {
-    const attributeField = tilesetFields.find((field) => field.name === attributeName || field.alias === attributeName);
-    return attributeField?.domain?.codedValues || [];
-  }
-  function getAttributeByIndexAndAttributeName(attributes, index, attributesName) {
-    const attributeObject = attributes[index];
-    if (attributeObject.status === REJECTED_STATUS) {
-      return null;
-    }
-    return attributeObject.value[attributesName];
-  }
-  function formatAttributeValue(attribute, featureIdIndex, codedValues) {
-    let value = EMPTY_VALUE;
-    if (attribute && featureIdIndex in attribute) {
-      value = String(attribute[featureIdIndex]).replace(/\u0000|NaN/g, "").trim();
-    }
-    if (codedValues.length) {
-      const codeValue = codedValues.find((codedValue) => codedValue.code === Number(value));
-      value = codeValue?.name || EMPTY_VALUE;
-    }
-    return value;
-  }
-
-  // src/lib/utils/customize-сolors.ts
-  async function customizeColors(colors, featureIds, tileOptions, tilesetOptions, options) {
-    if (!options?.i3s?.colorsByAttribute) {
-      return colors;
-    }
-    const colorizeAttributeField = tilesetOptions.fields.find(({
-      name
-    }) => name === options?.i3s?.colorsByAttribute?.attributeName);
-    if (!colorizeAttributeField || !["esriFieldTypeDouble", "esriFieldTypeInteger", "esriFieldTypeSmallInteger"].includes(colorizeAttributeField.type)) {
-      return colors;
-    }
-    const colorizeAttributeData = await loadFeatureAttributeData(colorizeAttributeField.name, tileOptions, tilesetOptions, options);
-    if (!colorizeAttributeData) {
-      return colors;
-    }
-    const objectIdField = tilesetOptions.fields.find(({
-      type
-    }) => type === "esriFieldTypeOID");
-    if (!objectIdField) {
-      return colors;
-    }
-    const objectIdAttributeData = await loadFeatureAttributeData(objectIdField.name, tileOptions, tilesetOptions, options);
-    if (!objectIdAttributeData) {
-      return colors;
-    }
-    const attributeValuesMap = {};
-    for (let i2 = 0; i2 < objectIdAttributeData[objectIdField.name].length; i2++) {
-      attributeValuesMap[objectIdAttributeData[objectIdField.name][i2]] = calculateColorForAttribute(colorizeAttributeData[colorizeAttributeField.name][i2], options);
-    }
-    for (let i2 = 0; i2 < featureIds.value.length; i2++) {
-      const color = attributeValuesMap[featureIds.value[i2]];
-      if (!color) {
-        continue;
-      }
-      if (options.i3s.colorsByAttribute.mode === "multiply") {
-        color.forEach((colorItem, index) => {
-          colors.value[i2 * 4 + index] = colors.value[i2 * 4 + index] * colorItem / 255;
-        });
-      } else {
-        colors.value.set(color, i2 * 4);
-      }
-    }
-    return colors;
-  }
-  function calculateColorForAttribute(attributeValue, options) {
-    if (!options?.i3s?.colorsByAttribute) {
-      return [255, 255, 255, 255];
-    }
-    const {
-      minValue,
-      maxValue,
-      minColor,
-      maxColor
-    } = options.i3s.colorsByAttribute;
-    const rate = (attributeValue - minValue) / (maxValue - minValue);
-    const color = [255, 255, 255, 255];
-    for (let i2 = 0; i2 < minColor.length; i2++) {
-      color[i2] = Math.round((maxColor[i2] - minColor[i2]) * rate + minColor[i2]);
-    }
-    return color;
-  }
-  async function loadFeatureAttributeData(attributeName, {
-    attributeUrls
-  }, {
-    attributeStorageInfo
-  }, options) {
-    const attributeIndex = attributeStorageInfo.findIndex(({
-      name
-    }) => attributeName === name);
-    if (attributeIndex === -1) {
-      return null;
-    }
-    const objectIdAttributeUrl = getUrlWithToken(attributeUrls[attributeIndex], options?.i3s?.token);
-    const attributeType = getAttributeValueType(attributeStorageInfo[attributeIndex]);
-    const objectIdAttributeData = await (0, import_core6.load)(objectIdAttributeUrl, I3SAttributeLoader, {
-      attributeName,
-      attributeType
-    });
-    return objectIdAttributeData;
+    for (let index = 0; index < attributeStorageInfo.length; index++) {
+      const fileName = attributeStorageInfo[index].key;
+      attributeUrls.push(`${url}/nodes/${resource}/attributes/${fileName}/0`);
+    }
+    return attributeUrls;
   }
 
   // src/lib/parsers/parse-i3s-tile-content.ts
@@ -11936,8 +11083,8 @@ var __exports__ = (() => {
     if (tileOptions.textureUrl) {
       const url = getUrlWithToken(tileOptions.textureUrl, options?.i3s?.token);
       const loader = getLoaderForTextureFormat(tileOptions.textureFormat);
-      const fetch2 = context?.fetch;
-      const response = await fetch2(url);
+      const fetchFunc = context?.fetch || fetch;
+      const response = await fetchFunc(url);
       const arrayBuffer2 = await response.arrayBuffer();
       if (options?.i3s.decodeTextures) {
         if (loader === ImageLoader) {
@@ -11951,11 +11098,11 @@ var __exports__ = (() => {
             const texture = await parseFromContext(arrayBuffer2, [], options2, context);
             content.texture = texture;
           } catch (e2) {
-            const texture = await (0, import_core7.parse)(arrayBuffer2, loader, options2, context);
+            const texture = await (0, import_core5.parse)(arrayBuffer2, loader, options2, context);
             content.texture = texture;
           }
         } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
-          let texture = await (0, import_core7.load)(arrayBuffer2, loader, tileOptions.textureLoaderOptions);
+          let texture = await (0, import_core5.load)(arrayBuffer2, loader, tileOptions.textureLoaderOptions);
           if (loader === BasisLoader) {
             texture = texture[0];
           }
@@ -11985,7 +11132,7 @@ var __exports__ = (() => {
     let featureCount = 0;
     let indices;
     if (tileOptions.isDracoGeometry) {
-      const decompressedGeometry = await (0, import_core7.parse)(arrayBuffer, DracoLoader2, {
+      const decompressedGeometry = await (0, import_core5.parse)(arrayBuffer, DracoLoader2, {
         draco: {
           attributeNameEntry: I3S_ATTRIBUTE_TYPE
         }
@@ -12042,7 +11189,6 @@ var __exports__ = (() => {
       content.modelMatrix = getModelMatrix(attributes.position);
       content.coordinateSystem = COORDINATE_SYSTEM.LNGLAT_OFFSETS;
     }
-    attributes.color = await customizeColors(attributes.color, attributes.id, tileOptions, tilesetOptions, options);
     content.attributes = {
       positions: attributes.position,
       normals: attributes.normal,
@@ -12329,13 +11475,13 @@ var __exports__ = (() => {
   }
 
   // src/i3s-content-loader.ts
-  var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
   var I3SContentLoader = {
     name: "I3S Content (Indexed Scene Layers)",
     id: "i3s-content",
     module: "i3s",
     worker: true,
-    version: VERSION6,
+    version: VERSION5,
     mimeTypes: ["application/octet-stream"],
     parse: parse3,
     extensions: ["bin"],
@@ -12654,7 +11800,7 @@ var __exports__ = (() => {
       this.fromNormalDistance(normal, distance2);
     }
     fromNormalDistance(normal, distance2) {
-      assert(Number.isFinite(distance2));
+      assert3(Number.isFinite(distance2));
       this.normal.from(normal).normalize();
       this.distance = distance2;
       return this;
@@ -12668,7 +11814,7 @@ var __exports__ = (() => {
     }
     fromCoefficients(a2, b, c2, d) {
       this.normal.set(a2, b, c2);
-      assert(equals(this.normal.len(), 1));
+      assert3(equals(this.normal.len(), 1));
       this.distance = d;
       return this;
     }
@@ -12742,7 +11888,7 @@ var __exports__ = (() => {
       return intersect;
     }
     computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {
-      assert(Number.isFinite(parentPlaneMask), "parentPlaneMask is required.");
+      assert3(Number.isFinite(parentPlaneMask), "parentPlaneMask is required.");
       if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {
         return parentPlaneMask;
       }
@@ -12809,7 +11955,7 @@ var __exports__ = (() => {
   };
 
   // src/lib/parsers/parse-i3s.ts
-  var import_core19 = __toESM(require_core(), 1);
+  var import_core17 = __toESM(require_core(), 1);
 
   // ../tiles/src/constants.ts
   var TILE_REFINEMENT = function(TILE_REFINEMENT2) {
@@ -12836,15 +11982,15 @@ var __exports__ = (() => {
   }({});
 
   // src/lib/helpers/i3s-nodepages-tiles.ts
-  var import_core18 = __toESM(require_core(), 1);
+  var import_core16 = __toESM(require_core(), 1);
 
   // src/i3s-node-page-loader.ts
-  var VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var I3SNodePageLoader = {
     name: "I3S Node Page",
     id: "i3s-node-page",
     module: "i3s",
-    version: VERSION7,
+    version: VERSION6,
     mimeTypes: ["application/json"],
     parse: parseNodePage,
     extensions: ["json"],
@@ -12879,7 +12025,7 @@ var __exports__ = (() => {
         const nodePageUrl = getUrlWithToken(`${this.url}/nodepages/${pageIndex}`, this.options.i3s?.token);
         this.pendingNodePages[pageIndex] = {
           status: "Pending",
-          promise: (0, import_core18.load)(nodePageUrl, I3SNodePageLoader, this.options)
+          promise: (0, import_core16.load)(nodePageUrl, I3SNodePageLoader, this.options)
         };
         this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
         this.nodesInNodePages += this.nodePages[pageIndex].nodes.length;
@@ -13105,7 +12251,7 @@ var __exports__ = (() => {
     } else {
       const parseOptions = options.i3s;
       const rootNodeUrl = getUrlWithToken(`${url}/nodes/root`, parseOptions.token);
-      root = await (0, import_core19.load)(rootNodeUrl, I3SLoader, {
+      root = await (0, import_core17.load)(rootNodeUrl, I3SLoader, {
         ...options,
         i3s: {
           ...options.i3s,
@@ -13129,7 +12275,7 @@ var __exports__ = (() => {
   }
 
   // src/i3s-loader.ts
-  var VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var TILESET_REGEX = /layers\/[0-9]+$/;
   var TILE_HEADER_REGEX = /nodes\/([0-9-]+|root)$/;
   var SLPK_HEX = "504b0304";
@@ -13138,7 +12284,7 @@ var __exports__ = (() => {
     name: "I3S (Indexed Scene Layers)",
     id: "i3s",
     module: "i3s",
-    version: VERSION8,
+    version: VERSION7,
     mimeTypes: ["application/octet-stream"],
     parse: parseI3S,
     extensions: ["bin"],
@@ -13154,8 +12300,7 @@ var __exports__ = (() => {
         useDracoGeometry: true,
         useCompressedTextures: true,
         decodeTextures: true,
-        coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS,
-        colorsByAttribute: null
+        coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS
       }
     }
   };
@@ -13189,7 +12334,7 @@ var __exports__ = (() => {
     return data;
   }
   async function parseTileContent(arrayBuffer, options) {
-    return await (0, import_core20.parse)(arrayBuffer, I3SContentLoader, options);
+    return await (0, import_core18.parse)(arrayBuffer, I3SContentLoader, options);
   }
   async function parseTileset(data, options, context) {
     const tilesetJson = JSON.parse(new TextDecoder().decode(data));
@@ -14183,12 +13328,12 @@ var __exports__ = (() => {
   }
 
   // src/i3s-slpk-loader.ts
-  var VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var SLPKLoader = {
     name: "I3S SLPK (Scene Layer Package)",
     id: "slpk",
     module: "i3s",
-    version: VERSION9,
+    version: VERSION8,
     mimeTypes: ["application/octet-stream"],
     extensions: ["slpk"],
     options: {},
@@ -14198,6 +13343,183 @@ var __exports__ = (() => {
     }
   };
 
+  // src/i3s-attribute-loader.ts
+  var import_core19 = __toESM(require_core(), 1);
+
+  // src/lib/parsers/parse-i3s-attribute.ts
+  function parseI3STileAttribute(arrayBuffer, options) {
+    const {
+      attributeName,
+      attributeType
+    } = options;
+    if (!attributeName) {
+      return {};
+    }
+    return {
+      [attributeName]: attributeType ? parseAttribute(attributeType, arrayBuffer) : null
+    };
+  }
+  function parseAttribute(attributeType, arrayBuffer) {
+    switch (attributeType) {
+      case STRING_ATTRIBUTE_TYPE:
+        return parseStringsAttribute(arrayBuffer);
+      case OBJECT_ID_ATTRIBUTE_TYPE:
+        return parseShortNumberAttribute(arrayBuffer);
+      case FLOAT_64_TYPE:
+        return parseFloatAttribute(arrayBuffer);
+      case INT_16_ATTRIBUTE_TYPE:
+        return parseInt16ShortNumberAttribute(arrayBuffer);
+      default:
+        return parseShortNumberAttribute(arrayBuffer);
+    }
+  }
+  function parseShortNumberAttribute(arrayBuffer) {
+    const countOffset = 4;
+    return new Uint32Array(arrayBuffer, countOffset);
+  }
+  function parseInt16ShortNumberAttribute(arrayBuffer) {
+    const countOffset = 4;
+    return new Int16Array(arrayBuffer, countOffset);
+  }
+  function parseFloatAttribute(arrayBuffer) {
+    const countOffset = 8;
+    return new Float64Array(arrayBuffer, countOffset);
+  }
+  function parseStringsAttribute(arrayBuffer) {
+    const stringsCountOffset = 0;
+    const dataOffset = 8;
+    const bytesPerStringSize = 4;
+    const stringsArray = [];
+    try {
+      const stringsCount = new DataView(arrayBuffer, stringsCountOffset, bytesPerStringSize).getUint32(stringsCountOffset, true);
+      const stringSizes = new Uint32Array(arrayBuffer, dataOffset, stringsCount);
+      let stringOffset = dataOffset + stringsCount * bytesPerStringSize;
+      for (const stringByteSize of stringSizes) {
+        const textDecoder = new TextDecoder("utf-8");
+        const stringAttribute = new Uint8Array(arrayBuffer, stringOffset, stringByteSize);
+        stringsArray.push(textDecoder.decode(stringAttribute));
+        stringOffset += stringByteSize;
+      }
+    } catch (error) {
+      console.error("Parse string attribute error: ", error.message);
+    }
+    return stringsArray;
+  }
+
+  // src/i3s-attribute-loader.ts
+  var VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var EMPTY_VALUE = "";
+  var REJECTED_STATUS = "rejected";
+  var I3SAttributeLoader = {
+    name: "I3S Attribute",
+    id: "i3s-attribute",
+    module: "i3s",
+    version: VERSION9,
+    mimeTypes: ["application/binary"],
+    parse: async (arrayBuffer, options) => parseI3STileAttribute(arrayBuffer, options),
+    extensions: ["bin"],
+    options: {},
+    binary: true
+  };
+  async function loadFeatureAttributes(tile, featureId, options = {}) {
+    const {
+      attributeStorageInfo,
+      attributeUrls,
+      tilesetFields
+    } = getAttributesData(tile);
+    if (!attributeStorageInfo || !attributeUrls || featureId < 0) {
+      return null;
+    }
+    let attributes = [];
+    const attributeLoadPromises = [];
+    for (let index = 0; index < attributeStorageInfo.length; index++) {
+      const url = getUrlWithToken(attributeUrls[index], options.i3s?.token);
+      const attributeName = attributeStorageInfo[index].name;
+      const attributeType = getAttributeValueType(attributeStorageInfo[index]);
+      const loadOptions = {
+        ...options,
+        attributeName,
+        attributeType
+      };
+      const promise = (0, import_core19.load)(url, I3SAttributeLoader, loadOptions);
+      attributeLoadPromises.push(promise);
+    }
+    try {
+      attributes = await Promise.allSettled(attributeLoadPromises);
+    } catch (error) {
+    }
+    if (!attributes.length) {
+      return null;
+    }
+    return generateAttributesByFeatureId(attributes, attributeStorageInfo, featureId, tilesetFields);
+  }
+  function getAttributesData(tile) {
+    const attributeStorageInfo = tile.tileset?.tileset?.attributeStorageInfo;
+    const attributeUrls = tile.header?.attributeUrls;
+    const tilesetFields = tile.tileset?.tileset?.fields || [];
+    return {
+      attributeStorageInfo,
+      attributeUrls,
+      tilesetFields
+    };
+  }
+  function getAttributeValueType(attribute) {
+    if (attribute.hasOwnProperty("objectIds")) {
+      return "Oid32";
+    } else if (attribute.hasOwnProperty("attributeValues")) {
+      return attribute.attributeValues.valueType;
+    }
+    return "";
+  }
+  function getFeatureIdsAttributeName(attributeStorageInfo) {
+    const objectIdsAttribute = attributeStorageInfo.find((attribute) => attribute.name.includes("OBJECTID"));
+    return objectIdsAttribute?.name;
+  }
+  function generateAttributesByFeatureId(attributes, attributeStorageInfo, featureId, tilesetFields) {
+    const objectIdsAttributeName = getFeatureIdsAttributeName(attributeStorageInfo);
+    const objectIds = attributes.find((attribute) => attribute.value[objectIdsAttributeName]);
+    if (!objectIds) {
+      return null;
+    }
+    const attributeIndex = objectIds.value[objectIdsAttributeName].indexOf(featureId);
+    if (attributeIndex < 0) {
+      return null;
+    }
+    return getFeatureAttributesByIndex(attributes, attributeIndex, attributeStorageInfo, tilesetFields);
+  }
+  function getFeatureAttributesByIndex(attributes, featureIdIndex, attributeStorageInfo, tilesetFields) {
+    const attributesObject = {};
+    for (let index = 0; index < attributeStorageInfo.length; index++) {
+      const attributeName = attributeStorageInfo[index].name;
+      const codedValues = getAttributeCodedValues(attributeName, tilesetFields);
+      const attribute = getAttributeByIndexAndAttributeName(attributes, index, attributeName);
+      attributesObject[attributeName] = formatAttributeValue(attribute, featureIdIndex, codedValues);
+    }
+    return attributesObject;
+  }
+  function getAttributeCodedValues(attributeName, tilesetFields) {
+    const attributeField = tilesetFields.find((field) => field.name === attributeName || field.alias === attributeName);
+    return attributeField?.domain?.codedValues || [];
+  }
+  function getAttributeByIndexAndAttributeName(attributes, index, attributesName) {
+    const attributeObject = attributes[index];
+    if (attributeObject.status === REJECTED_STATUS) {
+      return null;
+    }
+    return attributeObject.value[attributesName];
+  }
+  function formatAttributeValue(attribute, featureIdIndex, codedValues) {
+    let value = EMPTY_VALUE;
+    if (attribute && featureIdIndex in attribute) {
+      value = String(attribute[featureIdIndex]).replace(/\u0000|NaN/g, "").trim();
+    }
+    if (codedValues.length) {
+      const codeValue = codedValues.find((codedValue) => codedValue.code === Number(value));
+      value = codeValue?.name || EMPTY_VALUE;
+    }
+    return value;
+  }
+
   // src/lib/parsers/parse-i3s-building-scene-layer.ts
   var OBJECT_3D_LAYER_TYPE = "3DObject";
   async function parseBuildingSceneLayer(data, url) {
@@ -14257,7 +13579,7 @@ var __exports__ = (() => {
   }
 
   // src/lib/parsers/parse-arcgis-webscene.ts
-  var import_core21 = __toESM(require_core(), 1);
+  var import_core20 = __toESM(require_core(), 1);
   var SUPPORTED_WKID = 4326;
   var ARCGIS_SCENE_SERVER_LAYER_TYPE = "ArcGISSceneServiceLayer";
   var BUILDING_SCENE_LAYER = "BuildingSceneLayer";
@@ -14315,7 +13637,7 @@ var __exports__ = (() => {
   }
   async function checkSupportedIndexCRS(layer) {
     try {
-      const layerJson = await (0, import_core21.load)(layer.url, import_core21.JSONLoader);
+      const layerJson = await (0, import_core20.load)(layer.url, import_core20.JSONLoader);
       const wkid = layerJson?.spatialReference?.wkid;
       if (wkid !== SUPPORTED_WKID) {
         throw new Error(NOT_SUPPORTED_CRS_ERROR);
@@ -14340,6 +13662,88 @@ var __exports__ = (() => {
   async function parse6(data) {
     return parseWebscene(data);
   }
+
+  // src/lib/utils/customize-colors.ts
+  var import_core21 = __toESM(require_core(), 1);
+  async function customizeColors(colors, featureIds, attributeUrls, fields, attributeStorageInfo, colorsByAttribute, token) {
+    if (!colorsByAttribute) {
+      return colors;
+    }
+    const resultColors = {
+      ...colors,
+      value: new Uint8Array(colors.value)
+    };
+    const colorizeAttributeField = fields.find(({
+      name
+    }) => name === colorsByAttribute?.attributeName);
+    if (!colorizeAttributeField || !["esriFieldTypeDouble", "esriFieldTypeInteger", "esriFieldTypeSmallInteger"].includes(colorizeAttributeField.type)) {
+      return colors;
+    }
+    const colorizeAttributeData = await loadFeatureAttributeData(colorizeAttributeField.name, attributeUrls, attributeStorageInfo, token);
+    if (!colorizeAttributeData) {
+      return colors;
+    }
+    const objectIdField = fields.find(({
+      type
+    }) => type === "esriFieldTypeOID");
+    if (!objectIdField) {
+      return colors;
+    }
+    const objectIdAttributeData = await loadFeatureAttributeData(objectIdField.name, attributeUrls, attributeStorageInfo, token);
+    if (!objectIdAttributeData) {
+      return colors;
+    }
+    const attributeValuesMap = {};
+    for (let i2 = 0; i2 < objectIdAttributeData[objectIdField.name].length; i2++) {
+      attributeValuesMap[objectIdAttributeData[objectIdField.name][i2]] = calculateColorForAttribute(colorizeAttributeData[colorizeAttributeField.name][i2], colorsByAttribute);
+    }
+    for (let i2 = 0; i2 < featureIds.length; i2++) {
+      const color = attributeValuesMap[featureIds[i2]];
+      if (!color) {
+        continue;
+      }
+      if (colorsByAttribute.mode === "multiply") {
+        color.forEach((colorItem, index) => {
+          resultColors.value[i2 * 4 + index] = resultColors.value[i2 * 4 + index] * colorItem / 255;
+        });
+      } else {
+        resultColors.value.set(color, i2 * 4);
+      }
+    }
+    return resultColors;
+  }
+  function calculateColorForAttribute(attributeValue, colorsByAttribute) {
+    if (!colorsByAttribute) {
+      return [255, 255, 255, 255];
+    }
+    const {
+      minValue,
+      maxValue,
+      minColor,
+      maxColor
+    } = colorsByAttribute;
+    const rate = (attributeValue - minValue) / (maxValue - minValue);
+    const color = [255, 255, 255, 255];
+    for (let i2 = 0; i2 < minColor.length; i2++) {
+      color[i2] = Math.round((maxColor[i2] - minColor[i2]) * rate + minColor[i2]);
+    }
+    return color;
+  }
+  async function loadFeatureAttributeData(attributeName, attributeUrls, attributeStorageInfo, token) {
+    const attributeIndex = attributeStorageInfo.findIndex(({
+      name
+    }) => attributeName === name);
+    if (attributeIndex === -1) {
+      return null;
+    }
+    const objectIdAttributeUrl = getUrlWithToken(attributeUrls[attributeIndex], token);
+    const attributeType = getAttributeValueType(attributeStorageInfo[attributeIndex]);
+    const objectIdAttributeData = await (0, import_core21.load)(objectIdAttributeUrl, I3SAttributeLoader, {
+      attributeName,
+      attributeType
+    });
+    return objectIdAttributeData;
+  }
   return __toCommonJS(src_exports);
 })();
       return __exports__;