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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/shader-ast-stdlib",
-  "version": "0.16.9",
+  "version": "0.16.10",
   "description": "Function collection for modular GPGPU / shader programming with @thi.ng/shader-ast",
   "type": "module",
   "module": "./index.js",
@@ -27,7 +27,9 @@
   ],
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc color fog light math matrix noise raymarch screen sdf tex",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -36,11 +38,12 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/shader-ast": "^0.12.84"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/shader-ast": "^0.12.85"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -352,5 +355,5 @@
     ],
     "year": 2019
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/raymarch/ao.js

@@ -8,28 +8,29 @@ import { add, inc, lte, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $x } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { clamp01 } from "../math/clamp.js";
-/**
- * Higher order function returning an function to compute the Ambient
- * Occlusion term / shadow factor for given SDF scene function. The
- * returned function takes 2 arguments: surface pos and normal. It
- * returns a float in [0..1] interval (zero = fully occluded).
- *
- * @param scene -
- * @param numSamples -
- * @param name -
- */
-export const raymarchAO = (scene, numSamples = 5, name = gensym("raymarchAO_")) => defn(F, name, [V3, V3], (p, n) => {
-    let r;
-    let w;
-    let d0;
-    return [
-        (r = sym(FLOAT0)),
-        (w = sym(FLOAT1)),
-        forLoop(sym(float(1)), (i) => lte(i, float(numSamples)), inc, (i) => [
-            (d0 = sym(mul(i, 1 / numSamples))),
-            assign(r, add(r, mul(w, sub(d0, $x(scene(add(p, mul(n, d0)))))))),
-            assign(w, mul(w, FLOAT05)),
-        ]),
-        ret(sub(FLOAT1, clamp01(r))),
-    ];
+const raymarchAO = (scene, numSamples = 5, name = gensym("raymarchAO_")) => defn(F, name, [V3, V3], (p, n) => {
+  let r;
+  let w;
+  let d0;
+  return [
+    r = sym(FLOAT0),
+    w = sym(FLOAT1),
+    forLoop(
+      sym(float(1)),
+      (i) => lte(i, float(numSamples)),
+      inc,
+      (i) => [
+        d0 = sym(mul(i, 1 / numSamples)),
+        assign(
+          r,
+          add(r, mul(w, sub(d0, $x(scene(add(p, mul(n, d0)))))))
+        ),
+        assign(w, mul(w, FLOAT05))
+      ]
+    ),
+    ret(sub(FLOAT1, clamp01(r)))
+  ];
 });
+export {
+  raymarchAO
+};

package/raymarch/direction.js

@@ -5,15 +5,22 @@ import { div, neg, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { normalize, radians, tan } from "@thi.ng/shader-ast/builtin/math";
-/**
- * @param fragCoord - vec2
- * @param res - vec2
- * @param fov - float vertical FOV (in degrees)
- */
-export const raymarchDir = defn(V3, "raymarchDir", [V2, V2, F], (frag, res, fov) => {
+const raymarchDir = defn(
+  V3,
+  "raymarchDir",
+  [V2, V2, F],
+  (frag, res, fov) => {
     let uv;
     return [
-        (uv = sym(sub(frag, div(res, FLOAT2)))),
-        ret(normalize(vec3(uv, neg(div($y(res), tan(div(radians(fov), FLOAT2))))))),
+      uv = sym(sub(frag, div(res, FLOAT2))),
+      ret(
+        normalize(
+          vec3(uv, neg(div($y(res), tan(div(radians(fov), FLOAT2)))))
+        )
+      )
     ];
-});
+  }
+);
+export {
+  raymarchDir
+};

package/raymarch/normal.js

@@ -6,20 +6,14 @@ import { add, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $x } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { normalize } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Higher order function producing a function to compute the raymarched
- * scene normal for a given scene function and intersection position.
- * Like {@link raymarchScene}, this function takes an existing scene
- * function as argument.
- *
- * @param scene -
- * @param name -
- */
-export const raymarchNormal = (scene, name = gensym("raymarchNormal_")) => defn(V3, name, [V3, F], (p, smooth) => {
-    let dn;
-    const comp = (id) => sub($x(scene(add(p, $(dn, id)))), $x(scene(sub(p, $(dn, id)))));
-    return [
-        (dn = sym(vec2(smooth, 0))),
-        ret(normalize(vec3(comp("xyy"), comp("yxy"), comp("yyx")))),
-    ];
+const raymarchNormal = (scene, name = gensym("raymarchNormal_")) => defn(V3, name, [V3, F], (p, smooth) => {
+  let dn;
+  const comp = (id) => sub($x(scene(add(p, $(dn, id)))), $x(scene(sub(p, $(dn, id)))));
+  return [
+    dn = sym(vec2(smooth, 0)),
+    ret(normalize(vec3(comp("xyy"), comp("yxy"), comp("yyx"))))
+  ];
 });
+export {
+  raymarchNormal
+};

package/raymarch/point-at.js

@@ -1,13 +1,6 @@
 import { add, mul } from "@thi.ng/shader-ast/ast/ops";
 import { normalize } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Inline function. Returns point on ray (`p`, `dir`) at distance `t`.
- * Unless `norm` is true (default false), `dir` must be already
- * normalized.
- *
- * @param p -
- * @param dir -
- * @param t -
- * @param normalize -
- */
-export const rayPointAt = (p, dir, t, norm = false) => add(p, mul(norm ? normalize(dir) : dir, t));
+const rayPointAt = (p, dir, t, norm = false) => add(p, mul(norm ? normalize(dir) : dir, t));
+export {
+  rayPointAt
+};

package/raymarch/scene.js

@@ -8,48 +8,39 @@ import { gt, inc, lt, madd } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { rayPointAt } from "./point-at.js";
-/**
- * Higher order function producing a function to perform a raymarch
- * using the provided `scene` function and options to configure the
- * raymarch process itself.
- *
- * Returns an AST function which takes 2 args: ray origin, normalized
- * ray direction and returning a 2D vector of:
- *
- * - x = the signed distance to the `scene` defined SDF surface
- * - y = user data provided by `scene` (e.g. material ID)
- *
- * The `scene` function itself takes a 3D point as input and returns a
- * vec2 with the same component meaning as above.
- *
- * @param scene -
- * @param _opts -
- */
-export const raymarchScene = (scene, _opts) => {
-    const opts = {
-        name: gensym("raymarchScene_"),
-        near: 0.1,
-        far: 10,
-        steps: 100,
-        eps: 0.01,
-        bias: 0.7,
-        ..._opts,
-    };
-    return defn(V2, opts.name, [V3, V3], (pos, dir) => {
-        let total;
-        let res;
-        return [
-            (total = sym(float(opts.near))),
-            (res = sym(V2)),
-            forLoop(sym(INT0), (i) => lt(i, int(opts.steps)), inc, () => [
-                assign(res, scene(rayPointAt(pos, dir, total))),
-                ifThen(lt($x(res), float(opts.eps)), [
-                    ret(vec2(total, $y(res))),
-                ]),
-                assign(total, madd($x(res), float(opts.bias), total)),
-                ifThen(gt(total, float(opts.far)), [brk]),
-            ]),
-            ret(vec2(opts.far, 0)),
-        ];
-    });
+const raymarchScene = (scene, _opts) => {
+  const opts = {
+    name: gensym("raymarchScene_"),
+    near: 0.1,
+    far: 10,
+    steps: 100,
+    eps: 0.01,
+    bias: 0.7,
+    ..._opts
+  };
+  return defn(V2, opts.name, [V3, V3], (pos, dir) => {
+    let total;
+    let res;
+    return [
+      total = sym(float(opts.near)),
+      res = sym(V2),
+      forLoop(
+        sym(INT0),
+        (i) => lt(i, int(opts.steps)),
+        inc,
+        () => [
+          assign(res, scene(rayPointAt(pos, dir, total))),
+          ifThen(lt($x(res), float(opts.eps)), [
+            ret(vec2(total, $y(res)))
+          ]),
+          assign(total, madd($x(res), float(opts.bias), total)),
+          ifThen(gt(total, float(opts.far)), [brk])
+        ]
+      ),
+      ret(vec2(opts.far, 0))
+    ];
+  });
+};
+export {
+  raymarchScene
 };

package/screen/uv.js

@@ -4,34 +4,27 @@ import { VEC2_1, bvec4, vec2 } from "@thi.ng/shader-ast/ast/lit";
 import { add, div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $xy, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { _any, greaterThan, lessThan } from "@thi.ng/shader-ast/builtin/bvec";
-/**
- * Computes UV coord in [0..1] interval from given `fragCoord` and screen `res`.
- *
- * @param fragCoord -
- * @param res -
- */
-export const fragUV = (fragCoord, res) => div($xy(fragCoord), res);
-/**
- * Takes `pos`, a screen coord (e.g. gl_FragCoord) and viewport resolution
- * `res`, returns aspect corrected uv, with uv.y in [-1..1] interval and uv.x
- * scaled by the aspect ratio `resx / resy`.
- *
- * @param fragCoord - vec2
- * @param resolution - vec2
- */
-export const aspectCorrectedUV = defn(V2, "aspectCorrectedUV2", [V2, V2], (fragCoord, resolution) => [
-    ret(div(sub(mul(2, fragCoord), resolution), $y(resolution))),
-]);
-/**
- * Returns true if at least one coordinate of the given point is within the
- * `width` internal border region of UV rect ([0,0] .. [1,1]).
- *
- * ```c
- * borderMask(vec2(0.91, 0.5), 0.1) // true
- * borderMask(vec2(0.2, 0.01), 0.1) // true
- * borderMask(vec2(0.2, 0.2), 0.1) // false
- * ```
- */
-export const borderMask = defn("bool", "borderMask", [V2, F], (uv, width) => [
-    ret(_any(bvec4(lessThan(uv, vec2(width)), greaterThan(add(uv, width), VEC2_1)))),
+const fragUV = (fragCoord, res) => div($xy(fragCoord), res);
+const aspectCorrectedUV = defn(
+  V2,
+  "aspectCorrectedUV2",
+  [V2, V2],
+  (fragCoord, resolution) => [
+    ret(div(sub(mul(2, fragCoord), resolution), $y(resolution)))
+  ]
+);
+const borderMask = defn("bool", "borderMask", [V2, F], (uv, width) => [
+  ret(
+    _any(
+      bvec4(
+        lessThan(uv, vec2(width)),
+        greaterThan(add(uv, width), VEC2_1)
+      )
+    )
+  )
 ]);
+export {
+  aspectCorrectedUV,
+  borderMask,
+  fragUV
+};

package/sdf/annular.js

@@ -1,9 +1,6 @@
 import { sub } from "@thi.ng/shader-ast/ast/ops";
 import { abs } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Inline function. Bi-directional offset to create ring like shapes.
- *
- * @param d -
- * @param r -
- */
-export const sdfAnnular = (d, r) => sub(abs(d), r);
+const sdfAnnular = (d, r) => sub(abs(d), r);
+export {
+  sdfAnnular
+};

package/sdf/arc.js

@@ -6,23 +6,24 @@ import { gt, madd, mul, neg, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { abs, cos, length, sin } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Returns signed distance from `p` to 2D circular arc with `aperture` (in
- * [0..π] interval), radius `ra` and `thickness`.
- *
- * @remarks
- * Slightly modified version (easier to use aperture control) of original GLSL
- * impl by Inigo Quilez:
- *
- * - https://www.shadertoy.com/view/wl23RK
- * - https://iquilezles.org/articles/distfunctions2d/
- */
-export const sdfArc2 = defn(F, "sdfArc", [V2, F, F, F], (p, apert, ra, rb) => {
-    let q;
-    let sc;
-    return [
-        (q = sym(vec2(abs($x(p)), $y(p)))),
-        (sc = sym(vec2(sin(apert), cos(apert)))),
-        ret(sub(ternary(gt(mul($y(sc), $x(q)), mul($x(sc), $y(q))), length(madd(sc, neg(ra), q)), abs(sub(length(q), ra))), rb)),
-    ];
+const sdfArc2 = defn(F, "sdfArc", [V2, F, F, F], (p, apert, ra, rb) => {
+  let q;
+  let sc;
+  return [
+    q = sym(vec2(abs($x(p)), $y(p))),
+    sc = sym(vec2(sin(apert), cos(apert))),
+    ret(
+      sub(
+        ternary(
+          gt(mul($y(sc), $x(q)), mul($x(sc), $y(q))),
+          length(madd(sc, neg(ra), q)),
+          abs(sub(length(q), ra))
+        ),
+        rb
+      )
+    )
+  ];
 });
+export {
+  sdfArc2
+};

package/sdf/bezier.js

@@ -2,24 +2,42 @@ import { F, V2 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { ifThen } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { FLOAT0, FLOAT1, FLOAT2, float, vec2, } from "@thi.ng/shader-ast/ast/lit";
-import { add, div, gte, lt, madd, mul, neg, sub, } from "@thi.ng/shader-ast/ast/ops";
+import {
+  FLOAT0,
+  FLOAT1,
+  FLOAT2,
+  float,
+  vec2
+} from "@thi.ng/shader-ast/ast/lit";
+import {
+  add,
+  div,
+  gte,
+  lt,
+  madd,
+  mul,
+  neg,
+  sub
+} from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
-import { abs, acos, cos, dot, powf, sign, sin, sqrt, } from "@thi.ng/shader-ast/builtin/math";
+import {
+  abs,
+  acos,
+  cos,
+  dot,
+  powf,
+  sign,
+  sin,
+  sqrt
+} from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
 import { cross2 } from "../math/cross2.js";
-/**
- * Returns signed distance from `p` to 2D quadratic bezier (given by points A,
- * B, C).
- *
- * @remarks
- * Ported from original GLSL impl by Inigo Quilez:
- *
- * - https://www.shadertoy.com/view/MlKcDD
- * - https://iquilezles.org/articles/distfunctions2d/
- */
-export const sdfQuadratic2 = defn(F, "sdfQuadratic2", [V2, V2, V2, V2], (pos, A, B, C) => {
+const sdfQuadratic2 = defn(
+  F,
+  "sdfQuadratic2",
+  [V2, V2, V2, V2],
+  (pos, A, B, C) => {
     let a, b, c, d;
     let kk, kx, ky, kz;
     let p, q, p3, q2, h;
@@ -27,47 +45,65 @@ export const sdfQuadratic2 = defn(F, "sdfQuadratic2", [V2, V2, V2, V2], (pos, A,
     let res, sgn;
     let x, y, uv;
     return [
-        (a = sym(sub(B, A))),
-        (b = sym(add(madd(B, -2, A), C))),
-        (c = sym(mul(a, 2))),
-        (d = sym(sub(A, pos))),
-        (kk = sym(div(FLOAT1, dot(b, b)))),
-        (kx = sym(mul(kk, dot(a, b)))),
-        (ky = sym(mul(kk, div(madd(FLOAT2, dot(a, a), dot(d, b)), 3)))),
-        (kz = sym(mul(kk, dot(d, a)))),
-        (res = sym(FLOAT0)),
-        (sgn = sym(FLOAT0)),
-        (p = sym(sub(ky, mul(kx, kx)))),
-        (q = sym(madd(sub(mul(mul(FLOAT2, kx), kx), mul(3, ky)), kx, kz))),
-        (p3 = sym(mul(mul(p, p), p))),
-        (q2 = sym(mul(q, q))),
-        (h = sym(madd(p3, 4, q2))),
-        ifThen(gte(h, FLOAT0), [
-            assign(h, sqrt(h)),
-            (x = sym(div(sub(vec2(h, neg(h)), q), FLOAT2))),
-            (uv = sym(mul(sign(x), powf(abs(x), float(1 / 3))))),
-            (t = sym(clamp01(sub(add($x(uv), $y(uv)), kx)))),
-            assign(x, madd(madd(b, t, c), t, d)),
-            assign(res, dot(x, x)),
-            assign(sgn, cross2(madd(b, mul(t, FLOAT2), c), x)),
-        ], [
-            (z = sym(sqrt(neg(p)))),
-            (v = sym(div(acos(div(q, mul(mul(p, z), FLOAT2))), float(3)))),
-            (m = sym(cos(v))),
-            (n = sym(mul(sin(v), 1.732050808))),
-            (uv = sym(clamp01(sub(mul(vec2(add(m, m), sub(neg(n), m)), z), kx)))),
-            (x = sym(madd(madd(b, $x(uv), c), $x(uv), d))),
-            (y = sym(madd(madd(b, $y(uv), c), $y(uv), d))),
-            assign(m, dot(x, x)),
-            assign(n, dot(y, y)),
-            ifThen(lt(m, n), [
-                assign(res, m),
-                assign(sgn, cross2(madd(b, mul($x(uv), 2), c), x)),
-            ], [
-                assign(res, n),
-                assign(sgn, cross2(madd(b, mul($y(uv), 2), c), y)),
-            ]),
-        ]),
-        ret(mul(sign(sgn), sqrt(res))),
+      a = sym(sub(B, A)),
+      b = sym(add(madd(B, -2, A), C)),
+      c = sym(mul(a, 2)),
+      d = sym(sub(A, pos)),
+      kk = sym(div(FLOAT1, dot(b, b))),
+      kx = sym(mul(kk, dot(a, b))),
+      ky = sym(mul(kk, div(madd(FLOAT2, dot(a, a), dot(d, b)), 3))),
+      kz = sym(mul(kk, dot(d, a))),
+      res = sym(FLOAT0),
+      sgn = sym(FLOAT0),
+      p = sym(sub(ky, mul(kx, kx))),
+      q = sym(madd(sub(mul(mul(FLOAT2, kx), kx), mul(3, ky)), kx, kz)),
+      p3 = sym(mul(mul(p, p), p)),
+      q2 = sym(mul(q, q)),
+      h = sym(madd(p3, 4, q2)),
+      ifThen(
+        gte(h, FLOAT0),
+        [
+          assign(h, sqrt(h)),
+          x = sym(div(sub(vec2(h, neg(h)), q), FLOAT2)),
+          uv = sym(mul(sign(x), powf(abs(x), float(1 / 3)))),
+          t = sym(clamp01(sub(add($x(uv), $y(uv)), kx))),
+          assign(x, madd(madd(b, t, c), t, d)),
+          assign(res, dot(x, x)),
+          assign(sgn, cross2(madd(b, mul(t, FLOAT2), c), x))
+        ],
+        [
+          z = sym(sqrt(neg(p))),
+          v = sym(
+            div(acos(div(q, mul(mul(p, z), FLOAT2))), float(3))
+          ),
+          m = sym(cos(v)),
+          n = sym(mul(sin(v), 1.732050808)),
+          uv = sym(
+            clamp01(
+              sub(mul(vec2(add(m, m), sub(neg(n), m)), z), kx)
+            )
+          ),
+          x = sym(madd(madd(b, $x(uv), c), $x(uv), d)),
+          y = sym(madd(madd(b, $y(uv), c), $y(uv), d)),
+          assign(m, dot(x, x)),
+          assign(n, dot(y, y)),
+          ifThen(
+            lt(m, n),
+            [
+              assign(res, m),
+              assign(sgn, cross2(madd(b, mul($x(uv), 2), c), x))
+            ],
+            [
+              assign(res, n),
+              assign(sgn, cross2(madd(b, mul($y(uv), 2), c), y))
+            ]
+          )
+        ]
+      ),
+      ret(mul(sign(sgn), sqrt(res)))
     ];
-});
+  }
+);
+export {
+  sdfQuadratic2
+};

package/sdf/box-rounded.js

@@ -7,24 +7,20 @@ import { $, $x, $xy, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { abs, length, max, min } from "@thi.ng/shader-ast/builtin/math";
 import { maxComp2 } from "../math/maxcomp.js";
-/**
- * Returns signed distance from `p` to centered 2D rect of `size` and corner
- * radii defined by given vec4 `r`.
- *
- * @remarks
- * Ported from original GLSL impl by Inigo Quilez:
- * - https://iquilezles.org/articles/distfunctions2d/
- *
- * @param p - vec2
- * @param size - vec2
- * @param r - vec4
- */
-export const sdfBoxRounded = defn(F, "sdfBoxRounded", [V2, V2, V4], (p, size, r) => {
+const sdfBoxRounded = defn(
+  F,
+  "sdfBoxRounded",
+  [V2, V2, V4],
+  (p, size, r) => {
     let q, t, d;
     return [
-        (t = sym(ternary(gt($x(p), FLOAT0), $xy(r), $(r, "zw")))),
-        (d = sym(ternary(gt($y(p), FLOAT0), $x(t), $y(t)))),
-        (q = sym(add(sub(abs(p), size), d))),
-        ret(sub(add(min(maxComp2(q), FLOAT0), length(max(q, VEC2_0))), d)),
+      t = sym(ternary(gt($x(p), FLOAT0), $xy(r), $(r, "zw"))),
+      d = sym(ternary(gt($y(p), FLOAT0), $x(t), $y(t))),
+      q = sym(add(sub(abs(p), size), d)),
+      ret(sub(add(min(maxComp2(q), FLOAT0), length(max(q, VEC2_0))), d))
     ];
-});
+  }
+);
+export {
+  sdfBoxRounded
+};

package/sdf/box.js

@@ -5,29 +5,21 @@ import { add, sub } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { abs, length, max, min } from "@thi.ng/shader-ast/builtin/math";
 import { maxComp2, maxComp3 } from "../math/maxcomp.js";
-/**
- * Returns signed distance from `p` to centered AABB of `size`.
- *
- * @param p - vec2
- * @param size - vec2
- */
-export const sdfBox2 = defn(F, "sdfBox2", [V2, V2], (p, size) => {
-    let d;
-    return [
-        (d = sym(sub(abs(p), size))),
-        ret(add(min(maxComp2(d), FLOAT0), length(max(d, VEC2_0)))),
-    ];
+const sdfBox2 = defn(F, "sdfBox2", [V2, V2], (p, size) => {
+  let d;
+  return [
+    d = sym(sub(abs(p), size)),
+    ret(add(min(maxComp2(d), FLOAT0), length(max(d, VEC2_0))))
+  ];
 });
-/**
- * Returns signed distance from `p` to centered AABB of `size`.
- *
- * @param p - vec3
- * @param size - vec3
- */
-export const sdfBox3 = defn(F, "sdfBox3", [V3, V3], (p, size) => {
-    let d;
-    return [
-        (d = sym(sub(abs(p), size))),
-        ret(add(min(maxComp3(d), FLOAT0), length(max(d, VEC3_0)))),
-    ];
+const sdfBox3 = defn(F, "sdfBox3", [V3, V3], (p, size) => {
+  let d;
+  return [
+    d = sym(sub(abs(p), size)),
+    ret(add(min(maxComp3(d), FLOAT0), length(max(d, VEC3_0))))
+  ];
 });
+export {
+  sdfBox2,
+  sdfBox3
+};