shaders 2.3.69 → 2.3.71

package/dist/svelte/source/engine/Preview.svelte

@@ -0,0 +1,320 @@
+<script lang="ts">
+import { onMount } from 'svelte'
+
+import Shader from './Shader.svelte'
+// <<< SHADERS_PREVIEW_MAP:START >>>
+import AngularBlur from '../components/AngularBlur.svelte'
+import Ascii from '../components/Ascii.svelte'
+import Aurora from '../components/Aurora.svelte'
+import Beam from '../components/Beam.svelte'
+import Blob from '../components/Blob.svelte'
+import Blur from '../components/Blur.svelte'
+import BrightnessContrast from '../components/BrightnessContrast.svelte'
+import Bulge from '../components/Bulge.svelte'
+import CRTScreen from '../components/CRTScreen.svelte'
+import ChannelBlur from '../components/ChannelBlur.svelte'
+import Checkerboard from '../components/Checkerboard.svelte'
+import ChromaFlow from '../components/ChromaFlow.svelte'
+import ChromaticAberration from '../components/ChromaticAberration.svelte'
+import Circle from '../components/Circle.svelte'
+import ConcentricSpin from '../components/ConcentricSpin.svelte'
+import ContourLines from '../components/ContourLines.svelte'
+import CursorRipples from '../components/CursorRipples.svelte'
+import CursorTrail from '../components/CursorTrail.svelte'
+import DiffuseBlur from '../components/DiffuseBlur.svelte'
+import Dither from '../components/Dither.svelte'
+import DotGrid from '../components/DotGrid.svelte'
+import Duotone from '../components/Duotone.svelte'
+import FilmGrain from '../components/FilmGrain.svelte'
+import FloatingParticles from '../components/FloatingParticles.svelte'
+import FlowField from '../components/FlowField.svelte'
+import GlassTiles from '../components/GlassTiles.svelte'
+import Glitch from '../components/Glitch.svelte'
+import Glow from '../components/Glow.svelte'
+import Godrays from '../components/Godrays.svelte'
+import Grayscale from '../components/Grayscale.svelte'
+import Grid from '../components/Grid.svelte'
+import GridDistortion from '../components/GridDistortion.svelte'
+import Group from '../components/Group.svelte'
+import Halftone from '../components/Halftone.svelte'
+import HueShift from '../components/HueShift.svelte'
+import ImageTexture from '../components/ImageTexture.svelte'
+import Invert from '../components/Invert.svelte'
+import Kaleidoscope from '../components/Kaleidoscope.svelte'
+import LensFlare from '../components/LensFlare.svelte'
+import LinearBlur from '../components/LinearBlur.svelte'
+import LinearGradient from '../components/LinearGradient.svelte'
+import Liquify from '../components/Liquify.svelte'
+import Mirror from '../components/Mirror.svelte'
+import Perspective from '../components/Perspective.svelte'
+import Pixelate from '../components/Pixelate.svelte'
+import Plasma from '../components/Plasma.svelte'
+import PolarCoordinates from '../components/PolarCoordinates.svelte'
+import Posterize from '../components/Posterize.svelte'
+import ProgressiveBlur from '../components/ProgressiveBlur.svelte'
+import RadialGradient from '../components/RadialGradient.svelte'
+import RectangularCoordinates from '../components/RectangularCoordinates.svelte'
+import Ripples from '../components/Ripples.svelte'
+import Saturation from '../components/Saturation.svelte'
+import Sharpness from '../components/Sharpness.svelte'
+import Shatter from '../components/Shatter.svelte'
+import SimplexNoise from '../components/SimplexNoise.svelte'
+import SineWave from '../components/SineWave.svelte'
+import SolidColor from '../components/SolidColor.svelte'
+import Spherize from '../components/Spherize.svelte'
+import Spiral from '../components/Spiral.svelte'
+import Strands from '../components/Strands.svelte'
+import Stretch from '../components/Stretch.svelte'
+import Stripes from '../components/Stripes.svelte'
+import StudioBackground from '../components/StudioBackground.svelte'
+import Swirl from '../components/Swirl.svelte'
+import TiltShift from '../components/TiltShift.svelte'
+import Tint from '../components/Tint.svelte'
+import Tritone from '../components/Tritone.svelte'
+import Twirl from '../components/Twirl.svelte'
+import Vibrance from '../components/Vibrance.svelte'
+import VideoTexture from '../components/VideoTexture.svelte'
+import WaveDistortion from '../components/WaveDistortion.svelte'
+import WebcamTexture from '../components/WebcamTexture.svelte'
+import ZoomBlur from '../components/ZoomBlur.svelte'
+
+// --- Component Map ---
+
+const componentMap: Record<string, any> = {
+  AngularBlur,
+  Ascii,
+  Aurora,
+  Beam,
+  Blob,
+  Blur,
+  BrightnessContrast,
+  Bulge,
+  CRTScreen,
+  ChannelBlur,
+  Checkerboard,
+  ChromaFlow,
+  ChromaticAberration,
+  Circle,
+  ConcentricSpin,
+  ContourLines,
+  CursorRipples,
+  CursorTrail,
+  DiffuseBlur,
+  Dither,
+  DotGrid,
+  Duotone,
+  FilmGrain,
+  FloatingParticles,
+  FlowField,
+  GlassTiles,
+  Glitch,
+  Glow,
+  Godrays,
+  Grayscale,
+  Grid,
+  GridDistortion,
+  Group,
+  Halftone,
+  HueShift,
+  ImageTexture,
+  Invert,
+  Kaleidoscope,
+  LensFlare,
+  LinearBlur,
+  LinearGradient,
+  Liquify,
+  Mirror,
+  Perspective,
+  Pixelate,
+  Plasma,
+  PolarCoordinates,
+  Posterize,
+  ProgressiveBlur,
+  RadialGradient,
+  RectangularCoordinates,
+  Ripples,
+  Saturation,
+  Sharpness,
+  Shatter,
+  SimplexNoise,
+  SineWave,
+  SolidColor,
+  Spherize,
+  Spiral,
+  Strands,
+  Stretch,
+  Stripes,
+  StudioBackground,
+  Swirl,
+  TiltShift,
+  Tint,
+  Tritone,
+  Twirl,
+  Vibrance,
+  VideoTexture,
+  WaveDistortion,
+  WebcamTexture,
+  ZoomBlur,
+}
+// <<< SHADERS_PREVIEW_MAP:END >>>
+
+// --- Inlined Types ---
+
+interface ShaderComponent {
+  type: string
+  id?: string
+  props?: Record<string, any>
+  children?: ShaderComponent[]
+  blendMode?: string
+  opacity?: number
+  renderOrder?: number
+}
+
+interface ShaderDefinition {
+  components: ShaderComponent[]
+  structureVersion?: number
+  colorSpace?: 'p3-linear' | 'srgb'
+  devicePreview?: string
+}
+
+// --- Preview Decode Logic ---
+// No name mapping — preview definitions contain readable JSON.
+
+function xorCrypt(data: Uint8Array, key: string): Uint8Array {
+  const keyBytes = new TextEncoder().encode(key)
+  const result = new Uint8Array(data.length)
+  for (let i = 0; i < data.length; i++) {
+    result[i] = data[i] ^ keyBytes[i % keyBytes.length]
+  }
+  return result
+}
+
+function decodePreviewDefinition(encoded: string, key: string): ShaderDefinition {
+  const binaryString = atob(encoded)
+  const encrypted = new Uint8Array(binaryString.length)
+  for (let i = 0; i < binaryString.length; i++) {
+    encrypted[i] = binaryString.charCodeAt(i)
+  }
+  const decrypted = xorCrypt(encrypted, key)
+  const json = new TextDecoder().decode(decrypted)
+  try {
+    return JSON.parse(json)
+  } catch {
+    throw new Error('Failed to decode shader definition: invalid data or incorrect key')
+  }
+}
+
+// Fetch from API and decode response
+function fetchAndDecode(url: string, key: string): Promise<ShaderDefinition | null> {
+  return fetch(url)
+    .then(res => {
+      if (!res.ok) throw new Error(`Failed to fetch: ${res.status}`)
+      return res.json()
+    })
+    .then(data => {
+      const item = data.preset || data.shader
+      if (item?.definition && typeof item.definition === 'string') {
+        return decodePreviewDefinition(item.definition, key)
+      }
+      return null
+    })
+    .catch(err => {
+      console.error('[Shaders Preview] Failed to fetch preview:', err)
+      return null
+    })
+}
+
+// --- Props ---
+
+export let shader: string | undefined = undefined
+export let presetId: string | undefined = undefined
+export let apiBaseUrl: string = 'https://shaders.com'
+export let obfuscationKey: string = 'shaders-preview-key'
+export let watermarkText: string = 'Unlock your Shaders Pro license'
+export let watermarkLink: string = 'https://shaders.com/dashboard?pricing=true'
+export let style: string | undefined = undefined
+
+// --- Decode & Resolve ---
+
+let resolvedDefinition: ShaderDefinition | null = null
+let fetchedDefinition: ShaderDefinition | null = null
+let watermarkHovered = false
+
+// Fetch shader by token
+$: if (shader) {
+  fetchedDefinition = null
+  fetchAndDecode(`${apiBaseUrl}/api/preview/shader/${shader}`, obfuscationKey)
+    .then(def => { fetchedDefinition = def })
+} else if (!presetId) {
+  fetchedDefinition = null
+}
+
+// Fetch preset by ID
+$: if (presetId) {
+  fetchedDefinition = null
+  fetchAndDecode(`${apiBaseUrl}/api/preview/preset/${presetId}`, obfuscationKey)
+    .then(def => { fetchedDefinition = def })
+} else if (!shader) {
+  fetchedDefinition = null
+}
+
+$: resolvedDefinition = fetchedDefinition ?? null
+
+// --- Licensing Warning ---
+
+onMount(() => {
+  console.warn(
+    '[Shaders] Preview component is intended for use with a Shaders license. ' +
+    'Visit https://shaders.com for more information.'
+  )
+})
+
+</script>
+
+<script lang="ts" context="module">
+// Recursive component for rendering nested shader components
+import { default as RenderComponent } from './PreviewRenderComponent.svelte'
+</script>
+
+{#if resolvedDefinition}
+  <div class="shaders-preview" style="position: relative; width: 100%; height: 100%;{style ? ' ' + style : ''}" {...$$restProps}>
+    <Shader
+colorSpace={resolvedDefinition.colorSpace || 'p3-linear'}
+      isPreview={true}
+      enablePerformanceTracking={true}
+      style="width: 100%; height: 100%;"
+    >
+      {#each resolvedDefinition.components as config, index (config.id || `root_${index}_v${resolvedDefinition.structureVersion || 0}`)}
+        <RenderComponent
+          config={{ ...config, renderOrder: config.renderOrder ?? index }}
+          {componentMap}
+          structureVersion={resolvedDefinition.structureVersion}
+        />
+      {/each}
+    </Shader>
+    {#if watermarkText}
+      <a
+        href={watermarkLink}
+        target="_blank"
+        rel="noopener noreferrer"
+        style="
+          position: absolute;
+          bottom: 8px;
+          right: 12px;
+          font-size: 11px;
+          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+          color: {watermarkHovered ? 'rgba(255, 255, 255, 0.8)' : 'rgba(255, 255, 255, 0.5)'};
+          text-decoration: none;
+          pointer-events: auto;
+          z-index: 10;
+          text-shadow: 0 1px 3px rgba(0, 0, 0, 0.4);
+          transition: color 0.2s ease;
+        "
+        on:mouseenter={() => watermarkHovered = true}
+        on:mouseleave={() => watermarkHovered = false}
+      >
+        {watermarkText}
+      </a>
+    {/if}
+  </div>
+{/if}

package/dist/svelte/source/engine/PreviewRenderComponent.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">
+export let config: any
+export let componentMap: Record<string, any>
+export let structureVersion: number | undefined = undefined
+
+$: Component = componentMap[config.type]
+$: componentProps = config.props ? { ...config.props } : {}
+</script>
+
+{#if Component}
+  <svelte:component
+    this={Component}
+    id={config.id}
+    renderOrder={config.renderOrder}
+    {...componentProps}
+  >
+    {#if config.children}
+      {#each config.children as child, index (child.id || `child_${index}_v${structureVersion || 0}`)}
+        <svelte:self
+          config={{ ...child, renderOrder: child.renderOrder ?? index }}
+          {componentMap}
+          {structureVersion}
+        />
+      {/each}
+    {/if}
+  </svelte:component>
+{/if}

package/dist/svelte/source/engine/Shader.svelte

@@ -0,0 +1,263 @@
+<script lang="ts">
+  import { setContext, onMount, onDestroy } from 'svelte';
+  import { shaderRenderer } from '../../../core/index.js';
+  import { vec4 } from 'three/tsl';
+  import type { UniformsMap, BlendMode, NodeMetadata } from '../../../core/index.js';
+  import { shouldCollectTelemetry, isExternalUser, startTelemetry } from '../../../core/telemetry/index.js';
+  import { setColorSpaceMode } from '../../../core/utilities/transformations/index.js';
+
+  declare const __SHADERS_VERSION__: string;
+
+  interface Props {
+    disableTelemetry?: boolean;
+    colorSpace?: 'p3-linear' | 'srgb';
+    isPreview?: boolean;
+    children?: import('svelte').Snippet;
+    [key: string]: any;
+  }
+
+  const { disableTelemetry = false, colorSpace = 'p3-linear', isPreview = false, children, ...rest }: Props = $props();
+
+  // DOM references to the container and canvas
+  let containerRef: HTMLDivElement;
+  let canvasRef: HTMLCanvasElement;
+
+  // SSR guard — renderer and children are deferred until mount
+  let mounted = $state(false);
+
+  // Unique ID for this root component
+  const rootId = 'shader-root-' + Math.random().toString(36).substring(7);
+
+  // Renderer instance — created in onMount (deferred for SSR compatibility)
+  let rendererInstance: ReturnType<typeof shaderRenderer> | null = null;
+
+  // Telemetry collector reference for cleanup
+  let telemetryCollector: any = null;
+  let telemetryStartTimeout: number | null = null;
+  let shouldSendTelemetry: boolean | null = null;
+
+  // Set context for child components - provide parent ID
+  setContext('shaderParentId', rootId);
+
+  // Provide color space to child components (function getter for reactivity)
+  setContext('shaderColorSpace', () => colorSpace);
+
+  // Provide node registration function for child components
+  // Callbacks capture `rendererInstance` by reference — they see the live value after onMount sets it
+  setContext('shaderNodeRegister', (id: string, fragmentNodeFunc: any, parentId: string | null, metadata: any, uniforms: any = null, componentDef: any = null) => {
+    if (!rendererInstance) return
+    // If fragmentNodeFunc is null, the component is being unmounted, so remove it
+    if (fragmentNodeFunc === null) {
+      rendererInstance.removeNode(id);
+    } else {
+      rendererInstance.registerNode(id, fragmentNodeFunc, parentId, metadata, uniforms, componentDef);
+    }
+  });
+
+  // Provide optimized uniform update function
+  setContext('shaderUniformUpdate', (nodeId: string, uniformName: string, value: any) => {
+    if (!rendererInstance) return
+    rendererInstance.updateUniformValue(nodeId, uniformName, value);
+  });
+
+  // Provide optimized metadata update function
+  setContext('shaderMetadataUpdate', (nodeId: string, metadata: any) => {
+    if (!rendererInstance) return
+    rendererInstance.updateNodeMetadata(nodeId, metadata);
+  });
+
+  // Track visibility state
+  let wasVisible = false;
+  let visibilityObserver: IntersectionObserver | null = null;
+
+  // Wait for active rendering before starting telemetry collection
+  const startTelemetryWhenReady = () => {
+    const checkRendering = () => {
+      if (!rendererInstance) return
+      const stats = rendererInstance.getPerformanceStats();
+      if (stats.fps > 0) {
+        const version = typeof __SHADERS_VERSION__ !== 'undefined' ? __SHADERS_VERSION__ : 'unknown';
+        telemetryCollector = startTelemetry(
+          rendererInstance,
+          version,
+          disableTelemetry,
+          isPreview
+        );
+        if (telemetryCollector) {
+          telemetryCollector.start();
+        }
+        telemetryStartTimeout = null;
+      } else {
+        telemetryStartTimeout = window.setTimeout(checkRendering, 500);
+      }
+    };
+
+    telemetryStartTimeout = window.setTimeout(checkRendering, 500);
+  };
+
+  // Function to initialize renderer with visibility check
+  const initializeRenderer = async () => {
+    if (!canvasRef || !rendererInstance) return;
+
+    try {
+      // Check if renderer is already initialized to avoid double initialization
+      if (!rendererInstance.isInitialized()) {
+        await rendererInstance.initialize({
+          canvas: canvasRef,
+          colorSpace: colorSpace,
+        });
+      }
+
+      // Register the root node
+      rendererInstance.registerNode(
+        rootId,
+        ({ childNode }) => childNode || vec4(0, 0, 0, 0), // Root node that passes through children
+        null, // No parent (this is the root)
+        null, // No metadata to pass
+        {}
+      );
+
+      // Compute sampling decision once (includes random sampling roll)
+      if (shouldSendTelemetry === null) {
+        shouldSendTelemetry = isExternalUser() && shouldCollectTelemetry(disableTelemetry, isPreview);
+      }
+
+      if (shouldSendTelemetry && !telemetryCollector) {
+        startTelemetryWhenReady();
+      }
+
+    } catch (err) {
+      console.error('[Shader] Initialization failed:', err);
+      throw err;
+    }
+  };
+
+  // Setup visibility observer for container hide/show detection
+  const setupVisibilityObserver = () => {
+    if (!containerRef || visibilityObserver) return;
+
+    visibilityObserver = new IntersectionObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+
+      const rect = containerRef?.getBoundingClientRect();
+      const isCurrentlyVisible = entry.isIntersecting && rect && rect.width > 0 && rect.height > 0;
+      
+      if (isCurrentlyVisible && !wasVisible) {
+        // Canvas became visible - resume animation
+        if (rendererInstance?.isInitialized()) {
+          rendererInstance.startAnimation();
+          // Start telemetry if conditions are met and not already started
+          if (shouldSendTelemetry && !telemetryCollector && !telemetryStartTimeout) {
+            startTelemetryWhenReady();
+          }
+        } else {
+          // First time visible, need to initialize
+          initializeRenderer().catch(console.error);
+        }
+        wasVisible = true;
+      } else if (!isCurrentlyVisible && wasVisible) {
+        // Canvas became hidden - pause animation but keep renderer alive
+        rendererInstance?.stopAnimation();
+        wasVisible = false;
+      }
+    }, { threshold: 0 });
+
+    visibilityObserver.observe(containerRef);
+  };
+
+  // Initialize renderer on mount - with visibility awareness
+  onMount(async () => {
+    // Create the renderer instance (deferred from module scope for SSR compatibility)
+    rendererInstance = shaderRenderer();
+    mounted = true;
+
+    // Wait for Svelte to render the canvas + children before proceeding
+    await new Promise((resolve) => requestAnimationFrame(resolve));
+
+    if (!canvasRef || !containerRef) {
+      console.error('Canvas or container ref is null in Shader onMount');
+      return;
+    }
+
+    // Check if container is visible on mount
+    const rect = containerRef.getBoundingClientRect();
+    const isVisible = rect.width > 0 && rect.height > 0;
+
+    if (isVisible) {
+      // Container is visible, initialize immediately
+      await initializeRenderer();
+      wasVisible = true;
+    } else {
+      // Container is hidden, set up observer for when it becomes visible
+      wasVisible = false;
+    }
+
+    // Always set up observer to handle show/hide cycles
+    setupVisibilityObserver();
+  });
+
+  // Cleanup on component destroy
+  onDestroy(() => {
+    // Stop telemetry collection if active
+    if (telemetryCollector) {
+      telemetryCollector.stop();
+      telemetryCollector = null;
+    }
+
+    // Clear telemetry start timeout if pending
+    if (telemetryStartTimeout !== null) {
+      clearTimeout(telemetryStartTimeout);
+      telemetryStartTimeout = null;
+    }
+
+    // Clean up visibility observer
+    if (visibilityObserver) {
+      visibilityObserver.disconnect();
+      visibilityObserver = null;
+    }
+
+    // Only cleanup if renderer was initialized
+    if (rendererInstance?.isInitialized()) {
+      try {
+        rendererInstance.cleanup();
+      } catch (err) {
+        console.warn('[Shader] Error during cleanup:', err);
+      }
+    }
+  });
+
+  // Watch for colorSpace changes and update the renderer
+  // Skip the initial execution since colorSpace is set during initialization
+  let isFirstEffect = true;
+  $effect(() => {
+    // Access colorSpace to make it reactive
+    const currentColorSpace = colorSpace;
+    
+    if (isFirstEffect) {
+      isFirstEffect = false;
+      return;
+    }
+    
+    if (rendererInstance?.isInitialized()) {
+      // Update the global color space mode
+      setColorSpaceMode(currentColorSpace);
+      
+      // Force re-initialization to apply color space changes
+      rendererInstance.cleanup();
+      initializeRenderer().catch(console.error);
+    }
+  });
+
+</script>
+
+<div class="shader" bind:this={containerRef} {...rest}>
+  {#if mounted}
+    <canvas
+      data-renderer="shaders"
+      bind:this={canvasRef}
+      style="width: 100%; height: 100%; display: block;"
+    ></canvas>
+    {@render children?.()}
+  {/if}
+</div>

package/dist/svelte/source/index.js

@@ -0,0 +1,77 @@
+export { default as AngularBlur } from './components/AngularBlur.svelte';
+export { default as Ascii } from './components/Ascii.svelte';
+export { default as Aurora } from './components/Aurora.svelte';
+export { default as Beam } from './components/Beam.svelte';
+export { default as Blob } from './components/Blob.svelte';
+export { default as Blur } from './components/Blur.svelte';
+export { default as BrightnessContrast } from './components/BrightnessContrast.svelte';
+export { default as Bulge } from './components/Bulge.svelte';
+export { default as CRTScreen } from './components/CRTScreen.svelte';
+export { default as ChannelBlur } from './components/ChannelBlur.svelte';
+export { default as Checkerboard } from './components/Checkerboard.svelte';
+export { default as ChromaFlow } from './components/ChromaFlow.svelte';
+export { default as ChromaticAberration } from './components/ChromaticAberration.svelte';
+export { default as Circle } from './components/Circle.svelte';
+export { default as ConcentricSpin } from './components/ConcentricSpin.svelte';
+export { default as ContourLines } from './components/ContourLines.svelte';
+export { default as CursorRipples } from './components/CursorRipples.svelte';
+export { default as CursorTrail } from './components/CursorTrail.svelte';
+export { default as DiffuseBlur } from './components/DiffuseBlur.svelte';
+export { default as Dither } from './components/Dither.svelte';
+export { default as DotGrid } from './components/DotGrid.svelte';
+export { default as Duotone } from './components/Duotone.svelte';
+export { default as FilmGrain } from './components/FilmGrain.svelte';
+export { default as FloatingParticles } from './components/FloatingParticles.svelte';
+export { default as FlowField } from './components/FlowField.svelte';
+export { default as GlassTiles } from './components/GlassTiles.svelte';
+export { default as Glitch } from './components/Glitch.svelte';
+export { default as Glow } from './components/Glow.svelte';
+export { default as Godrays } from './components/Godrays.svelte';
+export { default as Grayscale } from './components/Grayscale.svelte';
+export { default as Grid } from './components/Grid.svelte';
+export { default as GridDistortion } from './components/GridDistortion.svelte';
+export { default as Group } from './components/Group.svelte';
+export { default as Halftone } from './components/Halftone.svelte';
+export { default as HueShift } from './components/HueShift.svelte';
+export { default as ImageTexture } from './components/ImageTexture.svelte';
+export { default as Invert } from './components/Invert.svelte';
+export { default as Kaleidoscope } from './components/Kaleidoscope.svelte';
+export { default as LensFlare } from './components/LensFlare.svelte';
+export { default as LinearBlur } from './components/LinearBlur.svelte';
+export { default as LinearGradient } from './components/LinearGradient.svelte';
+export { default as Liquify } from './components/Liquify.svelte';
+export { default as Mirror } from './components/Mirror.svelte';
+export { default as Perspective } from './components/Perspective.svelte';
+export { default as Pixelate } from './components/Pixelate.svelte';
+export { default as Plasma } from './components/Plasma.svelte';
+export { default as PolarCoordinates } from './components/PolarCoordinates.svelte';
+export { default as Posterize } from './components/Posterize.svelte';
+export { default as ProgressiveBlur } from './components/ProgressiveBlur.svelte';
+export { default as RadialGradient } from './components/RadialGradient.svelte';
+export { default as RectangularCoordinates } from './components/RectangularCoordinates.svelte';
+export { default as Ripples } from './components/Ripples.svelte';
+export { default as Saturation } from './components/Saturation.svelte';
+export { default as Sharpness } from './components/Sharpness.svelte';
+export { default as Shatter } from './components/Shatter.svelte';
+export { default as SimplexNoise } from './components/SimplexNoise.svelte';
+export { default as SineWave } from './components/SineWave.svelte';
+export { default as SolidColor } from './components/SolidColor.svelte';
+export { default as Spherize } from './components/Spherize.svelte';
+export { default as Spiral } from './components/Spiral.svelte';
+export { default as Strands } from './components/Strands.svelte';
+export { default as Stretch } from './components/Stretch.svelte';
+export { default as Stripes } from './components/Stripes.svelte';
+export { default as StudioBackground } from './components/StudioBackground.svelte';
+export { default as Swirl } from './components/Swirl.svelte';
+export { default as TiltShift } from './components/TiltShift.svelte';
+export { default as Tint } from './components/Tint.svelte';
+export { default as Tritone } from './components/Tritone.svelte';
+export { default as Twirl } from './components/Twirl.svelte';
+export { default as Vibrance } from './components/Vibrance.svelte';
+export { default as VideoTexture } from './components/VideoTexture.svelte';
+export { default as WaveDistortion } from './components/WaveDistortion.svelte';
+export { default as WebcamTexture } from './components/WebcamTexture.svelte';
+export { default as ZoomBlur } from './components/ZoomBlur.svelte';
+export { default as Shader } from './engine/Shader.svelte';
+export { default as Preview } from './engine/Preview.svelte';
+export { generatePresetCode } from '../utils/generatePresetCode.js';