@dskripchenko/ui 1.14.0 → 1.15.1

package/dist/hls/mp4.d.ts

@@ -0,0 +1,21 @@
+export interface Mp4Box {
+    type: string;
+    start: number;
+    /** First byte after the header. */
+    data: number;
+    end: number;
+}
+export declare function readBoxes(d: Uint8Array, start?: number, end?: number): Mp4Box[];
+/** Boxes at a path like `['moov', 'trak', 'mdia']`, descending through every match. */
+export declare function findBoxes(d: Uint8Array, path: string[], start?: number, end?: number): Mp4Box[];
+export declare function isFmp4(d: Uint8Array): boolean;
+export declare function isMpegTs(d: Uint8Array): boolean;
+export interface Mp4TrackInfo {
+    id: number;
+    timescale: number;
+    kind: 'video' | 'audio' | 'other';
+    codec?: string;
+}
+export declare function parseInit(d: Uint8Array): Mp4TrackInfo[];
+/** Decode time (seconds) of the first fragment in a media segment, from `tfdt`. */
+export declare function fragmentStart(d: Uint8Array, tracks: Mp4TrackInfo[]): number | null;

package/dist/hls/playlist.d.ts

@@ -0,0 +1,76 @@
+export interface HlsByteRange {
+    offset: number;
+    length: number;
+}
+export interface HlsKey {
+    method: 'NONE' | 'AES-128' | 'SAMPLE-AES' | string;
+    uri?: string;
+    iv?: Uint8Array;
+}
+export interface HlsInitSection {
+    uri: string;
+    byteRange?: HlsByteRange;
+    key?: HlsKey;
+}
+export interface HlsSegment {
+    uri: string;
+    duration: number;
+    /** Start on the playlist timeline (sum of the preceding durations). */
+    start: number;
+    /** Media sequence number. */
+    sn: number;
+    /** Discontinuity sequence: grows by one at every EXT-X-DISCONTINUITY. */
+    cc: number;
+    title?: string;
+    byteRange?: HlsByteRange;
+    key?: HlsKey;
+    map?: HlsInitSection;
+}
+export interface HlsMediaPlaylist {
+    type: 'media';
+    url: string;
+    targetDuration: number;
+    mediaSequence: number;
+    discontinuitySequence: number;
+    endList: boolean;
+    playlistType?: string;
+    segments: HlsSegment[];
+    totalDuration: number;
+}
+export interface HlsVariant {
+    uri: string;
+    bandwidth: number;
+    averageBandwidth?: number;
+    width?: number;
+    height?: number;
+    codecs?: string;
+    frameRate?: number;
+    name?: string;
+    audio?: string;
+}
+export interface HlsRendition {
+    type: string;
+    groupId: string;
+    name?: string;
+    language?: string;
+    uri?: string;
+    default?: boolean;
+    autoselect?: boolean;
+    channels?: string;
+}
+export interface HlsMasterPlaylist {
+    type: 'master';
+    url: string;
+    variants: HlsVariant[];
+    media: HlsRendition[];
+}
+export type HlsPlaylist = HlsMasterPlaylist | HlsMediaPlaylist;
+export declare class HlsParseError extends Error {
+    constructor(message: string);
+}
+/** Attribute list of a tag: `BANDWIDTH=1280000,CODECS="avc1.4d401f,mp4a.40.2"`. */
+export declare function parseAttributes(input: string): Record<string, string>;
+export declare function parseHexIv(value: string): Uint8Array;
+export declare function parsePlaylist(text: string, url: string): HlsPlaylist;
+/** IV of a segment without an explicit IV attribute: its media sequence number, big-endian. */
+export declare function sequenceIv(sn: number): Uint8Array;

package/dist/hls/transmux.d.ts

@@ -0,0 +1,27 @@
+import { Mp4TrackInfo } from './mp4.js';
+export interface TransmuxResult {
+    /** A new initialization segment, when the stream configuration appeared or changed. */
+    init?: Uint8Array;
+    /** Media fragments (`moof` + `mdat`) to append. */
+    data: Uint8Array;
+    /** MIME type with codecs for the SourceBuffer. */
+    mimeType: string;
+    tracks: Mp4TrackInfo[];
+    /** Decode time of the first sample, in seconds. */
+    startTime: number;
+}
+export interface TransmuxContext {
+    /** The segment starts after EXT-X-DISCONTINUITY (or after a seek / level switch). */
+    discontinuity: boolean;
+}
+export interface SegmentTransmuxer {
+    /** Whether this transmuxer understands the segment (by its first bytes). */
+    canHandle(data: Uint8Array): boolean;
+    push(data: Uint8Array, ctx: TransmuxContext): TransmuxResult;
+    reset(): void;
+}
+export type TransmuxerFactory = () => SegmentTransmuxer;
+export declare class TransmuxError extends Error {
+    readonly code: 'codec' | 'format';
+    constructor(message: string, code: 'codec' | 'format');
+}

package/dist/hls/ts/adts.d.ts

@@ -0,0 +1,16 @@
+export declare const ADTS_RATES: number[];
+export interface AdtsConfig {
+    objectType: number;
+    rateIndex: number;
+    sampleRate: number;
+    channels: number;
+}
+export interface AdtsFrames {
+    config?: AdtsConfig;
+    frames: Uint8Array[];
+    /** Bytes after the last complete frame (a frame cut at the end of the input). */
+    rest: Uint8Array;
+}
+export declare function parseAdts(d: Uint8Array): AdtsFrames;
+/** AudioSpecificConfig (2 bytes) for the esds box. */
+export declare function audioSpecificConfig(c: AdtsConfig): Uint8Array;

package/dist/hls/ts/demux.d.ts

@@ -0,0 +1,26 @@
+export declare const STREAM_H264 = 27;
+export declare const STREAM_AAC = 15;
+export declare const STREAM_HEVC = 36;
+export declare const STREAM_MP3: number[];
+export declare const STREAM_AC3: number[];
+export interface PesPacket {
+    pts?: number;
+    dts?: number;
+    data: Uint8Array;
+}
+export interface DemuxState {
+    pmtPid?: number;
+    videoPid?: number;
+    audioPid?: number;
+    videoType?: number;
+    audioType?: number;
+}
+export interface DemuxResult extends DemuxState {
+    video: PesPacket[];
+    audio: PesPacket[];
+}
+/** 33-bit PES timestamp at `o` (90 kHz), without bitwise ops beyond 32 bits. */
+export declare function readTimestamp(d: Uint8Array, o: number): number;
+export declare function parsePes(d: Uint8Array): PesPacket | null;
+/** Splits a transport stream segment into video and audio PES packets. */
+export declare function demuxTs(d: Uint8Array, previous?: DemuxState): DemuxResult;

package/dist/hls/ts/h264.d.ts

@@ -0,0 +1,30 @@
+export declare const NAL_IDR = 5;
+export declare const NAL_SPS = 7;
+export declare const NAL_PPS = 8;
+export declare const NAL_AUD = 9;
+/** NAL units of an Annex-B byte stream (start codes removed). */
+export declare function splitNals(d: Uint8Array): Uint8Array[];
+export declare function nalType(nal: Uint8Array): number;
+/** RBSP: drops emulation prevention bytes (00 00 03 → 00 00). */
+export declare function unescapeRbsp(d: Uint8Array): Uint8Array;
+export declare class BitReader {
+    private readonly d;
+    private pos;
+    constructor(d: Uint8Array);
+    bit(): number;
+    bits(n: number): number;
+    ue(): number;
+    se(): number;
+}
+export interface SpsInfo {
+    profile: number;
+    compatibility: number;
+    level: number;
+    width: number;
+    height: number;
+}
+/** Profile, level and coded picture size from a sequence parameter set NAL unit. */
+export declare function parseSps(nal: Uint8Array): SpsInfo;
+export declare function avcCodec(sps: Uint8Array): string;
+/** Length-prefixed (4-byte) sample payload from NAL units. */
+export declare function toAvcc(nals: Uint8Array[]): Uint8Array;

package/dist/hls/ts/id3.d.ts

@@ -0,0 +1,10 @@
+export declare function isAdtsSync(d: Uint8Array, o?: number): boolean;
+/** Packed audio (HLS "raw" AAC segments): ID3 tags followed by ADTS frames. */
+export declare function isPackedAudio(d: Uint8Array): boolean;
+export interface PackedAudio {
+    /** 90 kHz timestamp from the ID3 PRIV frame of Apple's transport stream timestamp. */
+    pts?: number;
+    /** ADTS payload after the leading ID3 tags. */
+    data: Uint8Array;
+}
+export declare function parsePackedAudio(d: Uint8Array): PackedAudio;

package/dist/hls/ts/mp4mux.d.ts

@@ -0,0 +1,32 @@
+export interface MuxVideoTrack {
+    id: number;
+    kind: 'video';
+    timescale: number;
+    width: number;
+    height: number;
+    sps: Uint8Array;
+    pps: Uint8Array;
+}
+export interface MuxAudioTrack {
+    id: number;
+    kind: 'audio';
+    timescale: number;
+    channels: number;
+    sampleRate: number;
+    config: Uint8Array;
+}
+export type MuxTrack = MuxVideoTrack | MuxAudioTrack;
+export interface MuxSample {
+    size: number;
+    duration: number;
+    /** Composition offset (pts − dts) in track timescale. */
+    cts: number;
+    key: boolean;
+}
+type Part = Uint8Array | number[];
+export declare function box(type: string, ...parts: Part[]): Uint8Array;
+export declare function initSegment(tracks: MuxTrack[]): Uint8Array;
+/** One `moof` + `mdat` pair for a track's samples. */
+export declare function fragment(seq: number, trackId: number, baseTime: number, samples: MuxSample[], payload: Uint8Array): Uint8Array;
+export declare function concatBytes(parts: Uint8Array[]): Uint8Array;
+export {};

package/dist/hls/ts/transmuxer.d.ts

@@ -0,0 +1,22 @@
+import { SegmentTransmuxer, TransmuxContext, TransmuxResult } from '../transmux.js';
+/** MPEG-TS (H.264 + AAC) → fragmented MP4, segment by segment, with a continuous timeline. */
+export declare class TsTransmuxer implements SegmentTransmuxer {
+    private demux;
+    private video?;
+    private audio?;
+    private initKey;
+    private seq;
+    private ref;
+    private nextVideoDts;
+    private nextAudioDts;
+    private videoDuration;
+    canHandle(data: Uint8Array): boolean;
+    reset(): void;
+    private unwrap;
+    push(data: Uint8Array, ctx: TransmuxContext): TransmuxResult;
+    private pushPacked;
+    private output;
+    private videoSamples;
+    private audioSamples;
+}
+export declare function createTsTransmuxer(): SegmentTransmuxer;