@jackuait/blok 0.17.0 → 0.18.0

package/dist/chunks/MP4Parser-0KMJ-q2k.mjs

@@ -0,0 +1,811 @@
+import { i as e } from "./chunk-5O_1xk2F.mjs";
+import { A as t, C as n, D as r, O as i, T as a, _ as o, c as s, d as c, f as l, k as u, p as d, r as f, s as p, t as ee, v as m, x as h, y as g } from "./BasicParser-BFTgNkp-.mjs";
+import { a as _, f as v } from "./Util-DiBcLCh8.mjs";
+import { i as y } from "./APEv2Parser-WvRvu4zL.mjs";
+import { t as b } from "./ID3v1Parser-DoxlznrE.mjs";
+import { n as x } from "./types-gj36fzRQ.mjs";
+//#region node_modules/music-metadata/lib/mp4/AtomToken.js
+var S = /* @__PURE__ */ e(s(), 1), C = (0, S.default)("music-metadata:parser:MP4:atom"), w = class extends p("MP4") {}, T = {
+	len: 8,
+	get: (e, t) => {
+		let r = n.get(e, t);
+		if (r < 0) throw new w("Invalid atom header length");
+		return {
+			length: BigInt(r),
+			name: new m(4, "latin1").get(e, t + 4)
+		};
+	},
+	put: (e, t, r) => (n.put(e, t, Number(r.length)), y.put(e, t + 4, r.name))
+}, E = a, D = {
+	len: 4,
+	get: (e, t) => ({ type: new m(4, "ascii").get(e, t) })
+}, O = class {
+	constructor(e, t, n) {
+		if (e < t) throw new w(`Atom ${n} expected to be ${t}, but specifies ${e} bytes long.`);
+		e > t && C(`Warning: atom ${n} expected to be ${t}, but was actually ${e} bytes long.`), this.len = e;
+	}
+}, k = {
+	len: 4,
+	get: (e, t) => {
+		let r = n.get(e, t) - 2082844800;
+		return /* @__PURE__ */ new Date(r * 1e3);
+	}
+}, A = {
+	len: 8,
+	get: (e, t) => {
+		let n = Number(a.get(e, t)) - 2082844800;
+		return /* @__PURE__ */ new Date(n * 1e3);
+	}
+}, j = class extends O {
+	constructor(e) {
+		super(e, 24, "mdhd");
+	}
+	get(e, t) {
+		let i = r.get(e, t + 0), o = h.get(e, t + 1);
+		switch (i) {
+			case 0: return {
+				version: i,
+				flags: o,
+				creationTime: k.get(e, t + 4),
+				modificationTime: k.get(e, t + 8),
+				timeScale: n.get(e, t + 12),
+				duration: n.get(e, t + 16),
+				language: g.get(e, t + 20),
+				quality: g.get(e, t + 22)
+			};
+			case 1: return {
+				version: i,
+				flags: o,
+				creationTime: A.get(e, t + 4),
+				modificationTime: A.get(e, t + 12),
+				timeScale: n.get(e, t + 20),
+				duration: Number(a.get(e, t + 24)),
+				language: g.get(e, t + 32),
+				quality: g.get(e, t + 34)
+			};
+			default: throw new f("Invalid mdhd version header");
+		}
+	}
+}, M = class extends O {
+	constructor(e) {
+		super(e, 100, "mvhd");
+	}
+	get(e, t) {
+		let i = r.get(e, t), o = h.get(e, t + 1);
+		return i === 1 ? {
+			version: i,
+			flags: o,
+			creationTime: A.get(e, t + 4),
+			modificationTime: A.get(e, t + 12),
+			timeScale: n.get(e, t + 20),
+			duration: Number(a.get(e, t + 24)),
+			preferredRate: n.get(e, t + 32),
+			preferredVolume: g.get(e, t + 36),
+			previewTime: n.get(e, t + 84),
+			previewDuration: n.get(e, t + 88),
+			posterTime: n.get(e, t + 92),
+			selectionTime: n.get(e, t + 96),
+			selectionDuration: n.get(e, t + 100),
+			currentTime: n.get(e, t + 104),
+			nextTrackID: n.get(e, t + 108)
+		} : {
+			version: i,
+			flags: o,
+			creationTime: k.get(e, t + 4),
+			modificationTime: k.get(e, t + 8),
+			timeScale: n.get(e, t + 12),
+			duration: n.get(e, t + 16),
+			preferredRate: n.get(e, t + 20),
+			preferredVolume: g.get(e, t + 24),
+			previewTime: n.get(e, t + 72),
+			previewDuration: n.get(e, t + 76),
+			posterTime: n.get(e, t + 80),
+			selectionTime: n.get(e, t + 84),
+			selectionDuration: n.get(e, t + 88),
+			currentTime: n.get(e, t + 92),
+			nextTrackID: n.get(e, t + 96)
+		};
+	}
+}, te = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		return {
+			type: {
+				set: r.get(e, t + 0),
+				type: h.get(e, t + 1)
+			},
+			locale: h.get(e, t + 4),
+			value: new i(this.len - 8).get(e, t + 8)
+		};
+	}
+}, ne = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		return {
+			version: r.get(e, t),
+			flags: h.get(e, t + 1),
+			name: new m(this.len - 4, "utf-8").get(e, t + 4)
+		};
+	}
+}, re = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		return {
+			version: r.get(e, t),
+			flags: h.get(e, t + 1),
+			creationTime: k.get(e, t + 4),
+			modificationTime: k.get(e, t + 8),
+			trackId: n.get(e, t + 12),
+			duration: n.get(e, t + 20),
+			layer: g.get(e, t + 24),
+			alternateGroup: g.get(e, t + 26),
+			volume: g.get(e, t + 28)
+		};
+	}
+}, N = {
+	len: 8,
+	get: (e, t) => ({
+		version: r.get(e, t),
+		flags: h.get(e, t + 1),
+		numberOfEntries: n.get(e, t + 4)
+	})
+}, P = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		let n = this.len - 12;
+		return {
+			dataFormat: y.get(e, t),
+			dataReferenceIndex: g.get(e, t + 10),
+			description: n > 0 ? new i(n).get(e, t + 12) : void 0
+		};
+	}
+}, F = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		let r = N.get(e, t);
+		t += N.len;
+		let i = [];
+		for (let a = 0; a < r.numberOfEntries; ++a) {
+			let r = n.get(e, t);
+			t += n.len, i.push(new P(r - n.len).get(e, t)), t += r;
+		}
+		return {
+			header: r,
+			table: i
+		};
+	}
+}, I = {
+	len: 8,
+	get(e, t) {
+		return {
+			version: c.get(e, t),
+			revision: c.get(e, t + 2),
+			vendor: d.get(e, t + 4)
+		};
+	}
+}, L = {
+	len: 12,
+	get(e, t) {
+		return {
+			numAudioChannels: c.get(e, t + 0),
+			sampleSize: c.get(e, t + 2),
+			compressionId: c.get(e, t + 4),
+			packetSize: c.get(e, t + 6),
+			sampleRate: g.get(e, t + 8) + g.get(e, t + 10) / 1e4
+		};
+	}
+}, R = class {
+	constructor(e, t) {
+		this.len = e, this.token = t;
+	}
+	get(e, t) {
+		let n = d.get(e, t + 4);
+		return {
+			version: o.get(e, t + 0),
+			flags: l.get(e, t + 1),
+			numberOfEntries: n,
+			entries: K(e, this.token, t + 8, this.len - 8, n)
+		};
+	}
+}, z = {
+	len: 8,
+	get(e, t) {
+		return {
+			count: d.get(e, t + 0),
+			duration: d.get(e, t + 4)
+		};
+	}
+}, B = class extends R {
+	constructor(e) {
+		super(e, z);
+	}
+}, V = {
+	len: 12,
+	get(e, t) {
+		return {
+			firstChunk: d.get(e, t),
+			samplesPerChunk: d.get(e, t + 4),
+			sampleDescriptionId: d.get(e, t + 8)
+		};
+	}
+}, H = class extends R {
+	constructor(e) {
+		super(e, V);
+	}
+}, U = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		let n = d.get(e, t + 8);
+		return {
+			version: o.get(e, t),
+			flags: l.get(e, t + 1),
+			sampleSize: d.get(e, t + 4),
+			numberOfEntries: n,
+			entries: K(e, d, t + 12, this.len - 12, n)
+		};
+	}
+}, W = class extends R {
+	constructor(e) {
+		super(e, d), this.len = e;
+	}
+}, G = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		return new m(c.get(e, t + 0), "utf-8").get(e, t + 2);
+	}
+};
+function K(e, t, n, r, i) {
+	if (C(`remainingLen=${r}, numberOfEntries=${i} * token-len=${t.len}`), r === 0) return [];
+	if (r !== i * t.len) throw new w("mismatch number-of-entries with remaining atom-length");
+	let a = [];
+	for (let r = 0; r < i; ++r) a.push(t.get(e, n)), n += t.len;
+	return a;
+}
+var q = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		let r = t + 1, i = {
+			version: o.get(e, t),
+			flags: {
+				baseDataOffsetPresent: _(e, r + 2, 0),
+				sampleDescriptionIndexPresent: _(e, r + 2, 1),
+				defaultSampleDurationPresent: _(e, r + 2, 3),
+				defaultSampleSizePresent: _(e, r + 2, 4),
+				defaultSampleFlagsPresent: _(e, r + 2, 5),
+				defaultDurationIsEmpty: _(e, r, 0),
+				defaultBaseIsMoof: _(e, r, 1)
+			},
+			trackId: n.get(e, 4)
+		}, s = 8;
+		return i.flags.baseDataOffsetPresent && (i.baseDataOffset = a.get(e, s), s += 8), i.flags.sampleDescriptionIndexPresent && (i.sampleDescriptionIndex = n.get(e, s), s += 4), i.flags.defaultSampleDurationPresent && (i.defaultSampleDuration = n.get(e, s), s += 4), i.flags.defaultSampleSizePresent && (i.defaultSampleSize = n.get(e, s), s += 4), i.flags.defaultSampleFlagsPresent && (i.defaultSampleFlags = n.get(e, s)), i;
+	}
+}, J = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		let r = t + 1, i = {
+			version: o.get(e, t),
+			flags: {
+				dataOffsetPresent: _(e, r + 2, 0),
+				firstSampleFlagsPresent: _(e, r + 2, 2),
+				sampleDurationPresent: _(e, r + 1, 0),
+				sampleSizePresent: _(e, r + 1, 1),
+				sampleFlagsPresent: _(e, r + 1, 2),
+				sampleCompositionTimeOffsetsPresent: _(e, r + 1, 3)
+			},
+			sampleCount: n.get(e, t + 4),
+			samples: []
+		}, a = t + 8;
+		i.flags.dataOffsetPresent && (i.dataOffset = n.get(e, a), a += 4), i.flags.firstSampleFlagsPresent && (i.firstSampleFlags = n.get(e, a), a += 4);
+		for (let t = 0; t < i.sampleCount; ++t) {
+			if (a >= this.len) {
+				C("TrackRunBox size mismatch");
+				break;
+			}
+			let t = {};
+			i.flags.sampleDurationPresent && (t.sampleDuration = n.get(e, a), a += 4), i.flags.sampleSizePresent && (t.sampleSize = n.get(e, a), a += 4), i.flags.sampleFlagsPresent && (t.sampleFlags = n.get(e, a), a += 4), i.flags.sampleCompositionTimeOffsetsPresent && (t.sampleCompositionTimeOffset = n.get(e, a), a += 4), i.samples.push(t);
+		}
+		return i;
+	}
+}, Y = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		t + 1;
+		let n = new m(4, "utf-8");
+		return {
+			version: o.get(e, t),
+			flags: h.get(e, t + 1),
+			componentType: n.get(e, t + 4),
+			handlerType: n.get(e, t + 8),
+			componentName: new m(this.len - 28, "utf-8").get(e, t + 28)
+		};
+	}
+}, ie = class {
+	constructor(e) {
+		this.len = e;
+	}
+	get(e, t) {
+		let r = 0, i = [];
+		for (; r < this.len;) i.push(n.get(e, t + r)), r += 4;
+		return i;
+	}
+}, X = (0, S.default)("music-metadata:parser:MP4:Atom"), ae = class e {
+	static async readAtom(t, n, r, i) {
+		let a = t.position;
+		X(`Reading next token on offset=${a}...`);
+		let o = await t.readToken(T), s = o.length === 1n;
+		s && (o.length = await t.readToken(E));
+		let c = new e(o, s, r), l = c.getPayloadLength(i);
+		return X(`parse atom name=${c.atomPath}, extended=${c.extended}, offset=${a}, len=${c.header.length}`), await c.readData(t, n, l), c;
+	}
+	constructor(e, t, n) {
+		this.header = e, this.extended = t, this.parent = n, this.children = [], this.atomPath = (this.parent ? `${this.parent.atomPath}.` : "") + this.header.name;
+	}
+	getHeaderLength() {
+		return this.extended ? 16 : 8;
+	}
+	getPayloadLength(e) {
+		return (this.header.length === 0n ? e : Number(this.header.length)) - this.getHeaderLength();
+	}
+	async readAtoms(t, n, r) {
+		for (var i = this; r > 0;) {
+			let a = await e.readAtom(t, n, i, r);
+			i.children.push(a), r -= a.header.length === 0n ? r : Number(a.header.length);
+		}
+	}
+	async readData(e, t, n) {
+		var r = this;
+		switch (r.header.name) {
+			case "moov":
+			case "udta":
+			case "mdia":
+			case "minf":
+			case "stbl":
+			case "<id>":
+			case "ilst":
+			case "tref":
+			case "moof": return r.readAtoms(e, t, r.getPayloadLength(n));
+			case "meta": {
+				let i = (await e.peekToken(T)).name === "hdlr" ? 0 : 4;
+				return await e.ignore(i), r.readAtoms(e, t, r.getPayloadLength(n) - i);
+			}
+			default: return t(r, n);
+		}
+	}
+}, Z = (0, S.default)("music-metadata:parser:MP4"), oe = "iTunes", Q = {
+	raw: {
+		lossy: !1,
+		format: "raw"
+	},
+	MAC3: {
+		lossy: !0,
+		format: "MACE 3:1"
+	},
+	MAC6: {
+		lossy: !0,
+		format: "MACE 6:1"
+	},
+	ima4: {
+		lossy: !0,
+		format: "IMA 4:1"
+	},
+	ulaw: {
+		lossy: !0,
+		format: "uLaw 2:1"
+	},
+	alaw: {
+		lossy: !0,
+		format: "uLaw 2:1"
+	},
+	Qclp: {
+		lossy: !0,
+		format: "QUALCOMM PureVoice"
+	},
+	".mp3": {
+		lossy: !0,
+		format: "MPEG-1 layer 3"
+	},
+	alac: {
+		lossy: !1,
+		format: "ALAC"
+	},
+	"ac-3": {
+		lossy: !0,
+		format: "AC-3"
+	},
+	mp4a: {
+		lossy: !0,
+		format: "MPEG-4/AAC"
+	},
+	mp4s: {
+		lossy: !0,
+		format: "MP4S"
+	},
+	c608: {
+		lossy: !0,
+		format: "CEA-608"
+	},
+	c708: {
+		lossy: !0,
+		format: "CEA-708"
+	}
+};
+function $(e, t, n) {
+	return n.indexOf(e) === t;
+}
+var se = class e extends ee {
+	constructor() {
+		var e;
+		super(...arguments), e = this, this.tracks = /* @__PURE__ */ new Map(), this.hasVideoTrack = !1, this.hasAudioTrack = !0, this.atomParsers = {
+			mvhd: async (t) => {
+				let n = await e.tokenizer.readToken(new M(t));
+				e.metadata.setFormat("creationTime", n.creationTime), e.metadata.setFormat("modificationTime", n.modificationTime);
+			},
+			chap: async (t) => {
+				let r = e.getTrackDescription(), i = [];
+				for (; t >= n.len;) i.push(await e.tokenizer.readNumber(n)), t -= n.len;
+				r.chapterList = i;
+			},
+			mdat: async (t) => {
+				if (e.options.includeChapters) {
+					let n = [...e.tracks.values()].filter((e) => e.chapterList);
+					if (n.length === 1) {
+						let r = n[0].chapterList, i = [...e.tracks.values()].filter((e) => r.indexOf(e.header.trackId) !== -1);
+						if (i.length === 1) return e.parseChapterTrack(i[0], n[0], t);
+					}
+				}
+				await e.tokenizer.ignore(t);
+			},
+			ftyp: async (t) => {
+				let n = [];
+				for (; t > 0;) {
+					let r = await e.tokenizer.readToken(D);
+					t -= D.len;
+					let i = r.type.replace(/\W/g, "");
+					i.length > 0 && n.push(i);
+				}
+				Z(`ftyp: ${n.join("/")}`);
+				let r = n.filter($).join("/");
+				e.metadata.setFormat("container", r);
+			},
+			stsd: async (t) => {
+				let n = await e.tokenizer.readToken(new F(t)), r = e.getTrackDescription();
+				r.soundSampleDescription = n.table.map((t) => e.parseSoundSampleDescription(t));
+			},
+			stsz: async (t) => {
+				let n = await e.tokenizer.readToken(new U(t)), r = e.getTrackDescription();
+				r.sampleSize = n.sampleSize, r.sampleSizeTable = n.entries;
+			},
+			date: async (t) => {
+				let n = await e.tokenizer.readToken(new m(t, "utf-8"));
+				await e.addTag("date", n);
+			}
+		};
+	}
+	static read_BE_Integer(e, t) {
+		let n = (t ? "INT" : "UINT") + e.length * 8 + (e.length > 1 ? "_BE" : ""), r = u[n];
+		if (!r) throw new w(`Token for integer type not found: "${n}"`);
+		return Number(r.get(e, 0));
+	}
+	async parse() {
+		var e = this;
+		e.hasVideoTrack = !1, e.hasAudioTrack = !0, e.tracks.clear();
+		let t = e.tokenizer.fileInfo.size || 0;
+		for (; !e.tokenizer.fileInfo.size || t > 0;) {
+			try {
+				if ((await e.tokenizer.peekToken(T)).name === "\0\0\0\0") {
+					let t = `Error at offset=${e.tokenizer.position}: box.id=0`;
+					Z(t), e.addWarning(t);
+					break;
+				}
+			} catch (t) {
+				if (t instanceof Error) {
+					let n = `Error at offset=${e.tokenizer.position}: ${t.message}`;
+					Z(n), e.addWarning(n);
+				} else throw t;
+				break;
+			}
+			let n = await ae.readAtom(e.tokenizer, (t, n) => e.handleAtom(t, n), null, t);
+			t -= n.header.length === BigInt(0) ? t : Number(n.header.length);
+		}
+		let n = [];
+		e.tracks.forEach((t) => {
+			let r = [];
+			t.soundSampleDescription.forEach((t) => {
+				let n = {}, i = Q[t.dataFormat];
+				if (i ? (r.push(i.format), n.codecName = i.format) : n.codecName = `<${t.dataFormat}>`, t.description) {
+					let { description: e } = t;
+					e.sampleRate > 0 && (n.type = x.audio, n.audio = {
+						samplingFrequency: e.sampleRate,
+						bitDepth: e.sampleSize,
+						channels: e.numAudioChannels
+					});
+				}
+				e.metadata.addStreamInfo(n);
+			}), r.length >= 1 && n.push(r.join("/"));
+		}), n.length > 0 && e.metadata.setFormat("codec", n.filter($).join("+"));
+		let r = [...e.tracks.values()].filter((e) => e.soundSampleDescription.length >= 1 && e.soundSampleDescription[0].description && e.soundSampleDescription[0].description.numAudioChannels > 0);
+		for (let t of r) {
+			if (t.media.header && t.media.header.timeScale > 0) if (t.sampleRate = t.media.header.timeScale, t.media.header.duration > 0 && (Z("Using duration defined on audio track"), t.samples = t.media.header.duration, t.duration = t.samples / t.sampleRate), t.fragments.length > 0) {
+				Z("Calculate duration defined in track fragments");
+				let e = 0;
+				t.sizeInBytes = 0;
+				for (let n of t.fragments) for (let r of n.trackRun.samples) {
+					var i, a, o, s;
+					let c = (i = (a = r.sampleDuration) == null ? n.header.defaultSampleDuration : a) == null ? 0 : i, l = (o = (s = r.sampleSize) == null ? n.header.defaultSampleSize : s) == null ? 0 : o;
+					if (c === 0) throw Error("Missing sampleDuration and no defaultSampleDuration in track fragment header");
+					if (l === 0) throw Error("Missing sampleSize and no defaultSampleSize in track fragment header");
+					e += c, t.sizeInBytes += l;
+				}
+				t.samples || (t.samples = e), t.duration || (t.duration = e / t.sampleRate);
+			} else t.sampleSizeTable.length > 0 && (t.sizeInBytes = t.sampleSizeTable.reduce((e, t) => e + t, 0));
+			let n = t.soundSampleDescription[0];
+			n.description && t.media.header && (e.metadata.setFormat("sampleRate", n.description.sampleRate), e.metadata.setFormat("bitsPerSample", n.description.sampleSize), e.metadata.setFormat("numberOfChannels", n.description.numAudioChannels), t.media.header.timeScale === 0 && t.timeToSampleTable.length > 0 && (t.duration = t.timeToSampleTable.map((e) => e.count * e.duration).reduce((e, t) => e + t) / n.description.sampleRate));
+			let r = Q[n.dataFormat];
+			r && e.metadata.setFormat("lossless", !r.lossy);
+		}
+		if (r.length >= 1) {
+			let t = r[0];
+			t.duration && (e.metadata.setFormat("duration", t.duration), t.sizeInBytes && e.metadata.setFormat("bitrate", 8 * t.sizeInBytes / t.duration));
+		}
+		e.metadata.setFormat("hasAudio", e.hasAudioTrack), e.metadata.setFormat("hasVideo", e.hasVideoTrack);
+	}
+	async handleAtom(e, t) {
+		var n = this;
+		if (e.parent) switch (e.parent.header.name) {
+			case "ilst":
+			case "<id>": return n.parseMetadataItemData(e);
+			case "moov":
+				switch (e.header.name) {
+					case "trak": return n.parseTrackBox(e);
+					case "udta": return n.parseTrackBox(e);
+				}
+				break;
+			case "moof": switch (e.header.name) {
+				case "traf": return n.parseTrackFragmentBox(e);
+			}
+		}
+		if (n.atomParsers[e.header.name]) return n.atomParsers[e.header.name](t);
+		Z(`No parser for atom path=${e.atomPath}, payload-len=${t}, ignoring atom`), await n.tokenizer.ignore(t);
+	}
+	getTrackDescription() {
+		let e = [...this.tracks.values()];
+		return e[e.length - 1];
+	}
+	async addTag(e, t) {
+		await this.metadata.addTag(oe, e, t);
+	}
+	addWarning(e) {
+		Z(`Warning: ${e}`), this.metadata.addWarning(e);
+	}
+	parseMetadataItemData(e) {
+		var n = this;
+		let r = e.header.name;
+		return e.readAtoms(this.tokenizer, async (e, a) => {
+			let o = e.getPayloadLength(a);
+			switch (e.header.name) {
+				case "data": return n.parseValueAtom(r, e);
+				case "name":
+				case "mean":
+				case "rate": {
+					let e = await n.tokenizer.readToken(new ne(o));
+					r += `:${e.name}`;
+					break;
+				}
+				default: {
+					let a = await n.tokenizer.readToken(new i(o));
+					n.addWarning(`Unsupported meta-item: ${r}[${e.header.name}] => value=${v(a)} ascii=${t(a, "ascii")}`);
+				}
+			}
+		}, e.getPayloadLength(0));
+	}
+	async parseValueAtom(i, a) {
+		var o = this;
+		let s = await o.tokenizer.readToken(new te(Number(a.header.length) - T.len));
+		if (s.type.set !== 0) throw new w(`Unsupported type-set != 0: ${s.type.set}`);
+		switch (s.type.type) {
+			case 0:
+				switch (i) {
+					case "trkn":
+					case "disk": {
+						let e = r.get(s.value, 3), t = r.get(s.value, 5);
+						await o.addTag(i, `${e}/${t}`);
+						break;
+					}
+					case "gnre": {
+						let e = b[r.get(s.value, 1) - 1];
+						await o.addTag(i, e);
+						break;
+					}
+					case "rate": {
+						let e = t(s.value, "ascii");
+						await o.addTag(i, e);
+						break;
+					}
+					default: Z(`unknown proprietary value type for: ${a.atomPath}`);
+				}
+				break;
+			case 1:
+			case 18:
+				await o.addTag(i, t(s.value));
+				break;
+			case 13:
+				if (o.options.skipCovers) break;
+				await o.addTag(i, {
+					format: "image/jpeg",
+					data: Uint8Array.from(s.value)
+				});
+				break;
+			case 14:
+				if (o.options.skipCovers) break;
+				await o.addTag(i, {
+					format: "image/png",
+					data: Uint8Array.from(s.value)
+				});
+				break;
+			case 21:
+				await o.addTag(i, e.read_BE_Integer(s.value, !0));
+				break;
+			case 22:
+				await o.addTag(i, e.read_BE_Integer(s.value, !1));
+				break;
+			case 65:
+				await o.addTag(i, r.get(s.value, 0));
+				break;
+			case 66:
+				await o.addTag(i, g.get(s.value, 0));
+				break;
+			case 67:
+				await o.addTag(i, n.get(s.value, 0));
+				break;
+			default: o.addWarning(`atom key=${i}, has unknown well-known-type (data-type): ${s.type.type}`);
+		}
+	}
+	async parseTrackBox(e) {
+		var t = this;
+		let n = {
+			media: {},
+			fragments: []
+		};
+		await e.readAtoms(t.tokenizer, async (e, r) => {
+			let i = e.getPayloadLength(r);
+			switch (e.header.name) {
+				case "chap":
+					n.chapterList = await t.tokenizer.readToken(new ie(r));
+					break;
+				case "tkhd":
+					n.header = await t.tokenizer.readToken(new re(i));
+					break;
+				case "hdlr":
+					n.handler = await t.tokenizer.readToken(new Y(i)), n.isAudio = () => n.handler.handlerType === "audi" || n.handler.handlerType === "soun", n.isVideo = () => n.handler.handlerType === "vide", n.isAudio() ? t.hasAudioTrack = !0 : n.isVideo() && (t.hasVideoTrack = !0);
+					break;
+				case "mdhd": {
+					let e = await t.tokenizer.readToken(new j(i));
+					n.media.header = e;
+					break;
+				}
+				case "stco":
+					n.chunkOffsetTable = (await t.tokenizer.readToken(new W(i))).entries;
+					break;
+				case "stsc":
+					n.sampleToChunkTable = (await t.tokenizer.readToken(new H(i))).entries;
+					break;
+				case "stsd":
+					n.soundSampleDescription = (await t.tokenizer.readToken(new F(i))).table.map((e) => t.parseSoundSampleDescription(e));
+					break;
+				case "stts":
+					n.timeToSampleTable = (await t.tokenizer.readToken(new B(i))).entries;
+					break;
+				case "stsz": {
+					let e = await t.tokenizer.readToken(new U(i));
+					n.sampleSize = e.sampleSize, n.sampleSizeTable = e.entries;
+					break;
+				}
+				case "dinf":
+				case "vmhd":
+				case "smhd":
+					Z(`Ignoring: ${e.header.name}`), await t.tokenizer.ignore(i);
+					break;
+				default: Z(`Unexpected track box: ${e.header.name}`), await t.tokenizer.ignore(i);
+			}
+		}, e.getPayloadLength(0)), t.tracks.set(n.header.trackId, n);
+	}
+	parseTrackFragmentBox(e) {
+		var t = this;
+		let n;
+		return e.readAtoms(this.tokenizer, async (e, r) => {
+			let i = e.getPayloadLength(r);
+			switch (e.header.name) {
+				case "tfhd": {
+					let i = new q(e.getPayloadLength(r));
+					n = await t.tokenizer.readToken(i);
+					break;
+				}
+				case "tfdt":
+					await t.tokenizer.ignore(i);
+					break;
+				case "trun": {
+					let e = new J(i), r = await t.tokenizer.readToken(e);
+					if (n) {
+						let e = t.tracks.get(n.trackId);
+						e == null || e.fragments.push({
+							header: n,
+							trackRun: r
+						});
+					}
+					break;
+				}
+				default: Z(`Unexpected box: ${e.header.name}`), await t.tokenizer.ignore(i);
+			}
+		}, e.getPayloadLength(0));
+	}
+	parseSoundSampleDescription(e) {
+		let t = {
+			dataFormat: e.dataFormat,
+			dataReferenceIndex: e.dataReferenceIndex
+		}, n = 0;
+		if (e.description) {
+			let r = I.get(e.description, n);
+			n += I.len, r.version === 0 || r.version === 1 ? t.description = L.get(e.description, n) : Z(`Warning: sound-sample-description ${r} not implemented`);
+		}
+		return t;
+	}
+	async parseChapterTrack(e, t, n) {
+		var r = this;
+		if (!e.sampleSize && e.chunkOffsetTable.length !== e.sampleSizeTable.length) throw Error("Expected equal chunk-offset-table & sample-size-table length.");
+		let i = [];
+		for (let a = 0; a < e.chunkOffsetTable.length && n > 0; ++a) {
+			let o = e.timeToSampleTable.slice(0, a).reduce((e, t) => e + t.duration, 0), s = e.chunkOffsetTable[a] - r.tokenizer.position, c = e.sampleSize > 0 ? e.sampleSize : e.sampleSizeTable[a];
+			if (n -= s + c, n < 0) throw new w("Chapter chunk exceeding token length");
+			await r.tokenizer.ignore(s);
+			let l = await r.tokenizer.readToken(new G(c));
+			Z(`Chapter ${a + 1}: ${l}`);
+			let u = {
+				title: l,
+				timeScale: e.media.header ? e.media.header.timeScale : 0,
+				start: o,
+				sampleOffset: r.findSampleOffset(t, r.tokenizer.position)
+			};
+			Z(`Chapter title=${u.title}, offset=${u.sampleOffset}/${t.header.duration}`), i.push(u);
+		}
+		r.metadata.setFormat("chapters", i), await r.tokenizer.ignore(n);
+	}
+	findSampleOffset(e, t) {
+		let n = 0;
+		for (; n < e.chunkOffsetTable.length && e.chunkOffsetTable[n] < t;) ++n;
+		return this.getChunkDuration(n + 1, e);
+	}
+	getChunkDuration(e, t) {
+		let n = 0, r = t.timeToSampleTable[n].count, i = t.timeToSampleTable[n].duration, a = 1, o = this.getSamplesPerChunk(a, t.sampleToChunkTable), s = 0;
+		for (; a < e;) {
+			let e = Math.min(r, o);
+			s += e * i, r -= e, o -= e, o === 0 ? (++a, o = this.getSamplesPerChunk(a, t.sampleToChunkTable)) : (++n, r = t.timeToSampleTable[n].count, i = t.timeToSampleTable[n].duration);
+		}
+		return s;
+	}
+	getSamplesPerChunk(e, t) {
+		for (let n = 0; n < t.length - 1; ++n) if (e >= t[n].firstChunk && e < t[n + 1].firstChunk) return t[n].samplesPerChunk;
+		return t[t.length - 1].samplesPerChunk;
+	}
+};
+//#endregion
+export { se as MP4Parser };