@videojs/spf 10.0.0-beta.3 → 10.0.0-beta.30

package/dist/dev/media/errors.d.ts

@@ -0,0 +1,82 @@
+//#region src/media/errors.d.ts
+/**
+ * SVTA 2070 (Standardized Error Codes) — the vocabulary for identifying a
+ * playback failure or notice, independent of how it's transported or who
+ * decides what to do about it.
+ *
+ * A code is a single integer: the leading digit(s) are the **category** (the
+ * error's domain) and the trailing three are the **index** (the specific error
+ * within it). Four digits for natively-defined errors, five when an external
+ * standard is embedded — `"03404"` is an HTTP 404 under the network category.
+ * Categories are `0` unknown, `1` media content, `2` playback, `3` network,
+ * `4` content protection, `5` accessibility, `6` remote play, `7` advertising,
+ * `99` custom.
+ *
+ * Two properties of the spec shape the types here:
+ *
+ * - **Severity is deliberately not part of a code.** Per §Approach, "impact
+ *   varies with player implementation, breaking the consistency of a specific
+ *   error mapping to single code." So an error carries no fatal flag — whether a
+ *   condition is fatal depends on the composition observing it, and is decided
+ *   downstream.
+ * - **Reporting is partial and stacked** (Principles 5–6). Errors are reported
+ *   as encountered, most of them non-fatal, and the *sequence* carries causation
+ *   a single value can't.
+ *
+ * See `internal/design/spf/features/errors.md`.
+ */
+/**
+ * A reported condition, identified by its SVTA code.
+ *
+ * Named for the spec rather than the engine because the vocabulary is
+ * format- and player-neutral. Not `MediaError` — that name belongs to the
+ * `@videojs/media` DOM-facing class this eventually maps *onto*, and the mapping
+ * is the point at which severity and user-facing text get decided.
+ */
+interface SvtaError {
+  /** The SVTA code — see {@link svtaCategory} / {@link svtaIndex}. */
+  code: number;
+  /** Engineer-facing detail. Optional; the code is the identity. */
+  message?: string;
+  /** Reporter-specific context (track type, url, the constraint that fired). */
+  data?: unknown;
+}
+/**
+ * SVTA 99 [Custom] 001 — this engine has no pipeline for something the source
+ * requires, so the source is unplayable *here* rather than broken.
+ *
+ * Custom rather than standard because the standard codes available describe
+ * either narrower or wider things. The causes (1004/1005 unsupported format,
+ * 4008 unsupported DRM) say what one rendition hit; the verdicts (2011/2012 no
+ * supported track) say a type emptied without saying why it's unfixable. And
+ * 2039 "Manifest feature unsupported" covers features that are unsupported but
+ * still *playable* — LL-HLS degrading to standard live is a 2039 — so
+ * overloading it for a fatal condition would make it useless for the notices it
+ * belongs on.
+ *
+ * Index `001`: the spec defines only `99000` (Unknown) for the custom category
+ * and leaves the rest to the publisher, so this is the first code we define.
+ *
+ * Five digits, and deliberately not special-cased anywhere: {@link svtaCategory}
+ * and {@link svtaIndex} decompose it correctly by arithmetic alone, because
+ * every standard category is below `8000` and custom starts at `99000`.
+ */
+declare const SVTA_UNSUPPORTED_PLAYBACK_FEATURE = 99001;
+/**
+ * The error's domain — `code / 1000`, per the spec's "divide by one thousand to
+ * obtain the error category". Works uniformly across the four-digit native form
+ * and the five-digit form embedding an external standard: `"03404"` is
+ * numerically 3404, which decomposes identically. That also makes a numeric code
+ * immune to the spec's inconsistent zero-padding (§Approach writes a
+ * category-unknown network error as `"0300"` where the error index implies
+ * category 3 / index 000).
+ */
+declare function svtaCategory(code: number): number;
+/**
+ * The specific error within its category — `code % 1000`. For a five-digit code
+ * this is the embedded external value (an HTTP status, a VAST code).
+ */
+declare function svtaIndex(code: number): number;
+//#endregion
+export { SVTA_UNSUPPORTED_PLAYBACK_FEATURE, SvtaError, svtaCategory, svtaIndex };
+//# sourceMappingURL=errors.d.ts.map

package/dist/dev/media/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../../src/media/errors.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmCiB;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;cAoDW;;;;;;;;;;iBAWG,aAAa;;;;;iBAQb,UAAU"}

package/dist/dev/media/errors.js

@@ -0,0 +1,69 @@
+//#region src/media/errors.ts
+/** SVTA 1 [Media Content] 004 — the video is in a format we can't play (e.g. an MPEG-TS container). */
+const SVTA_UNSUPPORTED_VIDEO_FORMAT = 1004;
+/** SVTA 1 [Media Content] 005 — the audio counterpart of {@link SVTA_UNSUPPORTED_VIDEO_FORMAT}. */
+const SVTA_UNSUPPORTED_AUDIO_FORMAT = 1005;
+/**
+* SVTA 4 [Content Protection] 008 — unsupported or unavailable DRM system. Used
+* for "this source is encrypted and we have no decryption pipeline," which is
+* detection, not a license failure.
+*/
+const SVTA_UNSUPPORTED_DRM_SYSTEM = 4008;
+/**
+* SVTA 2 [Playback] 011 — no video track the environment can play.
+*
+* Covers both ways a composition can end up with nothing to select: renditions
+* that existed and were all excluded as unplayable, and — where the composition
+* composes `reportAbsentTrackType` to say it needs the type — a source carrying
+* none to begin with. Deliberately one code for both, because they are the same
+* answer to a viewer, and because the alternative is a code the SVTA spec doesn't
+* define. Whether an absent type is a failure is the composition's to state,
+* which is why it opts in rather than being read off the source.
+*/
+const SVTA_NO_SUPPORTED_VIDEO_TRACK = 2011;
+/** SVTA 2 [Playback] 012 — the audio counterpart of {@link SVTA_NO_SUPPORTED_VIDEO_TRACK}. */
+const SVTA_NO_SUPPORTED_AUDIO_TRACK = 2012;
+/**
+* SVTA 99 [Custom] 001 — this engine has no pipeline for something the source
+* requires, so the source is unplayable *here* rather than broken.
+*
+* Custom rather than standard because the standard codes available describe
+* either narrower or wider things. The causes (1004/1005 unsupported format,
+* 4008 unsupported DRM) say what one rendition hit; the verdicts (2011/2012 no
+* supported track) say a type emptied without saying why it's unfixable. And
+* 2039 "Manifest feature unsupported" covers features that are unsupported but
+* still *playable* — LL-HLS degrading to standard live is a 2039 — so
+* overloading it for a fatal condition would make it useless for the notices it
+* belongs on.
+*
+* Index `001`: the spec defines only `99000` (Unknown) for the custom category
+* and leaves the rest to the publisher, so this is the first code we define.
+*
+* Five digits, and deliberately not special-cased anywhere: {@link svtaCategory}
+* and {@link svtaIndex} decompose it correctly by arithmetic alone, because
+* every standard category is below `8000` and custom starts at `99000`.
+*/
+const SVTA_UNSUPPORTED_PLAYBACK_FEATURE = 99001;
+/**
+* The error's domain — `code / 1000`, per the spec's "divide by one thousand to
+* obtain the error category". Works uniformly across the four-digit native form
+* and the five-digit form embedding an external standard: `"03404"` is
+* numerically 3404, which decomposes identically. That also makes a numeric code
+* immune to the spec's inconsistent zero-padding (§Approach writes a
+* category-unknown network error as `"0300"` where the error index implies
+* category 3 / index 000).
+*/
+function svtaCategory(code) {
+	return Math.floor(code / 1e3);
+}
+/**
+* The specific error within its category — `code % 1000`. For a five-digit code
+* this is the embedded external value (an HTTP status, a VAST code).
+*/
+function svtaIndex(code) {
+	return code % 1e3;
+}
+//#endregion
+export { SVTA_NO_SUPPORTED_AUDIO_TRACK, SVTA_NO_SUPPORTED_VIDEO_TRACK, SVTA_UNSUPPORTED_AUDIO_FORMAT, SVTA_UNSUPPORTED_DRM_SYSTEM, SVTA_UNSUPPORTED_PLAYBACK_FEATURE, SVTA_UNSUPPORTED_VIDEO_FORMAT, svtaCategory, svtaIndex };
+
+//# sourceMappingURL=errors.js.map

package/dist/dev/media/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../../src/media/errors.ts"],"sourcesContent":["/**\n * SVTA 2070 (Standardized Error Codes) — the vocabulary for identifying a\n * playback failure or notice, independent of how it's transported or who\n * decides what to do about it.\n *\n * A code is a single integer: the leading digit(s) are the **category** (the\n * error's domain) and the trailing three are the **index** (the specific error\n * within it). Four digits for natively-defined errors, five when an external\n * standard is embedded — `\"03404\"` is an HTTP 404 under the network category.\n * Categories are `0` unknown, `1` media content, `2` playback, `3` network,\n * `4` content protection, `5` accessibility, `6` remote play, `7` advertising,\n * `99` custom.\n *\n * Two properties of the spec shape the types here:\n *\n * - **Severity is deliberately not part of a code.** Per §Approach, \"impact\n *   varies with player implementation, breaking the consistency of a specific\n *   error mapping to single code.\" So an error carries no fatal flag — whether a\n *   condition is fatal depends on the composition observing it, and is decided\n *   downstream.\n * - **Reporting is partial and stacked** (Principles 5–6). Errors are reported\n *   as encountered, most of them non-fatal, and the *sequence* carries causation\n *   a single value can't.\n *\n * See `internal/design/spf/features/errors.md`.\n */\n\n/**\n * A reported condition, identified by its SVTA code.\n *\n * Named for the spec rather than the engine because the vocabulary is\n * format- and player-neutral. Not `MediaError` — that name belongs to the\n * `@videojs/media` DOM-facing class this eventually maps *onto*, and the mapping\n * is the point at which severity and user-facing text get decided.\n */\nexport interface SvtaError {\n  /** The SVTA code — see {@link svtaCategory} / {@link svtaIndex}. */\n  code: number;\n  /** Engineer-facing detail. Optional; the code is the identity. */\n  message?: string;\n  /** Reporter-specific context (track type, url, the constraint that fired). */\n  data?: unknown;\n}\n\n/** SVTA 1 [Media Content] 004 — the video is in a format we can't play (e.g. an MPEG-TS container). */\nexport const SVTA_UNSUPPORTED_VIDEO_FORMAT = 1004;\n\n/** SVTA 1 [Media Content] 005 — the audio counterpart of {@link SVTA_UNSUPPORTED_VIDEO_FORMAT}. */\nexport const SVTA_UNSUPPORTED_AUDIO_FORMAT = 1005;\n\n/**\n * SVTA 4 [Content Protection] 008 — unsupported or unavailable DRM system. Used\n * for \"this source is encrypted and we have no decryption pipeline,\" which is\n * detection, not a license failure.\n */\nexport const SVTA_UNSUPPORTED_DRM_SYSTEM = 4008;\n\n/**\n * SVTA 2 [Playback] 011 — no video track the environment can play.\n *\n * Covers both ways a composition can end up with nothing to select: renditions\n * that existed and were all excluded as unplayable, and — where the composition\n * composes `reportAbsentTrackType` to say it needs the type — a source carrying\n * none to begin with. Deliberately one code for both, because they are the same\n * answer to a viewer, and because the alternative is a code the SVTA spec doesn't\n * define. Whether an absent type is a failure is the composition's to state,\n * which is why it opts in rather than being read off the source.\n */\nexport const SVTA_NO_SUPPORTED_VIDEO_TRACK = 2011;\n\n/** SVTA 2 [Playback] 012 — the audio counterpart of {@link SVTA_NO_SUPPORTED_VIDEO_TRACK}. */\nexport const SVTA_NO_SUPPORTED_AUDIO_TRACK = 2012;\n\n/**\n * SVTA 99 [Custom] 001 — this engine has no pipeline for something the source\n * requires, so the source is unplayable *here* rather than broken.\n *\n * Custom rather than standard because the standard codes available describe\n * either narrower or wider things. The causes (1004/1005 unsupported format,\n * 4008 unsupported DRM) say what one rendition hit; the verdicts (2011/2012 no\n * supported track) say a type emptied without saying why it's unfixable. And\n * 2039 \"Manifest feature unsupported\" covers features that are unsupported but\n * still *playable* — LL-HLS degrading to standard live is a 2039 — so\n * overloading it for a fatal condition would make it useless for the notices it\n * belongs on.\n *\n * Index `001`: the spec defines only `99000` (Unknown) for the custom category\n * and leaves the rest to the publisher, so this is the first code we define.\n *\n * Five digits, and deliberately not special-cased anywhere: {@link svtaCategory}\n * and {@link svtaIndex} decompose it correctly by arithmetic alone, because\n * every standard category is below `8000` and custom starts at `99000`.\n */\nexport const SVTA_UNSUPPORTED_PLAYBACK_FEATURE = 99001;\n\n/**\n * The error's domain — `code / 1000`, per the spec's \"divide by one thousand to\n * obtain the error category\". Works uniformly across the four-digit native form\n * and the five-digit form embedding an external standard: `\"03404\"` is\n * numerically 3404, which decomposes identically. That also makes a numeric code\n * immune to the spec's inconsistent zero-padding (§Approach writes a\n * category-unknown network error as `\"0300\"` where the error index implies\n * category 3 / index 000).\n */\nexport function svtaCategory(code: number): number {\n  return Math.floor(code / 1000);\n}\n\n/**\n * The specific error within its category — `code % 1000`. For a five-digit code\n * this is the embedded external value (an HTTP status, a VAST code).\n */\nexport function svtaIndex(code: number): number {\n  return code % 1000;\n}\n"],"mappings":";;AA6CA,MAAa,gCAAgC;;AAG7C,MAAa,gCAAgC;;;;;;AAO7C,MAAa,8BAA8B;;;;;;;;;;;;AAa3C,MAAa,gCAAgC;;AAG7C,MAAa,gCAAgC;;;;;;;;;;;;;;;;;;;;;AAsB7C,MAAa,oCAAoC;;;;;;;;;;AAWjD,SAAgB,aAAa,MAAsB;CACjD,OAAO,KAAK,MAAM,OAAO,GAAI;AAC/B;;;;;AAMA,SAAgB,UAAU,MAAsB;CAC9C,OAAO,OAAO;AAChB"}

package/dist/dev/media/hls/parse-attributes.js

@@ -0,0 +1,148 @@
+//#region src/media/hls/parse-attributes.ts
+/**
+* Parse HLS attribute list from a tag line.
+* Handles both quoted and unquoted values.
+*/
+function parseAttributeList(line) {
+	const attributes = /* @__PURE__ */ new Map();
+	for (const match of line.matchAll(/([A-Z0-9-]+)=(?:"([^"]*)"|([^,]*))/g)) {
+		const key = match[1];
+		const value = match[2] ?? match[3] ?? "";
+		if (key) attributes.set(key, value);
+	}
+	return attributes;
+}
+/**
+* Parse RESOLUTION attribute value (WIDTHxHEIGHT).
+*/
+function parseResolution(value) {
+	const match = /^(\d+)x(\d+)$/.exec(value);
+	if (!match) return null;
+	return {
+		width: Number.parseInt(match[1], 10),
+		height: Number.parseInt(match[2], 10)
+	};
+}
+/**
+* Parse FRAME-RATE attribute to rational frame rate.
+*/
+function parseFrameRate(value) {
+	const fps = Number.parseFloat(value);
+	if (Number.isNaN(fps) || fps <= 0) return void 0;
+	if (Math.abs(fps - 23.976) < .01) return {
+		frameRateNumerator: 24e3,
+		frameRateDenominator: 1001
+	};
+	if (Math.abs(fps - 29.97) < .01) return {
+		frameRateNumerator: 3e4,
+		frameRateDenominator: 1001
+	};
+	if (Math.abs(fps - 59.94) < .01) return {
+		frameRateNumerator: 6e4,
+		frameRateDenominator: 1001
+	};
+	if (fps % 1 === 0) return { frameRateNumerator: Math.round(fps) };
+	return { frameRateNumerator: Math.round(fps) };
+}
+const AUDIO_CODEC_PREFIXES = [
+	"mp4a.",
+	"ac-3",
+	"ec-3",
+	"ac-4",
+	"opus",
+	"flac",
+	"dts",
+	"alac",
+	"vorbis"
+];
+/**
+* Parse CODECS attribute into separate video and audio codecs.
+*/
+function parseCodecs(codecs) {
+	const parts = codecs.split(",").map((s) => s.trim());
+	const result = {};
+	for (const codec of parts) {
+		const lower = codec.toLowerCase();
+		if (codec.startsWith("avc1.") || codec.startsWith("hvc1.") || codec.startsWith("hev1.")) result.video = codec;
+		else if (AUDIO_CODEC_PREFIXES.some((prefix) => lower.startsWith(prefix))) result.audio = codec;
+	}
+	return result;
+}
+/**
+* Parse #EXTINF duration value.
+*/
+function parseExtInfDuration(value) {
+	const durationPart = value.split(",")[0] ?? value;
+	const duration = Number.parseFloat(durationPart);
+	return Number.isNaN(duration) ? 0 : duration;
+}
+/**
+* Parse BYTERANGE attribute value.
+* Format: "length[@offset]"
+* If offset is omitted, it continues from the previous byte range end.
+*/
+function parseByteRange(value, previousEnd) {
+	const match = /^(\d+)(?:@(\d+))?$/.exec(value);
+	if (!match) return null;
+	const length = Number.parseInt(match[1], 10);
+	if (Number.isNaN(length)) return null;
+	let start;
+	if (match[2] !== void 0) {
+		start = Number.parseInt(match[2], 10);
+		if (Number.isNaN(start)) return null;
+	} else if (previousEnd !== void 0) start = previousEnd;
+	else return null;
+	return {
+		start,
+		end: start + length - 1
+	};
+}
+/**
+* Create AttributeList from raw attribute string.
+*/
+function createAttributeList(line) {
+	const map = parseAttributeList(line);
+	return {
+		get(key) {
+			return map.get(key);
+		},
+		getInt(key, defaultValue) {
+			const value = map.get(key);
+			if (value === void 0) return defaultValue;
+			const parsed = Number.parseInt(value, 10);
+			return Number.isNaN(parsed) ? defaultValue : parsed;
+		},
+		getFloat(key, defaultValue) {
+			const value = map.get(key);
+			if (value === void 0) return defaultValue;
+			const parsed = Number.parseFloat(value);
+			return Number.isNaN(parsed) ? defaultValue : parsed;
+		},
+		getBool(key) {
+			return map.get(key) === "YES";
+		},
+		getResolution(key) {
+			const value = map.get(key);
+			if (!value) return void 0;
+			return parseResolution(value) ?? void 0;
+		},
+		getFrameRate(key) {
+			const value = map.get(key);
+			if (!value) return void 0;
+			return parseFrameRate(value);
+		}
+	};
+}
+/**
+* Match a tag and extract its attributes.
+* Returns null if the line doesn't match the tag.
+*/
+function matchTag(line, tag) {
+	const prefix = `#${tag}:`;
+	if (!line.startsWith(prefix)) return null;
+	return createAttributeList(line.slice(prefix.length));
+}
+//#endregion
+export { createAttributeList, matchTag, parseAttributeList, parseByteRange, parseCodecs, parseExtInfDuration, parseFrameRate, parseResolution };
+
+//# sourceMappingURL=parse-attributes.js.map

package/dist/dev/media/hls/parse-attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-attributes.js","names":[],"sources":["../../../../src/media/hls/parse-attributes.ts"],"sourcesContent":["import type { FrameRate } from '../types';\n\n/**\n * Parse HLS attribute list from a tag line.\n * Handles both quoted and unquoted values.\n */\nexport function parseAttributeList(line: string): Map<string, string> {\n  const attributes = new Map<string, string>();\n  const regex = /([A-Z0-9-]+)=(?:\"([^\"]*)\"|([^,]*))/g;\n\n  for (const match of line.matchAll(regex)) {\n    const key = match[1];\n    const value = match[2] ?? match[3] ?? '';\n    if (key) {\n      attributes.set(key, value);\n    }\n  }\n\n  return attributes;\n}\n\n/**\n * Parse RESOLUTION attribute value (WIDTHxHEIGHT).\n */\nexport function parseResolution(value: string): { width: number; height: number } | null {\n  const match = /^(\\d+)x(\\d+)$/.exec(value);\n  if (!match) return null;\n\n  const width = Number.parseInt(match[1]!, 10);\n  const height = Number.parseInt(match[2]!, 10);\n\n  return { width, height };\n}\n\n/**\n * Parse FRAME-RATE attribute to rational frame rate.\n */\nexport function parseFrameRate(value: string): FrameRate | undefined {\n  const fps = Number.parseFloat(value);\n  if (Number.isNaN(fps) || fps <= 0) return undefined;\n\n  // Common frame rates with tolerance for floating point precision\n  if (Math.abs(fps - 23.976) < 0.01) {\n    return { frameRateNumerator: 24000, frameRateDenominator: 1001 };\n  }\n  if (Math.abs(fps - 29.97) < 0.01) {\n    return { frameRateNumerator: 30000, frameRateDenominator: 1001 };\n  }\n  if (Math.abs(fps - 59.94) < 0.01) {\n    return { frameRateNumerator: 60000, frameRateDenominator: 1001 };\n  }\n\n  // Integer frame rates\n  if (fps % 1 === 0) {\n    return { frameRateNumerator: Math.round(fps) };\n  }\n\n  // Default: use rounded value\n  return { frameRateNumerator: Math.round(fps) };\n}\n\n// Audio codec identifiers, matched case-insensitively against each CODECS\n// entry's prefix. Beyond AAC (`mp4a.*`): Dolby (`ac-3`, `ec-3`, `ac-4`), Opus,\n// FLAC (`fLaC`), DTS (`dts*`), ALAC, and Vorbis. Recognizing these is what lets\n// capability probing filter undecodable audio renditions (e.g. an AC-3 5.1\n// track on a browser without AC-3) — an unrecognized codec parses empty and is\n// treated as unprobeable, so it would never be pruned.\nconst AUDIO_CODEC_PREFIXES = ['mp4a.', 'ac-3', 'ec-3', 'ac-4', 'opus', 'flac', 'dts', 'alac', 'vorbis'];\n\n/**\n * Parse CODECS attribute into separate video and audio codecs.\n */\nexport function parseCodecs(codecs: string): { video?: string; audio?: string } {\n  const parts = codecs.split(',').map((s) => s.trim());\n  const result: { video?: string; audio?: string } = {};\n\n  for (const codec of parts) {\n    const lower = codec.toLowerCase();\n    if (codec.startsWith('avc1.') || codec.startsWith('hvc1.') || codec.startsWith('hev1.')) {\n      result.video = codec;\n    } else if (AUDIO_CODEC_PREFIXES.some((prefix) => lower.startsWith(prefix))) {\n      result.audio = codec;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse #EXTINF duration value.\n */\nexport function parseExtInfDuration(value: string): number {\n  const durationPart = value.split(',')[0] ?? value;\n  const duration = Number.parseFloat(durationPart);\n  return Number.isNaN(duration) ? 0 : duration;\n}\n\n/**\n * Parse BYTERANGE attribute value.\n * Format: \"length[@offset]\"\n * If offset is omitted, it continues from the previous byte range end.\n */\nexport function parseByteRange(value: string, previousEnd?: number): { start: number; end: number } | null {\n  const match = /^(\\d+)(?:@(\\d+))?$/.exec(value);\n  if (!match) return null;\n\n  const length = Number.parseInt(match[1]!, 10);\n  if (Number.isNaN(length)) return null;\n\n  let start: number;\n  if (match[2] !== undefined) {\n    start = Number.parseInt(match[2], 10);\n    if (Number.isNaN(start)) return null;\n  } else if (previousEnd !== undefined) {\n    start = previousEnd;\n  } else {\n    return null;\n  }\n\n  return { start, end: start + length - 1 };\n}\n\n/**\n * AttributeList - Typed attribute access wrapper.\n */\nexport interface AttributeList {\n  get: (key: string) => string | undefined;\n  getInt: (key: string, defaultValue?: number) => number | undefined;\n  getFloat: (key: string, defaultValue?: number) => number | undefined;\n  getBool: (key: string) => boolean;\n  getResolution: (key: string) => { width: number; height: number } | undefined;\n  getFrameRate: (key: string) => FrameRate | undefined;\n}\n\n/**\n * Create AttributeList from raw attribute string.\n */\nexport function createAttributeList(line: string): AttributeList {\n  const map = parseAttributeList(line);\n\n  return {\n    get(key: string): string | undefined {\n      return map.get(key);\n    },\n\n    getInt(key: string, defaultValue?: number): number | undefined {\n      const value = map.get(key);\n      if (value === undefined) return defaultValue;\n      const parsed = Number.parseInt(value, 10);\n      return Number.isNaN(parsed) ? defaultValue : parsed;\n    },\n\n    getFloat(key: string, defaultValue?: number): number | undefined {\n      const value = map.get(key);\n      if (value === undefined) return defaultValue;\n      const parsed = Number.parseFloat(value);\n      return Number.isNaN(parsed) ? defaultValue : parsed;\n    },\n\n    getBool(key: string): boolean {\n      return map.get(key) === 'YES';\n    },\n\n    getResolution(key: string): { width: number; height: number } | undefined {\n      const value = map.get(key);\n      if (!value) return undefined;\n      return parseResolution(value) ?? undefined;\n    },\n\n    getFrameRate(key: string): FrameRate | undefined {\n      const value = map.get(key);\n      if (!value) return undefined;\n      return parseFrameRate(value);\n    },\n  };\n}\n\n/**\n * Match a tag and extract its attributes.\n * Returns null if the line doesn't match the tag.\n */\nexport function matchTag(line: string, tag: string): AttributeList | null {\n  const prefix = `#${tag}:`;\n  if (!line.startsWith(prefix)) return null;\n  return createAttributeList(line.slice(prefix.length));\n}\n"],"mappings":"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"}

package/dist/dev/media/hls/parse-media-playlist.js

@@ -0,0 +1,261 @@
+import { MEDIA_PLAYLIST_METADATA_KEY, getMediaPlaylistMetadata, isResolvedTrack } from "../types/index.js";
+import { matchTag, parseByteRange, parseExtInfDuration } from "./parse-attributes.js";
+import { resolveUrl } from "./resolve-url.js";
+import { isUndefined } from "@videojs/utils/predicate";
+//#region src/media/hls/parse-media-playlist.ts
+/** MPEG-2 Transport Stream (IANA `video/MP2T`, lowercased for `isTypeSupported`). Video + audio TS — there is no `audio/mp2t`. */
+const MPEG_TS_MIME = "video/mp2t";
+/** Raw ADTS AAC packed-audio (HLS `.aac` segments; IANA `audio/aac`). */
+const RAW_AAC_MIME = "audio/aac";
+const CONTAINER_MIME_BY_EXTENSION = {
+	".ts": MPEG_TS_MIME,
+	".aac": RAW_AAC_MIME
+};
+/** The non-fMP4 container MIMEs the parser detects — all currently treated as unplayable. */
+const NON_FMP4_CONTAINER_MIMES = new Set(Object.values(CONTAINER_MIME_BY_EXTENSION));
+/**
+* Non-fMP4 container MIME for a (resolved, absolute) segment URL, by file
+* extension, ignoring the query string. `undefined` for fMP4 / unrecognized.
+*/
+function containerMimeFromSegment(url) {
+	if (!url) return void 0;
+	let path;
+	try {
+		path = new URL(url).pathname.toLowerCase();
+	} catch {
+		path = url.toLowerCase().split("?")[0] ?? "";
+	}
+	const dot = path.lastIndexOf(".");
+	return dot === -1 ? void 0 : CONTAINER_MIME_BY_EXTENSION[path.slice(dot)];
+}
+/**
+* Position a freshly-parsed window (whose segment `startTime`s are snapshot-
+* local, i.e. from 0) onto the timeline established by the previous resolved
+* snapshot. Carries the timeline forward using the media-sequence overlap and
+* the previous window's *actual* segment durations — see
+* `internal/design/spf/live-presentation-timeline-model.md`.
+*
+* - **Overlap** (`0 <= offset < previous.segments.length`): the new window's
+*   first segment is the same segment as `previous.segments[offset]`; anchor to
+*   its start (URLs checked — a mismatch warns).
+* - **Sequence went backwards** (non-conformant): reset to the local base.
+* - **Full turnover** (no overlap): estimate forward from the previous window's
+*   end across the unseen gap. This is the *only* place EXT-X-TARGETDURATION is
+*   used for timing — an upper-bound estimate, since the actual rolled-off
+*   durations are gone (exact recovery is the deferred PDT decision).
+*
+* Returns the rebased segments (the window edge is `segments[0].startTime`,
+* derived — never stored on the track).
+*/
+function placeOnPreviousTimeline(previous, segments, mediaSequence, targetDuration) {
+	const prevSegments = previous.segments;
+	const localBase = segments[0]?.startTime ?? 0;
+	if (prevSegments.length === 0 || segments.length === 0) return segments;
+	const offset = mediaSequence - (getMediaPlaylistMetadata(previous)?.mediaSequence ?? 0);
+	let anchor;
+	if (offset >= 0 && offset < prevSegments.length) {
+		const overlap = prevSegments[offset];
+		if (overlap.url !== segments[0].url) console.warn(`[parseMediaPlaylist] media-sequence aligns previous[${offset}] with the new window's first segment, but URLs differ (${overlap.url} vs ${segments[0].url}); sequence numbers may be unreliable.`);
+		anchor = overlap.startTime;
+	} else if (offset < 0) {
+		console.warn(`[parseMediaPlaylist] media-sequence went backwards (offset ${offset}); resetting timeline.`);
+		anchor = localBase;
+	} else {
+		const last = prevSegments[prevSegments.length - 1];
+		const newFirst = segments[0];
+		if (last.startDate !== void 0 && newFirst.startDate !== void 0) anchor = last.startTime + (newFirst.startDate - last.startDate);
+		else {
+			anchor = last.startTime + last.duration + (offset - prevSegments.length) * targetDuration;
+			console.warn(`[parseMediaPlaylist] full window turnover (offset ${offset} >= ${prevSegments.length}); no PDT to bridge — estimating from previous end.`);
+		}
+	}
+	const shift = anchor - localBase;
+	return shift === 0 ? segments : segments.map((segment) => ({
+		...segment,
+		startTime: segment.startTime + shift
+	}));
+}
+/**
+* Place a window on the frozen wall-clock anchor — the track's `startDate`
+* (wall clock at media-time 0). The anchoring PDT-bearing segment lands at
+* `segment.startDate − anchor`, so the window sits on the shared presentation
+* timeline rather than a local-from-zero one (the `startDate` recomputed
+* afterwards then reads back as the anchor — idempotent). This is the **main
+* live path on every parse**: first resolves place against the pre-stamped
+* shell anchor, and reloads re-place from PDT so drift can't accumulate and a
+* long-stall turnover re-places with no overlap bridging (the HLS authoring
+* spec's §8.1 EXTINF-accuracy rule bounds the per-reload correction to ~one
+* video frame). Falls back to the local base when no segment carries PDT —
+* there's nothing to anchor against (callers guard this for reloads, where the
+* local base would reset the timeline).
+*/
+function placeOnAnchor(segments, anchor) {
+	const anchorSegment = segments.find((segment) => !isUndefined(segment.startDate));
+	if (!anchorSegment || isUndefined(anchorSegment.startDate)) return segments;
+	const shift = anchorSegment.startDate - anchor - anchorSegment.startTime;
+	if (shift === 0) return segments;
+	return segments.map((segment) => ({
+		...segment,
+		startTime: segment.startTime + shift
+	}));
+}
+/**
+* Parse HLS media playlist and resolve track with segments.
+*
+* `previous` is what was known about this track before this parse: the
+* partially-resolved track from the multivariant playlist on the first resolve,
+* or the previously-resolved snapshot on a live reload. Its metadata is carried
+* onto the result either way; when it's already resolved (has segments), its
+* timeline is carried forward so the new window lands on a stable, advancing
+* timeline (see {@link placeOnPreviousTimeline}).
+*
+* @param text - Media playlist text content
+* @param previous - Prior track state (unresolved shell, or previous resolved snapshot)
+* @returns Resolved track with segments (type inferred from input)
+*/
+function parseMediaPlaylist(text, previous) {
+	const lines = text.split(/\r?\n/);
+	const baseUrl = previous.url;
+	const segments = [];
+	let initSegmentUrl;
+	let initSegmentByteRange;
+	let currentDuration = 0;
+	let currentByteRange;
+	let currentTime = 0;
+	let segmentIndex = 0;
+	let previousByteRangeEnd;
+	let currentStartDate;
+	let targetDuration = 0;
+	let mediaSequence = 0;
+	let playlistType;
+	let endList = false;
+	let holdBack;
+	let lowLatency = false;
+	let encrypted = false;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#") && !trimmed.startsWith("#EXT")) continue;
+		if (trimmed.startsWith("#EXT-X-TARGETDURATION:")) {
+			targetDuration = Number.parseInt(trimmed.slice(22), 10) || 0;
+			continue;
+		}
+		if (trimmed.startsWith("#EXT-X-MEDIA-SEQUENCE:")) {
+			mediaSequence = Number.parseInt(trimmed.slice(22), 10) || 0;
+			continue;
+		}
+		if (trimmed.startsWith("#EXT-X-PROGRAM-DATE-TIME:")) {
+			const parsed = Date.parse(trimmed.slice(25).trim());
+			currentStartDate = Number.isNaN(parsed) ? currentStartDate : parsed / 1e3;
+			continue;
+		}
+		if (trimmed.startsWith("#EXT-X-PLAYLIST-TYPE:")) {
+			const value = trimmed.slice(21).trim();
+			playlistType = value === "VOD" || value === "EVENT" ? value : void 0;
+			continue;
+		}
+		const key = matchTag(trimmed, "EXT-X-KEY");
+		if (key) {
+			const method = key.get("METHOD");
+			if (method !== void 0 && method !== "NONE") encrypted = true;
+			continue;
+		}
+		const serverControl = matchTag(trimmed, "EXT-X-SERVER-CONTROL");
+		if (serverControl) {
+			const value = serverControl.get("HOLD-BACK");
+			if (value !== void 0) {
+				const parsed = Number.parseFloat(value);
+				if (Number.isFinite(parsed) && parsed > 0) holdBack = parsed;
+			}
+			if (serverControl.get("PART-HOLD-BACK") !== void 0) lowLatency = true;
+			continue;
+		}
+		if (trimmed.startsWith("#EXT-X-PART-INF") || trimmed.startsWith("#EXT-X-PART:")) {
+			lowLatency = true;
+			continue;
+		}
+		if (trimmed === "#EXTM3U" || trimmed.startsWith("#EXT-X-VERSION:") || trimmed.startsWith("#EXT-X-INDEPENDENT-SEGMENTS")) continue;
+		const mapAttrs = matchTag(trimmed, "EXT-X-MAP");
+		if (mapAttrs) {
+			const uri = mapAttrs.get("URI");
+			if (uri) {
+				initSegmentUrl = resolveUrl(uri, baseUrl);
+				const byteRangeStr = mapAttrs.get("BYTERANGE");
+				if (byteRangeStr) initSegmentByteRange = parseByteRange(byteRangeStr, 0) ?? void 0;
+			}
+			continue;
+		}
+		if (trimmed.startsWith("#EXTINF:")) {
+			currentDuration = parseExtInfDuration(trimmed.slice(8));
+			continue;
+		}
+		if (trimmed.startsWith("#EXT-X-BYTERANGE:")) {
+			currentByteRange = parseByteRange(trimmed.slice(17), previousByteRangeEnd) ?? void 0;
+			continue;
+		}
+		if (trimmed === "#EXT-X-ENDLIST") {
+			endList = true;
+			continue;
+		}
+		if (!trimmed.startsWith("#") && currentDuration > 0) {
+			const segment = {
+				id: `segment-${mediaSequence + segmentIndex}`,
+				url: resolveUrl(trimmed, baseUrl),
+				duration: currentDuration,
+				startTime: currentTime
+			};
+			if (!isUndefined(currentStartDate)) {
+				segment.startDate = currentStartDate;
+				currentStartDate += currentDuration;
+			}
+			if (currentByteRange) {
+				segment.byteRange = currentByteRange;
+				previousByteRangeEnd = currentByteRange.end + 1;
+			} else previousByteRangeEnd = void 0;
+			segments.push(segment);
+			currentTime += currentDuration;
+			segmentIndex++;
+			currentDuration = 0;
+			currentByteRange = void 0;
+		}
+	}
+	const complete = endList || playlistType === "VOD";
+	const anchor = previous.startDate;
+	const hasPdt = segments.some((segment) => !isUndefined(segment.startDate));
+	const placed = !isUndefined(anchor) && hasPdt ? placeOnAnchor(segments, anchor) : isResolvedTrack(previous) ? placeOnPreviousTimeline(previous, segments, mediaSequence, targetDuration) : segments;
+	const lastPlaced = placed[placed.length - 1];
+	const placedEnd = lastPlaced ? lastPlaced.startTime + lastPlaced.duration : 0;
+	const trackDuration = complete ? placedEnd : Number.POSITIVE_INFINITY;
+	const anchorSegment = placed.find((segment) => !isUndefined(segment.startDate));
+	const startDate = anchorSegment && !isUndefined(anchorSegment.startDate) ? anchorSegment.startDate - anchorSegment.startTime : void 0;
+	const initialization = previous.type === "text" && !initSegmentUrl ? void 0 : initSegmentUrl ? {
+		url: initSegmentUrl,
+		...initSegmentByteRange ? { byteRange: initSegmentByteRange } : {}
+	} : { url: "" };
+	const detectedContainer = initSegmentUrl ? void 0 : containerMimeFromSegment(placed[0]?.url);
+	const mimeType = previous.type !== "text" && detectedContainer ? detectedContainer : previous.mimeType;
+	return {
+		...previous,
+		mimeType,
+		startTime: 0,
+		startDate,
+		duration: trackDuration,
+		segments: placed,
+		initialization,
+		metadata: {
+			...previous.metadata,
+			[MEDIA_PLAYLIST_METADATA_KEY]: {
+				targetDuration,
+				mediaSequence,
+				playlistType,
+				lowLatency,
+				endList,
+				holdBack,
+				encrypted
+			}
+		}
+	};
+}
+//#endregion
+export { MPEG_TS_MIME, NON_FMP4_CONTAINER_MIMES, RAW_AAC_MIME, parseMediaPlaylist };
+
+//# sourceMappingURL=parse-media-playlist.js.map

package/dist/dev/media/hls/parse-media-playlist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-media-playlist.js","names":[],"sources":["../../../../src/media/hls/parse-media-playlist.ts"],"sourcesContent":["import { isUndefined } from '@videojs/utils/predicate';\nimport {\n  type AudioTrack,\n  getMediaPlaylistMetadata,\n  isResolvedTrack,\n  MEDIA_PLAYLIST_METADATA_KEY,\n  type MediaPlaylistMetadata,\n  type PartiallyResolvedAudioTrack,\n  type PartiallyResolvedTextTrack,\n  type PartiallyResolvedTrack,\n  type PartiallyResolvedVideoTrack,\n  type ResolvedTrack,\n  type Segment,\n  type TextTrack,\n  type VideoTrack,\n} from '../types';\nimport { matchTag, parseByteRange, parseExtInfDuration } from './parse-attributes';\nimport { resolveUrl } from './resolve-url';\n\n/** MPEG-2 Transport Stream (IANA `video/MP2T`, lowercased for `isTypeSupported`). Video + audio TS — there is no `audio/mp2t`. */\nexport const MPEG_TS_MIME = 'video/mp2t';\n/** Raw ADTS AAC packed-audio (HLS `.aac` segments; IANA `audio/aac`). */\nexport const RAW_AAC_MIME = 'audio/aac';\n\n// Non-fMP4 container MIMEs keyed by segment file extension. fMP4 (the MSE\n// default) always carries an EXT-X-MAP init segment, so a media playlist with\n// no init segment and one of these extensions is a non-fMP4 rendition,\n// relabeled from the fMP4 default. Extend with `.mp3` → 'audio/mpeg' etc.\nconst CONTAINER_MIME_BY_EXTENSION: Record<string, string> = {\n  '.ts': MPEG_TS_MIME,\n  '.aac': RAW_AAC_MIME,\n};\n\n/** The non-fMP4 container MIMEs the parser detects — all currently treated as unplayable. */\nexport const NON_FMP4_CONTAINER_MIMES = new Set(Object.values(CONTAINER_MIME_BY_EXTENSION));\n\n/**\n * Non-fMP4 container MIME for a (resolved, absolute) segment URL, by file\n * extension, ignoring the query string. `undefined` for fMP4 / unrecognized.\n */\nfunction containerMimeFromSegment(url: string | undefined): string | undefined {\n  if (!url) return undefined;\n  let path: string;\n  try {\n    path = new URL(url).pathname.toLowerCase();\n  } catch {\n    path = url.toLowerCase().split('?')[0] ?? '';\n  }\n  const dot = path.lastIndexOf('.');\n  return dot === -1 ? undefined : CONTAINER_MIME_BY_EXTENSION[path.slice(dot)];\n}\n\n/**\n * Resolve unresolved track type to its resolved equivalent.\n */\ntype ResolveTrack<T> = T extends PartiallyResolvedVideoTrack\n  ? VideoTrack\n  : T extends PartiallyResolvedAudioTrack\n    ? AudioTrack\n    : T extends PartiallyResolvedTextTrack\n      ? TextTrack\n      : never;\n\n/**\n * Position a freshly-parsed window (whose segment `startTime`s are snapshot-\n * local, i.e. from 0) onto the timeline established by the previous resolved\n * snapshot. Carries the timeline forward using the media-sequence overlap and\n * the previous window's *actual* segment durations — see\n * `internal/design/spf/live-presentation-timeline-model.md`.\n *\n * - **Overlap** (`0 <= offset < previous.segments.length`): the new window's\n *   first segment is the same segment as `previous.segments[offset]`; anchor to\n *   its start (URLs checked — a mismatch warns).\n * - **Sequence went backwards** (non-conformant): reset to the local base.\n * - **Full turnover** (no overlap): estimate forward from the previous window's\n *   end across the unseen gap. This is the *only* place EXT-X-TARGETDURATION is\n *   used for timing — an upper-bound estimate, since the actual rolled-off\n *   durations are gone (exact recovery is the deferred PDT decision).\n *\n * Returns the rebased segments (the window edge is `segments[0].startTime`,\n * derived — never stored on the track).\n */\nfunction placeOnPreviousTimeline(\n  previous: ResolvedTrack,\n  segments: Segment[],\n  mediaSequence: number,\n  targetDuration: number\n): Segment[] {\n  const prevSegments = previous.segments;\n  const localBase = segments[0]?.startTime ?? 0;\n\n  if (prevSegments.length === 0 || segments.length === 0) {\n    return segments;\n  }\n\n  const prevMediaSequence = getMediaPlaylistMetadata(previous)?.mediaSequence ?? 0;\n  const offset = mediaSequence - prevMediaSequence;\n\n  let anchor: number;\n  if (offset >= 0 && offset < prevSegments.length) {\n    const overlap = prevSegments[offset]!;\n    if (overlap.url !== segments[0]!.url) {\n      console.warn(\n        `[parseMediaPlaylist] media-sequence aligns previous[${offset}] with the new window's first segment, ` +\n          `but URLs differ (${overlap.url} vs ${segments[0]!.url}); sequence numbers may be unreliable.`\n      );\n    }\n    anchor = overlap.startTime;\n  } else if (offset < 0) {\n    console.warn(`[parseMediaPlaylist] media-sequence went backwards (offset ${offset}); resetting timeline.`);\n    anchor = localBase;\n  } else {\n    const last = prevSegments[prevSegments.length - 1]!;\n    const newFirst = segments[0]!;\n    if (last.startDate !== undefined && newFirst.startDate !== undefined) {\n      // PDT bridges the gap exactly — the spec-consistent cross-reload reference,\n      // immune to the target-duration over-estimate when actual segment durations\n      // differ from the declared ceiling. (`startDate` is intrinsic PDT, unaffected\n      // by the new window's local positioning.)\n      anchor = last.startTime + (newFirst.startDate - last.startDate);\n    } else {\n      anchor = last.startTime + last.duration + (offset - prevSegments.length) * targetDuration;\n      console.warn(\n        `[parseMediaPlaylist] full window turnover (offset ${offset} >= ${prevSegments.length}); ` +\n          'no PDT to bridge — estimating from previous end.'\n      );\n    }\n  }\n\n  const shift = anchor - localBase;\n  return shift === 0 ? segments : segments.map((segment) => ({ ...segment, startTime: segment.startTime + shift }));\n}\n\n/**\n * Place a window on the frozen wall-clock anchor — the track's `startDate`\n * (wall clock at media-time 0). The anchoring PDT-bearing segment lands at\n * `segment.startDate − anchor`, so the window sits on the shared presentation\n * timeline rather than a local-from-zero one (the `startDate` recomputed\n * afterwards then reads back as the anchor — idempotent). This is the **main\n * live path on every parse**: first resolves place against the pre-stamped\n * shell anchor, and reloads re-place from PDT so drift can't accumulate and a\n * long-stall turnover re-places with no overlap bridging (the HLS authoring\n * spec's §8.1 EXTINF-accuracy rule bounds the per-reload correction to ~one\n * video frame). Falls back to the local base when no segment carries PDT —\n * there's nothing to anchor against (callers guard this for reloads, where the\n * local base would reset the timeline).\n */\nfunction placeOnAnchor(segments: Segment[], anchor: number): Segment[] {\n  const anchorSegment = segments.find((segment) => !isUndefined(segment.startDate));\n  if (!anchorSegment || isUndefined(anchorSegment.startDate)) {\n    return segments;\n  }\n\n  const shift = anchorSegment.startDate - anchor - anchorSegment.startTime;\n  if (shift === 0) {\n    return segments;\n  }\n\n  return segments.map((segment) => ({ ...segment, startTime: segment.startTime + shift }));\n}\n\n/**\n * Parse HLS media playlist and resolve track with segments.\n *\n * `previous` is what was known about this track before this parse: the\n * partially-resolved track from the multivariant playlist on the first resolve,\n * or the previously-resolved snapshot on a live reload. Its metadata is carried\n * onto the result either way; when it's already resolved (has segments), its\n * timeline is carried forward so the new window lands on a stable, advancing\n * timeline (see {@link placeOnPreviousTimeline}).\n *\n * @param text - Media playlist text content\n * @param previous - Prior track state (unresolved shell, or previous resolved snapshot)\n * @returns Resolved track with segments (type inferred from input)\n */\nexport function parseMediaPlaylist<T extends PartiallyResolvedTrack>(\n  text: string,\n  previous: T | ResolveTrack<T>\n): ResolveTrack<T> {\n  const lines = text.split(/\\r?\\n/);\n\n  // Segments and resources resolve relative to media playlist URL (per HLS spec)\n  const baseUrl = previous.url;\n\n  // Parse playlist\n  const segments: Segment[] = [];\n  let initSegmentUrl: string | undefined;\n  let initSegmentByteRange: { start: number; end: number } | undefined;\n\n  let currentDuration = 0;\n  let currentByteRange: { start: number; end: number } | undefined;\n  let currentTime = 0;\n  let segmentIndex = 0;\n  let previousByteRangeEnd: number | undefined;\n  // Absolute wall-clock of the next segment's first sample, in epoch seconds.\n  // Seeded by an explicit `#EXT-X-PROGRAM-DATE-TIME` (which re-anchors, e.g.\n  // across a discontinuity) and advanced by each segment's duration so segments\n  // without their own tag are interpolated forward (per RFC 8216).\n  let currentStartDate: number | undefined;\n\n  // Playlist-level metadata (surfaced for live reload pacing / merge / termination).\n  let targetDuration = 0;\n  let mediaSequence = 0;\n  let playlistType: 'VOD' | 'EVENT' | undefined;\n  let endList = false;\n  let holdBack: number | undefined;\n  // Low-Latency HLS delivery. Any of the partial-segment tags is enough: the\n  // parser ignores parts and the loader fetches whole segments, so this records\n  // that the publisher configured LL-HLS, not that we honour it.\n  let lowLatency = false;\n  // Any EXT-X-KEY with a real METHOD makes the rendition encrypted. Sticky: a\n  // clear lead (METHOD=NONE first, a real key later) still counts, since we can\n  // only report whether decryption is needed at all.\n  let encrypted = false;\n\n  for (const line of lines) {\n    const trimmed = line.trim();\n\n    if (!trimmed || (trimmed.startsWith('#') && !trimmed.startsWith('#EXT'))) {\n      continue;\n    }\n\n    if (trimmed.startsWith('#EXT-X-TARGETDURATION:')) {\n      targetDuration = Number.parseInt(trimmed.slice('#EXT-X-TARGETDURATION:'.length), 10) || 0;\n      continue;\n    }\n\n    if (trimmed.startsWith('#EXT-X-MEDIA-SEQUENCE:')) {\n      mediaSequence = Number.parseInt(trimmed.slice('#EXT-X-MEDIA-SEQUENCE:'.length), 10) || 0;\n      continue;\n    }\n\n    if (trimmed.startsWith('#EXT-X-PROGRAM-DATE-TIME:')) {\n      const parsed = Date.parse(trimmed.slice('#EXT-X-PROGRAM-DATE-TIME:'.length).trim());\n      currentStartDate = Number.isNaN(parsed) ? currentStartDate : parsed / 1000;\n      continue;\n    }\n\n    if (trimmed.startsWith('#EXT-X-PLAYLIST-TYPE:')) {\n      const value = trimmed.slice('#EXT-X-PLAYLIST-TYPE:'.length).trim();\n      playlistType = value === 'VOD' || value === 'EVENT' ? value : undefined;\n      continue;\n    }\n\n    const key = matchTag(trimmed, 'EXT-X-KEY');\n    if (key) {\n      const method = key.get('METHOD');\n      if (method !== undefined && method !== 'NONE') encrypted = true;\n      continue;\n    }\n\n    // #EXT-X-SERVER-CONTROL — HOLD-BACK supplies the latency target. PART-HOLD-BACK\n    // is read for its presence only, as an LL-HLS signal; see MediaPlaylistMetadata\n    // on why its value stays out of `holdBack` until LL-HLS support lands.\n    const serverControl = matchTag(trimmed, 'EXT-X-SERVER-CONTROL');\n    if (serverControl) {\n      const value = serverControl.get('HOLD-BACK');\n      if (value !== undefined) {\n        const parsed = Number.parseFloat(value);\n        if (Number.isFinite(parsed) && parsed > 0) holdBack = parsed;\n      }\n      // Advertised for clients playing partial segments — its presence is an\n      // LL-HLS signal even though the value stays deliberately unread.\n      if (serverControl.get('PART-HOLD-BACK') !== undefined) lowLatency = true;\n      continue;\n    }\n\n    // Partial segments: noted, then skipped. `#EXT-X-PART` lines would otherwise\n    // fall through as unrecognized `#EXT` tags, so LL-HLS delivery went unnoticed.\n    if (trimmed.startsWith('#EXT-X-PART-INF') || trimmed.startsWith('#EXT-X-PART:')) {\n      lowLatency = true;\n      continue;\n    }\n\n    if (\n      trimmed === '#EXTM3U' ||\n      trimmed.startsWith('#EXT-X-VERSION:') ||\n      trimmed.startsWith('#EXT-X-INDEPENDENT-SEGMENTS')\n    ) {\n      continue;\n    }\n\n    // #EXT-X-MAP - Init segment\n    const mapAttrs = matchTag(trimmed, 'EXT-X-MAP');\n    if (mapAttrs) {\n      const uri = mapAttrs.get('URI');\n      if (uri) {\n        initSegmentUrl = resolveUrl(uri, baseUrl);\n        const byteRangeStr = mapAttrs.get('BYTERANGE');\n        if (byteRangeStr) {\n          initSegmentByteRange = parseByteRange(byteRangeStr, 0) ?? undefined;\n        }\n      }\n      continue;\n    }\n\n    // #EXTINF - Segment duration\n    if (trimmed.startsWith('#EXTINF:')) {\n      currentDuration = parseExtInfDuration(trimmed.slice(8));\n      continue;\n    }\n\n    // #EXT-X-BYTERANGE - Segment byte range\n    if (trimmed.startsWith('#EXT-X-BYTERANGE:')) {\n      currentByteRange = parseByteRange(trimmed.slice(17), previousByteRangeEnd) ?? undefined;\n      continue;\n    }\n\n    if (trimmed === '#EXT-X-ENDLIST') {\n      endList = true;\n      continue;\n    }\n\n    // Segment URI\n    if (!trimmed.startsWith('#') && currentDuration > 0) {\n      const segment: Segment = {\n        id: `segment-${mediaSequence + segmentIndex}`,\n        url: resolveUrl(trimmed, baseUrl),\n        duration: currentDuration,\n        startTime: currentTime,\n      };\n\n      if (!isUndefined(currentStartDate)) {\n        segment.startDate = currentStartDate;\n        // Interpolate forward: the next segment without an explicit tag inherits\n        // this anchor plus this segment's duration.\n        currentStartDate += currentDuration;\n      }\n\n      if (currentByteRange) {\n        segment.byteRange = currentByteRange;\n        previousByteRangeEnd = currentByteRange.end + 1;\n      } else {\n        previousByteRangeEnd = undefined;\n      }\n\n      segments.push(segment);\n      currentTime += currentDuration;\n      segmentIndex++;\n\n      currentDuration = 0;\n      currentByteRange = undefined;\n    }\n  }\n\n  const complete = endList || playlistType === 'VOD';\n\n  // Position this window on the timeline. PDT is primary: whenever the track\n  // carries a wall-clock anchor (`startDate` — pre-stamped on the shell for a\n  // first resolve, recomputed-and-stable for a reload) and the new window has\n  // PDT to place with, place from PDT against that frozen anchor\n  // (`placeOnAnchor`) — self-correcting across reloads, history-free across\n  // turnovers. Media-sequence/EXTINF carry-forward is the fallback for\n  // PDT-less windows; a first resolve with neither anchors at the local base 0.\n  const anchor = previous.startDate;\n  const hasPdt = segments.some((segment) => !isUndefined(segment.startDate));\n  const placed =\n    !isUndefined(anchor) && hasPdt\n      ? placeOnAnchor(segments, anchor)\n      : isResolvedTrack(previous)\n        ? placeOnPreviousTimeline(previous, segments, mediaSequence, targetDuration)\n        : segments;\n\n  // `duration` is the track's duration: Infinity while the playlist can still\n  // grow (unended live), finite once complete (VOD / ENDLIST). Paired with\n  // `startTime: 0` below, it spans the presentation origin to the last placed\n  // segment's end — so it's measured off `placed`, not the local EXTINF sum:\n  // for a window that has slid, the sum is the window's length, not its span.\n  // Never the target duration.\n  const lastPlaced = placed[placed.length - 1];\n  const placedEnd = lastPlaced ? lastPlaced.startTime + lastPlaced.duration : 0;\n  const trackDuration = complete ? placedEnd : Number.POSITIVE_INFINITY;\n\n  // Wall-clock anchor: `startDate − startTime` for the first PDT-bearing\n  // segment (constant along a linear timeline). Maps this track's origin to\n  // wall clock; recomputed each parse, so it stays stable as the window slides\n  // and is comparable across tracks for A/V alignment.\n  const anchorSegment = placed.find((segment) => !isUndefined(segment.startDate));\n  const startDate =\n    anchorSegment && !isUndefined(anchorSegment.startDate)\n      ? anchorSegment.startDate - anchorSegment.startTime\n      : undefined;\n\n  // Build initialization (VTT may not have init segment)\n  const initialization =\n    previous.type === 'text' && !initSegmentUrl\n      ? undefined\n      : initSegmentUrl\n        ? { url: initSegmentUrl, ...(initSegmentByteRange ? { byteRange: initSegmentByteRange } : {}) }\n        : { url: '' };\n\n  // Container detection: fMP4 always carries an EXT-X-MAP init segment, so its\n  // absence plus a recognized non-fMP4 segment extension (`.ts` → MPEG-TS,\n  // `.aac` → raw ADTS AAC) marks a non-fMP4 rendition (high-precision — never\n  // trips on fMP4, which mandates the map). Relabel from the fMP4 default\n  // `video/mp4` / `audio/mp4` to the container MIME so capability probing prunes\n  // it (these containers are currently treated as unplayable; see `canPlayTrack`).\n  const detectedContainer = initSegmentUrl ? undefined : containerMimeFromSegment(placed[0]?.url);\n  const mimeType = previous.type !== 'text' && detectedContainer ? detectedContainer : previous.mimeType;\n\n  // Generic resolution: All type-specific fields already on `previous` track\n  // Just add parsed properties (startTime, duration, segments, initialization, metadata)\n  return {\n    ...previous,\n    mimeType,\n    startTime: 0,\n    startDate,\n    duration: trackDuration,\n    segments: placed,\n    initialization,\n    metadata: {\n      ...previous.metadata,\n      [MEDIA_PLAYLIST_METADATA_KEY]: {\n        targetDuration,\n        mediaSequence,\n        playlistType,\n        lowLatency,\n        endList,\n        holdBack,\n        encrypted,\n      } satisfies MediaPlaylistMetadata,\n    },\n  } as unknown as ResolveTrack<T>;\n}\n"],"mappings":"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"}