@firecms/neat 0.7.1 → 0.8.0

package/dist/shaders.js

@@ -72,7 +72,10 @@ export const vertexShaderSource = `void main() {
 
     v_color = color;
 
-    // 4. VERTEX POSITION
+    // 4. FRESNEL (rim glow)
+    // (Calculated in fragment shader using displacement slope approximation)
+
+    // 5. VERTEX POSITION
     vec3 newPosition = position + normal * v_displacement_amount * u_wave_amplitude;
     gl_Position = projectionMatrix * modelViewMatrix * vec4(newPosition, 1.0);
     v_new_position = gl_Position;
@@ -94,31 +97,32 @@ float fbm(vec3 x) {
     return value;
 }
 
+// Branchless HSL to RGB for iridescence
+vec3 hsl2rgb(float h, float s, float l) {
+    vec3 rgb = clamp(abs(mod(h * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);
+    return l + s * (rgb - 0.5) * (1.0 - abs(2.0 * l - 1.0));
+}
+
 void main() {
     vec2 finalUv = vFlowUv;
     
     vec3 baseColor;
 
     if (u_enable_procedural_texture > 0.5) {
-        // Calculate flow field distance for ease effect
         vec2 ppp = -1.0 + 2.0 * finalUv;
         ppp += 0.1 * cos((1.5 * u_flow_scale) * ppp.yx + 1.1 * u_time + vec2(0.1, 1.1));
         ppp += 0.1 * cos((2.3 * u_flow_scale) * ppp.yx + 1.3 * u_time + vec2(3.2, 3.4));
         ppp += 0.1 * cos((2.2 * u_flow_scale) * ppp.yx + 1.7 * u_time + vec2(1.8, 5.2));
         ppp += u_flow_distortion_a * cos((u_flow_distortion_b * u_flow_scale) * ppp.yx + 1.4 * u_time + vec2(6.3, 3.9));
-        float r = length(ppp); // Flow distance
+        float r = length(ppp);
         
-        // Ease blending: 0 = topographic (flow), 1 = image (UV)
         float vx = (finalUv.x * u_texture_ease) + (r * (1.0 - u_texture_ease));
         float vy = (finalUv.y * u_texture_ease) + (0.0 * (1.0 - u_texture_ease));
         vec2 texUv = vec2(vx, vy);
 
-        // PARALLAX SCROLLING
-        // We manually apply a smaller offset here to make the texture lag behind
-        float parallaxFactor = 0.25; // 25% speed of the color mixing
+        float parallaxFactor = 0.25;
         texUv.y -= (u_y_offset * u_y_offset_color_multiplier / u_plane_height) * parallaxFactor;
-
-        texUv *= 1.5; // Tiling scale
+        texUv *= 1.5;
 
         vec4 texSample = texture2D(u_procedural_texture, texUv);
         baseColor = texSample.rgb;
@@ -128,24 +132,70 @@ void main() {
 
     vec3 color = baseColor;
 
+    // === DOMAIN WARPING (simplified: 3 fbm calls instead of 5) ===
+    if (u_domain_warp_enabled > 0.5) {
+        vec3 p = vec3(finalUv * u_domain_warp_scale, u_time * 0.15);
+        vec2 q = vec2(fbm(p), fbm(p + vec3(5.2, 1.3, 0.0)));
+        float f = fbm(p + vec3(4.0 * q, 0.0));
+        vec3 warpColor = color * (1.0 + f * 0.8 * u_domain_warp_intensity);
+        float pattern = clamp(f * f * f + 0.6 * f * f + 0.5 * f, 0.0, 1.0);
+        color = mix(color, warpColor * (0.6 + pattern * 0.8), u_domain_warp_intensity * 0.7);
+    }
+
     // Post-processing
     color += v_displacement_amount * u_highlights;
-    // Replace pow() with direct multiplication to avoid negative base undefined behavior in GLSL
     float shadowFactor = 1.0 - v_displacement_amount;
     color -= shadowFactor * shadowFactor * u_shadows;
     color = saturation(color, 1.0 + u_saturation);
     color = color * u_brightness;
 
-    // Grain
-    vec2 noiseCoords = gl_FragCoord.xy / u_grain_scale;
+    // === IRIDESCENCE ===
+    if (u_iridescence_enabled > 0.5) {
+        float hue = fract(v_displacement_amount * 0.5 + 0.5 + u_time * u_iridescence_speed * 0.05);
+        vec3 iriColor = hsl2rgb(hue, 0.8, 0.6);
+        color = mix(color, iriColor, u_iridescence_intensity * abs(v_displacement_amount) * 0.6);
+    }
+
+    // === FRESNEL (Rim glow) ===
+    if (u_fresnel_enabled > 0.5) {
+        float slope = 1.0 - abs(v_displacement_amount);
+        float fresnel = pow(max(slope, 0.0), u_fresnel_power);
+        color += u_fresnel_color * fresnel * u_fresnel_intensity;
+    }
+
+    // === VIGNETTE ===
+    if (u_vignette_intensity > 0.0) {
+        float dist = length(vUv - vec2(0.5));
+        float vig = smoothstep(u_vignette_radius, u_vignette_radius * 0.3, dist);
+        color *= mix(1.0, vig, u_vignette_intensity);
+    }
+
+    // === FAKE BLOOM ===
+    if (u_bloom_intensity > 0.0) {
+        float luma = dot(color, vec3(0.2126, 0.7152, 0.0722));
+        float bloomMask = smoothstep(u_bloom_threshold, 1.0, luma);
+        color += color * bloomMask * u_bloom_intensity;
+    }
+
+    // === CHROMATIC ABERRATION ===
+    if (u_chromatic_aberration > 0.0) {
+        float caAmount = u_chromatic_aberration * 0.008;
+        float dist = length(vUv - vec2(0.5));
+        float rShift = v_displacement_amount + caAmount * dist;
+        float bShift = v_displacement_amount - caAmount * dist;
+        color.r *= 1.0 + rShift * caAmount * 10.0;
+        color.b *= 1.0 - bShift * caAmount * 10.0;
+    }
+
+    // Grain (use cheap hash noise instead of expensive fbm when static)
     float grain = 0.0;
-    
-    // Completely bypass expensive noise generation if grain is disabled
     if (u_grain_intensity > 0.0) {
+        vec2 noiseCoords = gl_FragCoord.xy / u_grain_scale;
         if (u_grain_speed != 0.0) {
             grain = fbm(vec3(noiseCoords, u_time * u_grain_speed));
         } else {
-            grain = fbm(vec3(noiseCoords, 0.0));
+            // Static grain: use cheap hash instead of fbm
+            grain = random(noiseCoords) - 0.5;
         }
 
         grain = grain * 0.5 + 0.5;
@@ -204,6 +254,12 @@ uniform float u_flow_distortion_b;
 uniform float u_flow_scale;
 uniform float u_flow_ease;
 uniform float u_flow_enabled;
+
+// Fresnel uniforms
+uniform float u_fresnel_enabled;
+uniform float u_fresnel_power;
+uniform float u_fresnel_intensity;
+uniform vec3 u_fresnel_color;
 `;
 }
 export function buildFragUniforms() {
@@ -215,6 +271,7 @@ varying vec3 v_color;
 varying float v_displacement_amount;
 
 uniform float u_time;
+uniform vec2 u_resolution;
 uniform float u_plane_height;
 
 uniform float u_shadows;
@@ -238,6 +295,35 @@ uniform float u_flow_scale;
 uniform sampler2D u_procedural_texture;
 uniform float u_enable_procedural_texture;
 uniform float u_texture_ease;
+
+// Domain warping uniforms
+uniform float u_domain_warp_enabled;
+uniform float u_domain_warp_intensity;
+uniform float u_domain_warp_scale;
+
+// Vignette uniforms
+uniform float u_vignette_intensity;
+uniform float u_vignette_radius;
+
+// Fresnel uniforms (fragment side)
+uniform float u_fresnel_enabled;
+uniform float u_fresnel_power;
+uniform float u_fresnel_intensity;
+uniform vec3 u_fresnel_color;
+
+
+
+// Iridescence uniforms
+uniform float u_iridescence_enabled;
+uniform float u_iridescence_intensity;
+uniform float u_iridescence_speed;
+
+// Bloom uniforms
+uniform float u_bloom_intensity;
+uniform float u_bloom_threshold;
+
+// Chromatic aberration
+uniform float u_chromatic_aberration;
 `;
 }
 export function buildNoise() {

package/dist/shaders.js.map

@@ -1 +1 @@
-{"version":3,"file":"shaders.js","sourceRoot":"","sources":["../src/shaders.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+EjC,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFnC,CAAC;AAEF,MAAM,UAAU,iBAAiB;IAC7B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CV,CAAC;AACF,CAAC;AAED,MAAM,UAAU,iBAAiB;IAC7B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BV,CAAC;AACF,CAAC;AAED,MAAM,UAAU,UAAU;IACtB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwJV,CAAC;AACF,CAAC;AAED,MAAM,UAAU,mBAAmB;IAC/B,OAAO;;;;;;CAMV,CAAC;AACF,CAAC"}
+{"version":3,"file":"shaders.js","sourceRoot":"","sources":["../src/shaders.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFjC,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HnC,CAAC;AAEF,MAAM,UAAU,iBAAiB;IAC7B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDV,CAAC;AACF,CAAC;AAED,MAAM,UAAU,iBAAiB;IAC7B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DV,CAAC;AACF,CAAC;AAED,MAAM,UAAU,UAAU;IACtB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwJV,CAAC;AACF,CAAC;AAED,MAAM,UAAU,mBAAmB;IAC/B,OAAO;;;;;;CAMV,CAAC;AACF,CAAC"}

package/dist/types.d.ts

@@ -41,6 +41,21 @@ export type NeatConfig = {
     textureShapeCircles?: number;
     textureShapeBars?: number;
     textureShapeSquiggles?: number;
+    domainWarpEnabled?: boolean;
+    domainWarpIntensity?: number;
+    domainWarpScale?: number;
+    vignetteIntensity?: number;
+    vignetteRadius?: number;
+    fresnelEnabled?: boolean;
+    fresnelPower?: number;
+    fresnelIntensity?: number;
+    fresnelColor?: string;
+    iridescenceEnabled?: boolean;
+    iridescenceIntensity?: number;
+    iridescenceSpeed?: number;
+    bloomIntensity?: number;
+    bloomThreshold?: number;
+    chromaticAberration?: number;
 };
 export type NeatColor = {
     color: string;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@firecms/neat",
   "description": "Beautiful 3D gradients for your website",
   "access": "public",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "main": "./dist/index.umd.js",
   "module": "./dist/index.es.js",
   "types": "dist/index.d.ts",

package/src/NeatGradient.ts

@@ -35,67 +35,7 @@ export interface WebGLState {
 }
 
 
-
-export type NeatConfig = {
-    resolution?: number;
-    speed?: number;
-    horizontalPressure?: number;
-    verticalPressure?: number;
-    waveFrequencyX?: number;
-    waveFrequencyY?: number;
-    waveAmplitude?: number;
-    highlights?: number;
-    shadows?: number;
-    colorSaturation?: number;
-    colorBrightness?: number;
-    colors: NeatColor[];
-    colorBlending?: number;
-    grainScale?: number;
-    grainIntensity?: number;
-    grainSparsity?: number;
-    grainSpeed?: number;
-    wireframe?: boolean;
-    backgroundColor?: string;
-    backgroundAlpha?: number;
-    yOffset?: number;
-    yOffsetWaveMultiplier?: number;
-    yOffsetColorMultiplier?: number;
-    yOffsetFlowMultiplier?: number;
-    // Flow field parameters
-    flowDistortionA?: number;
-    flowDistortionB?: number;
-    flowScale?: number;
-    flowEase?: number;
-    flowEnabled?: boolean;
-
-    // Texture generation
-    enableProceduralTexture?: boolean;
-    textureVoidLikelihood?: number;
-    textureVoidWidthMin?: number;
-    textureVoidWidthMax?: number;
-    textureBandDensity?: number;
-    textureColorBlending?: number;
-    textureSeed?: number;
-    textureEase?: number;
-    proceduralBackgroundColor?: string;
-    textureShapeTriangles?: number;
-    textureShapeCircles?: number;
-    textureShapeBars?: number;
-    textureShapeSquiggles?: number;
-};
-
-export type NeatColor = {
-    color: string;
-    enabled: boolean;
-    /**
-     * Value from 0 to 1
-     */
-    influence?: number;
-}
-
-export type NeatController = {
-    destroy: () => void;
-}
+import { NeatConfig, NeatColor, NeatController } from "./types";
 
 export class NeatGradient implements NeatController {
 
@@ -147,6 +87,29 @@ export class NeatGradient implements NeatController {
     private _textureColorBlending: number = 0.01;
     private _textureSeed: number = 333;
     private _textureEase: number = 0.5;
+
+    // New effects
+    private _domainWarpEnabled: boolean = false;
+    private _domainWarpIntensity: number = 0.5;
+    private _domainWarpScale: number = 1.0;
+
+    private _vignetteIntensity: number = 0.5;
+    private _vignetteRadius: number = 0.8;
+
+    private _fresnelEnabled: boolean = false;
+    private _fresnelPower: number = 2.0;
+    private _fresnelIntensity: number = 0.5;
+    private _fresnelColor: string = "#FFFFFF";
+    private _fresnelColorRgb: [number, number, number] = [1, 1, 1];
+
+    private _iridescenceEnabled: boolean = false;
+    private _iridescenceIntensity: number = 0.5;
+    private _iridescenceSpeed: number = 1.0;
+
+    private _bloomIntensity: number = 0;
+    private _bloomThreshold: number = 0.7;
+    private _chromaticAberration: number = 0;
+
     private _proceduralTexture: WebGLTexture | null = null;
     private _proceduralBackgroundColor: string = "#000000";
 
@@ -225,6 +188,22 @@ export class NeatGradient implements NeatController {
             textureShapeCircles = 15,
             textureShapeBars = 15,
             textureShapeSquiggles = 10,
+
+            domainWarpEnabled = false,
+            domainWarpIntensity = 0.5,
+            domainWarpScale = 1.0,
+            vignetteIntensity = 0.5,
+            vignetteRadius = 0.8,
+            fresnelEnabled = false,
+            fresnelPower = 2.0,
+            fresnelIntensity = 0.5,
+            fresnelColor = "#FFFFFF",
+            iridescenceEnabled = false,
+            iridescenceIntensity = 0.5,
+            iridescenceSpeed = 1.0,
+            bloomIntensity = 0.0,
+            bloomThreshold = 0.7,
+            chromaticAberration = 0.0,
         } = config;
 
 
@@ -282,6 +261,21 @@ export class NeatGradient implements NeatController {
         this._textureShapeBars = textureShapeBars;
         this._textureShapeSquiggles = textureShapeSquiggles;
 
+        this.domainWarpEnabled = domainWarpEnabled;
+        this.domainWarpIntensity = domainWarpIntensity;
+        this.domainWarpScale = domainWarpScale;
+        this.vignetteIntensity = vignetteIntensity;
+        this.vignetteRadius = vignetteRadius;
+        this.fresnelEnabled = fresnelEnabled;
+        this.fresnelPower = fresnelPower;
+        this.fresnelIntensity = fresnelIntensity;
+        this.fresnelColor = fresnelColor;
+        this.iridescenceEnabled = iridescenceEnabled;
+        this.iridescenceIntensity = iridescenceIntensity;
+        this.iridescenceSpeed = iridescenceSpeed;
+        this.bloomIntensity = bloomIntensity;
+        this.bloomThreshold = bloomThreshold;
+        this.chromaticAberration = chromaticAberration;
 
         this.glState = this._initScene(resolution);
 
@@ -342,6 +336,26 @@ export class NeatGradient implements NeatController {
                     gl.uniform1f(locations.uniforms['u_enable_procedural_texture'], this._enableProceduralTexture ? 1.0 : 0.0);
                     gl.uniform1f(locations.uniforms['u_texture_ease'], this._textureEase);
 
+                    gl.uniform1f(locations.uniforms['u_domain_warp_enabled'], this._domainWarpEnabled ? 1.0 : 0.0);
+                    gl.uniform1f(locations.uniforms['u_domain_warp_intensity'], this._domainWarpIntensity);
+                    gl.uniform1f(locations.uniforms['u_domain_warp_scale'], this._domainWarpScale);
+
+                    gl.uniform1f(locations.uniforms['u_vignette_intensity'], this._vignetteIntensity);
+                    gl.uniform1f(locations.uniforms['u_vignette_radius'], this._vignetteRadius);
+
+                    gl.uniform1f(locations.uniforms['u_fresnel_enabled'], this._fresnelEnabled ? 1.0 : 0.0);
+                    gl.uniform1f(locations.uniforms['u_fresnel_power'], this._fresnelPower);
+                    gl.uniform1f(locations.uniforms['u_fresnel_intensity'], this._fresnelIntensity);
+                    gl.uniform3fv(locations.uniforms['u_fresnel_color'], this._fresnelColorRgb);
+
+                    gl.uniform1f(locations.uniforms['u_iridescence_enabled'], this._iridescenceEnabled ? 1.0 : 0.0);
+                    gl.uniform1f(locations.uniforms['u_iridescence_intensity'], this._iridescenceIntensity);
+                    gl.uniform1f(locations.uniforms['u_iridescence_speed'], this._iridescenceSpeed);
+
+                    gl.uniform1f(locations.uniforms['u_bloom_intensity'], this._bloomIntensity);
+                    gl.uniform1f(locations.uniforms['u_bloom_threshold'], this._bloomThreshold);
+                    gl.uniform1f(locations.uniforms['u_chromatic_aberration'], this._chromaticAberration);
+
                     this._uniformsDirty = false;
                 }
 
@@ -893,7 +907,12 @@ export class NeatGradient implements NeatController {
             "u_flow_distortion_a", "u_flow_distortion_b", "u_flow_scale", "u_flow_ease", "u_flow_enabled",
             "u_y_offset", "u_y_offset_wave_multiplier", "u_y_offset_color_multiplier", "u_y_offset_flow_multiplier",
 
-            "u_procedural_texture", "u_enable_procedural_texture", "u_texture_ease", "u_saturation", "u_brightness", "u_color_blending"
+            "u_procedural_texture", "u_enable_procedural_texture", "u_texture_ease", "u_saturation", "u_brightness", "u_color_blending",
+            "u_domain_warp_enabled", "u_domain_warp_intensity", "u_domain_warp_scale",
+            "u_vignette_intensity", "u_vignette_radius",
+            "u_fresnel_enabled", "u_fresnel_power", "u_fresnel_intensity", "u_fresnel_color",
+            "u_iridescence_enabled", "u_iridescence_intensity", "u_iridescence_speed",
+            "u_bloom_intensity", "u_bloom_threshold", "u_chromatic_aberration"
         ];
 
         const locations: WebGLState["locations"] = {
@@ -1135,7 +1154,97 @@ export class NeatGradient implements NeatController {
         return tex;
     }
 
-
+    set domainWarpEnabled(enabled: boolean) {
+        if (this._domainWarpEnabled !== enabled) {
+            this._domainWarpEnabled = enabled;
+            this._uniformsDirty = true;
+        }
+    }
+    set domainWarpIntensity(intensity: number) {
+        if (this._domainWarpIntensity !== intensity) {
+            this._domainWarpIntensity = intensity;
+            this._uniformsDirty = true;
+        }
+    }
+    set domainWarpScale(scale: number) {
+        if (this._domainWarpScale !== scale) {
+            this._domainWarpScale = scale;
+            this._uniformsDirty = true;
+        }
+    }
+    set vignetteIntensity(intensity: number) {
+        if (this._vignetteIntensity !== intensity) {
+            this._vignetteIntensity = intensity;
+            this._uniformsDirty = true;
+        }
+    }
+    set vignetteRadius(radius: number) {
+        if (this._vignetteRadius !== radius) {
+            this._vignetteRadius = radius;
+            this._uniformsDirty = true;
+        }
+    }
+    set fresnelEnabled(enabled: boolean) {
+        if (this._fresnelEnabled !== enabled) {
+            this._fresnelEnabled = enabled;
+            this._uniformsDirty = true;
+        }
+    }
+    set fresnelPower(power: number) {
+        if (this._fresnelPower !== power) {
+            this._fresnelPower = power;
+            this._uniformsDirty = true;
+        }
+    }
+    set fresnelIntensity(intensity: number) {
+        if (this._fresnelIntensity !== intensity) {
+            this._fresnelIntensity = intensity;
+            this._uniformsDirty = true;
+        }
+    }
+    set fresnelColor(fresnelColor: string) {
+        if (this._fresnelColor !== fresnelColor) {
+            this._fresnelColor = fresnelColor;
+            this._fresnelColorRgb = this._hexToRgb(fresnelColor);
+            this._uniformsDirty = true;
+        }
+    }
+    set iridescenceEnabled(enabled: boolean) {
+        if (this._iridescenceEnabled !== enabled) {
+            this._iridescenceEnabled = enabled;
+            this._uniformsDirty = true;
+        }
+    }
+    set iridescenceIntensity(intensity: number) {
+        if (this._iridescenceIntensity !== intensity) {
+            this._iridescenceIntensity = intensity;
+            this._uniformsDirty = true;
+        }
+    }
+    set iridescenceSpeed(speed: number) {
+        if (this._iridescenceSpeed !== speed) {
+            this._iridescenceSpeed = speed;
+            this._uniformsDirty = true;
+        }
+    }
+    set bloomIntensity(intensity: number) {
+        if (this._bloomIntensity !== intensity) {
+            this._bloomIntensity = intensity;
+            this._uniformsDirty = true;
+        }
+    }
+    set bloomThreshold(threshold: number) {
+        if (this._bloomThreshold !== threshold) {
+            this._bloomThreshold = threshold;
+            this._uniformsDirty = true;
+        }
+    }
+    set chromaticAberration(aberration: number) {
+        if (this._chromaticAberration !== aberration) {
+            this._chromaticAberration = aberration;
+            this._uniformsDirty = true;
+        }
+    }
 }
 
 

package/src/index.ts

@@ -1 +1,2 @@
 export * from "./NeatGradient";
+export * from "./types";