@h3l1os/mp4vault 2.0.0

package/dist/index.js

@@ -0,0 +1,1479 @@
+// src/jspack.js
+function JSPack() {
+  var el;
+  var bBE = false;
+  var m = this;
+  m._DeArray = function(a, p, l) {
+    return [a.slice(p, p + l)];
+  };
+  m._EnArray = function(a, p, l, v) {
+    for (var i = 0; i < l; a[p + i] = v[i] ? v[i] : 0, i++) {
+    }
+  };
+  m._DeChar = function(a, p) {
+    return String.fromCharCode(a[p]);
+  };
+  m._EnChar = function(a, p, v) {
+    a[p] = v.charCodeAt(0);
+  };
+  m._DeInt = function(a, p) {
+    var lsb = bBE ? el.len - 1 : 0;
+    var nsb = bBE ? -1 : 1;
+    var stop = lsb + nsb * el.len;
+    var rv, i, f;
+    for (rv = 0, i = lsb, f = 1; i != stop; rv += a[p + i] * f, i += nsb, f *= 256) {
+    }
+    if (el.bSigned && rv & Math.pow(2, el.len * 8 - 1)) {
+      rv -= Math.pow(2, el.len * 8);
+    }
+    return rv;
+  };
+  m._EnInt = function(a, p, v) {
+    var lsb = bBE ? el.len - 1 : 0;
+    var nsb = bBE ? -1 : 1;
+    var stop = lsb + nsb * el.len;
+    var i;
+    v = v < el.min ? el.min : v > el.max ? el.max : v;
+    for (i = lsb; i != stop; a[p + i] = v & 255, i += nsb, v >>= 8) {
+    }
+  };
+  m._DeString = function(a, p, l) {
+    for (var rv = new Array(l), i = 0; i < l; rv[i] = String.fromCharCode(a[p + i]), i++) {
+    }
+    return rv.join("");
+  };
+  m._EnString = function(a, p, l, v) {
+    for (var t, i = 0; i < l; a[p + i] = (t = v.charCodeAt(i)) ? t : 0, i++) {
+    }
+  };
+  m._De754 = function(a, p) {
+    var s, e, m2, i, d, nBits, mLen, eLen, eBias, eMax;
+    mLen = el.mLen, eLen = el.len * 8 - el.mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1;
+    i = bBE ? 0 : el.len - 1;
+    d = bBE ? 1 : -1;
+    s = a[p + i];
+    i += d;
+    nBits = -7;
+    for (e = s & (1 << -nBits) - 1, s >>= -nBits, nBits += eLen; nBits > 0; e = e * 256 + a[p + i], i += d, nBits -= 8) {
+    }
+    for (m2 = e & (1 << -nBits) - 1, e >>= -nBits, nBits += mLen; nBits > 0; m2 = m2 * 256 + a[p + i], i += d, nBits -= 8) {
+    }
+    switch (e) {
+      case 0:
+        e = 1 - eBias;
+        break;
+      case eMax:
+        return m2 ? NaN : (s ? -1 : 1) * Infinity;
+      default:
+        m2 = m2 + Math.pow(2, mLen);
+        e = e - eBias;
+        break;
+    }
+    return (s ? -1 : 1) * m2 * Math.pow(2, e - mLen);
+  };
+  m._En754 = function(a, p, v) {
+    var s, e, m2, i, d, c, mLen, eLen, eBias, eMax;
+    mLen = el.mLen, eLen = el.len * 8 - el.mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1;
+    s = v < 0 ? 1 : 0;
+    v = Math.abs(v);
+    if (isNaN(v) || v == Infinity) {
+      m2 = isNaN(v) ? 1 : 0;
+      e = eMax;
+    } else {
+      e = Math.floor(Math.log(v) / Math.LN2);
+      if (v * (c = Math.pow(2, -e)) < 1) {
+        e--;
+        c *= 2;
+      }
+      if (e + eBias >= 1) {
+        v += el.rt / c;
+      } else {
+        v += el.rt * Math.pow(2, 1 - eBias);
+      }
+      if (v * c >= 2) {
+        e++;
+        c /= 2;
+      }
+      if (e + eBias >= eMax) {
+        m2 = 0;
+        e = eMax;
+      } else if (e + eBias >= 1) {
+        m2 = (v * c - 1) * Math.pow(2, mLen);
+        e = e + eBias;
+      } else {
+        m2 = v * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+        e = 0;
+      }
+    }
+    for (i = bBE ? el.len - 1 : 0, d = bBE ? -1 : 1; mLen >= 8; a[p + i] = m2 & 255, i += d, m2 /= 256, mLen -= 8) {
+    }
+    for (e = e << mLen | m2, eLen += mLen; eLen > 0; a[p + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+    }
+    a[p + i - d] |= s * 128;
+  };
+  m._DeInt64 = function(a, p) {
+    var start = bBE ? 0 : 7;
+    var nsb = bBE ? 1 : -1;
+    var stop = start + nsb * 8;
+    var rv = [0, 0, !el.bSigned];
+    var i, f, rvi;
+    for (i = start, rvi = 1, f = 0; i != stop; rv[rvi] = (rv[rvi] << 8 >>> 0) + a[p + i], i += nsb, f++, rvi = f < 4 ? 1 : 0) {
+    }
+    return rv[0] + rv[1] * 4294967296;
+  };
+  m._EnInt64 = function(a, p, v) {
+    if (!Array.isArray(v)) {
+      v = [
+        v % 4294967296,
+        Math.floor(v / 4294967296),
+        1
+      ];
+    }
+    var start = bBE ? 0 : 7;
+    var nsb = bBE ? 1 : -1;
+    var stop = start + nsb * 8;
+    var i, f, rvi, s;
+    for (i = start, rvi = 1, f = 0, s = 24; i != stop; a[p + i] = v[rvi] >> s & 255, i += nsb, f++, rvi = f < 4 ? 1 : 0, s = 24 - 8 * (f % 4)) {
+    }
+  };
+  m._sPattern = "(\\d+)?([AxcbBhHsfdiIlLqQ])";
+  m._lenLut = {
+    "A": 1,
+    "x": 1,
+    "c": 1,
+    "b": 1,
+    "B": 1,
+    "h": 2,
+    "H": 2,
+    "s": 1,
+    "f": 4,
+    "d": 8,
+    "i": 4,
+    "I": 4,
+    "l": 4,
+    "L": 4,
+    "q": 8,
+    "Q": 8
+  };
+  m._elLut = {
+    "A": { en: m._EnArray, de: m._DeArray },
+    "s": { en: m._EnString, de: m._DeString },
+    "c": { en: m._EnChar, de: m._DeChar },
+    "b": { en: m._EnInt, de: m._DeInt, len: 1, bSigned: true, min: -Math.pow(2, 7), max: Math.pow(2, 7) - 1 },
+    "B": { en: m._EnInt, de: m._DeInt, len: 1, bSigned: false, min: 0, max: Math.pow(2, 8) - 1 },
+    "h": { en: m._EnInt, de: m._DeInt, len: 2, bSigned: true, min: -Math.pow(2, 15), max: Math.pow(2, 15) - 1 },
+    "H": { en: m._EnInt, de: m._DeInt, len: 2, bSigned: false, min: 0, max: Math.pow(2, 16) - 1 },
+    "i": { en: m._EnInt, de: m._DeInt, len: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1 },
+    "I": { en: m._EnInt, de: m._DeInt, len: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1 },
+    "l": { en: m._EnInt, de: m._DeInt, len: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1 },
+    "L": { en: m._EnInt, de: m._DeInt, len: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1 },
+    "f": { en: m._En754, de: m._De754, len: 4, mLen: 23, rt: Math.pow(2, -24) - Math.pow(2, -77) },
+    "d": { en: m._En754, de: m._De754, len: 8, mLen: 52, rt: 0 },
+    "q": { en: m._EnInt64, de: m._DeInt64, bSigned: true },
+    "Q": { en: m._EnInt64, de: m._DeInt64, bSigned: false }
+  };
+  m._UnpackSeries = function(n, s, a, p) {
+    for (var fxn = el.de, rv = [], i = 0; i < n; rv.push(fxn(a, p + i * s)), i++) {
+    }
+    return rv;
+  };
+  m._PackSeries = function(n, s, a, p, v, i) {
+    for (var fxn = el.en, o = 0; o < n; fxn(a, p + o * s, v[i + o]), o++) {
+    }
+  };
+  m.UnpackTo = function(fmt, a, p, allowLessData = false) {
+    bBE = fmt.charAt(0) != "<";
+    p = p ? p : 0;
+    var re = new RegExp(this._sPattern, "g");
+    var m2, n, s;
+    var rv = [];
+    while (m2 = re.exec(fmt)) {
+      n = m2[1] == void 0 || m2[1] == "" ? 1 : parseInt(m2[1]);
+      s = this._lenLut[m2[2]];
+      if (p + n * s > a.length) {
+        if (allowLessData) {
+          break;
+        } else {
+          return void 0;
+        }
+      }
+      switch (m2[2]) {
+        case "A":
+        case "s":
+          rv.push(this._elLut[m2[2]].de(a, p, n));
+          break;
+        case "c":
+        case "b":
+        case "B":
+        case "h":
+        case "H":
+        case "i":
+        case "I":
+        case "l":
+        case "L":
+        case "f":
+        case "d":
+        case "q":
+        case "Q":
+          el = this._elLut[m2[2]];
+          if (n > 1) {
+            var arr = [];
+            arr.push(this._UnpackSeries(n, s, a, p));
+            rv.push(arr);
+          } else {
+            rv.push(this._UnpackSeries(n, s, a, p));
+          }
+          break;
+      }
+      p += n * s;
+    }
+    return Array.prototype.concat.apply([], rv);
+  };
+  m.PackTo = function(fmt, a, p, values, allowLessData) {
+    bBE = fmt.charAt(0) != "<";
+    var re = new RegExp(this._sPattern, "g");
+    var m2, n, s, j;
+    var i = 0;
+    while (m2 = re.exec(fmt)) {
+      n = m2[1] == void 0 || m2[1] == "" ? 1 : parseInt(m2[1]);
+      s = this._lenLut[m2[2]];
+      if (p + n * s > a.length) {
+        return false;
+      }
+      switch (m2[2]) {
+        case "A":
+        case "s":
+          if (i + 1 > values.length) {
+            return allowLessData ? a.slice(0, p) : false;
+          }
+          this._elLut[m2[2]].en(a, p, n, values[i]);
+          i += 1;
+          break;
+        case "c":
+        case "b":
+        case "B":
+        case "h":
+        case "H":
+        case "i":
+        case "I":
+        case "l":
+        case "L":
+        case "f":
+        case "d":
+        case "q":
+        case "Q":
+          el = this._elLut[m2[2]];
+          if (n > 1 && Array.isArray(values[i])) {
+            if (i + 1 > values.length) {
+              return allowLessData ? a.slice(0, p) : false;
+            }
+            this._PackSeries(n, s, a, p, values[i], 0);
+            i += 1;
+          } else {
+            if (i + n > values.length) {
+              return allowLessData ? a.slice(0, p) : false;
+            }
+            this._PackSeries(n, s, a, p, values, i);
+            i += n;
+          }
+          break;
+        case "x":
+          for (j = 0; j < n; j++) {
+            a[p + j] = 0;
+          }
+          break;
+      }
+      p += n * s;
+    }
+    return a;
+  };
+  m.Pack = function(fmt, values, allowLessData = false) {
+    return this.PackTo(fmt, new Array(this.CalcLength(fmt)), 0, values, allowLessData);
+  };
+  m.Unpack = function(fmt, values, allowLessData = false) {
+    return this.UnpackTo(fmt, values, 0, allowLessData);
+  };
+  m.CalcLength = function(fmt) {
+    var re = new RegExp(this._sPattern, "g");
+    var sum = 0;
+    var m2;
+    while (m2 = re.exec(fmt)) {
+      sum += (m2[1] == void 0 || m2[1] == "" ? 1 : parseInt(m2[1])) * this._lenLut[m2[2]];
+    }
+    return sum;
+  };
+}
+var jspack_default = new JSPack();
+
+// src/Pack.ts
+var Pack = class {
+  static pack(format, values) {
+    return jspack_default.Pack(format, values);
+  }
+  static unpack(format, buffer) {
+    return jspack_default.Unpack(format, buffer, 0);
+  }
+};
+
+// src/constants.ts
+var BUFFER_SIZE = 1e5;
+var MAX_HEADER_SIZE = 10485760;
+var MAX_INT32 = 4294967295;
+
+// src/Atom.ts
+var Atom = class {
+  constructor(params) {
+    this.readable = params.readable || null;
+    this.name = params.name;
+    this.start = params.start;
+    this.size = params.size;
+    this.header_size = params.header_size;
+    this.mother = params.mother || null;
+    this.children = [];
+    this.contents = null;
+  }
+  findAtoms(atoms, name) {
+    atoms = atoms || this.children;
+    let ret = [];
+    for (const a of atoms) {
+      if (a.name === name) {
+        ret.push(a);
+      }
+      if (a.children.length) {
+        ret = ret.concat(this.findAtoms(a.children, name));
+      }
+    }
+    return ret;
+  }
+  async unpackFromOffset(offset, length, fmt) {
+    try {
+      const data = await this.readable.getSlice(this.start + offset, length);
+      return Pack.unpack(fmt, data);
+    } catch {
+      return [];
+    }
+  }
+  isVideo() {
+    const vmhdAtoms = this.findAtoms(null, "vmhd");
+    return !!(vmhdAtoms && vmhdAtoms.length);
+  }
+  isAudio() {
+    const smhdAtoms = this.findAtoms(null, "smhd");
+    return !!(smhdAtoms && smhdAtoms.length);
+  }
+  async getChunkOffsets() {
+    let sampleOffsets = [];
+    if (this.name !== "stco" && this.name !== "co64") {
+      const sampleAtoms = this.findAtoms(null, "stco").concat(this.findAtoms(null, "co64"));
+      for (const atom of sampleAtoms) {
+        sampleOffsets = sampleOffsets.concat(await atom.getChunkOffsets());
+      }
+      return sampleOffsets;
+    }
+    const data = await this.readable.getSlice(this.start + this.header_size, 8);
+    const unpacked = Pack.unpack(">II", data);
+    const count = unpacked[1];
+    if (this.name === "stco") {
+      for (let i = 0; i < count; i += 1024) {
+        const cToRead = Math.min(1024, count - i);
+        const readOffsets = Pack.unpack(
+          ">" + "I".repeat(cToRead),
+          await this.readable.getSlice(this.start + this.header_size + 8 + i * 4, cToRead * 4)
+        );
+        sampleOffsets.push(...readOffsets);
+      }
+    } else if (this.name === "co64") {
+      for (let i = 0; i < count; i += 1024) {
+        const cToRead = Math.min(1024, count - i);
+        const readOffsets = Pack.unpack(
+          ">" + "Q".repeat(cToRead),
+          await this.readable.getSlice(this.start + this.header_size + 8 + i * 8, cToRead * 8)
+        );
+        sampleOffsets.push(...readOffsets);
+      }
+    }
+    return sampleOffsets;
+  }
+  async writeHeader(writable) {
+    if (this.size > MAX_INT32 && this.header_size === 8) {
+      throw new Error("Size too large for compact header");
+    }
+    if (this.size < MAX_INT32) {
+      await writable.write(Pack.pack(">I4s", [this.size, this.name]));
+    } else {
+      await writable.write(Pack.pack(">I4sQ", [1, this.name, this.size]));
+    }
+  }
+  async writePayload(writable) {
+    if (this.children.length) {
+      for (const a of this.children) {
+        await a.write(writable);
+      }
+    } else {
+      const bodySize = this.size - this.header_size;
+      if (this.readable) {
+        for (let i = 0; i < bodySize; i += BUFFER_SIZE) {
+          const copySize = Math.min(BUFFER_SIZE, bodySize - i);
+          const chunk = await this.readable.getSlice(this.start + this.header_size + i, copySize);
+          await writable.write(chunk);
+        }
+      } else if (this.contents) {
+        if (this.contents.length === bodySize) {
+          await writable.write(this.contents);
+        } else {
+          throw new Error("Invalid bodySize for contents chunk");
+        }
+      } else {
+        if (bodySize > 0) {
+          await writable.write(new Uint8Array([0]));
+        }
+      }
+    }
+  }
+  async write(writable) {
+    await this.writeHeader(writable);
+    await this.writePayload(writable);
+  }
+};
+
+// src/AES.ts
+import crypto from "crypto";
+var IV_BYTE_LENGTH = 12;
+var SALT_BYTE_LENGTH = 16;
+var AUTH_TAG_BYTE_LENGTH = 16;
+var KEY_BYTE_LENGTH = 32;
+var PBKDF2_ITERATIONS = 6e5;
+var PBKDF2_DIGEST = "sha512";
+var AES = class _AES {
+  constructor(params) {
+    this._cipher = null;
+    this._decipher = null;
+    this._iv = params.iv || crypto.randomBytes(IV_BYTE_LENGTH);
+    this._salt = params.salt || null;
+    this._authTag = params.authTag || null;
+    if (params.password) {
+      if (!this._salt) {
+        this._salt = crypto.randomBytes(SALT_BYTE_LENGTH);
+      }
+      this._key = _AES.deriveKey(params.password, this._salt);
+    } else if (params.key) {
+      this._key = _AES._normalizeKey(params.key);
+    } else {
+      throw new Error("Either key or password is required");
+    }
+  }
+  static {
+    this.ivByteLength = IV_BYTE_LENGTH;
+  }
+  static {
+    this.saltByteLength = SALT_BYTE_LENGTH;
+  }
+  static {
+    this.authTagByteLength = AUTH_TAG_BYTE_LENGTH;
+  }
+  static _normalizeKey(key) {
+    if (Buffer.isBuffer(key)) {
+      if (key.length !== 16 && key.length !== 24 && key.length !== 32) {
+        throw new Error("Key must be 16, 24, or 32 bytes. Got " + key.length);
+      }
+      return key;
+    }
+    if (key instanceof Uint8Array) {
+      if (key.length !== 16 && key.length !== 24 && key.length !== 32) {
+        throw new Error("Key must be 16, 24, or 32 bytes. Got " + key.length);
+      }
+      return Buffer.from(key);
+    }
+    throw new Error("Key must be a Buffer or Uint8Array");
+  }
+  static _algorithmForKey(key) {
+    switch (key.length) {
+      case 16:
+        return "aes-128-gcm";
+      case 24:
+        return "aes-192-gcm";
+      case 32:
+        return "aes-256-gcm";
+      default:
+        throw new Error("Key must be 16, 24, or 32 bytes. Got " + key.length);
+    }
+  }
+  static deriveKey(password, salt) {
+    return crypto.pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_BYTE_LENGTH, PBKDF2_DIGEST);
+  }
+  encrypt(chunk, finalize = false) {
+    if (!this._cipher) {
+      const algo = _AES._algorithmForKey(this._key);
+      this._cipher = crypto.createCipheriv(algo, this._key, this._iv);
+    }
+    if (finalize) {
+      if (chunk && chunk.length > 0) {
+        const processed = this._cipher.update(chunk);
+        const final = this._cipher.final();
+        this._authTag = this._cipher.getAuthTag();
+        return Buffer.concat([processed, final]);
+      } else {
+        const final = this._cipher.final();
+        this._authTag = this._cipher.getAuthTag();
+        return final;
+      }
+    } else {
+      return this._cipher.update(chunk);
+    }
+  }
+  decrypt(chunk, finalize = false) {
+    if (!this._decipher) {
+      const algo = _AES._algorithmForKey(this._key);
+      this._decipher = crypto.createDecipheriv(algo, this._key, this._iv);
+      if (this._authTag) {
+        this._decipher.setAuthTag(this._authTag);
+      }
+    }
+    if (finalize) {
+      if (chunk && chunk.length > 0) {
+        const processed = this._decipher.update(chunk);
+        const final = this._decipher.final();
+        return Buffer.concat([processed, final]);
+      } else {
+        return this._decipher.final();
+      }
+    } else {
+      return this._decipher.update(chunk);
+    }
+  }
+  getAuthTag() {
+    if (!this._authTag) {
+      throw new Error("Auth tag not available. Call encrypt with finalize=true first");
+    }
+    return this._authTag;
+  }
+  getIV() {
+    return this._iv;
+  }
+  getSalt() {
+    return this._salt;
+  }
+};
+
+// src/Convert.ts
+import crypto2 from "crypto";
+var Convert = class {
+  static randomByteIn(maxOptions, option) {
+    const maxMultiple = Math.floor(256 / maxOptions);
+    const randomValue = crypto2.randomInt(maxMultiple);
+    return randomValue * maxOptions + option;
+  }
+  static isByteIn(byte, maxOptions, option) {
+    return byte % maxOptions === option;
+  }
+  static objectToBuffer(object) {
+    return Buffer.from(JSON.stringify(object), "utf-8");
+  }
+  static bufferToObject(buffer) {
+    return JSON.parse(Buffer.from(buffer).toString("utf-8"));
+  }
+  static hexStringToBuffer(str) {
+    if (typeof str !== "string" || !/^[0-9a-fA-F]*$/.test(str) || str.length % 2 !== 0) {
+      throw new Error("Invalid hex string");
+    }
+    return Buffer.from(str, "hex");
+  }
+};
+
+// src/EmbedObject.ts
+var EmbedObject = class _EmbedObject {
+  constructor(params = {}) {
+    this._encryptor = null;
+    this._object = params.object || null;
+    this._binary = params.object ? Convert.objectToBuffer(params.object) : null;
+    this._key = params.key || null;
+    this._password = params.password || null;
+    this._iv = params.iv || null;
+    this._salt = params.salt || null;
+    this._readBytes = params.readBytes || 0;
+  }
+  get readBytes() {
+    return this._readBytes;
+  }
+  async getExpectedSize() {
+    if (this._key || this._password) {
+      return 2 + AES.saltByteLength + AES.ivByteLength + 4 + this._binary.length + AES.authTagByteLength;
+    } else {
+      return 2 + 4 + this._binary.length;
+    }
+  }
+  get object() {
+    return this._object;
+  }
+  getEncryptor() {
+    if (this._encryptor) {
+      return this._encryptor;
+    }
+    this._encryptor = new AES({
+      key: this._key || void 0,
+      password: this._password || void 0,
+      iv: this._iv || void 0,
+      salt: this._salt || void 0
+    });
+    if (!this._iv) {
+      this._iv = this._encryptor.getIV();
+    }
+    if (!this._salt) {
+      this._salt = this._encryptor.getSalt();
+    }
+    return this._encryptor;
+  }
+  getIV() {
+    if (!this._iv) {
+      throw new Error("IV is not yet ready. Run getEncryptor() first, or specify one yourself");
+    }
+    return this._iv;
+  }
+  static async restoreFromReadable(readable, params = {}, offset = 0) {
+    const firstByte = (await readable.getSlice(offset + 0, 1))[0];
+    const typeByte = (await readable.getSlice(offset + 1, 1))[0];
+    let size = null;
+    let readBytes = 2;
+    if (Convert.isByteIn(firstByte, 2, 1)) {
+      const salt = await readable.getSlice(offset + 2, AES.saltByteLength);
+      readBytes += AES.saltByteLength;
+      const iv = await readable.getSlice(offset + 2 + AES.saltByteLength, AES.ivByteLength);
+      readBytes += AES.ivByteLength;
+      const headerDataOffset = offset + 2 + AES.saltByteLength + AES.ivByteLength;
+      const sizeChunk = await readable.getSlice(headerDataOffset, 4);
+      readBytes += 4;
+      const decryptParams = {
+        iv: Buffer.from(iv),
+        salt: Buffer.from(salt)
+      };
+      if (params.key) decryptParams.key = params.key;
+      if (params.password) decryptParams.password = params.password;
+      const peekDecryptor = new AES(decryptParams);
+      const sizeDecrypted = peekDecryptor.decrypt(Buffer.from(sizeChunk));
+      size = Pack.unpack(">I", sizeDecrypted)[0];
+      if (!size) {
+        throw new Error("Can not get size of EmbedObject to restore");
+      }
+      if (size > MAX_HEADER_SIZE) {
+        throw new Error("Header is too large to extract");
+      }
+      const fullEncryptedSize = 4 + size;
+      const authTagOffset = headerDataOffset + fullEncryptedSize;
+      const authTag = await readable.getSlice(authTagOffset, AES.authTagByteLength);
+      readBytes += size + AES.authTagByteLength;
+      decryptParams.authTag = Buffer.from(authTag);
+      const fullDecryptor = new AES(decryptParams);
+      const fullChunk = await readable.getSlice(headerDataOffset, fullEncryptedSize);
+      const decrypted = fullDecryptor.decrypt(Buffer.from(fullChunk), true);
+      const jsonPayload = decrypted.subarray(4);
+      params.object = Convert.bufferToObject(jsonPayload);
+    } else {
+      const sizeBytes = await readable.getSlice(offset + 2, 4);
+      readBytes += 4;
+      size = Pack.unpack(">I", sizeBytes)[0];
+      if (!size) {
+        throw new Error("Can not get size of EmbedObject to restore");
+      }
+      if (size > MAX_HEADER_SIZE) {
+        throw new Error("Header is too large to extract");
+      }
+      const chunk = await readable.getSlice(offset + 6, size);
+      readBytes += size;
+      params.object = Convert.bufferToObject(Buffer.from(chunk));
+    }
+    delete params.iv;
+    delete params.salt;
+    await readable.close();
+    params.readBytes = readBytes;
+    return new _EmbedObject(params);
+  }
+  async writeTo(writable) {
+    const binary = this.getBinary();
+    await writable.write(binary);
+  }
+  getBinary() {
+    if (this._key || this._password) {
+      return this.getEncrypted();
+    } else {
+      return this.getRaw();
+    }
+  }
+  getRaw() {
+    const payload = this._binary;
+    const ret = new Uint8Array(payload.length + 2 + 4);
+    const firstByte = Convert.randomByteIn(2, 0);
+    const secondByte = Convert.randomByteIn(11, 0);
+    ret.set([firstByte], 0);
+    ret.set([secondByte], 1);
+    ret.set(Pack.pack(">I", [payload.length]), 2);
+    ret.set(payload, 6);
+    return ret;
+  }
+  getEncrypted() {
+    const encryptor = this.getEncryptor();
+    const packedSize = Pack.pack(">I", [this._binary.length]);
+    const plaintext = Buffer.concat([Buffer.from(packedSize), this._binary]);
+    const ciphertext = encryptor.encrypt(plaintext, true);
+    const iv = this.getIV();
+    const salt = encryptor.getSalt() || Buffer.alloc(AES.saltByteLength);
+    const authTag = encryptor.getAuthTag();
+    const ret = new Uint8Array(2 + salt.length + iv.length + ciphertext.length + authTag.length);
+    const firstByte = Convert.randomByteIn(2, 1);
+    const secondByte = Convert.randomByteIn(11, 0);
+    ret.set([firstByte], 0);
+    ret.set([secondByte], 1);
+    let pos = 2;
+    ret.set(salt, pos);
+    pos += salt.length;
+    ret.set(iv, pos);
+    pos += iv.length;
+    ret.set(ciphertext, pos);
+    pos += ciphertext.length;
+    ret.set(authTag, pos);
+    return ret;
+  }
+};
+
+// src/node/Readable.ts
+import fs from "fs/promises";
+var Readable = class {
+  constructor(params = {}) {
+    this._prepared = false;
+    this._size = 0;
+    this._fp = null;
+    this._filename = params.filename;
+  }
+  isPrepared() {
+    return this._prepared;
+  }
+  async prepare() {
+    if (this._prepared) {
+      return;
+    }
+    if (this._filename) {
+      this._fp = await fs.open(this._filename, "r");
+      const stats = await this._fp.stat();
+      this._size = stats.size;
+    }
+    this._prepared = true;
+  }
+  async close() {
+    if (this._fp) {
+      try {
+        await this._fp.close();
+      } catch {
+      }
+    }
+    this._fp = null;
+    this._prepared = false;
+  }
+  async getSlice(offset, length) {
+    if (!this._prepared) {
+      await this.prepare();
+    }
+    const ret = new Uint8Array(length);
+    await this._fp.read(ret, 0, length, offset);
+    return ret;
+  }
+  async size() {
+    if (!this._prepared) {
+      await this.prepare();
+    }
+    return this._size;
+  }
+};
+
+// src/node/Writable.ts
+import fs2 from "fs/promises";
+
+// src/utils.ts
+import tmp from "tmp";
+function tmpFileSync() {
+  const tmpobj = tmp.fileSync();
+  return tmpobj.name;
+}
+
+// src/node/Writable.ts
+var Writable = class {
+  constructor(params = {}) {
+    this._uint8Array = new Uint8Array([]);
+    this._prepared = false;
+    this._bytesWrote = 0;
+    this._fp = null;
+    if (params.filename) {
+      this._filename = params.filename;
+    }
+  }
+  size() {
+    if (this._filename) {
+      return this._bytesWrote;
+    }
+    return this._uint8Array.length;
+  }
+  async prepare() {
+    if (this._prepared) {
+      return;
+    }
+    if (this._filename) {
+      this._fp = await fs2.open(this._filename, "w");
+    }
+    this._prepared = true;
+  }
+  async close() {
+    if (this._fp) {
+      try {
+        await this._fp.close();
+      } catch {
+      }
+      this._fp = null;
+      this._prepared = false;
+    }
+  }
+  async saveToFile(filename) {
+    await fs2.writeFile(filename, this._uint8Array);
+  }
+  async write(append) {
+    if (!this._prepared) {
+      await this.prepare();
+    }
+    const data = append instanceof Uint8Array ? append : Uint8Array.from(append);
+    if (this._fp) {
+      await this._fp.write(data, 0, data.length);
+      this._bytesWrote += data.length;
+    } else {
+      const ret = new Uint8Array(this._uint8Array.length + data.length);
+      ret.set(this._uint8Array, 0);
+      ret.set(data, this._uint8Array.length);
+      this._bytesWrote += data.length;
+      this._uint8Array = ret;
+    }
+  }
+  async toReadable() {
+    if (this._filename) {
+      await this.close();
+      return new Readable({ filename: this._filename });
+    } else {
+      const tmpName = tmpFileSync();
+      await this.saveToFile(tmpName);
+      await this.close();
+      return new Readable({ filename: tmpName });
+    }
+  }
+};
+
+// src/EmbedBinary.ts
+var EmbedBinary = class {
+  constructor(params = {}) {
+    this._encryptor = null;
+    this._readable = null;
+    if (params.readable) {
+      this._readable = params.readable;
+    } else if (params.filename && !params.file) {
+      this._readable = new Readable({ filename: params.filename });
+    } else if (params.file) {
+      this._readable = new Readable({ filename: params.file.name });
+    }
+    this._key = params.key || null;
+    this._password = params.password || null;
+    this._iv = params.iv || null;
+    this._salt = params.salt || null;
+  }
+  async getExpectedSize() {
+    if (!this._readable) {
+      throw new Error("No readable source. Provide a filename, file, or readable");
+    }
+    const readableSize = await this._readable.size();
+    if (this._key || this._password) {
+      return 2 + AES.saltByteLength + AES.ivByteLength + readableSize + AES.authTagByteLength;
+    } else {
+      return 2 + readableSize;
+    }
+  }
+  getEncryptor() {
+    if (this._encryptor) {
+      return this._encryptor;
+    }
+    this._encryptor = new AES({
+      key: this._key || void 0,
+      password: this._password || void 0,
+      iv: this._iv || void 0,
+      salt: this._salt || void 0
+    });
+    if (!this._iv) {
+      this._iv = this._encryptor.getIV();
+    }
+    if (!this._salt) {
+      this._salt = this._encryptor.getSalt();
+    }
+    return this._encryptor;
+  }
+  getIV() {
+    if (!this._iv) {
+      throw new Error("IV is not yet ready. Run getEncryptor() first, or specify one yourself");
+    }
+    return this._iv;
+  }
+  static async restoreFromReadable(readable, params = {}, offset = 0, size = null, writable = null) {
+    const firstByte = (await readable.getSlice(offset + 0, 1))[0];
+    const typeByte = (await readable.getSlice(offset + 1, 1))[0];
+    if (!size) {
+      size = await readable.size() - offset;
+    }
+    let decryptor = null;
+    if (Convert.isByteIn(firstByte, 2, 1)) {
+      let readOffset = offset + 2;
+      const salt = await readable.getSlice(readOffset, AES.saltByteLength);
+      readOffset += AES.saltByteLength;
+      const iv = await readable.getSlice(readOffset, AES.ivByteLength);
+      const authTagOffset = offset + size - AES.authTagByteLength;
+      const authTag = await readable.getSlice(authTagOffset, AES.authTagByteLength);
+      const decryptParams = {
+        iv: Buffer.from(iv),
+        salt: Buffer.from(salt),
+        authTag: Buffer.from(authTag)
+      };
+      if (params.key) decryptParams.key = params.key;
+      if (params.password) decryptParams.password = params.password;
+      decryptor = new AES(decryptParams);
+    }
+    if (Convert.isByteIn(typeByte, 11, 1)) {
+      if (!writable) {
+        writable = new Writable();
+      }
+      let bodySize = size - 2;
+      let bodyOffset = offset + 2;
+      if (decryptor) {
+        bodySize = bodySize - AES.saltByteLength - AES.ivByteLength - AES.authTagByteLength;
+        bodyOffset = offset + 2 + AES.saltByteLength + AES.ivByteLength;
+      }
+      for (let i = 0; i < bodySize; i += BUFFER_SIZE) {
+        const copySize = Math.min(BUFFER_SIZE, bodySize - i);
+        const chunk = await readable.getSlice(bodyOffset + i, copySize);
+        if (decryptor) {
+          const isLast = i + copySize >= bodySize;
+          const decrypted = decryptor.decrypt(Buffer.from(chunk), isLast);
+          await writable.write(decrypted);
+        } else {
+          await writable.write(chunk);
+        }
+      }
+      if (decryptor && bodySize === 0) {
+        const final = decryptor.decrypt(null, true);
+        if (final.length > 0) {
+          await writable.write(final);
+        }
+      }
+      await readable.close();
+      return writable;
+    }
+    throw new Error("Unknown embed type");
+  }
+  async writeTo(writable) {
+    if (!this._readable) return;
+    let encryptor = null;
+    let firstByte = Convert.randomByteIn(2, 0);
+    if (this._key || this._password) {
+      encryptor = this.getEncryptor();
+      firstByte = Convert.randomByteIn(2, 1);
+    }
+    await writable.write([firstByte]);
+    await writable.write([Convert.randomByteIn(11, 1)]);
+    if (encryptor) {
+      await writable.write(this._encryptor.getSalt() || Buffer.alloc(AES.saltByteLength));
+      await writable.write(this.getIV());
+    }
+    const bodySize = await this._readable.size();
+    for (let i = 0; i < bodySize; i += BUFFER_SIZE) {
+      const copySize = Math.min(BUFFER_SIZE, bodySize - i);
+      const chunk = await this._readable.getSlice(i, copySize);
+      if (encryptor) {
+        const isLast = i + copySize >= bodySize;
+        const encrypted = encryptor.encrypt(Buffer.from(chunk), isLast);
+        await writable.write(encrypted);
+      } else {
+        await writable.write(chunk);
+      }
+    }
+    if (encryptor) {
+      await writable.write(encryptor.getAuthTag());
+    }
+    await this._readable.close();
+  }
+};
+
+// src/Embed.ts
+var Embed = class {
+  constructor(params = {}) {
+    this._files = [];
+    this._headerEmbed = null;
+    this._publicHeaderEmbed = null;
+    this.hasEncryptedFiles = false;
+    this.hasPublicFiles = false;
+    this._key = params.key || null;
+    this._password = params.password || null;
+  }
+  basename(path) {
+    return ("" + path).split(/[\\/]/).pop() || "";
+  }
+  async addFile(params) {
+    const file = params.file || null;
+    let filename = params.filename || null;
+    const meta = params.meta || null;
+    let isEncrypted = false;
+    if ((this._key || this._password) && params.key !== null && params.password !== null) {
+      isEncrypted = true;
+    }
+    let embedBinary;
+    if (isEncrypted) {
+      embedBinary = new EmbedBinary({
+        filename: filename || void 0,
+        file: file || void 0,
+        key: this._key,
+        password: this._password
+      });
+    } else {
+      embedBinary = new EmbedBinary({
+        filename: filename || void 0,
+        file: file || void 0
+      });
+    }
+    if (!filename && file) {
+      filename = file.name || null;
+    }
+    const fileEntity = {
+      filename,
+      embedBinary,
+      isEncrypted
+    };
+    if (meta) {
+      fileEntity.meta = meta;
+    }
+    this._files.push(fileEntity);
+  }
+  async composeHeader() {
+    const headerObject = { files: [] };
+    const publicHeaderObject = { files: [] };
+    for (const fileEntity of this._files) {
+      const size = await fileEntity.embedBinary.getExpectedSize();
+      const fileRecord = {
+        filename: this.basename(fileEntity.filename || ""),
+        size
+      };
+      if (fileEntity.meta) {
+        fileRecord.meta = fileEntity.meta;
+      }
+      if (fileEntity.isEncrypted) {
+        headerObject.files.push(fileRecord);
+        this.hasEncryptedFiles = true;
+      } else {
+        publicHeaderObject.files.push(fileRecord);
+        this.hasPublicFiles = true;
+      }
+    }
+    this._publicHeaderEmbed = new EmbedObject({ object: publicHeaderObject });
+    this._headerEmbed = new EmbedObject({
+      object: headerObject,
+      key: this._key,
+      password: this._password
+    });
+    return true;
+  }
+  async getExpectedSize() {
+    await this.composeHeader();
+    let size = 0;
+    if (this.hasEncryptedFiles) {
+      size += await this._headerEmbed.getExpectedSize();
+    }
+    if (this.hasPublicFiles) {
+      size += await this._publicHeaderEmbed.getExpectedSize();
+    }
+    const encFiles = this._headerEmbed.object.files;
+    for (const file of encFiles) {
+      size += file.size;
+    }
+    const pubFiles = this._publicHeaderEmbed.object.files;
+    for (const file of pubFiles) {
+      size += file.size;
+    }
+    return size;
+  }
+  async writeTo(writable) {
+    await this.composeHeader();
+    if (this.hasPublicFiles) {
+      await this._publicHeaderEmbed.writeTo(writable);
+    }
+    if (this.hasEncryptedFiles) {
+      await this._headerEmbed.writeTo(writable);
+    }
+    for (const file of this._files) {
+      await file.embedBinary.writeTo(writable);
+    }
+  }
+  async restoreFromReadable(readable, params = {}, offset = 0) {
+    const publicParams = {};
+    Object.assign(publicParams, params);
+    Object.assign(publicParams, { password: null, key: void 0 });
+    let encryptedHeaderOffset = 0;
+    try {
+      this._publicHeaderEmbed = await EmbedObject.restoreFromReadable(
+        readable,
+        publicParams,
+        offset
+      );
+      encryptedHeaderOffset = this._publicHeaderEmbed.readBytes;
+    } catch {
+      this._publicHeaderEmbed = new EmbedObject({ object: { files: [] } });
+    }
+    const pubObj = this._publicHeaderEmbed._object;
+    this.hasPublicFiles = !!(pubObj && pubObj.files && pubObj.files.length);
+    try {
+      this._headerEmbed = await EmbedObject.restoreFromReadable(
+        readable,
+        params,
+        offset + encryptedHeaderOffset
+      );
+    } catch {
+      this._headerEmbed = new EmbedObject({
+        object: { files: [] },
+        key: this._key,
+        password: this._password
+      });
+    }
+    const encObj = this._headerEmbed._object;
+    this.hasEncryptedFiles = !!(encObj && encObj.files && encObj.files.length);
+  }
+  getFilesToExtract() {
+    const filesToExtract = [];
+    let offset = 0;
+    offset += this._publicHeaderEmbed.readBytes;
+    offset += this._headerEmbed.readBytes;
+    const pubFiles = this._publicHeaderEmbed._object.files;
+    for (const fileRecord of pubFiles) {
+      filesToExtract.push({ ...fileRecord, isEncrypted: false, offset });
+      offset += fileRecord.size;
+    }
+    const encFiles = this._headerEmbed._object.files;
+    for (const fileRecord of encFiles) {
+      filesToExtract.push({ ...fileRecord, isEncrypted: true, offset });
+      offset += fileRecord.size;
+    }
+    return filesToExtract;
+  }
+  async restoreBinary(readable, params, n, offset, writable = null) {
+    if (!this._headerEmbed && !this._publicHeaderEmbed) {
+      await this.restoreFromReadable(readable, params, offset);
+    }
+    const filesToExtract = this.getFilesToExtract();
+    if (!filesToExtract[n]) {
+      throw new Error("There is no file " + n + " found in this container");
+    }
+    const fileSize = filesToExtract[n].size;
+    const fileOffset = offset + filesToExtract[n].offset;
+    if (filesToExtract[n].isEncrypted) {
+      return await EmbedBinary.restoreFromReadable(readable, params, fileOffset, fileSize, writable);
+    } else {
+      const publicParams = { ...params, password: void 0, key: void 0 };
+      return await EmbedBinary.restoreFromReadable(readable, publicParams, fileOffset, fileSize, writable);
+    }
+  }
+};
+
+// src/MP4.ts
+import debug from "debug";
+var log = debug("mp4vault");
+var MP4 = class {
+  constructor() {
+    this._analyzed = false;
+    this._readable = null;
+    this._embed = null;
+    this._key = null;
+    this._password = null;
+    this._atoms = [];
+    this._initialMdatStart = null;
+    this._initialEmbed = null;
+  }
+  getEmbedFiles() {
+    if (this._initialEmbed) {
+      return this._initialEmbed.getFilesToExtract();
+    }
+    return [];
+  }
+  setKey(key) {
+    this._key = key;
+    this._password = null;
+  }
+  setPassword(password) {
+    this._password = password;
+    this._key = null;
+  }
+  async loadFile(params) {
+    if (!params || !params.filename) {
+      throw new Error("filename is required");
+    }
+    this._readable = new Readable(params);
+    await this.analyzeFile();
+    await this._readable.close();
+  }
+  async embedFile(params) {
+    if (!this._embed) {
+      this._embed = new Embed({ mp4: this, key: this._key, password: this._password });
+    }
+    await this._embed.addFile(params);
+  }
+  async getExpectedSize() {
+    let expectedSize = 0;
+    const ftyp = this.findAtom("ftyp");
+    const mdat = this.findAtom("mdat");
+    const moov = this.findAtom("moov");
+    if (!ftyp || !mdat || !moov) {
+      throw new Error("ftyp, mdat and moov atoms required");
+    }
+    const extendOffset = this._embed ? await this._embed.getExpectedSize() : 0;
+    let mdatOffset = 0;
+    const mdatNewSize = mdat.size - mdat.header_size;
+    mdatOffset += ftyp.size;
+    expectedSize += ftyp.size;
+    const tempH = mdat.header_size;
+    const tempL = mdat.size;
+    if (mdatNewSize <= MAX_INT32) {
+      const freeAtom = new Atom({
+        name: "free",
+        start: 0,
+        size: 8,
+        header_size: 8
+      });
+      expectedSize += freeAtom.size;
+      mdat.size += extendOffset;
+      expectedSize += mdat.header_size;
+      mdatOffset += 8;
+      mdatOffset += 8;
+    } else {
+      mdat.size += extendOffset;
+      mdat.header_size = 16;
+      expectedSize += mdat.header_size;
+      mdatOffset += 16;
+    }
+    mdat.header_size = tempH;
+    mdat.size = tempL;
+    if (this._embed) {
+      expectedSize += await this._embed.getExpectedSize();
+    }
+    expectedSize += mdat.size - mdat.header_size;
+    const shiftOffsets = extendOffset + (mdatOffset - this._initialMdatStart);
+    await this.adjustSampleOffsets(shiftOffsets);
+    expectedSize += moov.size;
+    return expectedSize;
+  }
+  async adjustSampleOffsets(offset) {
+    const sampleAtoms = this.findAtoms(null, "stco").concat(this.findAtoms(null, "co64"));
+    log("adjusting sample offsets by", offset, "stco co64 atoms count:", sampleAtoms.length);
+    for (const atom of sampleAtoms) {
+      const data = await this._readable.getSlice(atom.start + atom.header_size, 8);
+      const unpacked = Pack.unpack(">II", data);
+      const verFlags = unpacked[0];
+      const count = unpacked[1];
+      const sampleOffsets = [];
+      if (atom.name === "stco") {
+        for (let i = 0; i < count; i += 1024) {
+          const cToRead = Math.min(1024, count - i);
+          const readOffsets = Pack.unpack(
+            ">" + "I".repeat(cToRead),
+            await this._readable.getSlice(atom.start + atom.header_size + 8 + i * 4, cToRead * 4)
+          );
+          sampleOffsets.push(...readOffsets);
+        }
+      } else if (atom.name === "co64") {
+        for (let i = 0; i < count; i += 1024) {
+          const cToRead = Math.min(1024, count - i);
+          const readOffsets = Pack.unpack(
+            ">" + "Q".repeat(cToRead),
+            await this._readable.getSlice(atom.start + atom.header_size + 8 + i * 8, cToRead * 8)
+          );
+          sampleOffsets.push(...readOffsets);
+        }
+      }
+      for (let i = 0; i < sampleOffsets.length; i++) {
+        sampleOffsets[i] = sampleOffsets[i] + offset;
+        if (atom.name === "stco" && sampleOffsets[i] >= MAX_INT32) {
+          atom.name = "co64";
+        }
+      }
+      if (atom.name === "stco") {
+        atom.contents = Pack.pack(">II", [verFlags, count]).concat(
+          Pack.pack(">" + "I".repeat(count), sampleOffsets)
+        );
+        atom.size = atom.contents.length + 8;
+      } else {
+        atom.contents = Pack.pack(">II", [verFlags, count]).concat(
+          Pack.pack(">" + "Q".repeat(count), sampleOffsets)
+        );
+        atom.size = atom.contents.length + 8;
+      }
+      atom.readable = null;
+    }
+  }
+  async extractEmbedHeader() {
+    const mdat = this.findAtom("mdat");
+    const offset = mdat.start + mdat.header_size;
+    this._initialEmbed = new Embed({ mp4: this });
+    await this._initialEmbed.restoreFromReadable(
+      this._readable,
+      { key: this._key || void 0, password: this._password },
+      offset
+    );
+  }
+  async extractFile(n, writable = null) {
+    const mdat = this.findAtom("mdat");
+    const offset = mdat.start + mdat.header_size;
+    return await this._initialEmbed.restoreBinary(
+      this._readable,
+      { key: this._key || void 0, password: this._password || void 0 },
+      n,
+      offset,
+      writable
+    );
+  }
+  async embed(writable) {
+    const ftyp = this.findAtom("ftyp");
+    const mdat = this.findAtom("mdat");
+    const moov = this.findAtom("moov");
+    if (!ftyp || !mdat || !moov) {
+      throw new Error("ftyp, mdat and moov atoms required");
+    }
+    if (!writable) {
+      writable = new Writable();
+    }
+    const extendOffset = this._embed ? await this._embed.getExpectedSize() : 0;
+    let mdatOffset = 0;
+    const mdatNewSize = mdat.size - mdat.header_size;
+    await ftyp.write(writable);
+    mdatOffset += ftyp.size;
+    const tempH = mdat.header_size;
+    const tempL = mdat.size;
+    if (mdatNewSize <= MAX_INT32) {
+      const freeAtom = new Atom({
+        name: "free",
+        start: 0,
+        size: 8,
+        header_size: 8
+      });
+      await freeAtom.write(writable);
+      mdat.size += extendOffset;
+      await mdat.writeHeader(writable);
+      mdatOffset += 8;
+      mdatOffset += 8;
+    } else {
+      mdat.size += extendOffset;
+      mdat.header_size = 16;
+      await mdat.writeHeader(writable);
+      mdatOffset += 16;
+    }
+    log("writing mdat atom start", mdatOffset);
+    mdat.header_size = tempH;
+    mdat.size = tempL;
+    if (this._embed) {
+      await this._embed.writeTo(writable);
+    }
+    await mdat.writePayload(writable);
+    const shiftOffsets = extendOffset + (mdatOffset - this._initialMdatStart);
+    await this.adjustSampleOffsets(shiftOffsets);
+    await moov.write(writable);
+    await this._readable.close();
+    await writable.close();
+    return writable;
+  }
+  async analyzeFile() {
+    this._atoms = [];
+    const size = await this._readable.size();
+    await this.parseAtoms(0, size, null);
+    this._analyzed = true;
+    const mdat = this.findAtom("mdat");
+    this._initialMdatStart = mdat.start + mdat.header_size;
+    log("initial mdat atom start", this._initialMdatStart);
+    try {
+      await this.extractEmbedHeader();
+    } catch {
+    }
+    return this._atoms;
+  }
+  printAtoms(atoms, level = 0) {
+    atoms = atoms || this._atoms;
+    for (const a of atoms) {
+      console.log(a.start, "".padStart(level, "-"), a.name, a.size, a.header_size);
+      if (a.children.length) {
+        this.printAtoms(a.children, level + 1);
+      }
+    }
+  }
+  findAtom(name) {
+    if (!this._analyzed) {
+      throw new Error("Run await analyzeFile() first");
+    }
+    const atoms = this.findAtoms(null, name);
+    return atoms.length ? atoms[0] : null;
+  }
+  findAtoms(atoms, name) {
+    if (!this._analyzed) {
+      throw new Error("Run await analyzeFile() first");
+    }
+    atoms = atoms || this._atoms;
+    let ret = [];
+    for (const a of atoms) {
+      if (a.name === name) {
+        ret.push(a);
+      }
+      if (a.children.length) {
+        ret = ret.concat(this.findAtoms(a.children, name));
+      }
+    }
+    return ret;
+  }
+  async parseAtoms(start, end, mother) {
+    let offset = start;
+    while (offset < end) {
+      let atomSize = Pack.unpack(">I", await this._readable.getSlice(offset, 4))[0];
+      const atomType = Pack.unpack(">4s", await this._readable.getSlice(offset + 4, 4))[0];
+      let atomHeaderSize;
+      if (atomSize === 1) {
+        atomSize = Pack.unpack(">Q", await this._readable.getSlice(offset + 8, 8))[0];
+        atomHeaderSize = 16;
+      } else {
+        atomHeaderSize = 8;
+        if (atomSize === 0) {
+          atomSize = end - offset;
+        }
+      }
+      const atom = new Atom({
+        readable: this._readable,
+        name: String(atomType),
+        start: offset,
+        size: atomSize,
+        header_size: atomHeaderSize,
+        mother
+      });
+      if (mother) {
+        mother.children.push(atom);
+      } else {
+        this._atoms.push(atom);
+      }
+      if (["moov", "trak", "mdia", "minf", "stbl", "edts", "udta"].includes(String(atomType))) {
+        await this.parseAtoms(offset + atomHeaderSize, offset + atomSize, atom);
+      }
+      offset = offset + atomSize;
+    }
+    return this._atoms;
+  }
+};
+export {
+  AES,
+  Atom,
+  Convert,
+  Embed,
+  EmbedBinary,
+  EmbedObject,
+  MP4,
+  Pack,
+  Readable,
+  Writable
+};
+//# sourceMappingURL=index.js.map