shifro 0.2.0 → 1.1.0

package/README.md

@@ -1,155 +1,99 @@
 # shifro
 
-A lightweight library for decrypting MP4 files, directly in the browser
+A lightweight library for decrypting MP4 files, directly in the browser or via CLI on your machine.
 
-## Features
+This tool is a small wrapper around the [Mediabunny](https://github.com/Vanilagy/mediabunny) library with slight API changes and command-line support.
 
-- **Decryption** of MP4 files with MPEG Common Encryption (CENC)
-- **Small** size (under 15kB without types, minified)
-- **Command-line** interface
-- **Segment-by-segment processing** with JavaScript library
-- **Custom handler** for samples processing
-
-## Prerequisites
-
-- [Node.js](https://nodejs.org/en)
-
-## Installation
-
-Install library as dependency for your project:
+## Usage
 
-```bash
-npm install shifro
-```
+### CLI
 
-Install globally to use as command-line tool:
+Run `npm install -g shifro` to install the command-line tool globally ([Node.js](https://nodejs.org/en/download) required).
 
 ```bash
-npm install -g shifro
+shifro --key eb676abbcb345e96bbcf616630f1a3da:100b6c20940f779a4589152b57d2dacb ./input.mp4 ./output.mp4
 ```
 
-## Usage
+This can be used as an alternative to the [mp4decrypt](https://www.bento4.com/documentation/mp4decrypt/) or [shaka-packager](https://shaka-project.github.io/shaka-packager/html/documentation.html#raw-key-encryption-options).
 
 ### Library
 
-#### Decrypting file using browser's Web Streams API
-
-```js
-import { Input, StreamSource, Output, StreamTarget, Decryption } from 'shifro';
+Run `npm install shifro` to install the library as dependency for your project.
 
-const selectFile = async () =>
-  new Promise<File>((resolve) => {
-    const input = document.querySelector<HTMLInputElement>('#input')!;
-    input.addEventListener('change', () => resolve(input.files![0]));
-  });
-
-async function main() {
-  const inputFile = await selectFile();
-  const inputStream = inputFile.stream();
+#### Decrypting file using Node.js streams
 
-  const outputFileHandle = window.showSaveFilePicker({ suggestedName: 'output.mp4', startIn: 'downloads' });
-  const outputStream = await outputFileHandle.createWritable();
+```ts
+import { Decryption, FilePathSource, FilePathTarget, Input, Output } from 'shifro';
+import type { Key, KeyId } from 'shifro';
 
-  const input = new Input({ source: new StreamSource(inputStream) });
-  const output = new Output({ target: new StreamTarget(outputStream) });
+async function decrypt() {
   const decryption = await Decryption.init({
-    input,
-    output,
-    keys: [
-      {
-        kid: 'eb676abbcb345e96bbcf616630f1a3da',
-        key: '100b6c20940f779a4589152b57d2dacb',
+    input: new Input({
+      source: new FilePathSource('./input.mp4'),
+      keys: new Map<KeyId, Key>([
+        ['4d97930a3d7b55fa81d0028653f5e499', '429ec76475e7a952d224d8ef867f12b6'],
+        ['d21373c0b8ab5ba9954742bcdfb5f48b', '150a6c7d7dee6a91b74dccfce5b31928'],
+      ]),
+      // Optinally, you can use this callback to handle encryption information (like key ID and PSSH boxes)
+      handleEncryptionInfo: ({ keyId, psshBoxes }) => {
+        console.group(`Key ID: ${keyId}`);
+        for (const psshBox of psshBoxes) {
+          console.log(`PSSH box: ${psshBox.systemId} (${psshBox.data.length} bytes)`);
+        }
+        console.groupEnd();
       },
-    ],
-    onProgress: (progress) => console.log(`Decrypting... ${progress}`),
+    }),
+    output: new Output({ target: new FilePathTarget('./output.mp4') }),
   });
-  await decryption.execute();
-}
-```
 
-#### Decrypting file using Node.js streams
+  decryption.onProgress = (progress) =>
+    process.stdout.write(`\rDecrypting... [${Math.round(progress * 100)}%]`);
 
-```js
-import { Input, FilePathSource, Output, FilePathTarget, Decryption } from 'shifro';
-
-async function main() {
-  const input = new Input({ source: new FilePathSource('./input.mp4') });
-  const output = new Output({ target: new FilePathTarget('./output.mp4') });
-  const decryption = await Decryption.init({
-    input,
-    output,
-    keys: [
-      {
-        kid: 'eb676abbcb345e96bbcf616630f1a3da',
-        key: '100b6c20940f779a4589152b57d2dacb',
-      },
-    ],
-    onProgress: (progress) => process.stdout.write(`\rDecrypting... [${progress}]`),
-  });
   await decryption.execute();
 }
 ```
 
-#### Segment-by-segment decryption
-
-```js
-import { decryptSegment } from 'shifro';
+#### Decrypting file using browser's Web Streams API
 
-const key = 'eb676abbcb345e96bbcf616630f1a3da';
-const keyId = '100b6c20940f779a4589152b57d2dacb';
-const encryptionScheme = 'cenc';
+```ts
+import { Decryption, Input, Output, ReadableStreamSource, StreamTarget } from 'shifro';
+import type { Key, KeyId } from 'shifro';
 
-const encryptedSegments = [
-  // List of binary MP4 segments (Uint8Array)
-  // ...
-];
-const decryptedSegments = [];
+async function decryptFromBrowser() {
+  const handleFileSelect = async () => {
+    return new Promise<File>((resolve) => {
+      const input = document.querySelector<HTMLInputElement>('#input')!;
+      input.addEventListener('change', () => resolve(input.files![0]));
+    });
+  };
 
-for (const segment of encryptedSegments) {
-  const decrypted = await decryptSegment(segment, { key, keyId, encryptionScheme });
-  decryptedSegments.push(decrypted);
-}
+  const inputFile = await handleFileSelect();
+  const inputReadableStream = inputFile.stream();
 
-// Do something with results...
-```
+  const outputFileHandle = window.showSaveFilePicker({
+    suggestedName: 'output.mp4',
+    startIn: 'downloads',
+  });
+  const outputWritableStream = await outputFileHandle.createWritable();
 
-#### Transform sample data in your own way instead of built-in decryption
-
-```js
-import { createDecipheriv } from 'node:crypto';
-import { decryptSegment } from 'shifro';
-
-const key = 'eb676abbcb345e96bbcf616630f1a3da';
-const keyId = '100b6c20940f779a4589152b57d2dacb';
-const encryptionScheme = 'cenc';
-
-const encryptedSegments = [
-  // List of binary MP4 segments (Uint8Array)
-  // ...
-];
-const decryptedSegments = [];
-
-for (const segment of encryptedSegments) {
-  const decrypted = await decryptSegment(segment, {
-    keyId,
-    transformSample: (params) => {
-      // Implement custom handler for subsample processing
-      // ...
-      const sampleData = params.data;
-      const iv = params.iv;
-      const decipher = createDecipheriv('aes-128-ctr', key, iv);
-      const decrypted = Buffer.concat([decipher.update(sampleData), decipher.final()]);
-      return decrypted;
-    },
+  const decryption = await Decryption.init({
+    input: new Input({
+      source: new ReadableStreamSource(inputReadableStream),
+      keys: new Map<KeyId, Key>([
+        ['4d97930a3d7b55fa81d0028653f5e499', '429ec76475e7a952d224d8ef867f12b6'],
+        ['d21373c0b8ab5ba9954742bcdfb5f48b', '150a6c7d7dee6a91b74dccfce5b31928'],
+      ]),
+    }),
+    output: new Output({ target: new StreamTarget(outputWritableStream) }),
   });
-  decryptedSegments.push(decrypted);
-}
 
-// Do something with results...
+  decryption.onProgress = (progress) =>
+    console.log(`Decrypting... [${Math.round(progress * 100)}%]`);
+
+  await decryption.execute();
+}
 ```
 
-### CLI
+## Credits
 
-```bash
-shifro --key eb676abbcb345e96bbcf616630f1a3da:100b6c20940f779a4589152b57d2dacb ./input.mp4 ./output.mp4
-```
+- [mediabunny](https://github.com/Vanilagy/mediabunny)

package/dist/cli.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { ALL_FORMATS, Conversion, FilePathSource, FilePathTarget, Input, Mp4OutputFormat, Output } from "mediabunny";
+//#region package.json
+var name = "shifro";
+var version = "1.1.0";
+var author = "Vitaly Gashkov <vitalygashkov@vk.com>";
+//#endregion
+//#region src/index.ts
+var Input$1 = class extends Input {
+	constructor({ keys, handleEncryptionInfo, ...options }) {
+		super({
+			...options,
+			formats: ALL_FORMATS,
+			formatOptions: { isobmff: { resolveKeyId: ({ keyId, psshBoxes }) => {
+				handleEncryptionInfo?.({
+					keyId,
+					psshBoxes
+				});
+				const key = keys.get(keyId);
+				if (!key) throw new Error("Unknown key ID.");
+				return key;
+			} } }
+		});
+	}
+};
+var Output$1 = class extends Output {
+	constructor({ ...options }) {
+		super({
+			...options,
+			format: options.format ?? new Mp4OutputFormat()
+		});
+	}
+};
+//#endregion
+//#region src/cli.ts
+const args = parseArgs({
+	allowPositionals: true,
+	strict: false,
+	options: {
+		key: {
+			short: "k",
+			type: "string",
+			multiple: true
+		},
+		help: {
+			short: "h",
+			type: "boolean"
+		}
+	}
+});
+const keyStrings = Array.isArray(args.values.key) ? args.values.key : [];
+const [inputPath, outputPath] = args.positionals;
+const decryptFile = async () => {
+	console.time("\nDone!");
+	const decryption = await Conversion.init({
+		input: new Input$1({
+			source: new FilePathSource(inputPath),
+			keys: new Map(keyStrings.map((keyString) => keyString.split(":")))
+		}),
+		output: new Output$1({ target: new FilePathTarget(outputPath) })
+	});
+	decryption.onProgress = (progress) => process.stdout.write(`\rDecrypting... [${Math.round(progress * 100)}%]`);
+	await decryption.execute();
+	console.timeEnd("\nDone!");
+};
+const showHelp = () => {
+	console.log(`
+${name} version ${version}
+(c) 2024-2026 ${author}
+
+Usage: ${name} [options] <input> <output>
+
+Options:
+  --key <id>:<k>
+    <id> is either a track ID in decimal or a 128-bit KID in hex,
+    <k> is a 128-bit key in hex
+    (several --key options can be used, one for each track or KID)
+      `.trim());
+};
+(async () => {
+	if (inputPath && outputPath && keyStrings.length > 0) await decryptFile();
+	else showHelp();
+})();
+//#endregion
+export {};

package/dist/index.cjs

@@ -0,0 +1,42 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let mediabunny = require("mediabunny");
+//#region src/index.ts
+var Input = class extends mediabunny.Input {
+	constructor({ keys, handleEncryptionInfo, ...options }) {
+		super({
+			...options,
+			formats: mediabunny.ALL_FORMATS,
+			formatOptions: { isobmff: { resolveKeyId: ({ keyId, psshBoxes }) => {
+				handleEncryptionInfo?.({
+					keyId,
+					psshBoxes
+				});
+				const key = keys.get(keyId);
+				if (!key) throw new Error("Unknown key ID.");
+				return key;
+			} } }
+		});
+	}
+};
+var Output = class extends mediabunny.Output {
+	constructor({ ...options }) {
+		super({
+			...options,
+			format: options.format ?? new mediabunny.Mp4OutputFormat()
+		});
+	}
+};
+//#endregion
+exports.Decryption = mediabunny.Conversion;
+exports.FilePathSource = mediabunny.FilePathSource;
+exports.FilePathTarget = mediabunny.FilePathTarget;
+exports.Input = Input;
+exports.MkvOutputFormat = mediabunny.MkvOutputFormat;
+exports.MovOutputFormat = mediabunny.MovOutputFormat;
+exports.Mp3OutputFormat = mediabunny.Mp3OutputFormat;
+exports.Mp4OutputFormat = mediabunny.Mp4OutputFormat;
+exports.Output = Output;
+exports.ReadableStreamSource = mediabunny.ReadableStreamSource;
+exports.StreamSource = mediabunny.StreamSource;
+exports.StreamTarget = mediabunny.StreamTarget;
+exports.UrlSource = mediabunny.UrlSource;

package/dist/index.d.cts

@@ -0,0 +1,28 @@
+import { Conversion, FilePathSource, FilePathTarget, Input as Input$1, InputOptions, MkvOutputFormat, MovOutputFormat, Mp3OutputFormat, Mp4OutputFormat, Output as Output$1, OutputFormat, OutputOptions, PsshBox, ReadableStreamSource, StreamSource, StreamSourceOptions, StreamTarget, StreamTargetOptions, UrlSource } from "mediabunny";
+
+//#region src/index.d.ts
+type KeyId = string;
+type Key = string;
+type KeyMap = Map<KeyId, Key>;
+declare class Input extends Input$1 {
+  constructor({
+    keys,
+    handleEncryptionInfo,
+    ...options
+  }: Omit<InputOptions, 'formats' | 'formatOptions'> & {
+    keys: KeyMap;
+    handleEncryptionInfo?: (options: {
+      keyId: string;
+      psshBoxes: PsshBox[];
+    }) => void;
+  });
+}
+declare class Output extends Output$1 {
+  constructor({
+    ...options
+  }: Omit<OutputOptions, 'format'> & {
+    format?: OutputFormat;
+  });
+}
+//#endregion
+export { Conversion as Decryption, FilePathSource, FilePathTarget, Input, type InputOptions, type Key, type KeyId, type KeyMap, MkvOutputFormat, MovOutputFormat, Mp3OutputFormat, Mp4OutputFormat, Output, type OutputFormat, type OutputOptions, ReadableStreamSource, StreamSource, type StreamSourceOptions, StreamTarget, type StreamTargetOptions, UrlSource };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { Conversion, FilePathSource, FilePathTarget, Input as Input$1, InputOptions, MkvOutputFormat, MovOutputFormat, Mp3OutputFormat, Mp4OutputFormat, Output as Output$1, OutputFormat, OutputOptions, PsshBox, ReadableStreamSource, StreamSource, StreamSourceOptions, StreamTarget, StreamTargetOptions, UrlSource } from "mediabunny";
+
+//#region src/index.d.ts
+type KeyId = string;
+type Key = string;
+type KeyMap = Map<KeyId, Key>;
+declare class Input extends Input$1 {
+  constructor({
+    keys,
+    handleEncryptionInfo,
+    ...options
+  }: Omit<InputOptions, 'formats' | 'formatOptions'> & {
+    keys: KeyMap;
+    handleEncryptionInfo?: (options: {
+      keyId: string;
+      psshBoxes: PsshBox[];
+    }) => void;
+  });
+}
+declare class Output extends Output$1 {
+  constructor({
+    ...options
+  }: Omit<OutputOptions, 'format'> & {
+    format?: OutputFormat;
+  });
+}
+//#endregion
+export { Conversion as Decryption, FilePathSource, FilePathTarget, Input, type InputOptions, type Key, type KeyId, type KeyMap, MkvOutputFormat, MovOutputFormat, Mp3OutputFormat, Mp4OutputFormat, Output, type OutputFormat, type OutputOptions, ReadableStreamSource, StreamSource, type StreamSourceOptions, StreamTarget, type StreamTargetOptions, UrlSource };

package/dist/index.js

@@ -0,0 +1,29 @@
+import { ALL_FORMATS, Conversion, FilePathSource, FilePathTarget, Input as Input$1, MkvOutputFormat, MovOutputFormat, Mp3OutputFormat, Mp4OutputFormat, Output as Output$1, ReadableStreamSource, StreamSource, StreamTarget, UrlSource } from "mediabunny";
+//#region src/index.ts
+var Input = class extends Input$1 {
+	constructor({ keys, handleEncryptionInfo, ...options }) {
+		super({
+			...options,
+			formats: ALL_FORMATS,
+			formatOptions: { isobmff: { resolveKeyId: ({ keyId, psshBoxes }) => {
+				handleEncryptionInfo?.({
+					keyId,
+					psshBoxes
+				});
+				const key = keys.get(keyId);
+				if (!key) throw new Error("Unknown key ID.");
+				return key;
+			} } }
+		});
+	}
+};
+var Output = class extends Output$1 {
+	constructor({ ...options }) {
+		super({
+			...options,
+			format: options.format ?? new Mp4OutputFormat()
+		});
+	}
+};
+//#endregion
+export { Conversion as Decryption, FilePathSource, FilePathTarget, Input, MkvOutputFormat, MovOutputFormat, Mp3OutputFormat, Mp4OutputFormat, Output, ReadableStreamSource, StreamSource, StreamTarget, UrlSource };

package/package.json

@@ -1,41 +1,31 @@
 {
   "name": "shifro",
-  "version": "0.2.0",
+  "version": "1.1.0",
   "description": "A lightweight library for decrypting MP4 files, directly in the browser",
   "files": [
     "dist"
   ],
-  "scripts": {
-    "start": "node ./dist/cli.cjs",
-    "web": "vite",
-    "build": "npm run build:lib && npm run build:cli",
-    "build:cli": "tsdown ./lib/node/cli.ts --format cjs --dts --minify --no-clean",
-    "build:lib": "tsdown shifro.ts --format cjs --format esm --dts --platform neutral",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest",
-    "prepublishOnly": "npm run build"
-  },
   "bin": {
-    "shifro": "./dist/cli.cjs"
+    "shifro": "./dist/cli.mjs"
   },
   "type": "module",
-  "main": "./dist/shifro.js",
-  "types": "./dist/shifro.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "require": {
-        "types": "./dist/shifro.d.cts",
-        "default": "./dist/shifro.cjs"
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       },
       "import": {
-        "types": "./dist/shifro.d.ts",
-        "default": "./dist/shifro.js"
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
       }
     }
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/streamyx-labs/shifro.git"
+    "url": "git+https://github.com/azot-labs/shifro.git"
   },
   "keywords": [
     "mp4",
@@ -54,11 +44,11 @@
     "shaka-packager"
   ],
   "bugs": {
-    "url": "https://github.com/streamyx-labs/shifro/issues",
+    "url": "https://github.com/azot-labs/shifro/issues",
     "email": "vitalygashkov@vk.com"
   },
   "author": "Vitaly Gashkov <vitalygashkov@vk.com>",
-  "license": "AGPL-3.0",
+  "license": "MIT",
   "readmeFilename": "README.md",
   "funding": [
     {
@@ -67,15 +57,34 @@
     }
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
+  },
+  "dependencies": {
+    "mediabunny": "^1.42.0-beta.7"
   },
   "devDependencies": {
     "@types/node": "^24.5.2",
-    "tsdown": "^0.15.5",
-    "typescript": "^5.9.2",
-    "vitest": "^3.2.4"
+    "oxfmt": "^0.46.0",
+    "oxlint": "^1.61.0",
+    "tsdown": "^0.21.10",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.5"
   },
-  "dependencies": {
-    "mp4box": "^2.1.1"
+  "scripts": {
+    "start": "node ./dist/cli.mjs",
+    "web": "vite",
+    "build": "pnpm run bundle:lib && pnpm run bundle:cli",
+    "bundle:lib": "tsdown ./src/index.ts --format cjs --format esm --dts --platform neutral",
+    "bundle:cli": "tsdown ./src/cli.ts --format esm --no-clean",
+    "build:cli": "pnpm run build:cli:mac && pnpm run build:cli:linux && pnpm run build:cli:win",
+    "build:cli:mac": "bun build --compile --minify --bytecode --target=bun-darwin-arm64 ./src/cli.ts --outfile shifro-windows.exe",
+    "build:cli:linux": "bun build --compile --minify --bytecode --target=bun-linux-x64 ./src/cli.ts --outfile shifro-linux",
+    "build:cli:win": "bun build --compile --minify --bytecode --target=bun-windows-x64 ./src/cli.ts --outfile shifro-macos",
+    "fmt": "oxfmt .",
+    "fmt:check": "oxfmt --check .",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest"
   }
-}
+}

package/dist/cli.cjs

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=e=>{let n={};for(var r in e)t(n,r,{get:e[r],enumerable:!0});return n},s=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},c=(n,r,a)=>(a=n==null?{}:e(i(n)),s(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));let l=require(`node:util`);l=c(l);let u=require(`node:fs`);u=c(u);let d=require(`mp4box`);d=c(d);let f=require(`node:stream`);f=c(f);const p=async({key:e,iv:t,data:n,algorithm:r=`AES-CTR`})=>{let i=r.toUpperCase(),a=await crypto.subtle.importKey(`raw`,e,{name:i},!1,[`decrypt`]),o=await crypto.subtle.decrypt({name:i,counter:t,length:64},a,n);return new Uint8Array(o)},m=e=>{let t=e.buffer;return new DataView(t,e.byteOffset,e.byteLength)},ee=(e,t=0,n)=>new Uint8Array(e.buffer,e.byteOffset+t,n);var h=class extends Error{constructor(e,t,n,r){super(r),this.severity=e,this.category=t,this.code=n,this.name=`DataViewReaderError`}},g=class{dataView;littleEndian;position=0;constructor(e,t=`BE`){this.dataView=m(e),this.littleEndian=t===`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);let e=this.dataView.getUint8(this.position);return this.position+=1,e}readUint16(){this.checkBounds(2);let e=this.dataView.getUint16(this.position,this.littleEndian);return this.position+=2,e}readUint32(){this.checkBounds(4);let e=this.dataView.getUint32(this.position,this.littleEndian);return this.position+=4,e}readInt32(){this.checkBounds(4);let e=this.dataView.getInt32(this.position,this.littleEndian);return this.position+=4,e}readUint64(){let e,t;try{this.littleEndian?(e=this.dataView.getUint32(this.position,!0),t=this.dataView.getUint32(this.position+4,!0)):(t=this.dataView.getUint32(this.position,!1),e=this.dataView.getUint32(this.position+4,!1))}catch{throw this.outOfBounds()}if(t>2097151)throw new h(`CRITICAL`,`MEDIA`,`JS_INTEGER_OVERFLOW`,`64-bit integer overflow`);return this.position+=8,t*2**32+e}readBytes(e){this.checkBounds(e);let t=ee(this.dataView,this.position,e);return this.position+=e,t}skip(e){this.checkBounds(e),this.position+=e}rewind(e){if(this.position<e)throw this.outOfBounds();this.position-=e}seek(e){if(e<0||e>this.dataView.byteLength)throw this.outOfBounds();this.position=e}readTerminatedString(){let e=this.position;for(;this.hasMoreData()&&this.dataView.getUint8(this.position)!==0;)this.position++;if(!this.hasMoreData())throw this.outOfBounds();let t=new Uint8Array(this.dataView.buffer,e,this.position-e);return this.position++,new TextDecoder().decode(t)}checkBounds(e){if(this.position+e>this.dataView.byteLength)throw this.outOfBounds()}outOfBounds(){return new h(`CRITICAL`,`MEDIA`,`BUFFER_READ_OUT_OF_BOUNDS`,`Read operation out of bounds`)}};const _=(e,t)=>{if(e.length===0)return new Uint8Array;let n=t??e.reduce((e,t)=>e+t.length,0);n=Math.min(n,e.reduce((e,t)=>e+t.length,0));let r=new Uint8Array(n),i=0;for(let t of e){if(i>=n)break;let e=t.subarray(0,Math.min(t.length,n-i));r.set(e,i),i+=e.length}return r},v=e=>e.match(/.{1,2}/g)?.map(e=>parseInt(e,16))??[];function y(e,t){let n=e.getBox(`tenc`);n.default_isProtected,n.default_KID;let r=n.default_Per_Sample_IV_Size,i=e.moofs[t],a=e.mdats[t],o=i.trafs[0],s=o.truns[0],c=o.senc,l=new g(c.data),u=l.readUint32();c.samples=[];for(let e=0;e<u;e++){s.sample_size[e],s.sample_duration[e];let t={},n=new Uint8Array(16);if(n.set(l.readBytes(r)),t.InitializationVector=n,c.flags&2){t.subsamples=[];let e=l.readUint16();for(let n=0;n<e;n++){let e={};e.BytesOfClearData=l.readUint16(),e.BytesOfProtectedData=l.readUint32(),t.subsamples.push(e)}}c.samples.push(t)}return{moof:i,mdat:a,traf:o,trun:s,senc:c}}var te=class{input;inputReady;output;buffer=new Uint8Array;bytesRead=0;processedBytes=0;samplesProcessingQueue=[];constructor(e={}){this.options=e,this.input=(0,d.createFile)(!0),this.output=(0,d.createFile)(!1),this.inputReady=new Promise(e=>{this.input.onReady=e}),this.inputReady.then(e=>{let t=e.tracks[0],n=t.nb_samples;this.input.setExtractionOptions(t.id,void 0,{nbSamples:n});let r=this.processInit();this.buffer=_([this.buffer,r]),this.input.onSamples=(e,t,n)=>{this.samplesProcessingQueue.push(this.processSamples(n))},this.input.start()})}processInit(){let e=new d.DataStream,t=this.output.ftyp,n=this.output.moov,r=n.traks[0].mdia.minf.stbl.stsd,i=r.entries?.find(e=>!e.box_name),a=i.sinf.frma,o=new d.BoxParser.sampleEntry[a.data_format];for(let e of Object.keys(i))o.set(e,i[e]);return o.boxes=o.boxes?.filter(e=>e.box_name!==`ProtectionSchemeInfoBox`),r.addEntry(o),r.entries=r.entries?.filter(e=>!!e.box_name),n.psshs=[],n.boxes=this.output.moov.boxes?.filter(e=>e.box_name!==`ProtectionSystemSpecificHeaderBox`),t.write(e),n.write(e),new Uint8Array(e.buffer)}async processSamples(e){let t=e[0].track_id,n=this.input.moofs[e[0].moof_number-1],r=n.trafs[0];r.truns[0];for(let t of e){let{senc:e}=y(this.input,t.moof_number-1),n=e.samples[t.number_in_traf],r=[],i=0;for(let e of n.subsamples)r.push(t.data.subarray(i+e.BytesOfClearData,i+e.BytesOfClearData+e.BytesOfProtectedData)),i+=e.BytesOfClearData+e.BytesOfProtectedData;let a=_(r),o=await this.options.transformSample?.({data:a,iv:n.InitializationVector,timestamp:t.cts,encryptionScheme:`cenc`}),s=[],c=0,l=0;for(let e of n.subsamples)s.push(t.data.subarray(c,c+e.BytesOfClearData)),c+=e.BytesOfClearData+e.BytesOfProtectedData,s.push(o.subarray(l,l+e.BytesOfProtectedData)),l+=e.BytesOfProtectedData;let u=_(s);t.data=u,t.size=u.byteLength}r.boxes=r.boxes?.filter(e=>e.box_name!==`PiffSampleEncryptionBox`&&e.box_name!==`SampleEncryptionBox`&&e.box_name!==`SampleAuxiliaryInformationOffsetsBox`&&e.box_name!==`SampleAuxiliaryInformationSizesBox`);let i=new d.DataStream;n.write(i),n.trafs[0].truns[0].data_offset=n.size+8,i.adjustUint32(n.trafs[0].truns[0].data_offset_position,n.trafs[0].truns[0].data_offset);let a=new d.BoxParser.box.mdat,o=_(e.map(e=>e.data)),s=d.MP4BoxBuffer.fromArrayBuffer(o.buffer,0);a.stream=new d.MultiBufferStream(s),a.write(i);let c=new Uint8Array(i.buffer),l=Math.max(...e.map(e=>e.moof_number))+1;return this.input.releaseUsedSamples(t,l),c}async transform(e,t){try{let n=d.MP4BoxBuffer.fromArrayBuffer(e.buffer,this.bytesRead);if(this.input.appendBuffer(n),this.output.appendBuffer(n),this.bytesRead+=e.length,this.samplesProcessingQueue.length>0){let e=await Promise.all(this.samplesProcessingQueue);this.samplesProcessingQueue=[];let t=_(e);this.buffer=_([this.buffer,t])}this.buffer.length>0&&(t.enqueue(this.buffer),this.updateProgress(this.buffer.byteLength),this.buffer=new Uint8Array)}catch(e){t.error(e)}}async flush(e){this.buffer.length>0&&(e.enqueue(this.buffer),this.updateProgress(this.buffer.byteLength))}updateProgress(e){this.processedBytes+=e,this.options.onProgress&&this.options.onProgress(this.processedBytes)}},ne=class extends TransformStream{constructor(e={}){let t=new te(e);super({transform:(e,n)=>t.transform(e,n),flush:e=>t.flush(e)})}},b=o({fs:()=>u,stream:()=>f.default});const x=b===void 0?void 0:b;var S=class{readable;constructor(e){this.filePath=e;let t=x.fs.createReadStream(e);this.readable=x.stream.Readable.toWeb(t)}},C=class{writable;constructor(e){this.filePath=e;let t=x.fs.createWriteStream(e);this.writable=x.stream.Writable.toWeb(t)}},w=class{source;constructor(e){this.source=e.source}},T=class{target;constructor(e){this.target=e.target}},E=class e{decrypt;input;output;static async init(t){let n=new e(t);return await n.#init(),n}constructor(e){this.input=e.input,this.output=e.output;let t=new Uint8Array(v(e.keys[0].key));this.decrypt=new ne({transformSample:async e=>D(t,e),onProgress:e.onProgress})}async#init(){}async execute(){let e=this.input.source.readable,t=this.output.target.writable,n=this.decrypt;await e.pipeThrough(n).pipeTo(t)}};const D=async(e,t)=>{let n=t.encryptionScheme,r=t.iv,i=t.data;return p(n===`cbcs`?{key:e,iv:r,data:i,algorithm:`AES-CBC`}:{key:e,iv:r,data:i,algorithm:`AES-CTR`})},O=async(e,t,n)=>{console.time(`
-Done!`);let r=new w({source:new S(e)}),i=new T({target:new C(t)});await(await E.init({input:r,output:i,keys:[{kid:n.keyId,key:`key`in n?n.key:``}],onProgress:e=>process.stdout.write(`\rDecrypting... [${e}]`)})).execute(),console.timeEnd(`
-Done!`)};var k=`shifro`,A=`0.2.0`,j=`A lightweight library for decrypting MP4 files, directly in the browser`,M=[`dist`],N={start:`node ./dist/cli.cjs`,web:`vite`,build:`npm run build:lib && npm run build:cli`,"build:cli":`tsdown ./lib/node/cli.ts --format cjs --dts --minify --no-clean`,"build:lib":`tsdown shifro.ts --format cjs --format esm --dts --platform neutral`,typecheck:`tsc --noEmit`,test:`vitest`,prepublishOnly:`npm run build`},P={shifro:`./dist/cli.cjs`},F=`module`,I=`./dist/shifro.js`,re=`./dist/shifro.d.ts`,L={".":{require:{types:`./dist/shifro.d.cts`,default:`./dist/shifro.cjs`},import:{types:`./dist/shifro.d.ts`,default:`./dist/shifro.js`}}},R={type:`git`,url:`git+https://github.com/streamyx-labs/shifro.git`},z=[`mp4`,`mpeg`,`cenc`,`cbcs`,`decrypt`,`decryption`,`decrypter`,`decryptor`,`dash`,`drm`,`mp4decrypt`,`mp4box`,`shaka`,`shaka-packager`],B={url:`https://github.com/streamyx-labs/shifro/issues`,email:`vitalygashkov@vk.com`},V=`Vitaly Gashkov <vitalygashkov@vk.com>`,H=`AGPL-3.0`,U=`README.md`,W=[{type:`individual`,url:`https://t.me/tribute/app?startapp=dqW2`}],G={node:`>=20`},K={"@types/node":`^24.5.2`,tsdown:`^0.15.5`,typescript:`^5.9.2`,vitest:`^3.2.4`},q={mp4box:`^2.1.1`},J={name:k,version:A,description:j,files:M,scripts:N,bin:P,type:F,main:I,types:re,exports:L,repository:R,keywords:z,bugs:B,author:V,license:H,readmeFilename:U,funding:W,engines:G,devDependencies:K,dependencies:q};const Y=(0,l.parseArgs)({allowPositionals:!0,strict:!1,options:{key:{short:`k`,type:`string`,multiple:!0},help:{short:`h`,type:`boolean`}}}),[X,Z]=(Array.isArray(Y.values.key)?Y.values.key:[])[0]?.split(`:`)??[],[Q,$]=Y.positionals;(async()=>{Q&&$&&X&&Z?await O(Q,$,{key:Z,keyId:X}):console.log(`
-${J.name} version ${J.version}
-(c) 2024-2025 ${J.author}
-
-Usage: ${J.name} [options] <input> <output>
-
-Options:
-  --key <id>:<k>
-    <id> is either a track ID in decimal or a 128-bit KID in hex,
-    <k> is a 128-bit key in hex
-    (several --key options can be used, one for each track or KID)
-      `.trim())})();