@remotion/effects 4.0.537 → 4.0.538

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

@@ -1,4 +1,4 @@
-declare const IRIS_SHAPES: readonly ["triangle", "square", "pentagon", "hexagon", "heptagon", "octagon", "nonagon", "decagon", "circle"];
+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`. */
@@ -25,6 +25,6 @@ export type LensBlurParams = {
     readonly linearLight?: boolean;
 };
 export declare const lensBlur: (params?: (LensBlurParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;
 export {};

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>;

package/dist/lines.d.ts

@@ -1,60 +1,60 @@
-declare const LINE_DIRECTIONS: readonly ["horizontal", "vertical"];
+declare const LINE_DIRECTIONS: readonly ['horizontal', 'vertical'];
 export declare const linesSchema: {
     readonly colors: {
-        readonly type: "array";
+        readonly type: 'array';
         readonly item: {
-            readonly type: "color";
+            readonly type: 'color';
         };
         readonly default: readonly ["#dff4ff", "#7cc6ff"];
         readonly minLength: 2;
-        readonly newItemDefault: "#ff0000";
-        readonly description: "Colors";
+        readonly newItemDefault: '#ff0000';
+        readonly description: 'Colors';
         readonly keyframable: false;
     };
     readonly direction: {
-        readonly type: "enum";
+        readonly type: 'enum';
         readonly variants: {
             readonly horizontal: {};
             readonly vertical: {};
         };
         readonly default: "horizontal";
-        readonly description: "Direction";
+        readonly description: 'Direction';
     };
     readonly thickness: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0.1;
         readonly max: 400;
         readonly step: 0.1;
         readonly default: 40;
-        readonly description: "Thickness";
+        readonly description: 'Thickness';
         readonly hiddenFromList: false;
     };
     readonly gap: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 400;
         readonly step: 0.1;
         readonly default: 0;
-        readonly description: "Gap";
+        readonly description: 'Gap';
         readonly hiddenFromList: false;
     };
     readonly angle: {
-        readonly type: "rotation-degrees";
+        readonly type: 'rotation-degrees';
         readonly step: 1;
         readonly default: 0;
-        readonly description: "Angle";
+        readonly description: 'Angle';
     };
     readonly offset: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly step: 0.1;
         readonly default: 0;
-        readonly description: "Offset";
+        readonly description: 'Offset';
         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 LinesDirection = (typeof LINE_DIRECTIONS)[number];
@@ -75,6 +75,6 @@ export type LinesParams = {
     readonly maskToSourceAlpha?: boolean;
 };
 export declare const lines: (params?: (LinesParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;
 export {};

package/dist/liquid-contours.d.ts

@@ -1,76 +1,76 @@
 export declare const liquidContoursSchema: {
     readonly firstColor: {
-        readonly type: "color";
+        readonly type: 'color';
         readonly default: "#ff1a0a";
-        readonly description: "First color";
+        readonly description: 'First color';
     };
     readonly secondColor: {
-        readonly type: "color";
+        readonly type: 'color';
         readonly default: "#050505";
-        readonly description: "Second color";
+        readonly description: 'Second color';
     };
     readonly spacing: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 2;
         readonly max: 300;
         readonly step: 1;
         readonly default: 62;
-        readonly description: "Spacing";
+        readonly description: 'Spacing';
         readonly hiddenFromList: false;
     };
     readonly scale: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 20;
         readonly max: 1000;
         readonly step: 1;
         readonly default: 300;
-        readonly description: "Scale";
+        readonly description: 'Scale';
         readonly hiddenFromList: false;
     };
     readonly complexity: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 0;
-        readonly description: "Complexity";
+        readonly description: 'Complexity';
         readonly hiddenFromList: false;
     };
     readonly smoothness: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 1;
-        readonly description: "Edge smoothness";
+        readonly description: 'Edge smoothness';
         readonly hiddenFromList: false;
     };
     readonly seed: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly step: 1;
         readonly default: 4;
-        readonly description: "Seed";
+        readonly description: 'Seed';
         readonly hiddenFromList: false;
     };
     readonly offsetX: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly step: 0.1;
         readonly default: 13.4;
-        readonly description: "Offset X";
+        readonly description: 'Offset X';
         readonly hiddenFromList: false;
     };
     readonly offsetY: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly step: 0.1;
         readonly default: 0;
-        readonly description: "Offset Y";
+        readonly description: 'Offset Y';
         readonly hiddenFromList: false;
     };
     readonly phase: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly step: 0.01;
         readonly default: 3.23;
-        readonly description: "Phase";
+        readonly description: 'Phase';
         readonly hiddenFromList: false;
     };
 };
@@ -97,5 +97,5 @@ export type LiquidContoursParams = {
     readonly phase?: number;
 };
 export declare const liquidContours: (params?: (LiquidContoursParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/long-shadows.d.ts

@@ -0,0 +1,13 @@
+export type LongShadowsParams = {
+    /** Length of the shadow in pixels. Defaults to `240`. */
+    readonly length?: number;
+    /** Clockwise angle in degrees, with `0` pointing right. Defaults to `45`. */
+    readonly angle?: number;
+    /** CSS color of the shadow. Defaults to `'#777777'`. */
+    readonly color?: string;
+    /** Shadow opacity from `0` to `1`. Defaults to `1`. */
+    readonly opacity?: number;
+};
+export declare const longShadows: (params?: (LongShadowsParams & {
+    readonly disabled?: boolean;
+}) | undefined) => import("remotion").EffectDescriptor<unknown>;

package/dist/lut/index.d.ts

@@ -1,8 +1,8 @@
 export declare const lutSchema: {
     readonly content: {
-        readonly type: "string";
+        readonly type: 'string';
         readonly default: "TITLE \"Identity\"\nLUT_3D_SIZE 2\n\n0 0 0\n1 0 0\n0 1 0\n1 1 0\n0 0 1\n1 0 1\n0 1 1\n1 1 1";
-        readonly description: "Cube LUT content";
+        readonly description: 'Cube LUT content';
         readonly keyframable: false;
     };
 };
@@ -11,5 +11,5 @@ export type LutParams = {
     readonly content: string;
 };
 export declare const lut: (params: LutParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) => import("remotion").EffectDescriptor<unknown>;

package/dist/mirror/index.d.ts

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

package/dist/noise-displacement.d.ts

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

package/dist/noise.d.ts

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

package/dist/outline/polygonize-alpha.d.ts

@@ -1,6 +1,6 @@
 export type OutlinePoint = readonly [x: number, y: number];
 export declare const polygonizeAlpha: ({ data, width, height, simplification, }: {
-    readonly data: Uint8ClampedArray<ArrayBufferLike>;
+    readonly data: Uint8ClampedArray;
     readonly width: number;
     readonly height: number;
     readonly simplification: number;

package/dist/outline.d.ts

@@ -1,40 +1,40 @@
 export declare const outlineSchema: {
     readonly width: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 100;
         readonly step: 1;
         readonly default: 8;
-        readonly description: "Width";
+        readonly description: 'Width';
         readonly hiddenFromList: false;
     };
     readonly edgeSimplification: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 100;
         readonly step: 1;
         readonly default: 0;
-        readonly description: "Edge simplification";
+        readonly description: 'Edge simplification';
         readonly hiddenFromList: false;
     };
     readonly color: {
-        readonly type: "color";
+        readonly type: 'color';
         readonly default: "#ffffff";
-        readonly description: "Color";
+        readonly description: 'Color';
     };
     readonly opacity: {
-        readonly type: "number";
+        readonly type: 'number';
         readonly min: 0;
         readonly max: 1;
         readonly step: 0.01;
         readonly default: 1;
-        readonly description: "Opacity";
+        readonly description: 'Opacity';
         readonly hiddenFromList: false;
     };
     readonly outlineOnly: {
-        readonly type: "boolean";
+        readonly type: 'boolean';
         readonly default: false;
-        readonly description: "Outline only";
+        readonly description: 'Outline only';
     };
 };
 export type OutlineParams = {
@@ -50,5 +50,5 @@ export type OutlineParams = {
     readonly outlineOnly?: boolean;
 };
 export declare const outline: (params?: (OutlineParams & {
-    readonly disabled?: boolean | undefined;
+    readonly disabled?: boolean;
 }) | undefined) => import("remotion").EffectDescriptor<unknown>;