@bendyline/squisq-react 2.11.0 → 2.11.2

package/dist/player-DSMhm8SL.d.ts

@@ -0,0 +1,539 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Block, VideoPresentation as VideoPresentation$1, VideoPipSize, VideoPipShape, VideoPipPosition, Doc, Theme, SurfaceScheme, Transition, CaptionTrack, ViewportConfig as ViewportConfig$1, CustomTemplateDefinition, ScheduledClip } from '@bendyline/squisq/schemas';
+import { ViewportConfig, DashboardStyleId, CoverSlideTemplate, CoverSlidePlayback, FlashcardFace, FlashcardSourceMode } from '@bendyline/squisq/doc';
+import { FenceRendererMap } from '@bendyline/squisq/fence';
+import { a as AudioController } from './AudioController-DwMsPe38.js';
+import { C as CodeBlockCopyHandler } from './MarkdownRenderer-CC9dOc6b.js';
+import { CSSProperties } from 'react';
+
+/**
+ * Doc Player Control Types
+ *
+ * Shared type definitions for doc player controls across different
+ * layout modes (overlay, sidebar, bottom). These interfaces allow
+ * control components to be decoupled from the core DocPlayer.
+ *
+ * Related Files:
+ * - DocPlayer.tsx — Core player component
+ * - DocProgressBar.tsx — Extracted progress bar
+ * - DocControlsOverlay.tsx — Overlay controls (default)
+ * - DocControlsSidebar.tsx — Vertical sidebar controls
+ * - DocControlsBottom.tsx — Horizontal bottom strip controls
+ */
+
+/** Layout mode for doc player controls */
+type ControlsLayout = 'overlay' | 'sidebar' | 'bottom';
+/**
+ * Placement of scheduled video relative to the rendered slide.
+ *
+ * `'background'` preserves the legacy full-bleed treatment behind the
+ * content. The other variants render above the content for presenter video.
+ */
+type VideoPresentation = VideoPresentation$1;
+/** Size of a picture-in-picture presenter video. */
+type PipSize = VideoPipSize;
+/** Shape of a picture-in-picture presenter video. */
+type PipShape = VideoPipShape;
+/** Corner occupied by a picture-in-picture presenter video. */
+type PipPosition = VideoPipPosition;
+/**
+ * Display mode for DocPlayer.
+ *
+ * - `'video'` — Traditional video-style playback with play/pause, scrub bar,
+ *   and time-based auto-advance. Default mode.
+ * - `'slideshow'` — PowerPoint-style presentation with prev/next navigation.
+ *   Blocks are treated as static slides that only change on user click.
+ *   No auto-advance, no scrub bar.
+ * - `'linear'` — Long-scrolling document view. Renders the full markdown as
+ *   readable HTML with template-annotated sections shown as inline SVG cards.
+ *   No audio, no timeline, no controls — just a scrollable page.
+ * - `'page'` — Plain semantic HTML preview matching what the
+ *   `markdownDocToPlainHtml` export produces. No SquisqPlayer, no SVG
+ *   cards — just `<h1>`/`<p>`/`<ul>` etc. inside a sandboxed iframe.
+ *   Use when you want a WYSIWYG view of the simple HTML export.
+ * - `'narrate'` — Teleprompter/performance surface. DocPlayer does not
+ *   implement this mode; it is owned by the editor package
+ *   (`@bendyline/squisq-editor-react`), which renders its own
+ *   voice-paced teleprompter view for it.
+ * - `'dashboard'` — One static canvas that arranges every block into a
+ *   layout's cells (grids, hero mosaics). No timeline, no navigation;
+ *   overflow blocks beyond the layout's capacity are not rendered.
+ * - `'flashcards'` — A progressively revealed study deck derived from the
+ *   document's nested block hierarchy, including multiple-choice quizzes.
+ */
+type DisplayMode = 'video' | 'slideshow' | 'linear' | 'page' | 'narrate' | 'dashboard' | 'flashcards';
+/**
+ * Caption display style.
+ *
+ * - `'standard'` — Traditional broadcast-style captions: small white text
+ *   on a semi-transparent black badge at the top of the player.
+ * - `'social'` — Social media-style (Instagram/TikTok): large centered words
+ *   showing 3-5 words at a time with the active word highlighted in the
+ *   theme's primary color. Font and colors pulled from the active theme.
+ */
+type CaptionStyle = 'standard' | 'social';
+/**
+ * Where captions sit over the frame. `'bottom'` is the classic lower band
+ * (social default), `'top'` keeps them clear of content that lives in the
+ * lower half (chat bubbles, summaries), `'center'` is the full-frame social
+ * look. Standard captions default to `'top'`, social to `'bottom'`.
+ */
+type CaptionPosition = 'top' | 'center' | 'bottom';
+/**
+ * Caption display mode — combines enable/disable with style selection.
+ * The CC button cycles through: off → standard → social → off.
+ */
+type CaptionMode = 'off' | 'standard' | 'social';
+/** Slide navigation actions for slideshow display mode */
+interface SlideNavActions {
+    /** Navigate to the next slide */
+    nextSlide: () => void;
+    /** Navigate to the previous slide */
+    prevSlide: () => void;
+    /** Navigate to a specific slide by index (0-based) */
+    goToSlide: (index: number) => void;
+}
+/** Playback state exposed to external control components */
+interface PlaybackState {
+    isPlaying: boolean;
+    currentTime: number;
+    totalDuration: number;
+    /** Whether the managed cover is the visual currently shown. */
+    isCoverVisible?: boolean;
+    currentBlockIndex: number;
+    totalBlocks: number;
+    docProgress: number;
+    hasCaptions: boolean;
+    captionsEnabled: boolean;
+    /** Current caption display mode (off, standard, social). */
+    captionMode: CaptionMode;
+    isFullscreen?: boolean;
+    /** Current audio segment index (0-based) */
+    currentSegmentIndex: number;
+    /** Current audio segment name (e.g., 'intro', 'history') */
+    currentSegmentName: string | null;
+    /** Current block data (for extracting image info, etc.) */
+    currentBlock: Block | null;
+    /** Optional display label for non-block slides, e.g. the managed cover. */
+    currentSlideLabel?: string;
+    /** Optional human-facing slide number, separate from internal nav index. */
+    currentSlideNumber?: number;
+    /** Optional human-facing slide total, separate from internal nav total. */
+    totalSlideNumber?: number;
+}
+/** Playback actions exposed to external control components */
+interface PlaybackActions {
+    toggle: () => void;
+    restart: () => void;
+    seekTo: (time: number) => void;
+    setCaptionsEnabled: (enabled: boolean) => void;
+    /** Cycle caption mode: off → standard → social → off */
+    cycleCaptionMode: () => void;
+    toggleFullscreen?: () => void;
+}
+/** Block marker data for the progress bar */
+interface BlockMarker {
+    block: Block;
+    index: number;
+    position: number;
+    title: string;
+    /** True if this block is the first in a new audio segment (section boundary) */
+    isSectionStart: boolean;
+}
+/** Block metadata returned by SquisqRenderAPI.getBlocks() */
+interface RenderBlockInfo {
+    id: string;
+    template: string;
+    startTime: number;
+    duration: number;
+}
+/** Audio segment info returned by SquisqRenderAPI.getAudioSegments() */
+interface RenderAudioSegmentInfo {
+    src: string;
+    name: string;
+    duration: number;
+    startTime: number;
+}
+/** Caption phrase info returned by SquisqRenderAPI.getCaptions() */
+interface RenderCaptionInfo {
+    text: string;
+    startTime: number;
+    endTime: number;
+}
+/** Chapter marker returned by SquisqRenderAPI.getChapters() */
+interface RenderChapterInfo {
+    title: string;
+    startTime: number;
+    duration: number;
+}
+/**
+ * Instance-scoped API created in render mode and debug mode.
+ * React hosts receive it via `DocPlayer.onRenderAPIReady`; standalone hosts
+ * receive it from their mount handle.
+ *
+ * @example
+ * ```ts
+ * const handle = SquisqPlayer.getHandle(rootElement);
+ * const api = await handle?.renderAPI;
+ * await api?.seekTo(5.0);
+ * ```
+ */
+interface SquisqRenderAPI {
+    /** Seek and resolve only after the requested visual state is capture-ready. */
+    seekTo: (time: number) => Promise<void>;
+    /** Timeline time most recently committed to the player DOM. */
+    getRenderedTime: () => number;
+    getDuration: () => number;
+    getBlocks: () => RenderBlockInfo[];
+    getAudioSegments: () => RenderAudioSegmentInfo[];
+    getCaptions: () => RenderCaptionInfo[];
+    getChapters: () => RenderChapterInfo[];
+    showCover: () => Promise<void>;
+    hideCover: () => Promise<void>;
+    hasCoverBlock: () => boolean;
+}
+/** Format time in seconds to MM:SS string */
+declare function formatTime(seconds: number): string;
+
+interface DocPlayerProps {
+    /** The Doc to play. Wins over `markdown` when both are provided. */
+    doc?: Doc;
+    /** Markdown source to convert when `doc` is absent. */
+    markdown?: string;
+    /** Base path for resolving media URLs (default: `'.'`). */
+    basePath?: string;
+    /** Render mode for deterministic video capture. */
+    renderMode?: boolean;
+    /** Render slide transitions and per-layer animations (default: true). */
+    animationsEnabled?: boolean;
+    /** Receives the instance-scoped render API, and `null` on cleanup. */
+    onRenderAPIReady?: (api: SquisqRenderAPI | null) => void;
+    autoPlay?: boolean;
+    /** Restart Video-mode playback automatically when the timeline ends. */
+    loop?: boolean;
+    onEnded?: () => void;
+    onTimeUpdate?: (time: number) => void;
+    /** Optional host-owned audio controller. */
+    audioController?: AudioController;
+    /** Explicit synthetic clock for timed documents that intentionally have no audio asset. */
+    audioMode?: 'media' | 'synthetic';
+    showControls?: boolean;
+    showScrubber?: boolean;
+    muted?: boolean;
+    captionsEnabled?: boolean;
+    onCaptionsToggle?: (enabled: boolean) => void;
+    onPlaybackStateChange?: (state: PlaybackState) => void;
+    onControlsReady?: (controls: PlaybackActions & {
+        play: () => void;
+        pause: () => void;
+    }) => void;
+    isFullscreen?: boolean;
+    onFullscreenToggle?: () => void;
+    onBlockMarkers?: (markers: BlockMarker[]) => void;
+    forceViewport?: ViewportConfig;
+    theme?: Theme;
+    surface?: SurfaceScheme | 'auto';
+    /** Video, slideshow, page, dashboard, or flashcards rendition. */
+    displayMode?: DisplayMode;
+    /** Dashboard mode: layout id or `'auto'`. Overrides doc frontmatter. */
+    dashboardLayout?: string;
+    /** Dashboard mode: title-band override. Overrides doc frontmatter. */
+    dashboardShowTitle?: boolean;
+    /** Dashboard mode: cell style variant. Overrides doc frontmatter. */
+    dashboardStyle?: DashboardStyleId;
+    /** Dashboard mode: host-supplied title fallback (typically the file name). */
+    dashboardDocumentTitle?: string;
+    showCoverSlide?: boolean;
+    /** Visual template used to materialize the managed cover. */
+    coverSlideTemplate?: CoverSlideTemplate;
+    /** Seconds the cover remains visible after Video playback starts. */
+    coverSlideDuration?: number;
+    /** Whether video export advances or delays the story while the cover is visible. */
+    coverSlidePlayback?: CoverSlidePlayback;
+    coverVisible?: boolean;
+    captionStyle?: CaptionStyle;
+    /**
+     * Where captions sit over the frame. Omitted → the style's classic spot
+     * (standard: top edge; social: lower band). Use `'top'` when the lower
+     * half of the frame carries content the band would cover.
+     */
+    captionPosition?: CaptionPosition;
+    /**
+     * Placement of scheduled video relative to the slide content.
+     * Defaults to `'background'` for backward compatibility.
+     */
+    videoPresentation?: VideoPresentation;
+    /** Size of presenter video in picture-in-picture mode (default `'small'`). */
+    pipSize?: PipSize;
+    /** Shape of presenter video in picture-in-picture mode (default `'square'`). */
+    pipShape?: PipShape;
+    /** Corner used by presenter video in picture-in-picture mode. */
+    pipPosition?: PipPosition;
+    enableSwipe?: boolean;
+    globalKeyboardShortcuts?: boolean;
+    /** Show a Copy button on fenced code blocks in linear mode (default: false). */
+    showCodeCopyButton?: boolean;
+    /** Optional host clipboard adapter; otherwise the browser Clipboard API is used. */
+    onCopyCode?: CodeBlockCopyHandler;
+    /**
+     * Host fence-renderer registry (`@bendyline/squisq/fence`), applied in
+     * linear mode's markdown sections. Video/slideshow modes render blocks
+     * as SVG layers and do not consult it.
+     */
+    fenceRenderers?: FenceRendererMap;
+}
+
+/**
+ * Front-door component: resolves the `doc` / `markdown` props into a Doc
+ * and renders a themed empty state when neither is provided. The playback
+ * machinery lives in `DocPlayerContent` so its hook order never changes
+ * when a doc appears or disappears.
+ */
+declare function DocPlayer(props: DocPlayerProps): react_jsx_runtime.JSX.Element;
+
+/** Viewport configuration type */
+interface ViewportDimensions {
+    width: number;
+    height: number;
+}
+interface BlockRendererProps {
+    /** The block to render */
+    block: Block;
+    /** Current time relative to block start (seconds) */
+    blockTime: number;
+    /** Base path for resolving media URLs */
+    basePath: string;
+    /** Whether this block is entering (for transition) */
+    isEntering?: boolean;
+    /** Whether this block is exiting (for transition) */
+    isExiting?: boolean;
+    /** Transition to apply. Defaults to block.transition. */
+    transition?: Transition;
+    /** Viewport dimensions (defaults to 1920x1080 landscape) */
+    viewport?: ViewportDimensions;
+    /** Whether the doc is currently playing (controls video playback) */
+    isPlaying?: boolean;
+    /** Silence audio carried by video layers. */
+    muted?: boolean;
+    /**
+     * Whether to render block transitions and layer animations (default: true).
+     * Disabling this only removes authored/render-style motion; timed video
+     * layers continue to advance normally.
+     */
+    animationsEnabled?: boolean;
+    /** Resolved theme inherited by rich-media renderers such as Mermaid. */
+    theme?: Theme;
+}
+declare function BlockRenderer({ block, blockTime, basePath, isEntering, isExiting, transition, viewport, isPlaying, muted, animationsEnabled, theme, }: BlockRendererProps): react_jsx_runtime.JSX.Element;
+
+interface CaptionOverlayProps {
+    /** Caption track with timestamped phrases */
+    captions: CaptionTrack | undefined;
+    /** Current playback time in seconds */
+    currentTime: number;
+    /** Whether captions are enabled */
+    enabled?: boolean;
+    /** Font size in pixels for standard style (default: 16) */
+    fontSize?: number;
+    /** Caption display style (default: 'standard') */
+    captionStyle?: CaptionStyle;
+    /**
+     * Frame placement. Omitted → each style's classic spot: standard at the
+     * top edge, social in the lower band.
+     */
+    captionPosition?: CaptionPosition;
+    /** Theme for social-style caption colors and fonts */
+    theme?: Theme;
+    /** Viewport config for social-style font scaling */
+    viewport?: ViewportConfig$1;
+}
+declare function CaptionOverlay({ captions, currentTime, enabled, fontSize, captionStyle, captionPosition, theme, viewport, }: CaptionOverlayProps): react_jsx_runtime.JSX.Element;
+
+interface SocialCaptionOverlayProps {
+    captions: CaptionTrack | undefined;
+    currentTime: number;
+    enabled?: boolean;
+    theme?: Theme;
+    viewport?: ViewportConfig$1;
+    /** Frame placement (default `'bottom'`). */
+    position?: CaptionPosition;
+}
+declare function SocialCaptionOverlay({ captions, currentTime, enabled, theme, viewport, position, }: SocialCaptionOverlayProps): react_jsx_runtime.JSX.Element | null;
+
+interface DocControlsOverlayProps {
+    state: PlaybackState;
+    actions: PlaybackActions;
+    blockMarkers: BlockMarker[];
+    expandedBlocks: Block[];
+    getBlockTitle?: (block: Block) => string;
+}
+declare function DocControlsOverlay({ state, actions, blockMarkers, expandedBlocks, getBlockTitle, }: DocControlsOverlayProps): react_jsx_runtime.JSX.Element;
+
+interface DocControlsBottomProps {
+    state: PlaybackState;
+    actions: PlaybackActions;
+    blockMarkers: BlockMarker[];
+    expandedBlocks: Block[];
+    getBlockTitle?: (block: Block) => string;
+}
+declare function DocControlsBottom({ state, actions, blockMarkers, expandedBlocks, getBlockTitle, }: DocControlsBottomProps): react_jsx_runtime.JSX.Element;
+
+interface DocControlsSidebarProps {
+    state: PlaybackState;
+    actions: PlaybackActions;
+}
+declare function DocControlsSidebar({ state, actions }: DocControlsSidebarProps): react_jsx_runtime.JSX.Element;
+
+interface SlideshowPickerItem {
+    /** Stable identifier for the slide/block. */
+    id: string;
+    /** Human-facing slide number, or a special label such as "Cover". */
+    label: string;
+    /** Short description shown in the slide picker. */
+    summary: string;
+}
+interface DocControlsSlideshowProps {
+    state: PlaybackState;
+    slideNav: SlideNavActions;
+    /** Slides available for direct navigation from the counter popover. */
+    slides?: readonly SlideshowPickerItem[];
+    /** Controlled open state for hosts that expose their own picker shortcut. */
+    pickerOpen?: boolean;
+    /** Called whenever the slide picker should open or close. */
+    onPickerOpenChange?: (open: boolean) => void;
+}
+declare function DocControlsSlideshow({ state, slideNav, slides, pickerOpen, onPickerOpenChange, }: DocControlsSlideshowProps): react_jsx_runtime.JSX.Element;
+
+interface DocPlayerWithSidebarProps {
+    /** The Doc to play */
+    doc: Doc;
+    /** Base path for resolving media URLs (default: `'.'`) */
+    basePath?: string;
+    autoPlay?: boolean;
+    /** Restart playback automatically when the video timeline ends. */
+    loop?: boolean;
+    onEnded?: () => void;
+    onTimeUpdate?: (time: number) => void;
+    /** Optional audio controller (if not provided, uses default HTML5 audio) */
+    audioController?: AudioController;
+    /** Whether to render slide transitions and per-layer animations (default: true). */
+    animationsEnabled?: boolean;
+    muted?: boolean;
+    captionsEnabled?: boolean;
+    isFullscreen?: boolean;
+    onFullscreenToggle?: () => void;
+    /** Force a specific viewport preset, bypassing window-based orientation detection. */
+    forceViewport?: ViewportConfig$1;
+    /** Called when playing state changes */
+    onPlayingChange?: (isPlaying: boolean) => void;
+    /**
+     * Theme for rendering. Forwarded to the inner DocPlayer so the sidebar
+     * (portrait) layout matches the default (landscape) layout — without it the
+     * inner player falls back to DEFAULT_THEME, whose dark text is unreadable
+     * over a hero cover image.
+     */
+    theme?: Theme;
+}
+declare function DocPlayerWithSidebar({ doc, basePath, autoPlay, loop, onEnded, onTimeUpdate, audioController, animationsEnabled, muted, captionsEnabled, isFullscreen, onFullscreenToggle, forceViewport, onPlayingChange, theme, }: DocPlayerWithSidebarProps): react_jsx_runtime.JSX.Element;
+
+interface DocProgressBarProps {
+    state: PlaybackState;
+    actions: PlaybackActions;
+    blockMarkers: BlockMarker[];
+    /** All expanded blocks for hover lookup */
+    expandedBlocks: Block[];
+    /** Optional: get block title for hover tooltip */
+    getBlockTitle?: (block: Block) => string;
+}
+declare function DocProgressBar({ state, actions, blockMarkers, expandedBlocks, getBlockTitle, }: DocProgressBarProps): react_jsx_runtime.JSX.Element;
+
+interface FlashcardViewProps {
+    doc: Doc;
+    theme?: Theme;
+    basePath?: string;
+    source?: FlashcardSourceMode;
+    /** Start the deck in shuffled order (default false). */
+    shuffle?: boolean;
+    /** Capture shortcuts without requiring focus (default false). */
+    globalKeyboardShortcuts?: boolean;
+    showCodeCopyButton?: boolean;
+    onCopyCode?: CodeBlockCopyHandler;
+    fenceRenderers?: FenceRendererMap;
+    /** Viewport used to materialize diagrams and other spatial content. */
+    viewport?: ViewportConfig$1;
+    className?: string;
+}
+interface FlashcardFaceViewProps {
+    face: FlashcardFace;
+    theme: Theme;
+    basePath: string;
+    showCodeCopyButton: boolean;
+    onCopyCode?: CodeBlockCopyHandler;
+    fenceRenderers?: FenceRendererMap;
+    viewport?: ViewportConfig$1;
+    customTemplates?: readonly CustomTemplateDefinition[];
+}
+/** Rich, theme-aware renderer for one materialized flashcard face. */
+declare function FlashcardFaceView(props: FlashcardFaceViewProps): react_jsx_runtime.JSX.Element;
+declare function FlashcardView({ doc, theme, basePath, source, shuffle: initialShuffle, globalKeyboardShortcuts, showCodeCopyButton, onCopyCode, fenceRenderers, viewport, className, }: FlashcardViewProps): react_jsx_runtime.JSX.Element;
+
+interface InlineVideoPlayerProps {
+    /** Source path — resolved through MediaContext when relative. */
+    src: string;
+    /** Base path used when no MediaProvider is in context. */
+    basePath?: string;
+    /** Optional explicit width (pixels or CSS length). */
+    width?: number | string;
+    /** Optional explicit height (pixels or CSS length). */
+    height?: number | string;
+    /** Optional poster image src — also resolved through MediaContext. */
+    poster?: string;
+    /** Whether to show native controls. Defaults to true. */
+    controls?: boolean;
+    /** `preload` attribute passthrough. Defaults to `'metadata'`. */
+    preload?: 'none' | 'metadata' | 'auto';
+    /** Extra className on the wrapper. */
+    className?: string;
+}
+declare function InlineVideoPlayer({ src, basePath, width, height, poster, controls, preload, className, }: InlineVideoPlayerProps): react_jsx_runtime.JSX.Element | null;
+
+interface InlineAudioPlayerProps {
+    /** Source path — resolved through MediaContext when relative. */
+    src: string;
+    /** Base path used when no MediaProvider is in context. */
+    basePath?: string;
+    /** Whether to show native controls. Defaults to true. */
+    controls?: boolean;
+    /** `preload` attribute passthrough. Defaults to `'metadata'`. */
+    preload?: 'none' | 'metadata' | 'auto';
+    /** Extra className on the wrapper. */
+    className?: string;
+}
+declare function InlineAudioPlayer({ src, basePath, controls, preload, className, }: InlineAudioPlayerProps): react_jsx_runtime.JSX.Element | null;
+
+interface MediaClipLayerProps {
+    schedule: ScheduledClip[];
+    currentTime: number;
+    isPlaying: boolean;
+    basePath: string;
+    renderMode?: boolean;
+    /** Silence every scheduled clip during live playback. */
+    muted?: boolean;
+    /** Placement of video clips relative to the rendered document. */
+    presentation?: VideoPresentation;
+    /** Size of picture-in-picture video (small or large). */
+    pipSize?: PipSize;
+    /** Shape of picture-in-picture video (square or 16:9 wide). */
+    pipShape?: PipShape;
+    /** Corner occupied by picture-in-picture video. */
+    pipPosition?: PipPosition;
+    /** Orientation of the rendered player viewport. */
+    pipOrientation?: 'landscape' | 'portrait';
+    /** Resolved theme frame applied directly to PIP video during raster capture. */
+    pipFrameStyle?: Pick<CSSProperties, 'border' | 'borderRadius' | 'boxShadow'>;
+    /** Honor each scheduled video's authored placement override. Default true. */
+    honorClipPresentation?: boolean;
+}
+declare function MediaClipLayer({ schedule, currentTime, isPlaying, basePath, renderMode, muted, presentation, pipSize, pipShape, pipPosition, pipOrientation, pipFrameStyle, honorClipPresentation, }: MediaClipLayerProps): react_jsx_runtime.JSX.Element | null;
+
+export { type RenderChapterInfo as A, type BlockMarker as B, type CaptionMode as C, type DisplayMode as D, type SlideNavActions as E, FlashcardFaceView as F, SocialCaptionOverlay as G, formatTime as H, InlineAudioPlayer as I, MediaClipLayer as M, type PipSize as P, type RenderAudioSegmentInfo as R, type SquisqRenderAPI as S, type VideoPresentation as V, type PipShape as a, type PipPosition as b, BlockRenderer as c, CaptionOverlay as d, type CaptionPosition as e, type CaptionStyle as f, type ControlsLayout as g, DocControlsBottom as h, DocControlsOverlay as i, DocControlsSidebar as j, DocControlsSlideshow as k, DocPlayer as l, type DocPlayerProps as m, DocPlayerWithSidebar as n, DocProgressBar as o, type FlashcardFaceViewProps as p, FlashcardView as q, type FlashcardViewProps as r, type InlineAudioPlayerProps as s, InlineVideoPlayer as t, type InlineVideoPlayerProps as u, type MediaClipLayerProps as v, type PlaybackActions as w, type PlaybackState as x, type RenderBlockInfo as y, type RenderCaptionInfo as z };