@alessmicrosystems/mpegts.js 1.8.1

package/d.ts/src/demux/scte35.d.ts

@@ -0,0 +1,250 @@
+export type SCTE35Data = {
+    splice_command_type: SCTE35CommandType.kSpliceInsert;
+    pts?: number;
+    nearest_pts?: number;
+    auto_return?: boolean;
+    duraiton?: number;
+    detail: SCTE35Detail;
+    data: Uint8Array;
+} | {
+    splice_command_type: SCTE35CommandType.kTimeSignal;
+    pts?: number;
+    nearest_pts?: number;
+    detail: SCTE35Detail;
+    data: Uint8Array;
+} | {
+    splice_command_type: SCTE35CommandType.kSpliceNull | SCTE35CommandType.kBandwidthReservation | SCTE35CommandType.kSpliceSchedule | SCTE35CommandType.kPrivateCommand;
+    pts: undefined;
+    nearest_pts?: number;
+    detail: SCTE35Detail;
+    data: Uint8Array;
+};
+type SCTE35Detail = {
+    table_id: number;
+    section_syntax_indicator: boolean;
+    private_indicator: boolean;
+    section_length: number;
+    protocol_version: number;
+    encrypted_packet: boolean;
+    encryption_algorithm: number;
+    pts_adjustment: number;
+    cw_index: number;
+    tier: number;
+    splice_command_length: number;
+    splice_command_type: SCTE35CommandType.kSpliceNull;
+    splice_command: SpliceNull;
+    descriptor_loop_length: number;
+    splice_descriptors: SpliceDescriptor[];
+    E_CRC32?: number;
+    CRC32: number;
+} | {
+    table_id: number;
+    section_syntax_indicator: boolean;
+    private_indicator: boolean;
+    section_length: number;
+    protocol_version: number;
+    encrypted_packet: boolean;
+    encryption_algorithm: number;
+    pts_adjustment: number;
+    cw_index: number;
+    tier: number;
+    splice_command_length: number;
+    splice_command_type: SCTE35CommandType.kSpliceSchedule;
+    splice_command: SpliceSchedule;
+    descriptor_loop_length: number;
+    splice_descriptors: SpliceDescriptor[];
+    E_CRC32?: number;
+    CRC32: number;
+} | {
+    table_id: number;
+    section_syntax_indicator: boolean;
+    private_indicator: boolean;
+    section_length: number;
+    protocol_version: number;
+    encrypted_packet: boolean;
+    encryption_algorithm: number;
+    pts_adjustment: number;
+    cw_index: number;
+    tier: number;
+    splice_command_length: number;
+    splice_command_type: SCTE35CommandType.kSpliceInsert;
+    splice_command: SpliceInsert;
+    descriptor_loop_length: number;
+    splice_descriptors: SpliceDescriptor[];
+    E_CRC32?: number;
+    CRC32: number;
+} | {
+    table_id: number;
+    section_syntax_indicator: boolean;
+    private_indicator: boolean;
+    section_length: number;
+    protocol_version: number;
+    encrypted_packet: boolean;
+    encryption_algorithm: number;
+    pts_adjustment: number;
+    cw_index: number;
+    tier: number;
+    splice_command_length: number;
+    splice_command_type: SCTE35CommandType.kTimeSignal;
+    splice_command: TimeSignal;
+    descriptor_loop_length: number;
+    splice_descriptors: SpliceDescriptor[];
+    E_CRC32?: number;
+    CRC32: number;
+} | {
+    table_id: number;
+    section_syntax_indicator: boolean;
+    private_indicator: boolean;
+    section_length: number;
+    protocol_version: number;
+    encrypted_packet: boolean;
+    encryption_algorithm: number;
+    pts_adjustment: number;
+    cw_index: number;
+    tier: number;
+    splice_command_length: number;
+    splice_command_type: SCTE35CommandType.kBandwidthReservation;
+    splice_command: BandwidthReservation;
+    descriptor_loop_length: number;
+    splice_descriptors: SpliceDescriptor[];
+    E_CRC32?: number;
+    CRC32: number;
+} | {
+    table_id: number;
+    section_syntax_indicator: boolean;
+    private_indicator: boolean;
+    section_length: number;
+    protocol_version: number;
+    encrypted_packet: boolean;
+    encryption_algorithm: number;
+    pts_adjustment: number;
+    cw_index: number;
+    tier: number;
+    splice_command_length: number;
+    splice_command_type: SCTE35CommandType.kPrivateCommand;
+    splice_command: PrivateCommand;
+    descriptor_loop_length: number;
+    splice_descriptors: SpliceDescriptor[];
+    E_CRC32?: number;
+    CRC32: number;
+};
+export declare enum SCTE35CommandType {
+    kSpliceNull = 0,
+    kSpliceSchedule = 4,
+    kSpliceInsert = 5,
+    kTimeSignal = 6,
+    kBandwidthReservation = 7,
+    kPrivateCommand = 255
+}
+type SpliceTime = {
+    time_specified_flag: boolean;
+    pts_time?: number;
+};
+type BreakDuration = {
+    auto_return: boolean;
+    duration: number;
+};
+type SpliceInsertComponent = {
+    component_tag: number;
+    splice_time?: SpliceTime;
+};
+type SpliceScheduleEventComponent = {
+    component_tag: number;
+    utc_splice_time: number;
+};
+type SpliceScheduleEvent = {
+    splice_event_id: number;
+    splice_event_cancel_indicator: boolean;
+    out_of_network_indicator?: boolean;
+    program_splice_flag?: boolean;
+    duration_flag?: boolean;
+    utc_splice_time?: number;
+    component_count?: number;
+    components?: SpliceScheduleEventComponent[];
+    break_duration?: BreakDuration;
+    unique_program_id?: number;
+    avail_num?: number;
+    avails_expected?: number;
+};
+type SpliceNull = {};
+type SpliceSchedule = {
+    splice_count: number;
+    events: SpliceScheduleEvent[];
+};
+type SpliceInsert = {
+    splice_event_id: number;
+    splice_event_cancel_indicator: boolean;
+    out_of_network_indicator?: boolean;
+    program_splice_flag?: boolean;
+    duration_flag?: boolean;
+    splice_immediate_flag?: boolean;
+    splice_time?: SpliceTime;
+    component_count?: number;
+    components?: SpliceInsertComponent[];
+    break_duration?: BreakDuration;
+    unique_program_id?: number;
+    avail_num?: number;
+    avails_expected?: number;
+};
+type TimeSignal = {
+    splice_time: SpliceTime;
+};
+type BandwidthReservation = {};
+type PrivateCommand = {
+    identifier: string;
+    private_data: ArrayBuffer;
+};
+type Descriptor = {
+    descriptor_tag: number;
+    descriptor_length: number;
+    identifier: string;
+};
+type AvailDescriptor = Descriptor & {
+    provider_avail_id: number;
+};
+type DTMFDescriptor = Descriptor & {
+    preroll: number;
+    dtmf_count: number;
+    DTMF_char: string;
+};
+type SegmentationDescriptor = Descriptor & {
+    segmentation_event_id: number;
+    segmentation_event_cancel_indicator: boolean;
+    program_segmentation_flag?: boolean;
+    segmentation_duration_flag?: boolean;
+    delivery_not_restricted_flag?: boolean;
+    web_delivery_allowed_flag?: boolean;
+    no_regional_blackout_flag?: boolean;
+    archive_allowed_flag?: boolean;
+    device_restrictions?: number;
+    component_count?: number;
+    components?: any[];
+    segmentation_duration?: number;
+    segmentation_upid_type?: number;
+    segmentation_upid_length?: number;
+    segmentation_upid?: ArrayBuffer;
+    segmentation_type_id?: number;
+    segment_num?: number;
+    segments_expected?: number;
+    sub_segment_num?: number;
+    sub_segments_expected?: number;
+};
+type TimeDescriptor = Descriptor & {
+    TAI_seconds: number;
+    TAI_ns: number;
+    UTC_offset: number;
+};
+type AudioDescriptorComponent = {
+    component_tag: number;
+    ISO_code: string;
+    Bit_Stream_Mode: number;
+    Num_Channels: number;
+    Full_Srvc_Audio: boolean;
+};
+type AudioDescriptor = Descriptor & {
+    audio_count: number;
+    components: AudioDescriptorComponent[];
+};
+type SpliceDescriptor = AvailDescriptor | DTMFDescriptor | SegmentationDescriptor | TimeDescriptor | AudioDescriptor;
+export declare const readSCTE35: (data: Uint8Array) => SCTE35Data;
+export {};

package/d.ts/src/demux/sei.d.ts

@@ -0,0 +1,8 @@
+export declare class SEIData {
+    type: number;
+    size: number;
+    uuid: Uint8Array;
+    user_data: Uint8Array;
+    pts?: number;
+}
+export declare function parseSEI(data: Uint8Array, pts?: number, codec?: 'h264' | 'h265'): SEIData | null;

package/d.ts/src/demux/smpte2038.d.ts

@@ -0,0 +1,22 @@
+export declare class SMPTE2038Data {
+    pid: number;
+    stream_id: number;
+    pts?: number;
+    dts?: number;
+    nearest_pts?: number;
+    ancillaries: AncillaryData[];
+    data: Uint8Array;
+    len: number;
+}
+type AncillaryData = {
+    yc_indicator: boolean;
+    line_number: number;
+    horizontal_offset: number;
+    did: number;
+    sdid: number;
+    user_data: Uint8Array;
+    description: string;
+    information: any;
+};
+export declare const smpte2038parse: (data: Uint8Array) => AncillaryData[];
+export {};

package/d.ts/src/demux/ts-demuxer.d.ts

@@ -0,0 +1,124 @@
+import BaseDemuxer from './base-demuxer';
+declare class TSDemuxer extends BaseDemuxer {
+    private readonly TAG;
+    private config_;
+    private ts_packet_size_;
+    private sync_offset_;
+    private first_parse_;
+    private media_info_;
+    private timescale_;
+    private duration_;
+    private pat_;
+    private current_program_;
+    private current_pmt_pid_;
+    private pmt_;
+    private program_pmt_map_;
+    private pes_slice_queues_;
+    private section_slice_queues_;
+    private video_metadata_;
+    private audio_metadata_;
+    private last_pcr_;
+    private last_pcr_base_;
+    private timestamp_offset_;
+    private audio_last_sample_pts_;
+    private aac_last_incomplete_data_;
+    private has_video_;
+    private has_audio_;
+    private video_init_segment_dispatched_;
+    private audio_init_segment_dispatched_;
+    private video_metadata_changed_;
+    private audio_metadata_changed_;
+    private video_keyframe_seen_after_init_;
+    private stashed_audio_before_video_init_;
+    private _last_dispatch_block_reason_;
+    private video_init_dispatch_time_;
+    private active_audio_pid_;
+    private loas_previous_frame;
+    private video_track_;
+    private audio_track_;
+    constructor(probe_data: any, config: any);
+    destroy(): void;
+    static probe(buffer: ArrayBuffer): {
+        needMoreData: boolean;
+        match?: undefined;
+        consumed?: undefined;
+        ts_packet_size?: undefined;
+        sync_offset?: undefined;
+    } | {
+        match: boolean;
+        needMoreData?: undefined;
+        consumed?: undefined;
+        ts_packet_size?: undefined;
+        sync_offset?: undefined;
+    } | {
+        match: boolean;
+        consumed: number;
+        ts_packet_size: number;
+        sync_offset: number;
+        needMoreData?: undefined;
+    };
+    bindDataSource(loader: any): this;
+    resetMediaInfo(): void;
+    /**
+     * Switch to a different audio PID discovered in the PMT.
+     * Call with a pid from onTracksUpdated audioTracks, or 0 to revert to default.
+     * Resets audio init state so the new stream is initialised cleanly.
+     */
+    selectAudioPid(pid: number): void;
+    /** Store a PID preference before PMT arrives — applied by auto-fallback on first parse. */
+    setPreferredAudioPid(pid: number): void;
+    /** Returns the current PMT track lists (same data as onTracksUpdated). */
+    getAvailableTracks(): {
+        audioTracks: {
+            pid: number;
+            codec: string;
+            lang?: string;
+        }[];
+        subtitleTracks: {
+            pid: number;
+            type: string;
+            lang?: string;
+        }[];
+    };
+    parseChunks(chunk: ArrayBuffer, byte_start: number): number;
+    private handleSectionSlice;
+    private handlePESSlice;
+    private emitSectionSlices;
+    private emitPESSlices;
+    private clearSlices;
+    private parseSection;
+    private parsePES;
+    private parsePAT;
+    private parsePMT;
+    private parseSCTE35;
+    private parseAV1Payload;
+    private parseH264Payload;
+    private parseH265Payload;
+    private detectVideoMetadataChange;
+    private isInitSegmentDispatched;
+    private dispatchVideoInitSegment;
+    private dispatchVideoMediaSegment;
+    private dispatchAudioMediaSegment;
+    private stashAudioBeforeVideoInit;
+    private dispatchAudioVideoMediaSegment;
+    private parseADTSAACPayload;
+    private parseLOASAACPayload;
+    private parseAC3Payload;
+    private parseEAC3Payload;
+    private parseOpusPayload;
+    private parseMP3Payload;
+    private detectAudioMetadataChange;
+    private dispatchAudioInitSegment;
+    private dispatchPESPrivateDataDescriptor;
+    private parsePESPrivateDataPayload;
+    private parseTimedID3MetadataPayload;
+    private parsePGSPayload;
+    private parseSynchronousKLVMetadataPayload;
+    private parseAsynchronousKLVMetadataPayload;
+    private parseSMPTE2038MetadataPayload;
+    private parseSEIPayload;
+    private getNearestTimestampMilliseconds;
+    private getPcrBase;
+    private getTimestamp;
+}
+export default TSDemuxer;

package/d.ts/src/player/live-latency-chaser.d.ts

@@ -0,0 +1,10 @@
+declare class LiveLatencyChaser {
+    private _config;
+    private _media_element;
+    private _on_direct_seek;
+    constructor(config: any, media_element: HTMLMediaElement, on_direct_seek: (target: number) => void);
+    destroy(): void;
+    notifyBufferedRangeUpdate(): void;
+    private _chaseLiveLatency;
+}
+export default LiveLatencyChaser;

package/d.ts/src/player/live-latency-synchronizer.d.ts

@@ -0,0 +1,10 @@
+declare class LiveLatencySynchronizer {
+    private _config;
+    private _media_element;
+    private e?;
+    constructor(config: any, media_element: HTMLMediaElement);
+    destroy(): void;
+    private _onMediaTimeUpdate;
+    private _getCurrentLatency;
+}
+export default LiveLatencySynchronizer;

package/d.ts/src/player/loading-controller.d.ts

@@ -0,0 +1,19 @@
+declare class LoadingController {
+    private readonly TAG;
+    private _config;
+    private _media_element;
+    private _on_pause_transmuxer;
+    private _on_resume_transmuxer;
+    private _paused;
+    private e?;
+    constructor(config: any, media_element: HTMLMediaElement, on_pause_transmuxer: () => void, on_resume_transmuxer: () => void);
+    destroy(): void;
+    notifyBufferedPositionChanged(buffered_position?: number): void;
+    private _onMediaTimeUpdate;
+    private _suspendTransmuxerIfNeeded;
+    private _suspendTransmuxerIfBufferedPositionExceeded;
+    suspendTransmuxer(): void;
+    private _resumeTransmuxerIfNeeded;
+    resumeTransmuxer(): void;
+}
+export default LoadingController;

package/d.ts/src/player/mse-player.d.ts

@@ -0,0 +1,30 @@
+import MediaInfo from '../core/media-info';
+declare class MSEPlayer {
+    private readonly TAG;
+    private _type;
+    private _media_element;
+    private _player_engine;
+    constructor(mediaDataSource: any, config?: any);
+    destroy(): void;
+    on(event: string, listener: (...args: any[]) => void): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    attachMediaElement(mediaElement: HTMLMediaElement): void;
+    detachMediaElement(): void;
+    load(): void;
+    unload(): void;
+    play(): Promise<void>;
+    pause(): void;
+    get type(): string;
+    get buffered(): TimeRanges;
+    get duration(): number;
+    get volume(): number;
+    set volume(value: number);
+    get muted(): boolean;
+    set muted(muted: boolean);
+    get currentTime(): number;
+    set currentTime(seconds: number);
+    get mediaInfo(): MediaInfo;
+    get statisticsInfo(): any;
+    switchAudioPid(pid: number): void;
+}
+export default MSEPlayer;

package/d.ts/src/player/player-engine-dedicated-thread-worker.d.ts

@@ -0,0 +1,2 @@
+declare let PlayerEngineWorker: (self: DedicatedWorkerGlobalScope) => void;
+export default PlayerEngineWorker;

package/d.ts/src/player/player-engine-dedicated-thread.d.ts

@@ -0,0 +1,48 @@
+import type PlayerEngine from './player-engine';
+import MediaInfo from '../core/media-info';
+declare class PlayerEngineDedicatedThread implements PlayerEngine {
+    private readonly TAG;
+    private _emitter;
+    private _media_data_source;
+    private _config;
+    private _media_element?;
+    private _worker;
+    private _worker_destroying;
+    private _seeking_handler?;
+    private _loading_controller?;
+    private _startup_stall_jumper?;
+    private _live_latency_chaser?;
+    private _live_latency_synchronizer?;
+    private _pending_seek_time?;
+    private _media_info?;
+    private _statistics_info?;
+    private e?;
+    static isSupported(): boolean;
+    constructor(mediaDataSource: any, config: any);
+    destroy(): void;
+    on(event: string, listener: (...args: any[]) => void): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    attachMediaElement(mediaElement: HTMLMediaElement): void;
+    detachMediaElement(): void;
+    load(): void;
+    unload(): void;
+    play(): Promise<void>;
+    pause(): void;
+    seek(seconds: number): void;
+    get mediaInfo(): MediaInfo;
+    get statisticsInfo(): any;
+    _onLoggingConfigChanged(config: any): void;
+    private _onMSEUpdateEnd;
+    private _onMSEBufferFull;
+    private _onMediaLoadedMetadata;
+    private _onRequestDirectSeek;
+    private _onRequiredUnbufferedSeek;
+    private _onRequestPauseTransmuxer;
+    private _onRequestResumeTransmuxer;
+    private _onMediaTimeUpdate;
+    private _onMediaReadyStateChange;
+    private _onWorkerMessage;
+    private _fillStatisticsInfo;
+    switchAudioPid(pid: number): void;
+}
+export default PlayerEngineDedicatedThread;

package/d.ts/src/player/player-engine-main-thread.d.ts

@@ -0,0 +1,50 @@
+import type PlayerEngine from './player-engine';
+import MediaInfo from '../core/media-info';
+declare class PlayerEngineMainThread implements PlayerEngine {
+    private readonly TAG;
+    private _emitter;
+    private _media_data_source;
+    private _config;
+    private _media_element?;
+    private _mse_controller?;
+    private _transmuxer?;
+    private _pending_seek_time?;
+    private _seeking_handler?;
+    private _loading_controller?;
+    private _startup_stall_jumper?;
+    private _live_latency_chaser?;
+    private _live_latency_synchronizer?;
+    private _mse_source_opened;
+    private _has_pending_load;
+    private _loaded_metadata_received;
+    private _media_info?;
+    private _statistics_info?;
+    private e?;
+    constructor(mediaDataSource: any, config: any);
+    destroy(): void;
+    on(event: string, listener: (...args: any[]) => void): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    attachMediaElement(mediaElement: HTMLMediaElement): void;
+    detachMediaElement(): void;
+    load(): void;
+    unload(): void;
+    play(): Promise<void>;
+    pause(): void;
+    seek(seconds: number): void;
+    get mediaInfo(): MediaInfo;
+    get statisticsInfo(): any;
+    private _onMSESourceOpen;
+    private _onMSEUpdateEnd;
+    private _onMSEBufferFull;
+    private _onMSEError;
+    private _onMSEStartStreaming;
+    private _onMSEEndStreaming;
+    private _onMediaLoadedMetadata;
+    private _onRequestDirectSeek;
+    private _onRequiredUnbufferedSeek;
+    private _onRequestPauseTransmuxer;
+    private _onRequestResumeTransmuxer;
+    private _fillStatisticsInfo;
+    switchAudioPid(pid: number): void;
+}
+export default PlayerEngineMainThread;

package/d.ts/src/player/player-engine-worker-cmd-def.d.ts

@@ -0,0 +1,25 @@
+export type WorkerCommandOp = 'logging_config' | 'init' | 'destroy' | 'initialize_mse' | 'shutdown_mse' | 'load' | 'unload' | 'unbuffered_seek' | 'timeupdate' | 'readystatechange' | 'pause_transmuxer' | 'resume_transmuxer' | 'switch_audio_pid';
+export type WorkerCommandPacket = {
+    cmd: WorkerCommandOp;
+};
+export type WorkerCommandPacketInit = WorkerCommandPacket & {
+    cmd: 'init';
+    media_data_source: any;
+    config: any;
+};
+export type WorkerCommandPacketLoggingConfig = WorkerCommandPacket & {
+    cmd: 'logging_config';
+    logging_config: any;
+};
+export type WorkerCommandPacketUnbufferedSeek = WorkerCommandPacket & {
+    cmd: 'unbuffered_seek';
+    milliseconds: number;
+};
+export type WorkerCommandPacketTimeUpdate = WorkerCommandPacket & {
+    cmd: 'timeupdate';
+    current_time: number;
+};
+export type WorkerCommandPacketReadyStateChange = WorkerCommandPacket & {
+    cmd: 'readystatechange';
+    ready_state: number;
+};

package/d.ts/src/player/player-engine-worker-msg-def.d.ts

@@ -0,0 +1,54 @@
+import MSEEvents from '../core/mse-events';
+import PlayerEvents from './player-events';
+import TransmuxingEvents from '../core/transmuxing-events';
+export type WorkerMessageType = 'destroyed' | 'mse_init' | 'mse_event' | 'player_event' | 'transmuxing_event' | 'buffered_position_changed' | 'logcat_callback';
+export type WorkerMessagePacket = {
+    msg: WorkerMessageType;
+};
+export type WorkerMessagePacketMSEInit = WorkerMessagePacket & {
+    msg: 'mse_init';
+    handle: any;
+};
+export type WorkerMessagePacketMSEEvent = WorkerMessagePacket & {
+    msg: 'mse_event';
+    event: MSEEvents;
+};
+export type WorkerMessagePacketPlayerEvent = WorkerMessagePacket & {
+    msg: 'player_event';
+    event: PlayerEvents;
+};
+export type WorkerMessagePacketPlayerEventError = WorkerMessagePacketPlayerEvent & {
+    msg: 'player_event';
+    event: PlayerEvents.ERROR;
+    error_type: string;
+    error_detail: string;
+    info: any;
+};
+export type WorkerMessagePacketPlayerEventExtraData = WorkerMessagePacketPlayerEvent & {
+    msg: 'player_event';
+    event: PlayerEvents.METADATA_ARRIVED | PlayerEvents.SCRIPTDATA_ARRIVED | PlayerEvents.TIMED_ID3_METADATA_ARRIVED | PlayerEvents.PGS_SUBTITLE_ARRIVED | PlayerEvents.SYNCHRONOUS_KLV_METADATA_ARRIVED | PlayerEvents.ASYNCHRONOUS_KLV_METADATA_ARRIVED | PlayerEvents.SMPTE2038_METADATA_ARRIVED | PlayerEvents.SEI_ARRIVED | PlayerEvents.SCTE35_METADATA_ARRIVED | PlayerEvents.PES_PRIVATE_DATA_DESCRIPTOR | PlayerEvents.PES_PRIVATE_DATA_ARRIVED;
+    extraData: any;
+};
+export type WorkerMessagePacketTransmuxingEvent = WorkerMessagePacket & {
+    msg: 'transmuxing_event';
+    event: TransmuxingEvents;
+};
+export type WorkerMessagePacketTransmuxingEventInfo = WorkerMessagePacketTransmuxingEvent & {
+    msg: 'transmuxing_event';
+    event: TransmuxingEvents.MEDIA_INFO | TransmuxingEvents.STATISTICS_INFO;
+    info: any;
+};
+export type WorkerMessagePacketTransmuxingEventRecommendSeekpoint = WorkerMessagePacketTransmuxingEvent & {
+    msg: 'transmuxing_event';
+    event: TransmuxingEvents.RECOMMEND_SEEKPOINT;
+    milliseconds: number;
+};
+export type WorkerMessagePacketBufferedPositionChanged = WorkerMessagePacket & {
+    msg: 'buffered_position_changed';
+    buffered_position_milliseconds: number;
+};
+export type WorkerMessagePacketLogcatCallback = WorkerMessagePacket & {
+    msg: 'logcat_callback';
+    type: string;
+    logcat: string;
+};

package/d.ts/src/player/player-engine-worker.d.ts

@@ -0,0 +1,2 @@
+declare const PlayerEngineWorker: (self: DedicatedWorkerGlobalScope) => void;
+export default PlayerEngineWorker;

package/d.ts/src/player/player-engine.d.ts

@@ -0,0 +1,16 @@
+import type MediaInfo from "../core/media-info";
+export default interface PlayerEngine {
+    destroy(): void;
+    on(event: string, listener: (...args: any[]) => void): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    attachMediaElement(mediaElement: HTMLMediaElement): void;
+    detachMediaElement(): void;
+    load(): void;
+    unload(): void;
+    play(): Promise<void>;
+    pause(): void;
+    seek(seconds: number): void;
+    readonly mediaInfo: MediaInfo | undefined;
+    readonly statisticsInfo: any | undefined;
+    switchAudioPid(pid: number): void;
+}