bililive-cli 4.0.0 → 4.1.0

package/lib/{index-CWkwaDmT.cjs → index-CyQ_VJuq.cjs}

@@ -17,7 +17,7 @@ var path$z = require('node:path');
 var process$2 = require('node:process');
 var require$$3$1 = require('node:util');
 var EventEmitter$l = require('node:events');
-var fs$F = require('node:fs');
+var fs$D = require('node:fs');
 var require$$0$b = require('node:stream');
 var Database = require('better-sqlite3');
 var require$$1$4 = require('http');
@@ -40,7 +40,7 @@ var require$$0$e = require('punycode');
 var canvas = require('@napi-rs/canvas');
 var require$$0$f = require('vm');
 var promises = require('node:stream/promises');
-var fs$G = require('fs/promises');
+var fs$E = require('fs/promises');
 var require$$0$g = require('node:assert');
 var require$$1$7 = require('node:net');
 var require$$5 = require('node:querystring');
@@ -112,7 +112,7 @@ function getAugmentedNamespace(n) {
 	return a;
 }
 
-var fs$E = {};
+var fs$C = {};
 
 var universalify$1 = {};
 
@@ -636,7 +636,7 @@ function clone$2 (obj) {
   return copy
 }
 
-var fs$D = require$$0$6;
+var fs$B = require$$0$6;
 var polyfills = polyfills$1;
 var legacy = legacyStreams;
 var clone$1 = clone_1;
@@ -678,18 +678,18 @@ else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
   };
 
 // Once time initialization
-if (!fs$D[gracefulQueue]) {
+if (!fs$B[gracefulQueue]) {
   // This queue can be shared by multiple loaded instances
   var queue$2 = commonjsGlobal[gracefulQueue] || [];
-  publishQueue(fs$D, queue$2);
+  publishQueue(fs$B, queue$2);
 
   // Patch fs.close/closeSync to shared queue version, because we need
   // to retry() whenever a close happens *anywhere* in the program.
   // This is essential when multiple graceful-fs instances are
   // in play at the same time.
-  fs$D.close = (function (fs$close) {
+  fs$B.close = (function (fs$close) {
     function close (fd, cb) {
-      return fs$close.call(fs$D, fd, function (err) {
+      return fs$close.call(fs$B, fd, function (err) {
         // This function uses the graceful-fs shared queue
         if (!err) {
           resetQueue();
@@ -704,12 +704,12 @@ if (!fs$D[gracefulQueue]) {
       value: fs$close
     });
     return close
-  })(fs$D.close);
+  })(fs$B.close);
 
-  fs$D.closeSync = (function (fs$closeSync) {
+  fs$B.closeSync = (function (fs$closeSync) {
     function closeSync (fd) {
       // This function uses the graceful-fs shared queue
-      fs$closeSync.apply(fs$D, arguments);
+      fs$closeSync.apply(fs$B, arguments);
       resetQueue();
     }
 
@@ -717,24 +717,24 @@ if (!fs$D[gracefulQueue]) {
       value: fs$closeSync
     });
     return closeSync
-  })(fs$D.closeSync);
+  })(fs$B.closeSync);
 
   if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
     process.on('exit', function() {
-      debug$7(fs$D[gracefulQueue]);
-      require$$0$5.equal(fs$D[gracefulQueue].length, 0);
+      debug$7(fs$B[gracefulQueue]);
+      require$$0$5.equal(fs$B[gracefulQueue].length, 0);
     });
   }
 }
 
 if (!commonjsGlobal[gracefulQueue]) {
-  publishQueue(commonjsGlobal, fs$D[gracefulQueue]);
+  publishQueue(commonjsGlobal, fs$B[gracefulQueue]);
 }
 
-var gracefulFs = patch(clone$1(fs$D));
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$D.__patched) {
-    gracefulFs = patch(fs$D);
-    fs$D.__patched = true;
+var gracefulFs = patch(clone$1(fs$B));
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$B.__patched) {
+    gracefulFs = patch(fs$B);
+    fs$B.__patched = true;
 }
 
 function patch (fs) {
@@ -1008,7 +1008,7 @@ function patch (fs) {
 
 function enqueue (elem) {
   debug$7('ENQUEUE', elem[0].name, elem[1]);
-  fs$D[gracefulQueue].push(elem);
+  fs$B[gracefulQueue].push(elem);
   retry$4();
 }
 
@@ -1020,12 +1020,12 @@ var retryTimer;
 // delay between attempts so that we'll retry these jobs sooner
 function resetQueue () {
   var now = Date.now();
-  for (var i = 0; i < fs$D[gracefulQueue].length; ++i) {
+  for (var i = 0; i < fs$B[gracefulQueue].length; ++i) {
     // entries that are only a length of 2 are from an older version, don't
     // bother modifying those since they'll be retried anyway.
-    if (fs$D[gracefulQueue][i].length > 2) {
-      fs$D[gracefulQueue][i][3] = now; // startTime
-      fs$D[gracefulQueue][i][4] = now; // lastTime
+    if (fs$B[gracefulQueue][i].length > 2) {
+      fs$B[gracefulQueue][i][3] = now; // startTime
+      fs$B[gracefulQueue][i][4] = now; // lastTime
     }
   }
   // call retry to make sure we're actively processing the queue
@@ -1037,10 +1037,10 @@ function retry$4 () {
   clearTimeout(retryTimer);
   retryTimer = undefined;
 
-  if (fs$D[gracefulQueue].length === 0)
+  if (fs$B[gracefulQueue].length === 0)
     return
 
-  var elem = fs$D[gracefulQueue].shift();
+  var elem = fs$B[gracefulQueue].shift();
   var fn = elem[0];
   var args = elem[1];
   // these items may be unset if they were added by an older graceful-fs
@@ -1075,7 +1075,7 @@ function retry$4 () {
     } else {
       // if we can't do this job yet, push it to the end of the queue
       // and let the next iteration check again
-      fs$D[gracefulQueue].push(elem);
+      fs$B[gracefulQueue].push(elem);
     }
   }
 
@@ -1225,7 +1225,7 @@ function retry$4 () {
 	    'Warning', 'fs-extra-WARN0003'
 	  );
 	} 
-} (fs$E));
+} (fs$C));
 
 var makeDir$1 = {};
 
@@ -1247,7 +1247,7 @@ utils$y.checkPath = function checkPath (pth) {
   }
 };
 
-const fs$C = fs$E;
+const fs$A = fs$C;
 const { checkPath } = utils$y;
 
 const getMode = options => {
@@ -1259,7 +1259,7 @@ const getMode = options => {
 makeDir$1.makeDir = async (dir, options) => {
   checkPath(dir);
 
-  return fs$C.mkdir(dir, {
+  return fs$A.mkdir(dir, {
     mode: getMode(options),
     recursive: true
   })
@@ -1268,7 +1268,7 @@ makeDir$1.makeDir = async (dir, options) => {
 makeDir$1.makeDirSync = (dir, options) => {
   checkPath(dir);
 
-  return fs$C.mkdirSync(dir, {
+  return fs$A.mkdirSync(dir, {
     mode: getMode(options),
     recursive: true
   })
@@ -1289,31 +1289,31 @@ var mkdirs$2 = {
 };
 
 const u$f = universalify$1.fromPromise;
-const fs$B = fs$E;
+const fs$z = fs$C;
 
 function pathExists$7 (path) {
-  return fs$B.access(path).then(() => true).catch(() => false)
+  return fs$z.access(path).then(() => true).catch(() => false)
 }
 
 var pathExists_1 = {
   pathExists: u$f(pathExists$7),
-  pathExistsSync: fs$B.existsSync
+  pathExistsSync: fs$z.existsSync
 };
 
-const fs$A = fs$E;
+const fs$y = fs$C;
 const u$e = universalify$1.fromPromise;
 
 async function utimesMillis$1 (path, atime, mtime) {
   // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
-  const fd = await fs$A.open(path, 'r+');
+  const fd = await fs$y.open(path, 'r+');
 
   let closeErr = null;
 
   try {
-    await fs$A.futimes(fd, atime, mtime);
+    await fs$y.futimes(fd, atime, mtime);
   } finally {
     try {
-      await fs$A.close(fd);
+      await fs$y.close(fd);
     } catch (e) {
       closeErr = e;
     }
@@ -1325,9 +1325,9 @@ async function utimesMillis$1 (path, atime, mtime) {
 }
 
 function utimesMillisSync$1 (path, atime, mtime) {
-  const fd = fs$A.openSync(path, 'r+');
-  fs$A.futimesSync(fd, atime, mtime);
-  return fs$A.closeSync(fd)
+  const fd = fs$y.openSync(path, 'r+');
+  fs$y.futimesSync(fd, atime, mtime);
+  return fs$y.closeSync(fd)
 }
 
 var utimes = {
@@ -1335,14 +1335,14 @@ var utimes = {
   utimesMillisSync: utimesMillisSync$1
 };
 
-const fs$z = fs$E;
+const fs$x = fs$C;
 const path$x = require$$0$7;
 const u$d = universalify$1.fromPromise;
 
 function getStats$1 (src, dest, opts) {
   const statFunc = opts.dereference
-    ? (file) => fs$z.stat(file, { bigint: true })
-    : (file) => fs$z.lstat(file, { bigint: true });
+    ? (file) => fs$x.stat(file, { bigint: true })
+    : (file) => fs$x.lstat(file, { bigint: true });
   return Promise.all([
     statFunc(src),
     statFunc(dest).catch(err => {
@@ -1355,8 +1355,8 @@ function getStats$1 (src, dest, opts) {
 function getStatsSync (src, dest, opts) {
   let destStat;
   const statFunc = opts.dereference
-    ? (file) => fs$z.statSync(file, { bigint: true })
-    : (file) => fs$z.lstatSync(file, { bigint: true });
+    ? (file) => fs$x.statSync(file, { bigint: true })
+    : (file) => fs$x.lstatSync(file, { bigint: true });
   const srcStat = statFunc(src);
   try {
     destStat = statFunc(dest);
@@ -1434,7 +1434,7 @@ async function checkParentPaths (src, srcStat, dest, funcName) {
 
   let destStat;
   try {
-    destStat = await fs$z.stat(destParent, { bigint: true });
+    destStat = await fs$x.stat(destParent, { bigint: true });
   } catch (err) {
     if (err.code === 'ENOENT') return
     throw err
@@ -1453,7 +1453,7 @@ function checkParentPathsSync (src, srcStat, dest, funcName) {
   if (destParent === srcParent || destParent === path$x.parse(destParent).root) return
   let destStat;
   try {
-    destStat = fs$z.statSync(destParent, { bigint: true });
+    destStat = fs$x.statSync(destParent, { bigint: true });
   } catch (err) {
     if (err.code === 'ENOENT') return
     throw err
@@ -1492,7 +1492,7 @@ var stat$5 = {
   areIdentical: areIdentical$2
 };
 
-const fs$y = fs$E;
+const fs$w = fs$C;
 const path$w = require$$0$7;
 const { mkdirs: mkdirs$1 } = mkdirs$2;
 const { pathExists: pathExists$6 } = pathExists_1;
@@ -1540,7 +1540,7 @@ async function runFilter (src, dest, opts) {
 }
 
 async function getStatsAndPerformCopy (destStat, src, dest, opts) {
-  const statFn = opts.dereference ? fs$y.stat : fs$y.lstat;
+  const statFn = opts.dereference ? fs$w.stat : fs$w.lstat;
   const srcStat = await statFn(src);
 
   if (srcStat.isDirectory()) return onDir$1(srcStat, destStat, src, dest, opts)
@@ -1561,7 +1561,7 @@ async function onFile$1 (srcStat, destStat, src, dest, opts) {
   if (!destStat) return copyFile$1(srcStat, src, dest, opts)
 
   if (opts.overwrite) {
-    await fs$y.unlink(dest);
+    await fs$w.unlink(dest);
     return copyFile$1(srcStat, src, dest, opts)
   }
   if (opts.errorOnExist) {
@@ -1570,7 +1570,7 @@ async function onFile$1 (srcStat, destStat, src, dest, opts) {
 }
 
 async function copyFile$1 (srcStat, src, dest, opts) {
-  await fs$y.copyFile(src, dest);
+  await fs$w.copyFile(src, dest);
   if (opts.preserveTimestamps) {
     // Make sure the file is writable before setting the timestamp
     // otherwise open fails with EPERM when invoked with 'r+'
@@ -1584,11 +1584,11 @@ async function copyFile$1 (srcStat, src, dest, opts) {
     // Note that The initial srcStat.atime cannot be trusted
     // because it is modified by the read(2) system call
     // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
-    const updatedSrcStat = await fs$y.stat(src);
+    const updatedSrcStat = await fs$w.stat(src);
     await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
   }
 
-  return fs$y.chmod(dest, srcStat.mode)
+  return fs$w.chmod(dest, srcStat.mode)
 }
 
 function fileIsNotWritable$1 (srcMode) {
@@ -1596,16 +1596,16 @@ function fileIsNotWritable$1 (srcMode) {
 }
 
 function makeFileWritable$1 (dest, srcMode) {
-  return fs$y.chmod(dest, srcMode | 0o200)
+  return fs$w.chmod(dest, srcMode | 0o200)
 }
 
 async function onDir$1 (srcStat, destStat, src, dest, opts) {
   // the dest directory might not exist, create it
   if (!destStat) {
-    await fs$y.mkdir(dest);
+    await fs$w.mkdir(dest);
   }
 
-  const items = await fs$y.readdir(src);
+  const items = await fs$w.readdir(src);
 
   // loop through the files in the current directory to copy everything
   await Promise.all(items.map(async item => {
@@ -1624,27 +1624,27 @@ async function onDir$1 (srcStat, destStat, src, dest, opts) {
   }));
 
   if (!destStat) {
-    await fs$y.chmod(dest, srcStat.mode);
+    await fs$w.chmod(dest, srcStat.mode);
   }
 }
 
 async function onLink$1 (destStat, src, dest, opts) {
-  let resolvedSrc = await fs$y.readlink(src);
+  let resolvedSrc = await fs$w.readlink(src);
   if (opts.dereference) {
     resolvedSrc = path$w.resolve(process.cwd(), resolvedSrc);
   }
   if (!destStat) {
-    return fs$y.symlink(resolvedSrc, dest)
+    return fs$w.symlink(resolvedSrc, dest)
   }
 
   let resolvedDest = null;
   try {
-    resolvedDest = await fs$y.readlink(dest);
+    resolvedDest = await fs$w.readlink(dest);
   } catch (e) {
     // dest exists and is a regular file or directory,
     // Windows may throw UNKNOWN error. If dest already exists,
     // fs throws error anyway, so no need to guard against it here.
-    if (e.code === 'EINVAL' || e.code === 'UNKNOWN') return fs$y.symlink(resolvedSrc, dest)
+    if (e.code === 'EINVAL' || e.code === 'UNKNOWN') return fs$w.symlink(resolvedSrc, dest)
     throw e
   }
   if (opts.dereference) {
@@ -1662,13 +1662,13 @@ async function onLink$1 (destStat, src, dest, opts) {
   }
 
   // copy the link
-  await fs$y.unlink(dest);
-  return fs$y.symlink(resolvedSrc, dest)
+  await fs$w.unlink(dest);
+  return fs$w.symlink(resolvedSrc, dest)
 }
 
 var copy_1 = copy$2;
 
-const fs$x = gracefulFs;
+const fs$v = gracefulFs;
 const path$v = require$$0$7;
 const mkdirsSync$1 = mkdirs$2.mkdirsSync;
 const utimesMillisSync = utimes.utimesMillisSync;
@@ -1696,12 +1696,12 @@ function copySync$1 (src, dest, opts) {
   stat$3.checkParentPathsSync(src, srcStat, dest, 'copy');
   if (opts.filter && !opts.filter(src, dest)) return
   const destParent = path$v.dirname(dest);
-  if (!fs$x.existsSync(destParent)) mkdirsSync$1(destParent);
+  if (!fs$v.existsSync(destParent)) mkdirsSync$1(destParent);
   return getStats(destStat, src, dest, opts)
 }
 
 function getStats (destStat, src, dest, opts) {
-  const statSync = opts.dereference ? fs$x.statSync : fs$x.lstatSync;
+  const statSync = opts.dereference ? fs$v.statSync : fs$v.lstatSync;
   const srcStat = statSync(src);
 
   if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)
@@ -1721,7 +1721,7 @@ function onFile (srcStat, destStat, src, dest, opts) {
 
 function mayCopyFile (srcStat, src, dest, opts) {
   if (opts.overwrite) {
-    fs$x.unlinkSync(dest);
+    fs$v.unlinkSync(dest);
     return copyFile(srcStat, src, dest, opts)
   } else if (opts.errorOnExist) {
     throw new Error(`'${dest}' already exists`)
@@ -1729,7 +1729,7 @@ function mayCopyFile (srcStat, src, dest, opts) {
 }
 
 function copyFile (srcStat, src, dest, opts) {
-  fs$x.copyFileSync(src, dest);
+  fs$v.copyFileSync(src, dest);
   if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
   return setDestMode(dest, srcStat.mode)
 }
@@ -1751,14 +1751,14 @@ function makeFileWritable (dest, srcMode) {
 }
 
 function setDestMode (dest, srcMode) {
-  return fs$x.chmodSync(dest, srcMode)
+  return fs$v.chmodSync(dest, srcMode)
 }
 
 function setDestTimestamps (src, dest) {
   // The initial srcStat.atime cannot be trusted
   // because it is modified by the read(2) system call
   // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
-  const updatedSrcStat = fs$x.statSync(src);
+  const updatedSrcStat = fs$v.statSync(src);
   return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
 }
 
@@ -1768,13 +1768,13 @@ function onDir (srcStat, destStat, src, dest, opts) {
 }
 
 function mkDirAndCopy (srcMode, src, dest, opts) {
-  fs$x.mkdirSync(dest);
+  fs$v.mkdirSync(dest);
   copyDir(src, dest, opts);
   return setDestMode(dest, srcMode)
 }
 
 function copyDir (src, dest, opts) {
-  fs$x.readdirSync(src).forEach(item => copyDirItem(item, src, dest, opts));
+  fs$v.readdirSync(src).forEach(item => copyDirItem(item, src, dest, opts));
 }
 
 function copyDirItem (item, src, dest, opts) {
@@ -1786,22 +1786,22 @@ function copyDirItem (item, src, dest, opts) {
 }
 
 function onLink (destStat, src, dest, opts) {
-  let resolvedSrc = fs$x.readlinkSync(src);
+  let resolvedSrc = fs$v.readlinkSync(src);
   if (opts.dereference) {
     resolvedSrc = path$v.resolve(process.cwd(), resolvedSrc);
   }
 
   if (!destStat) {
-    return fs$x.symlinkSync(resolvedSrc, dest)
+    return fs$v.symlinkSync(resolvedSrc, dest)
   } else {
     let resolvedDest;
     try {
-      resolvedDest = fs$x.readlinkSync(dest);
+      resolvedDest = fs$v.readlinkSync(dest);
     } catch (err) {
       // dest exists and is a regular file or directory,
       // Windows may throw UNKNOWN error. If dest already exists,
       // fs throws error anyway, so no need to guard against it here.
-      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$x.symlinkSync(resolvedSrc, dest)
+      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$v.symlinkSync(resolvedSrc, dest)
       throw err
     }
     if (opts.dereference) {
@@ -1822,8 +1822,8 @@ function onLink (destStat, src, dest, opts) {
 }
 
 function copyLink (resolvedSrc, dest) {
-  fs$x.unlinkSync(dest);
-  return fs$x.symlinkSync(resolvedSrc, dest)
+  fs$v.unlinkSync(dest);
+  return fs$v.symlinkSync(resolvedSrc, dest)
 }
 
 var copySync_1 = copySync$1;
@@ -1834,15 +1834,15 @@ var copy$1 = {
   copySync: copySync_1
 };
 
-const fs$w = gracefulFs;
+const fs$u = gracefulFs;
 const u$b = universalify$1.fromCallback;
 
 function remove$3 (path, callback) {
-  fs$w.rm(path, { recursive: true, force: true }, callback);
+  fs$u.rm(path, { recursive: true, force: true }, callback);
 }
 
 function removeSync$1 (path) {
-  fs$w.rmSync(path, { recursive: true, force: true });
+  fs$u.rmSync(path, { recursive: true, force: true });
 }
 
 var remove_1 = {
@@ -1851,7 +1851,7 @@ var remove_1 = {
 };
 
 const u$a = universalify$1.fromPromise;
-const fs$v = fs$E;
+const fs$t = fs$C;
 const path$u = require$$0$7;
 const mkdir$4 = mkdirs$2;
 const remove$2 = remove_1;
@@ -1859,7 +1859,7 @@ const remove$2 = remove_1;
 const emptyDir = u$a(async function emptyDir (dir) {
   let items;
   try {
-    items = await fs$v.readdir(dir);
+    items = await fs$t.readdir(dir);
   } catch {
     return mkdir$4.mkdirs(dir)
   }
@@ -1870,7 +1870,7 @@ const emptyDir = u$a(async function emptyDir (dir) {
 function emptyDirSync (dir) {
   let items;
   try {
-    items = fs$v.readdirSync(dir);
+    items = fs$t.readdirSync(dir);
   } catch {
     return mkdir$4.mkdirsSync(dir)
   }
@@ -1890,13 +1890,13 @@ var empty = {
 
 const u$9 = universalify$1.fromPromise;
 const path$t = require$$0$7;
-const fs$u = fs$E;
+const fs$s = fs$C;
 const mkdir$3 = mkdirs$2;
 
 async function createFile$1 (file) {
   let stats;
   try {
-    stats = await fs$u.stat(file);
+    stats = await fs$s.stat(file);
   } catch { }
   if (stats && stats.isFile()) return
 
@@ -1904,12 +1904,12 @@ async function createFile$1 (file) {
 
   let dirStats = null;
   try {
-    dirStats = await fs$u.stat(dir);
+    dirStats = await fs$s.stat(dir);
   } catch (err) {
     // if the directory doesn't exist, make it
     if (err.code === 'ENOENT') {
       await mkdir$3.mkdirs(dir);
-      await fs$u.writeFile(file, '');
+      await fs$s.writeFile(file, '');
       return
     } else {
       throw err
@@ -1917,27 +1917,27 @@ async function createFile$1 (file) {
   }
 
   if (dirStats.isDirectory()) {
-    await fs$u.writeFile(file, '');
+    await fs$s.writeFile(file, '');
   } else {
     // parent is not a directory
     // This is just to cause an internal ENOTDIR error to be thrown
-    await fs$u.readdir(dir);
+    await fs$s.readdir(dir);
   }
 }
 
 function createFileSync$1 (file) {
   let stats;
   try {
-    stats = fs$u.statSync(file);
+    stats = fs$s.statSync(file);
   } catch { }
   if (stats && stats.isFile()) return
 
   const dir = path$t.dirname(file);
   try {
-    if (!fs$u.statSync(dir).isDirectory()) {
+    if (!fs$s.statSync(dir).isDirectory()) {
       // parent is not a directory
       // This is just to cause an internal ENOTDIR error to be thrown
-      fs$u.readdirSync(dir);
+      fs$s.readdirSync(dir);
     }
   } catch (err) {
     // If the stat call above failed because the directory doesn't exist, create it
@@ -1945,7 +1945,7 @@ function createFileSync$1 (file) {
     else throw err
   }
 
-  fs$u.writeFileSync(file, '');
+  fs$s.writeFileSync(file, '');
 }
 
 var file$1 = {
@@ -1955,7 +1955,7 @@ var file$1 = {
 
 const u$8 = universalify$1.fromPromise;
 const path$s = require$$0$7;
-const fs$t = fs$E;
+const fs$r = fs$C;
 const mkdir$2 = mkdirs$2;
 const { pathExists: pathExists$5 } = pathExists_1;
 const { areIdentical: areIdentical$1 } = stat$5;
@@ -1963,14 +1963,14 @@ const { areIdentical: areIdentical$1 } = stat$5;
 async function createLink$1 (srcpath, dstpath) {
   let dstStat;
   try {
-    dstStat = await fs$t.lstat(dstpath);
+    dstStat = await fs$r.lstat(dstpath);
   } catch {
     // ignore error
   }
 
   let srcStat;
   try {
-    srcStat = await fs$t.lstat(srcpath);
+    srcStat = await fs$r.lstat(srcpath);
   } catch (err) {
     err.message = err.message.replace('lstat', 'ensureLink');
     throw err
@@ -1986,17 +1986,17 @@ async function createLink$1 (srcpath, dstpath) {
     await mkdir$2.mkdirs(dir);
   }
 
-  await fs$t.link(srcpath, dstpath);
+  await fs$r.link(srcpath, dstpath);
 }
 
 function createLinkSync$1 (srcpath, dstpath) {
   let dstStat;
   try {
-    dstStat = fs$t.lstatSync(dstpath);
+    dstStat = fs$r.lstatSync(dstpath);
   } catch {}
 
   try {
-    const srcStat = fs$t.lstatSync(srcpath);
+    const srcStat = fs$r.lstatSync(srcpath);
     if (dstStat && areIdentical$1(srcStat, dstStat)) return
   } catch (err) {
     err.message = err.message.replace('lstat', 'ensureLink');
@@ -2004,11 +2004,11 @@ function createLinkSync$1 (srcpath, dstpath) {
   }
 
   const dir = path$s.dirname(dstpath);
-  const dirExists = fs$t.existsSync(dir);
-  if (dirExists) return fs$t.linkSync(srcpath, dstpath)
+  const dirExists = fs$r.existsSync(dir);
+  if (dirExists) return fs$r.linkSync(srcpath, dstpath)
   mkdir$2.mkdirsSync(dir);
 
-  return fs$t.linkSync(srcpath, dstpath)
+  return fs$r.linkSync(srcpath, dstpath)
 }
 
 var link = {
@@ -2017,7 +2017,7 @@ var link = {
 };
 
 const path$r = require$$0$7;
-const fs$s = fs$E;
+const fs$q = fs$C;
 const { pathExists: pathExists$4 } = pathExists_1;
 
 const u$7 = universalify$1.fromPromise;
@@ -2047,7 +2047,7 @@ const u$7 = universalify$1.fromPromise;
 async function symlinkPaths$1 (srcpath, dstpath) {
   if (path$r.isAbsolute(srcpath)) {
     try {
-      await fs$s.lstat(srcpath);
+      await fs$q.lstat(srcpath);
     } catch (err) {
       err.message = err.message.replace('lstat', 'ensureSymlink');
       throw err
@@ -2071,7 +2071,7 @@ async function symlinkPaths$1 (srcpath, dstpath) {
   }
 
   try {
-    await fs$s.lstat(srcpath);
+    await fs$q.lstat(srcpath);
   } catch (err) {
     err.message = err.message.replace('lstat', 'ensureSymlink');
     throw err
@@ -2085,7 +2085,7 @@ async function symlinkPaths$1 (srcpath, dstpath) {
 
 function symlinkPathsSync$1 (srcpath, dstpath) {
   if (path$r.isAbsolute(srcpath)) {
-    const exists = fs$s.existsSync(srcpath);
+    const exists = fs$q.existsSync(srcpath);
     if (!exists) throw new Error('absolute srcpath does not exist')
     return {
       toCwd: srcpath,
@@ -2095,7 +2095,7 @@ function symlinkPathsSync$1 (srcpath, dstpath) {
 
   const dstdir = path$r.dirname(dstpath);
   const relativeToDst = path$r.join(dstdir, srcpath);
-  const exists = fs$s.existsSync(relativeToDst);
+  const exists = fs$q.existsSync(relativeToDst);
   if (exists) {
     return {
       toCwd: relativeToDst,
@@ -2103,7 +2103,7 @@ function symlinkPathsSync$1 (srcpath, dstpath) {
     }
   }
 
-  const srcExists = fs$s.existsSync(srcpath);
+  const srcExists = fs$q.existsSync(srcpath);
   if (!srcExists) throw new Error('relative srcpath does not exist')
   return {
     toCwd: srcpath,
@@ -2116,7 +2116,7 @@ var symlinkPaths_1 = {
   symlinkPathsSync: symlinkPathsSync$1
 };
 
-const fs$r = fs$E;
+const fs$p = fs$C;
 const u$6 = universalify$1.fromPromise;
 
 async function symlinkType$1 (srcpath, type) {
@@ -2124,7 +2124,7 @@ async function symlinkType$1 (srcpath, type) {
 
   let stats;
   try {
-    stats = await fs$r.lstat(srcpath);
+    stats = await fs$p.lstat(srcpath);
   } catch {
     return 'file'
   }
@@ -2137,7 +2137,7 @@ function symlinkTypeSync$1 (srcpath, type) {
 
   let stats;
   try {
-    stats = fs$r.lstatSync(srcpath);
+    stats = fs$p.lstatSync(srcpath);
   } catch {
     return 'file'
   }
@@ -2151,7 +2151,7 @@ var symlinkType_1 = {
 
 const u$5 = universalify$1.fromPromise;
 const path$q = require$$0$7;
-const fs$q = fs$E;
+const fs$o = fs$C;
 
 const { mkdirs, mkdirsSync } = mkdirs$2;
 
@@ -2165,13 +2165,13 @@ const { areIdentical } = stat$5;
 async function createSymlink$1 (srcpath, dstpath, type) {
   let stats;
   try {
-    stats = await fs$q.lstat(dstpath);
+    stats = await fs$o.lstat(dstpath);
   } catch { }
 
   if (stats && stats.isSymbolicLink()) {
     const [srcStat, dstStat] = await Promise.all([
-      fs$q.stat(srcpath),
-      fs$q.stat(dstpath)
+      fs$o.stat(srcpath),
+      fs$o.stat(dstpath)
     ]);
 
     if (areIdentical(srcStat, dstStat)) return
@@ -2186,17 +2186,17 @@ async function createSymlink$1 (srcpath, dstpath, type) {
     await mkdirs(dir);
   }
 
-  return fs$q.symlink(srcpath, dstpath, toType)
+  return fs$o.symlink(srcpath, dstpath, toType)
 }
 
 function createSymlinkSync$1 (srcpath, dstpath, type) {
   let stats;
   try {
-    stats = fs$q.lstatSync(dstpath);
+    stats = fs$o.lstatSync(dstpath);
   } catch { }
   if (stats && stats.isSymbolicLink()) {
-    const srcStat = fs$q.statSync(srcpath);
-    const dstStat = fs$q.statSync(dstpath);
+    const srcStat = fs$o.statSync(srcpath);
+    const dstStat = fs$o.statSync(dstpath);
     if (areIdentical(srcStat, dstStat)) return
   }
 
@@ -2204,10 +2204,10 @@ function createSymlinkSync$1 (srcpath, dstpath, type) {
   srcpath = relative.toDst;
   type = symlinkTypeSync(relative.toCwd, type);
   const dir = path$q.dirname(dstpath);
-  const exists = fs$q.existsSync(dir);
-  if (exists) return fs$q.symlinkSync(srcpath, dstpath, type)
+  const exists = fs$o.existsSync(dir);
+  if (exists) return fs$o.symlinkSync(srcpath, dstpath, type)
   mkdirsSync(dir);
-  return fs$q.symlinkSync(srcpath, dstpath, type)
+  return fs$o.symlinkSync(srcpath, dstpath, type)
 }
 
 var symlink = {
@@ -2352,7 +2352,7 @@ var jsonfile = {
 };
 
 const u$4 = universalify$1.fromPromise;
-const fs$p = fs$E;
+const fs$n = fs$C;
 const path$p = require$$0$7;
 const mkdir$1 = mkdirs$2;
 const pathExists$2 = pathExists_1.pathExists;
@@ -2364,16 +2364,16 @@ async function outputFile$1 (file, data, encoding = 'utf-8') {
     await mkdir$1.mkdirs(dir);
   }
 
-  return fs$p.writeFile(file, data, encoding)
+  return fs$n.writeFile(file, data, encoding)
 }
 
 function outputFileSync$1 (file, ...args) {
   const dir = path$p.dirname(file);
-  if (!fs$p.existsSync(dir)) {
+  if (!fs$n.existsSync(dir)) {
     mkdir$1.mkdirsSync(dir);
   }
 
-  fs$p.writeFileSync(file, ...args);
+  fs$n.writeFileSync(file, ...args);
 }
 
 var outputFile_1 = {
@@ -2418,7 +2418,7 @@ jsonFile.readJSONSync = jsonFile.readJsonSync;
 
 var json$3 = jsonFile;
 
-const fs$o = fs$E;
+const fs$m = fs$C;
 const path$o = require$$0$7;
 const { copy } = copy$1;
 const { remove: remove$1 } = remove_1;
@@ -2454,7 +2454,7 @@ async function doRename$1 (src, dest, overwrite, isChangingCase) {
 
   try {
     // Try w/ rename first, and try copy + remove if EXDEV
-    await fs$o.rename(src, dest);
+    await fs$m.rename(src, dest);
   } catch (err) {
     if (err.code !== 'EXDEV') {
       throw err
@@ -2476,7 +2476,7 @@ async function moveAcrossDevice$1 (src, dest, overwrite) {
 
 var move_1 = move$1;
 
-const fs$n = gracefulFs;
+const fs$l = gracefulFs;
 const path$n = require$$0$7;
 const copySync = copy$1.copySync;
 const removeSync = remove_1.removeSync;
@@ -2505,13 +2505,13 @@ function doRename (src, dest, overwrite, isChangingCase) {
     removeSync(dest);
     return rename(src, dest, overwrite)
   }
-  if (fs$n.existsSync(dest)) throw new Error('dest already exists.')
+  if (fs$l.existsSync(dest)) throw new Error('dest already exists.')
   return rename(src, dest, overwrite)
 }
 
 function rename (src, dest, overwrite) {
   try {
-    fs$n.renameSync(src, dest);
+    fs$l.renameSync(src, dest);
   } catch (err) {
     if (err.code !== 'EXDEV') throw err
     return moveAcrossDevice(src, dest, overwrite)
@@ -2538,7 +2538,7 @@ var move = {
 
 var lib$3 = {
   // Export promiseified graceful-fs:
-  ...fs$E,
+  ...fs$C,
   // Export extra methods:
   ...copy$1,
   ...empty,
@@ -2551,7 +2551,7 @@ var lib$3 = {
   ...remove_1
 };
 
-var fs$m = /*@__PURE__*/getDefaultExportFromCjs(lib$3);
+var fs$k = /*@__PURE__*/getDefaultExportFromCjs(lib$3);
 
 var tasks = {};
 
@@ -2590,10 +2590,10 @@ function isEnoentCodeError(error) {
 }
 errno$1.isEnoentCodeError = isEnoentCodeError;
 
-var fs$l = {};
+var fs$j = {};
 
-Object.defineProperty(fs$l, "__esModule", { value: true });
-fs$l.createDirentFromStats = void 0;
+Object.defineProperty(fs$j, "__esModule", { value: true });
+fs$j.createDirentFromStats = void 0;
 let DirentFromStats$1 = class DirentFromStats {
     constructor(name, stats) {
         this.name = name;
@@ -2609,7 +2609,7 @@ let DirentFromStats$1 = class DirentFromStats {
 function createDirentFromStats$1(name, stats) {
     return new DirentFromStats$1(name, stats);
 }
-fs$l.createDirentFromStats = createDirentFromStats$1;
+fs$j.createDirentFromStats = createDirentFromStats$1;
 
 var path$m = {};
 
@@ -7241,8 +7241,8 @@ const array = array$1;
 utils$w.array = array;
 const errno = errno$1;
 utils$w.errno = errno;
-const fs$k = fs$l;
-utils$w.fs = fs$k;
+const fs$i = fs$j;
+utils$w.fs = fs$i;
 const path$h = path$m;
 utils$w.path = path$h;
 const pattern = pattern$1;
@@ -7443,7 +7443,7 @@ sync$9.read = read$2;
 
 var settings$3 = {};
 
-var fs$j = {};
+var fs$h = {};
 
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
@@ -7462,15 +7462,15 @@ var fs$j = {};
 	    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
 	}
 	exports.createFileSystemAdapter = createFileSystemAdapter; 
-} (fs$j));
+} (fs$h));
 
 Object.defineProperty(settings$3, "__esModule", { value: true });
-const fs$i = fs$j;
+const fs$g = fs$h;
 let Settings$2 = class Settings {
     constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
-        this.fs = fs$i.createFileSystemAdapter(this._options.fs);
+        this.fs = fs$g.createFileSystemAdapter(this._options.fs);
         this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
     }
@@ -7591,10 +7591,10 @@ constants$h.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCH
 
 var utils$l = {};
 
-var fs$h = {};
+var fs$f = {};
 
-Object.defineProperty(fs$h, "__esModule", { value: true });
-fs$h.createDirentFromStats = void 0;
+Object.defineProperty(fs$f, "__esModule", { value: true });
+fs$f.createDirentFromStats = void 0;
 class DirentFromStats {
     constructor(name, stats) {
         this.name = name;
@@ -7610,12 +7610,12 @@ class DirentFromStats {
 function createDirentFromStats(name, stats) {
     return new DirentFromStats(name, stats);
 }
-fs$h.createDirentFromStats = createDirentFromStats;
+fs$f.createDirentFromStats = createDirentFromStats;
 
 Object.defineProperty(utils$l, "__esModule", { value: true });
 utils$l.fs = void 0;
-const fs$g = fs$h;
-utils$l.fs = fs$g;
+const fs$e = fs$f;
+utils$l.fs = fs$e;
 
 var common$c = {};
 
@@ -7794,7 +7794,7 @@ sync$7.readdir = readdir;
 
 var settings$2 = {};
 
-var fs$f = {};
+var fs$d = {};
 
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
@@ -7815,17 +7815,17 @@ var fs$f = {};
 	    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
 	}
 	exports.createFileSystemAdapter = createFileSystemAdapter; 
-} (fs$f));
+} (fs$d));
 
 Object.defineProperty(settings$2, "__esModule", { value: true });
 const path$g = require$$0$7;
 const fsStat$3 = out$1;
-const fs$e = fs$f;
+const fs$c = fs$d;
 let Settings$1 = class Settings {
     constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
-        this.fs = fs$e.createFileSystemAdapter(this._options.fs);
+        this.fs = fs$c.createFileSystemAdapter(this._options.fs);
         this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$g.sep);
         this.stats = this._getValue(this._options.stats, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
@@ -11351,44 +11351,44 @@ const RETRYIFY_OPTIONS = {
 const FS = {
     attempt: {
         /* ASYNC */
-        chmod: attemptifyAsync(require$$3$1.promisify(fs$F.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-        chown: attemptifyAsync(require$$3$1.promisify(fs$F.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-        close: attemptifyAsync(require$$3$1.promisify(fs$F.close), ATTEMPTIFY_NOOP_OPTIONS),
-        fsync: attemptifyAsync(require$$3$1.promisify(fs$F.fsync), ATTEMPTIFY_NOOP_OPTIONS),
-        mkdir: attemptifyAsync(require$$3$1.promisify(fs$F.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
-        realpath: attemptifyAsync(require$$3$1.promisify(fs$F.realpath), ATTEMPTIFY_NOOP_OPTIONS),
-        stat: attemptifyAsync(require$$3$1.promisify(fs$F.stat), ATTEMPTIFY_NOOP_OPTIONS),
-        unlink: attemptifyAsync(require$$3$1.promisify(fs$F.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+        chmod: attemptifyAsync(require$$3$1.promisify(fs$D.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+        chown: attemptifyAsync(require$$3$1.promisify(fs$D.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+        close: attemptifyAsync(require$$3$1.promisify(fs$D.close), ATTEMPTIFY_NOOP_OPTIONS),
+        fsync: attemptifyAsync(require$$3$1.promisify(fs$D.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+        mkdir: attemptifyAsync(require$$3$1.promisify(fs$D.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+        realpath: attemptifyAsync(require$$3$1.promisify(fs$D.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+        stat: attemptifyAsync(require$$3$1.promisify(fs$D.stat), ATTEMPTIFY_NOOP_OPTIONS),
+        unlink: attemptifyAsync(require$$3$1.promisify(fs$D.unlink), ATTEMPTIFY_NOOP_OPTIONS),
         /* SYNC */
-        chmodSync: attemptifySync(fs$F.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-        chownSync: attemptifySync(fs$F.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-        closeSync: attemptifySync(fs$F.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
-        existsSync: attemptifySync(fs$F.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
-        fsyncSync: attemptifySync(fs$F.fsync, ATTEMPTIFY_NOOP_OPTIONS),
-        mkdirSync: attemptifySync(fs$F.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
-        realpathSync: attemptifySync(fs$F.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
-        statSync: attemptifySync(fs$F.statSync, ATTEMPTIFY_NOOP_OPTIONS),
-        unlinkSync: attemptifySync(fs$F.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
+        chmodSync: attemptifySync(fs$D.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+        chownSync: attemptifySync(fs$D.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+        closeSync: attemptifySync(fs$D.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+        existsSync: attemptifySync(fs$D.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+        fsyncSync: attemptifySync(fs$D.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+        mkdirSync: attemptifySync(fs$D.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+        realpathSync: attemptifySync(fs$D.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+        statSync: attemptifySync(fs$D.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+        unlinkSync: attemptifySync(fs$D.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
     },
     retry: {
         /* ASYNC */
-        close: retryifyAsync(require$$3$1.promisify(fs$F.close), RETRYIFY_OPTIONS),
-        fsync: retryifyAsync(require$$3$1.promisify(fs$F.fsync), RETRYIFY_OPTIONS),
-        open: retryifyAsync(require$$3$1.promisify(fs$F.open), RETRYIFY_OPTIONS),
-        readFile: retryifyAsync(require$$3$1.promisify(fs$F.readFile), RETRYIFY_OPTIONS),
-        rename: retryifyAsync(require$$3$1.promisify(fs$F.rename), RETRYIFY_OPTIONS),
-        stat: retryifyAsync(require$$3$1.promisify(fs$F.stat), RETRYIFY_OPTIONS),
-        write: retryifyAsync(require$$3$1.promisify(fs$F.write), RETRYIFY_OPTIONS),
-        writeFile: retryifyAsync(require$$3$1.promisify(fs$F.writeFile), RETRYIFY_OPTIONS),
+        close: retryifyAsync(require$$3$1.promisify(fs$D.close), RETRYIFY_OPTIONS),
+        fsync: retryifyAsync(require$$3$1.promisify(fs$D.fsync), RETRYIFY_OPTIONS),
+        open: retryifyAsync(require$$3$1.promisify(fs$D.open), RETRYIFY_OPTIONS),
+        readFile: retryifyAsync(require$$3$1.promisify(fs$D.readFile), RETRYIFY_OPTIONS),
+        rename: retryifyAsync(require$$3$1.promisify(fs$D.rename), RETRYIFY_OPTIONS),
+        stat: retryifyAsync(require$$3$1.promisify(fs$D.stat), RETRYIFY_OPTIONS),
+        write: retryifyAsync(require$$3$1.promisify(fs$D.write), RETRYIFY_OPTIONS),
+        writeFile: retryifyAsync(require$$3$1.promisify(fs$D.writeFile), RETRYIFY_OPTIONS),
         /* SYNC */
-        closeSync: retryifySync(fs$F.closeSync, RETRYIFY_OPTIONS),
-        fsyncSync: retryifySync(fs$F.fsyncSync, RETRYIFY_OPTIONS),
-        openSync: retryifySync(fs$F.openSync, RETRYIFY_OPTIONS),
-        readFileSync: retryifySync(fs$F.readFileSync, RETRYIFY_OPTIONS),
-        renameSync: retryifySync(fs$F.renameSync, RETRYIFY_OPTIONS),
-        statSync: retryifySync(fs$F.statSync, RETRYIFY_OPTIONS),
-        writeSync: retryifySync(fs$F.writeSync, RETRYIFY_OPTIONS),
-        writeFileSync: retryifySync(fs$F.writeFileSync, RETRYIFY_OPTIONS)
+        closeSync: retryifySync(fs$D.closeSync, RETRYIFY_OPTIONS),
+        fsyncSync: retryifySync(fs$D.fsyncSync, RETRYIFY_OPTIONS),
+        openSync: retryifySync(fs$D.openSync, RETRYIFY_OPTIONS),
+        readFileSync: retryifySync(fs$D.readFileSync, RETRYIFY_OPTIONS),
+        renameSync: retryifySync(fs$D.renameSync, RETRYIFY_OPTIONS),
+        statSync: retryifySync(fs$D.statSync, RETRYIFY_OPTIONS),
+        writeSync: retryifySync(fs$D.writeSync, RETRYIFY_OPTIONS),
+        writeFileSync: retryifySync(fs$D.writeFileSync, RETRYIFY_OPTIONS)
     }
 };
 
@@ -11625,7 +11625,7 @@ async function writeFileAsync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
             await FS.retry.write(retryOptions)(fd, data, 0, options.encoding || DEFAULT_ENCODING);
         }
         else if (data instanceof require$$0$b.Readable) {
-            const writeStream = fs$F.createWriteStream(tempPath, { fd, autoClose: false });
+            const writeStream = fs$D.createWriteStream(tempPath, { fd, autoClose: false });
             const finishPromise = EventEmitter$l.once(writeStream, 'finish');
             data.pipe(writeStream);
             await finishPromise;
@@ -11744,8 +11744,8 @@ class CommonPreset {
     // 读取所有预设
     async list() {
         const presetsPath = this.filepath;
-        if (await fs$m.pathExists(presetsPath)) {
-            const presets = await fs$m.readJSON(presetsPath);
+        if (await fs$k.pathExists(presetsPath)) {
+            const presets = await fs$k.readJSON(presetsPath);
             presets.map((preset) => {
                 preset.config = { ...this.defaultConfig, ...preset.config };
                 return preset;
@@ -12169,6 +12169,7 @@ const APP_DEFAULT_CONFIG = {
             quality: "origin",
             formatName: "auto",
             cookie: "",
+            cookieMode: "all",
             doubleScreen: true,
             api: "web",
             checkInterval: undefined,
@@ -12639,6 +12640,7 @@ const defaultRecordConfig = {
     recorderType: "ffmpeg",
     cookie: "",
     proxy: "",
+    cookieMode: "all",
     doubleScreen: true,
     useServerTimestamp: false,
     handleTime: [null, null],
@@ -40048,7 +40050,7 @@ var path$c = require$$0$7;
 var http$e = require$$1$4;
 var https$b = require$$1$5;
 var parseUrl$2 = require$$0$9.parse;
-var fs$d = require$$0$6;
+var fs$b = require$$0$6;
 var Stream$2 = require$$0$4.Stream;
 var crypto$c = require$$1$6;
 var mime = mimeTypes$3;
@@ -40175,7 +40177,7 @@ FormData$1.prototype._lengthRetriever = function (value, callback) {
       // not that fast snoopy
     } else {
       // still need to fetch file size from fs
-      fs$d.stat(value.path, function (err, stat) {
+      fs$b.stat(value.path, function (err, stat) {
         if (err) {
           callback(err);
           return;
@@ -47305,7 +47307,7 @@ const {
   mergeConfig,
 } = axios;
 
-const fs$c = require$$0$6;
+const fs$a = require$$0$6;
 const path$b = require$$0$7;
 
 var packageJson$1 = {
@@ -47341,7 +47343,7 @@ function tryReadJsonAt(...searchPaths) {
       return undefined;
     }
 
-    const json = JSON.parse(fs$c.readFileSync(fileName, 'utf8'));
+    const json = JSON.parse(fs$a.readFileSync(fileName, 'utf8'));
     const name = json?.productName || json?.name;
     if (!name || name.toLowerCase() === 'electron') {
       return undefined;
@@ -47370,7 +47372,7 @@ function findUp(fileName, cwd) {
     const root = parsedPath.root;
     const dir = parsedPath.dir;
 
-    if (fs$c.existsSync(path$b.join(currentPath, fileName))) {
+    if (fs$a.existsSync(path$b.join(currentPath, fileName))) {
       return path$b.resolve(path$b.join(currentPath, fileName));
     }
 
@@ -48722,7 +48724,7 @@ function levelToStyle(level) {
 }
 
 const EventEmitter$k = require$$0$8;
-const fs$b = require$$0$6;
+const fs$9 = require$$0$6;
 const os$2 = require$$1$2;
 
 let File$3 = class File extends EventEmitter$k {
@@ -48752,7 +48754,7 @@ let File$3 = class File extends EventEmitter$k {
 
   clear() {
     try {
-      fs$b.writeFileSync(this.path, '', {
+      fs$9.writeFileSync(this.path, '', {
         mode: this.writeOptions.mode,
         flag: 'w',
       });
@@ -48785,7 +48787,7 @@ let File$3 = class File extends EventEmitter$k {
   getSize() {
     if (this.initialSize === undefined) {
       try {
-        const stats = fs$b.statSync(this.path);
+        const stats = fs$9.statSync(this.path);
         this.initialSize = stats.size;
       } catch (e) {
         this.initialSize = 0;
@@ -48814,7 +48816,7 @@ let File$3 = class File extends EventEmitter$k {
     this.asyncWriteQueue = [];
     this.hasActiveAsyncWriting = true;
 
-    fs$b.writeFile(this.path, text, this.writeOptions, (e) => {
+    fs$9.writeFile(this.path, text, this.writeOptions, (e) => {
       file.hasActiveAsyncWriting = false;
 
       if (e) {
@@ -48850,7 +48852,7 @@ let File$3 = class File extends EventEmitter$k {
     }
 
     try {
-      fs$b.writeFileSync(this.path, text, this.writeOptions);
+      fs$9.writeFileSync(this.path, text, this.writeOptions);
       this.increaseBytesWrittenCounter(text);
     } catch (e) {
       this.emit(
@@ -48866,14 +48868,14 @@ var File_1 = File$3;
 
 function readFileSyncFromEnd(filePath, bytesCount) {
   const buffer = Buffer.alloc(bytesCount);
-  const stats = fs$b.statSync(filePath);
+  const stats = fs$9.statSync(filePath);
 
   const readLength = Math.min(stats.size, bytesCount);
   const offset = Math.max(0, stats.size - bytesCount);
 
-  const fd = fs$b.openSync(filePath, 'r');
-  const totalBytes = fs$b.readSync(fd, buffer, 0, readLength, offset);
-  fs$b.closeSync(fd);
+  const fd = fs$9.openSync(filePath, 'r');
+  const totalBytes = fs$9.readSync(fd, buffer, 0, readLength, offset);
+  fs$9.closeSync(fd);
 
   return buffer.toString('utf8', 0, totalBytes);
 }
@@ -48905,7 +48907,7 @@ let NullFile$1 = class NullFile extends File$2 {
 var NullFile_1 = NullFile$1;
 
 const EventEmitter$j = require$$0$8;
-const fs$a = require$$0$6;
+const fs$8 = require$$0$6;
 const path$9 = require$$0$7;
 const File$1 = File_1;
 const NullFile = NullFile_1;
@@ -48972,14 +48974,14 @@ let FileRegistry$1 = class FileRegistry extends EventEmitter$j {
    * @private
    */
   testFileWriting({ filePath, writeOptions }) {
-    fs$a.mkdirSync(path$9.dirname(filePath), { recursive: true });
-    fs$a.writeFileSync(filePath, '', { flag: 'a', mode: writeOptions.mode });
+    fs$8.mkdirSync(path$9.dirname(filePath), { recursive: true });
+    fs$8.writeFileSync(filePath, '', { flag: 'a', mode: writeOptions.mode });
   }
 };
 
 var FileRegistry_1 = FileRegistry$1;
 
-const fs$9 = require$$0$6;
+const fs$7 = require$$0$6;
 const os$1 = require$$1$2;
 const path$8 = require$$0$7;
 const FileRegistry = FileRegistry_1;
@@ -49025,7 +49027,7 @@ function fileTransportFactory(
       const oldPath = file.toString();
       const inf = path$8.parse(oldPath);
       try {
-        fs$9.renameSync(oldPath, path$8.join(inf.dir, `${inf.name}.old${inf.ext}`));
+        fs$7.renameSync(oldPath, path$8.join(inf.dir, `${inf.name}.old${inf.ext}`));
       } catch (e) {
         logConsole('Could not rotate log', e);
         const quarterOfMaxSize = Math.round(transport.maxSize / 4);
@@ -49114,18 +49116,18 @@ function fileTransportFactory(
     initializeOnFirstAccess();
     const logsPath = path$8.dirname(transport.resolvePathFn(pathVariables));
 
-    if (!fs$9.existsSync(logsPath)) {
+    if (!fs$7.existsSync(logsPath)) {
       return [];
     }
 
-    return fs$9.readdirSync(logsPath)
+    return fs$7.readdirSync(logsPath)
       .map((fileName) => path$8.join(logsPath, fileName))
       .filter(fileFilter)
       .map((logPath) => {
         try {
           return {
             path: logPath,
-            lines: fs$9.readFileSync(logPath, 'utf8').split(os$1.EOL),
+            lines: fs$7.readFileSync(logPath, 'utf8').split(os$1.EOL),
           };
         } catch {
           return null;
@@ -49584,6 +49586,14 @@ class RecordHistoryModel extends BaseModel {
         });
         return resultMap;
     }
+    getRecordStartTimes(streamerId, startTime, endTime) {
+        const rows = this.db
+            .prepare(`SELECT record_start_time FROM ${this.tableName}
+         WHERE streamer_id = ? AND record_start_time >= ? AND record_start_time < ?
+         ORDER BY record_start_time`)
+            .all(streamerId, startTime, endTime);
+        return rows.map((row) => row.record_start_time);
+    }
     /**
      * 分页查询记录历史,支持时间范围过滤和排序
      * @param options 查询参数
@@ -50035,6 +50045,9 @@ class RecordHistoryService {
     getLastRecordTimes(streamerIds) {
         return this.recordHistoryModel.getLastRecordTimes(streamerIds);
     }
+    getRecordStartTimes(streamerId, startTime, endTime) {
+        return this.recordHistoryModel.getRecordStartTimes(streamerId, startTime, endTime);
+    }
     /**
      * 查询总视频时长，默认查询最近一个月
      * @param options 查询参数
@@ -50746,7 +50759,7 @@ var old$1 = {};
 
 var pathModule = require$$0$7;
 var isWindows$2 = process.platform === 'win32';
-var fs$8 = require$$0$6;
+var fs$6 = require$$0$6;
 
 // JavaScript implementation of realpath, ported from node pre-v6
 
@@ -50841,7 +50854,7 @@ old$1.realpathSync = function realpathSync(p, cache) {
 
     // On windows, check that the root exists. On unix there is no need.
     if (isWindows$2 && !knownHard[base]) {
-      fs$8.lstatSync(base);
+      fs$6.lstatSync(base);
       knownHard[base] = true;
     }
   }
@@ -50868,7 +50881,7 @@ old$1.realpathSync = function realpathSync(p, cache) {
       // some known symbolic link.  no need to stat again.
       resolvedLink = cache[base];
     } else {
-      var stat = fs$8.lstatSync(base);
+      var stat = fs$6.lstatSync(base);
       if (!stat.isSymbolicLink()) {
         knownHard[base] = true;
         if (cache) cache[base] = base;
@@ -50885,8 +50898,8 @@ old$1.realpathSync = function realpathSync(p, cache) {
         }
       }
       if (linkTarget === null) {
-        fs$8.statSync(base);
-        linkTarget = fs$8.readlinkSync(base);
+        fs$6.statSync(base);
+        linkTarget = fs$6.readlinkSync(base);
       }
       resolvedLink = pathModule.resolve(previous, linkTarget);
       // track this, if given a cache.
@@ -50943,7 +50956,7 @@ old$1.realpath = function realpath(p, cache, cb) {
 
     // On windows, check that the root exists. On unix there is no need.
     if (isWindows$2 && !knownHard[base]) {
-      fs$8.lstat(base, function(err) {
+      fs$6.lstat(base, function(err) {
         if (err) return cb(err);
         knownHard[base] = true;
         LOOP();
@@ -50980,7 +50993,7 @@ old$1.realpath = function realpath(p, cache, cb) {
       return gotResolvedLink(cache[base]);
     }
 
-    return fs$8.lstat(base, gotStat);
+    return fs$6.lstat(base, gotStat);
   }
 
   function gotStat(err, stat) {
@@ -51002,10 +51015,10 @@ old$1.realpath = function realpath(p, cache, cb) {
         return gotTarget(null, seenLinks[id], base);
       }
     }
-    fs$8.stat(base, function(err) {
+    fs$6.stat(base, function(err) {
       if (err) return cb(err);
 
-      fs$8.readlink(base, function(err, target) {
+      fs$6.readlink(base, function(err, target) {
         if (!isWindows$2) seenLinks[id] = target;
         gotTarget(err, target);
       });
@@ -51034,9 +51047,9 @@ realpath.realpathSync = realpathSync;
 realpath.monkeypatch = monkeypatch;
 realpath.unmonkeypatch = unmonkeypatch;
 
-var fs$7 = require$$0$6;
-var origRealpath = fs$7.realpath;
-var origRealpathSync = fs$7.realpathSync;
+var fs$5 = require$$0$6;
+var origRealpath = fs$5.realpath;
+var origRealpathSync = fs$5.realpathSync;
 
 var version$2 = process.version;
 var ok = /^v[0-5]\./.test(version$2);
@@ -51085,13 +51098,13 @@ function realpathSync (p, cache) {
 }
 
 function monkeypatch () {
-  fs$7.realpath = realpath;
-  fs$7.realpathSync = realpathSync;
+  fs$5.realpath = realpath;
+  fs$5.realpathSync = realpathSync;
 }
 
 function unmonkeypatch () {
-  fs$7.realpath = origRealpath;
-  fs$7.realpathSync = origRealpathSync;
+  fs$5.realpath = origRealpath;
+  fs$5.realpathSync = origRealpathSync;
 }
 
 var concatMap$1 = function (xs, fn) {
@@ -52403,7 +52416,7 @@ function ownProp (obj, field) {
   return Object.prototype.hasOwnProperty.call(obj, field)
 }
 
-var fs$6 = require$$0$6;
+var fs$4 = require$$0$6;
 var path$6 = require$$0$7;
 var minimatch = minimatch_1;
 var isAbsolute = pathIsAbsoluteExports;
@@ -52469,7 +52482,7 @@ function setopts (self, pattern, options) {
   self.stat = !!options.stat;
   self.noprocess = !!options.noprocess;
   self.absolute = !!options.absolute;
-  self.fs = options.fs || fs$6;
+  self.fs = options.fs || fs$4;
 
   self.maxLength = options.maxLength || Infinity;
   self.cache = options.cache || Object.create(null);
@@ -54138,7 +54151,7 @@ var dirGlob$1 = {exports: {}};
 
 var pathType$1 = {};
 
-const fs$5 = require$$0$6;
+const fs$3 = require$$0$6;
 const pify$2 = pify$3;
 
 function type$1(fn, fn2, fp) {
@@ -54146,7 +54159,7 @@ function type$1(fn, fn2, fp) {
 		return Promise.reject(new TypeError(`Expected a string, got ${typeof fp}`));
 	}
 
-	return pify$2(fs$5[fn])(fp)
+	return pify$2(fs$3[fn])(fp)
 		.then(stats => stats[fn2]())
 		.catch(err => {
 			if (err.code === 'ENOENT') {
@@ -54163,7 +54176,7 @@ function typeSync(fn, fn2, fp) {
 	}
 
 	try {
-		return fs$5[fn](fp)[fn2]();
+		return fs$3[fn](fp)[fn2]();
 	} catch (err) {
 		if (err.code === 'ENOENT') {
 			return false;
@@ -54684,7 +54697,7 @@ var slash$1 = function (str) {
 	return str.replace(/\\/g, '/');
 };
 
-const fs$4 = require$$0$6;
+const fs$2 = require$$0$6;
 const path$4 = require$$0$7;
 const glob$1 = requireGlob();
 const gitIgnore = ignore;
@@ -54692,7 +54705,7 @@ const pify$1 = pify$3;
 const slash = slash$1;
 
 const globP$1 = pify$1(glob$1);
-const readFileP = pify$1(fs$4.readFile);
+const readFileP = pify$1(fs$2.readFile);
 
 const mapGitIgnorePatternTo = base => ignore => {
 	if (ignore.startsWith('!')) {
@@ -54738,7 +54751,7 @@ const getFile = (file, cwd) => {
 
 const getFileSync = (file, cwd) => {
 	const filePath = path$4.join(cwd, file);
-	const content = fs$4.readFileSync(filePath, 'utf8');
+	const content = fs$2.readFileSync(filePath, 'utf8');
 
 	return {
 		content,
@@ -54945,7 +54958,7 @@ async function trash(paths, options) {
 		}
 
 		try {
-			await fs$F.promises.lstat(filePath);
+			await fs$D.promises.lstat(filePath);
 		} catch (error) {
 			if (error.code === 'ENOENT') {
 				return;
@@ -54969,7 +54982,7 @@ async function trash(paths, options) {
 	} else if (process$2.platform === 'win32') {
 		module = await Promise.resolve().then(function () { return require('./windows-C30k1cv-.cjs'); });
 	} else {
-		module = await Promise.resolve().then(function () { return require('./linux-dGf0gycY.cjs'); });
+		module = await Promise.resolve().then(function () { return require('./linux-BInfI0l8.cjs'); });
 	}
 
 	return module.default(paths);
@@ -60232,14 +60245,14 @@ class Config extends TypedEmitter {
     }
     save() {
         // 保存文件
-        fs$F.writeFileSync(this.filepath, JSON.stringify(this.data));
+        fs$D.writeFileSync(this.filepath, JSON.stringify(this.data));
     }
     load(filepath) {
         this.filepath = filepath;
     }
     init(filepath, initData = {}) {
         this.filepath = filepath;
-        if (!fs$F.existsSync(this.filepath)) {
+        if (!fs$D.existsSync(this.filepath)) {
             this.data = initData;
         }
         else {
@@ -60262,7 +60275,7 @@ class Config extends TypedEmitter {
     }
     read() {
         // 读取文件
-        this.data = JSON.parse(fs$F.readFileSync(this.filepath, "utf-8"));
+        this.data = JSON.parse(fs$D.readFileSync(this.filepath, "utf-8"));
         return this.data;
     }
 }
@@ -61948,11 +61961,11 @@ const uuid$4 = () => {
     return crypto$d.randomUUID();
 };
 const pathExists = async (path) => {
-    return await fs$m.pathExists(path);
+    return await fs$k.pathExists(path);
 };
 const deleteFile = async (path) => {
     try {
-        await fs$m.unlink(path);
+        await fs$k.unlink(path);
     }
     catch (error) {
         console.error(error);
@@ -61972,7 +61985,7 @@ const trashItem = async (path) => {
 };
 const isWin32 = process.platform === "win32";
 async function getFileSize$1(filePath) {
-    const stats = await fs$m.promises.stat(filePath);
+    const stats = await fs$k.promises.stat(filePath);
     const fileSizeInBytes = stats.size;
     return fileSizeInBytes;
 }
@@ -62013,18 +62026,18 @@ function getTempPath() {
     }
     if (cacheFolder) {
         try {
-            fs$m.ensureDirSync(cacheFolder);
+            fs$k.ensureDirSync(cacheFolder);
             return cacheFolder;
         }
         catch (e) {
             console.error("缓存文件夹创建失败，使用系统临时文件夹", e);
         }
     }
-    fs$m.ensureDirSync(cacheFolder);
+    fs$k.ensureDirSync(cacheFolder);
     return cacheFolder;
 }
 async function readLines(filePath, startLine, endLine) {
-    const fileStream = fs$m.createReadStream(filePath);
+    const fileStream = fs$k.createReadStream(filePath);
     const rl = readline.createInterface({
         input: fileStream,
         crlfDelay: Infinity,
@@ -62102,7 +62115,7 @@ const parseSavePath = async (input, options, createDir = true) => {
         throw new Error("没有找到保存路径");
     }
     if (createDir && !(await pathExists(savePath))) {
-        await fs$m.ensureDir(savePath);
+        await fs$k.ensureDir(savePath);
     }
     return savePath;
 };
@@ -62145,7 +62158,7 @@ async function getUnusedFileName(filePath) {
     const baseName = path$z.basename(filePath, ext);
     let newFilePath = filePath;
     let counter = 1;
-    while (await fs$m.pathExists(newFilePath)) {
+    while (await fs$k.pathExists(newFilePath)) {
         newFilePath = path$z.join(dir, `${baseName}(${counter})${ext}`);
         counter++;
         if (counter > 100) {
@@ -62169,7 +62182,7 @@ async function calculateFileQuickHash(filePath, headSize = 1 * 1024 * 1024, tail
     // 如果文件小于等于头部大小，直接读取整个文件
     if (fileSize <= headSize) {
         return new Promise((resolve, reject) => {
-            const stream = fs$F.createReadStream(filePath);
+            const stream = fs$D.createReadStream(filePath);
             stream.on("data", (chunk) => {
                 hash.update(chunk);
             });
@@ -62181,7 +62194,7 @@ async function calculateFileQuickHash(filePath, headSize = 1 * 1024 * 1024, tail
     }
     // 读取头部
     await new Promise((resolve, reject) => {
-        const headStream = fs$F.createReadStream(filePath, {
+        const headStream = fs$D.createReadStream(filePath, {
             start: 0,
             end: headSize - 1,
             highWaterMark: 64 * 1024,
@@ -62197,7 +62210,7 @@ async function calculateFileQuickHash(filePath, headSize = 1 * 1024 * 1024, tail
     // 读取尾部
     await new Promise((resolve, reject) => {
         const tailStart = Math.max(headSize, fileSize - tailSize);
-        const tailStream = fs$F.createReadStream(filePath, {
+        const tailStream = fs$D.createReadStream(filePath, {
             start: tailStart,
             end: fileSize - 1,
             highWaterMark: 64 * 1024,
@@ -62296,7 +62309,7 @@ function RGB2BGR(color, reverseAlpha = true) {
 
 async function getFileSize(filePath) {
     try {
-        const stats = await fs$F.promises.stat(filePath);
+        const stats = await fs$D.promises.stat(filePath);
         const fileSizeInBytes = stats.size;
         return fileSizeInBytes;
     }
@@ -62307,11 +62320,11 @@ async function getFileSize(filePath) {
 let isString$1 = (value) => typeof value === "string";
 function createReadStream(filePath, start, numBytes, totalBytes) {
     const endByte = Math.min(start + numBytes - 1, totalBytes - 1);
-    const readStream = fs$F.createReadStream(filePath, { start, end: endByte });
+    const readStream = fs$D.createReadStream(filePath, { start, end: endByte });
     return [readStream, endByte - start + 1];
 }
 async function readFileAsBase64(filePath) {
-    return fs$F.promises
+    return fs$D.promises
         .readFile(filePath)
         .then(data => {
         // 获取文件扩展名
@@ -63034,7 +63047,7 @@ class Auth {
      * @param path cookie文件路径
      */
     async loadCookieFile(path) {
-        const cookie = await fs$F.promises.readFile(path, "utf-8");
+        const cookie = await fs$D.promises.readFile(path, "utf-8");
         const cookieObj = JSON.parse(cookie);
         const cookieStr = cookieObj.cookie_info.cookies
             .map((item) => `${item.name}=${item.value}`)
@@ -65357,7 +65370,7 @@ class WebVideoUploader extends BaseRequest {
         }
     }
     getFileSizeSync(filePath) {
-        const stats = fs$F.statSync(filePath);
+        const stats = fs$D.statSync(filePath);
         const fileSizeInBytes = stats.size;
         return fileSizeInBytes;
     }
@@ -67099,7 +67112,7 @@ class RangeDownloader {
             return;
         if (this.status === "pending") {
             try {
-                await fs$F.promises.unlink(this.filePath);
+                await fs$D.promises.unlink(this.filePath);
             }
             catch (error) { }
         }
@@ -67153,7 +67166,7 @@ class RangeDownloader {
                 _self.totalSize = isNaN(_self.totalSize)
                     ? parseInt(response.headers["content-length"] || "0", 10)
                     : _self.totalSize;
-                const writableStream = fs$F.createWriteStream(this.filePath, {
+                const writableStream = fs$D.createWriteStream(this.filePath, {
                     flags: "a",
                 });
                 response.data.pipe(writableStream);
@@ -67564,7 +67577,7 @@ class Video extends BaseRequest {
         });
         const jsonData = (await res.json());
         const srtData = subtitleJsonToSrt(jsonData);
-        fs$F.writeFileSync(options.output, srtData);
+        fs$D.writeFileSync(options.output, srtData);
         return options.output;
     }
     authAid() {
@@ -67748,8 +67761,8 @@ class Video extends BaseRequest {
         }
         const clean = () => {
             try {
-                fs$F.promises.unlink(videoDownloader.filePath);
-                fs$F.promises.unlink(audioDownloader.filePath);
+                fs$D.promises.unlink(videoDownloader.filePath);
+                fs$D.promises.unlink(audioDownloader.filePath);
             }
             catch (error) {
                 console.warn(error);
@@ -67863,7 +67876,7 @@ class Video extends BaseRequest {
         });
         const clean = () => {
             try {
-                fs$F.promises.unlink(videoDownloader.filePath);
+                fs$D.promises.unlink(videoDownloader.filePath);
             }
             catch (error) {
                 console.warn(error);
@@ -75977,7 +75990,7 @@ class BcutASR {
      * 从文件设置数据
      */
     setDataFromFile(file) {
-        this.soundBin = fs$F.readFileSync(file);
+        this.soundBin = fs$D.readFileSync(file);
         const suffix = file.split(".").pop()?.toLowerCase();
         if (!this.isSupportFormat(suffix)) {
             throw new TypeError(`Format ${suffix} is not supported`);
@@ -78374,7 +78387,7 @@ class M3U8Downloader extends TypedEmitter {
         this.totalSegments = 0;
         this.downloadedSegments = 0;
         this.downloadedFiles = [];
-        fs$m.ensureDirSync(this.segmentsDir);
+        fs$k.ensureDirSync(this.segmentsDir);
         console.log("Temporary segments directory:", this.segmentsDir);
         // axios 统一实例化，方便增加axios功能，比如拦截器
         this.http = axios.create({
@@ -78405,10 +78418,10 @@ class M3U8Downloader extends TypedEmitter {
         try {
             this.emit("start");
             this.status = "running";
-            if (!(await fs$m.pathExists(this.segmentsDir))) {
-                await fs$m.mkdir(this.segmentsDir, { recursive: true });
+            if (!(await fs$k.pathExists(this.segmentsDir))) {
+                await fs$k.mkdir(this.segmentsDir, { recursive: true });
             }
-            if (!(await fs$m.pathExists(path$z.dirname(this.output)))) {
+            if (!(await fs$k.pathExists(path$z.dirname(this.output)))) {
                 throw new Error("Output directory does not exist");
             }
             const m3u8Content = await this.getM3U8();
@@ -78528,7 +78541,7 @@ class M3U8Downloader extends TypedEmitter {
             return;
         const formattedIndex = String(index).padStart(5, "0");
         const segmentPath = path$z.resolve(this.segmentsDir, `segment${formattedIndex}.${this.options.suffix}`);
-        if (this.options.skipExistSegments && (await fs$m.pathExists(segmentPath))) {
+        if (this.options.skipExistSegments && (await fs$k.pathExists(segmentPath))) {
             this.downloadedSegments++;
             const progress = {
                 downloadedFile: segmentPath,
@@ -78541,7 +78554,7 @@ class M3U8Downloader extends TypedEmitter {
         const response = await this.http.get(tsUrl, {
             responseType: "arraybuffer",
         });
-        await fs$m.writeFile(segmentPath, response.data);
+        await fs$k.writeFile(segmentPath, response.data);
         this.downloadedFiles.push(segmentPath);
         this.downloadedSegments++;
         const progress = {
@@ -78577,7 +78590,7 @@ class M3U8Downloader extends TypedEmitter {
         if (!this.options.convert2Mp4) {
             mergedFilePath = this.output;
         }
-        const writeStream = fs$m.createWriteStream(mergedFilePath, {
+        const writeStream = fs$k.createWriteStream(mergedFilePath, {
             highWaterMark: 1024 * 1024,
         });
         writeStream.on("error", error => {
@@ -78608,10 +78621,10 @@ class M3U8Downloader extends TypedEmitter {
                 const formattedIndex = String(index).padStart(5, "0");
                 const segmentPath = path$z.resolve(this.segmentsDir, `segment${formattedIndex}.${this.options.suffix}`);
                 // 读取并安全写入
-                const segmentData = await fs$m.promises.readFile(segmentPath);
+                const segmentData = await fs$k.promises.readFile(segmentPath);
                 await safeWrite(segmentData);
                 if (deleteSource)
-                    await fs$m.promises.unlink(segmentPath);
+                    await fs$k.promises.unlink(segmentPath);
             }
             // 关键：等待流完全关闭
             await new Promise((resolve, reject) => {
@@ -78631,14 +78644,14 @@ class M3U8Downloader extends TypedEmitter {
             return;
         await Promise.all(this.downloadedFiles.map(async (file) => {
             try {
-                await fs$m.unlink(file);
+                await fs$k.unlink(file);
             }
             catch (error) { }
         }));
         if (this.options.convert2Mp4) {
             let mergedFilePath = path$z.resolve(this.segmentsDir, `output.${this.options.suffix}`);
-            if (await fs$m.pathExists(mergedFilePath)) {
-                await fs$m.unlink(mergedFilePath);
+            if (await fs$k.pathExists(mergedFilePath)) {
+                await fs$k.unlink(mergedFilePath);
             }
         }
     }
@@ -78672,7 +78685,7 @@ class M3U8Downloader extends TypedEmitter {
                 }
                 // remove merged TS file with retry
                 try {
-                    await retry$2(() => fs$m.unlink(inputFilePath), 5, 1000);
+                    await retry$2(() => fs$k.unlink(inputFilePath), 5, 1000);
                 }
                 catch (error) {
                     console.error(`Failed to delete temporary TS file: ${error}`);
@@ -78691,7 +78704,7 @@ var nodemailer = {};
 
 var shared$c = {exports: {}};
 
-var fetch$3 = {exports: {}};
+var fetch$2 = {exports: {}};
 
 // module to handle cookies
 
@@ -79041,11 +79054,11 @@ const net$b = require$$4;
 
 const MAX_REDIRECTS = 5;
 
-fetch$3.exports = function (url, options) {
+fetch$2.exports = function (url, options) {
     return nmfetch$3(url, options);
 };
 
-fetch$3.exports.Cookies = Cookies;
+fetch$2.exports.Cookies = Cookies;
 
 function nmfetch$3(url, options) {
     options = options || {};
@@ -79303,7 +79316,7 @@ function nmfetch$3(url, options) {
     return fetchRes;
 }
 
-var fetchExports = fetch$3.exports;
+var fetchExports = fetch$2.exports;
 
 /* eslint no-console: 0 */
 
@@ -83993,7 +84006,7 @@ var leUnix = LeWindows$2;
 /* eslint no-undefined: 0, prefer-spread: 0, no-control-regex: 0 */
 
 const crypto$b = require$$1$6;
-const fs$3 = require$$0$6;
+const fs$1 = require$$0$6;
 const punycode$2 = punycode_1;
 const PassThrough$4 = require$$0$4.PassThrough;
 const shared$b = sharedExports;
@@ -84969,7 +84982,7 @@ let MimeNode$2 = class MimeNode {
                 return contentStream;
             }
             // read file
-            return fs$3.createReadStream(content.path);
+            return fs$1.createReadStream(content.path);
         } else if (content && typeof content.href === 'string') {
             if (this.disableUrlAccess) {
                 contentStream = new PassThrough$4();
@@ -86297,7 +86310,7 @@ const MessageParser = messageParser;
 const RelaxedBody = relaxedBody;
 const sign$2 = signExports;
 const PassThrough$3 = require$$0$4.PassThrough;
-const fs$2 = require$$0$6;
+const fs = require$$0$6;
 const path$2 = require$$0$7;
 const crypto$8 = require$$1$6;
 
@@ -86357,12 +86370,12 @@ class DKIMSigner {
         if (!this.cache || !this.cachePath) {
             return;
         }
-        fs$2.unlink(this.cachePath, () => false);
+        fs.unlink(this.cachePath, () => false);
     }
 
     createReadCache() {
         // pipe remainings to cache file
-        this.cache = fs$2.createReadStream(this.cachePath);
+        this.cache = fs.createReadStream(this.cachePath);
         this.cache.once('error', err => {
             this.cleanup();
             this.output.emit('error', err);
@@ -86425,7 +86438,7 @@ class DKIMSigner {
     createWriteCache() {
         this.output.usingCache = true;
         // pipe remainings to cache file
-        this.cache = fs$2.createWriteStream(this.cachePath);
+        this.cache = fs.createWriteStream(this.cachePath);
         this.cache.once('error', err => {
             this.cleanup();
             // drain input
@@ -173627,17 +173640,17 @@ const isSameProtocol = function isSameProtocol(destination, original) {
  * @param   Object   opts  Fetch options
  * @return  Promise
  */
-function fetch$2(url, opts) {
+function fetch$1(url, opts) {
 
 	// allow custom promise
-	if (!fetch$2.Promise) {
+	if (!fetch$1.Promise) {
 		throw new Error('native promise missing, set fetch.Promise to your favorite alternative');
 	}
 
-	Body.Promise = fetch$2.Promise;
+	Body.Promise = fetch$1.Promise;
 
 	// wrap http.request into fetch
-	return new fetch$2.Promise(function (resolve, reject) {
+	return new fetch$1.Promise(function (resolve, reject) {
 		// build request object
 		const request = new Request$4(url, opts);
 		const options = getNodeRequestOptions(request);
@@ -173735,7 +173748,7 @@ function fetch$2(url, opts) {
 			const headers = createHeadersLenient(res.headers);
 
 			// HTTP fetch step 5
-			if (fetch$2.isRedirect(res.statusCode)) {
+			if (fetch$1.isRedirect(res.statusCode)) {
 				// HTTP fetch step 5.2
 				const location = headers.get('Location');
 
@@ -173821,7 +173834,7 @@ function fetch$2(url, opts) {
 						}
 
 						// HTTP-redirect fetch step 15
-						resolve(fetch$2(new Request$4(locationURL, requestOpts)));
+						resolve(fetch$1(new Request$4(locationURL, requestOpts)));
 						finalize();
 						return;
 				}
@@ -173963,12 +173976,12 @@ function destroyStream(stream, err) {
  * @param   Number   code  Status code
  * @return  Boolean
  */
-fetch$2.isRedirect = function (code) {
+fetch$1.isRedirect = function (code) {
 	return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
 };
 
 // expose Promise
-fetch$2.Promise = global.Promise;
+fetch$1.Promise = global.Promise;
 
 var lib = /*#__PURE__*/Object.freeze({
 	__proto__: null,
@@ -173977,7 +173990,7 @@ var lib = /*#__PURE__*/Object.freeze({
 	Headers: Headers$1,
 	Request: Request$4,
 	Response: Response$2,
-	default: fetch$2
+	default: fetch$1
 });
 
 var require$$0 = /*@__PURE__*/getAugmentedNamespace(lib);
@@ -179783,7 +179796,7 @@ class DanmakuFactory {
         return params.filter((item) => item !== "");
     };
     convertXml2Ass = async (input, output, argsObj) => {
-        if (!(await fs$m.pathExists(input))) {
+        if (!(await fs$k.pathExists(input))) {
             throw new Error("input not exists");
         }
         const requiredArgs = [`-i "${input}"`, `-o "${output}"`, "--ignore-warnings", "--force"];
@@ -187103,7 +187116,7 @@ const traversalObject = (obj, callback) => {
     }
 };
 async function processRawStream(inputFilePath) {
-    const readStream = fs$m.createReadStream(inputFilePath, { encoding: "utf8" });
+    const readStream = fs$k.createReadStream(inputFilePath, { encoding: "utf8" });
     const rl = readline.createInterface({
         input: readStream,
         crlfDelay: Infinity,
@@ -187120,13 +187133,13 @@ async function processRawStream(inputFilePath) {
  */
 const parseXmlFile = async (input, parseRaw = false) => {
     let XMLdata;
-    const stat = await fs$m.stat(input);
+    const stat = await fs$k.stat(input);
     // 如果文件大于400M，且未开启parseRaw，使用processRawStream
     if (stat.size > 400 * 1024 * 1024 && !parseRaw) {
         XMLdata = await processRawStream(input);
     }
     else {
-        XMLdata = await fs$m.promises.readFile(input, "utf8");
+        XMLdata = await fs$k.promises.readFile(input, "utf8");
         if (!parseRaw) {
             XMLdata = XMLdata.replace(/raw=".*?"/g, "");
         }
@@ -187354,7 +187367,7 @@ const genTimeData = async (input) => {
         });
     }
     else if (ext === ".ass") {
-        const content = await fs$m.readFile(input, "utf-8");
+        const content = await fs$k.readFile(input, "utf-8");
         const assData = compile(content, {});
         return assData["dialogues"].map((item) => Math.floor(item.start));
     }
@@ -187383,7 +187396,7 @@ const generateDanmakuImage = async (input, output, iOptions) => {
     };
     const options = Object.assign(defaultOptins, iOptions);
     const data = await generateDanmakuData(input, options);
-    await fs$m.ensureDir(output);
+    await fs$k.ensureDir(output);
     const canvas$1 = canvas.createCanvas(options.width, options.height);
     const ctx = canvas$1.getContext("2d");
     const points = createChartPoints(data, options.width, options.height);
@@ -187394,7 +187407,7 @@ const generateDanmakuImage = async (input, output, iOptions) => {
         drawSmoothCurve(ctx, points);
         const outputPath = path$z.join(output, `${String(i).padStart(4, "0")}.png`);
         const png = await canvas$1.encode("png");
-        await fs$m.promises.writeFile(outputPath, png);
+        await fs$k.promises.writeFile(outputPath, png);
     }
     return data;
 };
@@ -187566,7 +187579,7 @@ const genProcessedXml = async (input, output, filterFunction) => {
     ];
     const processedBuckets = processXmlItems(events, filterFunction);
     const xmlData = generateMergedXmlContent(processedBuckets.danmu, processedBuckets.gift, processedBuckets.sc, processedBuckets.guard, metadata);
-    await fs$m.writeFile(output, xmlData);
+    await fs$k.writeFile(output, xmlData);
     return output;
 };
 /**
@@ -187604,7 +187617,7 @@ const addConvertDanmu2AssTask = async (originInput, output, danmuOptions, option
             .split(",")
             .filter((value) => value)
             .join("\n");
-        await fs$m.writeFile(fileTxtPath, fileTxtContent);
+        await fs$k.writeFile(fileTxtPath, fileTxtContent);
         opts.blacklist = fileTxtPath;
     }
     const input = filteredOutput || originInput;
@@ -187619,10 +187632,10 @@ const addConvertDanmu2AssTask = async (originInput, output, danmuOptions, option
                 await trashItem(originInput);
             }
             if (opts.blacklist) {
-                fs$m.unlink(opts.blacklist);
+                fs$k.unlink(opts.blacklist);
             }
             if (filteredOutput) {
-                fs$m.unlink(filteredOutput);
+                fs$k.unlink(filteredOutput);
             }
         },
         onError: async (error) => {
@@ -187633,10 +187646,10 @@ const addConvertDanmu2AssTask = async (originInput, output, danmuOptions, option
                 output: output,
             });
             if (opts.blacklist) {
-                fs$m.unlink(opts.blacklist);
+                fs$k.unlink(opts.blacklist);
             }
             if (filteredOutput) {
-                fs$m.unlink(filteredOutput);
+                fs$k.unlink(filteredOutput);
             }
         },
     });
@@ -187674,7 +187687,7 @@ const convertXml2Ass = async (file, danmuOptions, options) => {
  *
  */
 const isEmptyDanmu = async (filepath) => {
-    const readStream = fs$m.createReadStream(filepath, { encoding: "utf8" });
+    const readStream = fs$k.createReadStream(filepath, { encoding: "utf8" });
     const rl = readline.createInterface({
         input: readStream,
         crlfDelay: Infinity,
@@ -187852,7 +187865,7 @@ const mergeXml = async (inputFiles, options = {}) => {
     // 生成XML内容
     const xmlContent = generateMergedXmlContent(mergedDanmuku, mergedGift, mergedSc, mergedGuard, metadata);
     // 写入合并后的XML文件
-    await fs$m.writeFile(outputPath, xmlContent);
+    await fs$k.writeFile(outputPath, xmlContent);
     logObj.info("mergeXml", {
         status: "success",
         text: `合并完成，共处理了${inputFiles.length}个文件`,
@@ -187979,7 +187992,7 @@ const convertImage2Video = async (inputDir, output, options) => {
         onEnd: async () => {
             if ((await pathExists(inputDir))) {
                 logObj.info("convertImage2Video, remove origin file", inputDir);
-                fs$m.rm(inputDir, { recursive: true, force: true });
+                fs$k.rm(inputDir, { recursive: true, force: true });
             }
         },
     });
@@ -188413,10 +188426,10 @@ async function parseMeta(files) {
         duration: 0,
     };
     let content = "";
-    if (files.danmaFilePath && (await fs$m.pathExists(files.danmaFilePath))) {
+    if (files.danmaFilePath && (await fs$k.pathExists(files.danmaFilePath))) {
         content += (await readLines(files.danmaFilePath, 0, 30)).join("\n");
     }
-    if (files.videoFilePath && (await fs$m.pathExists(files.videoFilePath))) {
+    if (files.videoFilePath && (await fs$k.pathExists(files.videoFilePath))) {
         try {
             const meta = await readVideoMeta(files.videoFilePath, {
                 json: true,
@@ -188703,17 +188716,17 @@ const mergeAssMp4 = async (files, options = {
             }
             if (files.hotProgressFilePath) {
                 logObj.info("mergrAssMp4, remove hot progress origin file", assFile);
-                await fs$m.unlink(files.hotProgressFilePath);
+                await fs$k.unlink(files.hotProgressFilePath);
             }
             if (files.subtitlePath && options.removeSubtitle) {
                 logObj.info("mergrAssMp4, remove subtitle origin file", files.subtitlePath);
-                await fs$m.unlink(files.subtitlePath);
+                await fs$k.unlink(files.subtitlePath);
             }
         },
         onError: async () => {
             if (files.hotProgressFilePath) {
                 logObj.info("mergrAssMp4, remove hot progress origin file", assFile);
-                await fs$m.unlink(files.hotProgressFilePath);
+                await fs$k.unlink(files.hotProgressFilePath);
             }
         },
     });
@@ -188851,7 +188864,7 @@ const mergeVideos = async (inputFiles, options = {
     await setFfmpegPath();
     const fileTxtPath = path$z.join(getTempPath(), `${uuid$4()}.txt`);
     const fileTxtContent = inputFiles.map((videoFile) => `file '${videoFile}'`).join("\n");
-    await fs$m.writeFile(fileTxtPath, fileTxtContent);
+    await fs$k.writeFile(fileTxtPath, fileTxtContent);
     const command = ffmpeg(fileTxtPath).inputOptions("-f concat").inputOptions("-safe 0");
     if (options.keepFirstVideoMeta) {
         command.input(inputFiles[0]).outputOptions("-map 0").outputOptions(`-map_metadata 1`);
@@ -188880,13 +188893,13 @@ const mergeVideos = async (inputFiles, options = {
             return { ...progress, percentage: Math.round((currentTime / duration) * 100) };
         },
         onEnd: async () => {
-            fs$m.remove(fileTxtPath);
+            fs$k.remove(fileTxtPath);
             if (options.removeOrigin) {
                 await Promise.all(inputFiles.map((videoInput) => trashItem(videoInput)));
             }
         },
         onError: async () => {
-            fs$m.remove(fileTxtPath);
+            fs$k.remove(fileTxtPath);
         },
     });
     taskQueue.addTask(task, false);
@@ -189145,7 +189158,7 @@ async function getPlayUrl(bvid, cid, uid) {
  * 直播回放下载
  */
 async function sliceDownload(output, url, options) {
-    if ((await fs$m.pathExists(output)) && !options.override)
+    if ((await fs$k.pathExists(output)) && !options.override)
         throw new Error(`${output}已存在`);
     const { ffmpegPath } = getBinPath();
     const downloader = new M3U8Downloader(url, output, {
@@ -189163,7 +189176,7 @@ async function sliceDownload(output, url, options) {
 }
 // 下载视频
 async function download$2(options, uid) {
-    if ((await fs$m.pathExists(options.output)) && !options.override)
+    if ((await fs$k.pathExists(options.output)) && !options.override)
         throw new Error(`${options.output}已存在`);
     const client = createClient(uid);
     const { ffmpegPath } = getBinPath();
@@ -189179,7 +189192,7 @@ async function download$2(options, uid) {
             if (options.danmu !== "none") {
                 const data = await client.video.getAllDm({ bvid: options.bvid, cid: options.cid });
                 const xmlContent = await utils$8.protoBufToXml(data);
-                fs$m.writeFile(path$z.join(path$z.dirname(options.output), `${path$z.parse(options.output).name}.xml`), xmlContent);
+                fs$k.writeFile(path$z.join(path$z.dirname(options.output), `${path$z.parse(options.output).name}.xml`), xmlContent);
             }
         },
     });
@@ -189245,7 +189258,7 @@ function formatOptions(options, coverDir = undefined) {
     else {
         cover = undefined;
     }
-    if (cover && !fs$m.pathExistsSync(cover)) {
+    if (cover && !fs$k.pathExistsSync(cover)) {
         console.warn("封面不存在", cover);
         cover = undefined;
     }
@@ -190369,7 +190382,7 @@ async function post(url, data, config) {
 function md5File(path) {
     return new Promise((resolve, reject) => {
         const output = crypto$d.createHash("md5");
-        const input = fs$F.createReadStream(path);
+        const input = fs$D.createReadStream(path);
         input.on("error", err => {
             reject(err);
         });
@@ -190469,7 +190482,7 @@ class Uploader {
      * @returns 文件大小(字节)
      */
     getFileSizeSync(filePath) {
-        const stats = fs$F.statSync(filePath);
+        const stats = fs$D.statSync(filePath);
         return stats.size;
     }
     /**
@@ -190725,7 +190738,7 @@ class Uploader {
      */
     createChunkStream(filePath, start, chunkSize) {
         const endByte = start + chunkSize - 1;
-        return fs$F.createReadStream(filePath, {
+        return fs$D.createReadStream(filePath, {
             start,
             end: endByte,
             highWaterMark: 64 * 1024, // 64KB 块大小
@@ -191219,7 +191232,7 @@ class Pan123 extends TypedEmitter {
      * @returns Promise<void> 上传成功时resolve，失败时reject
      */
     async uploadFile(localFilePath, remoteDir = "", options) {
-        if (!(await fs$m.pathExists(localFilePath))) {
+        if (!(await fs$k.pathExists(localFilePath))) {
             const error = new Error(`文件不存在: ${localFilePath}`);
             this.logger.error(error.message);
             console.log(remoteDir);
@@ -191227,7 +191240,7 @@ class Pan123 extends TypedEmitter {
             throw error;
         }
         // 检查文件大小是否超过10GB
-        const stats = await fs$m.stat(localFilePath);
+        const stats = await fs$k.stat(localFilePath);
         const fileSize = stats.size;
         const maxSize = 10 * 1024 * 1024 * 1024; // 10GB
         if (fileSize > maxSize) {
@@ -191964,7 +191977,7 @@ const handleRestartTask = (taskId) => {
 
 let ntsuspend;
 function getNtSuspend() {
-    ntsuspend ??= node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-CWkwaDmT.cjs', document.baseURI).href)))("ntsuspend");
+    ntsuspend ??= node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-CyQ_VJuq.cjs', document.baseURI).href)))("ntsuspend");
     return ntsuspend;
 }
 class DanmuTask extends AbstractTask {
@@ -192231,7 +192244,7 @@ class BiliPartVideoTask extends AbstractTask {
             if (this.useUploadPartPersistence) {
                 try {
                     const fileHash = await calculateFileQuickHash(command.filePath);
-                    const fileSize = await fs$m.stat(command.filePath).then((stat) => stat.size);
+                    const fileSize = await fs$k.stat(command.filePath).then((stat) => stat.size);
                     uploadPartService.addOrUpdate({
                         file_hash: fileHash,
                         file_size: fileSize,
@@ -192297,7 +192310,7 @@ class BiliPartVideoTask extends AbstractTask {
         if (this.useUploadPartPersistence) {
             try {
                 const fileHash = await calculateFileQuickHash(command.filePath);
-                const fileSize = await fs$m.stat(command.filePath).then((stat) => stat.size);
+                const fileSize = await fs$k.stat(command.filePath).then((stat) => stat.size);
                 const part = uploadPartService.findValidPartByHash(fileHash, fileSize, String(this.uid));
                 if (part) {
                     this.status = "completed";
@@ -192327,7 +192340,7 @@ class BiliPartVideoTask extends AbstractTask {
         this.scheduleStalledProgressTimer();
         command.upload();
         try {
-            const fileSize = await fs$m.stat(command.filePath).then((stat) => stat.size);
+            const fileSize = await fs$k.stat(command.filePath).then((stat) => stat.size);
             this.extra = { ...this.extra, fileSize };
         }
         catch (error) {
@@ -194139,8 +194152,8 @@ function getValuesFromArrayLikeFlexSpaceBetween(array, columnCount) {
 }
 function ensureFolderExist(fileOrFolderPath) {
     const folder = path$z.dirname(fileOrFolderPath);
-    if (!fs$F.existsSync(folder)) {
-        fs$F.mkdirSync(folder, { recursive: true });
+    if (!fs$D.existsSync(folder)) {
+        fs$D.mkdirSync(folder, { recursive: true });
     }
 }
 function assert$p(assertion, msg) {
@@ -194294,7 +194307,7 @@ async function downloadImage(imageUrl, savePath) {
     if (!res.body) {
         throw new Error("No body in response");
     }
-    const fileStream = fs$F.createWriteStream(savePath, { flags: "wx" });
+    const fileStream = fs$D.createWriteStream(savePath, { flags: "wx" });
     // @ts-ignore
     await promises.finished(require$$0$b.Readable.fromWeb(res.body).pipe(fileStream));
 }
@@ -194783,7 +194796,7 @@ function createRecordExtraDataController(savePath) {
     const initializeFile = async (content) => {
         // 这里有个假设，那就是第一次保存必然存在metatdata信息
         const initialContent = data.header.replace(METADATA_PLACEHOLDER, generateMetadataXml(data.meta));
-        await fs$F.promises.writeFile(savePath, initialContent + content);
+        await fs$D.promises.writeFile(savePath, initialContent + content);
         hasPersistedHeader = true;
     };
     const writeToFile = async (force = false) => {
@@ -194961,7 +194974,7 @@ function generateXmlContent(metadata, messages) {
 async function appendToXmlFile(filePath, content) {
     try {
         // 直接追加内容
-        await fs$F.promises.appendFile(filePath, content);
+        await fs$D.promises.appendFile(filePath, content);
     }
     catch (error) {
         console.error(`写入XML文件失败: ${filePath}`, error);
@@ -195025,7 +195038,7 @@ class Segment extends EventEmitter$l {
                 text: `Renaming segment file: ${this.rawRecordingVideoPath} -> ${this.outputFilePath}`,
             });
             await Promise.all([
-                retry$1(() => fs$G.rename(this.rawRecordingVideoPath, this.outputFilePath), 20, 1000),
+                retry$1(() => fs$E.rename(this.rawRecordingVideoPath, this.outputFilePath), 20, 1000),
                 this.extraDataController?.flush(),
             ]);
             this.emit("videoFileCompleted", data);
@@ -224778,11 +224791,11 @@ function requireSubresourceIntegrity () {
 }
 
 var fetch_1$1;
-var hasRequiredFetch;
+var hasRequiredFetch$1;
 
-function requireFetch () {
-	if (hasRequiredFetch) return fetch_1$1;
-	hasRequiredFetch = 1;
+function requireFetch$1 () {
+	if (hasRequiredFetch$1) return fetch_1$1;
+	hasRequiredFetch$1 = 1;
 
 	const {
 	  makeNetworkError,
@@ -227212,7 +227225,7 @@ function requireCache () {
 	const { webidl } = requireWebidl();
 	const { cloneResponse, fromInnerResponse, getResponseState } = requireResponse();
 	const { Request, fromInnerRequest, getRequestState } = requireRequest();
-	const { fetching } = requireFetch();
+	const { fetching } = requireFetch$1();
 	const { urlIsHttpHttpsScheme, readAllBytes } = requireUtil$5();
 	/**
 	 * @see https://w3c.github.io/ServiceWorker/#dfn-cache-batch-operation
@@ -230039,7 +230052,7 @@ function requireConnection () {
 	const { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = requireConstants();
 	const { parseExtensions, isClosed, isClosing, isEstablished, isConnecting, validateCloseCodeAndReason } = requireUtil$2();
 	const { makeRequest } = requireRequest();
-	const { fetching } = requireFetch();
+	const { fetching } = requireFetch$1();
 	const { Headers, getHeadersList } = requireHeaders();
 	const { getDecodeSplit } = requireUtil$5();
 	const { WebsocketFrameSend } = requireFrame();
@@ -233066,7 +233079,7 @@ function requireEventsource () {
 	hasRequiredEventsource = 1;
 
 	const { pipeline } = require$$0$b;
-	const { fetching } = requireFetch();
+	const { fetching } = requireFetch$1();
 	const { webidl } = requireWebidl();
 	const { EventSourceStream } = requireEventsourceStream();
 	const { parseMIMEType } = requireDataUrl();
@@ -233683,7 +233696,7 @@ undici.exports;
 	module.exports.setGlobalDispatcher = setGlobalDispatcher;
 	module.exports.getGlobalDispatcher = getGlobalDispatcher;
 
-	const fetchImpl = requireFetch().fetch;
+	const fetchImpl = requireFetch$1().fetch;
 
 	// Capture __filename at module load time for stack trace augmentation.
 	// This may be undefined when bundled in environments like Node.js internals.
@@ -245994,13 +246007,13 @@ const getStream$6 = async (data, resoltion) => {
  */
 async function download$1(output, decodeData, options) {
     const mp4Output = replaceExtName$1(output, ".mp4");
-    if ((await fs$m.pathExists(mp4Output)) && !options.override)
+    if ((await fs$k.pathExists(mp4Output)) && !options.override)
         throw new Error(`${mp4Output}已存在`);
     if (options.danmu !== "none" && !options.vid)
         throw new Error("下载弹幕时vid不能为空");
     const { dir, name } = path$z.parse(output);
     const tsOutput = path$z.join(dir, `${name}.ts`);
-    if (await fs$m.pathExists(tsOutput)) {
+    if (await fs$k.pathExists(tsOutput)) {
         throw new Error(`${tsOutput}已存在，您可以直接执行转封装命令，或者删除后重新下载`);
     }
     let m3u8Url = await getStream$6(decodeData, options.resoltion);
@@ -246023,7 +246036,7 @@ async function download$1(output, decodeData, options) {
             if (options.danmu !== "none" && options.vid) {
                 const danmu = await getVideoDanmu(options.vid);
                 const xml = convert2Xml(danmu, options.danmuMeta || {});
-                fs$m.writeFile(path$z.join(path$z.dirname(output), `${path$z.parse(output).name}.xml`), xml);
+                fs$k.writeFile(path$z.join(path$z.dirname(output), `${path$z.parse(output).name}.xml`), xml);
             }
             const outputName = `${name}.mp4`;
             await sleep$1(2000);
@@ -246063,11 +246076,11 @@ const parseVideo$1 = async (url) => {
     return videoList;
 };
 const downloadDanmu = async (vid, output, override, meta) => {
-    if ((await fs$m.pathExists(output)) && !override)
+    if ((await fs$k.pathExists(output)) && !override)
         throw new Error(`${output}已存在`);
     const danmu = await getVideoDanmu(vid);
     const xml = convert2Xml(danmu, meta || {});
-    await fs$m.writeFile(output, xml);
+    await fs$k.writeFile(output, xml);
     return output;
 };
 async function getReplayList(subId, opts) {
@@ -246082,11 +246095,11 @@ var douyu = { download: download$1, parseVideo: parseVideo$1, getAvailableStream
 
 async function download(output, url, options) {
     const mp4Output = replaceExtName$1(output, ".mp4");
-    if ((await fs$m.pathExists(mp4Output)) && !options.override)
+    if ((await fs$k.pathExists(mp4Output)) && !options.override)
         throw new Error(`${mp4Output}已存在`);
     const { dir, name } = path$z.parse(output);
     const tsOutput = path$z.join(dir, `${name}.ts`);
-    if (await fs$m.pathExists(tsOutput)) {
+    if (await fs$k.pathExists(tsOutput)) {
         throw new Error(`${tsOutput}已存在，您可以直接执行转封装命令，或者删除后重新下载`);
     }
     const { ffmpegPath } = getBinPath();
@@ -246462,7 +246475,7 @@ async function checkAll() {
         if (!savePath) {
             throw new Error("请先设置下载路径");
         }
-        await fs$m.ensureDir(savePath);
+        await fs$k.ensureDir(savePath);
     }
     for (const item of needCheckItems) {
         try {
@@ -246558,13 +246571,13 @@ const extractStartTimeFromFilename = (filename, startTimeAutoMatch, fileBirthtim
  */
 const getMatchingFiles = async (config, folderPath, startTime) => {
     // 检查监听文件夹是否存在
-    const exists = await fs$m.pathExists(folderPath);
+    const exists = await fs$k.pathExists(folderPath);
     if (!exists) {
         logObj.warn(`文件夹不存在: ${folderPath}`);
         return [];
     }
     // 筛选出符合条件的文件
-    const files = await fs$m.readdir(folderPath);
+    const files = await fs$k.readdir(folderPath);
     const videoFiles = files
         .filter((file) => {
         // 使用配置的文件匹配规则，如果未配置则使用默认规则
@@ -246608,7 +246621,7 @@ const getMatchingFiles = async (config, folderPath, startTime) => {
     if (unprocessedFiles.length === 0) {
         return [];
     }
-    const stats = await Promise.allSettled(unprocessedFiles.map((file) => fs$m.stat(file)));
+    const stats = await Promise.allSettled(unprocessedFiles.map((file) => fs$k.stat(file)));
     const newRecords = stats
         .map((item, index) => {
         return {
@@ -265677,7 +265690,7 @@ var indexMinimal$1 = {};
 
 var minimal$2 = {};
 
-var aspromise$1 = asPromise$3;
+var aspromise$1 = asPromise$2;
 
 /**
  * Callback as used by {@link util.asPromise}.
@@ -265696,7 +265709,7 @@ var aspromise$1 = asPromise$3;
  * @param {...*} params Function arguments
  * @returns {Promise<*>} Promisified function
  */
-function asPromise$3(fn, ctx/*, varargs */) {
+function asPromise$2(fn, ctx/*, varargs */) {
     var params  = new Array(arguments.length - 1),
         offset  = 0,
         index   = 2,
@@ -270085,328 +270098,367 @@ var types$1 = {};
 
 var util$7 = {exports: {}};
 
-var patterns$1 = {};
-
-(function (exports) {
-
-	var patterns = exports;
-
-	patterns.numberRe    = /^(?![eE])[0-9]*(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?$/;
-	patterns.typeRefRe   = /^(?:\.?[a-zA-Z_][a-zA-Z_0-9]*)(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*$/;
-	patterns.reservedRe  = /^(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)$/;
-	patterns.unsafePropertyRe = /^(?:__proto__|prototype|constructor)$/; 
-} (patterns$1));
+var patterns = {};
 
-var codegen_1 = codegen;
+var hasRequiredPatterns;
 
-var patterns = patterns$1;
-var reservedRe = patterns.reservedRe;
-
-/**
- * Begins generating a function.
- * @memberof util
- * @param {string[]} functionParams Function parameter names
- * @param {string} [functionName] Function name if not anonymous
- * @returns {Codegen} Appender that appends code to the function's body
- */
-function codegen(functionParams, functionName) {
-
-    /* istanbul ignore if */
-    if (typeof functionParams === "string") {
-        functionName = functionParams;
-        functionParams = undefined;
-    }
+function requirePatterns () {
+	if (hasRequiredPatterns) return patterns;
+	hasRequiredPatterns = 1;
+	(function (exports) {
 
-    var body = [];
+		var patterns = exports;
 
-    /**
-     * Appends code to the function's body or finishes generation.
-     * @typedef Codegen
-     * @type {function}
-     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
-     * @param {...*} [formatParams] Format parameters
-     * @returns {Codegen|Function} Itself or the generated function if finished
-     * @throws {Error} If format parameter counts do not match
-     */
+		patterns.numberRe    = /^(?![eE])[0-9]*(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?$/;
+		patterns.typeRefRe   = /^(?:\.?[a-zA-Z_][a-zA-Z_0-9]*)(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*$/;
+		patterns.reservedRe  = /^(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)$/;
+		patterns.unsafePropertyRe = /^(?:__proto__|prototype|constructor)$/; 
+	} (patterns));
+	return patterns;
+}
 
-    function Codegen(formatStringOrScope) {
-        // note that explicit array handling below makes this ~50% faster
-
-        // finish the function
-        if (typeof formatStringOrScope !== "string") {
-            var source = toString();
-            if (codegen.verbose)
-                console.log("codegen: " + source); // eslint-disable-line no-console
-            source = "return " + source;
-            if (formatStringOrScope) {
-                var scopeKeys   = Object.keys(formatStringOrScope),
-                    scopeParams = new Array(scopeKeys.length + 1),
-                    scopeValues = new Array(scopeKeys.length),
-                    scopeOffset = 0;
-                while (scopeOffset < scopeKeys.length) {
-                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
-                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
-                }
-                scopeParams[scopeOffset] = source;
-                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
-            }
-            return Function(source)(); // eslint-disable-line no-new-func
-        }
-
-        // otherwise append to body
-        var formatParams = new Array(arguments.length - 1),
-            formatOffset = 0;
-        while (formatOffset < formatParams.length)
-            formatParams[formatOffset] = arguments[++formatOffset];
-        formatOffset = 0;
-        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
-            var value = formatParams[formatOffset++];
-            switch ($1) {
-                case "d": case "f": return String(Number(value));
-                case "i": return String(Math.floor(value));
-                case "j": return JSON.stringify(value);
-                case "s": return String(value);
-            }
-            return "%";
-        });
-        if (formatOffset !== formatParams.length)
-            throw Error("parameter count mismatch");
-        body.push(formatStringOrScope);
-        return Codegen;
-    }
+var codegen_1;
+var hasRequiredCodegen;
 
-    function toString(functionNameOverride) {
-        return "function " + safeFunctionName(functionNameOverride || functionName) + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
-    }
+function requireCodegen () {
+	if (hasRequiredCodegen) return codegen_1;
+	hasRequiredCodegen = 1;
+	codegen_1 = codegen;
 
-    Codegen.toString = toString;
-    return Codegen;
-}
+	var patterns = requirePatterns();
+	var reservedRe = patterns.reservedRe;
 
-/**
- * Begins generating a function.
- * @memberof util
- * @function codegen
- * @param {string} [functionName] Function name if not anonymous
- * @returns {Codegen} Appender that appends code to the function's body
- * @variation 2
- */
+	/**
+	 * Begins generating a function.
+	 * @memberof util
+	 * @param {string[]} functionParams Function parameter names
+	 * @param {string} [functionName] Function name if not anonymous
+	 * @returns {Codegen} Appender that appends code to the function's body
+	 */
+	function codegen(functionParams, functionName) {
 
-/**
- * When set to `true`, codegen will log generated code to console. Useful for debugging.
- * @name util.codegen.verbose
- * @type {boolean}
- */
-codegen.verbose = false;
+	    /* istanbul ignore if */
+	    if (typeof functionParams === "string") {
+	        functionName = functionParams;
+	        functionParams = undefined;
+	    }
 
-function safeFunctionName(name) {
-    if (!name)
-        return "";
-    name = String(name).replace(/[^\w$]/g, "");
-    if (!name)
-        return "";
-    if (/^\d/.test(name))
-        name = "_" + name;
-    return reservedRe.test(name) ? name + "_" : name;
-}
+	    var body = [];
 
-var fs$1 = null;
-try {
-    fs$1 = require(/* webpackIgnore: true */ "fs");
-    if (!fs$1 || !fs$1.readFile || !fs$1.readFileSync)
-        fs$1 = null;
-} catch (e) {
-    // `fs` is unavailable in browsers and browser-like bundles.
-}
-var fs_1 = fs$1;
+	    /**
+	     * Appends code to the function's body or finishes generation.
+	     * @typedef Codegen
+	     * @type {function}
+	     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
+	     * @param {...*} [formatParams] Format parameters
+	     * @returns {Codegen|Function} Itself or the generated function if finished
+	     * @throws {Error} If format parameter counts do not match
+	     */
 
-var fetch_1 = fetch$1;
+	    function Codegen(formatStringOrScope) {
+	        // note that explicit array handling below makes this ~50% faster
+
+	        // finish the function
+	        if (typeof formatStringOrScope !== "string") {
+	            var source = toString();
+	            if (codegen.verbose)
+	                console.log("codegen: " + source); // eslint-disable-line no-console
+	            source = "return " + source;
+	            if (formatStringOrScope) {
+	                var scopeKeys   = Object.keys(formatStringOrScope),
+	                    scopeParams = new Array(scopeKeys.length + 1),
+	                    scopeValues = new Array(scopeKeys.length),
+	                    scopeOffset = 0;
+	                while (scopeOffset < scopeKeys.length) {
+	                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
+	                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
+	                }
+	                scopeParams[scopeOffset] = source;
+	                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
+	            }
+	            return Function(source)(); // eslint-disable-line no-new-func
+	        }
 
-var asPromise$2 = aspromise$1,
-    fs        = fs_1;
+	        // otherwise append to body
+	        var formatParams = new Array(arguments.length - 1),
+	            formatOffset = 0;
+	        while (formatOffset < formatParams.length)
+	            formatParams[formatOffset] = arguments[++formatOffset];
+	        formatOffset = 0;
+	        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
+	            var value = formatParams[formatOffset++];
+	            switch ($1) {
+	                case "d": case "f": return String(Number(value));
+	                case "i": return String(Math.floor(value));
+	                case "j": return JSON.stringify(value);
+	                case "s": return String(value);
+	            }
+	            return "%";
+	        });
+	        if (formatOffset !== formatParams.length)
+	            throw Error("parameter count mismatch");
+	        body.push(formatStringOrScope);
+	        return Codegen;
+	    }
 
-/**
- * Node-style callback as used by {@link util.fetch}.
- * @typedef FetchCallback
- * @type {function}
- * @param {?Error} error Error, if any, otherwise `null`
- * @param {string} [contents] File contents, if there hasn't been an error
- * @returns {undefined}
- */
+	    function toString(functionNameOverride) {
+	        return "function " + safeFunctionName(functionNameOverride || functionName) + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
+	    }
 
-/**
- * Options as used by {@link util.fetch}.
- * @interface IFetchOptions
- * @property {boolean} [binary=false] Whether expecting a binary response
- * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
- */
+	    Codegen.toString = toString;
+	    return Codegen;
+	}
 
-/**
- * Fetches the contents of a file.
- * @memberof util
- * @param {string} filename File path or url
- * @param {IFetchOptions} options Fetch options
- * @param {FetchCallback} callback Callback function
- * @returns {undefined}
- */
-function fetch$1(filename, options, callback) {
-    if (typeof options === "function") {
-        callback = options;
-        options = {};
-    } else if (!options)
-        options = {};
+	/**
+	 * Begins generating a function.
+	 * @memberof util
+	 * @function codegen
+	 * @param {string} [functionName] Function name if not anonymous
+	 * @returns {Codegen} Appender that appends code to the function's body
+	 * @variation 2
+	 */
 
-    if (!callback)
-        return asPromise$2(fetch$1, this, filename, options); // eslint-disable-line no-invalid-this
-
-    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
-    if (!options.xhr && fs && fs.readFile)
-        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
-            return err && typeof XMLHttpRequest !== "undefined"
-                ? fetch$1.xhr(filename, options, callback)
-                : err
-                ? callback(err)
-                : callback(null, options.binary ? contents : contents.toString("utf8"));
-        });
+	/**
+	 * When set to `true`, codegen will log generated code to console. Useful for debugging.
+	 * @name util.codegen.verbose
+	 * @type {boolean}
+	 */
+	codegen.verbose = false;
 
-    // use the XHR version otherwise.
-    return fetch$1.xhr(filename, options, callback);
+	function safeFunctionName(name) {
+	    if (!name)
+	        return "";
+	    name = String(name).replace(/[^\w$]/g, "");
+	    if (!name)
+	        return "";
+	    if (/^\d/.test(name))
+	        name = "_" + name;
+	    return reservedRe.test(name) ? name + "_" : name;
+	}
+	return codegen_1;
 }
 
-/**
- * Fetches the contents of a file.
- * @name util.fetch
- * @function
- * @param {string} path File path or url
- * @param {FetchCallback} callback Callback function
- * @returns {undefined}
- * @variation 2
- */
-
-/**
- * Fetches the contents of a file.
- * @name util.fetch
- * @function
- * @param {string} path File path or url
- * @param {IFetchOptions} [options] Fetch options
- * @returns {Promise<string|Uint8Array>} Promise
- * @variation 3
- */
-
-/**/
-fetch$1.xhr = function fetch_xhr(filename, options, callback) {
-    var xhr = new XMLHttpRequest();
-    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
+var fs_1;
+var hasRequiredFs;
 
-        if (xhr.readyState !== 4)
-            return undefined;
+function requireFs () {
+	if (hasRequiredFs) return fs_1;
+	hasRequiredFs = 1;
 
-        // local cors security errors return status 0 / empty string, too. afaik this cannot be
-        // reliably distinguished from an actually empty file for security reasons. feel free
-        // to send a pull request if you are aware of a solution.
-        if (xhr.status !== 0 && xhr.status !== 200)
-            return callback(Error("status " + xhr.status));
+	var fs = null;
+	try {
+	    fs = require(/* webpackIgnore: true */ "fs");
+	    if (!fs || !fs.readFile || !fs.readFileSync)
+	        fs = null;
+	} catch (e) {
+	    // `fs` is unavailable in browsers and browser-like bundles.
+	}
+	fs_1 = fs;
+	return fs_1;
+}
 
-        // if binary data is expected, make sure that some sort of array is returned, even if
-        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
-        if (options.binary) {
-            var buffer = xhr.response;
-            if (!buffer) {
-                buffer = [];
-                for (var i = 0; i < xhr.responseText.length; ++i)
-                    buffer.push(xhr.responseText.charCodeAt(i) & 255);
-            }
-            return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
-        }
-        return callback(null, xhr.responseText);
-    };
+var fetch_1;
+var hasRequiredFetch;
 
-    if (options.binary) {
-        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
-        if ("overrideMimeType" in xhr)
-            xhr.overrideMimeType("text/plain; charset=x-user-defined");
-        xhr.responseType = "arraybuffer";
-    }
+function requireFetch () {
+	if (hasRequiredFetch) return fetch_1;
+	hasRequiredFetch = 1;
+	fetch_1 = fetch;
 
-    xhr.open("GET", filename);
-    xhr.send();
-};
+	var asPromise = aspromise$1,
+	    fs        = requireFs();
 
-var path = {};
+	/**
+	 * Node-style callback as used by {@link util.fetch}.
+	 * @typedef FetchCallback
+	 * @type {function}
+	 * @param {?Error} error Error, if any, otherwise `null`
+	 * @param {string} [contents] File contents, if there hasn't been an error
+	 * @returns {undefined}
+	 */
 
-(function (exports) {
+	/**
+	 * Options as used by {@link util.fetch}.
+	 * @interface IFetchOptions
+	 * @property {boolean} [binary=false] Whether expecting a binary response
+	 * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
+	 */
 
 	/**
-	 * A minimal path module to resolve Unix, Windows and URL paths alike.
+	 * Fetches the contents of a file.
 	 * @memberof util
-	 * @namespace
+	 * @param {string} filename File path or url
+	 * @param {IFetchOptions} options Fetch options
+	 * @param {FetchCallback} callback Callback function
+	 * @returns {undefined}
 	 */
-	var path = exports;
+	function fetch(filename, options, callback) {
+	    if (typeof options === "function") {
+	        callback = options;
+	        options = {};
+	    } else if (!options)
+	        options = {};
+
+	    if (!callback)
+	        return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this
+
+	    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
+	    if (!options.xhr && fs && fs.readFile)
+	        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
+	            return err && typeof XMLHttpRequest !== "undefined"
+	                ? fetch.xhr(filename, options, callback)
+	                : err
+	                ? callback(err)
+	                : callback(null, options.binary ? contents : contents.toString("utf8"));
+	        });
+
+	    // use the XHR version otherwise.
+	    return fetch.xhr(filename, options, callback);
+	}
 
-	var isAbsolute =
 	/**
-	 * Tests if the specified path is absolute.
-	 * @param {string} path Path to test
-	 * @returns {boolean} `true` if path is absolute
+	 * Fetches the contents of a file.
+	 * @name util.fetch
+	 * @function
+	 * @param {string} path File path or url
+	 * @param {FetchCallback} callback Callback function
+	 * @returns {undefined}
+	 * @variation 2
 	 */
-	path.isAbsolute = function isAbsolute(path) {
-	    return /^(?:\/|\w+:|\\\\\w+)/.test(path);
-	};
 
-	var normalize =
 	/**
-	 * Normalizes the specified path.
-	 * @param {string} path Path to normalize
-	 * @returns {string} Normalized path
+	 * Fetches the contents of a file.
+	 * @name util.fetch
+	 * @function
+	 * @param {string} path File path or url
+	 * @param {IFetchOptions} [options] Fetch options
+	 * @returns {Promise<string|Uint8Array>} Promise
+	 * @variation 3
 	 */
-	path.normalize = function normalize(path) {
-	    var firstTwoCharacters = path.substring(0,2);
-	    var uncPrefix = "";
-	    if (firstTwoCharacters === "\\\\") {
-	        uncPrefix = firstTwoCharacters;
-	        path = path.substring(2);
-	    }
 
-	    path = path.replace(/\\/g, "/")
-	               .replace(/\/{2,}/g, "/");
-	    var parts    = path.split("/"),
-	        absolute = isAbsolute(path),
-	        prefix   = "";
-	    if (absolute)
-	        prefix = parts.shift() + "/";
-	    for (var i = 0; i < parts.length;) {
-	        if (parts[i] === "..") {
-	            if (i > 0 && parts[i - 1] !== "..")
-	                parts.splice(--i, 2);
-	            else if (absolute)
-	                parts.splice(i, 1);
-	            else
-	                ++i;
-	        } else if (parts[i] === ".")
-	            parts.splice(i, 1);
-	        else
-	            ++i;
+	/**/
+	fetch.xhr = function fetch_xhr(filename, options, callback) {
+	    var xhr = new XMLHttpRequest();
+	    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
+
+	        if (xhr.readyState !== 4)
+	            return undefined;
+
+	        // local cors security errors return status 0 / empty string, too. afaik this cannot be
+	        // reliably distinguished from an actually empty file for security reasons. feel free
+	        // to send a pull request if you are aware of a solution.
+	        if (xhr.status !== 0 && xhr.status !== 200)
+	            return callback(Error("status " + xhr.status));
+
+	        // if binary data is expected, make sure that some sort of array is returned, even if
+	        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
+	        if (options.binary) {
+	            var buffer = xhr.response;
+	            if (!buffer) {
+	                buffer = [];
+	                for (var i = 0; i < xhr.responseText.length; ++i)
+	                    buffer.push(xhr.responseText.charCodeAt(i) & 255);
+	            }
+	            return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
+	        }
+	        return callback(null, xhr.responseText);
+	    };
+
+	    if (options.binary) {
+	        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
+	        if ("overrideMimeType" in xhr)
+	            xhr.overrideMimeType("text/plain; charset=x-user-defined");
+	        xhr.responseType = "arraybuffer";
 	    }
-	    return uncPrefix + prefix + parts.join("/");
+
+	    xhr.open("GET", filename);
+	    xhr.send();
 	};
+	return fetch_1;
+}
 
-	/**
-	 * Resolves the specified include path against the specified origin path.
-	 * @param {string} originPath Path to the origin file
-	 * @param {string} includePath Include path relative to origin path
-	 * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
-	 * @returns {string} Path to the include file
-	 */
-	path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
-	    if (!alreadyNormalized)
-	        includePath = normalize(includePath);
-	    if (isAbsolute(includePath))
-	        return includePath;
-	    if (!alreadyNormalized)
-	        originPath = normalize(originPath);
-	    return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
-	}; 
-} (path));
+var path = {};
+
+var hasRequiredPath;
+
+function requirePath () {
+	if (hasRequiredPath) return path;
+	hasRequiredPath = 1;
+	(function (exports) {
+
+		/**
+		 * A minimal path module to resolve Unix, Windows and URL paths alike.
+		 * @memberof util
+		 * @namespace
+		 */
+		var path = exports;
+
+		var isAbsolute =
+		/**
+		 * Tests if the specified path is absolute.
+		 * @param {string} path Path to test
+		 * @returns {boolean} `true` if path is absolute
+		 */
+		path.isAbsolute = function isAbsolute(path) {
+		    return /^(?:\/|\w+:|\\\\\w+)/.test(path);
+		};
+
+		var normalize =
+		/**
+		 * Normalizes the specified path.
+		 * @param {string} path Path to normalize
+		 * @returns {string} Normalized path
+		 */
+		path.normalize = function normalize(path) {
+		    var firstTwoCharacters = path.substring(0,2);
+		    var uncPrefix = "";
+		    if (firstTwoCharacters === "\\\\") {
+		        uncPrefix = firstTwoCharacters;
+		        path = path.substring(2);
+		    }
+
+		    path = path.replace(/\\/g, "/")
+		               .replace(/\/{2,}/g, "/");
+		    var parts    = path.split("/"),
+		        absolute = isAbsolute(path),
+		        prefix   = "";
+		    if (absolute)
+		        prefix = parts.shift() + "/";
+		    for (var i = 0; i < parts.length;) {
+		        if (parts[i] === "..") {
+		            if (i > 0 && parts[i - 1] !== "..")
+		                parts.splice(--i, 2);
+		            else if (absolute)
+		                parts.splice(i, 1);
+		            else
+		                ++i;
+		        } else if (parts[i] === ".")
+		            parts.splice(i, 1);
+		        else
+		            ++i;
+		    }
+		    return uncPrefix + prefix + parts.join("/");
+		};
+
+		/**
+		 * Resolves the specified include path against the specified origin path.
+		 * @param {string} originPath Path to the origin file
+		 * @param {string} includePath Include path relative to origin path
+		 * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
+		 * @returns {string} Path to the include file
+		 */
+		path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
+		    if (!alreadyNormalized)
+		        includePath = normalize(includePath);
+		    if (isAbsolute(includePath))
+		        return includePath;
+		    if (!alreadyNormalized)
+		        originPath = normalize(originPath);
+		    return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
+		}; 
+	} (path));
+	return path;
+}
 
 var namespace;
 var hasRequiredNamespace;
@@ -273574,10 +273626,10 @@ function requireUtil () {
 	var Type, // cyclic
 	    Enum;
 
-	util.codegen  = codegen_1;
-	util.fetch    = fetch_1;
-	util.path     = path;
-	util.patterns = patterns$1;
+	util.codegen  = requireCodegen();
+	util.fetch    = requireFetch();
+	util.path     = requirePath();
+	util.patterns = requirePatterns();
 
 	var reservedRe = util.patterns.reservedRe,
 	    unsafePropertyRe = util.patterns.unsafePropertyRe;
@@ -273586,7 +273638,7 @@ function requireUtil () {
 	 * Node's fs module if available.
 	 * @type {Object.<string,*>}
 	 */
-	util.fs = fs_1;
+	util.fs = requireFs();
 
 	/**
 	 * Converts an object's values to an array.
@@ -283299,10 +283351,32 @@ class DanmaClient extends EventEmitter$l.EventEmitter {
                 };
                 this.emit("Message", gift);
             },
+            raw: {
+                SEND_GIFT_V2: (data) => {
+                    const msg = data.data;
+                    const timestamp = this.useServerTimestamp ? msg.timestamp * 1000 : Date.now();
+                    const gift = {
+                        type: "give_gift",
+                        timestamp: timestamp,
+                        name: msg.gift_name,
+                        count: msg.num,
+                        price: msg.coin_type === "silver" ? 0 : msg.price / 1000,
+                        sender: {
+                            uid: String(msg.uid),
+                            name: msg.uname,
+                            avatar: msg.face,
+                        },
+                    };
+                    this.emit("Message", gift);
+                },
+            },
             onGift: (msg) => {
+                // 由于兼容性0.5.6-beta.1，与上游存在冲突
+                if (msg.type === "SEND_GIFT_V2")
+                    return;
                 let timestamp = this.useServerTimestamp ? msg?.raw?.data?.timestamp * 1000 : Date.now();
                 if (msg.type === "SEND_GIFT_V2") {
-                    timestamp = this.useServerTimestamp ? msg.timestamp : Date.now();
+                    timestamp = this.useServerTimestamp ? msg.timestamp * 1000 : Date.now();
                 }
                 const gift = {
                     type: "give_gift",
@@ -285857,12 +285931,12 @@ const qualityList$1 = [
         desc: "真原画",
     },
 ];
-let cookieCache;
+let cookieCache$1;
 const getCookie$1 = async () => {
     const now = new Date().getTime();
     // 缓存6小时
-    if (cookieCache?.startTimestamp && now - cookieCache.startTimestamp < 6 * 60 * 60 * 1000) {
-        return cookieCache.cookies;
+    if (cookieCache$1?.startTimestamp && now - cookieCache$1.startTimestamp < 6 * 60 * 60 * 1000) {
+        return cookieCache$1.cookies;
     }
     const res = await requester.get("https://live.douyin.com/");
     if (!res.headers["set-cookie"]) {
@@ -285875,12 +285949,12 @@ const getCookie$1 = async () => {
         .join("; ");
     if (!cookies.includes("ttwid")) {
         // 如果不含ttwid，且已经存在含ttwid的cookie，将缓存时间直接增加1小时，复用之前的参数
-        if (cookieCache?.cookies) {
-            cookieCache.startTimestamp += 60 * 60 * 1000; // 增加1小时
-            return cookieCache.cookies;
+        if (cookieCache$1?.cookies) {
+            cookieCache$1.startTimestamp += 60 * 60 * 1000; // 增加1小时
+            return cookieCache$1.cookies;
         }
     }
-    cookieCache = {
+    cookieCache$1 = {
         startTimestamp: now,
         cookies,
     };
@@ -317841,7 +317915,14 @@ const $root = minimal.roots["default"] || (minimal.roots["default"] = {});
     return douyin;
 })());
 
+let cookieCache;
 const getCookie = async () => {
+    const now = new Date().getTime();
+    // 缓存1小时：重连时优先复用，避免每次连接都依赖实时网络抓取，
+    // 瞬时网络抖动时不会导致 connect() 失败、重试链断裂
+    if (cookieCache?.startTimestamp && now - cookieCache.startTimestamp < 60 * 60 * 1000) {
+        return cookieCache.cookies;
+    }
     const res = await fetch("https://live.douyin.com/", {
         method: "GET",
     });
@@ -317854,6 +317935,17 @@ const getCookie = async () => {
         return cookie.split(";")[0];
     })
         .join("; ");
+    if (!cookies.includes("ttwid")) {
+        // 新cookie不含ttwid，且缓存中有含ttwid的旧cookie时，延长旧缓存继续复用
+        if (cookieCache?.cookies) {
+            cookieCache.startTimestamp += 60 * 60 * 1000;
+            return cookieCache.cookies;
+        }
+    }
+    cookieCache = {
+        startTimestamp: now,
+        cookies,
+    };
     return cookies;
 };
 
@@ -317891,39 +317983,46 @@ class DouYinDanmaClient extends TypedEmitter {
         }
     }
     async connect() {
-        const url = await this.getWsInfo(this.roomId);
-        if (!url) {
-            this.emit("error", new Error("获取抖音弹幕签名失败"));
-            return;
+        try {
+            const url = await this.getWsInfo(this.roomId);
+            if (!url) {
+                throw new Error("获取抖音弹幕签名失败");
+            }
+            this.emit("init", url);
+            const cookies = this.cookie || (await getCookie());
+            this.ws = new WebSocket$7(url, {
+                headers: {
+                    Cookie: cookies,
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+                    Origin: "https://live.douyin.com",
+                    Referer: "https://live.douyin.com/",
+                },
+            });
+            this.ws.on("open", () => {
+                this.emit("open");
+                this.startHeartbeat();
+                this.startTimeoutCheck();
+            });
+            this.ws.on("message", (data) => {
+                this.lastMessageTime = Date.now();
+                this.decode(data);
+            });
+            this.ws.on("close", () => {
+                this.emit("close");
+                this.reconnect();
+            });
+            this.ws.on("error", (error) => {
+                this.emit("error", error);
+                this.reconnect();
+            });
         }
-        this.emit("init", url);
-        const cookies = this.cookie || (await getCookie());
-        this.ws = new WebSocket$7(url, {
-            headers: {
-                Cookie: cookies,
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
-                Origin: "https://live.douyin.com",
-                Referer: "https://live.douyin.com/",
-            },
-        });
-        this.ws.on("open", () => {
-            this.reconnectAttempts = 0;
-            this.emit("open");
-            this.startHeartbeat();
-            this.startTimeoutCheck();
-        });
-        this.ws.on("message", (data) => {
-            this.lastMessageTime = Date.now();
-            this.decode(data);
-        });
-        this.ws.on("close", () => {
-            this.emit("close");
-            this.reconnect();
-        });
-        this.ws.on("error", (error) => {
-            this.emit("error", error);
+        catch (err) {
+            // getWsInfo/getCookie 等前置步骤失败时，必须让错误可见并继续重试：
+            // 否则 WebSocket 不会创建，没有任何事件能触发下一次 reconnect，
+            // 弹幕客户端将静默死亡直到录制结束
+            this.emit("error", err);
             this.reconnect();
-        });
+        }
     }
     send(data) {
         if (!this.ws) {
@@ -318263,6 +318362,7 @@ function createRecorder$2(opts) {
         availableSources: [],
         qualityRetry: opts.qualityRetry ?? 0,
         useServerTimestamp: opts.useServerTimestamp ?? true,
+        cookieMode: opts.cookieMode ?? "all",
         state: "idle",
         cache: null,
         appendTimeline: null,
@@ -318276,7 +318376,7 @@ function createRecorder$2(opts) {
         async getLiveInfo() {
             const channelId = this.channelId;
             const info = await getInfo$2(channelId, {
-                auth: this.auth,
+                auth: this.cookieMode === "danma" ? undefined : this.auth,
                 uid: this.uid,
             });
             return {
@@ -318291,7 +318391,7 @@ function createRecorder$2(opts) {
                 streamPriorities: this.streamPriorities,
                 sourcePriorities: this.sourcePriorities,
                 strictQuality: false,
-                auth: this.auth,
+                auth: this.cookieMode === "danma" ? undefined : this.auth,
                 formatPriorities: this.formatPriorities,
                 doubleScreen: this.doubleScreen,
                 api: this.api,
@@ -318317,7 +318417,7 @@ const checkLiveStatusAndRecord$2 = async function ({ getSavePath, banLiveId, isM
     // 如果已经在录制中,只在需要检查标题关键词时才获取最新信息
     if (this.recordHandle != null) {
         const shouldStop = await utils$3.checkTitleKeywordsWhileRecording(this, isManualStart, (channelId) => getInfo$2(channelId, {
-            auth: this.auth,
+            auth: this.cookieMode === "danma" ? undefined : this.auth,
             api: this.api,
             uid: this.uid,
         }));
@@ -318331,7 +318431,7 @@ const checkLiveStatusAndRecord$2 = async function ({ getSavePath, banLiveId, isM
     let isLiveRadio = false;
     try {
         const liveInfo = await getInfo$2(this.channelId, {
-            auth: this.auth,
+            auth: this.cookieMode === "danma" ? undefined : this.auth,
             api: this.api,
             uid: this.uid,
         });
@@ -318369,7 +318469,7 @@ const checkLiveStatusAndRecord$2 = async function ({ getSavePath, banLiveId, isM
             streamPriorities: this.streamPriorities,
             sourcePriorities: this.sourcePriorities,
             strictQuality: strictQuality,
-            auth: this.auth,
+            auth: this.cookieMode === "danma" ? undefined : this.auth,
             formatPriorities: this.formatPriorities,
             doubleScreen: this.doubleScreen,
             api: this.api,
@@ -318440,7 +318540,7 @@ const checkLiveStatusAndRecord$2 = async function ({ getSavePath, banLiveId, isM
         proxy: this.proxy,
     }, onEnd, async () => {
         const info = await getInfo$2(this.channelId, {
-            auth: this.auth,
+            auth: this.cookieMode === "danma" ? undefined : this.auth,
         });
         return info;
     });
@@ -318480,8 +318580,9 @@ const checkLiveStatusAndRecord$2 = async function ({ getSavePath, banLiveId, isM
     // 礼物延迟处理时间(毫秒),可根据实际情况调整
     const GIFT_DELAY = 5000;
     const client = new DouYinDanmaClient(this?.liveInfo?.liveId, {
-        cookie: this.auth,
+        cookie: this.cookieMode === "stream" ? undefined : this.auth,
     });
+    console.log("DouYinDanmaClient", this?.liveInfo?.liveId, this.cookieMode, this.auth);
     client.on("chat", (msg) => {
         const extraDataController = downloader.getExtraDataController();
         if (!extraDataController)
@@ -382118,6 +382219,11 @@ class RecorderConfig {
                         return get$1(globalConfig, "tiktok.cookie");
                     }
                 }
+                else if (key === "cookieMode") {
+                    if (setting.providerId === "DouYin") {
+                        return get$1(globalConfig, "douyin.cookieMode");
+                    }
+                }
                 else if (key === "doubleScreen") {
                     if (setting.providerId === "DouYin") {
                         return get$1(globalConfig, "douyin.doubleScreen");
@@ -382265,6 +382371,7 @@ class RecorderConfig {
             debugLevel: getValue("debugLevel") ?? "none",
             recorderType: getValue("recorderType") ?? "ffmpeg",
             auth: auth,
+            cookieMode: getValue("cookieMode") ?? "all",
             useM3U8Proxy: getValue("useM3U8Proxy") ?? false,
             customHost: getValue("customHost"),
             segmentOnTitleChange: getValue("segmentOnTitleChange") ?? false,
@@ -382433,7 +382540,7 @@ async function sendEndLiveNotification(appConfig, recorder, config) {
 }
 async function convert2Mp4(videoFile) {
     const output = replaceExtName$1(videoFile, ".mp4");
-    if (await fs$m.pathExists(output)) {
+    if (await fs$k.pathExists(output)) {
         throw new Error(`目标文件已存在: ${output}`);
     }
     const name = path$z.basename(output);
@@ -382587,7 +382694,7 @@ async function createRecorderManager(appConfig) {
             return;
         if (recorder.recordHandle) {
             const logFilePath = utils$3.replaceExtName(`${recorder.recordHandle.savePath}_${recorder.id}`, ".recorder.log");
-            fs$m.appendFile(logFilePath, log.text + "\n").catch(() => { });
+            fs$k.appendFile(logFilePath, log.text + "\n").catch(() => { });
             return;
         }
         else {
@@ -382737,7 +382844,7 @@ async function createRecorderManager(appConfig) {
                     danma_stats_json: JSON.stringify(stats.danmaStats),
                 });
             }
-            else if (xmlFile && (await fs$m.pathExists(xmlFile))) {
+            else if (xmlFile && (await fs$k.pathExists(xmlFile))) {
                 const { uniqMember, danmaNum } = await danmaReport(xmlFile);
                 recordHistory.upadteLive({
                     video_file: filename,
@@ -382750,7 +382857,7 @@ async function createRecorderManager(appConfig) {
             if (data?.convert2Mp4) {
                 try {
                     await convert2Mp4(filename);
-                    await fs$m.unlink(filename);
+                    await fs$k.unlink(filename);
                     logObj.info("转换 mp4 成功，已删除原文件", { filename });
                 }
                 catch (error) {
@@ -382822,7 +382929,7 @@ async function createRecorderManager(appConfig) {
             }
         }
         const xmlFile = replaceExtName$1(filename, ".xml");
-        if (config.recorder.saveDanma2DB && xmlFile && (await fs$m.pathExists(xmlFile))) {
+        if (config.recorder.saveDanma2DB && xmlFile && (await fs$k.pathExists(xmlFile))) {
             const history = recordHistory.getRecord({
                 file: filename,
                 live_id: liveId,
@@ -383035,7 +383142,7 @@ const checkDiskSpaceLoop = async () => {
         const threshold = config?.notification?.task?.diskSpaceCheck?.threshold ?? 10;
         if (config?.notification?.task?.diskSpaceCheck?.values?.includes("bilirecorder")) {
             if (config?.webhook?.recoderFolder &&
-                (await fs$m.pathExists(config?.webhook?.recoderFolder))) {
+                (await fs$k.pathExists(config?.webhook?.recoderFolder))) {
                 // @ts-ignore
                 const diskInfo = await checkDiskSpace(config?.webhook?.recoderFolder);
                 if (diskInfo.free < threshold * 1024 * 1024 * 1024) {
@@ -383054,7 +383161,7 @@ const checkDiskSpaceLoop = async () => {
             }
         }
         if (config?.notification?.task?.diskSpaceCheck?.values?.includes("bililiveTools")) {
-            if (config?.recorder?.savePath && (await fs$m.pathExists(config?.recorder?.savePath))) {
+            if (config?.recorder?.savePath && (await fs$k.pathExists(config?.recorder?.savePath))) {
                 // @ts-ignore
                 const diskInfo = await checkDiskSpace(config?.recorder?.savePath);
                 if (diskInfo.free < threshold * 1024 * 1024 * 1024) {
@@ -383139,12 +383246,12 @@ exports.esDefineProperty = esDefineProperty;
 exports.escaped = escaped;
 exports.executeVirtualRecordConfig = executeVirtualRecordConfig;
 exports.extension = extension$4;
-exports.fetch = fetch$2;
+exports.fetch = fetch$1;
 exports.formatDesc = formatDesc;
 exports.formatPartTitle = formatPartTitle;
 exports.formatSeasonTitle = formatSeasonTitle;
 exports.formatTitle = formatTitle;
-exports.fs = fs$m;
+exports.fs = fs$k;
 exports.functionBind = functionBind;
 exports.genTimeData = genTimeData;
 exports.getBinPath = getBinPath;