@vitreajs/vitrea 0.1.0

package/dist/chunk-ST6GFEQT.js

@@ -0,0 +1,502 @@
+// ../geometry/dist/channels.js
+var SHAPE_FAMILIES = ["fixed-rounded-rect", "capsule", "concentric-rounded-rect"];
+function halfExtents(size) {
+  return { halfW: Math.max(size[0], 0) / 2, halfH: Math.max(size[1], 0) / 2 };
+}
+var uniformRadii = (r) => [r, r, r, r];
+
+// ../geometry/dist/errors.js
+var GeometryError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "GeometryError";
+    this.code = code;
+  }
+};
+
+// ../geometry/dist/corner.js
+var toRad = (deg) => deg * Math.PI / 180;
+function cornerBudget(halfW, halfH) {
+  return Math.min(halfW, halfH);
+}
+function smoothingCeiling(radius, budget) {
+  if (radius <= 0)
+    return Number.POSITIVE_INFINITY;
+  return Math.max(0, budget / radius - 1);
+}
+function resolveCornerConstruction(halfW, halfH, radius, smoothing) {
+  const budget = cornerBudget(halfW, halfH);
+  const r = Math.min(Math.max(radius, 0), budget);
+  const requested = Math.min(Math.max(smoothing, 0), 1);
+  const s = Math.min(requested, smoothingCeiling(r, budget));
+  const reach = Math.min((1 + s) * r, budget);
+  const arcMeasureDeg = 90 * (1 - s);
+  const arcSectionLength = Math.sin(toRad(arcMeasureDeg / 2)) * r * Math.SQRT2;
+  const angleAlpha = (90 - arcMeasureDeg) / 2;
+  const p3ToP4Distance = r * Math.tan(toRad(angleAlpha / 2));
+  const angleBeta = 45 * s;
+  const c = p3ToP4Distance * Math.cos(toRad(angleBeta));
+  const d = c * Math.tan(toRad(angleBeta));
+  const b = (reach - arcSectionLength - c - d) / 3;
+  const a = 2 * b;
+  return {
+    radius: r,
+    smoothingEff: s,
+    reach,
+    a,
+    b,
+    c,
+    d,
+    arcSectionLength,
+    arcMeasure: toRad(arcMeasureDeg),
+    budget
+  };
+}
+
+// ../geometry/dist/coefficients.js
+var ZERO_COEFFICIENTS = [0, 0, 0, 0, 0];
+var FIGMA_RSUPN_TABLE = [
+  { sEff: 0, k: [0, 0, 0, 0, 0], contourDevPerR: 444089e-20 },
+  { sEff: 0.05, k: [0.17192786, -0.57453584, 0.93678851, -0.74224658, 0.22784924], contourDevPerR: 787263e-10 },
+  { sEff: 0.1, k: [0.15267992, -0.12909167, -0.22499519, 0.42555348, -0.18655278], contourDevPerR: 220143e-9 },
+  { sEff: 0.15, k: [0.08481224, 0.39460055, -1.27818536, 1.3146661, -0.46204673], contourDevPerR: 208252e-9 },
+  { sEff: 0.2, k: [0.06710202, 0.4426899, -1.08444805, 0.90833394, -0.26486554], contourDevPerR: 317781e-9 },
+  { sEff: 0.25, k: [0.08593485, 0.21389316, -0.284278, -0.03442399, 0.10203143], contourDevPerR: 393427e-9 },
+  { sEff: 0.3, k: [0.12086127, -0.09837148, 0.58740362, -0.92505881, 0.41092682], contourDevPerR: 384627e-9 },
+  { sEff: 0.35, k: [0.19195982, -0.58065521, 1.68747114, -1.90488976, 0.71339719], contourDevPerR: 37628e-8 },
+  { sEff: 0.4, k: [0.20580383, -0.64359429, 1.72183146, -1.7735827, 0.60749205], contourDevPerR: 554941e-9 },
+  { sEff: 0.45, k: [0.20963391, -0.6235343, 1.53893663, -1.42961335, 0.43272753], contourDevPerR: 696599e-9 },
+  { sEff: 0.5, k: [0.18345838, -0.39738895, 0.86930065, -0.6162596, 0.09847429], contourDevPerR: 729633e-9 },
+  { sEff: 0.55, k: [0.15021017, -0.10642312, 0.03456218, 0.35031318, -0.28210743], contourDevPerR: 65723e-8 },
+  { sEff: 0.6, k: [0.0574571, 0.54959359, -1.57948482, 2.01134453, -0.88391405], contourDevPerR: 533969e-9 },
+  { sEff: 0.65, k: [0.0290426, 0.79150557, -2.2341988, 2.71564668, -1.13881723], contourDevPerR: 705984e-9 },
+  { sEff: 0.7, k: [610502e-8, 0.95536509, -2.62411085, 3.08626749, -1.25256664], contourDevPerR: 951783e-9 },
+  { sEff: 0.75, k: [-912482e-8, 1.0608592, -2.86162189, 3.29090302, -1.30280908], contourDevPerR: 120108e-8 },
+  { sEff: 0.8, k: [-0.02095565, 1.12907188, -2.97794712, 3.34408477, -1.28941254], contourDevPerR: 134355e-8 },
+  { sEff: 0.85, k: [0.01389408, 0.89302668, -2.39016784, 2.70448292, -1.03018516], contourDevPerR: 138316e-8 },
+  { sEff: 0.9, k: [0.01628625, 0.79606496, -2.00469962, 2.1767657, -0.78757687], contourDevPerR: 120458e-8 },
+  { sEff: 0.95, k: [0.06037106, 0.48294462, -1.1916487, 1.27094865, -0.42038678], contourDevPerR: 843346e-9 },
+  { sEff: 1, k: [0.10910234, 0.09555105, -0.1426663, 0.0921919, 0.05309191], contourDevPerR: 328245e-9 }
+];
+var FIGMA_RSUP_TABLE = [
+  { sEff: 0, k: [0, 0, 0, 0, 0], contourDevPerR: 455191e-20 },
+  { sEff: 0.05, k: [0.17229922, -0.57843267, 0.94745447, -0.75342668, 0.23188652], contourDevPerR: 795723e-10 },
+  { sEff: 0.1, k: [0.1528229, -0.13030581, -0.2214859, 0.42143243, -0.18487674], contourDevPerR: 221321e-9 },
+  { sEff: 0.15, k: [0.08799722, 0.37596759, -1.23860352, 1.27833243, -0.44984249], contourDevPerR: 20311e-8 },
+  { sEff: 0.2, k: [0.06791092, 0.43598426, -1.06654674, 0.88960434, -0.25815276], contourDevPerR: 314471e-9 },
+  { sEff: 0.25, k: [0.08568973, 0.21482387, -0.2852117, -0.03448269, 0.10234124], contourDevPerR: 397169e-9 },
+  { sEff: 0.3, k: [0.12107115, -0.10034704, 0.59290929, -0.93110813, 0.41323529], contourDevPerR: 389318e-9 },
+  { sEff: 0.35, k: [0.19473757, -0.60204839, 1.74425741, -1.96756079, 0.73790198], contourDevPerR: 396366e-9 },
+  { sEff: 0.4, k: [0.20633019, -0.64612615, 1.7257626, -1.77580066, 0.60777871], contourDevPerR: 562865e-9 },
+  { sEff: 0.45, k: [0.20740344, -0.60694729, 1.49567287, -1.38229267, 0.41422845], contourDevPerR: 702136e-9 },
+  { sEff: 0.5, k: [0.18442027, -0.40109927, 0.87301409, -0.61604528, 0.09728682], contourDevPerR: 741861e-9 },
+  { sEff: 0.55, k: [0.14433866, -0.07398101, -0.03198855, 0.41009473, -0.30191682], contourDevPerR: 669581e-9 },
+  { sEff: 0.6, k: [0.05594672, 0.55731115, -1.59567242, 2.0268849, -0.88947808], contourDevPerR: 540505e-9 },
+  { sEff: 0.65, k: [0.02895533, 0.78966635, -2.22398983, 2.69966652, -1.13103881], contourDevPerR: 713798e-9 },
+  { sEff: 0.7, k: [364655e-8, 0.97120044, -2.65963414, 3.1198731, -1.26404382], contourDevPerR: 983567e-9 },
+  { sEff: 0.75, k: [-900127e-8, 1.06159349, -2.86306846, 3.29036733, -1.30166793], contourDevPerR: 123106e-8 },
+  { sEff: 0.8, k: [-0.02181546, 1.13237968, -2.9794545, 3.33958794, -1.28583799], contourDevPerR: 137656e-8 },
+  { sEff: 0.85, k: [0.01079982, 0.90842707, -2.41502297, 2.7192196, -1.03234863], contourDevPerR: 140703e-8 },
+  { sEff: 0.9, k: [0.02082712, 0.78785003, -2.01122302, 2.1960281, -0.79663302], contourDevPerR: 122131e-8 },
+  { sEff: 0.95, k: [0.06028054, 0.48151129, -1.18355152, 1.25863912, -0.41464021], contourDevPerR: 863628e-9 },
+  { sEff: 1, k: [0.10998181, 0.08963148, -0.12832942, 0.07742006, 0.05857178], contourDevPerR: 337869e-9 }
+];
+var APPLE_RSUPN = {
+  k: [0.058939, 0.53608908, -1.48273371, 1.77253595, -0.74059491],
+  contourDevPerR: 606381e-9
+};
+var APPLE_RSUP = {
+  k: [0.05944375, 0.53352847, -1.47723609, 1.76689797, -0.73837656],
+  contourDevPerR: 62355e-8
+};
+function coefficientsAt(table, sEff) {
+  const first = table[0];
+  const last = table[table.length - 1];
+  if (first === void 0 || last === void 0) {
+    throw new Error("empty coefficient table");
+  }
+  if (sEff <= first.sEff)
+    return { k: first.k, contourDevPerR: first.contourDevPerR };
+  if (sEff >= last.sEff)
+    return { k: last.k, contourDevPerR: last.contourDevPerR };
+  for (let i = 1; i < table.length; i++) {
+    const lo = table[i - 1];
+    const hi = table[i];
+    if (lo === void 0 || hi === void 0)
+      break;
+    if (sEff <= hi.sEff) {
+      const u = (sEff - lo.sEff) / (hi.sEff - lo.sEff);
+      const mix = (j) => lo.k[j] + u * (hi.k[j] - lo.k[j]);
+      return {
+        k: [mix(0), mix(1), mix(2), mix(3), mix(4)],
+        contourDevPerR: lo.contourDevPerR + u * (hi.contourDevPerR - lo.contourDevPerR)
+      };
+    }
+  }
+  return { k: last.k, contourDevPerR: last.contourDevPerR };
+}
+
+// ../geometry/dist/apple.js
+var APPLE_REACH = 1.52866495;
+var APPLE_CONTINUOUS_SMOOTHING_SEED = APPLE_REACH - 1;
+
+// ../geometry/dist/shape.js
+function assertUniformRadii(radii) {
+  const [tl, tr, br, bl] = radii;
+  const spread = Math.max(tl, tr, br, bl) - Math.min(tl, tr, br, bl);
+  if (spread > 1e-9) {
+    throw new GeometryError("non-uniform-radii", `Per-corner radii are post-v1: got [${tl}, ${tr}, ${br}, ${bl}]. v1's corner algebra is mirror-symmetric (it reads |x| and |y|), so it cannot express four different corners, and the declared error bound was swept for uniform radii only. Use one radius for all four corners.`);
+  }
+  return tl;
+}
+function coefficientsFor(reference, family, sEff, radius) {
+  if (radius <= 0)
+    return { k: ZERO_COEFFICIENTS, contourDevPerR: 0 };
+  if (reference === "apple-continuous") {
+    const fit = family === "rsupn" ? APPLE_RSUPN : APPLE_RSUP;
+    return { k: fit.k, contourDevPerR: fit.contourDevPerR };
+  }
+  return coefficientsAt(family === "rsupn" ? FIGMA_RSUPN_TABLE : FIGMA_RSUP_TABLE, sEff);
+}
+function resolveCorner(size, radius, smoothing, reference, family = "rsupn") {
+  const { halfW, halfH } = halfExtents(size);
+  if (reference === "apple-continuous") {
+    const budget = cornerBudget(halfW, halfH);
+    const r = Math.max(0, Math.min(radius, budget / APPLE_REACH));
+    const fit2 = coefficientsFor(reference, family, APPLE_CONTINUOUS_SMOOTHING_SEED, r);
+    return {
+      reference,
+      radius: r,
+      smoothingEff: r > 0 ? APPLE_CONTINUOUS_SMOOTHING_SEED : 0,
+      reach: APPLE_REACH * r,
+      a: 0,
+      b: 0,
+      c: 0,
+      d: 0,
+      arcSectionLength: 0,
+      arcMeasure: 50 * Math.PI / 180,
+      budget,
+      k: fit2.k,
+      contourDevPerR: fit2.contourDevPerR
+    };
+  }
+  const construction = resolveCornerConstruction(halfW, halfH, radius, smoothing);
+  const fit = coefficientsFor(reference, family, construction.smoothingEff, construction.radius);
+  return { ...construction, reference, k: fit.k, contourDevPerR: fit.contourDevPerR };
+}
+function resolveFromChannels(channels, reference, family = "fixed-rounded-rect", options = {}) {
+  const devMode = options.devMode ?? true;
+  const radius = devMode ? assertUniformRadii(channels.radii) : channels.radii[0] ?? 0;
+  return {
+    family,
+    channels,
+    corner: resolveCorner(channels.size, radius, channels.smoothing, reference)
+  };
+}
+function fieldParams(shape) {
+  const { halfW, halfH } = halfExtents(shape.channels.size);
+  return { halfW, halfH, reach: shape.corner.reach, k: shape.corner.k };
+}
+function governorFieldParams(shape) {
+  const { halfW, halfH } = halfExtents(shape.channels.size);
+  const corner = resolveCorner(shape.channels.size, shape.corner.radius, shape.channels.smoothing, shape.corner.reference, "rsup");
+  return { halfW, halfH, reach: corner.reach, k: corner.k };
+}
+
+// ../geometry/dist/concentric.js
+var MEASURED_BAND_PX = 8;
+var DEFAULT_CONCENTRIC_MIN_RADIUS = 2;
+function resolveConcentric(parent, spec) {
+  const inset = Math.max(spec.inset, 0);
+  const minRadius = spec.minRadius ?? DEFAULT_CONCENTRIC_MIN_RADIUS;
+  const size = [
+    Math.max(parent.channels.size[0] - 2 * inset, 0),
+    Math.max(parent.channels.size[1] - 2 * inset, 0)
+  ];
+  const { halfW, halfH } = halfExtents(size);
+  const childBudget = cornerBudget(halfW, halfH);
+  const offsetRadius = parent.corner.radius - inset;
+  const floored = Math.max(offsetRadius, minRadius);
+  const radius = Math.min(floored, childBudget);
+  const radiusFloored = floored > offsetRadius + 1e-12;
+  const smoothing = parent.channels.smoothing;
+  const channels = {
+    center: parent.channels.center,
+    size,
+    radii: uniformRadii(radius),
+    smoothing,
+    thickness: spec.thickness ?? parent.channels.thickness
+  };
+  return {
+    shape: {
+      family: "concentric-rounded-rect",
+      channels,
+      corner: resolveCorner(size, radius, smoothing, parent.corner.reference)
+    },
+    radiusFloored,
+    beyondMeasuredBand: inset > MEASURED_BAND_PX
+  };
+}
+
+// ../geometry/dist/union.js
+var DEFAULT_GROUP_UNION = {
+  neckWidth: 8,
+  maxBulge: 2,
+  separationThreshold: 16
+};
+var WGSL_RSUPN = `fn sd_rsupn(p : vec2f, half : vec2f, re : f32, k : vec4f, k4 : f32) -> f32 {
+  let q  = abs(p) - half + vec2f(re, re);
+  let c  = max(q, vec2f(0.0, 0.0));
+  let r2 = max(dot(c, c), 1e-20);
+  let inv = 1.0 / r2;
+  let s2 = 2.0 * c.x * c.y * inv;             // sin(2*theta)
+  let c2 = (c.x * c.x - c.y * c.y) * inv;     // cos(2*theta)
+
+  // R(theta) = re * (1 + s2^2 * poly(s2)), Horner
+  var acc = k4;
+  acc = acc * s2 + k.w;
+  acc = acc * s2 + k.z;
+  acc = acc * s2 + k.y;
+  acc = acc * s2 + k.x;
+  let R = re * (1.0 + s2 * s2 * acc);
+
+  // dR/d(s2) * d(s2)/dtheta, same Horner shape with the differentiated weights
+  var dac = 6.0 * k4;
+  dac = dac * s2 + 5.0 * k.w;
+  dac = dac * s2 + 4.0 * k.z;
+  dac = dac * s2 + 3.0 * k.y;
+  dac = dac * s2 + 2.0 * k.x;
+  let dRdt = re * s2 * dac * (2.0 * c2);
+
+  let base = sqrt(r2) + min(max(q.x, q.y), 0.0) - R;
+  // The normalization is a Newton step to the zero set, so its slope is read at
+  // the FOOT of the step: at the contour radius R, never at a sample radius
+  // inside it. On and outside the level set the selected arm is bit-for-bit the
+  // product S2 benchmarked; inside the corner sector the anchor is what stops
+  // R'/rho diverging toward the sector vertex and collapsing the field into a
+  // false near-surface region. See field.ts, "The normalization".
+  let g = select(dRdt / R, dRdt * inv * sqrt(r2), sqrt(r2) >= R);
+  return base * inverseSqrt(1.0 + g * g);
+}`;
+var WGSL_RSUP = `fn sd_rsup(p : vec2f, half : vec2f, re : f32, k : vec4f, k4 : f32) -> f32 {
+  let q  = abs(p) - half + vec2f(re, re);
+  let c  = max(q, vec2f(0.0, 0.0));
+  let r2 = max(dot(c, c), 1e-20);
+  let s2 = 2.0 * c.x * c.y / r2;
+  var acc = k4;
+  acc = acc * s2 + k.w;
+  acc = acc * s2 + k.z;
+  acc = acc * s2 + k.y;
+  acc = acc * s2 + k.x;
+  let R = re * (1.0 + s2 * s2 * acc);
+  return sqrt(r2) + min(max(q.x, q.y), 0.0) - R;
+}`;
+
+// ../motion/dist/channels.js
+var MOTION_CHANNELS = [
+  "position",
+  "size",
+  "radius",
+  "pressCompression",
+  "lensStrength",
+  "glow",
+  "backdropAdaptation",
+  "foregroundTone",
+  "materialization",
+  "disabled",
+  "qualityTier"
+];
+var MOTION_DRIVER_BY_CHANNEL = {
+  position: "interruptible-spring",
+  size: "interruptible-spring",
+  radius: "interruptible-spring",
+  pressCompression: "interruptible-spring",
+  lensStrength: "critically-damped",
+  glow: "attack-decay",
+  backdropAdaptation: "low-pass-hysteresis",
+  foregroundTone: "threshold-crossfade",
+  materialization: "monotonic-ease",
+  disabled: "step",
+  qualityTier: "hysteresis-cooldown"
+};
+MOTION_CHANNELS.filter((channel) => MOTION_DRIVER_BY_CHANNEL[channel] === "monotonic-ease" || MOTION_DRIVER_BY_CHANNEL[channel] === "step");
+
+// ../motion/dist/states.js
+var INTERACTION_STATES = [
+  "idle",
+  "hover",
+  "pressed",
+  "focused",
+  "disabled",
+  "morphing"
+];
+
+// ../motion/dist/drivers/low-pass.js
+var LowPassHysteresisDriver = class {
+  config;
+  #value;
+  #committed;
+  constructor(config, initialValue) {
+    this.config = config;
+    this.#value = initialValue;
+    this.#committed = initialValue;
+  }
+  get value() {
+    return this.#value;
+  }
+  get velocity() {
+    const tau = this.config.timeConstantMs;
+    if (tau <= 0)
+      return 0;
+    return (this.#committed - this.#value) * 1e3 / tau;
+  }
+  get target() {
+    return this.#committed;
+  }
+  get settled() {
+    return Math.abs(this.#value - this.#committed) <= this.config.restDistance;
+  }
+  retarget(input) {
+    if (Math.abs(input - this.#committed) <= this.config.hysteresis)
+      return;
+    this.#committed = input;
+  }
+  jumpTo(value) {
+    this.#value = value;
+    this.#committed = value;
+  }
+  advance(dtMs) {
+    if (!(dtMs > 0))
+      return;
+    const tau = this.config.timeConstantMs;
+    if (tau <= 0) {
+      this.#value = this.#committed;
+      return;
+    }
+    this.#value = this.#committed + (this.#value - this.#committed) * Math.exp(-dtMs / tau);
+  }
+};
+
+// ../motion/dist/tunables.js
+var DEFAULT_MOTION_PROFILE = {
+  frame: { maxDeltaMs: 50 },
+  channels: {
+    // Layout and morph geometry. Slightly underdamped: a trace of overshoot is
+    // what reads as material rather than as a tween.
+    position: {
+      kind: "interruptible-spring",
+      responseMs: 420,
+      dampingRatio: 0.82,
+      restDistance: 0.02,
+      restVelocity: 0.05
+    },
+    size: {
+      kind: "interruptible-spring",
+      responseMs: 460,
+      dampingRatio: 0.85,
+      restDistance: 0.02,
+      restVelocity: 0.05
+    },
+    radius: {
+      kind: "interruptible-spring",
+      responseMs: 460,
+      dampingRatio: 0.9,
+      restDistance: 0.02,
+      restVelocity: 0.05
+    },
+    // Press compression. Faster and looser than layout — the release bounce is
+    // most of what makes a press feel physical.
+    pressCompression: {
+      kind: "interruptible-spring",
+      responseMs: 260,
+      dampingRatio: 0.72,
+      restDistance: 1e-3,
+      restVelocity: 5e-3
+    },
+    // Optical strength must not overshoot: past 1 the lens visibly over-bends.
+    lensStrength: {
+      kind: "critically-damped",
+      responseMs: 300,
+      dampingRatio: 1,
+      restDistance: 1e-3,
+      restVelocity: 5e-3
+    },
+    // Fast attack, slow decay: light arrives with the finger and lingers after.
+    glow: { kind: "attack-decay", attackMs: 70, decayMs: 320, restDistance: 1e-3 },
+    // Backdrop adaptation. Long constant and a wide band so scrolling past a
+    // contrast edge cannot pump the material.
+    backdropAdaptation: {
+      kind: "low-pass-hysteresis",
+      timeConstantMs: 500,
+      hysteresis: 0.04,
+      restDistance: 1e-3
+    },
+    // Foreground light/dark. Band wide enough that mid-luminance backdrops do
+    // not oscillate the text colour.
+    foregroundTone: {
+      kind: "threshold-crossfade",
+      threshold: 0.5,
+      hysteresis: 0.08,
+      crossfadeMs: 180
+    },
+    materialization: { kind: "monotonic-ease", durationMs: 220, easing: "easeOutCubic" },
+    disabled: { kind: "step", hysteresis: 0, cooldownMs: 0 },
+    // Quality tier. Long dwell, half-a-tier band: §Performance's governor
+    // switches tiers only with long hysteresis and cooldown.
+    qualityTier: { kind: "hysteresis-cooldown", hysteresis: 0.5, cooldownMs: 2500 }
+  },
+  // Interaction-driven targets. Geometry, backdrop and governor channels are
+  // absent because interaction state does not decide them (§channels).
+  stateTargets: {
+    idle: {
+      pressCompression: 0,
+      lensStrength: 1,
+      glow: 0,
+      materialization: 1,
+      disabled: 0
+    },
+    hover: {
+      pressCompression: 0,
+      lensStrength: 1.06,
+      glow: 0.28,
+      materialization: 1,
+      disabled: 0
+    },
+    pressed: {
+      pressCompression: 1,
+      lensStrength: 1.14,
+      glow: 1,
+      materialization: 1,
+      disabled: 0
+    },
+    focused: {
+      pressCompression: 0,
+      lensStrength: 1.03,
+      glow: 0.16,
+      materialization: 1,
+      disabled: 0
+    },
+    disabled: {
+      pressCompression: 0,
+      lensStrength: 0.5,
+      glow: 0,
+      materialization: 1,
+      disabled: 1
+    },
+    morphing: {
+      pressCompression: 0,
+      lensStrength: 1.1,
+      glow: 0.35,
+      materialization: 1,
+      disabled: 0
+    }
+  },
+  reducedMotion: { minDampingRatio: 1, morphResponseFactor: 0.7 },
+  pressCompressionScale: 0.015,
+  reducedMotionApplied: false
+};
+
+export { DEFAULT_GROUP_UNION, DEFAULT_MOTION_PROFILE, INTERACTION_STATES, LowPassHysteresisDriver, MOTION_DRIVER_BY_CHANNEL, SHAPE_FAMILIES, WGSL_RSUP, WGSL_RSUPN, fieldParams, governorFieldParams, resolveConcentric, resolveFromChannels };
+//# sourceMappingURL=chunk-ST6GFEQT.js.map
+//# sourceMappingURL=chunk-ST6GFEQT.js.map