@broadcastingplatforms/player 0.0.0-dev.0c8c26d

package/dist/core/player-core.d.ts

@@ -0,0 +1,182 @@
+import type { PlayerState, QualityLevel, PresentationMode, ConnectionState, StreamType, PlayerError } from './state';
+import type { ProviderType, PlayerSource, ProviderConfig } from '../providers/contract';
+import { BPLiveService } from '../bplive/service';
+export interface PlayerCoreEventMap {
+    play: void;
+    playing: void;
+    pause: void;
+    ended: void;
+    waiting: void;
+    seeking: {
+        currentTime: number;
+    };
+    seeked: {
+        currentTime: number;
+    };
+    timeupdate: {
+        currentTime: number;
+        duration: number;
+    };
+    emptied: void;
+    loadstart: void;
+    loadedmetadata: {
+        duration: number;
+        videoWidth: number;
+        videoHeight: number;
+    };
+    loadeddata: void;
+    canplay: void;
+    canplaythrough: void;
+    durationchange: {
+        duration: number;
+    };
+    progress: {
+        buffered: TimeRanges;
+    };
+    resize: {
+        videoWidth: number;
+        videoHeight: number;
+    };
+    volumechange: {
+        volume: number;
+        muted: boolean;
+    };
+    ratechange: {
+        playbackRate: number;
+    };
+    qualitieschange: {
+        qualities: QualityLevel[];
+    };
+    qualitychange: {
+        quality: QualityLevel;
+        auto: boolean;
+    };
+    targetqualitychanged: {
+        quality: QualityLevel | null;
+    };
+    sourcechange: {
+        source: string | PlayerSource | null;
+    };
+    fullscreenchange: {
+        fullscreen: boolean;
+    };
+    presentationmodechange: {
+        mode: PresentationMode;
+    };
+    connectionstatechange: {
+        state: ConnectionState;
+    };
+    streamtypechange: {
+        streamType: StreamType;
+    };
+    videoelementchange: {
+        video: HTMLVideoElement | null;
+    };
+    error: PlayerError;
+    destroy: void;
+    statechange: {
+        state: PlayerState;
+    };
+}
+export type PlayerCoreEventType = keyof PlayerCoreEventMap;
+type EventListener<T> = (event: T) => void;
+/**
+ * Custom video element interface - all video elements (HlsVideoElement, NanoVideoElement, etc.)
+ * extend CustomVideoElement from custom-media-element and expose nativeEl
+ */
+export type CustomVideoElement = HTMLVideoElement & {
+    nativeEl: HTMLVideoElement;
+};
+/**
+ * Result returned when a source is loaded, containing metadata from the source.
+ */
+export interface SourceLoadResult {
+    poster?: string;
+    videoWidth?: number;
+    videoHeight?: number;
+}
+export interface PlayerCore {
+    readonly state: PlayerState;
+    readonly videoElement: HTMLVideoElement | null;
+    readonly bpLive: BPLiveService | null;
+    /** Whether the player is ready (attached and can accept sources) */
+    readonly ready: boolean;
+    /** Current provider type based on loaded source */
+    readonly providerType: ProviderType | null;
+    addEventListener<K extends PlayerCoreEventType>(type: K | K[], listener: EventListener<PlayerCoreEventMap[K]>): void;
+    removeEventListener<K extends PlayerCoreEventType>(type: K | K[], listener: EventListener<PlayerCoreEventMap[K]>): void;
+    /**
+     * Attach the player to a container element. Call once during initialization.
+     * After attaching, you can set sources via the source property or loadSource().
+     */
+    attach(container: HTMLElement, config?: ProviderConfig): void;
+    /**
+     * Load a source. Handles provider switching automatically.
+     * If source type changes (e.g., video -> nano), the player will
+     * destroy the old element and create a new one.
+     */
+    loadSource(source: string | PlayerSource, container?: HTMLElement, config?: ProviderConfig): Promise<SourceLoadResult | void>;
+    unloadSource(): void;
+    play(): Promise<void>;
+    pause(): void;
+    seek(time: number): void;
+    setVolume(volume: number): void;
+    setMuted(muted: boolean): void;
+    setLoop(loop: boolean): void;
+    setPlaybackRate(rate: number): void;
+    setTargetQuality(quality: QualityLevel | null): void;
+    setQuality(quality: QualityLevel | null): void;
+    setFullscreen(fullscreen: boolean): void;
+    setPresentationMode(mode: PresentationMode): void;
+    destroy(): void;
+}
+export declare class PlayerCoreImpl implements PlayerCore {
+    private _state;
+    private _mediaElement;
+    private _container;
+    private _config;
+    private _listeners;
+    private _eventCleanup;
+    private _destroyed;
+    private _bpLive;
+    private _currentProviderType;
+    private _ready;
+    constructor();
+    get state(): PlayerState;
+    get videoElement(): HTMLVideoElement | null;
+    get bpLive(): BPLiveService | null;
+    get ready(): boolean;
+    get providerType(): ProviderType | null;
+    addEventListener<K extends PlayerCoreEventType>(type: K | K[], listener: EventListener<PlayerCoreEventMap[K]>): void;
+    removeEventListener<K extends PlayerCoreEventType>(type: K | K[], listener: EventListener<PlayerCoreEventMap[K]>): void;
+    private dispatch;
+    private updateState;
+    /**
+     * Attach the player to a container. Call once during initialization.
+     */
+    attach(container: HTMLElement, config?: ProviderConfig): void;
+    loadSource(source: string | PlayerSource, container?: HTMLElement, config?: ProviderConfig): Promise<SourceLoadResult | void>;
+    /**
+     * Destroy the current media element and clean up listeners.
+     */
+    private destroyMediaElement;
+    private createMediaElement;
+    private attachMediaElementListeners;
+    private handleMediaEvent;
+    unloadSource(): void;
+    play(): Promise<void>;
+    pause(): void;
+    seek(time: number): void;
+    setVolume(volume: number): void;
+    setMuted(muted: boolean): void;
+    setLoop(loop: boolean): void;
+    setPlaybackRate(rate: number): void;
+    setTargetQuality(quality: QualityLevel | null): void;
+    setQuality(quality: QualityLevel | null): void;
+    setFullscreen(fullscreen: boolean): void;
+    setPresentationMode(mode: PresentationMode): void;
+    destroy(): void;
+}
+export declare function createPlayerCore(): PlayerCore;
+export {};
+//# sourceMappingURL=player-core.d.ts.map

package/dist/core/state-receiver.d.ts

@@ -0,0 +1,37 @@
+import type { PlayerState, QualityLevel, StreamType, PresentationMode, ConnectionState, PlayerError } from './state';
+import type { PlayerCore } from './player-core';
+export declare const StateReceiverProps: "bpPlayerObservedProperties";
+export interface StateReceiverPropertyMap {
+    player: PlayerCore | undefined;
+    paused: boolean;
+    playing: boolean;
+    ended: boolean;
+    seeking: boolean;
+    currentTime: number;
+    duration: number;
+    volume: number;
+    muted: boolean;
+    playbackRate: number;
+    readyState: number;
+    videoWidth: number;
+    videoHeight: number;
+    qualities: QualityLevel[];
+    currentQuality: QualityLevel | null;
+    targetQuality: QualityLevel | null;
+    fullscreen: boolean;
+    presentationMode: PresentationMode;
+    connectionState: ConnectionState;
+    streamType: StreamType;
+    error: PlayerError | null;
+}
+export interface StateReceiverElement extends Partial<StateReceiverPropertyMap>, Element {
+    readonly [StateReceiverProps]: Array<keyof StateReceiverPropertyMap>;
+}
+export declare function isStateReceiverElement(element: Element): element is StateReceiverElement;
+type Constructor<T> = abstract new (...args: any[]) => T;
+export declare function StateReceiverMixin<T extends Constructor<Element>>(base: T, props: Array<keyof StateReceiverPropertyMap>): T & Constructor<StateReceiverElement>;
+export declare function forEachStateReceiverElement(element: Element, excludeElement: HTMLElement | null, callback: (receiver: StateReceiverElement) => void): Promise<void>;
+export declare function propagateStateToReceiver(receiver: StateReceiverElement, player: PlayerCore | undefined, state: PlayerState): void;
+export declare function removeStateFromReceiver(receiver: StateReceiverElement): void;
+export {};
+//# sourceMappingURL=state-receiver.d.ts.map

package/dist/core/state.d.ts

@@ -0,0 +1,52 @@
+export interface PlayerState {
+    readonly paused: boolean;
+    readonly playing: boolean;
+    readonly ended: boolean;
+    readonly seeking: boolean;
+    readonly waiting: boolean;
+    readonly currentTime: number;
+    readonly duration: number;
+    readonly buffered: TimeRanges | null;
+    readonly volume: number;
+    readonly muted: boolean;
+    readonly loop: boolean;
+    readonly playbackRate: number;
+    readonly readyState: 0 | 1 | 2 | 3 | 4;
+    readonly videoWidth: number;
+    readonly videoHeight: number;
+    readonly qualities: QualityLevel[];
+    readonly currentQuality: QualityLevel | null;
+    readonly targetQuality: QualityLevel | null;
+    readonly fullscreen: boolean;
+    readonly presentationMode: PresentationMode;
+    readonly providerType: ProviderType | null;
+    readonly connectionState: ConnectionState;
+    readonly streamType: StreamType;
+    readonly contentType: ContentType;
+    readonly error: PlayerError | null;
+}
+export interface QualityLevel {
+    index: number;
+    height: number;
+    width: number;
+    bitrate: number;
+    codec?: string;
+    label?: string;
+}
+export type PresentationMode = 'inline' | 'fullscreen' | 'pip';
+export type ConnectionState = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'failed';
+export type StreamType = 'vod' | 'live' | 'dvr';
+export type ProviderType = 'video' | 'nano' | 'livekit';
+export type ContentType = 'clip' | 'stream' | 'video';
+export type ErrorCategory = 'offline' | 'network' | 'security' | 'media' | 'autoplay' | 'setup' | 'unknown';
+export interface PlayerError {
+    code: number;
+    message: string;
+    fatal: boolean;
+    category: ErrorCategory;
+}
+export declare const NANOPLAYER_NO_REPLAY_CODES: readonly [1005, 1007, 1008, 1009, 3001, 3002, 3003, 3004, 3005, 3100, 3101, 3200, 4003];
+export declare function classifyNanoPlayerError(code: number): ErrorCategory;
+export declare function classifyLiveKitError(code: number): ErrorCategory;
+export declare function createInitialState(): PlayerState;
+//# sourceMappingURL=state.d.ts.map

package/dist/elements/hls-video.d.ts

@@ -0,0 +1,27 @@
+import { CustomVideoElement } from 'custom-media-element';
+import Hls from 'hls.js';
+type HlsVideoConfig = Partial<Hls['config']>;
+declare const MediaTracksVideoElement: import("media-tracks").WithMediaTracks<CustomVideoElement>;
+declare class HlsVideoElement extends MediaTracksVideoElement {
+    #private;
+    static shadowRootOptions: {
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        delegatesFocus?: boolean;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    static getTemplateHTML(attrs: Record<string, string>, props?: {
+        config?: HlsVideoConfig;
+    }): string;
+    api: Hls | null;
+    constructor();
+    get config(): HlsVideoConfig | null;
+    set config(value: HlsVideoConfig | null);
+    attributeChangedCallback(attrName: string, oldValue: string | null, newValue: string | null): void;
+    load(): Promise<void>;
+}
+export default HlsVideoElement;
+export { Hls, HlsVideoElement };
+//# sourceMappingURL=hls-video.d.ts.map

package/dist/elements/index.d.ts

@@ -0,0 +1,4 @@
+export { default as HlsVideoElement, Hls, HlsVideoElement as HlsVideo } from './hls-video';
+export { default as NanoVideoElement, NanoVideoElement as NanoVideo } from './nano-video';
+export { default as LiveKitVideoElement, LiveKitVideoElement as LiveKitVideo } from './livekit-video';
+//# sourceMappingURL=index.d.ts.map

package/dist/elements/livekit-video.d.ts

@@ -0,0 +1,51 @@
+import { CustomVideoElement } from 'custom-media-element';
+import { Room } from 'livekit-client';
+interface LiveKitVideoConfig {
+    peerConnectionTimeout?: number;
+    iceTransportPolicy?: 'all' | 'relay';
+    adaptiveStream?: boolean;
+    dynacast?: boolean;
+    disconnectOnPageLeave?: boolean;
+}
+declare const MediaTracksVideoElement: import("media-tracks").WithMediaTracks<CustomVideoElement>;
+declare class LiveKitVideoElement extends MediaTracksVideoElement {
+    #private;
+    static get observedAttributes(): string[];
+    static shadowRootOptions: {
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        delegatesFocus?: boolean;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    static getTemplateHTML(attrs: Record<string, string>, props?: {
+        config?: LiveKitVideoConfig;
+    }): string;
+    room: Room | null;
+    constructor();
+    get config(): LiveKitVideoConfig | null;
+    set config(value: LiveKitVideoConfig | null);
+    get url(): string | null;
+    set url(value: string | null);
+    get token(): string | null;
+    set token(value: string | null);
+    attributeChangedCallback(attrName: string, oldValue: string | null, newValue: string | null): void;
+    load(): Promise<void>;
+    play(): Promise<void>;
+    pause(): void;
+    get currentTime(): number;
+    set currentTime(value: number);
+    get duration(): number;
+    get paused(): boolean;
+    get volume(): number;
+    set volume(value: number);
+    get muted(): boolean;
+    set muted(value: boolean);
+    get videoWidth(): number;
+    get videoHeight(): number;
+    disconnectedCallback(): void;
+}
+export default LiveKitVideoElement;
+export { LiveKitVideoElement };
+//# sourceMappingURL=livekit-video.d.ts.map

package/dist/elements/nano-video.d.ts

@@ -0,0 +1,142 @@
+import { CustomVideoElement } from 'custom-media-element';
+interface NanoPlayerInstance {
+    setup: (config: NanoPlayerConfig) => Promise<NanoSetupResult>;
+    destroy: () => void;
+    play: () => void;
+    pause: () => void;
+    mute: () => void;
+    unmute: () => void;
+    setAdaption: (options: {
+        rule: string;
+    }) => void;
+    switchStream: (index: number) => Promise<void>;
+}
+interface NanoSetupResult {
+    source: {
+        entries?: Array<{
+            info: {
+                height: number;
+                width: number;
+                bitrate: number;
+                framerate: number;
+            };
+        }>;
+    };
+}
+interface NanoPlayerEvent<T = unknown> {
+    name: string;
+    player: string;
+    id: string;
+    version: string;
+    data: T;
+    state: number;
+}
+interface NanoPlayerConfig {
+    source: unknown;
+    playback: {
+        autoplay: boolean;
+        muted: boolean;
+        reconnect?: {
+            minDelay: number;
+            maxDelay: number;
+            delaySteps: number;
+            maxRetries: number;
+        };
+        buffer?: {
+            min: number;
+            max: number;
+            target: number;
+        };
+    };
+    style: {
+        width: string | number;
+        height: string | number;
+        controls: boolean;
+        view?: boolean;
+        interactive?: boolean;
+    };
+    events: {
+        onReady?: (event: NanoPlayerEvent) => void;
+        onPlay?: (event: NanoPlayerEvent) => void;
+        onPause?: (event: NanoPlayerEvent<{
+            reason: string;
+        }>) => void;
+        onLoading?: (event: NanoPlayerEvent) => void;
+        onStartBuffering?: (event: NanoPlayerEvent) => void;
+        onStopBuffering?: (event: NanoPlayerEvent) => void;
+        onError?: (event: NanoPlayerEvent<{
+            code: number;
+            message?: string;
+        }>) => void;
+        onSwitchStreamSuccess?: (event: NanoPlayerEvent<{
+            id: string;
+            index: number;
+        }>) => void;
+        onSwitchStreamFail?: (event: NanoPlayerEvent<{
+            id: string;
+            index: number;
+        }>) => void;
+        onActiveVideoElementChange?: (event: NanoPlayerEvent<{
+            activeVideoElement: HTMLVideoElement;
+            videoElementList: HTMLVideoElement[];
+        }>) => void;
+    };
+}
+interface NanoVideoConfig {
+    reconnect?: {
+        minDelay: number;
+        maxDelay: number;
+        delaySteps: number;
+        maxRetries: number;
+    };
+    buffer?: {
+        min: number;
+        max: number;
+        target: number;
+    };
+}
+declare const MediaTracksVideoElement: import("media-tracks").WithMediaTracks<CustomVideoElement>;
+declare class NanoVideoElement extends MediaTracksVideoElement {
+    #private;
+    static get observedAttributes(): string[];
+    static shadowRootOptions: {
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        delegatesFocus?: boolean;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    static getTemplateHTML(attrs: Record<string, string>, props?: {
+        config?: NanoVideoConfig;
+    }): string;
+    api: NanoPlayerInstance | null;
+    constructor();
+    get config(): NanoVideoConfig | null;
+    set config(value: NanoVideoConfig | null);
+    /** Full NanoPlayer source configuration from API */
+    get sourceConfig(): unknown | null;
+    set sourceConfig(value: unknown | null);
+    get streamid(): string | null;
+    set streamid(value: string | null);
+    get libraryLocation(): string;
+    set libraryLocation(value: string);
+    attributeChangedCallback(attrName: string, oldValue: string | null, newValue: string | null): void;
+    load(): Promise<void>;
+    play(): Promise<void>;
+    pause(): void;
+    get currentTime(): number;
+    set currentTime(value: number);
+    get duration(): number;
+    get paused(): boolean;
+    get volume(): number;
+    set volume(value: number);
+    get muted(): boolean;
+    set muted(value: boolean);
+    get videoWidth(): number;
+    get videoHeight(): number;
+    disconnectedCallback(): void;
+}
+export default NanoVideoElement;
+export { NanoVideoElement };
+//# sourceMappingURL=nano-video.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { BPPlayer, type BPPlayerReadyEvent } from './components/bp-player';
+export { BPDefaultUI, type BPDefaultUIReadyEvent } from './components/bp-default-ui';
+export { BPErrorDisplay } from './components/bp-error-display';
+export { BPOverlay, type OverlayType } from './components/bp-overlay';
+export { addGlobalStyles, createTemplate, templateWithStyles } from './styles/index';
+export { Attribute, toggleAttribute } from './util/attribute';
+export { HlsVideoElement, HlsVideo, Hls, NanoVideoElement, NanoVideo, LiveKitVideoElement, LiveKitVideo, } from './elements/index';
+export { createPlayerCore, PlayerCoreImpl } from './core/player-core';
+export type { PlayerCore, PlayerCoreEventMap, PlayerCoreEventType, CustomVideoElement } from './core/player-core';
+export { createInitialState, classifyNanoPlayerError, classifyLiveKitError, NANOPLAYER_NO_REPLAY_CODES } from './core/state';
+export type { PlayerState, QualityLevel, PresentationMode, ConnectionState, StreamType, ContentType, PlayerError, ErrorCategory, } from './core/state';
+export { StateReceiverMixin, StateReceiverProps, isStateReceiverElement, forEachStateReceiverElement, propagateStateToReceiver, removeStateFromReceiver, } from './core/state-receiver';
+export type { StateReceiverElement, StateReceiverPropertyMap } from './core/state-receiver';
+export type { ProviderType, ProviderConfig, VideoProviderConfig, NanoProviderConfig, LiveKitProviderConfig, PlayerSource, ResolvedPlayerSource, VideoSource, NanoSource, LiveKitSource, PosterSource, PlayerSourceItem, PlayerSources, SourceDescription, } from './providers/contract';
+export { BPLiveService, BPLiveError, type BPLiveResolvedResult } from './bplive/service';
+export { isBPLiveSource, isBPLiveStreamSource, isBPLiveClipSource, } from './bplive/types';
+export type { BPLiveConfig, BPLiveSource, BPLiveStreamSource, BPLiveClipSource, BPLiveStream, BPLiveStreamResponse, BPLiveClip, BPLiveClipResponse, BPLiveChannel, BPLiveActiveStream, BPLivePlayerSource, BPLiveLiveKitPlayerSource, BPLiveNanoPlayerSource, BPLiveClipMedia, } from './bplive/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/contract.d.ts

@@ -0,0 +1,111 @@
+import type { BPLiveSource, BPLiveConfig } from '../bplive/types';
+export type ProviderType = 'video' | 'nano' | 'livekit';
+export type VideoSource = {
+    type: 'video';
+    url: string;
+};
+export type NanoSource = {
+    type: 'nano';
+    /** Bintu group ID for simple config */
+    streamid?: string;
+    /** Full NanoPlayer source config from API */
+    source?: NanoPlayerSourceConfig;
+};
+/** NanoPlayer source configuration from API */
+export interface NanoPlayerSourceConfig {
+    h5live?: unknown;
+    startIndex?: number;
+    options?: {
+        switch?: {
+            method?: string;
+            pauseOnError?: boolean;
+            forcePlay?: boolean;
+            fastStart?: boolean;
+            timeout?: number;
+        };
+        adaption?: {
+            rule?: string;
+        };
+    };
+    entries?: Array<{
+        h5live?: unknown;
+        info?: {
+            height?: number;
+            width?: number;
+            bitrate?: number;
+            framerate?: number;
+        };
+    }>;
+}
+export type LiveKitSource = {
+    type: 'livekit';
+    url: string;
+    token: string;
+    room?: string;
+};
+export type ResolvedPlayerSource = VideoSource | NanoSource | LiveKitSource;
+export type PlayerSource = ResolvedPlayerSource | BPLiveSource;
+export type PosterSource = {
+    type: 'poster';
+    url: string;
+};
+export type PlayerSourceItem = PlayerSource | PosterSource;
+export type PlayerSources = PlayerSourceItem[];
+/**
+ * Source description containing sources and optional metadata.
+ */
+export interface SourceDescription {
+    /** Array of playable sources */
+    sources: PlayerSource[];
+    /** Poster image URL */
+    poster?: string;
+}
+export interface ProviderConfig {
+    libraryLocation?: string;
+    video?: VideoProviderConfig;
+    nano?: NanoProviderConfig;
+    livekit?: LiveKitProviderConfig;
+    bpLive?: BPLiveConfig;
+}
+export interface VideoProviderConfig {
+    enableWorker?: boolean;
+    lowLatencyMode?: boolean;
+    backBufferLength?: number;
+    maxBufferLength?: number;
+    maxMaxBufferLength?: number;
+    fragLoadingTimeOut?: number;
+    manifestLoadingTimeOut?: number;
+    levelLoadingTimeOut?: number;
+    abrEwmaDefaultEstimate?: number;
+    startLevel?: number;
+    capLevelToPlayerSize?: boolean;
+}
+export interface NanoProviderConfig {
+    reconnect?: {
+        minDelay: number;
+        maxDelay: number;
+        delaySteps: number;
+        maxRetries: number;
+    };
+    buffer?: {
+        min: number;
+        max: number;
+        target: number;
+    };
+    timeouts?: {
+        loading: number;
+        buffering: number;
+        connecting: number;
+    };
+    adaption?: {
+        rule: string;
+    };
+}
+export interface LiveKitProviderConfig {
+    peerConnectionTimeout?: number;
+    iceTransportPolicy?: 'all' | 'relay';
+    adaptiveStream?: boolean;
+    dynacast?: boolean;
+    disconnectOnPageLeave?: boolean;
+}
+//# sourceMappingURL=contract.d.ts.map

package/dist/providers/index.d.ts

@@ -0,0 +1,2 @@
+export type { ProviderType, ProviderConfig, VideoProviderConfig, NanoProviderConfig, LiveKitProviderConfig, PlayerSource, ResolvedPlayerSource, VideoSource, NanoSource, LiveKitSource, PosterSource, PlayerSourceItem, PlayerSources, } from './contract';
+//# sourceMappingURL=index.d.ts.map

package/dist/styles/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * BP Player Styles
+ *
+ * Exports CSS as strings for injection into components.
+ */
+import variablesCss from './variables.css';
+import globalCss from './global.css';
+export { variablesCss, globalCss };
+/**
+ * Injects global styles into the document head.
+ * Safe to call multiple times - will only inject once.
+ */
+export declare function addGlobalStyles(): void;
+/**
+ * Creates a template element with styles and HTML content.
+ * Caches the template for reuse.
+ */
+export declare function createTemplate(name: string, html: string): () => HTMLTemplateElement;
+/**
+ * Combines CSS and HTML into a template string.
+ */
+export declare function templateWithStyles(css: string, html: string): string;
+//# sourceMappingURL=index.d.ts.map