shaders 2.2.23 → 2.2.25

package/dist/core/Saturation-Dup81Pnq.js

@@ -1,31 +0,0 @@
-import { O as o } from "./three.tsl-Btj1hLsf.js";
-import { r as i } from "./ColorAdjustment-CKwpE_4M.js";
-const s = {
-  name: "Saturation",
-  category: "Adjustments",
-  description: "Adjust color saturation intensity",
-  requiresChild: !0,
-  props: { intensity: {
-    default: 1,
-    description: "The intensity of the saturation effect (1 being no change)",
-    ui: {
-      type: "range",
-      min: 0,
-      max: 3,
-      step: 0.01,
-      label: "Intensity"
-    }
-  } },
-  fragmentNode: ({ uniforms: r, childNode: e }) => {
-    const { vec4: t } = o;
-    if (!e)
-      return console.error("You must pass a child component into the Saturation shader."), t(0);
-    const n = e || t(0, 0, 0, 0);
-    return t(i(n.rgb, r.intensity.uniform).rgb, n.a);
-  }
-};
-var c = s;
-export {
-  s as n,
-  c as t
-};

package/dist/core/SimplexNoise-BYEiCjDj.js

@@ -1,94 +0,0 @@
-import { A as f, N as r, a as u, d as x, j as g, u as v, v as y, x as b } from "./three.tsl-Btj1hLsf.js";
-import { t as C } from "./time-DbRMw6Jm.js";
-import { r as n } from "./transformations-CsrIJXh-.js";
-import { t as A } from "./colorMixing--dhzx0ch.js";
-const B = {
-  name: "SimplexNoise",
-  category: "Base Layers",
-  description: "Organic noise with animated movement",
-  acceptsUVContext: !0,
-  props: {
-    colorA: {
-      default: "#ffffff",
-      description: "First color",
-      transform: n,
-      ui: {
-        type: "color",
-        label: "Color A"
-      }
-    },
-    colorB: {
-      default: "#000000",
-      description: "Second color",
-      transform: n,
-      ui: {
-        type: "color",
-        label: "Color B"
-      }
-    },
-    scale: {
-      default: 2,
-      description: "Pattern scale (higher = larger patterns)",
-      ui: {
-        type: "range",
-        min: -2,
-        max: 5,
-        step: 0.1,
-        label: "Scale"
-      }
-    },
-    balance: {
-      default: 0,
-      description: "Balance between colors (negative = more colorB, positive = more colorA)",
-      ui: {
-        type: "range",
-        min: -1,
-        max: 1,
-        step: 0.01,
-        label: "Balance"
-      }
-    },
-    contrast: {
-      default: 0,
-      description: "Pattern contrast (higher = sharper transitions)",
-      ui: {
-        type: "range",
-        min: -2,
-        max: 5,
-        step: 0.1,
-        label: "Contrast"
-      }
-    },
-    seed: {
-      default: 0,
-      description: "Random seed for pattern variation",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 100,
-        step: 1,
-        label: "Seed"
-      }
-    },
-    speed: {
-      default: 1,
-      description: "Animation speed",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 5,
-        step: 0.1,
-        label: "Speed"
-      }
-    }
-  },
-  fragmentNode: (o) => {
-    const { uniforms: e, uvContext: i } = o, t = i ?? b, s = r.x.div(r.y), l = f(t.x.mul(s), t.y), c = C(o, e.speed), a = l.mul(v(e.scale.uniform)).add(e.seed.uniform), m = y(g(a.x, a.y, c.mul(0.5))), p = e.contrast.uniform.add(1), d = u(0, 1, m.mul(p).add(e.balance.uniform).mul(0.5).add(0.5));
-    return A(e.colorB.uniform, e.colorA.uniform, d, x(0));
-  }
-};
-var U = B;
-export {
-  B as n,
-  U as t
-};

package/dist/core/SineWave-C6MRPtsy.js

@@ -1,107 +0,0 @@
-import { O as U } from "./three.tsl-Btj1hLsf.js";
-import { n as V, o as W, r as _ } from "./transformations-CsrIJXh-.js";
-const F = {
-  name: "SineWave",
-  category: "Base Layers",
-  description: "Animated wave with thickness and softness",
-  acceptsUVContext: !0,
-  props: {
-    color: {
-      default: "#ffffff",
-      transform: _,
-      description: "The color of the sine wave",
-      ui: {
-        type: "color",
-        label: "Color"
-      }
-    },
-    amplitude: {
-      default: 0.15,
-      description: "The height/amplitude of the sine wave",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Amplitude"
-      }
-    },
-    frequency: {
-      default: 1,
-      description: "The frequency/number of wave cycles",
-      ui: {
-        type: "range",
-        min: 0.1,
-        max: 20,
-        step: 0.1,
-        label: "Frequency"
-      }
-    },
-    speed: {
-      default: 1,
-      description: "The animation speed of the wave",
-      ui: {
-        type: "range",
-        min: -5,
-        max: 5,
-        step: 0.1,
-        label: "Speed"
-      }
-    },
-    angle: {
-      default: 0,
-      transform: V,
-      description: "The rotation angle of the wave (in degrees)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 360,
-        step: 1,
-        label: "Angle"
-      }
-    },
-    position: {
-      default: {
-        x: 0.5,
-        y: 0.5
-      },
-      transform: W,
-      description: "The center position of the wave",
-      ui: {
-        type: "position",
-        label: "Position"
-      }
-    },
-    thickness: {
-      default: 0.2,
-      description: "The thickness of the wave line",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 2,
-        step: 0.01,
-        label: "Thickness"
-      }
-    },
-    softness: {
-      default: 0.4,
-      description: "Edge softness of the wave line",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Softness"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: e, uvContext: p }) => {
-    const { vec2: n, vec4: d, sin: o, cos: f, abs: h, smoothstep: y, screenUV: g, viewportSize: s, time: v, radians: b, PI: x } = U, a = p ?? g, i = s.x.div(s.y), w = n(a.x.mul(i), a.y), T = n(e.position.uniform.x.mul(i), e.position.uniform.y.oneMinus()), t = w.sub(T), r = b(e.angle.uniform), l = f(r), c = o(r), k = t.x.mul(l).sub(t.y.mul(c)), A = t.x.mul(c).add(t.y.mul(l)), S = v.mul(e.speed.uniform), q = o(k.mul(e.frequency.uniform).mul(x.mul(2)).add(S)).mul(e.amplitude.uniform), C = h(A.sub(q)), m = e.thickness.uniform.mul(0.5), u = e.softness.uniform.mul(0.5), P = y(m.add(u), m.sub(u), C);
-    return d(e.color.uniform.rgb, e.color.uniform.a.mul(P));
-  }
-};
-var B = F;
-export {
-  F as n,
-  B as t
-};

package/dist/core/SolidColor-BZHRczgb.js

@@ -1,22 +0,0 @@
-import { r } from "./transformations-CsrIJXh-.js";
-const t = {
-  name: "SolidColor",
-  category: "Base Layers",
-  description: "Fill the canvas with a single solid color",
-  acceptsUVContext: !0,
-  props: { color: {
-    default: "#5b18ca",
-    transform: r,
-    description: "The solid color to display",
-    ui: {
-      type: "color",
-      label: "Color"
-    }
-  } },
-  fragmentNode: ({ uniforms: o }) => o.color.uniform
-};
-var l = t;
-export {
-  t as n,
-  l as t
-};

package/dist/core/Spherize-DOAnDx2l.js

@@ -1,103 +0,0 @@
-import { O as K } from "./three.tsl-Btj1hLsf.js";
-import { o as z, r as Q } from "./transformations-CsrIJXh-.js";
-const W = {
-  name: "Spherize",
-  category: "Distortions",
-  description: "Map content onto a 3D sphere surface with depth distortion",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    radius: {
-      default: 1,
-      description: "Radius of the sphere (1 = half viewport height)",
-      ui: {
-        type: "range",
-        min: 0.1,
-        max: 3,
-        step: 0.01,
-        label: "Radius"
-      }
-    },
-    depth: {
-      default: 1,
-      description: "How much the sphere bulges toward viewer (0 = flat, higher = more bulge)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 3,
-        step: 0.01,
-        label: "Depth"
-      }
-    },
-    center: {
-      default: {
-        x: 0.5,
-        y: 0.5
-      },
-      transform: z,
-      description: "The center point of the sphere",
-      ui: {
-        type: "position",
-        label: "Center"
-      }
-    },
-    lightPosition: {
-      default: {
-        x: 0.3,
-        y: 0.3
-      },
-      transform: z,
-      description: "Position of the specular light source",
-      ui: {
-        type: "position",
-        label: "Light Position"
-      }
-    },
-    lightIntensity: {
-      default: 0.5,
-      description: "Intensity of the rim light (0 = off)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Light Intensity"
-      }
-    },
-    lightSoftness: {
-      default: 0.5,
-      description: "Softness of the rim light falloff (0 = hard edge, 1 = soft glow)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Light Softness"
-      }
-    },
-    lightColor: {
-      default: "#ffffff",
-      transform: Q,
-      description: "Color of the specular highlight",
-      ui: {
-        type: "color",
-        label: "Light Color"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: e, childNode: p, onCleanup: T }) => {
-    const { vec2: o, vec3: l, vec4: m, float: t, screenUV: I, convertToTexture: L, viewportSize: g, sqrt: q, max: a, smoothstep: R, pow: y, normalize: u, dot: x } = K;
-    if (!p) return m(0, 0, 0, 0);
-    const d = L(p);
-    T(() => {
-      d?.renderTarget?.dispose && d.renderTarget.dispose();
-    });
-    const b = I, v = g.x.div(g.y), s = o(e.center.uniform.x, e.center.uniform.y.oneMinus()), w = e.radius.uniform, i = o(b.x.sub(s.x).mul(v), b.y.sub(s.y)).mul(2).div(w), C = i.x.mul(i.x).add(i.y.mul(i.y)), U = t(1).sub(R(t(0.98), t(1), C)), D = q(a(t(0), t(1).sub(C))), V = t(1).add(D.mul(e.depth.uniform)), P = i.div(V).mul(w).div(2), M = o(P.x.div(v).add(s.x), P.y.add(s.y)), n = d.sample(M), S = o(e.lightPosition.uniform.x, e.lightPosition.uniform.y.oneMinus()), _ = e.lightIntensity.uniform, A = e.lightSoftness.uniform, c = l(e.lightColor.uniform.x, e.lightColor.uniform.y, e.lightColor.uniform.z), h = u(l(i.x, i.y, D)), B = l(0, 0, 1), F = t(1).add(t(4).mul(t(1).sub(A))), G = y(t(1).sub(a(x(h, B), t(0))), F), H = o(S.x.sub(t(0.5)).mul(2), S.y.sub(t(0.5)).mul(2)), N = u(o(h.x, h.y).add(o(1e-4, 1e-4))), O = u(H.add(o(1e-4, 1e-4))), j = y(a(t(0), x(N, O)), t(2)), f = G.mul(j).mul(_).mul(t(2)), k = n.x.add(c.x.mul(f)), E = n.y.add(c.y.mul(f)), J = n.z.add(c.z.mul(f)), r = n.w.mul(U);
-    return m(k.mul(r), E.mul(r), J.mul(r), r);
-  }
-};
-var Z = W;
-export {
-  W as n,
-  Z as t
-};

package/dist/core/Spiral-BMjnWXh1.js

@@ -1,115 +0,0 @@
-import { O as L } from "./three.tsl-Btj1hLsf.js";
-import { i as N, o as j, r as g, t as D } from "./transformations-CsrIJXh-.js";
-import { t as I } from "./colorMixing--dhzx0ch.js";
-const R = {
-  name: "Spiral",
-  category: "Base Layers",
-  description: "Rotating spiral pattern with animated movement",
-  acceptsUVContext: !0,
-  props: {
-    colorA: {
-      default: "#000000",
-      transform: g,
-      description: "Background color",
-      ui: {
-        type: "color",
-        label: "Color A"
-      }
-    },
-    colorB: {
-      default: "#ffffff",
-      transform: g,
-      description: "Spiral stroke color",
-      ui: {
-        type: "color",
-        label: "Color B"
-      }
-    },
-    strokeWidth: {
-      default: 0.5,
-      description: "Thickness of spiral stroke",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 2,
-        step: 0.01,
-        label: "Stroke Width"
-      }
-    },
-    strokeFalloff: {
-      default: 0,
-      description: "Stroke losing width further from center",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Stroke Falloff"
-      }
-    },
-    softness: {
-      default: 0,
-      description: "Color transition sharpness (0 = hard edge, 1 = smooth fade)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Softness"
-      }
-    },
-    speed: {
-      default: 1,
-      description: "Animation speed (negative values reverse direction)",
-      ui: {
-        type: "range",
-        min: -3,
-        max: 3,
-        step: 0.1,
-        label: "Speed"
-      }
-    },
-    center: {
-      default: {
-        x: 0.5,
-        y: 0.5
-      },
-      transform: j,
-      description: "The center point of the spiral",
-      ui: {
-        type: "position",
-        label: "Center"
-      }
-    },
-    scale: {
-      default: 1,
-      description: "Scale factor for spiral bands (higher = more bands, lower = fewer bands)",
-      ui: {
-        type: "range",
-        min: 0.1,
-        max: 5,
-        step: 0.1,
-        label: "Scale"
-      }
-    },
-    colorSpace: {
-      default: "linear",
-      transform: N,
-      description: "Color space for color interpolation",
-      ui: {
-        type: "select",
-        options: D,
-        label: "Color Space"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: e, uvContext: x }) => {
-    const { vec2: s, vec4: S, float: a, atan: y, length: k, clamp: o, fract: C, abs: v, mix: w, smoothstep: t, screenUV: W, time: A, fwidth: n, viewportSize: l } = L, i = x ?? W, c = l.x.div(l.y), B = s(i.x.mul(c), i.y), F = s(e.center.uniform.x.mul(c), e.center.uniform.y.oneMinus()), r = B.sub(F), U = A.mul(e.speed.uniform), p = k(r), V = p, _ = y(r.y, r.x).sub(U), M = a(6.283185307), O = _.div(M), f = V.mul(e.scale.uniform).add(O), d = v(C(f).sub(0.5)).mul(2), P = o(e.strokeWidth.uniform, e.strokeFalloff.uniform.mul(5e-3), 1), T = o(e.strokeFalloff.uniform, 0, 1).mul(p).oneMinus(), m = P.mul(T), u = n(f), h = w(a(4).sub(t(0.05, 0.4, e.strokeWidth.uniform.mul(2)).mul(t(0.05, 0.4, e.strokeWidth.uniform.oneMinus().mul(2))).mul(3)).mul(u), n(d), o(u, 0, 1)), z = t(m.sub(h).sub(e.softness.uniform), m.add(h).add(e.softness.uniform), d), b = I(e.colorA.uniform, e.colorB.uniform, z, e.colorSpace.uniform);
-    return S(b.rgb, b.a);
-  }
-};
-var H = R;
-export {
-  R as n,
-  H as t
-};

package/dist/core/Strands-BOVsuJLe.js

@@ -1,125 +0,0 @@
-import { O as te } from "./three.tsl-Btj1hLsf.js";
-import { t as ne } from "./time-DbRMw6Jm.js";
-import { o as V, r as oe } from "./transformations-CsrIJXh-.js";
-const se = {
-  name: "Strands",
-  category: "Base Layers",
-  description: "Procedural wavy strands with layered animation",
-  requiresRTT: !1,
-  requiresChild: !1,
-  acceptsUVContext: !0,
-  props: {
-    speed: {
-      default: 0.5,
-      description: "Overall animation speed",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Speed"
-      }
-    },
-    amplitude: {
-      default: 1,
-      description: "Wave height amplitude",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 5,
-        step: 0.1,
-        label: "Amplitude"
-      }
-    },
-    frequency: {
-      default: 1,
-      description: "Wave frequency",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 5,
-        step: 0.01,
-        label: "Frequency"
-      }
-    },
-    lineCount: {
-      default: 12,
-      description: "Number of wave lines",
-      ui: {
-        type: "range",
-        min: 4,
-        max: 32,
-        step: 1,
-        label: "Line Count"
-      }
-    },
-    lineWidth: {
-      default: 0.1,
-      description: "Width of wave lines",
-      ui: {
-        type: "range",
-        min: 0.01,
-        max: 0.5,
-        step: 0.01,
-        label: "Line Width"
-      }
-    },
-    waveColor: {
-      default: "#f1c907",
-      transform: oe,
-      description: "Color of the waves",
-      ui: {
-        type: "color",
-        label: "Wave Color"
-      }
-    },
-    pinEdges: {
-      default: !0,
-      description: "Pin waves at edges (fade effect)",
-      ui: {
-        type: "checkbox",
-        label: "Pin Edges"
-      }
-    },
-    start: {
-      default: {
-        x: 0,
-        y: 0.5
-      },
-      transform: V,
-      description: "Starting point of the waves",
-      ui: {
-        type: "position",
-        label: "Start"
-      }
-    },
-    end: {
-      default: {
-        x: 1,
-        y: 0.5
-      },
-      transform: V,
-      description: "Ending point of the waves",
-      ui: {
-        type: "position",
-        label: "End"
-      }
-    }
-  },
-  fragmentNode: (p) => {
-    const { uniforms: e, uvContext: z } = p, { vec2: i, vec4: a, cos: o, abs: M, smoothstep: d, mix: v, max: U, screenUV: A, viewportSize: y, float: t, Fn: g } = te, D = z ?? A, x = ne(p, e.speed), l = g(([n]) => o(n).add(o(n.mul(1.2).add(1.6))).add(o(n.mul(1.4).add(1.5))).div(3));
-    return g(([n]) => {
-      const u = y.x.div(y.y), h = i(e.start.uniform.x.mul(u), e.start.uniform.y.oneMinus()), _ = i(e.end.uniform.x.mul(u), e.end.uniform.y.oneMinus()), I = i(n.x.mul(u), n.y), b = _.sub(h), C = b.length(), m = b.div(C), N = i(m.y.negate(), m.x), w = I.sub(h), s = w.dot(m).div(C), O = w.dot(N), S = s.mul(10), R = O.mul(10), k = e.pinEdges.uniform.select(d(t(0), t(0.1), s).mul(d(t(1), t(0.9), s)), t(1)), c = e.pinEdges.uniform.select(o(s.mul(6.28)).mul(0.5).add(0.5).oneMinus(), t(1)), B = o(s.mul(6.28)).mul(0.5).add(0.5).oneMinus(), f = a(0, 0, 0, 0).toVar(), P = e.lineCount.uniform;
-      for (let r = 0; r < 32; r++) {
-        const j = t(r).lessThan(P), W = t(r), G = W.div(P), H = t(0.5), J = t(1.33), q = x.mul(J), E = W.add(S.mul(H)), F = l(E.add(q)).mul(0.5).add(0.5), L = v(t(0.01), e.lineWidth.uniform, F.mul(c)).mul(0.5), K = t(0.6), Q = t(2), X = l(E.add(q.mul(G.add(1)))).mul(v(K, Q, c)).mul(e.amplitude.uniform), Y = l(S.mul(e.frequency.uniform).add(x)).mul(c).mul(e.amplitude.uniform).add(X), Z = M(R.sub(Y)), T = t(0.01), $ = d(L.add(T), L.sub(T), Z), ee = a(e.waveColor.uniform.r, e.waveColor.uniform.g, e.waveColor.uniform.b, $).mul(F);
-        f.assign(U(f, j.select(ee, a(0, 0, 0, 0))));
-      }
-      return f.mul(a(1, 1, 1, B.mul(k)));
-    })(D);
-  }
-};
-var de = se;
-export {
-  se as n,
-  de as t
-};

package/dist/core/Stretch-D6bHc6yp.js

@@ -1,103 +0,0 @@
-import { O as S, a as U, g as C } from "./three.tsl-Btj1hLsf.js";
-import { t as F } from "./edges-CDzKsauJ.js";
-import { a as R, o as W } from "./transformations-CsrIJXh-.js";
-const _ = {
-  name: "Stretch",
-  category: "Distortions",
-  description: "Stretch content towards a direction from a center point",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    center: {
-      default: {
-        x: 0.5,
-        y: 0.5
-      },
-      transform: W,
-      description: "The center point of the stretch effect",
-      ui: {
-        type: "position",
-        label: "Center"
-      }
-    },
-    strength: {
-      default: 1,
-      description: "The intensity of the stretch effect",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Strength"
-      }
-    },
-    angle: {
-      default: 0,
-      description: "The direction of the stretch in degrees",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 360,
-        step: 1,
-        label: "Angle"
-      }
-    },
-    falloff: {
-      default: 0,
-      description: "Controls the sharpness of the transition (0 = sharp edge, 1 = gradual transition)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Falloff"
-      }
-    },
-    edges: {
-      default: "stretch",
-      description: "How to handle edges when distortion pushes content out of bounds",
-      transform: R,
-      ui: {
-        type: "select",
-        options: [
-          {
-            label: "Stretch",
-            value: "stretch"
-          },
-          {
-            label: "Transparent",
-            value: "transparent"
-          },
-          {
-            label: "Mirror",
-            value: "mirror"
-          },
-          {
-            label: "Wrap",
-            value: "wrap"
-          }
-        ],
-        label: "Edges"
-      }
-    }
-  },
-  uvTransformNode: ({ uv: t, uniforms: n, viewportSize: f }) => {
-    const { vec2: e, float: o, sin: u, cos: p } = S, c = f.x.div(f.y), r = e(t.x.mul(c), t.y), m = e(n.center.uniform.x.mul(c), n.center.uniform.y.oneMinus()), h = r.sub(m), s = n.angle.uniform.mul(Math.PI / 180), a = e(p(s), u(s)), i = h.dot(a), g = h.sub(a.mul(i)), v = n.falloff.uniform, x = C(o(1e-3), o(75), v), l = U(i.div(x), o(0), o(1)), d = n.strength.uniform.mul(o(100)), b = o(1).add(d.mul(l)), T = i.div(b), V = a.mul(T).add(g), y = m.add(V);
-    return e(y.x.div(c), y.y);
-  },
-  fragmentNode: ({ uniforms: t, childNode: n, onCleanup: f }) => {
-    const { vec2: e, vec4: o, screenUV: u, viewportSize: p, convertToTexture: c, float: r, sin: m, cos: h } = S;
-    if (!n) return o(0, 0, 0, 0);
-    const s = c(n);
-    f(() => {
-      s?.renderTarget?.dispose && s.renderTarget.dispose();
-    });
-    const a = p.x.div(p.y), i = e(u.x.mul(a), u.y), g = e(t.center.uniform.x.mul(a), t.center.uniform.y.oneMinus()), v = i.sub(g), x = t.angle.uniform.mul(Math.PI / 180), l = e(h(x), m(x)), d = v.dot(l), b = l.mul(d), T = v.sub(b), V = t.falloff.uniform, y = C(r(1e-3), r(75), V), j = U(d.div(y), r(0), r(1)), w = t.strength.uniform.mul(r(100)), D = r(1).add(w.mul(j)), A = d.div(D), E = l.mul(A).add(T), M = g.add(E), P = e(M.x.div(a), M.y);
-    return F(P, s.sample(P), s, t.edges.uniform);
-  }
-};
-var I = _;
-export {
-  _ as n,
-  I as t
-};