@remotion/renderer 4.0.461 → 4.0.463

package/dist/esm/index.mjs

@@ -1,16 +1,669 @@
 import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// vendor/yauzl-patched/pend.js
+var require_pend = __commonJS((exports, module) => {
+  module.exports = Pend;
+  function Pend() {
+    this.pending = 0;
+    this.max = Infinity;
+    this.listeners = [];
+    this.waiting = [];
+    this.error = null;
+  }
+  Pend.prototype.go = function(fn) {
+    if (this.pending < this.max) {
+      pendGo(this, fn);
+    } else {
+      this.waiting.push(fn);
+    }
+  };
+  Pend.prototype.wait = function(cb) {
+    if (this.pending === 0) {
+      cb(this.error);
+    } else {
+      this.listeners.push(cb);
+    }
+  };
+  Pend.prototype.hold = function() {
+    return pendHold(this);
+  };
+  function pendHold(self) {
+    self.pending += 1;
+    var called = false;
+    return onCb;
+    function onCb(err) {
+      if (called)
+        throw new Error("callback called twice");
+      called = true;
+      self.error = self.error || err;
+      self.pending -= 1;
+      if (self.waiting.length > 0 && self.pending < self.max) {
+        pendGo(self, self.waiting.shift());
+      } else if (self.pending === 0) {
+        var listeners = self.listeners;
+        self.listeners = [];
+        listeners.forEach(cbListener);
+      }
+    }
+    function cbListener(listener) {
+      listener(self.error);
+    }
+  }
+  function pendGo(self, fn) {
+    fn(pendHold(self));
+  }
+});
+
+// vendor/yauzl-patched/fd-slicer.js
+var require_fd_slicer = __commonJS((exports) => {
+  var fs5 = __require("fs");
+  var util = __require("util");
+  var stream = __require("stream");
+  var Readable = stream.Readable;
+  var Writable = stream.Writable;
+  var PassThrough = stream.PassThrough;
+  var Pend = require_pend();
+  var EventEmitter2 = __require("events").EventEmitter;
+  exports.createFromBuffer = createFromBuffer;
+  exports.createFromFd = createFromFd;
+  exports.BufferSlicer = BufferSlicer;
+  exports.FdSlicer = FdSlicer;
+  util.inherits(FdSlicer, EventEmitter2);
+  function FdSlicer(fd, options2) {
+    options2 = options2 || {};
+    EventEmitter2.call(this);
+    this.fd = fd;
+    this.pend = new Pend;
+    this.pend.max = 1;
+    this.refCount = 0;
+    this.autoClose = !!options2.autoClose;
+  }
+  FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+    var self = this;
+    self.pend.go(function(cb) {
+      fs5.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        cb();
+        callback(err, bytesRead, buffer2);
+      });
+    });
+  };
+  FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
+    var self = this;
+    self.pend.go(function(cb) {
+      fs5.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        cb();
+        callback(err, written, buffer2);
+      });
+    });
+  };
+  FdSlicer.prototype.createReadStream = function(options2) {
+    return new ReadStream(this, options2);
+  };
+  FdSlicer.prototype.createWriteStream = function(options2) {
+    return new WriteStream(this, options2);
+  };
+  FdSlicer.prototype.ref = function() {
+    this.refCount += 1;
+  };
+  FdSlicer.prototype.unref = function() {
+    var self = this;
+    self.refCount -= 1;
+    if (self.refCount > 0)
+      return;
+    if (self.refCount < 0)
+      throw new Error("invalid unref");
+    if (self.autoClose) {
+      fs5.close(self.fd, onCloseDone);
+    }
+    function onCloseDone(err) {
+      if (err) {
+        self.emit("error", err);
+      } else {
+        self.emit("close");
+      }
+    }
+  };
+  util.inherits(ReadStream, Readable);
+  function ReadStream(context, options2) {
+    options2 = options2 || {};
+    Readable.call(this, options2);
+    this.context = context;
+    this.context.ref();
+    this.start = options2.start || 0;
+    this.endOffset = options2.end;
+    this.pos = this.start;
+    this._destroyed = false;
+  }
+  ReadStream.prototype._read = function(n) {
+    var self = this;
+    if (self._destroyed)
+      return;
+    var toRead = Math.min(self._readableState.highWaterMark, n);
+    if (self.endOffset != null) {
+      toRead = Math.min(toRead, self.endOffset - self.pos);
+    }
+    if (toRead <= 0) {
+      self._destroyed = true;
+      self.push(null);
+      self.context.unref();
+      return;
+    }
+    self.context.pend.go(function(cb) {
+      if (self._destroyed)
+        return cb();
+      var buffer = Buffer.allocUnsafe(toRead);
+      fs5.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+        if (self._destroyed)
+          return cb();
+        if (err) {
+          self.destroy(err);
+        } else if (bytesRead === 0) {
+          self._destroyed = true;
+          self.push(null);
+          self.context.unref();
+        } else {
+          self.pos += bytesRead;
+          self.push(buffer.slice(0, bytesRead));
+        }
+        cb();
+      });
+    });
+  };
+  ReadStream.prototype.destroy = function(err) {
+    if (err == null && !this.readableEnded) {
+      err = new Error("stream _destroyed");
+    }
+    return Readable.prototype.destroy.call(this, err);
+  };
+  ReadStream.prototype._destroy = function(err, cb) {
+    if (!this._destroyed) {
+      this._destroyed = true;
+      this.context.unref();
+    }
+    cb(err);
+  };
+  util.inherits(WriteStream, Writable);
+  function WriteStream(context, options2) {
+    options2 = options2 || {};
+    Writable.call(this, options2);
+    this.context = context;
+    this.context.ref();
+    this.start = options2.start || 0;
+    this.endOffset = options2.end == null ? Infinity : +options2.end;
+    this.bytesWritten = 0;
+    this.pos = this.start;
+    this._destroyed = false;
+    this.on("finish", this.destroy.bind(this));
+  }
+  WriteStream.prototype._write = function(buffer, encoding, callback) {
+    var self = this;
+    if (self._destroyed)
+      return;
+    if (self.pos + buffer.length > self.endOffset) {
+      var err = new Error("maximum file length exceeded");
+      err.code = "ETOOBIG";
+      self.destroy();
+      callback(err);
+      return;
+    }
+    self.context.pend.go(function(cb) {
+      if (self._destroyed)
+        return cb();
+      fs5.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
+        if (err2) {
+          self.destroy();
+          cb();
+          callback(err2);
+        } else {
+          self.bytesWritten += bytes;
+          self.pos += bytes;
+          self.emit("progress");
+          cb();
+          callback();
+        }
+      });
+    });
+  };
+  WriteStream.prototype._destroy = function(err, cb) {
+    if (!this._destroyed) {
+      this._destroyed = true;
+      this.context.unref();
+    }
+    cb(err);
+  };
+  util.inherits(BufferSlicer, EventEmitter2);
+  function BufferSlicer(buffer, options2) {
+    EventEmitter2.call(this);
+    options2 = options2 || {};
+    this.refCount = 0;
+    this.buffer = buffer;
+    this.maxChunkSize = options2.maxChunkSize || Number.MAX_SAFE_INTEGER;
+  }
+  BufferSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+    if (!(0 <= offset && offset <= buffer.length))
+      throw new RangeError("offset outside buffer: 0 <= " + offset + " <= " + buffer.length);
+    if (position < 0)
+      throw new RangeError("position is negative: " + position);
+    if (offset + length > buffer.length) {
+      length = buffer.length - offset;
+    }
+    if (position + length > this.buffer.length) {
+      length = this.buffer.length - position;
+    }
+    if (length <= 0) {
+      setImmediate(function() {
+        callback(null, 0);
+      });
+      return;
+    }
+    this.buffer.copy(buffer, offset, position, position + length);
+    setImmediate(function() {
+      callback(null, length);
+    });
+  };
+  BufferSlicer.prototype.write = function(buffer, offset, length, position, callback) {
+    buffer.copy(this.buffer, position, offset, offset + length);
+    setImmediate(function() {
+      callback(null, length, buffer);
+    });
+  };
+  BufferSlicer.prototype.createReadStream = function(options2) {
+    options2 = options2 || {};
+    var readStream = new PassThrough(options2);
+    readStream._destroyed = false;
+    readStream.start = options2.start || 0;
+    readStream.endOffset = options2.end;
+    readStream.pos = readStream.endOffset || this.buffer.length;
+    var entireSlice = this.buffer.slice(readStream.start, readStream.pos);
+    var offset = 0;
+    while (true) {
+      var nextOffset = offset + this.maxChunkSize;
+      if (nextOffset >= entireSlice.length) {
+        if (offset < entireSlice.length) {
+          readStream.write(entireSlice.slice(offset, entireSlice.length));
+        }
+        break;
+      }
+      readStream.write(entireSlice.slice(offset, nextOffset));
+      offset = nextOffset;
+    }
+    readStream.end();
+    readStream._destroy = function(err, cb) {
+      readStream._destroyed = true;
+      PassThrough.prototype._destroy.call(readStream, err, cb);
+    };
+    return readStream;
+  };
+  BufferSlicer.prototype.createWriteStream = function(options2) {
+    var bufferSlicer = this;
+    options2 = options2 || {};
+    var writeStream = new Writable(options2);
+    writeStream.start = options2.start || 0;
+    writeStream.endOffset = options2.end == null ? this.buffer.length : +options2.end;
+    writeStream.bytesWritten = 0;
+    writeStream.pos = writeStream.start;
+    writeStream._destroyed = false;
+    writeStream._write = function(buffer, encoding, callback) {
+      if (writeStream._destroyed)
+        return;
+      var end = writeStream.pos + buffer.length;
+      if (end > writeStream.endOffset) {
+        var err = new Error("maximum file length exceeded");
+        err.code = "ETOOBIG";
+        writeStream._destroyed = true;
+        callback(err);
+        return;
+      }
+      buffer.copy(bufferSlicer.buffer, writeStream.pos, 0, buffer.length);
+      writeStream.bytesWritten += buffer.length;
+      writeStream.pos = end;
+      writeStream.emit("progress");
+      callback();
+    };
+    writeStream._destroy = function(err, cb) {
+      writeStream._destroyed = true;
+      cb(err);
+    };
+    return writeStream;
+  };
+  BufferSlicer.prototype.ref = function() {
+    this.refCount += 1;
+  };
+  BufferSlicer.prototype.unref = function() {
+    this.refCount -= 1;
+    if (this.refCount < 0) {
+      throw new Error("invalid unref");
+    }
+  };
+  function createFromBuffer(buffer, options2) {
+    return new BufferSlicer(buffer, options2);
+  }
+  function createFromFd(fd, options2) {
+    return new FdSlicer(fd, options2);
+  }
+});
+
+// vendor/yauzl-patched/buffer-crc32.js
+var require_buffer_crc32 = __commonJS((exports, module) => {
+  var Buffer2 = __require("buffer").Buffer;
+  var CRC_TABLE = [
+    0,
+    1996959894,
+    3993919788,
+    2567524794,
+    124634137,
+    1886057615,
+    3915621685,
+    2657392035,
+    249268274,
+    2044508324,
+    3772115230,
+    2547177864,
+    162941995,
+    2125561021,
+    3887607047,
+    2428444049,
+    498536548,
+    1789927666,
+    4089016648,
+    2227061214,
+    450548861,
+    1843258603,
+    4107580753,
+    2211677639,
+    325883990,
+    1684777152,
+    4251122042,
+    2321926636,
+    335633487,
+    1661365465,
+    4195302755,
+    2366115317,
+    997073096,
+    1281953886,
+    3579855332,
+    2724688242,
+    1006888145,
+    1258607687,
+    3524101629,
+    2768942443,
+    901097722,
+    1119000684,
+    3686517206,
+    2898065728,
+    853044451,
+    1172266101,
+    3705015759,
+    2882616665,
+    651767980,
+    1373503546,
+    3369554304,
+    3218104598,
+    565507253,
+    1454621731,
+    3485111705,
+    3099436303,
+    671266974,
+    1594198024,
+    3322730930,
+    2970347812,
+    795835527,
+    1483230225,
+    3244367275,
+    3060149565,
+    1994146192,
+    31158534,
+    2563907772,
+    4023717930,
+    1907459465,
+    112637215,
+    2680153253,
+    3904427059,
+    2013776290,
+    251722036,
+    2517215374,
+    3775830040,
+    2137656763,
+    141376813,
+    2439277719,
+    3865271297,
+    1802195444,
+    476864866,
+    2238001368,
+    4066508878,
+    1812370925,
+    453092731,
+    2181625025,
+    4111451223,
+    1706088902,
+    314042704,
+    2344532202,
+    4240017532,
+    1658658271,
+    366619977,
+    2362670323,
+    4224994405,
+    1303535960,
+    984961486,
+    2747007092,
+    3569037538,
+    1256170817,
+    1037604311,
+    2765210733,
+    3554079995,
+    1131014506,
+    879679996,
+    2909243462,
+    3663771856,
+    1141124467,
+    855842277,
+    2852801631,
+    3708648649,
+    1342533948,
+    654459306,
+    3188396048,
+    3373015174,
+    1466479909,
+    544179635,
+    3110523913,
+    3462522015,
+    1591671054,
+    702138776,
+    2966460450,
+    3352799412,
+    1504918807,
+    783551873,
+    3082640443,
+    3233442989,
+    3988292384,
+    2596254646,
+    62317068,
+    1957810842,
+    3939845945,
+    2647816111,
+    81470997,
+    1943803523,
+    3814918930,
+    2489596804,
+    225274430,
+    2053790376,
+    3826175755,
+    2466906013,
+    167816743,
+    2097651377,
+    4027552580,
+    2265490386,
+    503444072,
+    1762050814,
+    4150417245,
+    2154129355,
+    426522225,
+    1852507879,
+    4275313526,
+    2312317920,
+    282753626,
+    1742555852,
+    4189708143,
+    2394877945,
+    397917763,
+    1622183637,
+    3604390888,
+    2714866558,
+    953729732,
+    1340076626,
+    3518719985,
+    2797360999,
+    1068828381,
+    1219638859,
+    3624741850,
+    2936675148,
+    906185462,
+    1090812512,
+    3747672003,
+    2825379669,
+    829329135,
+    1181335161,
+    3412177804,
+    3160834842,
+    628085408,
+    1382605366,
+    3423369109,
+    3138078467,
+    570562233,
+    1426400815,
+    3317316542,
+    2998733608,
+    733239954,
+    1555261956,
+    3268935591,
+    3050360625,
+    752459403,
+    1541320221,
+    2607071920,
+    3965973030,
+    1969922972,
+    40735498,
+    2617837225,
+    3943577151,
+    1913087877,
+    83908371,
+    2512341634,
+    3803740692,
+    2075208622,
+    213261112,
+    2463272603,
+    3855990285,
+    2094854071,
+    198958881,
+    2262029012,
+    4057260610,
+    1759359992,
+    534414190,
+    2176718541,
+    4139329115,
+    1873836001,
+    414664567,
+    2282248934,
+    4279200368,
+    1711684554,
+    285281116,
+    2405801727,
+    4167216745,
+    1634467795,
+    376229701,
+    2685067896,
+    3608007406,
+    1308918612,
+    956543938,
+    2808555105,
+    3495958263,
+    1231636301,
+    1047427035,
+    2932959818,
+    3654703836,
+    1088359270,
+    936918000,
+    2847714899,
+    3736837829,
+    1202900863,
+    817233897,
+    3183342108,
+    3401237130,
+    1404277552,
+    615818150,
+    3134207493,
+    3453421203,
+    1423857449,
+    601450431,
+    3009837614,
+    3294710456,
+    1567103746,
+    711928724,
+    3020668471,
+    3272380065,
+    1510334235,
+    755167117
+  ];
+  if (typeof Int32Array !== "undefined") {
+    CRC_TABLE = new Int32Array(CRC_TABLE);
+  }
+  function ensureBuffer(input) {
+    if (Buffer2.isBuffer(input)) {
+      return input;
+    }
+    var hasNewBufferAPI = typeof Buffer2.alloc === "function" && typeof Buffer2.from === "function";
+    if (typeof input === "number") {
+      return hasNewBufferAPI ? Buffer2.alloc(input) : new Buffer2(input);
+    } else if (typeof input === "string") {
+      return hasNewBufferAPI ? Buffer2.from(input) : new Buffer2(input);
+    } else {
+      throw new Error("input must be buffer, number, or string, received " + typeof input);
+    }
+  }
+  function bufferizeInt(num) {
+    var tmp = ensureBuffer(4);
+    tmp.writeInt32BE(num, 0);
+    return tmp;
+  }
+  function _crc32(buf, previous) {
+    buf = ensureBuffer(buf);
+    if (Buffer2.isBuffer(previous)) {
+      previous = previous.readUInt32BE(0);
+    }
+    var crc = ~~previous ^ -1;
+    for (var n = 0;n < buf.length; n++) {
+      crc = CRC_TABLE[(crc ^ buf[n]) & 255] ^ crc >>> 8;
+    }
+    return crc ^ -1;
+  }
+  function crc32() {
+    return bufferizeInt(_crc32.apply(null, arguments));
+  }
+  crc32.signed = function() {
+    return _crc32.apply(null, arguments);
+  };
+  crc32.unsigned = function() {
+    return _crc32.apply(null, arguments) >>> 0;
+  };
+  module.exports = crc32;
+});
+
 // src/index.ts
 import execa2 from "execa";
 
@@ -383,10 +1036,10 @@ var verboseTag = (str) => {
   return isColorSupported() ? chalk.bgBlack(` ${str} `) : `[${str}]`;
 };
 var Log = {
-  formatLogs: (logLevel, options, args) => {
+  formatLogs: (logLevel, options2, args) => {
     return [
-      options.indent ? INDENT_TOKEN : null,
-      options.tag ? verboseTag(options.tag) : null
+      options2.indent ? INDENT_TOKEN : null,
+      options2.tag ? verboseTag(options2.tag) : null
     ].filter(truthy).concat(args.map((a) => {
       if (logLevel === "warn") {
         return chalk.yellow(a);
@@ -400,54 +1053,54 @@ var Log = {
       return a;
     }));
   },
-  trace: (options, ...args) => {
+  trace: (options2, ...args) => {
     writeInRepro("trace", ...args);
-    if (isEqualOrBelowLogLevel(options.logLevel, "trace")) {
+    if (isEqualOrBelowLogLevel(options2.logLevel, "trace")) {
       if (args.length === 0) {
         return process.stdout.write(`
 `);
       }
-      return console.log(...Log.formatLogs("trace", options, args));
+      return console.log(...Log.formatLogs("trace", options2, args));
     }
   },
-  verbose: (options, ...args) => {
+  verbose: (options2, ...args) => {
     writeInRepro("verbose", ...args);
-    if (isEqualOrBelowLogLevel(options.logLevel, "verbose")) {
+    if (isEqualOrBelowLogLevel(options2.logLevel, "verbose")) {
       if (args.length === 0) {
         return process.stdout.write(`
 `);
       }
-      return console.log(...Log.formatLogs("verbose", options, args));
+      return console.log(...Log.formatLogs("verbose", options2, args));
     }
   },
-  info: (options, ...args) => {
+  info: (options2, ...args) => {
     writeInRepro("info", ...args);
-    if (isEqualOrBelowLogLevel(options.logLevel, "info")) {
+    if (isEqualOrBelowLogLevel(options2.logLevel, "info")) {
       if (args.length === 0) {
         return process.stdout.write(`
 `);
       }
-      return console.log(...Log.formatLogs("info", options, args));
+      return console.log(...Log.formatLogs("info", options2, args));
     }
   },
-  warn: (options, ...args) => {
+  warn: (options2, ...args) => {
     writeInRepro("warn", ...args);
-    if (isEqualOrBelowLogLevel(options.logLevel, "warn")) {
+    if (isEqualOrBelowLogLevel(options2.logLevel, "warn")) {
       if (args.length === 0) {
         return process.stdout.write(`
 `);
       }
-      return console.warn(...Log.formatLogs("warn", options, args));
+      return console.warn(...Log.formatLogs("warn", options2, args));
     }
   },
-  error: (options, ...args) => {
+  error: (options2, ...args) => {
     writeInRepro("error", ...args);
-    if (isEqualOrBelowLogLevel(options.logLevel, "error")) {
+    if (isEqualOrBelowLogLevel(options2.logLevel, "error")) {
       if (args.length === 0) {
         return process.stdout.write(`
 `);
       }
-      return console.error(...Log.formatLogs("error", options, args));
+      return console.error(...Log.formatLogs("error", options2, args));
     }
   }
 };
@@ -655,9 +1308,9 @@ var downloadFileWithoutRetries = ({
     });
   });
 };
-var downloadFile = async (options, retries = 2, attempt = 1) => {
+var downloadFile = async (options2, retries = 2, attempt = 1) => {
   try {
-    const res = await downloadFileWithoutRetries(options);
+    const res = await downloadFileWithoutRetries(options2);
     return res;
   } catch (err) {
     const { message } = err;
@@ -668,12 +1321,12 @@ var downloadFile = async (options, retries = 2, attempt = 1) => {
       if (retries === 0) {
         throw err;
       }
-      Log.warn({ indent: options.indent, logLevel: options.logLevel }, `Downloading ${options.url} failed (will retry): ${message}`);
+      Log.warn({ indent: options2.indent, logLevel: options2.logLevel }, `Downloading ${options2.url} failed (will retry): ${message}`);
       const backoffInSeconds = (attempt + 1) ** 2;
       await new Promise((resolve) => {
         setTimeout(() => resolve(), backoffInSeconds * 1000);
       });
-      return downloadFile(options, retries - 1, attempt + 1);
+      return downloadFile(options2, retries - 1, attempt + 1);
     }
     throw err;
   }
@@ -1445,30 +2098,30 @@ class WaitTask {
   #terminated = false;
   #browser;
   promise;
-  constructor(options) {
+  constructor(options2) {
     function getPredicateBody(predicateBody) {
       if (isString(predicateBody)) {
         return `return (${predicateBody});`;
       }
       return `return (${predicateBody})(...args);`;
     }
-    this.#domWorld = options.domWorld;
-    this.#timeout = options.timeout;
-    this.#predicateBody = getPredicateBody(options.predicateBody);
-    this.#args = options.args;
+    this.#domWorld = options2.domWorld;
+    this.#timeout = options2.timeout;
+    this.#predicateBody = getPredicateBody(options2.predicateBody);
+    this.#args = options2.args;
     this.#runCount = 0;
     this.#domWorld._waitTasks.add(this);
     this.promise = new Promise((resolve, reject) => {
       this.#resolve = resolve;
       this.#reject = reject;
     });
-    if (options.timeout) {
-      const timeoutError = new TimeoutError(`waiting for ${options.title} failed: timeout ${options.timeout}ms exceeded`);
+    if (options2.timeout) {
+      const timeoutError = new TimeoutError(`waiting for ${options2.title} failed: timeout ${options2.timeout}ms exceeded`);
       this.#timeoutTimer = setTimeout(() => {
         return this.#reject(timeoutError);
-      }, options.timeout);
+      }, options2.timeout);
     }
-    this.#browser = options.browser;
+    this.#browser = options2.browser;
     this.#browser.on("closed" /* Closed */, this.onBrowserClose);
     this.#browser.on("closed-silent" /* ClosedSilent */, this.onBrowserCloseSilent);
     this.rerun();
@@ -2352,8 +3005,8 @@ class FrameManager extends EventEmitter {
   networkManager() {
     return this.#networkManager;
   }
-  async navigateFrame(frame, url, timeout, options = {}) {
-    const { referer = undefined, waitUntil = "load" } = options;
+  async navigateFrame(frame, url, timeout, options2 = {}) {
+    const { referer = undefined, waitUntil = "load" } = options2;
     const watcher = new LifecycleWatcher(this, frame, waitUntil, timeout);
     let error = await Promise.race([
       navigate(this.#client, url, referer, frame._id),
@@ -2630,8 +3283,8 @@ class Frame {
   isOOPFrame() {
     return this.#client !== this._frameManager._client;
   }
-  goto(url, timeout, options = {}) {
-    return this._frameManager.navigateFrame(this, url, timeout, options);
+  goto(url, timeout, options2 = {}) {
+    return this._frameManager.navigateFrame(this, url, timeout, options2);
   }
   _client() {
     return this.#client;
@@ -3065,9 +3718,9 @@ class Page extends EventEmitter {
   goto({
     url,
     timeout,
-    options = {}
+    options: options2 = {}
   }) {
-    return this.#frameManager.mainFrame().goto(url, timeout, options);
+    return this.#frameManager.mainFrame().goto(url, timeout, options2);
   }
   async bringToFront() {
     await this.#client.send("Page.bringToFront");
@@ -3093,12 +3746,12 @@ class Page extends EventEmitter {
       source
     });
   }
-  async close(options = { runBeforeUnload: undefined }) {
+  async close(options2 = { runBeforeUnload: undefined }) {
     const connection = this.#client.connection();
     if (!connection) {
       return;
     }
-    const runBeforeUnload = Boolean(options.runBeforeUnload);
+    const runBeforeUnload = Boolean(options2.runBeforeUnload);
     if (runBeforeUnload) {
       await this.#client.send("Page.close");
     } else {
@@ -3809,8 +4462,8 @@ class HeadlessBrowser extends EventEmitter {
       return target._isInitialized;
     });
   }
-  async waitForTarget(predicate, options = {}) {
-    const { timeout = 30000 } = options;
+  async waitForTarget(predicate, options2 = {}) {
+    const { timeout = 30000 } = options2;
     let resolve;
     let isResolved = false;
     const targetPromise = new Promise((x) => {
@@ -3868,10 +4521,10 @@ class BrowserContext extends EventEmitter {
       return target.browserContext() === this;
     });
   }
-  waitForTarget(predicate, options = {}) {
+  waitForTarget(predicate, options2 = {}) {
     return this.#browser.waitForTarget((target) => {
       return target.browserContext() === this && predicate(target);
-    }, options);
+    }, options2);
   }
   async pages() {
     const pages = await Promise.all(this.targets().filter((target) => target.type() === "page").map((target) => target.expectPage()));
@@ -4047,7 +4700,7 @@ var callFf = ({
   bin,
   indent,
   logLevel,
-  options,
+  options: options2,
   binariesDirectory,
   cancelSignal
 }) => {
@@ -4062,7 +4715,7 @@ var callFf = ({
   const task = execa(executablePath, args.filter(truthy), {
     cwd,
     env: getExplicitEnv(cwd),
-    ...options
+    ...options2
   });
   cancelSignal?.(() => {
     task.kill();
@@ -4074,7 +4727,7 @@ var callFfNative = ({
   bin,
   indent,
   logLevel,
-  options,
+  options: options2,
   binariesDirectory,
   cancelSignal
 }) => {
@@ -4089,7 +4742,7 @@ var callFfNative = ({
   const task = spawn2(executablePath, args.filter(truthy), {
     cwd,
     env: getExplicitEnv(cwd),
-    ...options
+    ...options2
   });
   cancelSignal?.(() => {
     task.kill();
@@ -4791,9 +5444,9 @@ var defaultOnLog = ({ logLevel, tag, previewString }) => {
 };
 
 // src/open-browser.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import os6 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // src/browser/Launcher.ts
 var launchChrome = async ({
@@ -4826,17 +5479,909 @@ var launchChrome = async ({
 };
 
 // src/ensure-browser.ts
-import fs8 from "fs";
+import fs9 from "fs";
 
 // src/browser/BrowserFetcher.ts
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as os4 from "node:os";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
+import { promisify as promisify2 } from "node:util";
+
+// src/browser/extract-zip-archive.ts
+import { createWriteStream as createWriteStream2 } from "node:fs";
+import { mkdir, realpath, symlink } from "node:fs/promises";
+import * as path7 from "node:path";
+import { buffer } from "node:stream/consumers";
+import { pipeline } from "node:stream/promises";
 import { promisify } from "node:util";
-import extractZip from "extract-zip";
+
+// vendor/yauzl-patched/index.js
+var fs5 = __require("fs");
+var zlib = __require("zlib");
+var fd_slicer = require_fd_slicer();
+var crc32 = require_buffer_crc32();
+var util = __require("util");
+var EventEmitter2 = __require("events").EventEmitter;
+var Transform = __require("stream").Transform;
+var PassThrough = __require("stream").PassThrough;
+var Writable = __require("stream").Writable;
+var $open = open;
+function open(path7, options2, callback) {
+  if (typeof options2 === "function") {
+    callback = options2;
+    options2 = null;
+  }
+  if (options2 == null)
+    options2 = {};
+  if (options2.autoClose == null)
+    options2.autoClose = true;
+  if (options2.lazyEntries == null)
+    options2.lazyEntries = false;
+  if (options2.decodeStrings == null)
+    options2.decodeStrings = true;
+  if (options2.validateEntrySizes == null)
+    options2.validateEntrySizes = true;
+  if (options2.strictFileNames == null)
+    options2.strictFileNames = false;
+  if (callback == null)
+    callback = defaultCallback;
+  fs5.open(path7, "r", function(err, fd) {
+    if (err)
+      return callback(err);
+    fromFd(fd, options2, function(err2, zipfile) {
+      if (err2)
+        fs5.close(fd, defaultCallback);
+      callback(err2, zipfile);
+    });
+  });
+}
+function fromFd(fd, options2, callback) {
+  if (typeof options2 === "function") {
+    callback = options2;
+    options2 = null;
+  }
+  if (options2 == null)
+    options2 = {};
+  if (options2.autoClose == null)
+    options2.autoClose = false;
+  if (options2.lazyEntries == null)
+    options2.lazyEntries = false;
+  if (options2.decodeStrings == null)
+    options2.decodeStrings = true;
+  if (options2.validateEntrySizes == null)
+    options2.validateEntrySizes = true;
+  if (options2.strictFileNames == null)
+    options2.strictFileNames = false;
+  if (callback == null)
+    callback = defaultCallback;
+  fs5.fstat(fd, function(err, stats) {
+    if (err)
+      return callback(err);
+    var reader = fd_slicer.createFromFd(fd, { autoClose: true });
+    fromRandomAccessReader(reader, stats.size, options2, callback);
+  });
+}
+function fromRandomAccessReader(reader, totalSize, options2, callback) {
+  if (typeof options2 === "function") {
+    callback = options2;
+    options2 = null;
+  }
+  if (options2 == null)
+    options2 = {};
+  if (options2.autoClose == null)
+    options2.autoClose = true;
+  if (options2.lazyEntries == null)
+    options2.lazyEntries = false;
+  if (options2.decodeStrings == null)
+    options2.decodeStrings = true;
+  var decodeStrings = !!options2.decodeStrings;
+  if (options2.validateEntrySizes == null)
+    options2.validateEntrySizes = true;
+  if (options2.strictFileNames == null)
+    options2.strictFileNames = false;
+  if (callback == null)
+    callback = defaultCallback;
+  if (typeof totalSize !== "number")
+    throw new Error("expected totalSize parameter to be a number");
+  if (totalSize > Number.MAX_SAFE_INTEGER) {
+    throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
+  }
+  reader.ref();
+  var eocdrWithoutCommentSize = 22;
+  var zip64EocdlSize = 20;
+  var maxCommentSize = 65535;
+  var bufferSize = Math.min(zip64EocdlSize + eocdrWithoutCommentSize + maxCommentSize, totalSize);
+  var buffer = newBuffer(bufferSize);
+  var bufferReadStart = totalSize - buffer.length;
+  readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
+    if (err)
+      return callback(err);
+    for (var i = bufferSize - eocdrWithoutCommentSize;i >= 0; i -= 1) {
+      if (buffer.readUInt32LE(i) !== 101010256)
+        continue;
+      var eocdrBuffer = buffer.subarray(i);
+      var diskNumber = eocdrBuffer.readUInt16LE(4);
+      var entryCount = eocdrBuffer.readUInt16LE(10);
+      var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
+      var commentLength = eocdrBuffer.readUInt16LE(20);
+      var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
+      if (commentLength !== expectedCommentLength) {
+        return callback(new Error("Invalid comment length. Expected: " + expectedCommentLength + ". Found: " + commentLength + ". Are there extra bytes at the end of the file? Or is the end of central dir signature `PK☺☻` in the comment?"));
+      }
+      var comment = decodeStrings ? decodeBuffer(eocdrBuffer.subarray(22), false) : eocdrBuffer.subarray(22);
+      if (i - zip64EocdlSize >= 0 && buffer.readUInt32LE(i - zip64EocdlSize) === 117853008) {
+        var zip64EocdlBuffer = buffer.subarray(i - zip64EocdlSize, i - zip64EocdlSize + zip64EocdlSize);
+        var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
+        var zip64EocdrBuffer = newBuffer(56);
+        return readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err2) {
+          if (err2)
+            return callback(err2);
+          if (zip64EocdrBuffer.readUInt32LE(0) !== 101075792) {
+            return callback(new Error("invalid zip64 end of central directory record signature"));
+          }
+          diskNumber = zip64EocdrBuffer.readUInt32LE(16);
+          if (diskNumber !== 0) {
+            return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+          }
+          entryCount = readUInt64LE(zip64EocdrBuffer, 32);
+          centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
+          return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options2.autoClose, options2.lazyEntries, decodeStrings, options2.validateEntrySizes, options2.strictFileNames));
+        });
+      }
+      if (diskNumber !== 0) {
+        return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+      }
+      return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options2.autoClose, options2.lazyEntries, decodeStrings, options2.validateEntrySizes, options2.strictFileNames));
+    }
+    callback(new Error("End of central directory record signature not found. Either not a zip file, or file is truncated."));
+  });
+}
+util.inherits(ZipFile, EventEmitter2);
+function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
+  var self = this;
+  EventEmitter2.call(self);
+  self.reader = reader;
+  self.reader.on("error", function(err) {
+    emitError(self, err);
+  });
+  self.reader.once("close", function() {
+    self.emit("close");
+  });
+  self.readEntryCursor = centralDirectoryOffset;
+  self.fileSize = fileSize;
+  self.entryCount = entryCount;
+  self.comment = comment;
+  self.entriesRead = 0;
+  self.autoClose = !!autoClose;
+  self.lazyEntries = !!lazyEntries;
+  self.decodeStrings = !!decodeStrings;
+  self.validateEntrySizes = !!validateEntrySizes;
+  self.strictFileNames = !!strictFileNames;
+  self.isOpen = true;
+  self.emittedError = false;
+  if (!self.lazyEntries)
+    self._readEntry();
+}
+ZipFile.prototype.close = function() {
+  if (!this.isOpen)
+    return;
+  this.isOpen = false;
+  this.reader.unref();
+};
+function emitErrorAndAutoClose(self, err) {
+  if (self.autoClose)
+    self.close();
+  emitError(self, err);
+}
+function emitError(self, err) {
+  if (self.emittedError)
+    return;
+  self.emittedError = true;
+  self.emit("error", err);
+}
+ZipFile.prototype.readEntry = function() {
+  if (!this.lazyEntries)
+    throw new Error("readEntry() called without lazyEntries:true");
+  this._readEntry();
+};
+ZipFile.prototype._readEntry = function() {
+  var self = this;
+  if (self.entryCount === self.entriesRead) {
+    setImmediate(function() {
+      if (self.autoClose)
+        self.close();
+      if (self.emittedError)
+        return;
+      self.emit("end");
+    });
+    return;
+  }
+  if (self.emittedError)
+    return;
+  var buffer = newBuffer(46);
+  readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
+    if (err)
+      return emitErrorAndAutoClose(self, err);
+    if (self.emittedError)
+      return;
+    var entry = new Entry;
+    var signature = buffer.readUInt32LE(0);
+    if (signature !== 33639248)
+      return emitErrorAndAutoClose(self, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
+    entry.versionMadeBy = buffer.readUInt16LE(4);
+    entry.versionNeededToExtract = buffer.readUInt16LE(6);
+    entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
+    entry.compressionMethod = buffer.readUInt16LE(10);
+    entry.lastModFileTime = buffer.readUInt16LE(12);
+    entry.lastModFileDate = buffer.readUInt16LE(14);
+    entry.crc32 = buffer.readUInt32LE(16);
+    entry.compressedSize = buffer.readUInt32LE(20);
+    entry.uncompressedSize = buffer.readUInt32LE(24);
+    entry.fileNameLength = buffer.readUInt16LE(28);
+    entry.extraFieldLength = buffer.readUInt16LE(30);
+    entry.fileCommentLength = buffer.readUInt16LE(32);
+    entry.internalFileAttributes = buffer.readUInt16LE(36);
+    entry.externalFileAttributes = buffer.readUInt32LE(38);
+    entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
+    if (entry.generalPurposeBitFlag & 64)
+      return emitErrorAndAutoClose(self, new Error("strong encryption is not supported"));
+    self.readEntryCursor += 46;
+    buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
+    readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err2) {
+      if (err2)
+        return emitErrorAndAutoClose(self, err2);
+      if (self.emittedError)
+        return;
+      entry.fileNameRaw = buffer.subarray(0, entry.fileNameLength);
+      var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
+      entry.extraFieldRaw = buffer.subarray(entry.fileNameLength, fileCommentStart);
+      entry.fileCommentRaw = buffer.subarray(fileCommentStart, fileCommentStart + entry.fileCommentLength);
+      try {
+        entry.extraFields = parseExtraFields(entry.extraFieldRaw);
+      } catch (err3) {
+        return emitErrorAndAutoClose(self, err3);
+      }
+      if (self.decodeStrings) {
+        var isUtf8 = (entry.generalPurposeBitFlag & 2048) !== 0;
+        entry.fileComment = decodeBuffer(entry.fileCommentRaw, isUtf8);
+        entry.fileName = getFileNameLowLevel(entry.generalPurposeBitFlag, entry.fileNameRaw, entry.extraFields, self.strictFileNames);
+        var errorMessage = validateFileName(entry.fileName);
+        if (errorMessage != null)
+          return emitErrorAndAutoClose(self, new Error(errorMessage));
+      } else {
+        entry.fileComment = entry.fileCommentRaw;
+        entry.fileName = entry.fileNameRaw;
+      }
+      entry.comment = entry.fileComment;
+      self.readEntryCursor += buffer.length;
+      self.entriesRead += 1;
+      for (var i = 0;i < entry.extraFields.length; i++) {
+        var extraField = entry.extraFields[i];
+        if (extraField.id !== 1)
+          continue;
+        var zip64EiefBuffer = extraField.data;
+        var index = 0;
+        if (entry.uncompressedSize === 4294967295) {
+          if (index + 8 > zip64EiefBuffer.length) {
+            return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include uncompressed size"));
+          }
+          entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
+          index += 8;
+        }
+        if (entry.compressedSize === 4294967295) {
+          if (index + 8 > zip64EiefBuffer.length) {
+            return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include compressed size"));
+          }
+          entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
+          index += 8;
+        }
+        if (entry.relativeOffsetOfLocalHeader === 4294967295) {
+          if (index + 8 > zip64EiefBuffer.length) {
+            return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include relative header offset"));
+          }
+          entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
+          index += 8;
+        }
+        break;
+      }
+      if (self.validateEntrySizes && entry.compressionMethod === 0) {
+        var expectedCompressedSize = entry.uncompressedSize;
+        if (entry.isEncrypted()) {
+          expectedCompressedSize += 12;
+        }
+        if (entry.compressedSize !== expectedCompressedSize) {
+          var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
+          return emitErrorAndAutoClose(self, new Error(msg));
+        }
+      }
+      self.emit("entry", entry);
+      if (!self.lazyEntries)
+        self._readEntry();
+    });
+  });
+};
+ZipFile.prototype.openReadStream = function(entry, options2, callback) {
+  var self = this;
+  var relativeStart = 0;
+  var relativeEnd = entry.compressedSize;
+  if (callback == null) {
+    callback = options2;
+    options2 = null;
+  }
+  if (options2 == null) {
+    options2 = {};
+  } else {
+    if (options2.decodeFileData === false) {
+      if (options2.decrypt != null) {
+        throw new Error("cannot use options.decrypt when options.decodeFileData === false");
+      }
+      if (options2.decompress != null) {
+        throw new Error("cannot use options.decompress when options.decodeFileData === false");
+      }
+    } else {
+      if (options2.decrypt != null) {
+        if (!entry.isEncrypted()) {
+          throw new Error("options.decrypt can only be specified for encrypted entries. See also option decodeFileData.");
+        }
+        if (options2.decrypt !== false)
+          throw new Error("invalid options.decrypt value: " + options2.decrypt);
+        if (entry.isCompressed()) {
+          if (options2.decompress !== false)
+            throw new Error("entry is encrypted and compressed, and options.decompress !== false. See also option decodeFileData.");
+        }
+      }
+      if (options2.decompress != null) {
+        if (!entry.isCompressed()) {
+          throw new Error("options.decompress can only be specified for compressed entries. See also option decodeFileData.");
+        }
+        if (!(options2.decompress === false || options2.decompress === true)) {
+          throw new Error("invalid options.decompress value: " + options2.decompress);
+        }
+        decompress = options2.decompress;
+      }
+    }
+    if (options2.start != null) {
+      relativeStart = options2.start;
+      if (relativeStart < 0)
+        throw new Error("options.start < 0");
+      if (relativeStart > entry.compressedSize)
+        throw new Error("options.start > entry.compressedSize");
+    }
+    if (options2.end != null) {
+      relativeEnd = options2.end;
+      if (relativeEnd < 0)
+        throw new Error("options.end < 0");
+      if (relativeEnd > entry.compressedSize)
+        throw new Error("options.end > entry.compressedSize");
+      if (relativeEnd < relativeStart)
+        throw new Error("options.end < options.start");
+    }
+  }
+  var rawMode = options2.decodeFileData === false || (entry.compressionMethod === 0 || entry.compressionMethod === 8 && options2.decompress === false) && (!entry.isEncrypted() || options2.decrypt === false);
+  if (options2.start != null || options2.end != null) {
+    if (!rawMode)
+      throw new Error("start/end range require options.decodeFileData === false for non-trivial encoded entries.");
+  }
+  if (!self.isOpen)
+    return callback(new Error("closed"));
+  if (entry.isEncrypted() && !rawMode) {
+    if (options2.decrypt !== false)
+      return callback(new Error("entry is encrypted, and options.decodeFileData !== false"));
+  }
+  var decompress;
+  if (rawMode) {
+    decompress = false;
+  } else if (entry.compressionMethod === 8) {
+    decompress = options2.decodeFileData !== true;
+  } else {
+    return callback(new Error("unsupported compression method: " + entry.compressionMethod));
+  }
+  self.readLocalFileHeader(entry, { minimal: true }, function(err, localFileHeader) {
+    if (err)
+      return callback(err);
+    self.openReadStreamLowLevel(localFileHeader.fileDataStart, entry.compressedSize, relativeStart, relativeEnd, decompress, entry.uncompressedSize, callback);
+  });
+};
+ZipFile.prototype.openReadStreamLowLevel = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, callback) {
+  var self = this;
+  var fileDataEnd = fileDataStart + compressedSize;
+  var readStream = self.reader.createReadStream({
+    start: fileDataStart + relativeStart,
+    end: fileDataStart + relativeEnd
+  });
+  var endpointStream = readStream;
+  if (decompress) {
+    var destroyed = false;
+    var inflateFilter = zlib.createInflateRaw();
+    readStream.on("error", function(err) {
+      setImmediate(function() {
+        if (!destroyed)
+          inflateFilter.emit("error", err);
+      });
+    });
+    readStream.pipe(inflateFilter);
+    if (self.validateEntrySizes) {
+      endpointStream = new AssertByteCountStream(uncompressedSize);
+      inflateFilter.on("error", function(err) {
+        setImmediate(function() {
+          if (!destroyed)
+            endpointStream.emit("error", err);
+        });
+      });
+      inflateFilter.pipe(endpointStream);
+    } else {
+      endpointStream = inflateFilter;
+    }
+    installDestroyFn(endpointStream, function() {
+      destroyed = true;
+      if (inflateFilter !== endpointStream)
+        inflateFilter.unpipe(endpointStream);
+      readStream.unpipe(inflateFilter);
+      readStream.destroy();
+    });
+  }
+  callback(null, endpointStream);
+};
+ZipFile.prototype.readLocalFileHeader = function(entry, options2, callback) {
+  var self = this;
+  if (callback == null) {
+    callback = options2;
+    options2 = null;
+  }
+  if (options2 == null)
+    options2 = {};
+  self.reader.ref();
+  var buffer = newBuffer(30);
+  readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
+    try {
+      if (err)
+        return callback(err);
+      var signature = buffer.readUInt32LE(0);
+      if (signature !== 67324752) {
+        return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
+      }
+      var fileNameLength = buffer.readUInt16LE(26);
+      var extraFieldLength = buffer.readUInt16LE(28);
+      var fileDataStart = entry.relativeOffsetOfLocalHeader + 30 + fileNameLength + extraFieldLength;
+      if (fileDataStart + entry.compressedSize > self.fileSize) {
+        return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self.fileSize));
+      }
+      if (options2.minimal) {
+        return callback(null, { fileDataStart });
+      }
+      var localFileHeader = new LocalFileHeader;
+      localFileHeader.fileDataStart = fileDataStart;
+      localFileHeader.versionNeededToExtract = buffer.readUInt16LE(4);
+      localFileHeader.generalPurposeBitFlag = buffer.readUInt16LE(6);
+      localFileHeader.compressionMethod = buffer.readUInt16LE(8);
+      localFileHeader.lastModFileTime = buffer.readUInt16LE(10);
+      localFileHeader.lastModFileDate = buffer.readUInt16LE(12);
+      localFileHeader.crc32 = buffer.readUInt32LE(14);
+      localFileHeader.compressedSize = buffer.readUInt32LE(18);
+      localFileHeader.uncompressedSize = buffer.readUInt32LE(22);
+      localFileHeader.fileNameLength = fileNameLength;
+      localFileHeader.extraFieldLength = extraFieldLength;
+      buffer = newBuffer(fileNameLength + extraFieldLength);
+      self.reader.ref();
+      readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader + 30, function(err2) {
+        try {
+          if (err2)
+            return callback(err2);
+          localFileHeader.fileName = buffer.subarray(0, fileNameLength);
+          localFileHeader.extraField = buffer.subarray(fileNameLength);
+          return callback(null, localFileHeader);
+        } finally {
+          self.reader.unref();
+        }
+      });
+    } finally {
+      self.reader.unref();
+    }
+  });
+};
+function Entry() {}
+Entry.prototype.getLastModDate = function(options2) {
+  if (options2 == null)
+    options2 = {};
+  if (!options2.forceDosFormat) {
+    for (var i = 0;i < this.extraFields.length; i++) {
+      var extraField = this.extraFields[i];
+      if (extraField.id === 21589) {
+        var data = extraField.data;
+        if (data.length < 5)
+          continue;
+        var flags = data[0];
+        var HAS_MTIME = 1;
+        if (!(flags & HAS_MTIME))
+          continue;
+        var posixTimestamp = data.readInt32LE(1);
+        return new Date(posixTimestamp * 1000);
+      } else if (extraField.id === 10) {
+        var data = extraField.data;
+        if (data.length !== 32)
+          continue;
+        if (data.readUInt16LE(4) !== 1)
+          continue;
+        if (data.readUInt16LE(6) !== 24)
+          continue;
+        var hundredNanoSecondsSince1601 = data.readUInt32LE(8) + 4294967296 * data.readInt32LE(12);
+        var millisecondsSince1970 = hundredNanoSecondsSince1601 / 1e4 - 11644473600000;
+        return new Date(millisecondsSince1970);
+      }
+    }
+  }
+  return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime, options2.timezone);
+};
+Entry.prototype.canDecodeFileData = function() {
+  return !this.isEncrypted() && (this.compressionMethod === 0 || this.compressionMethod === 8);
+};
+Entry.prototype.isEncrypted = function() {
+  return (this.generalPurposeBitFlag & 1) !== 0;
+};
+Entry.prototype.isCompressed = function() {
+  return this.compressionMethod === 8;
+};
+function LocalFileHeader() {}
+function dosDateTimeToDate(date, time, timezone) {
+  var day = date & 31;
+  var month = (date >> 5 & 15) - 1;
+  var year = (date >> 9 & 127) + 1980;
+  var millisecond = 0;
+  var second = (time & 31) * 2;
+  var minute = time >> 5 & 63;
+  var hour = time >> 11 & 31;
+  if (timezone == null || timezone === "local") {
+    return new Date(year, month, day, hour, minute, second, millisecond);
+  } else if (timezone === "UTC") {
+    return new Date(Date.UTC(year, month, day, hour, minute, second, millisecond));
+  } else {
+    throw new Error("unrecognized options.timezone: " + options.timezone);
+  }
+}
+function getFileNameLowLevel(generalPurposeBitFlag, fileNameBuffer, extraFields, strictFileNames) {
+  var fileName = null;
+  for (var i = 0;i < extraFields.length; i++) {
+    var extraField = extraFields[i];
+    if (extraField.id === 28789) {
+      if (extraField.data.length < 6) {
+        continue;
+      }
+      if (extraField.data.readUInt8(0) !== 1) {
+        continue;
+      }
+      var oldNameCrc32 = extraField.data.readUInt32LE(1);
+      if (crc32.unsigned(fileNameBuffer) !== oldNameCrc32) {
+        continue;
+      }
+      fileName = decodeBuffer(extraField.data.subarray(5), true);
+      break;
+    }
+  }
+  if (fileName == null) {
+    var isUtf8 = (generalPurposeBitFlag & 2048) !== 0;
+    fileName = decodeBuffer(fileNameBuffer, isUtf8);
+  }
+  if (!strictFileNames) {
+    fileName = fileName.replace(/\\/g, "/");
+  }
+  return fileName;
+}
+function validateFileName(fileName) {
+  if (fileName.indexOf("\\") !== -1) {
+    return "invalid characters in fileName: " + fileName;
+  }
+  if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
+    return "absolute path: " + fileName;
+  }
+  if (fileName.split("/").indexOf("..") !== -1) {
+    return "invalid relative path: " + fileName;
+  }
+  return null;
+}
+function parseExtraFields(extraFieldBuffer) {
+  var extraFields = [];
+  var i = 0;
+  while (i < extraFieldBuffer.length - 3) {
+    var headerId = extraFieldBuffer.readUInt16LE(i + 0);
+    var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
+    var dataStart = i + 4;
+    var dataEnd = dataStart + dataSize;
+    if (dataEnd > extraFieldBuffer.length)
+      throw new Error("extra field length exceeds extra field buffer size");
+    var dataBuffer = extraFieldBuffer.subarray(dataStart, dataEnd);
+    extraFields.push({
+      id: headerId,
+      data: dataBuffer
+    });
+    i = dataEnd;
+  }
+  return extraFields;
+}
+function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
+  if (length === 0) {
+    return setImmediate(function() {
+      callback(null, newBuffer(0));
+    });
+  }
+  reader.read(buffer, offset, length, position, function(err, bytesRead) {
+    if (err)
+      return callback(err);
+    if (bytesRead < length) {
+      return callback(new Error("unexpected EOF"));
+    }
+    callback();
+  });
+}
+util.inherits(AssertByteCountStream, Transform);
+function AssertByteCountStream(byteCount) {
+  Transform.call(this);
+  this.actualByteCount = 0;
+  this.expectedByteCount = byteCount;
+}
+AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
+  this.actualByteCount += chunk.length;
+  if (this.actualByteCount > this.expectedByteCount) {
+    var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
+    return cb(new Error(msg));
+  }
+  cb(null, chunk);
+};
+AssertByteCountStream.prototype._flush = function(cb) {
+  if (this.actualByteCount < this.expectedByteCount) {
+    var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
+    return cb(new Error(msg));
+  }
+  cb();
+};
+util.inherits(RandomAccessReader, EventEmitter2);
+function RandomAccessReader() {
+  EventEmitter2.call(this);
+  this.refCount = 0;
+}
+RandomAccessReader.prototype.ref = function() {
+  this.refCount += 1;
+};
+RandomAccessReader.prototype.unref = function() {
+  var self = this;
+  self.refCount -= 1;
+  if (self.refCount > 0)
+    return;
+  if (self.refCount < 0)
+    throw new Error("invalid unref");
+  self.close(onCloseDone);
+  function onCloseDone(err) {
+    if (err)
+      return self.emit("error", err);
+    self.emit("close");
+  }
+};
+RandomAccessReader.prototype.createReadStream = function(options2) {
+  if (options2 == null)
+    options2 = {};
+  var start = options2.start;
+  var end = options2.end;
+  if (start === end) {
+    var emptyStream = new PassThrough;
+    setImmediate(function() {
+      emptyStream.end();
+    });
+    return emptyStream;
+  }
+  var stream = this._readStreamForRange(start, end);
+  var destroyed = false;
+  var refUnrefFilter = new RefUnrefFilter(this);
+  stream.on("error", function(err) {
+    setImmediate(function() {
+      if (!destroyed)
+        refUnrefFilter.emit("error", err);
+    });
+  });
+  installDestroyFn(refUnrefFilter, function() {
+    stream.unpipe(refUnrefFilter);
+    refUnrefFilter.unref();
+    stream.destroy();
+  });
+  var byteCounter = new AssertByteCountStream(end - start);
+  refUnrefFilter.on("error", function(err) {
+    setImmediate(function() {
+      if (!destroyed)
+        byteCounter.emit("error", err);
+    });
+  });
+  installDestroyFn(byteCounter, function() {
+    destroyed = true;
+    refUnrefFilter.unpipe(byteCounter);
+    refUnrefFilter.destroy();
+  });
+  return stream.pipe(refUnrefFilter).pipe(byteCounter);
+};
+RandomAccessReader.prototype._readStreamForRange = function(start, end) {
+  throw new Error("not implemented");
+};
+RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
+  var readStream = this.createReadStream({ start: position, end: position + length });
+  var writeStream = new Writable;
+  var written = 0;
+  writeStream._write = function(chunk, encoding, cb) {
+    chunk.copy(buffer, offset + written, 0, chunk.length);
+    written += chunk.length;
+    cb();
+  };
+  writeStream.on("finish", callback);
+  readStream.on("error", function(error) {
+    callback(error);
+  });
+  readStream.pipe(writeStream);
+};
+RandomAccessReader.prototype.close = function(callback) {
+  setImmediate(callback);
+};
+util.inherits(RefUnrefFilter, PassThrough);
+function RefUnrefFilter(context) {
+  PassThrough.call(this);
+  this.context = context;
+  this.context.ref();
+  this.unreffedYet = false;
+}
+RefUnrefFilter.prototype._flush = function(cb) {
+  this.unref();
+  cb();
+};
+RefUnrefFilter.prototype.unref = function(cb) {
+  if (this.unreffedYet)
+    return;
+  this.unreffedYet = true;
+  this.context.unref();
+};
+var cp437 = "\x00☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ";
+function decodeBuffer(buffer, isUtf8) {
+  if (isUtf8) {
+    return buffer.toString("utf8");
+  } else {
+    var result = "";
+    for (var i = 0;i < buffer.length; i++) {
+      result += cp437[buffer[i]];
+    }
+    return result;
+  }
+}
+function readUInt64LE(buffer, offset) {
+  var lower32 = buffer.readUInt32LE(offset);
+  var upper32 = buffer.readUInt32LE(offset + 4);
+  return upper32 * 4294967296 + lower32;
+}
+var newBuffer;
+if (typeof Buffer.allocUnsafe === "function") {
+  newBuffer = function(len) {
+    return Buffer.allocUnsafe(len);
+  };
+} else {
+  newBuffer = function(len) {
+    return new Buffer(len);
+  };
+}
+function installDestroyFn(stream, fn) {
+  if (typeof stream.destroy === "function") {
+    stream._destroy = function(err, cb) {
+      fn();
+      if (cb != null)
+        cb(err);
+    };
+  } else {
+    stream.destroy = fn;
+  }
+}
+function defaultCallback(err) {
+  if (err)
+    throw err;
+}
+
+// src/browser/extract-zip-archive.ts
+var openZip = promisify($open);
+var openReadStream = (zipfile, entry) => {
+  return new Promise((resolve, reject) => {
+    zipfile.openReadStream(entry, (err, readStream) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      if (!readStream) {
+        reject(new Error("Failed to open zip read stream"));
+        return;
+      }
+      resolve(readStream);
+    });
+  });
+};
+var getExtractedMode = (entryMode, isDir) => {
+  if (entryMode !== 0) {
+    return entryMode;
+  }
+  return isDir ? 493 : 420;
+};
+var extractEntry = async ({
+  entry,
+  zipfile,
+  dir
+}) => {
+  if (entry.fileName.startsWith("__MACOSX/")) {
+    return;
+  }
+  const dest = path7.join(dir, entry.fileName);
+  const destDir = path7.dirname(dest);
+  await mkdir(destDir, { recursive: true });
+  const canonicalDestDir = await realpath(destDir);
+  const relativeDestDir = path7.relative(dir, canonicalDestDir);
+  if (relativeDestDir.split(path7.sep).includes("..")) {
+    throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
+  }
+  const mode = entry.externalFileAttributes >> 16 & 65535;
+  const IFMT = 61440;
+  const IFDIR = 16384;
+  const IFLNK = 40960;
+  const symlinkEntry = (mode & IFMT) === IFLNK;
+  let isDir = (mode & IFMT) === IFDIR;
+  if (!isDir && entry.fileName.endsWith("/")) {
+    isDir = true;
+  }
+  const madeBy = entry.versionMadeBy >> 8;
+  if (!isDir && madeBy === 0 && entry.externalFileAttributes === 16) {
+    isDir = true;
+  }
+  const procMode = getExtractedMode(mode, isDir) & 511;
+  const destDirectory = isDir ? dest : path7.dirname(dest);
+  await mkdir(destDirectory, {
+    recursive: true,
+    mode: isDir ? procMode : undefined
+  });
+  if (isDir) {
+    return;
+  }
+  const readStream = await openReadStream(zipfile, entry);
+  if (symlinkEntry) {
+    const link = (await buffer(readStream)).toString();
+    await symlink(link, dest);
+    return;
+  }
+  await pipeline(readStream, createWriteStream2(dest, { mode: procMode }));
+};
+var extractZipArchive = async (archivePath, dir) => {
+  if (!path7.isAbsolute(dir)) {
+    throw new Error("Target directory is expected to be absolute");
+  }
+  await mkdir(dir, { recursive: true });
+  const resolvedDir = await realpath(dir);
+  const zipfile = await openZip(archivePath, { lazyEntries: true });
+  return new Promise((resolve, reject) => {
+    let canceled = false;
+    const cancel = (err) => {
+      if (canceled) {
+        return;
+      }
+      canceled = true;
+      zipfile.close();
+      reject(err);
+    };
+    zipfile.on("error", cancel);
+    zipfile.on("close", () => {
+      if (!canceled) {
+        resolve();
+      }
+    });
+    zipfile.on("entry", (entry) => {
+      if (canceled) {
+        return;
+      }
+      extractEntry({ entry, zipfile, dir: resolvedDir }).then(() => {
+        zipfile.readEntry();
+      }).catch(cancel);
+    });
+    zipfile.readEntry();
+  });
+};
 
 // src/browser/get-chrome-download-url.ts
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 import * as os3 from "node:os";
 var TESTED_VERSION = "149.0.7790.0";
 var PLAYWRIGHT_VERSION = "1421";
@@ -4845,7 +6390,7 @@ var isAmazonLinux2023 = () => {
     return false;
   }
   try {
-    const osRelease = fs5.readFileSync("/etc/os-release", "utf-8");
+    const osRelease = fs6.readFileSync("/etc/os-release", "utf-8");
     return osRelease.includes("Amazon Linux") && osRelease.includes('VERSION="2023"');
   } catch {
     return false;
@@ -4938,18 +6483,18 @@ var logDownloadUrl = ({
 };
 
 // src/browser/get-download-destination.ts
-import fs6 from "node:fs";
-import path7 from "node:path";
+import fs7 from "node:fs";
+import path8 from "node:path";
 var getDownloadsCacheDir = () => {
   const cwd = process.cwd();
   let dir = cwd;
   for (;; ) {
     try {
-      if (fs6.statSync(path7.join(dir, "package.json")).isFile()) {
+      if (fs7.statSync(path8.join(dir, "package.json")).isFile()) {
         break;
       }
     } catch (e) {}
-    const parent = path7.dirname(dir);
+    const parent = path8.dirname(dir);
     if (dir === parent) {
       dir = undefined;
       break;
@@ -4957,23 +6502,23 @@ var getDownloadsCacheDir = () => {
     dir = parent;
   }
   if (!dir) {
-    return path7.resolve(cwd, ".remotion");
+    return path8.resolve(cwd, ".remotion");
   }
   if (process.versions.pnp === "1") {
-    return path7.resolve(dir, ".pnp/.remotion");
+    return path8.resolve(dir, ".pnp/.remotion");
   }
   if (process.versions.pnp === "3") {
-    return path7.resolve(dir, ".yarn/.remotion");
+    return path8.resolve(dir, ".yarn/.remotion");
   }
-  return path7.resolve(dir, "node_modules/.remotion");
+  return path8.resolve(dir, "node_modules/.remotion");
 };
 
 // src/browser/BrowserFetcher.ts
-var mkdirAsync = fs7.promises.mkdir;
-var unlinkAsync = promisify(fs7.unlink.bind(fs7));
+var mkdirAsync = fs8.promises.mkdir;
+var unlinkAsync = promisify2(fs8.unlink.bind(fs8));
 function existsAsync(filePath) {
   return new Promise((resolve2) => {
-    fs7.access(filePath, (err) => {
+    fs8.access(filePath, (err) => {
       return resolve2(!err);
     });
   });
@@ -4993,11 +6538,11 @@ var getPlatform = () => {
 };
 var getDownloadsFolder = (chromeMode) => {
   const destination = chromeMode === "headless-shell" ? "chrome-headless-shell" : "chrome-for-testing";
-  return path8.join(getDownloadsCacheDir(), destination);
+  return path9.join(getDownloadsCacheDir(), destination);
 };
 var getVersionFilePath = (chromeMode) => {
   const downloadsFolder = getDownloadsFolder(chromeMode);
-  return path8.join(downloadsFolder, "VERSION");
+  return path9.join(downloadsFolder, "VERSION");
 };
 var getExpectedVersion = (version, _chromeMode) => {
   if (version) {
@@ -5008,14 +6553,14 @@ var getExpectedVersion = (version, _chromeMode) => {
 var readVersionFile = (chromeMode) => {
   const versionFilePath = getVersionFilePath(chromeMode);
   try {
-    return fs7.readFileSync(versionFilePath, "utf-8").trim();
+    return fs8.readFileSync(versionFilePath, "utf-8").trim();
   } catch {
     return null;
   }
 };
 var writeVersionFile = (chromeMode, version) => {
   const versionFilePath = getVersionFilePath(chromeMode);
-  fs7.writeFileSync(versionFilePath, version);
+  fs8.writeFileSync(versionFilePath, version);
 };
 var downloadBrowser = async ({
   logLevel,
@@ -5031,7 +6576,7 @@ var downloadBrowser = async ({
     throw new Error(`A malformed download URL was found: ${downloadURL}.`);
   }
   const downloadsFolder = getDownloadsFolder(chromeMode);
-  const archivePath = path8.join(downloadsFolder, fileName);
+  const archivePath = path9.join(downloadsFolder, fileName);
   const outputPath = getFolderPath(downloadsFolder, platform3);
   const expectedVersion = getExpectedVersion(version, chromeMode);
   if (await existsAsync(outputPath)) {
@@ -5039,7 +6584,7 @@ var downloadBrowser = async ({
     if (installedVersion === expectedVersion) {
       return getRevisionInfo(chromeMode);
     }
-    fs7.rmSync(outputPath, { recursive: true, force: true });
+    fs8.rmSync(outputPath, { recursive: true, force: true });
   }
   if (!await existsAsync(downloadsFolder)) {
     await mkdirAsync(downloadsFolder, {
@@ -5072,7 +6617,7 @@ var downloadBrowser = async ({
       logLevel,
       abortSignal: new AbortController().signal
     });
-    await extractZip(archivePath, { dir: outputPath });
+    await extractZipArchive(archivePath, outputPath);
     const possibleSubdirs = [
       "chrome-linux",
       "chrome-headless-shell-linux64",
@@ -5080,16 +6625,16 @@ var downloadBrowser = async ({
       "chromium-headless-shell-amazon-linux2023-x64"
     ];
     for (const subdir of possibleSubdirs) {
-      const chromeLinuxFolder = path8.join(outputPath, subdir);
-      const chromePath = path8.join(chromeLinuxFolder, "chrome");
-      if (fs7.existsSync(chromePath)) {
-        const chromeHeadlessShellPath = path8.join(chromeLinuxFolder, "chrome-headless-shell");
-        fs7.renameSync(chromePath, chromeHeadlessShellPath);
+      const chromeLinuxFolder = path9.join(outputPath, subdir);
+      const chromePath = path9.join(chromeLinuxFolder, "chrome");
+      if (fs8.existsSync(chromePath)) {
+        const chromeHeadlessShellPath = path9.join(chromeLinuxFolder, "chrome-headless-shell");
+        fs8.renameSync(chromePath, chromeHeadlessShellPath);
       }
-      if (fs7.existsSync(chromeLinuxFolder)) {
-        const targetFolder = path8.join(outputPath, "chrome-headless-shell-" + platform3);
+      if (fs8.existsSync(chromeLinuxFolder)) {
+        const targetFolder = path9.join(outputPath, "chrome-headless-shell-" + platform3);
         if (chromeLinuxFolder !== targetFolder) {
-          fs7.renameSync(chromeLinuxFolder, targetFolder);
+          fs8.renameSync(chromeLinuxFolder, targetFolder);
         }
       }
     }
@@ -5106,7 +6651,7 @@ var downloadBrowser = async ({
   return revisionInfo;
 };
 var getFolderPath = (downloadsFolder, platform3) => {
-  return path8.resolve(downloadsFolder, platform3);
+  return path9.resolve(downloadsFolder, platform3);
 };
 var getExecutablePath2 = (chromeMode) => {
   const downloadsFolder = getDownloadsFolder(chromeMode);
@@ -5114,18 +6659,18 @@ var getExecutablePath2 = (chromeMode) => {
   const folderPath = getFolderPath(downloadsFolder, platform3);
   if (chromeMode === "chrome-for-testing") {
     if (platform3 === "mac-arm64" || platform3 === "mac-x64") {
-      return path8.join(folderPath, `chrome-${platform3}`, "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing");
+      return path9.join(folderPath, `chrome-${platform3}`, "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing");
     }
     if (platform3 === "win64") {
-      return path8.join(folderPath, "chrome-win64", "chrome.exe");
+      return path9.join(folderPath, "chrome-win64", "chrome.exe");
     }
     if (platform3 === "linux64" || platform3 === "linux-arm64") {
-      return path8.join(folderPath, "chrome-linux64", "chrome");
+      return path9.join(folderPath, "chrome-linux64", "chrome");
     }
     throw new Error("unsupported platform" + platform3);
   }
   if (chromeMode === "headless-shell") {
-    return path8.join(folderPath, `chrome-headless-shell-${platform3}`, platform3 === "win64" ? "chrome-headless-shell.exe" : platform3 === "linux-arm64" || isAmazonLinux2023() ? "headless_shell" : "chrome-headless-shell");
+    return path9.join(folderPath, `chrome-headless-shell-${platform3}`, platform3 === "win64" ? "chrome-headless-shell.exe" : platform3 === "linux-arm64" || isAmazonLinux2023() ? "headless_shell" : "chrome-headless-shell");
   }
   throw new Error("unsupported chrome mode" + chromeMode);
 };
@@ -5135,7 +6680,7 @@ var getRevisionInfo = (chromeMode) => {
   const platform3 = getPlatform();
   const folderPath = getFolderPath(downloadsFolder, platform3);
   const url = getChromeDownloadUrl({ platform: platform3, version: null, chromeMode });
-  const local = fs7.existsSync(folderPath);
+  const local = fs8.existsSync(folderPath);
   return {
     executablePath,
     folderPath,
@@ -5165,8 +6710,8 @@ var internalEnsureBrowserUncapped = async ({
   const newStatus = getBrowserStatus({ browserExecutable, chromeMode });
   return newStatus;
 };
-var internalEnsureBrowser = (options) => {
-  currentEnsureBrowserOperation = currentEnsureBrowserOperation.then(() => internalEnsureBrowserUncapped(options));
+var internalEnsureBrowser = (options2) => {
+  currentEnsureBrowserOperation = currentEnsureBrowserOperation.then(() => internalEnsureBrowserUncapped(options2));
   return currentEnsureBrowserOperation;
 };
 var getBrowserStatus = ({
@@ -5174,13 +6719,13 @@ var getBrowserStatus = ({
   chromeMode
 }) => {
   if (browserExecutable) {
-    if (!fs8.existsSync(browserExecutable)) {
+    if (!fs9.existsSync(browserExecutable)) {
       throw new Error(`"browserExecutable" was specified as '${browserExecutable}' but the path doesn't exist. Pass "null" for "browserExecutable" to download a browser automatically.`);
     }
     return { path: browserExecutable, type: "user-defined-path" };
   }
   const revision = getRevisionInfo(chromeMode);
-  if (revision.local && fs8.existsSync(revision.executablePath)) {
+  if (revision.local && fs9.existsSync(revision.executablePath)) {
     const actualVersion = readVersionFile(chromeMode);
     if (actualVersion === TESTED_VERSION) {
       return { path: revision.executablePath, type: "local-puppeteer-browser" };
@@ -5189,24 +6734,24 @@ var getBrowserStatus = ({
   }
   return { type: "no-browser" };
 };
-var ensureBrowser = (options) => {
+var ensureBrowser = (options2) => {
   const indent = false;
-  const logLevel = options?.logLevel ?? "info";
+  const logLevel = options2?.logLevel ?? "info";
   return internalEnsureBrowser({
-    browserExecutable: options?.browserExecutable ?? null,
+    browserExecutable: options2?.browserExecutable ?? null,
     indent,
-    logLevel: options?.logLevel ?? "info",
-    onBrowserDownload: options?.onBrowserDownload ?? defaultBrowserDownloadProgress({
+    logLevel: options2?.logLevel ?? "info",
+    onBrowserDownload: options2?.onBrowserDownload ?? defaultBrowserDownloadProgress({
       api: "ensureBrowser()",
       indent: false,
       logLevel
     }),
-    chromeMode: options?.chromeMode ?? "headless-shell"
+    chromeMode: options2?.chromeMode ?? "headless-shell"
   });
 };
 
 // src/get-local-browser-executable.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 var getBrowserStatus2 = ({
   browserExecutablePath,
   indent,
@@ -5214,13 +6759,13 @@ var getBrowserStatus2 = ({
   chromeMode
 }) => {
   if (browserExecutablePath) {
-    if (!fs9.existsSync(browserExecutablePath)) {
+    if (!fs10.existsSync(browserExecutablePath)) {
       Log.warn({ indent, logLevel }, `Browser executable was specified as '${browserExecutablePath}' but the path doesn't exist.`);
     }
     return { path: browserExecutablePath, type: "user-defined-path" };
   }
   const revision = getRevisionInfo(chromeMode);
-  if (revision.local && fs9.existsSync(revision.executablePath)) {
+  if (revision.local && fs10.existsSync(revision.executablePath)) {
     return { path: revision.executablePath, type: "local-puppeteer-browser" };
   }
   return { type: "no-browser" };
@@ -5518,7 +7063,7 @@ var internalOpenBrowser = async ({
   if (chromiumOptions.userAgent) {
     Log.verbose({ indent, logLevel, tag: "openBrowser()" }, `Using custom user agent: ${chromiumOptions.userAgent}`);
   }
-  const userDataDir = await fs10.promises.mkdtemp(path9.join(os6.tmpdir(), "puppeteer_dev_chrome_profile-"));
+  const userDataDir = await fs11.promises.mkdtemp(path10.join(os6.tmpdir(), "puppeteer_dev_chrome_profile-"));
   const browserInstance = await launchChrome({
     executablePath,
     logLevel,
@@ -5597,10 +7142,10 @@ var internalOpenBrowser = async ({
   await pages[0]?.close();
   return browserInstance;
 };
-var openBrowser = (browser, options) => {
-  const { browserExecutable, chromiumOptions, forceDeviceScaleFactor } = options ?? {};
+var openBrowser = (browser, options2) => {
+  const { browserExecutable, chromiumOptions, forceDeviceScaleFactor } = options2 ?? {};
   const indent = false;
-  const logLevel = options?.logLevel ?? (options?.shouldDumpIo ? "verbose" : "info");
+  const logLevel = options2?.logLevel ?? (options2?.shouldDumpIo ? "verbose" : "info");
   return internalOpenBrowser({
     browser,
     browserExecutable: browserExecutable ?? null,
@@ -5614,7 +7159,7 @@ var openBrowser = (browser, options) => {
       logLevel,
       api: "openBrowser()"
     }),
-    chromeMode: options?.chromeMode ?? "headless-shell"
+    chromeMode: options2?.chromeMode ?? "headless-shell"
   });
 };
 
@@ -5691,12 +7236,12 @@ var DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS = 2;
 
 // src/prepare-server.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 import { NoReactInternals as NoReactInternals7 } from "remotion/no-react";
 
 // src/assets/download-and-map-assets-to-file.ts
-import fs11 from "node:fs";
-import path11, { extname as extname2 } from "node:path";
+import fs12 from "node:fs";
+import path12, { extname as extname2 } from "node:path";
 import { random } from "remotion/no-react";
 
 // src/compress-assets.ts
@@ -14362,11 +15907,11 @@ populateMaps(extensions, {});
 var getExt = (contentType) => {
   return mimeDb[contentType.toLowerCase()]?.extensions?.[0] ?? null;
 };
-function mimeLookup(path10) {
-  if (!path10 || typeof path10 !== "string") {
+function mimeLookup(path11) {
+  if (!path11 || typeof path11 !== "string") {
     return false;
   }
-  const ext = extname("." + path10).toLowerCase().substr(1);
+  const ext = extname("." + path11).toLowerCase().substr(1);
   if (!ext) {
     return false;
   }
@@ -14565,7 +16110,7 @@ var getAudioChannelsAndDuration = ({
 };
 
 // src/assets/sanitize-filepath.ts
-import path10 from "node:path";
+import path11 from "node:path";
 
 // src/assets/truncate-utf8-bytes.ts
 function isHighSurrogate(codePoint) {
@@ -14626,7 +16171,7 @@ var sanitizeFilename = (input) => {
 // src/assets/sanitize-filepath.ts
 var pathSeparators = /[/\\]/;
 var sanitizeFilePath = (pathToSanitize) => {
-  return pathToSanitize.split(pathSeparators).map((s) => sanitizeFilename(s)).join(path10.sep);
+  return pathToSanitize.split(pathSeparators).map((s) => sanitizeFilename(s)).join(path11.sep);
 };
 
 // src/assets/download-and-map-assets-to-file.ts
@@ -14731,7 +16276,7 @@ var downloadAsset = async ({
   const { downloadDir } = downloadMap;
   if (downloadMap.hasBeenDownloadedMap[src]?.[downloadDir]) {
     const claimedDownloadLocation = downloadMap.hasBeenDownloadedMap[src]?.[downloadDir];
-    if (fs11.existsSync(claimedDownloadLocation)) {
+    if (fs12.existsSync(claimedDownloadLocation)) {
       return claimedDownloadLocation;
     }
     downloadMap.hasBeenDownloadedMap[src][downloadDir] = null;
@@ -14770,7 +16315,7 @@ var downloadAsset = async ({
     });
     ensureOutputDirectory(output);
     const buff = Buffer.from(assetData, encoding);
-    await fs11.promises.writeFile(output, buff);
+    await fs12.promises.writeFile(output, buff);
     notifyAssetIsDownloaded({ src, downloadMap, downloadDir, to: output });
     return output;
   }
@@ -14858,7 +16403,7 @@ var getSanitizedFilenameForAssetUrl = ({
   const fileExtension = split.length > 1 && split[split.length - 1] ? `.${split[split.length - 1]}` : "";
   const hashedFileName = String(random(`${src}${pathname}${search}`)).replace("0.", "");
   const filename = hashedFileName + fileExtension;
-  return path11.join(downloadDir, sanitizeFilePath(filename));
+  return path12.join(downloadDir, sanitizeFilePath(filename));
 };
 var downloadAndMapAssetsToFileUrl = async ({
   renderAsset,
@@ -14927,7 +16472,7 @@ var attachDownloadListenerToEmitter = (downloadMap, onDownload) => {
 
 // src/assets/download-map.ts
 import { mkdirSync as mkdirSync2 } from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 import { VERSION as VERSION2 } from "remotion/version";
 
 // src/offthread-video-server.ts
@@ -14935,7 +16480,7 @@ import { URLSearchParams } from "node:url";
 
 // src/compositor/compositor.ts
 import { spawn as spawn3 } from "node:child_process";
-import path12 from "node:path";
+import path13 from "node:path";
 import { makeStreamer } from "@remotion/streaming";
 
 // src/compositor/make-nonce.ts
@@ -14989,7 +16534,7 @@ var startCompositor = ({
   });
   makeFileExecutableIfItIsNot(bin);
   const fullCommand = serializeCommand(type, payload);
-  const cwd = path12.dirname(bin);
+  const cwd = path13.dirname(bin);
   const jsonArg = JSON.stringify(fullCommand);
   const launch = wrapExecutableWithSetprivIfAvailable({
     executablePath: bin,
@@ -15356,9 +16901,9 @@ class OffthreadVideoServerEmitter {
 }
 
 // src/tmp-dir.ts
-import fs12, { mkdirSync } from "node:fs";
+import fs13, { mkdirSync } from "node:fs";
 import os7 from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 var alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
 var randomHash = () => {
   return new Array(10).fill(1).map(() => {
@@ -15366,9 +16911,9 @@ var randomHash = () => {
   }).join("");
 };
 var tmpDir = (str) => {
-  const newDir = path13.join(os7.tmpdir(), str + randomHash());
-  if (fs12.existsSync(newDir)) {
-    fs12.rmSync(newDir, {
+  const newDir = path14.join(os7.tmpdir(), str + randomHash());
+  if (fs13.existsSync(newDir)) {
+    fs13.rmSync(newDir, {
       recursive: true,
       force: true
     });
@@ -15378,8 +16923,8 @@ var tmpDir = (str) => {
 };
 
 // src/assets/inline-audio-mixing.ts
-import fs13, { writeSync } from "node:fs";
-import path14 from "node:path";
+import fs14, { writeSync } from "node:fs";
+import path15 from "node:path";
 
 // src/assets/apply-tone-frequency.ts
 var applyToneFrequencyUsingFfmpeg = async ({
@@ -15449,7 +16994,7 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
   const cleanup = () => {
     for (const fileName of Object.keys(openFiles)) {
       try {
-        fs13.closeSync(openFiles[fileName]);
+        fs14.closeSync(openFiles[fileName]);
         delete openFiles[fileName];
       } catch {}
     }
@@ -15459,7 +17004,7 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
     return Object.keys(openFiles);
   };
   const getFilePath = (asset) => {
-    return path14.join(folderToAdd, `${asset.id}.wav`);
+    return path15.join(folderToAdd, `${asset.id}.wav`);
   };
   const ensureAsset = ({
     asset,
@@ -15470,7 +17015,7 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
   }) => {
     const filePath = getFilePath(asset);
     if (!openFiles[filePath]) {
-      openFiles[filePath] = fs13.openSync(filePath, "w");
+      openFiles[filePath] = fs14.openSync(filePath, "w");
     }
     if (writtenHeaders[filePath]) {
       return;
@@ -15517,9 +17062,9 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
         sampleRate: finishSampleRate
       });
       try {
-        fs13.closeSync(openFiles[fileName]);
+        fs14.closeSync(openFiles[fileName]);
       } catch {}
-      fs13.renameSync(tmpFile, fileName);
+      fs14.renameSync(tmpFile, fileName);
     }
   };
   const addAsset = ({
@@ -15568,7 +17113,7 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
 
 // src/assets/download-map.ts
 var makeAndReturn = (dir, name) => {
-  const p = path15.join(dir, name);
+  const p = path16.join(dir, name);
   mkdirSync2(p);
   return p;
 };
@@ -15617,7 +17162,7 @@ var cleanDownloadMap = (downloadMap) => {
 };
 
 // src/get-bundle-url-from-serve-url.ts
-import path16 from "path";
+import path17 from "path";
 import { NoReactInternals as NoReactInternals6 } from "remotion/no-react";
 var map = (webpackBundleOrServeUrl, suffix) => {
   if (isServeUrl(webpackBundleOrServeUrl)) {
@@ -15628,7 +17173,7 @@ var map = (webpackBundleOrServeUrl, suffix) => {
     }
     return parsed.origin + parsed.pathname.substring(0, idx + 1) + suffix;
   }
-  const index = webpackBundleOrServeUrl.lastIndexOf(path16.sep);
+  const index = webpackBundleOrServeUrl.lastIndexOf(path17.sep);
   const url = webpackBundleOrServeUrl.substring(0, index + 1) + suffix;
   return url;
 };
@@ -15877,10 +17422,10 @@ var hasIpv4LoopbackAddress = (flattened) => {
 
 // src/serve-handler/index.ts
 import { createReadStream, promises as promises2 } from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 
 // src/serve-handler/is-path-inside.ts
-import path17 from "node:path";
+import path18 from "node:path";
 var isPathInside = function(thePath, potentialParent) {
   thePath = stripTrailingSep(thePath);
   potentialParent = stripTrailingSep(potentialParent);
@@ -15888,10 +17433,10 @@ var isPathInside = function(thePath, potentialParent) {
     thePath = thePath.toLowerCase();
     potentialParent = potentialParent.toLowerCase();
   }
-  return thePath.lastIndexOf(potentialParent, 0) === 0 && (thePath[potentialParent.length] === path17.sep || thePath[potentialParent.length] === undefined);
+  return thePath.lastIndexOf(potentialParent, 0) === 0 && (thePath[potentialParent.length] === path18.sep || thePath[potentialParent.length] === undefined);
 };
 function stripTrailingSep(thePath) {
-  if (thePath[thePath.length - 1] === path17.sep) {
+  if (thePath[thePath.length - 1] === path18.sep) {
     return thePath.slice(0, -1);
   }
   return thePath;
@@ -15944,7 +17489,7 @@ var rangeParser = (size, str) => {
 
 // src/serve-handler/index.ts
 var getHeaders = (absolutePath, stats) => {
-  const { base } = path18.parse(absolutePath);
+  const { base } = path19.parse(absolutePath);
   let defaultHeaders = {};
   if (stats) {
     defaultHeaders = {
@@ -15960,15 +17505,15 @@ var getHeaders = (absolutePath, stats) => {
   return defaultHeaders;
 };
 var getPossiblePaths = (relativePath, extension) => [
-  path18.join(relativePath, `index${extension}`),
+  path19.join(relativePath, `index${extension}`),
   relativePath.endsWith("/") ? relativePath.replace(/\/$/g, extension) : relativePath + extension
-].filter((item) => path18.basename(item) !== extension);
+].filter((item) => path19.basename(item) !== extension);
 var findRelated = async (current, relativePath) => {
   const possible = getPossiblePaths(relativePath, ".html");
   let stats = null;
   for (let index = 0;index < possible.length; index++) {
     const related = possible[index];
-    const absolutePath = path18.join(current, related);
+    const absolutePath = path19.join(current, related);
     try {
       stats = await promises2.lstat(absolutePath);
     } catch (err) {
@@ -16003,7 +17548,7 @@ var internalError = (absolutePath, response) => {
 };
 var serveHandler = async (request, response, config) => {
   const cwd = process.cwd();
-  const current = path18.resolve(cwd, config.public);
+  const current = path19.resolve(cwd, config.public);
   let relativePath = null;
   try {
     const parsedUrl = new URL(request.url, `http://${request.headers.host}`);
@@ -16015,7 +17560,7 @@ var serveHandler = async (request, response, config) => {
       message: "Bad Request"
     });
   }
-  let absolutePath = path18.join(current, relativePath);
+  let absolutePath = path19.join(current, relativePath);
   if (!isPathInside(absolutePath, current)) {
     return sendError(absolutePath, response, {
       statusCode: 400,
@@ -16024,7 +17569,7 @@ var serveHandler = async (request, response, config) => {
     });
   }
   let stats = null;
-  if (path18.extname(relativePath) !== "") {
+  if (path19.extname(relativePath) !== "") {
     try {
       stats = await promises2.lstat(absolutePath);
     } catch (err) {
@@ -16107,31 +17652,31 @@ var serveHandler = async (request, response, config) => {
 };
 
 // src/serve-static.ts
-var serveStatic = async (path19, options) => {
+var serveStatic = async (path20, options2) => {
   const {
     listener: offthreadRequest,
     close: closeCompositor,
     compositor
   } = startOffthreadVideoServer({
-    downloadMap: options.downloadMap,
-    offthreadVideoThreads: options.offthreadVideoThreads,
-    logLevel: options.logLevel,
-    indent: options.indent,
-    offthreadVideoCacheSizeInBytes: options.offthreadVideoCacheSizeInBytes,
-    binariesDirectory: options.binariesDirectory
+    downloadMap: options2.downloadMap,
+    offthreadVideoThreads: options2.offthreadVideoThreads,
+    logLevel: options2.logLevel,
+    indent: options2.indent,
+    offthreadVideoCacheSizeInBytes: options2.offthreadVideoCacheSizeInBytes,
+    binariesDirectory: options2.binariesDirectory
   });
   const connections = {};
   const server = http2.createServer((request, response) => {
     if (request.url?.startsWith("/proxy")) {
       return offthreadRequest(request, response);
     }
-    if (path19 === null) {
+    if (path20 === null) {
       response.writeHead(404);
       response.end("Server only supports /proxy");
       return;
     }
     serveHandler(request, response, {
-      public: path19
+      public: path20
     }).catch(() => {
       if (!response.headersSent) {
         response.writeHead(500);
@@ -16153,13 +17698,13 @@ var serveStatic = async (path19, options) => {
   });
   let selectedPort = null;
   const maxTries = 10;
-  const portConfig = getPortConfig(options.forceIPv4);
+  const portConfig = getPortConfig(options2.forceIPv4);
   for (let i = 0;i < maxTries; i++) {
     let unlock = () => {};
     try {
       selectedPort = await new Promise((resolve2, reject) => {
         getDesiredPort({
-          desiredPort: options?.port ?? undefined,
+          desiredPort: options2?.port ?? undefined,
           from: 3000,
           to: 3100,
           hostsToTry: portConfig.hostsToTry
@@ -16283,13 +17828,13 @@ var prepareServer = async ({
       downloadMap
     });
   }
-  const indexFile = path19.join(webpackConfigOrServeUrl, "index.html");
+  const indexFile = path20.join(webpackConfigOrServeUrl, "index.html");
   const exists = existsSync4(indexFile);
   if (!exists) {
     throw new Error(`Tried to serve the Webpack bundle on a HTTP server, but the file ${indexFile} does not exist. Is this a valid path to a Webpack bundle?`);
   }
   let localSourceMap = null;
-  getSourceMapFromLocalFile(path19.join(webpackConfigOrServeUrl, NoReactInternals7.bundleName)).then((s) => {
+  getSourceMapFromLocalFile(path20.join(webpackConfigOrServeUrl, NoReactInternals7.bundleName)).then((s) => {
     localSourceMap = s;
   }).catch((err) => {
     Log.verbose({ indent, logLevel }, "Could not fetch sourcemap for ", webpackConfigOrServeUrl, err);
@@ -17361,21 +18906,21 @@ var defaultCodecsForFileExtension = {
 // src/path-normalize.ts
 var SLASH = 47;
 var DOT = 46;
-var assertPath = (path20) => {
-  const t = typeof path20;
+var assertPath = (path21) => {
+  const t = typeof path21;
   if (t !== "string") {
     throw new TypeError(`Expected a string, got a ${t}`);
   }
 };
-var posixNormalize = (path20, allowAboveRoot) => {
+var posixNormalize = (path21, allowAboveRoot) => {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let code;
-  for (let i = 0;i <= path20.length; ++i) {
-    if (i < path20.length) {
-      code = path20.charCodeAt(i);
+  for (let i = 0;i <= path21.length; ++i) {
+    if (i < path21.length) {
+      code = path21.charCodeAt(i);
     } else if (code === SLASH) {
       break;
     } else {
@@ -17416,9 +18961,9 @@ var posixNormalize = (path20, allowAboveRoot) => {
         }
       } else {
         if (res.length > 0) {
-          res += "/" + path20.slice(lastSlash + 1, i);
+          res += "/" + path21.slice(lastSlash + 1, i);
         } else {
-          res = path20.slice(lastSlash + 1, i);
+          res = path21.slice(lastSlash + 1, i);
         }
         lastSegmentLength = i - lastSlash - 1;
       }
@@ -17441,24 +18986,24 @@ var decode = (s) => {
 };
 var pathNormalize = (p) => {
   assertPath(p);
-  let path20 = p;
-  if (path20.length === 0) {
+  let path21 = p;
+  if (path21.length === 0) {
     return ".";
   }
-  const isAbsolute = path20.charCodeAt(0) === SLASH;
-  const trailingSeparator = path20.charCodeAt(path20.length - 1) === SLASH;
-  path20 = decode(path20);
-  path20 = posixNormalize(path20, !isAbsolute);
-  if (path20.length === 0 && !isAbsolute) {
-    path20 = ".";
+  const isAbsolute2 = path21.charCodeAt(0) === SLASH;
+  const trailingSeparator = path21.charCodeAt(path21.length - 1) === SLASH;
+  path21 = decode(path21);
+  path21 = posixNormalize(path21, !isAbsolute2);
+  if (path21.length === 0 && !isAbsolute2) {
+    path21 = ".";
   }
-  if (path20.length > 0 && trailingSeparator) {
-    path20 += "/";
+  if (path21.length > 0 && trailingSeparator) {
+    path21 += "/";
   }
-  if (isAbsolute) {
-    return "/" + path20;
+  if (isAbsolute2) {
+    return "/" + path21;
   }
-  return path20;
+  return path21;
 };
 
 // src/get-extension-of-filename.ts
@@ -17615,8 +19160,8 @@ var validateSelectedPixelFormatAndCodecCombination = (pixelFormat, codec) => {
 };
 
 // src/render-frames.ts
-import fs15 from "node:fs";
-import path21 from "node:path";
+import fs16 from "node:fs";
+import path22 from "node:path";
 import { NoReactInternals as NoReactInternals12 } from "remotion/no-react";
 
 // src/cycle-browser-tabs.ts
@@ -17668,7 +19213,7 @@ var cycleBrowserTabs = ({
 
 // src/combine-audio.ts
 import { rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { VERSION as VERSION4 } from "remotion/version";
 
 // src/options/separate-audio.tsx
@@ -17925,7 +19470,7 @@ var encodeAudio = async ({
 }) => {
   const fileList = files.map((p) => `file '${p}'`).join(`
 `);
-  const fileListTxt = join3(filelistDir, "audio-files.txt");
+  const fileListTxt = join4(filelistDir, "audio-files.txt");
   writeFileSync2(fileListTxt, fileList);
   const startCombining = Date.now();
   const command = [
@@ -18007,7 +19552,7 @@ var combineAudioSeamlessly = async ({
 `);
   }).join(`
 `);
-  const fileListTxt = join3(filelistDir, "audio-files.txt");
+  const fileListTxt = join4(filelistDir, "audio-files.txt");
   writeFileSync2(fileListTxt, fileList);
   const command = [
     "-hide_banner",
@@ -18469,7 +20014,7 @@ var getRetriesLeftFromError = (error) => {
 };
 
 // src/render-frame-with-option-to-reject.ts
-import path20 from "path";
+import path21 from "path";
 
 // src/collect-assets.ts
 var collectAssets = async ({
@@ -18548,14 +20093,14 @@ var onlyInlineAudio = (assets) => {
 import * as assert2 from "node:assert";
 
 // src/screenshot-task.ts
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 var screenshotTask = async ({
   format: format2,
   height,
   omitBackground,
   page,
   width,
-  path: path20,
+  path: path21,
   jpegQuality,
   scale
 }) => {
@@ -18607,11 +20152,11 @@ var screenshotTask = async ({
     if (omitBackground) {
       await client.send("Emulation.setDefaultBackgroundColorOverride");
     }
-    const buffer = Buffer.from(result.data, "base64");
-    if (path20) {
-      await fs14.promises.writeFile(path20, buffer);
+    const buffer2 = Buffer.from(result.data, "base64");
+    if (path21) {
+      await fs15.promises.writeFile(path21, buffer2);
     }
-    return buffer;
+    return buffer2;
   } catch (err) {
     if (err.message.includes("Unable to capture screenshot")) {
       const errMessage = [
@@ -18625,21 +20170,21 @@ var screenshotTask = async ({
 };
 
 // src/puppeteer-screenshot.ts
-var screenshot = (options) => {
-  if (options.jpegQuality) {
-    assert2.ok(typeof options.jpegQuality === "number", "Expected options.quality to be a number but found " + typeof options.jpegQuality);
-    assert2.ok(Number.isInteger(options.jpegQuality), "Expected options.quality to be an integer");
-    assert2.ok(options.jpegQuality >= 0 && options.jpegQuality <= 100, "Expected options.quality to be between 0 and 100 (inclusive), got " + options.jpegQuality);
-  }
-  return options.page.screenshotTaskQueue.postTask(() => screenshotTask({
-    page: options.page,
-    format: options.type,
-    height: options.height,
-    width: options.width,
-    omitBackground: options.omitBackground,
-    path: options.path,
-    jpegQuality: options.type === "jpeg" ? options.jpegQuality : undefined,
-    scale: options.scale
+var screenshot = (options2) => {
+  if (options2.jpegQuality) {
+    assert2.ok(typeof options2.jpegQuality === "number", "Expected options.quality to be a number but found " + typeof options2.jpegQuality);
+    assert2.ok(Number.isInteger(options2.jpegQuality), "Expected options.quality to be an integer");
+    assert2.ok(options2.jpegQuality >= 0 && options2.jpegQuality <= 100, "Expected options.quality to be between 0 and 100 (inclusive), got " + options2.jpegQuality);
+  }
+  return options2.page.screenshotTaskQueue.postTask(() => screenshotTask({
+    page: options2.page,
+    format: options2.type,
+    height: options2.height,
+    width: options2.width,
+    omitBackground: options2.omitBackground,
+    path: options2.path,
+    jpegQuality: options2.type === "jpeg" ? options2.jpegQuality : undefined,
+    scale: options2.scale
   }));
 };
 
@@ -18764,12 +20309,12 @@ var renderFrameWithOptionToReject = async ({
   if (outputDir && onFrameBuffer && imageFormat !== "none") {
     throw new Error("Pass either `outputDir` or `onFrameBuffer` to renderFrames(), not both.");
   }
-  const [buffer, collectedAssets] = await Promise.all([
+  const [buffer2, collectedAssets] = await Promise.all([
     takeFrame({
       freePage: page,
       height,
       imageFormat: assetsOnly ? "none" : imageFormat,
-      output: index === null ? null : path20.join(frameDir, getFrameOutputFileName({
+      output: index === null ? null : path21.join(frameDir, getFrameOutputFileName({
         frame,
         imageFormat,
         index,
@@ -18791,10 +20336,10 @@ var renderFrameWithOptionToReject = async ({
     })
   ]);
   if (onFrameBuffer && !assetsOnly) {
-    if (!buffer) {
+    if (!buffer2) {
       throw new Error("unexpected null buffer");
     }
-    onFrameBuffer(buffer, frame);
+    onFrameBuffer(buffer2, frame);
   }
   const onlyAvailableAssets = assets.filter(truthy);
   const previousAudioRenderAssets = onlyAvailableAssets.map((a) => a.audioAndVideoAssets).flat(2);
@@ -18802,7 +20347,7 @@ var renderFrameWithOptionToReject = async ({
   const audioAndVideoAssets = onlyAudioAndVideoAssets(collectedAssets);
   const artifactAssets = onlyArtifact({
     assets: collectedAssets,
-    frameBuffer: buffer
+    frameBuffer: buffer2
   });
   for (const artifact of artifactAssets) {
     for (const previousArtifact of previousArtifactAssets) {
@@ -19248,8 +20793,8 @@ var innerRenderFrames = async ({
   sampleRate
 }) => {
   if (outputDir) {
-    if (!fs15.existsSync(outputDir)) {
-      fs15.mkdirSync(outputDir, {
+    if (!fs16.existsSync(outputDir)) {
+      fs16.mkdirSync(outputDir, {
         recursive: true
       });
     }
@@ -19390,7 +20935,7 @@ var innerRenderFrames = async ({
       assets: assets.sort((a, b) => {
         return a.frame - b.frame;
       }),
-      imageSequenceName: path21.join(frameDir, imageSequenceName),
+      imageSequenceName: path22.join(frameDir, imageSequenceName),
       firstFrameIndex,
       downloadMap,
       trimLeftOffset,
@@ -19583,7 +21128,7 @@ var internalRenderFramesRaw = ({
   });
 };
 var internalRenderFrames = wrapWithErrorHandling(internalRenderFramesRaw);
-var renderFrames = (options) => {
+var renderFrames = (options2) => {
   const {
     composition,
     inputProps,
@@ -19621,7 +21166,7 @@ var renderFrames = (options) => {
     imageSequencePattern,
     mediaCacheSizeInBytes,
     sampleRate
-  } = options;
+  } = options2;
   if (!composition) {
     throw new Error("No `composition` option has been specified for renderFrames()");
   }
@@ -19686,9 +21231,9 @@ var renderFrames = (options) => {
 };
 
 // src/render-media.ts
-import fs17 from "node:fs";
+import fs18 from "node:fs";
 import os9 from "node:os";
-import path26 from "node:path";
+import path27 from "node:path";
 import { LicensingInternals } from "@remotion/licensing";
 import { NoReactInternals as NoReactInternals15 } from "remotion/no-react";
 
@@ -20184,77 +21729,77 @@ var validateEvenDimensionsWithCodec = ({
 };
 
 // src/prespawn-ffmpeg.ts
-var prespawnFfmpeg = (options) => {
-  validateDimension(options.height, "height", "passed to `stitchFramesToVideo()`");
-  validateDimension(options.width, "width", "passed to `stitchFramesToVideo()`");
-  const codec = options.codec ?? DEFAULT_CODEC;
-  validateFps(options.fps, "in `stitchFramesToVideo()`", codec === "gif");
+var prespawnFfmpeg = (options2) => {
+  validateDimension(options2.height, "height", "passed to `stitchFramesToVideo()`");
+  validateDimension(options2.width, "width", "passed to `stitchFramesToVideo()`");
+  const codec = options2.codec ?? DEFAULT_CODEC;
+  validateFps(options2.fps, "in `stitchFramesToVideo()`", codec === "gif");
   validateEvenDimensionsWithCodec({
-    width: options.width,
-    height: options.height,
+    width: options2.width,
+    height: options2.height,
     codec,
     scale: 1,
     wantsImageSequence: false,
-    indent: options.indent,
-    logLevel: options.logLevel
+    indent: options2.indent,
+    logLevel: options2.logLevel
   });
-  const pixelFormat = options.pixelFormat ?? DEFAULT_PIXEL_FORMAT;
-  const proResProfileName = getProResProfileName(codec, options.proResProfile);
+  const pixelFormat = options2.pixelFormat ?? DEFAULT_PIXEL_FORMAT;
+  const proResProfileName = getProResProfileName(codec, options2.proResProfile);
   validateSelectedPixelFormatAndCodecCombination(pixelFormat, codec);
   const ffmpegArgs = [
-    ["-r", options.fps],
+    ["-r", options2.fps],
     ...[
       ["-f", "image2pipe"],
-      ["-s", `${options.width}x${options.height}`],
-      ["-vcodec", options.imageFormat === "jpeg" ? "mjpeg" : "png"],
+      ["-s", `${options2.width}x${options2.height}`],
+      ["-vcodec", options2.imageFormat === "jpeg" ? "mjpeg" : "png"],
       ["-i", "-"]
     ],
     ...generateFfmpegArgs({
       hasPreencoded: false,
       proResProfileName,
       pixelFormat,
-      x264Preset: options.x264Preset,
+      x264Preset: options2.x264Preset,
       codec,
-      crf: options.crf,
-      videoBitrate: options.videoBitrate,
-      encodingMaxRate: options.encodingMaxRate,
-      encodingBufferSize: options.encodingBufferSize,
-      colorSpace: options.colorSpace,
-      hardwareAcceleration: options.hardwareAcceleration,
-      indent: options.indent,
-      logLevel: options.logLevel
+      crf: options2.crf,
+      videoBitrate: options2.videoBitrate,
+      encodingMaxRate: options2.encodingMaxRate,
+      encodingBufferSize: options2.encodingBufferSize,
+      colorSpace: options2.colorSpace,
+      hardwareAcceleration: options2.hardwareAcceleration,
+      indent: options2.indent,
+      logLevel: options2.logLevel
     }),
     "-y",
-    options.outputLocation
+    options2.outputLocation
   ];
   Log.verbose({
-    indent: options.indent,
-    logLevel: options.logLevel,
+    indent: options2.indent,
+    logLevel: options2.logLevel,
     tag: "prespawnFfmpeg()"
   }, "Generated FFMPEG command:");
   Log.verbose({
-    indent: options.indent,
-    logLevel: options.logLevel,
+    indent: options2.indent,
+    logLevel: options2.logLevel,
     tag: "prespawnFfmpeg()"
   }, ffmpegArgs.join(" "));
   const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
-  const finalFfmpegString = options.ffmpegOverride ? options.ffmpegOverride({ type: "pre-stitcher", args: ffmpegString }) : ffmpegString;
+  const finalFfmpegString = options2.ffmpegOverride ? options2.ffmpegOverride({ type: "pre-stitcher", args: ffmpegString }) : ffmpegString;
   const task = callFf({
     bin: "ffmpeg",
     args: finalFfmpegString,
-    indent: options.indent,
-    logLevel: options.logLevel,
-    binariesDirectory: options.binariesDirectory,
-    cancelSignal: options.signal
+    indent: options2.indent,
+    logLevel: options2.logLevel,
+    binariesDirectory: options2.binariesDirectory,
+    cancelSignal: options2.signal
   });
   let ffmpegOutput = "";
   task.stderr?.on("data", (data) => {
     const str = data.toString();
     ffmpegOutput += str;
-    if (options.onProgress) {
-      const parsed = parseFfmpegProgress(str, options.fps);
+    if (options2.onProgress) {
+      const parsed = parseFfmpegProgress(str, options2.fps);
       if (parsed !== undefined) {
-        options.onProgress(parsed);
+        options2.onProgress(parsed);
       }
     }
   });
@@ -20322,7 +21867,7 @@ var validateSelectedCodecAndProResCombination = ({
 
 // src/stitch-frames-to-video.ts
 import { cpSync as cpSync2, promises as promises3, rmSync as rmSync4 } from "node:fs";
-import path25 from "node:path";
+import path26 from "node:path";
 
 // src/convert-number-of-gif-loops-to-ffmpeg.ts
 var convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
@@ -20336,7 +21881,7 @@ var convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
 };
 
 // src/create-audio.ts
-import path24 from "path";
+import path25 from "path";
 
 // src/resolve-asset-src.ts
 import url from "node:url";
@@ -20537,7 +22082,7 @@ var compressAudio = async ({
 };
 
 // src/merge-audio-track.ts
-import path23 from "node:path";
+import path24 from "node:path";
 
 // src/chunk.ts
 var chunk2 = (input, size) => {
@@ -20568,8 +22113,8 @@ var createFfmpegMergeFilter = ({
 };
 
 // src/ffmpeg-filter-file.ts
-import fs16, { existsSync as existsSync5 } from "node:fs";
-import path22 from "node:path";
+import fs17, { existsSync as existsSync5 } from "node:fs";
+import path23 from "node:path";
 var makeFfmpegFilterFile = (complexFilter, downloadMap) => {
   if (complexFilter.filter === null) {
     return {
@@ -20583,15 +22128,15 @@ var makeFfmpegFilterFile = (complexFilter, downloadMap) => {
 };
 var makeFfmpegFilterFileStr = async (complexFilter, downloadMap) => {
   const random2 = Math.random().toString().replace(".", "");
-  const filterFile = path22.join(downloadMap.complexFilter, "complex-filter-" + random2 + ".txt");
+  const filterFile = path23.join(downloadMap.complexFilter, "complex-filter-" + random2 + ".txt");
   if (!existsSync5(downloadMap.complexFilter)) {
-    fs16.mkdirSync(downloadMap.complexFilter, { recursive: true });
+    fs17.mkdirSync(downloadMap.complexFilter, { recursive: true });
   }
-  await fs16.promises.writeFile(filterFile, complexFilter);
+  await fs17.promises.writeFile(filterFile, complexFilter);
   return {
     file: filterFile,
     cleanup: () => {
-      fs16.unlinkSync(filterFile);
+      fs17.unlinkSync(filterFile);
     }
   };
 };
@@ -20693,7 +22238,7 @@ var mergeAudioTrackUnlimited = async ({
         onProgress(combinedProgress);
       };
       const chunkNames = await Promise.all(chunked.map(async (chunkFiles, i) => {
-        const chunkOutname = path23.join(tempPath, `chunk-${i}.wav`);
+        const chunkOutname = path24.join(tempPath, `chunk-${i}.wav`);
         await mergeAudioTrack({
           files: chunkFiles,
           chunkLengthInSeconds,
@@ -20778,8 +22323,8 @@ var mergeAudioTrackUnlimited = async ({
   cleanup();
 };
 var limit2 = pLimit(3);
-var mergeAudioTrack = (options) => {
-  return limit2(mergeAudioTrackUnlimited, options);
+var mergeAudioTrack = (options2) => {
+  return limit2(mergeAudioTrackUnlimited, options2);
 };
 
 // src/assets/calculate-atempo.ts
@@ -21109,8 +22654,8 @@ var preprocessAudioTrackUnlimited = async ({
   return { outName, filter };
 };
 var limit3 = pLimit(2);
-var preprocessAudioTrack = (options) => {
-  return limit3(preprocessAudioTrackUnlimited, options);
+var preprocessAudioTrack = (options2) => {
+  return limit3(preprocessAudioTrackUnlimited, options2);
 };
 
 // src/create-audio.ts
@@ -21155,7 +22700,7 @@ var createAudio = async ({
     onProgress(totalProgress);
   };
   const audioTracks = await Promise.all(assetPositions.map(async (asset, index) => {
-    const filterFile = path24.join(downloadMap.audioMixing, `${index}.wav`);
+    const filterFile = path25.join(downloadMap.audioMixing, `${index}.wav`);
     const result = await preprocessAudioTrack({
       outName: filterFile,
       asset,
@@ -21199,9 +22744,9 @@ var createAudio = async ({
       }
     }))
   ];
-  const merged = path24.join(downloadMap.audioPreprocessing, "merged.wav");
+  const merged = path25.join(downloadMap.audioPreprocessing, "merged.wav");
   const extension = getExtensionFromAudioCodec(audioCodec);
-  const outName = path24.join(downloadMap.audioPreprocessing, `audio.${extension}`);
+  const outName = path25.join(downloadMap.audioPreprocessing, `audio.${extension}`);
   await mergeAudioTrack({
     files: preprocessed,
     outName: merged,
@@ -21379,7 +22924,7 @@ var innerStitchFramesToVideo = async ({
     setting: audioCodecSetting,
     separateAudioTo
   });
-  const tempFile = outputLocation ? null : path25.join(assetsInfo.downloadMap.stitchFrames, `out.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`);
+  const tempFile = outputLocation ? null : path26.join(assetsInfo.downloadMap.stitchFrames, `out.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`);
   Log.verbose({
     indent,
     logLevel,
@@ -21454,7 +22999,7 @@ var innerStitchFramesToVideo = async ({
     }
     cpSync2(audio, outputLocation ?? tempFile);
     onProgress?.(Math.round(assetsInfo.chunkLengthInSeconds * fps));
-    deleteDirectory(path25.dirname(audio));
+    deleteDirectory(path26.dirname(audio));
     const file = await new Promise((resolve2, reject) => {
       if (tempFile) {
         promises3.readFile(tempFile).then((f) => {
@@ -21543,7 +23088,7 @@ var innerStitchFramesToVideo = async ({
     if (!audio) {
       throw new Error(`\`separateAudioTo\` was set to ${JSON.stringify(separateAudioTo)}, but this render included no audio`);
     }
-    const finalDestination = path25.resolve(remotionRoot, separateAudioTo);
+    const finalDestination = path26.resolve(remotionRoot, separateAudioTo);
     cpSync2(audio, finalDestination);
     rmSync4(audio);
   }
@@ -21569,13 +23114,13 @@ var innerStitchFramesToVideo = async ({
   assetsInfo.downloadMap.allowCleanup();
   return result;
 };
-var internalStitchFramesToVideo = (options) => {
+var internalStitchFramesToVideo = (options2) => {
   const remotionRoot = findRemotionRoot();
-  const task = innerStitchFramesToVideo(options, remotionRoot);
+  const task = innerStitchFramesToVideo(options2, remotionRoot);
   return Promise.race([
     task,
     new Promise((_resolve, reject) => {
-      options.cancelSignal?.(() => {
+      options2.cancelSignal?.(() => {
         reject(new Error(cancelErrorMessages.stitchFramesToVideo));
       });
     })
@@ -21872,7 +23417,7 @@ var internalRenderMediaRaw = ({
       separateAudioTo
     });
   }
-  const absoluteOutputLocation = outputLocation ? path26.resolve(process.cwd(), outputLocation) : null;
+  const absoluteOutputLocation = outputLocation ? path27.resolve(process.cwd(), outputLocation) : null;
   validateScale(scale);
   validateFfmpegOverride(ffmpegOverride);
   validateEveryNthFrame(everyNthFrame);
@@ -21938,8 +23483,8 @@ var internalRenderMediaRaw = ({
   }
   const imageFormat = isAudioCodec(codec) ? "none" : provisionalImageFormat ?? compositionWithPossibleUnevenDimensions.defaultVideoImageFormat ?? DEFAULT_VIDEO_IMAGE_FORMAT;
   validateSelectedPixelFormatAndImageFormatCombination(pixelFormat, imageFormat);
-  const workingDir = fs17.mkdtempSync(path26.join(os9.tmpdir(), "react-motion-render"));
-  const preEncodedFileLocation = parallelEncoding ? path26.join(workingDir, "pre-encode." + getFileExtensionFromCodec(codec, audioCodec)) : null;
+  const workingDir = fs18.mkdtempSync(path27.join(os9.tmpdir(), "react-motion-render"));
+  const preEncodedFileLocation = parallelEncoding ? path27.join(workingDir, "pre-encode." + getFileExtensionFromCodec(codec, audioCodec)) : null;
   if (onCtrlCExit && workingDir) {
     onCtrlCExit(`Delete ${workingDir}`, () => deleteDirectory(workingDir));
   }
@@ -22100,7 +23645,7 @@ var internalRenderMediaRaw = ({
         frameRange,
         puppeteerInstance,
         everyNthFrame,
-        onFrameBuffer: parallelEncoding ? async (buffer, frame) => {
+        onFrameBuffer: parallelEncoding ? async (buffer2, frame) => {
           await waitForRightTimeOfFrameToBeInserted(frame);
           if (cancelled) {
             return;
@@ -22113,7 +23658,7 @@ var internalRenderMediaRaw = ({
           if (exitStatus?.type === "quit-with-error") {
             throw new Error(`FFmpeg quit with code ${exitStatus.exitCode}${exitStatus.signal ? ` (signal ${exitStatus.signal})` : ""} while piping frame ${frame}. Stderr: ${exitStatus.stderr}`);
           }
-          stitcherFfmpeg?.stdin?.write(buffer);
+          stitcherFfmpeg?.stdin?.write(buffer2);
           stopPerfMeasure(id);
           setFrameToStitch(Math.min(realFrameRange[1] + 1, frame + everyNthFrame));
         } : null,
@@ -22207,11 +23752,11 @@ var internalRenderMediaRaw = ({
         hardwareAcceleration,
         sampleRate
       });
-    }).then((buffer) => {
+    }).then((buffer2) => {
       Log.verbose({ indent, logLevel }, "Stitching done in", encodedDoneIn + "ms");
       slowestFrames.sort((a, b) => b.time - a.time);
       const result = {
-        buffer,
+        buffer: buffer2,
         slowestFrames,
         contentType: mimeLookup("file." + getFileExtensionFromCodec(codec, audioCodec)) || "application/octet-stream"
       };
@@ -22267,10 +23812,10 @@ var internalRenderMediaRaw = ({
       }
       reject(err);
     }).finally(() => {
-      if (preEncodedFileLocation !== null && fs17.existsSync(preEncodedFileLocation)) {
-        deleteDirectory(path26.dirname(preEncodedFileLocation));
+      if (preEncodedFileLocation !== null && fs18.existsSync(preEncodedFileLocation)) {
+        deleteDirectory(path27.dirname(preEncodedFileLocation));
       }
-      if (workingDir && fs17.existsSync(workingDir)) {
+      if (workingDir && fs18.existsSync(workingDir)) {
         deleteDirectory(workingDir);
       }
       cleanupServerFn?.(false).catch((err) => {
@@ -22439,8 +23984,8 @@ var renderMedia = ({
 };
 
 // src/render-still.ts
-import fs18, { statSync as statSync2 } from "node:fs";
-import path27 from "node:path";
+import fs19, { statSync as statSync2 } from "node:fs";
+import path28 from "node:path";
 import { LicensingInternals as LicensingInternals2 } from "@remotion/licensing";
 import { NoReactInternals as NoReactInternals16 } from "remotion/no-react";
 var innerRenderStill = async ({
@@ -22491,10 +24036,10 @@ var innerRenderStill = async ({
   });
   validatePuppeteerTimeout(timeoutInMilliseconds);
   validateScale(scale);
-  output = typeof output === "string" ? path27.resolve(process.cwd(), output) : null;
+  output = typeof output === "string" ? path28.resolve(process.cwd(), output) : null;
   validateJpegQuality(jpegQuality);
   if (output) {
-    if (fs18.existsSync(output)) {
+    if (fs19.existsSync(output)) {
       if (!overwrite) {
         throw new Error(`Cannot render still - "overwrite" option was set to false, but the output destination ${output} already exists.`);
       }
@@ -22618,7 +24163,7 @@ var innerRenderStill = async ({
     logLevel,
     attempt: 0
   });
-  const [buffer, collectedAssets] = await Promise.all([
+  const [buffer2, collectedAssets] = await Promise.all([
     takeFrame({
       freePage: page,
       height: composition.height,
@@ -22638,7 +24183,7 @@ var innerRenderStill = async ({
   ]);
   const artifactAssets = onlyArtifact({
     assets: collectedAssets,
-    frameBuffer: buffer
+    frameBuffer: buffer2
   });
   const previousArtifactAssets = [];
   for (const artifact of artifactAssets) {
@@ -22652,61 +24197,61 @@ var innerRenderStill = async ({
   }
   await cleanup();
   return {
-    buffer: output ? null : buffer,
+    buffer: output ? null : buffer2,
     contentType: mimeLookup("file." + imageFormat) || "application/octet-stream"
   };
 };
-var internalRenderStillRaw = (options) => {
+var internalRenderStillRaw = (options2) => {
   const cleanup = [];
   const happyPath = new Promise((resolve2, reject) => {
     const onError = (err) => reject(err);
-    makeOrReuseServer(options.server, {
-      webpackConfigOrServeUrl: options.serveUrl,
-      port: options.port,
+    makeOrReuseServer(options2.server, {
+      webpackConfigOrServeUrl: options2.serveUrl,
+      port: options2.port,
       remotionRoot: findRemotionRoot(),
-      offthreadVideoThreads: options.offthreadVideoThreads ?? 2,
-      logLevel: options.logLevel,
-      indent: options.indent,
-      offthreadVideoCacheSizeInBytes: options.offthreadVideoCacheSizeInBytes,
-      binariesDirectory: options.binariesDirectory,
+      offthreadVideoThreads: options2.offthreadVideoThreads ?? 2,
+      logLevel: options2.logLevel,
+      indent: options2.indent,
+      offthreadVideoCacheSizeInBytes: options2.offthreadVideoCacheSizeInBytes,
+      binariesDirectory: options2.binariesDirectory,
       forceIPv4: false,
       sampleRate: 48000
     }, {
-      onDownload: options.onDownload
+      onDownload: options2.onDownload
     }).then(({ server, cleanupServer }) => {
       cleanup.push(() => cleanupServer(false));
       const { serveUrl, offthreadPort, sourceMap: sourceMapGetter } = server;
       return innerRenderStill({
-        ...options,
+        ...options2,
         serveUrl,
         onError,
         proxyPort: offthreadPort,
         sourceMapGetter
       });
     }).then((res) => {
-      if (options.licenseKey === null) {
+      if (options2.licenseKey === null) {
         resolve2(res);
         return;
       }
       LicensingInternals2.internalRegisterUsageEvent({
-        licenseKey: options.licenseKey,
+        licenseKey: options2.licenseKey,
         event: "cloud-render",
         host: null,
         succeeded: true,
         isStill: true,
-        isProduction: options.isProduction ?? true
+        isProduction: options2.isProduction ?? true
       }).then(() => {
-        Log.verbose(options, "Usage event sent successfully");
+        Log.verbose(options2, "Usage event sent successfully");
       }).catch((err) => {
-        Log.error(options, "Failed to send usage event");
-        Log.error(options, err);
+        Log.error(options2, "Failed to send usage event");
+        Log.error(options2, err);
       }).finally(() => {
         resolve2(res);
       });
     }).catch((err) => reject(err)).finally(() => {
       cleanup.forEach((c) => {
         c().catch((err) => {
-          Log.error(options, "Cleanup error:", err);
+          Log.error(options2, "Cleanup error:", err);
         });
       });
     });
@@ -22714,14 +24259,14 @@ var internalRenderStillRaw = (options) => {
   return Promise.race([
     happyPath,
     new Promise((_resolve, reject) => {
-      options.cancelSignal?.(() => {
+      options2.cancelSignal?.(() => {
         reject(new Error(cancelErrorMessages.renderStill));
       });
     })
   ]);
 };
 var internalRenderStill = wrapWithErrorHandling(internalRenderStillRaw);
-var renderStill = (options) => {
+var renderStill = (options2) => {
   const {
     composition,
     serveUrl,
@@ -22755,7 +24300,7 @@ var renderStill = (options) => {
     apiKey,
     licenseKey,
     isProduction
-  } = options;
+  } = options2;
   if (typeof jpegQuality !== "undefined" && imageFormat !== "jpeg") {
     throw new Error("You can only pass the `quality` option if `imageFormat` is 'jpeg'.");
   }
@@ -22919,7 +24464,7 @@ var innerSelectComposition = async ({
     propsSize: size
   };
 };
-var internalSelectCompositionRaw = async (options) => {
+var internalSelectCompositionRaw = async (options2) => {
   const cleanup = [];
   const {
     puppeteerInstance,
@@ -22941,7 +24486,7 @@ var internalSelectCompositionRaw = async (options) => {
     onServeUrlVisited,
     chromeMode,
     mediaCacheSizeInBytes
-  } = options;
+  } = options2;
   const [{ page, cleanupPage }, serverUsed] = await Promise.all([
     getPageAndCleanupFn({
       passedInInstance: puppeteerInstance,
@@ -22956,7 +24501,7 @@ var internalSelectCompositionRaw = async (options) => {
       onBrowserLog,
       onLog: RenderInternals.defaultOnLog
     }),
-    makeOrReuseServer(options.server, {
+    makeOrReuseServer(options2.server, {
       webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
       port,
       remotionRoot: findRemotionRoot(),
@@ -23019,7 +24564,7 @@ var internalSelectCompositionRaw = async (options) => {
   });
 };
 var internalSelectComposition = wrapWithErrorHandling(internalSelectCompositionRaw);
-var selectComposition = async (options) => {
+var selectComposition = async (options2) => {
   const {
     id,
     serveUrl,
@@ -23039,7 +24584,7 @@ var selectComposition = async (options) => {
     chromeMode,
     offthreadVideoThreads,
     mediaCacheSizeInBytes
-  } = options;
+  } = options2;
   const indent = false;
   const logLevel = passedLogLevel ?? (verbose ? "verbose" : "info");
   const data = await internalSelectComposition({
@@ -23159,10 +24704,9 @@ var getMaxConcurrency = () => {
   return getCpuCount();
 };
 var getMinConcurrency = () => 1;
-
 // src/combine-chunks.ts
 import { rmSync as rmSync6 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/can-concat-seamlessly.ts
 var canConcatAudioSeamlessly = (audioCodec, chunkDurationInFrames) => {
@@ -23177,7 +24721,7 @@ var canConcatVideoSeamlessly = (codec) => {
 
 // src/combine-video-streams.ts
 import { rmSync as rmSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { VERSION as VERSION6 } from "remotion/version";
 var combineVideoStreams = async ({
   fps,
@@ -23195,7 +24739,7 @@ var combineVideoStreams = async ({
 }) => {
   const fileList = files.map((p) => `file '${p}'`).join(`
 `);
-  const fileListTxt = join4(filelistDir, "video-files.txt");
+  const fileListTxt = join5(filelistDir, "video-files.txt");
   writeFileSync3(fileListTxt, fileList);
   const encoder = codec === "gif" ? "gif" : "copy";
   const command = [
@@ -23372,8 +24916,8 @@ var internalCombineChunks = async ({
   const seamlessAudio = canConcatAudioSeamlessly(resolvedAudioCodec, framesPerChunk);
   const realFrameRange = getRealFrameRange(compositionDurationInFrames, frameRange);
   const numberOfFrames = getFramesToRender(realFrameRange, everyNthFrame).length;
-  const videoOutput = shouldCreateVideo ? join5(filelistDir, `video.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`) : null;
-  const audioOutput = shouldCreateAudio ? join5(filelistDir, `audio.${getExtensionFromAudioCodec(resolvedAudioCodec)}`) : null;
+  const videoOutput = shouldCreateVideo ? join6(filelistDir, `video.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`) : null;
+  const audioOutput = shouldCreateAudio ? join6(filelistDir, `audio.${getExtensionFromAudioCodec(resolvedAudioCodec)}`) : null;
   const chunkDurationInSeconds = framesPerChunk / fps;
   let concatenatedAudio = 0;
   let concatenatedVideo = 0;
@@ -23451,42 +24995,42 @@ var internalCombineChunks = async ({
     throw err;
   }
 };
-var combineChunks = (options) => {
+var combineChunks = (options2) => {
   return internalCombineChunks({
-    audioBitrate: options.audioBitrate ?? null,
-    numberOfGifLoops: options.numberOfGifLoops ?? null,
+    audioBitrate: options2.audioBitrate ?? null,
+    numberOfGifLoops: options2.numberOfGifLoops ?? null,
     indent: false,
-    logLevel: options.logLevel ?? "info",
-    binariesDirectory: options.binariesDirectory ?? null,
-    cancelSignal: options.cancelSignal,
-    metadata: options.metadata ?? null,
-    audioCodec: options.audioCodec ?? null,
-    preferLossless: options.preferLossless,
-    audioFiles: options.audioFiles,
-    codec: options.codec,
-    fps: options.fps,
-    framesPerChunk: options.framesPerChunk,
-    outputLocation: options.outputLocation,
-    onProgress: options.onProgress ?? (() => {}),
-    videoFiles: options.videoFiles,
-    everyNthFrame: options.everyNthFrame ?? 1,
-    frameRange: options.frameRange ?? null,
-    compositionDurationInFrames: options.compositionDurationInFrames,
-    sampleRate: options.sampleRate ?? 48000
+    logLevel: options2.logLevel ?? "info",
+    binariesDirectory: options2.binariesDirectory ?? null,
+    cancelSignal: options2.cancelSignal,
+    metadata: options2.metadata ?? null,
+    audioCodec: options2.audioCodec ?? null,
+    preferLossless: options2.preferLossless,
+    audioFiles: options2.audioFiles,
+    codec: options2.codec,
+    fps: options2.fps,
+    framesPerChunk: options2.framesPerChunk,
+    outputLocation: options2.outputLocation,
+    onProgress: options2.onProgress ?? (() => {}),
+    videoFiles: options2.videoFiles,
+    everyNthFrame: options2.everyNthFrame ?? 1,
+    frameRange: options2.frameRange ?? null,
+    compositionDurationInFrames: options2.compositionDurationInFrames,
+    sampleRate: options2.sampleRate ?? 48000
   });
 };
 // src/extract-audio.ts
-var extractAudio = async (options) => {
+var extractAudio = async (options2) => {
   const compositor = startLongRunningCompositor({
     maximumFrameCacheItemsInBytes: null,
-    logLevel: options?.logLevel ?? "info",
+    logLevel: options2?.logLevel ?? "info",
     indent: false,
-    binariesDirectory: options.binariesDirectory ?? null,
+    binariesDirectory: options2.binariesDirectory ?? null,
     extraThreads: 0
   });
   await compositor.executeCommand("ExtractAudio", {
-    input_path: options.videoSource,
-    output_path: options.audioOutput
+    input_path: options2.videoSource,
+    output_path: options2.audioOutput
   });
   await compositor.finishCommands();
   await compositor.waitForDone();
@@ -23560,12 +25104,12 @@ var getAudibleParts = ({
 };
 // src/get-video-metadata.ts
 import { resolve as resolve2 } from "node:path";
-var getVideoMetadata = async (videoSource, options) => {
+var getVideoMetadata = async (videoSource, options2) => {
   const compositor = startLongRunningCompositor({
     maximumFrameCacheItemsInBytes: null,
-    logLevel: options?.logLevel ?? "info",
+    logLevel: options2?.logLevel ?? "info",
     indent: false,
-    binariesDirectory: options?.binariesDirectory ?? null,
+    binariesDirectory: options2?.binariesDirectory ?? null,
     extraThreads: 0
   });
   const metadataResponse = await compositor.executeCommand("GetVideoMetadata", {
@@ -23575,6 +25119,12 @@ var getVideoMetadata = async (videoSource, options) => {
   await compositor.waitForDone();
   return JSON.parse(new TextDecoder("utf-8").decode(metadataResponse));
 };
+// src/options/chrome-mode.tsx
+import { jsx as jsx6, jsxs as jsxs6, Fragment as Fragment6 } from "react/jsx-runtime";
+// src/options/number-of-gif-loops.tsx
+import { jsx as jsx7, jsxs as jsxs7, Fragment as Fragment7 } from "react/jsx-runtime";
+// src/options/on-browser-download.tsx
+import { jsx as jsx8, jsxs as jsxs8, Fragment as Fragment8 } from "react/jsx-runtime";
 // src/index.ts
 var RenderInternals = {
   resolveConcurrency,