@cardstack/boxel-cli 0.9.0 → 0.10.0-unstable.0

package/bundled-test-harness/assets/mp3-meta-extractor-C3u34UHM.js

@@ -0,0 +1,476 @@
+import "./chunk-Rp0pCe6z.js";
+import { u as FileContentMismatchError } from "./card-api-Dzje0smT.js";
+import "./file-api-DPMJghBY.js";
+import { r as prunedEncoding } from "./audio-metadata-C6yIFxTY.js";
+import { t as parseId3v2Tags } from "./id3v2-parser-DgMqM8nP.js";
+import { t as StreamingEnvelope } from "./streaming-envelope-C80-34IV.js";
+//#region ../base/mp3-meta-extractor.ts
+var FRAME_SYNC_FIRST = 255;
+var FRAME_SYNC_SECOND_MASK = 224;
+var ID3V2_HEADER_BYTES = 10;
+var MPEG_VERSION_2_5 = 0;
+var MPEG_VERSION_2 = 2;
+var MPEG_VERSION_1 = 3;
+var LAYER_III = 1;
+var LAYER_II = 2;
+var LAYER_I = 3;
+var SAMPLE_RATES = {
+	[MPEG_VERSION_1]: [
+		44100,
+		48e3,
+		32e3
+	],
+	[MPEG_VERSION_2]: [
+		22050,
+		24e3,
+		16e3
+	],
+	[MPEG_VERSION_2_5]: [
+		11025,
+		12e3,
+		8e3
+	]
+};
+function samplesPerFrame(version, layer) {
+	if (layer === LAYER_I) return 384;
+	if (version === MPEG_VERSION_1) return layer === LAYER_II || layer === LAYER_III ? 1152 : void 0;
+	if (layer === LAYER_II) return 1152;
+	if (layer === LAYER_III) return 576;
+}
+function parseSyncSafeSize(bytes, offset) {
+	return bytes[offset] << 21 | bytes[offset + 1] << 14 | bytes[offset + 2] << 7 | bytes[offset + 3];
+}
+function id3v2TagSize(bytes) {
+	if (bytes.length < ID3V2_HEADER_BYTES) return 0;
+	if (bytes[0] !== 73 || bytes[1] !== 68 || bytes[2] !== 51) return 0;
+	return ID3V2_HEADER_BYTES + parseSyncSafeSize(bytes, 6);
+}
+function findFrameSync(bytes, startOffset) {
+	for (let i = startOffset; i < bytes.length - 1; i++) if (bytes[i] === FRAME_SYNC_FIRST && (bytes[i + 1] & FRAME_SYNC_SECOND_MASK) === FRAME_SYNC_SECOND_MASK) return i;
+}
+function parseFrameHeader(bytes, offset) {
+	if (offset + 4 > bytes.length) return;
+	let b1 = bytes[offset + 1];
+	let b2 = bytes[offset + 2];
+	let version = b1 >> 3 & 3;
+	let layer = b1 >> 1 & 3;
+	let sampleRateIdx = b2 >> 2 & 3;
+	if (version === 1) return;
+	if (layer === 0) return;
+	let rates = SAMPLE_RATES[version];
+	if (!rates || sampleRateIdx === 3) return;
+	let sampleRate = rates[sampleRateIdx];
+	if (!sampleRate) return;
+	let samples = samplesPerFrame(version, layer);
+	if (!samples) return;
+	return {
+		version,
+		layer,
+		sampleRate,
+		samplesPerFrame: samples
+	};
+}
+var VBR_TAG_SCAN_BYTES = 64;
+function findVbrTotalFrames(bytes, frameStart) {
+	let scanStart = frameStart + 4;
+	let scanEnd = Math.min(bytes.length - 4, scanStart + VBR_TAG_SCAN_BYTES);
+	let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	for (let i = scanStart; i <= scanEnd; i++) {
+		let tag = String.fromCharCode(bytes[i], bytes[i + 1], bytes[i + 2], bytes[i + 3]);
+		if (tag === "Xing" || tag === "Info") {
+			if (i + 12 > bytes.length) return;
+			if ((view.getUint32(i + 4) & 1) === 0) return;
+			return view.getUint32(i + 8);
+		}
+		if (tag === "VBRI") {
+			if (i + 18 > bytes.length) return;
+			return view.getUint32(i + 14);
+		}
+	}
+}
+function extractMp3Duration(bytes) {
+	let frameOffset = findFrameSync(bytes, id3v2TagSize(bytes));
+	if (frameOffset === void 0) throw new FileContentMismatchError("MP3 file does not contain an MPEG audio frame in the read window");
+	let header = parseFrameHeader(bytes, frameOffset);
+	if (!header) throw new FileContentMismatchError("MP3 file has an invalid MPEG frame header");
+	let totalFrames = findVbrTotalFrames(bytes, frameOffset);
+	if (totalFrames === void 0 || totalFrames === 0) throw new FileContentMismatchError("MP3 file has no Xing/Info/VBRI header to derive frame count");
+	return { duration: totalFrames * header.samplesPerFrame / header.sampleRate };
+}
+var BITRATE_KBPS = {
+	"3-3": [
+		void 0,
+		32,
+		64,
+		96,
+		128,
+		160,
+		192,
+		224,
+		256,
+		288,
+		320,
+		352,
+		384,
+		416,
+		448,
+		void 0
+	],
+	"3-2": [
+		void 0,
+		32,
+		48,
+		56,
+		64,
+		80,
+		96,
+		112,
+		128,
+		160,
+		192,
+		224,
+		256,
+		320,
+		384,
+		void 0
+	],
+	"3-1": [
+		void 0,
+		32,
+		40,
+		48,
+		56,
+		64,
+		80,
+		96,
+		112,
+		128,
+		160,
+		192,
+		224,
+		256,
+		320,
+		void 0
+	],
+	"2-3": [
+		void 0,
+		32,
+		48,
+		56,
+		64,
+		80,
+		96,
+		112,
+		128,
+		144,
+		160,
+		176,
+		192,
+		224,
+		256,
+		void 0
+	],
+	"2-2": [
+		void 0,
+		8,
+		16,
+		24,
+		32,
+		40,
+		48,
+		56,
+		64,
+		80,
+		96,
+		112,
+		128,
+		144,
+		160,
+		void 0
+	],
+	"2-1": [
+		void 0,
+		8,
+		16,
+		24,
+		32,
+		40,
+		48,
+		56,
+		64,
+		80,
+		96,
+		112,
+		128,
+		144,
+		160,
+		void 0
+	]
+};
+var CHANNEL_MODES = {
+	0: {
+		mode: "stereo",
+		channels: 2
+	},
+	1: {
+		mode: "joint-stereo",
+		channels: 2
+	},
+	2: {
+		mode: "dual-mono",
+		channels: 2
+	},
+	3: {
+		mode: "mono",
+		channels: 1
+	}
+};
+var LAYER_NAMES = {
+	[LAYER_I]: "MPEG Layer I",
+	[LAYER_II]: "MPEG Layer II",
+	[LAYER_III]: "MP3 (MPEG Layer III)"
+};
+function bitrateTableKey(version, layer) {
+	return `${version === MPEG_VERSION_1 ? "3" : "2"}-${layer}`;
+}
+function extractMp3Encoding(bytes) {
+	let frameOffset = findFrameSync(bytes, id3v2TagSize(bytes));
+	if (frameOffset === void 0) return;
+	let header = parseFrameHeader(bytes, frameOffset);
+	if (!header) return;
+	let b2 = bytes[frameOffset + 2];
+	let b3 = bytes[frameOffset + 3];
+	let bitrateIndex = b2 >> 4 & 15;
+	let bitrateKbps = BITRATE_KBPS[bitrateTableKey(header.version, header.layer)]?.[bitrateIndex];
+	let channelMode = CHANNEL_MODES[b3 >> 6 & 3];
+	let isVariableBitrate = findVbrTotalFrames(bytes, frameOffset) !== void 0;
+	return prunedEncoding({
+		container: "MPEG",
+		audioCodec: LAYER_NAMES[header.layer],
+		sampleRateHz: header.sampleRate,
+		bitrateBps: bitrateKbps === void 0 ? void 0 : bitrateKbps * 1e3,
+		isVariableBitrate,
+		channels: channelMode?.channels,
+		channelMode: channelMode?.mode
+	});
+}
+function extractMp3Tags(bytes) {
+	return parseId3v2Tags(bytes);
+}
+var SAMPLES_PER_GRANULE = 576;
+var GLOBAL_GAIN_BIAS = 210;
+var GLOBAL_GAIN_BIT_OFFSET = 21;
+var SIDE_INFO_BLOCK_BITS_V1 = 59;
+var SIDE_INFO_BLOCK_BITS_V2 = 63;
+function readBits(bytes, base, bitOffset, count) {
+	let value = 0;
+	for (let index = 0; index < count; index++) {
+		let bit = bitOffset + index;
+		let byteIndex = base + (bit >> 3);
+		if (byteIndex >= bytes.length) return;
+		value = value << 1 | bytes[byteIndex] >> 7 - (bit & 7) & 1;
+	}
+	return value;
+}
+function frameLengthBytes(version, layer, bitrateKbps, sampleRate, hasPadding) {
+	if (bitrateKbps <= 0 || sampleRate <= 0 || layer !== LAYER_III) return;
+	return Math.floor((version === MPEG_VERSION_1 ? 144 : 72) * bitrateKbps * 1e3 / sampleRate) + (hasPadding ? 1 : 0);
+}
+function frameGlobalGains(bytes, frameOffset, version, channelCount, hasCrc) {
+	let base = frameOffset + 4 + (hasCrc ? 2 : 0);
+	let isMono = channelCount === 1;
+	let gains = [];
+	if (version === MPEG_VERSION_1) {
+		let start = 9 + (isMono ? 5 : 3) + 4 * channelCount;
+		for (let granule = 0; granule < 2; granule++) for (let channel = 0; channel < channelCount; channel++) {
+			let gain = readBits(bytes, base, start + (granule * channelCount + channel) * SIDE_INFO_BLOCK_BITS_V1 + GLOBAL_GAIN_BIT_OFFSET, 8);
+			if (gain === void 0) return gains;
+			gains.push(gain);
+		}
+	} else {
+		let start = 8 + (isMono ? 1 : 2);
+		for (let channel = 0; channel < channelCount; channel++) {
+			let gain = readBits(bytes, base, start + channel * SIDE_INFO_BLOCK_BITS_V2 + GLOBAL_GAIN_BIT_OFFSET, 8);
+			if (gain === void 0) return gains;
+			gains.push(gain);
+		}
+	}
+	return gains;
+}
+function scanFrames(bytes, startOffset, envelope) {
+	let offset = startOffset;
+	let granuleCount = 0;
+	let frameCount = 0;
+	let sampleRate;
+	while (offset + 4 <= bytes.length) {
+		let header = bytes[offset] === FRAME_SYNC_FIRST && (bytes[offset + 1] & FRAME_SYNC_SECOND_MASK) === FRAME_SYNC_SECOND_MASK ? parseFrameHeader(bytes, offset) : void 0;
+		if (!header) {
+			let resync = findFrameSync(bytes, offset + 1);
+			if (resync === void 0) break;
+			offset = resync;
+			continue;
+		}
+		sampleRate ??= header.sampleRate;
+		let b1 = bytes[offset + 1];
+		let b2 = bytes[offset + 2];
+		let b3 = bytes[offset + 3];
+		let hasCrc = (b1 & 1) === 0;
+		let bitrateIndex = b2 >> 4 & 15;
+		let bitrateKbps = BITRATE_KBPS[bitrateTableKey(header.version, header.layer)]?.[bitrateIndex];
+		let hasPadding = (b2 >> 1 & 1) === 1;
+		let channelCount = (b3 >> 6 & 3) === 3 ? 1 : 2;
+		let length = frameLengthBytes(header.version, header.layer, bitrateKbps ?? 0, header.sampleRate, hasPadding);
+		if (length === void 0 || length < 4) break;
+		for (let gain of frameGlobalGains(bytes, offset, header.version, channelCount, hasCrc)) {
+			let amplitude = 2 ** ((gain - GLOBAL_GAIN_BIAS) / 4);
+			envelope.push(amplitude * amplitude, 1, amplitude);
+			granuleCount++;
+		}
+		frameCount++;
+		offset += length;
+	}
+	return {
+		granuleCount,
+		sampleRate,
+		frameCount
+	};
+}
+function normalizeBarsToLoudest(bars) {
+	let loudest = Math.max(0, ...bars);
+	return loudest > 0 ? bars.map((bar) => Math.round(bar / loudest * 1e4) / 1e4) : bars;
+}
+function extractMp3Envelope(bytes, barCount) {
+	let start = findFrameSync(bytes, id3v2TagSize(bytes));
+	if (start === void 0) return;
+	let envelope = new StreamingEnvelope(barCount);
+	let { granuleCount, sampleRate, frameCount } = scanFrames(bytes, start, envelope);
+	if (granuleCount === 0 || envelope.isEmpty) return;
+	let normalized = normalizeBarsToLoudest(envelope.bars());
+	let durationSeconds = sampleRate && sampleRate > 0 ? Math.round(granuleCount * SAMPLES_PER_GRANULE / sampleRate * 1e3) / 1e3 : void 0;
+	return {
+		bars: normalized,
+		granuleCount,
+		frameCount,
+		...sampleRate === void 0 ? {} : { sampleRateHz: sampleRate },
+		...durationSeconds === void 0 ? {} : { durationSeconds }
+	};
+}
+async function extractMp3EnvelopeFromStream(stream, barCount) {
+	if (stream instanceof Uint8Array) return extractMp3Envelope(stream, barCount);
+	let envelope = new StreamingEnvelope(barCount);
+	const MAX_FRAME_BYTES = 1441;
+	const WINDOW_BYTES = MAX_FRAME_BYTES * 4;
+	let buffer = new Uint8Array(0);
+	let granuleCount = 0;
+	let frameCount = 0;
+	let sampleRate;
+	let tagBytesRemaining;
+	let started = false;
+	let reader = stream.getReader();
+	try {
+		for (;;) {
+			let { done, value } = await reader.read();
+			if (done) break;
+			if (!value || value.length === 0) continue;
+			let incoming = value;
+			if (!started) {
+				buffer = buffer.length === 0 ? incoming.slice() : concatBytes(buffer, incoming);
+				if (buffer.length < 10) continue;
+				tagBytesRemaining = id3v2TagSize(buffer);
+				started = true;
+				incoming = buffer;
+				buffer = new Uint8Array(0);
+			}
+			if (tagBytesRemaining !== void 0 && tagBytesRemaining > 0) {
+				let skip = Math.min(tagBytesRemaining, incoming.length);
+				tagBytesRemaining -= skip;
+				incoming = incoming.subarray(skip);
+				if (incoming.length === 0) continue;
+			}
+			buffer = buffer.length === 0 ? incoming.slice() : concatBytes(buffer, incoming);
+			let consumed = 0;
+			for (;;) {
+				let progress = readOneFrame(buffer, consumed, envelope);
+				if (!progress) break;
+				consumed = progress.nextOffset;
+				granuleCount += progress.granules;
+				if (progress.granules > 0) frameCount++;
+				sampleRate ??= progress.sampleRate;
+			}
+			buffer = consumed > 0 ? buffer.slice(consumed) : buffer;
+			if (buffer.length > WINDOW_BYTES) buffer = buffer.slice(buffer.length - MAX_FRAME_BYTES);
+		}
+	} finally {
+		await reader.cancel().catch(() => {});
+	}
+	if (granuleCount === 0 || envelope.isEmpty) return;
+	let normalized = normalizeBarsToLoudest(envelope.bars());
+	let durationSeconds = sampleRate && sampleRate > 0 ? Math.round(granuleCount * SAMPLES_PER_GRANULE / sampleRate * 1e3) / 1e3 : void 0;
+	return {
+		bars: normalized,
+		granuleCount,
+		frameCount,
+		...sampleRate === void 0 ? {} : { sampleRateHz: sampleRate },
+		...durationSeconds === void 0 ? {} : { durationSeconds }
+	};
+}
+function concatBytes(left, right) {
+	let out = new Uint8Array(left.length + right.length);
+	out.set(left, 0);
+	out.set(right, left.length);
+	return out;
+}
+function readOneFrame(bytes, offset, envelope) {
+	if (offset + 4 > bytes.length) return;
+	let header = bytes[offset] === FRAME_SYNC_FIRST && (bytes[offset + 1] & FRAME_SYNC_SECOND_MASK) === FRAME_SYNC_SECOND_MASK ? parseFrameHeader(bytes, offset) : void 0;
+	if (!header) {
+		let resync = findFrameSync(bytes, offset + 1);
+		if (resync === void 0) return;
+		return {
+			nextOffset: resync,
+			granules: 0,
+			sampleRate: void 0
+		};
+	}
+	let b1 = bytes[offset + 1];
+	let b2 = bytes[offset + 2];
+	let b3 = bytes[offset + 3];
+	let bitrateKbps = BITRATE_KBPS[bitrateTableKey(header.version, header.layer)]?.[b2 >> 4 & 15];
+	let length = frameLengthBytes(header.version, header.layer, bitrateKbps ?? 0, header.sampleRate, (b2 >> 1 & 1) === 1);
+	if (length === void 0 || length < 4) return {
+		nextOffset: offset + 1,
+		granules: 0,
+		sampleRate: void 0
+	};
+	if (offset + length > bytes.length) return;
+	let channelCount = (b3 >> 6 & 3) === 3 ? 1 : 2;
+	let granules = 0;
+	for (let gain of frameGlobalGains(bytes, offset, header.version, channelCount, (b1 & 1) === 0)) {
+		let amplitude = 2 ** ((gain - GLOBAL_GAIN_BIAS) / 4);
+		envelope.push(amplitude * amplitude, 1, amplitude);
+		granules++;
+	}
+	return {
+		nextOffset: offset + length,
+		granules,
+		sampleRate: header.sampleRate
+	};
+}
+(globalThis.__boxelBundledBaseScopedCSS ??= {})["mp3-meta-extractor"] = {
+	"css": [],
+	"imports": [
+		"audio-metadata",
+		"file-api",
+		"id3v2-parser",
+		"streaming-envelope"
+	]
+};
+(globalThis.__boxelBundledBaseIdentities ??= {})["mp3-meta-extractor"] = {
+	"extractMp3Duration": extractMp3Duration,
+	"extractMp3Encoding": extractMp3Encoding,
+	"extractMp3Envelope": extractMp3Envelope,
+	"extractMp3EnvelopeFromStream": extractMp3EnvelopeFromStream,
+	"extractMp3Tags": extractMp3Tags
+};
+//#endregion
+export { extractMp3Duration, extractMp3Encoding, extractMp3Envelope, extractMp3EnvelopeFromStream, extractMp3Tags };

package/bundled-test-harness/assets/mp4-meta-extractor-Bj3F7dxs.js

@@ -0,0 +1,188 @@
+import "./chunk-Rp0pCe6z.js";
+import { u as FileContentMismatchError } from "./card-api-Dzje0smT.js";
+import "./file-api-DPMJghBY.js";
+import { a as MOOV, c as findChildBox, d as parseMvhd, f as readBoxAt, o as MVHD, p as typeAt, s as descend } from "./iso-bmff-DHtkSbQM.js";
+import { n as prunedVideoEncoding } from "./video-metadata-kk5-smxt.js";
+//#region ../base/mp4-meta-extractor.ts
+var MAX_TRACKS = 64;
+var VIDEO_SAMPLE_ENTRY_CODECS = {
+	avc1: "H.264 (AVC)",
+	avc3: "H.264 (AVC)",
+	hvc1: "H.265 (HEVC)",
+	hev1: "H.265 (HEVC)",
+	av01: "AV1",
+	vp09: "VP9",
+	mp4v: "MPEG-4 Visual",
+	jpeg: "Motion JPEG",
+	ap4h: "Apple ProRes 4444",
+	apch: "Apple ProRes 422 HQ",
+	apcn: "Apple ProRes 422"
+};
+var AUDIO_SAMPLE_ENTRY_CODECS = {
+	mp4a: "AAC",
+	alac: "ALAC (Apple Lossless)",
+	"ac-3": "Dolby Digital",
+	"ec-3": "Dolby Digital Plus",
+	Opus: "Opus",
+	twos: "PCM",
+	sowt: "PCM"
+};
+var HANDLER_VIDEO = "vide";
+var HANDLER_AUDIO = "soun";
+function rotationFromMatrix(view, offset, end) {
+	if (offset + 36 > end) return;
+	let a = view.getInt32(offset) / 65536;
+	let b = view.getInt32(offset + 4) / 65536;
+	if (a === 1 && b === 0) return 0;
+	if (a === 0 && b === 1) return 90;
+	if (a === -1 && b === 0) return 180;
+	if (a === 0 && b === -1) return 270;
+}
+function parseTkhd(bytes, view, start, end) {
+	if (start + 4 > end) return {};
+	let matrixOffset = (bytes[start] === 1 ? start + 4 + 32 : start + 4 + 20) + 16;
+	let dimensionsOffset = matrixOffset + 36;
+	if (dimensionsOffset + 8 > end) return {};
+	let width = view.getUint32(dimensionsOffset) / 65536;
+	let height = view.getUint32(dimensionsOffset + 4) / 65536;
+	return {
+		...width > 0 ? { width: Math.round(width) } : {},
+		...height > 0 ? { height: Math.round(height) } : {},
+		...(() => {
+			let rotation = rotationFromMatrix(view, matrixOffset, end);
+			return rotation === void 0 ? {} : { rotationDegrees: rotation };
+		})()
+	};
+}
+function parseMdhd(bytes, view, start, end) {
+	if (start + 4 > end) return;
+	let version = bytes[start];
+	let cursor = start + 4;
+	if (version === 1) {
+		if (cursor + 28 > end) return;
+		let timescale = view.getUint32(cursor + 16);
+		let duration = view.getUint32(cursor + 20) * 4294967296 + view.getUint32(cursor + 24);
+		return timescale > 0 ? {
+			timescale,
+			duration
+		} : void 0;
+	}
+	if (cursor + 16 > end) return;
+	let timescale = view.getUint32(cursor + 8);
+	let duration = view.getUint32(cursor + 12);
+	return timescale > 0 ? {
+		timescale,
+		duration
+	} : void 0;
+}
+function frameCountFromStts(view, start, end) {
+	if (start + 8 > end) return;
+	let entryCount = view.getUint32(start + 4);
+	let cursor = start + 8;
+	let frames = 0;
+	for (let entry = 0; entry < entryCount; entry++) {
+		if (cursor + 8 > end) return frames > 0 ? frames : void 0;
+		frames += view.getUint32(cursor);
+		cursor += 8;
+	}
+	return frames > 0 ? frames : void 0;
+}
+function readTrack(bytes, view, trackStart, trackEnd) {
+	let facts = {};
+	let hdlr = descend(bytes, view, trackStart, trackEnd, ["mdia", "hdlr"]);
+	if (hdlr) {
+		if (hdlr.payloadOffset + 12 <= hdlr.payloadEnd) facts.handler = typeAt(bytes, hdlr.payloadOffset + 8);
+	}
+	let tkhd = descend(bytes, view, trackStart, trackEnd, ["tkhd"]);
+	if (tkhd) Object.assign(facts, parseTkhd(bytes, view, tkhd.payloadOffset, tkhd.payloadEnd));
+	let mdhd = descend(bytes, view, trackStart, trackEnd, ["mdia", "mdhd"]);
+	let media = mdhd ? parseMdhd(bytes, view, mdhd.payloadOffset, mdhd.payloadEnd) : void 0;
+	if (media) facts.durationSeconds = media.duration / media.timescale;
+	let stsd = descend(bytes, view, trackStart, trackEnd, [
+		"mdia",
+		"minf",
+		"stbl",
+		"stsd"
+	]);
+	if (stsd) try {
+		let entry = readBoxAt(bytes, view, stsd.payloadOffset + 8, stsd.payloadEnd);
+		if (entry) facts.codec = facts.handler === HANDLER_AUDIO ? AUDIO_SAMPLE_ENTRY_CODECS[entry.type] : VIDEO_SAMPLE_ENTRY_CODECS[entry.type];
+	} catch {}
+	let stts = descend(bytes, view, trackStart, trackEnd, [
+		"mdia",
+		"minf",
+		"stbl",
+		"stts"
+	]);
+	if (stts && media && facts.durationSeconds && facts.durationSeconds > 0) {
+		let frames = frameCountFromStts(view, stts.payloadOffset, stts.payloadEnd);
+		if (frames !== void 0) facts.frameRate = Math.round(frames / facts.durationSeconds * 1e3) / 1e3;
+	}
+	return facts;
+}
+function extractMp4VideoEncoding(bytes, container = "MP4") {
+	let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let moov;
+	try {
+		moov = findChildBox(bytes, view, 0, bytes.length, MOOV);
+	} catch {
+		return;
+	}
+	if (!moov) return;
+	let video;
+	let audio;
+	let offset = moov.payloadOffset;
+	for (let index = 0; index < MAX_TRACKS && offset < moov.payloadEnd; index++) {
+		let box;
+		try {
+			box = readBoxAt(bytes, view, offset, moov.payloadEnd);
+		} catch {
+			break;
+		}
+		if (!box) break;
+		if (box.type === "trak") {
+			let facts = readTrack(bytes, view, box.payloadOffset, box.payloadEnd);
+			if (facts.handler === HANDLER_VIDEO && !video) video = facts;
+			else if (facts.handler === HANDLER_AUDIO && !audio) audio = facts;
+		}
+		offset = box.nextBoxOffset;
+	}
+	if (!video && !audio) return;
+	let durationSeconds;
+	let mvhd = findChildBox(bytes, view, moov.payloadOffset, moov.payloadEnd, MVHD);
+	if (mvhd) try {
+		let { timescale, duration } = parseMvhd(bytes, view, mvhd);
+		if (timescale > 0) durationSeconds = duration / timescale;
+	} catch {}
+	durationSeconds ??= video?.durationSeconds ?? audio?.durationSeconds;
+	return prunedVideoEncoding({
+		container,
+		videoCodec: video?.codec,
+		audioCodec: audio?.codec,
+		width: video?.width,
+		height: video?.height,
+		frameRate: video?.frameRate,
+		rotationDegrees: video?.rotationDegrees,
+		durationSeconds: durationSeconds === void 0 ? void 0 : Math.round(durationSeconds * 1e3) / 1e3,
+		hasAudio: audio !== void 0
+	});
+}
+function assertMp4Container(bytes) {
+	if (bytes.length < 12) throw new FileContentMismatchError("File is too small to be a valid MP4 container");
+	let first = typeAt(bytes, 4);
+	if (first !== "ftyp" && first !== "moov" && first !== "mdat") throw new FileContentMismatchError(`File does not begin with an ISO BMFF box (found "${first}")`);
+}
+(globalThis.__boxelBundledBaseScopedCSS ??= {})["mp4-meta-extractor"] = {
+	"css": [],
+	"imports": [
+		"file-api",
+		"iso-bmff",
+		"video-metadata"
+	]
+};
+(globalThis.__boxelBundledBaseIdentities ??= {})["mp4-meta-extractor"] = {
+	"assertMp4Container": assertMp4Container,
+	"extractMp4VideoEncoding": extractMp4VideoEncoding
+};
+//#endregion
+export { assertMp4Container, extractMp4VideoEncoding };