shifro 0.2.0 → 1.0.0

package/dist/shifro.cjs

@@ -1,1066 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (all) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let mp4box = require("mp4box");
-mp4box = __toESM(mp4box);
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs);
-let node_stream = require("node:stream");
-node_stream = __toESM(node_stream);
-
-//#region lib/decrypt.ts
-const decrypt = async ({ key, iv, data, algorithm = "AES-CTR" }) => {
-	const algorithmName = algorithm.toUpperCase();
-	const cryptoKey = await crypto.subtle.importKey("raw", key, { name: algorithmName }, false, ["decrypt"]);
-	const decryptedData = await crypto.subtle.decrypt({
-		name: algorithmName,
-		counter: iv,
-		length: 64
-	}, cryptoKey, data);
-	return new Uint8Array(decryptedData);
-};
-
-//#endregion
-//#region lib/data-view-reader.ts
-const toDataView = (uint8Array) => {
-	const arrayBuffer = uint8Array.buffer;
-	return new DataView(arrayBuffer, uint8Array.byteOffset, uint8Array.byteLength);
-};
-const fromDataView = (dataView, position = 0, length) => {
-	return new Uint8Array(dataView.buffer, dataView.byteOffset + position, length);
-};
-var DataViewReaderError = class extends Error {
-	constructor(severity, category, code, message) {
-		super(message);
-		this.severity = severity;
-		this.category = category;
-		this.code = code;
-		this.name = "DataViewReaderError";
-	}
-};
-var DataViewReader = class {
-	dataView;
-	littleEndian;
-	position = 0;
-	constructor(data, endianness = "BE") {
-		this.dataView = toDataView(data);
-		this.littleEndian = endianness === "LE";
-	}
-	getDataView() {
-		return this.dataView;
-	}
-	hasMoreData() {
-		return this.position < this.dataView.byteLength;
-	}
-	getPosition() {
-		return this.position;
-	}
-	getLength() {
-		return this.dataView.byteLength;
-	}
-	readUint8() {
-		this.checkBounds(1);
-		const value = this.dataView.getUint8(this.position);
-		this.position += 1;
-		return value;
-	}
-	readUint16() {
-		this.checkBounds(2);
-		const value = this.dataView.getUint16(this.position, this.littleEndian);
-		this.position += 2;
-		return value;
-	}
-	readUint32() {
-		this.checkBounds(4);
-		const value = this.dataView.getUint32(this.position, this.littleEndian);
-		this.position += 4;
-		return value;
-	}
-	readInt32() {
-		this.checkBounds(4);
-		const value = this.dataView.getInt32(this.position, this.littleEndian);
-		this.position += 4;
-		return value;
-	}
-	readUint64() {
-		let low, high;
-		try {
-			if (this.littleEndian) {
-				low = this.dataView.getUint32(this.position, true);
-				high = this.dataView.getUint32(this.position + 4, true);
-			} else {
-				high = this.dataView.getUint32(this.position, false);
-				low = this.dataView.getUint32(this.position + 4, false);
-			}
-		} catch (e) {
-			throw this.outOfBounds();
-		}
-		if (high > 2097151) throw new DataViewReaderError("CRITICAL", "MEDIA", "JS_INTEGER_OVERFLOW", "64-bit integer overflow");
-		this.position += 8;
-		return high * Math.pow(2, 32) + low;
-	}
-	readBytes(bytes) {
-		this.checkBounds(bytes);
-		const value = fromDataView(this.dataView, this.position, bytes);
-		this.position += bytes;
-		return value;
-	}
-	skip(bytes) {
-		this.checkBounds(bytes);
-		this.position += bytes;
-	}
-	rewind(bytes) {
-		if (this.position < bytes) throw this.outOfBounds();
-		this.position -= bytes;
-	}
-	seek(position) {
-		if (position < 0 || position > this.dataView.byteLength) throw this.outOfBounds();
-		this.position = position;
-	}
-	readTerminatedString() {
-		const start = this.position;
-		while (this.hasMoreData() && this.dataView.getUint8(this.position) !== 0) this.position++;
-		if (!this.hasMoreData()) throw this.outOfBounds();
-		const buffer = new Uint8Array(this.dataView.buffer, start, this.position - start);
-		this.position++;
-		return new TextDecoder().decode(buffer);
-	}
-	checkBounds(bytes) {
-		if (this.position + bytes > this.dataView.byteLength) throw this.outOfBounds();
-	}
-	outOfBounds() {
-		return new DataViewReaderError("CRITICAL", "MEDIA", "BUFFER_READ_OUT_OF_BOUNDS", "Read operation out of bounds");
-	}
-};
-
-//#endregion
-//#region lib/parser.ts
-let BoxType = /* @__PURE__ */ function(BoxType$1) {
-	BoxType$1[BoxType$1["BASIC_BOX"] = 0] = "BASIC_BOX";
-	BoxType$1[BoxType$1["FULL_BOX"] = 1] = "FULL_BOX";
-	return BoxType$1;
-}({});
-var Mp4Parser = class Mp4Parser {
-	headers = /* @__PURE__ */ new Map();
-	boxDefinitions = /* @__PURE__ */ new Map();
-	done = false;
-	box(type, definition) {
-		const typeCode = Mp4Parser.typeFromString(type);
-		this.headers.set(typeCode, BoxType.BASIC_BOX);
-		this.boxDefinitions.set(typeCode, definition);
-		return this;
-	}
-	fullBox(type, definition) {
-		const typeCode = Mp4Parser.typeFromString(type);
-		this.headers.set(typeCode, BoxType.FULL_BOX);
-		this.boxDefinitions.set(typeCode, definition);
-		return this;
-	}
-	stop() {
-		this.done = true;
-	}
-	parse(data, partialOkay = false, stopOnPartial = false) {
-		const reader = new DataViewReader(data);
-		this.done = false;
-		while (reader.hasMoreData() && !this.done) this.parseNext(0, reader, partialOkay, stopOnPartial);
-	}
-	parseNext(absStart, reader, partialOkay, stopOnPartial) {
-		const start = reader.getPosition();
-		if (stopOnPartial && start + 8 > reader.getLength()) {
-			this.done = true;
-			return;
-		}
-		let size = reader.readUint32();
-		const type = reader.readUint32();
-		const name = Mp4Parser.typeToString(type);
-		let has64BitSize = false;
-		switch (size) {
-			case 0:
-				size = reader.getLength() - start;
-				break;
-			case 1:
-				if (stopOnPartial && reader.getPosition() + 8 > reader.getLength()) {
-					this.done = true;
-					return;
-				}
-				size = Number(reader.readUint64());
-				has64BitSize = true;
-				break;
-		}
-		const boxDefinition = this.boxDefinitions.get(type);
-		if (boxDefinition) {
-			let version = null;
-			let flags = null;
-			if (this.headers.get(type) === BoxType.FULL_BOX) {
-				if (stopOnPartial && reader.getPosition() + 4 > reader.getLength()) {
-					this.done = true;
-					return;
-				}
-				const versionAndFlags = reader.readUint32();
-				version = versionAndFlags >>> 24;
-				flags = versionAndFlags & 16777215;
-			}
-			let end = start + size;
-			if (partialOkay && end > reader.getLength()) end = reader.getLength();
-			if (stopOnPartial && end > reader.getLength()) {
-				this.done = true;
-				return;
-			}
-			const payloadSize = end - reader.getPosition();
-			const payload = payloadSize > 0 ? reader.readBytes(payloadSize) : new Uint8Array();
-			const payloadReader = new DataViewReader(payload);
-			const box = {
-				name,
-				parser: this,
-				partialOkay: !!partialOkay,
-				version,
-				flags,
-				reader: payloadReader,
-				size,
-				start: start + absStart,
-				has64BitSize
-			};
-			boxDefinition(box);
-		} else {
-			const skipLength = Math.min(start + size - reader.getPosition(), reader.getLength() - reader.getPosition());
-			reader.skip(skipLength);
-		}
-	}
-	static children(box) {
-		const headerSize = Mp4Parser.headerSize(box);
-		while (box.reader.hasMoreData() && !box.parser.done) box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
-	}
-	static sampleDescription(box) {
-		const headerSize = Mp4Parser.headerSize(box);
-		const count = box.reader.readUint32();
-		for (let i = 0; i < count; i++) {
-			box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
-			if (box.parser.done) break;
-		}
-	}
-	static visualSampleEntry(box) {
-		const headerSize = Mp4Parser.headerSize(box);
-		box.reader.skip(78);
-		while (box.reader.hasMoreData() && !box.parser.done) box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
-	}
-	static audioSampleEntry(box) {
-		const headerSize = Mp4Parser.headerSize(box);
-		box.reader.skip(8);
-		const version = box.reader.readUint16();
-		box.reader.skip(6);
-		if (version === 2) box.reader.skip(48);
-		else box.reader.skip(12);
-		if (version === 1) box.reader.skip(16);
-		while (box.reader.hasMoreData() && !box.parser.done) box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
-	}
-	static allData(callback) {
-		return (box) => {
-			const remaining = box.reader.getLength() - box.reader.getPosition();
-			callback(box.reader.readBytes(remaining));
-		};
-	}
-	static typeFromString(name) {
-		if (name.length !== 4) throw new Error("MP4 box names must be 4 characters long");
-		let code = 0;
-		for (const char of name) code = code << 8 | char.charCodeAt(0);
-		return code;
-	}
-	static typeToString(type) {
-		return String.fromCharCode(type >> 24 & 255, type >> 16 & 255, type >> 8 & 255, type & 255);
-	}
-	static headerSize(box) {
-		const basicHeaderSize = 8;
-		const size64Bit = box.has64BitSize ? 8 : 0;
-		const versionAndFlags = box.flags !== null ? 4 : 0;
-		return basicHeaderSize + size64Bit + versionAndFlags;
-	}
-};
-
-//#endregion
-//#region lib/parsing/senc.ts
-const parseSencBox = (reader, flags) => {
-	if (flags && flags & 1) {
-		reader.readUint8();
-		reader.readUint8();
-		reader.readBytes(16);
-	}
-	const sampleCount = reader.readUint32();
-	const samples = [];
-	for (let i = 0; i < sampleCount; i++) {
-		const ivSize = 8;
-		const iv = new Uint8Array(16);
-		iv.set(reader.readBytes(ivSize));
-		const sample = {
-			iv,
-			subsamples: []
-		};
-		if (flags && flags & 2) {
-			const subsampleCount = reader.readUint16();
-			for (let j = 0; j < subsampleCount; j++) {
-				const bytesOfClearData = reader.readUint16();
-				const bytesOfEncryptedData = reader.readUint32();
-				sample.subsamples.push({
-					bytesOfClearData,
-					bytesOfEncryptedData
-				});
-			}
-		}
-		samples.push(sample);
-	}
-	return { samples };
-};
-
-//#endregion
-//#region lib/parsing/trun.ts
-const parseTrunBox = (reader, flags, version) => {
-	const sampleCount = reader.readUint32();
-	const samples = [];
-	let dataOffset = null;
-	if (flags & 1) dataOffset = reader.readInt32();
-	if (flags & 4) reader.skip(4);
-	for (let i = 0; i < sampleCount; i++) {
-		const sample = {};
-		if (flags & 256) sample.duration = reader.readUint32();
-		if (flags & 512) sample.size = reader.readUint32();
-		if (flags & 1024) reader.skip(4);
-		if (flags & 2048) sample.compositionTimeOffset = version == 0 ? reader.readUint32() : reader.readInt32();
-		samples.push(sample);
-	}
-	return {
-		samples,
-		dataOffset
-	};
-};
-
-//#endregion
-//#region lib/parsing/tfhd.ts
-const parseTfhdBox = (reader, flags) => {
-	let defaultSampleDuration;
-	let defaultSampleSize;
-	let baseDataOffset;
-	let sampleDescriptionIndex;
-	const trackId = reader.readUint32();
-	if (flags & 1) baseDataOffset = reader.readUint64();
-	if (flags & 2) sampleDescriptionIndex = reader.readUint32();
-	if (flags & 8) defaultSampleDuration = reader.readUint32();
-	if (flags & 16) defaultSampleSize = reader.readUint32();
-	return {
-		trackId,
-		defaultSampleDuration,
-		defaultSampleSize,
-		baseDataOffset,
-		sampleDescriptionIndex
-	};
-};
-
-//#endregion
-//#region lib/buffer.ts
-const indexOfUint8Array = (buffer, search, start) => {
-	if (search.length === 0) return -1;
-	const max = buffer.length - search.length + 1;
-	for (let i = start; i < max; i++) {
-		let match = true;
-		for (let j = 0; j < search.length; j++) if (buffer[i + j] !== search[j]) {
-			match = false;
-			break;
-		}
-		if (match) return i;
-	}
-	return -1;
-};
-const bufferReplaceAll = (buffer, original, replacement) => {
-	const encoder = new TextEncoder();
-	const originalBytes = encoder.encode(original);
-	const replacementBytes = encoder.encode(replacement);
-	if (originalBytes.length !== replacementBytes.length) throw new Error("Original and replacement must have the same byte length");
-	let idx = 0;
-	do {
-		idx = indexOfUint8Array(buffer, originalBytes, 0);
-		if (idx !== -1) buffer.set(replacementBytes, idx);
-	} while (idx !== -1);
-};
-const bufferIncludes = (buffer, search, offset = 0) => {
-	const encoder = new TextEncoder();
-	let searchBytes;
-	if (typeof search === "string") searchBytes = encoder.encode(search);
-	else if (typeof search === "number") searchBytes = new Uint8Array([search]);
-	else searchBytes = search;
-	if (searchBytes.length === 0) return true;
-	if (buffer.length < searchBytes.length) return false;
-	return indexOfUint8Array(buffer, searchBytes, offset) !== -1;
-};
-const concatUint8Array = (list, totalLength) => {
-	if (list.length === 0) return new Uint8Array(0);
-	let calculatedLength = totalLength ?? list.reduce((acc, curr) => acc + curr.length, 0);
-	calculatedLength = Math.min(calculatedLength, list.reduce((acc, curr) => acc + curr.length, 0));
-	const result = new Uint8Array(calculatedLength);
-	let offset = 0;
-	for (const bytes of list) {
-		if (offset >= calculatedLength) break;
-		const chunk = bytes.subarray(0, Math.min(bytes.length, calculatedLength - offset));
-		result.set(chunk, offset);
-		offset += chunk.length;
-	}
-	return result;
-};
-const copyUint8Array = (source, target, targetStart = 0, sourceStart = 0, sourceEnd = source.length) => {
-	targetStart = Math.max(0, Math.min(targetStart, target.length));
-	sourceStart = Math.max(0, Math.min(sourceStart, source.length));
-	sourceEnd = Math.min(sourceEnd, source.length);
-	if (sourceEnd < sourceStart) sourceEnd = sourceStart;
-	const bytesToCopy = Math.min(sourceEnd - sourceStart, target.length - targetStart);
-	if (bytesToCopy <= 0) return 0;
-	target.set(source.subarray(sourceStart, sourceStart + bytesToCopy), targetStart);
-	return bytesToCopy;
-};
-const writeUint8Array = (target, str, offset = 0, maxBytes) => {
-	const encoded = new TextEncoder().encode(str);
-	const safeOffset = Math.max(0, Math.min(offset, target.length));
-	const remainingSpace = target.length - safeOffset;
-	let bytesToWrite = encoded.length;
-	if (typeof maxBytes === "number") bytesToWrite = Math.min(bytesToWrite, maxBytes);
-	bytesToWrite = Math.min(bytesToWrite, remainingSpace);
-	if (bytesToWrite <= 0) return 0;
-	target.set(encoded.subarray(0, bytesToWrite), safeOffset);
-	return bytesToWrite;
-};
-const toHex = (data) => Array.from(data).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-const toBase64 = (data) => {
-	const binString = Array.from(data, (byte) => String.fromCodePoint(byte)).join("");
-	return btoa(binString);
-};
-const parseHex = (hex) => hex.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
-
-//#endregion
-//#region lib/parsing/tenc.ts
-const parseTencBox = (reader) => {
-	reader.readUint8();
-	reader.readUint8();
-	reader.readUint8();
-	reader.readUint8();
-	return { defaultKID: toHex(reader.readBytes(16)) };
-};
-
-//#endregion
-//#region lib/parsing/pssh.ts
-const parsePsshBox = (box) => {
-	const SYSTEM_ID_WIDEVINE = "edef8ba9-79d6-4ace-a3c8-27dcd51d21ed".replaceAll("-", "");
-	const version = box.version ?? 0;
-	if (version !== 0 && version !== 1) throw new Error("PSSH version can only be 0 or 1");
-	const systemIdBytes = box.reader.readBytes(16);
-	const systemIdHex = toHex(systemIdBytes);
-	const systemIdUuid = [
-		systemIdHex.slice(0, 8),
-		systemIdHex.slice(8, 12),
-		systemIdHex.slice(12, 16),
-		systemIdHex.slice(16, 20),
-		systemIdHex.slice(20)
-	].join("-");
-	const dataView = box.reader.getDataView();
-	const pssh = new Uint8Array(dataView.buffer, dataView.byteOffset - 12, box.size);
-	const psshBase64 = toBase64(pssh);
-	const keyIds = [];
-	if (version >= 1) {
-		const kidCount = box.reader.readUint32();
-		for (let i = 0; i < kidCount; i++) keyIds.push(toHex(box.reader.readBytes(16)));
-	}
-	const dataSize = box.reader.readUint32();
-	const systemData = box.reader.readBytes(dataSize);
-	if (systemIdHex === SYSTEM_ID_WIDEVINE) {}
-	return {
-		version,
-		systemId: systemIdUuid,
-		pssh: psshBase64,
-		keyIds,
-		systemData
-	};
-};
-
-//#endregion
-//#region lib/initialization.ts
-const isInitData = (chunk) => {
-	try {
-		let hasMoov = false;
-		let hasMoof = false;
-		new Mp4Parser().box("moov", () => {
-			hasMoov = true;
-		}).box("moof", () => {
-			hasMoof = true;
-		}).parse(chunk, true, true);
-		return hasMoov && !hasMoof;
-	} catch (e) {
-		console.log(e);
-		return false;
-	}
-};
-const getOriginalCodec = (chunk) => {
-	let format = null;
-	new Mp4Parser().box("moov", Mp4Parser.children).box("trak", Mp4Parser.children).box("mdia", Mp4Parser.children).box("minf", Mp4Parser.children).box("stbl", Mp4Parser.children).fullBox("stsd", Mp4Parser.sampleDescription).box("encv", Mp4Parser.visualSampleEntry).box("enca", Mp4Parser.audioSampleEntry).box("sinf", Mp4Parser.children).box("frma", (box) => {
-		const bytes = box.reader.readBytes(4);
-		format = new TextDecoder().decode(bytes);
-	}).parse(chunk, true, true);
-	return format;
-};
-const processInit = async (chunk) => {
-	const originalCodec = getOriginalCodec(chunk);
-	bufferReplaceAll(chunk, "sinf", "skip");
-	bufferReplaceAll(chunk, "pssh", "skip");
-	if (originalCodec) {
-		bufferReplaceAll(chunk, "encv", originalCodec);
-		bufferReplaceAll(chunk, "enca", originalCodec);
-	} else {
-		console.warn("Could not detect original codec, using fallback values");
-		if ((bufferIncludes(chunk, "encv") ? "video" : "audio") === "video") bufferReplaceAll(chunk, "encv", "avc1");
-		else bufferReplaceAll(chunk, "enca", "mp4a");
-	}
-	return chunk;
-};
-const parseInit = (data) => {
-	const initInfo = {
-		schemeType: "",
-		defaultKID: "",
-		psshList: []
-	};
-	new Mp4Parser().box("moov", Mp4Parser.children).box("trak", Mp4Parser.children).box("mdia", Mp4Parser.children).box("minf", Mp4Parser.children).box("stbl", Mp4Parser.children).fullBox("stsd", Mp4Parser.sampleDescription).fullBox("pssh", (box) => initInfo.psshList.push(parsePsshBox(box))).box("encv", Mp4Parser.visualSampleEntry).box("enca", Mp4Parser.audioSampleEntry).box("sinf", Mp4Parser.children).box("schi", Mp4Parser.children).fullBox("schm", (box) => {
-		initInfo.schemeType = new TextDecoder().decode(box.reader.readBytes(4));
-	}).fullBox("tenc", (box) => {
-		const { defaultKID } = parseTencBox(box.reader);
-		initInfo.defaultKID = defaultKID;
-	}).parse(data, false, true);
-	return initInfo;
-};
-
-//#endregion
-//#region lib/process.ts
-const processEncryptedSegment = async (segment, transformSample) => {
-	if (isInitData(segment)) return processInit(segment);
-	let sencInfo;
-	let trunInfo;
-	let tfhdInfo;
-	let mdatOffset;
-	new Mp4Parser().box("moof", Mp4Parser.children).box("traf", Mp4Parser.children).fullBox("tfhd", (box) => {
-		tfhdInfo = parseTfhdBox(box.reader, box.flags);
-	}).fullBox("trun", (box) => {
-		trunInfo = parseTrunBox(box.reader, box.flags, box.version);
-	}).fullBox("senc", (box) => {
-		sencInfo = parseSencBox(box.reader, box.flags);
-	}).parse(segment, true, true);
-	mdatOffset = trunInfo.dataOffset;
-	if (sencInfo.samples.length !== trunInfo.samples.length) throw new Error(`sample count mismatch: trun has ${trunInfo.samples.length}, senc has ${sencInfo.samples.length}`);
-	let position = 0;
-	let time = 0;
-	for (let i = 0; i < sencInfo.samples.length; i++) {
-		const sencSample = sencInfo.samples[i];
-		const trunSample = trunInfo.samples[i];
-		const expectedSize = trunInfo.samples[i].size || tfhdInfo.defaultSampleSize || 0;
-		if (!sencSample.subsamples.length) sencSample.subsamples.push({
-			bytesOfClearData: 0,
-			bytesOfEncryptedData: expectedSize
-		});
-		if (sencSample.subsamples.some((subsample) => subsample.bytesOfEncryptedData > 0)) {
-			let offset = 0;
-			const encryptedParts = [];
-			for (const subsample of sencSample.subsamples) {
-				offset += subsample.bytesOfClearData;
-				if (subsample.bytesOfEncryptedData > 0) {
-					const encryptedData$1 = segment.subarray(mdatOffset + position + offset, mdatOffset + position + offset + subsample.bytesOfEncryptedData);
-					encryptedParts.push(encryptedData$1);
-				}
-				offset += subsample.bytesOfEncryptedData;
-			}
-			const encryptedData = concatUint8Array(encryptedParts);
-			const subsampleParams = {
-				iv: sencSample.iv,
-				data: encryptedData,
-				timestamp: time
-			};
-			const decryptedData = await transformSample(subsampleParams);
-			if (decryptedData) {
-				offset = 0;
-				let decryptedOffset = 0;
-				const decryptedSampleParts = [];
-				for (const subsample of sencSample.subsamples) {
-					if (subsample.bytesOfClearData > 0) {
-						const clearData = segment.subarray(mdatOffset + position + offset, mdatOffset + position + offset + subsample.bytesOfClearData);
-						decryptedSampleParts.push(clearData);
-						offset += subsample.bytesOfClearData;
-					}
-					if (subsample.bytesOfEncryptedData > 0) {
-						const decryptedPart = decryptedData.subarray(decryptedOffset, decryptedOffset + subsample.bytesOfEncryptedData);
-						decryptedSampleParts.push(decryptedPart);
-						decryptedOffset += subsample.bytesOfEncryptedData;
-						offset += subsample.bytesOfEncryptedData;
-					}
-				}
-				const decryptedSample = concatUint8Array(decryptedSampleParts);
-				copyUint8Array(decryptedSample, segment, mdatOffset + position);
-			}
-		}
-		position += expectedSize;
-		time += trunSample.duration || tfhdInfo.defaultSampleDuration || 0;
-	}
-	new Mp4Parser().box("moof", Mp4Parser.children).box("traf", Mp4Parser.children).box("senc", (box) => {
-		const newName = "skip";
-		const offset = box.start + 4;
-		writeUint8Array(segment, newName, offset);
-	}).parse(segment, true, true);
-	return segment;
-};
-
-//#endregion
-//#region lib/stream.ts
-const findInit = (buffer) => {
-	let moovEnd = null;
-	new Mp4Parser().box("moov", (box) => {
-		moovEnd = box.start + box.size;
-	}).parse(buffer, true, true);
-	const init = moovEnd ? buffer.subarray(0, moovEnd) : null;
-	return {
-		moovEnd,
-		init
-	};
-};
-const findSegment = (buffer) => {
-	let moofStart = null;
-	let mdatEnd = null;
-	new Mp4Parser().box("moof", (box) => {
-		if (moofStart === null) moofStart = box.start;
-	}).box("mdat", (box) => {
-		if (mdatEnd === null) mdatEnd = box.start + box.size;
-	}).parse(buffer, true, true);
-	return {
-		segment: moofStart !== null && mdatEnd !== null ? buffer.subarray(moofStart, mdatEnd) : null,
-		moofStart,
-		mdatEnd
-	};
-};
-var Mp4SegmentTransformer = class {
-	buffer = new Uint8Array();
-	isProcessingInit = true;
-	scheme = null;
-	processedBytes = 0;
-	constructor(options) {
-		this.options = options;
-	}
-	async transform(chunk, controller) {
-		try {
-			this.buffer = concatUint8Array([this.buffer, chunk]);
-			let shouldContinue = true;
-			while (shouldContinue) {
-				if (this.isProcessingInit) {
-					const { init, moovEnd } = findInit(this.buffer);
-					if (!moovEnd || this.buffer.length < moovEnd) break;
-					if (init && isInitData(init)) {
-						this.scheme = parseInit(init).schemeType;
-						const processedInit = await processInit(init);
-						controller.enqueue(processedInit);
-						this.updateProgress(processedInit.byteLength);
-						this.buffer = this.buffer.subarray(moovEnd);
-						this.isProcessingInit = false;
-						continue;
-					}
-				}
-				const { moofStart, mdatEnd, segment } = findSegment(this.buffer);
-				if (moofStart === null || mdatEnd === null || !segment || this.buffer.length < mdatEnd) break;
-				const onSubsampleData = (params) => {
-					params.encryptionScheme = this.scheme;
-					return this.options.transformSample(params);
-				};
-				const processedSegment = await processEncryptedSegment(segment, onSubsampleData);
-				controller.enqueue(processedSegment);
-				this.updateProgress(processedSegment.byteLength);
-				this.buffer = this.buffer.subarray(mdatEnd);
-				shouldContinue = this.buffer.length >= 8;
-			}
-		} catch (error) {
-			controller.error(error);
-		}
-	}
-	async flush(controller) {
-		if (this.buffer.length > 0) {
-			controller.enqueue(this.buffer);
-			this.updateProgress(this.buffer.byteLength);
-		}
-	}
-	updateProgress(bytes) {
-		this.processedBytes += bytes;
-		if (this.options.onProgress) this.options.onProgress(this.processedBytes);
-	}
-};
-const processStream = async (readable, writable, { transformSample, onProgress, preventClose }) => {
-	const transformer = new Mp4SegmentTransformer({
-		transformSample,
-		onProgress
-	});
-	const transform = new TransformStream({
-		transform: (chunk, controller) => transformer.transform(chunk, controller),
-		flush: (controller) => transformer.flush(controller)
-	});
-	await readable.pipeThrough(transform).pipeTo(writable, { preventClose });
-};
-
-//#endregion
-//#region lib/decrypt-stream.ts
-function getSencForMoofNumber(mp4, num) {
-	const tenc = mp4.getBox("tenc");
-	tenc.default_isProtected;
-	tenc.default_KID;
-	const perSampleIvSize = tenc.default_Per_Sample_IV_Size;
-	const moof = mp4.moofs[num];
-	const mdat = mp4.mdats[num];
-	const traf = moof.trafs[0];
-	const trun = traf.truns[0];
-	const senc = traf.senc;
-	const reader = new DataViewReader(senc.data);
-	const sampleCount = reader.readUint32();
-	senc.samples = [];
-	for (let i = 0; i < sampleCount; i++) {
-		trun.sample_size[i];
-		trun.sample_duration[i];
-		const sample = {};
-		const iv = new Uint8Array(16);
-		iv.set(reader.readBytes(perSampleIvSize));
-		sample.InitializationVector = iv;
-		if (senc.flags & 2) {
-			sample.subsamples = [];
-			const subsampleCount = reader.readUint16();
-			for (let j = 0; j < subsampleCount; j++) {
-				let subsample = {};
-				subsample.BytesOfClearData = reader.readUint16();
-				subsample.BytesOfProtectedData = reader.readUint32();
-				sample.subsamples.push(subsample);
-			}
-		}
-		senc.samples.push(sample);
-	}
-	return {
-		moof,
-		mdat,
-		traf,
-		trun,
-		senc
-	};
-}
-var DecryptTransformer = class {
-	input;
-	inputReady;
-	output;
-	buffer = new Uint8Array();
-	bytesRead = 0;
-	processedBytes = 0;
-	samplesProcessingQueue = [];
-	constructor(options = {}) {
-		this.options = options;
-		this.input = (0, mp4box.createFile)(true);
-		this.output = (0, mp4box.createFile)(false);
-		this.inputReady = new Promise((resolve) => {
-			this.input.onReady = resolve;
-		});
-		this.inputReady.then((info) => {
-			const track = info.tracks[0];
-			const totalSamples = track.nb_samples;
-			this.input.setExtractionOptions(track.id, void 0, { nbSamples: totalSamples });
-			const init = this.processInit();
-			this.buffer = concatUint8Array([this.buffer, init]);
-			this.input.onSamples = (_id, _user, samples) => {
-				this.samplesProcessingQueue.push(this.processSamples(samples));
-			};
-			this.input.start();
-		});
-	}
-	processInit() {
-		const initStream = new mp4box.DataStream();
-		const ftyp = this.output.ftyp;
-		const moov = this.output.moov;
-		const stsd = moov.traks[0].mdia.minf.stbl.stsd;
-		const encSampleEntry = stsd.entries?.find((box) => !box.box_name);
-		const frma = encSampleEntry.sinf.frma;
-		const decSampleEntry = new mp4box.BoxParser.sampleEntry[frma.data_format]();
-		for (const key of Object.keys(encSampleEntry)) decSampleEntry.set(key, encSampleEntry[key]);
-		decSampleEntry.boxes = decSampleEntry.boxes?.filter((box) => box.box_name !== "ProtectionSchemeInfoBox");
-		stsd.addEntry(decSampleEntry);
-		stsd.entries = stsd.entries?.filter((box) => !!box.box_name);
-		moov.psshs = [];
-		moov.boxes = this.output.moov.boxes?.filter((box) => box.box_name !== "ProtectionSystemSpecificHeaderBox");
-		ftyp.write(initStream);
-		moov.write(initStream);
-		return new Uint8Array(initStream.buffer);
-	}
-	async processSamples(samples) {
-		const trackId = samples[0].track_id;
-		let moof = this.input.moofs[samples[0].moof_number - 1];
-		let traf = moof.trafs[0];
-		traf.truns[0];
-		for (const sample of samples) {
-			const { senc } = getSencForMoofNumber(this.input, sample.moof_number - 1);
-			const sencSample = senc.samples[sample.number_in_traf];
-			const encryptedParts = [];
-			let sampleOffset = 0;
-			for (const subsample of sencSample.subsamples) {
-				encryptedParts.push(sample.data.subarray(sampleOffset + subsample.BytesOfClearData, sampleOffset + subsample.BytesOfClearData + subsample.BytesOfProtectedData));
-				sampleOffset += subsample.BytesOfClearData + subsample.BytesOfProtectedData;
-			}
-			const encryptedData = concatUint8Array(encryptedParts);
-			const decrypted = await this.options.transformSample?.({
-				data: encryptedData,
-				iv: sencSample.InitializationVector,
-				timestamp: sample.cts,
-				encryptionScheme: "cenc"
-			});
-			const decryptedParts = [];
-			let sample_idx = 0;
-			let pt_idx = 0;
-			for (const subsample of sencSample.subsamples) {
-				decryptedParts.push(sample.data.subarray(sample_idx, sample_idx + subsample.BytesOfClearData));
-				sample_idx += subsample.BytesOfClearData + subsample.BytesOfProtectedData;
-				decryptedParts.push(decrypted.subarray(pt_idx, pt_idx + subsample.BytesOfProtectedData));
-				pt_idx += subsample.BytesOfProtectedData;
-			}
-			const decryptedSample = concatUint8Array(decryptedParts);
-			sample.data = decryptedSample;
-			sample.size = decryptedSample.byteLength;
-		}
-		traf.boxes = traf.boxes?.filter((box) => box.box_name !== "PiffSampleEncryptionBox" && box.box_name !== "SampleEncryptionBox" && box.box_name !== "SampleAuxiliaryInformationOffsetsBox" && box.box_name !== "SampleAuxiliaryInformationSizesBox");
-		const stream$1 = new mp4box.DataStream();
-		moof.write(stream$1);
-		moof.trafs[0].truns[0].data_offset = moof.size + 8;
-		stream$1.adjustUint32(moof.trafs[0].truns[0].data_offset_position, moof.trafs[0].truns[0].data_offset);
-		const mdat = new mp4box.BoxParser.box.mdat();
-		const samplesData = concatUint8Array(samples.map((s) => s.data));
-		const samplesMp4Buffer = mp4box.MP4BoxBuffer.fromArrayBuffer(samplesData.buffer, 0);
-		mdat.stream = new mp4box.MultiBufferStream(samplesMp4Buffer);
-		mdat.write(stream$1);
-		const segment = new Uint8Array(stream$1.buffer);
-		const nextSampleNum = Math.max(...samples.map((s) => s.moof_number)) + 1;
-		this.input.releaseUsedSamples(trackId, nextSampleNum);
-		return segment;
-	}
-	async transform(chunk, controller) {
-		try {
-			const boxBuffer = mp4box.MP4BoxBuffer.fromArrayBuffer(chunk.buffer, this.bytesRead);
-			this.input.appendBuffer(boxBuffer);
-			this.output.appendBuffer(boxBuffer);
-			this.bytesRead += chunk.length;
-			if (this.samplesProcessingQueue.length > 0) {
-				const segments = await Promise.all(this.samplesProcessingQueue);
-				this.samplesProcessingQueue = [];
-				const processed = concatUint8Array(segments);
-				this.buffer = concatUint8Array([this.buffer, processed]);
-			}
-			if (this.buffer.length > 0) {
-				controller.enqueue(this.buffer);
-				this.updateProgress(this.buffer.byteLength);
-				this.buffer = new Uint8Array();
-			}
-		} catch (error) {
-			controller.error(error);
-		}
-	}
-	async flush(controller) {
-		if (this.buffer.length > 0) {
-			controller.enqueue(this.buffer);
-			this.updateProgress(this.buffer.byteLength);
-		}
-	}
-	updateProgress(bytes) {
-		this.processedBytes += bytes;
-		if (this.options.onProgress) this.options.onProgress(this.processedBytes);
-	}
-};
-var DecryptStream = class extends TransformStream {
-	constructor(options = {}) {
-		const transformer = new DecryptTransformer(options);
-		super({
-			transform: (chunk, controller) => transformer.transform(chunk, controller),
-			flush: (controller) => transformer.flush(controller)
-		});
-	}
-};
-
-//#endregion
-//#region lib/node/exports.ts
-var exports_exports = /* @__PURE__ */ __export({
-	fs: () => node_fs,
-	stream: () => node_stream.default
-});
-
-//#endregion
-//#region lib/api.ts
-const node = typeof exports_exports !== "undefined" ? exports_exports : void 0;
-var FilePathSource = class {
-	readable;
-	constructor(filePath) {
-		this.filePath = filePath;
-		const readStream = node.fs.createReadStream(filePath);
-		this.readable = node.stream.Readable.toWeb(readStream);
-	}
-};
-var FilePathTarget = class {
-	writable;
-	constructor(filePath) {
-		this.filePath = filePath;
-		const writeStream = node.fs.createWriteStream(filePath);
-		this.writable = node.stream.Writable.toWeb(writeStream);
-	}
-};
-var StreamSource = class {
-	constructor(readable) {
-		this.readable = readable;
-	}
-};
-var StreamTarget = class {
-	constructor(writable) {
-		this.writable = writable;
-	}
-};
-var BufferSource = class {
-	readable;
-	constructor(buffer) {
-		this.buffer = buffer;
-		this.readable = new ReadableStream({ start(controller) {
-			controller.enqueue(buffer);
-			controller.close();
-		} });
-	}
-};
-var BufferTarget = class {
-	writable;
-	buffer = null;
-	constructor() {
-		const chunks = [];
-		this.writable = new WritableStream({
-			start: () => {},
-			write: (chunk) => {
-				chunks.push(chunk);
-			},
-			abort: (reason) => {
-				console.error("WritableStream aborted:", reason);
-			},
-			close: () => {
-				this.buffer = concatUint8Array(chunks);
-			}
-		});
-	}
-};
-var Input = class {
-	source;
-	constructor(options) {
-		this.source = options.source;
-	}
-};
-var Output = class {
-	target;
-	constructor(options) {
-		this.target = options.target;
-	}
-};
-var Decryption = class Decryption {
-	decrypt;
-	input;
-	output;
-	static async init(options) {
-		const decryption = new Decryption(options);
-		await decryption.#init();
-		return decryption;
-	}
-	constructor(options) {
-		this.input = options.input;
-		this.output = options.output;
-		const key = new Uint8Array(parseHex(options.keys[0].key));
-		const decryptFn = async (params) => decryptWithKey(key, params);
-		this.decrypt = new DecryptStream({
-			transformSample: decryptFn,
-			onProgress: options.onProgress
-		});
-	}
-	async #init() {}
-	async execute() {
-		const readable = this.input.source.readable;
-		const writable = this.output.target.writable;
-		const decrypt$1 = this.decrypt;
-		await readable.pipeThrough(decrypt$1).pipeTo(writable);
-	}
-};
-
-//#endregion
-//#region shifro.ts
-const decryptWithKey = async (key, params) => {
-	const scheme = params.encryptionScheme;
-	const iv = params.iv;
-	const data = params.data;
-	if (scheme === "cbcs") return decrypt({
-		key,
-		iv,
-		data,
-		algorithm: "AES-CBC"
-	});
-	else return decrypt({
-		key,
-		iv,
-		data,
-		algorithm: "AES-CTR"
-	});
-};
-const decryptSegment = async (segment, params) => {
-	const hasKey = "key" in params;
-	const key = new Uint8Array(parseHex(hasKey ? params.key : ""));
-	const decryptFn = async (subsampleParams) => decryptWithKey(key, {
-		encryptionScheme: "encryptionScheme" in params ? params.encryptionScheme : void 0,
-		...subsampleParams
-	});
-	const transformSample = hasKey ? decryptFn : params.transformSample;
-	return processEncryptedSegment(segment, transformSample);
-};
-const decryptStream = async (readable, writable, { preventClose, onProgress,...params }) => {
-	const hasKey = "key" in params;
-	const key = new Uint8Array(parseHex(hasKey ? params.key : ""));
-	const decryptFn = async (params$1) => decryptWithKey(key, params$1);
-	const transformSample = hasKey ? decryptFn : params.transformSample;
-	await processStream(readable, writable, {
-		preventClose,
-		onProgress,
-		transformSample
-	});
-};
-
-//#endregion
-exports.BufferSource = BufferSource;
-exports.BufferTarget = BufferTarget;
-exports.Decryption = Decryption;
-exports.FilePathSource = FilePathSource;
-exports.FilePathTarget = FilePathTarget;
-exports.Input = Input;
-exports.Output = Output;
-exports.StreamSource = StreamSource;
-exports.StreamTarget = StreamTarget;
-exports.decryptSegment = decryptSegment;
-exports.decryptStream = decryptStream;
-exports.decryptWithKey = decryptWithKey;