googlevideo 1.0.0

package/dist/src/core/ChunkedDataBuffer.js

@@ -0,0 +1,82 @@
+export class ChunkedDataBuffer {
+    constructor(chunks = []) {
+        this.chunks = [];
+        this.currentChunkOffset = this.currentChunkIndex = 0;
+        this.currentDataView = undefined;
+        this.totalLength = 0;
+        chunks.forEach((chunk) => {
+            this.append(chunk);
+        });
+    }
+    getLength() {
+        return this.totalLength;
+    }
+    append(chunk) {
+        if (this.canMergeWithLastChunk(chunk)) {
+            const lastChunk = this.chunks[this.chunks.length - 1];
+            this.chunks[this.chunks.length - 1] = new Uint8Array(lastChunk.buffer, lastChunk.byteOffset, lastChunk.length + chunk.length);
+            this.resetFocus();
+        }
+        else {
+            this.chunks.push(chunk);
+        }
+        this.totalLength += chunk.length;
+    }
+    split(position) {
+        const extractedBuffer = new ChunkedDataBuffer();
+        const remainingBuffer = new ChunkedDataBuffer();
+        const iterator = this.chunks[Symbol.iterator]();
+        let item = iterator.next();
+        while (!item.done) {
+            const chunk = item.value;
+            if (position >= chunk.length) {
+                extractedBuffer.append(chunk);
+                position -= chunk.length;
+            }
+            else if (position > 0) {
+                extractedBuffer.append(new Uint8Array(chunk.buffer, chunk.byteOffset, position));
+                remainingBuffer.append(new Uint8Array(chunk.buffer, chunk.byteOffset + position, chunk.length - position));
+                position = 0;
+            }
+            else {
+                remainingBuffer.append(chunk);
+            }
+            item = iterator.next();
+        }
+        return { extractedBuffer, remainingBuffer };
+    }
+    isFocused(position) {
+        return position >= this.currentChunkOffset && position < this.currentChunkOffset + this.chunks[this.currentChunkIndex].length;
+    }
+    focus(position) {
+        if (!this.isFocused(position)) {
+            if (position < this.currentChunkOffset)
+                this.resetFocus();
+            while (this.currentChunkOffset + this.chunks[this.currentChunkIndex].length <= position &&
+                this.currentChunkIndex < this.chunks.length - 1) {
+                this.currentChunkOffset += this.chunks[this.currentChunkIndex].length;
+                this.currentChunkIndex += 1;
+            }
+            this.currentDataView = undefined;
+        }
+    }
+    canReadBytes(position, length) {
+        return position + length <= this.totalLength;
+    }
+    getUint8(position) {
+        this.focus(position);
+        return this.chunks[this.currentChunkIndex][position - this.currentChunkOffset];
+    }
+    canMergeWithLastChunk(chunk) {
+        if (this.chunks.length === 0)
+            return false;
+        const lastChunk = this.chunks[this.chunks.length - 1];
+        return (lastChunk.buffer === chunk.buffer &&
+            lastChunk.byteOffset + lastChunk.length === chunk.byteOffset);
+    }
+    resetFocus() {
+        this.currentDataView = undefined;
+        this.currentChunkIndex = 0;
+        this.currentChunkOffset = 0;
+    }
+}

package/dist/src/core/ServerAbrStream.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitterLike } from '../utils/index.js';
+import type { InitOptions, ServerAbrResponse, ServerAbrStreamOptions } from '../utils/types.js';
+export declare class ServerAbrStream extends EventEmitterLike {
+    private fetchFunction;
+    private serverAbrStreamingUrl;
+    private videoPlaybackUstreamerConfig;
+    private poToken?;
+    private playbackCookie?;
+    private totalDurationMs;
+    private initializedFormats;
+    private formatsByKey;
+    private headerIdToFormatKeyMap;
+    private previousSequences;
+    constructor(args: ServerAbrStreamOptions);
+    on(event: 'end', listener: (streamData: ServerAbrResponse) => void): void;
+    on(event: 'data', listener: (streamData: ServerAbrResponse) => void): void;
+    on(event: 'error', listener: (error: Error) => void): void;
+    once(event: 'end', listener: (streamData: ServerAbrResponse) => void): void;
+    once(event: 'data', listener: (streamData: ServerAbrResponse) => void): void;
+    once(event: 'error', listener: (error: Error) => void): void;
+    /**
+     * Initializes the server ABR stream with the provided options.
+     * @param args - The initialization options.
+     */
+    init(args: InitOptions): Promise<void>;
+    private fetchMedia;
+    /**
+     * Parses the UMP response data and updates the initialized formats.
+     * @param response - The UMP response data as a byte array.
+     */
+    parseUMPResponse(response: Uint8Array): Promise<ServerAbrResponse>;
+    private processMediaHeader;
+    private processMediaData;
+    private processEndOfMedia;
+    private processNextRequestPolicy;
+    private processFormatInitialization;
+    private processSabrRedirect;
+}

package/dist/src/core/ServerAbrStream.js

@@ -0,0 +1,272 @@
+import { UMP } from './UMP.js';
+import { ChunkedDataBuffer } from './ChunkedDataBuffer.js';
+import { EventEmitterLike, PART, QUALITY, base64ToU8, getFormatKey } from '../utils/index.js';
+import { ClientAbrState_MediaType } from '../../protos/generated/video_streaming/client_abr_state.js';
+import { VideoPlaybackAbrRequest } from '../../protos/generated/video_streaming/video_playback_abr_request.js';
+import { MediaHeader } from '../../protos/generated/video_streaming/media_header.js';
+import { NextRequestPolicy } from '../../protos/generated/video_streaming/next_request_policy.js';
+import { FormatInitializationMetadata } from '../../protos/generated/video_streaming/format_initialization_metadata.js';
+import { SabrRedirect } from '../../protos/generated/video_streaming/sabr_redirect.js';
+import { SabrError } from '../../protos/generated/video_streaming/sabr_error.js';
+import { StreamProtectionStatus } from '../../protos/generated/video_streaming/stream_protection_status.js';
+import { PlaybackCookie } from '../../protos/generated/video_streaming/playback_cookie.js';
+const DEFAULT_QUALITY = QUALITY.HD720;
+export class ServerAbrStream extends EventEmitterLike {
+    constructor(args) {
+        super();
+        this.initializedFormats = [];
+        this.formatsByKey = new Map();
+        this.headerIdToFormatKeyMap = new Map();
+        this.previousSequences = new Map();
+        this.fetchFunction = args.fetch || fetch;
+        this.serverAbrStreamingUrl = args.serverAbrStreamingUrl;
+        this.videoPlaybackUstreamerConfig = args.videoPlaybackUstreamerConfig;
+        this.poToken = args.poToken;
+        this.totalDurationMs = args.durationMs;
+    }
+    on(event, listener) {
+        super.on(event, listener);
+    }
+    once(event, listener) {
+        super.once(event, listener);
+    }
+    /**
+     * Initializes the server ABR stream with the provided options.
+     * @param args - The initialization options.
+     */
+    async init(args) {
+        const { audioFormats, videoFormats, clientAbrState: initialState } = args;
+        const firstVideoFormat = videoFormats ? videoFormats[0] : undefined;
+        const clientAbrState = {
+            lastManualDirection: 0,
+            timeSinceLastManualFormatSelectionMs: 0,
+            quality: videoFormats.length === 1 ? firstVideoFormat?.width : DEFAULT_QUALITY,
+            selectedQualityHeight: videoFormats.length === 1 ? firstVideoFormat?.width : DEFAULT_QUALITY,
+            startTimeMs: 0,
+            visibility: 0,
+            mediaType: ClientAbrState_MediaType.MEDIA_TYPE_DEFAULT,
+            ...initialState
+        };
+        const audioFormatIds = audioFormats.map((fmt) => ({
+            itag: fmt.itag,
+            lastModified: parseInt(fmt.lastModified),
+            xtags: fmt.xtags
+        }));
+        const videoFormatIds = videoFormats.map((fmt) => ({
+            itag: fmt.itag,
+            lastModified: parseInt(fmt.lastModified),
+            xtags: fmt.xtags
+        }));
+        if (typeof clientAbrState.startTimeMs !== 'number')
+            throw new Error('Invalid media start time');
+        try {
+            while (clientAbrState.startTimeMs < this.totalDurationMs) {
+                const data = await this.fetchMedia({ clientAbrState, audioFormatIds, videoFormatIds });
+                this.emit('data', data);
+                if (data.sabrError)
+                    break;
+                const mainFormat = clientAbrState.mediaType === ClientAbrState_MediaType.MEDIA_TYPE_DEFAULT
+                    ? data.initializedFormats.find((fmt) => fmt.mimeType?.includes('video'))
+                    : data.initializedFormats[0];
+                for (const fmt of data.initializedFormats) {
+                    this.previousSequences.set(`${fmt.formatId.itag};${fmt.formatId.lastModified};`, fmt.sequenceList.map((seq) => seq.sequenceNumber || 0));
+                }
+                if (!mainFormat ||
+                    mainFormat.sequenceCount ===
+                        mainFormat.sequenceList[mainFormat.sequenceList.length - 1]?.sequenceNumber) {
+                    this.emit('end', data);
+                    break;
+                }
+                clientAbrState.startTimeMs += mainFormat.sequenceList.reduce((acc, seq) => acc + (seq.durationMs || 0), 0);
+            }
+        }
+        catch (error) {
+            this.emit('error', error);
+        }
+    }
+    async fetchMedia(args) {
+        const { clientAbrState, audioFormatIds, videoFormatIds } = args;
+        const body = VideoPlaybackAbrRequest.encode({
+            clientAbrState: clientAbrState,
+            selectedAudioFormatIds: audioFormatIds,
+            selectedVideoFormatIds: videoFormatIds,
+            selectedFormatIds: this.initializedFormats.map((fmt) => fmt.formatId),
+            videoPlaybackUstreamerConfig: base64ToU8(this.videoPlaybackUstreamerConfig),
+            streamerContext: {
+                field5: [],
+                field6: [],
+                poToken: this.poToken ? base64ToU8(this.poToken) : undefined,
+                playbackCookie: this.playbackCookie ? PlaybackCookie.encode(this.playbackCookie).finish() : undefined,
+                clientInfo: {
+                    clientName: 1,
+                    clientVersion: '2.2040620.05.00',
+                    osName: 'Windows',
+                    osVersion: '10.0'
+                }
+            },
+            bufferedRanges: this.initializedFormats.map((fmt) => fmt._state),
+            field1000: []
+        }).finish();
+        const response = await this.fetchFunction(this.serverAbrStreamingUrl, { method: 'POST', body });
+        const data = await response.arrayBuffer();
+        if (response.status !== 200 || !data.byteLength)
+            throw new Error(`Received an invalid response from the server: ${response.status}`);
+        return this.parseUMPResponse(new Uint8Array(data));
+    }
+    /**
+     * Parses the UMP response data and updates the initialized formats.
+     * @param response - The UMP response data as a byte array.
+     */
+    async parseUMPResponse(response) {
+        this.headerIdToFormatKeyMap.clear();
+        this.initializedFormats.forEach((format) => {
+            format.sequenceList = [];
+            format.mediaChunks = [];
+        });
+        let sabrError;
+        let sabrRedirect;
+        let streamProtectionStatus;
+        const ump = new UMP(new ChunkedDataBuffer([response]));
+        ump.parse((part) => {
+            const data = part.data.chunks[0];
+            switch (part.type) {
+                case PART.MEDIA_HEADER:
+                    this.processMediaHeader(data);
+                    break;
+                case PART.MEDIA:
+                    this.processMediaData(part.data);
+                    break;
+                case PART.MEDIA_END:
+                    this.processEndOfMedia(part.data);
+                    break;
+                case PART.NEXT_REQUEST_POLICY:
+                    this.processNextRequestPolicy(data);
+                    break;
+                case PART.FORMAT_INITIALIZATION_METADATA:
+                    this.processFormatInitialization(data);
+                    break;
+                case PART.SABR_ERROR:
+                    sabrError = SabrError.decode(data);
+                    break;
+                case PART.SABR_REDIRECT:
+                    sabrRedirect = this.processSabrRedirect(data);
+                    break;
+                case PART.STREAM_PROTECTION_STATUS:
+                    streamProtectionStatus = StreamProtectionStatus.decode(data);
+                    break;
+                default:
+                    break;
+            }
+        });
+        return {
+            initializedFormats: this.initializedFormats,
+            streamProtectionStatus,
+            sabrRedirect,
+            sabrError
+        };
+    }
+    processMediaHeader(data) {
+        const mediaHeader = MediaHeader.decode(data);
+        if (!mediaHeader.formatId)
+            return;
+        const formatKey = getFormatKey(mediaHeader.formatId);
+        let currentFormat = this.formatsByKey.get(formatKey);
+        if (!currentFormat) {
+            this.initializedFormats.push({
+                formatId: mediaHeader.formatId,
+                formatKey,
+                durationMs: mediaHeader.durationMs,
+                mimeType: undefined,
+                sequenceCount: undefined,
+                sequenceList: [],
+                mediaChunks: [],
+                _state: {
+                    formatId: mediaHeader.formatId,
+                    startTimeMs: 0,
+                    durationMs: 0,
+                    startSegmentIndex: 1,
+                    endSegmentIndex: 0
+                }
+            });
+            this.formatsByKey.set(formatKey, this.initializedFormats[this.initializedFormats.length - 1]);
+            currentFormat = this.formatsByKey.get(formatKey);
+        }
+        // FIXME: This is a hacky workaround to prevent duplicate sequences from being added. This should be fixed in the future (preferably by figuring out how to make the server not send duplicates).
+        if (mediaHeader.sequenceNumber !== undefined && this.previousSequences.get(formatKey)?.includes(mediaHeader.sequenceNumber))
+            return;
+        // Save the header's ID so we can identify its stream data later.
+        if (mediaHeader.headerId !== undefined) {
+            if (!this.headerIdToFormatKeyMap.has(mediaHeader.headerId)) {
+                this.headerIdToFormatKeyMap.set(mediaHeader.headerId, formatKey);
+            }
+        }
+        if (!currentFormat.sequenceList.some((seq) => seq.sequenceNumber === (mediaHeader.sequenceNumber || 0))) {
+            currentFormat.sequenceList.push({
+                itag: mediaHeader.itag,
+                formatId: mediaHeader.formatId,
+                isInitSegment: mediaHeader.isInitSeg,
+                durationMs: mediaHeader.durationMs,
+                startMs: mediaHeader.startMs,
+                startDataRange: mediaHeader.startDataRange,
+                sequenceNumber: mediaHeader.sequenceNumber,
+                contentLength: mediaHeader.contentLength,
+                timeRange: mediaHeader.timeRange
+            });
+            if (typeof mediaHeader.sequenceNumber === 'number') {
+                currentFormat._state.durationMs += mediaHeader.durationMs || 0;
+                currentFormat._state.endSegmentIndex += 1;
+            }
+        }
+    }
+    processMediaData(data) {
+        const headerId = data.getUint8(0);
+        const streamData = data.split(1).remainingBuffer;
+        const formatKey = this.headerIdToFormatKeyMap.get(headerId);
+        if (!formatKey)
+            return;
+        const currentFormat = this.formatsByKey.get(formatKey);
+        if (!currentFormat)
+            return;
+        currentFormat.mediaChunks.push(streamData.chunks[0]);
+    }
+    processEndOfMedia(data) {
+        const headerId = data.getUint8(0);
+        this.headerIdToFormatKeyMap.delete(headerId);
+    }
+    processNextRequestPolicy(data) {
+        const nextRequestPolicy = NextRequestPolicy.decode(data);
+        this.playbackCookie = nextRequestPolicy.playbackCookie;
+    }
+    processFormatInitialization(data) {
+        const formatInitializationMetadata = FormatInitializationMetadata.decode(data);
+        if (!formatInitializationMetadata.formatId)
+            return;
+        const formatKey = getFormatKey(formatInitializationMetadata.formatId);
+        if (!this.formatsByKey.has(formatKey)) {
+            this.initializedFormats.push({
+                formatId: formatInitializationMetadata.formatId,
+                formatKey: getFormatKey(formatInitializationMetadata.formatId),
+                durationMs: formatInitializationMetadata.durationMs,
+                mimeType: formatInitializationMetadata.mimeType,
+                sequenceCount: formatInitializationMetadata.field4,
+                sequenceList: [],
+                mediaChunks: [],
+                _state: {
+                    formatId: formatInitializationMetadata.formatId,
+                    startTimeMs: 0,
+                    durationMs: 0,
+                    startSegmentIndex: 1,
+                    endSegmentIndex: 0
+                }
+            });
+            this.formatsByKey.set(formatKey, this.initializedFormats[this.initializedFormats.length - 1]);
+        }
+    }
+    processSabrRedirect(data) {
+        const sabrRedirect = SabrRedirect.decode(data);
+        if (!sabrRedirect.url)
+            throw new Error('Invalid SABR redirect');
+        this.serverAbrStreamingUrl = sabrRedirect.url;
+        return sabrRedirect;
+    }
+}

package/dist/src/core/UMP.d.ts

@@ -0,0 +1,10 @@
+import type { Part } from '../index.js';
+import type { ChunkedDataBuffer } from './ChunkedDataBuffer.js';
+export declare class UMP {
+    private chunkedDataBuffer;
+    constructor(chunkedDataBuffer: ChunkedDataBuffer);
+    parse(handlePart: (part: Part) => void): void;
+    readVarInt(offset: number): [number, number];
+    canReadFromCurrentChunk(offset: number, length: number): boolean;
+    getCurrentDataView(): DataView;
+}

package/dist/src/core/UMP.js

@@ -0,0 +1,110 @@
+export class UMP {
+    constructor(chunkedDataBuffer) {
+        this.chunkedDataBuffer = chunkedDataBuffer;
+    }
+    parse(handlePart) {
+        while (true) {
+            let offset = 0;
+            const [partType, newOffset] = this.readVarInt(offset);
+            offset = newOffset;
+            const [partSize, finalOffset] = this.readVarInt(offset);
+            offset = finalOffset;
+            if (partType < 0 || partSize < 0)
+                break;
+            // Note that we don't handle cases like this YET..
+            if (!this.chunkedDataBuffer.canReadBytes(offset, partSize))
+                break;
+            const splitResult = this.chunkedDataBuffer.split(offset).remainingBuffer.split(partSize);
+            offset = 0;
+            handlePart({
+                type: partType,
+                size: partSize,
+                data: splitResult.extractedBuffer
+            });
+            this.chunkedDataBuffer = splitResult.remainingBuffer;
+        }
+    }
+    readVarInt(offset) {
+        let byteLength;
+        if (this.chunkedDataBuffer.canReadBytes(offset, 1)) {
+            const firstByte = this.chunkedDataBuffer.getUint8(offset);
+            // Determine the length of the val
+            if (firstByte < 128) {
+                byteLength = 1;
+            }
+            else if (firstByte < 192) {
+                byteLength = 2;
+            }
+            else if (firstByte < 224) {
+                byteLength = 3;
+            }
+            else if (firstByte < 240) {
+                byteLength = 4;
+            }
+            else {
+                byteLength = 5;
+            }
+        }
+        else {
+            byteLength = 0;
+        }
+        if (byteLength < 1 || !this.chunkedDataBuffer.canReadBytes(offset, byteLength)) {
+            return [-1, offset];
+        }
+        let value;
+        // Now read it based on the length
+        switch (byteLength) {
+            case 1:
+                value = this.chunkedDataBuffer.getUint8(offset++);
+                break;
+            case 2: {
+                const byte1 = this.chunkedDataBuffer.getUint8(offset++);
+                const byte2 = this.chunkedDataBuffer.getUint8(offset++);
+                value = (byte1 & 0x3f) + 64 * byte2;
+                break;
+            }
+            case 3: {
+                const byte1 = this.chunkedDataBuffer.getUint8(offset++);
+                const byte2 = this.chunkedDataBuffer.getUint8(offset++);
+                const byte3 = this.chunkedDataBuffer.getUint8(offset++);
+                value = (byte1 & 0x1f) + 32 * (byte2 + 256 * byte3);
+                break;
+            }
+            case 4: {
+                const byte1 = this.chunkedDataBuffer.getUint8(offset++);
+                const byte2 = this.chunkedDataBuffer.getUint8(offset++);
+                const byte3 = this.chunkedDataBuffer.getUint8(offset++);
+                const byte4 = this.chunkedDataBuffer.getUint8(offset++);
+                value = (byte1 & 0x0f) + 16 * (byte2 + 256 * (byte3 + 256 * byte4));
+                break;
+            }
+            default: {
+                const tempOffset = offset + 1;
+                this.chunkedDataBuffer.focus(tempOffset);
+                if (this.canReadFromCurrentChunk(tempOffset, 4)) {
+                    value = this.getCurrentDataView().getUint32(tempOffset - this.chunkedDataBuffer.currentChunkOffset, true);
+                }
+                else {
+                    const byte3 = this.chunkedDataBuffer.getUint8(tempOffset + 2) + 256 * this.chunkedDataBuffer.getUint8(tempOffset + 3);
+                    value =
+                        this.chunkedDataBuffer.getUint8(tempOffset) +
+                            256 * (this.chunkedDataBuffer.getUint8(tempOffset + 1) + 256 * byte3);
+                }
+                offset += 5;
+                break;
+            }
+        }
+        return [value, offset];
+    }
+    canReadFromCurrentChunk(offset, length) {
+        this.chunkedDataBuffer.isFocused(offset);
+        return offset - this.chunkedDataBuffer.currentChunkOffset + length <= this.chunkedDataBuffer.chunks[this.chunkedDataBuffer.currentChunkIndex].length;
+    }
+    getCurrentDataView() {
+        if (!this.chunkedDataBuffer.currentDataView) {
+            const currentChunk = this.chunkedDataBuffer.chunks[this.chunkedDataBuffer.currentChunkIndex];
+            this.chunkedDataBuffer.currentDataView = new DataView(currentChunk.buffer, currentChunk.byteOffset, currentChunk.length);
+        }
+        return this.chunkedDataBuffer.currentDataView;
+    }
+}

package/dist/src/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ChunkedDataBuffer.js';
+export * from './UMP.js';
+export * from './ServerAbrStream.js';

package/dist/src/core/index.js

@@ -0,0 +1,3 @@
+export * from './ChunkedDataBuffer.js';
+export * from './UMP.js';
+export * from './ServerAbrStream.js';

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+import * as GoogleVideo from './core/index.js';
+export { GoogleVideo };
+export default GoogleVideo;
+export * from './utils/index.js';

package/dist/src/index.js

@@ -0,0 +1,4 @@
+import * as GoogleVideo from './core/index.js';
+export { GoogleVideo };
+export default GoogleVideo;
+export * from './utils/index.js';

package/dist/src/utils/EventEmitterLike.d.ts

@@ -0,0 +1,8 @@
+export declare class EventEmitterLike extends EventTarget {
+    #private;
+    constructor();
+    emit(type: string, ...args: any[]): void;
+    on(type: string, listener: (...args: any[]) => void): void;
+    once(type: string, listener: (...args: any[]) => void): void;
+    off(type: string, listener: (...args: any[]) => void): void;
+}

package/dist/src/utils/EventEmitterLike.js

@@ -0,0 +1,50 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EventEmitterLike_legacy_listeners;
+import { CustomEvent } from './index.js';
+export class EventEmitterLike extends EventTarget {
+    constructor() {
+        super();
+        _EventEmitterLike_legacy_listeners.set(this, new Map());
+    }
+    emit(type, ...args) {
+        const event = new CustomEvent(type, { detail: args });
+        this.dispatchEvent(event);
+    }
+    on(type, listener) {
+        const wrapper = (ev) => {
+            if (ev instanceof CustomEvent) {
+                listener(...ev.detail);
+            }
+            else {
+                listener(ev);
+            }
+        };
+        __classPrivateFieldGet(this, _EventEmitterLike_legacy_listeners, "f").set(listener, wrapper);
+        this.addEventListener(type, wrapper);
+    }
+    once(type, listener) {
+        const wrapper = (ev) => {
+            if (ev instanceof CustomEvent) {
+                listener(...ev.detail);
+            }
+            else {
+                listener(ev);
+            }
+            this.off(type, listener);
+        };
+        __classPrivateFieldGet(this, _EventEmitterLike_legacy_listeners, "f").set(listener, wrapper);
+        this.addEventListener(type, wrapper);
+    }
+    off(type, listener) {
+        const wrapper = __classPrivateFieldGet(this, _EventEmitterLike_legacy_listeners, "f").get(listener);
+        if (wrapper) {
+            this.removeEventListener(type, wrapper);
+            __classPrivateFieldGet(this, _EventEmitterLike_legacy_listeners, "f").delete(listener);
+        }
+    }
+}
+_EventEmitterLike_legacy_listeners = new WeakMap();

package/dist/src/utils/Protos.d.ts

@@ -0,0 +1,23 @@
+export { FormatInitializationMetadata } from '../../protos/generated/video_streaming/format_initialization_metadata.js';
+export { BufferedRange } from '../../protos/generated/video_streaming/buffered_range.js';
+export { MediaHeader } from '../../protos/generated/video_streaming/media_header.js';
+export { NextRequestPolicy } from '../../protos/generated/video_streaming/next_request_policy.js';
+export { PlaybackCookie } from '../../protos/generated/video_streaming/playback_cookie.js';
+export { PlaybackStartPolicy } from '../../protos/generated/video_streaming/playback_start_policy.js';
+export { RequestCancellationPolicy } from '../../protos/generated/video_streaming/request_cancellation_policy.js';
+export { SabrError } from '../../protos/generated/video_streaming/sabr_error.js';
+export { SabrRedirect } from '../../protos/generated/video_streaming/sabr_redirect.js';
+export { StreamProtectionStatus } from '../../protos/generated/video_streaming/stream_protection_status.js';
+export { VideoPlaybackAbrRequest } from '../../protos/generated/video_streaming/video_playback_abr_request.js';
+export { OnesieRequest } from '../../protos/generated/video_streaming/onesie_request.js';
+export { EncryptedPlayerRequest } from '../../protos/generated/video_streaming/encrypted_player_request.js';
+export { OnesieHeader } from '../../protos/generated/video_streaming/onesie_header.js';
+export { OnesieHeaderType } from '../../protos/generated/video_streaming/onesie_header_type.js';
+export { OnesiePlayerRequest } from '../../protos/generated/video_streaming/onesie_player_request.js';
+export { OnesiePlayerResponse } from '../../protos/generated/video_streaming/onesie_player_response.js';
+export { ClientAbrState } from '../../protos/generated/video_streaming/client_abr_state.js';
+export { StreamerContext } from '../../protos/generated/video_streaming/streamer_context.js';
+export { ProxyStatus } from '../../protos/generated/video_streaming/proxy_status.js';
+export { MediaCapabilities } from '../../protos/generated/video_streaming/media_capabilities.js';
+export { CryptoParams } from '../../protos/generated/video_streaming/crypto_params.js';
+export { ClientAbrState_MediaType as MediaType } from '../../protos/generated/video_streaming/client_abr_state.js';

package/dist/src/utils/Protos.js

@@ -0,0 +1,23 @@
+export { FormatInitializationMetadata } from '../../protos/generated/video_streaming/format_initialization_metadata.js';
+export { BufferedRange } from '../../protos/generated/video_streaming/buffered_range.js';
+export { MediaHeader } from '../../protos/generated/video_streaming/media_header.js';
+export { NextRequestPolicy } from '../../protos/generated/video_streaming/next_request_policy.js';
+export { PlaybackCookie } from '../../protos/generated/video_streaming/playback_cookie.js';
+export { PlaybackStartPolicy } from '../../protos/generated/video_streaming/playback_start_policy.js';
+export { RequestCancellationPolicy } from '../../protos/generated/video_streaming/request_cancellation_policy.js';
+export { SabrError } from '../../protos/generated/video_streaming/sabr_error.js';
+export { SabrRedirect } from '../../protos/generated/video_streaming/sabr_redirect.js';
+export { StreamProtectionStatus } from '../../protos/generated/video_streaming/stream_protection_status.js';
+export { VideoPlaybackAbrRequest } from '../../protos/generated/video_streaming/video_playback_abr_request.js';
+export { OnesieRequest } from '../../protos/generated/video_streaming/onesie_request.js';
+export { EncryptedPlayerRequest } from '../../protos/generated/video_streaming/encrypted_player_request.js';
+export { OnesieHeader } from '../../protos/generated/video_streaming/onesie_header.js';
+export { OnesieHeaderType } from '../../protos/generated/video_streaming/onesie_header_type.js';
+export { OnesiePlayerRequest } from '../../protos/generated/video_streaming/onesie_player_request.js';
+export { OnesiePlayerResponse } from '../../protos/generated/video_streaming/onesie_player_response.js';
+export { ClientAbrState } from '../../protos/generated/video_streaming/client_abr_state.js';
+export { StreamerContext } from '../../protos/generated/video_streaming/streamer_context.js';
+export { ProxyStatus } from '../../protos/generated/video_streaming/proxy_status.js';
+export { MediaCapabilities } from '../../protos/generated/video_streaming/media_capabilities.js';
+export { CryptoParams } from '../../protos/generated/video_streaming/crypto_params.js';
+export { ClientAbrState_MediaType as MediaType } from '../../protos/generated/video_streaming/client_abr_state.js';