@remotion/effects 4.0.536 → 4.0.538

package/dist/fisheye/index.d.ts

@@ -22,5 +22,5 @@ export type FisheyeParams = {
     readonly zoom?: number;
 };
 export declare const fisheye: (params?: (FisheyeParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/flannel.d.ts

@@ -11,5 +11,5 @@ export type FlannelParams = {
     readonly stripeColor?: string;
 };
 export declare const flannel: (params?: (FlannelParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/fractal-noise/index.d.ts

@@ -0,0 +1,40 @@
+declare const FRACTAL_TYPES: readonly ['basic', 'turbulent-smooth', 'turbulent-basic', 'turbulent-sharp', 'dynamic', 'dynamic-twist', 'dynamic-progressive', 'max', 'strings'];
+declare const NOISE_TYPES: readonly ['block', 'linear', 'soft-linear', 'spline'];
+export type FractalNoiseParams = {
+    /** Texture shape. Defaults to `basic`. */
+    readonly fractalType?: (typeof FRACTAL_TYPES)[number];
+    /** Lattice interpolation. Defaults to `soft-linear`. */
+    readonly noiseType?: (typeof NOISE_TYPES)[number];
+    /** Size of the largest noise cells in pixels. Defaults to `100`. */
+    readonly scale?: number;
+    /** Number of noise layers, including fractional layers, from `1` to `20`. Defaults to `6`. */
+    readonly complexity?: number;
+    /** Evolution in degrees. Animate to morph the texture. Defaults to `0`. */
+    readonly evolution?: number;
+    /** Contrast multiplier around mid-gray. Defaults to `1`. */
+    readonly contrast?: number;
+    /** Brightness added after contrast. Defaults to `0`. */
+    readonly brightness?: number;
+    /** Horizontal texture translation in pixels. Defaults to `0`. */
+    readonly offsetX?: number;
+    /** Vertical texture translation in pixels. Defaults to `0`. */
+    readonly offsetY?: number;
+    /** Relative strength of each successive layer, from `0` to `1`. Defaults to `0.7`. */
+    readonly subInfluence?: number;
+    /** Relative cell size of each successive layer, from `0.1` to `1`. Defaults to `0.56`. */
+    readonly subScaling?: number;
+    /** Loop evolution after `cycle` revolutions. Defaults to `false`. */
+    readonly cycleEvolution?: boolean;
+    /** Loop length in whole revolutions. Defaults to `1`. */
+    readonly cycle?: number;
+    /** Unsigned 32-bit integer seed for a repeatable texture. Defaults to `0`. */
+    readonly seed?: number;
+    /** Invert the generated grayscale values. Defaults to `false`. */
+    readonly invert?: boolean;
+    /** Mix with the source from `0` (unchanged) to `1` (noise only). Defaults to `1`. */
+    readonly amount?: number;
+};
+export declare const fractalNoise: (params?: (FractalNoiseParams & {
+    readonly disabled?: boolean;
+}) | undefined) => import("remotion").EffectDescriptor<unknown>;
+export {};

package/dist/fractal-noise/shader.d.ts

@@ -0,0 +1 @@
+export declare const FRACTAL_NOISE_FRAGMENT_SHADER = "#version 300 es\nprecision highp float;\nprecision highp int;\n\nin vec2 vUv;\nout vec4 fragColor;\nuniform sampler2D uSource;\nuniform vec2 uResolution;\nuniform vec2 uOffset;\nuniform float uScale;\nuniform float uComplexity;\nuniform float uEvolution;\nuniform float uSubInfluence;\nuniform float uSubScaling;\nuniform float uContrast;\nuniform float uBrightness;\nuniform float uAmount;\nuniform float uCycle;\nuniform uint uSeed;\nuniform int uFractalType;\nuniform int uNoiseType;\nuniform bool uInvert;\nuniform bool uCycleEvolution;\n\n\nfloat lattice(ivec3 point, uint seed) {\n  // Wrap lattice indices as well as coordinates so interpolation stays continuous\n  // across the period boundary, including negative coordinates.\n  uvec3 p = uvec3(point) & uvec3(65535u);\n  uint h = p.x * 0x27d4eb2du ^ p.y * 0x165667b1u ^ p.z * 0x9e3779b9u ^ seed * 0x85ebca6bu;\n  h ^= h >> 15;\n  h *= 0x2c1b3c6du;\n  h ^= h >> 12;\n  h *= 0x297a2d39u;\n  h ^= h >> 15;\n  return float(h & 65535u) / 65535.0;\n}\n\nfloat catmull(vec4 p, float t) {\n  return 0.5 * (2.0 * p.y + (p.z - p.x) * t\n    + (2.0 * p.x - 5.0 * p.y + 4.0 * p.z - p.w) * t * t\n    + (3.0 * p.y - p.x - 3.0 * p.z + p.w) * t * t * t);\n}\n\nvec3 bspline(float t) {\n  return vec3(0.5 * (1.0-t) * (1.0-t), 0.5 + t * (1.0-t), 0.5 * t * t);\n}\n\nfloat sliceNoise(ivec3 p, vec2 t, uint seed) {\n  if (uNoiseType == 0) return lattice(p, seed);\n  if (uNoiseType == 1) {\n    return mix(mix(lattice(p, seed), lattice(p + ivec3(1,0,0), seed), t.x),\n      mix(lattice(p + ivec3(0,1,0), seed), lattice(p + ivec3(1,1,0), seed), t.x), t.y);\n  }\n  if (uNoiseType == 2) {\n    vec3 wx = bspline(t.x);\n    vec3 wy = bspline(t.y);\n    float result = 0.0;\n    for (int y = 0; y < 3; y++) {\n      for (int x = 0; x < 3; x++) {\n        result += wx[x] * wy[y] * lattice(p + ivec3(x-1, y-1, 0), seed);\n      }\n    }\n    return result;\n  }\n  vec4 rows;\n  for (int y = 0; y < 4; y++) {\n    vec4 row;\n    for (int x = 0; x < 4; x++) {\n      row[x] = lattice(p + ivec3(x-1, y-1, 0), seed);\n    }\n    rows[y] = catmull(row, t.x);\n  }\n  return catmull(rows, t.y);\n}\n\nfloat valueNoise(vec3 point, uint seed) {\n  // A large period keeps conversion to integer coordinates defined at extreme scales.\n  vec3 p = mod(point + vec3(uNoiseType == 2 ? 0.5 : 0.0, uNoiseType == 2 ? 0.5 : 0.0, 0.0), 65536.0);\n  ivec3 cell = ivec3(floor(p));\n  vec3 t = fract(p);\n  float fz = t.z * t.z * t.z * (t.z * (t.z * 6.0 - 15.0) + 10.0);\n  float n = mix(sliceNoise(cell, t.xy, seed), sliceNoise(cell + ivec3(0,0,1), t.xy, seed), fz);\n  return uNoiseType == 2 ? 0.5 + (n - 0.5) * (181.0 / 231.0) / 0.55 : n;\n}\n\n\nfloat layer(vec2 p, float z, uint seed) {\n  if (!uCycleEvolution) return valueNoise(vec3(p, uEvolution + z), seed);\n  float t = mod(uEvolution, uCycle);\n  return mix(valueNoise(vec3(p, t + z), seed), valueNoise(vec3(p, t - uCycle + z), seed), t / uCycle);\n}\n\nfloat shape(float n) {\n  float s = 2.0 * n - 1.0;\n  if (uFractalType == 1) return 1.0 - s * s;\n  if (uFractalType == 2) return 1.0 - abs(s);\n  if (uFractalType == 3) return (1.0 - abs(s)) * (1.0 - abs(s));\n  if (uFractalType == 8) {\n    float distance = clamp(abs(s) / 0.12, 0.0, 1.0);\n    return 1.0 - distance * distance;\n  }\n  return n;\n}\n\nvoid main() {\n  vec4 source = texture(uSource, vUv);\n  if (source.a == 0.0 || uAmount == 0.0) {\n    fragColor = source;\n    return;\n  }\n  vec2 pixel = vec2(vUv.x, 1.0 - vUv.y) * uResolution;\n  vec2 base = (pixel - uResolution * 0.5 - uOffset) / uScale;\n  float sum = 0.0;\n  float norm = 0.0;\n  float amplitude = 1.0;\n  float frequency = 1.0;\n  float best = 0.0;\n  for (int octave = 0; octave < 20; octave++) {\n    float weight = clamp(uComplexity - float(octave), 0.0, 1.0);\n    if (weight == 0.0 || amplitude == 0.0) break;\n    vec2 p = base * frequency;\n    float z = float(octave) * 7.31;\n    uint seed = (uSeed ^ 0x51edu) + uint(octave);\n    if (uFractalType >= 4 && uFractalType <= 6) {\n      float a = layer(p * 0.5, z + 3.1, seed ^ 0x55u) - 0.5;\n      if (uFractalType == 5) {\n        float angle = a * 3.0;\n        p = mat2(cos(angle), sin(angle), -sin(angle), cos(angle)) * p;\n      } else {\n        float b = layer(p * 0.5, z + 5.7, seed ^ 0xaau) - 0.5;\n        float strength = uFractalType == 6 ? 0.5 + float(octave) * 0.35 : 1.0;\n        p += vec2(a, b) * 1.5 * strength;\n      }\n    }\n    float n = shape(layer(p, z, seed));\n    // Fade fractional octaves in for Max too, so animating complexity is continuous.\n    best = max(best, n * amplitude * weight);\n    sum += n * amplitude * weight;\n    norm += amplitude * weight;\n    amplitude *= uSubInfluence;\n    frequency /= uSubScaling;\n  }\n  float noise = uFractalType == 7 ? best : sum / norm;\n  noise = clamp((noise - 0.5) * uContrast + 0.5 + uBrightness, 0.0, 1.0);\n  if (uInvert) noise = 1.0 - noise;\n  fragColor = vec4(mix(source.rgb, vec3(noise) * source.a, uAmount), source.a);\n}\n";

package/dist/fractal-noise.d.ts

@@ -0,0 +1 @@
+export { fractalNoise, type FractalNoiseParams } from './fractal-noise/index.js';

package/dist/gaussian-blur-shader.d.ts

@@ -1 +1 @@
-export declare const buildGaussianBlurFs: (direction: "horizontal" | "vertical") => string;
+export declare const buildGaussianBlurFs: (direction: 'horizontal' | 'vertical') => string;

package/dist/glow/index.d.ts

@@ -9,5 +9,5 @@ export type GlowParams = {
     readonly color?: string;
 };
 export declare const glow: (params?: (GlowParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/grayscale.d.ts

@@ -3,5 +3,5 @@ export type GrayscaleParams = {
     readonly amount?: number;
 };
 export declare const grayscale: (params?: (GrayscaleParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/gridlines.d.ts

@@ -1,87 +1,87 @@
 export declare const gridlinesSchema: {
     readonly gridSize: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 1;
         readonly max: 400;
         readonly step: 1;
         readonly default: 64;
-        readonly description: "Grid size";
+        readonly description: 'Grid size';
         readonly hiddenFromList: false;
     };
     readonly lineWidth: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 100;
         readonly step: 0.1;
         readonly default: 2;
-        readonly description: "Line width";
+        readonly description: 'Line width';
         readonly hiddenFromList: false;
     };
     readonly lineColor: {
-        readonly type: "color";
+        readonly type: 'color';
         readonly default: "#ffffff";
-        readonly description: "Line color";
+        readonly description: 'Line color';
     };
     readonly backgroundColor: {
-        readonly type: "color";
+        readonly type: 'color';
         readonly default: "transparent";
-        readonly description: "Background color";
+        readonly description: 'Background color';
     };
     readonly rotation: {
-        readonly type: "rotation-degrees";
+        readonly type: 'rotation-degrees';
         readonly min: -180;
         readonly max: 180;
         readonly step: 1;
         readonly default: 0;
-        readonly description: "Rotation";
+        readonly description: 'Rotation';
     };
     readonly rotationX: {
-        readonly type: "rotation-degrees";
+        readonly type: 'rotation-degrees';
         readonly min: -180;
         readonly max: 180;
         readonly step: 0.1;
         readonly default: 0;
-        readonly description: "Rotation X";
+        readonly description: 'Rotation X';
     };
     readonly rotationY: {
-        readonly type: "rotation-degrees";
+        readonly type: 'rotation-degrees';
         readonly min: -180;
         readonly max: 180;
         readonly step: 0.1;
         readonly default: 0;
-        readonly description: "Rotation Y";
+        readonly description: 'Rotation Y';
     };
     readonly perspective: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 4000;
         readonly step: 1;
         readonly default: 0;
-        readonly description: "Perspective";
+        readonly description: 'Perspective';
         readonly hiddenFromList: false;
     };
     readonly offsetX: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: -400;
         readonly max: 400;
         readonly step: 0.1;
         readonly default: 0;
-        readonly description: "Offset X";
+        readonly description: 'Offset X';
         readonly hiddenFromList: false;
     };
     readonly offsetY: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: -400;
         readonly max: 400;
         readonly step: 0.1;
         readonly default: 0;
-        readonly description: "Offset Y";
+        readonly description: 'Offset Y';
         readonly hiddenFromList: false;
     };
     readonly maskToSourceAlpha: {
-        readonly type: "boolean";
+        readonly type: 'boolean';
         readonly default: false;
-        readonly description: "Mask to source alpha";
+        readonly description: 'Mask to source alpha';
     };
 };
 export type GridlinesParams = {
@@ -109,5 +109,5 @@ export type GridlinesParams = {
     readonly maskToSourceAlpha?: boolean;
 };
 export declare const gridlines: (params?: (GridlinesParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/halftone-linear-gradient.d.ts

@@ -1,71 +1,71 @@
-declare const HALFTONE_LINEAR_GRADIENT_COLOR_MODES: readonly ["solid", "source"];
+declare const HALFTONE_LINEAR_GRADIENT_COLOR_MODES: readonly ['solid', 'source'];
 export declare const halftoneLinearGradientSchema: {
     readonly firstStopDotSize: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 400;
         readonly step: 1;
         readonly default: 0;
-        readonly description: "First stop dot size";
+        readonly description: 'First stop dot size';
         readonly hiddenFromList: false;
     };
     readonly secondStopDotSize: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 400;
         readonly step: 1;
         readonly default: 40;
-        readonly description: "Second stop dot size";
+        readonly description: 'Second stop dot size';
         readonly hiddenFromList: false;
     };
     readonly firstStopPosition: {
-        readonly type: "uv-coordinate";
+        readonly type: 'uv-coordinate';
         readonly min: -1;
         readonly max: 2;
         readonly step: 0.01;
         readonly default: readonly [0, 0.5];
-        readonly description: "First stop position";
+        readonly description: 'First stop position';
         readonly visual: {
-            readonly type: "line";
-            readonly to: "secondStopPosition";
+            readonly type: 'line';
+            readonly to: 'secondStopPosition';
         };
     };
     readonly secondStopPosition: {
-        readonly type: "uv-coordinate";
+        readonly type: 'uv-coordinate';
         readonly min: -1;
         readonly max: 2;
         readonly step: 0.01;
         readonly default: readonly [1, 0.5];
-        readonly description: "Second stop position";
+        readonly description: 'Second stop position';
     };
     readonly gridSize: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 1;
         readonly max: 400;
         readonly step: 1;
         readonly default: 24;
-        readonly description: "Grid size";
+        readonly description: 'Grid size';
         readonly hiddenFromList: false;
     };
     readonly colorMode: {
-        readonly type: "enum";
-        readonly default: "solid";
-        readonly description: "Color mode";
+        readonly type: 'enum';
+        readonly default: 'solid';
+        readonly description: 'Color mode';
         readonly variants: {
             readonly solid: {
                 readonly dotColor: {
-                    readonly type: "color";
+                    readonly type: 'color';
                     readonly default: "black";
-                    readonly description: "Dot color";
+                    readonly description: 'Dot color';
                 };
             };
             readonly source: {};
         };
     };
     readonly maskToSourceAlpha: {
-        readonly type: "boolean";
+        readonly type: 'boolean';
         readonly default: false;
-        readonly description: "Mask to source alpha";
+        readonly description: 'Mask to source alpha';
     };
 };
 export type HalftoneLinearGradientColorMode = (typeof HALFTONE_LINEAR_GRADIENT_COLOR_MODES)[number];
@@ -104,6 +104,6 @@ export type HalftoneLinearGradientParams = HalftoneLinearGradientCommonParams &
     readonly colorMode: 'source';
 });
 export declare const halftoneLinearGradient: (params?: (HalftoneLinearGradientParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;
 export {};

package/dist/halftone.d.ts

@@ -1,70 +1,70 @@
-declare const HALFTONE_SHAPES: readonly ["circle", "square", "line"];
-declare const HALFTONE_SAMPLING: readonly ["bilinear", "nearest"];
-declare const HALFTONE_COLOR_MODES: readonly ["solid", "source"];
+declare const HALFTONE_SHAPES: readonly ['circle', 'square', 'line'];
+declare const HALFTONE_SAMPLING: readonly ['bilinear', 'nearest'];
+declare const HALFTONE_COLOR_MODES: readonly ['solid', 'source'];
 export declare const halftoneSchema: {
     readonly dotSize: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 1;
         readonly max: 200;
         readonly step: 1;
         readonly default: 20;
-        readonly description: "Dot size";
+        readonly description: 'Dot size';
         readonly hiddenFromList: false;
     };
     readonly dotSpacing: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 1;
         readonly max: 200;
         readonly step: 1;
         readonly default: 20;
-        readonly description: "Dot spacing";
+        readonly description: 'Dot spacing';
         readonly hiddenFromList: false;
     };
     readonly rotation: {
-        readonly type: "rotation-degrees";
+        readonly type: 'rotation-degrees';
         readonly step: 1;
         readonly default: 0;
-        readonly description: "Rotation";
+        readonly description: 'Rotation';
     };
     readonly offsetX: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly step: 1;
         readonly default: 0;
-        readonly description: "Offset X";
+        readonly description: 'Offset X';
         readonly hiddenFromList: false;
     };
     readonly offsetY: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly step: 1;
         readonly default: 0;
-        readonly description: "Offset Y";
+        readonly description: 'Offset Y';
         readonly hiddenFromList: false;
     };
     readonly shape: {
-        readonly type: "enum";
+        readonly type: 'enum';
         readonly variants: {
             readonly circle: {};
             readonly square: {};
             readonly line: {};
         };
-        readonly default: "circle";
-        readonly description: "Shape";
+        readonly default: 'circle';
+        readonly description: 'Shape';
     };
     readonly invert: {
-        readonly type: "boolean";
+        readonly type: 'boolean';
         readonly default: false;
-        readonly description: "Invert";
+        readonly description: 'Invert';
     };
     readonly colorMode: {
-        readonly type: "enum";
-        readonly default: "solid";
-        readonly description: "Color mode";
+        readonly type: 'enum';
+        readonly default: 'solid';
+        readonly description: 'Color mode';
         readonly variants: {
             readonly solid: {
                 readonly dotColor: {
-                    readonly type: "color";
-                    readonly default: "red";
-                    readonly description: "Dot color";
+                    readonly type: 'color';
+                    readonly default: 'red';
+                    readonly description: 'Dot color';
                 };
             };
             readonly source: {};
@@ -101,6 +101,6 @@ export type HalftoneParams = HalftoneCommonParams & ({
     readonly colorMode: 'source';
 });
 export declare const halftone: (params?: (HalftoneParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;
 export {};

package/dist/hue.d.ts

@@ -3,5 +3,5 @@ export type HueParams = {
     readonly degrees?: number;
 };
 export declare const hue: (params?: (HueParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/invert.d.ts

@@ -3,5 +3,5 @@ export type InvertParams = {
     readonly amount?: number;
 };
 export declare const invert: (params?: (InvertParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/lens-blur/index.d.ts

@@ -0,0 +1,30 @@
+declare const IRIS_SHAPES: readonly ['triangle', 'square', 'pentagon', 'hexagon', 'heptagon', 'octagon', 'nonagon', 'decagon', 'circle'];
+export type LensBlurIrisShape = (typeof IRIS_SHAPES)[number];
+export type LensBlurParams = {
+    /** Blur radius in pixels. Defaults to `10`. */
+    readonly radius?: number;
+    /** Iris shape. Defaults to `hexagon`. */
+    readonly irisShape?: LensBlurIrisShape;
+    /** Roundness of the iris, from 0 (polygon) to 1 (circle). Defaults to `0`. */
+    readonly irisRoundness?: number;
+    /** Clockwise iris rotation in degrees. Defaults to `0`. */
+    readonly irisRotation?: number;
+    /** Horizontal stretch of the iris. Must be greater than zero. Defaults to `1`. */
+    readonly irisAspectRatio?: number;
+    /** Additional brightness of highlights, from 0 to 1. Defaults to `0`. */
+    readonly highlightGain?: number;
+    /** Minimum luminance for highlight gain, from 0 to 1. Defaults to `1`. */
+    readonly highlightThreshold?: number;
+    /** Saturation of added highlight brightness, from 0 to 1. Defaults to `1`. */
+    readonly highlightSaturation?: number;
+    /** Repeat edge pixels outside the source instead of sampling transparency. Defaults to `false`. */
+    readonly repeatEdgePixels?: boolean;
+    /** Number of aperture samples, from 16 to 2048. Higher values reduce grain. Defaults to `256`. */
+    readonly samples?: number;
+    /** Average colors in linear light. Defaults to `false`. */
+    readonly linearLight?: boolean;
+};
+export declare const lensBlur: (params?: (LensBlurParams & {
+    readonly disabled?: boolean;
+}) | undefined) => import("remotion").EffectDescriptor<unknown>;
+export {};

package/dist/lens-blur/shader.d.ts

@@ -0,0 +1 @@
+export declare const LENS_BLUR_FRAGMENT_SHADER = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform sampler2D uSource;\nuniform vec2 uResolution;\nuniform float uRadius;\nuniform int uIrisShape;\nuniform float uIrisRoundness;\nuniform float uIrisRotation;\nuniform float uIrisAspectRatio;\nuniform float uHighlightGain;\nuniform float uHighlightThreshold;\nuniform float uHighlightSaturation;\nuniform bool uRepeatEdgePixels;\nuniform int uSamples;\nuniform bool uLinearLight;\n\nconst float PI = 3.141592653589793;\nconst float GOLDEN_ANGLE = 2.399963229728653;\n\nvec3 toLinear(vec3 color) {\n\treturn mix(color / 12.92, pow((color + 0.055) / 1.055, vec3(2.4)), step(vec3(0.04045), color));\n}\n\nvec3 toSrgb(vec3 color) {\n\treturn mix(color * 12.92, 1.055 * pow(max(color, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055, step(vec3(0.0031308), color));\n}\n\nvec4 readSource(vec2 uv) {\n\tvec4 sampleColor = texture(uSource, uv);\n\tif (sampleColor.a <= 0.0) return vec4(0.0);\n\tvec3 color = sampleColor.rgb / sampleColor.a;\n\tfloat luminance = dot(color, vec3(0.2126, 0.7152, 0.0722));\n\tif (uLinearLight) color = toLinear(color);\n\tif (luminance >= uHighlightThreshold) {\n\t\tfloat brightest = max(color.r, max(color.g, color.b));\n\t\tvec3 highlight = mix(vec3(brightest), color, uHighlightSaturation);\n\t\tcolor += highlight * (4.0 * uHighlightGain);\n\t}\n\n\tfloat coverage = 1.0;\n\tif (!uRepeatEdgePixels) {\n\t\t// The texture clamps to its edge texels. Fade their bilinear footprint\n\t\t// against transparent texels beyond the canvas instead of cutting it off.\n\t\tvec2 pixel = uv * uResolution;\n\t\tvec2 nearEdge = clamp(pixel + 0.5, 0.0, 1.0);\n\t\tvec2 farEdge = clamp(uResolution + 0.5 - pixel, 0.0, 1.0);\n\t\tcoverage = nearEdge.x * nearEdge.y * farEdge.x * farEdge.y;\n\t}\n\treturn vec4(color * sampleColor.a, sampleColor.a) * coverage;\n}\n\nvoid main() {\n\t// A zero radius must be an exact identity, including with highlight gain.\n\tif (uRadius == 0.0) {\n\t\tfragColor = texture(uSource, vUv);\n\t\treturn;\n\t}\n\n\tvec4 sum = vec4(0.0);\n\tfloat totalWeight = 0.0;\n\tfor (int i = 0; i < 2048; i++) {\n\t\tif (i >= uSamples) break;\n\t\tfloat angle = float(i) * GOLDEN_ANGLE;\n\t\tfloat boundary = 1.0;\n\t\tif (uIrisShape < 11) {\n\t\t\tfloat halfSector = PI / float(uIrisShape);\n\t\t\tfloat localAngle = mod(angle + PI / 2.0, 2.0 * halfSector) - halfSector;\n\t\t\tfloat polygon = cos(halfSector) / cos(localAngle);\n\t\t\tboundary = mix(polygon, 1.0, uIrisRoundness);\n\t\t}\n\t\tfloat distance = sqrt((float(i) + 0.5) / float(uSamples)) * boundary;\n\t\tfloat rotatedAngle = angle + uIrisRotation;\n\t\tvec2 offset = vec2(cos(rotatedAngle) * uIrisAspectRatio, -sin(rotatedAngle)) * distance * uRadius;\n\t\t// Radially mapping a disc onto a polygon changes area by boundary^2.\n\t\t// Weight by that Jacobian to keep the aperture uniformly illuminated.\n\t\tfloat weight = boundary * boundary;\n\t\tsum += readSource(vUv - offset / uResolution) * weight;\n\t\ttotalWeight += weight;\n\t}\n\n\tvec4 color = sum / totalWeight;\n\tif (uLinearLight && color.a > 0.0) {\n\t\tcolor.rgb = toSrgb(color.rgb / color.a) * color.a;\n\t}\n\t// Keep the result premultiplied even when highlights exceed display white.\n\tfragColor = vec4(clamp(color.rgb, vec3(0.0), vec3(color.a)), color.a);\n}\n";

package/dist/lens-blur.d.ts

@@ -0,0 +1 @@
+export { lensBlur, type LensBlurParams, type LensBlurIrisShape, } from './lens-blur/index.js';

package/dist/levels.d.ts

@@ -7,5 +7,5 @@ export type LevelsParams = {
     readonly gamma?: number;
 };
 export declare const levels: (params?: (LevelsParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/light-leak.d.ts

@@ -1,25 +1,25 @@
 export declare const lightLeakEffectSchema: {
     readonly seed: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly default: 0;
-        readonly description: "Seed";
+        readonly description: 'Seed';
         readonly hiddenFromList: false;
     };
     readonly hueShift: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 360;
         readonly default: 0;
-        readonly description: "Hue Shift";
+        readonly description: 'Hue Shift';
         readonly hiddenFromList: false;
     };
     readonly progress: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 0.5;
-        readonly description: "Progress";
+        readonly description: 'Progress';
         readonly hiddenFromList: false;
     };
 };
@@ -30,5 +30,5 @@ export type LightLeakEffectParams = {
     readonly progress?: number;
 };
 export declare const lightLeak: (params?: (LightLeakEffectParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/light-trail/index.d.ts

@@ -15,5 +15,5 @@ export type LightTrailParams = {
     readonly color?: string;
 };
 export declare const lightTrail: (params?: (LightTrailParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/linear-gradient-tint.d.ts

@@ -22,5 +22,5 @@ export type LinearGradientTintParams = {
     readonly amount?: number;
 };
 export declare const linearGradientTint: (params?: (LinearGradientTintParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/linear-gradient.d.ts

@@ -18,5 +18,5 @@ export type LinearGradientParams = {
     readonly endColor?: string;
 };
 export declare const linearGradient: (params?: (LinearGradientParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/linear-progressive-blur/index.d.ts

@@ -24,5 +24,5 @@ export type LinearProgressiveBlurResolved = {
     readonly endBlur: number;
 };
 export declare const linearProgressiveBlur: (params?: (LinearProgressiveBlurParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/linear-progressive-blur/linear-progressive-blur-shaders.d.ts

@@ -1,2 +1,2 @@
 export declare const LINEAR_PROGRESSIVE_BLUR_VS = "#version 300 es\nlayout(location = 0) in vec2 aPos;\nlayout(location = 1) in vec2 aUv;\nout vec2 vUv;\nvoid main() {\n\tvUv = aUv;\n\tgl_Position = vec4(aPos, 0.0, 1.0);\n}\n";
-export declare const buildLinearProgressiveBlurFs: (direction: "horizontal" | "vertical") => string;
+export declare const buildLinearProgressiveBlurFs: (direction: 'horizontal' | 'vertical') => string;

package/dist/linear-progressive-pixelate/index.d.ts

@@ -10,5 +10,5 @@ export type LinearProgressivePixelateParams = {
     readonly endBlockSize?: number;
 };
 export declare const linearProgressivePixelate: (params?: (LinearProgressivePixelateParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;