@deck.gl/extensions 9.0.0-alpha.3 → 9.0.0-alpha.5

package/dist/dist.dev.js

@@ -7628,21 +7628,21 @@ varying float dataFilter_value;
     getUniforms: getUniforms64
   };
 
-  // ../../node_modules/@luma.gl/engine/dist/model/model.js
+  // ../../../luma.gl/modules/engine/dist/model/model.js
   var import_core36 = __toESM(require_core2(), 1);
   var import_core37 = __toESM(require_core2(), 1);
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/highlight.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/glsl-utils/highlight.js
   var glsl = (x) => `${x}`;
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/utils/assert.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/utils/assert.js
   function assert17(condition, message2) {
     if (!condition) {
       throw new Error(message2 || "shadertools: assertion failed.");
     }
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/filters/prop-types.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/filters/prop-types.js
   var DEFAULT_PROP_VALIDATORS = {
     number: {
       type: "number",
@@ -7723,7 +7723,7 @@ varying float dataFilter_value;
     return typeof value;
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/module-injectors.js
+  // ../../../luma.gl/modules/shadertools/dist/module-injectors.js
   var MODULE_INJECTORS_VS = glsl`\
 #ifdef MODULE_LOGDEPTH
   logdepth_adjustPosition(gl_Position);
@@ -7752,7 +7752,7 @@ varying float dataFilter_value;
 #endif
 `;
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/shader-injections.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/shader-injections.js
   var MODULE_INJECTORS = {
     vertex: MODULE_INJECTORS_VS,
     fragment: MODULE_INJECTORS_FS
@@ -7844,7 +7844,7 @@ varying float dataFilter_value;
     return source;
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-module/shader-module-instance.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/shader-module/shader-module-instance.js
   var ShaderModuleInstance = class {
     static instantiateModules(modules) {
       return modules.map((module) => {
@@ -7874,7 +7874,7 @@ varying float dataFilter_value;
         vs: vs5,
         fs: fs4,
         dependencies = [],
-        uniforms = {},
+        uniformPropTypes = {},
         getUniforms: getUniforms4,
         deprecations = [],
         defines = {},
@@ -7889,8 +7889,8 @@ varying float dataFilter_value;
       this.deprecations = this._parseDeprecationDefinitions(deprecations);
       this.defines = defines;
       this.injections = normalizeInjections(inject6);
-      if (uniforms) {
-        this.uniforms = makePropValidators(uniforms);
+      if (uniformPropTypes) {
+        this.uniforms = makePropValidators(uniformPropTypes);
       }
     }
     getModuleSource(stage) {
@@ -7962,7 +7962,7 @@ ${moduleSource}// END MODULE_${this.name}
     }
   };
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/resolve-modules.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/resolve-modules.js
   function resolveModules(modules) {
     const instances = ShaderModuleInstance.instantiateModules(modules);
     return getShaderDependencies(instances);
@@ -8006,7 +8006,7 @@ ${moduleSource}// END MODULE_${this.name}
     }
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/platform-defines.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/platform-defines.js
   function getPlatformShaderDefines(platformInfo) {
     switch (platformInfo === null || platformInfo === void 0 ? void 0 : platformInfo.gpu.toLowerCase()) {
       case "apple":
@@ -8106,7 +8106,7 @@ ${moduleSource}// END MODULE_${this.name}
     return versionDefines;
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-transpiler/transpile-glsl-shader.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/shader-transpiler/transpile-glsl-shader.js
   function transpileGLSLShader(source, targetGLSLVersion, stage) {
     switch (targetGLSLVersion) {
       case 300:
@@ -8172,7 +8172,7 @@ ${match}`).replace(new RegExp(`\\b${ES100_FRAGMENT_OUTPUT_NAME}\\b`, "g"), outpu
     return new RegExp(`\\b${qualifier}[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)`, "g");
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/shader-hooks.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/shader-hooks.js
   function getShaderHooks(hookFunctions, hookInjections) {
     let result = "";
     for (const hookName in hookFunctions) {
@@ -8232,7 +8232,7 @@ ${match}`).replace(new RegExp(`\\b${ES100_FRAGMENT_OUTPUT_NAME}\\b`, "g"), outpu
     return result;
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/assemble-shaders.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/assemble-shaders.js
   var INJECT_SHADER_DECLARATIONS = `
 
 ${DECLARATION_INJECT_MARKER}
@@ -8504,7 +8504,7 @@ ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
     return sourceText;
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/select-shaders.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/select-shaders.js
   function selectShaders(platformInfo, props) {
     if (!props.vs) {
       throw new Error("no vertex shader");
@@ -8538,7 +8538,7 @@ ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
     }
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembler.js
+  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembler.js
   var ShaderAssembler = class {
     constructor() {
       this._hookFunctions = [];
@@ -8601,2125 +8601,2128 @@ ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
   };
   ShaderAssembler.defaultShaderAssembler = void 0;
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-utils.js
-  function fp64ify(a) {
-    let out = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
-    let startIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
-    const hiPart = Math.fround(a);
-    const loPart = a - hiPart;
-    out[startIndex] = hiPart;
-    out[startIndex + 1] = loPart;
-    return out;
+  // ../../../luma.gl/modules/engine/dist/geometry/gpu-geometry.js
+  var import_core34 = __toESM(require_core2(), 1);
+  var GPUGeometry = class {
+    constructor(props) {
+      this.id = void 0;
+      this.userData = {};
+      this.topology = void 0;
+      this.bufferLayout = [];
+      this.vertexCount = void 0;
+      this.indices = void 0;
+      this.attributes = void 0;
+      this.id = props.id || (0, import_core34.uid)("geometry");
+      this.topology = props.topology;
+      this.indices = props.indices || null;
+      this.attributes = props.attributes;
+      this.vertexCount = props.vertexCount;
+      this.bufferLayout = props.bufferLayout || [];
+      if (this.indices) {
+        (0, import_core34.assert)(this.indices.usage === import_core34.Buffer.INDEX);
+      }
+    }
+    destroy() {
+      var _this$attributes$colo;
+      this.indices.destroy();
+      this.attributes.positions.destroy();
+      this.attributes.normals.destroy();
+      this.attributes.texCoords.destroy();
+      (_this$attributes$colo = this.attributes.colors) === null || _this$attributes$colo === void 0 ? void 0 : _this$attributes$colo.destroy();
+    }
+    getVertexCount() {
+      return this.vertexCount;
+    }
+    getAttributes() {
+      return this.attributes;
+    }
+    getIndexes() {
+      return this.indices;
+    }
+    _calculateVertexCount(positions) {
+      const vertexCount = positions.byteLength / 12;
+      return vertexCount;
+    }
+  };
+  function makeGPUGeometry(device, geometry) {
+    if (geometry instanceof GPUGeometry) {
+      return geometry;
+    }
+    const indices = getIndexBufferFromGeometry(device, geometry);
+    const {
+      attributes,
+      bufferLayout
+    } = getAttributeBuffersFromGeometry(device, geometry);
+    return new GPUGeometry({
+      topology: geometry.topology || "triangle-list",
+      bufferLayout,
+      vertexCount: geometry.vertexCount,
+      indices,
+      attributes
+    });
   }
-  function fp64LowPart(a) {
-    return a - Math.fround(a);
+  function getIndexBufferFromGeometry(device, geometry) {
+    if (!geometry.indices) {
+      return void 0;
+    }
+    const data = geometry.indices.value;
+    return device.createBuffer({
+      usage: import_core34.Buffer.INDEX,
+      data
+    });
   }
-  function fp64ifyMatrix4(matrix) {
-    const matrixFP64 = new Float32Array(32);
-    for (let i = 0; i < 4; ++i) {
-      for (let j = 0; j < 4; ++j) {
-        const index = i * 4 + j;
-        fp64ify(matrix[j * 4 + i], matrixFP64, index * 2);
+  function getAttributeBuffersFromGeometry(device, geometry) {
+    const bufferLayout = [];
+    const attributes = {};
+    for (const [attributeName, attribute] of Object.entries(geometry.attributes)) {
+      let name = attributeName;
+      switch (attributeName) {
+        case "POSITION":
+          name = "positions";
+          break;
+        case "NORMAL":
+          name = "normals";
+          break;
+        case "TEXCOORD_0":
+          name = "texCoords";
+          break;
       }
+      attributes[name] = device.createBuffer({
+        data: attribute.value,
+        id: `${attributeName}-buffer`
+      });
+      bufferLayout.push({
+        name,
+        format: `float32x${attribute.size}`
+      });
     }
-    return matrixFP64;
+    const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices);
+    return {
+      attributes,
+      bufferLayout,
+      vertexCount
+    };
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-arithmetic.glsl.js
-  var fp64arithmeticShader = glsl`\
-uniform float ONE;
-
-/*
-About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
-
-The purpose of this workaround is to prevent shader compilers from
-optimizing away necessary arithmetic operations by swapping their sequences
-or transform the equation to some 'equivalent' from.
-
-The method is to multiply an artifical variable, ONE, which will be known to
-the compiler to be 1 only at runtime. The whole expression is then represented
-as a polynomial with respective to ONE. In the coefficients of all terms, only one a
-and one b should appear
-
-err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
-*/
-
-// Divide float number to high and low floats to extend fraction bits
-vec2 split(float a) {
-  const float SPLIT = 4097.0;
-  float t = a * SPLIT;
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float a_hi = t * ONE - (t - a);
-  float a_lo = a * ONE - a_hi;
-#else
-  float a_hi = t - (t - a);
-  float a_lo = a - a_hi;
-#endif
-  return vec2(a_hi, a_lo);
-}
-
-// Divide float number again when high float uses too many fraction bits
-vec2 split2(vec2 a) {
-  vec2 b = split(a.x);
-  b.y += a.y;
-  return b;
-}
+  // ../../../luma.gl/modules/engine/dist/lib/pipeline-factory.js
+  var import_core35 = __toESM(require_core2(), 1);
+  var PipelineFactory = class {
+    static getDefaultPipelineFactory(device) {
+      device._lumaData.defaultPipelineFactory = device._lumaData.defaultPipelineFactory || new PipelineFactory(device);
+      return device._lumaData.defaultPipelineFactory;
+    }
+    constructor(device) {
+      this.device = void 0;
+      this._hashCounter = 0;
+      this._hashes = {};
+      this._useCounts = {};
+      this._pipelineCache = {};
+      this.device = device;
+    }
+    createRenderPipeline(options) {
+      const props = {
+        ...PipelineFactory.defaultProps,
+        ...options
+      };
+      const hash = this._hashRenderPipeline({
+        ...props
+      });
+      if (!this._pipelineCache[hash]) {
+        const pipeline = this.device.createRenderPipeline({
+          ...props,
+          vs: this.device.createShader({
+            stage: "vertex",
+            source: props.vs
+          }),
+          fs: props.fs ? this.device.createShader({
+            stage: "fragment",
+            source: props.fs
+          }) : null
+        });
+        pipeline.hash = hash;
+        this._pipelineCache[hash] = pipeline;
+        this._useCounts[hash] = 0;
+      }
+      this._useCounts[hash]++;
+      return this._pipelineCache[hash];
+    }
+    release(pipeline) {
+      const hash = pipeline.hash;
+      this._useCounts[hash]--;
+      if (this._useCounts[hash] === 0) {
+        this._pipelineCache[hash].destroy();
+        delete this._pipelineCache[hash];
+        delete this._useCounts[hash];
+      }
+    }
+    _createRenderPipeline(props) {
+      if (!props.fs) {
+        throw new Error("fs");
+      }
+      const pipeline = this.device.createRenderPipeline({
+        ...props,
+        vs: this.device.createShader({
+          stage: "vertex",
+          source: props.vs
+        }),
+        fs: props.fs ? this.device.createShader({
+          stage: "fragment",
+          source: props.fs
+        }) : null
+      });
+      return pipeline;
+    }
+    _hashRenderPipeline(props) {
+      const vsHash = this._getHash(props.vs);
+      const fsHash = props.fs ? this._getHash(props.fs) : 0;
+      const varyingHash = "-";
+      switch (this.device.info.type) {
+        case "webgpu":
+          const parameterHash = this._getHash(JSON.stringify(props.parameters));
+          const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout));
+          return `${vsHash}/${fsHash}V${varyingHash}T${props.topology}P${parameterHash}BL${bufferLayoutHash}}`;
+        default:
+          return `${vsHash}/${fsHash}V${varyingHash}`;
+      }
+    }
+    _getHash(key) {
+      if (this._hashes[key] === void 0) {
+        this._hashes[key] = this._hashCounter++;
+      }
+      return this._hashes[key];
+    }
+  };
+  PipelineFactory.defaultProps = {
+    ...import_core35.RenderPipeline.defaultProps,
+    vs: void 0,
+    fs: void 0
+  };
 
-// Special sum operation when a > b
-vec2 quickTwoSum(float a, float b) {
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float sum = (a + b) * ONE;
-  float err = b - (sum - a) * ONE;
-#else
-  float sum = a + b;
-  float err = b - (sum - a);
-#endif
-  return vec2(sum, err);
-}
-
-// General sum operation
-vec2 twoSum(float a, float b) {
-  float s = (a + b);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float v = (s * ONE - a) * ONE;
-  float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v);
-#else
-  float v = s - a;
-  float err = (a - (s - v)) + (b - v);
-#endif
-  return vec2(s, err);
-}
-
-vec2 twoSub(float a, float b) {
-  float s = (a - b);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float v = (s * ONE - a) * ONE;
-  float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v);
-#else
-  float v = s - a;
-  float err = (a - (s - v)) - (b + v);
-#endif
-  return vec2(s, err);
-}
-
-vec2 twoSqr(float a) {
-  float prod = a * a;
-  vec2 a_fp64 = split(a);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x *
-    a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE;
-#else
-  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
-#endif
-  return vec2(prod, err);
-}
-
-vec2 twoProd(float a, float b) {
-  float prod = a * b;
-  vec2 a_fp64 = split(a);
-  vec2 b_fp64 = split(b);
-  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
-    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
-  return vec2(prod, err);
-}
-
-vec2 sum_fp64(vec2 a, vec2 b) {
-  vec2 s, t;
-  s = twoSum(a.x, b.x);
-  t = twoSum(a.y, b.y);
-  s.y += t.x;
-  s = quickTwoSum(s.x, s.y);
-  s.y += t.y;
-  s = quickTwoSum(s.x, s.y);
-  return s;
-}
-
-vec2 sub_fp64(vec2 a, vec2 b) {
-  vec2 s, t;
-  s = twoSub(a.x, b.x);
-  t = twoSub(a.y, b.y);
-  s.y += t.x;
-  s = quickTwoSum(s.x, s.y);
-  s.y += t.y;
-  s = quickTwoSum(s.x, s.y);
-  return s;
-}
-
-vec2 mul_fp64(vec2 a, vec2 b) {
-  vec2 prod = twoProd(a.x, b.x);
-  // y component is for the error
-  prod.y += a.x * b.y;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  prod = split2(prod);
-#endif
-  prod = quickTwoSum(prod.x, prod.y);
-  prod.y += a.y * b.x;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  prod = split2(prod);
-#endif
-  prod = quickTwoSum(prod.x, prod.y);
-  return prod;
-}
-
-vec2 div_fp64(vec2 a, vec2 b) {
-  float xn = 1.0 / b.x;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  vec2 yn = mul_fp64(a, vec2(xn, 0));
-#else
-  vec2 yn = a * xn;
-#endif
-  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
-  vec2 prod = twoProd(xn, diff);
-  return sum_fp64(yn, prod);
-}
-
-vec2 sqrt_fp64(vec2 a) {
-  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
-  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
-
-  float x = 1.0 / sqrt(a.x);
-  float yn = a.x * x;
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  vec2 yn_sqr = twoSqr(yn) * ONE;
-#else
-  vec2 yn_sqr = twoSqr(yn);
-#endif
-  float diff = sub_fp64(a, yn_sqr).x;
-  vec2 prod = twoProd(x * 0.5, diff);
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  return sum_fp64(split(yn), prod);
-#else
-  return sum_fp64(vec2(yn, 0.0), prod);
-#endif
-}
-`;
-
-  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-functions.glsl.js
-  var fp64functionShader = glsl`\
-const vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);
-const vec2 LOG2_FP64 = vec2(0.6931471824645996e+00, -1.9046542121259336e-09);
-const vec2 PI_FP64 = vec2(3.1415927410125732, -8.742278012618954e-8);
-const vec2 TWO_PI_FP64 = vec2(6.2831854820251465, -1.7484556025237907e-7);
-const vec2 PI_2_FP64 = vec2(1.5707963705062866, -4.371139006309477e-8);
-const vec2 PI_4_FP64 = vec2(0.7853981852531433, -2.1855695031547384e-8);
-const vec2 PI_16_FP64 = vec2(0.19634954631328583, -5.463923757886846e-9);
-const vec2 PI_16_2_FP64 = vec2(0.39269909262657166, -1.0927847515773692e-8);
-const vec2 PI_16_3_FP64 = vec2(0.5890486240386963, -1.4906100798128818e-9);
-const vec2 PI_180_FP64 = vec2(0.01745329238474369, 1.3519960498364902e-10);
-
-const vec2 SIN_TABLE_0_FP64 = vec2(0.19509032368659973, -1.6704714833615242e-9);
-const vec2 SIN_TABLE_1_FP64 = vec2(0.3826834261417389, 6.22335089017767e-9);
-const vec2 SIN_TABLE_2_FP64 = vec2(0.5555702447891235, -1.1769521357507529e-8);
-const vec2 SIN_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617041793133e-8);
-
-const vec2 COS_TABLE_0_FP64 = vec2(0.9807852506637573, 2.9739473106360492e-8);
-const vec2 COS_TABLE_1_FP64 = vec2(0.9238795042037964, 2.8307490351764386e-8);
-const vec2 COS_TABLE_2_FP64 = vec2(0.8314695954322815, 1.6870263741530778e-8);
-const vec2 COS_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617152815436e-8);
-
-const vec2 INVERSE_FACTORIAL_3_FP64 = vec2(1.666666716337204e-01, -4.967053879312289e-09); // 1/3!
-const vec2 INVERSE_FACTORIAL_4_FP64 = vec2(4.16666679084301e-02, -1.2417634698280722e-09); // 1/4!
-const vec2 INVERSE_FACTORIAL_5_FP64 = vec2(8.333333767950535e-03, -4.34617203337595e-10); // 1/5!
-const vec2 INVERSE_FACTORIAL_6_FP64 = vec2(1.3888889225199819e-03, -3.3631094437103215e-11); // 1/6!
-const vec2 INVERSE_FACTORIAL_7_FP64 = vec2(1.9841270113829523e-04,  -2.725596874933456e-12); // 1/7!
-const vec2 INVERSE_FACTORIAL_8_FP64 = vec2(2.4801587642286904e-05, -3.406996025904184e-13); // 1/8!
-const vec2 INVERSE_FACTORIAL_9_FP64 = vec2(2.75573188446287533e-06, 3.7935713937038186e-14); // 1/9!
-const vec2 INVERSE_FACTORIAL_10_FP64 = vec2(2.755731998149713e-07, -7.575112367869873e-15); // 1/10!
-
-float nint(float d) {
-    if (d == floor(d)) return d;
-    return floor(d + 0.5);
-}
-
-vec2 nint_fp64(vec2 a) {
-    float hi = nint(a.x);
-    float lo;
-    vec2 tmp;
-    if (hi == a.x) {
-        lo = nint(a.y);
-        tmp = quickTwoSum(hi, lo);
-    } else {
-        lo = 0.0;
-        if (abs(hi - a.x) == 0.5 && a.y < 0.0) {
-            hi -= 1.0;
-        }
-        tmp = vec2(hi, lo);
-    }
-    return tmp;
-}
-
-/* k_power controls how much range reduction we would like to have
-Range reduction uses the following method:
-assume a = k_power * r + m * log(2), k and m being integers.
-Set k_power = 4 (we can choose other k to trade accuracy with performance.
-we only need to calculate exp(r) and using exp(a) = 2^m * exp(r)^k_power;
-*/
-
-vec2 exp_fp64(vec2 a) {
-  // We need to make sure these two numbers match
-  // as bit-wise shift is not available in GLSL 1.0
-  const int k_power = 4;
-  const float k = 16.0;
-
-  const float inv_k = 1.0 / k;
-
-  if (a.x <= -88.0) return vec2(0.0, 0.0);
-  if (a.x >= 88.0) return vec2(1.0 / 0.0, 1.0 / 0.0);
-  if (a.x == 0.0 && a.y == 0.0) return vec2(1.0, 0.0);
-  if (a.x == 1.0 && a.y == 0.0) return E_FP64;
-
-  float m = floor(a.x / LOG2_FP64.x + 0.5);
-  vec2 r = sub_fp64(a, mul_fp64(LOG2_FP64, vec2(m, 0.0))) * inv_k;
-  vec2 s, t, p;
-
-  p = mul_fp64(r, r);
-  s = sum_fp64(r, p * 0.5);
-  p = mul_fp64(p, r);
-  t = mul_fp64(p, INVERSE_FACTORIAL_3_FP64);
-
-  s = sum_fp64(s, t);
-  p = mul_fp64(p, r);
-  t = mul_fp64(p, INVERSE_FACTORIAL_4_FP64);
-
-  s = sum_fp64(s, t);
-  p = mul_fp64(p, r);
-  t = mul_fp64(p, INVERSE_FACTORIAL_5_FP64);
-
-  // s = sum_fp64(s, t);
-  // p = mul_fp64(p, r);
-  // t = mul_fp64(p, INVERSE_FACTORIAL_6_FP64);
-
-  // s = sum_fp64(s, t);
-  // p = mul_fp64(p, r);
-  // t = mul_fp64(p, INVERSE_FACTORIAL_7_FP64);
-
-  s = sum_fp64(s, t);
-
-
-  // At this point, s = exp(r) - 1; but after following 4 recursions, we will get exp(r) ^ 512 - 1.
-  for (int i = 0; i < k_power; i++) {
-    s = sum_fp64(s * 2.0, mul_fp64(s, s));
-  }
-
-#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-  s = sum_fp64(s, vec2(ONE, 0.0));
-#else
-  s = sum_fp64(s, vec2(1.0, 0.0));
-#endif
-
-  return s * pow(2.0, m);
-//   return r;
-}
-
-vec2 log_fp64(vec2 a)
-{
-  if (a.x == 1.0 && a.y == 0.0) return vec2(0.0, 0.0);
-  if (a.x <= 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
-  vec2 x = vec2(log(a.x), 0.0);
-  vec2 s;
-#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-  s = vec2(ONE, 0.0);
-#else
-  s = vec2(1.0, 0.0);
-#endif
-
-  x = sub_fp64(sum_fp64(x, mul_fp64(a, exp_fp64(-x))), s);
-  return x;
-}
-
-vec2 sin_taylor_fp64(vec2 a) {
-  vec2 r, s, t, x;
-
-  if (a.x == 0.0 && a.y == 0.0) {
-    return vec2(0.0, 0.0);
-  }
-
-  x = -mul_fp64(a, a);
-  s = a;
-  r = a;
-
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_3_FP64);
-  s = sum_fp64(s, t);
-
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_5_FP64);
-  s = sum_fp64(s, t);
-
-  /* keep the following commented code in case we need them
-  for extra accuracy from the Taylor expansion*/
-
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_7_FP64);
-  // s = sum_fp64(s, t);
-
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_9_FP64);
-  // s = sum_fp64(s, t);
-
-  return s;
-}
-
-vec2 cos_taylor_fp64(vec2 a) {
-  vec2 r, s, t, x;
-
-  if (a.x == 0.0 && a.y == 0.0) {
-    return vec2(1.0, 0.0);
-  }
-
-  x = -mul_fp64(a, a);
-  r = x;
-  s = sum_fp64(vec2(1.0, 0.0), r * 0.5);
-
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_4_FP64);
-  s = sum_fp64(s, t);
-
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_6_FP64);
-  s = sum_fp64(s, t);
-
-  /* keep the following commented code in case we need them
-  for extra accuracy from the Taylor expansion*/
-
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_8_FP64);
-  // s = sum_fp64(s, t);
-
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_10_FP64);
-  // s = sum_fp64(s, t);
-
-  return s;
-}
-
-void sincos_taylor_fp64(vec2 a, out vec2 sin_t, out vec2 cos_t) {
-  if (a.x == 0.0 && a.y == 0.0) {
-    sin_t = vec2(0.0, 0.0);
-    cos_t = vec2(1.0, 0.0);
-  }
-
-  sin_t = sin_taylor_fp64(a);
-  cos_t = sqrt_fp64(sub_fp64(vec2(1.0, 0.0), mul_fp64(sin_t, sin_t)));
-}
-
-vec2 sin_fp64(vec2 a) {
-    if (a.x == 0.0 && a.y == 0.0) {
-        return vec2(0.0, 0.0);
-    }
-
-    // 2pi range reduction
-    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
-    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
-
-    vec2 t;
-    float q = floor(r.x / PI_2_FP64.x + 0.5);
-    int j = int(q);
-
-    if (j < -2 || j > 2) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    }
-
-    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
-
-    q = floor(t.x / PI_16_FP64.x + 0.5);
-    int k = int(q);
-
-    if (k == 0) {
-        if (j == 0) {
-            return sin_taylor_fp64(t);
-        } else if (j == 1) {
-            return cos_taylor_fp64(t);
-        } else if (j == -1) {
-            return -cos_taylor_fp64(t);
-        } else {
-            return -sin_taylor_fp64(t);
-        }
-    }
-
-    int abs_k = int(abs(float(k)));
-
-    if (abs_k > 4) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    } else {
-        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
-    }
-
-    vec2 u = vec2(0.0, 0.0);
-    vec2 v = vec2(0.0, 0.0);
-
-#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-    if (abs(float(abs_k) - 1.0) < 0.5) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs(float(abs_k) - 2.0) < 0.5) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs(float(abs_k) - 3.0) < 0.5) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs(float(abs_k) - 4.0) < 0.5) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
-    }
-#else
-    if (abs_k == 1) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs_k == 2) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs_k == 3) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs_k == 4) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
-    }
-#endif
-
-    vec2 sin_t, cos_t;
-    sincos_taylor_fp64(t, sin_t, cos_t);
-
-
-
-    vec2 result = vec2(0.0, 0.0);
-    if (j == 0) {
-        if (k > 0) {
-            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        }
-    } else if (j == 1) {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        } else {
-            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
-    } else if (j == -1) {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
-        } else {
-            result = -sum_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
-        }
-    } else {
-        if (k > 0) {
-            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
-        }
-    }
-
-    return result;
-}
-
-vec2 cos_fp64(vec2 a) {
-    if (a.x == 0.0 && a.y == 0.0) {
-        return vec2(1.0, 0.0);
+  // ../../../luma.gl/modules/engine/dist/model/model.js
+  var Model = class {
+    constructor(device, props) {
+      this.device = void 0;
+      this.id = void 0;
+      this.vs = void 0;
+      this.fs = void 0;
+      this.pipelineFactory = void 0;
+      this.userData = {};
+      this.parameters = void 0;
+      this.topology = void 0;
+      this.bufferLayout = void 0;
+      this.vertexCount = void 0;
+      this.instanceCount = 0;
+      this.indexBuffer = null;
+      this.bufferAttributes = {};
+      this.constantAttributes = {};
+      this.bindings = {};
+      this.uniforms = {};
+      this.pipeline = void 0;
+      this.vertexArray = void 0;
+      this._pipelineNeedsUpdate = "newly created";
+      this._attributeInfos = {};
+      this._gpuGeometry = null;
+      this._getModuleUniforms = void 0;
+      this.props = void 0;
+      this.props = {
+        ...Model.defaultProps,
+        ...props
+      };
+      props = this.props;
+      this.id = props.id || (0, import_core36.uid)("model");
+      this.device = device;
+      Object.assign(this.userData, props.userData);
+      const platformInfo = {
+        type: device.info.type,
+        shaderLanguage: device.info.shadingLanguages[0],
+        gpu: device.info.gpu,
+        features: device.features
+      };
+      const {
+        vs: vs5,
+        fs: fs4,
+        getUniforms: getUniforms4
+      } = this.props.shaderAssembler.assembleShaders(platformInfo, this.props);
+      this.vs = vs5;
+      this.fs = fs4;
+      this._getModuleUniforms = getUniforms4;
+      this.vertexCount = this.props.vertexCount;
+      this.instanceCount = this.props.instanceCount;
+      this.topology = this.props.topology;
+      this.bufferLayout = this.props.bufferLayout;
+      this.parameters = this.props.parameters;
+      if (props.geometry) {
+        this._gpuGeometry = this.setGeometry(props.geometry);
+      }
+      this.pipelineFactory = props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);
+      this.pipeline = this._updatePipeline();
+      this.vertexArray = device.createVertexArray({
+        renderPipeline: this.pipeline
+      });
+      if (this._gpuGeometry) {
+        this._setGeometryAttributes(this._gpuGeometry);
+      }
+      if (props.vertexCount) {
+        this.setVertexCount(props.vertexCount);
+      }
+      if (props.instanceCount) {
+        this.setInstanceCount(props.instanceCount);
+      }
+      if (props.indices) {
+        throw new Error("Model.props.indices removed. Use props.indexBuffer");
+      }
+      if (props.indexBuffer) {
+        this.setIndexBuffer(props.indexBuffer);
+      }
+      if (props.attributes) {
+        this.setAttributes(props.attributes);
+      }
+      if (props.constantAttributes) {
+        this.setConstantAttributes(props.constantAttributes);
+      }
+      if (props.bindings) {
+        this.setBindings(props.bindings);
+      }
+      if (props.uniforms) {
+        this.setUniforms(props.uniforms);
+      }
+      if (props.moduleSettings) {
+        this.updateModuleSettings(props.moduleSettings);
+      }
+      this.setUniforms(this._getModuleUniforms());
+      Object.seal(this);
     }
-
-    // 2pi range reduction
-    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
-    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
-
-    vec2 t;
-    float q = floor(r.x / PI_2_FP64.x + 0.5);
-    int j = int(q);
-
-    if (j < -2 || j > 2) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    destroy() {
+      this.pipelineFactory.release(this.pipeline);
     }
-
-    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
-
-    q = floor(t.x / PI_16_FP64.x + 0.5);
-    int k = int(q);
-
-    if (k == 0) {
-        if (j == 0) {
-            return cos_taylor_fp64(t);
-        } else if (j == 1) {
-            return -sin_taylor_fp64(t);
-        } else if (j == -1) {
-            return sin_taylor_fp64(t);
-        } else {
-            return -cos_taylor_fp64(t);
-        }
+    draw(renderPass) {
+      this.pipeline = this._updatePipeline();
+      this.pipeline.setBindings(this.bindings);
+      this.pipeline.setUniforms(this.uniforms);
+      this.pipeline.draw({
+        renderPass,
+        vertexArray: this.vertexArray,
+        vertexCount: this.vertexCount,
+        instanceCount: this.instanceCount
+      });
     }
-
-    int abs_k = int(abs(float(k)));
-
-    if (abs_k > 4) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    } else {
-        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+    setGeometry(geometry) {
+      const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
+      this.setTopology(gpuGeometry.topology || "triangle-list");
+      this.bufferLayout = mergeBufferLayouts(this.bufferLayout, gpuGeometry.bufferLayout);
+      if (this.vertexArray) {
+        this._setGeometryAttributes(gpuGeometry);
+      }
+      return gpuGeometry;
     }
-
-    vec2 u = vec2(0.0, 0.0);
-    vec2 v = vec2(0.0, 0.0);
-
-#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-    if (abs(float(abs_k) - 1.0) < 0.5) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs(float(abs_k) - 2.0) < 0.5) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs(float(abs_k) - 3.0) < 0.5) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs(float(abs_k) - 4.0) < 0.5) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
+    _setGeometryAttributes(gpuGeometry) {
+      this.vertexCount = gpuGeometry.vertexCount;
+      this.setAttributes(gpuGeometry.attributes);
+      this.setIndexBuffer(gpuGeometry.indices);
     }
-#else
-    if (abs_k == 1) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs_k == 2) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs_k == 3) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs_k == 4) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
+    setTopology(topology) {
+      if (topology !== this.topology) {
+        this.topology = topology;
+        this._setPipelineNeedsUpdate("topology");
+      }
     }
-#endif
-
-    vec2 sin_t, cos_t;
-    sincos_taylor_fp64(t, sin_t, cos_t);
-
-    vec2 result = vec2(0.0, 0.0);
-    if (j == 0) {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        } else {
-            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
-    } else if (j == 1) {
-        if (k > 0) {
-            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
-        }
-    } else if (j == -1) {
-        if (k > 0) {
-            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        }
-    } else {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
-        } else {
-            result = -sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
+    setBufferLayout(bufferLayout) {
+      this.bufferLayout = this._gpuGeometry ? mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout) : bufferLayout;
+      this._setPipelineNeedsUpdate("bufferLayout");
+      this.pipeline = this._updatePipeline();
+      this.vertexArray = this.device.createVertexArray({
+        renderPipeline: this.pipeline
+      });
+      if (this._gpuGeometry) {
+        this._setGeometryAttributes(this._gpuGeometry);
+      }
     }
-
-    return result;
-}
-
-vec2 tan_fp64(vec2 a) {
-    vec2 sin_a;
-    vec2 cos_a;
-
-    if (a.x == 0.0 && a.y == 0.0) {
-        return vec2(0.0, 0.0);
+    setParameters(parameters2) {
+      if (!(0, import_core36.deepEqual)(parameters2, this.parameters, 2)) {
+        this.parameters = parameters2;
+        this._setPipelineNeedsUpdate("parameters");
+      }
     }
-
-    // 2pi range reduction
-    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
-    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
-
-    vec2 t;
-    float q = floor(r.x / PI_2_FP64.x + 0.5);
-    int j = int(q);
-
-
-    if (j < -2 || j > 2) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    setVertexCount(vertexCount) {
+      this.vertexCount = vertexCount;
     }
-
-    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
-
-    q = floor(t.x / PI_16_FP64.x + 0.5);
-    int k = int(q);
-    int abs_k = int(abs(float(k)));
-
-    // We just can't get PI/16 * 3.0 very accurately.
-    // so let's just store it
-    if (abs_k > 4) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    } else {
-        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+    setInstanceCount(instanceCount) {
+      this.instanceCount = instanceCount;
     }
-
-
-    vec2 u = vec2(0.0, 0.0);
-    vec2 v = vec2(0.0, 0.0);
-
-    vec2 sin_t, cos_t;
-    vec2 s, c;
-    sincos_taylor_fp64(t, sin_t, cos_t);
-
-    if (k == 0) {
-        s = sin_t;
-        c = cos_t;
-    } else {
-#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-        if (abs(float(abs_k) - 1.0) < 0.5) {
-            u = COS_TABLE_0_FP64;
-            v = SIN_TABLE_0_FP64;
-        } else if (abs(float(abs_k) - 2.0) < 0.5) {
-            u = COS_TABLE_1_FP64;
-            v = SIN_TABLE_1_FP64;
-        } else if (abs(float(abs_k) - 3.0) < 0.5) {
-            u = COS_TABLE_2_FP64;
-            v = SIN_TABLE_2_FP64;
-        } else if (abs(float(abs_k) - 4.0) < 0.5) {
-            u = COS_TABLE_3_FP64;
-            v = SIN_TABLE_3_FP64;
+    setShaderModuleProps(props) {
+      const uniforms = this._getModuleUniforms(props);
+      const keys = Object.keys(uniforms).filter((k) => {
+        const uniform = uniforms[k];
+        return !(0, import_core36.isNumberArray)(uniform) && typeof uniform !== "number" && typeof uniform !== "boolean";
+      });
+      const bindings = {};
+      for (const k of keys) {
+        bindings[k] = uniforms[k];
+        delete uniforms[k];
+      }
+      Object.assign(this.uniforms, uniforms);
+      Object.assign(this.bindings, bindings);
+    }
+    updateModuleSettings(props) {
+      this.setShaderModuleProps(props);
+    }
+    setBindings(bindings) {
+      Object.assign(this.bindings, bindings);
+    }
+    setUniforms(uniforms) {
+      this.pipeline.setUniforms(uniforms);
+      Object.assign(this.uniforms, uniforms);
+    }
+    setIndexBuffer(indexBuffer) {
+      this.vertexArray.setIndexBuffer(indexBuffer);
+    }
+    setAttributes(buffers) {
+      if (buffers.indices) {
+        import_core36.log.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`);
+      }
+      for (const [bufferName, buffer] of Object.entries(buffers)) {
+        var _bufferLayout$attribu;
+        const bufferLayout = this.bufferLayout.find((layout) => layout.name === bufferName);
+        if (!bufferLayout) {
+          continue;
         }
-#else
-        if (abs_k == 1) {
-            u = COS_TABLE_0_FP64;
-            v = SIN_TABLE_0_FP64;
-        } else if (abs_k == 2) {
-            u = COS_TABLE_1_FP64;
-            v = SIN_TABLE_1_FP64;
-        } else if (abs_k == 3) {
-            u = COS_TABLE_2_FP64;
-            v = SIN_TABLE_2_FP64;
-        } else if (abs_k == 4) {
-            u = COS_TABLE_3_FP64;
-            v = SIN_TABLE_3_FP64;
+        const attributeNames = bufferLayout.attributes ? (_bufferLayout$attribu = bufferLayout.attributes) === null || _bufferLayout$attribu === void 0 ? void 0 : _bufferLayout$attribu.map((layout) => layout.attribute) : [bufferLayout.name];
+        let set2 = false;
+        for (const attributeName of attributeNames) {
+          const attributeInfo = this._attributeInfos[attributeName];
+          if (attributeInfo) {
+            this.vertexArray.setBuffer(attributeInfo.location, buffer);
+            set2 = true;
+          }
         }
-#endif
-        if (k > 0) {
-            s = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-            c = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        if (!set2) {
+          import_core36.log.warn(`Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`)();
+        }
+      }
+    }
+    setConstantAttributes(attributes) {
+      for (const [attributeName, value] of Object.entries(attributes)) {
+        const attributeInfo = this._attributeInfos[attributeName];
+        if (attributeInfo) {
+          this.vertexArray.setConstant(attributeInfo.location, value);
         } else {
-            s = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-            c = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+          import_core36.log.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)();
         }
+      }
     }
-
-    if (j == 0) {
-        sin_a = s;
-        cos_a = c;
-    } else if (j == 1) {
-        sin_a = c;
-        cos_a = -s;
-    } else if (j == -1) {
-        sin_a = -c;
-        cos_a = s;
-    } else {
-        sin_a = -s;
-        cos_a = -c;
+    _setPipelineNeedsUpdate(reason) {
+      this._pipelineNeedsUpdate = this._pipelineNeedsUpdate || reason;
     }
-    return div_fp64(sin_a, cos_a);
-}
-
-vec2 radians_fp64(vec2 degree) {
-  return mul_fp64(degree, PI_180_FP64);
-}
-
-vec2 mix_fp64(vec2 a, vec2 b, float x) {
-  vec2 range = sub_fp64(b, a);
-  return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));
-}
-
-// Vector functions
-// vec2 functions
-void vec2_sum_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = sum_fp64(a[0], b[0]);
-    out_val[1] = sum_fp64(a[1], b[1]);
-}
-
-void vec2_sub_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = sub_fp64(a[0], b[0]);
-    out_val[1] = sub_fp64(a[1], b[1]);
-}
-
-void vec2_mul_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = mul_fp64(a[0], b[0]);
-    out_val[1] = mul_fp64(a[1], b[1]);
-}
-
-void vec2_div_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = div_fp64(a[0], b[0]);
-    out_val[1] = div_fp64(a[1], b[1]);
-}
-
-void vec2_mix_fp64(vec2 x[2], vec2 y[2], float a, out vec2 out_val[2]) {
-  vec2 range[2];
-  vec2_sub_fp64(y, x, range);
-  vec2 portion[2];
-  portion[0] = range[0] * a;
-  portion[1] = range[1] * a;
-  vec2_sum_fp64(x, portion, out_val);
-}
-
-vec2 vec2_length_fp64(vec2 x[2]) {
-  return sqrt_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])));
-}
-
-void vec2_normalize_fp64(vec2 x[2], out vec2 out_val[2]) {
-  vec2 length = vec2_length_fp64(x);
-  vec2 length_vec2[2];
-  length_vec2[0] = length;
-  length_vec2[1] = length;
-
-  vec2_div_fp64(x, length_vec2, out_val);
-}
-
-vec2 vec2_distance_fp64(vec2 x[2], vec2 y[2]) {
-  vec2 diff[2];
-  vec2_sub_fp64(x, y, diff);
-  return vec2_length_fp64(diff);
-}
-
-vec2 vec2_dot_fp64(vec2 a[2], vec2 b[2]) {
-  vec2 v[2];
-
-  v[0] = mul_fp64(a[0], b[0]);
-  v[1] = mul_fp64(a[1], b[1]);
-
-  return sum_fp64(v[0], v[1]);
-}
-
-// vec3 functions
-void vec3_sub_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {
-  for (int i = 0; i < 3; i++) {
-    out_val[i] = sum_fp64(a[i], b[i]);
-  }
-}
-
-void vec3_sum_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {
-  for (int i = 0; i < 3; i++) {
-    out_val[i] = sum_fp64(a[i], b[i]);
-  }
-}
-
-vec2 vec3_length_fp64(vec2 x[3]) {
-  return sqrt_fp64(sum_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])),
-    mul_fp64(x[2], x[2])));
-}
-
-vec2 vec3_distance_fp64(vec2 x[3], vec2 y[3]) {
-  vec2 diff[3];
-  vec3_sub_fp64(x, y, diff);
-  return vec3_length_fp64(diff);
-}
-
-// vec4 functions
-void vec4_fp64(vec4 a, out vec2 out_val[4]) {
-  out_val[0].x = a[0];
-  out_val[0].y = 0.0;
-
-  out_val[1].x = a[1];
-  out_val[1].y = 0.0;
-
-  out_val[2].x = a[2];
-  out_val[2].y = 0.0;
-
-  out_val[3].x = a[3];
-  out_val[3].y = 0.0;
-}
-
-void vec4_scalar_mul_fp64(vec2 a[4], vec2 b, out vec2 out_val[4]) {
-  out_val[0] = mul_fp64(a[0], b);
-  out_val[1] = mul_fp64(a[1], b);
-  out_val[2] = mul_fp64(a[2], b);
-  out_val[3] = mul_fp64(a[3], b);
-}
-
-void vec4_sum_fp64(vec2 a[4], vec2 b[4], out vec2 out_val[4]) {
-  for (int i = 0; i < 4; i++) {
-    out_val[i] = sum_fp64(a[i], b[i]);
+    _updatePipeline() {
+      if (this._pipelineNeedsUpdate) {
+        if (this.pipeline) {
+          import_core36.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
+        }
+        this._pipelineNeedsUpdate = false;
+        this.pipeline = this.device.createRenderPipeline({
+          ...this.props,
+          bufferLayout: this.bufferLayout,
+          topology: this.topology,
+          parameters: this.parameters,
+          vs: this.device.createShader({
+            id: "{$this.id}-vertex",
+            stage: "vertex",
+            source: this.vs
+          }),
+          fs: this.fs ? this.device.createShader({
+            id: "{$this.id}-fragment",
+            stage: "fragment",
+            source: this.fs
+          }) : null
+        });
+        this._attributeInfos = (0, import_core37.getAttributeInfosFromLayouts)(this.pipeline.shaderLayout, this.bufferLayout);
+      }
+      return this.pipeline;
+    }
+  };
+  Model.defaultProps = {
+    ...import_core36.RenderPipeline.defaultProps,
+    vs: null,
+    fs: null,
+    id: "unnamed",
+    handle: void 0,
+    userData: {},
+    defines: {},
+    modules: [],
+    moduleSettings: {},
+    geometry: null,
+    indexBuffer: null,
+    attributes: {},
+    constantAttributes: {},
+    pipelineFactory: void 0,
+    shaderAssembler: ShaderAssembler.getDefaultShaderAssembler()
+  };
+  function mergeBufferLayouts(layouts1, layouts2) {
+    const layouts = [...layouts1];
+    for (const attribute of layouts2) {
+      const index = layouts.findIndex((attribute2) => attribute2.name === attribute.name);
+      if (index < 0) {
+        layouts.push(attribute);
+      } else {
+        layouts[index] = attribute;
+      }
+    }
+    return layouts;
   }
-}
 
-void vec4_dot_fp64(vec2 a[4], vec2 b[4], out vec2 out_val) {
-  vec2 v[4];
+  // src/data-filter/aggregator.ts
+  var AGGREGATE_VS = `#define SHADER_NAME data-filter-vertex-shader
 
-  v[0] = mul_fp64(a[0], b[0]);
-  v[1] = mul_fp64(a[1], b[1]);
-  v[2] = mul_fp64(a[2], b[2]);
-  v[3] = mul_fp64(a[3], b[3]);
+#ifdef FLOAT_TARGET
+  attribute float filterIndices;
+  attribute float filterPrevIndices;
+#else
+  attribute vec2 filterIndices;
+  attribute vec2 filterPrevIndices;
+#endif
 
-  out_val = sum_fp64(sum_fp64(v[0], v[1]), sum_fp64(v[2], v[3]));
+varying vec4 vColor;
+const float component = 1.0 / 255.0;
+
+void main() {
+  #ifdef FLOAT_TARGET
+    dataFilter_value *= float(filterIndices != filterPrevIndices);
+    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+    vColor = vec4(0.0, 0.0, 0.0, 1.0);
+  #else
+    // Float texture is not supported: pack result into 4 channels x 256 px x 64px
+    dataFilter_value *= float(filterIndices.x != filterPrevIndices.x);
+    float col = filterIndices.x;
+    float row = filterIndices.y * 4.0;
+    float channel = floor(row);
+    row = fract(row);
+    vColor = component * vec4(bvec4(channel == 0.0, channel == 1.0, channel == 2.0, channel == 3.0));
+    gl_Position = vec4(col * 2.0 - 1.0, row * 2.0 - 1.0, 0.0, 1.0);
+  #endif
+  gl_PointSize = 1.0;
 }
+`;
+  var AGGREGATE_FS = `#define SHADER_NAME data-filter-fragment-shader
+precision highp float;
 
-void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
-  vec2 tmp[4];
+varying vec4 vColor;
 
-  for (int i = 0; i < 4; i++)
-  {
-    for (int j = 0; j < 4; j++)
-    {
-      tmp[j] = b[j + i * 4];
-    }
-    vec4_dot_fp64(a, tmp, out_val[i]);
+void main() {
+  if (dataFilter_value < 0.5) {
+    discard;
   }
+  gl_FragColor = vColor;
 }
 `;
-
-  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64.js
-  var CONST_UNIFORMS = {
-    ONE: 1
-  };
-  function getUniforms2() {
-    return CONST_UNIFORMS;
+  function supportsFloatTarget(device) {
+    const gl = device.gl;
+    return Boolean(gl.getExtension("EXT_float_blend") && (gl.getExtension("EXT_color_buffer_float") || gl.getExtension("WEBGL_color_buffer_float")));
   }
-  var fp64arithmetic = {
-    name: "fp64-arithmetic",
-    vs: fp64arithmeticShader,
-    getUniforms: getUniforms2,
-    fp64ify,
-    fp64LowPart,
-    fp64ifyMatrix4
-  };
-  var fp64 = {
-    name: "fp64",
-    vs: fp64functionShader,
-    dependencies: [fp64arithmetic],
-    fp64ify,
-    fp64LowPart,
-    fp64ifyMatrix4
+  function getFramebuffer3(device, useFloatTarget) {
+    if (useFloatTarget) {
+      return device.createFramebuffer({
+        width: 1,
+        height: 1,
+        colorAttachments: [device.createTexture({
+          format: device.info.type === "webgl2" ? "rgba32float" : "rgba8unorm",
+          type: 5126,
+          mipmaps: false
+        })]
+      });
+    }
+    return device.createFramebuffer({
+      width: 256,
+      height: 64,
+      colorAttachments: [device.createTexture({
+        format: "rgba8unorm",
+        type: 5126,
+        mipmaps: false
+      })]
+    });
+  }
+  function getModel(device, shaderOptions, useFloatTarget) {
+    shaderOptions.defines.NON_INSTANCED_MODEL = 1;
+    if (useFloatTarget) {
+      shaderOptions.defines.FLOAT_TARGET = 1;
+    }
+    return new Model(device, {
+      id: "data-filter-aggregation-model",
+      vertexCount: 1,
+      isInstanced: false,
+      drawMode: 0,
+      vs: AGGREGATE_VS,
+      fs: AGGREGATE_FS,
+      ...shaderOptions
+    });
+  }
+  var parameters = {
+    blend: true,
+    blendFunc: [1, 1, 1, 1],
+    blendEquation: [32774, 32774],
+    depthTest: false
   };
 
-  // ../../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
+  // src/data-filter/data-filter-extension.ts
+  var defaultProps2 = {
+    getFilterValue: {
+      type: "accessor",
+      value: 0
+    },
+    onFilteredItemsChange: {
+      type: "function",
+      value: null,
+      optional: true
+    },
+    filterEnabled: true,
+    filterRange: [-1, 1],
+    filterSoftRange: null,
+    filterTransformSize: true,
+    filterTransformColor: true
   };
-  globalThis.mathgl = globalThis.mathgl || {
-    config: {
-      ...DEFAULT_CONFIG
-    }
+  var DATA_TYPE_FROM_SIZE = {
+    1: "float",
+    2: "vec2",
+    3: "vec3",
+    4: "vec4"
   };
-  var config = globalThis.mathgl.config;
-  function isArray2(value) {
-    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
-  }
-  function equals(a, b, epsilon) {
-    const oldEpsilon = config.EPSILON;
-    if (epsilon) {
-      config.EPSILON = epsilon;
+  var DataFilterExtension = class extends import_core38.LayerExtension {
+    constructor({
+      filterSize = 1,
+      fp64: fp642 = false,
+      countItems = false
+    } = {}) {
+      if (!DATA_TYPE_FROM_SIZE[filterSize]) {
+        throw new Error("filterSize out of range");
+      }
+      super({
+        filterSize,
+        fp64: fp642,
+        countItems
+      });
     }
-    try {
-      if (a === b) {
-        return true;
+    getShaders(extension) {
+      const {
+        filterSize,
+        fp64: fp642
+      } = extension.opts;
+      return {
+        modules: [fp642 ? shaderModule64 : shaderModule],
+        defines: {
+          DATAFILTER_TYPE: DATA_TYPE_FROM_SIZE[filterSize],
+          DATAFILTER_DOUBLE: Boolean(fp642)
+        }
+      };
+    }
+    initializeState(context, extension) {
+      const attributeManager = this.getAttributeManager();
+      if (attributeManager) {
+        attributeManager.add({
+          filterValues: {
+            size: extension.opts.filterSize,
+            type: extension.opts.fp64 ? 5130 : 5126,
+            accessor: "getFilterValue",
+            shaderAttributes: {
+              filterValues: {
+                divisor: 0
+              },
+              instanceFilterValues: {
+                divisor: 1
+              }
+            }
+          }
+        });
       }
-      if (isArray2(a) && isArray2(b)) {
-        if (a.length !== b.length) {
-          return false;
+      const {
+        device
+      } = this.context;
+      if (attributeManager && extension.opts.countItems) {
+        const useFloatTarget = supportsFloatTarget(device);
+        attributeManager.add({
+          filterIndices: {
+            size: useFloatTarget ? 1 : 2,
+            vertexOffset: 1,
+            type: 5121,
+            normalized: true,
+            accessor: (object, {
+              index
+            }) => {
+              const i = object && object.__source ? object.__source.index : index;
+              return useFloatTarget ? (i + 1) % 255 : [(i + 1) % 255, Math.floor(i / 255) % 255];
+            },
+            shaderAttributes: {
+              filterPrevIndices: {
+                vertexOffset: 0
+              },
+              filterIndices: {
+                vertexOffset: 1
+              }
+            }
+          }
+        });
+        const filterFBO = getFramebuffer3(device, useFloatTarget);
+        const filterModel = getModel(device, extension.getShaders.call(this, extension), useFloatTarget);
+        this.setState({
+          filterFBO,
+          filterModel
+        });
+      }
+    }
+    updateState({
+      props,
+      oldProps
+    }) {
+      if (this.state.filterModel) {
+        const attributeManager = this.getAttributeManager();
+        const filterNeedsUpdate = attributeManager.attributes.filterValues.needsUpdate() || props.filterEnabled !== oldProps.filterEnabled || props.filterRange !== oldProps.filterRange || props.filterSoftRange !== oldProps.filterSoftRange;
+        if (filterNeedsUpdate) {
+          this.setState({
+            filterNeedsUpdate
+          });
         }
-        for (let i = 0; i < a.length; ++i) {
-          if (!equals(a[i], b[i])) {
-            return false;
+      }
+    }
+    draw(params, extension) {
+      const filterFBO = this.state.filterFBO;
+      const filterModel = this.state.filterModel;
+      const filterNeedsUpdate = this.state.filterNeedsUpdate;
+      const {
+        onFilteredItemsChange
+      } = this.props;
+      if (filterNeedsUpdate && onFilteredItemsChange && filterModel) {
+        const {
+          attributes: {
+            filterValues,
+            filterIndices
           }
+        } = this.getAttributeManager();
+        filterModel.setVertexCount(this.getNumInstances());
+        clear(this.context.device, {
+          framebuffer: filterFBO,
+          color: [0, 0, 0, 0]
+        });
+        filterModel.updateModuleSettings(params.moduleParameters);
+        filterModel.setAttributes({
+          ...filterValues.getValue(),
+          ...filterIndices?.getValue()
+        });
+        withGLParameters(filterModel.device, {
+          framebuffer: filterFBO,
+          ...parameters,
+          viewport: [0, 0, filterFBO.width, filterFBO.height]
+        }, () => {
+          filterModel.draw(this.context.renderPass);
+        });
+        const color = readPixelsToArray(filterFBO);
+        let count = 0;
+        for (let i = 0; i < color.length; i++) {
+          count += color[i];
         }
-        return true;
-      }
-      if (a && a.equals) {
-        return a.equals(b);
-      }
-      if (b && b.equals) {
-        return b.equals(a);
-      }
-      if (typeof a === "number" && typeof b === "number") {
-        return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
+        onFilteredItemsChange({
+          id: this.id,
+          count
+        });
+        this.state.filterNeedsUpdate = false;
       }
-      return false;
-    } finally {
-      config.EPSILON = oldEpsilon;
     }
-  }
+    finalizeState() {
+      const filterFBO = this.state.filterFBO;
+      const filterModel = this.state.filterModel;
+      filterFBO?.destroy();
+      filterModel?.destroy();
+    }
+  };
+  __publicField(DataFilterExtension, "defaultProps", defaultProps2);
+  __publicField(DataFilterExtension, "extensionName", "DataFilterExtension");
 
-  // ../../node_modules/@math.gl/core/dist/gl-matrix/common.js
-  var EPSILON = 1e-6;
-  var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
-  var RANDOM = Math.random;
-  function round(a) {
-    if (a >= 0)
-      return Math.round(a);
-    return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
-  }
-  var degree = Math.PI / 180;
+  // src/fp64/fp64-extension.ts
+  var import_core40 = __toESM(require_core());
 
-  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec3.js
-  var vec3_exports = {};
-  __export(vec3_exports, {
-    add: () => add,
-    angle: () => angle,
-    bezier: () => bezier,
-    ceil: () => ceil,
-    clone: () => clone,
-    copy: () => copy,
-    create: () => create,
-    cross: () => cross,
-    dist: () => dist,
-    distance: () => distance,
-    div: () => div,
-    divide: () => divide,
-    dot: () => dot,
-    equals: () => equals2,
-    exactEquals: () => exactEquals,
-    floor: () => floor,
-    forEach: () => forEach,
-    fromValues: () => fromValues,
-    hermite: () => hermite,
-    inverse: () => inverse,
-    len: () => len,
-    length: () => length,
-    lerp: () => lerp,
-    max: () => max,
-    min: () => min,
-    mul: () => mul,
-    multiply: () => multiply,
-    negate: () => negate,
-    normalize: () => normalize,
-    random: () => random,
-    rotateX: () => rotateX,
-    rotateY: () => rotateY,
-    rotateZ: () => rotateZ,
-    round: () => round2,
-    scale: () => scale,
-    scaleAndAdd: () => scaleAndAdd,
-    set: () => set,
-    slerp: () => slerp,
-    sqrDist: () => sqrDist,
-    sqrLen: () => sqrLen,
-    squaredDistance: () => squaredDistance,
-    squaredLength: () => squaredLength,
-    str: () => str,
-    sub: () => sub,
-    subtract: () => subtract,
-    transformMat3: () => transformMat3,
-    transformMat4: () => transformMat4,
-    transformQuat: () => transformQuat,
-    zero: () => zero
-  });
-  function create() {
-    const out = new ARRAY_TYPE(3);
-    if (ARRAY_TYPE != Float32Array) {
-      out[0] = 0;
-      out[1] = 0;
-      out[2] = 0;
-    }
-    return out;
-  }
-  function clone(a) {
-    const out = new ARRAY_TYPE(3);
-    out[0] = a[0];
-    out[1] = a[1];
-    out[2] = a[2];
-    return out;
-  }
-  function length(a) {
-    const x = a[0];
-    const y = a[1];
-    const z = a[2];
-    return Math.sqrt(x * x + y * y + z * z);
-  }
-  function fromValues(x, y, z) {
-    const out = new ARRAY_TYPE(3);
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-    return out;
-  }
-  function copy(out, a) {
-    out[0] = a[0];
-    out[1] = a[1];
-    out[2] = a[2];
-    return out;
-  }
-  function set(out, x, y, z) {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-    return out;
-  }
-  function add(out, a, b) {
-    out[0] = a[0] + b[0];
-    out[1] = a[1] + b[1];
-    out[2] = a[2] + b[2];
-    return out;
-  }
-  function subtract(out, a, b) {
-    out[0] = a[0] - b[0];
-    out[1] = a[1] - b[1];
-    out[2] = a[2] - b[2];
-    return out;
-  }
-  function multiply(out, a, b) {
-    out[0] = a[0] * b[0];
-    out[1] = a[1] * b[1];
-    out[2] = a[2] * b[2];
-    return out;
-  }
-  function divide(out, a, b) {
-    out[0] = a[0] / b[0];
-    out[1] = a[1] / b[1];
-    out[2] = a[2] / b[2];
-    return out;
-  }
-  function ceil(out, a) {
-    out[0] = Math.ceil(a[0]);
-    out[1] = Math.ceil(a[1]);
-    out[2] = Math.ceil(a[2]);
-    return out;
-  }
-  function floor(out, a) {
-    out[0] = Math.floor(a[0]);
-    out[1] = Math.floor(a[1]);
-    out[2] = Math.floor(a[2]);
-    return out;
-  }
-  function min(out, a, b) {
-    out[0] = Math.min(a[0], b[0]);
-    out[1] = Math.min(a[1], b[1]);
-    out[2] = Math.min(a[2], b[2]);
-    return out;
-  }
-  function max(out, a, b) {
-    out[0] = Math.max(a[0], b[0]);
-    out[1] = Math.max(a[1], b[1]);
-    out[2] = Math.max(a[2], b[2]);
-    return out;
-  }
-  function round2(out, a) {
-    out[0] = round(a[0]);
-    out[1] = round(a[1]);
-    out[2] = round(a[2]);
-    return out;
-  }
-  function scale(out, a, b) {
-    out[0] = a[0] * b;
-    out[1] = a[1] * b;
-    out[2] = a[2] * b;
-    return out;
-  }
-  function scaleAndAdd(out, a, b, scale2) {
-    out[0] = a[0] + b[0] * scale2;
-    out[1] = a[1] + b[1] * scale2;
-    out[2] = a[2] + b[2] * scale2;
+  // ../../node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/highlight.js
+  var glsl2 = (x) => `${x}`;
+
+  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-utils.js
+  function fp64ify(a) {
+    let out = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+    let startIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+    const hiPart = Math.fround(a);
+    const loPart = a - hiPart;
+    out[startIndex] = hiPart;
+    out[startIndex + 1] = loPart;
     return out;
   }
-  function distance(a, b) {
-    const x = b[0] - a[0];
-    const y = b[1] - a[1];
-    const z = b[2] - a[2];
-    return Math.sqrt(x * x + y * y + z * z);
-  }
-  function squaredDistance(a, b) {
-    const x = b[0] - a[0];
-    const y = b[1] - a[1];
-    const z = b[2] - a[2];
-    return x * x + y * y + z * z;
-  }
-  function squaredLength(a) {
-    const x = a[0];
-    const y = a[1];
-    const z = a[2];
-    return x * x + y * y + z * z;
-  }
-  function negate(out, a) {
-    out[0] = -a[0];
-    out[1] = -a[1];
-    out[2] = -a[2];
-    return out;
+  function fp64LowPart(a) {
+    return a - Math.fround(a);
   }
-  function inverse(out, a) {
-    out[0] = 1 / a[0];
-    out[1] = 1 / a[1];
-    out[2] = 1 / a[2];
-    return out;
+  function fp64ifyMatrix4(matrix) {
+    const matrixFP64 = new Float32Array(32);
+    for (let i = 0; i < 4; ++i) {
+      for (let j = 0; j < 4; ++j) {
+        const index = i * 4 + j;
+        fp64ify(matrix[j * 4 + i], matrixFP64, index * 2);
+      }
+    }
+    return matrixFP64;
   }
-  function normalize(out, a) {
-    const x = a[0];
-    const y = a[1];
-    const z = a[2];
-    let len2 = x * x + y * y + z * z;
-    if (len2 > 0) {
-      len2 = 1 / Math.sqrt(len2);
+
+  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-arithmetic.glsl.js
+  var fp64arithmeticShader = glsl2`\
+uniform float ONE;
+
+/*
+About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+
+The purpose of this workaround is to prevent shader compilers from
+optimizing away necessary arithmetic operations by swapping their sequences
+or transform the equation to some 'equivalent' from.
+
+The method is to multiply an artifical variable, ONE, which will be known to
+the compiler to be 1 only at runtime. The whole expression is then represented
+as a polynomial with respective to ONE. In the coefficients of all terms, only one a
+and one b should appear
+
+err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
+*/
+
+// Divide float number to high and low floats to extend fraction bits
+vec2 split(float a) {
+  const float SPLIT = 4097.0;
+  float t = a * SPLIT;
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float a_hi = t * ONE - (t - a);
+  float a_lo = a * ONE - a_hi;
+#else
+  float a_hi = t - (t - a);
+  float a_lo = a - a_hi;
+#endif
+  return vec2(a_hi, a_lo);
+}
+
+// Divide float number again when high float uses too many fraction bits
+vec2 split2(vec2 a) {
+  vec2 b = split(a.x);
+  b.y += a.y;
+  return b;
+}
+
+// Special sum operation when a > b
+vec2 quickTwoSum(float a, float b) {
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float sum = (a + b) * ONE;
+  float err = b - (sum - a) * ONE;
+#else
+  float sum = a + b;
+  float err = b - (sum - a);
+#endif
+  return vec2(sum, err);
+}
+
+// General sum operation
+vec2 twoSum(float a, float b) {
+  float s = (a + b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * ONE - a) * ONE;
+  float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) + (b - v);
+#endif
+  return vec2(s, err);
+}
+
+vec2 twoSub(float a, float b) {
+  float s = (a - b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * ONE - a) * ONE;
+  float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) - (b + v);
+#endif
+  return vec2(s, err);
+}
+
+vec2 twoSqr(float a) {
+  float prod = a * a;
+  vec2 a_fp64 = split(a);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x *
+    a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE;
+#else
+  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
+#endif
+  return vec2(prod, err);
+}
+
+vec2 twoProd(float a, float b) {
+  float prod = a * b;
+  vec2 a_fp64 = split(a);
+  vec2 b_fp64 = split(b);
+  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
+    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
+  return vec2(prod, err);
+}
+
+vec2 sum_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSum(a.x, b.x);
+  t = twoSum(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+vec2 sub_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSub(a.x, b.x);
+  t = twoSub(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+vec2 mul_fp64(vec2 a, vec2 b) {
+  vec2 prod = twoProd(a.x, b.x);
+  // y component is for the error
+  prod.y += a.x * b.y;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  prod.y += a.y * b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  return prod;
+}
+
+vec2 div_fp64(vec2 a, vec2 b) {
+  float xn = 1.0 / b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  vec2 yn = mul_fp64(a, vec2(xn, 0));
+#else
+  vec2 yn = a * xn;
+#endif
+  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
+  vec2 prod = twoProd(xn, diff);
+  return sum_fp64(yn, prod);
+}
+
+vec2 sqrt_fp64(vec2 a) {
+  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
+  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
+
+  float x = 1.0 / sqrt(a.x);
+  float yn = a.x * x;
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  vec2 yn_sqr = twoSqr(yn) * ONE;
+#else
+  vec2 yn_sqr = twoSqr(yn);
+#endif
+  float diff = sub_fp64(a, yn_sqr).x;
+  vec2 prod = twoProd(x * 0.5, diff);
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  return sum_fp64(split(yn), prod);
+#else
+  return sum_fp64(vec2(yn, 0.0), prod);
+#endif
+}
+`;
+
+  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-functions.glsl.js
+  var fp64functionShader = glsl2`\
+const vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);
+const vec2 LOG2_FP64 = vec2(0.6931471824645996e+00, -1.9046542121259336e-09);
+const vec2 PI_FP64 = vec2(3.1415927410125732, -8.742278012618954e-8);
+const vec2 TWO_PI_FP64 = vec2(6.2831854820251465, -1.7484556025237907e-7);
+const vec2 PI_2_FP64 = vec2(1.5707963705062866, -4.371139006309477e-8);
+const vec2 PI_4_FP64 = vec2(0.7853981852531433, -2.1855695031547384e-8);
+const vec2 PI_16_FP64 = vec2(0.19634954631328583, -5.463923757886846e-9);
+const vec2 PI_16_2_FP64 = vec2(0.39269909262657166, -1.0927847515773692e-8);
+const vec2 PI_16_3_FP64 = vec2(0.5890486240386963, -1.4906100798128818e-9);
+const vec2 PI_180_FP64 = vec2(0.01745329238474369, 1.3519960498364902e-10);
+
+const vec2 SIN_TABLE_0_FP64 = vec2(0.19509032368659973, -1.6704714833615242e-9);
+const vec2 SIN_TABLE_1_FP64 = vec2(0.3826834261417389, 6.22335089017767e-9);
+const vec2 SIN_TABLE_2_FP64 = vec2(0.5555702447891235, -1.1769521357507529e-8);
+const vec2 SIN_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617041793133e-8);
+
+const vec2 COS_TABLE_0_FP64 = vec2(0.9807852506637573, 2.9739473106360492e-8);
+const vec2 COS_TABLE_1_FP64 = vec2(0.9238795042037964, 2.8307490351764386e-8);
+const vec2 COS_TABLE_2_FP64 = vec2(0.8314695954322815, 1.6870263741530778e-8);
+const vec2 COS_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617152815436e-8);
+
+const vec2 INVERSE_FACTORIAL_3_FP64 = vec2(1.666666716337204e-01, -4.967053879312289e-09); // 1/3!
+const vec2 INVERSE_FACTORIAL_4_FP64 = vec2(4.16666679084301e-02, -1.2417634698280722e-09); // 1/4!
+const vec2 INVERSE_FACTORIAL_5_FP64 = vec2(8.333333767950535e-03, -4.34617203337595e-10); // 1/5!
+const vec2 INVERSE_FACTORIAL_6_FP64 = vec2(1.3888889225199819e-03, -3.3631094437103215e-11); // 1/6!
+const vec2 INVERSE_FACTORIAL_7_FP64 = vec2(1.9841270113829523e-04,  -2.725596874933456e-12); // 1/7!
+const vec2 INVERSE_FACTORIAL_8_FP64 = vec2(2.4801587642286904e-05, -3.406996025904184e-13); // 1/8!
+const vec2 INVERSE_FACTORIAL_9_FP64 = vec2(2.75573188446287533e-06, 3.7935713937038186e-14); // 1/9!
+const vec2 INVERSE_FACTORIAL_10_FP64 = vec2(2.755731998149713e-07, -7.575112367869873e-15); // 1/10!
+
+float nint(float d) {
+    if (d == floor(d)) return d;
+    return floor(d + 0.5);
+}
+
+vec2 nint_fp64(vec2 a) {
+    float hi = nint(a.x);
+    float lo;
+    vec2 tmp;
+    if (hi == a.x) {
+        lo = nint(a.y);
+        tmp = quickTwoSum(hi, lo);
+    } else {
+        lo = 0.0;
+        if (abs(hi - a.x) == 0.5 && a.y < 0.0) {
+            hi -= 1.0;
+        }
+        tmp = vec2(hi, lo);
     }
-    out[0] = a[0] * len2;
-    out[1] = a[1] * len2;
-    out[2] = a[2] * len2;
-    return out;
-  }
-  function dot(a, b) {
-    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-  }
-  function cross(out, a, b) {
-    const ax = a[0];
-    const ay = a[1];
-    const az = a[2];
-    const bx = b[0];
-    const by = b[1];
-    const bz = b[2];
-    out[0] = ay * bz - az * by;
-    out[1] = az * bx - ax * bz;
-    out[2] = ax * by - ay * bx;
-    return out;
-  }
-  function lerp(out, a, b, t) {
-    const ax = a[0];
-    const ay = a[1];
-    const az = a[2];
-    out[0] = ax + t * (b[0] - ax);
-    out[1] = ay + t * (b[1] - ay);
-    out[2] = az + t * (b[2] - az);
-    return out;
-  }
-  function slerp(out, a, b, t) {
-    const angle2 = Math.acos(Math.min(Math.max(dot(a, b), -1), 1));
-    const sinTotal = Math.sin(angle2);
-    const ratioA = Math.sin((1 - t) * angle2) / sinTotal;
-    const ratioB = Math.sin(t * angle2) / sinTotal;
-    out[0] = ratioA * a[0] + ratioB * b[0];
-    out[1] = ratioA * a[1] + ratioB * b[1];
-    out[2] = ratioA * a[2] + ratioB * b[2];
-    return out;
-  }
-  function hermite(out, a, b, c, d, t) {
-    const factorTimes2 = t * t;
-    const factor1 = factorTimes2 * (2 * t - 3) + 1;
-    const factor2 = factorTimes2 * (t - 2) + t;
-    const factor3 = factorTimes2 * (t - 1);
-    const factor4 = factorTimes2 * (3 - 2 * t);
-    out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
-    out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
-    out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
-    return out;
-  }
-  function bezier(out, a, b, c, d, t) {
-    const inverseFactor = 1 - t;
-    const inverseFactorTimesTwo = inverseFactor * inverseFactor;
-    const factorTimes2 = t * t;
-    const factor1 = inverseFactorTimesTwo * inverseFactor;
-    const factor2 = 3 * t * inverseFactorTimesTwo;
-    const factor3 = 3 * factorTimes2 * inverseFactor;
-    const factor4 = factorTimes2 * t;
-    out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
-    out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
-    out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
-    return out;
-  }
-  function random(out, scale2) {
-    scale2 = scale2 === void 0 ? 1 : scale2;
-    const r = RANDOM() * 2 * Math.PI;
-    const z = RANDOM() * 2 - 1;
-    const zScale = Math.sqrt(1 - z * z) * scale2;
-    out[0] = Math.cos(r) * zScale;
-    out[1] = Math.sin(r) * zScale;
-    out[2] = z * scale2;
-    return out;
-  }
-  function transformMat4(out, a, m) {
-    const x = a[0];
-    const y = a[1];
-    const z = a[2];
-    let w = m[3] * x + m[7] * y + m[11] * z + m[15];
-    w = w || 1;
-    out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
-    out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
-    out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
-    return out;
-  }
-  function transformMat3(out, a, m) {
-    const x = a[0];
-    const y = a[1];
-    const z = a[2];
-    out[0] = x * m[0] + y * m[3] + z * m[6];
-    out[1] = x * m[1] + y * m[4] + z * m[7];
-    out[2] = x * m[2] + y * m[5] + z * m[8];
-    return out;
-  }
-  function transformQuat(out, a, q) {
-    const qx = q[0];
-    const qy = q[1];
-    const qz = q[2];
-    const qw = q[3];
-    const x = a[0];
-    const y = a[1];
-    const z = a[2];
-    let uvx = qy * z - qz * y;
-    let uvy = qz * x - qx * z;
-    let uvz = qx * y - qy * x;
-    let uuvx = qy * uvz - qz * uvy;
-    let uuvy = qz * uvx - qx * uvz;
-    let uuvz = qx * uvy - qy * uvx;
-    const w2 = qw * 2;
-    uvx *= w2;
-    uvy *= w2;
-    uvz *= w2;
-    uuvx *= 2;
-    uuvy *= 2;
-    uuvz *= 2;
-    out[0] = x + uvx + uuvx;
-    out[1] = y + uvy + uuvy;
-    out[2] = z + uvz + uuvz;
-    return out;
-  }
-  function rotateX(out, a, b, rad) {
-    const p = [];
-    const r = [];
-    p[0] = a[0] - b[0];
-    p[1] = a[1] - b[1];
-    p[2] = a[2] - b[2];
-    r[0] = p[0];
-    r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
-    r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
-    out[0] = r[0] + b[0];
-    out[1] = r[1] + b[1];
-    out[2] = r[2] + b[2];
-    return out;
-  }
-  function rotateY(out, a, b, rad) {
-    const p = [];
-    const r = [];
-    p[0] = a[0] - b[0];
-    p[1] = a[1] - b[1];
-    p[2] = a[2] - b[2];
-    r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
-    r[1] = p[1];
-    r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
-    out[0] = r[0] + b[0];
-    out[1] = r[1] + b[1];
-    out[2] = r[2] + b[2];
-    return out;
-  }
-  function rotateZ(out, a, b, rad) {
-    const p = [];
-    const r = [];
-    p[0] = a[0] - b[0];
-    p[1] = a[1] - b[1];
-    p[2] = a[2] - b[2];
-    r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
-    r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
-    r[2] = p[2];
-    out[0] = r[0] + b[0];
-    out[1] = r[1] + b[1];
-    out[2] = r[2] + b[2];
-    return out;
-  }
-  function angle(a, b) {
-    const ax = a[0];
-    const ay = a[1];
-    const az = a[2];
-    const bx = b[0];
-    const by = b[1];
-    const bz = b[2];
-    const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz));
-    const cosine = mag && dot(a, b) / mag;
-    return Math.acos(Math.min(Math.max(cosine, -1), 1));
-  }
-  function zero(out) {
-    out[0] = 0;
-    out[1] = 0;
-    out[2] = 0;
-    return out;
+    return tmp;
+}
+
+/* k_power controls how much range reduction we would like to have
+Range reduction uses the following method:
+assume a = k_power * r + m * log(2), k and m being integers.
+Set k_power = 4 (we can choose other k to trade accuracy with performance.
+we only need to calculate exp(r) and using exp(a) = 2^m * exp(r)^k_power;
+*/
+
+vec2 exp_fp64(vec2 a) {
+  // We need to make sure these two numbers match
+  // as bit-wise shift is not available in GLSL 1.0
+  const int k_power = 4;
+  const float k = 16.0;
+
+  const float inv_k = 1.0 / k;
+
+  if (a.x <= -88.0) return vec2(0.0, 0.0);
+  if (a.x >= 88.0) return vec2(1.0 / 0.0, 1.0 / 0.0);
+  if (a.x == 0.0 && a.y == 0.0) return vec2(1.0, 0.0);
+  if (a.x == 1.0 && a.y == 0.0) return E_FP64;
+
+  float m = floor(a.x / LOG2_FP64.x + 0.5);
+  vec2 r = sub_fp64(a, mul_fp64(LOG2_FP64, vec2(m, 0.0))) * inv_k;
+  vec2 s, t, p;
+
+  p = mul_fp64(r, r);
+  s = sum_fp64(r, p * 0.5);
+  p = mul_fp64(p, r);
+  t = mul_fp64(p, INVERSE_FACTORIAL_3_FP64);
+
+  s = sum_fp64(s, t);
+  p = mul_fp64(p, r);
+  t = mul_fp64(p, INVERSE_FACTORIAL_4_FP64);
+
+  s = sum_fp64(s, t);
+  p = mul_fp64(p, r);
+  t = mul_fp64(p, INVERSE_FACTORIAL_5_FP64);
+
+  // s = sum_fp64(s, t);
+  // p = mul_fp64(p, r);
+  // t = mul_fp64(p, INVERSE_FACTORIAL_6_FP64);
+
+  // s = sum_fp64(s, t);
+  // p = mul_fp64(p, r);
+  // t = mul_fp64(p, INVERSE_FACTORIAL_7_FP64);
+
+  s = sum_fp64(s, t);
+
+
+  // At this point, s = exp(r) - 1; but after following 4 recursions, we will get exp(r) ^ 512 - 1.
+  for (int i = 0; i < k_power; i++) {
+    s = sum_fp64(s * 2.0, mul_fp64(s, s));
   }
-  function str(a) {
-    return "vec3(".concat(a[0], ", ").concat(a[1], ", ").concat(a[2], ")");
+
+#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
+  s = sum_fp64(s, vec2(ONE, 0.0));
+#else
+  s = sum_fp64(s, vec2(1.0, 0.0));
+#endif
+
+  return s * pow(2.0, m);
+//   return r;
+}
+
+vec2 log_fp64(vec2 a)
+{
+  if (a.x == 1.0 && a.y == 0.0) return vec2(0.0, 0.0);
+  if (a.x <= 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
+  vec2 x = vec2(log(a.x), 0.0);
+  vec2 s;
+#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
+  s = vec2(ONE, 0.0);
+#else
+  s = vec2(1.0, 0.0);
+#endif
+
+  x = sub_fp64(sum_fp64(x, mul_fp64(a, exp_fp64(-x))), s);
+  return x;
+}
+
+vec2 sin_taylor_fp64(vec2 a) {
+  vec2 r, s, t, x;
+
+  if (a.x == 0.0 && a.y == 0.0) {
+    return vec2(0.0, 0.0);
   }
-  function exactEquals(a, b) {
-    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+
+  x = -mul_fp64(a, a);
+  s = a;
+  r = a;
+
+  r = mul_fp64(r, x);
+  t = mul_fp64(r, INVERSE_FACTORIAL_3_FP64);
+  s = sum_fp64(s, t);
+
+  r = mul_fp64(r, x);
+  t = mul_fp64(r, INVERSE_FACTORIAL_5_FP64);
+  s = sum_fp64(s, t);
+
+  /* keep the following commented code in case we need them
+  for extra accuracy from the Taylor expansion*/
+
+  // r = mul_fp64(r, x);
+  // t = mul_fp64(r, INVERSE_FACTORIAL_7_FP64);
+  // s = sum_fp64(s, t);
+
+  // r = mul_fp64(r, x);
+  // t = mul_fp64(r, INVERSE_FACTORIAL_9_FP64);
+  // s = sum_fp64(s, t);
+
+  return s;
+}
+
+vec2 cos_taylor_fp64(vec2 a) {
+  vec2 r, s, t, x;
+
+  if (a.x == 0.0 && a.y == 0.0) {
+    return vec2(1.0, 0.0);
   }
-  function equals2(a, b) {
-    const a0 = a[0];
-    const a1 = a[1];
-    const a2 = a[2];
-    const b0 = b[0];
-    const b1 = b[1];
-    const b2 = b[2];
-    return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2));
+
+  x = -mul_fp64(a, a);
+  r = x;
+  s = sum_fp64(vec2(1.0, 0.0), r * 0.5);
+
+  r = mul_fp64(r, x);
+  t = mul_fp64(r, INVERSE_FACTORIAL_4_FP64);
+  s = sum_fp64(s, t);
+
+  r = mul_fp64(r, x);
+  t = mul_fp64(r, INVERSE_FACTORIAL_6_FP64);
+  s = sum_fp64(s, t);
+
+  /* keep the following commented code in case we need them
+  for extra accuracy from the Taylor expansion*/
+
+  // r = mul_fp64(r, x);
+  // t = mul_fp64(r, INVERSE_FACTORIAL_8_FP64);
+  // s = sum_fp64(s, t);
+
+  // r = mul_fp64(r, x);
+  // t = mul_fp64(r, INVERSE_FACTORIAL_10_FP64);
+  // s = sum_fp64(s, t);
+
+  return s;
+}
+
+void sincos_taylor_fp64(vec2 a, out vec2 sin_t, out vec2 cos_t) {
+  if (a.x == 0.0 && a.y == 0.0) {
+    sin_t = vec2(0.0, 0.0);
+    cos_t = vec2(1.0, 0.0);
   }
-  var sub = subtract;
-  var mul = multiply;
-  var div = divide;
-  var dist = distance;
-  var sqrDist = squaredDistance;
-  var len = length;
-  var sqrLen = squaredLength;
-  var forEach = function() {
-    const vec = create();
-    return function(a, stride, offset, count, fn, arg) {
-      let i;
-      let l;
-      if (!stride) {
-        stride = 3;
-      }
-      if (!offset) {
-        offset = 0;
-      }
-      if (count) {
-        l = Math.min(count * stride + offset, a.length);
-      } else {
-        l = a.length;
-      }
-      for (i = offset; i < l; i += stride) {
-        vec[0] = a[i];
-        vec[1] = a[i + 1];
-        vec[2] = a[i + 2];
-        fn(vec, vec, arg);
-        a[i] = vec[0];
-        a[i + 1] = vec[1];
-        a[i + 2] = vec[2];
-      }
-      return a;
-    };
-  }();
 
-  // ../../node_modules/@luma.gl/engine/dist/geometry/gpu-geometry.js
-  var import_core34 = __toESM(require_core2(), 1);
-  var GPUGeometry = class {
-    constructor(props) {
-      this.id = void 0;
-      this.userData = {};
-      this.topology = void 0;
-      this.bufferLayout = [];
-      this.vertexCount = void 0;
-      this.indices = void 0;
-      this.attributes = void 0;
-      this.id = props.id || (0, import_core34.uid)("geometry");
-      this.topology = props.topology;
-      this.indices = props.indices || null;
-      this.attributes = props.attributes;
-      this.vertexCount = props.vertexCount;
-      this.bufferLayout = props.bufferLayout || [];
-      if (this.indices) {
-        (0, import_core34.assert)(this.indices.usage === import_core34.Buffer.INDEX);
-      }
-    }
-    destroy() {
-      var _this$attributes$colo;
-      this.indices.destroy();
-      this.attributes.positions.destroy();
-      this.attributes.normals.destroy();
-      this.attributes.texCoords.destroy();
-      (_this$attributes$colo = this.attributes.colors) === null || _this$attributes$colo === void 0 ? void 0 : _this$attributes$colo.destroy();
-    }
-    getVertexCount() {
-      return this.vertexCount;
-    }
-    getAttributes() {
-      return this.attributes;
-    }
-    getIndexes() {
-      return this.indices;
-    }
-    _calculateVertexCount(positions) {
-      const vertexCount = positions.byteLength / 12;
-      return vertexCount;
-    }
-  };
-  function makeGPUGeometry(device, geometry) {
-    if (geometry instanceof GPUGeometry) {
-      return geometry;
-    }
-    const indices = getIndexBufferFromGeometry(device, geometry);
-    const {
-      attributes,
-      bufferLayout
-    } = getAttributeBuffersFromGeometry(device, geometry);
-    return new GPUGeometry({
-      topology: geometry.topology || "triangle-list",
-      bufferLayout,
-      vertexCount: geometry.vertexCount,
-      indices,
-      attributes
-    });
+  sin_t = sin_taylor_fp64(a);
+  cos_t = sqrt_fp64(sub_fp64(vec2(1.0, 0.0), mul_fp64(sin_t, sin_t)));
+}
+
+vec2 sin_fp64(vec2 a) {
+    if (a.x == 0.0 && a.y == 0.0) {
+        return vec2(0.0, 0.0);
+    }
+
+    // 2pi range reduction
+    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
+    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
+
+    vec2 t;
+    float q = floor(r.x / PI_2_FP64.x + 0.5);
+    int j = int(q);
+
+    if (j < -2 || j > 2) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    }
+
+    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
+
+    q = floor(t.x / PI_16_FP64.x + 0.5);
+    int k = int(q);
+
+    if (k == 0) {
+        if (j == 0) {
+            return sin_taylor_fp64(t);
+        } else if (j == 1) {
+            return cos_taylor_fp64(t);
+        } else if (j == -1) {
+            return -cos_taylor_fp64(t);
+        } else {
+            return -sin_taylor_fp64(t);
+        }
+    }
+
+    int abs_k = int(abs(float(k)));
+
+    if (abs_k > 4) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    } else {
+        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+    }
+
+    vec2 u = vec2(0.0, 0.0);
+    vec2 v = vec2(0.0, 0.0);
+
+#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
+    if (abs(float(abs_k) - 1.0) < 0.5) {
+        u = COS_TABLE_0_FP64;
+        v = SIN_TABLE_0_FP64;
+    } else if (abs(float(abs_k) - 2.0) < 0.5) {
+        u = COS_TABLE_1_FP64;
+        v = SIN_TABLE_1_FP64;
+    } else if (abs(float(abs_k) - 3.0) < 0.5) {
+        u = COS_TABLE_2_FP64;
+        v = SIN_TABLE_2_FP64;
+    } else if (abs(float(abs_k) - 4.0) < 0.5) {
+        u = COS_TABLE_3_FP64;
+        v = SIN_TABLE_3_FP64;
+    }
+#else
+    if (abs_k == 1) {
+        u = COS_TABLE_0_FP64;
+        v = SIN_TABLE_0_FP64;
+    } else if (abs_k == 2) {
+        u = COS_TABLE_1_FP64;
+        v = SIN_TABLE_1_FP64;
+    } else if (abs_k == 3) {
+        u = COS_TABLE_2_FP64;
+        v = SIN_TABLE_2_FP64;
+    } else if (abs_k == 4) {
+        u = COS_TABLE_3_FP64;
+        v = SIN_TABLE_3_FP64;
+    }
+#endif
+
+    vec2 sin_t, cos_t;
+    sincos_taylor_fp64(t, sin_t, cos_t);
+
+
+
+    vec2 result = vec2(0.0, 0.0);
+    if (j == 0) {
+        if (k > 0) {
+            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        } else {
+            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        }
+    } else if (j == 1) {
+        if (k > 0) {
+            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        } else {
+            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        }
+    } else if (j == -1) {
+        if (k > 0) {
+            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
+        } else {
+            result = -sum_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
+        }
+    } else {
+        if (k > 0) {
+            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        } else {
+            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
+        }
+    }
+
+    return result;
+}
+
+vec2 cos_fp64(vec2 a) {
+    if (a.x == 0.0 && a.y == 0.0) {
+        return vec2(1.0, 0.0);
+    }
+
+    // 2pi range reduction
+    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
+    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
+
+    vec2 t;
+    float q = floor(r.x / PI_2_FP64.x + 0.5);
+    int j = int(q);
+
+    if (j < -2 || j > 2) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    }
+
+    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
+
+    q = floor(t.x / PI_16_FP64.x + 0.5);
+    int k = int(q);
+
+    if (k == 0) {
+        if (j == 0) {
+            return cos_taylor_fp64(t);
+        } else if (j == 1) {
+            return -sin_taylor_fp64(t);
+        } else if (j == -1) {
+            return sin_taylor_fp64(t);
+        } else {
+            return -cos_taylor_fp64(t);
+        }
+    }
+
+    int abs_k = int(abs(float(k)));
+
+    if (abs_k > 4) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    } else {
+        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+    }
+
+    vec2 u = vec2(0.0, 0.0);
+    vec2 v = vec2(0.0, 0.0);
+
+#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
+    if (abs(float(abs_k) - 1.0) < 0.5) {
+        u = COS_TABLE_0_FP64;
+        v = SIN_TABLE_0_FP64;
+    } else if (abs(float(abs_k) - 2.0) < 0.5) {
+        u = COS_TABLE_1_FP64;
+        v = SIN_TABLE_1_FP64;
+    } else if (abs(float(abs_k) - 3.0) < 0.5) {
+        u = COS_TABLE_2_FP64;
+        v = SIN_TABLE_2_FP64;
+    } else if (abs(float(abs_k) - 4.0) < 0.5) {
+        u = COS_TABLE_3_FP64;
+        v = SIN_TABLE_3_FP64;
+    }
+#else
+    if (abs_k == 1) {
+        u = COS_TABLE_0_FP64;
+        v = SIN_TABLE_0_FP64;
+    } else if (abs_k == 2) {
+        u = COS_TABLE_1_FP64;
+        v = SIN_TABLE_1_FP64;
+    } else if (abs_k == 3) {
+        u = COS_TABLE_2_FP64;
+        v = SIN_TABLE_2_FP64;
+    } else if (abs_k == 4) {
+        u = COS_TABLE_3_FP64;
+        v = SIN_TABLE_3_FP64;
+    }
+#endif
+
+    vec2 sin_t, cos_t;
+    sincos_taylor_fp64(t, sin_t, cos_t);
+
+    vec2 result = vec2(0.0, 0.0);
+    if (j == 0) {
+        if (k > 0) {
+            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        } else {
+            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        }
+    } else if (j == 1) {
+        if (k > 0) {
+            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        } else {
+            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
+        }
+    } else if (j == -1) {
+        if (k > 0) {
+            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        } else {
+            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        }
+    } else {
+        if (k > 0) {
+            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
+        } else {
+            result = -sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        }
+    }
+
+    return result;
+}
+
+vec2 tan_fp64(vec2 a) {
+    vec2 sin_a;
+    vec2 cos_a;
+
+    if (a.x == 0.0 && a.y == 0.0) {
+        return vec2(0.0, 0.0);
+    }
+
+    // 2pi range reduction
+    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
+    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
+
+    vec2 t;
+    float q = floor(r.x / PI_2_FP64.x + 0.5);
+    int j = int(q);
+
+
+    if (j < -2 || j > 2) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    }
+
+    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
+
+    q = floor(t.x / PI_16_FP64.x + 0.5);
+    int k = int(q);
+    int abs_k = int(abs(float(k)));
+
+    // We just can't get PI/16 * 3.0 very accurately.
+    // so let's just store it
+    if (abs_k > 4) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    } else {
+        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+    }
+
+
+    vec2 u = vec2(0.0, 0.0);
+    vec2 v = vec2(0.0, 0.0);
+
+    vec2 sin_t, cos_t;
+    vec2 s, c;
+    sincos_taylor_fp64(t, sin_t, cos_t);
+
+    if (k == 0) {
+        s = sin_t;
+        c = cos_t;
+    } else {
+#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
+        if (abs(float(abs_k) - 1.0) < 0.5) {
+            u = COS_TABLE_0_FP64;
+            v = SIN_TABLE_0_FP64;
+        } else if (abs(float(abs_k) - 2.0) < 0.5) {
+            u = COS_TABLE_1_FP64;
+            v = SIN_TABLE_1_FP64;
+        } else if (abs(float(abs_k) - 3.0) < 0.5) {
+            u = COS_TABLE_2_FP64;
+            v = SIN_TABLE_2_FP64;
+        } else if (abs(float(abs_k) - 4.0) < 0.5) {
+            u = COS_TABLE_3_FP64;
+            v = SIN_TABLE_3_FP64;
+        }
+#else
+        if (abs_k == 1) {
+            u = COS_TABLE_0_FP64;
+            v = SIN_TABLE_0_FP64;
+        } else if (abs_k == 2) {
+            u = COS_TABLE_1_FP64;
+            v = SIN_TABLE_1_FP64;
+        } else if (abs_k == 3) {
+            u = COS_TABLE_2_FP64;
+            v = SIN_TABLE_2_FP64;
+        } else if (abs_k == 4) {
+            u = COS_TABLE_3_FP64;
+            v = SIN_TABLE_3_FP64;
+        }
+#endif
+        if (k > 0) {
+            s = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+            c = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        } else {
+            s = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+            c = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        }
+    }
+
+    if (j == 0) {
+        sin_a = s;
+        cos_a = c;
+    } else if (j == 1) {
+        sin_a = c;
+        cos_a = -s;
+    } else if (j == -1) {
+        sin_a = -c;
+        cos_a = s;
+    } else {
+        sin_a = -s;
+        cos_a = -c;
+    }
+    return div_fp64(sin_a, cos_a);
+}
+
+vec2 radians_fp64(vec2 degree) {
+  return mul_fp64(degree, PI_180_FP64);
+}
+
+vec2 mix_fp64(vec2 a, vec2 b, float x) {
+  vec2 range = sub_fp64(b, a);
+  return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));
+}
+
+// Vector functions
+// vec2 functions
+void vec2_sum_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
+    out_val[0] = sum_fp64(a[0], b[0]);
+    out_val[1] = sum_fp64(a[1], b[1]);
+}
+
+void vec2_sub_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
+    out_val[0] = sub_fp64(a[0], b[0]);
+    out_val[1] = sub_fp64(a[1], b[1]);
+}
+
+void vec2_mul_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
+    out_val[0] = mul_fp64(a[0], b[0]);
+    out_val[1] = mul_fp64(a[1], b[1]);
+}
+
+void vec2_div_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
+    out_val[0] = div_fp64(a[0], b[0]);
+    out_val[1] = div_fp64(a[1], b[1]);
+}
+
+void vec2_mix_fp64(vec2 x[2], vec2 y[2], float a, out vec2 out_val[2]) {
+  vec2 range[2];
+  vec2_sub_fp64(y, x, range);
+  vec2 portion[2];
+  portion[0] = range[0] * a;
+  portion[1] = range[1] * a;
+  vec2_sum_fp64(x, portion, out_val);
+}
+
+vec2 vec2_length_fp64(vec2 x[2]) {
+  return sqrt_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])));
+}
+
+void vec2_normalize_fp64(vec2 x[2], out vec2 out_val[2]) {
+  vec2 length = vec2_length_fp64(x);
+  vec2 length_vec2[2];
+  length_vec2[0] = length;
+  length_vec2[1] = length;
+
+  vec2_div_fp64(x, length_vec2, out_val);
+}
+
+vec2 vec2_distance_fp64(vec2 x[2], vec2 y[2]) {
+  vec2 diff[2];
+  vec2_sub_fp64(x, y, diff);
+  return vec2_length_fp64(diff);
+}
+
+vec2 vec2_dot_fp64(vec2 a[2], vec2 b[2]) {
+  vec2 v[2];
+
+  v[0] = mul_fp64(a[0], b[0]);
+  v[1] = mul_fp64(a[1], b[1]);
+
+  return sum_fp64(v[0], v[1]);
+}
+
+// vec3 functions
+void vec3_sub_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {
+  for (int i = 0; i < 3; i++) {
+    out_val[i] = sum_fp64(a[i], b[i]);
   }
-  function getIndexBufferFromGeometry(device, geometry) {
-    if (!geometry.indices) {
-      return void 0;
-    }
-    const data = geometry.indices.value;
-    return device.createBuffer({
-      usage: import_core34.Buffer.INDEX,
-      data
-    });
+}
+
+void vec3_sum_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {
+  for (int i = 0; i < 3; i++) {
+    out_val[i] = sum_fp64(a[i], b[i]);
   }
-  function getAttributeBuffersFromGeometry(device, geometry) {
-    const bufferLayout = [];
-    const attributes = {};
-    for (const [attributeName, attribute] of Object.entries(geometry.attributes)) {
-      let name = attributeName;
-      switch (attributeName) {
-        case "POSITION":
-          name = "positions";
-          break;
-        case "NORMAL":
-          name = "normals";
-          break;
-        case "TEXCOORD_0":
-          name = "texCoords";
-          break;
-      }
-      attributes[name] = device.createBuffer({
-        data: attribute.value,
-        id: `${attributeName}-buffer`
-      });
-      bufferLayout.push({
-        name,
-        format: `float32x${attribute.size}`
-      });
-    }
-    const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices);
-    return {
-      attributes,
-      bufferLayout,
-      vertexCount
-    };
+}
+
+vec2 vec3_length_fp64(vec2 x[3]) {
+  return sqrt_fp64(sum_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])),
+    mul_fp64(x[2], x[2])));
+}
+
+vec2 vec3_distance_fp64(vec2 x[3], vec2 y[3]) {
+  vec2 diff[3];
+  vec3_sub_fp64(x, y, diff);
+  return vec3_length_fp64(diff);
+}
+
+// vec4 functions
+void vec4_fp64(vec4 a, out vec2 out_val[4]) {
+  out_val[0].x = a[0];
+  out_val[0].y = 0.0;
+
+  out_val[1].x = a[1];
+  out_val[1].y = 0.0;
+
+  out_val[2].x = a[2];
+  out_val[2].y = 0.0;
+
+  out_val[3].x = a[3];
+  out_val[3].y = 0.0;
+}
+
+void vec4_scalar_mul_fp64(vec2 a[4], vec2 b, out vec2 out_val[4]) {
+  out_val[0] = mul_fp64(a[0], b);
+  out_val[1] = mul_fp64(a[1], b);
+  out_val[2] = mul_fp64(a[2], b);
+  out_val[3] = mul_fp64(a[3], b);
+}
+
+void vec4_sum_fp64(vec2 a[4], vec2 b[4], out vec2 out_val[4]) {
+  for (int i = 0; i < 4; i++) {
+    out_val[i] = sum_fp64(a[i], b[i]);
   }
+}
 
-  // ../../node_modules/@luma.gl/engine/dist/lib/pipeline-factory.js
-  var import_core35 = __toESM(require_core2(), 1);
-  var PipelineFactory = class {
-    static getDefaultPipelineFactory(device) {
-      device._lumaData.defaultPipelineFactory = device._lumaData.defaultPipelineFactory || new PipelineFactory(device);
-      return device._lumaData.defaultPipelineFactory;
-    }
-    constructor(device) {
-      this.device = void 0;
-      this._hashCounter = 0;
-      this._hashes = {};
-      this._useCounts = {};
-      this._pipelineCache = {};
-      this.device = device;
-    }
-    createRenderPipeline(options) {
-      const props = {
-        ...PipelineFactory.defaultProps,
-        ...options
-      };
-      const hash = this._hashRenderPipeline({
-        ...props
-      });
-      if (!this._pipelineCache[hash]) {
-        const pipeline = this.device.createRenderPipeline({
-          ...props,
-          vs: this.device.createShader({
-            stage: "vertex",
-            source: props.vs
-          }),
-          fs: props.fs ? this.device.createShader({
-            stage: "fragment",
-            source: props.fs
-          }) : null
-        });
-        pipeline.hash = hash;
-        this._pipelineCache[hash] = pipeline;
-        this._useCounts[hash] = 0;
-      }
-      this._useCounts[hash]++;
-      return this._pipelineCache[hash];
-    }
-    release(pipeline) {
-      const hash = pipeline.hash;
-      this._useCounts[hash]--;
-      if (this._useCounts[hash] === 0) {
-        this._pipelineCache[hash].destroy();
-        delete this._pipelineCache[hash];
-        delete this._useCounts[hash];
-      }
-    }
-    _createRenderPipeline(props) {
-      if (!props.fs) {
-        throw new Error("fs");
-      }
-      const pipeline = this.device.createRenderPipeline({
-        ...props,
-        vs: this.device.createShader({
-          stage: "vertex",
-          source: props.vs
-        }),
-        fs: props.fs ? this.device.createShader({
-          stage: "fragment",
-          source: props.fs
-        }) : null
-      });
-      return pipeline;
-    }
-    _hashRenderPipeline(props) {
-      const vsHash = this._getHash(props.vs);
-      const fsHash = props.fs ? this._getHash(props.fs) : 0;
-      const varyingHash = "-";
-      switch (this.device.info.type) {
-        case "webgpu":
-          const parameterHash = this._getHash(JSON.stringify(props.parameters));
-          const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout));
-          return `${vsHash}/${fsHash}V${varyingHash}T${props.topology}P${parameterHash}BL${bufferLayoutHash}}`;
-        default:
-          return `${vsHash}/${fsHash}V${varyingHash}`;
-      }
-    }
-    _getHash(key) {
-      if (this._hashes[key] === void 0) {
-        this._hashes[key] = this._hashCounter++;
-      }
-      return this._hashes[key];
+void vec4_dot_fp64(vec2 a[4], vec2 b[4], out vec2 out_val) {
+  vec2 v[4];
+
+  v[0] = mul_fp64(a[0], b[0]);
+  v[1] = mul_fp64(a[1], b[1]);
+  v[2] = mul_fp64(a[2], b[2]);
+  v[3] = mul_fp64(a[3], b[3]);
+
+  out_val = sum_fp64(sum_fp64(v[0], v[1]), sum_fp64(v[2], v[3]));
+}
+
+void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
+  vec2 tmp[4];
+
+  for (int i = 0; i < 4; i++)
+  {
+    for (int j = 0; j < 4; j++)
+    {
+      tmp[j] = b[j + i * 4];
     }
+    vec4_dot_fp64(a, tmp, out_val[i]);
+  }
+}
+`;
+
+  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64.js
+  var CONST_UNIFORMS = {
+    ONE: 1
   };
-  PipelineFactory.defaultProps = {
-    ...import_core35.RenderPipeline.defaultProps,
-    vs: void 0,
-    fs: void 0
+  function getUniforms2() {
+    return CONST_UNIFORMS;
+  }
+  var fp64arithmetic = {
+    name: "fp64-arithmetic",
+    vs: fp64arithmeticShader,
+    getUniforms: getUniforms2,
+    fp64ify,
+    fp64LowPart,
+    fp64ifyMatrix4
+  };
+  var fp64 = {
+    name: "fp64",
+    vs: fp64functionShader,
+    dependencies: [fp64arithmetic],
+    fp64ify,
+    fp64LowPart,
+    fp64ifyMatrix4
   };
 
-  // ../../node_modules/@luma.gl/engine/dist/model/model.js
-  var Model = class {
-    constructor(device, props) {
-      this.device = void 0;
-      this.id = void 0;
-      this.vs = void 0;
-      this.fs = void 0;
-      this.pipelineFactory = void 0;
-      this.userData = {};
-      this.parameters = void 0;
-      this.topology = void 0;
-      this.bufferLayout = void 0;
-      this.vertexCount = void 0;
-      this.instanceCount = 0;
-      this.indexBuffer = null;
-      this.bufferAttributes = {};
-      this.constantAttributes = {};
-      this.bindings = {};
-      this.uniforms = {};
-      this.pipeline = void 0;
-      this.vertexArray = void 0;
-      this._pipelineNeedsUpdate = "newly created";
-      this._attributeInfos = {};
-      this._gpuGeometry = null;
-      this._getModuleUniforms = void 0;
-      this.props = void 0;
-      this.props = {
-        ...Model.defaultProps,
-        ...props
-      };
-      props = this.props;
-      this.id = props.id || (0, import_core36.uid)("model");
-      this.device = device;
-      Object.assign(this.userData, props.userData);
-      const platformInfo = {
-        type: device.info.type,
-        shaderLanguage: device.info.shadingLanguages[0],
-        gpu: device.info.gpu,
-        features: device.features
-      };
-      const {
-        vs: vs5,
-        fs: fs4,
-        getUniforms: getUniforms4
-      } = this.props.shaderAssembler.assembleShaders(platformInfo, this.props);
-      this.vs = vs5;
-      this.fs = fs4;
-      this._getModuleUniforms = getUniforms4;
-      this.vertexCount = this.props.vertexCount;
-      this.instanceCount = this.props.instanceCount;
-      this.topology = this.props.topology;
-      this.bufferLayout = this.props.bufferLayout;
-      this.parameters = this.props.parameters;
-      if (props.geometry) {
-        this._gpuGeometry = this.setGeometry(props.geometry);
-      }
-      this.pipelineFactory = props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);
-      this.pipeline = this._updatePipeline();
-      this.vertexArray = device.createVertexArray({
-        renderPipeline: this.pipeline
-      });
-      if (this._gpuGeometry) {
-        this._setGeometryAttributes(this._gpuGeometry);
-      }
-      if (props.vertexCount) {
-        this.setVertexCount(props.vertexCount);
-      }
-      if (props.instanceCount) {
-        this.setInstanceCount(props.instanceCount);
-      }
-      if (props.indices) {
-        throw new Error("Model.props.indices removed. Use props.indexBuffer");
-      }
-      if (props.indexBuffer) {
-        this.setIndexBuffer(props.indexBuffer);
-      }
-      if (props.attributes) {
-        this.setAttributes(props.attributes);
-      }
-      if (props.constantAttributes) {
-        this.setConstantAttributes(props.constantAttributes);
-      }
-      if (props.bindings) {
-        this.setBindings(props.bindings);
-      }
-      if (props.uniforms) {
-        this.setUniforms(props.uniforms);
-      }
-      if (props.moduleSettings) {
-        this.updateModuleSettings(props.moduleSettings);
-      }
-      this.setUniforms(this._getModuleUniforms());
-      Object.seal(this);
-    }
-    destroy() {
-      this.pipelineFactory.release(this.pipeline);
-    }
-    draw(renderPass) {
-      this.pipeline = this._updatePipeline();
-      this.pipeline.setBindings(this.bindings);
-      this.pipeline.setUniforms(this.uniforms);
-      this.pipeline.draw({
-        renderPass,
-        vertexArray: this.vertexArray,
-        vertexCount: this.vertexCount,
-        instanceCount: this.instanceCount
-      });
-    }
-    setGeometry(geometry) {
-      const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
-      this.setTopology(gpuGeometry.topology || "triangle-list");
-      this.bufferLayout = mergeBufferLayouts(this.bufferLayout, gpuGeometry.bufferLayout);
-      if (this.vertexArray) {
-        this._setGeometryAttributes(gpuGeometry);
-      }
-      return gpuGeometry;
-    }
-    _setGeometryAttributes(gpuGeometry) {
-      this.vertexCount = gpuGeometry.vertexCount;
-      this.setAttributes(gpuGeometry.attributes);
-      this.setIndexBuffer(gpuGeometry.indices);
-    }
-    setTopology(topology) {
-      if (topology !== this.topology) {
-        this.topology = topology;
-        this._setPipelineNeedsUpdate("topology");
-      }
-    }
-    setBufferLayout(bufferLayout) {
-      this.bufferLayout = this._gpuGeometry ? mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout) : bufferLayout;
-      this._setPipelineNeedsUpdate("bufferLayout");
-      this.pipeline = this._updatePipeline();
-      this.vertexArray = this.device.createVertexArray({
-        renderPipeline: this.pipeline
-      });
-      if (this._gpuGeometry) {
-        this._setGeometryAttributes(this._gpuGeometry);
-      }
-    }
-    setParameters(parameters2) {
-      if (!(0, import_core36.deepEqual)(parameters2, this.parameters, 2)) {
-        this.parameters = parameters2;
-        this._setPipelineNeedsUpdate("parameters");
-      }
-    }
-    setVertexCount(vertexCount) {
-      this.vertexCount = vertexCount;
-    }
-    setInstanceCount(instanceCount) {
-      this.instanceCount = instanceCount;
-    }
-    setShaderModuleProps(props) {
-      const uniforms = this._getModuleUniforms(props);
-      const keys = Object.keys(uniforms).filter((k) => {
-        const uniform = uniforms[k];
-        return !(0, import_core36.isNumberArray)(uniform) && typeof uniform !== "number" && typeof uniform !== "boolean";
-      });
-      const bindings = {};
-      for (const k of keys) {
-        bindings[k] = uniforms[k];
-        delete uniforms[k];
-      }
-      Object.assign(this.uniforms, uniforms);
-      Object.assign(this.bindings, bindings);
-    }
-    updateModuleSettings(props) {
-      this.setShaderModuleProps(props);
-    }
-    setBindings(bindings) {
-      Object.assign(this.bindings, bindings);
-    }
-    setUniforms(uniforms) {
-      this.pipeline.setUniforms(uniforms);
-      Object.assign(this.uniforms, uniforms);
+  // ../../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
     }
-    setIndexBuffer(indexBuffer) {
-      this.vertexArray.setIndexBuffer(indexBuffer);
+  };
+  var config = globalThis.mathgl.config;
+  function isArray2(value) {
+    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  function equals(a, b, epsilon) {
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+      config.EPSILON = epsilon;
     }
-    setAttributes(buffers) {
-      if (buffers.indices) {
-        import_core36.log.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`);
+    try {
+      if (a === b) {
+        return true;
       }
-      for (const [bufferName, buffer] of Object.entries(buffers)) {
-        var _bufferLayout$attribu;
-        const bufferLayout = this.bufferLayout.find((layout) => layout.name === bufferName);
-        if (!bufferLayout) {
-          continue;
-        }
-        const attributeNames = bufferLayout.attributes ? (_bufferLayout$attribu = bufferLayout.attributes) === null || _bufferLayout$attribu === void 0 ? void 0 : _bufferLayout$attribu.map((layout) => layout.attribute) : [bufferLayout.name];
-        let set2 = false;
-        for (const attributeName of attributeNames) {
-          const attributeInfo = this._attributeInfos[attributeName];
-          if (attributeInfo) {
-            this.vertexArray.setBuffer(attributeInfo.location, buffer);
-            set2 = true;
-          }
+      if (isArray2(a) && isArray2(b)) {
+        if (a.length !== b.length) {
+          return false;
         }
-        if (!set2) {
-          import_core36.log.warn(`Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`)();
+        for (let i = 0; i < a.length; ++i) {
+          if (!equals(a[i], b[i])) {
+            return false;
+          }
         }
+        return true;
       }
-    }
-    setConstantAttributes(attributes) {
-      for (const [attributeName, value] of Object.entries(attributes)) {
-        const attributeInfo = this._attributeInfos[attributeName];
-        if (attributeInfo) {
-          this.vertexArray.setConstant(attributeInfo.location, value);
-        } else {
-          import_core36.log.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)();
-        }
+      if (a && a.equals) {
+        return a.equals(b);
       }
-    }
-    _setPipelineNeedsUpdate(reason) {
-      this._pipelineNeedsUpdate = this._pipelineNeedsUpdate || reason;
-    }
-    _updatePipeline() {
-      if (this._pipelineNeedsUpdate) {
-        if (this.pipeline) {
-          import_core36.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
-        }
-        this._pipelineNeedsUpdate = false;
-        this.pipeline = this.device.createRenderPipeline({
-          ...this.props,
-          bufferLayout: this.bufferLayout,
-          topology: this.topology,
-          parameters: this.parameters,
-          vs: this.device.createShader({
-            id: "{$this.id}-vertex",
-            stage: "vertex",
-            source: this.vs
-          }),
-          fs: this.fs ? this.device.createShader({
-            id: "{$this.id}-fragment",
-            stage: "fragment",
-            source: this.fs
-          }) : null
-        });
-        this._attributeInfos = (0, import_core37.getAttributeInfosFromLayouts)(this.pipeline.shaderLayout, this.bufferLayout);
+      if (b && b.equals) {
+        return b.equals(a);
       }
-      return this.pipeline;
-    }
-  };
-  Model.defaultProps = {
-    ...import_core36.RenderPipeline.defaultProps,
-    vs: null,
-    fs: null,
-    id: "unnamed",
-    handle: void 0,
-    userData: {},
-    defines: {},
-    modules: [],
-    moduleSettings: {},
-    geometry: null,
-    indexBuffer: null,
-    attributes: {},
-    constantAttributes: {},
-    pipelineFactory: void 0,
-    shaderAssembler: ShaderAssembler.getDefaultShaderAssembler()
-  };
-  function mergeBufferLayouts(layouts1, layouts2) {
-    const layouts = [...layouts1];
-    for (const attribute of layouts2) {
-      const index = layouts.findIndex((attribute2) => attribute2.name === attribute.name);
-      if (index < 0) {
-        layouts.push(attribute);
-      } else {
-        layouts[index] = attribute;
+      if (typeof a === "number" && typeof b === "number") {
+        return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
       }
+      return false;
+    } finally {
+      config.EPSILON = oldEpsilon;
+    }
+  }
+
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/common.js
+  var EPSILON = 1e-6;
+  var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+  var RANDOM = Math.random;
+  function round(a) {
+    if (a >= 0)
+      return Math.round(a);
+    return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
+  }
+  var degree = Math.PI / 180;
+
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec3.js
+  var vec3_exports = {};
+  __export(vec3_exports, {
+    add: () => add,
+    angle: () => angle,
+    bezier: () => bezier,
+    ceil: () => ceil,
+    clone: () => clone,
+    copy: () => copy,
+    create: () => create,
+    cross: () => cross,
+    dist: () => dist,
+    distance: () => distance,
+    div: () => div,
+    divide: () => divide,
+    dot: () => dot,
+    equals: () => equals2,
+    exactEquals: () => exactEquals,
+    floor: () => floor,
+    forEach: () => forEach,
+    fromValues: () => fromValues,
+    hermite: () => hermite,
+    inverse: () => inverse,
+    len: () => len,
+    length: () => length,
+    lerp: () => lerp,
+    max: () => max,
+    min: () => min,
+    mul: () => mul,
+    multiply: () => multiply,
+    negate: () => negate,
+    normalize: () => normalize,
+    random: () => random,
+    rotateX: () => rotateX,
+    rotateY: () => rotateY,
+    rotateZ: () => rotateZ,
+    round: () => round2,
+    scale: () => scale,
+    scaleAndAdd: () => scaleAndAdd,
+    set: () => set,
+    slerp: () => slerp,
+    sqrDist: () => sqrDist,
+    sqrLen: () => sqrLen,
+    squaredDistance: () => squaredDistance,
+    squaredLength: () => squaredLength,
+    str: () => str,
+    sub: () => sub,
+    subtract: () => subtract,
+    transformMat3: () => transformMat3,
+    transformMat4: () => transformMat4,
+    transformQuat: () => transformQuat,
+    zero: () => zero
+  });
+  function create() {
+    const out = new ARRAY_TYPE(3);
+    if (ARRAY_TYPE != Float32Array) {
+      out[0] = 0;
+      out[1] = 0;
+      out[2] = 0;
+    }
+    return out;
+  }
+  function clone(a) {
+    const out = new ARRAY_TYPE(3);
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    return out;
+  }
+  function length(a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    return Math.sqrt(x * x + y * y + z * z);
+  }
+  function fromValues(x, y, z) {
+    const out = new ARRAY_TYPE(3);
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    return out;
+  }
+  function copy(out, a) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    return out;
+  }
+  function set(out, x, y, z) {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    return out;
+  }
+  function add(out, a, b) {
+    out[0] = a[0] + b[0];
+    out[1] = a[1] + b[1];
+    out[2] = a[2] + b[2];
+    return out;
+  }
+  function subtract(out, a, b) {
+    out[0] = a[0] - b[0];
+    out[1] = a[1] - b[1];
+    out[2] = a[2] - b[2];
+    return out;
+  }
+  function multiply(out, a, b) {
+    out[0] = a[0] * b[0];
+    out[1] = a[1] * b[1];
+    out[2] = a[2] * b[2];
+    return out;
+  }
+  function divide(out, a, b) {
+    out[0] = a[0] / b[0];
+    out[1] = a[1] / b[1];
+    out[2] = a[2] / b[2];
+    return out;
+  }
+  function ceil(out, a) {
+    out[0] = Math.ceil(a[0]);
+    out[1] = Math.ceil(a[1]);
+    out[2] = Math.ceil(a[2]);
+    return out;
+  }
+  function floor(out, a) {
+    out[0] = Math.floor(a[0]);
+    out[1] = Math.floor(a[1]);
+    out[2] = Math.floor(a[2]);
+    return out;
+  }
+  function min(out, a, b) {
+    out[0] = Math.min(a[0], b[0]);
+    out[1] = Math.min(a[1], b[1]);
+    out[2] = Math.min(a[2], b[2]);
+    return out;
+  }
+  function max(out, a, b) {
+    out[0] = Math.max(a[0], b[0]);
+    out[1] = Math.max(a[1], b[1]);
+    out[2] = Math.max(a[2], b[2]);
+    return out;
+  }
+  function round2(out, a) {
+    out[0] = round(a[0]);
+    out[1] = round(a[1]);
+    out[2] = round(a[2]);
+    return out;
+  }
+  function scale(out, a, b) {
+    out[0] = a[0] * b;
+    out[1] = a[1] * b;
+    out[2] = a[2] * b;
+    return out;
+  }
+  function scaleAndAdd(out, a, b, scale2) {
+    out[0] = a[0] + b[0] * scale2;
+    out[1] = a[1] + b[1] * scale2;
+    out[2] = a[2] + b[2] * scale2;
+    return out;
+  }
+  function distance(a, b) {
+    const x = b[0] - a[0];
+    const y = b[1] - a[1];
+    const z = b[2] - a[2];
+    return Math.sqrt(x * x + y * y + z * z);
+  }
+  function squaredDistance(a, b) {
+    const x = b[0] - a[0];
+    const y = b[1] - a[1];
+    const z = b[2] - a[2];
+    return x * x + y * y + z * z;
+  }
+  function squaredLength(a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    return x * x + y * y + z * z;
+  }
+  function negate(out, a) {
+    out[0] = -a[0];
+    out[1] = -a[1];
+    out[2] = -a[2];
+    return out;
+  }
+  function inverse(out, a) {
+    out[0] = 1 / a[0];
+    out[1] = 1 / a[1];
+    out[2] = 1 / a[2];
+    return out;
+  }
+  function normalize(out, a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    let len2 = x * x + y * y + z * z;
+    if (len2 > 0) {
+      len2 = 1 / Math.sqrt(len2);
     }
-    return layouts;
+    out[0] = a[0] * len2;
+    out[1] = a[1] * len2;
+    out[2] = a[2] * len2;
+    return out;
   }
-
-  // src/data-filter/aggregator.ts
-  var AGGREGATE_VS = `#define SHADER_NAME data-filter-vertex-shader
-
-#ifdef FLOAT_TARGET
-  attribute float filterIndices;
-  attribute float filterPrevIndices;
-#else
-  attribute vec2 filterIndices;
-  attribute vec2 filterPrevIndices;
-#endif
-
-varying vec4 vColor;
-const float component = 1.0 / 255.0;
-
-void main() {
-  #ifdef FLOAT_TARGET
-    dataFilter_value *= float(filterIndices != filterPrevIndices);
-    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
-    vColor = vec4(0.0, 0.0, 0.0, 1.0);
-  #else
-    // Float texture is not supported: pack result into 4 channels x 256 px x 64px
-    dataFilter_value *= float(filterIndices.x != filterPrevIndices.x);
-    float col = filterIndices.x;
-    float row = filterIndices.y * 4.0;
-    float channel = floor(row);
-    row = fract(row);
-    vColor = component * vec4(bvec4(channel == 0.0, channel == 1.0, channel == 2.0, channel == 3.0));
-    gl_Position = vec4(col * 2.0 - 1.0, row * 2.0 - 1.0, 0.0, 1.0);
-  #endif
-  gl_PointSize = 1.0;
-}
-`;
-  var AGGREGATE_FS = `#define SHADER_NAME data-filter-fragment-shader
-precision highp float;
-
-varying vec4 vColor;
-
-void main() {
-  if (dataFilter_value < 0.5) {
-    discard;
+  function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
   }
-  gl_FragColor = vColor;
-}
-`;
-  function supportsFloatTarget(device) {
-    const gl = device.gl;
-    return Boolean(gl.getExtension("EXT_float_blend") && (gl.getExtension("EXT_color_buffer_float") || gl.getExtension("WEBGL_color_buffer_float")));
+  function cross(out, a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
+    out[0] = ay * bz - az * by;
+    out[1] = az * bx - ax * bz;
+    out[2] = ax * by - ay * bx;
+    return out;
+  }
+  function lerp(out, a, b, t) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    out[0] = ax + t * (b[0] - ax);
+    out[1] = ay + t * (b[1] - ay);
+    out[2] = az + t * (b[2] - az);
+    return out;
+  }
+  function slerp(out, a, b, t) {
+    const angle2 = Math.acos(Math.min(Math.max(dot(a, b), -1), 1));
+    const sinTotal = Math.sin(angle2);
+    const ratioA = Math.sin((1 - t) * angle2) / sinTotal;
+    const ratioB = Math.sin(t * angle2) / sinTotal;
+    out[0] = ratioA * a[0] + ratioB * b[0];
+    out[1] = ratioA * a[1] + ratioB * b[1];
+    out[2] = ratioA * a[2] + ratioB * b[2];
+    return out;
+  }
+  function hermite(out, a, b, c, d, t) {
+    const factorTimes2 = t * t;
+    const factor1 = factorTimes2 * (2 * t - 3) + 1;
+    const factor2 = factorTimes2 * (t - 2) + t;
+    const factor3 = factorTimes2 * (t - 1);
+    const factor4 = factorTimes2 * (3 - 2 * t);
+    out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+    out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+    out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+    return out;
+  }
+  function bezier(out, a, b, c, d, t) {
+    const inverseFactor = 1 - t;
+    const inverseFactorTimesTwo = inverseFactor * inverseFactor;
+    const factorTimes2 = t * t;
+    const factor1 = inverseFactorTimesTwo * inverseFactor;
+    const factor2 = 3 * t * inverseFactorTimesTwo;
+    const factor3 = 3 * factorTimes2 * inverseFactor;
+    const factor4 = factorTimes2 * t;
+    out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+    out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+    out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+    return out;
+  }
+  function random(out, scale2) {
+    scale2 = scale2 === void 0 ? 1 : scale2;
+    const r = RANDOM() * 2 * Math.PI;
+    const z = RANDOM() * 2 - 1;
+    const zScale = Math.sqrt(1 - z * z) * scale2;
+    out[0] = Math.cos(r) * zScale;
+    out[1] = Math.sin(r) * zScale;
+    out[2] = z * scale2;
+    return out;
+  }
+  function transformMat4(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    let w = m[3] * x + m[7] * y + m[11] * z + m[15];
+    w = w || 1;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+    return out;
+  }
+  function transformMat3(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    out[0] = x * m[0] + y * m[3] + z * m[6];
+    out[1] = x * m[1] + y * m[4] + z * m[7];
+    out[2] = x * m[2] + y * m[5] + z * m[8];
+    return out;
+  }
+  function transformQuat(out, a, q) {
+    const qx = q[0];
+    const qy = q[1];
+    const qz = q[2];
+    const qw = q[3];
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    let uvx = qy * z - qz * y;
+    let uvy = qz * x - qx * z;
+    let uvz = qx * y - qy * x;
+    let uuvx = qy * uvz - qz * uvy;
+    let uuvy = qz * uvx - qx * uvz;
+    let uuvz = qx * uvy - qy * uvx;
+    const w2 = qw * 2;
+    uvx *= w2;
+    uvy *= w2;
+    uvz *= w2;
+    uuvx *= 2;
+    uuvy *= 2;
+    uuvz *= 2;
+    out[0] = x + uvx + uuvx;
+    out[1] = y + uvy + uuvy;
+    out[2] = z + uvz + uuvz;
+    return out;
+  }
+  function rotateX(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    r[0] = p[0];
+    r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
+    r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
+    return out;
+  }
+  function rotateY(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
+    r[1] = p[1];
+    r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
+    return out;
+  }
+  function rotateZ(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
+    r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
+    r[2] = p[2];
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
+    return out;
+  }
+  function angle(a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
+    const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz));
+    const cosine = mag && dot(a, b) / mag;
+    return Math.acos(Math.min(Math.max(cosine, -1), 1));
+  }
+  function zero(out) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    return out;
+  }
+  function str(a) {
+    return "vec3(".concat(a[0], ", ").concat(a[1], ", ").concat(a[2], ")");
   }
-  function getFramebuffer3(device, useFloatTarget) {
-    if (useFloatTarget) {
-      return device.createFramebuffer({
-        width: 1,
-        height: 1,
-        colorAttachments: [device.createTexture({
-          format: device.info.type === "webgl2" ? "rgba32float" : "rgba8unorm",
-          type: 5126,
-          mipmaps: false
-        })]
-      });
-    }
-    return device.createFramebuffer({
-      width: 256,
-      height: 64,
-      colorAttachments: [device.createTexture({
-        format: "rgba8unorm",
-        type: 5126,
-        mipmaps: false
-      })]
-    });
+  function exactEquals(a, b) {
+    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
   }
-  function getModel(device, shaderOptions, useFloatTarget) {
-    shaderOptions.defines.NON_INSTANCED_MODEL = 1;
-    if (useFloatTarget) {
-      shaderOptions.defines.FLOAT_TARGET = 1;
-    }
-    return new Model(device, {
-      id: "data-filter-aggregation-model",
-      vertexCount: 1,
-      isInstanced: false,
-      drawMode: 0,
-      vs: AGGREGATE_VS,
-      fs: AGGREGATE_FS,
-      ...shaderOptions
-    });
+  function equals2(a, b) {
+    const a0 = a[0];
+    const a1 = a[1];
+    const a2 = a[2];
+    const b0 = b[0];
+    const b1 = b[1];
+    const b2 = b[2];
+    return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2));
   }
-  var parameters = {
-    blend: true,
-    blendFunc: [1, 1, 1, 1],
-    blendEquation: [32774, 32774],
-    depthTest: false
-  };
-
-  // src/data-filter/data-filter-extension.ts
-  var defaultProps2 = {
-    getFilterValue: {
-      type: "accessor",
-      value: 0
-    },
-    onFilteredItemsChange: {
-      type: "function",
-      value: null,
-      optional: true
-    },
-    filterEnabled: true,
-    filterRange: [-1, 1],
-    filterSoftRange: null,
-    filterTransformSize: true,
-    filterTransformColor: true
-  };
-  var DATA_TYPE_FROM_SIZE = {
-    1: "float",
-    2: "vec2",
-    3: "vec3",
-    4: "vec4"
-  };
-  var DataFilterExtension = class extends import_core38.LayerExtension {
-    constructor({
-      filterSize = 1,
-      fp64: fp642 = false,
-      countItems = false
-    } = {}) {
-      if (!DATA_TYPE_FROM_SIZE[filterSize]) {
-        throw new Error("filterSize out of range");
-      }
-      super({
-        filterSize,
-        fp64: fp642,
-        countItems
-      });
-    }
-    getShaders(extension) {
-      const {
-        filterSize,
-        fp64: fp642
-      } = extension.opts;
-      return {
-        modules: [fp642 ? shaderModule64 : shaderModule],
-        defines: {
-          DATAFILTER_TYPE: DATA_TYPE_FROM_SIZE[filterSize],
-          DATAFILTER_DOUBLE: Boolean(fp642)
-        }
-      };
-    }
-    initializeState(context, extension) {
-      const attributeManager = this.getAttributeManager();
-      if (attributeManager) {
-        attributeManager.add({
-          filterValues: {
-            size: extension.opts.filterSize,
-            type: extension.opts.fp64 ? 5130 : 5126,
-            accessor: "getFilterValue",
-            shaderAttributes: {
-              filterValues: {
-                divisor: 0
-              },
-              instanceFilterValues: {
-                divisor: 1
-              }
-            }
-          }
-        });
+  var sub = subtract;
+  var mul = multiply;
+  var div = divide;
+  var dist = distance;
+  var sqrDist = squaredDistance;
+  var len = length;
+  var sqrLen = squaredLength;
+  var forEach = function() {
+    const vec = create();
+    return function(a, stride, offset, count, fn, arg) {
+      let i;
+      let l;
+      if (!stride) {
+        stride = 3;
       }
-      const {
-        device
-      } = this.context;
-      if (attributeManager && extension.opts.countItems) {
-        const useFloatTarget = supportsFloatTarget(device);
-        attributeManager.add({
-          filterIndices: {
-            size: useFloatTarget ? 1 : 2,
-            vertexOffset: 1,
-            type: 5121,
-            normalized: true,
-            accessor: (object, {
-              index
-            }) => {
-              const i = object && object.__source ? object.__source.index : index;
-              return useFloatTarget ? (i + 1) % 255 : [(i + 1) % 255, Math.floor(i / 255) % 255];
-            },
-            shaderAttributes: {
-              filterPrevIndices: {
-                vertexOffset: 0
-              },
-              filterIndices: {
-                vertexOffset: 1
-              }
-            }
-          }
-        });
-        const filterFBO = getFramebuffer3(device, useFloatTarget);
-        const filterModel = getModel(device, extension.getShaders.call(this, extension), useFloatTarget);
-        this.setState({
-          filterFBO,
-          filterModel
-        });
+      if (!offset) {
+        offset = 0;
       }
-    }
-    updateState({
-      props,
-      oldProps
-    }) {
-      if (this.state.filterModel) {
-        const attributeManager = this.getAttributeManager();
-        const filterNeedsUpdate = attributeManager.attributes.filterValues.needsUpdate() || props.filterEnabled !== oldProps.filterEnabled || props.filterRange !== oldProps.filterRange || props.filterSoftRange !== oldProps.filterSoftRange;
-        if (filterNeedsUpdate) {
-          this.setState({
-            filterNeedsUpdate
-          });
-        }
+      if (count) {
+        l = Math.min(count * stride + offset, a.length);
+      } else {
+        l = a.length;
       }
-    }
-    draw(params, extension) {
-      const filterFBO = this.state.filterFBO;
-      const filterModel = this.state.filterModel;
-      const filterNeedsUpdate = this.state.filterNeedsUpdate;
-      const {
-        onFilteredItemsChange
-      } = this.props;
-      if (filterNeedsUpdate && onFilteredItemsChange && filterModel) {
-        const {
-          attributes: {
-            filterValues,
-            filterIndices
-          }
-        } = this.getAttributeManager();
-        filterModel.setVertexCount(this.getNumInstances());
-        clear(this.context.device, {
-          framebuffer: filterFBO,
-          color: [0, 0, 0, 0]
-        });
-        filterModel.updateModuleSettings(params.moduleParameters);
-        filterModel.setAttributes({
-          ...filterValues.getValue(),
-          ...filterIndices?.getValue()
-        });
-        withGLParameters(filterModel.device, {
-          framebuffer: filterFBO,
-          ...parameters,
-          viewport: [0, 0, filterFBO.width, filterFBO.height]
-        }, () => {
-          filterModel.draw(this.context.renderPass);
-        });
-        const color = readPixelsToArray(filterFBO);
-        let count = 0;
-        for (let i = 0; i < color.length; i++) {
-          count += color[i];
-        }
-        onFilteredItemsChange({
-          id: this.id,
-          count
-        });
-        this.state.filterNeedsUpdate = false;
+      for (i = offset; i < l; i += stride) {
+        vec[0] = a[i];
+        vec[1] = a[i + 1];
+        vec[2] = a[i + 2];
+        fn(vec, vec, arg);
+        a[i] = vec[0];
+        a[i + 1] = vec[1];
+        a[i + 2] = vec[2];
       }
-    }
-    finalizeState() {
-      const filterFBO = this.state.filterFBO;
-      const filterModel = this.state.filterModel;
-      filterFBO?.destroy();
-      filterModel?.destroy();
-    }
-  };
-  __publicField(DataFilterExtension, "defaultProps", defaultProps2);
-  __publicField(DataFilterExtension, "extensionName", "DataFilterExtension");
-
-  // src/fp64/fp64-extension.ts
-  var import_core40 = __toESM(require_core());
+      return a;
+    };
+  }();
 
   // src/fp64/project64.ts
   var import_core39 = __toESM(require_core());
@@ -11482,7 +11485,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     } = opts;
     return {
       collision_sort: Boolean(drawToCollisionMap),
-      collision_texture: !drawToCollisionMap && collisionFBO ? collisionFBO : dummyCollisionMap
+      collision_texture: !drawToCollisionMap && collisionFBO ? collisionFBO.colorAttachments[0] : dummyCollisionMap
     };
   };
   var shader_module_default2 = {
@@ -11501,15 +11504,16 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
   var CollisionFilterPass = class extends import_core47._LayersPass {
     renderCollisionMap(target, options) {
       const padding = 1;
+      const clearColor = [0, 0, 0, 0];
       return withGLParameters(this.device, {
         scissorTest: true,
         scissor: [padding, padding, target.width - 2 * padding, target.height - 2 * padding],
-        clearColor: [0, 0, 0, 0],
         blend: false,
         depthTest: true,
         depthRange: [0, 1]
       }, () => this.render({
         ...options,
+        clearColor,
         target,
         pass: "collision"
       }));
@@ -11556,8 +11560,8 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     render(options) {
       const colorMask = [false, false, false, false];
       colorMask[options.channel] = true;
+      const clearColor = [255, 255, 255, 255];
       return withGLParameters(this.device, {
-        clearColor: [255, 255, 255, 255],
         blend: true,
         blendFunc: [0, 1],
         blendEquation: 32778,
@@ -11565,6 +11569,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
         depthTest: false
       }, () => super.render({
         ...options,
+        clearColor,
         target: this.fbo,
         pass: "mask"
       }));
@@ -12064,7 +12069,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
         }
       });
       const depthBuffer = new WEBGLRenderbuffer(device, {
-        format: "depth16",
+        format: "depth16unorm",
         width,
         height
       });
@@ -12078,11 +12083,9 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     }
     destroyFBO(collisionGroup) {
       const fbo = this.collisionFBOs[collisionGroup];
-      const attachments = fbo.attachments;
-      for (const attachment of Object.values(attachments)) {
-        attachment.delete();
-      }
-      fbo.delete();
+      fbo.colorAttachments[0]?.destroy();
+      fbo.depthStencilAttachment?.destroy();
+      fbo.destroy();
       delete this.collisionFBOs[collisionGroup];
     }
   };