@thi.ng/shader-ast-stdlib 0.16.8 → 0.16.10

package/noise/simplex2.js

@@ -2,50 +2,96 @@ import { F, V2 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { ternary } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { FLOAT05, FLOAT1, VEC3_0, float, vec2, vec3, vec4, } from "@thi.ng/shader-ast/ast/lit";
+import {
+  FLOAT05,
+  FLOAT1,
+  VEC3_0,
+  float,
+  vec2,
+  vec3,
+  vec4
+} from "@thi.ng/shader-ast/ast/lit";
 import { add, gt, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $x, $xy, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
-import { abs, dot, floor, fract, max, mod, } from "@thi.ng/shader-ast/builtin/math";
+import {
+  abs,
+  dot,
+  floor,
+  fract,
+  max,
+  mod
+} from "@thi.ng/shader-ast/builtin/math";
 import { magSq2 } from "../math/magsq.js";
 import { permute3 } from "./permute.js";
-/**
- * Array and textureless GLSL 2D simplex noise function. Ported from original
- * GLSL implementation by Ian McEwan & Ashima Arts.
- *
- * https://github.com/ashima/webgl-noise
- */
-export const snoise2 = defn(F, "snoise2", [V2], (v) => {
-    let C;
-    let i;
-    let i1;
-    let x0;
-    let x12;
-    let p;
-    let m;
-    let x;
-    let h;
-    let ox;
-    let a0;
-    let g;
-    return [
-        (C = sym(vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439))),
-        (i = sym(floor(add(v, dot(v, $(C, "yy")))))),
-        (x0 = sym(add(sub(v, i), dot(i, $(C, "xx"))))),
-        (i1 = sym(ternary(gt($x(x0), $y(x0)), vec2(1, 0), vec2(0, 1)))),
-        (x12 = sym(sub(add($(x0, "xyxy"), $(C, "xxzz")), vec4(i1, 0, 0)))),
-        assign(i, mod(i, float(289))),
-        (p = sym(permute3(add(permute3(add(vec3(0, $y(i1), 1), $y(i))), add(vec3(0, $x(i1), 1), $x(i)))))),
-        (m = sym(max(sub(FLOAT05, vec3(magSq2(x0), magSq2($xy(x12)), magSq2($(x12, "zw")))), VEC3_0))),
-        assign(m, mul(m, m)),
-        assign(m, mul(m, m)),
-        (x = sym(sub(mul(2, fract(mul(p, $(C, "www")))), FLOAT1))),
-        (h = sym(sub(abs(x), FLOAT05))),
-        (ox = sym(floor(add(x, FLOAT05)))),
-        (a0 = sym(sub(x, ox))),
-        assign(m, mul(m, sub(1.79284291400159, mul(0.85373472095314, add(mul(a0, a0), mul(h, h)))))),
-        (g = sym(vec3(add(mul($x(a0), $x(x0)), mul($x(h), $y(x0)))))),
-        assign($(g, "yz"), add(mul($(a0, "yz"), $(x12, "xz")), mul($(h, "yz"), $(x12, "yw")))),
-        ret(mul(130, dot(m, g))),
-    ];
+const snoise2 = defn(F, "snoise2", [V2], (v) => {
+  let C;
+  let i;
+  let i1;
+  let x0;
+  let x12;
+  let p;
+  let m;
+  let x;
+  let h;
+  let ox;
+  let a0;
+  let g;
+  return [
+    C = sym(
+      vec4(
+        0.211324865405187,
+        0.366025403784439,
+        -0.577350269189626,
+        0.024390243902439
+      )
+    ),
+    i = sym(floor(add(v, dot(v, $(C, "yy"))))),
+    x0 = sym(add(sub(v, i), dot(i, $(C, "xx")))),
+    i1 = sym(ternary(gt($x(x0), $y(x0)), vec2(1, 0), vec2(0, 1))),
+    x12 = sym(sub(add($(x0, "xyxy"), $(C, "xxzz")), vec4(i1, 0, 0))),
+    assign(i, mod(i, float(289))),
+    p = sym(
+      permute3(
+        add(
+          permute3(add(vec3(0, $y(i1), 1), $y(i))),
+          add(vec3(0, $x(i1), 1), $x(i))
+        )
+      )
+    ),
+    m = sym(
+      max(
+        sub(
+          FLOAT05,
+          vec3(magSq2(x0), magSq2($xy(x12)), magSq2($(x12, "zw")))
+        ),
+        VEC3_0
+      )
+    ),
+    assign(m, mul(m, m)),
+    assign(m, mul(m, m)),
+    x = sym(sub(mul(2, fract(mul(p, $(C, "www")))), FLOAT1)),
+    h = sym(sub(abs(x), FLOAT05)),
+    ox = sym(floor(add(x, FLOAT05))),
+    a0 = sym(sub(x, ox)),
+    assign(
+      m,
+      mul(
+        m,
+        sub(
+          1.79284291400159,
+          mul(0.85373472095314, add(mul(a0, a0), mul(h, h)))
+        )
+      )
+    ),
+    g = sym(vec3(add(mul($x(a0), $x(x0)), mul($x(h), $y(x0))))),
+    assign(
+      $(g, "yz"),
+      add(mul($(a0, "yz"), $(x12, "xz")), mul($(h, "yz"), $(x12, "yw")))
+    ),
+    ret(mul(130, dot(m, g)))
+  ];
 });
+export {
+  snoise2
+};

package/noise/simplex3.js

@@ -1,85 +1,178 @@
 import { F, V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { FLOAT0, FLOAT05, FLOAT1, FLOAT2, float, vec2, vec3, vec4, } from "@thi.ng/shader-ast/ast/lit";
+import {
+  FLOAT0,
+  FLOAT05,
+  FLOAT1,
+  FLOAT2,
+  float,
+  vec2,
+  vec3,
+  vec4
+} from "@thi.ng/shader-ast/ast/lit";
 import { add, mul, neg, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $w, $x, $xy, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
-import { abs, dot, floor, max, min, mod, step, } from "@thi.ng/shader-ast/builtin/math";
+import {
+  abs,
+  dot,
+  floor,
+  max,
+  min,
+  mod,
+  step
+} from "@thi.ng/shader-ast/builtin/math";
 import { permute4 } from "./permute.js";
-export const snoise3 = defn(F, "snoise3", [V3], (v) => {
-    let g;
-    let j;
-    let l;
-    let m;
-    let p;
-    let norm;
-    let _x;
-    let x;
-    let y;
-    let h;
-    let sh;
-    let a0;
-    let a1;
-    let b0;
-    let b1;
-    let x0;
-    let x1;
-    let x2;
-    let x3;
-    let p0;
-    let p1;
-    let p2;
-    let p3;
-    let i;
-    let i1;
-    let i2;
-    const NS = 1 / 7;
-    const NSX = NS * 2;
-    const NSY = NS * 0.5 - 1;
-    return [
-        (i = sym(floor(add(v, dot(v, vec3(1 / 3)))))),
-        (x0 = sym(add(sub(v, i), dot(i, vec3(1 / 6))))),
-        (g = sym(step($(x0, "yzx"), x0))),
-        (l = sym($(sub(FLOAT1, g), "zxy"))),
-        (i1 = sym(min(g, l))),
-        (i2 = sym(max(g, l))),
-        (x1 = sym(add(sub(x0, i1), 1 / 6))),
-        (x2 = sym(add(sub(x0, i2), 1 / 3))),
-        (x3 = sym(sub(x0, FLOAT05))),
-        assign(i, mod(i, float(289))),
-        (p = sym(permute4(add(permute4(add(permute4(add(vec4(FLOAT0, $z(i1), $z(i2), FLOAT1), $z(i))), add(vec4(FLOAT0, $y(i1), $y(i2), FLOAT1), $y(i)))), add(vec4(FLOAT0, $x(i1), $x(i2), FLOAT1), $x(i)))))),
-        (j = sym(sub(p, mul(floor(mul(p, NS * NS)), 49)))),
-        (_x = sym(floor(mul(j, NS)))),
-        (x = sym(add(mul(_x, NSX), NSY))),
-        (y = sym(add(mul(floor(sub(j, mul(_x, 7))), NSX), NSY))),
-        (h = sym(sub(sub(FLOAT1, abs(x)), abs(y)))),
-        (sh = sym(neg(step(h, vec4())))),
-        (b0 = sym(vec4($xy(x), $xy(y)))),
-        (b1 = sym(vec4($(x, "zw"), $(y, "zw")))),
-        (a0 = sym(add($(b0, "xzyw"), mul($(add(mul(floor(b0), FLOAT2), FLOAT1), "xzyw"), $(sh, "xxyy"))))),
-        (a1 = sym(add($(b1, "xzyw"), mul($(add(mul(floor(b1), FLOAT2), FLOAT1), "xzyw"), $(sh, "zzww"))))),
-        (p0 = sym(vec3($xy(a0), $x(h)))),
-        (p1 = sym(vec3($(a0, "zw"), $y(h)))),
-        (p2 = sym(vec3($xy(a1), $z(h)))),
-        (p3 = sym(vec3($(a1, "zw"), $w(h)))),
-        (norm = sym(sub(1.79284291400159, mul(vec4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)), 0.85373472095314)))),
-        assign(p0, mul(p0, $x(norm))),
-        assign(p1, mul(p1, $y(norm))),
-        assign(p2, mul(p2, $z(norm))),
-        assign(p3, mul(p3, $w(norm))),
-        (m = sym(max(vec4(), sub(0.6, vec4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)))))),
-        assign(m, mul(m, m)),
-        ret(mul(42, dot(mul(m, m), vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3))))),
-    ];
+const snoise3 = defn(F, "snoise3", [V3], (v) => {
+  let g;
+  let j;
+  let l;
+  let m;
+  let p;
+  let norm;
+  let _x;
+  let x;
+  let y;
+  let h;
+  let sh;
+  let a0;
+  let a1;
+  let b0;
+  let b1;
+  let x0;
+  let x1;
+  let x2;
+  let x3;
+  let p0;
+  let p1;
+  let p2;
+  let p3;
+  let i;
+  let i1;
+  let i2;
+  const NS = 1 / 7;
+  const NSX = NS * 2;
+  const NSY = NS * 0.5 - 1;
+  return [
+    i = sym(floor(add(v, dot(v, vec3(1 / 3))))),
+    x0 = sym(add(sub(v, i), dot(i, vec3(1 / 6)))),
+    g = sym(step($(x0, "yzx"), x0)),
+    l = sym($(sub(FLOAT1, g), "zxy")),
+    i1 = sym(min(g, l)),
+    i2 = sym(max(g, l)),
+    x1 = sym(add(sub(x0, i1), 1 / 6)),
+    x2 = sym(add(sub(x0, i2), 1 / 3)),
+    x3 = sym(sub(x0, FLOAT05)),
+    assign(i, mod(i, float(289))),
+    p = sym(
+      permute4(
+        add(
+          permute4(
+            add(
+              permute4(
+                add(vec4(FLOAT0, $z(i1), $z(i2), FLOAT1), $z(i))
+              ),
+              add(vec4(FLOAT0, $y(i1), $y(i2), FLOAT1), $y(i))
+            )
+          ),
+          add(vec4(FLOAT0, $x(i1), $x(i2), FLOAT1), $x(i))
+        )
+      )
+    ),
+    j = sym(sub(p, mul(floor(mul(p, NS * NS)), 49))),
+    _x = sym(floor(mul(j, NS))),
+    x = sym(add(mul(_x, NSX), NSY)),
+    y = sym(add(mul(floor(sub(j, mul(_x, 7))), NSX), NSY)),
+    h = sym(sub(sub(FLOAT1, abs(x)), abs(y))),
+    sh = sym(neg(step(h, vec4()))),
+    b0 = sym(vec4($xy(x), $xy(y))),
+    b1 = sym(vec4($(x, "zw"), $(y, "zw"))),
+    a0 = sym(
+      add(
+        $(b0, "xzyw"),
+        mul(
+          $(add(mul(floor(b0), FLOAT2), FLOAT1), "xzyw"),
+          $(sh, "xxyy")
+        )
+      )
+    ),
+    a1 = sym(
+      add(
+        $(b1, "xzyw"),
+        mul(
+          $(add(mul(floor(b1), FLOAT2), FLOAT1), "xzyw"),
+          $(sh, "zzww")
+        )
+      )
+    ),
+    p0 = sym(vec3($xy(a0), $x(h))),
+    p1 = sym(vec3($(a0, "zw"), $y(h))),
+    p2 = sym(vec3($xy(a1), $z(h))),
+    p3 = sym(vec3($(a1, "zw"), $w(h))),
+    norm = sym(
+      sub(
+        1.79284291400159,
+        mul(
+          vec4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)),
+          0.85373472095314
+        )
+      )
+    ),
+    assign(p0, mul(p0, $x(norm))),
+    assign(p1, mul(p1, $y(norm))),
+    assign(p2, mul(p2, $z(norm))),
+    assign(p3, mul(p3, $w(norm))),
+    m = sym(
+      max(
+        vec4(),
+        sub(
+          0.6,
+          vec4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3))
+        )
+      )
+    ),
+    assign(m, mul(m, m)),
+    ret(
+      mul(
+        42,
+        dot(
+          mul(m, m),
+          vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3))
+        )
+      )
+    )
+  ];
 });
-export const snoiseVec32 = defn(V2, "snoiseVec32", [V3], (p) => {
-    return [
-        ret(vec2(snoise3(p), snoise3(vec3(sub($y(p), 19.1), add($z(p), 33.4), add($x(p), 47.2))))),
-    ];
+const snoiseVec32 = defn(V2, "snoiseVec32", [V3], (p) => {
+  return [
+    ret(
+      vec2(
+        snoise3(p),
+        snoise3(
+          vec3(sub($y(p), 19.1), add($z(p), 33.4), add($x(p), 47.2))
+        )
+      )
+    )
+  ];
 });
-export const snoiseVec3 = defn(V3, "snoiseVec3", [V3], (p) => {
-    return [
-        ret(vec3(snoise3(p), snoise3(vec3(sub($y(p), 19.1), add($z(p), 33.4), add($x(p), 47.2))), snoise3(vec3(add($z(p), 74.2), sub($x(p), 124.5), add($y(p), 99.4))))),
-    ];
+const snoiseVec3 = defn(V3, "snoiseVec3", [V3], (p) => {
+  return [
+    ret(
+      vec3(
+        snoise3(p),
+        snoise3(
+          vec3(sub($y(p), 19.1), add($z(p), 33.4), add($x(p), 47.2))
+        ),
+        snoise3(
+          vec3(add($z(p), 74.2), sub($x(p), 124.5), add($y(p), 99.4))
+        )
+      )
+    )
+  ];
 });
+export {
+  snoise3,
+  snoiseVec3,
+  snoiseVec32
+};

package/noise/voronoi2.js

@@ -2,58 +2,75 @@ import { F, V2 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { forLoop } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { FLOAT0, SQRT2, float, int, vec2, vec3, } from "@thi.ng/shader-ast/ast/lit";
+import {
+  FLOAT0,
+  SQRT2,
+  float,
+  int,
+  vec2,
+  vec3
+} from "@thi.ng/shader-ast/ast/lit";
 import { add, div, inc, lte, madd, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $xy, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
-import { dot, floor, fract, pow, smoothstep, sqrt, } from "@thi.ng/shader-ast/builtin/math";
+import {
+  dot,
+  floor,
+  fract,
+  pow,
+  smoothstep,
+  sqrt
+} from "@thi.ng/shader-ast/builtin/math";
 import { hash32 } from "./hash.js";
-/**
- * IQ's parametric 2D voronoise. Depending on `u` and `v`, this function
- * produces 4 different noise types
- *
- * - cell noise (0,0)
- * - voronoi (1,0)
- * - perlin noise (0,1)
- * - voronoise (1,1)
- *
- * http://www.iquilezles.org/www/articles/voronoise/voronoise.htm
- *
- * Note: This implementation uses the improved {@link hash32} by Dave Hoskins
- * instead of iq's original {@link hash3}.
- *
- * @param p -
- * @param u -
- * @param v -
- */
-export const voronoise2 = defn(F, "voronoise2", [V2, F, F], (x, u, v) => {
-    let p;
-    let f;
-    let coeff;
-    let k;
-    let va;
-    let wt;
-    let g;
-    let o;
-    let r;
-    let w;
-    return [
-        (p = sym(floor(x))),
-        (f = sym(fract(x))),
-        (coeff = sym(vec3(u, u, 1))),
-        (k = sym(add(1, mul(63, pow(sub(1, v), float(4)))))),
-        (va = sym(FLOAT0)),
-        (wt = sym(FLOAT0)),
-        forLoop(sym(int(-2)), (i) => lte(i, int(2)), inc, (i) => [
-            forLoop(sym(int(-2)), (j) => lte(j, int(2)), inc, (j) => [
-                (g = sym(vec2(float(i), float(j)))),
-                (o = sym(mul(hash32(add(p, g)), coeff))),
-                (r = sym(add(sub(g, f), $xy(o)))),
-                (w = sym(pow(sub(1, smoothstep(FLOAT0, SQRT2, sqrt(dot(r, r)))), k))),
-                assign(va, madd(w, $z(o), va)),
-                assign(wt, add(wt, w)),
-            ]),
-        ]),
-        ret(div(va, wt)),
-    ];
+const voronoise2 = defn(F, "voronoise2", [V2, F, F], (x, u, v) => {
+  let p;
+  let f;
+  let coeff;
+  let k;
+  let va;
+  let wt;
+  let g;
+  let o;
+  let r;
+  let w;
+  return [
+    p = sym(floor(x)),
+    f = sym(fract(x)),
+    coeff = sym(vec3(u, u, 1)),
+    k = sym(add(1, mul(63, pow(sub(1, v), float(4))))),
+    va = sym(FLOAT0),
+    wt = sym(FLOAT0),
+    forLoop(
+      sym(int(-2)),
+      (i) => lte(i, int(2)),
+      inc,
+      (i) => [
+        forLoop(
+          sym(int(-2)),
+          (j) => lte(j, int(2)),
+          inc,
+          (j) => [
+            g = sym(vec2(float(i), float(j))),
+            o = sym(mul(hash32(add(p, g)), coeff)),
+            r = sym(add(sub(g, f), $xy(o))),
+            w = sym(
+              pow(
+                sub(
+                  1,
+                  smoothstep(FLOAT0, SQRT2, sqrt(dot(r, r)))
+                ),
+                k
+              )
+            ),
+            assign(va, madd(w, $z(o), va)),
+            assign(wt, add(wt, w))
+          ]
+        )
+      ]
+    ),
+    ret(div(va, wt))
+  ];
 });
+export {
+  voronoise2
+};

package/noise/worley2.js

@@ -7,64 +7,76 @@ import { float, vec3 } from "@thi.ng/shader-ast/ast/lit";
 import { add, lt, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $x, $xy, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
-import { abs, floor, fract, max, min, mod, sqrt, } from "@thi.ng/shader-ast/builtin/math";
+import {
+  abs,
+  floor,
+  fract,
+  max,
+  min,
+  mod,
+  sqrt
+} from "@thi.ng/shader-ast/builtin/math";
 import { permute3 } from "./permute.js";
-export const worleyDist = defn(V3, "worleyDist", [V3, V3], (a, b) => [
-    ret(add(mul(a, a), mul(b, b))),
+const worleyDist = defn(V3, "worleyDist", [V3, V3], (a, b) => [
+  ret(add(mul(a, a), mul(b, b)))
 ]);
-export const worleyDistManhattan = defn(V3, "worleyDistManhatten", [V3, V3], (a, b) => [ret(add(abs(a), abs(b)))]);
-/**
- * Higher order function. Computes 2D Worley noise using provided distance
- * function. The returned function takes 2 args: position and jitter amount, the
- * latter in [0..1] interval. Returns noise components as vec2, with the x
- * component containing the distance from closest simplex center and y the noise
- * value. The vector components can be used individually or combined (e.g.
- * `noise.y - noise.x`)...
- *
- * THe optional `name` arg can be used to customize the name of the generated
- * function.
- *
- * @remarks
- * Based on implementation by Stefan Gustavson:
- * http://webstaff.itn.liu.se/~stegu/GLSL-cellular/GLSL-cellular-notes.pdf
- *
- * @param distFn -
- * @param name -
- */
-export const worley2 = (distFn, name = gensym("worley2_")) => defn(V2, name, [V2, F], (P, jitter) => {
-    const K = float(1 / 7);
-    const Ko = float(3 / 7);
-    const oI = sym(vec3(-1, 0, 1));
-    const oF = sym(vec3(-0.5, 0.5, 1.5));
-    let pI;
-    let pF;
-    let px;
-    let p;
-    let d1;
-    let d2;
-    let d3;
-    let d1a;
-    const $dist = (x) => distFn(add(add($x(pF), x), mul(sub(fract(mul(p, K)), Ko), jitter)), add(sub($y(pF), oF), mul(sub(mul(mod(floor(mul(p, K)), float(7)), K), Ko), jitter)));
-    return [
-        oI,
-        oF,
-        (pI = sym(mod(floor(P), float(289)))),
-        (pF = sym(fract(P))),
-        (px = sym(permute3(add(oI, $x(pI))))),
-        (p = sym(permute3(add(add(oI, $y(pI)), $x(px))))),
-        (d1 = sym($dist(0.5))),
-        assign(p, permute3(add(oI, add($y(pI), $y(px))))),
-        (d2 = sym($dist(-0.5))),
-        assign(p, permute3(add(oI, add($y(pI), $z(px))))),
-        (d3 = sym($dist(-1.5))),
-        (d1a = sym(min(d1, d2))),
-        assign(d2, min(max(d1, d2), d3)),
-        assign(d1, min(d1a, d2)),
-        assign(d2, max(d1a, d2)),
-        assign($xy(d1), ternary(lt($x(d1), $y(d1)), $xy(d1), $(d1, "yx"))),
-        assign($(d1, "xz"), ternary(lt($x(d1), $z(d1)), $(d1, "xz"), $(d1, "zx"))),
-        assign($(d1, "yz"), min($(d1, "yz"), $(d2, "yz"))),
-        assign($y(d1), min(min($y(d1), $z(d1)), $x(d2))),
-        ret(sqrt($xy(d1))),
-    ];
+const worleyDistManhattan = defn(
+  V3,
+  "worleyDistManhatten",
+  [V3, V3],
+  (a, b) => [ret(add(abs(a), abs(b)))]
+);
+const worley2 = (distFn, name = gensym("worley2_")) => defn(V2, name, [V2, F], (P, jitter) => {
+  const K = float(1 / 7);
+  const Ko = float(3 / 7);
+  const oI = sym(vec3(-1, 0, 1));
+  const oF = sym(vec3(-0.5, 0.5, 1.5));
+  let pI;
+  let pF;
+  let px;
+  let p;
+  let d1;
+  let d2;
+  let d3;
+  let d1a;
+  const $dist = (x) => distFn(
+    add(add($x(pF), x), mul(sub(fract(mul(p, K)), Ko), jitter)),
+    add(
+      sub($y(pF), oF),
+      mul(
+        sub(mul(mod(floor(mul(p, K)), float(7)), K), Ko),
+        jitter
+      )
+    )
+  );
+  return [
+    oI,
+    oF,
+    pI = sym(mod(floor(P), float(289))),
+    pF = sym(fract(P)),
+    px = sym(permute3(add(oI, $x(pI)))),
+    p = sym(permute3(add(add(oI, $y(pI)), $x(px)))),
+    d1 = sym($dist(0.5)),
+    assign(p, permute3(add(oI, add($y(pI), $y(px))))),
+    d2 = sym($dist(-0.5)),
+    assign(p, permute3(add(oI, add($y(pI), $z(px))))),
+    d3 = sym($dist(-1.5)),
+    d1a = sym(min(d1, d2)),
+    assign(d2, min(max(d1, d2), d3)),
+    assign(d1, min(d1a, d2)),
+    assign(d2, max(d1a, d2)),
+    assign($xy(d1), ternary(lt($x(d1), $y(d1)), $xy(d1), $(d1, "yx"))),
+    assign(
+      $(d1, "xz"),
+      ternary(lt($x(d1), $z(d1)), $(d1, "xz"), $(d1, "zx"))
+    ),
+    assign($(d1, "yz"), min($(d1, "yz"), $(d2, "yz"))),
+    assign($y(d1), min(min($y(d1), $z(d1)), $x(d2))),
+    ret(sqrt($xy(d1)))
+  ];
 });
+export {
+  worley2,
+  worleyDist,
+  worleyDistManhattan
+};