shaders-oneshot 0.0.81-shared.1

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+/** The core Shader Mount class. Pass it a parent element and a fragment shader to get started. */
+export { ShaderMount, isPaperShaderElement } from './shader-mount.js';
+export type { PaperShaderElement, ShaderMotionParams, ShaderMountUniforms, ShaderPreset, ImageShaderPreset, WebGlContextMode, } from './shader-mount.js';
+/** Shader sizing options and uniforms */
+export { defaultObjectSizing, defaultPatternSizing, ShaderFitOptions, type ShaderFit, type ShaderSizingParams, type ShaderSizingUniforms, } from './shader-sizing.js';
+/** A flowing interplay of color spots, moving along distinct trajectories and transformed by organic distortion */
+export { meshGradientFragmentShader, meshGradientMeta, type MeshGradientParams, type MeshGradientUniforms, } from './shaders/mesh-gradient.js';
+/** Radial multi-colored gradient shaped with layered noise for a natural, smoky aesthetic */
+export { smokeRingMeta, smokeRingFragmentShader, type SmokeRingParams, type SmokeRingUniforms, } from './shaders/smoke-ring.js';
+/** A glowing, web-like structure of fluid lines and soft intersections. Great for creating atmospheric, organic-yet-futuristic visuals */
+export { neuroNoiseFragmentShader, type NeuroNoiseParams, type NeuroNoiseUniforms } from './shaders/neuro-noise.js';
+/** Animated multi-color dots pattern with each dot orbiting around its cell center. Supports up to 40 colors and various shape and motion controls. Great for playful, dynamic backgrounds and UI textures */
+export { dotOrbitMeta, dotOrbitFragmentShader, type DotOrbitParams, type DotOrbitUniforms, } from './shaders/dot-orbit.js';
+/** Static grid pattern made of circles, diamonds, squares or triangles */
+export { dotGridFragmentShader, DotGridShapes, type DotGridShape, type DotGridParams, type DotGridUniforms, } from './shaders/dot-grid.js';
+/** A multi-color gradient mapped into smooth, animated curves, delivering a sleek, futuristic visual */
+export { simplexNoiseMeta, simplexNoiseFragmentShader, type SimplexNoiseParams, type SimplexNoiseUniforms, } from './shaders/simplex-noise.js';
+/** Up to 20 gooey blobs moving around the center and merging into smooth organic shapes */
+export { metaballsMeta, metaballsFragmentShader, type MetaballsParams, type MetaballsUniforms, } from './shaders/metaballs.js';
+/** Animated 3D Perlin noise with exposed controls */
+export { perlinNoiseFragmentShader, type PerlinNoiseParams, type PerlinNoiseUniforms } from './shaders/perlin-noise.js';
+/** Anti-aliased animated Voronoi pattern with smooth and customizable edges */
+export { voronoiMeta, voronoiFragmentShader, type VoronoiParams, type VoronoiUniforms } from './shaders/voronoi.js';
+/** Static line pattern configurable into textures ranging from sharp zigzags to smooth flowing waves */
+export { wavesFragmentShader, type WavesParams, type WavesUniforms } from './shaders/waves.js';
+/** Animated color fields warped by noise and swirls, applied over base patterns (checks, stripes, or split edge). Blends up to 10 colors with adjustable distribution, softness, distortion, and swirl. Great for fluid, smoky, or marbled effects */
+export { warpMeta, warpFragmentShader, WarpPatterns, type WarpParams, type WarpUniforms, type WarpPattern, } from './shaders/warp.js';
+/** Animated rays of light radiating from the center, blended with up to 5 colors. The rays are adjustable by size, density, brightness and center glow. Great for dramatic backgrounds, logo reveals, and VFX like energy bursts or sun shafts */
+export { godRaysMeta, godRaysFragmentShader, type GodRaysParams, type GodRaysUniforms } from './shaders/god-rays.js';
+/** A single-colored animated spiral that morphs across a wide range of shapes - from crisp, thin-lined geometry to flowing whirlpool forms and wavy, abstract rings */
+export { spiralFragmentShader, type SpiralParams, type SpiralUniforms } from './shaders/spiral.js';
+/** Animated bands of color twisting and bending, producing spirals, arcs, and flowing circular patterns */
+export { swirlMeta, swirlFragmentShader, type SwirlParams, type SwirlUniforms } from './shaders/swirl.js';
+/** Animated 2-color dithering over with multiple pattern sources (noise, warp, dots, waves, ripple, swirl, sphere) */
+export { ditheringFragmentShader, DitheringShapes, DitheringTypes, type DitheringParams, type DitheringUniforms, type DitheringShape, type DitheringType, } from './shaders/dithering.js';
+/** Multi-color gradients with grainy, noise-textured distortion available in 7 animated abstract forms */
+export { grainGradientFragmentShader, grainGradientMeta, GrainGradientShapes, type GrainGradientParams, type GrainGradientUniforms, type GrainGradientShape, } from './shaders/grain-gradient.js';
+/** Luminous trails of color merging into a glowing gradient frame */
+export { pulsingBorderMeta, pulsingBorderFragmentShader, PulsingBorderAspectRatios, type PulsingBorderParams, type PulsingBorderUniforms, type PulsingBorderAspectRatio, } from './shaders/pulsing-border.js';
+/** Glowing translucent 3D panels rotating around a central axis */
+export { colorPanelsFragmentShader, colorPanelsMeta, type ColorPanelsParams, type ColorPanelsUniforms, } from './shaders/color-panels.js';
+/** Multi-point mesh gradients with up to 10 color spots, enhanced by two-direction warping, adjustable blend sharpness, and grain controls. Perfect for elegant wallpapers and atmospheric backdrops */
+export { staticMeshGradientFragmentShader, staticMeshGradientMeta, type StaticMeshGradientParams, type StaticMeshGradientUniforms, } from './shaders/static-mesh-gradient.js';
+/** Radial gradient with up to 10 blended colors, featuring advanced focal point control, shape distortion, and grain effects */
+export { staticRadialGradientFragmentShader, staticRadialGradientMeta, type StaticRadialGradientParams, type StaticRadialGradientUniforms, } from './shaders/static-radial-gradient.js';
+/** A static texture built from multiple noise layers, usable for a realistic paper and cardboard surfaces or generating abstract patterns. Can be used as a image filter or as a texture */
+export { paperTextureFragmentShader, paperTextureMeta, type PaperTextureParams, type PaperTextureUniforms, } from './shaders/paper-texture.js';
+/** Water-like surface distortion with natural caustic realism. Works as an image filter or animated texture without image */
+export { waterFragmentShader, type WaterParams, type WaterUniforms } from './shaders/water.js';
+/** Fluted glass image filter transforms an image into streaked, ribbed distortions, giving a mix of clarity and obscurity */
+export { flutedGlassFragmentShader, GlassDistortionShapes, GlassGridShapes, type GlassDistortionShape, type GlassGridShape, type FlutedGlassParams, type FlutedGlassUniforms, } from './shaders/fluted-glass.js';
+/** A dithering image filter with support for 4 dithering modes and multiple color palettes (2-color, 3-color, and multicolor options, using either predefined colors or ones sampled directly from the original image) */
+export { imageDitheringFragmentShader, type ImageDitheringParams, type ImageDitheringUniforms, } from './shaders/image-dithering.js';
+/** Lens Distortion image filter that separates an image into shifting color layers, recreating the chromatic aberration of a lens, and warps the image geometry with barrel or pincushion curvature */
+export { lensDistortionFragmentShader, lensDistortionMeta, type LensDistortionParams, type LensDistortionUniforms, } from './shaders/lens-distortion.js';
+/** A glowing gradient of colors flowing through an input image. The effect creates a smoothly animated wave of intensity across the image */
+export { heatmapMeta, heatmapFragmentShader, toProcessedHeatmap, type HeatmapParams, type HeatmapUniforms, } from './shaders/heatmap.js';
+/** Futuristic liquid metal material applied to uploaded logo or one of pre-defined abstract shape */
+export { liquidMetalFragmentShader, LiquidMetalShapes, toProcessedLiquidMetal, type LiquidMetalShape, type LiquidMetalParams, type LiquidMetalUniforms, } from './shaders/liquid-metal.js';
+/** A halftone-dot image filter featuring customizable grids, color palettes, and dot styles */
+export { HalftoneDotsTypes, HalftoneDotsGrids, halftoneDotsFragmentShader, type HalftoneDotsParams, type HalftoneDotsUniforms, type HalftoneDotsType, type HalftoneDotsGrid, } from './shaders/halftone-dots.js';
+/** A halftone CMYK classic algo */
+export { HalftoneCmykTypes, halftoneCmykFragmentShader, type HalftoneCmykParams, type HalftoneCmykUniforms, type HalftoneCmykType, } from './shaders/halftone-cmyk.js';
+/** Animated color fields running around a glassy logo shape */
+export { gemSmokeMeta, gemSmokeFragmentShader, toProcessedGemSmoke, GemSmokeShapes, type GemSmokeShape, type GemSmokeParams, type GemSmokeUniforms, } from './shaders/gem-smoke.js';
+export { getShaderColorFromString } from './get-shader-color-from-string.js';
+export { getShaderNoiseTexture } from './get-shader-noise-texture.js';
+export { emptyPixel } from './empty-pixel.js';

package/dist/index.js

@@ -0,0 +1,194 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                    Paper Shaders                    *
+ *       https://github.com/paper-design/shaders       *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+import { ShaderMount, isPaperShaderElement } from "./shader-mount.js";
+import {
+  defaultObjectSizing,
+  defaultPatternSizing,
+  ShaderFitOptions
+} from "./shader-sizing.js";
+import {
+  meshGradientFragmentShader,
+  meshGradientMeta
+} from "./shaders/mesh-gradient.js";
+import {
+  smokeRingMeta,
+  smokeRingFragmentShader
+} from "./shaders/smoke-ring.js";
+import { neuroNoiseFragmentShader } from "./shaders/neuro-noise.js";
+import {
+  dotOrbitMeta,
+  dotOrbitFragmentShader
+} from "./shaders/dot-orbit.js";
+import {
+  dotGridFragmentShader,
+  DotGridShapes
+} from "./shaders/dot-grid.js";
+import {
+  simplexNoiseMeta,
+  simplexNoiseFragmentShader
+} from "./shaders/simplex-noise.js";
+import {
+  metaballsMeta,
+  metaballsFragmentShader
+} from "./shaders/metaballs.js";
+import { perlinNoiseFragmentShader } from "./shaders/perlin-noise.js";
+import { voronoiMeta, voronoiFragmentShader } from "./shaders/voronoi.js";
+import { wavesFragmentShader } from "./shaders/waves.js";
+import {
+  warpMeta,
+  warpFragmentShader,
+  WarpPatterns
+} from "./shaders/warp.js";
+import { godRaysMeta, godRaysFragmentShader } from "./shaders/god-rays.js";
+import { spiralFragmentShader } from "./shaders/spiral.js";
+import { swirlMeta, swirlFragmentShader } from "./shaders/swirl.js";
+import {
+  ditheringFragmentShader,
+  DitheringShapes,
+  DitheringTypes
+} from "./shaders/dithering.js";
+import {
+  grainGradientFragmentShader,
+  grainGradientMeta,
+  GrainGradientShapes
+} from "./shaders/grain-gradient.js";
+import {
+  pulsingBorderMeta,
+  pulsingBorderFragmentShader,
+  PulsingBorderAspectRatios
+} from "./shaders/pulsing-border.js";
+import {
+  colorPanelsFragmentShader,
+  colorPanelsMeta
+} from "./shaders/color-panels.js";
+import {
+  staticMeshGradientFragmentShader,
+  staticMeshGradientMeta
+} from "./shaders/static-mesh-gradient.js";
+import {
+  staticRadialGradientFragmentShader,
+  staticRadialGradientMeta
+} from "./shaders/static-radial-gradient.js";
+import {
+  paperTextureFragmentShader,
+  paperTextureMeta
+} from "./shaders/paper-texture.js";
+import { waterFragmentShader } from "./shaders/water.js";
+import {
+  flutedGlassFragmentShader,
+  GlassDistortionShapes,
+  GlassGridShapes
+} from "./shaders/fluted-glass.js";
+import {
+  imageDitheringFragmentShader
+} from "./shaders/image-dithering.js";
+import {
+  lensDistortionFragmentShader,
+  lensDistortionMeta
+} from "./shaders/lens-distortion.js";
+import {
+  heatmapMeta,
+  heatmapFragmentShader,
+  toProcessedHeatmap
+} from "./shaders/heatmap.js";
+import {
+  liquidMetalFragmentShader,
+  LiquidMetalShapes,
+  toProcessedLiquidMetal
+} from "./shaders/liquid-metal.js";
+import {
+  HalftoneDotsTypes,
+  HalftoneDotsGrids,
+  halftoneDotsFragmentShader
+} from "./shaders/halftone-dots.js";
+import {
+  HalftoneCmykTypes,
+  halftoneCmykFragmentShader
+} from "./shaders/halftone-cmyk.js";
+import {
+  gemSmokeMeta,
+  gemSmokeFragmentShader,
+  toProcessedGemSmoke,
+  GemSmokeShapes
+} from "./shaders/gem-smoke.js";
+import { getShaderColorFromString } from "./get-shader-color-from-string.js";
+import { getShaderNoiseTexture } from "./get-shader-noise-texture.js";
+import { emptyPixel } from "./empty-pixel.js";
+export {
+  DitheringShapes,
+  DitheringTypes,
+  DotGridShapes,
+  GemSmokeShapes,
+  GlassDistortionShapes,
+  GlassGridShapes,
+  GrainGradientShapes,
+  HalftoneCmykTypes,
+  HalftoneDotsGrids,
+  HalftoneDotsTypes,
+  LiquidMetalShapes,
+  PulsingBorderAspectRatios,
+  ShaderFitOptions,
+  ShaderMount,
+  WarpPatterns,
+  colorPanelsFragmentShader,
+  colorPanelsMeta,
+  defaultObjectSizing,
+  defaultPatternSizing,
+  ditheringFragmentShader,
+  dotGridFragmentShader,
+  dotOrbitFragmentShader,
+  dotOrbitMeta,
+  emptyPixel,
+  flutedGlassFragmentShader,
+  gemSmokeFragmentShader,
+  gemSmokeMeta,
+  getShaderColorFromString,
+  getShaderNoiseTexture,
+  godRaysFragmentShader,
+  godRaysMeta,
+  grainGradientFragmentShader,
+  grainGradientMeta,
+  halftoneCmykFragmentShader,
+  halftoneDotsFragmentShader,
+  heatmapFragmentShader,
+  heatmapMeta,
+  imageDitheringFragmentShader,
+  isPaperShaderElement,
+  lensDistortionFragmentShader,
+  lensDistortionMeta,
+  liquidMetalFragmentShader,
+  meshGradientFragmentShader,
+  meshGradientMeta,
+  metaballsFragmentShader,
+  metaballsMeta,
+  neuroNoiseFragmentShader,
+  paperTextureFragmentShader,
+  paperTextureMeta,
+  perlinNoiseFragmentShader,
+  pulsingBorderFragmentShader,
+  pulsingBorderMeta,
+  simplexNoiseFragmentShader,
+  simplexNoiseMeta,
+  smokeRingFragmentShader,
+  smokeRingMeta,
+  spiralFragmentShader,
+  staticMeshGradientFragmentShader,
+  staticMeshGradientMeta,
+  staticRadialGradientFragmentShader,
+  staticRadialGradientMeta,
+  swirlFragmentShader,
+  swirlMeta,
+  toProcessedGemSmoke,
+  toProcessedHeatmap,
+  toProcessedLiquidMetal,
+  voronoiFragmentShader,
+  voronoiMeta,
+  warpFragmentShader,
+  warpMeta,
+  waterFragmentShader,
+  wavesFragmentShader
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["/** The core Shader Mount class. Pass it a parent element and a fragment shader to get started. */\r\nexport { ShaderMount, isPaperShaderElement } from './shader-mount.js';\r\nexport type {\r\n  PaperShaderElement,\r\n  ShaderMotionParams,\r\n  ShaderMountUniforms,\r\n  ShaderPreset,\r\n  ImageShaderPreset,\r\n  WebGlContextMode,\r\n} from './shader-mount.js';\r\n\r\n/** Shader sizing options and uniforms */\r\nexport {\r\n  defaultObjectSizing,\r\n  defaultPatternSizing,\r\n  ShaderFitOptions,\r\n  type ShaderFit,\r\n  type ShaderSizingParams,\r\n  type ShaderSizingUniforms,\r\n} from './shader-sizing.js';\r\n\r\n/** A flowing interplay of color spots, moving along distinct trajectories and transformed by organic distortion */\r\nexport {\r\n  meshGradientFragmentShader,\r\n  meshGradientMeta,\r\n  type MeshGradientParams,\r\n  type MeshGradientUniforms,\r\n} from './shaders/mesh-gradient.js';\r\n\r\n/** Radial multi-colored gradient shaped with layered noise for a natural, smoky aesthetic */\r\nexport {\r\n  smokeRingMeta,\r\n  smokeRingFragmentShader,\r\n  type SmokeRingParams,\r\n  type SmokeRingUniforms,\r\n} from './shaders/smoke-ring.js';\r\n\r\n/** A glowing, web-like structure of fluid lines and soft intersections. Great for creating atmospheric, organic-yet-futuristic visuals */\r\nexport { neuroNoiseFragmentShader, type NeuroNoiseParams, type NeuroNoiseUniforms } from './shaders/neuro-noise.js';\r\n\r\n/** Animated multi-color dots pattern with each dot orbiting around its cell center. Supports up to 40 colors and various shape and motion controls. Great for playful, dynamic backgrounds and UI textures */\r\nexport {\r\n  dotOrbitMeta,\r\n  dotOrbitFragmentShader,\r\n  type DotOrbitParams,\r\n  type DotOrbitUniforms,\r\n} from './shaders/dot-orbit.js';\r\n\r\n/** Static grid pattern made of circles, diamonds, squares or triangles */\r\nexport {\r\n  dotGridFragmentShader,\r\n  DotGridShapes,\r\n  type DotGridShape,\r\n  type DotGridParams,\r\n  type DotGridUniforms,\r\n} from './shaders/dot-grid.js';\r\n\r\n/** A multi-color gradient mapped into smooth, animated curves, delivering a sleek, futuristic visual */\r\nexport {\r\n  simplexNoiseMeta,\r\n  simplexNoiseFragmentShader,\r\n  type SimplexNoiseParams,\r\n  type SimplexNoiseUniforms,\r\n} from './shaders/simplex-noise.js';\r\n\r\n/** Up to 20 gooey blobs moving around the center and merging into smooth organic shapes */\r\nexport {\r\n  metaballsMeta,\r\n  metaballsFragmentShader,\r\n  type MetaballsParams,\r\n  type MetaballsUniforms,\r\n} from './shaders/metaballs.js';\r\n\r\n/** Animated 3D Perlin noise with exposed controls */\r\nexport { perlinNoiseFragmentShader, type PerlinNoiseParams, type PerlinNoiseUniforms } from './shaders/perlin-noise.js';\r\n\r\n/** Anti-aliased animated Voronoi pattern with smooth and customizable edges */\r\nexport { voronoiMeta, voronoiFragmentShader, type VoronoiParams, type VoronoiUniforms } from './shaders/voronoi.js';\r\n\r\n/** Static line pattern configurable into textures ranging from sharp zigzags to smooth flowing waves */\r\nexport { wavesFragmentShader, type WavesParams, type WavesUniforms } from './shaders/waves.js';\r\n\r\n/** Animated color fields warped by noise and swirls, applied over base patterns (checks, stripes, or split edge). Blends up to 10 colors with adjustable distribution, softness, distortion, and swirl. Great for fluid, smoky, or marbled effects */\r\nexport {\r\n  warpMeta,\r\n  warpFragmentShader,\r\n  WarpPatterns,\r\n  type WarpParams,\r\n  type WarpUniforms,\r\n  type WarpPattern,\r\n} from './shaders/warp.js';\r\n\r\n/** Animated rays of light radiating from the center, blended with up to 5 colors. The rays are adjustable by size, density, brightness and center glow. Great for dramatic backgrounds, logo reveals, and VFX like energy bursts or sun shafts */\r\nexport { godRaysMeta, godRaysFragmentShader, type GodRaysParams, type GodRaysUniforms } from './shaders/god-rays.js';\r\n\r\n/** A single-colored animated spiral that morphs across a wide range of shapes - from crisp, thin-lined geometry to flowing whirlpool forms and wavy, abstract rings */\r\nexport { spiralFragmentShader, type SpiralParams, type SpiralUniforms } from './shaders/spiral.js';\r\n\r\n/** Animated bands of color twisting and bending, producing spirals, arcs, and flowing circular patterns */\r\nexport { swirlMeta, swirlFragmentShader, type SwirlParams, type SwirlUniforms } from './shaders/swirl.js';\r\n\r\n/** Animated 2-color dithering over with multiple pattern sources (noise, warp, dots, waves, ripple, swirl, sphere) */\r\nexport {\r\n  ditheringFragmentShader,\r\n  DitheringShapes,\r\n  DitheringTypes,\r\n  type DitheringParams,\r\n  type DitheringUniforms,\r\n  type DitheringShape,\r\n  type DitheringType,\r\n} from './shaders/dithering.js';\r\n\r\n/** Multi-color gradients with grainy, noise-textured distortion available in 7 animated abstract forms */\r\nexport {\r\n  grainGradientFragmentShader,\r\n  grainGradientMeta,\r\n  GrainGradientShapes,\r\n  type GrainGradientParams,\r\n  type GrainGradientUniforms,\r\n  type GrainGradientShape,\r\n} from './shaders/grain-gradient.js';\r\n\r\n/** Luminous trails of color merging into a glowing gradient frame */\r\nexport {\r\n  pulsingBorderMeta,\r\n  pulsingBorderFragmentShader,\r\n  PulsingBorderAspectRatios,\r\n  type PulsingBorderParams,\r\n  type PulsingBorderUniforms,\r\n  type PulsingBorderAspectRatio,\r\n} from './shaders/pulsing-border.js';\r\n\r\n/** Glowing translucent 3D panels rotating around a central axis */\r\nexport {\r\n  colorPanelsFragmentShader,\r\n  colorPanelsMeta,\r\n  type ColorPanelsParams,\r\n  type ColorPanelsUniforms,\r\n} from './shaders/color-panels.js';\r\n\r\n/** Multi-point mesh gradients with up to 10 color spots, enhanced by two-direction warping, adjustable blend sharpness, and grain controls. Perfect for elegant wallpapers and atmospheric backdrops */\r\nexport {\r\n  staticMeshGradientFragmentShader,\r\n  staticMeshGradientMeta,\r\n  type StaticMeshGradientParams,\r\n  type StaticMeshGradientUniforms,\r\n} from './shaders/static-mesh-gradient.js';\r\n\r\n/** Radial gradient with up to 10 blended colors, featuring advanced focal point control, shape distortion, and grain effects */\r\nexport {\r\n  staticRadialGradientFragmentShader,\r\n  staticRadialGradientMeta,\r\n  type StaticRadialGradientParams,\r\n  type StaticRadialGradientUniforms,\r\n} from './shaders/static-radial-gradient.js';\r\n\r\n/** A static texture built from multiple noise layers, usable for a realistic paper and cardboard surfaces or generating abstract patterns. Can be used as a image filter or as a texture */\r\nexport {\r\n  paperTextureFragmentShader,\r\n  paperTextureMeta,\r\n  type PaperTextureParams,\r\n  type PaperTextureUniforms,\r\n} from './shaders/paper-texture.js';\r\n\r\n/** Water-like surface distortion with natural caustic realism. Works as an image filter or animated texture without image */\r\nexport { waterFragmentShader, type WaterParams, type WaterUniforms } from './shaders/water.js';\r\n\r\n/** Fluted glass image filter transforms an image into streaked, ribbed distortions, giving a mix of clarity and obscurity */\r\nexport {\r\n  flutedGlassFragmentShader,\r\n  GlassDistortionShapes,\r\n  GlassGridShapes,\r\n  type GlassDistortionShape,\r\n  type GlassGridShape,\r\n  type FlutedGlassParams,\r\n  type FlutedGlassUniforms,\r\n} from './shaders/fluted-glass.js';\r\n\r\n/** A dithering image filter with support for 4 dithering modes and multiple color palettes (2-color, 3-color, and multicolor options, using either predefined colors or ones sampled directly from the original image) */\r\nexport {\r\n  imageDitheringFragmentShader,\r\n  type ImageDitheringParams,\r\n  type ImageDitheringUniforms,\r\n} from './shaders/image-dithering.js';\r\n\r\n/** Lens Distortion image filter that separates an image into shifting color layers, recreating the chromatic aberration of a lens, and warps the image geometry with barrel or pincushion curvature */\r\nexport {\r\n  lensDistortionFragmentShader,\r\n  lensDistortionMeta,\r\n  type LensDistortionParams,\r\n  type LensDistortionUniforms,\r\n} from './shaders/lens-distortion.js';\r\n\r\n/** A glowing gradient of colors flowing through an input image. The effect creates a smoothly animated wave of intensity across the image */\r\nexport {\r\n  heatmapMeta,\r\n  heatmapFragmentShader,\r\n  toProcessedHeatmap,\r\n  type HeatmapParams,\r\n  type HeatmapUniforms,\r\n} from './shaders/heatmap.js';\r\n\r\n/** Futuristic liquid metal material applied to uploaded logo or one of pre-defined abstract shape */\r\nexport {\r\n  liquidMetalFragmentShader,\r\n  LiquidMetalShapes,\r\n  toProcessedLiquidMetal,\r\n  type LiquidMetalShape,\r\n  type LiquidMetalParams,\r\n  type LiquidMetalUniforms,\r\n} from './shaders/liquid-metal.js';\r\n\r\n/** A halftone-dot image filter featuring customizable grids, color palettes, and dot styles */\r\nexport {\r\n  HalftoneDotsTypes,\r\n  HalftoneDotsGrids,\r\n  halftoneDotsFragmentShader,\r\n  type HalftoneDotsParams,\r\n  type HalftoneDotsUniforms,\r\n  type HalftoneDotsType,\r\n  type HalftoneDotsGrid,\r\n} from './shaders/halftone-dots.js';\r\n\r\n/** A halftone CMYK classic algo */\r\nexport {\r\n  HalftoneCmykTypes,\r\n  halftoneCmykFragmentShader,\r\n  type HalftoneCmykParams,\r\n  type HalftoneCmykUniforms,\r\n  type HalftoneCmykType,\r\n} from './shaders/halftone-cmyk.js';\r\n\r\n/** Animated color fields running around a glassy logo shape */\r\nexport {\r\n  gemSmokeMeta,\r\n  gemSmokeFragmentShader,\r\n  toProcessedGemSmoke,\r\n  GemSmokeShapes,\r\n  type GemSmokeShape,\r\n  type GemSmokeParams,\r\n  type GemSmokeUniforms,\r\n} from './shaders/gem-smoke.js';\r\n\r\n// ----- Utils ----- //\r\nexport { getShaderColorFromString } from './get-shader-color-from-string.js';\r\nexport { getShaderNoiseTexture } from './get-shader-noise-texture.js';\r\nexport { emptyPixel } from './empty-pixel.js';\r\n"],
+  "mappings": ";;;;;AACA,SAAS,aAAa,4BAA4B;AAWlD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAGP,SAAS,gCAAgF;AAGzF;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAIK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAGP,SAAS,iCAAmF;AAG5F,SAAS,aAAa,6BAAuE;AAG7F,SAAS,2BAAiE;AAG1E;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AAGP,SAAS,aAAa,6BAAuE;AAG7F,SAAS,4BAAoE;AAG7E,SAAS,WAAW,2BAAiE;AAGrF;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAKK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAGP,SAAS,2BAAiE;AAG1E;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAKK;AAGP;AAAA,EACE;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAKK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,OAIK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AAGP,SAAS,gCAAgC;AACzC,SAAS,6BAA6B;AACtC,SAAS,kBAAkB;",
+  "names": []
+}

package/dist/shader-color-spaces.d.ts

@@ -0,0 +1,6 @@
+export declare const ShaderColorSpaces: {
+    readonly rgb: 0;
+    readonly oklch: 1;
+};
+export type ShaderColorSpace = keyof typeof ShaderColorSpaces;
+export declare const declareOklchTransforms = "\n\n// magic numbers (and magic could be better tbh)\n#define OKLCH_CHROMA_THRESHOLD .001\n#define OKLCH_HUE_NEUTRALIZER - 2.\n\nvec3 srgbToLinear(vec3 srgb) {\n  return pow(srgb, vec3(2.2));\n}\n\nvec3 linearToSrgb(vec3 linear) {\n  return pow(linear, vec3(1.0 / 2.2));\n}\n\nvec3 LrgbToOklab(vec3 rgb) {\n  float L = pow(0.4122214708 * rgb.r + 0.5363325363 * rgb.g + 0.0514459929 * rgb.b, 1.0 / 3.0);\n  float M = pow(0.2119034982 * rgb.r + 0.6806995451 * rgb.g + 0.1073969566 * rgb.b, 1.0 / 3.0);\n  float S = pow(0.0883024619 * rgb.r + 0.2817188376 * rgb.g + 0.6299787005 * rgb.b, 1.0 / 3.0);\n  return vec3(\n    0.2104542553 * L + 0.793617785 * M - 0.0040720468 * S,\n    1.9779984951 * L - 2.428592205 * M + 0.4505937099 * S,\n    0.0259040371 * L + 0.7827717662 * M - 0.808675766 * S\n  );\n}\n\nvec3 OklabToLrgb(vec3 oklab) {\n  float L = oklab.x;\n  float a = oklab.y;\n  float b = oklab.z;\n\n  float l_ = L + 0.3963377774 * a + 0.2158037573 * b;\n  float m_ = L - 0.1055613458 * a - 0.0638541728 * b;\n  float s_ = L - 0.0894841775 * a - 1.291485548 * b;\n\n  float l = l_ * l_ * l_;\n  float m = m_ * m_ * m_;\n  float s = s_ * s_ * s_;\n\n  return vec3(\n    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,\n    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,\n    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s\n  );\n}\n\nvec3 oklabToOklch(vec3 oklab) {\n  float C = length(oklab.yz);\n  float H = atan(oklab.z, oklab.y);\n  if (C < OKLCH_CHROMA_THRESHOLD) {\n    H = OKLCH_HUE_NEUTRALIZER;\n  }\n  return vec3(oklab.x, C, H);\n}\n\nvec3 oklchToOklab(vec3 oklch) {\n  float a = oklch.y * cos(oklch.z);\n  float b = oklch.y * sin(oklch.z);\n  return vec3(oklch.x, a, b);\n}\n\nfloat mixHue(float h1, float h2, float mixer) {\n  float delta = mod(h2 - h1 + PI, TWO_PI) - PI;\n  return h1 + mixer * delta;\n}\n\nvec3 srgbToOklab(vec3 rgb) {\n  return oklabToOklch(LrgbToOklab(srgbToLinear(rgb)));\n}\n\nvec3 oklabToSrgb(vec3 oklab) {\n  return linearToSrgb(OklabToLrgb(oklchToOklab(oklab)));\n}\n\nvec3 mixOklabVector(vec3 color1, vec3 color2, float mixer) {\n  color1.x = mix(color1.x, color2.x, mixer);\n  color1.y = mix(color1.y, color2.y, mixer);\n  if (color1.y > OKLCH_CHROMA_THRESHOLD && color2.y > OKLCH_CHROMA_THRESHOLD) {\n    color1.z = mixHue(color1.z, color2.z, mixer);\n  }\n  return color1;\n}\n";

package/dist/shader-color-spaces.js

@@ -0,0 +1,96 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                    Paper Shaders                    *
+ *       https://github.com/paper-design/shaders       *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+const ShaderColorSpaces = {
+  rgb: 0,
+  oklch: 1
+};
+const declareOklchTransforms = `
+
+// magic numbers (and magic could be better tbh)
+#define OKLCH_CHROMA_THRESHOLD .001
+#define OKLCH_HUE_NEUTRALIZER - 2.
+
+vec3 srgbToLinear(vec3 srgb) {
+  return pow(srgb, vec3(2.2));
+}
+
+vec3 linearToSrgb(vec3 linear) {
+  return pow(linear, vec3(1.0 / 2.2));
+}
+
+vec3 LrgbToOklab(vec3 rgb) {
+  float L = pow(0.4122214708 * rgb.r + 0.5363325363 * rgb.g + 0.0514459929 * rgb.b, 1.0 / 3.0);
+  float M = pow(0.2119034982 * rgb.r + 0.6806995451 * rgb.g + 0.1073969566 * rgb.b, 1.0 / 3.0);
+  float S = pow(0.0883024619 * rgb.r + 0.2817188376 * rgb.g + 0.6299787005 * rgb.b, 1.0 / 3.0);
+  return vec3(
+    0.2104542553 * L + 0.793617785 * M - 0.0040720468 * S,
+    1.9779984951 * L - 2.428592205 * M + 0.4505937099 * S,
+    0.0259040371 * L + 0.7827717662 * M - 0.808675766 * S
+  );
+}
+
+vec3 OklabToLrgb(vec3 oklab) {
+  float L = oklab.x;
+  float a = oklab.y;
+  float b = oklab.z;
+
+  float l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+  float m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+  float s_ = L - 0.0894841775 * a - 1.291485548 * b;
+
+  float l = l_ * l_ * l_;
+  float m = m_ * m_ * m_;
+  float s = s_ * s_ * s_;
+
+  return vec3(
+    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  );
+}
+
+vec3 oklabToOklch(vec3 oklab) {
+  float C = length(oklab.yz);
+  float H = atan(oklab.z, oklab.y);
+  if (C < OKLCH_CHROMA_THRESHOLD) {
+    H = OKLCH_HUE_NEUTRALIZER;
+  }
+  return vec3(oklab.x, C, H);
+}
+
+vec3 oklchToOklab(vec3 oklch) {
+  float a = oklch.y * cos(oklch.z);
+  float b = oklch.y * sin(oklch.z);
+  return vec3(oklch.x, a, b);
+}
+
+float mixHue(float h1, float h2, float mixer) {
+  float delta = mod(h2 - h1 + PI, TWO_PI) - PI;
+  return h1 + mixer * delta;
+}
+
+vec3 srgbToOklab(vec3 rgb) {
+  return oklabToOklch(LrgbToOklab(srgbToLinear(rgb)));
+}
+
+vec3 oklabToSrgb(vec3 oklab) {
+  return linearToSrgb(OklabToLrgb(oklchToOklab(oklab)));
+}
+
+vec3 mixOklabVector(vec3 color1, vec3 color2, float mixer) {
+  color1.x = mix(color1.x, color2.x, mixer);
+  color1.y = mix(color1.y, color2.y, mixer);
+  if (color1.y > OKLCH_CHROMA_THRESHOLD && color2.y > OKLCH_CHROMA_THRESHOLD) {
+    color1.z = mixHue(color1.z, color2.z, mixer);
+  }
+  return color1;
+}
+`;
+export {
+  ShaderColorSpaces,
+  declareOklchTransforms
+};
+//# sourceMappingURL=shader-color-spaces.js.map

package/dist/shader-color-spaces.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/shader-color-spaces.ts"],
+  "sourcesContent": ["export const ShaderColorSpaces = {\r\n  rgb: 0,\r\n  oklch: 1,\r\n} as const;\r\n\r\nexport type ShaderColorSpace = keyof typeof ShaderColorSpaces;\r\n\r\nexport const declareOklchTransforms = `\r\n\r\n// magic numbers (and magic could be better tbh)\r\n#define OKLCH_CHROMA_THRESHOLD .001\r\n#define OKLCH_HUE_NEUTRALIZER - 2.\r\n\r\nvec3 srgbToLinear(vec3 srgb) {\r\n  return pow(srgb, vec3(2.2));\r\n}\r\n\r\nvec3 linearToSrgb(vec3 linear) {\r\n  return pow(linear, vec3(1.0 / 2.2));\r\n}\r\n\r\nvec3 LrgbToOklab(vec3 rgb) {\r\n  float L = pow(0.4122214708 * rgb.r + 0.5363325363 * rgb.g + 0.0514459929 * rgb.b, 1.0 / 3.0);\r\n  float M = pow(0.2119034982 * rgb.r + 0.6806995451 * rgb.g + 0.1073969566 * rgb.b, 1.0 / 3.0);\r\n  float S = pow(0.0883024619 * rgb.r + 0.2817188376 * rgb.g + 0.6299787005 * rgb.b, 1.0 / 3.0);\r\n  return vec3(\r\n    0.2104542553 * L + 0.793617785 * M - 0.0040720468 * S,\r\n    1.9779984951 * L - 2.428592205 * M + 0.4505937099 * S,\r\n    0.0259040371 * L + 0.7827717662 * M - 0.808675766 * S\r\n  );\r\n}\r\n\r\nvec3 OklabToLrgb(vec3 oklab) {\r\n  float L = oklab.x;\r\n  float a = oklab.y;\r\n  float b = oklab.z;\r\n\r\n  float l_ = L + 0.3963377774 * a + 0.2158037573 * b;\r\n  float m_ = L - 0.1055613458 * a - 0.0638541728 * b;\r\n  float s_ = L - 0.0894841775 * a - 1.291485548 * b;\r\n\r\n  float l = l_ * l_ * l_;\r\n  float m = m_ * m_ * m_;\r\n  float s = s_ * s_ * s_;\r\n\r\n  return vec3(\r\n    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,\r\n    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,\r\n    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s\r\n  );\r\n}\r\n\r\nvec3 oklabToOklch(vec3 oklab) {\r\n  float C = length(oklab.yz);\r\n  float H = atan(oklab.z, oklab.y);\r\n  if (C < OKLCH_CHROMA_THRESHOLD) {\r\n    H = OKLCH_HUE_NEUTRALIZER;\r\n  }\r\n  return vec3(oklab.x, C, H);\r\n}\r\n\r\nvec3 oklchToOklab(vec3 oklch) {\r\n  float a = oklch.y * cos(oklch.z);\r\n  float b = oklch.y * sin(oklch.z);\r\n  return vec3(oklch.x, a, b);\r\n}\r\n\r\nfloat mixHue(float h1, float h2, float mixer) {\r\n  float delta = mod(h2 - h1 + PI, TWO_PI) - PI;\r\n  return h1 + mixer * delta;\r\n}\r\n\r\nvec3 srgbToOklab(vec3 rgb) {\r\n  return oklabToOklch(LrgbToOklab(srgbToLinear(rgb)));\r\n}\r\n\r\nvec3 oklabToSrgb(vec3 oklab) {\r\n  return linearToSrgb(OklabToLrgb(oklchToOklab(oklab)));\r\n}\r\n\r\nvec3 mixOklabVector(vec3 color1, vec3 color2, float mixer) {\r\n  color1.x = mix(color1.x, color2.x, mixer);\r\n  color1.y = mix(color1.y, color2.y, mixer);\r\n  if (color1.y > OKLCH_CHROMA_THRESHOLD && color2.y > OKLCH_CHROMA_THRESHOLD) {\r\n    color1.z = mixHue(color1.z, color2.z, mixer);\r\n  }\r\n  return color1;\r\n}\r\n`;\r\n"],
+  "mappings": ";;;;;AAAO,MAAM,oBAAoB;AAAA,EAC/B,KAAK;AAAA,EACL,OAAO;AACT;AAIO,MAAM,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/shader-mount.d.ts

@@ -0,0 +1,199 @@
+import { type SharedRenderTarget, type SharedTargetSize } from './shared-webgl-renderer.js';
+export declare class ShaderMount implements SharedRenderTarget {
+    parentElement: PaperShaderElement;
+    canvasElement: HTMLCanvasElement;
+    private gl;
+    /** Set when this mount draws through the context shared by all shared mounts, null when it owns a context */
+    private sharedRenderer;
+    /** The visible canvas's 2D context in shared mode, where each frame is copied to */
+    private context2d;
+    private webGlContextAttributes;
+    private program;
+    private vertexArray;
+    private positionBuffer;
+    private uniformLocations;
+    /** The fragment shader that we are using */
+    private fragmentShader;
+    /** Stores the RAF for the render loop */
+    private rafId;
+    /** Time of the last rendered frame */
+    private lastRenderTime;
+    /** Total time that we have played any animation, passed as a uniform to the shader for time-based VFX */
+    private currentFrame;
+    /** The speed that we progress through animation time (multiplies by delta time every update). Allows negatives to play in reverse. If set to 0, rAF will stop entirely so static shaders have no recurring performance costs */
+    private speed;
+    /** Actual speed used that accounts for visibility: we pause the shader if the tab is hidden or the element out of the viewport */
+    private currentSpeed;
+    /** Uniforms that are provided by the user for the specific shader being mounted (not including uniforms that this Mount adds, like time and resolution) */
+    private providedUniforms;
+    /** Names of the uniforms that should have mipmaps generated for them */
+    private mipmaps;
+    /** Just a sanity check to make sure frames don't run after we're disposed */
+    private hasBeenDisposed;
+    /** If the resolution of the canvas has changed since the last render */
+    private resolutionChanged;
+    /** Store textures that are provided by the user */
+    private textures;
+    private minPixelRatio;
+    private maxPixelCount;
+    private isSafari;
+    private uniformCache;
+    private textureUnitMap;
+    private ownerDocument;
+    /** Shared mode: whether time is advancing from frame to frame, as opposed to one-off redraws */
+    private sharedLoopActive;
+    /** Shared mode: the canvas size to apply right before the next draw (resizing clears the canvas) */
+    private pendingCanvasWidth;
+    private pendingCanvasHeight;
+    private contextRecoveries;
+    /** Dedicated mode: the context was lost and a new one goes in once the mount is visible */
+    private awaitingNewContext;
+    constructor(
+    /** The div you'd like to mount the shader to. The shader will match its size. */
+    parentElement: HTMLElement, fragmentShader: string, uniforms: ShaderMountUniforms, webGlContextAttributes?: WebGLContextAttributes, 
+    /** The speed of the animation, or 0 to stop it. Supports negative values to play in reverse. */
+    speed?: number, 
+    /** Pass a frame to offset the starting u_time value and give deterministic results*/
+    frame?: number, 
+    /**
+     * The minimum pixel ratio to render at, defaults to 2.
+     * May be reduced to improve performance or increased together with `maxPixelCount` to improve antialiasing.
+     */
+    minPixelRatio?: number, 
+    /**
+     * The maximum amount of physical device pixels to render for the shader,
+     * by default it's 1920 * 1080 * 2x dpi (per each side) = 8,294,400 pixels of a 4K screen.
+     * Actual DOM size of the canvas can be larger, it will just lose quality after this.
+     *
+     * May be reduced to improve performance or increased to improve quality on high-resolution screens.
+     */
+    maxPixelCount?: number, 
+    /** Names of the uniforms that should have mipmaps generated for them */
+    mipmaps?: string[], 
+    /**
+     * "shared" (the default) draws through one WebGL context shared by every shared mount on the page, so any number
+     * of shaders can run without hitting the browser's context limit. "dedicated" gives this mount its own context,
+     * which suits a large, always visible shader like a full screen background. Defaults to "dedicated" when
+     * `webGlContextAttributes` are passed, since a shared context can't honor per-mount attributes.
+     */
+    webGlContextMode?: WebGlContextMode);
+    /** Create every GL resource this mount owns on the current context. Also rebuilds them after a context is replaced */
+    private initGL;
+    private initProgram;
+    private setupPositionAttribute;
+    private setupUniforms;
+    /**
+     * The scale that we should render at.
+     * - Used to target 2x rendering even on 1x screens for better antialiasing
+     * - Prevents the virtual resolution from going beyond the maximum resolution
+     * - Accounts for the page zoom level so we render in physical device pixels rather than CSS pixels
+     */
+    private renderScale;
+    private parentWidth;
+    private parentHeight;
+    private parentDevicePixelWidth;
+    private parentDevicePixelHeight;
+    private devicePixelsSupported;
+    private intersectionObserver;
+    private isInViewport;
+    private resizeObserver;
+    private setupResizeObserver;
+    private setupIntersectionObserver;
+    private handleVisualViewportChange;
+    /** Resize handler for when the container div changes size or the max pixel count changes and we want to resize our canvas to match */
+    private handleResize;
+    private render;
+    /** Issue the draw call with this mount's program, geometry, textures and per-frame uniforms */
+    private draw;
+    private requestRender;
+    /** Draw the current state: right away with a dedicated context, on the next batched frame with the shared one */
+    private redraw;
+    /** @internal Shared renderer hook, see SharedRenderTarget */
+    prepareSharedFrame: (currentTime: number) => SharedTargetSize | null;
+    /** @internal Shared renderer hook, see SharedRenderTarget */
+    drawShared: (x: number, y: number) => void;
+    /** @internal Shared renderer hook, see SharedRenderTarget */
+    presentShared: (frame: ImageBitmap, x: number, y: number, width: number, height: number) => void;
+    /** @internal Shared renderer hook, see SharedRenderTarget */
+    finishSharedFrame: () => boolean;
+    /** @internal Shared renderer hook, see SharedRenderTarget */
+    restoreShared: (gl: WebGL2RenderingContext) => void;
+    /**
+     * A dedicated context was lost, usually because the page went over the browser's context limit and ours was the
+     * one that rendered least recently.
+     */
+    private handleContextLost;
+    /**
+     * We don't wait for 'webglcontextrestored': browsers restore an evicted context only once another context has been
+     * garbage collected, which can take a long time or never happen. A new canvas with a new context goes in instead,
+     * but only once the mount is on screen: every new context pushes the least recently used one out when the page is
+     * at the limit, so offscreen or hidden mounts replacing theirs would just take turns evicting each other.
+     */
+    private maybeReplaceDedicatedContext;
+    private replaceDedicatedContext;
+    /** Creates a texture from an image and sets it into a uniform value */
+    private setTextureUniform;
+    /** Utility: recursive equality test for all the uniforms */
+    private areUniformValuesEqual;
+    /** Sets the provided uniform values into the WebGL program, can be a partial list of uniforms that have changed */
+    private setUniformValues;
+    /** Gets the current total animation time from 0ms */
+    getCurrentFrame: () => number;
+    /** Set a frame to get a deterministic result, frames are literally just milliseconds from zero since the animation started */
+    setFrame: (newFrame: number) => void;
+    /** Set an animation speed (or 0 to stop animation) */
+    setSpeed: (newSpeed?: number) => void;
+    /** Apply the target speed, pausing (0) while the tab is hidden or the element is out of the viewport */
+    private updateCurrentSpeed;
+    private setCurrentSpeed;
+    /** Set the maximum pixel count for the shader, this will limit the number of pixels that will be rendered */
+    setMaxPixelCount: (newMaxPixelCount?: number) => void;
+    /** Set the minimum pixel ratio for the shader */
+    setMinPixelRatio: (newMinPixelRatio?: number) => void;
+    /** Update the uniforms that are provided by the outside shader, can be a partial set with only the uniforms that have changed */
+    setUniforms: (newUniforms: ShaderMountUniforms) => void;
+    private handleDocumentVisibilityChange;
+    /** Dispose of the shader mount, cleaning up all of the WebGL resources */
+    dispose: () => void;
+}
+/** The parent `<div>` element that has a ShaderMount available on it */
+export interface PaperShaderElement extends HTMLElement {
+    paperShaderMount: ShaderMount | undefined;
+}
+/**
+ * How a ShaderMount gets its WebGL context:
+ * - "shared": draws through one context shared by all shared mounts, so any number of shaders stays within the
+ *   browser's context limit. Each frame is copied into the mount's own canvas, a small cost for the typical widget.
+ * - "dedicated": owns a context, drawn without a copy. Best for a single large shader such as a full screen background.
+ */
+export type WebGlContextMode = 'shared' | 'dedicated';
+/** Check if an element is a Paper shader element */
+export declare function isPaperShaderElement(element: HTMLElement): element is PaperShaderElement;
+/**
+ * Uniform types that we support to be auto-mapped into the fragment shader
+ *
+ * We accept undefined as a convenience for server rendering, when some things may be undefined
+ * We just skip setting the uniform if it's undefined. This allows the shader mount to still take up space during server rendering
+ */
+export interface ShaderMountUniforms {
+    [key: string]: boolean | number | number[] | number[][] | HTMLImageElement | undefined;
+}
+export interface ShaderMotionParams {
+    speed?: number;
+    frame?: number;
+}
+export type ShaderPreset<T> = {
+    name: string;
+    params: Required<T>;
+};
+export type ImageShaderPreset<T> = {
+    name: string;
+    /**
+     * Params for the shader excluding the image.
+     * Image is excluded as it isn't considered a preset,
+     * e.g. when switching between presets it shouldn't switch the image.
+     *
+     * While we exclude images from presets they should still be set with a default prop value so the code-first usage of shaders remains great.
+     */
+    params: Required<Omit<T, 'image'>>;
+};