react-motion-gallery 2.0.19 → 2.0.20

package/dist/plyrTypes-DhzgHNfX.d.mts

@@ -0,0 +1,9 @@
+import Plyr from 'plyr';
+import { MediaItem } from './media.mjs';
+
+type PlyrSource = Plyr.SourceInfo;
+type PlyrOptions = Plyr.Options;
+type PlyrSourceBuilder = (item: MediaItem, index: number) => PlyrSource;
+type PlyrOptionsBuilder = PlyrOptions | ((item: MediaItem, index: number) => PlyrOptions);
+
+export type { PlyrSourceBuilder as P, PlyrOptionsBuilder as a, PlyrSource as b, PlyrOptions as c };

package/dist/responsive-Ch5b4LC-.d.mts

@@ -0,0 +1,526 @@
+import { T as ThumbnailPosition } from './types-DP7ogmr4.mjs';
+import * as React$1 from 'react';
+import { MediaItem } from './media.mjs';
+import { E as ElementStyle, C as CrossFade, J as FullscreenOpenMethod } from './types-CfvTYIyd.mjs';
+import { P as PlyrSourceBuilder, a as PlyrOptionsBuilder } from './plyrTypes-DhzgHNfX.mjs';
+import { a as ZoomPanOptions } from './types-Dhh8xfHo.mjs';
+import { L as LoadingForceOptions } from './force-C5m1QpdF.mjs';
+import { R as ResponsiveTextBarHeight, a as ResponsiveTextBarWidth, b as ResponsiveTextLineHeight, c as ResponsiveTextLineCount, d as ResponsiveTextLastBarWidth, T as TextSkeletonResponsiveBy } from './text-BBcRGVzn.mjs';
+import { APITypes } from 'plyr-react';
+import { c as FullscreenThumbnailSlotLayout } from './types-B7AiQJkM.mjs';
+import { Root } from 'react-dom/client';
+import { R as ResponsiveNumber } from './responsiveNumber-CouEMJ9O.mjs';
+
+type SkeletonLength = number | string;
+type SkeletonShimmer = {
+    enabled?: boolean;
+    durationMs?: number;
+    angleDeg?: number;
+    opacity?: number;
+    blurPx?: number;
+    timing?: string;
+    c1?: string;
+    c2?: string;
+    c3?: string;
+};
+type SkeletonBaseStyle = {
+    width?: SkeletonLength;
+    maxWidth?: SkeletonLength;
+    height?: SkeletonLength;
+    maxHeight?: SkeletonLength;
+    backgroundColor?: string;
+    borderRadius?: SkeletonLength;
+    overflow?: React$1.CSSProperties["overflow"];
+    marginTop?: SkeletonLength;
+    marginRight?: SkeletonLength;
+    marginBottom?: SkeletonLength;
+    marginLeft?: SkeletonLength;
+    alignSelf?: React$1.CSSProperties["alignSelf"];
+    aspectRatio?: number | string;
+};
+type SkeletonBaseStyleResponsive = SkeletonBaseStyle | Record<string, SkeletonBaseStyle>;
+type SkeletonContainerStyle = {
+    display?: React$1.CSSProperties["display"];
+    gap?: SkeletonLength;
+    padding?: SkeletonLength;
+    align?: React$1.CSSProperties["alignItems"];
+    justify?: React$1.CSSProperties["justifyContent"];
+    wrap?: boolean;
+    width?: SkeletonLength;
+    maxWidth?: SkeletonLength;
+    overflow?: React$1.CSSProperties["overflow"];
+};
+type SkeletonContainerStyleResponsive = SkeletonContainerStyle | Record<string, SkeletonContainerStyle>;
+type SkeletonNode = {
+    kind: "stack" | "row" | "col";
+    style?: SkeletonContainerStyleResponsive;
+    children: SkeletonNode[];
+} | {
+    kind: "rect" | "square" | "circle";
+    style?: SkeletonBaseStyleResponsive;
+    shimmer?: SkeletonShimmer;
+} | {
+    kind: "media";
+    count: number;
+    direction?: "row" | "col";
+    style?: SkeletonContainerStyleResponsive;
+    tile?: {
+        shape?: "rect" | "square" | "circle";
+        style?: SkeletonBaseStyleResponsive;
+        shimmer?: SkeletonShimmer;
+    };
+} | {
+    kind: "text";
+    barHeight: ResponsiveTextBarHeight;
+    barWidth?: ResponsiveTextBarWidth;
+    lineHeight: ResponsiveTextLineHeight;
+    lines?: ResponsiveTextLineCount;
+    lastBarWidth?: ResponsiveTextLastBarWidth;
+    responsiveBy?: TextSkeletonResponsiveBy;
+    style?: SkeletonBaseStyleResponsive;
+    shimmer?: SkeletonShimmer;
+};
+type EntrySkeletonSpec = {
+    layout?: SkeletonNode;
+    variant?: "solid";
+    minHeight?: SkeletonLength;
+    defaults?: {
+        backgroundColor?: string;
+        highlightColor?: string;
+        radius?: SkeletonLength;
+        shimmer?: SkeletonShimmer;
+    };
+};
+
+type EntryItem = {
+    media?: MediaItem[];
+    [key: string]: any;
+};
+type EntryMediaRenderArgs = {
+    entry: EntryItem;
+    entryIndex: number;
+    media: MediaItem;
+    mediaIndex: number;
+};
+type MediaEntryLink = {
+    entryIndex: number;
+    mediaIndex: number;
+};
+type EntryOverlayRenderArgs = {
+    entry: EntryItem;
+    entryIndex: number;
+    media: MediaItem | null;
+    mediaIndex: number | null;
+    link: MediaEntryLink | null;
+    opacity: number;
+    fsIndex: number;
+    style: React.CSSProperties;
+    containerProps: React.HTMLAttributes<HTMLDivElement>;
+};
+type EntryOverlayStyle = ElementStyle & {
+    width?: ResponsiveLength;
+    height?: ResponsiveLength;
+    placement?: ResponsiveCaptionPlacement;
+    breakpoint?: number;
+    overlayCrossfadeTarget?: "content" | "overlay";
+    overlayCrossfadeDurationMs?: number;
+    overlayCrossfadeEasing?: string;
+    zoomFade?: boolean;
+    zoomFadeDurationMs?: number;
+    zoomFadeEasing?: string;
+    zoomInTransform?: string;
+    zoomOutTransform?: string;
+};
+type EntryMediaLayout = "slider" | "grid" | "masonry";
+type EntryCardRenderArgs = {
+    entry: EntryItem;
+    entryIndex: number;
+    media: React.ReactNode;
+};
+type EntrySkeletonResolverArgs = {
+    entry: EntryItem;
+    entryIndex: number;
+};
+type EntriesLoadingOptions = {
+    enabled?: boolean;
+    force?: LoadingForceOptions;
+    skeleton?: EntrySkeletonSpec | ((args: EntrySkeletonResolverArgs) => EntrySkeletonSpec | null | undefined);
+    minHeight?: SkeletonLength;
+    nearMargin?: string;
+    viewMargin?: string;
+    threshold?: number;
+    waitForDecode?: boolean;
+    decodeTimeoutMs?: number;
+    skeletonWrap?: ElementStyle;
+};
+type IntroOptions = {
+    renderIntro?: (args: {
+        active: boolean;
+        containerProps: React.HTMLAttributes<HTMLDivElement>;
+    }, content: React.ReactNode) => React.ReactNode;
+    staggerMs?: number;
+    durationMs?: number;
+    easing?: string;
+    staggerLimit?: number;
+};
+type EntrySkeletonRenderArgs = {
+    entry: EntryItem;
+    entryIndex: number;
+};
+type EntriesOptions = {
+    items?: EntryItem[];
+    mediaLayout?: EntryMediaLayout;
+    render?: {
+        card?: (args: EntryCardRenderArgs) => React.ReactNode;
+        media?: (args: EntryMediaRenderArgs) => React.ReactNode;
+        overlay?: (args: EntryOverlayRenderArgs) => React.ReactNode;
+        skeleton?: (args: EntrySkeletonRenderArgs) => React.ReactNode;
+    };
+    overlay?: EntryOverlayStyle;
+    loading?: EntriesLoadingOptions;
+    intro?: IntroOptions;
+    entryList?: ElementStyle;
+    entryRow?: ElementStyle;
+};
+type SlideOwner = {
+    entryIndex: number;
+};
+
+interface FullscreenSliderHandle {
+    centerSlider(): void;
+}
+
+type LimitType = ReturnType<typeof Limit>;
+declare function Limit(min: number, max: number): {
+    min: number;
+    max: number;
+    reachedMin(n: number): boolean;
+    reachedMax(n: number): boolean;
+    constrain(n: number): number;
+    reachedAny(n: number): boolean;
+    removeOffset(n: number): number;
+};
+
+type Vector1DType = {
+    get: () => number;
+    set: (n: number) => void;
+    add: (n: number) => void;
+};
+
+type ScrollBodyType = ReturnType<typeof ScrollBody>;
+declare function ScrollBody(location: Vector1DType, offsetLocation: Vector1DType, previousLocation: Vector1DType, target: Vector1DType, baseDuration: number, baseFriction: number): {
+    sync(): /*elided*/ any;
+    resetVelocity(): /*elided*/ any;
+    useDuration(n: number): /*elided*/ any;
+    useFriction(n: number): /*elided*/ any;
+    useBaseDuration(): /*elided*/ any;
+    useBaseFriction(): /*elided*/ any;
+    duration(): number;
+    frictionFactor(): number;
+    direction(): number;
+    velocity(): number;
+    seek(): /*elided*/ any;
+    settled(): boolean;
+};
+
+type ScrollBoundsType = ReturnType<typeof ScrollBounds>;
+declare function ScrollBounds(limit: LimitType, location: Vector1DType, target: Vector1DType, body: ScrollBodyType, pov: PercentOfViewType, selectDuration: number): {
+    reached: () => boolean;
+    passed: () => boolean;
+    constrain(pointerDown: boolean): void;
+};
+type PercentOfViewType = ReturnType<typeof PercentOfView>;
+declare function PercentOfView(viewSize: number): {
+    measure(n: number): number;
+};
+
+declare function PanAxis(): {
+    scroll: "x";
+    cross: "y";
+    direction(n: number): number;
+};
+type PanAxisType = ReturnType<typeof PanAxis>;
+
+type AnimationsType = {
+    start: () => void;
+    stop: () => void;
+    init: () => void;
+    destroy: () => void;
+    resetBlend: () => void;
+};
+
+type FullscreenRuntimeProps = {
+    fsEnabled: boolean;
+    fsSub: any;
+    showFullscreenModal: boolean;
+    setShowFullscreenModal: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    setShowFullscreenSlider: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    showFullscreenSlider: boolean;
+    isClick: React$1.RefObject<boolean>;
+    isAnimatingRef: React$1.RefObject<boolean>;
+    overlayDivRef: React$1.RefObject<HTMLDivElement | null>;
+    duplicateImgRef: React$1.RefObject<HTMLElement | null>;
+    cells: React$1.RefObject<{
+        element: HTMLElement;
+        index: number;
+    }[]>;
+    slidesForFullscreen: React$1.RefObject<{
+        cells: {
+            element: HTMLElement;
+            index: number;
+        }[];
+        target: number;
+    }[]>;
+    sliderForFullscreen: React$1.RefObject<HTMLDivElement | null>;
+    isWrappingForFullscreen: React$1.RefObject<boolean>;
+    setClosingModal: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    closingModal: boolean;
+    closeButtonRef: React$1.RefObject<HTMLElement | null>;
+    counterRef: React$1.RefObject<HTMLElement | null>;
+    leftChevronRef: React$1.RefObject<HTMLElement | null>;
+    rightChevronRef: React$1.RefObject<HTMLElement | null>;
+    centerSliderForFullscreen: () => void;
+    setSliderIndexForFullscreen: (index: number, mode?: any) => void;
+    layout?: 'slider' | 'grid' | 'masonry' | 'entries' | null;
+    expandableImageRefs: React$1.RefObject<any[]>;
+    resolveLayoutlessTarget: (index: number) => {
+        host: HTMLElement | null;
+        image: HTMLImageElement | null;
+        media: HTMLElement | null;
+    };
+    entryMapRef: React$1.RefObject<MediaEntryLink[] | null>;
+    entryMediaLayout: any;
+    introFade: boolean;
+    introDuration: number;
+    introEasing: any;
+    fullscreenSliderApi: React$1.RefObject<FullscreenSliderHandle | null>;
+    slideIndex: number;
+    isZoomClick: React$1.RefObject<boolean>;
+    isZoomed: boolean;
+    windowSize: any;
+    imageRefs: React$1.RefObject<React$1.RefObject<HTMLDivElement | null>[]>;
+    wrappedItems: MediaItem[];
+    setWrappedItems: React$1.Dispatch<React$1.SetStateAction<MediaItem[]>>;
+    scale: number;
+    isZooming: React$1.RefObject<boolean>;
+    singleModePlyrRefs: React$1.RefObject<(APITypes | null)[]>;
+    wrappedModePlyrRefs: React$1.RefObject<(APITypes | null)[]>;
+    direction: 'ltr' | 'rtl';
+    sliderGap?: number;
+    sliderDuration: number;
+    sliderFriction: number;
+    suppressLoopRef: React$1.RefObject<boolean>;
+    fsFadeOpening: boolean;
+    normalizedItems: MediaItem[];
+    fsThumbContainerRef: React$1.RefObject<HTMLDivElement | null>;
+    fullscreenThumbnailSlot: FullscreenThumbnailSlotLayout | null;
+    setFullscreenThumbnailMountEl: React$1.RefCallback<HTMLDivElement>;
+    showFsEntryOverlayMount: boolean;
+    fsIntroReq: FsIntroRequest;
+    clearFsIntroReq: () => void;
+    styles: Record<string, string>;
+    fs: FullscreenOptions;
+    overlayCaptionRef: React$1.RefObject<HTMLDivElement | null>;
+    overlayCaptionRootRef: React$1.RefObject<Root | null>;
+    setFsFadeOpening: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    addShield: (timeoutMs?: number | undefined) => void;
+    resolveFsCaptionPlacement: (placement: ResponsiveCaptionPlacement | undefined, breakpoint: number | undefined, viewportWidth: number) => FsCaptionPlacement | null;
+    requestFsCloseRef: React$1.RefObject<null | (() => void)>;
+    cancelFsCloseRef: React$1.RefObject<null | (() => void)>;
+    suppressNextClickRef: React$1.RefObject<boolean>;
+    currentImage: React$1.RefObject<HTMLDivElement | null>;
+    scaleRef: React$1.RefObject<number>;
+    pointerDownRef: React$1.RefObject<boolean>;
+    interactionModeRef: React$1.RefObject<'idle' | 'drag' | 'wheel' | 'programmatic'>;
+    boundsX: React$1.RefObject<ScrollBoundsType | null>;
+    boundsY: React$1.RefObject<ScrollBoundsType | null>;
+    bodyX: React$1.RefObject<ScrollBodyType | null>;
+    bodyY: React$1.RefObject<ScrollBodyType | null>;
+    locX: React$1.RefObject<Vector1DType | null>;
+    locY: React$1.RefObject<Vector1DType | null>;
+    prevX: React$1.RefObject<Vector1DType | null>;
+    prevY: React$1.RefObject<Vector1DType | null>;
+    offX: React$1.RefObject<Vector1DType | null>;
+    offY: React$1.RefObject<Vector1DType | null>;
+    tgtX: React$1.RefObject<Vector1DType | null>;
+    tgtY: React$1.RefObject<Vector1DType | null>;
+    axisRef: React$1.RefObject<PanAxisType | null>;
+    animRef: React$1.RefObject<AnimationsType | null>;
+    setScale: (newScale: number) => void;
+    previousZoom: React$1.RefObject<{
+        x: number;
+        y: number;
+    }>;
+    panRef: React$1.RefObject<{
+        x: number;
+        y: number;
+    }>;
+    changingSlides: React$1.RefObject<boolean>;
+    fsIndexRef: React$1.RefObject<number>;
+    entriesObject: EntriesOptions;
+    syncFullscreenSourceFromIndex: (nextIndex: number) => void;
+    setFullscreenOpen: (open: boolean) => void;
+    runtimePlugins?: FullscreenPlugin[];
+};
+
+type FsCounterArgs = {
+    index: number;
+    count: number;
+};
+type FsCaptionPlacement = "top" | "right" | "bottom" | "left";
+type FsIntroRequest = null | {
+    originalImage: HTMLImageElement | null;
+    index: number;
+    method: FullscreenOpenMethod;
+    closestSelector?: string;
+};
+type FSImageRender = (args: {
+    item: Extract<MediaItem, {
+        kind: "image";
+    }>;
+    index: number;
+    isZoomed: boolean;
+    className: string;
+    baseStyle: React$1.CSSProperties;
+}) => React$1.ReactNode;
+type FullscreenArrows = {
+    enabled?: boolean;
+    arrow?: ElementStyle;
+    prev?: ElementStyle;
+    next?: ElementStyle;
+    render?: (args: {
+        dir: "prev" | "next";
+    }) => React$1.ReactNode;
+    renderPrev?: () => React$1.ReactNode;
+    renderNext?: () => React$1.ReactNode;
+};
+type FullscreenClose = {
+    enabled?: boolean;
+    style?: React$1.CSSProperties;
+    className?: string;
+    render?: () => React$1.ReactNode;
+};
+type FullscreenCounter = {
+    enabled?: boolean;
+    style?: React$1.CSSProperties;
+    className?: string;
+    render?: (args: FsCounterArgs) => React$1.ReactNode;
+};
+type FullscreenControlsOptions = {
+    close?: FullscreenClose;
+    arrows?: FullscreenArrows;
+    counter?: FullscreenCounter;
+};
+type FsCaptionRenderArgs = {
+    item: MediaItem;
+    index: number;
+    isZoomed: boolean;
+};
+type FullscreenCaptionOptions = {
+    className?: string;
+    style?: React$1.CSSProperties;
+    width?: ResponsiveLength;
+    height?: ResponsiveLength;
+    placement?: ResponsiveCaptionPlacement;
+    breakpoint?: number;
+    render?: (args: FsCaptionRenderArgs) => React$1.ReactNode;
+    layout?: "overlay" | "slide";
+    overlayCrossfadeTarget?: "content" | "overlay";
+    overlayCrossfadeDurationMs?: number;
+    overlayCrossfadeEasing?: string;
+    zoomFade?: boolean;
+    zoomFadeDurationMs?: number;
+    zoomFadeEasing?: string;
+    zoomInTransform?: string;
+    zoomOutTransform?: string;
+};
+type FullscreenCrossfadeOptions = CrossFade;
+type FullscreenEffectsOptions = {
+    introDuration?: number;
+    introEasing?: string;
+    introFade?: boolean;
+    introStickyNavSelector?: string;
+    crossfade?: FullscreenCrossfadeOptions;
+};
+type FullscreenSliderOptions = {
+    gap?: ResponsiveNumber;
+    duration?: number;
+    friction?: number;
+    direction?: "ltr" | "rtl";
+};
+type FullscreenZoomPanOptions = ZoomPanOptions;
+type FullscreenVideoOptions = {
+    source?: PlyrSourceBuilder;
+    options?: PlyrOptionsBuilder;
+    playOnOpen?: boolean;
+    style?: React$1.CSSProperties;
+    className?: string;
+};
+type FullscreenLazyLoadKind = "image" | "video";
+type FullscreenLazyLoadArgs = {
+    kind: FullscreenLazyLoadKind;
+    isClone?: boolean;
+};
+type FullscreenLazyLoadConfig = {
+    enabled?: boolean;
+    spinner?: boolean | React$1.ReactNode | ((args: FullscreenLazyLoadArgs) => React$1.ReactNode);
+    spinnerClassName?: string;
+    spinnerStyle?: React$1.CSSProperties;
+};
+type FullscreenLazyLoadOptions = {
+    images?: FullscreenLazyLoadConfig;
+    videos?: FullscreenLazyLoadConfig;
+};
+type FullscreenOptions = {
+    enabled?: boolean;
+    items?: MediaItem[] | string[];
+    renderImage?: FSImageRender;
+    video?: FullscreenVideoOptions;
+    controls?: FullscreenControlsOptions;
+    caption?: FullscreenCaptionOptions;
+    slider?: FullscreenSliderOptions;
+    zoom?: FullscreenZoomPanOptions;
+    effects?: FullscreenEffectsOptions;
+    lazyLoad?: FullscreenLazyLoadOptions;
+};
+type FullscreenPluginKind = "slider" | "controls" | "captions" | "zoom-pan" | "video" | "lazy-load" | "crossfade" | "thumbnails";
+type FullscreenPluginOptions = Partial<FullscreenOptions>;
+type FullscreenRuntimeFeatures = {
+    useZoomPanRuntime?: (args: any) => {
+        isPinching: React$1.RefObject<boolean>;
+        isTouchPinching: React$1.RefObject<boolean>;
+        entryOverlayZoomMotion?: unknown;
+        captionZoomMotion?: unknown;
+        handlePanPointerStart: (e: React$1.PointerEvent<HTMLDivElement>, imageRef: React$1.RefObject<HTMLDivElement | null>) => void;
+        handleZoomToggle: (e: React$1.PointerEvent<HTMLDivElement> | React$1.TouchEvent<HTMLDivElement>, imageRef: React$1.RefObject<HTMLDivElement | null>) => void;
+        resetAllZoomDom: (args?: {
+            disableImageTransition?: boolean;
+        }) => void;
+        resetForSlideNavigation: () => void;
+        forceResetZoom?: () => void;
+    };
+    usePlyrProps?: (args: {
+        items: MediaItem[];
+        source?: FullscreenVideoOptions["source"];
+        options?: FullscreenVideoOptions["options"];
+    }) => unknown[];
+    defaultPlayerStyle?: React$1.CSSProperties;
+    createVideoSnapshotStore?: () => unknown;
+    renderSlides?: (args: any) => React$1.ReactNode[];
+    renderCrossfadeSlides?: (args: any) => React$1.ReactNode[];
+};
+type FullscreenPlugin = {
+    readonly __rmgFullscreenPlugin: true;
+    readonly kind: FullscreenPluginKind;
+    readonly options?: FullscreenPluginOptions;
+    readonly runtime?: FullscreenRuntimeFeatures;
+    readonly RuntimeHost?: React$1.ComponentType<FullscreenRuntimeProps>;
+    readonly preload?: () => void;
+};
+
+type ResponsiveLengthValue = number | string;
+type ResponsiveLength = ResponsiveLengthValue | Record<string, ResponsiveLengthValue>;
+type ResponsivePosition = ThumbnailPosition | Array<ThumbnailPosition> | Record<string, ThumbnailPosition>;
+type ResponsiveCaptionPlacement = FsCaptionPlacement | Array<FsCaptionPlacement> | Record<string, FsCaptionPlacement>;
+
+export type { FSImageRender as A, ResponsivePosition as B, EntriesOptions as E, FullscreenCaptionOptions as F, IntroOptions as I, MediaEntryLink as M, PanAxisType as P, ResponsiveCaptionPlacement as R, SlideOwner as S, FullscreenControlsOptions as a, FullscreenCrossfadeOptions as b, FullscreenLazyLoadOptions as c, FullscreenOptions as d, FullscreenPlugin as e, FullscreenPluginKind as f, FullscreenSliderOptions as g, FullscreenVideoOptions as h, FullscreenZoomPanOptions as i, FsCaptionPlacement as j, FsIntroRequest as k, ResponsiveLength as l, ResponsiveLengthValue as m, EntryItem as n, EntryMediaRenderArgs as o, EntryOverlayRenderArgs as p, EntryOverlayStyle as q, EntryMediaLayout as r, EntryCardRenderArgs as s, EntrySkeletonResolverArgs as t, EntriesLoadingOptions as u, EntrySkeletonRenderArgs as v, FullscreenClose as w, FullscreenArrows as x, FullscreenCounter as y, FsCaptionRenderArgs as z };

package/dist/responsive.d.mts

@@ -0,0 +1,15 @@
+export { R as ResponsiveCaptionPlacement, l as ResponsiveLength, m as ResponsiveLengthValue, B as ResponsivePosition } from './responsive-Ch5b4LC-.mjs';
+export { a as BREAKPOINT_MAP, B as BreakpointMap, R as ResponsiveNumber } from './responsiveNumber-CouEMJ9O.mjs';
+import './types-DP7ogmr4.mjs';
+import 'react';
+import './force-C5m1QpdF.mjs';
+import './types-CfvTYIyd.mjs';
+import './media.mjs';
+import './transitions-DU3ftmIq.mjs';
+import './plyrTypes-DhzgHNfX.mjs';
+import 'plyr';
+import './types-Dhh8xfHo.mjs';
+import './text-BBcRGVzn.mjs';
+import 'plyr-react';
+import './types-B7AiQJkM.mjs';
+import 'react-dom/client';

package/dist/responsive.mjs

@@ -0,0 +1 @@
+import'./chunk-B4CC5AGE.mjs';export{a as BREAKPOINT_MAP}from'./chunk-HK2DPKES.mjs';

package/dist/responsiveNumber-CouEMJ9O.d.mts

@@ -0,0 +1,5 @@
+declare const BREAKPOINT_MAP: Record<string, number>;
+type BreakpointMap = Record<string, number>;
+type ResponsiveNumber = number | Record<string, number>;
+
+export { type BreakpointMap as B, type ResponsiveNumber as R, BREAKPOINT_MAP as a };

package/dist/skeleton-base.css

@@ -0,0 +1 @@
+.ce{aspect-ratio:1 / 1}.ge{aspect-ratio:1 / 1;border-radius:999px}.pe{display:flex;min-width:0}.he{flex-direction:row;align-items:center}.fe,.be{flex-direction:column;align-items:stretch}.ve{display:flex;flex-direction:column;width:100%;min-width:0;box-sizing:border-box;align-items:flex-start;align-content:flex-start}.ue{min-width:0;align-self:flex-start}.ye{position:relative;display:block;width:100%;min-width:0;height:auto;background:var(--rmg-skel-bg, #e5e5e5);border-radius:var(--rmg-skel-radius, 12px);overflow:hidden}.g{position:relative;overflow:hidden;border-radius:var(--rmg-skel-radius, 12px);--rmg-skel-shimmer-enabled: 0}.g:after{content:"";position:absolute;inset:0;opacity:calc(var(--rmg-skel-card-shimmer-enabled, 1) * var(--rmg-skel-shimmer-opacity, 1));filter:var(--rmg-skel-shimmer-filter, none);background-image:linear-gradient(var(--rmg-skel-shimmer-angle, 90deg),transparent 0%,var(--rmg-skel-shimmer-c1, rgba(255, 255, 255, .25)) 22%,var(--rmg-skel-shimmer-c2, rgba(255, 255, 255, .45)) 50%,var(--rmg-skel-shimmer-c3, rgba(255, 255, 255, .25)) 78%,transparent 100%);animation:p var(--rmg-skel-shimmer-duration, 1.2s) var(--rmg-skel-shimmer-timing, linear) infinite;transform:translate(-100%);pointer-events:none}.B:before{content:"";position:absolute;inset:0;opacity:calc(var(--rmg-skel-shimmer-enabled, 1) * var(--rmg-skel-shimmer-opacity, 1));filter:var(--rmg-skel-shimmer-filter, none);background-image:linear-gradient(var(--rmg-skel-shimmer-angle, 90deg),transparent 0%,var(--rmg-skel-shimmer-c1, rgba(255, 255, 255, .25)) 22%,var(--rmg-skel-shimmer-c2, rgba(255, 255, 255, .45)) 50%,var(--rmg-skel-shimmer-c3, rgba(255, 255, 255, .25)) 78%,transparent 100%);animation:p var(--rmg-skel-shimmer-duration, 1.2s) var(--rmg-skel-shimmer-timing, linear) infinite;transform:translate(-100%);pointer-events:none}@keyframes p{0%{transform:translate(-100%)}to{transform:translate(100%)}}@media(prefers-reduced-motion:reduce){.g:after,.B:before{animation:none}}.We{display:grid;position:relative;width:100%}.y,.x{grid-area:1 / 1;min-width:0}.y{position:relative;z-index:2;opacity:0;pointer-events:none;transition:opacity var(--rmg-loading-fade-duration, .6s) ease;will-change:opacity}.er{opacity:1;pointer-events:auto}.rr{position:absolute;inset:0;width:100%;height:100%;overflow:hidden;pointer-events:none}.x{position:relative;z-index:1;opacity:var(--rmg-standalone-skeleton-opacity, 1);--rmg-masonry-skel-wrap-shadow-opacity: 1;pointer-events:none;transition:opacity var(--rmg-loading-fade-duration, .6s) ease;will-change:opacity;overflow:hidden}.ir{position:absolute;inset:0;width:100%;height:100%;overflow:visible}.ar{z-index:3}.tr{--rmg-standalone-skeleton-opacity: 0;--rmg-masonry-skel-wrap-shadow-opacity: 0}@media(prefers-reduced-motion:reduce){.y,.x{transition:none}}

package/dist/skeleton-base.d.mts

@@ -0,0 +1,52 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import { B as BreakpointMap } from './responsiveNumber-CouEMJ9O.mjs';
+import { L as LoadingForceOptions } from './force-C5m1QpdF.mjs';
+import { L as LoadingTimingOptions } from './transitions-DU3ftmIq.mjs';
+import { S as SkeletonNode, a as SkeletonLength, b as SkeletonShimmer } from './layout-DoYnPD0I.mjs';
+export { e as SkeletonBaseStyle, f as SkeletonBaseStyleResponsive, g as SkeletonContainerStyle, h as SkeletonContainerStyleResponsive } from './layout-DoYnPD0I.mjs';
+export { R as ResponsiveTextBarHeight, a as ResponsiveTextBarWidth, d as ResponsiveTextLastBarWidth, c as ResponsiveTextLineCount, b as ResponsiveTextLineHeight, T as TextSkeletonResponsiveBy } from './text-BBcRGVzn.mjs';
+
+type SkeletonForceOptions = LoadingForceOptions;
+type SkeletonTimingOptions = LoadingTimingOptions;
+type SkeletonFrameProps = {
+    skeletonNode: React.ReactNode;
+    children?: React.ReactNode;
+    ready?: boolean;
+    enabled?: boolean;
+    force?: SkeletonForceOptions;
+    timing?: SkeletonTimingOptions;
+    shellClassName?: string;
+    shellStyle?: React.CSSProperties;
+    loadingShellStyle?: React.CSSProperties | null;
+    contentClassName?: string;
+    contentStyle?: React.CSSProperties;
+    contentOwnsWrapperLayout?: boolean;
+    loadingLayerFirst?: boolean;
+    contentWrapper?: (children: React.ReactNode) => React.ReactNode;
+    shellDataAttributes?: Record<string, string | boolean | undefined>;
+};
+type SkeletonProps = {
+    layout: SkeletonNode;
+    children?: React.ReactNode;
+    breakpoints?: BreakpointMap;
+    className?: string;
+    style?: React.CSSProperties;
+    shellClassName?: string;
+    shellStyle?: React.CSSProperties;
+    contentClassName?: string;
+    contentStyle?: React.CSSProperties;
+    backgroundColor?: string;
+    radius?: SkeletonLength;
+    shimmer?: SkeletonShimmer;
+    disableShimmer?: boolean;
+    ariaLabel?: string;
+    ready?: boolean;
+    enabled?: boolean;
+    force?: SkeletonForceOptions;
+    timing?: SkeletonTimingOptions;
+};
+declare function SkeletonFrame({ skeletonNode, children, ready, enabled, force, timing, shellClassName, shellStyle, loadingShellStyle, contentClassName, contentStyle, contentOwnsWrapperLayout, loadingLayerFirst, contentWrapper, shellDataAttributes, }: SkeletonFrameProps): react_jsx_runtime.JSX.Element;
+declare function Skeleton({ layout, children, breakpoints, className, style, shellClassName, shellStyle, contentClassName, contentStyle, backgroundColor, radius, shimmer, disableShimmer, ariaLabel, ready, enabled, force, timing, }: SkeletonProps): react_jsx_runtime.JSX.Element;
+
+export { Skeleton, type SkeletonForceOptions, SkeletonFrame, type SkeletonFrameProps, SkeletonLength, SkeletonNode, type SkeletonProps, SkeletonShimmer, type SkeletonTimingOptions, Skeleton as default };

package/dist/skeleton-base.mjs

@@ -0,0 +1 @@
+export{b as Skeleton,a as SkeletonFrame,b as default}from'./chunk-6FFRWH2C.mjs';import'./chunk-AX2FSVFD.mjs';import'./chunk-Z34PSRMG.mjs';import'./chunk-UUAWLGWO.mjs';import'./chunk-LVYED5ZM.mjs';import'./chunk-B4CC5AGE.mjs';import'./chunk-HK2DPKES.mjs';

package/dist/skeleton-grid.css

@@ -0,0 +1 @@
+.ce{aspect-ratio:1 / 1}.ge{aspect-ratio:1 / 1;border-radius:999px}.pe{display:flex;min-width:0}.he{flex-direction:row;align-items:center}.fe,.be{flex-direction:column;align-items:stretch}.ve{display:flex;flex-direction:column;width:100%;min-width:0;box-sizing:border-box;align-items:flex-start;align-content:flex-start}.ue{min-width:0;align-self:flex-start}.ye{position:relative;display:block;width:100%;min-width:0;height:auto;background:var(--rmg-skel-bg, #e5e5e5);border-radius:var(--rmg-skel-radius, 12px);overflow:hidden}.g{position:relative;overflow:hidden;border-radius:var(--rmg-skel-radius, 12px);--rmg-skel-shimmer-enabled: 0}.g:after{content:"";position:absolute;inset:0;opacity:calc(var(--rmg-skel-card-shimmer-enabled, 1) * var(--rmg-skel-shimmer-opacity, 1));filter:var(--rmg-skel-shimmer-filter, none);background-image:linear-gradient(var(--rmg-skel-shimmer-angle, 90deg),transparent 0%,var(--rmg-skel-shimmer-c1, rgba(255, 255, 255, .25)) 22%,var(--rmg-skel-shimmer-c2, rgba(255, 255, 255, .45)) 50%,var(--rmg-skel-shimmer-c3, rgba(255, 255, 255, .25)) 78%,transparent 100%);animation:p var(--rmg-skel-shimmer-duration, 1.2s) var(--rmg-skel-shimmer-timing, linear) infinite;transform:translate(-100%);pointer-events:none}.B:before{content:"";position:absolute;inset:0;opacity:calc(var(--rmg-skel-shimmer-enabled, 1) * var(--rmg-skel-shimmer-opacity, 1));filter:var(--rmg-skel-shimmer-filter, none);background-image:linear-gradient(var(--rmg-skel-shimmer-angle, 90deg),transparent 0%,var(--rmg-skel-shimmer-c1, rgba(255, 255, 255, .25)) 22%,var(--rmg-skel-shimmer-c2, rgba(255, 255, 255, .45)) 50%,var(--rmg-skel-shimmer-c3, rgba(255, 255, 255, .25)) 78%,transparent 100%);animation:p var(--rmg-skel-shimmer-duration, 1.2s) var(--rmg-skel-shimmer-timing, linear) infinite;transform:translate(-100%);pointer-events:none}@keyframes p{0%{transform:translate(-100%)}to{transform:translate(100%)}}@media(prefers-reduced-motion:reduce){.g:after,.B:before{animation:none}}.Te{position:relative;width:100%}.Ue{display:grid;grid-template-columns:repeat(auto-fill,minmax(var(--rmg-grid-min, 160px),1fr));gap:var(--rmg-grid-gap, 8px)}.K{position:relative;width:100%}.K:before{content:"";position:absolute;inset:0;border-radius:var(--rmg-grid-skel-wrap-shadow-radius, var(--rmg-skel-radius, 12px));box-shadow:var(--rmg-grid-skel-wrap-shadow, none);opacity:var(--rmg-grid-skel-wrap-shadow-opacity, 1);transition:opacity calc(var(--rmg-loading-fade-duration, .6s) * .45) ease-out;pointer-events:none}.Ve{position:relative;z-index:1;width:100%;min-width:0}.We{display:grid;position:relative;width:100%}.y,.x{grid-area:1 / 1;min-width:0}.y{position:relative;z-index:2;opacity:0;pointer-events:none;transition:opacity var(--rmg-loading-fade-duration, .6s) ease;will-change:opacity}.er{opacity:1;pointer-events:auto}.rr{position:absolute;inset:0;width:100%;height:100%;overflow:hidden;pointer-events:none}.x{position:relative;z-index:1;opacity:var(--rmg-standalone-skeleton-opacity, 1);--rmg-masonry-skel-wrap-shadow-opacity: 1;pointer-events:none;transition:opacity var(--rmg-loading-fade-duration, .6s) ease;will-change:opacity;overflow:hidden}.ir{position:absolute;inset:0;width:100%;height:100%;overflow:visible}.ar{z-index:3}.tr{--rmg-standalone-skeleton-opacity: 0;--rmg-masonry-skel-wrap-shadow-opacity: 0}@media(prefers-reduced-motion:reduce){.y,.x{transition:none}}