recker 1.0.26 → 1.0.27

package/dist/browser/plugins/hls.d.ts

@@ -0,0 +1,105 @@
+import type { Client } from '../core/client.js';
+import { type WriteStream } from 'node:fs';
+import { Writable } from 'node:stream';
+export interface HlsVariant {
+    url: string;
+    bandwidth?: number;
+    resolution?: string;
+    codecs?: string;
+    name?: string;
+}
+export interface HlsSegment {
+    url: string;
+    duration: number;
+    sequence: number;
+    key?: HlsKeyInfo;
+    discontinuity?: boolean;
+    programDateTime?: Date;
+}
+export interface HlsKeyInfo {
+    method: 'NONE' | 'AES-128' | 'SAMPLE-AES';
+    uri?: string;
+    iv?: string;
+}
+export interface HlsPlaylist {
+    segments: HlsSegment[];
+    targetDuration: number;
+    mediaSequence: number;
+    endList: boolean;
+    playlistType?: 'VOD' | 'EVENT';
+    discontinuitySequence: number;
+}
+export interface HlsMasterPlaylist {
+    variants: HlsVariant[];
+    isMaster: true;
+}
+export interface SegmentData {
+    sequence: number;
+    duration: number;
+    data: Uint8Array;
+    url: string;
+    downloadedAt: Date;
+}
+export interface HlsProgress {
+    downloadedSegments: number;
+    totalSegments?: number;
+    downloadedBytes: number;
+    currentSegment: number;
+    isLive: boolean;
+    elapsed: number;
+}
+export interface HlsOptions {
+    mode?: 'merge' | 'chunks';
+    format?: 'ts' | 'mp4' | 'mkv';
+    live?: boolean | {
+        duration: number;
+    };
+    quality?: 'highest' | 'lowest' | {
+        bandwidth?: number;
+        resolution?: string;
+    };
+    concurrency?: number;
+    onSegment?: (segment: SegmentData) => void | Promise<void>;
+    onProgress?: (progress: HlsProgress) => void;
+    onError?: (error: Error) => void;
+    headers?: Record<string, string>;
+}
+type DownloadDest = string | ((segment: HlsSegment) => string);
+export declare class HlsPromise implements Promise<void> {
+    private client;
+    private manifestUrl;
+    private options;
+    private seenSequences;
+    private downloadedBytes;
+    private downloadedSegments;
+    private startTime;
+    private aborted;
+    private abortController;
+    constructor(client: Client, manifestUrl: string, options?: HlsOptions);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<void | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<void>;
+    cancel(): void;
+    download(dest: DownloadDest): Promise<void>;
+    stream(): AsyncGenerator<SegmentData>;
+    pipe(writable: Writable | WriteStream): Promise<void>;
+    info(): Promise<{
+        master?: HlsMasterPlaylist;
+        playlist?: HlsPlaylist;
+        selectedVariant?: HlsVariant;
+        isLive: boolean;
+        totalDuration?: number;
+    }>;
+    private resolveMediaPlaylist;
+    private fetchMediaPlaylist;
+    private downloadSegment;
+    private downloadMerged;
+    private downloadChunks;
+    private isLiveMode;
+    private getMaxDuration;
+    private emitProgress;
+    private sleep;
+}
+export declare function hls(client: Client, manifestUrl: string, options?: HlsOptions): HlsPromise;
+export type { HlsVariant as Variant, HlsSegment as Segment, HlsKeyInfo as KeyInfo, };

package/dist/browser/plugins/hls.js

@@ -0,0 +1,395 @@
+import { createWriteStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+function parseAttributes(line, prefix) {
+    const attrs = {};
+    const content = line.substring(prefix.length);
+    const regex = /([A-Z0-9-]+)=(?:"([^"]*)"|([^,]*))/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        attrs[match[1]] = match[2] ?? match[3];
+    }
+    return attrs;
+}
+function resolveUrl(url, baseUrl) {
+    if (url.startsWith('http://') || url.startsWith('https://')) {
+        return url;
+    }
+    try {
+        const base = new URL(baseUrl);
+        const basePath = base.pathname.substring(0, base.pathname.lastIndexOf('/') + 1);
+        return new URL(url, base.origin + basePath).toString();
+    }
+    catch {
+        return url;
+    }
+}
+function parseMasterPlaylist(content, baseUrl) {
+    const lines = content.split('\n');
+    const variants = [];
+    let pendingVariant = {};
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        if (line.startsWith('#EXT-X-STREAM-INF:')) {
+            const attrs = parseAttributes(line, '#EXT-X-STREAM-INF:');
+            pendingVariant = {
+                bandwidth: attrs.BANDWIDTH ? parseInt(attrs.BANDWIDTH, 10) : undefined,
+                resolution: attrs.RESOLUTION,
+                codecs: attrs.CODECS,
+                name: attrs.NAME,
+            };
+        }
+        else if (!line.startsWith('#') && pendingVariant.bandwidth !== undefined) {
+            variants.push({
+                ...pendingVariant,
+                url: resolveUrl(line, baseUrl),
+            });
+            pendingVariant = {};
+        }
+    }
+    return { variants, isMaster: true };
+}
+function parseMediaPlaylist(content, baseUrl) {
+    const lines = content.split('\n');
+    const segments = [];
+    let targetDuration = 5;
+    let mediaSequence = 0;
+    let discontinuitySequence = 0;
+    let endList = false;
+    let playlistType;
+    let currentDuration = 0;
+    let currentKey;
+    let currentDiscontinuity = false;
+    let currentProgramDateTime;
+    let segmentIndex = 0;
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        if (line.startsWith('#EXT-X-TARGETDURATION:')) {
+            targetDuration = parseInt(line.split(':')[1], 10);
+        }
+        else if (line.startsWith('#EXT-X-MEDIA-SEQUENCE:')) {
+            mediaSequence = parseInt(line.split(':')[1], 10);
+        }
+        else if (line.startsWith('#EXT-X-DISCONTINUITY-SEQUENCE:')) {
+            discontinuitySequence = parseInt(line.split(':')[1], 10);
+        }
+        else if (line.startsWith('#EXT-X-PLAYLIST-TYPE:')) {
+            playlistType = line.split(':')[1];
+        }
+        else if (line === '#EXT-X-ENDLIST') {
+            endList = true;
+        }
+        else if (line === '#EXT-X-DISCONTINUITY') {
+            currentDiscontinuity = true;
+        }
+        else if (line.startsWith('#EXT-X-PROGRAM-DATE-TIME:')) {
+            currentProgramDateTime = new Date(line.split(':').slice(1).join(':'));
+        }
+        else if (line.startsWith('#EXT-X-KEY:')) {
+            const attrs = parseAttributes(line, '#EXT-X-KEY:');
+            if (attrs.METHOD === 'NONE') {
+                currentKey = undefined;
+            }
+            else {
+                currentKey = {
+                    method: attrs.METHOD,
+                    uri: attrs.URI ? resolveUrl(attrs.URI, baseUrl) : undefined,
+                    iv: attrs.IV,
+                };
+            }
+        }
+        else if (line.startsWith('#EXTINF:')) {
+            const durationStr = line.substring(8).split(',')[0];
+            currentDuration = parseFloat(durationStr);
+        }
+        else if (!line.startsWith('#')) {
+            segments.push({
+                url: resolveUrl(line, baseUrl),
+                duration: currentDuration,
+                sequence: mediaSequence + segmentIndex,
+                key: currentKey,
+                discontinuity: currentDiscontinuity,
+                programDateTime: currentProgramDateTime,
+            });
+            segmentIndex++;
+            currentDiscontinuity = false;
+            currentProgramDateTime = undefined;
+        }
+    }
+    return {
+        segments,
+        targetDuration,
+        mediaSequence,
+        endList,
+        playlistType,
+        discontinuitySequence,
+    };
+}
+function isMasterPlaylist(content) {
+    return content.includes('#EXT-X-STREAM-INF');
+}
+function selectVariant(variants, quality) {
+    if (!variants.length) {
+        throw new Error('No variants found in master playlist');
+    }
+    const sorted = [...variants].sort((a, b) => (a.bandwidth ?? 0) - (b.bandwidth ?? 0));
+    if (quality === 'lowest') {
+        return sorted[0];
+    }
+    if (quality === 'highest' || quality === undefined) {
+        return sorted[sorted.length - 1];
+    }
+    if (quality.resolution) {
+        const match = variants.find((v) => v.resolution === quality.resolution);
+        if (match)
+            return match;
+    }
+    if (quality.bandwidth) {
+        const target = quality.bandwidth;
+        return sorted.reduce((prev, curr) => {
+            const prevDiff = Math.abs((prev.bandwidth ?? 0) - target);
+            const currDiff = Math.abs((curr.bandwidth ?? 0) - target);
+            return currDiff < prevDiff ? curr : prev;
+        });
+    }
+    return sorted[sorted.length - 1];
+}
+export class HlsPromise {
+    client;
+    manifestUrl;
+    options;
+    seenSequences = new Set();
+    downloadedBytes = 0;
+    downloadedSegments = 0;
+    startTime = 0;
+    aborted = false;
+    abortController = new AbortController();
+    constructor(client, manifestUrl, options = {}) {
+        this.client = client;
+        this.manifestUrl = manifestUrl;
+        this.options = {
+            mode: 'merge',
+            format: 'ts',
+            concurrency: 5,
+            ...options,
+        };
+        if (this.options.format !== 'ts') {
+            throw new Error(`Format '${this.options.format}' requires ffmpeg. Use format: 'ts' or install ffmpeg.`);
+        }
+    }
+    get [Symbol.toStringTag]() {
+        return 'HlsPromise';
+    }
+    then(onfulfilled, onrejected) {
+        return Promise.reject(new Error('HlsPromise requires .download(), .stream(), or .pipe() to execute')).then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.then(null, onrejected);
+    }
+    finally(onfinally) {
+        return this.then(() => {
+            onfinally?.();
+        }, () => {
+            onfinally?.();
+        });
+    }
+    cancel() {
+        this.aborted = true;
+        this.abortController.abort();
+    }
+    async download(dest) {
+        this.startTime = Date.now();
+        const mediaPlaylistUrl = await this.resolveMediaPlaylist();
+        if (this.options.mode === 'chunks') {
+            await this.downloadChunks(mediaPlaylistUrl, dest);
+        }
+        else {
+            if (typeof dest !== 'string') {
+                throw new Error('Merge mode requires a string path, not a function');
+            }
+            await this.downloadMerged(mediaPlaylistUrl, dest);
+        }
+    }
+    async *stream() {
+        this.startTime = Date.now();
+        const mediaPlaylistUrl = await this.resolveMediaPlaylist();
+        const isLive = this.isLiveMode();
+        const maxDuration = this.getMaxDuration();
+        while (!this.aborted) {
+            const playlist = await this.fetchMediaPlaylist(mediaPlaylistUrl);
+            const newSegments = playlist.segments.filter((s) => !this.seenSequences.has(s.sequence));
+            for (const segment of newSegments) {
+                if (this.aborted)
+                    break;
+                if (maxDuration && Date.now() - this.startTime > maxDuration) {
+                    return;
+                }
+                this.seenSequences.add(segment.sequence);
+                const data = await this.downloadSegment(segment);
+                const segmentData = {
+                    sequence: segment.sequence,
+                    duration: segment.duration,
+                    data,
+                    url: segment.url,
+                    downloadedAt: new Date(),
+                };
+                this.downloadedSegments++;
+                this.downloadedBytes += data.byteLength;
+                this.emitProgress(playlist, isLive);
+                if (this.options.onSegment) {
+                    await this.options.onSegment(segmentData);
+                }
+                yield segmentData;
+            }
+            if (!isLive || playlist.endList) {
+                break;
+            }
+            if (maxDuration && Date.now() - this.startTime > maxDuration) {
+                break;
+            }
+            const pollInterval = Math.max(1000, (playlist.targetDuration * 1000) / 2);
+            await this.sleep(pollInterval);
+        }
+    }
+    async pipe(writable) {
+        try {
+            for await (const segment of this.stream()) {
+                const canContinue = writable.write(segment.data);
+                if (!canContinue) {
+                    await new Promise((resolve) => writable.once('drain', resolve));
+                }
+            }
+        }
+        finally {
+            if ('end' in writable && typeof writable.end === 'function') {
+                writable.end();
+            }
+        }
+    }
+    async info() {
+        const content = await this.client.get(this.manifestUrl).text();
+        if (isMasterPlaylist(content)) {
+            const master = parseMasterPlaylist(content, this.manifestUrl);
+            const selectedVariant = selectVariant(master.variants, this.options.quality);
+            const playlistContent = await this.client.get(selectedVariant.url).text();
+            const playlist = parseMediaPlaylist(playlistContent, selectedVariant.url);
+            const totalDuration = playlist.endList
+                ? playlist.segments.reduce((sum, s) => sum + s.duration, 0)
+                : undefined;
+            return {
+                master,
+                playlist,
+                selectedVariant,
+                isLive: !playlist.endList,
+                totalDuration,
+            };
+        }
+        const playlist = parseMediaPlaylist(content, this.manifestUrl);
+        const totalDuration = playlist.endList
+            ? playlist.segments.reduce((sum, s) => sum + s.duration, 0)
+            : undefined;
+        return {
+            playlist,
+            isLive: !playlist.endList,
+            totalDuration,
+        };
+    }
+    async resolveMediaPlaylist() {
+        const content = await this.client.get(this.manifestUrl).text();
+        if (!isMasterPlaylist(content)) {
+            return this.manifestUrl;
+        }
+        const master = parseMasterPlaylist(content, this.manifestUrl);
+        const variant = selectVariant(master.variants, this.options.quality);
+        return variant.url;
+    }
+    async fetchMediaPlaylist(url) {
+        const content = await this.client.get(url).text();
+        return parseMediaPlaylist(content, url);
+    }
+    async downloadSegment(segment) {
+        if (segment.key && segment.key.method !== 'NONE') {
+            throw new Error(`Encrypted HLS (${segment.key.method}) requires ffmpeg. Use unencrypted streams or install ffmpeg.`);
+        }
+        const response = await this.client.get(segment.url, {
+            headers: this.options.headers,
+            signal: this.abortController.signal,
+        });
+        const blob = await response.blob();
+        return new Uint8Array(await blob.arrayBuffer());
+    }
+    async downloadMerged(playlistUrl, outputPath) {
+        await mkdir(dirname(outputPath), { recursive: true });
+        const output = createWriteStream(outputPath);
+        try {
+            await this.pipe(output);
+        }
+        catch (error) {
+            output.destroy();
+            throw error;
+        }
+    }
+    async downloadChunks(playlistUrl, dest) {
+        const getPath = typeof dest === 'string'
+            ? (seg) => join(dest, `segment-${seg.sequence}.ts`)
+            : dest;
+        const baseDir = typeof dest === 'string' ? dest : dirname(getPath({ sequence: 0, duration: 0, url: '' }));
+        await mkdir(baseDir, { recursive: true });
+        for await (const segment of this.stream()) {
+            const filePath = getPath({
+                sequence: segment.sequence,
+                duration: segment.duration,
+                url: segment.url,
+            });
+            await mkdir(dirname(filePath), { recursive: true });
+            const output = createWriteStream(filePath);
+            await new Promise((resolve, reject) => {
+                output.write(segment.data, (err) => {
+                    if (err)
+                        reject(err);
+                    else {
+                        output.end();
+                        resolve();
+                    }
+                });
+            });
+        }
+    }
+    isLiveMode() {
+        return this.options.live === true || typeof this.options.live === 'object';
+    }
+    getMaxDuration() {
+        if (typeof this.options.live === 'object' && this.options.live.duration) {
+            return this.options.live.duration;
+        }
+        return undefined;
+    }
+    emitProgress(playlist, isLive) {
+        if (!this.options.onProgress)
+            return;
+        this.options.onProgress({
+            downloadedSegments: this.downloadedSegments,
+            totalSegments: isLive ? undefined : playlist.segments.length,
+            downloadedBytes: this.downloadedBytes,
+            currentSegment: Math.max(...this.seenSequences),
+            isLive,
+            elapsed: Date.now() - this.startTime,
+        });
+    }
+    sleep(ms) {
+        return new Promise((resolve) => {
+            const timeout = setTimeout(resolve, ms);
+            this.abortController.signal.addEventListener('abort', () => {
+                clearTimeout(timeout);
+                resolve();
+            }, { once: true });
+        });
+    }
+}
+export function hls(client, manifestUrl, options = {}) {
+    return new HlsPromise(client, manifestUrl, options);
+}

package/dist/browser/plugins/jsonrpc.d.ts

@@ -0,0 +1,75 @@
+import type { Client } from '../core/client.js';
+import type { RequestOptions } from '../types/index.js';
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown[] | Record<string, unknown>;
+    id?: string | number | null;
+}
+export interface JsonRpcResponse<T = unknown> {
+    jsonrpc: '2.0';
+    result?: T;
+    error?: JsonRpcError;
+    id: string | number | null;
+}
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface JsonRpcBatchResponse<T = unknown> {
+    responses: JsonRpcResponse<T>[];
+    errors: JsonRpcError[];
+    hasErrors: boolean;
+}
+export declare const JsonRpcErrorCodes: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    readonly SERVER_ERROR: -32000;
+};
+export declare class JsonRpcException extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(error: JsonRpcError);
+    static isParseError(error: JsonRpcException): boolean;
+    static isInvalidRequest(error: JsonRpcException): boolean;
+    static isMethodNotFound(error: JsonRpcException): boolean;
+    static isInvalidParams(error: JsonRpcException): boolean;
+    static isInternalError(error: JsonRpcException): boolean;
+    static isServerError(error: JsonRpcException): boolean;
+}
+export interface JsonRpcClientOptions {
+    endpoint: string;
+    requestOptions?: RequestOptions;
+    autoId?: boolean;
+    idGenerator?: () => string | number;
+    throwOnError?: boolean;
+}
+export declare class JsonRpcClient {
+    private client;
+    private options;
+    private idCounter;
+    constructor(client: Client, options: JsonRpcClientOptions);
+    call<T = unknown>(method: string, params?: unknown[] | Record<string, unknown>, options?: RequestOptions): Promise<T>;
+    notify(method: string, params?: unknown[] | Record<string, unknown>, options?: RequestOptions): Promise<void>;
+    batch<T = unknown>(requests: Array<{
+        method: string;
+        params?: unknown[] | Record<string, unknown>;
+        id?: string | number;
+    }>, options?: RequestOptions): Promise<JsonRpcBatchResponse<T>>;
+    getFromBatch<T>(batch: JsonRpcBatchResponse<T>, id: string | number): T | undefined;
+    proxy<T extends Record<string, (...args: unknown[]) => unknown>>(): {
+        [K in keyof T]: (...args: Parameters<T[K]>) => Promise<ReturnType<T[K]>>;
+    };
+    private sendRequest;
+}
+export declare function createJsonRpcClient(client: Client, options: JsonRpcClientOptions): JsonRpcClient;
+export declare function jsonrpc(): (client: Client) => void;
+declare module '../core/client.js' {
+    interface Client {
+        jsonrpc(endpoint: string, options?: Omit<JsonRpcClientOptions, 'endpoint'>): JsonRpcClient;
+    }
+}