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

package/math/additive.js

@@ -6,36 +6,31 @@ import { gensym } from "@thi.ng/shader-ast/ast/idgen";
 import { FLOAT0, FLOAT05, float } from "@thi.ng/shader-ast/ast/lit";
 import { add, inc, lt, mul } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
-/**
- * Higher order function. Takes an AST type ID, a single-arg scalar
- * function `fn`, number of octaves (default: 4) and an optional
- * function name. Returns a new function which computes the summed value
- * of `fn` over the given number octaves and accepts 3 args:
- *
- * - position (float)
- * - octave shift (float)
- * - octave decay (usually 0.5)
- *
- * For each octave `i` [0..oct), the function is (in principle)
- * evaluated as:
- *
- * n += decay / exp2(i) * fn(pos * exp2(i) + i * shift)
- *
- * @param fn -
- * @param oct -
- * @param name -
- */
-export const additive = (type, fn, oct = 4, name = gensym("additive_")) => defn(F, name, [[type], [type], F], (pos, shift, decay) => {
-    let n;
-    let amp;
-    return [
-        (n = sym(FLOAT0)),
-        (amp = sym(FLOAT05)),
-        forLoop(sym(FLOAT0), (i) => lt(i, float(oct)), inc, (i) => [
-            assign(n, add(n, mul(amp, fn(add(pos, mul(i, shift)))))),
-            assign(amp, mul(amp, decay)),
-            assign(pos, mul(pos, 2)),
-        ]),
-        ret(n),
-    ];
+const additive = (type, fn, oct = 4, name = gensym("additive_")) => defn(F, name, [[type], [type], F], (pos, shift, decay) => {
+  let n;
+  let amp;
+  return [
+    n = sym(FLOAT0),
+    amp = sym(FLOAT05),
+    forLoop(
+      sym(FLOAT0),
+      (i) => lt(i, float(oct)),
+      inc,
+      (i) => [
+        assign(
+          n,
+          add(
+            n,
+            mul(amp, fn(add(pos, mul(i, shift))))
+          )
+        ),
+        assign(amp, mul(amp, decay)),
+        assign(pos, mul(pos, 2))
+      ]
+    ),
+    ret(n)
+  ];
 });
+export {
+  additive
+};

package/math/cartesian.js

@@ -5,28 +5,25 @@ import { mul } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { cossin } from "./sincos.js";
-/**
- * Converts 2D polar vector `v`, i.e. `[r,θ]` (angle in radians) to
- * cartesian coordinates. See {@link polar2} for reverse operation.
- *
- * @param v -
- */
-export const cartesian2 = (v) => mul(cossin($y(v)), $x(v));
-/**
- * Converts 3D polar/spherical vector `v`, i.e. `[r,θ,ϕ]` (angles in
- * radians) to cartesian coordinates. See {@link polar3} for reverse
- * operation.
- *
- * @param v -
- */
-export const cartesian3 = defn(V3, "cartesian3", [V3], (v) => {
-    let r;
-    let t;
-    let p;
-    return [
-        (r = sym($x(v))),
-        (t = sym(cossin($y(v)))),
-        (p = sym(cossin($z(v)))),
-        ret(vec3(mul(mul(r, $x(t)), $x(p)), mul(mul(r, $x(t)), $y(p)), mul(r, $y(t)))),
-    ];
+const cartesian2 = (v) => mul(cossin($y(v)), $x(v));
+const cartesian3 = defn(V3, "cartesian3", [V3], (v) => {
+  let r;
+  let t;
+  let p;
+  return [
+    r = sym($x(v)),
+    t = sym(cossin($y(v))),
+    p = sym(cossin($z(v))),
+    ret(
+      vec3(
+        mul(mul(r, $x(t)), $x(p)),
+        mul(mul(r, $x(t)), $y(p)),
+        mul(r, $y(t))
+      )
+    )
+  ];
 });
+export {
+  cartesian2,
+  cartesian3
+};

package/math/clamp.js

@@ -1,22 +1,10 @@
 import { F, V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { float, vec2, vec3, vec4 } from "@thi.ng/shader-ast/ast/lit";
 import { clamp } from "@thi.ng/shader-ast/builtin/math";
-const __clamp = (min, max) => (x) => x.type === F
-    ? clamp(x, float(min), float(max))
-    : x.type === V2
-        ? clamp(x, vec2(min), vec2(max))
-        : x.type === V3
-            ? clamp(x, vec3(min), vec3(max))
-            : clamp(x, vec4(min), vec4(max));
-/**
- * Inline function, expands to equivalent of `clamp(x, 0, 1)`.
- *
- * @param x -
- */
-export const clamp01 = __clamp(0, 1);
-/**
- * Inline function, expands to equivalent of `clamp(x, -1, 1)`.
- *
- * @param x -
- */
-export const clamp11 = __clamp(-1, 1);
+const __clamp = (min, max) => (x) => x.type === F ? clamp(x, float(min), float(max)) : x.type === V2 ? clamp(x, vec2(min), vec2(max)) : x.type === V3 ? clamp(x, vec3(min), vec3(max)) : clamp(x, vec4(min), vec4(max));
+const clamp01 = __clamp(0, 1);
+const clamp11 = __clamp(-1, 1);
+export {
+  clamp01,
+  clamp11
+};

package/math/cross2.js

@@ -2,23 +2,11 @@ import { F, V2 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
-/**
- * Computes 2D "cross product" of given vectors. Also see
- * {@link crossC2}.
- *
- * @param a -
- * @param b -
- */
-export const cross2 = defn(F, "cross2", [V2, V2], (a, b) => [
-    ret(sub(mul($x(a), $y(b)), mul($y(a), $x(b)))),
+const cross2 = defn(F, "cross2", [V2, V2], (a, b) => [
+  ret(sub(mul($x(a), $y(b)), mul($y(a), $x(b))))
 ]);
-/**
- * Inline function. Computes 2D cross product of given individual
- * components: ax * by - ay * bx
- *
- * @param ax -
- * @param ay -
- * @param bx -
- * @param by -
- */
-export const crossC2 = (ax, ay, bx, by) => sub(mul(ax, by), mul(ay, bx));
+const crossC2 = (ax, ay, bx, by) => sub(mul(ax, by), mul(ay, bx));
+export {
+  cross2,
+  crossC2
+};

package/math/dist-chebyshev.js

@@ -1,6 +1,11 @@
 import { sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $x, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { abs, max } from "@thi.ng/shader-ast/builtin/math";
-export const distChebyshev2 = (a, b) => max(abs(sub($x(a), $x(b))), abs(sub($y(a), $y(b))));
-export const distChebyshev3 = (a, b) => max(distChebyshev2(a, b), abs(sub($z(a), $z(b))));
-export const distChebyshev4 = (a, b) => max(distChebyshev2(a, b), distChebyshev2($(a, "zw"), $(b, "zw")));
+const distChebyshev2 = (a, b) => max(abs(sub($x(a), $x(b))), abs(sub($y(a), $y(b))));
+const distChebyshev3 = (a, b) => max(distChebyshev2(a, b), abs(sub($z(a), $z(b))));
+const distChebyshev4 = (a, b) => max(distChebyshev2(a, b), distChebyshev2($(a, "zw"), $(b, "zw")));
+export {
+  distChebyshev2,
+  distChebyshev3,
+  distChebyshev4
+};

package/math/dist-manhattan.js

@@ -1,6 +1,11 @@
 import { add, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $x, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { abs } from "@thi.ng/shader-ast/builtin/math";
-export const distManhattan2 = (a, b) => add(abs(sub($x(a), $x(b))), abs(sub($y(a), $y(b))));
-export const distManhattan3 = (a, b) => add(distManhattan2(a, b), abs(sub($z(a), $z(b))));
-export const distManhattan4 = (a, b) => add(distManhattan2(a, b), distManhattan2($(a, "zw"), $(b, "zw")));
+const distManhattan2 = (a, b) => add(abs(sub($x(a), $x(b))), abs(sub($y(a), $y(b))));
+const distManhattan3 = (a, b) => add(distManhattan2(a, b), abs(sub($z(a), $z(b))));
+const distManhattan4 = (a, b) => add(distManhattan2(a, b), distManhattan2($(a, "zw"), $(b, "zw")));
+export {
+  distManhattan2,
+  distManhattan3,
+  distManhattan4
+};

package/math/easing.js

@@ -1,117 +1,354 @@
 import { F } from "@thi.ng/shader-ast/api/types";
 import { ifThen, ternary } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { FLOAT0, FLOAT05, FLOAT1, FLOAT2, HALF_PI, PI, TAU, float, } from "@thi.ng/shader-ast/ast/lit";
-import { add, div, eq, gte, lt, lte, madd, mul, neg, reciprocal, sub, } from "@thi.ng/shader-ast/ast/ops";
+import {
+  FLOAT0,
+  FLOAT05,
+  FLOAT1,
+  FLOAT2,
+  HALF_PI,
+  PI,
+  TAU,
+  float
+} from "@thi.ng/shader-ast/ast/lit";
+import {
+  add,
+  div,
+  eq,
+  gte,
+  lt,
+  lte,
+  madd,
+  mul,
+  neg,
+  reciprocal,
+  sub
+} from "@thi.ng/shader-ast/ast/ops";
 import { cos, exp2, pow, sin, sqrt } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Higher order helper function to wrap a given easing function body as proper
- * shader-ast function.
- *
- * @param body
- */
-export const defEasing = (body) => defn(F, null, [F], body);
-export const easeInSine = defEasing((x) => [
-    ret(sub(FLOAT1, cos(mul(x, HALF_PI)))),
+const defEasing = (body) => defn(F, null, [F], body);
+const easeInSine = defEasing((x) => [
+  ret(sub(FLOAT1, cos(mul(x, HALF_PI))))
 ]);
-export const easeOutSine = defEasing((x) => [ret(sin(mul(x, HALF_PI)))]);
-export const easeInOutSine = defEasing((x) => [
-    ret(div(neg(sub(cos(mul(PI, x)), FLOAT1)), FLOAT2)),
+const easeOutSine = defEasing((x) => [ret(sin(mul(x, HALF_PI)))]);
+const easeInOutSine = defEasing((x) => [
+  ret(div(neg(sub(cos(mul(PI, x)), FLOAT1)), FLOAT2))
 ]);
-export const easeInQuad = defEasing((x) => [ret(pow(x, FLOAT2))]);
-export const easeOutQuad = defEasing((x) => [
-    ret(sub(FLOAT1, pow(sub(FLOAT1, x), FLOAT2))),
+const easeInQuad = defEasing((x) => [ret(pow(x, FLOAT2))]);
+const easeOutQuad = defEasing((x) => [
+  ret(sub(FLOAT1, pow(sub(FLOAT1, x), FLOAT2)))
 ]);
-export const easeInOutQuad = defEasing((x) => [
-    ret(ternary(lt(x, FLOAT05), mul(FLOAT2, pow(x, FLOAT2)), sub(FLOAT1, div(pow(madd(neg(FLOAT2), x, FLOAT2), FLOAT2), FLOAT2)))),
+const easeInOutQuad = defEasing((x) => [
+  ret(
+    ternary(
+      lt(x, FLOAT05),
+      mul(FLOAT2, pow(x, FLOAT2)),
+      sub(FLOAT1, div(pow(madd(neg(FLOAT2), x, FLOAT2), FLOAT2), FLOAT2))
+    )
+  )
 ]);
-export const easeInCubic = defEasing((x) => [ret(pow(x, float(3)))]);
-export const easeOutCubic = defEasing((x) => [
-    ret(sub(FLOAT1, pow(sub(FLOAT1, x), float(3)))),
+const easeInCubic = defEasing((x) => [ret(pow(x, float(3)))]);
+const easeOutCubic = defEasing((x) => [
+  ret(sub(FLOAT1, pow(sub(FLOAT1, x), float(3))))
 ]);
-export const easeInOutCubic = defEasing((x) => [
-    ret(ternary(lt(x, FLOAT05), mul(float(4), pow(x, float(3))), sub(FLOAT1, div(pow(madd(neg(FLOAT2), x, FLOAT2), float(3)), FLOAT2)))),
+const easeInOutCubic = defEasing((x) => [
+  ret(
+    ternary(
+      lt(x, FLOAT05),
+      mul(float(4), pow(x, float(3))),
+      sub(
+        FLOAT1,
+        div(pow(madd(neg(FLOAT2), x, FLOAT2), float(3)), FLOAT2)
+      )
+    )
+  )
 ]);
-export const easeInQuart = defEasing((x) => [ret(pow(x, float(4)))]);
-export const easeOutQuart = defEasing((x) => [
-    ret(sub(FLOAT1, pow(sub(FLOAT1, x), float(4)))),
+const easeInQuart = defEasing((x) => [ret(pow(x, float(4)))]);
+const easeOutQuart = defEasing((x) => [
+  ret(sub(FLOAT1, pow(sub(FLOAT1, x), float(4))))
 ]);
-export const easeInOutQuart = defEasing((x) => [
-    ret(ternary(lt(x, FLOAT05), mul(float(8), pow(x, float(4))), sub(FLOAT1, div(pow(madd(neg(FLOAT2), x, FLOAT2), float(4)), FLOAT2)))),
+const easeInOutQuart = defEasing((x) => [
+  ret(
+    ternary(
+      lt(x, FLOAT05),
+      mul(float(8), pow(x, float(4))),
+      sub(
+        FLOAT1,
+        div(pow(madd(neg(FLOAT2), x, FLOAT2), float(4)), FLOAT2)
+      )
+    )
+  )
 ]);
-export const easeInQuint = defEasing((x) => [ret(pow(x, float(5)))]);
-export const easeOutQuint = defEasing((x) => [
-    ret(sub(FLOAT1, pow(sub(FLOAT1, x), float(5)))),
+const easeInQuint = defEasing((x) => [ret(pow(x, float(5)))]);
+const easeOutQuint = defEasing((x) => [
+  ret(sub(FLOAT1, pow(sub(FLOAT1, x), float(5))))
 ]);
-export const easeInOutQuint = defEasing((x) => [
-    ret(ternary(lt(x, FLOAT05), mul(float(16), pow(x, float(5))), sub(FLOAT1, div(pow(madd(neg(FLOAT2), x, FLOAT2), float(5)), FLOAT2)))),
+const easeInOutQuint = defEasing((x) => [
+  ret(
+    ternary(
+      lt(x, FLOAT05),
+      mul(float(16), pow(x, float(5))),
+      sub(
+        FLOAT1,
+        div(pow(madd(neg(FLOAT2), x, FLOAT2), float(5)), FLOAT2)
+      )
+    )
+  )
 ]);
-export const easeInExpo = defEasing((x) => [
-    ret(ternary(eq(x, FLOAT0), FLOAT0, exp2(sub(mul(float(10), x), float(10))))),
+const easeInExpo = defEasing((x) => [
+  ret(
+    ternary(eq(x, FLOAT0), FLOAT0, exp2(sub(mul(float(10), x), float(10))))
+  )
 ]);
-export const easeOutExpo = defEasing((x) => [
-    ret(ternary(eq(x, FLOAT1), FLOAT1, sub(FLOAT1, exp2(mul(neg(float(10)), x))))),
+const easeOutExpo = defEasing((x) => [
+  ret(
+    ternary(
+      eq(x, FLOAT1),
+      FLOAT1,
+      sub(FLOAT1, exp2(mul(neg(float(10)), x)))
+    )
+  )
 ]);
-export const easeInOutExpo = defEasing((x) => [
-    ret(ternary(eq(x, FLOAT0), FLOAT0, ternary(eq(x, FLOAT1), FLOAT1, ternary(lt(x, FLOAT05), div(exp2(sub(mul(float(20), x), float(10))), FLOAT2), div(sub(FLOAT2, exp2(madd(neg(float(20)), x, float(10)))), FLOAT2))))),
+const easeInOutExpo = defEasing((x) => [
+  ret(
+    ternary(
+      eq(x, FLOAT0),
+      FLOAT0,
+      ternary(
+        eq(x, FLOAT1),
+        FLOAT1,
+        ternary(
+          lt(x, FLOAT05),
+          div(exp2(sub(mul(float(20), x), float(10))), FLOAT2),
+          div(
+            sub(FLOAT2, exp2(madd(neg(float(20)), x, float(10)))),
+            FLOAT2
+          )
+        )
+      )
+    )
+  )
 ]);
-export const easeInCirc = defEasing((x) => [
-    ret(sub(FLOAT1, sqrt(sub(FLOAT1, pow(x, FLOAT2))))),
+const easeInCirc = defEasing((x) => [
+  ret(sub(FLOAT1, sqrt(sub(FLOAT1, pow(x, FLOAT2)))))
 ]);
-export const easeOutCirc = defEasing((x) => [
-    ret(sqrt(sub(FLOAT1, pow(sub(x, FLOAT1), FLOAT2)))),
+const easeOutCirc = defEasing((x) => [
+  ret(sqrt(sub(FLOAT1, pow(sub(x, FLOAT1), FLOAT2))))
 ]);
-export const easeInOutCirc = defEasing((x) => [
-    ret(ternary(lt(x, FLOAT05), div(sub(FLOAT1, sqrt(sub(FLOAT1, pow(mul(FLOAT2, x), FLOAT2)))), FLOAT2), div(add(sqrt(sub(FLOAT1, pow(madd(neg(FLOAT2), x, FLOAT2), FLOAT2))), FLOAT1), FLOAT2))),
+const easeInOutCirc = defEasing((x) => [
+  ret(
+    ternary(
+      lt(x, FLOAT05),
+      div(
+        sub(FLOAT1, sqrt(sub(FLOAT1, pow(mul(FLOAT2, x), FLOAT2)))),
+        FLOAT2
+      ),
+      div(
+        add(
+          sqrt(
+            sub(FLOAT1, pow(madd(neg(FLOAT2), x, FLOAT2), FLOAT2))
+          ),
+          FLOAT1
+        ),
+        FLOAT2
+      )
+    )
+  )
 ]);
-export const easeInBack = defEasing((x) => {
-    const c1 = 1.70158;
-    const c3 = c1 + 1;
-    return [ret(sub(mul(c3, pow(x, float(3))), mul(c1, pow(x, FLOAT2))))];
+const easeInBack = defEasing((x) => {
+  const c1 = 1.70158;
+  const c3 = c1 + 1;
+  return [ret(sub(mul(c3, pow(x, float(3))), mul(c1, pow(x, FLOAT2))))];
 });
-export const easeOutBack = defEasing((x) => {
-    const c1 = 1.70158;
-    const c3 = c1 + 1;
-    return [
-        ret(add(madd(float(c3), pow(sub(x, FLOAT1), float(3)), FLOAT1), mul(c1, pow(sub(x, FLOAT1), FLOAT2)))),
-    ];
+const easeOutBack = defEasing((x) => {
+  const c1 = 1.70158;
+  const c3 = c1 + 1;
+  return [
+    ret(
+      add(
+        madd(float(c3), pow(sub(x, FLOAT1), float(3)), FLOAT1),
+        mul(c1, pow(sub(x, FLOAT1), FLOAT2))
+      )
+    )
+  ];
 });
-export const easeInOutBack = defEasing((x) => {
-    const c1 = 1.70158;
-    const c2 = c1 * 1.525;
-    return [
-        ret(ternary(lt(x, FLOAT05), div(mul(pow(mul(FLOAT2, x), FLOAT2), sub(mul(mul(add(c2, FLOAT1), FLOAT2), x), c2)), FLOAT2), div(add(mul(pow(sub(mul(FLOAT2, x), FLOAT2), FLOAT2), add(mul(add(c2, FLOAT1), sub(mul(x, FLOAT2), FLOAT2)), c2)), FLOAT2), FLOAT2))),
-    ];
+const easeInOutBack = defEasing((x) => {
+  const c1 = 1.70158;
+  const c2 = c1 * 1.525;
+  return [
+    ret(
+      ternary(
+        lt(x, FLOAT05),
+        div(
+          mul(
+            pow(mul(FLOAT2, x), FLOAT2),
+            sub(mul(mul(add(c2, FLOAT1), FLOAT2), x), c2)
+          ),
+          FLOAT2
+        ),
+        div(
+          add(
+            mul(
+              pow(sub(mul(FLOAT2, x), FLOAT2), FLOAT2),
+              add(
+                mul(
+                  add(c2, FLOAT1),
+                  sub(mul(x, FLOAT2), FLOAT2)
+                ),
+                c2
+              )
+            ),
+            FLOAT2
+          ),
+          FLOAT2
+        )
+      )
+    )
+  ];
 });
-export const easeInElastic = defEasing((x) => [
-    ret(ternary(eq(x, FLOAT0), FLOAT0, ternary(eq(x, FLOAT1), FLOAT1, mul(neg(exp2(sub(mul(10, x), 10))), sin(mul(sub(mul(x, 10), 10.75), div(TAU, 3))))))),
+const easeInElastic = defEasing((x) => [
+  ret(
+    ternary(
+      eq(x, FLOAT0),
+      FLOAT0,
+      ternary(
+        eq(x, FLOAT1),
+        FLOAT1,
+        mul(
+          neg(exp2(sub(mul(10, x), 10))),
+          sin(mul(sub(mul(x, 10), 10.75), div(TAU, 3)))
+        )
+      )
+    )
+  )
 ]);
-export const easeOutElastic = defEasing((x) => [
-    ret(ternary(lte(x, FLOAT0), FLOAT0, ternary(gte(x, FLOAT1), FLOAT1, madd(exp2(mul(-10, x)), sin(mul(sub(mul(x, 10), 0.75), div(TAU, 3))), FLOAT1)))),
+const easeOutElastic = defEasing((x) => [
+  ret(
+    ternary(
+      lte(x, FLOAT0),
+      FLOAT0,
+      ternary(
+        gte(x, FLOAT1),
+        FLOAT1,
+        madd(
+          exp2(mul(-10, x)),
+          sin(mul(sub(mul(x, 10), 0.75), div(TAU, 3))),
+          FLOAT1
+        )
+      )
+    )
+  )
 ]);
-export const easeInOutElastic = defEasing((x) => {
-    const c5 = div(TAU, 4.5);
-    return [
-        ret(ternary(eq(x, FLOAT0), FLOAT0, ternary(eq(x, FLOAT1), FLOAT1, ternary(lt(x, FLOAT05), div(neg(mul(exp2(sub(mul(20, x), 10)), sin(mul(sub(mul(20, x), 11.125), c5)))), FLOAT2), add(div(mul(exp2(madd(neg(float(20)), x, float(10))), sin(mul(sub(mul(20, x), 11.125), c5))), FLOAT2), FLOAT1))))),
-    ];
+const easeInOutElastic = defEasing((x) => {
+  const c5 = div(TAU, 4.5);
+  return [
+    ret(
+      ternary(
+        eq(x, FLOAT0),
+        FLOAT0,
+        ternary(
+          eq(x, FLOAT1),
+          FLOAT1,
+          ternary(
+            lt(x, FLOAT05),
+            div(
+              neg(
+                mul(
+                  exp2(sub(mul(20, x), 10)),
+                  sin(mul(sub(mul(20, x), 11.125), c5))
+                )
+              ),
+              FLOAT2
+            ),
+            add(
+              div(
+                mul(
+                  exp2(madd(neg(float(20)), x, float(10))),
+                  sin(mul(sub(mul(20, x), 11.125), c5))
+                ),
+                FLOAT2
+              ),
+              FLOAT1
+            )
+          )
+        )
+      )
+    )
+  ];
 });
-export const easeOutBounce = defEasing((x) => {
-    const n1 = 7.5625;
-    const d1 = float(2.75);
-    return [
-        ifThen(lt(x, reciprocal(d1)), [ret(mul(n1, pow(x, FLOAT2)))]),
-        ifThen(lt(x, div(FLOAT2, d1)), [
-            ret(add(mul(mul(n1, sub(x, div(1.5, d1))), sub(x, div(1.5, d1))), 0.75)),
-        ]),
-        ifThen(lt(x, div(2.5, d1)), [
-            ret(add(mul(mul(n1, sub(x, div(2.25, d1))), sub(x, div(2.25, d1))), 0.9375)),
-        ]),
-        ret(add(mul(mul(n1, sub(x, div(2.625, d1))), sub(x, div(2.625, d1))), 0.984375)),
-    ];
+const easeOutBounce = defEasing((x) => {
+  const n1 = 7.5625;
+  const d1 = float(2.75);
+  return [
+    ifThen(lt(x, reciprocal(d1)), [ret(mul(n1, pow(x, FLOAT2)))]),
+    ifThen(lt(x, div(FLOAT2, d1)), [
+      ret(
+        add(
+          mul(mul(n1, sub(x, div(1.5, d1))), sub(x, div(1.5, d1))),
+          0.75
+        )
+      )
+    ]),
+    ifThen(lt(x, div(2.5, d1)), [
+      ret(
+        add(
+          mul(mul(n1, sub(x, div(2.25, d1))), sub(x, div(2.25, d1))),
+          0.9375
+        )
+      )
+    ]),
+    ret(
+      add(
+        mul(mul(n1, sub(x, div(2.625, d1))), sub(x, div(2.625, d1))),
+        0.984375
+      )
+    )
+  ];
 });
-export const easeInBounce = defEasing((x) => [
-    ret(sub(FLOAT1, easeOutBounce(sub(FLOAT1, x)))),
+const easeInBounce = defEasing((x) => [
+  ret(sub(FLOAT1, easeOutBounce(sub(FLOAT1, x))))
 ]);
-export const easeInOutBounce = defEasing((x) => [
-    ret(ternary(lt(x, FLOAT05), div(sub(FLOAT1, easeOutBounce(sub(FLOAT1, mul(FLOAT2, x)))), FLOAT2), div(add(FLOAT1, easeOutBounce(sub(mul(FLOAT2, x), FLOAT1))), FLOAT2))),
+const easeInOutBounce = defEasing((x) => [
+  ret(
+    ternary(
+      lt(x, FLOAT05),
+      div(
+        sub(FLOAT1, easeOutBounce(sub(FLOAT1, mul(FLOAT2, x)))),
+        FLOAT2
+      ),
+      div(add(FLOAT1, easeOutBounce(sub(mul(FLOAT2, x), FLOAT1))), FLOAT2)
+    )
+  )
 ]);
+export {
+  defEasing,
+  easeInBack,
+  easeInBounce,
+  easeInCirc,
+  easeInCubic,
+  easeInElastic,
+  easeInExpo,
+  easeInOutBack,
+  easeInOutBounce,
+  easeInOutCirc,
+  easeInOutCubic,
+  easeInOutElastic,
+  easeInOutExpo,
+  easeInOutQuad,
+  easeInOutQuart,
+  easeInOutQuint,
+  easeInOutSine,
+  easeInQuad,
+  easeInQuart,
+  easeInQuint,
+  easeInSine,
+  easeOutBack,
+  easeOutBounce,
+  easeOutCirc,
+  easeOutCubic,
+  easeOutElastic,
+  easeOutExpo,
+  easeOutQuad,
+  easeOutQuart,
+  easeOutQuint,
+  easeOutSine
+};