mattebox 0.1.0

package/dist/es2015/kernel/trace.js

@@ -0,0 +1,134 @@
+/** Fixed capacity, overwriting. Roughly 200 bytes of code for the whole payoff. */
+function createTraceBuffer(capacity = 500) {
+	const entries = [];
+	let head = 0;
+	return {
+		capacity,
+		push(entry) {
+			if (entries.length < capacity) entries.push(entry);
+			else {
+				entries[head] = entry;
+				head = (head + 1) % capacity;
+			}
+		},
+		snapshot() {
+			return [...entries.slice(head), ...entries.slice(0, head)];
+		}
+	};
+}
+function isPlainObject(value) {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Deterministic serialization for hashing: sorted object keys, sorted Map
+* entries, opaque values tagged by constructor name. Not a wire format.
+*/
+function stableStringify(value) {
+	if (value === null || typeof value === "number" || typeof value === "boolean") return String(value);
+	if (typeof value === "string") return JSON.stringify(value);
+	if (value === void 0) return "undefined";
+	if (typeof value === "function") return "[function]";
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (value instanceof Map) return `Map{${[...value.entries()].map(([k, v]) => `${stableStringify(k)}:${stableStringify(v)}`).sort().join(",")}}`;
+	if (value instanceof ArrayBuffer) return `ArrayBuffer(${value.byteLength})`;
+	if (ArrayBuffer.isView(value)) return `${value.constructor.name}(${value.byteLength})`;
+	if (typeof value === "object") {
+		var _value$constructor$na, _value$constructor;
+		if (!isPlainObject(value)) return `[${(_value$constructor$na = (_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name) !== null && _value$constructor$na !== void 0 ? _value$constructor$na : "opaque"}]`;
+		return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
+	}
+	return String(value);
+}
+/** 32-bit FNV-1a over a string, as fixed-width hex. */
+function fnv1a(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i += 1) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619) >>> 0;
+	}
+	return hash.toString(16).padStart(8, "0");
+}
+/**
+* A cheap, stable hash of the state slices that matter for divergence
+* detection. Stable across runs: it depends only on the state.
+*/
+function digest(state) {
+	var _state$presentation$i, _state$presentation;
+	return fnv1a(stableStringify({
+		phase: state.lifecycle.phase,
+		presentation: (_state$presentation$i = (_state$presentation = state.presentation) === null || _state$presentation === void 0 ? void 0 : _state$presentation.id) !== null && _state$presentation$i !== void 0 ? _state$presentation$i : null,
+		inflight: [...state.scheduling.inflight.keys()].sort(),
+		bufferGoal: state.scheduling.bufferGoal,
+		tokenSeq: state.scheduling.tokenSeq,
+		buffers: state.buffers,
+		tracks: state.tracks.active,
+		quality: {
+			pinned: state.quality.pinned,
+			active: state.quality.active,
+			constraints: [...state.quality.constraints.keys()].sort()
+		},
+		currentTime: state.playback.currentTime
+	}));
+}
+/**
+* JSON for a bug report. Byte payloads are reduced to their length and
+* non-plain objects to their constructor name; the shape of the
+* interleaving is what matters, not the media bytes.
+*/
+function exportTrace(entries) {
+	return JSON.stringify(entries, (_key, value) => {
+		if (value instanceof ArrayBuffer) return { $bytes: value.byteLength };
+		if (ArrayBuffer.isView(value)) return { $bytes: value.byteLength };
+		if (value instanceof Map) return Object.fromEntries(value);
+		if (typeof value === "function") return { $opaque: "function" };
+		if (typeof value === "object" && value !== null && !Array.isArray(value) && !isPlainObject(value)) {
+			var _value$constructor$na2, _value$constructor2;
+			return { $opaque: (_value$constructor$na2 = (_value$constructor2 = value.constructor) === null || _value$constructor2 === void 0 ? void 0 : _value$constructor2.name) !== null && _value$constructor$na2 !== void 0 ? _value$constructor$na2 : "object" };
+		}
+		return value;
+	});
+}
+function buffersEqual(a, b) {
+	if (a.byteLength !== b.byteLength) return false;
+	const va = new Uint8Array(a);
+	const vb = new Uint8Array(b);
+	for (let i = 0; i < va.length; i += 1) if (va[i] !== vb[i]) return false;
+	return true;
+}
+/** Structural equality over effect payloads: plain data plus ArrayBuffer. */
+function deepEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (a instanceof ArrayBuffer && b instanceof ArrayBuffer) return buffersEqual(a, b);
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));
+	if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+		const ka = Object.keys(a);
+		const kb = Object.keys(b);
+		if (ka.length !== kb.length) return false;
+		return ka.every((k) => deepEqual(a[k], b[k]));
+	}
+	return false;
+}
+/**
+* Feeds a recorded message sequence into a fresh reducer and checks that the
+* same effects come out. The reducer must be built with the same slices as
+* the one that produced the trace.
+*/
+function replay(entries, reducer, initial) {
+	let state = initial;
+	for (let i = 0; i < entries.length; i += 1) {
+		const entry = entries[i];
+		if (entry === void 0) continue;
+		const [next, effects] = reducer(state, entry.msg);
+		if (!deepEqual(effects, entry.effects)) return {
+			ok: false,
+			divergedAt: i,
+			expected: entry.effects,
+			actual: effects
+		};
+		state = next;
+	}
+	return { ok: true };
+}
+//#endregion
+export { createTraceBuffer, digest, exportTrace, replay };

package/dist/es2015/kernel/track-registry.js

@@ -0,0 +1,47 @@
+//#region src/kernel/track-registry.ts
+function allTracks(state) {
+	if (state.presentation === null) return [];
+	return state.presentation.periods.flatMap((period) => period.tracks);
+}
+function createTrackRegistry(deps) {
+	function find(trackId) {
+		var _allTracks$find;
+		return (_allTracks$find = allTracks(deps.getState()).find((track) => track.id === trackId)) !== null && _allTracks$find !== void 0 ? _allTracks$find : null;
+	}
+	return {
+		get available() {
+			return allTracks(deps.getState());
+		},
+		active(contentType) {
+			const activeId = deps.getState().tracks.active.get(contentType);
+			if (activeId === void 0) return null;
+			return find(activeId);
+		},
+		selectable(trackId) {
+			const track = find(trackId);
+			return track !== null && deps.hasSink(track.contentType);
+		},
+		select(trackId) {
+			const track = find(trackId);
+			if (track !== null && !deps.hasSink(track.contentType)) {
+				deps.emitEvent("command:rejected", {
+					command: "SELECT_TRACK",
+					reason: `no sink registered for '${track.contentType}'`
+				});
+				return;
+			}
+			deps.dispatch({
+				type: "SELECT_TRACK",
+				trackId
+			});
+		},
+		deselect(contentType) {
+			deps.dispatch({
+				type: "DESELECT_TRACK",
+				contentType
+			});
+		}
+	};
+}
+//#endregion
+export { createTrackRegistry };

package/dist/es2015/kernel/transport.js

@@ -0,0 +1,242 @@
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import _asyncToGenerator from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/asyncToGenerator.js";
+//#region src/kernel/transport.ts
+const DEFAULT_RETRY_POLICY = {
+	maxAttempts: 3,
+	baseDelayMs: 500,
+	factor: 2,
+	maxDelayMs: 5e3,
+	retryStatuses: [
+		408,
+		429,
+		500,
+		502,
+		503,
+		504
+	]
+};
+/** Backoff delay before retry `attempt` (1 = first retry). Exported so tests pin the schedule. */
+function backoffDelayMs(policy, attempt) {
+	return Math.min(policy.maxDelayMs, policy.baseDelayMs * Math.pow(policy.factor, attempt - 1));
+}
+function createTransport(options) {
+	var _options$fetchImpl, _options$now;
+	const policy = _objectSpread2(_objectSpread2({}, DEFAULT_RETRY_POLICY), options.retry);
+	const fetchImpl = (_options$fetchImpl = options.fetchImpl) !== null && _options$fetchImpl !== void 0 ? _options$fetchImpl : ((url, init) => globalThis.fetch(url, init));
+	const now = (_options$now = options.now) !== null && _options$now !== void 0 ? _options$now : (() => globalThis.performance.now());
+	const defaultTimeout = options.defaultTimeoutMs === void 0 ? 2e4 : options.defaultTimeoutMs;
+	const requestHooks = /* @__PURE__ */ new Set();
+	const responseHooks = /* @__PURE__ */ new Set();
+	const live = /* @__PURE__ */ new Map();
+	function fail(token, request, code, status) {
+		live.delete(token);
+		options.absorb(_objectSpread2(_objectSpread2(_objectSpread2({
+			type: "SEGMENT_FAILED",
+			trackId: request.trackId,
+			seq: request.seq
+		}, request.renditionId !== void 0 ? { renditionId: request.renditionId } : {}), status !== void 0 ? { status } : {}), {}, { error: {
+			category: "network",
+			code,
+			fatal: false,
+			recoverable: true,
+			context: {
+				url: request.url,
+				token
+			}
+		} }));
+	}
+	function notifyResponse(info) {
+		for (const hook of [...responseHooks]) try {
+			hook(info);
+		} catch (_unused) {}
+	}
+	function attempt(token, request, effectUrl, range, timeoutFromEffect, attemptNo) {
+		const state = {
+			controller: new AbortController(),
+			timedOut: false,
+			userAborted: false,
+			timeoutId: null,
+			retryId: null
+		};
+		live.set(token, state);
+		const draft = {
+			url: effectUrl,
+			headers: {},
+			timeoutMs: timeoutFromEffect !== null && timeoutFromEffect !== void 0 ? timeoutFromEffect : defaultTimeout,
+			token,
+			attempt: attemptNo
+		};
+		if (range !== void 0) {
+			const end = Number.isFinite(range.end) ? String(range.end) : "";
+			draft.headers.Range = `bytes=${range.start}-${end}`;
+		}
+		for (const hook of [...requestHooks]) try {
+			hook(draft);
+		} catch (_unused2) {}
+		if (draft.timeoutMs !== null) state.timeoutId = setTimeout(() => {
+			state.timedOut = true;
+			state.controller.abort();
+		}, draft.timeoutMs);
+		const startedAt = now();
+		const retryOrFail = (code, status) => {
+			if (!(attemptNo < policy.maxAttempts && (code !== "NETWORK_HTTP_STATUS" || status !== void 0 && policy.retryStatuses.includes(status)))) {
+				fail(token, request, code, status);
+				return;
+			}
+			state.retryId = setTimeout(() => {
+				state.retryId = null;
+				attempt(token, request, effectUrl, range, timeoutFromEffect, attemptNo + 1);
+			}, backoffDelayMs(policy, attemptNo));
+		};
+		fetchImpl(draft.url, {
+			headers: draft.headers,
+			signal: state.controller.signal
+		}).then(function() {
+			var _ref = _asyncToGenerator(function* (response) {
+				var _options$acceptManife, _response$body;
+				if (state.timeoutId !== null) clearTimeout(state.timeoutId);
+				if (!response.ok) {
+					notifyResponse({
+						token,
+						url: draft.url,
+						status: response.status,
+						rtt: now() - startedAt,
+						size: 0,
+						outcome: "failure",
+						attempt: attemptNo
+					});
+					retryOrFail("NETWORK_HTTP_STATUS", response.status);
+					return;
+				}
+				const contentType = response.headers.get("content-type");
+				const refused = request.trackId === "manifest" && contentType !== null && ((_options$acceptManife = options.acceptManifestType) === null || _options$acceptManife === void 0 ? void 0 : _options$acceptManife.call(options, contentType)) === false;
+				if (refused) yield (_response$body = response.body) === null || _response$body === void 0 ? void 0 : _response$body.cancel();
+				const bytes = refused ? /* @__PURE__ */ new ArrayBuffer(0) : yield response.arrayBuffer();
+				if (state.userAborted) {
+					live.delete(token);
+					return;
+				}
+				const rtt = now() - startedAt;
+				notifyResponse({
+					token,
+					url: draft.url,
+					status: response.status,
+					rtt,
+					size: bytes.byteLength,
+					outcome: refused ? "failure" : "success",
+					attempt: attemptNo
+				});
+				live.delete(token);
+				if (refused) {
+					options.absorb({
+						type: "SEGMENT_FAILED",
+						trackId: request.trackId,
+						seq: request.seq,
+						status: response.status,
+						error: {
+							category: "manifest",
+							code: "MANIFEST_UNSUPPORTED",
+							fatal: true,
+							recoverable: false,
+							context: {
+								url: request.url,
+								token,
+								contentType
+							}
+						}
+					});
+					return;
+				}
+				options.absorb({
+					type: "SEGMENT_LOADED",
+					trackId: request.trackId,
+					seq: request.seq,
+					token,
+					bytes,
+					rtt,
+					size: bytes.byteLength,
+					wallClock: Date.now() / 1e3
+				});
+			});
+			return function(_x) {
+				return _ref.apply(this, arguments);
+			};
+		}()).catch(() => {
+			if (state.timeoutId !== null) clearTimeout(state.timeoutId);
+			if (state.userAborted) {
+				live.delete(token);
+				return;
+			}
+			const outcome = state.timedOut ? "timeout" : "failure";
+			notifyResponse({
+				token,
+				url: draft.url,
+				status: null,
+				rtt: now() - startedAt,
+				size: 0,
+				outcome,
+				attempt: attemptNo
+			});
+			retryOrFail(state.timedOut ? "NETWORK_TIMEOUT" : "NETWORK_FAILED");
+		});
+	}
+	function cancel(token) {
+		const state = live.get(token);
+		if (state === void 0) return;
+		state.userAborted = true;
+		if (state.timeoutId !== null) clearTimeout(state.timeoutId);
+		if (state.retryId !== null) {
+			clearTimeout(state.retryId);
+			live.delete(token);
+			return;
+		}
+		state.controller.abort();
+	}
+	return {
+		registerHandlers(runner) {
+			runner.register("fetch", (effect) => {
+				var _options$inflight;
+				const request = (_options$inflight = options.inflight(effect.token)) !== null && _options$inflight !== void 0 ? _options$inflight : {
+					token: effect.token,
+					trackId: effect.token,
+					seq: -1,
+					url: effect.url
+				};
+				attempt(effect.token, request, effect.url, effect.range, effect.timeout, 1);
+				return () => cancel(effect.token);
+			});
+		},
+		request(url, init) {
+			return _asyncToGenerator(function* () {
+				var _init$headers, _init$method;
+				const draft = {
+					url,
+					headers: _objectSpread2({}, (_init$headers = init.headers) !== null && _init$headers !== void 0 ? _init$headers : {}),
+					timeoutMs: defaultTimeout,
+					token: `req:${url}`,
+					attempt: 1
+				};
+				for (const hook of [...requestHooks]) try {
+					hook(draft);
+				} catch (_unused3) {}
+				return fetchImpl(draft.url, _objectSpread2({
+					method: (_init$method = init.method) !== null && _init$method !== void 0 ? _init$method : init.body !== void 0 ? "POST" : "GET",
+					headers: draft.headers
+				}, init.body !== void 0 ? { body: init.body } : {}));
+			})();
+		},
+		addRequestHook(hook) {
+			requestHooks.add(hook);
+			return () => requestHooks.delete(hook);
+		},
+		addResponseHook(hook) {
+			responseHooks.add(hook);
+			return () => responseHooks.delete(hook);
+		},
+		pending() {
+			return [...live.keys()];
+		}
+	};
+}
+//#endregion
+export { DEFAULT_RETRY_POLICY, backoffDelayMs, createTransport };

package/dist/es2015/kernel/watchdog.js

@@ -0,0 +1,38 @@
+//#region src/kernel/watchdog.ts
+/** Data the decoder could be consuming: a range at, or just ahead of, the playhead. */
+function hasDataAhead(el) {
+	const t = el.currentTime;
+	for (let i = 0; i < el.buffered.length; i += 1) if (el.buffered.end(i) > t + .1 && el.buffered.start(i) <= t + 2) return true;
+	return false;
+}
+/** Starts the watchdog; the returned function stops it. */
+function createPlaybackWatchdog(el, absorb, options = {}, timers = {
+	setInterval: (fn, ms) => setInterval(fn, ms),
+	clearInterval: (id) => clearInterval(id)
+}) {
+	var _options$intervalMs, _options$stuckChecks;
+	const intervalMs = (_options$intervalMs = options.intervalMs) !== null && _options$intervalMs !== void 0 ? _options$intervalMs : 250;
+	const stuckChecks = (_options$stuckChecks = options.stuckChecks) !== null && _options$stuckChecks !== void 0 ? _options$stuckChecks : 4;
+	let lastTime = -1;
+	let stuck = 0;
+	const timer = timers.setInterval(() => {
+		if (el.paused || el.seeking || el.ended || el.readyState < 1) {
+			stuck = 0;
+			lastTime = el.currentTime;
+			return;
+		}
+		if (el.currentTime !== lastTime) {
+			stuck = 0;
+			lastTime = el.currentTime;
+			return;
+		}
+		stuck += 1;
+		if (stuck % stuckChecks === 0 && hasDataAhead(el)) absorb({
+			type: "STALLED",
+			at: el.currentTime
+		});
+	}, intervalMs);
+	return () => timers.clearInterval(timer);
+}
+//#endregion
+export { createPlaybackWatchdog };

package/dist/es2015/presets/dash/index.js

@@ -0,0 +1,9 @@
+import { definePreset } from "../define.js";
+import { base, dashLine } from "../tiers.js";
+//#region src/presets/dash/index.ts
+/**
+* The `dash` preset: DASH on demand and live, the base.
+*/
+const preset = definePreset("dash", () => [...dashLine(), ...base()]);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/dash-drm/index.js

@@ -0,0 +1,13 @@
+import { definePreset } from "../define.js";
+import { base, dashLine, drmTier } from "../tiers.js";
+//#region src/presets/dash-drm/index.ts
+/**
+* The `dash-drm` preset: `dash` plus the EME stages, for protected DASH.
+*/
+const preset = definePreset("dash-drm", () => [
+	...dashLine(),
+	...base(),
+	...drmTier()
+]);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/define.js

@@ -0,0 +1,45 @@
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import _objectWithoutProperties from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectWithoutProperties.js";
+import { mattebox } from "../index.js";
+//#region src/presets/define.ts
+const _excluded = ["stages", "without"];
+/** Applies the merge rule. Exported for tests; presets call it through `stages`. */
+function mergeStages(defaults, options = {}) {
+	var _options$without, _options$stages;
+	const without = new Set((_options$without = options.without) !== null && _options$without !== void 0 ? _options$without : []);
+	const overrides = /* @__PURE__ */ new Map();
+	for (const stage of (_options$stages = options.stages) !== null && _options$stages !== void 0 ? _options$stages : []) overrides.set(stage.name, stage);
+	const out = [];
+	for (const stage of defaults) {
+		if (without.has(stage.name)) continue;
+		const override = overrides.get(stage.name);
+		if (override === void 0) {
+			out.push(stage);
+			continue;
+		}
+		out.push(override);
+		overrides.delete(stage.name);
+	}
+	for (const stage of overrides.values()) out.push(stage);
+	return out;
+}
+/**
+* Builds a preset from a name and a function returning fresh default stage
+* instances. A function, not an array: a stage instance carries install
+* state, so every engine must get its own.
+*/
+function definePreset(presetName, defaults) {
+	function stages(options) {
+		return mergeStages(defaults(), options);
+	}
+	const preset = (options = {}) => {
+		const { stages: _overrides, without: _without } = options, rest = _objectWithoutProperties(options, _excluded);
+		return mattebox(_objectSpread2(_objectSpread2({}, rest), {}, { stages: stages(options) }));
+	};
+	return Object.assign(preset, {
+		presetName,
+		stages
+	});
+}
+//#endregion
+export { definePreset, mergeStages };

package/dist/es2015/presets/dual/index.js

@@ -0,0 +1,14 @@
+import { definePreset } from "../define.js";
+import { base, dashLine, hlsLine } from "../tiers.js";
+//#region src/presets/dual/index.ts
+/**
+* The `dual` preset: both protocol lines, CMAF segments, the base. One
+* engine for a catalogue that mixes HLS and DASH.
+*/
+const preset = definePreset("dual", () => [
+	...hlsLine(),
+	...dashLine(),
+	...base()
+]);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/dual-drm/index.js

@@ -0,0 +1,14 @@
+import { definePreset } from "../define.js";
+import { base, dashLine, drmTier, hlsLine } from "../tiers.js";
+//#region src/presets/dual-drm/index.ts
+/**
+* The `dual-drm` preset: `dual` plus the EME stages.
+*/
+const preset = definePreset("dual-drm", () => [
+	...hlsLine(),
+	...dashLine(),
+	...base(),
+	...drmTier()
+]);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/dual-ts/index.js

@@ -0,0 +1,14 @@
+import { definePreset } from "../define.js";
+import { base, dashLine, hlsLine, tsTier } from "../tiers.js";
+//#region src/presets/dual-ts/index.ts
+/**
+* The `dual-ts` preset: `dual` plus the MPEG-TS family.
+*/
+const preset = definePreset("dual-ts", () => [
+	...hlsLine(),
+	...dashLine(),
+	...base(),
+	...tsTier()
+]);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/dual-ts-drm/index.js

@@ -0,0 +1,15 @@
+import { definePreset } from "../define.js";
+import { base, dashLine, drmTier, hlsLine, tsTier } from "../tiers.js";
+//#region src/presets/dual-ts-drm/index.ts
+/**
+* The `dual-ts-drm` preset: both lines, MPEG-TS, and DRM. Everything a production backend needs; `full` adds only the accessories.
+*/
+const preset = definePreset("dual-ts-drm", () => [
+	...hlsLine(),
+	...dashLine(),
+	...base(),
+	...tsTier(),
+	...drmTier()
+]);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/full/index.js

@@ -0,0 +1,28 @@
+import thumbnails from "../../stages/thumbnails/index.js";
+import mp4Box from "../../stages/mp4-box/index.js";
+import codecProbe from "../../stages/codec-probe/index.js";
+import cmcd from "../../stages/cmcd/index.js";
+import { definePreset } from "../define.js";
+import { base, dashLine, drmTier, hlsLine, tsTier } from "../tiers.js";
+//#region src/presets/full/index.ts
+/**
+* The `full` preset: every stage the catalogue ships. `dual-ts-drm` plus
+* the accessories: the mp4-box namespace and codec probe (diagnostics),
+* CMCD (changes every request, so opt-in elsewhere), and thumbnails (needs
+* an app-supplied sprite track). Feature parity with videojs-http-streaming;
+* the modularity claim is measured against it, and the main CDN bundle
+* exposes it.
+*/
+const preset = definePreset("full", () => [
+	...hlsLine(),
+	...dashLine(),
+	...base(),
+	...tsTier(),
+	...drmTier(),
+	mp4Box(),
+	codecProbe(),
+	cmcd(),
+	thumbnails()
+]);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/hls/index.js

@@ -0,0 +1,9 @@
+import { definePreset } from "../define.js";
+import { base, hlsLine } from "../tiers.js";
+//#region src/presets/hls/index.ts
+/**
+* The `hls` preset: HLS on demand and live, CMAF segments, the base.
+*/
+const preset = definePreset("hls", () => [...hlsLine(), ...base()]);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/hls-drm/index.js

@@ -0,0 +1,13 @@
+import { definePreset } from "../define.js";
+import { base, drmTier, hlsLine } from "../tiers.js";
+//#region src/presets/hls-drm/index.ts
+/**
+* The `hls-drm` preset: `hls` plus the EME stages, for protected HLS.
+*/
+const preset = definePreset("hls-drm", () => [
+	...hlsLine(),
+	...base(),
+	...drmTier()
+]);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/hls-ts/index.js

@@ -0,0 +1,13 @@
+import { definePreset } from "../define.js";
+import { base, hlsLine, tsTier } from "../tiers.js";
+//#region src/presets/hls-ts/index.ts
+/**
+* The `hls-ts` preset: `hls` plus the MPEG-TS family, for a backend that still emits transport streams.
+*/
+const preset = definePreset("hls-ts", () => [
+	...hlsLine(),
+	...base(),
+	...tsTier()
+]);
+//#endregion
+export { preset as default };

package/dist/es2015/presets/hls-ts-drm/index.js

@@ -0,0 +1,14 @@
+import { definePreset } from "../define.js";
+import { base, drmTier, hlsLine, tsTier } from "../tiers.js";
+//#region src/presets/hls-ts-drm/index.ts
+/**
+* The `hls-ts-drm` preset: `hls-ts` plus the EME stages.
+*/
+const preset = definePreset("hls-ts-drm", () => [
+	...hlsLine(),
+	...base(),
+	...tsTier(),
+	...drmTier()
+]);
+//#endregion
+export { preset as default };