@svta/cml-iso-bmff 0.23.2 → 1.0.0-alpha.2

package/dist/index.js

@@ -1,6 +1,17 @@
-import { UTF_8, decodeText } from "@svta/cml-utils";
+import { UTF_8, decodeText, encodeText } from "@svta/cml-utils";
 
-//#region src/CONTAINERS.ts
+//#region src/utils/createWriterConfig.ts
+function createWriterConfig(config) {
+	return { writers: config?.writers ?? {} };
+}
+
+//#endregion
+//#region src/utils/CONTAINERS.ts
+/**
+* List of container box types
+*
+* @public
+*/
 const CONTAINERS = [
 	"dinf",
 	"edts",
@@ -28,74 +39,1740 @@ const CONTAINERS = [
 ];
 
 //#endregion
-//#region src/fields/DATA.ts
+//#region src/utils/isContainer.ts
+/**
+* Check if a box is a container
+*
+* @param box - The box to check
+*
+* @returns `true` if the box is a container, `false` otherwise
+*
+* @public
+*/
+function isContainer(box) {
+	return "boxes" in box || CONTAINERS.includes(box.type);
+}
+
+//#endregion
+//#region src/fields/TEMPLATE.ts
+/**
+* The template field type
+*
+* @public
+*/
+const TEMPLATE = "template";
+
+//#endregion
+//#region src/fields/UINT.ts
+/**
+* The unsigned integer field type
+*
+* @public
+*/
+const UINT = "uint";
+
+//#endregion
+//#region src/IsoBoxWriteView.ts
+/**
+* A view for writing ISO BMFF data.
+*
+* @public
+*/
+var IsoBoxWriteView = class {
+	/**
+	* Constructs a new IsoBoxWriteView.
+	*
+	* @param size - The size of the data view.
+	*/
+	constructor(type, size) {
+		this.writeUint = (value, size$1) => {
+			const { dataView, cursor } = this;
+			switch (size$1) {
+				case 1:
+					dataView.setUint8(cursor, value);
+					break;
+				case 2:
+					dataView.setUint16(cursor, value);
+					break;
+				case 3: {
+					const s1 = (value & 16776960) >> 8;
+					const s2 = value & 255;
+					dataView.setUint16(cursor, s1);
+					dataView.setUint8(cursor + 2, s2);
+					break;
+				}
+				case 4:
+					dataView.setUint32(cursor, value);
+					break;
+				case 8: {
+					const s1 = Math.floor(value / Math.pow(2, 32));
+					const s2 = value - s1 * Math.pow(2, 32);
+					dataView.setUint32(cursor, s1);
+					dataView.setUint32(cursor + 4, s2);
+					break;
+				}
+			}
+			this.cursor += size$1;
+		};
+		this.writeInt = (value, size$1) => {
+			const { dataView, cursor } = this;
+			switch (size$1) {
+				case 1:
+					dataView.setInt8(cursor, value);
+					break;
+				case 2:
+					dataView.setInt16(cursor, value);
+					break;
+				case 4:
+					dataView.setInt32(cursor, value);
+					break;
+				case 8:
+					const s1 = Math.floor(value / Math.pow(2, 32));
+					const s2 = value - s1 * Math.pow(2, 32);
+					dataView.setUint32(cursor, s1);
+					dataView.setUint32(cursor + 4, s2);
+					break;
+			}
+			this.cursor += size$1;
+		};
+		this.writeString = (value) => {
+			for (let c = 0, len = value.length; c < len; c++) this.writeUint(value.charCodeAt(c), 1);
+		};
+		this.writeTerminatedString = (value) => {
+			if (value.length === 0) return;
+			for (let c = 0, len = value.length; c < len; c++) this.writeUint(value.charCodeAt(c), 1);
+			this.writeUint(0, 1);
+		};
+		this.writeUtf8TerminatedString = (value) => {
+			const bytes = encodeText(value);
+			new Uint8Array(this.dataView.buffer).set(bytes, this.cursor);
+			this.cursor += bytes.length;
+			this.writeUint(0, 1);
+		};
+		this.writeBytes = (data) => {
+			new Uint8Array(this.dataView.buffer).set(data, this.cursor);
+			this.cursor += data.length;
+		};
+		this.writeArray = (data, type$1, size$1, length) => {
+			const write = type$1 === UINT ? this.writeUint : type$1 === TEMPLATE ? this.writeTemplate : this.writeInt;
+			for (let i = 0; i < length; i++) write(data[i] ?? 0, size$1);
+		};
+		this.writeTemplate = (value, size$1) => {
+			const shift = size$1 === 4 ? 16 : 8;
+			const fixedPoint = Math.round(value * Math.pow(2, shift));
+			this.writeUint(fixedPoint, size$1);
+		};
+		this.writeBoxHeader = (type$1, size$1) => {
+			if (size$1 > 4294967295) {
+				this.writeUint(1, 4);
+				this.writeString(type$1);
+				this.writeUint(size$1, 8);
+			} else {
+				this.writeUint(size$1, 4);
+				this.writeString(type$1);
+			}
+		};
+		this.dataView = new DataView(new ArrayBuffer(size));
+		this.cursor = 0;
+		this.writeBoxHeader(type, size);
+	}
+	/**
+	* The buffer of the data view.
+	*
+	* @returns The buffer of the data view.
+	*/
+	get buffer() {
+		return this.dataView.buffer;
+	}
+	/**
+	* The length of the data view.
+	*
+	* @returns The length of the data view.
+	*/
+	get byteLength() {
+		return this.dataView.byteLength;
+	}
+	/**
+	* The offset of the data view.
+	*
+	* @returns The offset of the data view.
+	*/
+	get byteOffset() {
+		return this.dataView.byteOffset;
+	}
+	/**
+	* Writes a full box header to the data view.
+	*
+	* @param version - The version of the full box.
+	* @param flags - The flags of the full box.
+	*/
+	writeFullBox(version, flags) {
+		this.writeUint(version, 1);
+		this.writeUint(flags, 3);
+	}
+};
+
+//#endregion
+//#region src/writers/writeContainerBox.ts
+/**
+* Write a ContainerBox to an IsoBmffWriter.
+*
+* This function writes a container box with its child boxes. Child boxes are
+* extracted from the container box's `boxes` array and encoded using their `view` property.
+*
+* @param box - The ContainerBox to write
+*
+* @returns An IsoBmffWriter containing the encoded box
+*/
+function writeContainerBox(box, config) {
+	const children = [];
+	const headerSize = 8;
+	let childrenSize = 0;
+	for (const childBox of box.boxes) {
+		const view = writeIsoBox(childBox, config);
+		childrenSize += view.byteLength;
+		children.push(view);
+	}
+	const totalSize = headerSize + childrenSize;
+	const writer = new IsoBoxWriteView(box.type, totalSize);
+	for (const child of children) writer.writeBytes(child);
+	return writer;
+}
+
+//#endregion
+//#region src/writers/writeBox.ts
+/**
+* Write a box to a Uint8Array.
+*
+* @param box - The box to write
+* @param writers - The writers to use
+* @returns The written box
+*
+* @internal
+*/
+function writeBox(box, config) {
+	let view = null;
+	if ("type" in box) {
+		const { type } = box;
+		if (type !== "" && isContainer(box)) view = writeContainerBox(box, config);
+		else {
+			const writer = config.writers[type];
+			if (writer) view = writer(box, config);
+			else if ("view" in box) view = box.view;
+		}
+		if (!view) throw new Error(`No writer found for box type: ${type}`);
+	}
+	if ("buffer" in box) view = box;
+	if (!view) throw new Error("Invalid box");
+	return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+}
+
+//#endregion
+//#region src/writeIsoBox.ts
+/**
+* Write an ISO box to a Uint8Array.
+*
+* @param box - The box to write
+* @param writers - The writers to use
+* @returns The written box
+*
+* @public
+*/
+function writeIsoBox(box, config) {
+	return writeBox(box, createWriterConfig(config));
+}
+
+//#endregion
+//#region src/IsoBoxReadableStream.ts
+/**
+* A readable stream of ISO BMFF boxes as Uint8Arrays.
+*
+* @public
+*/
+var IsoBoxReadableStream = class extends ReadableStream {
+	/**
+	* Constructs a new IsoBoxReadableStream.
+	*
+	* @param boxes - The boxes to stream.
+	* @param config - The configuration for the stream.
+	*/
+	constructor(boxes, config = {}) {
+		const iterator = boxes[Symbol.iterator]();
+		const cfg = createWriterConfig(config);
+		function pull(controller) {
+			const desiredSize = controller.desiredSize ?? 0;
+			for (let i = 0; i < desiredSize; i++) {
+				const { value, done } = iterator.next();
+				if (done) controller.close();
+				else controller.enqueue(writeIsoBox(value, cfg));
+			}
+		}
+		super({
+			start: pull,
+			pull
+		});
+	}
+};
+
+//#endregion
+//#region src/createIsoBoxReadableStream.ts
+/**
+* Creates a ReadableStream of ISO BMFF boxes as Uint8Arrays.
+*
+* @param boxes - The boxes to stream.
+* @param config - The configuration for the stream.
+*
+* @returns A new IsoBoxReadableStream.
+*
+* @example
+* {@includeCode ../test/createIsoBoxReadableStream.test.ts#example}
+*
+* @public
+*/
+function createIsoBoxReadableStream(boxes, config = {}) {
+	return new IsoBoxReadableStream(boxes, config);
+}
+
+//#endregion
+//#region src/readers/readArdi.ts
+/**
+* Parse a AudioRenderingIndicationBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed AudioRenderingIndicationBox
+*
+* @public
+*/
+function readArdi(view) {
+	return {
+		type: "ardi",
+		...view.readFullBox(),
+		audioRenderingIndication: view.readUint(1)
+	};
+}
+
+//#endregion
+//#region src/readers/readAvc1.ts
+/**
+* Parse a VisualSampleEntryBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed VisualSampleEntryBox
+*
+* @public
+*/
+function readAvc1(view) {
+	const { readArray, readUint: readUint$1, readInt: readInt$1, readTemplate: readTemplate$1, readData: readData$1 } = view;
+	return {
+		type: "avc1",
+		reserved1: readArray(UINT, 1, 6),
+		dataReferenceIndex: readUint$1(2),
+		preDefined1: readUint$1(2),
+		reserved2: readUint$1(2),
+		preDefined2: readArray(UINT, 4, 3),
+		width: readUint$1(2),
+		height: readUint$1(2),
+		horizresolution: readTemplate$1(4),
+		vertresolution: readTemplate$1(4),
+		reserved3: readUint$1(4),
+		frameCount: readUint$1(2),
+		compressorName: readArray(UINT, 1, 32),
+		depth: readUint$1(2),
+		preDefined3: readInt$1(2),
+		config: readData$1(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readAvc2.ts
+/**
+* Parse a VisualSampleEntryBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed VisualSampleEntryBox
+*
+* @public
+*/
+function readAvc2(view) {
+	return {
+		...readAvc1(view),
+		type: "avc2"
+	};
+}
+
+//#endregion
+//#region src/readers/readAvc3.ts
+/**
+* Parse a VisualSampleEntryBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed VisualSampleEntryBox
+*
+* @public
+*/
+function readAvc3(view) {
+	return {
+		...readAvc1(view),
+		type: "avc3"
+	};
+}
+
+//#endregion
+//#region src/readers/readAvc4.ts
+/**
+* Parse a VisualSampleEntryBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed VisualSampleEntryBox
+*
+* @public
+*/
+function readAvc4(view) {
+	return {
+		...readAvc1(view),
+		type: "avc4"
+	};
+}
+
+//#endregion
+//#region src/readers/readCtts.ts
+/**
+* Parse a CompositionTimeToSampleBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed CompositionTimeToSampleBox
+*
+* @public
+*/
+function readCtts(view) {
+	const { version, flags } = view.readFullBox();
+	const read = version === 1 ? view.readInt : view.readUint;
+	const entryCount = view.readUint(4);
+	return {
+		type: "ctts",
+		version,
+		flags,
+		entryCount,
+		entries: view.readEntries(entryCount, () => ({
+			sampleCount: view.readUint(4),
+			sampleOffset: read(4)
+		}))
+	};
+}
+
+//#endregion
+//#region src/readers/readDref.ts
+/**
+* Parse a DataReferenceBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed DataReferenceBox
+*
+* @public
+*/
+function readDref(view) {
+	const { version, flags } = view.readFullBox();
+	const entryCount = view.readUint(4);
+	return {
+		type: "dref",
+		version,
+		flags,
+		entryCount,
+		entries: view.readBoxes(entryCount)
+	};
+}
+
+//#endregion
+//#region src/readers/readElng.ts
+/**
+* Parse a ExtendedLanguageBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed ExtendedLanguageBox
+*
+* @public
+*/
+function readElng(view) {
+	return {
+		type: "elng",
+		...view.readFullBox(),
+		extendedLanguage: view.readUtf8(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readElst.ts
+/**
+* Parse a Box from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed Box
+*
+* @public
+*/
+function readElst(view) {
+	const { version, flags } = view.readFullBox();
+	const size = version === 1 ? 8 : 4;
+	const entryCount = view.readUint(4);
+	return {
+		type: "elst",
+		version,
+		flags,
+		entryCount,
+		entries: view.readEntries(entryCount, () => ({
+			segmentDuration: view.readUint(size),
+			mediaTime: view.readInt(size),
+			mediaRateInteger: view.readInt(2),
+			mediaRateFraction: view.readInt(2)
+		}))
+	};
+}
+
+//#endregion
+//#region src/readers/readEmsg.ts
+/**
+* Parse an EventMessageBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed EventMessageBox
+*
+* @public
+*/
+function readEmsg(view) {
+	const { readUint: readUint$1, readString: readString$1, readData: readData$1 } = view;
+	const result = {
+		type: "emsg",
+		...view.readFullBox()
+	};
+	if (result.version == 1) {
+		result.timescale = readUint$1(4);
+		result.presentationTime = readUint$1(8);
+		result.eventDuration = readUint$1(4);
+		result.id = readUint$1(4);
+		result.schemeIdUri = readString$1(-1);
+		result.value = readString$1(-1);
+	} else {
+		result.schemeIdUri = readString$1(-1);
+		result.value = readString$1(-1);
+		result.timescale = readUint$1(4);
+		result.presentationTimeDelta = readUint$1(4);
+		result.eventDuration = readUint$1(4);
+		result.id = readUint$1(4);
+	}
+	result.messageData = readData$1(-1);
+	return result;
+}
+
+//#endregion
+//#region src/readers/readMp4a.ts
+/**
+* Parse an AudioSampleEntry from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed AudioSampleEntry
+*
+* @public
+*/
+function readMp4a(view) {
+	const { readArray, readUint: readUint$1, readTemplate: readTemplate$1, readData: readData$1 } = view;
+	return {
+		type: "mp4a",
+		reserved1: readArray(UINT, 1, 6),
+		dataReferenceIndex: readUint$1(2),
+		reserved2: readArray(UINT, 4, 2),
+		channelcount: readUint$1(2),
+		samplesize: readUint$1(2),
+		preDefined: readUint$1(2),
+		reserved3: readUint$1(2),
+		samplerate: readTemplate$1(4),
+		esds: readData$1(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readEnca.ts
+/**
+* Parse an AudioSampleEntry from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed AudioSampleEntry
+*
+* @public
+*/
+function readEnca(view) {
+	return {
+		...readMp4a(view),
+		type: "enca"
+	};
+}
+
+//#endregion
+//#region src/readers/readEncv.ts
+/**
+* Parse a VisualSampleEntryBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed VisualSampleEntryBox
+*
+* @public
+*/
+function readEncv(view) {
+	return {
+		...readAvc1(view),
+		type: "encv"
+	};
+}
+
+//#endregion
+//#region src/readers/readFree.ts
+/**
+* Parse a Box from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed Box
+*
+* @public
+*/
+function readFree(view) {
+	return {
+		type: "free",
+		data: view.readData(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readFrma.ts
+/**
+* Parse an OriginalFormatBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed OriginalFormatBox
+*
+* @public
+*/
+function readFrma(view) {
+	return {
+		type: "frma",
+		dataFormat: view.readUint(4)
+	};
+}
+
+//#endregion
+//#region src/fields/STRING.ts
+/**
+* The string field type
+*
+* @public
+*/
+const STRING = "string";
+
+//#endregion
+//#region src/readers/readFtyp.ts
+/**
+* Parse a FileTypeBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed FileTypeBox
+*
+* @public
+*/
+function readFtyp(view) {
+	const size = 4;
+	const majorBrand = view.readString(4);
+	const minorVersion = view.readUint(4);
+	const length = view.bytesRemaining / size;
+	return {
+		type: "ftyp",
+		majorBrand,
+		minorVersion,
+		compatibleBrands: view.readArray(STRING, size, length)
+	};
+}
+
+//#endregion
+//#region src/readers/readHdlr.ts
+/**
+* Parse a HandlerReferenceBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed HandlerReferenceBox
+*
+* @public
+*/
+function readHdlr(view) {
+	return {
+		type: "hdlr",
+		...view.readFullBox(),
+		preDefined: view.readUint(4),
+		handlerType: view.readString(4),
+		reserved: view.readArray(UINT, 4, 3),
+		name: view.readString(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readHev1.ts
+/**
+* Parse a VisualSampleEntryBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed VisualSampleEntryBox
+*
+* @public
+*/
+function readHev1(view) {
+	return {
+		...readAvc1(view),
+		type: "hev1"
+	};
+}
+
+//#endregion
+//#region src/readers/readHvc1.ts
+/**
+* Parse a VisualSampleEntryBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed VisualSampleEntryBox
+*
+* @public
+*/
+function readHvc1(view) {
+	return {
+		...readAvc1(view),
+		type: "hvc1"
+	};
+}
+
+//#endregion
+//#region src/readers/readIden.ts
+/**
+* Parse a WebVTTCueIdBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed WebVTTCueIdBox
+*
+* @public
+*/
+function readIden(view) {
+	return {
+		type: "iden",
+		cueId: view.readUtf8(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readImda.ts
+/**
+* Parse a IdentifiedMediaDataBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed IdentifiedMediaDataBox
+*
+* @public
+*/
+function readImda(view) {
+	return {
+		type: "imda",
+		imdaIdentifier: view.readUint(4),
+		data: view.readData(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readKind.ts
+/**
+* Parse a TrackKinBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed TrackKindBox
+*
+* @public
+*/
+function readKind(view) {
+	return {
+		type: "kind",
+		...view.readFullBox(),
+		schemeUri: view.readUtf8(-1),
+		value: view.readUtf8(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readLabl.ts
+/**
+* Parse a LabelBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed LabelBox
+*
+* @public
+*/
+function readLabl(view) {
+	const { version, flags } = view.readFullBox();
+	return {
+		type: "labl",
+		version,
+		flags,
+		isGroupLabel: (flags & 1) !== 0,
+		labelId: view.readUint(2),
+		language: view.readUtf8(-1),
+		label: view.readUtf8(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readMdat.ts
+/**
+* Parse a MediaDataBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed MediaDataBox
+*
+* @public
+*/
+function readMdat(view) {
+	return {
+		type: "mdat",
+		data: view.readData(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readMdhd.ts
+/**
+* Parse a MediaHeaderBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed MediaHeaderBox
+*
+* @public
+*/
+function readMdhd(view) {
+	const { version, flags } = view.readFullBox();
+	const creationTime = view.readUint(version == 1 ? 8 : 4);
+	const modificationTime = view.readUint(version == 1 ? 8 : 4);
+	const timescale = view.readUint(4);
+	const duration = view.readUint(version == 1 ? 8 : 4);
+	const lang = view.readUint(2);
+	return {
+		type: "mdhd",
+		version,
+		flags,
+		creationTime,
+		modificationTime,
+		timescale,
+		duration,
+		language: String.fromCharCode((lang >> 10 & 31) + 96, (lang >> 5 & 31) + 96, (lang & 31) + 96),
+		preDefined: view.readUint(2)
+	};
+}
+
+//#endregion
+//#region src/readers/readMehd.ts
+/**
+* Parse a MovieExtendsHeaderBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed MovieExtendsHeaderBox
+*
+* @public
+*/
+function readMehd(view) {
+	const { version, flags } = view.readFullBox();
+	return {
+		type: "mehd",
+		version,
+		flags,
+		fragmentDuration: view.readUint(version === 1 ? 8 : 4)
+	};
+}
+
+//#endregion
+//#region src/readers/readMeta.ts
+/**
+* Parse a MetaBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed MetaBox
+*
+* @public
+*/
+function readMeta(view) {
+	return {
+		type: "meta",
+		...view.readFullBox(),
+		boxes: view.readBoxes()
+	};
+}
+
+//#endregion
+//#region src/readers/readMfhd.ts
+/**
+* Parse a MovieFragmentHeaderBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed MovieFragmentHeaderBox
+*
+* @public
+*/
+function readMfhd(view) {
+	return {
+		type: "mfhd",
+		...view.readFullBox(),
+		sequenceNumber: view.readUint(4)
+	};
+}
+
+//#endregion
+//#region src/readers/readMfro.ts
+/**
+* Parse a MovieFragmentRandomAccessBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed MovieFragmentRandomAccessBox
+*
+* @public
+*/
+function readMfro(view) {
+	return {
+		type: "mfro",
+		...view.readFullBox(),
+		mfraSize: view.readUint(4)
+	};
+}
+
+//#endregion
+//#region src/readers/readMvhd.ts
+/**
+* Parse a Box from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed Box
+*
+* @public
+*/
+function readMvhd(view) {
+	const { readUint: readUint$1, readTemplate: readTemplate$1, readArray } = view;
+	const { version, flags } = view.readFullBox();
+	const size = version == 1 ? 8 : 4;
+	return {
+		type: "mvhd",
+		version,
+		flags,
+		creationTime: readUint$1(size),
+		modificationTime: readUint$1(size),
+		timescale: readUint$1(4),
+		duration: readUint$1(size),
+		rate: readTemplate$1(4),
+		volume: readTemplate$1(2),
+		reserved1: readUint$1(2),
+		reserved2: readArray(UINT, 4, 2),
+		matrix: readArray(TEMPLATE, 4, 9),
+		preDefined: readArray(UINT, 4, 6),
+		nextTrackId: readUint$1(4)
+	};
+}
+
+//#endregion
+//#region src/readers/readPayl.ts
+/**
+* Parse a WebVTTCuePayloadBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed WebVTTCuePayloadBox
+*
+* @public
+*/
+function readPayl(view) {
+	return {
+		type: "payl",
+		cueText: view.readUtf8(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readPrft.ts
+/**
+* Parse a ProducerReferenceTimeBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed ProducerReferenceTimeBox
+*
+* @public
+*/
+function readPrft(view) {
+	const { version, flags } = view.readFullBox();
+	return {
+		type: "prft",
+		version,
+		flags,
+		referenceTrackId: view.readUint(4),
+		ntpTimestampSec: view.readUint(4),
+		ntpTimestampFrac: view.readUint(4),
+		mediaTime: view.readUint(version === 1 ? 8 : 4)
+	};
+}
+
+//#endregion
+//#region src/readers/readPrsl.ts
+/**
+* Parse a PreselectionGroupBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed PreselectionGroupBox
+*
+* @public
+*/
+function readPrsl(view) {
+	const { version, flags } = view.readFullBox();
+	const groupId = view.readUint(4);
+	const numEntitiesInGroup = view.readUint(4);
+	return {
+		type: "prsl",
+		version,
+		flags,
+		groupId,
+		numEntitiesInGroup,
+		entities: view.readEntries(numEntitiesInGroup, () => ({ entityId: view.readUint(4) })),
+		preselectionTag: flags & 4096 ? view.readUtf8(-1) : void 0,
+		selectionPriority: flags & 8192 ? view.readUint(1) : void 0,
+		interleavingTag: flags & 16384 ? view.readUtf8(-1) : void 0
+	};
+}
+
+//#endregion
+//#region src/readers/readPssh.ts
+/**
+* Parse a ProtectionSystemSpecificHeaderBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed ProtectionSystemSpecificHeaderBox
+*
+* @public
+*/
+function readPssh(view) {
+	const { readUint: readUint$1, readArray } = view;
+	const { version, flags } = view.readFullBox();
+	const systemId = readArray(UINT, 1, 16);
+	let kidCount = 0;
+	let kid = [];
+	if (version > 0) {
+		kidCount = readUint$1(4);
+		kid = readArray(UINT, 1, kidCount);
+	}
+	const dataSize = readUint$1(4);
+	const data = readArray(UINT, 1, dataSize);
+	return {
+		type: "pssh",
+		version,
+		flags,
+		systemId,
+		kidCount,
+		kid,
+		dataSize,
+		data
+	};
+}
+
+//#endregion
+//#region src/readers/readSchm.ts
+/**
+* Parse a SchemeTypeBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed SchemeTypeBox
+*
+* @public
+*/
+function readSchm(view) {
+	const { version, flags } = view.readFullBox();
+	return {
+		type: "schm",
+		version,
+		flags,
+		schemeType: view.readUint(4),
+		schemeVersion: view.readUint(4),
+		schemeUri: flags & 1 ? view.readString(-1) : void 0
+	};
+}
+
+//#endregion
+//#region src/readers/readSdtp.ts
+/**
+* Parse a SampleDependencyTypeBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed SampleDependencyTypeBox
+*
+* @public
+*/
+function readSdtp(view) {
+	return {
+		type: "sdtp",
+		...view.readFullBox(),
+		sampleDependencyTable: view.readArray(UINT, 1, view.bytesRemaining)
+	};
+}
+
+//#endregion
+//#region src/readers/readSidx.ts
+/**
+* Parse a SegmentIndexBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed SegmentIndexBox
+*
+* @public
+*/
+function readSidx(view) {
+	const { readUint: readUint$1 } = view;
+	const { version, flags } = view.readFullBox();
+	const size = version === 1 ? 8 : 4;
+	const referenceId = readUint$1(4);
+	const timescale = readUint$1(4);
+	const earliestPresentationTime = readUint$1(size);
+	const firstOffset = readUint$1(size);
+	const reserved = readUint$1(2);
+	const referenceCount = readUint$1(2);
+	return {
+		type: "sidx",
+		version,
+		flags,
+		referenceId,
+		timescale,
+		earliestPresentationTime,
+		firstOffset,
+		reserved,
+		references: view.readEntries(referenceCount, () => {
+			const entry = {};
+			entry.reference = readUint$1(4);
+			entry.subsegmentDuration = readUint$1(4);
+			entry.sap = readUint$1(4);
+			entry.referenceType = entry.reference >> 31 & 1;
+			entry.referencedSize = entry.reference & 2147483647;
+			entry.startsWithSap = entry.sap >> 31 & 1;
+			entry.sapType = entry.sap >> 28 & 7;
+			entry.sapDeltaTime = entry.sap & 268435455;
+			return entry;
+		})
+	};
+}
+
+//#endregion
+//#region src/readers/readSkip.ts
+/**
+* Parse a FreeSpaceBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed FreeSpaceBox
+*
+* @public
+*/
+function readSkip(view) {
+	return {
+		...readFree(view),
+		type: "skip"
+	};
+}
+
+//#endregion
+//#region src/readers/readSmhd.ts
+/**
+* Parse a SoundMediaHeaderBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed SoundMediaHeaderBox
+*
+* @public
+*/
+function readSmhd(view) {
+	return {
+		type: "smhd",
+		...view.readFullBox(),
+		balance: view.readUint(2),
+		reserved: view.readUint(2)
+	};
+}
+
+//#endregion
+//#region src/readers/readSsix.ts
+/**
+* Parse a SubsegmentIndexBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed SubsegmentIndexBox
+*
+* @public
+*/
+function readSsix(view) {
+	const { version, flags } = view.readFullBox();
+	const subsegmentCount = view.readUint(4);
+	return {
+		type: "ssix",
+		version,
+		flags,
+		subsegmentCount,
+		subsegments: view.readEntries(subsegmentCount, () => {
+			const rangesCount = view.readUint(4);
+			return {
+				rangesCount,
+				ranges: view.readEntries(rangesCount, () => ({
+					level: view.readUint(1),
+					rangeSize: view.readUint(3)
+				}))
+			};
+		})
+	};
+}
+
+//#endregion
+//#region src/readers/readSthd.ts
+/**
+* Parse a SubtitleMediaHeaderBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed SubtitleMediaHeaderBox
+*
+* @public
+*/
+function readSthd(view) {
+	return {
+		type: "sthd",
+		...view.readFullBox()
+	};
+}
+
+//#endregion
+//#region src/readers/readStsd.ts
+/**
+* Parse a SampleDescriptionBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed SampleDescriptionBox
+*
+* @public
+*/
+function readStsd(view) {
+	const { version, flags } = view.readFullBox();
+	const entryCount = view.readUint(4);
+	return {
+		type: "stsd",
+		version,
+		flags,
+		entryCount,
+		entries: view.readBoxes(entryCount)
+	};
+}
+
+//#endregion
+//#region src/readers/readStss.ts
+/**
+* Parse a SyncSampleBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed SyncSampleBox
+*
+* @public
+*/
+function readStss(view) {
+	const { version, flags } = view.readFullBox();
+	const entryCount = view.readUint(4);
+	return {
+		type: "stss",
+		version,
+		flags,
+		entryCount,
+		entries: view.readEntries(entryCount, () => ({ sampleNumber: view.readUint(4) }))
+	};
+}
+
+//#endregion
+//#region src/readers/readSttg.ts
+/**
+* Parse a WebVTTSettingsBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed WebVTTSettingsBox
+*
+* @public
+*/
+function readSttg(view) {
+	return {
+		type: "sttg",
+		settings: view.readUtf8(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readStts.ts
+/**
+* Parse a DecodingTimeToSampleBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed DecodingTimeToSampleBox
+*
+* @public
+*/
+function readStts(view) {
+	const { version, flags } = view.readFullBox();
+	const entryCount = view.readUint(4);
+	return {
+		type: "stts",
+		version,
+		flags,
+		entryCount,
+		entries: view.readEntries(entryCount, () => ({
+			sampleCount: view.readUint(4),
+			sampleDelta: view.readUint(4)
+		}))
+	};
+}
+
+//#endregion
+//#region src/readers/readStyp.ts
+/**
+* Parse a SegmentTypeBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed SegmentTypeBox
+*
+* @public
+*/
+function readStyp(view) {
+	return {
+		...readFtyp(view),
+		type: "styp"
+	};
+}
+
+//#endregion
+//#region src/readers/readSubs.ts
+/**
+* Parse a SubSampleInformationBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed SubSampleInformationBox
+*
+* @public
+*/
+function readSubs(view) {
+	const { version, flags } = view.readFullBox();
+	const entryCount = view.readUint(4);
+	return {
+		type: "subs",
+		version,
+		flags,
+		entryCount,
+		entries: view.readEntries(entryCount, () => {
+			const sampleDelta = view.readUint(4);
+			const subsampleCount = view.readUint(2);
+			return {
+				sampleDelta,
+				subsampleCount,
+				subsamples: view.readEntries(subsampleCount, () => ({
+					subsampleSize: view.readUint(version === 1 ? 4 : 2),
+					subsamplePriority: view.readUint(1),
+					discardable: view.readUint(1),
+					codecSpecificParameters: view.readUint(4)
+				}))
+			};
+		})
+	};
+}
+
+//#endregion
+//#region src/readers/readTenc.ts
+/**
+* Parse a TrackEncryptionBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed TrackEncryptionBox
+*
+* @public
+*/
+function readTenc(view) {
+	return {
+		type: "tenc",
+		...view.readFullBox(),
+		defaultIsEncrypted: view.readUint(3),
+		defaultIvSize: view.readUint(1),
+		defaultKid: view.readArray(UINT, 1, 16)
+	};
+}
+
+//#endregion
+//#region src/readers/readTfdt.ts
+/**
+* Parse a TrackFragmentDecodeTimeBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed TrackFragmentDecodeTimeBox
+*
+* @public
+*/
+function readTfdt(view) {
+	const { version, flags } = view.readFullBox();
+	return {
+		type: "tfdt",
+		version,
+		flags,
+		baseMediaDecodeTime: view.readUint(version == 1 ? 8 : 4)
+	};
+}
+
+//#endregion
+//#region src/readers/readTfhd.ts
+/**
+* Parse a TrackFragmentHeaderBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed TrackFragmentHeaderBox
+*
+* @public
+*/
+function readTfhd(view) {
+	const { version, flags } = view.readFullBox();
+	return {
+		type: "tfhd",
+		version,
+		flags,
+		trackId: view.readUint(4),
+		baseDataOffset: flags & 1 ? view.readUint(8) : void 0,
+		sampleDescriptionIndex: flags & 2 ? view.readUint(4) : void 0,
+		defaultSampleDuration: flags & 8 ? view.readUint(4) : void 0,
+		defaultSampleSize: flags & 16 ? view.readUint(4) : void 0,
+		defaultSampleFlags: flags & 32 ? view.readUint(4) : void 0
+	};
+}
+
+//#endregion
+//#region src/readers/readTfra.ts
+/**
+* Parse a TrackFragmentRandomAccessBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed TrackFragmentRandomAccessBox
+*
+* @public
+*/
+function readTfra(view) {
+	const { version, flags } = view.readFullBox();
+	const trackId = view.readUint(4);
+	const reserved = view.readUint(4);
+	const lengthSizeOfTrafNum = (reserved & 48) >> 4;
+	const lengthSizeOfTrunNum = (reserved & 12) >> 2;
+	const lengthSizeOfSampleNum = reserved & 3;
+	const numberOfEntry = view.readUint(4);
+	return {
+		type: "tfra",
+		version,
+		flags,
+		trackId,
+		reserved,
+		lengthSizeOfTrafNum,
+		lengthSizeOfTrunNum,
+		lengthSizeOfSampleNum,
+		numberOfEntry,
+		entries: view.readEntries(numberOfEntry, () => ({
+			time: view.readUint(version === 1 ? 8 : 4),
+			moofOffset: view.readUint(version === 1 ? 8 : 4),
+			trafNumber: view.readUint(lengthSizeOfTrafNum + 1),
+			trunNumber: view.readUint(lengthSizeOfTrunNum + 1),
+			sampleNumber: view.readUint(lengthSizeOfSampleNum + 1)
+		}))
+	};
+}
+
+//#endregion
+//#region src/readers/readTkhd.ts
+/**
+* Parse a TrackHeaderBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed TrackHeaderBox
+*
+* @public
+*/
+function readTkhd(view) {
+	const { version, flags } = view.readFullBox();
+	const size = version === 1 ? 8 : 4;
+	return {
+		type: "tkhd",
+		version,
+		flags,
+		creationTime: view.readUint(size),
+		modificationTime: view.readUint(size),
+		trackId: view.readUint(4),
+		reserved1: view.readUint(4),
+		duration: view.readUint(size),
+		reserved2: view.readArray(UINT, 4, 2),
+		layer: view.readUint(2),
+		alternateGroup: view.readUint(2),
+		volume: view.readTemplate(2),
+		reserved3: view.readUint(2),
+		matrix: view.readArray(TEMPLATE, 4, 9),
+		width: view.readTemplate(4),
+		height: view.readTemplate(4)
+	};
+}
+
+//#endregion
+//#region src/readers/readTrex.ts
+/**
+* Parse a TrackExtendsBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed TrackExtendsBox
+*
+* @public
+*/
+function readTrex(view) {
+	return {
+		type: "trex",
+		...view.readFullBox(),
+		trackId: view.readUint(4),
+		defaultSampleDescriptionIndex: view.readUint(4),
+		defaultSampleDuration: view.readUint(4),
+		defaultSampleSize: view.readUint(4),
+		defaultSampleFlags: view.readUint(4)
+	};
+}
+
+//#endregion
+//#region src/readers/readTrun.ts
+/**
+* Parse a TrackRunBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed TrackRunBox
+*
+* @public
+*/
+function readTrun(view) {
+	const { version, flags } = view.readFullBox();
+	const sampleCount = view.readUint(4);
+	let dataOffset;
+	let firstSampleFlags;
+	if (flags & 1) dataOffset = view.readInt(4);
+	if (flags & 4) firstSampleFlags = view.readUint(4);
+	const samples = view.readEntries(sampleCount, () => {
+		const sample = {};
+		if (flags & 256) sample.sampleDuration = view.readUint(4);
+		if (flags & 512) sample.sampleSize = view.readUint(4);
+		if (flags & 1024) sample.sampleFlags = view.readUint(4);
+		if (flags & 2048) sample.sampleCompositionTimeOffset = version === 1 ? view.readInt(4) : view.readUint(4);
+		return sample;
+	});
+	return {
+		type: "trun",
+		version,
+		flags,
+		sampleCount,
+		dataOffset,
+		firstSampleFlags,
+		samples
+	};
+}
+
+//#endregion
+//#region src/readers/readUrl.ts
+/**
+* Parse a UrlBox from an IsoView
+*
+* @param view - The IsoView to read data from
+*
+* @returns A parsed UrlBox
+*
+* @public
+*/
+function readUrl(view) {
+	return {
+		type: "url ",
+		...view.readFullBox(),
+		location: view.readString(-1)
+	};
+}
+
+//#endregion
+//#region src/readers/readUrn.ts
 /**
-* The data field type
+* Parse a UrnBox from an IsoView
+*
+* @param view - The IsoView to read data from
 *
+* @returns A parsed UrnBox
 *
-* @beta
+* @public
 */
-const DATA = "data";
+function readUrn(view) {
+	return {
+		type: "urn ",
+		...view.readFullBox(),
+		name: view.readString(-1),
+		location: view.readString(-1)
+	};
+}
 
 //#endregion
-//#region src/fields/INT.ts
+//#region src/readers/readVlab.ts
 /**
-* The integer field type
+* Parse a WebVTTSourceLabelBox from an IsoView
+*
+* @param view - The IsoView to read data from
 *
+* @returns A parsed WebVTTSourceLabelBox
 *
-* @beta
+* @public
 */
-const INT = "int";
+function readVlab(view) {
+	return {
+		type: "vlab",
+		sourceLabel: view.readUtf8(-1)
+	};
+}
 
 //#endregion
-//#region src/fields/STRING.ts
+//#region src/readers/readVmhd.ts
 /**
-* The string field type
+* Parse a VideoMediaHeaderBox from an IsoView
 *
+* @param view - The IsoView to read data from
+*
+* @returns A parsed VideoMediaHeaderBox
 *
-* @beta
+* @public
 */
-const STRING = "string";
+function readVmhd(view) {
+	return {
+		type: "vmhd",
+		...view.readFullBox(),
+		graphicsmode: view.readUint(2),
+		opcolor: view.readArray(UINT, 2, 3)
+	};
+}
 
 //#endregion
-//#region src/fields/TEMPLATE.ts
+//#region src/readers/readVttC.ts
 /**
-* The template field type
+* Parse a WebVTTConfigurationBox from an IsoView
+*
+* @param view - The IsoView to read data from
 *
+* @returns A parsed WebVttConfigurationBox
 *
-* @beta
+* @public
 */
-const TEMPLATE = "template";
+function readVttC(view) {
+	return {
+		type: "vttC",
+		config: view.readUtf8()
+	};
+}
 
 //#endregion
-//#region src/fields/UINT.ts
+//#region src/readers/readVtte.ts
 /**
-* The unsigned integer field type
+* Parse a WebVTT Empty Sample Box from an IsoView
 *
+* @returns A parsed WebVTT Empty Sample Box
 *
-* @beta
+* @public
 */
-const UINT = "uint";
+function readVtte(_) {
+	return { type: "vtte" };
+}
+
+//#endregion
+//#region src/fields/DATA.ts
+/**
+* The data field type
+*
+* @public
+*/
+const DATA = "data";
+
+//#endregion
+//#region src/fields/INT.ts
+/**
+* The integer field type
+*
+* @public
+*/
+const INT = "int";
 
 //#endregion
 //#region src/fields/UTF8.ts
 /**
 * The UTF8 field type
 *
-*
-* @beta
+* @public
 */
 const UTF8 = "utf8";
 
 //#endregion
-//#region src/readers/readData.ts
+//#region src/utils/readData.ts
 function readData(dataView, offset, size) {
 	const length = size > 0 ? size : dataView.byteLength - (offset - dataView.byteOffset);
 	return new Uint8Array(dataView.buffer, offset, Math.max(length, 0));
 }
 
 //#endregion
-//#region src/readers/readInt.ts
+//#region src/utils/readInt.ts
 function readInt(dataView, offset, size) {
 	let result = NaN;
 	const cursor = offset - dataView.byteOffset;
@@ -119,7 +1796,7 @@ function readInt(dataView, offset, size) {
 }
 
 //#endregion
-//#region src/readers/readUint.ts
+//#region src/utils/readUint.ts
 function readUint(dataView, offset, size) {
 	const cursor = offset - dataView.byteOffset;
 	let value = NaN;
@@ -150,7 +1827,7 @@ function readUint(dataView, offset, size) {
 }
 
 //#endregion
-//#region src/readers/readString.ts
+//#region src/utils/readString.ts
 function readString(dataView, offset, length) {
 	let str = "";
 	for (let c = 0; c < length; c++) {
@@ -161,14 +1838,14 @@ function readString(dataView, offset, length) {
 }
 
 //#endregion
-//#region src/readers/readTemplate.ts
+//#region src/utils/readTemplate.ts
 function readTemplate(dataView, offset, size) {
 	const half = size / 2;
 	return readUint(dataView, offset, half) + readUint(dataView, offset + half, half) / Math.pow(2, half);
 }
 
 //#endregion
-//#region src/readers/readTerminatedString.ts
+//#region src/utils/readTerminatedString.ts
 function readTerminatedString(dataView, offset) {
 	let str = "";
 	let cursor = offset;
@@ -182,7 +1859,7 @@ function readTerminatedString(dataView, offset) {
 }
 
 //#endregion
-//#region src/readers/readUtf8String.ts
+//#region src/utils/readUtf8String.ts
 /**
 * Reads a UTF-8 string from a data view.
 *
@@ -198,7 +1875,7 @@ function readUtf8String(dataView, offset) {
 }
 
 //#endregion
-//#region src/readers/readUtf8TerminatedString.ts
+//#region src/utils/readUtf8TerminatedString.ts
 /**
 * Reads a UTF-8 terminated string from a data view.
 *
@@ -221,15 +1898,14 @@ function readUtf8TerminatedString(dataView, offset) {
 }
 
 //#endregion
-//#region src/IsoView.ts
+//#region src/IsoBoxReadView.ts
 /**
 * ISO BMFF data view. Similar to DataView, but with additional methods for reading ISO BMFF data.
 * It implements the iterator protocol, so it can be used in a for...of loop.
 *
-*
-* @beta
+* @public
 */
-var IsoView = class IsoView {
+var IsoBoxReadView = class IsoBoxReadView {
 	/**
 	* Creates a new IsoView instance. Similar to DataView, but with additional
 	* methods for reading ISO BMFF data. It implements the iterator protocol,
@@ -240,10 +1916,13 @@ var IsoView = class IsoView {
 	*/
 	constructor(raw, config) {
 		this.truncated = false;
-		this.slice = (size) => {
-			const dataView = new DataView(this.dataView.buffer, this.offset, size);
-			this.offset += size;
-			return new IsoView(dataView, this.config);
+		this.slice = (offset, size) => {
+			const isoView = new IsoBoxReadView(new DataView(this.dataView.buffer, offset, size), this.config);
+			const headerSize = this.offset - offset;
+			const bodySize = size - headerSize;
+			this.offset += bodySize;
+			isoView.jump(headerSize);
+			return isoView;
 		};
 		this.read = (type, size = 0) => {
 			const { dataView, offset } = this;
@@ -309,30 +1988,34 @@ var IsoView = class IsoView {
 			for (let i = 0; i < length; i++) value.push(this.read(type, size));
 			return value;
 		};
+		this.jump = (size) => {
+			this.offset += size;
+		};
 		this.readBox = () => {
 			const { dataView, offset } = this;
 			let cursor = 0;
+			const size = readUint(dataView, offset, 4);
+			const type = readString(dataView, offset + 4, 4);
 			const box = {
-				size: readUint(dataView, offset, 4),
-				type: readString(dataView, offset + 4, 4)
+				size,
+				type
 			};
 			cursor += 8;
 			if (box.size === 1) {
 				box.largesize = readUint(dataView, offset + cursor, 8);
 				cursor += 8;
 			}
-			const actualSize = box.largesize || box.size;
+			const actualSize = box.size === 0 ? this.bytesRemaining : box.largesize ?? box.size;
 			if (this.cursor + actualSize > dataView.byteLength) {
 				this.truncated = true;
 				throw new Error("Truncated box");
 			}
-			this.offset += cursor;
-			if (box.type === "uuid") box.usertype = this.readArray("uint", 1, 16);
-			const viewSize = box.size === 0 ? this.bytesRemaining : actualSize - cursor;
-			box.data = this.slice(viewSize);
+			this.jump(cursor);
+			if (type === "uuid") box.usertype = this.readArray("uint", 1, 16);
+			box.view = this.slice(offset, actualSize);
 			return box;
 		};
-		this.readBoxes = (length) => {
+		this.readBoxes = (length = -1) => {
 			const result = [];
 			for (const box of this) {
 				result.push(box);
@@ -345,12 +2028,27 @@ var IsoView = class IsoView {
 			for (let i = 0; i < length; i++) result.push(map());
 			return result;
 		};
-		this.dataView = raw instanceof ArrayBuffer ? new DataView(raw) : raw instanceof Uint8Array ? new DataView(raw.buffer, raw.byteOffset, raw.byteLength) : raw;
+		this.dataView = raw instanceof ArrayBuffer ? new DataView(raw) : raw instanceof DataView ? raw : new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
 		this.offset = this.dataView.byteOffset;
-		this.config = config || {
-			recursive: false,
-			parsers: {}
-		};
+		this.config = config || { readers: {} };
+	}
+	/**
+	* The buffer of the data view.
+	*/
+	get buffer() {
+		return this.dataView.buffer;
+	}
+	/**
+	* The byte offset of the data view.
+	*/
+	get byteOffset() {
+		return this.dataView.byteOffset;
+	}
+	/**
+	* The byte length of the data view.
+	*/
+	get byteLength() {
+		return this.dataView.byteLength;
 	}
 	/**
 	* The current byteoffset in the data view.
@@ -376,1522 +2074,1643 @@ var IsoView = class IsoView {
 	* @returns A generator of boxes.
 	*/
 	*[Symbol.iterator]() {
-		const { parsers = {}, recursive = false } = this.config;
+		const { readers = {} } = this.config;
 		while (!this.done) try {
-			const { type, data,...rest } = this.readBox();
-			const box = {
-				type,
-				...rest
-			};
-			const parser = parsers[type] || parsers[type.trim()];
-			if (parser) Object.assign(box, parser(data, this.config));
-			box.view = data;
-			if (CONTAINERS.includes(type)) {
+			const box = this.readBox();
+			const { type, view } = box;
+			const parser = readers[type] || readers[type.trim()];
+			if (parser) Object.assign(box, parser(view));
+			if (isContainer(box) && !box.boxes) {
 				const boxes = [];
-				for (const child of data) {
-					if (recursive) yield child;
-					boxes.push(child);
-				}
+				for (const child of view) boxes.push(child);
 				box.boxes = boxes;
 			}
 			yield box;
 		} catch (error) {
-			break;
+			if (error instanceof Error && error.message === "Truncated box") break;
+			throw error;
 		}
 	}
 };
 
 //#endregion
-//#region src/createIsoView.ts
+//#region src/readIsoBoxes.ts
 /**
-* Create an IsoView from a raw ISO data.
+* Reads ISO boxes from a data source.
 *
 * @param raw - The raw ISO data
 * @param config - The configuration for the IsoView
 *
-* @returns The created IsoView
-*
-*
-* @beta
-*/
-function createIsoView(raw, config) {
-	return new IsoView(raw, config);
-}
-
-//#endregion
-//#region src/filterBoxes.ts
-function filter(iterator, fn, recursive, result) {
-	for (const box of iterator) {
-		if (fn(box)) result.push(box);
-		const { boxes } = box;
-		if (recursive && Array.isArray(boxes)) filter(boxes, fn, recursive, result);
-	}
-	return result;
-}
-/**
-* Filters boxes based on the given filter function.
+* @returns The parsed boxes
 *
-* @param raw - The raw boxes to filter.
-* @param config - The box parser configuration.
-* @param fn - The filter function.
-* @returns The filtered boxes.
+* @example
+* {@includeCode ../test/readIsoBoxes.test.ts#example}
 *
-* @beta
+* @public
 */
-function filterBoxes(raw, fn, config) {
-	if (raw instanceof DataView || raw instanceof Uint8Array || raw instanceof ArrayBuffer) raw = createIsoView(raw, {
-		...config,
-		recursive: false
-	});
-	const recursive = config?.recursive ?? true;
-	return filter(raw, fn, recursive, []);
+function readIsoBoxes(raw, config) {
+	const boxes = [];
+	for (const box of new IsoBoxReadView(raw, config)) boxes.push(box);
+	return boxes;
 }
 
 //#endregion
-//#region src/filterBoxesByType.ts
+//#region src/traverseIsoBoxes.ts
 /**
-* Filter boxes by type from an IsoView
+* Traverse ISO boxes
 *
-* @param type - The type(s) of boxes to filter
-* @param raw - The raw ISO data
-* @param config - The configuration for the IsoView
+* @param boxes - The boxes to traverse
+* @param depthFirst - Whether to traverse the boxes depth-first or breadth-first
+* @param maxDepth - The maximum depth to traverse. A value of 0 will only traverse the root boxes.
 *
-* @returns The filtered boxes
+* @returns A generator of boxes
 *
+* @example
+* {@includeCode ../test/traverseIsoBoxes.test.ts#example}
 *
-* @beta
+* @public
 */
-function filterBoxesByType(raw, type, config = {}) {
-	if (!Array.isArray(type)) type = [type];
-	return filterBoxes(raw, (box) => type.includes(box.type), config);
-}
-
-//#endregion
-//#region src/findBox.ts
-function find(iterator, recursive, fn) {
-	for (const box of iterator) {
-		if (fn(box)) return box;
-		const { boxes } = box;
-		if (recursive && Array.isArray(boxes)) {
-			const result = find(boxes, recursive, fn);
-			if (result) return result;
+function* traverseIsoBoxes(boxes, depthFirst = true, maxDepth = Infinity) {
+	if (maxDepth < 0 || typeof maxDepth !== "number" || Number.isNaN(maxDepth)) return;
+	const queue = [[boxes, 0]];
+	while (queue.length > 0) {
+		const item = queue.shift();
+		if (!item) continue;
+		const [children, depth] = item;
+		for (const child of children) {
+			yield child;
+			if (depth >= maxDepth) continue;
+			if (isContainer(child) && child.boxes) {
+				const next = child.boxes;
+				if (depthFirst) yield* traverseIsoBoxes(next, depthFirst, maxDepth - 1);
+				else queue.push([next, depth + 1]);
+			}
 		}
 	}
-	return null;
 }
+
+//#endregion
+//#region src/utils/isFullBox.ts
 /**
-* Find a box from an IsoView that matches a filter function
+* Check if a box is a full box
 *
-* @param raw - The raw ISO data
-* @param config - The configuration for the IsoView
-* @param fn - The filter function
+* @param box - The box to check
 *
-* @returns The first box that matches the filter function
+* @returns `true` if the box is a full box, `false` otherwise
 *
-*
-* @beta
+* @public
 */
-function findBox(raw, fn, config) {
-	const recursive = config?.recursive ?? true;
-	if (raw instanceof DataView || raw instanceof Uint8Array || raw instanceof ArrayBuffer) raw = createIsoView(raw, {
-		...config,
-		recursive: false
-	});
-	return find(raw, recursive, fn);
+function isFullBox(box) {
+	return "version" in box && "flags" in box;
 }
 
 //#endregion
-//#region src/findBoxByType.ts
+//#region src/writeIsoBoxes.ts
 /**
-* Find a box from an IsoView that matches a given type
+* Writes ISO boxes to a readable stream.
 *
-* @param type - The type of box to find
-* @param raw - The raw ISO data
-* @param config - The configuration for the IsoView
+* @param boxes - The boxes to write
+* @param config - The configuration for the readable stream
 *
-* @returns The first box that matches the type
+* @returns A readable stream of the written boxes
 *
+* @example
+* {@includeCode ../test/writeIsoBoxes.test.ts#example}
 *
-* @beta
+* @public
 */
-function findBoxByType(raw, type, config = {}) {
-	return findBox(raw, (box) => box.type === type, config);
+function writeIsoBoxes(boxes, config) {
+	const cfg = createWriterConfig(config);
+	return Array.from(boxes, (box) => writeBox(box, cfg));
 }
 
 //#endregion
-//#region src/parseBoxes.ts
+//#region src/writers/writeArdi.ts
 /**
-* Parse boxes from an IsoView
-*
-* @param raw - The raw ISO data
-* @param config - The configuration for the IsoView
+* Write an AudioRenderingIndicationBox to an IsoDataWriter.
 *
-* @returns The parsed boxes
+* @param box - The AudioRenderingIndicationBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function parseBoxes(raw, config) {
-	const boxes = [];
-	for (const box of createIsoView(raw, config)) boxes.push(box);
-	return boxes;
+function writeArdi(box) {
+	const writer = new IsoBoxWriteView("ardi", 13);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.audioRenderingIndication, 1);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/ardi.ts
+//#region src/writers/writeVisualSampleEntryBox.ts
 /**
-* Parse a AudioRenderingIndicationBox from an IsoView
+* Write a VisualSampleEntryBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 12.1.3 Visual Sample Entry
 *
-* @returns A parsed AudioRenderingIndicationBox
+* @param box - The VisualSampleEntryBox fields to write
+* @param type - The box type
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function ardi(view) {
-	return {
-		...view.readFullBox(),
-		audioRenderingIndication: view.readUint(1)
-	};
+function writeVisualSampleEntryBox(box, type) {
+	const headerSize = 8;
+	const reserved1Size = 6;
+	const dataReferenceIndexSize = 2;
+	const preDefined1Size = 2;
+	const reserved2Size = 2;
+	const preDefined2Size = 12;
+	const widthSize = 2;
+	const heightSize = 2;
+	const horizresolutionSize = 4;
+	const vertresolutionSize = 4;
+	const reserved3Size = 4;
+	const frameCountSize = 2;
+	const compressorNameSize = 32;
+	const depthSize = 2;
+	const preDefined3Size = 2;
+	const configSize = box.config.length;
+	const writer = new IsoBoxWriteView(type, headerSize + reserved1Size + dataReferenceIndexSize + preDefined1Size + reserved2Size + preDefined2Size + widthSize + heightSize + horizresolutionSize + vertresolutionSize + reserved3Size + frameCountSize + compressorNameSize + depthSize + preDefined3Size + configSize);
+	writer.writeArray(box.reserved1, UINT, 1, 6);
+	writer.writeUint(box.dataReferenceIndex, 2);
+	writer.writeUint(box.preDefined1, 2);
+	writer.writeUint(box.reserved2, 2);
+	writer.writeArray(box.preDefined2, UINT, 4, 3);
+	writer.writeUint(box.width, 2);
+	writer.writeUint(box.height, 2);
+	writer.writeTemplate(box.horizresolution, 4);
+	writer.writeTemplate(box.vertresolution, 4);
+	writer.writeUint(box.reserved3, 4);
+	writer.writeUint(box.frameCount, 2);
+	writer.writeArray(box.compressorName, UINT, 1, 32);
+	writer.writeUint(box.depth, 2);
+	writer.writeUint(box.preDefined3 & 65535, 2);
+	writer.writeBytes(box.config);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/avc1.ts
+//#region src/writers/writeAvc1.ts
 /**
-* Parse a VisualSampleEntryBox from an IsoView
+* Write a VisualSampleEntryBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 12.1.3 Visual Sample Entry
 *
-* @returns A parsed VisualSampleEntryBox
+* @param box - The VisualSampleEntryBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function avc1(view) {
-	const { readArray, readUint: readUint$1, readInt: readInt$1, readTemplate: readTemplate$1, readData: readData$1 } = view;
-	return {
-		reserved1: readArray(UINT, 1, 6),
-		dataReferenceIndex: readUint$1(2),
-		preDefined1: readUint$1(2),
-		reserved2: readUint$1(2),
-		preDefined2: readArray(UINT, 4, 3),
-		width: readUint$1(2),
-		height: readUint$1(2),
-		horizresolution: readTemplate$1(4),
-		vertresolution: readTemplate$1(4),
-		reserved3: readUint$1(4),
-		frameCount: readUint$1(2),
-		compressorName: readArray(UINT, 1, 32),
-		depth: readUint$1(2),
-		preDefined3: readInt$1(2),
-		config: readData$1(-1)
-	};
+function writeAvc1(box) {
+	return writeVisualSampleEntryBox(box, "avc1");
 }
 
 //#endregion
-//#region src/parsers/avc2.ts
+//#region src/writers/writeAvc2.ts
 /**
-* Parse a VisualSampleEntryBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a VisualSampleEntryBox (avc2) to an IsoDataWriter.
 *
-* @returns A parsed VisualSampleEntryBox
+* @param box - The VisualSampleEntryBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function avc2(view) {
-	return avc1(view);
+function writeAvc2(box) {
+	return writeVisualSampleEntryBox(box, "avc2");
 }
 
 //#endregion
-//#region src/parsers/avc3.ts
+//#region src/writers/writeAvc3.ts
 /**
-* Parse a VisualSampleEntryBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a VisualSampleEntryBox (avc3) to an IsoDataWriter.
 *
-* @returns A parsed VisualSampleEntryBox
+* @param box - The VisualSampleEntryBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function avc3(view) {
-	return avc1(view);
+function writeAvc3(box) {
+	return writeVisualSampleEntryBox(box, "avc3");
 }
 
 //#endregion
-//#region src/parsers/avc4.ts
+//#region src/writers/writeAvc4.ts
 /**
-* Parse a VisualSampleEntryBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a VisualSampleEntryBox (avc4) to an IsoDataWriter.
 *
-* @returns A parsed VisualSampleEntryBox
+* @param box - The VisualSampleEntryBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function avc4(view) {
-	return avc1(view);
+function writeAvc4(box) {
+	return writeVisualSampleEntryBox(box, "avc4");
 }
 
 //#endregion
-//#region src/parsers/ctts.ts
+//#region src/writers/writeCtts.ts
 /**
-* Parse a CompositionTimeToSampleBox from an IsoView
+* Write a CompositionTimeToSampleBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.6.1.3 Composition Time to Sample Box
 *
-* @returns A parsed CompositionTimeToSampleBox
+* @param box - The CompositionTimeToSampleBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function ctts(view) {
-	const { version, flags } = view.readFullBox();
-	const read = version === 1 ? view.readInt : view.readUint;
-	const entryCount = view.readUint(4);
-	return {
-		version,
-		flags,
-		entryCount,
-		entries: view.readEntries(entryCount, () => ({
-			sampleCount: view.readUint(4),
-			sampleOffset: read(4)
-		}))
-	};
+function writeCtts(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const entryCountSize = 4;
+	const entriesSize = box.entryCount * 8;
+	const writer = new IsoBoxWriteView("ctts", headerSize + fullBoxSize + entryCountSize + entriesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.entryCount, 4);
+	for (const entry of box.entries) {
+		writer.writeUint(entry.sampleCount, 4);
+		writer.writeUint(entry.sampleOffset, 4);
+	}
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/dref.ts
+//#region src/writers/writeDref.ts
 /**
-* Parse a DataReferenceBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a DataReferenceBox to an IsoDataWriter.
 *
-* @returns A parsed DataReferenceBox
+* @param box - The DataReferenceBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function dref(view) {
-	const { version, flags } = view.readFullBox();
-	const entryCount = view.readUint(4);
-	return {
-		version,
-		flags,
-		entryCount,
-		entries: view.readBoxes(entryCount)
-	};
+function writeDref(box, config) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const entryCountSize = 4;
+	const entryCount = box.entries.length;
+	const entries = writeIsoBoxes(box.entries, config);
+	const entriesSize = entries.reduce((size, entry) => size + entry.byteLength, 0);
+	const writer = new IsoBoxWriteView("dref", headerSize + fullBoxSize + entryCountSize + entriesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(entryCount, 4);
+	for (const entry of entries) writer.writeBytes(entry);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/elng.ts
+//#region src/writers/writeElng.ts
 /**
-* Parse a ExtendedLanguageBox from an IsoView
+* Write an ExtendedLanguageBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.4.6 Extended Language Tag
 *
-* @returns A parsed ExtendedLanguageBox
+* @param box - The ExtendedLanguageBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function elng(view) {
-	return {
-		...view.readFullBox(),
-		extendedLanguage: view.readUtf8(-1)
-	};
+function writeElng(box) {
+	const extendedLanguageBytes = encodeText(box.extendedLanguage);
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const extendedLanguageSize = extendedLanguageBytes.length + 1;
+	const writer = new IsoBoxWriteView("elng", headerSize + fullBoxSize + extendedLanguageSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUtf8TerminatedString(box.extendedLanguage);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/elst.ts
+//#region src/writers/writeElst.ts
 /**
-* Parse a Box from an IsoView
+* Write an EditListBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.6.6 Edit List Box
 *
-* @returns A parsed Box
+* @param box - The EditListBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function elst(view) {
-	const { version, flags } = view.readFullBox();
-	const size = version === 1 ? 8 : 4;
-	const entryCount = view.readUint(4);
-	return {
-		version,
-		flags,
-		entryCount,
-		entries: view.readEntries(entryCount, () => ({
-			segmentDuration: view.readUint(size),
-			mediaTime: view.readInt(size),
-			mediaRateInteger: view.readInt(2),
-			mediaRateFraction: view.readInt(2)
-		}))
-	};
+function writeElst(box) {
+	const size = box.version === 1 ? 8 : 4;
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const entryCountSize = 4;
+	const entrySize = size + size + 2 + 2;
+	const entriesSize = box.entryCount * entrySize;
+	const writer = new IsoBoxWriteView("elst", headerSize + fullBoxSize + entryCountSize + entriesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.entryCount, 4);
+	for (const entry of box.entries) {
+		writer.writeUint(entry.segmentDuration, size);
+		writer.writeInt(entry.mediaTime, size);
+		writer.writeInt(entry.mediaRateInteger, 2);
+		writer.writeInt(entry.mediaRateFraction, 2);
+	}
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/emsg.ts
+//#region src/writers/writeEmsg.ts
 /**
-* Parse an EventMessageBox from an IsoView
+* Write an EventMessageBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 23009-1 - 5.10.3.3 Event Message Box
 *
-* @returns A parsed EventMessageBox
+* @param box - The EventMessageBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function emsg(view) {
-	const { readUint: readUint$1, readString: readString$1, readData: readData$1 } = view;
-	const result = { ...view.readFullBox() };
-	if (result.version == 1) {
-		result.timescale = readUint$1(4);
-		result.presentationTime = readUint$1(8);
-		result.eventDuration = readUint$1(4);
-		result.id = readUint$1(4);
-		result.schemeIdUri = readString$1(-1);
-		result.value = readString$1(-1);
+function writeEmsg(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	let contentSize;
+	if (box.version === 0) contentSize = box.schemeIdUri.length + 1 + (box.value.length + 1) + 4 + 4 + 4 + 4 + box.messageData.length;
+	else contentSize = 20 + (box.schemeIdUri.length + 1) + (box.value.length + 1) + box.messageData.length;
+	const writer = new IsoBoxWriteView("emsg", headerSize + fullBoxSize + contentSize);
+	writer.writeFullBox(box.version, box.flags);
+	if (box.version === 0) {
+		writer.writeTerminatedString(box.schemeIdUri);
+		writer.writeTerminatedString(box.value);
+		writer.writeUint(box.timescale, 4);
+		writer.writeUint(box.presentationTimeDelta ?? 0, 4);
+		writer.writeUint(box.eventDuration, 4);
+		writer.writeUint(box.id, 4);
 	} else {
-		result.schemeIdUri = readString$1(-1);
-		result.value = readString$1(-1);
-		result.timescale = readUint$1(4);
-		result.presentationTimeDelta = readUint$1(4);
-		result.eventDuration = readUint$1(4);
-		result.id = readUint$1(4);
+		writer.writeUint(box.timescale, 4);
+		writer.writeUint(box.presentationTime ?? 0, 8);
+		writer.writeUint(box.eventDuration, 4);
+		writer.writeUint(box.id, 4);
+		writer.writeTerminatedString(box.schemeIdUri);
+		writer.writeTerminatedString(box.value);
 	}
-	result.messageData = readData$1(-1);
-	return result;
+	writer.writeBytes(box.messageData);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/mp4a.ts
+//#region src/writers/writeEnca.ts
 /**
-* Parse an AudioSampleEntry from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write an AudioSampleEntryBox (enca) to an IsoDataWriter.
 *
-* @returns A parsed AudioSampleEntry
+* @param box - The AudioSampleEntryBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function mp4a(view) {
-	const { readArray, readUint: readUint$1, readTemplate: readTemplate$1, readData: readData$1 } = view;
-	return {
-		reserved1: readArray(UINT, 1, 6),
-		dataReferenceIndex: readUint$1(2),
-		reserved2: readArray(UINT, 4, 2),
-		channelcount: readUint$1(2),
-		samplesize: readUint$1(2),
-		preDefined: readUint$1(2),
-		reserved3: readUint$1(2),
-		samplerate: readTemplate$1(4),
-		esds: readData$1(-1)
-	};
+function writeEnca(box) {
+	const headerSize = 8;
+	const reserved1Size = 6;
+	const dataReferenceIndexSize = 2;
+	const reserved2Size = 8;
+	const channelcountSize = 2;
+	const samplesizeSize = 2;
+	const preDefinedSize = 2;
+	const reserved3Size = 2;
+	const samplerateSize = 4;
+	const esdsSize = box.esds.length;
+	const writer = new IsoBoxWriteView("enca", headerSize + reserved1Size + dataReferenceIndexSize + reserved2Size + channelcountSize + samplesizeSize + preDefinedSize + reserved3Size + samplerateSize + esdsSize);
+	writer.writeArray(box.reserved1, UINT, 1, 6);
+	writer.writeUint(box.dataReferenceIndex, 2);
+	writer.writeArray(box.reserved2, UINT, 4, 2);
+	writer.writeUint(box.channelcount, 2);
+	writer.writeUint(box.samplesize, 2);
+	writer.writeUint(box.preDefined, 2);
+	writer.writeUint(box.reserved3, 2);
+	writer.writeTemplate(box.samplerate, 4);
+	writer.writeBytes(box.esds);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/enca.ts
-/**
-* Parse an AudioSampleEntry from an IsoView
-*
-* @param view - The IsoView to read data from
+//#region src/writers/writeEncv.ts
+/**
+* Write a VisualSampleEntryBox (encv) to an IsoDataWriter.
 *
-* @returns A parsed AudioSampleEntry
+* @param box - The VisualSampleEntryBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function enca(view) {
-	return mp4a(view);
+function writeEncv(box) {
+	return writeVisualSampleEntryBox(box, "encv");
 }
 
 //#endregion
-//#region src/parsers/encv.ts
+//#region src/writers/writeFree.ts
 /**
-* Parse a VisualSampleEntryBox from an IsoView
+* Write a FreeSpaceBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.1.2 Free Space Box
 *
-* @returns A parsed VisualSampleEntryBox
+* @param box - The FreeSpaceBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function encv(view) {
-	return avc1(view);
+function writeFree(box) {
+	const writer = new IsoBoxWriteView("free", 8 + box.data.length);
+	writer.writeBytes(box.data);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/free.ts
+//#region src/writers/writeFrma.ts
 /**
-* Parse a Box from an IsoView
+* Write an OriginalFormatBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.12.2 Original Format Box
 *
-* @returns A parsed Box
+* @param box - The OriginalFormatBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function free(view) {
-	return { data: view.readData(-1) };
+function writeFrma(box) {
+	const writer = new IsoBoxWriteView("frma", 12);
+	writer.writeUint(box.dataFormat, 4);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/frma.ts
+//#region src/writers/writeFtyp.ts
 /**
-* Parse an OriginalFormatBox from an IsoView
+* Write a FileTypeBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 4.3 File Type Box
 *
-* @returns A parsed OriginalFormatBox
+* @param box - The FileTypeBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function frma(view) {
-	return { dataFormat: view.readUint(4) };
+function writeFtyp(box) {
+	const headerSize = 8;
+	const majorBrandSize = 4;
+	const minorVersionSize = 4;
+	const compatibleBrandsSize = box.compatibleBrands.length * 4;
+	const writer = new IsoBoxWriteView("ftyp", headerSize + majorBrandSize + minorVersionSize + compatibleBrandsSize);
+	writer.writeString(box.majorBrand);
+	writer.writeUint(box.minorVersion, 4);
+	for (const brand of box.compatibleBrands) writer.writeString(brand);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/ftyp.ts
+//#region src/writers/writeHdlr.ts
 /**
-* Parse a FileTypeBox from an IsoView
+* Write a HandlerReferenceBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.4.3 Handler Reference Box
 *
-* @returns A parsed FileTypeBox
+* @param box - The HandlerReferenceBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function ftyp(view) {
-	const size = 4;
-	const majorBrand = view.readString(4);
-	const minorVersion = view.readUint(4);
-	const length = view.bytesRemaining / size;
-	return {
-		majorBrand,
-		minorVersion,
-		compatibleBrands: view.readArray(STRING, size, length)
-	};
+function writeHdlr(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const preDefinedSize = 4;
+	const handlerTypeSize = 4;
+	const reservedSize = 12;
+	const nameSize = box.name.length + 1;
+	const writer = new IsoBoxWriteView("hdlr", headerSize + fullBoxSize + preDefinedSize + handlerTypeSize + reservedSize + nameSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.preDefined, 4);
+	writer.writeString(box.handlerType);
+	writer.writeArray(box.reserved, UINT, 4, 3);
+	writer.writeTerminatedString(box.name);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/hdlr.ts
+//#region src/writers/writeHev1.ts
 /**
-* Parse a HandlerReferenceBox from an IsoView
+* Write a VisualSampleEntryBox (hev1) to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
-*
-* @returns A parsed HandlerReferenceBox
+* @param box - The VisualSampleEntryBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function hdlr(view) {
-	return {
-		...view.readFullBox(),
-		preDefined: view.readUint(4),
-		handlerType: view.readString(4),
-		reserved: view.readArray(UINT, 4, 3),
-		name: view.readString(-1)
-	};
+function writeHev1(box) {
+	return writeVisualSampleEntryBox(box, "hev1");
 }
 
 //#endregion
-//#region src/parsers/hev1.ts
+//#region src/writers/writeHvc1.ts
 /**
-* Parse a VisualSampleEntryBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a VisualSampleEntryBox (hvc1) to an IsoDataWriter.
 *
-* @returns A parsed VisualSampleEntryBox
+* @param box - The VisualSampleEntryBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function hev1(view) {
-	return avc1(view);
+function writeHvc1(box) {
+	return writeVisualSampleEntryBox(box, "hvc1");
 }
 
 //#endregion
-//#region src/parsers/hvc1.ts
+//#region src/writers/writeIden.ts
 /**
-* Parse a VisualSampleEntryBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a WebVttCueIdBox to an IsoDataWriter.
 *
-* @returns A parsed VisualSampleEntryBox
+* @param box - The WebVttCueIdBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function hvc1(view) {
-	return avc1(view);
+function writeIden(box) {
+	const writer = new IsoBoxWriteView("iden", 8 + (encodeText(box.cueId).length + 1));
+	writer.writeUtf8TerminatedString(box.cueId);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/iden.ts
+//#region src/writers/writeImda.ts
 /**
-* Parse a WebVTTCueIdBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write an IdentifiedMediaDataBox to an IsoDataWriter.
 *
-* @returns A parsed WebVTTCueIdBox
+* @param box - The IdentifiedMediaDataBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function iden(view) {
-	return { cueId: view.readUtf8(-1) };
+function writeImda(box) {
+	const headerSize = 8;
+	const imdaIdentifierSize = 4;
+	const dataSize = box.data.length;
+	const writer = new IsoBoxWriteView("imda", headerSize + imdaIdentifierSize + dataSize);
+	writer.writeUint(box.imdaIdentifier, 4);
+	writer.writeBytes(box.data);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/imda.ts
+//#region src/writers/writeKind.ts
 /**
-* Parse a IdentifiedMediaDataBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a TrackKindBox to an IsoDataWriter.
 *
-* @returns A parsed IdentifiedMediaDataBox
+* @param box - The TrackKindBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function imda(view) {
-	return {
-		imdaIdentifier: view.readUint(4),
-		data: view.readData(-1)
-	};
+function writeKind(box) {
+	const schemeUriBytes = encodeText(box.schemeUri);
+	const valueBytes = encodeText(box.value);
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const schemeUriSize = schemeUriBytes.length + 1;
+	const valueSize = valueBytes.length + 1;
+	const writer = new IsoBoxWriteView("kind", headerSize + fullBoxSize + schemeUriSize + valueSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUtf8TerminatedString(box.schemeUri);
+	writer.writeUtf8TerminatedString(box.value);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/kind.ts
+//#region src/writers/writeLabl.ts
 /**
-* Parse a TrackKinBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a LabelBox to an IsoDataWriter.
 *
-* @returns A parsed TrackKindBox
+* @param box - The LabelBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function kind(view) {
-	return {
-		...view.readFullBox(),
-		schemeUri: view.readUtf8(-1),
-		value: view.readUtf8(-1)
-	};
+function writeLabl(box) {
+	const languageBytes = encodeText(box.language);
+	const labelBytes = encodeText(box.label);
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const labelIdSize = 2;
+	const languageSize = languageBytes.length + 1;
+	const labelSize = labelBytes.length + 1;
+	const writer = new IsoBoxWriteView("labl", headerSize + fullBoxSize + labelIdSize + languageSize + labelSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.labelId, 2);
+	writer.writeUtf8TerminatedString(box.language);
+	writer.writeUtf8TerminatedString(box.label);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/labl.ts
+//#region src/writers/writeMdat.ts
 /**
-* Parse a LabelBox from an IsoView
+* Write a MediaDataBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.1.1 Media Data Box
 *
-* @returns A parsed LabelBox
+* @param box - The MediaDataBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function labl(view) {
-	const { version, flags } = view.readFullBox();
-	return {
-		version,
-		flags,
-		isGroupLabel: (flags & 1) !== 0,
-		labelId: view.readUint(2),
-		language: view.readUtf8(-1),
-		label: view.readUtf8(-1)
-	};
+function writeMdat(box) {
+	const writer = new IsoBoxWriteView("mdat", 8 + box.data.length);
+	writer.writeBytes(box.data);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/mdat.ts
+//#region src/writers/writeMdhd.ts
 /**
-* Parse a MediaDataBox from an IsoView
+* Write a MediaHeaderBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.4.2 Media Header Box
 *
-* @returns A parsed MediaDataBox
+* @param box - The MediaHeaderBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function mdat(view) {
-	return { data: view.readData(-1) };
+function writeMdhd(box) {
+	const size = box.version === 1 ? 8 : 4;
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const timesSize = size * 3;
+	const writer = new IsoBoxWriteView("mdhd", headerSize + fullBoxSize + timesSize + 4 + 2 + 2);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.creationTime, size);
+	writer.writeUint(box.modificationTime, size);
+	writer.writeUint(box.timescale, 4);
+	writer.writeUint(box.duration, size);
+	const lang = box.language.length >= 3 ? (box.language.charCodeAt(0) - 96 & 31) << 10 | (box.language.charCodeAt(1) - 96 & 31) << 5 | box.language.charCodeAt(2) - 96 & 31 : 0;
+	writer.writeUint(lang, 2);
+	writer.writeUint(box.preDefined, 2);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/mdhd.ts
+//#region src/writers/writeMehd.ts
 /**
-* Parse a MediaHeaderBox from an IsoView
+* Write a MovieExtendsHeaderBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.8.2 Movie Extends Header Box
 *
-* @returns A parsed MediaHeaderBox
+* @param box - The MovieExtendsHeaderBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function mdhd(view) {
-	const { version, flags } = view.readFullBox();
-	const creationTime = view.readUint(version == 1 ? 8 : 4);
-	const modificationTime = view.readUint(version == 1 ? 8 : 4);
-	const timescale = view.readUint(4);
-	const duration = view.readUint(version == 1 ? 8 : 4);
-	const lang = view.readUint(2);
-	return {
-		version,
-		flags,
-		creationTime,
-		modificationTime,
-		timescale,
-		duration,
-		language: String.fromCharCode((lang >> 10 & 31) + 96, (lang >> 5 & 31) + 96, (lang & 31) + 96),
-		preDefined: view.readUint(2)
-	};
+function writeMehd(box) {
+	const size = box.version === 1 ? 8 : 4;
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const fragmentDurationSize = size;
+	const writer = new IsoBoxWriteView("mehd", headerSize + fullBoxSize + fragmentDurationSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.fragmentDuration, size);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/mehd.ts
+//#region src/writers/writeMeta.ts
 /**
-* Parse a MovieExtendsHeaderBox from an IsoView
+* Write a MetaBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.11.1 Meta Box
 *
-* @returns A parsed MovieExtendsHeaderBox
+* @param box - The MetaBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function mehd(view) {
-	const { version, flags } = view.readFullBox();
-	return {
-		version,
-		flags,
-		fragmentDuration: view.readUint(version === 1 ? 8 : 4)
-	};
+function writeMeta(box) {
+	const writer = new IsoBoxWriteView("meta", 12);
+	writer.writeFullBox(box.version, box.flags);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/meta.ts
+//#region src/writers/writeMfhd.ts
 /**
-* Parse a MetaBox from an IsoView
+* Write a MovieFragmentHeaderBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.8.5 Movie Fragment Header Box
 *
-* @returns A parsed MetaBox
+* @param box - The MovieFragmentHeaderBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function meta(view) {
-	return view.readFullBox();
+function writeMfhd(box) {
+	const writer = new IsoBoxWriteView("mfhd", 16);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.sequenceNumber, 4);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/mfhd.ts
+//#region src/writers/writeMfro.ts
 /**
-* Parse a MovieFragmentHeaderBox from an IsoView
+* Write a MovieFragmentRandomAccessOffsetBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.8.11 Movie Fragment Random Access Offset Box
 *
-* @returns A parsed MovieFragmentHeaderBox
+* @param box - The MovieFragmentRandomAccessOffsetBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function mfhd(view) {
-	return {
-		...view.readFullBox(),
-		sequenceNumber: view.readUint(4)
-	};
+function writeMfro(box) {
+	const writer = new IsoBoxWriteView("mfro", 16);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.mfraSize, 4);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/mfro.ts
+//#region src/writers/writeMp4a.ts
 /**
-* Parse a MovieFragmentRandomAccessBox from an IsoView
+* Write an AudioSampleEntryBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 12.2.3 Audio Sample Entry
 *
-* @returns A parsed MovieFragmentRandomAccessBox
+* @param box - The AudioSampleEntryBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function mfro(view) {
-	return {
-		...view.readFullBox(),
-		mfraSize: view.readUint(4)
-	};
+function writeMp4a(box) {
+	const headerSize = 8;
+	const reserved1Size = 6;
+	const dataReferenceIndexSize = 2;
+	const reserved2Size = 8;
+	const channelcountSize = 2;
+	const samplesizeSize = 2;
+	const preDefinedSize = 2;
+	const reserved3Size = 2;
+	const samplerateSize = 4;
+	const esdsSize = box.esds.length;
+	const writer = new IsoBoxWriteView("mp4a", headerSize + reserved1Size + dataReferenceIndexSize + reserved2Size + channelcountSize + samplesizeSize + preDefinedSize + reserved3Size + samplerateSize + esdsSize);
+	writer.writeArray(box.reserved1, UINT, 1, 6);
+	writer.writeUint(box.dataReferenceIndex, 2);
+	writer.writeArray(box.reserved2, UINT, 4, 2);
+	writer.writeUint(box.channelcount, 2);
+	writer.writeUint(box.samplesize, 2);
+	writer.writeUint(box.preDefined, 2);
+	writer.writeUint(box.reserved3, 2);
+	writer.writeTemplate(box.samplerate, 4);
+	writer.writeBytes(box.esds);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/mvhd.ts
+//#region src/writers/writeMvhd.ts
 /**
-* Parse a Box from an IsoView
+* Write a MovieHeaderBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.2.2 Movie Header Box
 *
-* @returns A parsed Box
+* @param box - The MovieHeaderBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function mvhd(view) {
-	const { readUint: readUint$1, readTemplate: readTemplate$1, readArray } = view;
-	const { version, flags } = view.readFullBox();
-	const size = version == 1 ? 8 : 4;
-	return {
-		version,
-		flags,
-		creationTime: readUint$1(size),
-		modificationTime: readUint$1(size),
-		timescale: readUint$1(4),
-		duration: readUint$1(size),
-		rate: readTemplate$1(4),
-		volume: readTemplate$1(2),
-		reserved1: readUint$1(2),
-		reserved2: readArray(UINT, 4, 2),
-		matrix: readArray(UINT, 4, 9),
-		preDefined: readArray(UINT, 4, 6),
-		nextTrackId: readUint$1(4)
-	};
+function writeMvhd(box) {
+	const size = box.version === 1 ? 8 : 4;
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const timesSize = size * 3;
+	const writer = new IsoBoxWriteView("mvhd", headerSize + fullBoxSize + timesSize + 4 + 4 + 2 + 2 + 8 + 36 + 24 + 4);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.creationTime, size);
+	writer.writeUint(box.modificationTime, size);
+	writer.writeUint(box.timescale, 4);
+	writer.writeUint(box.duration, size);
+	writer.writeTemplate(box.rate, 4);
+	writer.writeTemplate(box.volume, 2);
+	writer.writeUint(box.reserved1, 2);
+	writer.writeArray(box.reserved2, UINT, 4, 2);
+	writer.writeArray(box.matrix, TEMPLATE, 4, 9);
+	writer.writeArray(box.preDefined, UINT, 4, 6);
+	writer.writeUint(box.nextTrackId, 4);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/payl.ts
+//#region src/writers/writePayl.ts
 /**
-* Parse a WebVTTCuePayloadBox from an IsoView
+* Write a WebVttCuePayloadBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
-*
-* @returns A parsed WebVTTCuePayloadBox
+* @param box - The WebVttCuePayloadBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function payl(view) {
-	return { cueText: view.readUtf8(-1) };
+function writePayl(box) {
+	const writer = new IsoBoxWriteView("payl", 8 + (encodeText(box.cueText).length + 1));
+	writer.writeUtf8TerminatedString(box.cueText);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/prft.ts
+//#region src/writers/writePrft.ts
 /**
-* Parse a ProducerReferenceTimeBox from an IsoView
+* Write a ProducerReferenceTimeBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.16.5 Producer Reference Time Box
 *
-* @returns A parsed ProducerReferenceTimeBox
+* @param box - The ProducerReferenceTimeBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function prft(view) {
-	const { version, flags } = view.readFullBox();
-	return {
-		version,
-		flags,
-		referenceTrackId: view.readUint(4),
-		ntpTimestampSec: view.readUint(4),
-		ntpTimestampFrac: view.readUint(4),
-		mediaTime: view.readUint(version === 1 ? 8 : 4)
-	};
+function writePrft(box) {
+	const mediaTimeSize = box.version === 1 ? 8 : 4;
+	const writer = new IsoBoxWriteView("prft", 24 + mediaTimeSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.referenceTrackId, 4);
+	writer.writeUint(box.ntpTimestampSec, 4);
+	writer.writeUint(box.ntpTimestampFrac, 4);
+	writer.writeUint(box.mediaTime, mediaTimeSize);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/prsl.ts
+//#region src/writers/writePrsl.ts
 /**
-* Parse a PreselectionGroupBox from an IsoView
+* Write a PreselectionGroupBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
-*
-* @returns A parsed PreselectionGroupBox
+* @param box - The PreselectionGroupBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function prsl(view) {
-	const { version, flags } = view.readFullBox();
-	const groupId = view.readUint(4);
-	const numEntitiesInGroup = view.readUint(4);
-	return {
-		version,
-		flags,
-		groupId,
-		numEntitiesInGroup,
-		entities: view.readEntries(numEntitiesInGroup, () => ({ entityId: view.readUint(4) })),
-		preselectionTag: flags & 4096 ? view.readUtf8(-1) : void 0,
-		selectionPriority: flags & 8192 ? view.readUint(1) : void 0,
-		interleavingTag: flags & 16384 ? view.readUtf8(-1) : void 0
-	};
+function writePrsl(box) {
+	const preselectionTagBytes = box.flags & 4096 && box.preselectionTag ? encodeText(box.preselectionTag) : null;
+	const interleavingTagBytes = box.flags & 16384 && box.interleavingTag ? encodeText(box.interleavingTag) : null;
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const groupIdSize = 4;
+	const numEntitiesInGroupSize = 4;
+	const entitiesSize = box.numEntitiesInGroup * 4;
+	const preselectionTagSize = preselectionTagBytes ? preselectionTagBytes.length + 1 : 0;
+	const selectionPrioritySize = box.flags & 8192 ? 1 : 0;
+	const interleavingTagSize = interleavingTagBytes ? interleavingTagBytes.length + 1 : 0;
+	const writer = new IsoBoxWriteView("prsl", headerSize + fullBoxSize + groupIdSize + numEntitiesInGroupSize + entitiesSize + preselectionTagSize + selectionPrioritySize + interleavingTagSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.groupId, 4);
+	writer.writeUint(box.numEntitiesInGroup, 4);
+	for (const entity of box.entities) writer.writeUint(entity.entityId, 4);
+	if (preselectionTagBytes && box.preselectionTag) writer.writeUtf8TerminatedString(box.preselectionTag);
+	if (box.flags & 8192) writer.writeUint(box.selectionPriority ?? 0, 1);
+	if (interleavingTagBytes && box.interleavingTag) writer.writeUtf8TerminatedString(box.interleavingTag);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/pssh.ts
+//#region src/writers/writePssh.ts
 /**
-* Parse a ProtectionSystemSpecificHeaderBox from an IsoView
+* Write a ProtectionSystemSpecificHeaderBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 23001-7 - 8.1 Protection System Specific Header Box
 *
-* @returns A parsed ProtectionSystemSpecificHeaderBox
+* @param box - The ProtectionSystemSpecificHeaderBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function pssh(view) {
-	const { readUint: readUint$1, readArray } = view;
-	const { version, flags } = view.readFullBox();
-	const systemId = readArray(UINT, 1, 16);
-	let kidCount = 0;
-	let kid = [];
-	if (version > 0) {
-		kidCount = readUint$1(4);
-		kid = readArray(UINT, 1, kidCount);
+function writePssh(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const systemIdSize = 16;
+	const kidCountSize = box.version > 0 ? 4 : 0;
+	const kidSize = box.version > 0 ? box.kidCount * 16 : 0;
+	const dataSizeField = 4;
+	const dataSize = box.dataSize;
+	const writer = new IsoBoxWriteView("pssh", headerSize + fullBoxSize + systemIdSize + kidCountSize + kidSize + dataSizeField + dataSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeArray(box.systemId, UINT, 1, 16);
+	if (box.version > 0) {
+		writer.writeUint(box.kidCount, 4);
+		writer.writeArray(box.kid, UINT, 1, box.kidCount);
 	}
-	const dataSize = readUint$1(4);
-	const data = readArray(UINT, 1, dataSize);
-	return {
-		version,
-		flags,
-		systemId,
-		kidCount,
-		kid,
-		dataSize,
-		data
-	};
+	writer.writeUint(box.dataSize, 4);
+	writer.writeArray(box.data, UINT, 1, box.dataSize);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/schm.ts
+//#region src/writers/writeSchm.ts
 /**
-* Parse a SchemeTypeBox from an IsoView
+* Write a SchemeTypeBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.12.5 Scheme Type Box
 *
-* @returns A parsed SchemeTypeBox
+* @param box - The SchemeTypeBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function schm(view) {
-	const { version, flags } = view.readFullBox();
-	return {
-		version,
-		flags,
-		schemeType: view.readUint(4),
-		schemeVersion: view.readUint(4),
-		schemeUri: flags & 1 ? view.readString(-1) : void 0
-	};
+function writeSchm(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const schemeTypeSize = 4;
+	const schemeVersionSize = 4;
+	const schemeUriSize = box.flags & 1 && box.schemeUri ? box.schemeUri.length + 1 : 0;
+	const writer = new IsoBoxWriteView("schm", headerSize + fullBoxSize + schemeTypeSize + schemeVersionSize + schemeUriSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.schemeType, 4);
+	writer.writeUint(box.schemeVersion, 4);
+	if (box.flags & 1 && box.schemeUri) writer.writeTerminatedString(box.schemeUri);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/sdtp.ts
+//#region src/writers/writeSdtp.ts
 /**
-* Parse a SampleDependencyTypeBox from an IsoView
+* Write a SampleDependencyTypeBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.6.4 Independent and Disposable Samples Box
 *
-* @returns A parsed SampleDependencyTypeBox
+* @param box - The SampleDependencyTypeBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function sdtp(view) {
-	return {
-		...view.readFullBox(),
-		sampleDependencyTable: view.readArray(UINT, 1, view.bytesRemaining)
-	};
+function writeSdtp(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const sampleDependencyTableSize = box.sampleDependencyTable.length;
+	const writer = new IsoBoxWriteView("sdtp", headerSize + fullBoxSize + sampleDependencyTableSize);
+	writer.writeFullBox(box.version, box.flags);
+	for (const entry of box.sampleDependencyTable) writer.writeUint(entry, 1);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/sidx.ts
+//#region src/writers/writeSidx.ts
 /**
-* Parse a SegmentIndexBox from an IsoView
+* Write a SegmentIndexBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.16.3 Segment Index Box
 *
-* @returns A parsed SegmentIndexBox
+* @param box - The SegmentIndexBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function sidx(view) {
-	const { readUint: readUint$1 } = view;
-	const { version, flags } = view.readFullBox();
-	const size = version === 1 ? 8 : 4;
-	const referenceId = readUint$1(4);
-	const timescale = readUint$1(4);
-	const earliestPresentationTime = readUint$1(size);
-	const firstOffset = readUint$1(size);
-	const reserved = readUint$1(2);
-	const referenceCount = readUint$1(2);
-	return {
-		version,
-		flags,
-		referenceId,
-		timescale,
-		earliestPresentationTime,
-		firstOffset,
-		reserved,
-		references: view.readEntries(referenceCount, () => {
-			const entry = {};
-			entry.reference = readUint$1(4);
-			entry.subsegmentDuration = readUint$1(4);
-			entry.sap = readUint$1(4);
-			entry.referenceType = entry.reference >> 31 & 1;
-			entry.referencedSize = entry.reference & 2147483647;
-			entry.startsWithSap = entry.sap >> 31 & 1;
-			entry.sapType = entry.sap >> 28 & 7;
-			entry.sapDeltaTime = entry.sap & 268435455;
-			return entry;
-		})
-	};
+function writeSidx(box) {
+	const size = box.version === 1 ? 8 : 4;
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const referenceIdSize = 4;
+	const timescaleSize = 4;
+	const earliestPresentationTimeSize = size;
+	const firstOffsetSize = size;
+	const reservedSize = 2;
+	const referenceCountSize = 2;
+	const referencesSize = box.references.length * 12;
+	const writer = new IsoBoxWriteView("sidx", headerSize + fullBoxSize + referenceIdSize + timescaleSize + earliestPresentationTimeSize + firstOffsetSize + reservedSize + referenceCountSize + referencesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.referenceId, 4);
+	writer.writeUint(box.timescale, 4);
+	writer.writeUint(box.earliestPresentationTime, size);
+	writer.writeUint(box.firstOffset, size);
+	writer.writeUint(box.reserved ?? 0, 2);
+	writer.writeUint(box.references.length, 2);
+	for (const ref of box.references) {
+		const reference = (ref.referenceType & 1) << 31 | ref.referencedSize & 2147483647;
+		writer.writeUint(reference, 4);
+		writer.writeUint(ref.subsegmentDuration, 4);
+		const sap = (ref.startsWithSap & 1) << 31 | (ref.sapType & 7) << 28 | ref.sapDeltaTime & 268435455;
+		writer.writeUint(sap, 4);
+	}
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/skip.ts
+//#region src/writers/writeSkip.ts
 /**
-* Parse a FreeSpaceBox from an IsoView
+* Write a FreeSpaceBox (skip variant) to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.1.2 Free Space Box
 *
-* @returns A parsed FreeSpaceBox
+* @param box - The FreeSpaceBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function skip(view) {
-	return free(view);
+function writeSkip(box) {
+	const writer = new IsoBoxWriteView("skip", 8 + box.data.length);
+	writer.writeBytes(box.data);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/smhd.ts
+//#region src/writers/writeSmhd.ts
 /**
-* Parse a SoundMediaHeaderBox from an IsoView
+* Write a SoundMediaHeaderBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 12.2.2 Sound Media Header Box
 *
-* @returns A parsed SoundMediaHeaderBox
+* @param box - The SoundMediaHeaderBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function smhd(view) {
-	return {
-		...view.readFullBox(),
-		balance: view.readUint(2),
-		reserved: view.readUint(2)
-	};
+function writeSmhd(box) {
+	const writer = new IsoBoxWriteView("smhd", 16);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.balance, 2);
+	writer.writeUint(box.reserved, 2);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/ssix.ts
+//#region src/writers/writeSsix.ts
 /**
-* Parse a SubsegmentIndexBox from an IsoView
+* Write a SubsegmentIndexBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.16.4 Subsegment Index Box
 *
-* @returns A parsed SubsegmentIndexBox
+* @param box - The SubsegmentIndexBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function ssix(view) {
-	const { version, flags } = view.readFullBox();
-	const subsegmentCount = view.readUint(4);
-	return {
-		version,
-		flags,
-		subsegmentCount,
-		subsegments: view.readEntries(subsegmentCount, () => {
-			const rangesCount = view.readUint(4);
-			return {
-				rangesCount,
-				ranges: view.readEntries(rangesCount, () => ({
-					level: view.readUint(1),
-					rangeSize: view.readUint(3)
-				}))
-			};
-		})
-	};
+function writeSsix(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const subsegmentCountSize = 4;
+	let rangesSize = 0;
+	for (const subsegment of box.subsegments) {
+		rangesSize += 4;
+		rangesSize += subsegment.rangesCount * 4;
+	}
+	const writer = new IsoBoxWriteView("ssix", headerSize + fullBoxSize + subsegmentCountSize + rangesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.subsegmentCount, 4);
+	for (const subsegment of box.subsegments) {
+		writer.writeUint(subsegment.rangesCount, 4);
+		for (const range of subsegment.ranges) {
+			writer.writeUint(range.level, 1);
+			writer.writeUint(range.rangeSize, 3);
+		}
+	}
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/sthd.ts
+//#region src/writers/writeSthd.ts
 /**
-* Parse a SubtitleMediaHeaderBox from an IsoView
+* Write a SubtitleMediaHeaderBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 12.6.2 Subtitle Media Header Box
 *
-* @returns A parsed SubtitleMediaHeaderBox
+* @param box - The SubtitleMediaHeaderBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function sthd(view) {
-	return view.readFullBox();
+function writeSthd(box) {
+	const writer = new IsoBoxWriteView("sthd", 12);
+	writer.writeFullBox(box.version, box.flags);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/stsd.ts
+//#region src/writers/writeStsd.ts
 /**
-* Parse a SampleDescriptionBox from an IsoView
+* Write a SampleDescriptionBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
-*
-* @returns A parsed SampleDescriptionBox
+* @param box - The SampleDescriptionBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function stsd(view) {
-	const { version, flags } = view.readFullBox();
-	const entryCount = view.readUint(4);
-	return {
-		version,
-		flags,
-		entryCount,
-		entries: view.readBoxes(entryCount)
-	};
+function writeStsd(box, config) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const entryCountSize = 4;
+	const entryCount = box.entries.length;
+	const entries = writeIsoBoxes(box.entries, config);
+	const entriesSize = entries.reduce((size, entry) => size + entry.byteLength, 0);
+	const writer = new IsoBoxWriteView("stsd", headerSize + fullBoxSize + entryCountSize + entriesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(entryCount, 4);
+	for (const entry of entries) writer.writeBytes(entry);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/stss.ts
+//#region src/writers/writeStss.ts
 /**
-* Parse a SyncSampleBox from an IsoView
+* Write a SyncSampleBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.6.2 Sync Sample Box
 *
-* @returns A parsed SyncSampleBox
+* @param box - The SyncSampleBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function stss(view) {
-	const { version, flags } = view.readFullBox();
-	const entryCount = view.readUint(4);
-	return {
-		version,
-		flags,
-		entryCount,
-		entries: view.readEntries(entryCount, () => ({ sampleNumber: view.readUint(4) }))
-	};
+function writeStss(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const entryCountSize = 4;
+	const entriesSize = box.entryCount * 4;
+	const writer = new IsoBoxWriteView("stss", headerSize + fullBoxSize + entryCountSize + entriesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.entryCount, 4);
+	for (const entry of box.entries) writer.writeUint(entry.sampleNumber, 4);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/sttg.ts
+//#region src/writers/writeSttg.ts
 /**
-* Parse a WebVTTSettingsBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a WebVttSettingsBox to an IsoDataWriter.
 *
-* @returns A parsed WebVTTSettingsBox
+* @param box - The WebVttSettingsBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function sttg(view) {
-	return { settings: view.readUtf8(-1) };
+function writeSttg(box) {
+	const writer = new IsoBoxWriteView("sttg", 8 + (encodeText(box.settings).length + 1));
+	writer.writeUtf8TerminatedString(box.settings);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/stts.ts
+//#region src/writers/writeStts.ts
 /**
-* Parse a DecodingTimeToSampleBox from an IsoView
+* Write a DecodingTimeToSampleBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.6.1.2 Decoding Time to Sample Box
 *
-* @returns A parsed DecodingTimeToSampleBox
+* @param box - The DecodingTimeToSampleBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function stts(view) {
-	const { version, flags } = view.readFullBox();
-	const entryCount = view.readUint(4);
-	return {
-		version,
-		flags,
-		entryCount,
-		entries: view.readEntries(entryCount, () => ({
-			sampleCount: view.readUint(4),
-			sampleDelta: view.readUint(4)
-		}))
-	};
+function writeStts(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const entryCountSize = 4;
+	const entriesSize = box.entryCount * 8;
+	const writer = new IsoBoxWriteView("stts", headerSize + fullBoxSize + entryCountSize + entriesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.entryCount, 4);
+	for (const entry of box.entries) {
+		writer.writeUint(entry.sampleCount, 4);
+		writer.writeUint(entry.sampleDelta, 4);
+	}
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/styp.ts
+//#region src/writers/writeStyp.ts
 /**
-* Parse a SegmentTypeBox from an IsoView
+* Write a SegmentTypeBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.16.2 Segment Type Box
 *
-* @returns A parsed SegmentTypeBox
+* @param box - The SegmentTypeBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function styp(view) {
-	return ftyp(view);
+function writeStyp(box) {
+	const headerSize = 8;
+	const majorBrandSize = 4;
+	const minorVersionSize = 4;
+	const compatibleBrandsSize = box.compatibleBrands.length * 4;
+	const writer = new IsoBoxWriteView("styp", headerSize + majorBrandSize + minorVersionSize + compatibleBrandsSize);
+	writer.writeString(box.majorBrand);
+	writer.writeUint(box.minorVersion, 4);
+	for (const brand of box.compatibleBrands) writer.writeString(brand);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/subs.ts
+//#region src/writers/writeSubs.ts
 /**
-* Parse a SubSampleInformationBox from an IsoView
+* Write a SubsampleInformationBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.7.7 Sub-Sample Information Box
 *
-* @returns A parsed SubSampleInformationBox
+* @param box - The SubsampleInformationBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function subs(view) {
-	const { version, flags } = view.readFullBox();
-	const entryCount = view.readUint(4);
-	return {
-		version,
-		flags,
-		entryCount,
-		entries: view.readEntries(entryCount, () => {
-			const sampleDelta = view.readUint(4);
-			const subsampleCount = view.readUint(2);
-			return {
-				sampleDelta,
-				subsampleCount,
-				subsamples: view.readEntries(subsampleCount, () => ({
-					subsampleSize: view.readUint(version === 1 ? 4 : 2),
-					subsamplePriority: view.readUint(1),
-					discardable: view.readUint(1),
-					codecSpecificParameters: view.readUint(4)
-				}))
-			};
-		})
-	};
+function writeSubs(box) {
+	const subsampleSizeBytes = box.version === 1 ? 4 : 2;
+	let entriesSize = 0;
+	for (const entry of box.entries) {
+		entriesSize += 4;
+		entriesSize += 2;
+		entriesSize += entry.subsampleCount * (subsampleSizeBytes + 1 + 1 + 4);
+	}
+	const writer = new IsoBoxWriteView("subs", 16 + entriesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.entryCount, 4);
+	for (const entry of box.entries) {
+		writer.writeUint(entry.sampleDelta, 4);
+		writer.writeUint(entry.subsampleCount, 2);
+		for (const subsample of entry.subsamples) {
+			writer.writeUint(subsample.subsampleSize, subsampleSizeBytes);
+			writer.writeUint(subsample.subsamplePriority, 1);
+			writer.writeUint(subsample.discardable, 1);
+			writer.writeUint(subsample.codecSpecificParameters, 4);
+		}
+	}
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/tenc.ts
+//#region src/writers/writeTenc.ts
 /**
-* Parse a TrackEncryptionBox from an IsoView
+* Write a TrackEncryptionBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 23001-7 - 8.2 Track Encryption Box
 *
-* @returns A parsed TrackEncryptionBox
+* @param box - The TrackEncryptionBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function tenc(view) {
-	return {
-		...view.readFullBox(),
-		defaultIsEncrypted: view.readUint(3),
-		defaultIvSize: view.readUint(1),
-		defaultKid: view.readArray(UINT, 1, 16)
-	};
+function writeTenc(box) {
+	const writer = new IsoBoxWriteView("tenc", 32);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.defaultIsEncrypted, 3);
+	writer.writeUint(box.defaultIvSize, 1);
+	writer.writeArray(box.defaultKid, UINT, 1, 16);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/tfdt.ts
+//#region src/writers/writeTfdt.ts
 /**
-* Parse a TrackFragmentDecodeTimeBox from an IsoView
+* Write a TrackFragmentBaseMediaDecodeTimeBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.8.12 Track Fragment Base Media Decode Time Box
 *
-* @returns A parsed TrackFragmentDecodeTimeBox
+* @param box - The TrackFragmentBaseMediaDecodeTimeBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function tfdt(view) {
-	const { version, flags } = view.readFullBox();
-	return {
-		version,
-		flags,
-		baseMediaDecodeTime: view.readUint(version == 1 ? 8 : 4)
-	};
+function writeTfdt(box) {
+	const size = box.version === 1 ? 8 : 4;
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const baseMediaDecodeTimeSize = size;
+	const writer = new IsoBoxWriteView("tfdt", headerSize + fullBoxSize + baseMediaDecodeTimeSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.baseMediaDecodeTime, size);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/tfhd.ts
+//#region src/writers/writeTfhd.ts
 /**
-* Parse a TrackFragmentHeaderBox from an IsoView
+* Write a TrackFragmentHeaderBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.8.7 Track Fragment Header Box
 *
-* @returns A parsed TrackFragmentHeaderBox
+* @param box - The TrackFragmentHeaderBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function tfhd(view) {
-	const { version, flags } = view.readFullBox();
-	return {
-		version,
-		flags,
-		trackId: view.readUint(4),
-		baseDataOffset: flags & 1 ? view.readUint(8) : void 0,
-		sampleDescriptionIndex: flags & 2 ? view.readUint(4) : void 0,
-		defaultSampleDuration: flags & 8 ? view.readUint(4) : void 0,
-		defaultSampleSize: flags & 16 ? view.readUint(4) : void 0,
-		defaultSampleFlags: flags & 32 ? view.readUint(4) : void 0
-	};
+function writeTfhd(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const trackIdSize = 4;
+	const baseDataOffsetSize = box.flags & 1 ? 8 : 0;
+	const sampleDescriptionIndexSize = box.flags & 2 ? 4 : 0;
+	const defaultSampleDurationSize = box.flags & 8 ? 4 : 0;
+	const defaultSampleSizeSize = box.flags & 16 ? 4 : 0;
+	const defaultSampleFlagsSize = box.flags & 32 ? 4 : 0;
+	const writer = new IsoBoxWriteView("tfhd", headerSize + fullBoxSize + trackIdSize + baseDataOffsetSize + sampleDescriptionIndexSize + defaultSampleDurationSize + defaultSampleSizeSize + defaultSampleFlagsSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.trackId, 4);
+	if (box.flags & 1) writer.writeUint(box.baseDataOffset ?? 0, 8);
+	if (box.flags & 2) writer.writeUint(box.sampleDescriptionIndex ?? 0, 4);
+	if (box.flags & 8) writer.writeUint(box.defaultSampleDuration ?? 0, 4);
+	if (box.flags & 16) writer.writeUint(box.defaultSampleSize ?? 0, 4);
+	if (box.flags & 32) writer.writeUint(box.defaultSampleFlags ?? 0, 4);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/tfra.ts
+//#region src/writers/writeTfra.ts
 /**
-* Parse a TrackFragmentRandomAccessBox from an IsoView
+* Write a TrackFragmentRandomAccessBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.8.10 Track Fragment Random Access Box
 *
-* @returns A parsed TrackFragmentRandomAccessBox
+* @param box - The TrackFragmentRandomAccessBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function tfra(view) {
-	const { version, flags } = view.readFullBox();
-	const trackId = view.readUint(4);
-	const reserved = view.readUint(4);
-	const lengthSizeOfTrafNum = (reserved & 48) >> 4;
-	const lengthSizeOfTrunNum = (reserved & 12) >> 2;
-	const lengthSizeOfSampleNum = reserved & 3;
-	const numberOfEntry = view.readUint(4);
-	return {
-		version,
-		flags,
-		trackId,
-		reserved,
-		lengthSizeOfTrafNum,
-		lengthSizeOfTrunNum,
-		lengthSizeOfSampleNum,
-		numberOfEntry,
-		entries: view.readEntries(numberOfEntry, () => ({
-			time: view.readUint(version === 1 ? 8 : 4),
-			moofOffset: view.readUint(version === 1 ? 8 : 4),
-			trafNumber: view.readUint(lengthSizeOfTrafNum + 1),
-			trunNumber: view.readUint(lengthSizeOfTrunNum + 1),
-			sampleNumber: view.readUint(lengthSizeOfSampleNum + 1)
-		}))
-	};
+function writeTfra(box) {
+	const timeSize = box.version === 1 ? 8 : 4;
+	const entrySize = timeSize + timeSize + (box.lengthSizeOfTrafNum + 1) + (box.lengthSizeOfTrunNum + 1) + (box.lengthSizeOfSampleNum + 1);
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const trackIdSize = 4;
+	const reservedSize = 4;
+	const numberOfEntrySize = 4;
+	const entriesSize = box.numberOfEntry * entrySize;
+	const writer = new IsoBoxWriteView("tfra", headerSize + fullBoxSize + trackIdSize + reservedSize + numberOfEntrySize + entriesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.trackId, 4);
+	const reserved = box.lengthSizeOfTrafNum << 4 | box.lengthSizeOfTrunNum << 2 | box.lengthSizeOfSampleNum;
+	writer.writeUint(reserved, 4);
+	writer.writeUint(box.numberOfEntry, 4);
+	for (const entry of box.entries) {
+		writer.writeUint(entry.time, timeSize);
+		writer.writeUint(entry.moofOffset, timeSize);
+		writer.writeUint(entry.trafNumber, box.lengthSizeOfTrafNum + 1);
+		writer.writeUint(entry.trunNumber, box.lengthSizeOfTrunNum + 1);
+		writer.writeUint(entry.sampleNumber, box.lengthSizeOfSampleNum + 1);
+	}
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/tkhd.ts
+//#region src/writers/writeTkhd.ts
 /**
-* Parse a TrackHeaderBox from an IsoView
+* Write a TrackHeaderBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.3.2 Track Header Box
 *
-* @returns A parsed TrackHeaderBox
+* @param box - The TrackHeaderBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function tkhd(view) {
-	const { version, flags } = view.readFullBox();
-	const size = version === 1 ? 8 : 4;
-	return {
-		version,
-		flags,
-		creationTime: view.readUint(size),
-		modificationTime: view.readUint(size),
-		trackId: view.readUint(4),
-		reserved1: view.readUint(4),
-		duration: view.readUint(size),
-		reserved2: view.readArray(UINT, 4, 2),
-		layer: view.readUint(2),
-		alternateGroup: view.readUint(2),
-		volume: view.readTemplate(2),
-		reserved3: view.readUint(2),
-		matrix: view.readArray(TEMPLATE, 4, 9),
-		width: view.readTemplate(4),
-		height: view.readTemplate(4)
-	};
+function writeTkhd(box) {
+	const size = box.version === 1 ? 8 : 4;
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const timesSize = size * 3;
+	const writer = new IsoBoxWriteView("tkhd", headerSize + fullBoxSize + timesSize + 4 + 4 + 8 + 2 + 2 + 2 + 2 + 36 + 4 + 4);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.creationTime, size);
+	writer.writeUint(box.modificationTime, size);
+	writer.writeUint(box.trackId, 4);
+	writer.writeUint(box.reserved1, 4);
+	writer.writeUint(box.duration, size);
+	writer.writeArray(box.reserved2, UINT, 4, 2);
+	writer.writeUint(box.layer, 2);
+	writer.writeUint(box.alternateGroup, 2);
+	writer.writeTemplate(box.volume, 2);
+	writer.writeUint(box.reserved3, 2);
+	writer.writeArray(box.matrix, TEMPLATE, 4, 9);
+	writer.writeTemplate(box.width, 4);
+	writer.writeTemplate(box.height, 4);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/trex.ts
+//#region src/writers/writeTrex.ts
 /**
-* Parse a TrackExtendsBox from an IsoView
+* Write a TrackExtendsBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.8.3 Track Extends Box
 *
-* @returns A parsed TrackExtendsBox
+* @param box - The TrackExtendsBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function trex(view) {
-	return {
-		...view.readFullBox(),
-		trackId: view.readUint(4),
-		defaultSampleDescriptionIndex: view.readUint(4),
-		defaultSampleDuration: view.readUint(4),
-		defaultSampleSize: view.readUint(4),
-		defaultSampleFlags: view.readUint(4)
-	};
+function writeTrex(box) {
+	const writer = new IsoBoxWriteView("trex", 32);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.trackId, 4);
+	writer.writeUint(box.defaultSampleDescriptionIndex, 4);
+	writer.writeUint(box.defaultSampleDuration, 4);
+	writer.writeUint(box.defaultSampleSize, 4);
+	writer.writeUint(box.defaultSampleFlags, 4);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/trun.ts
+//#region src/writers/writeTrun.ts
 /**
-* Parse a TrackRunBox from an IsoView
+* Write a TrackRunBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.8.8 Track Run Box
 *
-* @returns A parsed TrackRunBox
+* @param box - The TrackRunBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function trun(view) {
-	const { version, flags } = view.readFullBox();
-	const sampleCount = view.readUint(4);
-	let dataOffset;
-	let firstSampleFlags;
-	if (flags & 1) dataOffset = view.readInt(4);
-	if (flags & 4) firstSampleFlags = view.readUint(4);
-	const samples = view.readEntries(sampleCount, () => {
-		const sample = {};
-		if (flags & 256) sample.sampleDuration = view.readUint(4);
-		if (flags & 512) sample.sampleSize = view.readUint(4);
-		if (flags & 1024) sample.sampleFlags = view.readUint(4);
-		if (flags & 2048) sample.sampleCompositionTimeOffset = version === 1 ? view.readInt(4) : view.readUint(4);
-		return sample;
-	});
-	return {
-		version,
-		flags,
-		sampleCount,
-		dataOffset,
-		firstSampleFlags,
-		samples
-	};
+function writeTrun(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const sampleCountSize = 4;
+	const dataOffsetSize = box.flags & 1 ? 4 : 0;
+	const firstSampleFlagsSize = box.flags & 4 ? 4 : 0;
+	let sampleSize = 0;
+	if (box.flags & 256) sampleSize += 4;
+	if (box.flags & 512) sampleSize += 4;
+	if (box.flags & 1024) sampleSize += 4;
+	if (box.flags & 2048) sampleSize += 4;
+	const samplesSize = sampleSize * box.sampleCount;
+	const writer = new IsoBoxWriteView("trun", headerSize + fullBoxSize + sampleCountSize + dataOffsetSize + firstSampleFlagsSize + samplesSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.sampleCount, 4);
+	if (box.flags & 1) writer.writeUint(box.dataOffset ?? 0, 4);
+	if (box.flags & 4) writer.writeUint(box.firstSampleFlags ?? 0, 4);
+	for (const sample of box.samples) {
+		if (box.flags & 256) writer.writeUint(sample.sampleDuration ?? 0, 4);
+		if (box.flags & 512) writer.writeUint(sample.sampleSize ?? 0, 4);
+		if (box.flags & 1024) writer.writeUint(sample.sampleFlags ?? 0, 4);
+		if (box.flags & 2048) writer.writeUint(sample.sampleCompositionTimeOffset ?? 0, 4);
+	}
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/url.ts
+//#region src/writers/writeUrl.ts
 /**
-* Parse a UrlBox from an IsoView
+* Write a UrlBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.7.2 Data Reference Box
 *
-* @returns A parsed UrlBox
+* @param box - The UrlBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function url(view) {
-	return {
-		...view.readFullBox(),
-		location: view.readString(-1)
-	};
+function writeUrl(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const locationSize = box.location.length + 1;
+	const writer = new IsoBoxWriteView("url ", headerSize + fullBoxSize + locationSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeTerminatedString(box.location);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/urn.ts
+//#region src/writers/writeUrn.ts
 /**
-* Parse a UrnBox from an IsoView
+* Write a UrnBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 8.7.2 Data Reference Box
 *
-* @returns A parsed UrnBox
+* @param box - The UrnBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function urn(view) {
-	return {
-		...view.readFullBox(),
-		name: view.readString(-1),
-		location: view.readString(-1)
-	};
+function writeUrn(box) {
+	const headerSize = 8;
+	const fullBoxSize = 4;
+	const nameSize = box.name.length + 1;
+	const locationSize = box.location.length + 1;
+	const writer = new IsoBoxWriteView("urn ", headerSize + fullBoxSize + nameSize + locationSize);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeTerminatedString(box.name);
+	writer.writeTerminatedString(box.location);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/vlab.ts
+//#region src/writers/writeVlab.ts
 /**
-* Parse a WebVTTSourceLabelBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a WebVttSourceLabelBox to an IsoDataWriter.
 *
-* @returns A parsed WebVTTSourceLabelBox
+* @param box - The WebVttSourceLabelBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function vlab(view) {
-	return { sourceLabel: view.readUtf8(-1) };
+function writeVlab(box) {
+	const writer = new IsoBoxWriteView("vlab", 8 + (encodeText(box.sourceLabel).length + 1));
+	writer.writeUtf8TerminatedString(box.sourceLabel);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/vmhd.ts
+//#region src/writers/writeVmhd.ts
 /**
-* Parse a VideoMediaHeaderBox from an IsoView
+* Write a VideoMediaHeaderBox to an IsoDataWriter.
 *
-* @param view - The IsoView to read data from
+* ISO/IEC 14496-12:2012 - 12.1.2 Video Media Header Box
 *
-* @returns A parsed VideoMediaHeaderBox
+* @param box - The VideoMediaHeaderBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function vmhd(view) {
-	return {
-		...view.readFullBox(),
-		graphicsmode: view.readUint(2),
-		opcolor: view.readArray(UINT, 2, 3)
-	};
+function writeVmhd(box) {
+	const writer = new IsoBoxWriteView("vmhd", 20);
+	writer.writeFullBox(box.version, box.flags);
+	writer.writeUint(box.graphicsmode, 2);
+	writer.writeArray(box.opcolor, UINT, 2, 3);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/vttC.ts
+//#region src/writers/writeVttC.ts
 /**
-* Parse a WebVTTConfigurationBox from an IsoView
-*
-* @param view - The IsoView to read data from
+* Write a WebVttConfigurationBox to an IsoDataWriter.
 *
-* @returns A parsed WebVttConfigurationBox
+* @param box - The WebVttConfigurationBox fields to write
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function vttC(view) {
-	return { config: view.readUtf8() };
+function writeVttC(box) {
+	const configBytes = encodeText(box.config);
+	const writer = new IsoBoxWriteView("vttC", 8 + configBytes.length);
+	writer.writeBytes(configBytes);
+	return writer;
 }
 
 //#endregion
-//#region src/parsers/vtte.ts
+//#region src/writers/writeVtte.ts
 /**
-* Parse a WebVTT Empty Sample Box from an IsoView
-*
-* @returns A parsed WebVTT Empty Sample Box
+* Write a WebVttEmptySampleBox to an IsoDataWriter.
 *
+* @returns An IsoDataWriter containing the encoded box
 *
-* @beta
+* @public
 */
-function vtte() {
-	return {};
+function writeVtte(_) {
+	return new IsoBoxWriteView("vtte", 8);
 }
 
 //#endregion
-export { ardi, avc1, avc2, avc3, avc4, createIsoView, ctts, dref, elng, elst, emsg, enca, encv, filterBoxes, filterBoxesByType, findBox, findBoxByType, free, frma, ftyp, hdlr, hev1, hvc1, iden, imda, kind, labl, mdat, mdhd, mehd, meta, mfhd, mfro, mp4a, mvhd, parseBoxes, payl, prft, prsl, pssh, schm, sdtp, sidx, skip, smhd, ssix, sthd, stsd, stss, sttg, stts, styp, subs, tenc, tfdt, tfhd, tfra, tkhd, trex, trun, url, urn, vlab, vmhd, vttC, vtte };
+export { CONTAINERS, IsoBoxReadableStream, createIsoBoxReadableStream, isContainer, isFullBox, readArdi, readAvc1, readAvc2, readAvc3, readAvc4, readCtts, readDref, readElng, readElst, readEmsg, readEnca, readEncv, readFree, readFrma, readFtyp, readHdlr, readHev1, readHvc1, readIden, readImda, readIsoBoxes, readKind, readLabl, readMdat, readMdhd, readMehd, readMeta, readMfhd, readMfro, readMp4a, readMvhd, readPayl, readPrft, readPrsl, readPssh, readSchm, readSdtp, readSidx, readSkip, readSmhd, readSsix, readSthd, readStsd, readStss, readSttg, readStts, readStyp, readSubs, readTenc, readTfdt, readTfhd, readTfra, readTkhd, readTrex, readTrun, readUrl, readUrn, readVlab, readVmhd, readVttC, readVtte, traverseIsoBoxes, writeArdi, writeAvc1, writeAvc2, writeAvc3, writeAvc4, writeCtts, writeDref, writeElng, writeElst, writeEmsg, writeEnca, writeEncv, writeFree, writeFrma, writeFtyp, writeHdlr, writeHev1, writeHvc1, writeIden, writeImda, writeIsoBox, writeIsoBoxes, writeKind, writeLabl, writeMdat, writeMdhd, writeMehd, writeMeta, writeMfhd, writeMfro, writeMp4a, writeMvhd, writePayl, writePrft, writePrsl, writePssh, writeSchm, writeSdtp, writeSidx, writeSkip, writeSmhd, writeSsix, writeSthd, writeStsd, writeStss, writeSttg, writeStts, writeStyp, writeSubs, writeTenc, writeTfdt, writeTfhd, writeTfra, writeTkhd, writeTrex, writeTrun, writeUrl, writeUrn, writeVlab, writeVmhd, writeVttC, writeVtte };
 //# sourceMappingURL=index.js.map