@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.11

package/dist/modules/math/fp64/fp64-functions-wgsl.cjs

@@ -0,0 +1,180 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fp64_functions_wgsl_exports = {};
+__export(fp64_functions_wgsl_exports, {
+  fp64functionsWGSL: () => fp64functionsWGSL
+});
+module.exports = __toCommonJS(fp64_functions_wgsl_exports);
+const fp64functionsWGSL = (
+  /* wgsl */
+  `const E_FP64 = vec2f(2.7182817459106445, 8.254840366817007e-8);
+const LOG2_FP64 = vec2f(0.6931471824645996, -1.9046542121259336e-9);
+const PI_FP64 = vec2f(3.1415927410125732, -8.742278012618954e-8);
+const TWO_PI_FP64 = vec2f(6.2831854820251465, -1.7484556025237907e-7);
+const PI_2_FP64 = vec2f(1.5707963705062866, -4.371139006309477e-8);
+const PI_4_FP64 = vec2f(0.7853981852531433, -2.1855695031547384e-8);
+const PI_180_FP64 = vec2f(0.01745329238474369, 1.3519960498364902e-10);
+
+// High/low splits of 1/n!, 1/(2n+1)!, and 1/(2n)! respectively.
+const FP64_EXP_COEFFICIENTS = array<vec2f, 17>(
+  vec2f(1.0, 0.0),
+  vec2f(1.0, 0.0),
+  vec2f(0.5, 0.0),
+  vec2f(0.1666666716337204, -4.967053879312289e-09),
+  vec2f(0.0416666679084301, -1.2417634698280722e-09),
+  vec2f(0.008333333767950535, -4.34617203337595e-10),
+  vec2f(0.0013888889225199819, -3.3631094437103215e-11),
+  vec2f(0.00019841270113829523, -2.725596874933456e-12),
+  vec2f(2.4801587642286904e-05, -3.40699609366682e-13),
+  vec2f(2.7557318844628753e-06, 3.793571224297229e-14),
+  vec2f(2.755731998149713e-07, -7.575112209051195e-15),
+  vec2f(2.5052107943679403e-08, 4.4176230446483665e-16),
+  vec2f(2.0876755879584152e-09, 1.1082839809204342e-16),
+  vec2f(1.6059044372074283e-10, -5.352526511562726e-18),
+  vec2f(1.147074536050896e-11, 2.372207689231238e-19),
+  vec2f(7.647163609812713e-13, 1.2200710471178288e-20),
+  vec2f(4.7794772561329454e-14, 7.62544404448643e-22)
+);
+const FP64_SIN_COEFFICIENTS = array<vec2f, 9>(
+  vec2f(1.0, 0.0),
+  vec2f(0.1666666716337204, -4.967053879312289e-09),
+  vec2f(0.008333333767950535, -4.34617203337595e-10),
+  vec2f(0.00019841270113829523, -2.725596874933456e-12),
+  vec2f(2.7557318844628753e-06, 3.793571224297229e-14),
+  vec2f(2.5052107943679403e-08, 4.4176230446483665e-16),
+  vec2f(1.6059044372074283e-10, -5.352526511562726e-18),
+  vec2f(7.647163609812713e-13, 1.2200710471178288e-20),
+  vec2f(2.8114573589663704e-15, -1.0462084739763658e-22)
+);
+const FP64_COS_COEFFICIENTS = array<vec2f, 9>(
+  vec2f(1.0, 0.0),
+  vec2f(0.5, 0.0),
+  vec2f(0.0416666679084301, -1.2417634698280722e-09),
+  vec2f(0.0013888889225199819, -3.3631094437103215e-11),
+  vec2f(2.4801587642286904e-05, -3.40699609366682e-13),
+  vec2f(2.755731998149713e-07, -7.575112209051195e-15),
+  vec2f(2.0876755879584152e-09, 1.1082839809204342e-16),
+  vec2f(1.147074536050896e-11, 2.372207689231238e-19),
+  vec2f(4.7794772561329454e-14, 7.62544404448643e-22)
+);
+
+// Reduce by log(2) before evaluating the exponential. Horner evaluation uses split
+// coefficients to retain low terms without repeatedly expanding double-single division.
+fn exp_fp64(value: vec2f) -> vec2f {
+  let a = normalize_fp64(value);
+  if (is_nan_fp64(a)) { return a; }
+  // WGSL rejects non-finite constant expressions; construct infinity from runtime bits.
+  if (a.x > 88.72283905206835) { return vec2f(bitcast<f32>(0x7f800000u | (bitcast<u32>(a.x) & 0x80000000u)), 0.0); }
+  if (a.x < -103.9720770839918) { return vec2f(0.0); }
+  let exponent = min(127.0, floor(a.x / LOG2_FP64.x + 0.5));
+  let remainder = sub_fp64(a, mul_fp64(LOG2_FP64, vec2f(exponent, 0.0)));
+  var result = FP64_EXP_COEFFICIENTS[16];
+  for (var i = 15; i >= 0; i--) {
+    result = sum_fp64(FP64_EXP_COEFFICIENTS[i], mul_fp64(remainder, result));
+  }
+  return fp64_scale_fp64(result, i32(exponent));
+}
+
+fn log_fp64(value: vec2f) -> vec2f {
+  let a = normalize_fp64(value);
+  if (is_nan_fp64(a)) { return a; }
+  // Match the GLSL helper's domain: zero and negative inputs return NaN.
+  if (sign_fp64(a) <= 0) { return vec2f(fp64_nan(a.x), 0.0); }
+  if (!is_finite_fp64(a)) { return a; }
+  // Normalize the magnitude before Newton refinement so exp(estimate) cannot overflow
+  // for large inputs or underflow for tiny inputs. Bit extraction also handles subnormals.
+  let exponent = max(-126, i32((bitcast<u32>(a.x) >> 23u) & 255u) - 127);
+  let mantissa = fp64_scale_fp64(a, -exponent);
+  var result = vec2f(log(mantissa.x), 0.0);
+  // Newton correction, written as (a - exp(x)) / exp(x), preserves tiny log(1 + low).
+  // Two iterations remove the error in the native f32 starting estimate.
+  for (var i = 0; i < 2; i++) {
+    let estimate = exp_fp64(result);
+    result = sum_fp64(result, div_fp64(sub_fp64(mantissa, estimate), estimate));
+  }
+  return sum_fp64(result, mul_fp64(LOG2_FP64, vec2f(f32(exponent), 0.0)));
+}
+
+struct Fp64SinCos {
+  sine: vec2f,
+  cosine: vec2f,
+};
+
+fn fp64_sincos(value: vec2f) -> Fp64SinCos {
+  let a = normalize_fp64(value);
+  // The projection use case stays within one turn. Bound conversion to an integer quadrant;
+  // this is not a large-argument Payne-Hanek trigonometric range reducer.
+  if (!is_finite_fp64(a) || abs(a.x) > 1000000.0) {
+    return Fp64SinCos(vec2f(fp64_nan(a.x), 0.0), vec2f(fp64_nan(a.x), 0.0));
+  }
+  let quadrant = i32(floor(a.x / PI_2_FP64.x + 0.5));
+  let remainder = sub_fp64(a, mul_fp64(PI_2_FP64, vec2f(f32(quadrant), 0.0)));
+  let negativeSquare = -mul_fp64(remainder, remainder);
+  var sinePolynomial = FP64_SIN_COEFFICIENTS[8];
+  var cosine = FP64_COS_COEFFICIENTS[8];
+  for (var i = 7; i >= 0; i--) {
+    sinePolynomial = sum_fp64(FP64_SIN_COEFFICIENTS[i], mul_fp64(negativeSquare, sinePolynomial));
+    cosine = sum_fp64(FP64_COS_COEFFICIENTS[i], mul_fp64(negativeSquare, cosine));
+  }
+  let sine = mul_fp64(remainder, sinePolynomial);
+  switch ((quadrant % 4 + 4) % 4) {
+    case 0: { return Fp64SinCos(sine, cosine); }
+    case 1: { return Fp64SinCos(cosine, -sine); }
+    case 2: { return Fp64SinCos(-sine, -cosine); }
+    default: { return Fp64SinCos(-cosine, sine); }
+  }
+}
+
+fn sin_fp64(a: vec2f) -> vec2f { return fp64_sincos(a).sine; }
+fn cos_fp64(a: vec2f) -> vec2f { return fp64_sincos(a).cosine; }
+fn tan_fp64(a: vec2f) -> vec2f {
+  let result = fp64_sincos(a);
+  return div_fp64(result.sine, result.cosine);
+}
+
+fn radians_fp64(degree: vec2f) -> vec2f { return mul_fp64(degree, PI_180_FP64); }
+fn mix_fp64(a: vec2f, b: vec2f, x: f32) -> vec2f {
+  return sum_fp64(a, mul_fp64(sub_fp64(b, a), vec2f(x, 0.0)));
+}
+
+// WGSL returns arrays in place of GLSL out parameters. Each vec2f stores [high, low].
+fn vec4_fp64(a: vec4f) -> array<vec2f, 4> {
+  return array<vec2f, 4>(vec2f(a.x, 0.0), vec2f(a.y, 0.0), vec2f(a.z, 0.0), vec2f(a.w, 0.0));
+}
+
+fn vec4_dot_fp64(a: array<vec2f, 4>, b: array<vec2f, 4>) -> vec2f {
+  return sum_fp64(
+    sum_fp64(mul_fp64(a[0], b[0]), mul_fp64(a[1], b[1])),
+    sum_fp64(mul_fp64(a[2], b[2]), mul_fp64(a[3], b[3])));
+}
+
+// Same row-major pair ordering as the GLSL helper: result[i] = dot(matrix[i * 4..], a).
+fn mat4_vec4_mul_fp64(matrix: array<vec2f, 16>, a: array<vec2f, 4>) -> array<vec2f, 4> {
+  var result: array<vec2f, 4>;
+  for (var i = 0; i < 4; i++) {
+    let row = array<vec2f, 4>(matrix[i * 4], matrix[i * 4 + 1], matrix[i * 4 + 2], matrix[i * 4 + 3]);
+    result[i] = vec4_dot_fp64(a, row);
+  }
+  return result;
+}
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fp64functionsWGSL
+});

package/dist/modules/math/fp64/fp64-functions-wgsl.d.ts

@@ -0,0 +1,3 @@
+/** WGSL double-single functions used by geographic projection. */
+export declare const fp64functionsWGSL = "const E_FP64 = vec2f(2.7182817459106445, 8.254840366817007e-8);\nconst LOG2_FP64 = vec2f(0.6931471824645996, -1.9046542121259336e-9);\nconst PI_FP64 = vec2f(3.1415927410125732, -8.742278012618954e-8);\nconst TWO_PI_FP64 = vec2f(6.2831854820251465, -1.7484556025237907e-7);\nconst PI_2_FP64 = vec2f(1.5707963705062866, -4.371139006309477e-8);\nconst PI_4_FP64 = vec2f(0.7853981852531433, -2.1855695031547384e-8);\nconst PI_180_FP64 = vec2f(0.01745329238474369, 1.3519960498364902e-10);\n\n// High/low splits of 1/n!, 1/(2n+1)!, and 1/(2n)! respectively.\nconst FP64_EXP_COEFFICIENTS = array<vec2f, 17>(\n  vec2f(1.0, 0.0),\n  vec2f(1.0, 0.0),\n  vec2f(0.5, 0.0),\n  vec2f(0.1666666716337204, -4.967053879312289e-09),\n  vec2f(0.0416666679084301, -1.2417634698280722e-09),\n  vec2f(0.008333333767950535, -4.34617203337595e-10),\n  vec2f(0.0013888889225199819, -3.3631094437103215e-11),\n  vec2f(0.00019841270113829523, -2.725596874933456e-12),\n  vec2f(2.4801587642286904e-05, -3.40699609366682e-13),\n  vec2f(2.7557318844628753e-06, 3.793571224297229e-14),\n  vec2f(2.755731998149713e-07, -7.575112209051195e-15),\n  vec2f(2.5052107943679403e-08, 4.4176230446483665e-16),\n  vec2f(2.0876755879584152e-09, 1.1082839809204342e-16),\n  vec2f(1.6059044372074283e-10, -5.352526511562726e-18),\n  vec2f(1.147074536050896e-11, 2.372207689231238e-19),\n  vec2f(7.647163609812713e-13, 1.2200710471178288e-20),\n  vec2f(4.7794772561329454e-14, 7.62544404448643e-22)\n);\nconst FP64_SIN_COEFFICIENTS = array<vec2f, 9>(\n  vec2f(1.0, 0.0),\n  vec2f(0.1666666716337204, -4.967053879312289e-09),\n  vec2f(0.008333333767950535, -4.34617203337595e-10),\n  vec2f(0.00019841270113829523, -2.725596874933456e-12),\n  vec2f(2.7557318844628753e-06, 3.793571224297229e-14),\n  vec2f(2.5052107943679403e-08, 4.4176230446483665e-16),\n  vec2f(1.6059044372074283e-10, -5.352526511562726e-18),\n  vec2f(7.647163609812713e-13, 1.2200710471178288e-20),\n  vec2f(2.8114573589663704e-15, -1.0462084739763658e-22)\n);\nconst FP64_COS_COEFFICIENTS = array<vec2f, 9>(\n  vec2f(1.0, 0.0),\n  vec2f(0.5, 0.0),\n  vec2f(0.0416666679084301, -1.2417634698280722e-09),\n  vec2f(0.0013888889225199819, -3.3631094437103215e-11),\n  vec2f(2.4801587642286904e-05, -3.40699609366682e-13),\n  vec2f(2.755731998149713e-07, -7.575112209051195e-15),\n  vec2f(2.0876755879584152e-09, 1.1082839809204342e-16),\n  vec2f(1.147074536050896e-11, 2.372207689231238e-19),\n  vec2f(4.7794772561329454e-14, 7.62544404448643e-22)\n);\n\n// Reduce by log(2) before evaluating the exponential. Horner evaluation uses split\n// coefficients to retain low terms without repeatedly expanding double-single division.\nfn exp_fp64(value: vec2f) -> vec2f {\n  let a = normalize_fp64(value);\n  if (is_nan_fp64(a)) { return a; }\n  // WGSL rejects non-finite constant expressions; construct infinity from runtime bits.\n  if (a.x > 88.72283905206835) { return vec2f(bitcast<f32>(0x7f800000u | (bitcast<u32>(a.x) & 0x80000000u)), 0.0); }\n  if (a.x < -103.9720770839918) { return vec2f(0.0); }\n  let exponent = min(127.0, floor(a.x / LOG2_FP64.x + 0.5));\n  let remainder = sub_fp64(a, mul_fp64(LOG2_FP64, vec2f(exponent, 0.0)));\n  var result = FP64_EXP_COEFFICIENTS[16];\n  for (var i = 15; i >= 0; i--) {\n    result = sum_fp64(FP64_EXP_COEFFICIENTS[i], mul_fp64(remainder, result));\n  }\n  return fp64_scale_fp64(result, i32(exponent));\n}\n\nfn log_fp64(value: vec2f) -> vec2f {\n  let a = normalize_fp64(value);\n  if (is_nan_fp64(a)) { return a; }\n  // Match the GLSL helper's domain: zero and negative inputs return NaN.\n  if (sign_fp64(a) <= 0) { return vec2f(fp64_nan(a.x), 0.0); }\n  if (!is_finite_fp64(a)) { return a; }\n  // Normalize the magnitude before Newton refinement so exp(estimate) cannot overflow\n  // for large inputs or underflow for tiny inputs. Bit extraction also handles subnormals.\n  let exponent = max(-126, i32((bitcast<u32>(a.x) >> 23u) & 255u) - 127);\n  let mantissa = fp64_scale_fp64(a, -exponent);\n  var result = vec2f(log(mantissa.x), 0.0);\n  // Newton correction, written as (a - exp(x)) / exp(x), preserves tiny log(1 + low).\n  // Two iterations remove the error in the native f32 starting estimate.\n  for (var i = 0; i < 2; i++) {\n    let estimate = exp_fp64(result);\n    result = sum_fp64(result, div_fp64(sub_fp64(mantissa, estimate), estimate));\n  }\n  return sum_fp64(result, mul_fp64(LOG2_FP64, vec2f(f32(exponent), 0.0)));\n}\n\nstruct Fp64SinCos {\n  sine: vec2f,\n  cosine: vec2f,\n};\n\nfn fp64_sincos(value: vec2f) -> Fp64SinCos {\n  let a = normalize_fp64(value);\n  // The projection use case stays within one turn. Bound conversion to an integer quadrant;\n  // this is not a large-argument Payne-Hanek trigonometric range reducer.\n  if (!is_finite_fp64(a) || abs(a.x) > 1000000.0) {\n    return Fp64SinCos(vec2f(fp64_nan(a.x), 0.0), vec2f(fp64_nan(a.x), 0.0));\n  }\n  let quadrant = i32(floor(a.x / PI_2_FP64.x + 0.5));\n  let remainder = sub_fp64(a, mul_fp64(PI_2_FP64, vec2f(f32(quadrant), 0.0)));\n  let negativeSquare = -mul_fp64(remainder, remainder);\n  var sinePolynomial = FP64_SIN_COEFFICIENTS[8];\n  var cosine = FP64_COS_COEFFICIENTS[8];\n  for (var i = 7; i >= 0; i--) {\n    sinePolynomial = sum_fp64(FP64_SIN_COEFFICIENTS[i], mul_fp64(negativeSquare, sinePolynomial));\n    cosine = sum_fp64(FP64_COS_COEFFICIENTS[i], mul_fp64(negativeSquare, cosine));\n  }\n  let sine = mul_fp64(remainder, sinePolynomial);\n  switch ((quadrant % 4 + 4) % 4) {\n    case 0: { return Fp64SinCos(sine, cosine); }\n    case 1: { return Fp64SinCos(cosine, -sine); }\n    case 2: { return Fp64SinCos(-sine, -cosine); }\n    default: { return Fp64SinCos(-cosine, sine); }\n  }\n}\n\nfn sin_fp64(a: vec2f) -> vec2f { return fp64_sincos(a).sine; }\nfn cos_fp64(a: vec2f) -> vec2f { return fp64_sincos(a).cosine; }\nfn tan_fp64(a: vec2f) -> vec2f {\n  let result = fp64_sincos(a);\n  return div_fp64(result.sine, result.cosine);\n}\n\nfn radians_fp64(degree: vec2f) -> vec2f { return mul_fp64(degree, PI_180_FP64); }\nfn mix_fp64(a: vec2f, b: vec2f, x: f32) -> vec2f {\n  return sum_fp64(a, mul_fp64(sub_fp64(b, a), vec2f(x, 0.0)));\n}\n\n// WGSL returns arrays in place of GLSL out parameters. Each vec2f stores [high, low].\nfn vec4_fp64(a: vec4f) -> array<vec2f, 4> {\n  return array<vec2f, 4>(vec2f(a.x, 0.0), vec2f(a.y, 0.0), vec2f(a.z, 0.0), vec2f(a.w, 0.0));\n}\n\nfn vec4_dot_fp64(a: array<vec2f, 4>, b: array<vec2f, 4>) -> vec2f {\n  return sum_fp64(\n    sum_fp64(mul_fp64(a[0], b[0]), mul_fp64(a[1], b[1])),\n    sum_fp64(mul_fp64(a[2], b[2]), mul_fp64(a[3], b[3])));\n}\n\n// Same row-major pair ordering as the GLSL helper: result[i] = dot(matrix[i * 4..], a).\nfn mat4_vec4_mul_fp64(matrix: array<vec2f, 16>, a: array<vec2f, 4>) -> array<vec2f, 4> {\n  var result: array<vec2f, 4>;\n  for (var i = 0; i < 4; i++) {\n    let row = array<vec2f, 4>(matrix[i * 4], matrix[i * 4 + 1], matrix[i * 4 + 2], matrix[i * 4 + 3]);\n    result[i] = vec4_dot_fp64(a, row);\n  }\n  return result;\n}\n";
+//# sourceMappingURL=fp64-functions-wgsl.d.ts.map

package/dist/modules/math/fp64/fp64-functions-wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-functions-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-functions-wgsl.ts"],"names":[],"mappings":"AAIA,kEAAkE;AAClE,eAAO,MAAM,iBAAiB,o1NAuJ7B,CAAC"}

package/dist/modules/math/fp64/fp64-functions-wgsl.js

@@ -0,0 +1,157 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/** WGSL double-single functions used by geographic projection. */
+export const fp64functionsWGSL = /* wgsl */ `\
+const E_FP64 = vec2f(2.7182817459106445, 8.254840366817007e-8);
+const LOG2_FP64 = vec2f(0.6931471824645996, -1.9046542121259336e-9);
+const PI_FP64 = vec2f(3.1415927410125732, -8.742278012618954e-8);
+const TWO_PI_FP64 = vec2f(6.2831854820251465, -1.7484556025237907e-7);
+const PI_2_FP64 = vec2f(1.5707963705062866, -4.371139006309477e-8);
+const PI_4_FP64 = vec2f(0.7853981852531433, -2.1855695031547384e-8);
+const PI_180_FP64 = vec2f(0.01745329238474369, 1.3519960498364902e-10);
+
+// High/low splits of 1/n!, 1/(2n+1)!, and 1/(2n)! respectively.
+const FP64_EXP_COEFFICIENTS = array<vec2f, 17>(
+  vec2f(1.0, 0.0),
+  vec2f(1.0, 0.0),
+  vec2f(0.5, 0.0),
+  vec2f(0.1666666716337204, -4.967053879312289e-09),
+  vec2f(0.0416666679084301, -1.2417634698280722e-09),
+  vec2f(0.008333333767950535, -4.34617203337595e-10),
+  vec2f(0.0013888889225199819, -3.3631094437103215e-11),
+  vec2f(0.00019841270113829523, -2.725596874933456e-12),
+  vec2f(2.4801587642286904e-05, -3.40699609366682e-13),
+  vec2f(2.7557318844628753e-06, 3.793571224297229e-14),
+  vec2f(2.755731998149713e-07, -7.575112209051195e-15),
+  vec2f(2.5052107943679403e-08, 4.4176230446483665e-16),
+  vec2f(2.0876755879584152e-09, 1.1082839809204342e-16),
+  vec2f(1.6059044372074283e-10, -5.352526511562726e-18),
+  vec2f(1.147074536050896e-11, 2.372207689231238e-19),
+  vec2f(7.647163609812713e-13, 1.2200710471178288e-20),
+  vec2f(4.7794772561329454e-14, 7.62544404448643e-22)
+);
+const FP64_SIN_COEFFICIENTS = array<vec2f, 9>(
+  vec2f(1.0, 0.0),
+  vec2f(0.1666666716337204, -4.967053879312289e-09),
+  vec2f(0.008333333767950535, -4.34617203337595e-10),
+  vec2f(0.00019841270113829523, -2.725596874933456e-12),
+  vec2f(2.7557318844628753e-06, 3.793571224297229e-14),
+  vec2f(2.5052107943679403e-08, 4.4176230446483665e-16),
+  vec2f(1.6059044372074283e-10, -5.352526511562726e-18),
+  vec2f(7.647163609812713e-13, 1.2200710471178288e-20),
+  vec2f(2.8114573589663704e-15, -1.0462084739763658e-22)
+);
+const FP64_COS_COEFFICIENTS = array<vec2f, 9>(
+  vec2f(1.0, 0.0),
+  vec2f(0.5, 0.0),
+  vec2f(0.0416666679084301, -1.2417634698280722e-09),
+  vec2f(0.0013888889225199819, -3.3631094437103215e-11),
+  vec2f(2.4801587642286904e-05, -3.40699609366682e-13),
+  vec2f(2.755731998149713e-07, -7.575112209051195e-15),
+  vec2f(2.0876755879584152e-09, 1.1082839809204342e-16),
+  vec2f(1.147074536050896e-11, 2.372207689231238e-19),
+  vec2f(4.7794772561329454e-14, 7.62544404448643e-22)
+);
+
+// Reduce by log(2) before evaluating the exponential. Horner evaluation uses split
+// coefficients to retain low terms without repeatedly expanding double-single division.
+fn exp_fp64(value: vec2f) -> vec2f {
+  let a = normalize_fp64(value);
+  if (is_nan_fp64(a)) { return a; }
+  // WGSL rejects non-finite constant expressions; construct infinity from runtime bits.
+  if (a.x > 88.72283905206835) { return vec2f(bitcast<f32>(0x7f800000u | (bitcast<u32>(a.x) & 0x80000000u)), 0.0); }
+  if (a.x < -103.9720770839918) { return vec2f(0.0); }
+  let exponent = min(127.0, floor(a.x / LOG2_FP64.x + 0.5));
+  let remainder = sub_fp64(a, mul_fp64(LOG2_FP64, vec2f(exponent, 0.0)));
+  var result = FP64_EXP_COEFFICIENTS[16];
+  for (var i = 15; i >= 0; i--) {
+    result = sum_fp64(FP64_EXP_COEFFICIENTS[i], mul_fp64(remainder, result));
+  }
+  return fp64_scale_fp64(result, i32(exponent));
+}
+
+fn log_fp64(value: vec2f) -> vec2f {
+  let a = normalize_fp64(value);
+  if (is_nan_fp64(a)) { return a; }
+  // Match the GLSL helper's domain: zero and negative inputs return NaN.
+  if (sign_fp64(a) <= 0) { return vec2f(fp64_nan(a.x), 0.0); }
+  if (!is_finite_fp64(a)) { return a; }
+  // Normalize the magnitude before Newton refinement so exp(estimate) cannot overflow
+  // for large inputs or underflow for tiny inputs. Bit extraction also handles subnormals.
+  let exponent = max(-126, i32((bitcast<u32>(a.x) >> 23u) & 255u) - 127);
+  let mantissa = fp64_scale_fp64(a, -exponent);
+  var result = vec2f(log(mantissa.x), 0.0);
+  // Newton correction, written as (a - exp(x)) / exp(x), preserves tiny log(1 + low).
+  // Two iterations remove the error in the native f32 starting estimate.
+  for (var i = 0; i < 2; i++) {
+    let estimate = exp_fp64(result);
+    result = sum_fp64(result, div_fp64(sub_fp64(mantissa, estimate), estimate));
+  }
+  return sum_fp64(result, mul_fp64(LOG2_FP64, vec2f(f32(exponent), 0.0)));
+}
+
+struct Fp64SinCos {
+  sine: vec2f,
+  cosine: vec2f,
+};
+
+fn fp64_sincos(value: vec2f) -> Fp64SinCos {
+  let a = normalize_fp64(value);
+  // The projection use case stays within one turn. Bound conversion to an integer quadrant;
+  // this is not a large-argument Payne-Hanek trigonometric range reducer.
+  if (!is_finite_fp64(a) || abs(a.x) > 1000000.0) {
+    return Fp64SinCos(vec2f(fp64_nan(a.x), 0.0), vec2f(fp64_nan(a.x), 0.0));
+  }
+  let quadrant = i32(floor(a.x / PI_2_FP64.x + 0.5));
+  let remainder = sub_fp64(a, mul_fp64(PI_2_FP64, vec2f(f32(quadrant), 0.0)));
+  let negativeSquare = -mul_fp64(remainder, remainder);
+  var sinePolynomial = FP64_SIN_COEFFICIENTS[8];
+  var cosine = FP64_COS_COEFFICIENTS[8];
+  for (var i = 7; i >= 0; i--) {
+    sinePolynomial = sum_fp64(FP64_SIN_COEFFICIENTS[i], mul_fp64(negativeSquare, sinePolynomial));
+    cosine = sum_fp64(FP64_COS_COEFFICIENTS[i], mul_fp64(negativeSquare, cosine));
+  }
+  let sine = mul_fp64(remainder, sinePolynomial);
+  switch ((quadrant % 4 + 4) % 4) {
+    case 0: { return Fp64SinCos(sine, cosine); }
+    case 1: { return Fp64SinCos(cosine, -sine); }
+    case 2: { return Fp64SinCos(-sine, -cosine); }
+    default: { return Fp64SinCos(-cosine, sine); }
+  }
+}
+
+fn sin_fp64(a: vec2f) -> vec2f { return fp64_sincos(a).sine; }
+fn cos_fp64(a: vec2f) -> vec2f { return fp64_sincos(a).cosine; }
+fn tan_fp64(a: vec2f) -> vec2f {
+  let result = fp64_sincos(a);
+  return div_fp64(result.sine, result.cosine);
+}
+
+fn radians_fp64(degree: vec2f) -> vec2f { return mul_fp64(degree, PI_180_FP64); }
+fn mix_fp64(a: vec2f, b: vec2f, x: f32) -> vec2f {
+  return sum_fp64(a, mul_fp64(sub_fp64(b, a), vec2f(x, 0.0)));
+}
+
+// WGSL returns arrays in place of GLSL out parameters. Each vec2f stores [high, low].
+fn vec4_fp64(a: vec4f) -> array<vec2f, 4> {
+  return array<vec2f, 4>(vec2f(a.x, 0.0), vec2f(a.y, 0.0), vec2f(a.z, 0.0), vec2f(a.w, 0.0));
+}
+
+fn vec4_dot_fp64(a: array<vec2f, 4>, b: array<vec2f, 4>) -> vec2f {
+  return sum_fp64(
+    sum_fp64(mul_fp64(a[0], b[0]), mul_fp64(a[1], b[1])),
+    sum_fp64(mul_fp64(a[2], b[2]), mul_fp64(a[3], b[3])));
+}
+
+// Same row-major pair ordering as the GLSL helper: result[i] = dot(matrix[i * 4..], a).
+fn mat4_vec4_mul_fp64(matrix: array<vec2f, 16>, a: array<vec2f, 4>) -> array<vec2f, 4> {
+  var result: array<vec2f, 4>;
+  for (var i = 0; i < 4; i++) {
+    let row = array<vec2f, 4>(matrix[i * 4], matrix[i * 4 + 1], matrix[i * 4 + 2], matrix[i * 4 + 3]);
+    result[i] = vec4_dot_fp64(a, row);
+  }
+  return result;
+}
+`;
+//# sourceMappingURL=fp64-functions-wgsl.js.map

package/dist/modules/math/fp64/fp64-functions-wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-functions-wgsl.js","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-functions-wgsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAE5D,kEAAkE;AAClE,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuJ3C,CAAC"}

package/dist/modules/math/fp64/fp64-utils.cjs

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fp64_utils_exports = {};
+__export(fp64_utils_exports, {
+  fp64LowPart: () => fp64LowPart,
+  fp64ify: () => fp64ify,
+  fp64ifyMatrix4: () => fp64ifyMatrix4
+});
+module.exports = __toCommonJS(fp64_utils_exports);
+function fp64ify(a, out = [], startIndex = 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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fp64LowPart,
+  fp64ify,
+  fp64ifyMatrix4
+});

package/dist/modules/math/fp64/fp64-utils.d.ts

@@ -0,0 +1,22 @@
+import type { NumericArray } from '@math.gl/core';
+/**
+ * Calculate WebGL 64 bit float
+ * @param a  - the input float number
+ * @param out - the output array. If not supplied, a new array is created.
+ * @param startIndex - the index in the output array to fill from. Default 0.
+ * @returns - the fp64 representation of the input number
+ */
+export declare function fp64ify(a: number, out?: NumericArray, startIndex?: number): NumericArray;
+/**
+ * Calculate the low part of a WebGL 64 bit float
+ * @param a the input float number
+ * @returns the lower 32 bit of the number
+ */
+export declare function fp64LowPart(a: number): number;
+/**
+ * Calculate WebGL 64 bit matrix (transposed "Float64Array")
+ * @param matrix  the input matrix
+ * @returns the fp64 representation of the input matrix
+ */
+export declare function fp64ifyMatrix4(matrix: NumericArray): Float32Array;
+//# sourceMappingURL=fp64-utils.d.ts.map

package/dist/modules/math/fp64/fp64-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-utils.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAEhD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,GAAE,YAAiB,EAAE,UAAU,GAAE,MAAU,GAAG,YAAY,CAM/F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAUjE"}

package/dist/modules/math/fp64/fp64-utils.js

@@ -0,0 +1,42 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/**
+ * Calculate WebGL 64 bit float
+ * @param a  - the input float number
+ * @param out - the output array. If not supplied, a new array is created.
+ * @param startIndex - the index in the output array to fill from. Default 0.
+ * @returns - the fp64 representation of the input number
+ */
+export function fp64ify(a, out = [], startIndex = 0) {
+    const hiPart = Math.fround(a);
+    const loPart = a - hiPart;
+    out[startIndex] = hiPart;
+    out[startIndex + 1] = loPart;
+    return out;
+}
+/**
+ * Calculate the low part of a WebGL 64 bit float
+ * @param a the input float number
+ * @returns the lower 32 bit of the number
+ */
+export function fp64LowPart(a) {
+    return a - Math.fround(a);
+}
+/**
+ * Calculate WebGL 64 bit matrix (transposed "Float64Array")
+ * @param matrix  the input matrix
+ * @returns the fp64 representation of the input matrix
+ */
+export function fp64ifyMatrix4(matrix) {
+    // Transpose the projection matrix to column major for GLSL.
+    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;
+}
+//# sourceMappingURL=fp64-utils.js.map

package/dist/modules/math/fp64/fp64-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-utils.js","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-utils.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAI5D;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CAAC,CAAS,EAAE,MAAoB,EAAE,EAAE,aAAqB,CAAC;IAC/E,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAC9B,MAAM,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC;IAC1B,GAAG,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC;IACzB,GAAG,CAAC,UAAU,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC;IAC7B,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,CAAS;IACnC,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAC5B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,MAAoB;IACjD,4DAA4D;IAC5D,MAAM,UAAU,GAAG,IAAI,YAAY,CAAC,EAAE,CAAC,CAAC;IACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YAC3B,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACxB,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/dist/modules/math/fp64/fp64.cjs

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fp64_exports = {};
+__export(fp64_exports, {
+  fp64: () => fp64,
+  fp64LowPart: () => import_fp64_utils.fp64LowPart,
+  fp64arithmetic: () => fp64arithmetic,
+  fp64ify: () => import_fp64_utils.fp64ify,
+  fp64ifyMatrix4: () => import_fp64_utils.fp64ifyMatrix4
+});
+module.exports = __toCommonJS(fp64_exports);
+var import_fp64_utils = require("./fp64-utils.cjs");
+var import_fp64_arithmetic_glsl = require("./fp64-arithmetic-glsl.cjs");
+var import_fp64_arithmetic_wgsl = require("./fp64-arithmetic-wgsl.cjs");
+var import_fp64_functions_glsl = require("./fp64-functions-glsl.cjs");
+var import_fp64_functions_wgsl = require("./fp64-functions-wgsl.cjs");
+const defaultUniforms = {
+  // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  ONE: 1,
+  // Runtime split factor for Dekker splitting. Keeping this as a uniform helps
+  // prevent aggressive constant folding in shader compilers.
+  SPLIT: 4097
+};
+const fp64arithmetic = {
+  name: "fp64arithmetic",
+  source: import_fp64_arithmetic_wgsl.fp64arithmeticWGSL,
+  fs: import_fp64_arithmetic_glsl.fp64arithmeticShader,
+  vs: import_fp64_arithmetic_glsl.fp64arithmeticShader,
+  defaultUniforms,
+  uniformTypes: { ONE: "f32", SPLIT: "f32" },
+  // Additional Functions
+  fp64ify: import_fp64_utils.fp64ify,
+  fp64LowPart: import_fp64_utils.fp64LowPart,
+  fp64ifyMatrix4: import_fp64_utils.fp64ifyMatrix4
+};
+const fp64 = {
+  name: "fp64",
+  source: import_fp64_functions_wgsl.fp64functionsWGSL,
+  vs: import_fp64_functions_glsl.fp64functionShader,
+  dependencies: [fp64arithmetic],
+  // Additional Functions
+  fp64ify: import_fp64_utils.fp64ify,
+  fp64LowPart: import_fp64_utils.fp64LowPart,
+  fp64ifyMatrix4: import_fp64_utils.fp64ifyMatrix4
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fp64,
+  fp64LowPart,
+  fp64arithmetic,
+  fp64ify,
+  fp64ifyMatrix4
+});

package/dist/modules/math/fp64/fp64.d.ts

@@ -0,0 +1,24 @@
+import { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+import { fp64ify, fp64LowPart, fp64ifyMatrix4 } from "./fp64-utils.js";
+type FP64Props = {};
+type FP64Uniforms = {
+    ONE: number;
+    SPLIT: number;
+};
+type FP64Bindings = {};
+type FP64Utilities = {
+    fp64ify: typeof fp64ify;
+    fp64LowPart: typeof fp64LowPart;
+    fp64ifyMatrix4: typeof fp64ifyMatrix4;
+};
+/**
+ * 64bit arithmetic: add, sub, mul, div (small subset of fp64 module)
+ */
+export declare const fp64arithmetic: ShaderModule<FP64Props, FP64Uniforms, FP64Bindings> & FP64Utilities;
+/**
+ * Double-single math: full GLSL library and WGSL projection functions.
+ * WGSL vector/matrix helpers return arrays instead of using GLSL out parameters.
+ */
+export declare const fp64: ShaderModule<{}> & FP64Utilities;
+export { fp64ify, fp64LowPart, fp64ifyMatrix4 };
+//# sourceMappingURL=fp64.d.ts.map

package/dist/modules/math/fp64/fp64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAEtE,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,wBAAqB;AAMlE,KAAK,SAAS,GAAG,EAAE,CAAC;AACpB,KAAK,YAAY,GAAG;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAAC;AACjD,KAAK,YAAY,GAAG,EAAE,CAAC;AAEvB,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,OAAO,OAAO,CAAC;IACxB,WAAW,EAAE,OAAO,WAAW,CAAC;IAChC,cAAc,EAAE,OAAO,cAAc,CAAC;CACvC,CAAC;AAUF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,CAAC,GAAG,aAYlF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,aAUrC,CAAC;AAEF,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,CAAC"}

package/dist/modules/math/fp64/fp64.js

@@ -0,0 +1,46 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { fp64ify, fp64LowPart, fp64ifyMatrix4 } from "./fp64-utils.js";
+import { fp64arithmeticShader } from "./fp64-arithmetic-glsl.js";
+import { fp64arithmeticWGSL } from "./fp64-arithmetic-wgsl.js";
+import { fp64functionShader } from "./fp64-functions-glsl.js";
+import { fp64functionsWGSL } from "./fp64-functions-wgsl.js";
+const defaultUniforms = {
+    // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+    ONE: 1.0,
+    // Runtime split factor for Dekker splitting. Keeping this as a uniform helps
+    // prevent aggressive constant folding in shader compilers.
+    SPLIT: 4097.0
+};
+/**
+ * 64bit arithmetic: add, sub, mul, div (small subset of fp64 module)
+ */
+export const fp64arithmetic = {
+    name: 'fp64arithmetic',
+    source: fp64arithmeticWGSL,
+    fs: fp64arithmeticShader,
+    vs: fp64arithmeticShader,
+    defaultUniforms,
+    uniformTypes: { ONE: 'f32', SPLIT: 'f32' },
+    // Additional Functions
+    fp64ify,
+    fp64LowPart,
+    fp64ifyMatrix4
+};
+/**
+ * Double-single math: full GLSL library and WGSL projection functions.
+ * WGSL vector/matrix helpers return arrays instead of using GLSL out parameters.
+ */
+export const fp64 = {
+    name: 'fp64',
+    source: fp64functionsWGSL,
+    vs: fp64functionShader,
+    dependencies: [fp64arithmetic],
+    // Additional Functions
+    fp64ify,
+    fp64LowPart,
+    fp64ifyMatrix4
+};
+export { fp64ify, fp64LowPart, fp64ifyMatrix4 };
+//# sourceMappingURL=fp64.js.map

package/dist/modules/math/fp64/fp64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64.js","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAI5D,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,wBAAqB;AAClE,OAAO,EAAC,oBAAoB,EAAC,kCAA+B;AAC5D,OAAO,EAAC,kBAAkB,EAAC,kCAA+B;AAC1D,OAAO,EAAC,kBAAkB,EAAC,iCAA8B;AACzD,OAAO,EAAC,iBAAiB,EAAC,iCAA8B;AAYxD,MAAM,eAAe,GAAiB;IACpC,gDAAgD;IAChD,GAAG,EAAE,GAAG;IACR,6EAA6E;IAC7E,2DAA2D;IAC3D,KAAK,EAAE,MAAM;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAwE;IACjG,IAAI,EAAE,gBAAgB;IACtB,MAAM,EAAE,kBAAkB;IAC1B,EAAE,EAAE,oBAAoB;IACxB,EAAE,EAAE,oBAAoB;IACxB,eAAe;IACf,YAAY,EAAE,EAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAC;IAExC,uBAAuB;IACvB,OAAO;IACP,WAAW;IACX,cAAc;CACf,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,IAAI,GAAqC;IACpD,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,iBAAiB;IACzB,EAAE,EAAE,kBAAkB;IACtB,YAAY,EAAE,CAAC,cAAc,CAAC;IAE9B,uBAAuB;IACvB,OAAO;IACP,WAAW;IACX,cAAc;CACf,CAAC;AAEF,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,CAAC"}