@osmo.inc/cli 0.1.18 → 0.1.20

package/third-party/npm/mediabunny@1.52.2/source/src/hls/hls-demuxer.ts

@@ -1,995 +0,0 @@
-/*!
- * Copyright (c) 2026-present, Vanilagy and contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-import { AUDIO_CODECS, AudioCodec, inferCodecFromCodecString, MediaCodec, VIDEO_CODECS, VideoCodec } from '../codec';
-import { Demuxer, DurationMetadataRequestOptions } from '../demuxer';
-import { Input } from '../input';
-import {
-	InputAudioTrackBacking,
-	InputTrackBacking,
-	InputVideoTrackBacking,
-} from '../input-track';
-import { PacketRetrievalOptions } from '../media-sink';
-import { DEFAULT_TRACK_DISPOSITION, MetadataTags, TrackDisposition } from '../metadata';
-import { TrackType } from '../output';
-import { assert, joinPaths, MaybePromise, Rotation, UNDETERMINED_LANGUAGE } from '../misc';
-import { EncodedPacket } from '../packet';
-import { readAllLines } from '../reader';
-import {
-	AttributeList,
-	canIgnoreLine,
-	HLS_MIME_TYPE,
-	TAG_EXTINF,
-	TAG_I_FRAME_STREAM_INF,
-	TAG_I_FRAMES_ONLY,
-	TAG_MEDIA,
-	TAG_STREAM_INF,
-} from './hls-misc';
-import { HlsSegmentedInput } from './hls-segmented-input';
-import { SegmentedInputTrackDeclaration } from '../segmented-input';
-import { PathedSource } from '../source';
-
-type InternalTrack = {
-	id: number;
-	demuxer: HlsDemuxer;
-	backingTrack: InputTrackBacking | null;
-	default: boolean;
-	autoselect: boolean;
-	languageCode: string;
-	lineNumber: number;
-
-	fullPath: string;
-	fullCodecString: string;
-	pairingMask: bigint;
-	peakBitrate: number | null;
-	averageBitrate: number | null;
-	name: string | null;
-	hasOnlyKeyPackets: boolean;
-
-	info: {
-		type: 'video';
-		width: number | null;
-		height: number | null;
-	} | {
-		type: 'audio';
-		numberOfChannels: number | null;
-	};
-};
-type InternalVideoTrack = InternalTrack & { info: { type: 'video' } };
-type InternalAudioTrack = InternalTrack & { info: { type: 'audio' } };
-
-export class HlsDemuxer extends Demuxer {
-	metadataPromise: Promise<void> | null = null;
-	trackBackings: InputTrackBacking[] | null = null;
-	internalTracks: InternalTrack[] | null = null;
-	segmentedInputs: HlsSegmentedInput[] = [];
-	hasMasterPlaylist = true;
-
-	constructor(input: Input) {
-		super(input);
-	}
-
-	readMetadata() {
-		return this.metadataPromise ??= (async () => {
-			assert(this.input._rootSource instanceof PathedSource);
-
-			const slice = await this.input._reader.requestEntireFile();
-			assert(slice);
-			const lines = readAllLines(slice, slice.length, { ignore: canIgnoreLine });
-
-			// Important: get the root path AFTER reading data to get the final root path, possibly affected by
-			// redirects. Any follow requests should be related to the redirected path, not the original one.
-			const { rootPath } = this.input._rootSource;
-
-			const variantStreams: {
-				fullPath: string;
-				attributes: AttributeList;
-				lineNumber: number;
-				hasOnlyKeyPackets: boolean;
-			}[] = [];
-			const mediaTags: {
-				fullPath: string | null;
-				attributes: AttributeList;
-				lineNumber: number;
-			}[] = [];
-
-			// Let's first iterate through the entire file, collecting all variant streams and media tags
-
-			for (let i = 1; i < lines.length; i++) {
-				const line = lines[i]!;
-
-				if (line.startsWith(TAG_STREAM_INF)) {
-					const streamInfLineNumber = i;
-					const playlistPath = lines[++i];
-					if (playlistPath === undefined) {
-						throw new Error('Incorrect M3U8 file; a line must follow the #EXT-X-STREAM-INF tag.');
-					}
-
-					const fullPath = joinPaths(rootPath, playlistPath);
-					const attributes = new AttributeList(line.slice(TAG_STREAM_INF.length));
-
-					const bandwidth = attributes.getAsNumber('bandwidth');
-					if (bandwidth === null) {
-						throw new Error(
-							'Invalid M3U8 file; #EXT-X-STREAM-INF tag requires a BANDWIDTH attribute with a valid'
-							+ ' numerical value.',
-						);
-					}
-
-					variantStreams.push({
-						fullPath,
-						attributes,
-						lineNumber: streamInfLineNumber,
-						hasOnlyKeyPackets: false,
-					});
-				} else if (line.startsWith(TAG_I_FRAME_STREAM_INF)) {
-					const attributes = new AttributeList(line.slice(TAG_I_FRAME_STREAM_INF.length));
-					const playlistPath = attributes.get('uri');
-
-					if (playlistPath === null) {
-						throw new Error(
-							'Invalid M3U8 file; #EXT-X-I-FRAME-STREAM-INF tag requires a URI attribute.',
-						);
-					}
-
-					const bandwidth = attributes.getAsNumber('bandwidth');
-					if (bandwidth === null) {
-						throw new Error(
-							'Invalid M3U8 file; #EXT-X-I-FRAME-STREAM-INF tag requires a BANDWIDTH attribute with a'
-							+ ' valid numerical value.',
-						);
-					}
-
-					const fullPath = joinPaths(rootPath, playlistPath);
-
-					variantStreams.push({
-						fullPath,
-						attributes,
-						lineNumber: i,
-						hasOnlyKeyPackets: true,
-					});
-				} else if (line.startsWith(TAG_MEDIA)) {
-					const attributes = new AttributeList(line.slice(TAG_MEDIA.length));
-
-					const type = attributes.get('type');
-					if (type === null) {
-						throw new Error(
-							'Invalid M3U8 file; #EXT-X-MEDIA tag requires a TYPE attribute.',
-						);
-					}
-
-					const groupId = attributes.get('group-id');
-					if (groupId === null) {
-						throw new Error(
-							'Invalid M3U8 file; #EXT-X-MEDIA tag requires a GROUP-ID attribute.',
-						);
-					}
-
-					let fullPath: string | null = null;
-					const uri = attributes.get('uri');
-					if (uri !== null) {
-						fullPath = joinPaths(rootPath, uri);
-					}
-
-					mediaTags.push({ fullPath, attributes, lineNumber: i });
-				} else if (line === TAG_I_FRAMES_ONLY) {
-					// iFramesOnlyTagFound = true;
-				} else if (line.startsWith(TAG_EXTINF)) {
-					// This is a media playlist, not a master playlist
-					const segmentedInput = new HlsSegmentedInput(this, rootPath, null, lines);
-
-					this.segmentedInputs = [segmentedInput];
-					this.hasMasterPlaylist = false;
-					this.trackBackings = await segmentedInput.getTrackBackings();
-
-					return;
-				}
-			}
-
-			const videoGroupIds = [...new Set(
-				mediaTags
-					.filter(tag => tag.attributes.get('type')!.toLowerCase() === 'video')
-					.map(tag => tag.attributes.get('group-id')!)),
-			];
-			const audioGroupIds = [...new Set(
-				mediaTags
-					.filter(tag => tag.attributes.get('type')!.toLowerCase() === 'audio')
-					.map(tag => tag.attributes.get('group-id')!)),
-			];
-
-			// Now, let's process & resolve all variant streams in parallel, mapping each of them to tracks.
-
-			const internalTracksByVariant = await Promise.all(variantStreams.map(async (variantStream, i) => {
-				const result: InternalTrack[] = [];
-
-				const codecsList = variantStream.attributes.get('codecs');
-				let codecStrings: string[];
-
-				if (codecsList) {
-					codecStrings = codecsList.split(',').map(x => x.trim());
-				} else {
-					// No codecs were specified, we need to read the underlying media data
-					const segmentedInput = this.getSegmentedInputForPath(variantStream.fullPath);
-					const trackBackings = await segmentedInput.getTrackBackings();
-
-					const tracksWithCodec = await Promise.all(
-						trackBackings.map(async t => ({ track: t, codec: await t.getCodec() })),
-					);
-					codecStrings = await Promise.all(
-						tracksWithCodec
-							.filter(x => x.codec !== null)
-							.map(x => x.track.getDecoderConfig().then(x => x!.codec)),
-					);
-				}
-
-				const videoGroupId = variantStream.attributes.get('video');
-				const audioGroupId = variantStream.attributes.get('audio');
-				const containsVideoCodecs = codecStrings.some(x =>
-					VIDEO_CODECS.includes(inferCodecFromCodecString(x) as VideoCodec),
-				);
-				const containsAudioCodecs = codecStrings.some(x =>
-					AUDIO_CODECS.includes(inferCodecFromCodecString(x) as AudioCodec),
-				);
-
-				if (videoGroupId !== null && !containsVideoCodecs) {
-					// A video group is linked but no video codec is listed, sigh. Let's resolve the video codec.
-
-					if (!videoGroupIds.includes(videoGroupId)) {
-						throw new Error(
-							`Invalid M3U8 file; variant stream references video group "${videoGroupId}" which`
-							+ ` is not defined in any #EXT-X-MEDIA tags.`,
-						);
-					}
-
-					// We only need to look at the first matching tag, since all tags are required to have the same
-					// codec anyway
-					const matchingVideoMediaTag = mediaTags.find((mediaTag) => {
-						const groupId = mediaTag.attributes.get('group-id')!;
-						const type = mediaTag.attributes.get('type')!;
-						return groupId === videoGroupId && type.toLowerCase() === 'video';
-					});
-
-					outer:
-					if (matchingVideoMediaTag) {
-						const uri = matchingVideoMediaTag.attributes.get('uri');
-						if (uri === null) {
-							break outer;
-						}
-
-						const fullPath = joinPaths(rootPath, uri);
-						const segmentedInput = this.getSegmentedInputForPath(fullPath);
-						const trackBackings = await segmentedInput.getTrackBackings();
-						const videoTrack = trackBackings.find(x => x.getType() === 'video');
-
-						if (!videoTrack || (await videoTrack.getCodec()) === null) {
-							break outer;
-						}
-
-						const additionalCodecString = await videoTrack.getDecoderConfig().then(x => x?.codec ?? null);
-						assert(additionalCodecString !== null);
-
-						codecStrings.push(additionalCodecString);
-					}
-				}
-
-				if (audioGroupId !== null && !containsAudioCodecs) {
-					// An audio group is linked but no audio codec is listed, sigh. Let's resolve the audio codec.
-
-					if (!audioGroupIds.includes(audioGroupId)) {
-						throw new Error(
-							`Invalid M3U8 file; variant stream references audio group "${audioGroupId}" which`
-							+ ` is not defined in any #EXT-X-MEDIA tags.`,
-						);
-					}
-
-					// We only need to look at the first matching tag, since all tags are required to have the same
-					// codec anyway
-					const matchingAudioMediaTag = mediaTags.find((tag) => {
-						const groupId = tag.attributes.get('group-id')!;
-						const type = tag.attributes.get('type')!;
-						return groupId === audioGroupId && type.toLowerCase() === 'audio';
-					});
-
-					outer:
-					if (matchingAudioMediaTag) {
-						const uri = matchingAudioMediaTag.attributes.get('uri');
-						if (uri === null) {
-							break outer;
-						}
-
-						const fullPath = joinPaths(rootPath, uri);
-						const segmentedInput = this.getSegmentedInputForPath(fullPath);
-						const trackBackings = await segmentedInput.getTrackBackings();
-						const audioTrack = trackBackings.find(x => x.getType() === 'audio');
-
-						if (!audioTrack || (await audioTrack.getCodec()) === null) {
-							break outer;
-						}
-
-						const additionalCodecString = await audioTrack.getDecoderConfig().then(x => x?.codec ?? null);
-						assert(additionalCodecString !== null);
-
-						codecStrings.push(additionalCodecString);
-					}
-				}
-
-				// Unique that shit
-				codecStrings = [...new Set(codecStrings)];
-
-				let videoCodecString: string | null = null;
-				let audioCodecString: string | null = null;
-
-				const bandwidth = variantStream.attributes.getAsNumber('bandwidth');
-				assert(bandwidth !== null);
-
-				const averageBandwidth = variantStream.attributes.getAsNumber('average-bandwidth');
-				const name = variantStream.attributes.get('name');
-
-				// Now, finally, loop over each codec string for the variant and resolve each one to one or more tracks.
-				for (const codecString of codecStrings) {
-					const inferredCodec = inferCodecFromCodecString(codecString);
-					if (inferredCodec === null) {
-						continue;
-					}
-
-					if (VIDEO_CODECS.includes(inferredCodec as VideoCodec)) {
-						if (videoCodecString !== null) {
-							throw new Error(
-								'Unsupported M3U8 file; multiple video codecs found in the CODECS attribute of a'
-								+ ' variant stream.',
-							);
-						}
-
-						videoCodecString = codecString;
-
-						const videoGroupId = variantStream.attributes.get('video');
-
-						if (videoGroupId === null) {
-							const resolution = variantStream.attributes.get('resolution');
-							let width: number | null = null;
-							let height: number | null = null;
-
-							if (resolution) {
-								const match = resolution.match(/^(\d+)x(\d+)$/);
-								if (match) {
-									width = Number(match[1]);
-									height = Number(match[2]);
-								}
-							}
-
-							result.push({
-								id: -1,
-								demuxer: this,
-								backingTrack: null,
-								default: true,
-								autoselect: true,
-								languageCode: UNDETERMINED_LANGUAGE,
-								lineNumber: variantStream.lineNumber,
-								fullPath: variantStream.fullPath,
-								fullCodecString: videoCodecString,
-								pairingMask: 1n << BigInt(i),
-								peakBitrate: bandwidth,
-								averageBitrate: averageBandwidth,
-								name,
-								hasOnlyKeyPackets: variantStream.hasOnlyKeyPackets,
-								info: {
-									type: 'video',
-									width,
-									height,
-								},
-							});
-						} else {
-							if (!videoGroupIds.includes(videoGroupId)) {
-								throw new Error(
-									`Invalid M3U8 file; variant stream references video group "${videoGroupId}"`
-									+ ` which is not defined in any #EXT-X-MEDIA tags.`,
-								);
-							}
-
-							for (const mediaTag of mediaTags) {
-								const groupId = mediaTag.attributes.get('group-id')!;
-								const type = mediaTag.attributes.get('type')!;
-
-								if (groupId !== videoGroupId || type.toLowerCase() !== 'video') {
-									continue;
-								}
-
-								const resolution = mediaTag.attributes.get('resolution')
-									?? variantStream.attributes.get('resolution');
-								let width: number | null = null;
-								let height: number | null = null;
-
-								if (resolution) {
-									const match = resolution.match(/^(\d+)x(\d+)$/);
-									if (match) {
-										width = Number(match[1]);
-										height = Number(match[2]);
-									}
-								}
-
-								result.push({
-									id: -1,
-									demuxer: this,
-									backingTrack: null,
-									default: getMediaTagDefault(mediaTag.attributes),
-									// Autoselect is inferred to be true if the default is true
-									autoselect: getMediaTagDefault(mediaTag.attributes)
-										|| getMediaTagAutoselect(mediaTag.attributes),
-									languageCode: preprocessLanguageCode(mediaTag.attributes.get('language')),
-									lineNumber: mediaTag.lineNumber,
-									fullPath: mediaTag.fullPath ?? variantStream.fullPath,
-									fullCodecString: videoCodecString,
-									pairingMask: 1n << BigInt(i),
-									peakBitrate: null,
-									averageBitrate: null,
-									name: mediaTag.attributes.get('name'),
-									hasOnlyKeyPackets: variantStream.hasOnlyKeyPackets,
-									info: {
-										type: 'video',
-										width,
-										height,
-									},
-								});
-							}
-						}
-					} else if (AUDIO_CODECS.includes(inferredCodec as AudioCodec)) {
-						if (audioCodecString !== null) {
-							throw new Error(
-								'Unsupported M3U8 file; multiple audio codecs found in the CODECS attribute of a'
-								+ ' variant stream.',
-							);
-						}
-
-						audioCodecString = codecString;
-
-						const audioGroupId = variantStream.attributes.get('audio');
-
-						if (audioGroupId === null) {
-							const channels = variantStream.attributes.get('channels');
-							const parsedChannels = channels !== null
-								? Number(channels.split('/')[0]!)
-								: null;
-
-							result.push({
-								id: -1,
-								demuxer: this,
-								backingTrack: null,
-								default: true,
-								autoselect: true,
-								languageCode: UNDETERMINED_LANGUAGE,
-								lineNumber: variantStream.lineNumber,
-								fullPath: variantStream.fullPath,
-								fullCodecString: audioCodecString,
-								pairingMask: 1n << BigInt(i),
-								peakBitrate: bandwidth,
-								averageBitrate: averageBandwidth,
-								name,
-								hasOnlyKeyPackets: variantStream.hasOnlyKeyPackets,
-								info: {
-									type: 'audio',
-									numberOfChannels:
-											parsedChannels !== null
-											&& Number.isInteger(parsedChannels)
-											&& parsedChannels > 0
-												? parsedChannels
-												: null,
-								},
-							});
-						} else {
-							if (!audioGroupIds.includes(audioGroupId)) {
-								throw new Error(
-									`Invalid M3U8 file; variant stream references audio group "${audioGroupId}"`
-									+ ` which is not defined in any #EXT-X-MEDIA tags.`,
-								);
-							}
-
-							for (const mediaTag of mediaTags) {
-								const groupId = mediaTag.attributes.get('group-id')!;
-								const type = mediaTag.attributes.get('type')!;
-
-								if (groupId !== audioGroupId || type.toLowerCase() !== 'audio') {
-									continue;
-								}
-
-								const channels = mediaTag.attributes.get('channels')
-									?? variantStream.attributes.get('channels');
-								const parsedChannels = channels !== null
-									? Number(channels.split('/')[0]!)
-									: null;
-
-								result.push({
-									id: -1,
-									demuxer: this,
-									backingTrack: null,
-									default: getMediaTagDefault(mediaTag.attributes),
-									// Autoselect is inferred to be true if the default is true
-									autoselect: getMediaTagDefault(mediaTag.attributes)
-										|| getMediaTagAutoselect(mediaTag.attributes),
-									languageCode: preprocessLanguageCode(mediaTag.attributes.get('language')),
-									lineNumber: mediaTag.lineNumber,
-									fullPath: mediaTag.fullPath ?? variantStream.fullPath,
-									fullCodecString: audioCodecString,
-									pairingMask: 1n << BigInt(i),
-									peakBitrate: null,
-									averageBitrate: null,
-									name: mediaTag.attributes.get('name'),
-									hasOnlyKeyPackets: variantStream.hasOnlyKeyPackets,
-									info: {
-										type: 'audio',
-										numberOfChannels:
-												parsedChannels !== null
-												&& Number.isInteger(parsedChannels)
-												&& parsedChannels > 0
-													? parsedChannels
-													: null,
-									},
-								});
-							}
-						}
-					}
-				}
-
-				return result;
-			}));
-
-			const internalTracks: InternalTrack[] = [];
-			const addInternalTrack = (track: InternalTrack) => {
-				const existingTrack = internalTracks.find(x =>
-					x.fullPath === track.fullPath && x.info.type === track.info.type,
-				);
-
-				if (existingTrack) {
-					existingTrack.pairingMask |= track.pairingMask;
-					existingTrack.default ||= track.default;
-					existingTrack.autoselect ||= track.autoselect;
-					existingTrack.lineNumber = Math.min(existingTrack.lineNumber, track.lineNumber);
-
-					if (track.peakBitrate !== null) {
-						existingTrack.peakBitrate = Math.max(
-							existingTrack.peakBitrate ?? -Infinity,
-							track.peakBitrate,
-						);
-					}
-					if (track.averageBitrate !== null) {
-						existingTrack.averageBitrate = Math.max(
-							existingTrack.averageBitrate ?? -Infinity,
-							track.averageBitrate,
-						);
-					}
-
-					if (existingTrack.languageCode === UNDETERMINED_LANGUAGE) {
-						existingTrack.languageCode = track.languageCode;
-					}
-				} else {
-					track.id = internalTracks.length + 1;
-					internalTracks.push(track);
-				}
-			};
-
-			for (const variantInternalTracks of internalTracksByVariant) {
-				for (const trackEntry of variantInternalTracks) {
-					addInternalTrack(trackEntry);
-				}
-			}
-
-			// Order tracks by how they appear in the file
-			internalTracks.sort((a, b) => a.lineNumber - b.lineNumber);
-
-			this.trackBackings = [];
-			for (const internalTrack of internalTracks) {
-				if (internalTrack.info.type === 'video') {
-					this.trackBackings.push(
-						new HlsInputVideoTrackBacking(internalTrack as InternalVideoTrack),
-					);
-				} else {
-					this.trackBackings.push(
-						new HlsInputAudioTrackBacking(internalTrack as InternalAudioTrack),
-					);
-				}
-			}
-
-			this.internalTracks = internalTracks;
-		})();
-	}
-
-	async getTrackBackings() {
-		await this.readMetadata();
-		assert(this.trackBackings);
-
-		return this.trackBackings;
-	}
-
-	getSegmentedInputForPath(path: string) {
-		let segmentedInput = this.segmentedInputs.find(x => x.path === path);
-		if (segmentedInput) {
-			return segmentedInput;
-		}
-
-		let decls: SegmentedInputTrackDeclaration[] | null = null;
-		if (this.internalTracks) {
-			const tracks = this.internalTracks.filter(x => x.fullPath === path);
-			decls = tracks.map(x => ({
-				id: x.id,
-				type: x.info.type,
-			}));
-		}
-
-		segmentedInput = new HlsSegmentedInput(this, path, decls, null);
-		this.segmentedInputs.push(segmentedInput);
-
-		return segmentedInput;
-	}
-
-	async getMetadataTags(): Promise<MetadataTags> {
-		return {};
-	}
-
-	async getMimeType(): Promise<string> {
-		return HLS_MIME_TYPE;
-	}
-
-	override dispose(): void {
-		if (this.segmentedInputs) {
-			for (const segInput of this.segmentedInputs) {
-				segInput.dispose();
-			}
-			this.segmentedInputs.length = 0;
-		}
-	}
-}
-
-abstract class HlsInputTrackBacking implements InputTrackBacking {
-	hydrationPromise: Promise<void> | null = null;
-
-	constructor(public internalTrack: InternalTrack) {}
-
-	abstract getType(): TrackType;
-	abstract getDecoderConfig(): Promise<VideoDecoderConfig | AudioDecoderConfig | null>;
-
-	hydrate() {
-		return this.hydrationPromise ??= (async () => {
-			const segmentedInput = this.internalTrack.demuxer.getSegmentedInputForPath(this.internalTrack.fullPath);
-
-			let trackBacking: InputTrackBacking | null = null;
-
-			const trackBackings = await segmentedInput.getTrackBackings();
-			const matchingType = trackBackings.filter(x => x.getType() === this.getType());
-
-			if (matchingType.length === 1) {
-				// Avoids reading fields on the track
-				trackBacking = matchingType[0]!;
-			} else {
-				if (this instanceof HlsInputVideoTrackBacking) {
-					for (const backing of matchingType) {
-						if ((await backing.getCodec()) === this.getCodec()) {
-							trackBacking = backing;
-							break;
-						}
-					}
-				} else {
-					assert(this instanceof HlsInputAudioTrackBacking);
-
-					for (const backing of matchingType) {
-						if ((await backing.getCodec()) === this.getCodec()) {
-							trackBacking = backing;
-							break;
-						}
-					}
-				}
-			}
-
-			if (!trackBacking) {
-				throw new Error('Could not find matching track in underlying media data.');
-			}
-
-			this.internalTrack.backingTrack = trackBacking;
-		})();
-	}
-
-	/** If the backing track is already present, delegate synchronously; otherwise, hydrate first. */
-	delegate<T>(fn: () => MaybePromise<T>): MaybePromise<T> {
-		if (this.internalTrack.backingTrack) {
-			return fn();
-		}
-
-		return this.hydrate().then(fn);
-	}
-
-	getCodec(): MediaCodec | null {
-		throw new Error('Not implemented on base class.');
-	}
-
-	getDisposition(): TrackDisposition {
-		return {
-			...DEFAULT_TRACK_DISPOSITION,
-			// Meanings are swapped in HLS: "Default" means that a track is the primary track.
-			default: this.internalTrack.autoselect,
-			primary: this.internalTrack.default,
-		};
-	}
-
-	getId(): number {
-		return this.internalTrack.id;
-	}
-
-	getPairingMask(): bigint {
-		return this.internalTrack.pairingMask;
-	}
-
-	getInternalCodecId(): string | number | Uint8Array | null {
-		return null;
-	}
-
-	getLanguageCode(): string {
-		return this.internalTrack.languageCode;
-	}
-
-	getName(): string | null {
-		return this.internalTrack.name;
-	}
-
-	getNumber(): number {
-		assert(this.internalTrack.demuxer.internalTracks);
-
-		const trackType = this.internalTrack.info.type;
-		let number = 0;
-		for (const track of this.internalTrack.demuxer.internalTracks) {
-			if (track.info.type === trackType) {
-				number++;
-			}
-
-			if (track === this.internalTrack) {
-				break;
-			}
-		}
-
-		return number;
-	}
-
-	getTimeResolution(): MaybePromise<number> {
-		return this.delegate(() => this.internalTrack.backingTrack!.getTimeResolution());
-	}
-
-	isRelativeToUnixEpoch(): MaybePromise<boolean> {
-		return this.delegate(() => this.internalTrack.backingTrack!.isRelativeToUnixEpoch());
-	}
-
-	getUnixTimeForTimestamp(timestamp: number): MaybePromise<number | null> {
-		return this.delegate(() => this.internalTrack.backingTrack!.getUnixTimeForTimestamp(timestamp));
-	}
-
-	getBitrate(): number | null {
-		return this.internalTrack.peakBitrate;
-	}
-
-	getAverageBitrate(): number | null {
-		return this.internalTrack.averageBitrate;
-	}
-
-	async getDurationFromMetadata(options: DurationMetadataRequestOptions): Promise<number | null> {
-		await this.hydrate();
-		return this.internalTrack.backingTrack!.getDurationFromMetadata(options);
-	}
-
-	async getLiveRefreshInterval(): Promise<number | null> {
-		await this.hydrate();
-		return this.internalTrack.backingTrack!.getLiveRefreshInterval();
-	}
-
-	getHasOnlyKeyPackets() {
-		return this.internalTrack.hasOnlyKeyPackets || null;
-	}
-
-	async getFirstPacket(options: PacketRetrievalOptions): Promise<EncodedPacket | null> {
-		await this.hydrate();
-		return this.internalTrack.backingTrack!.getFirstPacket(options);
-	}
-
-	async getPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null> {
-		await this.hydrate();
-		return this.internalTrack.backingTrack!.getPacket(timestamp, options);
-	}
-
-	async getKeyPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null> {
-		await this.hydrate();
-		return this.internalTrack.backingTrack!.getKeyPacket(timestamp, options);
-	}
-
-	async getNextPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null> {
-		await this.hydrate();
-		return this.internalTrack.backingTrack!.getNextPacket(packet, options);
-	}
-
-	async getNextKeyPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null> {
-		await this.hydrate();
-		return this.internalTrack.backingTrack!.getNextKeyPacket(packet, options);
-	}
-}
-
-class HlsInputVideoTrackBacking
-	extends HlsInputTrackBacking
-	implements InputVideoTrackBacking {
-	override internalTrack!: InternalVideoTrack;
-
-	constructor(internalTrack: InternalVideoTrack) {
-		super(internalTrack);
-	}
-
-	get backingVideoTrack() {
-		return this.internalTrack.backingTrack as InputVideoTrackBacking | null;
-	}
-
-	getType() {
-		return 'video' as const;
-	}
-
-	override getCodec(): VideoCodec | null {
-		const inferredCodec = inferCodecFromCodecString(this.internalTrack.fullCodecString);
-		return inferredCodec as VideoCodec;
-	}
-
-	getCodedWidth(): MaybePromise<number> {
-		return this.delegate(() => this.backingVideoTrack!.getCodedWidth());
-	}
-
-	getCodedHeight(): MaybePromise<number> {
-		return this.delegate(() => this.backingVideoTrack!.getCodedHeight());
-	}
-
-	getSquarePixelWidth(): MaybePromise<number> {
-		return this.delegate(() => this.backingVideoTrack!.getSquarePixelWidth());
-	}
-
-	getSquarePixelHeight(): MaybePromise<number> {
-		return this.delegate(() => this.backingVideoTrack!.getSquarePixelHeight());
-	}
-
-	getMetadataDisplayWidth(): number | null {
-		if (this.backingVideoTrack) {
-			return null;
-		}
-
-		return this.internalTrack.info.width;
-	}
-
-	getMetadataDisplayHeight(): number | null {
-		if (this.backingVideoTrack) {
-			return null;
-		}
-
-		return this.internalTrack.info.height;
-	}
-
-	getRotation(): MaybePromise<Rotation> {
-		return this.delegate(() => this.backingVideoTrack!.getRotation());
-	}
-
-	async getColorSpace(): Promise<VideoColorSpaceInit> {
-		await this.hydrate();
-		return this.backingVideoTrack!.getColorSpace();
-	}
-
-	async canBeTransparent(): Promise<boolean> {
-		await this.hydrate();
-		return this.backingVideoTrack!.canBeTransparent();
-	}
-
-	getMetadataCodecParameterString(): string | null {
-		if (this.backingVideoTrack) {
-			return null;
-		}
-		return this.internalTrack.fullCodecString;
-	}
-
-	async getDecoderConfig(): Promise<VideoDecoderConfig | null> {
-		await this.hydrate();
-		return this.backingVideoTrack!.getDecoderConfig();
-	}
-}
-
-class HlsInputAudioTrackBacking
-	extends HlsInputTrackBacking
-	implements InputAudioTrackBacking {
-	override internalTrack!: InternalAudioTrack;
-
-	constructor(internalTrack: InternalAudioTrack) {
-		super(internalTrack);
-	}
-
-	get backingAudioTrack() {
-		return this.internalTrack.backingTrack as InputAudioTrackBacking | null;
-	}
-
-	getType() {
-		return 'audio' as const;
-	}
-
-	override getCodec(): AudioCodec | null {
-		const inferredCodec = inferCodecFromCodecString(this.internalTrack.fullCodecString);
-		return inferredCodec as AudioCodec;
-	}
-
-	getNumberOfChannels(): MaybePromise<number> {
-		if (this.internalTrack.info.numberOfChannels !== null) {
-			return this.internalTrack.info.numberOfChannels;
-		}
-
-		return this.delegate(() => this.backingAudioTrack!.getNumberOfChannels());
-	}
-
-	getSampleRate(): MaybePromise<number> {
-		return this.delegate(() => this.backingAudioTrack!.getSampleRate());
-	}
-
-	getMetadataCodecParameterString(): string | null {
-		if (this.backingAudioTrack) {
-			return null;
-		}
-		return this.internalTrack.fullCodecString;
-	}
-
-	async getDecoderConfig(): Promise<AudioDecoderConfig | null> {
-		await this.hydrate();
-		return this.backingAudioTrack!.getDecoderConfig();
-	}
-}
-
-const getMediaTagDefault = (attributes: AttributeList) => {
-	const value = attributes.get('default');
-	if (value === null) {
-		return false;
-	}
-
-	const normalized = value.toUpperCase();
-	if (normalized === 'YES') {
-		return true;
-	}
-	if (normalized === 'NO') {
-		return false;
-	}
-
-	throw new Error(
-		`Invalid M3U8 file; #EXT-X-MEDIA DEFAULT attribute must be YES or NO, got "${value}".`,
-	);
-};
-
-const getMediaTagAutoselect = (attributes: AttributeList) => {
-	const value = attributes.get('autoselect');
-	if (value === null) {
-		return false;
-	}
-
-	const normalized = value.toUpperCase();
-	if (normalized === 'YES') {
-		return true;
-	}
-	if (normalized === 'NO') {
-		return false;
-	}
-
-	throw new Error(
-		`Invalid M3U8 file; #EXT-X-MEDIA AUTOSELECT attribute must be YES or NO, got "${value}".`,
-	);
-};
-
-const preprocessLanguageCode = (code: string | null) => {
-	if (code === null) {
-		return UNDETERMINED_LANGUAGE;
-	}
-
-	const languageSubtag = code.split('-')[0];
-	if (!languageSubtag) {
-		return UNDETERMINED_LANGUAGE;
-	}
-
-	// Technically invalid, for now: The language subtag might be a language code from ISO 639-1,
-	// ISO 639-2, ISO 639-3, ISO 639-5 or some other thing (source: Wikipedia). But, `languageCode` is
-	// documented as ISO 639-2. Changing the definition would be a breaking change. This will get
-	// cleaned up in the future by defining languageCode to be BCP 47 instead.
-	return languageSubtag;
-};