@deck.gl/extensions 9.0.0-alpha.4 → 9.0.0-alpha.6

package/dist/dist.dev.js

@@ -7628,21 +7628,21 @@ varying float dataFilter_value;
     getUniforms: getUniforms64
   };
 
-  // ../../../luma.gl/modules/engine/dist/model/model.js
+  // ../../node_modules/@luma.gl/engine/dist/model/model.js
   var import_core36 = __toESM(require_core2(), 1);
   var import_core37 = __toESM(require_core2(), 1);
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/glsl-utils/highlight.js
+  // ../../node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/highlight.js
   var glsl = (x) => `${x}`;
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/utils/assert.js
+  // ../../node_modules/@luma.gl/shadertools/dist/lib/utils/assert.js
   function assert17(condition, message2) {
     if (!condition) {
       throw new Error(message2 || "shadertools: assertion failed.");
     }
   }
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/filters/prop-types.js
+  // ../../node_modules/@luma.gl/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;
   }
 
-  // ../../../luma.gl/modules/shadertools/dist/module-injectors.js
+  // ../../node_modules/@luma.gl/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
 `;
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/shader-injections.js
+  // ../../node_modules/@luma.gl/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;
   }
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/shader-module/shader-module-instance.js
+  // ../../node_modules/@luma.gl/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 = [],
-        uniformPropTypes = {},
+        uniforms = {},
         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 (uniformPropTypes) {
-        this.uniforms = makePropValidators(uniformPropTypes);
+      if (uniforms) {
+        this.uniforms = makePropValidators(uniforms);
       }
     }
     getModuleSource(stage) {
@@ -7962,7 +7962,7 @@ ${moduleSource}// END MODULE_${this.name}
     }
   };
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/resolve-modules.js
+  // ../../node_modules/@luma.gl/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}
     }
   }
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/platform-defines.js
+  // ../../node_modules/@luma.gl/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;
   }
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/shader-transpiler/transpile-glsl-shader.js
+  // ../../node_modules/@luma.gl/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");
   }
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/shader-hooks.js
+  // ../../node_modules/@luma.gl/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;
   }
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/assemble-shaders.js
+  // ../../node_modules/@luma.gl/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;
   }
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembly/select-shaders.js
+  // ../../node_modules/@luma.gl/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 : ""}
     }
   }
 
-  // ../../../luma.gl/modules/shadertools/dist/lib/shader-assembler.js
+  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembler.js
   var ShaderAssembler = class {
     constructor() {
       this._hookFunctions = [];
@@ -8601,1036 +8601,297 @@ ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
   };
   ShaderAssembler.defaultShaderAssembler = void 0;
 
-  // ../../../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
-    });
+  // ../../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 getIndexBufferFromGeometry(device, geometry) {
-    if (!geometry.indices) {
-      return void 0;
-    }
-    const data = geometry.indices.value;
-    return device.createBuffer({
-      usage: import_core34.Buffer.INDEX,
-      data
-    });
+  function fp64LowPart(a) {
+    return a - Math.fround(a);
   }
-  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;
+  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);
       }
-      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
-    };
+    return matrixFP64;
   }
 
-  // ../../../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
-  };
+  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-arithmetic.glsl.js
+  var fp64arithmeticShader = glsl`\
+uniform float ONE;
 
-  // ../../../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);
-    }
-    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);
-    }
-    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;
-        }
-        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 (!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 {
-          import_core36.log.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)();
-        }
-      }
-    }
-    _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);
-      }
-      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;
-  }
+/*
+About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
 
-  // src/data-filter/aggregator.ts
-  var AGGREGATE_VS = `#define SHADER_NAME data-filter-vertex-shader
+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.
 
-#ifdef FLOAT_TARGET
-  attribute float filterIndices;
-  attribute float filterPrevIndices;
+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
-  attribute vec2 filterIndices;
-  attribute vec2 filterPrevIndices;
+  float a_hi = t - (t - a);
+  float a_lo = a - a_hi;
 #endif
+  return vec2(a_hi, a_lo);
+}
 
-varying vec4 vColor;
-const float component = 1.0 / 255.0;
+// 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;
+}
 
-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;
+// 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);
 }
-`;
-  var AGGREGATE_FS = `#define SHADER_NAME data-filter-fragment-shader
-precision highp float;
 
-varying vec4 vColor;
+// 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);
+}
 
-void main() {
-  if (dataFilter_value < 0.5) {
-    discard;
-  }
-  gl_FragColor = vColor;
+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
 }
 `;
-  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 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;
+
+  // ../../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 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
-  };
+    return tmp;
+}
 
-  // 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
-              }
-            }
-          }
-        });
-      }
-      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
-          });
-        }
-      }
-    }
-    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;
-      }
-    }
-    finalizeState() {
-      const filterFBO = this.state.filterFBO;
-      const filterModel = this.state.filterModel;
-      filterFBO?.destroy();
-      filterModel?.destroy();
-    }
-  };
-  __publicField(DataFilterExtension, "defaultProps", defaultProps2);
-  __publicField(DataFilterExtension, "extensionName", "DataFilterExtension");
+/* 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;
+*/
 
-  // src/fp64/fp64-extension.ts
-  var import_core40 = __toESM(require_core());
+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;
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/highlight.js
-  var glsl2 = (x) => `${x}`;
+  const float inv_k = 1.0 / k;
 
-  // ../../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 fp64LowPart(a) {
-    return a - Math.fround(a);
-  }
-  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;
-  }
+  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;
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-arithmetic.glsl.js
-  var fp64arithmeticShader = glsl2`\
-uniform float ONE;
+  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;
 
-/*
-About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  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);
 
-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.
+  s = sum_fp64(s, t);
+  p = mul_fp64(p, r);
+  t = mul_fp64(p, INVERSE_FACTORIAL_4_FP64);
 
-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
+  s = sum_fp64(s, t);
+  p = mul_fp64(p, r);
+  t = mul_fp64(p, INVERSE_FACTORIAL_5_FP64);
 
-err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
-*/
+  // s = sum_fp64(s, t);
+  // p = mul_fp64(p, r);
+  // t = mul_fp64(p, INVERSE_FACTORIAL_6_FP64);
 
-// 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);
-    }
-    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);
+  // p = mul_fp64(p, r);
+  // t = mul_fp64(p, INVERSE_FACTORIAL_7_FP64);
 
   s = sum_fp64(s, t);
 
@@ -10676,53 +9937,789 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
   function str(a) {
     return "vec3(".concat(a[0], ", ").concat(a[1], ", ").concat(a[2], ")");
   }
-  function exactEquals(a, b) {
-    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+  function exactEquals(a, b) {
+    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+  }
+  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 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
+    });
+  }
+  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 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
+    };
+  }
+
+  // ../../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];
+    }
+  };
+  PipelineFactory.defaultProps = {
+    ...import_core35.RenderPipeline.defaultProps,
+    vs: void 0,
+    fs: void 0
+  };
+
+  // ../../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);
+    }
+    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;
+        }
+        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 (!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 {
+          import_core36.log.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)();
+        }
+      }
+    }
+    _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);
+      }
+      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;
+  }
+
+  // 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;
+  }
+  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 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 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));
+  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 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;
+  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");
       }
-      if (!offset) {
-        offset = 0;
+      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
+              }
+            }
+          }
+        });
       }
-      if (count) {
-        l = Math.min(count * stride + offset, a.length);
-      } else {
-        l = a.length;
+      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
+        });
       }
-      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];
+    }
+    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
+          });
+        }
       }
-      return a;
-    };
-  }();
+    }
+    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;
+      }
+    }
+    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());
 
   // src/fp64/project64.ts
   var import_core39 = __toESM(require_core());