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

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:04Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -105,7 +105,7 @@ For Node.js REPL:
 const shaderAstStdlib = await import("@thi.ng/shader-ast-stdlib");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 13.42 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 13.40 KB
 
 ## Dependencies
 

package/api.js

@@ -1 +0,0 @@
-export {};

package/color/aces-film.js

@@ -2,14 +2,16 @@ import { V3 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { add, div, mul } from "@thi.ng/shader-ast/ast/ops";
 import { clamp01 } from "../math/clamp.js";
-/**
- * Filmic HDR -> LDR mapping based on ACES.
- *
- * Reference:
- * https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/
- *
- * @param col -
- */
-export const ACESFilm = defn(V3, "ACESFilm", [V3], (col) => [
-    ret(clamp01(div(mul(col, add(mul(col, 2.51), 0.03)), add(mul(col, add(mul(col, 2.43), 0.59)), 0.14)))),
+const ACESFilm = defn(V3, "ACESFilm", [V3], (col) => [
+  ret(
+    clamp01(
+      div(
+        mul(col, add(mul(col, 2.51), 0.03)),
+        add(mul(col, add(mul(col, 2.43), 0.59)), 0.14)
+      )
+    )
+  )
 ]);
+export {
+  ACESFilm
+};

package/color/levels.js

@@ -2,74 +2,88 @@ import { F, M3, V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { ternary } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { indexMat } from "@thi.ng/shader-ast/ast/indexed";
-import { FLOAT0, FLOAT05, FLOAT1, VEC3_0, VEC3_1, float, vec3, } from "@thi.ng/shader-ast/ast/lit";
+import {
+  FLOAT0,
+  FLOAT05,
+  FLOAT1,
+  VEC3_0,
+  VEC3_1,
+  float,
+  vec3
+} from "@thi.ng/shader-ast/ast/lit";
 import { lt, madd, mul, reciprocal, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { max, min, pow } from "@thi.ng/shader-ast/builtin/math";
 import { fit01, fitClamped } from "../math/fit.js";
-/**
- * Takes normalized `mid` level and converts it into an exponent for gamma
- * correction using {@link levelAdjustGamma}.
- *
- * @remarks
- * Reference: https://stackoverflow.com/a/48859502/294515
- */
-export const midLevelGamma = defn(F, "midLevelGamma", [F], (mid) => [
-    ret(reciprocal(ternary(lt(mid, FLOAT05), min(float(9.99), madd(float(9), sub(1, mul(mid, 2)), 1)), max(float(0.01), sub(1, sub(mul(mid, 2), 1)))))),
+const midLevelGamma = defn(F, "midLevelGamma", [F], (mid) => [
+  ret(
+    reciprocal(
+      ternary(
+        lt(mid, FLOAT05),
+        min(float(9.99), madd(float(9), sub(1, mul(mid, 2)), 1)),
+        max(float(0.01), sub(1, sub(mul(mid, 2), 1)))
+      )
+    )
+  )
 ]);
-/**
- * Inline function.  Similar to {@link midLevelGamma}, but for RGB values (with
- * potentially varying settings per channel). To be used with
- * {@link levelAdjustGammaRGB}.
- *
- * @param mid -
- */
-export const midLevelGammaRGB = (mid) => vec3(midLevelGamma($x(mid)), midLevelGamma($y(mid)), midLevelGamma($z(mid)));
-/**
- * Applies level remapping from `input` to `output` (each given as
- * `vec2(min,max)`) with `gamma` correction. Results will be clamped to [0..1]
- * range.
- */
-export const levelAdjustGamma = defn(F, "levelAdjustGamma", [F, F, V2, V2], (x, gamma, input, output) => [
-    ret(fit01(pow(fitClamped(x, $x(input), $y(input), FLOAT0, FLOAT1), gamma), $x(output), $y(output))),
-]);
-/**
- * Similar to {@link levelAdjustGamma}, but for RGB values (with potentially
- * varying settings per channel).
- *
- * @remarks
- * Note: Only the first to columns of the `mat3` args will be used (for WebGL1
- * compatibility):
- *
- * - 1st column = RGB min values
- * - 2nd column = RGB max values
- */
-export const levelAdjustGammaRGB = defn(V3, "levelAdjustGammaRGB", [V3, V3, M3, M3], (x, gamma, input, output) => [
-    ret(fit01(pow(fitClamped(x, indexMat(input, 0), indexMat(input, 1), VEC3_0, VEC3_1), gamma), indexMat(output, 0), indexMat(output, 1))),
-]);
-/**
- * Inline function. Similar to {@link levelAdjustGamma}, but first computes
- * gamma from given `mid` level.
- *
- * @remarks
- * Also see {@link midLevelGamma}.
- *
- * @param x - float
- * @param mid - float
- * @param input - vec2(min,max)
- * @param output - vec2(min,max)
- */
-export const levelAdjustMid = (x, mid, input, output) => levelAdjustGamma(x, midLevelGamma(mid), input, output);
-/**
- * Inline function. Similar to {@link levelAdjustMid}, but for RGB values (with
- * potentially varying settings per channel).
- *
- * @remarks
- * Also see {@link levelAdjustGammaRGB}, {@link midLevelGammaRGB}.
- *
- * @param x -
- * @param mid -
- * @param input -
- * @param output -
- */
-export const levelAdjustMidRGB = (x, mid, input, output) => levelAdjustGammaRGB(x, midLevelGammaRGB(mid), input, output);
+const midLevelGammaRGB = (mid) => vec3(
+  midLevelGamma($x(mid)),
+  midLevelGamma($y(mid)),
+  midLevelGamma($z(mid))
+);
+const levelAdjustGamma = defn(
+  F,
+  "levelAdjustGamma",
+  [F, F, V2, V2],
+  (x, gamma, input, output) => [
+    ret(
+      fit01(
+        pow(
+          fitClamped(
+            x,
+            $x(input),
+            $y(input),
+            FLOAT0,
+            FLOAT1
+          ),
+          gamma
+        ),
+        $x(output),
+        $y(output)
+      )
+    )
+  ]
+);
+const levelAdjustGammaRGB = defn(
+  V3,
+  "levelAdjustGammaRGB",
+  [V3, V3, M3, M3],
+  (x, gamma, input, output) => [
+    ret(
+      fit01(
+        pow(
+          fitClamped(
+            x,
+            indexMat(input, 0),
+            indexMat(input, 1),
+            VEC3_0,
+            VEC3_1
+          ),
+          gamma
+        ),
+        indexMat(output, 0),
+        indexMat(output, 1)
+      )
+    )
+  ]
+);
+const levelAdjustMid = (x, mid, input, output) => levelAdjustGamma(x, midLevelGamma(mid), input, output);
+const levelAdjustMidRGB = (x, mid, input, output) => levelAdjustGammaRGB(x, midLevelGammaRGB(mid), input, output);
+export {
+  levelAdjustGamma,
+  levelAdjustGammaRGB,
+  levelAdjustMid,
+  levelAdjustMidRGB,
+  midLevelGamma,
+  midLevelGammaRGB
+};

package/color/linear-srgb.js

@@ -3,24 +3,14 @@ import { pow } from "@thi.ng/shader-ast/builtin/math";
 const GAMMA = float(2.2);
 const INV_GAMMA = float(1 / 2.2);
 const $ = (t, x) => ({
-    float: x,
-    vec2: vec2(x),
-    vec3: vec3(x),
-    vec4: vec4(x, x, x, 1),
-}[t.type]);
-/**
- * Inline function. Converts sRGB color term (1D-4D) to linear space via
- * `pow(rgb, GAMMA)`, where gamma is hardcoded to 2.2. For vec4 args,
- * the `w` component (alpha) remains unchanged.
- *
- * @param x -
- */
-export const toLinear = (x) => pow(x, $(x, GAMMA));
-/**
- * Inline function. Converts linear color term (1D-4D) to sRGB via
- * `pow(rgb, 1.0 / GAMMA)`, where gamma is hardcoded to 2.2. For vec4
- * args, the `w` component (alpha) remains unchanged.
- *
- * @param x -
- */
-export const toSRGB = (x) => pow(x, $(x, INV_GAMMA));
+  float: x,
+  vec2: vec2(x),
+  vec3: vec3(x),
+  vec4: vec4(x, x, x, 1)
+})[t.type];
+const toLinear = (x) => pow(x, $(x, GAMMA));
+const toSRGB = (x) => pow(x, $(x, INV_GAMMA));
+export {
+  toLinear,
+  toSRGB
+};

package/color/luminance.js

@@ -1,8 +1,6 @@
 import { vec3 } from "@thi.ng/shader-ast/ast/lit";
 import { dot } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Inline function. Computes luminance of given RGB color
- *
- * @param rgb -
- */
-export const luminanceRGB = (rgb) => dot(rgb, vec3(0.299, 0.587, 0.114));
+const luminanceRGB = (rgb) => dot(rgb, vec3(0.299, 0.587, 0.114));
+export {
+  luminanceRGB
+};

package/color/porter-duff.js

@@ -4,60 +4,56 @@ import { FLOAT0, FLOAT1, vec4 } from "@thi.ng/shader-ast/ast/lit";
 import { add, div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $w, $xyz } from "@thi.ng/shader-ast/ast/swizzle";
 import { clamp01 } from "../math/clamp.js";
-/** @internal */
 const __coeff = (col, f) => f === FLOAT0 ? vec4() : f === FLOAT1 ? col : mul(col, f);
-/**
- * Higher-order Porter-Duff alpha compositing operator. See
- * [thi.ng/porter-duff](https://thi.ng/porter-duff) for reference. Returns an
- * optimized AST function which accepts 2 RGBA colors (vec4) and returns blended
- * & clamped result (also a vec4).
- *
- * @remark
- * All built-in PD operators are defined via this HOF. The two given coefficient
- * functions are used to extract blending coefficients for src/dest colors and
- * are called with the alpha components of both colors.
- *
- * Optimization only happens for cases where either `fa` and/or `fb` are
- * {@link ZERO} or {@link ONE}.
- *
- * *IMPORTANT*: Both colors MUST be use pre-multiplied alpha for correct
- * results. If needed, use {@link premultiplyAlpha} and
- * {@link postmultiplyAlpha}.
- *
- * @param name - function name
- * @param fa - src coeff fn
- * @param fb - dest coeff fn
- */
-export const porterDuff = (name, fa, fb) => defn(V4, name, [V4, V4], (a, b) => {
-    const sa = fa($w(a), $w(b));
-    const sb = fb($w(a), $w(b));
-    const src = __coeff(a, sa);
-    const dest = __coeff(b, sb);
-    const srcZero = sa === FLOAT0;
-    const destZero = sb === FLOAT0;
-    return [
-        ret(srcZero && destZero
-            ? vec4()
-            : clamp01(srcZero ? dest : destZero ? src : add(src, dest))),
-    ];
+const porterDuff = (name, fa, fb) => defn(V4, name, [V4, V4], (a, b) => {
+  const sa = fa($w(a), $w(b));
+  const sb = fb($w(a), $w(b));
+  const src = __coeff(a, sa);
+  const dest = __coeff(b, sb);
+  const srcZero = sa === FLOAT0;
+  const destZero = sb === FLOAT0;
+  return [
+    ret(
+      srcZero && destZero ? vec4() : clamp01(srcZero ? dest : destZero ? src : add(src, dest))
+    )
+  ];
 });
-export const premultiplyAlpha = (col) => vec4(mul($xyz(col), $w(col)), $w(col));
-export const postmultiplyAlpha = (col) => vec4(div($xyz(col), $w(col)), $w(col));
-// coefficient functions
-export const ZERO = () => FLOAT0;
-export const ONE = () => FLOAT1;
-export const A = (a) => a;
-export const B = (_, b) => b;
-export const ONE_MINUS_A = (a) => sub(FLOAT1, a);
-export const ONE_MINUS_B = (_, b) => sub(FLOAT1, b);
-// standard Porter-Duff operators
-export const blendSrcOver = porterDuff("blendSrcOver", ONE, ONE_MINUS_A);
-export const blendDestOver = porterDuff("blendDestOver", ONE_MINUS_B, ONE);
-export const blendSrcIn = porterDuff("blendSrcIn", B, ZERO);
-export const blendDestIn = porterDuff("blendDestIn", ZERO, A);
-export const blendSrcOut = porterDuff("blendSrcOut", ONE_MINUS_B, ZERO);
-export const blendDestOut = porterDuff("blendDestOut", ZERO, ONE_MINUS_A);
-export const blendSrcAtop = porterDuff("blendSrcAtop", B, ONE_MINUS_A);
-export const blendDestAtop = porterDuff("blendDestAtop", ONE_MINUS_B, A);
-export const blendXor = porterDuff("blendXor", ONE_MINUS_B, ONE_MINUS_A);
-export const blendPlus = porterDuff("blendPlus", ONE, ONE);
+const premultiplyAlpha = (col) => vec4(mul($xyz(col), $w(col)), $w(col));
+const postmultiplyAlpha = (col) => vec4(div($xyz(col), $w(col)), $w(col));
+const ZERO = () => FLOAT0;
+const ONE = () => FLOAT1;
+const A = (a) => a;
+const B = (_, b) => b;
+const ONE_MINUS_A = (a) => sub(FLOAT1, a);
+const ONE_MINUS_B = (_, b) => sub(FLOAT1, b);
+const blendSrcOver = porterDuff("blendSrcOver", ONE, ONE_MINUS_A);
+const blendDestOver = porterDuff("blendDestOver", ONE_MINUS_B, ONE);
+const blendSrcIn = porterDuff("blendSrcIn", B, ZERO);
+const blendDestIn = porterDuff("blendDestIn", ZERO, A);
+const blendSrcOut = porterDuff("blendSrcOut", ONE_MINUS_B, ZERO);
+const blendDestOut = porterDuff("blendDestOut", ZERO, ONE_MINUS_A);
+const blendSrcAtop = porterDuff("blendSrcAtop", B, ONE_MINUS_A);
+const blendDestAtop = porterDuff("blendDestAtop", ONE_MINUS_B, A);
+const blendXor = porterDuff("blendXor", ONE_MINUS_B, ONE_MINUS_A);
+const blendPlus = porterDuff("blendPlus", ONE, ONE);
+export {
+  A,
+  B,
+  ONE,
+  ONE_MINUS_A,
+  ONE_MINUS_B,
+  ZERO,
+  blendDestAtop,
+  blendDestIn,
+  blendDestOut,
+  blendDestOver,
+  blendPlus,
+  blendSrcAtop,
+  blendSrcIn,
+  blendSrcOut,
+  blendSrcOver,
+  blendXor,
+  porterDuff,
+  postmultiplyAlpha,
+  premultiplyAlpha
+};

package/color/rgbe.js

@@ -5,19 +5,17 @@ import { INT0, VEC3_0, float, vec3 } from "@thi.ng/shader-ast/ast/lit";
 import { gt, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $w, $xyz } from "@thi.ng/shader-ast/ast/swizzle";
 import { exp2 } from "@thi.ng/shader-ast/builtin/math";
-/**
- * RGBE (Radiance HDR) to linear float RGB conversion. The input vec is supposed
- * to contain unsigned byte values, with the last component being the exponent.
- *
- * @remarks
- * Reference: https://en.wikipedia.org/wiki/RGBE_image_format
- *
- * Code based on:
- * https://github.com/box/hdrCompressor/blob/master/src/rgbe/rgbe.c
- *
- */
-export const decodeRGBE = defn(V3, "decodeRGBE", ["ivec4"], (col) => {
-    return [
-        ret(ternary(gt($w(col), INT0), mul(vec3($xyz(col)), exp2(float(sub($w(col), 136)))), VEC3_0)),
-    ];
+const decodeRGBE = defn(V3, "decodeRGBE", ["ivec4"], (col) => {
+  return [
+    ret(
+      ternary(
+        gt($w(col), INT0),
+        mul(vec3($xyz(col)), exp2(float(sub($w(col), 136)))),
+        VEC3_0
+      )
+    )
+  ];
 });
+export {
+  decodeRGBE
+};

package/fog/exp.js

@@ -4,13 +4,9 @@ import { FLOAT1 } from "@thi.ng/shader-ast/ast/lit";
 import { mul, neg, sub } from "@thi.ng/shader-ast/ast/ops";
 import { exp } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
-/**
- * Computes exponential fog factor [0..1], based on given fully
- * saturated fog distance and density.
- *
- * @param dist - float
- * @param density - float
- */
-export const fogExp = defn(F, "fogExp", [F, F], (dist, density) => [
-    ret(sub(FLOAT1, clamp01(exp(mul(neg(density), dist))))),
+const fogExp = defn(F, "fogExp", [F, F], (dist, density) => [
+  ret(sub(FLOAT1, clamp01(exp(mul(neg(density), dist)))))
 ]);
+export {
+  fogExp
+};

package/fog/exp2.js

@@ -5,16 +5,10 @@ import { FLOAT1 } from "@thi.ng/shader-ast/ast/lit";
 import { mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { exp2 } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
-/**
- * Similar to {@link fogExp}. Computes exponential fog factor [0..1], based on
- * given fully saturated fog distance and density. Uses
- * [`exp2()`](https://docs.thi.ng/umbrella/shader-ast/functions/exp2.html)
- * internally.
- *
- * @param dist - float
- * @param density - float
- */
-export const fogExp2 = defn(F, "fogExp2", [F, F], (dist, density) => [
-    assign(density, mul(density, dist)),
-    ret(sub(FLOAT1, clamp01(exp2(mul(mul(density, density), -Math.LOG2E))))),
+const fogExp2 = defn(F, "fogExp2", [F, F], (dist, density) => [
+  assign(density, mul(density, dist)),
+  ret(sub(FLOAT1, clamp01(exp2(mul(mul(density, density), -Math.LOG2E)))))
 ]);
+export {
+  fogExp2
+};

package/fog/linear.js

@@ -2,15 +2,9 @@ import { F } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { clamp01 } from "../math/clamp.js";
 import { fitNorm1 } from "../math/fit.js";
-/**
- * Computes linear fog factor [0..1], based on given fog min/max
- * distances.
- *
- * @param dist - float
- * @param start - float
- * @param end - float
- *
- */
-export const fogLinear = defn(F, "fogLinear", [F, F, F], (dist, start, end) => [
-    ret(clamp01(fitNorm1(dist, start, end))),
+const fogLinear = defn(F, "fogLinear", [F, F, F], (dist, start, end) => [
+  ret(clamp01(fitNorm1(dist, start, end)))
 ]);
+export {
+  fogLinear
+};

package/isec/point.js

@@ -5,19 +5,25 @@ import { add } 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 { distance, min, step } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Predicate function to check if given point `p` is inside the circle defined
- * by `pos` and `radius`.
- */
-export const isPointInCircle = defn("bool", null, [V2, V2, F], (p, pos, radius) => [ret(bool(step(distance(p, pos), radius)))]);
-/**
- * Predicate function to check if given point `p` is inside the axis-aligned
- * rect defined by `pos` and `size`. Branchless.
- */
-export const isPointInRect = defn("bool", null, [V2, V2, V2], (p, pos, size) => {
+const isPointInCircle = defn(
+  "bool",
+  null,
+  [V2, V2, F],
+  (p, pos, radius) => [ret(bool(step(distance(p, pos), radius)))]
+);
+const isPointInRect = defn(
+  "bool",
+  null,
+  [V2, V2, V2],
+  (p, pos, size) => {
     let q;
     return [
-        (q = sym(min(step(pos, p), step(p, add(pos, size))))),
-        ret(bool(min($x(q), $y(q)))),
+      q = sym(min(step(pos, p), step(p, add(pos, size)))),
+      ret(bool(min($x(q), $y(q))))
     ];
-});
+  }
+);
+export {
+  isPointInCircle,
+  isPointInRect
+};

package/light/lambert.js

@@ -2,32 +2,11 @@ import { FLOAT0 } from "@thi.ng/shader-ast/ast/lit";
 import { madd, mul } from "@thi.ng/shader-ast/ast/ops";
 import { dot, max } from "@thi.ng/shader-ast/builtin/math";
 import { fit1101 } from "../math/fit.js";
-/**
- * Inline function. Computes Lambert term, i.e. `max(dot(n, l), 0)`. Both
- * vectors must be pre-normalized.
- *
- * @param surfNormal - vec3
- * @param lightDir - vec3
- */
-export const lambert = (n, ldir) => max(dot(n, ldir), FLOAT0);
-/**
- * Inline function. Computes Half-Lambertian term. Both vectors must be
- * pre-normalized.
- *
- * https://developer.valvesoftware.com/wiki/Half_Lambert
- *
- * @param n -
- * @param ldir -
- */
-export const halfLambert = (n, ldir) => fit1101(dot(n, ldir));
-/**
- * Inline function. Computes:
- *
- * col = lambert * lightCol * diffuseCol + ambientCol
- *
- * @param lambertian - float
- * @param diffuseCol - vec3
- * @param lightCol - vec3
- * @param ambientCol - vec3
- */
-export const diffuseLighting = (lambertian, diffuse, light, ambient) => madd(mul(light, lambertian), diffuse, ambient);
+const lambert = (n, ldir) => max(dot(n, ldir), FLOAT0);
+const halfLambert = (n, ldir) => fit1101(dot(n, ldir));
+const diffuseLighting = (lambertian, diffuse, light, ambient) => madd(mul(light, lambertian), diffuse, ambient);
+export {
+  diffuseLighting,
+  halfLambert,
+  lambert
+};

package/light/trilight.js

@@ -4,21 +4,23 @@ import { FLOAT0, FLOAT1 } from "@thi.ng/shader-ast/ast/lit";
 import { add, mul, neg, sub } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { abs, dot, max } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Tom Forsyth's Trilight lighting model.
- *
- * {@link tomforsyth1000.github.io/papers/trilight/trilight.html}
- *
- * @param surfNormal - vec3
- * @param lightDir - vec3
- * @param col1 - vec3
- * @param col2 - vec3
- * @param col3 - vec3
- */
-export const trilight = defn(V3, "trilight", [V3, V3, V3, V3, V3], (n, l, c1, c2, c3) => {
+const trilight = defn(
+  V3,
+  "trilight",
+  [V3, V3, V3, V3, V3],
+  (n, l, c1, c2, c3) => {
     let d;
     return [
-        (d = sym(dot(n, l))),
-        ret(add(add(mul(c1, max(d, FLOAT0)), mul(c2, sub(FLOAT1, abs(d)))), mul(c3, max(dot(neg(n), l), FLOAT0)))),
+      d = sym(dot(n, l)),
+      ret(
+        add(
+          add(mul(c1, max(d, FLOAT0)), mul(c2, sub(FLOAT1, abs(d)))),
+          mul(c3, max(dot(neg(n), l), FLOAT0))
+        )
+      )
     ];
-});
+  }
+);
+export {
+  trilight
+};