react-motion-gallery 2.0.19 → 2.0.20

package/dist/types-CfvTYIyd.d.mts

@@ -0,0 +1,450 @@
+import { B as BreakpointMap, R as ResponsiveNumber } from './responsiveNumber-CouEMJ9O.mjs';
+import { RefObject } from 'react';
+import { L as LoadingForceOptions } from './force-C5m1QpdF.mjs';
+import { MediaItem } from './media.mjs';
+
+type ArrowRenderArgs = {
+    ref: React.RefObject<HTMLDivElement | null>;
+    onClick: () => void;
+    hidden: boolean;
+    disabled: boolean;
+    createRipple: (el: HTMLElement) => void;
+    className?: string;
+};
+type DotsRenderArgs = {
+    ref: React.RefObject<HTMLDivElement | null>;
+    count: number;
+    activeIndex: number;
+    hidden: boolean;
+    goTo: (index: number) => void;
+    getDotRef: (index: number) => (el: HTMLDivElement | null) => void;
+    createRipple: (el: HTMLElement) => void;
+    classNameContainer?: string;
+    classNameDot?: string;
+};
+type ProgressRenderArgs = {
+    ref: React.Ref<HTMLDivElement>;
+    innerRef?: React.Ref<HTMLDivElement>;
+    hidden: boolean;
+    progress: number;
+    axis: 'x' | 'y';
+    className?: string;
+    style?: React.CSSProperties;
+    innerClassName?: string;
+    innerStyle?: React.CSSProperties;
+};
+type ScrollbarRenderArgs = {
+    ref: React.RefObject<HTMLInputElement | null>;
+    hidden: boolean;
+    value: number;
+    axis: 'x' | 'y';
+    min: number;
+    max: number;
+    step: number;
+    onChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    className?: string;
+    style?: React.CSSProperties;
+};
+
+type ElementStyle = {
+    className?: string;
+    style?: React.CSSProperties;
+};
+
+type IndexMode = "animated" | "instant";
+type FullscreenOpenMethod = "fade" | "scale";
+type OpenFullscreenAtArgs = {
+    index: number;
+    method?: FullscreenOpenMethod;
+    event?: Event;
+};
+type FullscreenOpenSource = "slider" | "grid" | "masonry" | "entries" | "api";
+type FullscreenOpenRequest = {
+    source: FullscreenOpenSource;
+    index: number;
+    image: HTMLImageElement | null;
+    method?: FullscreenOpenMethod;
+    requestedMethod?: FullscreenOpenMethod;
+    event?: Event;
+};
+interface GalleryCoreApi {
+    layout: "slider" | "grid" | "masonry" | "entries" | null;
+    effectiveBreakpoints: BreakpointMap;
+    normalizedItems: MediaItem[];
+    fsEnabled: boolean;
+    setFsEnabled: (enabled: boolean) => void;
+    isFullscreenOpen: boolean;
+    isFullscreenOpenRef: React.RefObject<boolean>;
+    setFullscreenOpen: (open: boolean) => void;
+    openFullscreenAt: (args: OpenFullscreenAtArgs) => void;
+    notifyBaseVisibleIndex: (index: number) => void;
+    notifyFsVisibleIndex: (index: number) => void;
+    registerExpandableImage: (index: number, node: HTMLElement | null) => void;
+}
+interface GalleryLayoutApi {
+    rootNode(): HTMLElement | null;
+    containerNode(): HTMLElement | null;
+    getViewportNode: () => HTMLDivElement | null;
+    slideNodes(): HTMLElement[];
+    onReady?(cb: (nodes: HTMLElement[]) => void): () => void;
+    whenReady?(): Promise<HTMLElement[]>;
+    isReady?(): boolean;
+    scrollTo(index: number, jump?: boolean): void;
+    scrollNext(jump?: boolean): void;
+    scrollPrev(jump?: boolean): void;
+    canScrollNext(): boolean;
+    canScrollPrev(): boolean;
+    getIndex(): number;
+    selectCell(index: number, jump?: boolean): void;
+    scrollProgress(): number;
+    cellsInView(): number[];
+}
+interface GalleryApi extends GalleryLayoutApi, SliderApi {
+    openFullscreenAt: (args: OpenFullscreenAtArgs) => void;
+}
+
+type IndexListener = () => void;
+type IndexEventMeta = {
+    source?: "thumbnail" | "external";
+    transition?: "scroll" | "crossfade";
+    crossfade?: {
+        durationMs?: number;
+        easing?: string;
+    };
+};
+type IndexEvent = {
+    type: "set";
+    index: number;
+    mode: IndexMode;
+    meta?: IndexEventMeta;
+} | {
+    type: "bump";
+    delta: number;
+    mode: IndexMode;
+    meta?: IndexEventMeta;
+};
+type EventListener = (ev: IndexEvent) => void;
+type BasePointerDownListener = () => void;
+type SliderIndexChannel = ReturnType<typeof createSliderIndexChannel>;
+declare function createSliderIndexChannel(initialIndex?: number, initialMode?: IndexMode): {
+    get(): {
+        index: number;
+        mode: IndexMode;
+    };
+    set(next: number, m?: IndexMode, opts?: {
+        silent?: boolean;
+        meta?: IndexEventMeta;
+    }): void;
+    bump(delta: number, m?: IndexMode, opts?: {
+        silent?: boolean;
+        meta?: IndexEventMeta;
+    }): void;
+    subscribe(fn: IndexListener): () => void;
+    onEvent(fn: EventListener): () => void;
+    onBasePointerDown(fn: BasePointerDownListener): () => void;
+    emitBasePointerDown: () => void;
+};
+
+type SliderNodeInput = React.ReactNode | React.ReactNode[];
+type SliderRemoveTarget = number | ((i: number) => boolean);
+interface SliderItemsApi {
+    append(nodes: SliderNodeInput): number;
+    prepend(nodes: SliderNodeInput): number;
+    insert(index: number, nodes: SliderNodeInput): number;
+    remove(indexOrPredicate: SliderRemoveTarget): number;
+    replace(index: number, node: React.ReactNode): void;
+    setItems(nodes: React.ReactNode[]): number;
+}
+interface SliderApi extends SliderItemsApi {
+    onIndexChange(cb: (i: number, meta: {
+        mode: IndexMode;
+    }) => void): () => void;
+}
+type ResponsiveHeightRule = {
+    query: string;
+    height: string;
+};
+type SliderLayout = {
+    gap?: number;
+    cellsPerSlide?: ResponsiveNumber;
+};
+type SliderDirection = {
+    dir?: "ltr" | "rtl";
+    axis?: "x" | "y";
+};
+type SliderElements = {
+    viewport?: ElementStyle;
+    container?: ElementStyle;
+};
+type SliderSkipSnapsOptions = {
+    enabled?: boolean;
+    threshold?: number;
+};
+type SliderSkipSnaps = boolean | SliderSkipSnapsOptions;
+type SliderScroll = {
+    groupCells?: boolean;
+    skipSnaps?: SliderSkipSnaps;
+    strictSnaps?: boolean;
+    freeScroll?: boolean;
+    loop?: boolean;
+};
+type SliderArrows = {
+    enabled?: boolean;
+    arrow?: ElementStyle;
+    prev?: ElementStyle;
+    next?: ElementStyle;
+    render?: (args: ArrowRenderArgs & {
+        dir: "prev" | "next";
+    }) => React.ReactNode;
+    renderPrev?: (args: ArrowRenderArgs) => React.ReactNode;
+    renderNext?: (args: ArrowRenderArgs) => React.ReactNode;
+};
+type SliderDots = {
+    enabled?: boolean;
+    root?: ElementStyle;
+    dot?: ElementStyle;
+    render?: (args: DotsRenderArgs) => React.ReactNode;
+};
+type SliderProgress = {
+    enabled?: boolean;
+    root?: ElementStyle;
+    bar?: ElementStyle;
+    render?: (args: ProgressRenderArgs) => React.ReactNode;
+};
+type SliderScrollbar = {
+    enabled?: boolean;
+    root?: ElementStyle;
+    render?: (args: ScrollbarRenderArgs) => React.ReactNode;
+};
+type SliderRipple = {
+    enabled?: boolean;
+    className?: string;
+};
+type SliderAutoPlay = {
+    enabled?: boolean;
+    speedMs?: number;
+    pauseMs?: number;
+    pauseOnHover?: boolean;
+};
+type SliderAutoPlayTimer = {
+    active: boolean;
+    speedMs: number;
+    startedAt: number | null;
+    elapsedMs: number;
+    remainingMs: number;
+    progress: number;
+};
+type SliderAutoScroll = {
+    enabled?: boolean;
+    speedMs?: number;
+    pauseMs?: number;
+    pauseOnHover?: boolean;
+};
+type SliderAutoHeight = {
+    enabled?: boolean;
+    duration?: string;
+    easing?: string;
+};
+type SliderLoadingOptions = {
+    enabled?: boolean;
+    force?: LoadingForceOptions;
+    skeletonCount?: ResponsiveNumber;
+    renderLoading?: (args: {
+        count: number;
+    }) => React.ReactNode;
+};
+type SliderIntroOptions = {
+    renderIntro?: (args: {
+        active: boolean;
+        containerProps: React.HTMLAttributes<HTMLDivElement>;
+    }, content: React.ReactNode) => React.ReactNode;
+    inView?: boolean;
+    staggerMs?: number;
+    durationMs?: number;
+    easing?: string;
+};
+type SliderTransitions = {
+    intro?: SliderIntroOptions;
+};
+type SliderParallax = {
+    enabled?: boolean;
+    bleedPct?: string;
+    borderRadius?: string;
+    sideWidth?: string;
+};
+type SliderScale = {
+    enabled?: boolean;
+    amount?: number;
+};
+type SliderFade = {
+    enabled?: boolean;
+    minOpacity?: number;
+};
+type CrossFadeWheelOptions = {
+    enabled?: boolean;
+    sensitivity?: number;
+    commitThreshold?: number;
+    durationMs?: number;
+    sessionGapMs?: number;
+};
+type CrossFadeWheel = boolean | CrossFadeWheelOptions;
+type CrossFade = {
+    controls?: boolean;
+    drag?: boolean;
+    wheel?: CrossFadeWheel;
+    durationMs?: number;
+    easing?: string;
+};
+type SliderMotion = {
+    selectDuration?: number;
+    freeScrollDuration?: number;
+    friction?: number;
+};
+type SliderLazyLoadOptions = {
+    enabled?: boolean;
+    spinner?: boolean | React.ReactNode | ((args: {
+        kind: "image" | "video";
+        isClone: boolean;
+    }) => React.ReactNode);
+    spinnerClassName?: string;
+    spinnerStyle?: React.CSSProperties;
+};
+type SliderPluginKind = "arrows" | "dots" | "progress" | "scrollbar" | "ripple" | "auto-play" | "auto-scroll" | "auto-height" | "lazy-load" | "parallax" | "scale" | "fade" | "crossfade" | "fullscreen" | "loading";
+type SliderPluginHost = {
+    handle: SliderHandle | null;
+    coreReady: boolean;
+    index: number;
+    slideCount: number;
+    cellsInView: number[];
+    progress: number;
+    axis: "x" | "y";
+    dir: "ltr" | "rtl";
+    loop: boolean;
+    freeScroll: boolean;
+    canScrollPrev: boolean;
+    canScrollNext: boolean;
+    createRipple: (el: HTMLElement) => void;
+    hasPlugin: (kind: SliderPluginKind) => boolean;
+    setPluginReady: (ready: boolean) => void;
+    setAutoPlayTimer: (timer: SliderAutoPlayTimer | null) => void;
+};
+type SliderPluginRuntimeProps = {
+    host: SliderPluginHost;
+};
+type SliderPlugin = {
+    readonly __rmgSliderPlugin: true;
+    readonly kind: SliderPluginKind;
+    readonly options?: unknown;
+    readonly blocksReady?: boolean;
+    transformChildren?: (children: React.ReactNode, options?: unknown) => React.ReactNode;
+    Runtime?: React.ComponentType<SliderPluginRuntimeProps & {
+        options?: unknown;
+    }>;
+    renderOverlay?: (host: SliderPluginHost, options?: unknown) => React.ReactNode;
+};
+type SliderOptions = {
+    initialIndex?: number;
+    layout?: SliderLayout;
+    direction?: SliderDirection;
+    align?: "start" | "center";
+    scroll?: SliderScroll;
+    elements?: SliderElements;
+    transitions?: SliderTransitions;
+    motion?: SliderMotion;
+    indexChannel?: SliderIndexChannel;
+    plugins?: SliderPlugin[];
+};
+type SliderUiSelectOptions = {
+    crossfade?: boolean;
+    durationMs?: number;
+    easing?: string;
+};
+type SliderMotionSnapshot = {
+    location: number;
+    previous: number;
+    offset: number;
+    target: number;
+    x: number;
+};
+type SliderCrossfadeCoreApi = {
+    getIndex: () => number;
+    getSlideCount: () => number;
+    getViewportMainSize: () => number;
+    getViewportNode: () => HTMLDivElement | null;
+    getSnapLocationForIndex: (index: number) => number;
+    readMotionState: () => SliderMotionSnapshot;
+    restoreMotionState: (state: SliderMotionSnapshot) => void;
+    renderTrackAtLocation: (location: number) => void;
+    jumpTrackToIndexInstant: (index: number) => void;
+    jumpToIndexInstant: (index: number, mode?: IndexMode) => void;
+    commitIndexOnly: (index: number, mode: IndexMode, sourceIndex?: number) => void;
+};
+type SliderCrossfadeRuntime = {
+    isBusy: () => boolean;
+    finish: () => void;
+    canUseDrag: () => boolean;
+    beginDrag: () => void;
+    updateDrag: (delta: number) => boolean;
+    settleDrag: (force: number) => boolean;
+    canUseWheel: () => boolean;
+    updateWheel: (signedWheelDelta: number, now: number) => boolean;
+    clearWheelSession: () => void;
+    startUi: (index: number, options?: {
+        durationMs?: number;
+        easing?: string;
+    }) => boolean;
+};
+interface SliderCoreHandle {
+    centerSlider: () => void;
+    getIndex: () => number;
+    setIndex: (i: number, mode?: IndexMode) => void;
+    subscribeIndex: (fn: () => void) => () => void;
+    getAutoPlayTimer: () => SliderAutoPlayTimer;
+    slideIndexForCell: (cellIndex: number) => number;
+    getRootNode(): HTMLElement | null;
+    getContainerNode(): HTMLElement | null;
+    getSlideNodes(): HTMLElement[];
+    getViewportNode: () => HTMLDivElement | null;
+    onSlidesBuilt(cb: (nodes: HTMLElement[]) => void): () => void;
+    whenSlidesBuilt(): Promise<HTMLElement[]>;
+    isSlidesBuilt(): boolean;
+    onReady(cb: (nodes: HTMLElement[]) => void): () => void;
+    whenReady(): Promise<HTMLElement[]>;
+    isReady(): boolean;
+    scrollNext: (mode?: IndexMode) => void;
+    scrollPrev: (mode?: IndexMode) => void;
+    canScrollNext: () => boolean;
+    canScrollPrev: () => boolean;
+    scrollProgress: () => number;
+    cellsInView: () => number[];
+    getInternals(): {
+        slides: RefObject<{
+            cells: {
+                element: HTMLElement;
+                index: number;
+            }[];
+            target: number;
+        }[]>;
+        slider: RefObject<HTMLDivElement | null>;
+        sliderWidth: RefObject<number>;
+        offsetLocation: RefObject<{
+            get(): number;
+        } | null>;
+        visibleImages: RefObject<number>;
+        selectedIndex: RefObject<number>;
+        sliderX: RefObject<number>;
+        sliderVelocity: RefObject<number>;
+        isWrapping: RefObject<boolean>;
+        getCenterOffsetForIndex: (idx: number) => number;
+    };
+    _scrollByPixels?: (deltaPx: number) => boolean;
+    _scrollToProgressFromUi?: (progress: number) => boolean;
+    _usesLegacyEngine?: boolean;
+    _getCrossfadeCore?: () => SliderCrossfadeCoreApi;
+    _registerCrossfadeRuntime?: (runtime: SliderCrossfadeRuntime | null) => () => void;
+    setIndexFromUi: (i: number, opts?: SliderUiSelectOptions) => void;
+}
+interface SliderHandle extends SliderCoreHandle, SliderApi {
+}
+
+export { type ArrowRenderArgs as A, type SliderRipple as B, type CrossFade as C, type SliderScale as D, type ElementStyle as E, type SliderScrollbar as F, type GalleryApi as G, type FullscreenOpenRequest as H, type IndexMode as I, type FullscreenOpenMethod as J, type ResponsiveHeightRule as R, type SliderAutoHeight as S, type GalleryCoreApi as a, type GalleryLayoutApi as b, createSliderIndexChannel as c, type CrossFadeWheel as d, type CrossFadeWheelOptions as e, type SliderAutoPlayTimer as f, type SliderSkipSnaps as g, type SliderSkipSnapsOptions as h, type SliderOptions as i, type SliderHandle as j, type SliderApi as k, type SliderItemsApi as l, type SliderNodeInput as m, type SliderRemoveTarget as n, type SliderPlugin as o, type SliderPluginKind as p, type SliderIndexChannel as q, type SliderArrows as r, type SliderAutoPlay as s, type SliderAutoScroll as t, type SliderDots as u, type SliderFade as v, type SliderLazyLoadOptions as w, type SliderLoadingOptions as x, type SliderParallax as y, type SliderProgress as z };

package/dist/{types-CHUayqcj.d.mts → types-DP7ogmr4.d.mts}

@@ -1,6 +1,8 @@
 import * as React from 'react';
-import { E as ElementStyle, R as ResponsiveNumber, L as LoadingTimingOptions, c as BreakpointMap } from './responsive-D_xhZmVI.mjs';
-import { A as ArrowRenderArgs } from './controls-SpWg1Kgt.mjs';
+import { R as ResponsiveNumber, B as BreakpointMap } from './responsiveNumber-CouEMJ9O.mjs';
+import { L as LoadingForceOptions } from './force-C5m1QpdF.mjs';
+import { E as ElementStyle, A as ArrowRenderArgs } from './types-CfvTYIyd.mjs';
+import { L as LoadingTimingOptions } from './transitions-DU3ftmIq.mjs';
 
 type ThumbnailPosition = "top" | "right" | "bottom" | "left";
 type ResponsivePosition = ThumbnailPosition | Array<ThumbnailPosition> | Record<string, ThumbnailPosition>;
@@ -15,7 +17,7 @@ type ThumbnailLoadingRenderArgs = {
 };
 type ThumbnailLoadingOptions = {
     enabled?: boolean;
-    force?: boolean;
+    force?: LoadingForceOptions;
     skeletonCount?: ResponsiveNumber;
     mode?: ThumbnailSkeletonMode;
     renderLoading?: (args: ThumbnailLoadingRenderArgs) => React.ReactNode;

package/dist/types-DWzjXjYR.d.mts

@@ -0,0 +1,48 @@
+import { R as ResponsiveNumber } from './responsiveNumber-CouEMJ9O.mjs';
+import { G as GalleryLazyLoadOptions } from './lazy-dGoYpcRa.mjs';
+
+type IntroOptions = {
+    renderIntro?: (args: {
+        active: boolean;
+        containerProps: React.HTMLAttributes<HTMLDivElement>;
+    }, content: React.ReactNode) => React.ReactNode;
+    staggerMs?: number;
+    durationMs?: number;
+    easing?: string;
+    staggerLimit?: number;
+};
+type FullscreenTrigger = "item" | "media";
+type MasonryLazyLoadOptions = GalleryLazyLoadOptions;
+type MasonrySpan = number | "full";
+type ResponsiveMasonrySpan = MasonrySpan | Record<string, MasonrySpan>;
+type MasonryItemProps = {
+    span?: ResponsiveMasonrySpan;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+};
+type MasonryHandle = {
+    getRootNode: () => HTMLElement | null;
+    getItemNodes: () => HTMLElement[];
+    isReady: () => boolean;
+    onReady: (callback: (nodes: HTMLElement[]) => void) => () => void;
+};
+type MasonryOptions = {
+    columns?: ResponsiveNumber;
+    gap?: ResponsiveNumber;
+    placement?: "balanced" | "roundRobin" | "horizontalOrder";
+    fullscreenTrigger?: FullscreenTrigger;
+    itemWrapClassName?: string;
+    itemWrapStyle?: React.CSSProperties;
+    as?: React.ElementType;
+    rootRef?: React.Ref<HTMLDivElement>;
+    classNames?: {
+        root?: string;
+        column?: string;
+        item?: string;
+    };
+    lazyLoad?: MasonryLazyLoadOptions;
+    intro?: IntroOptions;
+};
+
+export type { IntroOptions as I, MasonryHandle as M, ResponsiveMasonrySpan as R, MasonryItemProps as a, MasonryLazyLoadOptions as b, MasonryOptions as c, MasonrySpan as d };

package/dist/video.css

@@ -1 +1 @@
-.Re{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:44px;height:44px;border-radius:50%;pointer-events:none;opacity:0;visibility:hidden;transition:opacity .18s ease;will-change:opacity;z-index:3;animation:I 1s linear infinite;background:conic-gradient(from 0deg,#fff,#cfe6ff,#8ec5ff,#4ea1ff,#2f7fff,#1d4ed8);-webkit-mask:radial-gradient(farthest-side,transparent calc(100% - 4px),#000 0);mask:radial-gradient(farthest-side,transparent calc(100% - 4px),#000 0)}.Se{position:absolute;inset:0;display:grid;place-items:center;pointer-events:none;opacity:0;visibility:hidden;transition:opacity .18s ease;will-change:opacity;z-index:3}@keyframes I{0%{transform:translate(-50%,-50%) rotate(0)}to{transform:translate(-50%,-50%) rotate(360deg)}}.ci{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:44px;height:44px;border-radius:50%;pointer-events:none;opacity:0;visibility:hidden;transition:opacity .18s ease;will-change:opacity;z-index:3;animation:P 1s linear infinite;background:conic-gradient(from 0deg,#fff,#cfe6ff,#8ec5ff,#4ea1ff,#2f7fff,#1d4ed8);-webkit-mask:radial-gradient(farthest-side,transparent calc(100% - 4px),#000 0);mask:radial-gradient(farthest-side,transparent calc(100% - 4px),#000 0)}@keyframes P{0%{transform:translate(-50%,-50%) rotate(0)}to{transform:translate(-50%,-50%) rotate(360deg)}}.gi{position:absolute;inset:0;display:grid;place-items:center;pointer-events:none;opacity:0;visibility:hidden;transition:opacity .18s ease;will-change:opacity;z-index:3}.Q .plyr__poster{pointer-events:none}
+.Re{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:44px;height:44px;border-radius:50%;pointer-events:none;opacity:0;visibility:hidden;transition:opacity .18s ease;will-change:opacity;z-index:3;animation:J 1s linear infinite;background:conic-gradient(from 0deg,#fff,#cfe6ff,#8ec5ff,#4ea1ff,#2f7fff,#1d4ed8);-webkit-mask:radial-gradient(farthest-side,transparent calc(100% - 4px),#000 0);mask:radial-gradient(farthest-side,transparent calc(100% - 4px),#000 0)}.Se{position:absolute;inset:0;display:grid;place-items:center;pointer-events:none;opacity:0;visibility:hidden;transition:opacity .18s ease;will-change:opacity;z-index:3}@keyframes J{0%{transform:translate(-50%,-50%) rotate(0)}to{transform:translate(-50%,-50%) rotate(360deg)}}.gr{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:44px;height:44px;border-radius:50%;pointer-events:none;opacity:0;visibility:hidden;transition:opacity .18s ease;will-change:opacity;z-index:3;animation:M 1s linear infinite;animation-play-state:paused;background:conic-gradient(from 0deg,#fff,#cfe6ff,#8ec5ff,#4ea1ff,#2f7fff,#1d4ed8);-webkit-mask:radial-gradient(farthest-side,transparent calc(100% - 4px),#000 0);mask:radial-gradient(farthest-side,transparent calc(100% - 4px),#000 0)}@keyframes M{0%{transform:translate(-50%,-50%) rotate(0)}to{transform:translate(-50%,-50%) rotate(360deg)}}.pr{position:absolute;inset:0;display:grid;place-items:center;pointer-events:none;opacity:0;visibility:hidden;transition:opacity .18s ease;will-change:opacity;z-index:3}.N .plyr__poster{pointer-events:none}

package/dist/video.d.mts

@@ -1,8 +1,9 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React from 'react';
 import { APITypes } from 'plyr-react';
-import { b as PlyrSource, c as PlyrOptions } from './plyrTypes-Cq4C3ul5.mjs';
+import { b as PlyrSource, c as PlyrOptions } from './plyrTypes-DhzgHNfX.mjs';
 import 'plyr';
+import './media.mjs';
 
 type RmgPlyrSourceBuilder = (args: {
     src: string;

package/dist/video.mjs

@@ -1 +1 @@
-export{a as Video,a as default}from'./chunk-GSEIEFRW.mjs';import'./chunk-WZWMG4ZT.mjs';import'./chunk-UAEPMZQY.mjs';import'./chunk-GT6IL37J.mjs';import'./chunk-AKY343WN.mjs';import'./chunk-JMFDRKTX.mjs';import'./chunk-J4E4PKE5.mjs';import'./chunk-LVYED5ZM.mjs';import'./chunk-6TPHLAUP.mjs';
+export{a as Video,a as default}from'./chunk-3YENO5LQ.mjs';import'./chunk-C6PKH3FH.mjs';import'./chunk-PFEGIWQJ.mjs';import'./chunk-AKY343WN.mjs';import'./chunk-VXMW2JT5.mjs';import'./chunk-UAEPMZQY.mjs';import'./chunk-LVYED5ZM.mjs';import'./chunk-ASH5AOA4.mjs';import'./chunk-UP6P6CQS.mjs';import'./chunk-NHIKOJLU.mjs';import'./chunk-WMG2LTLR.mjs';import'./chunk-L2HRIINV.mjs';import'./chunk-B4CC5AGE.mjs';import'./chunk-HK2DPKES.mjs';

package/dist/zoomPan.d.mts

@@ -2,7 +2,7 @@ import { a as ZoomPanOptions } from './types-Dhh8xfHo.mjs';
 export { Z as ZoomPanImageProps } from './types-Dhh8xfHo.mjs';
 import * as React from 'react';
 
-declare const ZoomPanImage: React.ForwardRefExoticComponent<Omit<React.ImgHTMLAttributes<HTMLImageElement>, "style" | "children" | "className"> & {
+declare const ZoomPanImage: React.ForwardRefExoticComponent<Omit<React.ImgHTMLAttributes<HTMLImageElement>, "children" | "className" | "style"> & {
     className?: string;
     style?: React.CSSProperties;
     imageClassName?: string;
@@ -11,6 +11,4 @@ declare const ZoomPanImage: React.ForwardRefExoticComponent<Omit<React.ImgHTMLAt
     disabled?: boolean;
 } & React.RefAttributes<HTMLDivElement>>;
 
-declare const DEFAULT_ZOOM_PAN: Required<ZoomPanOptions>;
-
-export { DEFAULT_ZOOM_PAN, ZoomPanImage, ZoomPanOptions, ZoomPanImage as default };
+export { ZoomPanImage, ZoomPanOptions, ZoomPanImage as default };

package/dist/zoomPan.mjs

@@ -1 +1 @@
-export{a as ZoomPanImage,a as default}from'./chunk-VXSRNAH4.mjs';export{a as DEFAULT_ZOOM_PAN}from'./chunk-TKPLWDPW.mjs';import'./chunk-UAEPMZQY.mjs';import'./chunk-P2GQPFSL.mjs';import'./chunk-FJYYM5TH.mjs';import'./chunk-AKY343WN.mjs';
+export{a as ZoomPanImage,a as default}from'./chunk-V25YIPLC.mjs';import'./chunk-L4TRPKGX.mjs';import'./chunk-ADIHG7AT.mjs';import'./chunk-JJMFOLJZ.mjs';import'./chunk-P2GQPFSL.mjs';import'./chunk-HGY3QLCE.mjs';import'./chunk-AKY343WN.mjs';import'./chunk-UAEPMZQY.mjs';