@broadcastingplatforms/player 0.0.0-dev.c57124a → 1.1.0

package/dist/components/bp-default-ui.d.ts

@@ -1,19 +1,17 @@
 import { LitElement, PropertyValues } from 'lit';
 import type { PlayerCore } from '../core/player-core';
 import type { ProviderConfig, SourceDescription } from '../providers/contract';
+import { type ReadyEvent } from '../events';
 import 'media-chrome';
 import 'media-chrome/menu';
 import './bp-player';
 import './bp-error-display';
 import type { BPLiveService } from '../bplive/service';
-export type BPDefaultUIReadyEvent = CustomEvent<PlayerCore>;
+export type BPDefaultUIReadyEvent = ReadyEvent;
 declare global {
     interface HTMLElementTagNameMap {
         'bp-default-ui': BPDefaultUI;
     }
-    interface HTMLElementEventMap {
-        ready: BPDefaultUIReadyEvent;
-    }
 }
 /**
  * Complete player UI with controls, loading states, and error handling.

package/dist/components/bp-player.d.ts

@@ -4,7 +4,8 @@ import type { PlayerState } from '../core/state';
 import type { ProviderType, ProviderConfig, SourceDescription } from '../providers/contract';
 import type { BPLiveService } from '../bplive/service';
 import { VideoRenditionList } from './video-rendition-list';
-export type BPPlayerReadyEvent = CustomEvent<PlayerCore>;
+import type { ReadyEvent } from '../events';
+export type BPPlayerReadyEvent = ReadyEvent;
 declare global {
     interface HTMLElementTagNameMap {
         'bp-player': BPPlayer;

package/dist/core/events.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Player event system with typed events.
+ * Inspired by THEOplayer's event architecture.
+ */
+/**
+ * Base player event interface.
+ */
+export interface PlayerEvent<TType extends string = string> {
+    /** The type of the event. */
+    readonly type: TType;
+    /** The creation date of the event. */
+    readonly date: Date;
+}
+/**
+ * Player event types as const for type safety.
+ */
+export declare const PlayerEventType: {
+    readonly PLAY: "play";
+    readonly PAUSE: "pause";
+    readonly PLAYING: "playing";
+    readonly WAITING: "waiting";
+    readonly ENDED: "ended";
+    readonly SEEKING: "seeking";
+    readonly SEEKED: "seeked";
+    readonly TIME_UPDATE: "timeupdate";
+    readonly DURATION_CHANGE: "durationchange";
+    readonly LOAD_START: "loadstart";
+    readonly LOADED_METADATA: "loadedmetadata";
+    readonly LOADED_DATA: "loadeddata";
+    readonly CAN_PLAY: "canplay";
+    readonly CAN_PLAY_THROUGH: "canplaythrough";
+    readonly PROGRESS: "progress";
+    readonly EMPTIED: "emptied";
+    readonly VOLUME_CHANGE: "volumechange";
+    readonly RATE_CHANGE: "ratechange";
+    readonly RESIZE: "resize";
+    readonly QUALITIES_CHANGE: "qualitieschange";
+    readonly QUALITY_CHANGE: "qualitychange";
+    readonly TARGET_QUALITY_CHANGED: "targetqualitychanged";
+    readonly STATE_CHANGE: "statechange";
+    readonly READY: "ready";
+    readonly ERROR: "error";
+    readonly DESTROY: "destroy";
+};
+export type PlayerEventTypes = typeof PlayerEventType[keyof typeof PlayerEventType];
+export interface PlayEvent extends PlayerEvent<'play'> {
+}
+export interface PauseEvent extends PlayerEvent<'pause'> {
+}
+export interface PlayingEvent extends PlayerEvent<'playing'> {
+}
+export interface WaitingEvent extends PlayerEvent<'waiting'> {
+}
+export interface EndedEvent extends PlayerEvent<'ended'> {
+}
+export interface SeekingEvent extends PlayerEvent<'seeking'> {
+}
+export interface SeekedEvent extends PlayerEvent<'seeked'> {
+}
+export interface TimeUpdateEvent extends PlayerEvent<'timeupdate'> {
+    readonly currentTime: number;
+}
+export interface DurationChangeEvent extends PlayerEvent<'durationchange'> {
+    readonly duration: number;
+}
+export interface LoadStartEvent extends PlayerEvent<'loadstart'> {
+}
+export interface LoadedMetadataEvent extends PlayerEvent<'loadedmetadata'> {
+}
+export interface LoadedDataEvent extends PlayerEvent<'loadeddata'> {
+}
+export interface CanPlayEvent extends PlayerEvent<'canplay'> {
+}
+export interface CanPlayThroughEvent extends PlayerEvent<'canplaythrough'> {
+}
+export interface ProgressEvent extends PlayerEvent<'progress'> {
+}
+export interface EmptiedEvent extends PlayerEvent<'emptied'> {
+}
+export interface VolumeChangeEvent extends PlayerEvent<'volumechange'> {
+    readonly volume: number;
+    readonly muted: boolean;
+}
+export interface RateChangeEvent extends PlayerEvent<'ratechange'> {
+    readonly playbackRate: number;
+}
+export interface ResizeEvent extends PlayerEvent<'resize'> {
+    readonly videoWidth: number;
+    readonly videoHeight: number;
+}
+export interface StateChangeEvent extends PlayerEvent<'statechange'> {
+}
+export interface ReadyEvent extends PlayerEvent<'ready'> {
+}
+export interface DestroyEvent extends PlayerEvent<'destroy'> {
+}
+export interface PlayerErrorEvent extends PlayerEvent<'error'> {
+    readonly error: Error;
+    readonly code?: number;
+    readonly message: string;
+}
+/**
+ * Maps player event types to their event interfaces.
+ */
+export interface PlayerEventMap {
+    play: PlayEvent;
+    pause: PauseEvent;
+    playing: PlayingEvent;
+    waiting: WaitingEvent;
+    ended: EndedEvent;
+    seeking: SeekingEvent;
+    seeked: SeekedEvent;
+    timeupdate: TimeUpdateEvent;
+    durationchange: DurationChangeEvent;
+    loadstart: LoadStartEvent;
+    loadedmetadata: LoadedMetadataEvent;
+    loadeddata: LoadedDataEvent;
+    canplay: CanPlayEvent;
+    canplaythrough: CanPlayThroughEvent;
+    progress: ProgressEvent;
+    emptied: EmptiedEvent;
+    volumechange: VolumeChangeEvent;
+    ratechange: RateChangeEvent;
+    resize: ResizeEvent;
+    statechange: StateChangeEvent;
+    ready: ReadyEvent;
+    error: PlayerErrorEvent;
+    destroy: DestroyEvent;
+}
+/**
+ * Creates a player event with the given type and optional data.
+ */
+export declare function createPlayerEvent<TType extends keyof PlayerEventMap>(type: TType, data?: Omit<PlayerEventMap[TType], 'type' | 'date'>): PlayerEventMap[TType];
+/**
+ * Creates a DOM CustomEvent that wraps a PlayerEvent.
+ * Use this when dispatching events through DOM elements.
+ */
+export declare function createCustomEvent<TType extends keyof PlayerEventMap>(type: TType, data?: Omit<PlayerEventMap[TType], 'type' | 'date'>): CustomEvent<PlayerEventMap[TType]>;
+/**
+ * Creates a standard DOM Event with bubbles and composed.
+ * Use this for simple events that don't need extra data.
+ */
+export declare function createEvent(type: string): Event;
+/**
+ * Creates a DOM ErrorEvent with proper structure.
+ */
+export declare function createErrorEvent(error: Error, code?: number): ErrorEvent;
+//# sourceMappingURL=events.d.ts.map

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

@@ -126,7 +126,7 @@ export interface PlayerCore {
     setPlaybackRate(rate: number): void;
     setTargetQuality(quality: QualityLevel | null): void;
     setQuality(quality: QualityLevel | null): void;
-    setFullscreen(fullscreen: boolean): void;
+    setFullscreen(fullscreen: boolean): Promise<void>;
     setPresentationMode(mode: PresentationMode): void;
     destroy(): void;
 }
@@ -173,7 +173,8 @@ export declare class PlayerCoreImpl implements PlayerCore {
     setPlaybackRate(rate: number): void;
     setTargetQuality(quality: QualityLevel | null): void;
     setQuality(quality: QualityLevel | null): void;
-    setFullscreen(fullscreen: boolean): void;
+    private _getFullscreenTarget;
+    setFullscreen(fullscreen: boolean): Promise<void>;
     setPresentationMode(mode: PresentationMode): void;
     destroy(): void;
 }

package/dist/core/state.d.ts

@@ -1,3 +1,5 @@
+import type { ProviderType } from '../providers/contract';
+export type { ProviderType };
 export interface PlayerState {
     readonly paused: boolean;
     readonly playing: boolean;
@@ -36,7 +38,6 @@ export interface QualityLevel {
 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 {

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

@@ -20,6 +20,7 @@ declare class HlsVideoElement extends MediaTracksVideoElement {
     get config(): HlsVideoConfig | null;
     set config(value: HlsVideoConfig | null);
     attributeChangedCallback(attrName: string, oldValue: string | null, newValue: string | null): void;
+    disconnectedCallback(): void;
     load(): Promise<void>;
 }
 export default HlsVideoElement;

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

@@ -83,6 +83,8 @@ interface NanoPlayerConfig {
     };
 }
 interface NanoVideoConfig {
+    /** Direct URL to the NanoPlayer script. When set, bypasses libraryLocation construction. */
+    scriptUrl?: string;
     reconnect?: {
         minDelay: number;
         maxDelay: number;

package/dist/events/AddRenditionEvent.d.ts

@@ -0,0 +1,6 @@
+import type { VideoRendition } from '../components/video-rendition-list';
+export declare const ADD_RENDITION_EVENT: "addrendition";
+export interface AddRenditionEvent extends CustomEvent<VideoRendition> {
+    type: typeof ADD_RENDITION_EVENT;
+}
+//# sourceMappingURL=AddRenditionEvent.d.ts.map

package/dist/events/CanPlayEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const CAN_PLAY_EVENT: "canplay";
+export interface CanPlayEvent extends Event {
+    type: typeof CAN_PLAY_EVENT;
+}
+//# sourceMappingURL=CanPlayEvent.d.ts.map

package/dist/events/CanPlayThroughEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const CAN_PLAY_THROUGH_EVENT: "canplaythrough";
+export interface CanPlayThroughEvent extends Event {
+    type: typeof CAN_PLAY_THROUGH_EVENT;
+}
+//# sourceMappingURL=CanPlayThroughEvent.d.ts.map

package/dist/events/ChangeEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const CHANGE_EVENT: "change";
+export interface ChangeEvent extends Event {
+    type: typeof CHANGE_EVENT;
+}
+//# sourceMappingURL=ChangeEvent.d.ts.map

package/dist/events/DurationChangeEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const DURATION_CHANGE_EVENT: "durationchange";
+export interface DurationChangeEvent extends Event {
+    type: typeof DURATION_CHANGE_EVENT;
+}
+//# sourceMappingURL=DurationChangeEvent.d.ts.map

package/dist/events/EmptiedEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const EMPTIED_EVENT: "emptied";
+export interface EmptiedEvent extends Event {
+    type: typeof EMPTIED_EVENT;
+}
+//# sourceMappingURL=EmptiedEvent.d.ts.map

package/dist/events/EndedEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const ENDED_EVENT: "ended";
+export interface EndedEvent extends Event {
+    type: typeof ENDED_EVENT;
+}
+//# sourceMappingURL=EndedEvent.d.ts.map

package/dist/events/ErrorEvent.d.ts

@@ -0,0 +1,9 @@
+export declare const ERROR_EVENT: "error";
+export interface ErrorEventDetail {
+    error: Error;
+    code?: number;
+}
+export interface PlayerErrorEvent extends CustomEvent<ErrorEventDetail> {
+    type: typeof ERROR_EVENT;
+}
+//# sourceMappingURL=ErrorEvent.d.ts.map

package/dist/events/EventUtils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Cross-browser event factory utilities.
+ */
+export type EventFactory = <TType extends string = string>(type: TType, eventInitDict?: EventInit) => Event & {
+    readonly type: TType;
+};
+export type CustomEventFactory = <TType extends string = string, TDetail = unknown>(type: TType, eventInitDict?: CustomEventInit<TDetail>) => CustomEvent<TDetail> & {
+    readonly type: TType;
+};
+/**
+ * Creates a DOM Event with bubbles and composed enabled by default.
+ */
+export declare const createEvent: EventFactory;
+/**
+ * Creates a DOM CustomEvent with bubbles and composed enabled by default.
+ */
+export declare const createCustomEvent: CustomEventFactory;
+/**
+ * Creates a DOM ErrorEvent with bubbles and composed enabled by default.
+ */
+export declare function createErrorEvent(error: Error, code?: number): ErrorEvent;
+//# sourceMappingURL=EventUtils.d.ts.map

package/dist/events/LoadStartEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const LOAD_START_EVENT: "loadstart";
+export interface LoadStartEvent extends Event {
+    type: typeof LOAD_START_EVENT;
+}
+//# sourceMappingURL=LoadStartEvent.d.ts.map

package/dist/events/LoadedDataEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const LOADED_DATA_EVENT: "loadeddata";
+export interface LoadedDataEvent extends Event {
+    type: typeof LOADED_DATA_EVENT;
+}
+//# sourceMappingURL=LoadedDataEvent.d.ts.map

package/dist/events/LoadedMetadataEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const LOADED_METADATA_EVENT: "loadedmetadata";
+export interface LoadedMetadataEvent extends Event {
+    type: typeof LOADED_METADATA_EVENT;
+}
+//# sourceMappingURL=LoadedMetadataEvent.d.ts.map

package/dist/events/PauseEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const PAUSE_EVENT: "pause";
+export interface PauseEvent extends Event {
+    type: typeof PAUSE_EVENT;
+}
+//# sourceMappingURL=PauseEvent.d.ts.map

package/dist/events/PlayEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const PLAY_EVENT: "play";
+export interface PlayEvent extends Event {
+    type: typeof PLAY_EVENT;
+}
+//# sourceMappingURL=PlayEvent.d.ts.map

package/dist/events/PlayingEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const PLAYING_EVENT: "playing";
+export interface PlayingEvent extends Event {
+    type: typeof PLAYING_EVENT;
+}
+//# sourceMappingURL=PlayingEvent.d.ts.map

package/dist/events/ProgressEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const PROGRESS_EVENT: "progress";
+export interface ProgressEvent extends Event {
+    type: typeof PROGRESS_EVENT;
+}
+//# sourceMappingURL=ProgressEvent.d.ts.map

package/dist/events/RateChangeEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const RATE_CHANGE_EVENT: "ratechange";
+export interface RateChangeEvent extends Event {
+    type: typeof RATE_CHANGE_EVENT;
+}
+//# sourceMappingURL=RateChangeEvent.d.ts.map

package/dist/events/ReadyEvent.d.ts

@@ -0,0 +1,6 @@
+import type { PlayerCore } from '../core/player-core';
+export declare const READY_EVENT: "ready";
+export interface ReadyEvent extends CustomEvent<PlayerCore> {
+    type: typeof READY_EVENT;
+}
+//# sourceMappingURL=ReadyEvent.d.ts.map

package/dist/events/ResizeEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const RESIZE_EVENT: "resize";
+export interface ResizeEvent extends Event {
+    type: typeof RESIZE_EVENT;
+}
+//# sourceMappingURL=ResizeEvent.d.ts.map

package/dist/events/SeekedEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const SEEKED_EVENT: "seeked";
+export interface SeekedEvent extends Event {
+    type: typeof SEEKED_EVENT;
+}
+//# sourceMappingURL=SeekedEvent.d.ts.map

package/dist/events/SeekingEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const SEEKING_EVENT: "seeking";
+export interface SeekingEvent extends Event {
+    type: typeof SEEKING_EVENT;
+}
+//# sourceMappingURL=SeekingEvent.d.ts.map

package/dist/events/TimeUpdateEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const TIME_UPDATE_EVENT: "timeupdate";
+export interface TimeUpdateEvent extends Event {
+    type: typeof TIME_UPDATE_EVENT;
+}
+//# sourceMappingURL=TimeUpdateEvent.d.ts.map

package/dist/events/VolumeChangeEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const VOLUME_CHANGE_EVENT: "volumechange";
+export interface VolumeChangeEvent extends Event {
+    type: typeof VOLUME_CHANGE_EVENT;
+}
+//# sourceMappingURL=VolumeChangeEvent.d.ts.map

package/dist/events/WaitingEvent.d.ts

@@ -0,0 +1,5 @@
+export declare const WAITING_EVENT: "waiting";
+export interface WaitingEvent extends Event {
+    type: typeof WAITING_EVENT;
+}
+//# sourceMappingURL=WaitingEvent.d.ts.map

package/dist/events/index.d.ts

@@ -0,0 +1,49 @@
+export { createEvent, createCustomEvent, createErrorEvent } from './EventUtils';
+export type { EventFactory, CustomEventFactory } from './EventUtils';
+export { PLAY_EVENT } from './PlayEvent';
+export type { PlayEvent } from './PlayEvent';
+export { PAUSE_EVENT } from './PauseEvent';
+export type { PauseEvent } from './PauseEvent';
+export { PLAYING_EVENT } from './PlayingEvent';
+export type { PlayingEvent } from './PlayingEvent';
+export { WAITING_EVENT } from './WaitingEvent';
+export type { WaitingEvent } from './WaitingEvent';
+export { ENDED_EVENT } from './EndedEvent';
+export type { EndedEvent } from './EndedEvent';
+export { SEEKING_EVENT } from './SeekingEvent';
+export type { SeekingEvent } from './SeekingEvent';
+export { SEEKED_EVENT } from './SeekedEvent';
+export type { SeekedEvent } from './SeekedEvent';
+export { TIME_UPDATE_EVENT } from './TimeUpdateEvent';
+export type { TimeUpdateEvent } from './TimeUpdateEvent';
+export { DURATION_CHANGE_EVENT } from './DurationChangeEvent';
+export type { DurationChangeEvent } from './DurationChangeEvent';
+export { LOAD_START_EVENT } from './LoadStartEvent';
+export type { LoadStartEvent } from './LoadStartEvent';
+export { LOADED_METADATA_EVENT } from './LoadedMetadataEvent';
+export type { LoadedMetadataEvent } from './LoadedMetadataEvent';
+export { LOADED_DATA_EVENT } from './LoadedDataEvent';
+export type { LoadedDataEvent } from './LoadedDataEvent';
+export { CAN_PLAY_EVENT } from './CanPlayEvent';
+export type { CanPlayEvent } from './CanPlayEvent';
+export { CAN_PLAY_THROUGH_EVENT } from './CanPlayThroughEvent';
+export type { CanPlayThroughEvent } from './CanPlayThroughEvent';
+export { PROGRESS_EVENT } from './ProgressEvent';
+export type { ProgressEvent } from './ProgressEvent';
+export { EMPTIED_EVENT } from './EmptiedEvent';
+export type { EmptiedEvent } from './EmptiedEvent';
+export { VOLUME_CHANGE_EVENT } from './VolumeChangeEvent';
+export type { VolumeChangeEvent } from './VolumeChangeEvent';
+export { RATE_CHANGE_EVENT } from './RateChangeEvent';
+export type { RateChangeEvent } from './RateChangeEvent';
+export { RESIZE_EVENT } from './ResizeEvent';
+export type { ResizeEvent } from './ResizeEvent';
+export { ERROR_EVENT } from './ErrorEvent';
+export type { PlayerErrorEvent, ErrorEventDetail } from './ErrorEvent';
+export { READY_EVENT } from './ReadyEvent';
+export type { ReadyEvent } from './ReadyEvent';
+export { CHANGE_EVENT } from './ChangeEvent';
+export type { ChangeEvent } from './ChangeEvent';
+export { ADD_RENDITION_EVENT } from './AddRenditionEvent';
+export type { AddRenditionEvent } from './AddRenditionEvent';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts

@@ -5,7 +5,7 @@ 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 { createPlayerCore } 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';

package/dist/providers/contract.d.ts

@@ -81,6 +81,8 @@ export interface VideoProviderConfig {
     capLevelToPlayerSize?: boolean;
 }
 export interface NanoProviderConfig {
+    /** Direct URL to the NanoPlayer script. When set, bypasses libraryLocation construction. */
+    scriptUrl?: string;
     reconnect?: {
         minDelay: number;
         maxDelay: number;

package/dist/util/converters.d.ts

@@ -0,0 +1,14 @@
+import type { ComplexAttributeConverter } from 'lit';
+/**
+ * Creates a JSON converter for Lit complex attributes.
+ * Allows setting complex objects (source, config) as JSON strings in HTML attributes.
+ *
+ * @returns A ComplexAttributeConverter for use with Lit @property decorator
+ *
+ * @example
+ * ```typescript
+ * @property({ converter: jsonConverter() }) config?: Config;
+ * ```
+ */
+export declare function jsonConverter<T = unknown>(): ComplexAttributeConverter<T | undefined>;
+//# sourceMappingURL=converters.d.ts.map

package/dist/util/index.d.ts

@@ -1,2 +1,3 @@
 export * from './attribute';
+export * from './converters';
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@broadcastingplatforms/player",
-  "version": "0.0.0-dev.c57124a",
+  "version": "1.1.0",
   "description": "Universal video player web component built with Lit",
   "type": "module",
   "main": "dist/bp-player.js",
@@ -9,29 +9,12 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/bp-player.mjs",
-      "require": "./dist/bp-player.js"
+      "import": "./dist/bp-player.mjs"
     },
     "./standalone": {
       "types": "./dist/index.d.ts",
       "import": "./dist/bp-player.standalone.mjs"
     },
-    "./elements": {
-      "types": "./dist/elements/index.d.ts",
-      "import": "./dist/elements/index.js"
-    },
-    "./elements/hls-video": {
-      "types": "./dist/elements/hls-video.d.ts",
-      "import": "./dist/elements/hls-video.js"
-    },
-    "./elements/nano-video": {
-      "types": "./dist/elements/nano-video.d.ts",
-      "import": "./dist/elements/nano-video.js"
-    },
-    "./elements/livekit-video": {
-      "types": "./dist/elements/livekit-video.d.ts",
-      "import": "./dist/elements/livekit-video.js"
-    },
     "./dist/*": "./dist/*",
     "./package.json": "./package.json"
   },
@@ -53,10 +36,9 @@
     "concurrently": "^9.1.2",
     "esbuild": "^0.24.0",
     "typescript": "^5.7.2",
-    "vite": "^6.0.5",
-    "@broadcastingplatforms/web-connectors": "0.0.0-dev.c57124a"
+    "vite": "^6.0.5"
   },
-  "license": "UNLICENSED",
+  "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {
     "access": "public"
   },