@deck.gl/aggregation-layers 9.0.0-alpha.3 → 9.0.0-alpha.4

package/dist/dist.dev.js

@@ -758,21 +758,21 @@ var __exports__ = (() => {
     return GL2;
   }({});
 
-  // ../../node_modules/@luma.gl/engine/dist/model/model.js
+  // ../../../luma.gl/modules/engine/dist/model/model.js
   var import_core3 = __toESM(require_core2(), 1);
   var import_core4 = __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 assert(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",
@@ -853,7 +853,7 @@ var __exports__ = (() => {
     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);
@@ -882,7 +882,7 @@ var __exports__ = (() => {
 #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
@@ -974,7 +974,7 @@ var __exports__ = (() => {
     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) => {
@@ -1004,7 +1004,7 @@ var __exports__ = (() => {
         vs,
         fs,
         dependencies = [],
-        uniforms = {},
+        uniformPropTypes = {},
         getUniforms: getUniforms2,
         deprecations = [],
         defines = {},
@@ -1019,8 +1019,8 @@ var __exports__ = (() => {
       this.deprecations = this._parseDeprecationDefinitions(deprecations);
       this.defines = defines;
       this.injections = normalizeInjections(inject);
-      if (uniforms) {
-        this.uniforms = makePropValidators(uniforms);
+      if (uniformPropTypes) {
+        this.uniforms = makePropValidators(uniformPropTypes);
       }
     }
     getModuleSource(stage) {
@@ -1092,7 +1092,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);
@@ -1136,7 +1136,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":
@@ -1236,7 +1236,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:
@@ -1302,7 +1302,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) {
@@ -1362,7 +1362,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}
@@ -1634,7 +1634,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");
@@ -1668,7 +1668,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 = [];
@@ -1731,216 +1731,7 @@ ${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;
-  }
-  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;
-  }
-
-  // ../../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;
-}
-
-// 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.js
-  var CONST_UNIFORMS = {
-    ONE: 1
-  };
-  function getUniforms() {
-    return CONST_UNIFORMS;
-  }
-  var fp64arithmetic = {
-    name: "fp64-arithmetic",
-    vs: fp64arithmeticShader,
-    getUniforms,
-    fp64ify,
-    fp64LowPart,
-    fp64ifyMatrix4
-  };
-
-  // ../../node_modules/@luma.gl/engine/dist/geometry/gpu-geometry.js
+  // ../../../luma.gl/modules/engine/dist/geometry/gpu-geometry.js
   var import_core = __toESM(require_core2(), 1);
   var GPUGeometry = class {
     constructor(props) {
@@ -2043,7 +1834,7 @@ vec2 sqrt_fp64(vec2 a) {
     };
   }
 
-  // ../../node_modules/@luma.gl/engine/dist/lib/pipeline-factory.js
+  // ../../../luma.gl/modules/engine/dist/lib/pipeline-factory.js
   var import_core2 = __toESM(require_core2(), 1);
   var PipelineFactory = class {
     static getDefaultPipelineFactory(device) {
@@ -2137,7 +1928,7 @@ vec2 sqrt_fp64(vec2 a) {
     fs: void 0
   };
 
-  // ../../node_modules/@luma.gl/engine/dist/model/model.js
+  // ../../../luma.gl/modules/engine/dist/model/model.js
   var Model = class {
     constructor(device, props) {
       this.device = void 0;
@@ -2409,7 +2200,7 @@ vec2 sqrt_fp64(vec2 a) {
     return layouts;
   }
 
-  // ../../node_modules/@luma.gl/engine/dist/transform/transform.js
+  // ../../../luma.gl/modules/engine/dist/transform/transform.js
   var Transform = class {
     static isSupported(device) {
       return false;
@@ -2463,7 +2254,7 @@ vec2 sqrt_fp64(vec2 a) {
     }
   };
 
-  // ../../node_modules/@luma.gl/engine/dist/geometry/geometry.js
+  // ../../../luma.gl/modules/engine/dist/geometry/geometry.js
   var import_core5 = __toESM(require_core2(), 1);
   var Geometry = class {
     constructor(props) {
@@ -2543,7 +2334,7 @@ vec2 sqrt_fp64(vec2 a) {
     }
   };
 
-  // ../../node_modules/@luma.gl/engine/dist/geometries/cube-geometry.js
+  // ../../../luma.gl/modules/engine/dist/geometries/cube-geometry.js
   var import_core6 = __toESM(require_core2(), 1);
   var CubeGeometry = class extends Geometry {
     constructor() {
@@ -2612,6 +2403,218 @@ vec2 sqrt_fp64(vec2 a) {
     }
   };
 
+  // ../../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 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;
+  }
+
+  // ../../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.js
+  var CONST_UNIFORMS = {
+    ONE: 1
+  };
+  function getUniforms() {
+    return CONST_UNIFORMS;
+  }
+  var fp64arithmetic = {
+    name: "fp64-arithmetic",
+    vs: fp64arithmeticShader,
+    getUniforms,
+    fp64ify,
+    fp64LowPart,
+    fp64ifyMatrix4
+  };
+
   // ../../node_modules/@luma.gl/webgl/dist/context/context/create-headless-context.js
   var ERR_HEADLESSGL_FAILED = "Failed to create WebGL context in Node.js, headless gl returned null";
   var ERR_HEADLESSGL_LOAD = "  luma.gl: loaded under Node.js without headless gl installed, meaning that WebGL   contexts can not be created. This may not be an error. For example, this is a   typical configuration for isorender applications running on the server.";