reacthub-pixitweenjs 0.2.109-alpha.7 → 0.3.0-alpha.4

package/dist/constants/animation.d.ts

@@ -0,0 +1,232 @@
+/**
+ * Animation System Constants
+ *
+ * UPPER_SNAKE_CASE names match GSAP effect names in utils/gsapEffects.
+ * Use these values for transformation.animationIn.name / animationOut.name.
+ */
+export declare const ANIMATION_TIMING: {
+    /** Default animation duration in milliseconds */
+    DEFAULT_DURATION_MS: number;
+    /** Default animation duration in seconds */
+    DEFAULT_DURATION_SEC: number;
+    /** Minimum animation duration in seconds */
+    MIN_DURATION_SEC: number;
+    /** Maximum animation duration in seconds */
+    MAX_DURATION_SEC: number;
+    /**
+     * Entrance overlap at hard cuts (seconds). When element B starts exactly
+     * where element A ends AND A has an animationOut AND B has an animationIn,
+     * B's entrance begins this long BEFORE B.start so the cut crossfades
+     * instead of blinking through a near-black frame (A faded to 0 + B still
+     * at scale 0). Clamped per element to its animationIn duration and length.
+     * Must match the nodejs renderer (ENTRANCE_OVERLAP_SEC) frame-exactly.
+     */
+    ENTRANCE_OVERLAP_SEC: number;
+    /** Default speed for loop animations (e.g. SPIN_360), in full rotations per second.
+     *  0.25 = one full turn every 4s — a slow, product-turntable-style spin. */
+    DEFAULT_LOOP_ROTATIONS_PER_SEC: number; /** Loop animation speed bounds, in rotations per second. */
+    MIN_LOOP_ROTATIONS_PER_SEC: number;
+    MAX_LOOP_ROTATIONS_PER_SEC: number;
+};
+export declare const CANVAS_DEFAULTS: {
+    WIDTH: number;
+    HEIGHT: number;
+};
+export declare const ANIMATIONS_WITHOUT_ALPHA: Set<string>;
+export declare const SPECIAL_ANIMATIONS: Set<string>;
+export declare const LOOP_ANIMATIONS: Set<string>;
+/**
+ * Check if an animation name is a continuous loop animation (as opposed to
+ * an entrance/exit gsap.effects animation).
+ * @param {string} animationName
+ * @returns {boolean}
+ */
+export declare function isLoopAnimation(animationName: any): boolean;
+export declare const ANIMATION: {
+    NONE: string;
+    BOUNCE: string;
+    FLASH: string;
+    PULSE: string;
+    RUBBER_BAND: string;
+    SHAKE_X: string;
+    SHAKE_Y: string;
+    HEAD_SHAKE: string;
+    SWING: string;
+    TADA: string;
+    WOBBLE: string;
+    JELLO: string;
+    HEART_BEAT: string;
+    BACK_IN_DOWN: string;
+    BACK_IN_LEFT: string;
+    BACK_IN_RIGHT: string;
+    BACK_IN_UP: string;
+    BACK_OUT_DOWN: string;
+    BACK_OUT_LEFT: string;
+    BACK_OUT_RIGHT: string;
+    BACK_OUT_UP: string;
+    BOUNCE_IN: string;
+    BOUNCE_IN_DOWN: string;
+    BOUNCE_IN_LEFT: string;
+    BOUNCE_IN_RIGHT: string;
+    BOUNCE_IN_UP: string;
+    BOUNCE_OUT: string;
+    BOUNCE_OUT_DOWN: string;
+    BOUNCE_OUT_LEFT: string;
+    BOUNCE_OUT_RIGHT: string;
+    BOUNCE_OUT_UP: string;
+    FADE_IN: string;
+    FADE_IN_DOWN: string;
+    FADE_IN_DOWN_BIG: string;
+    FADE_IN_LEFT: string;
+    FADE_IN_LEFT_BIG: string;
+    FADE_IN_RIGHT: string;
+    FADE_IN_RIGHT_BIG: string;
+    FADE_IN_UP: string;
+    FADE_IN_UP_BIG: string;
+    FADE_IN_TOP_LEFT: string;
+    FADE_IN_TOP_RIGHT: string;
+    FADE_IN_BOTTOM_LEFT: string;
+    FADE_IN_BOTTOM_RIGHT: string;
+    FADE_OUT: string;
+    FADE_OUT_DOWN: string;
+    FADE_OUT_DOWN_BIG: string;
+    FADE_OUT_LEFT: string;
+    FADE_OUT_LEFT_BIG: string;
+    FADE_OUT_RIGHT: string;
+    FADE_OUT_RIGHT_BIG: string;
+    FADE_OUT_UP: string;
+    FADE_OUT_UP_BIG: string;
+    FADE_OUT_TOP_LEFT: string;
+    FADE_OUT_TOP_RIGHT: string;
+    FADE_OUT_BOTTOM_RIGHT: string;
+    FADE_OUT_BOTTOM_LEFT: string;
+    FLIP: string;
+    FLIP_IN_X: string;
+    FLIP_IN_Y: string;
+    FLIP_OUT_X: string;
+    FLIP_OUT_Y: string;
+    LIGHT_SPEED_IN_RIGHT: string;
+    LIGHT_SPEED_IN_LEFT: string;
+    LIGHT_SPEED_OUT_RIGHT: string;
+    LIGHT_SPEED_OUT_LEFT: string;
+    ROTATE_IN: string;
+    ROTATE_IN_DOWN_LEFT: string;
+    ROTATE_IN_DOWN_RIGHT: string;
+    ROTATE_IN_UP_LEFT: string;
+    ROTATE_IN_UP_RIGHT: string;
+    ROTATE_OUT: string;
+    ROTATE_OUT_DOWN_LEFT: string;
+    ROTATE_OUT_DOWN_RIGHT: string;
+    ROTATE_OUT_UP_LEFT: string;
+    ROTATE_OUT_UP_RIGHT: string;
+    HINGE: string;
+    JACK_IN_THE_BOX: string;
+    ROLL_IN: string;
+    ROLL_OUT: string;
+    ZOOM_IN: string;
+    ZOOM_IN_DOWN: string;
+    ZOOM_IN_LEFT: string;
+    ZOOM_IN_RIGHT: string;
+    ZOOM_IN_UP: string;
+    ZOOM_OUT: string;
+    ZOOM_OUT_DOWN: string;
+    ZOOM_OUT_LEFT: string;
+    ZOOM_OUT_RIGHT: string;
+    ZOOM_OUT_UP: string;
+    SLIDE_IN_DOWN: string;
+    SLIDE_IN_LEFT: string;
+    SLIDE_IN_RIGHT: string;
+    SLIDE_IN_UP: string;
+    SLIDE_OUT_DOWN: string;
+    SLIDE_OUT_LEFT: string;
+    SLIDE_OUT_RIGHT: string;
+    SLIDE_OUT_UP: string;
+    SPIN_360: string;
+    SCALE_POP: string;
+    WIPE_LEFT_RIGHT: string;
+    WIPE_RADIAL: string;
+    MASK_PAINT_ON: string;
+    TYPEWRITER: string;
+    RISE: string;
+    STAGGER_FADE_UP_TEXT: string;
+    STAGGER_FADE_TEXT: string;
+    STAGGER_FADE_UP: string;
+    STAGGER_FADE: string;
+    TEXT_CASCADE: string;
+    TEXT_SPOTLIGHT: string;
+    TEXT_BLINDS: string;
+    TEXT_POPCORN: string;
+    TEXT_RIPPLE: string;
+    TEXT_SHUFFLE: string;
+    TEXT_DOMINO: string;
+    TEXT_PENDULUM: string;
+    TEXT_SLIDE_REVEAL: string;
+    TEXT_SLOT: string;
+    TEXT_CURTAIN: string;
+    LIGHT_SPEED_IN: string;
+    LIGHT_SPEED_OUT: string;
+    ROATATE_IN_DOWN_LEFT: string;
+    ROATATE_IN_DOWN_RIGHT: string;
+    ROATATE_IN_UP_LEFT: string;
+    ROATATE_IN_UP_RIGHT: string;
+};
+/**
+ * Convert a camelCase animation name to UPPER_SNAKE_CASE.
+ * Uses explicit map first, then regex fallback.
+ * Already-UPPER_SNAKE_CASE names pass through unchanged.
+ *
+ * @param {string} name - Animation name in any format
+ * @returns {string} UPPER_SNAKE_CASE animation name
+ */
+export declare function camelToUpperSnake(name: any): any;
+/**
+ * Normalize animation config from various input formats.
+ * @param {string|object|null} anim - Animation name or config object
+ * @returns {{ name: string, durationSec: number }}
+ */
+interface AnimationConfig {
+    name?: string;
+    duration?: number;
+}
+interface NormalizedAnimation {
+    name: string;
+    durationSec: number;
+}
+export declare function normalizeAnimation(anim: string | AnimationConfig | null | undefined): NormalizedAnimation;
+interface LoopAnimationConfig {
+    name?: string;
+    rotationsPerSecond?: number;
+    direction?: 1 | -1;
+}
+interface NormalizedLoopAnimation {
+    name: string;
+    rotationsPerSecond: number;
+    direction: 1 | -1;
+}
+/**
+ * Normalize a loop-animation config from various input formats.
+ * Mirrors normalizeAnimation() but for `transformation.animationLoop`
+ * (continuous animations — see LOOP_ANIMATIONS).
+ * @param {string|object|null} anim - Loop animation name or config object
+ * @returns {{ name: string, rotationsPerSecond: number, direction: 1|-1 }}
+ */
+export declare function normalizeLoopAnimation(anim: string | LoopAnimationConfig | null | undefined): NormalizedLoopAnimation;
+/**
+ * Check if an animation affects the alpha/opacity of the target.
+ * @param {string} animationName - The animation name
+ * @returns {boolean}
+ */
+export declare function animationAffectsAlpha(animationName: string): boolean;
+/**
+ * Check if an animation requires special handling.
+ * @param {string} animationName - The animation name
+ * @returns {boolean}
+ */
+export declare function isSpecialAnimation(animationName: string): boolean;
+/**
+ * Check if an animation name is valid (exists as GSAP effect).
+ * @param {string} animationName - The animation name
+ * @returns {boolean}
+ */
+export declare function isValidAnimation(animationName: string): boolean;
+export {};

package/dist/constants/animationConstants.d.ts

@@ -0,0 +1,90 @@
+export declare const ANIMATION_DIRECTION: {
+    IN: string;
+    OUT: string;
+    ATTENTION: string;
+};
+export declare const ANIMATION_CATEGORY: {
+    NONE: string;
+    FADE: string;
+    SLIDE: string;
+    ZOOM: string;
+    BOUNCE: string;
+    BACK: string;
+    FLIP: string;
+    ROTATE: string;
+    ROLL: string;
+    LIGHT_SPEED: string;
+    WIPE: string;
+    SHAKE: string;
+    SPECIAL: string;
+};
+export declare const ANIMATION_DEFAULTS: {
+    OFFSET_SMALL: number;
+    OFFSET_MEDIUM: number;
+    OFFSET_LARGE: number;
+    DEFAULT_DURATION: number;
+    MIN_DURATION: number;
+    MAX_DURATION: number;
+    OPACITY_HIDDEN: number;
+    OPACITY_PARTIAL: number;
+    OPACITY_VISIBLE: number;
+    SCALE_HIDDEN: number;
+    SCALE_SMALL: number;
+    SCALE_NORMAL: number;
+    SCALE_LARGE: number;
+    ROTATION_NONE: number;
+    ROTATION_SMALL: number;
+    ROTATION_MEDIUM: number;
+    ROTATION_LARGE: number;
+    ROTATION_FULL: number;
+};
+export declare const EASING_PRESETS: {
+    EASE_IN_OUT: string;
+    EASE_OUT: string;
+    EASE_IN: string;
+    EASE_OUT_STRONG: string;
+    EASE_IN_STRONG: string;
+    BOUNCE_OUT: string;
+    BOUNCE_IN: string;
+    ELASTIC_OUT: string;
+    BACK_OUT: string;
+    BACK_IN: string;
+};
+export declare const BEZIER_CURVES: {
+    EASE_IN_OUT: number[];
+    EASE_OUT: number[];
+    EASE_IN: number[];
+    BOUNCE: number[];
+    SMOOTH: number[];
+    ZOOM_OUT: number[];
+    ZOOM_IN: number[];
+};
+export declare const SPRING_CONFIG: {
+    DEFAULT: {
+        damping: number;
+        stiffness: number;
+        mass: number;
+    };
+    BOUNCY: {
+        damping: number;
+        stiffness: number;
+        mass: number;
+    };
+    SMOOTH: {
+        damping: number;
+        stiffness: number;
+        mass: number;
+    };
+};
+export declare const KEYFRAME_PRESETS: {
+    BOUNCE_IN: number[];
+    BOUNCE_IN_VALUES: number[];
+    SHAKE: number[];
+    SHAKE_VALUES: number[];
+    HEARTBEAT: number[];
+    HEARTBEAT_VALUES: number[];
+    PULSE: number[];
+    PULSE_VALUES: number[];
+};
+export declare function getAnimationDirection(animationName: string): string | null;
+export declare function getAnimationCategory(animationName: string): string;

package/dist/constants/elementNames.d.ts

@@ -0,0 +1,4 @@
+export declare const PIXITEXT_HITAREA_PREFIX = "pixitext-hitarea";
+export declare const getPixiTextHitAreaName: (uniqueId: string) => string;
+/** Label of the PIXI.Text node inside PixiTextSprite, for `getChildByLabel(label, true)`. */
+export declare const PIXITEXT_TEXT_LABEL = "pixitext-text";

package/dist/events/Events.d.ts

@@ -1,5 +1,4 @@
 import { DependencyList } from 'react';
-
 export declare function useCustomEventListener<T>(eventName: string, eventHandler: (data: T) => void, deps?: DependencyList): (el: HTMLElement | null) => void;
 export declare function emitCustomEvent<T>(eventName: string, data?: T): void;
 export declare function newCustomEventEmitter(): {

package/dist/filters/animated-vfx/AnimatedVfxFilter.d.ts

@@ -0,0 +1,19 @@
+import { Filter } from 'pixi.js';
+import { CreateAnimatedVfxFilterOptions } from './types';
+/**
+ * Generic time-driven VFX filter.
+ *
+ * `useSpriteFilters` advances `.time` for every filter with `__vfxAnimated`.
+ * Keep this contract stable so editor preview, scrubbing, and Remotion export
+ * all use the same deterministic timeline clock.
+ */
+export declare class AnimatedVfxFilter extends Filter {
+    readonly __vfxAnimated = true;
+    private vfx;
+    constructor({ fragment, name, intensity, uniforms }: CreateAnimatedVfxFilterOptions);
+    apply(filterManager: any, input: any, output: any, clearMode: any): void;
+    get time(): number;
+    set time(value: number);
+    get intensity(): number;
+    set intensity(value: number);
+}

package/dist/filters/animated-vfx/composeShader.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultAnimatedVfxVertex: string;
+export declare const composeAnimatedVfxFragment: (body: string) => string;

package/dist/filters/animated-vfx/index.d.ts

@@ -0,0 +1,14 @@
+export { AnimatedVfxFilter } from './AnimatedVfxFilter';
+export { animatedVfxRegistry, isAnimatedVfxEffectName, type AnimatedVfxEffectName, } from './registry/animatedVfxRegistry';
+export declare const createVhsFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createGlitchWaveFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createLightLeakFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createFilmGrainFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createChromaticWaveFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createLiquidGlassFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createBrokenGlassFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createComicFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createWaveTearDownFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createWaveTearUpFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createWaveTearAcrossFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;
+export declare const createWaveBrushFilter: (intensity?: number) => import('./AnimatedVfxFilter').AnimatedVfxFilter;

package/dist/filters/animated-vfx/registry/animatedVfxRegistry.d.ts

@@ -0,0 +1,65 @@
+import { AnimatedVfxFilter } from '../AnimatedVfxFilter';
+export declare const animatedVfxRegistry: {
+    VHS: {
+        shaderName: string;
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    GlitchWave: {
+        shaderName: string;
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    LightLeak: {
+        shaderName: string;
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    FilmGrain: {
+        shaderName: string;
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    ChromaticWave: {
+        shaderName: string;
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    LiquidGlass: {
+        shaderName: string;
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    BrokenGlass: {
+        shaderName: string;
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    Comic: {
+        shaderName: string;
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    WaveTearDown: {
+        shaderName: "vfx-wave-tear-down";
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    WaveTearUp: {
+        shaderName: "vfx-wave-tear-up";
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    WaveTearAcross: {
+        shaderName: "vfx-wave-tear-across";
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+    WaveBrush: {
+        shaderName: string;
+        defaultIntensity: number;
+        create: (intensity?: number | undefined) => AnimatedVfxFilter;
+    };
+};
+export type AnimatedVfxEffectName = keyof typeof animatedVfxRegistry;
+export declare const isAnimatedVfxEffectName: (effect: string) => effect is AnimatedVfxEffectName;

package/dist/filters/animated-vfx/registry/waveTearVariants.d.ts

@@ -0,0 +1,14 @@
+export declare const WAVE_TEAR_VARIANTS: {
+    readonly WaveTearDown: {
+        readonly shaderName: "vfx-wave-tear-down";
+        readonly direction: Float32Array<ArrayBuffer>;
+    };
+    readonly WaveTearUp: {
+        readonly shaderName: "vfx-wave-tear-up";
+        readonly direction: Float32Array<ArrayBuffer>;
+    };
+    readonly WaveTearAcross: {
+        readonly shaderName: "vfx-wave-tear-across";
+        readonly direction: Float32Array<ArrayBuffer>;
+    };
+};

package/dist/filters/animated-vfx/toStrength.d.ts

@@ -0,0 +1 @@
+export declare const toStrength: (intensity: number, max?: number) => number;

package/dist/filters/animated-vfx/types.d.ts

@@ -0,0 +1,18 @@
+import { AnimatedVfxFilter } from './AnimatedVfxFilter';
+export type AnimatedVfxUniformValue = number | Float32Array;
+export interface AnimatedVfxUniformDefinition {
+    value: AnimatedVfxUniformValue;
+    type: string;
+}
+export type AnimatedVfxUniformDefinitions = Record<string, AnimatedVfxUniformDefinition>;
+export interface CreateAnimatedVfxFilterOptions {
+    name: string;
+    fragment: string;
+    intensity: number;
+    uniforms?: AnimatedVfxUniformDefinitions;
+}
+export interface AnimatedVfxDefinition {
+    shaderName: string;
+    defaultIntensity: number;
+    create: (intensity?: number) => AnimatedVfxFilter;
+}

package/dist/filters/animatedVfxFilters.d.ts

@@ -0,0 +1 @@
+export * from './animated-vfx';

package/dist/filters/blend-mode/createBlendCompositeFilter.d.ts

@@ -0,0 +1,26 @@
+import { Filter } from 'pixi.js';
+/**
+ * Builds a PIXI Filter that composites its input using the given blend mode,
+ * meant to be appended as the LAST entry of an element's own `filters` array
+ * — NOT applied via `Container.blendMode`.
+ *
+ * WHY: in PIXI v8, once an object has its own `filters` array, the object's
+ * effective blend mode against its backdrop is decided entirely by the LAST
+ * filter's own `Filter.blendMode` / shader (each filter carries its own
+ * compositing state). A `blendMode` set on the object or an ancestor
+ * Container is silently ignored the moment that object also has `filters` —
+ * PixiJS's BlendModePipe pushes the blend as a nested filter *inside* the
+ * object's own filter push, so its backdrop capture reads the object's own
+ * (still-empty) offscreen filter texture instead of the real scene, and the
+ * blend collapses to "just show the foreground normally".
+ *
+ * Appending the correct blend filter as the last item of the SAME `filters`
+ * array avoids this: the whole chain is one filter push, so the backdrop is
+ * captured once, correctly, and this filter's blend state is what finally
+ * composites the (fully color-adjusted) result back onto the real scene.
+ *
+ * Only call this when the element already has >0 other filters — with zero
+ * filters, `Container.blendMode` on `AbstractContainer`'s outer wrapper
+ * already works correctly (no offscreen filter pass to interfere with it).
+ */
+export declare const createBlendCompositeFilter: (blendModeCode: number | undefined | null) => Filter | null;

package/dist/filters/edge-feather/EdgeFeatherFilter.d.ts

@@ -0,0 +1,19 @@
+import { Filter } from 'pixi.js';
+/**
+ * EdgeFeatherFilter
+ *
+ * Fades an element's alpha to 0 near its own rectangular edges so that blend
+ * modes / composites melt smoothly into whatever is behind them, instead of
+ * showing the element's hard rectangle cutoff.
+ *
+ * `featherAmount` is 0 (no feather, sharp edge) to 1 (fully faded from the
+ * element's center outward — feather radius equals half of its shorter
+ * dimension).
+ */
+export declare class EdgeFeatherFilter extends Filter {
+    private edge;
+    constructor(featherAmount: number);
+    apply(filterManager: any, input: any, output: any, clearMode: any): void;
+    get featherAmount(): number;
+    set featherAmount(value: number);
+}

package/dist/filters/plate-key/PlateKeyFilter.d.ts

@@ -0,0 +1,29 @@
+import { Filter } from 'pixi.js';
+/**
+ * PlateKeyFilter
+ *
+ * Knocks a flat background plate out of a logo/wordmark image at draw time.
+ *
+ * Why this exists: uploaded brand assets frequently carry a baked-in solid
+ * background. The CoffeeCo brand-kit logo is a 512x512 RGBA PNG that is 100%
+ * opaque, with every corner at rgb(236,234,218) — so the end card composited it
+ * as a hard cream rectangle floating over the plate. Measured on that asset,
+ * the border ring has a standard deviation of 3.2, i.e. it is genuinely flat and
+ * safe to key; a tolerance of ~0.16 (40/255) lifts it cleanly while leaving the
+ * dark brown lettering and the fine gold filigree untouched.
+ *
+ * This is a render-time repair, not a replacement for storing a transparent
+ * asset. It exists because the assets already sitting in customer workspaces
+ * cannot be re-uploaded retroactively.
+ */
+export declare class PlateKeyFilter extends Filter {
+    private plate;
+    constructor(keyColor: [number, number, number], tolerance?: number, softness?: number);
+    get tolerance(): number;
+    set tolerance(value: number);
+    set keyColor(rgb: [number, number, number]);
+}
+/** Parse `#RRGGBB` / `0xRRGGBB` / `rgb(r,g,b)` into normalised 0..1 RGB. */
+export declare function parsePlateKeyColor(input: string | number | null | undefined): [number, number, number] | null;
+/** The cream/near-white plate that uploaded logos ship with most often. */
+export declare const DEFAULT_PLATE_KEY_COLOR: [number, number, number];

package/dist/hocs/AbstractContainer.d.ts

@@ -2,6 +2,11 @@ import { PixiBaseSpriteProps, ForwardedRefResponse, containerScale } from '../ty
 import * as React from "react";
 import * as PIXI from "pixi.js";
 interface AbstractContainerProps extends PixiBaseSpriteProps {
+    /** Container label/id override. Defaults to `getElementName(uniqueId)`. */
+    id?: string;
+    sortableChildren?: boolean;
+    /** Text handed to text-unit / typewriter effects (see usePixiAnimation). */
+    animationText?: string;
     ignoreTlForVideo?: boolean;
     isText?: boolean;
     isDragging?: boolean;
@@ -26,5 +31,7 @@ interface AbstractContainerProps extends PixiBaseSpriteProps {
      */
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
 }
-declare const AbstractContainer: React.ForwardRefExoticComponent<AbstractContainerProps & React.RefAttributes<ForwardedRefResponse | null>>;
+declare const AbstractContainer: ({ ref, ...props }: AbstractContainerProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
 export default AbstractContainer;

package/dist/hocs/BorderMaskContainer.d.ts

@@ -0,0 +1,43 @@
+import { Container } from 'pixi.js';
+import { CropRect } from '../types/CropTypes';
+import { MaskShapeInput } from './drawMaskShape';
+import * as React from "react";
+export interface BorderConfig {
+    width: number;
+    color: number | string | null;
+}
+export interface BorderMaskContainerProps {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    border?: BorderConfig;
+    /** `true` = radius 10% of the shorter side; a number = radius in px. */
+    roundedCorners?: boolean | number;
+    maskShape?: MaskShapeInput;
+    /**
+     * Sprite-local crop rect (top-left origin). The mask, border and named shape
+     * are all drawn inside this sub-rect.
+     */
+    crop?: CropRect;
+    spriteRef?: React.RefObject<Container | null>;
+    children?: React.ReactNode;
+}
+/**
+ * BorderMaskContainer — wraps a sprite child with an optional stroke border
+ * and/or a Graphics mask (rounded rect, named shape, or crop rect).
+ *
+ * Ported from the Clippy editor:
+ *  - declarative `draw` callbacks (redraw when their deps change)
+ *  - `useLayoutEffect` attaches the mask before paint (no unmasked flash)
+ *  - the wrapper container is ALWAYS rendered, so toggling a border/mask never
+ *    changes the tree shape and remounts the sprite child (texture/ref reset)
+ *  - mask/border Graphics mount only when needed: an empty Graphics still adds
+ *    its (0,0) origin to the parent's getBounds() and inflates transformer boxes
+ */
+declare const BorderMaskContainer: {
+    ({ x, y, width, height, border, roundedCorners, maskShape, crop, spriteRef, children, }: BorderMaskContainerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default BorderMaskContainer;
+export { BorderMaskContainer };

package/dist/hocs/OverlayTilingSprite.d.ts

@@ -1,4 +1,4 @@
-export declare enum OverlayTypes {
+export declare enum OverlayTilingSpriteTypes {
     NONE = "none",
     NORMAL = "normal",
     LENSFLARE = "lensflare",
@@ -20,11 +20,11 @@ export interface Overlays {
 }
 export declare const overlays: Overlays;
 interface PixiOverlayProps {
-    overlay: OverlayTypes;
+    overlay: OverlayTilingSpriteTypes;
     width: number;
     height: number;
     x: number;
     y: number;
 }
-export declare const PixiOverlayTilingSprite: (props: PixiOverlayProps) => import("react/jsx-runtime").JSX.Element;
+export declare const PixiOverlayTilingSprite: (props: PixiOverlayProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/hocs/drawMaskShape.d.ts

@@ -0,0 +1,7 @@
+import { Graphics } from 'pixi.js';
+import { MaskTypes } from '../types/MaskTypes';
+import { CropRect } from '../types/CropTypes';
+/** Accepts the enum or its plain string value (e.g. 'circle' from JSON). */
+export type MaskShapeInput = MaskTypes | `${MaskTypes}`;
+export declare function drawMaskShape(g: Graphics, shape: MaskShapeInput, cx: number, cy: number, w: number, h: number, crop?: CropRect): void;
+export declare function applyMaskClipPath(ctx: CanvasRenderingContext2D, shape: MaskShapeInput, w: number, h: number, crop?: CropRect): void;

package/dist/hocs/index.d.ts

@@ -0,0 +1,5 @@
+export { default as AbstractContainer } from './AbstractContainer';
+export { default as BorderMaskContainer } from './BorderMaskContainer';
+export type { BorderMaskContainerProps, BorderConfig } from './BorderMaskContainer';
+export { drawMaskShape } from './drawMaskShape';
+export * from './OverlayTilingSprite';

package/dist/hooks/aep/buildAudioLevelTimeline.d.ts

@@ -0,0 +1,7 @@
+import { AepAnimatable } from '../../types/aep';
+import { AepScalarTimelineBuild } from './buildScalarValueTimeline';
+export type AepAudioLevelBuild = AepScalarTimelineBuild;
+export interface AudioLevelTarget {
+    level: number;
+}
+export declare function buildAudioLevelTimeline(level: AepAnimatable<number> | undefined, fps: number, inPointFrames: number, target: AudioLevelTarget): AepAudioLevelBuild;