@kiki_agent/daemon 0.1.1 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist/cli.cjs +682 -506
  2. package/package.json +1 -1
package/dist/cli.cjs CHANGED
@@ -10607,8 +10607,8 @@ var require_utils = __commonJS({
10607
10607
  var result = transform[inputType][outputType](input);
10608
10608
  return result;
10609
10609
  };
10610
- exports2.resolve = function(path12) {
10611
- var parts = path12.split("/");
10610
+ exports2.resolve = function(path13) {
10611
+ var parts = path13.split("/");
10612
10612
  var result = [];
10613
10613
  for (var index = 0; index < parts.length; index++) {
10614
10614
  var part = parts[index];
@@ -16461,18 +16461,18 @@ var require_object = __commonJS({
16461
16461
  var object = new ZipObject(name, zipObjectContent, o);
16462
16462
  this.files[name] = object;
16463
16463
  };
16464
- var parentFolder = function(path12) {
16465
- if (path12.slice(-1) === "/") {
16466
- path12 = path12.substring(0, path12.length - 1);
16464
+ var parentFolder = function(path13) {
16465
+ if (path13.slice(-1) === "/") {
16466
+ path13 = path13.substring(0, path13.length - 1);
16467
16467
  }
16468
- var lastSlash = path12.lastIndexOf("/");
16469
- return lastSlash > 0 ? path12.substring(0, lastSlash) : "";
16468
+ var lastSlash = path13.lastIndexOf("/");
16469
+ return lastSlash > 0 ? path13.substring(0, lastSlash) : "";
16470
16470
  };
16471
- var forceTrailingSlash = function(path12) {
16472
- if (path12.slice(-1) !== "/") {
16473
- path12 += "/";
16471
+ var forceTrailingSlash = function(path13) {
16472
+ if (path13.slice(-1) !== "/") {
16473
+ path13 += "/";
16474
16474
  }
16475
- return path12;
16475
+ return path13;
16476
16476
  };
16477
16477
  var folderAdd = function(name, createFolders) {
16478
16478
  createFolders = typeof createFolders !== "undefined" ? createFolders : defaults.createFolders;
@@ -20152,7 +20152,7 @@ var require_readable2 = __commonJS({
20152
20152
  var require_utils2 = __commonJS({
20153
20153
  "../../node_modules/.pnpm/exceljs@4.4.0/node_modules/exceljs/lib/utils/utils.js"(exports2, module2) {
20154
20154
  "use strict";
20155
- var fs14 = require("fs");
20155
+ var fs15 = require("fs");
20156
20156
  var inherits2 = function(cls, superCtor, statics, prototype) {
20157
20157
  cls.super_ = superCtor;
20158
20158
  if (!prototype) {
@@ -20212,8 +20212,8 @@ var require_utils2 = __commonJS({
20212
20212
  };
20213
20213
  },
20214
20214
  getRelsPath(filepath) {
20215
- const path12 = utils.parsePath(filepath);
20216
- return `${path12.path}/_rels/${path12.name}.rels`;
20215
+ const path13 = utils.parsePath(filepath);
20216
+ return `${path13.path}/_rels/${path13.name}.rels`;
20217
20217
  },
20218
20218
  xmlEncode(text2) {
20219
20219
  const regexResult = xmlDecodeRegex.exec(text2);
@@ -20290,9 +20290,9 @@ var require_utils2 = __commonJS({
20290
20290
  return result;
20291
20291
  },
20292
20292
  fs: {
20293
- exists(path12) {
20293
+ exists(path13) {
20294
20294
  return new Promise((resolve) => {
20295
- fs14.access(path12, fs14.constants.F_OK, (err) => {
20295
+ fs15.access(path13, fs15.constants.F_OK, (err) => {
20296
20296
  resolve(!err);
20297
20297
  });
20298
20298
  });
@@ -32508,7 +32508,7 @@ var require_theme1 = __commonJS({
32508
32508
  var require_xlsx = __commonJS({
32509
32509
  "../../node_modules/.pnpm/exceljs@4.4.0/node_modules/exceljs/lib/xlsx/xlsx.js"(exports2, module2) {
32510
32510
  "use strict";
32511
- var fs14 = require("fs");
32511
+ var fs15 = require("fs");
32512
32512
  var JSZip = require_lib3();
32513
32513
  var { PassThrough } = require_readable2();
32514
32514
  var ZipStream = require_zip_stream();
@@ -32531,7 +32531,7 @@ var require_xlsx = __commonJS({
32531
32531
  var theme1Xml = require_theme1();
32532
32532
  function fsReadFileAsync(filename, options) {
32533
32533
  return new Promise((resolve, reject) => {
32534
- fs14.readFile(filename, options, (error, data) => {
32534
+ fs15.readFile(filename, options, (error, data) => {
32535
32535
  if (error) {
32536
32536
  reject(error);
32537
32537
  } else {
@@ -32552,7 +32552,7 @@ var require_xlsx = __commonJS({
32552
32552
  if (!await utils.fs.exists(filename)) {
32553
32553
  throw new Error(`File not found: ${filename}`);
32554
32554
  }
32555
- const stream = fs14.createReadStream(filename);
32555
+ const stream = fs15.createReadStream(filename);
32556
32556
  try {
32557
32557
  const workbook = await this.read(stream, options);
32558
32558
  stream.close();
@@ -32635,11 +32635,11 @@ var require_xlsx = __commonJS({
32635
32635
  delete model.drawingRels;
32636
32636
  delete model.vmlDrawings;
32637
32637
  }
32638
- async _processWorksheetEntry(stream, model, sheetNo, options, path12) {
32638
+ async _processWorksheetEntry(stream, model, sheetNo, options, path13) {
32639
32639
  const xform = new WorksheetXform(options);
32640
32640
  const worksheet = await xform.parseStream(stream);
32641
32641
  worksheet.sheetNo = sheetNo;
32642
- model.worksheetHash[path12] = worksheet;
32642
+ model.worksheetHash[path13] = worksheet;
32643
32643
  model.worksheets.push(worksheet);
32644
32644
  }
32645
32645
  async _processCommentEntry(stream, model, name) {
@@ -32935,8 +32935,8 @@ var require_xlsx = __commonJS({
32935
32935
  const themes = model.themes || { theme1: theme1Xml };
32936
32936
  Object.keys(themes).forEach((name) => {
32937
32937
  const xml = themes[name];
32938
- const path12 = `xl/theme/${name}.xml`;
32939
- zip.append(xml, { name: path12 });
32938
+ const path13 = `xl/theme/${name}.xml`;
32939
+ zip.append(xml, { name: path13 });
32940
32940
  });
32941
32941
  }
32942
32942
  async addOfficeRels(zip) {
@@ -33074,7 +33074,7 @@ var require_xlsx = __commonJS({
33074
33074
  return this._finalize(zip);
33075
33075
  }
33076
33076
  writeFile(filename, options) {
33077
- const stream = fs14.createWriteStream(filename);
33077
+ const stream = fs15.createWriteStream(filename);
33078
33078
  return new Promise((resolve, reject) => {
33079
33079
  stream.on("finish", () => {
33080
33080
  resolve();
@@ -34326,7 +34326,7 @@ var require_src = __commonJS({
34326
34326
  exports2.writeToPath = exports2.writeToString = exports2.writeToBuffer = exports2.writeToStream = exports2.write = exports2.format = exports2.FormatterOptions = exports2.CsvFormatterStream = void 0;
34327
34327
  var util_1 = require("util");
34328
34328
  var stream_1 = require("stream");
34329
- var fs14 = __importStar(require("fs"));
34329
+ var fs15 = __importStar(require("fs"));
34330
34330
  var FormatterOptions_1 = require_FormatterOptions();
34331
34331
  var CsvFormatterStream_1 = require_CsvFormatterStream();
34332
34332
  __exportStar(require_types(), exports2);
@@ -34364,8 +34364,8 @@ var require_src = __commonJS({
34364
34364
  });
34365
34365
  };
34366
34366
  exports2.writeToString = (rows, options) => exports2.writeToBuffer(rows, options).then((buffer) => buffer.toString());
34367
- exports2.writeToPath = (path12, rows, options) => {
34368
- const stream = fs14.createWriteStream(path12, { encoding: "utf8" });
34367
+ exports2.writeToPath = (path13, rows, options) => {
34368
+ const stream = fs15.createWriteStream(path13, { encoding: "utf8" });
34369
34369
  return exports2.write(rows, options).pipe(stream);
34370
34370
  };
34371
34371
  }
@@ -35226,11 +35226,11 @@ var require_lodash8 = __commonJS({
35226
35226
  function baseForOwn(object, iteratee) {
35227
35227
  return object && baseFor(object, iteratee, keys);
35228
35228
  }
35229
- function baseGet(object, path12) {
35230
- path12 = isKey(path12, object) ? [path12] : castPath(path12);
35231
- var index = 0, length = path12.length;
35229
+ function baseGet(object, path13) {
35230
+ path13 = isKey(path13, object) ? [path13] : castPath(path13);
35231
+ var index = 0, length = path13.length;
35232
35232
  while (object != null && index < length) {
35233
- object = object[toKey(path12[index++])];
35233
+ object = object[toKey(path13[index++])];
35234
35234
  }
35235
35235
  return index && index == length ? object : void 0;
35236
35236
  }
@@ -35352,18 +35352,18 @@ var require_lodash8 = __commonJS({
35352
35352
  return object === source || baseIsMatch(object, source, matchData);
35353
35353
  };
35354
35354
  }
35355
- function baseMatchesProperty(path12, srcValue) {
35356
- if (isKey(path12) && isStrictComparable(srcValue)) {
35357
- return matchesStrictComparable(toKey(path12), srcValue);
35355
+ function baseMatchesProperty(path13, srcValue) {
35356
+ if (isKey(path13) && isStrictComparable(srcValue)) {
35357
+ return matchesStrictComparable(toKey(path13), srcValue);
35358
35358
  }
35359
35359
  return function(object) {
35360
- var objValue = get(object, path12);
35361
- return objValue === void 0 && objValue === srcValue ? hasIn(object, path12) : baseIsEqual(srcValue, objValue, void 0, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
35360
+ var objValue = get(object, path13);
35361
+ return objValue === void 0 && objValue === srcValue ? hasIn(object, path13) : baseIsEqual(srcValue, objValue, void 0, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
35362
35362
  };
35363
35363
  }
35364
- function basePropertyDeep(path12) {
35364
+ function basePropertyDeep(path13) {
35365
35365
  return function(object) {
35366
- return baseGet(object, path12);
35366
+ return baseGet(object, path13);
35367
35367
  };
35368
35368
  }
35369
35369
  function baseToString(value) {
@@ -35581,11 +35581,11 @@ var require_lodash8 = __commonJS({
35581
35581
  return result;
35582
35582
  };
35583
35583
  }
35584
- function hasPath(object, path12, hasFunc) {
35585
- path12 = isKey(path12, object) ? [path12] : castPath(path12);
35586
- var result, index = -1, length = path12.length;
35584
+ function hasPath(object, path13, hasFunc) {
35585
+ path13 = isKey(path13, object) ? [path13] : castPath(path13);
35586
+ var result, index = -1, length = path13.length;
35587
35587
  while (++index < length) {
35588
- var key = toKey(path12[index]);
35588
+ var key = toKey(path13[index]);
35589
35589
  if (!(result = object != null && hasFunc(object, key))) {
35590
35590
  break;
35591
35591
  }
@@ -35722,12 +35722,12 @@ var require_lodash8 = __commonJS({
35722
35722
  function toString(value) {
35723
35723
  return value == null ? "" : baseToString(value);
35724
35724
  }
35725
- function get(object, path12, defaultValue) {
35726
- var result = object == null ? void 0 : baseGet(object, path12);
35725
+ function get(object, path13, defaultValue) {
35726
+ var result = object == null ? void 0 : baseGet(object, path13);
35727
35727
  return result === void 0 ? defaultValue : result;
35728
35728
  }
35729
- function hasIn(object, path12) {
35730
- return object != null && hasPath(object, path12, baseHasIn);
35729
+ function hasIn(object, path13) {
35730
+ return object != null && hasPath(object, path13, baseHasIn);
35731
35731
  }
35732
35732
  function keys(object) {
35733
35733
  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
@@ -35735,8 +35735,8 @@ var require_lodash8 = __commonJS({
35735
35735
  function identity(value) {
35736
35736
  return value;
35737
35737
  }
35738
- function property(path12) {
35739
- return isKey(path12) ? baseProperty(toKey(path12)) : basePropertyDeep(path12);
35738
+ function property(path13) {
35739
+ return isKey(path13) ? baseProperty(toKey(path13)) : basePropertyDeep(path13);
35740
35740
  }
35741
35741
  module2.exports = groupBy;
35742
35742
  }
@@ -36608,7 +36608,7 @@ var require_src2 = __commonJS({
36608
36608
  };
36609
36609
  Object.defineProperty(exports2, "__esModule", { value: true });
36610
36610
  exports2.parseString = exports2.parseFile = exports2.parseStream = exports2.parse = exports2.ParserOptions = exports2.CsvParserStream = void 0;
36611
- var fs14 = __importStar(require("fs"));
36611
+ var fs15 = __importStar(require("fs"));
36612
36612
  var stream_1 = require("stream");
36613
36613
  var ParserOptions_1 = require_ParserOptions();
36614
36614
  var CsvParserStream_1 = require_CsvParserStream();
@@ -36623,7 +36623,7 @@ var require_src2 = __commonJS({
36623
36623
  } });
36624
36624
  exports2.parse = (args) => new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(args));
36625
36625
  exports2.parseStream = (stream, options) => stream.pipe(new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(options)));
36626
- exports2.parseFile = (location, options = {}) => fs14.createReadStream(location).pipe(new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(options)));
36626
+ exports2.parseFile = (location, options = {}) => fs15.createReadStream(location).pipe(new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(options)));
36627
36627
  exports2.parseString = (string, options) => {
36628
36628
  const rs = new stream_1.Readable();
36629
36629
  rs.push(string);
@@ -37177,7 +37177,7 @@ var require_dayjs_min = __commonJS({
37177
37177
  var require_csv = __commonJS({
37178
37178
  "../../node_modules/.pnpm/exceljs@4.4.0/node_modules/exceljs/lib/csv/csv.js"(exports2, module2) {
37179
37179
  "use strict";
37180
- var fs14 = require("fs");
37180
+ var fs15 = require("fs");
37181
37181
  var fastCsv = require_src3();
37182
37182
  var customParseFormat = require_customParseFormat();
37183
37183
  var utc = require_utc();
@@ -37207,7 +37207,7 @@ var require_csv = __commonJS({
37207
37207
  if (!await exists(filename)) {
37208
37208
  throw new Error(`File not found: ${filename}`);
37209
37209
  }
37210
- const stream = fs14.createReadStream(filename);
37210
+ const stream = fs15.createReadStream(filename);
37211
37211
  const worksheet = await this.read(stream, options);
37212
37212
  stream.close();
37213
37213
  return worksheet;
@@ -37323,7 +37323,7 @@ var require_csv = __commonJS({
37323
37323
  const streamOptions = {
37324
37324
  encoding: options.encoding || "utf8"
37325
37325
  };
37326
- const stream = fs14.createWriteStream(filename, streamOptions);
37326
+ const stream = fs15.createWriteStream(filename, streamOptions);
37327
37327
  return this.write(stream, options);
37328
37328
  }
37329
37329
  async writeBuffer(options) {
@@ -37775,8 +37775,8 @@ var require_minimatch = __commonJS({
37775
37775
  return new Minimatch(pattern, options).match(p);
37776
37776
  };
37777
37777
  module2.exports = minimatch;
37778
- var path12 = require_path();
37779
- minimatch.sep = path12.sep;
37778
+ var path13 = require_path();
37779
+ minimatch.sep = path13.sep;
37780
37780
  var GLOBSTAR = Symbol("globstar **");
37781
37781
  minimatch.GLOBSTAR = GLOBSTAR;
37782
37782
  var expand = require_brace_expansion();
@@ -38382,8 +38382,8 @@ var require_minimatch = __commonJS({
38382
38382
  if (this.empty) return f === "";
38383
38383
  if (f === "/" && partial) return true;
38384
38384
  const options = this.options;
38385
- if (path12.sep !== "/") {
38386
- f = f.split(path12.sep).join("/");
38385
+ if (path13.sep !== "/") {
38386
+ f = f.split(path13.sep).join("/");
38387
38387
  }
38388
38388
  f = f.split(slashSplit);
38389
38389
  this.debug(this.pattern, "split", f);
@@ -38422,13 +38422,13 @@ var require_readdir_glob = __commonJS({
38422
38422
  "../../node_modules/.pnpm/readdir-glob@1.1.3/node_modules/readdir-glob/index.js"(exports2, module2) {
38423
38423
  "use strict";
38424
38424
  module2.exports = readdirGlob;
38425
- var fs14 = require("fs");
38425
+ var fs15 = require("fs");
38426
38426
  var { EventEmitter } = require("events");
38427
38427
  var { Minimatch } = require_minimatch();
38428
38428
  var { resolve } = require("path");
38429
38429
  function readdir(dir, strict) {
38430
38430
  return new Promise((resolve2, reject) => {
38431
- fs14.readdir(dir, { withFileTypes: true }, (err, files) => {
38431
+ fs15.readdir(dir, { withFileTypes: true }, (err, files) => {
38432
38432
  if (err) {
38433
38433
  switch (err.code) {
38434
38434
  case "ENOTDIR":
@@ -38461,7 +38461,7 @@ var require_readdir_glob = __commonJS({
38461
38461
  }
38462
38462
  function stat2(file, followSymlinks) {
38463
38463
  return new Promise((resolve2, reject) => {
38464
- const statFunc = followSymlinks ? fs14.stat : fs14.lstat;
38464
+ const statFunc = followSymlinks ? fs15.stat : fs15.lstat;
38465
38465
  statFunc(file, (err, stats) => {
38466
38466
  if (err) {
38467
38467
  switch (err.code) {
@@ -38482,8 +38482,8 @@ var require_readdir_glob = __commonJS({
38482
38482
  });
38483
38483
  });
38484
38484
  }
38485
- async function* exploreWalkAsync(dir, path12, followSymlinks, useStat, shouldSkip, strict) {
38486
- let files = await readdir(path12 + dir, strict);
38485
+ async function* exploreWalkAsync(dir, path13, followSymlinks, useStat, shouldSkip, strict) {
38486
+ let files = await readdir(path13 + dir, strict);
38487
38487
  for (const file of files) {
38488
38488
  let name = file.name;
38489
38489
  if (name === void 0) {
@@ -38492,7 +38492,7 @@ var require_readdir_glob = __commonJS({
38492
38492
  }
38493
38493
  const filename = dir + "/" + name;
38494
38494
  const relative = filename.slice(1);
38495
- const absolute = path12 + "/" + relative;
38495
+ const absolute = path13 + "/" + relative;
38496
38496
  let stats = null;
38497
38497
  if (useStat || followSymlinks) {
38498
38498
  stats = await stat2(absolute, followSymlinks);
@@ -38506,15 +38506,15 @@ var require_readdir_glob = __commonJS({
38506
38506
  if (stats.isDirectory()) {
38507
38507
  if (!shouldSkip(relative)) {
38508
38508
  yield { relative, absolute, stats };
38509
- yield* exploreWalkAsync(filename, path12, followSymlinks, useStat, shouldSkip, false);
38509
+ yield* exploreWalkAsync(filename, path13, followSymlinks, useStat, shouldSkip, false);
38510
38510
  }
38511
38511
  } else {
38512
38512
  yield { relative, absolute, stats };
38513
38513
  }
38514
38514
  }
38515
38515
  }
38516
- async function* explore(path12, followSymlinks, useStat, shouldSkip) {
38517
- yield* exploreWalkAsync("", path12, followSymlinks, useStat, shouldSkip, true);
38516
+ async function* explore(path13, followSymlinks, useStat, shouldSkip) {
38517
+ yield* exploreWalkAsync("", path13, followSymlinks, useStat, shouldSkip, true);
38518
38518
  }
38519
38519
  function readOptions(options) {
38520
38520
  return {
@@ -40528,54 +40528,54 @@ var require_polyfills = __commonJS({
40528
40528
  }
40529
40529
  var chdir;
40530
40530
  module2.exports = patch;
40531
- function patch(fs14) {
40531
+ function patch(fs15) {
40532
40532
  if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
40533
- patchLchmod(fs14);
40534
- }
40535
- if (!fs14.lutimes) {
40536
- patchLutimes(fs14);
40537
- }
40538
- fs14.chown = chownFix(fs14.chown);
40539
- fs14.fchown = chownFix(fs14.fchown);
40540
- fs14.lchown = chownFix(fs14.lchown);
40541
- fs14.chmod = chmodFix(fs14.chmod);
40542
- fs14.fchmod = chmodFix(fs14.fchmod);
40543
- fs14.lchmod = chmodFix(fs14.lchmod);
40544
- fs14.chownSync = chownFixSync(fs14.chownSync);
40545
- fs14.fchownSync = chownFixSync(fs14.fchownSync);
40546
- fs14.lchownSync = chownFixSync(fs14.lchownSync);
40547
- fs14.chmodSync = chmodFixSync(fs14.chmodSync);
40548
- fs14.fchmodSync = chmodFixSync(fs14.fchmodSync);
40549
- fs14.lchmodSync = chmodFixSync(fs14.lchmodSync);
40550
- fs14.stat = statFix(fs14.stat);
40551
- fs14.fstat = statFix(fs14.fstat);
40552
- fs14.lstat = statFix(fs14.lstat);
40553
- fs14.statSync = statFixSync(fs14.statSync);
40554
- fs14.fstatSync = statFixSync(fs14.fstatSync);
40555
- fs14.lstatSync = statFixSync(fs14.lstatSync);
40556
- if (fs14.chmod && !fs14.lchmod) {
40557
- fs14.lchmod = function(path12, mode, cb) {
40533
+ patchLchmod(fs15);
40534
+ }
40535
+ if (!fs15.lutimes) {
40536
+ patchLutimes(fs15);
40537
+ }
40538
+ fs15.chown = chownFix(fs15.chown);
40539
+ fs15.fchown = chownFix(fs15.fchown);
40540
+ fs15.lchown = chownFix(fs15.lchown);
40541
+ fs15.chmod = chmodFix(fs15.chmod);
40542
+ fs15.fchmod = chmodFix(fs15.fchmod);
40543
+ fs15.lchmod = chmodFix(fs15.lchmod);
40544
+ fs15.chownSync = chownFixSync(fs15.chownSync);
40545
+ fs15.fchownSync = chownFixSync(fs15.fchownSync);
40546
+ fs15.lchownSync = chownFixSync(fs15.lchownSync);
40547
+ fs15.chmodSync = chmodFixSync(fs15.chmodSync);
40548
+ fs15.fchmodSync = chmodFixSync(fs15.fchmodSync);
40549
+ fs15.lchmodSync = chmodFixSync(fs15.lchmodSync);
40550
+ fs15.stat = statFix(fs15.stat);
40551
+ fs15.fstat = statFix(fs15.fstat);
40552
+ fs15.lstat = statFix(fs15.lstat);
40553
+ fs15.statSync = statFixSync(fs15.statSync);
40554
+ fs15.fstatSync = statFixSync(fs15.fstatSync);
40555
+ fs15.lstatSync = statFixSync(fs15.lstatSync);
40556
+ if (fs15.chmod && !fs15.lchmod) {
40557
+ fs15.lchmod = function(path13, mode, cb) {
40558
40558
  if (cb) process.nextTick(cb);
40559
40559
  };
40560
- fs14.lchmodSync = function() {
40560
+ fs15.lchmodSync = function() {
40561
40561
  };
40562
40562
  }
40563
- if (fs14.chown && !fs14.lchown) {
40564
- fs14.lchown = function(path12, uid2, gid, cb) {
40563
+ if (fs15.chown && !fs15.lchown) {
40564
+ fs15.lchown = function(path13, uid2, gid, cb) {
40565
40565
  if (cb) process.nextTick(cb);
40566
40566
  };
40567
- fs14.lchownSync = function() {
40567
+ fs15.lchownSync = function() {
40568
40568
  };
40569
40569
  }
40570
40570
  if (platform === "win32") {
40571
- fs14.rename = typeof fs14.rename !== "function" ? fs14.rename : function(fs$rename) {
40571
+ fs15.rename = typeof fs15.rename !== "function" ? fs15.rename : function(fs$rename) {
40572
40572
  function rename(from, to, cb) {
40573
40573
  var start = Date.now();
40574
40574
  var backoff = 0;
40575
40575
  fs$rename(from, to, function CB(er) {
40576
40576
  if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
40577
40577
  setTimeout(function() {
40578
- fs14.stat(to, function(stater, st) {
40578
+ fs15.stat(to, function(stater, st) {
40579
40579
  if (stater && stater.code === "ENOENT")
40580
40580
  fs$rename(from, to, CB);
40581
40581
  else
@@ -40591,9 +40591,9 @@ var require_polyfills = __commonJS({
40591
40591
  }
40592
40592
  if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
40593
40593
  return rename;
40594
- }(fs14.rename);
40594
+ }(fs15.rename);
40595
40595
  }
40596
- fs14.read = typeof fs14.read !== "function" ? fs14.read : function(fs$read) {
40596
+ fs15.read = typeof fs15.read !== "function" ? fs15.read : function(fs$read) {
40597
40597
  function read(fd, buffer, offset, length, position, callback_) {
40598
40598
  var callback;
40599
40599
  if (callback_ && typeof callback_ === "function") {
@@ -40601,22 +40601,22 @@ var require_polyfills = __commonJS({
40601
40601
  callback = function(er, _2, __) {
40602
40602
  if (er && er.code === "EAGAIN" && eagCounter < 10) {
40603
40603
  eagCounter++;
40604
- return fs$read.call(fs14, fd, buffer, offset, length, position, callback);
40604
+ return fs$read.call(fs15, fd, buffer, offset, length, position, callback);
40605
40605
  }
40606
40606
  callback_.apply(this, arguments);
40607
40607
  };
40608
40608
  }
40609
- return fs$read.call(fs14, fd, buffer, offset, length, position, callback);
40609
+ return fs$read.call(fs15, fd, buffer, offset, length, position, callback);
40610
40610
  }
40611
40611
  if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
40612
40612
  return read;
40613
- }(fs14.read);
40614
- fs14.readSync = typeof fs14.readSync !== "function" ? fs14.readSync : /* @__PURE__ */ function(fs$readSync) {
40613
+ }(fs15.read);
40614
+ fs15.readSync = typeof fs15.readSync !== "function" ? fs15.readSync : /* @__PURE__ */ function(fs$readSync) {
40615
40615
  return function(fd, buffer, offset, length, position) {
40616
40616
  var eagCounter = 0;
40617
40617
  while (true) {
40618
40618
  try {
40619
- return fs$readSync.call(fs14, fd, buffer, offset, length, position);
40619
+ return fs$readSync.call(fs15, fd, buffer, offset, length, position);
40620
40620
  } catch (er) {
40621
40621
  if (er.code === "EAGAIN" && eagCounter < 10) {
40622
40622
  eagCounter++;
@@ -40626,11 +40626,11 @@ var require_polyfills = __commonJS({
40626
40626
  }
40627
40627
  }
40628
40628
  };
40629
- }(fs14.readSync);
40630
- function patchLchmod(fs15) {
40631
- fs15.lchmod = function(path12, mode, callback) {
40632
- fs15.open(
40633
- path12,
40629
+ }(fs15.readSync);
40630
+ function patchLchmod(fs16) {
40631
+ fs16.lchmod = function(path13, mode, callback) {
40632
+ fs16.open(
40633
+ path13,
40634
40634
  constants2.O_WRONLY | constants2.O_SYMLINK,
40635
40635
  mode,
40636
40636
  function(err, fd) {
@@ -40638,80 +40638,80 @@ var require_polyfills = __commonJS({
40638
40638
  if (callback) callback(err);
40639
40639
  return;
40640
40640
  }
40641
- fs15.fchmod(fd, mode, function(err2) {
40642
- fs15.close(fd, function(err22) {
40641
+ fs16.fchmod(fd, mode, function(err2) {
40642
+ fs16.close(fd, function(err22) {
40643
40643
  if (callback) callback(err2 || err22);
40644
40644
  });
40645
40645
  });
40646
40646
  }
40647
40647
  );
40648
40648
  };
40649
- fs15.lchmodSync = function(path12, mode) {
40650
- var fd = fs15.openSync(path12, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
40649
+ fs16.lchmodSync = function(path13, mode) {
40650
+ var fd = fs16.openSync(path13, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
40651
40651
  var threw = true;
40652
40652
  var ret2;
40653
40653
  try {
40654
- ret2 = fs15.fchmodSync(fd, mode);
40654
+ ret2 = fs16.fchmodSync(fd, mode);
40655
40655
  threw = false;
40656
40656
  } finally {
40657
40657
  if (threw) {
40658
40658
  try {
40659
- fs15.closeSync(fd);
40659
+ fs16.closeSync(fd);
40660
40660
  } catch (er) {
40661
40661
  }
40662
40662
  } else {
40663
- fs15.closeSync(fd);
40663
+ fs16.closeSync(fd);
40664
40664
  }
40665
40665
  }
40666
40666
  return ret2;
40667
40667
  };
40668
40668
  }
40669
- function patchLutimes(fs15) {
40670
- if (constants2.hasOwnProperty("O_SYMLINK") && fs15.futimes) {
40671
- fs15.lutimes = function(path12, at, mt, cb) {
40672
- fs15.open(path12, constants2.O_SYMLINK, function(er, fd) {
40669
+ function patchLutimes(fs16) {
40670
+ if (constants2.hasOwnProperty("O_SYMLINK") && fs16.futimes) {
40671
+ fs16.lutimes = function(path13, at, mt, cb) {
40672
+ fs16.open(path13, constants2.O_SYMLINK, function(er, fd) {
40673
40673
  if (er) {
40674
40674
  if (cb) cb(er);
40675
40675
  return;
40676
40676
  }
40677
- fs15.futimes(fd, at, mt, function(er2) {
40678
- fs15.close(fd, function(er22) {
40677
+ fs16.futimes(fd, at, mt, function(er2) {
40678
+ fs16.close(fd, function(er22) {
40679
40679
  if (cb) cb(er2 || er22);
40680
40680
  });
40681
40681
  });
40682
40682
  });
40683
40683
  };
40684
- fs15.lutimesSync = function(path12, at, mt) {
40685
- var fd = fs15.openSync(path12, constants2.O_SYMLINK);
40684
+ fs16.lutimesSync = function(path13, at, mt) {
40685
+ var fd = fs16.openSync(path13, constants2.O_SYMLINK);
40686
40686
  var ret2;
40687
40687
  var threw = true;
40688
40688
  try {
40689
- ret2 = fs15.futimesSync(fd, at, mt);
40689
+ ret2 = fs16.futimesSync(fd, at, mt);
40690
40690
  threw = false;
40691
40691
  } finally {
40692
40692
  if (threw) {
40693
40693
  try {
40694
- fs15.closeSync(fd);
40694
+ fs16.closeSync(fd);
40695
40695
  } catch (er) {
40696
40696
  }
40697
40697
  } else {
40698
- fs15.closeSync(fd);
40698
+ fs16.closeSync(fd);
40699
40699
  }
40700
40700
  }
40701
40701
  return ret2;
40702
40702
  };
40703
- } else if (fs15.futimes) {
40704
- fs15.lutimes = function(_a, _b, _c, cb) {
40703
+ } else if (fs16.futimes) {
40704
+ fs16.lutimes = function(_a, _b, _c, cb) {
40705
40705
  if (cb) process.nextTick(cb);
40706
40706
  };
40707
- fs15.lutimesSync = function() {
40707
+ fs16.lutimesSync = function() {
40708
40708
  };
40709
40709
  }
40710
40710
  }
40711
40711
  function chmodFix(orig) {
40712
40712
  if (!orig) return orig;
40713
40713
  return function(target, mode, cb) {
40714
- return orig.call(fs14, target, mode, function(er) {
40714
+ return orig.call(fs15, target, mode, function(er) {
40715
40715
  if (chownErOk(er)) er = null;
40716
40716
  if (cb) cb.apply(this, arguments);
40717
40717
  });
@@ -40721,7 +40721,7 @@ var require_polyfills = __commonJS({
40721
40721
  if (!orig) return orig;
40722
40722
  return function(target, mode) {
40723
40723
  try {
40724
- return orig.call(fs14, target, mode);
40724
+ return orig.call(fs15, target, mode);
40725
40725
  } catch (er) {
40726
40726
  if (!chownErOk(er)) throw er;
40727
40727
  }
@@ -40730,7 +40730,7 @@ var require_polyfills = __commonJS({
40730
40730
  function chownFix(orig) {
40731
40731
  if (!orig) return orig;
40732
40732
  return function(target, uid2, gid, cb) {
40733
- return orig.call(fs14, target, uid2, gid, function(er) {
40733
+ return orig.call(fs15, target, uid2, gid, function(er) {
40734
40734
  if (chownErOk(er)) er = null;
40735
40735
  if (cb) cb.apply(this, arguments);
40736
40736
  });
@@ -40740,7 +40740,7 @@ var require_polyfills = __commonJS({
40740
40740
  if (!orig) return orig;
40741
40741
  return function(target, uid2, gid) {
40742
40742
  try {
40743
- return orig.call(fs14, target, uid2, gid);
40743
+ return orig.call(fs15, target, uid2, gid);
40744
40744
  } catch (er) {
40745
40745
  if (!chownErOk(er)) throw er;
40746
40746
  }
@@ -40760,13 +40760,13 @@ var require_polyfills = __commonJS({
40760
40760
  }
40761
40761
  if (cb) cb.apply(this, arguments);
40762
40762
  }
40763
- return options ? orig.call(fs14, target, options, callback) : orig.call(fs14, target, callback);
40763
+ return options ? orig.call(fs15, target, options, callback) : orig.call(fs15, target, callback);
40764
40764
  };
40765
40765
  }
40766
40766
  function statFixSync(orig) {
40767
40767
  if (!orig) return orig;
40768
40768
  return function(target, options) {
40769
- var stats = options ? orig.call(fs14, target, options) : orig.call(fs14, target);
40769
+ var stats = options ? orig.call(fs15, target, options) : orig.call(fs15, target);
40770
40770
  if (stats) {
40771
40771
  if (stats.uid < 0) stats.uid += 4294967296;
40772
40772
  if (stats.gid < 0) stats.gid += 4294967296;
@@ -40796,16 +40796,16 @@ var require_legacy_streams = __commonJS({
40796
40796
  "use strict";
40797
40797
  var Stream = require("stream").Stream;
40798
40798
  module2.exports = legacy;
40799
- function legacy(fs14) {
40799
+ function legacy(fs15) {
40800
40800
  return {
40801
40801
  ReadStream,
40802
40802
  WriteStream
40803
40803
  };
40804
- function ReadStream(path12, options) {
40805
- if (!(this instanceof ReadStream)) return new ReadStream(path12, options);
40804
+ function ReadStream(path13, options) {
40805
+ if (!(this instanceof ReadStream)) return new ReadStream(path13, options);
40806
40806
  Stream.call(this);
40807
40807
  var self2 = this;
40808
- this.path = path12;
40808
+ this.path = path13;
40809
40809
  this.fd = null;
40810
40810
  this.readable = true;
40811
40811
  this.paused = false;
@@ -40839,7 +40839,7 @@ var require_legacy_streams = __commonJS({
40839
40839
  });
40840
40840
  return;
40841
40841
  }
40842
- fs14.open(this.path, this.flags, this.mode, function(err, fd) {
40842
+ fs15.open(this.path, this.flags, this.mode, function(err, fd) {
40843
40843
  if (err) {
40844
40844
  self2.emit("error", err);
40845
40845
  self2.readable = false;
@@ -40850,10 +40850,10 @@ var require_legacy_streams = __commonJS({
40850
40850
  self2._read();
40851
40851
  });
40852
40852
  }
40853
- function WriteStream(path12, options) {
40854
- if (!(this instanceof WriteStream)) return new WriteStream(path12, options);
40853
+ function WriteStream(path13, options) {
40854
+ if (!(this instanceof WriteStream)) return new WriteStream(path13, options);
40855
40855
  Stream.call(this);
40856
- this.path = path12;
40856
+ this.path = path13;
40857
40857
  this.fd = null;
40858
40858
  this.writable = true;
40859
40859
  this.flags = "w";
@@ -40878,7 +40878,7 @@ var require_legacy_streams = __commonJS({
40878
40878
  this.busy = false;
40879
40879
  this._queue = [];
40880
40880
  if (this.fd === null) {
40881
- this._open = fs14.open;
40881
+ this._open = fs15.open;
40882
40882
  this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
40883
40883
  this.flush();
40884
40884
  }
@@ -40914,7 +40914,7 @@ var require_clone = __commonJS({
40914
40914
  var require_graceful_fs = __commonJS({
40915
40915
  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
40916
40916
  "use strict";
40917
- var fs14 = require("fs");
40917
+ var fs15 = require("fs");
40918
40918
  var polyfills = require_polyfills();
40919
40919
  var legacy = require_legacy_streams();
40920
40920
  var clone = require_clone();
@@ -40946,12 +40946,12 @@ var require_graceful_fs = __commonJS({
40946
40946
  m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
40947
40947
  console.error(m);
40948
40948
  };
40949
- if (!fs14[gracefulQueue]) {
40949
+ if (!fs15[gracefulQueue]) {
40950
40950
  queue = global[gracefulQueue] || [];
40951
- publishQueue(fs14, queue);
40952
- fs14.close = function(fs$close) {
40951
+ publishQueue(fs15, queue);
40952
+ fs15.close = function(fs$close) {
40953
40953
  function close(fd, cb) {
40954
- return fs$close.call(fs14, fd, function(err) {
40954
+ return fs$close.call(fs15, fd, function(err) {
40955
40955
  if (!err) {
40956
40956
  resetQueue();
40957
40957
  }
@@ -40963,48 +40963,48 @@ var require_graceful_fs = __commonJS({
40963
40963
  value: fs$close
40964
40964
  });
40965
40965
  return close;
40966
- }(fs14.close);
40967
- fs14.closeSync = function(fs$closeSync) {
40966
+ }(fs15.close);
40967
+ fs15.closeSync = function(fs$closeSync) {
40968
40968
  function closeSync(fd) {
40969
- fs$closeSync.apply(fs14, arguments);
40969
+ fs$closeSync.apply(fs15, arguments);
40970
40970
  resetQueue();
40971
40971
  }
40972
40972
  Object.defineProperty(closeSync, previousSymbol, {
40973
40973
  value: fs$closeSync
40974
40974
  });
40975
40975
  return closeSync;
40976
- }(fs14.closeSync);
40976
+ }(fs15.closeSync);
40977
40977
  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
40978
40978
  process.on("exit", function() {
40979
- debug(fs14[gracefulQueue]);
40980
- require("assert").equal(fs14[gracefulQueue].length, 0);
40979
+ debug(fs15[gracefulQueue]);
40980
+ require("assert").equal(fs15[gracefulQueue].length, 0);
40981
40981
  });
40982
40982
  }
40983
40983
  }
40984
40984
  var queue;
40985
40985
  if (!global[gracefulQueue]) {
40986
- publishQueue(global, fs14[gracefulQueue]);
40987
- }
40988
- module2.exports = patch(clone(fs14));
40989
- if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs14.__patched) {
40990
- module2.exports = patch(fs14);
40991
- fs14.__patched = true;
40992
- }
40993
- function patch(fs15) {
40994
- polyfills(fs15);
40995
- fs15.gracefulify = patch;
40996
- fs15.createReadStream = createReadStream;
40997
- fs15.createWriteStream = createWriteStream;
40998
- var fs$readFile = fs15.readFile;
40999
- fs15.readFile = readFile;
41000
- function readFile(path12, options, cb) {
40986
+ publishQueue(global, fs15[gracefulQueue]);
40987
+ }
40988
+ module2.exports = patch(clone(fs15));
40989
+ if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs15.__patched) {
40990
+ module2.exports = patch(fs15);
40991
+ fs15.__patched = true;
40992
+ }
40993
+ function patch(fs16) {
40994
+ polyfills(fs16);
40995
+ fs16.gracefulify = patch;
40996
+ fs16.createReadStream = createReadStream;
40997
+ fs16.createWriteStream = createWriteStream;
40998
+ var fs$readFile = fs16.readFile;
40999
+ fs16.readFile = readFile;
41000
+ function readFile(path13, options, cb) {
41001
41001
  if (typeof options === "function")
41002
41002
  cb = options, options = null;
41003
- return go$readFile(path12, options, cb);
41004
- function go$readFile(path13, options2, cb2, startTime) {
41005
- return fs$readFile(path13, options2, function(err) {
41003
+ return go$readFile(path13, options, cb);
41004
+ function go$readFile(path14, options2, cb2, startTime) {
41005
+ return fs$readFile(path14, options2, function(err) {
41006
41006
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
41007
- enqueue([go$readFile, [path13, options2, cb2], err, startTime || Date.now(), Date.now()]);
41007
+ enqueue([go$readFile, [path14, options2, cb2], err, startTime || Date.now(), Date.now()]);
41008
41008
  else {
41009
41009
  if (typeof cb2 === "function")
41010
41010
  cb2.apply(this, arguments);
@@ -41012,16 +41012,16 @@ var require_graceful_fs = __commonJS({
41012
41012
  });
41013
41013
  }
41014
41014
  }
41015
- var fs$writeFile = fs15.writeFile;
41016
- fs15.writeFile = writeFile;
41017
- function writeFile(path12, data, options, cb) {
41015
+ var fs$writeFile = fs16.writeFile;
41016
+ fs16.writeFile = writeFile;
41017
+ function writeFile(path13, data, options, cb) {
41018
41018
  if (typeof options === "function")
41019
41019
  cb = options, options = null;
41020
- return go$writeFile(path12, data, options, cb);
41021
- function go$writeFile(path13, data2, options2, cb2, startTime) {
41022
- return fs$writeFile(path13, data2, options2, function(err) {
41020
+ return go$writeFile(path13, data, options, cb);
41021
+ function go$writeFile(path14, data2, options2, cb2, startTime) {
41022
+ return fs$writeFile(path14, data2, options2, function(err) {
41023
41023
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
41024
- enqueue([go$writeFile, [path13, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
41024
+ enqueue([go$writeFile, [path14, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
41025
41025
  else {
41026
41026
  if (typeof cb2 === "function")
41027
41027
  cb2.apply(this, arguments);
@@ -41029,17 +41029,17 @@ var require_graceful_fs = __commonJS({
41029
41029
  });
41030
41030
  }
41031
41031
  }
41032
- var fs$appendFile = fs15.appendFile;
41032
+ var fs$appendFile = fs16.appendFile;
41033
41033
  if (fs$appendFile)
41034
- fs15.appendFile = appendFile;
41035
- function appendFile(path12, data, options, cb) {
41034
+ fs16.appendFile = appendFile;
41035
+ function appendFile(path13, data, options, cb) {
41036
41036
  if (typeof options === "function")
41037
41037
  cb = options, options = null;
41038
- return go$appendFile(path12, data, options, cb);
41039
- function go$appendFile(path13, data2, options2, cb2, startTime) {
41040
- return fs$appendFile(path13, data2, options2, function(err) {
41038
+ return go$appendFile(path13, data, options, cb);
41039
+ function go$appendFile(path14, data2, options2, cb2, startTime) {
41040
+ return fs$appendFile(path14, data2, options2, function(err) {
41041
41041
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
41042
- enqueue([go$appendFile, [path13, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
41042
+ enqueue([go$appendFile, [path14, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
41043
41043
  else {
41044
41044
  if (typeof cb2 === "function")
41045
41045
  cb2.apply(this, arguments);
@@ -41047,9 +41047,9 @@ var require_graceful_fs = __commonJS({
41047
41047
  });
41048
41048
  }
41049
41049
  }
41050
- var fs$copyFile = fs15.copyFile;
41050
+ var fs$copyFile = fs16.copyFile;
41051
41051
  if (fs$copyFile)
41052
- fs15.copyFile = copyFile;
41052
+ fs16.copyFile = copyFile;
41053
41053
  function copyFile(src, dest, flags, cb) {
41054
41054
  if (typeof flags === "function") {
41055
41055
  cb = flags;
@@ -41067,34 +41067,34 @@ var require_graceful_fs = __commonJS({
41067
41067
  });
41068
41068
  }
41069
41069
  }
41070
- var fs$readdir = fs15.readdir;
41071
- fs15.readdir = readdir;
41070
+ var fs$readdir = fs16.readdir;
41071
+ fs16.readdir = readdir;
41072
41072
  var noReaddirOptionVersions = /^v[0-5]\./;
41073
- function readdir(path12, options, cb) {
41073
+ function readdir(path13, options, cb) {
41074
41074
  if (typeof options === "function")
41075
41075
  cb = options, options = null;
41076
- var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path13, options2, cb2, startTime) {
41077
- return fs$readdir(path13, fs$readdirCallback(
41078
- path13,
41076
+ var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path14, options2, cb2, startTime) {
41077
+ return fs$readdir(path14, fs$readdirCallback(
41078
+ path14,
41079
41079
  options2,
41080
41080
  cb2,
41081
41081
  startTime
41082
41082
  ));
41083
- } : function go$readdir2(path13, options2, cb2, startTime) {
41084
- return fs$readdir(path13, options2, fs$readdirCallback(
41085
- path13,
41083
+ } : function go$readdir2(path14, options2, cb2, startTime) {
41084
+ return fs$readdir(path14, options2, fs$readdirCallback(
41085
+ path14,
41086
41086
  options2,
41087
41087
  cb2,
41088
41088
  startTime
41089
41089
  ));
41090
41090
  };
41091
- return go$readdir(path12, options, cb);
41092
- function fs$readdirCallback(path13, options2, cb2, startTime) {
41091
+ return go$readdir(path13, options, cb);
41092
+ function fs$readdirCallback(path14, options2, cb2, startTime) {
41093
41093
  return function(err, files) {
41094
41094
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
41095
41095
  enqueue([
41096
41096
  go$readdir,
41097
- [path13, options2, cb2],
41097
+ [path14, options2, cb2],
41098
41098
  err,
41099
41099
  startTime || Date.now(),
41100
41100
  Date.now()
@@ -41109,21 +41109,21 @@ var require_graceful_fs = __commonJS({
41109
41109
  }
41110
41110
  }
41111
41111
  if (process.version.substr(0, 4) === "v0.8") {
41112
- var legStreams = legacy(fs15);
41112
+ var legStreams = legacy(fs16);
41113
41113
  ReadStream = legStreams.ReadStream;
41114
41114
  WriteStream = legStreams.WriteStream;
41115
41115
  }
41116
- var fs$ReadStream = fs15.ReadStream;
41116
+ var fs$ReadStream = fs16.ReadStream;
41117
41117
  if (fs$ReadStream) {
41118
41118
  ReadStream.prototype = Object.create(fs$ReadStream.prototype);
41119
41119
  ReadStream.prototype.open = ReadStream$open;
41120
41120
  }
41121
- var fs$WriteStream = fs15.WriteStream;
41121
+ var fs$WriteStream = fs16.WriteStream;
41122
41122
  if (fs$WriteStream) {
41123
41123
  WriteStream.prototype = Object.create(fs$WriteStream.prototype);
41124
41124
  WriteStream.prototype.open = WriteStream$open;
41125
41125
  }
41126
- Object.defineProperty(fs15, "ReadStream", {
41126
+ Object.defineProperty(fs16, "ReadStream", {
41127
41127
  get: function() {
41128
41128
  return ReadStream;
41129
41129
  },
@@ -41133,7 +41133,7 @@ var require_graceful_fs = __commonJS({
41133
41133
  enumerable: true,
41134
41134
  configurable: true
41135
41135
  });
41136
- Object.defineProperty(fs15, "WriteStream", {
41136
+ Object.defineProperty(fs16, "WriteStream", {
41137
41137
  get: function() {
41138
41138
  return WriteStream;
41139
41139
  },
@@ -41144,7 +41144,7 @@ var require_graceful_fs = __commonJS({
41144
41144
  configurable: true
41145
41145
  });
41146
41146
  var FileReadStream = ReadStream;
41147
- Object.defineProperty(fs15, "FileReadStream", {
41147
+ Object.defineProperty(fs16, "FileReadStream", {
41148
41148
  get: function() {
41149
41149
  return FileReadStream;
41150
41150
  },
@@ -41155,7 +41155,7 @@ var require_graceful_fs = __commonJS({
41155
41155
  configurable: true
41156
41156
  });
41157
41157
  var FileWriteStream = WriteStream;
41158
- Object.defineProperty(fs15, "FileWriteStream", {
41158
+ Object.defineProperty(fs16, "FileWriteStream", {
41159
41159
  get: function() {
41160
41160
  return FileWriteStream;
41161
41161
  },
@@ -41165,7 +41165,7 @@ var require_graceful_fs = __commonJS({
41165
41165
  enumerable: true,
41166
41166
  configurable: true
41167
41167
  });
41168
- function ReadStream(path12, options) {
41168
+ function ReadStream(path13, options) {
41169
41169
  if (this instanceof ReadStream)
41170
41170
  return fs$ReadStream.apply(this, arguments), this;
41171
41171
  else
@@ -41185,7 +41185,7 @@ var require_graceful_fs = __commonJS({
41185
41185
  }
41186
41186
  });
41187
41187
  }
41188
- function WriteStream(path12, options) {
41188
+ function WriteStream(path13, options) {
41189
41189
  if (this instanceof WriteStream)
41190
41190
  return fs$WriteStream.apply(this, arguments), this;
41191
41191
  else
@@ -41203,22 +41203,22 @@ var require_graceful_fs = __commonJS({
41203
41203
  }
41204
41204
  });
41205
41205
  }
41206
- function createReadStream(path12, options) {
41207
- return new fs15.ReadStream(path12, options);
41206
+ function createReadStream(path13, options) {
41207
+ return new fs16.ReadStream(path13, options);
41208
41208
  }
41209
- function createWriteStream(path12, options) {
41210
- return new fs15.WriteStream(path12, options);
41209
+ function createWriteStream(path13, options) {
41210
+ return new fs16.WriteStream(path13, options);
41211
41211
  }
41212
- var fs$open = fs15.open;
41213
- fs15.open = open;
41214
- function open(path12, flags, mode, cb) {
41212
+ var fs$open = fs16.open;
41213
+ fs16.open = open;
41214
+ function open(path13, flags, mode, cb) {
41215
41215
  if (typeof mode === "function")
41216
41216
  cb = mode, mode = null;
41217
- return go$open(path12, flags, mode, cb);
41218
- function go$open(path13, flags2, mode2, cb2, startTime) {
41219
- return fs$open(path13, flags2, mode2, function(err, fd) {
41217
+ return go$open(path13, flags, mode, cb);
41218
+ function go$open(path14, flags2, mode2, cb2, startTime) {
41219
+ return fs$open(path14, flags2, mode2, function(err, fd) {
41220
41220
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
41221
- enqueue([go$open, [path13, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
41221
+ enqueue([go$open, [path14, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
41222
41222
  else {
41223
41223
  if (typeof cb2 === "function")
41224
41224
  cb2.apply(this, arguments);
@@ -41226,20 +41226,20 @@ var require_graceful_fs = __commonJS({
41226
41226
  });
41227
41227
  }
41228
41228
  }
41229
- return fs15;
41229
+ return fs16;
41230
41230
  }
41231
41231
  function enqueue(elem) {
41232
41232
  debug("ENQUEUE", elem[0].name, elem[1]);
41233
- fs14[gracefulQueue].push(elem);
41233
+ fs15[gracefulQueue].push(elem);
41234
41234
  retry();
41235
41235
  }
41236
41236
  var retryTimer;
41237
41237
  function resetQueue() {
41238
41238
  var now = Date.now();
41239
- for (var i = 0; i < fs14[gracefulQueue].length; ++i) {
41240
- if (fs14[gracefulQueue][i].length > 2) {
41241
- fs14[gracefulQueue][i][3] = now;
41242
- fs14[gracefulQueue][i][4] = now;
41239
+ for (var i = 0; i < fs15[gracefulQueue].length; ++i) {
41240
+ if (fs15[gracefulQueue][i].length > 2) {
41241
+ fs15[gracefulQueue][i][3] = now;
41242
+ fs15[gracefulQueue][i][4] = now;
41243
41243
  }
41244
41244
  }
41245
41245
  retry();
@@ -41247,9 +41247,9 @@ var require_graceful_fs = __commonJS({
41247
41247
  function retry() {
41248
41248
  clearTimeout(retryTimer);
41249
41249
  retryTimer = void 0;
41250
- if (fs14[gracefulQueue].length === 0)
41250
+ if (fs15[gracefulQueue].length === 0)
41251
41251
  return;
41252
- var elem = fs14[gracefulQueue].shift();
41252
+ var elem = fs15[gracefulQueue].shift();
41253
41253
  var fn = elem[0];
41254
41254
  var args = elem[1];
41255
41255
  var err = elem[2];
@@ -41271,7 +41271,7 @@ var require_graceful_fs = __commonJS({
41271
41271
  debug("RETRY", fn.name, args);
41272
41272
  fn.apply(null, args.concat([startTime]));
41273
41273
  } else {
41274
- fs14[gracefulQueue].push(elem);
41274
+ fs15[gracefulQueue].push(elem);
41275
41275
  }
41276
41276
  }
41277
41277
  if (retryTimer === void 0) {
@@ -41339,22 +41339,22 @@ var require_lazystream = __commonJS({
41339
41339
  var require_normalize_path = __commonJS({
41340
41340
  "../../node_modules/.pnpm/normalize-path@3.0.0/node_modules/normalize-path/index.js"(exports2, module2) {
41341
41341
  "use strict";
41342
- module2.exports = function(path12, stripTrailing) {
41343
- if (typeof path12 !== "string") {
41342
+ module2.exports = function(path13, stripTrailing) {
41343
+ if (typeof path13 !== "string") {
41344
41344
  throw new TypeError("expected path to be a string");
41345
41345
  }
41346
- if (path12 === "\\" || path12 === "/") return "/";
41347
- var len = path12.length;
41348
- if (len <= 1) return path12;
41346
+ if (path13 === "\\" || path13 === "/") return "/";
41347
+ var len = path13.length;
41348
+ if (len <= 1) return path13;
41349
41349
  var prefix = "";
41350
- if (len > 4 && path12[3] === "\\") {
41351
- var ch = path12[2];
41352
- if ((ch === "?" || ch === ".") && path12.slice(0, 2) === "\\\\") {
41353
- path12 = path12.slice(2);
41350
+ if (len > 4 && path13[3] === "\\") {
41351
+ var ch = path13[2];
41352
+ if ((ch === "?" || ch === ".") && path13.slice(0, 2) === "\\\\") {
41353
+ path13 = path13.slice(2);
41354
41354
  prefix = "//";
41355
41355
  }
41356
41356
  }
41357
- var segs = path12.split(/[/\\]+/);
41357
+ var segs = path13.split(/[/\\]+/);
41358
41358
  if (stripTrailing !== false && segs[segs.length - 1] === "") {
41359
41359
  segs.pop();
41360
41360
  }
@@ -42479,7 +42479,7 @@ var require_old = __commonJS({
42479
42479
  "use strict";
42480
42480
  var pathModule = require("path");
42481
42481
  var isWindows = process.platform === "win32";
42482
- var fs14 = require("fs");
42482
+ var fs15 = require("fs");
42483
42483
  var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
42484
42484
  function rethrow() {
42485
42485
  var callback;
@@ -42544,7 +42544,7 @@ var require_old = __commonJS({
42544
42544
  base = m[0];
42545
42545
  previous = "";
42546
42546
  if (isWindows && !knownHard[base]) {
42547
- fs14.lstatSync(base);
42547
+ fs15.lstatSync(base);
42548
42548
  knownHard[base] = true;
42549
42549
  }
42550
42550
  }
@@ -42562,7 +42562,7 @@ var require_old = __commonJS({
42562
42562
  if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
42563
42563
  resolvedLink = cache[base];
42564
42564
  } else {
42565
- var stat2 = fs14.lstatSync(base);
42565
+ var stat2 = fs15.lstatSync(base);
42566
42566
  if (!stat2.isSymbolicLink()) {
42567
42567
  knownHard[base] = true;
42568
42568
  if (cache) cache[base] = base;
@@ -42576,8 +42576,8 @@ var require_old = __commonJS({
42576
42576
  }
42577
42577
  }
42578
42578
  if (linkTarget === null) {
42579
- fs14.statSync(base);
42580
- linkTarget = fs14.readlinkSync(base);
42579
+ fs15.statSync(base);
42580
+ linkTarget = fs15.readlinkSync(base);
42581
42581
  }
42582
42582
  resolvedLink = pathModule.resolve(previous, linkTarget);
42583
42583
  if (cache) cache[base] = resolvedLink;
@@ -42611,7 +42611,7 @@ var require_old = __commonJS({
42611
42611
  base = m[0];
42612
42612
  previous = "";
42613
42613
  if (isWindows && !knownHard[base]) {
42614
- fs14.lstat(base, function(err) {
42614
+ fs15.lstat(base, function(err) {
42615
42615
  if (err) return cb(err);
42616
42616
  knownHard[base] = true;
42617
42617
  LOOP();
@@ -42637,7 +42637,7 @@ var require_old = __commonJS({
42637
42637
  if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
42638
42638
  return gotResolvedLink(cache[base]);
42639
42639
  }
42640
- return fs14.lstat(base, gotStat);
42640
+ return fs15.lstat(base, gotStat);
42641
42641
  }
42642
42642
  function gotStat(err, stat2) {
42643
42643
  if (err) return cb(err);
@@ -42652,9 +42652,9 @@ var require_old = __commonJS({
42652
42652
  return gotTarget(null, seenLinks[id], base);
42653
42653
  }
42654
42654
  }
42655
- fs14.stat(base, function(err2) {
42655
+ fs15.stat(base, function(err2) {
42656
42656
  if (err2) return cb(err2);
42657
- fs14.readlink(base, function(err3, target) {
42657
+ fs15.readlink(base, function(err3, target) {
42658
42658
  if (!isWindows) seenLinks[id] = target;
42659
42659
  gotTarget(err3, target);
42660
42660
  });
@@ -42684,9 +42684,9 @@ var require_fs = __commonJS({
42684
42684
  realpath.realpathSync = realpathSync;
42685
42685
  realpath.monkeypatch = monkeypatch;
42686
42686
  realpath.unmonkeypatch = unmonkeypatch;
42687
- var fs14 = require("fs");
42688
- var origRealpath = fs14.realpath;
42689
- var origRealpathSync = fs14.realpathSync;
42687
+ var fs15 = require("fs");
42688
+ var origRealpath = fs15.realpath;
42689
+ var origRealpathSync = fs15.realpathSync;
42690
42690
  var version2 = process.version;
42691
42691
  var ok = /^v[0-5]\./.test(version2);
42692
42692
  var old = require_old();
@@ -42724,12 +42724,12 @@ var require_fs = __commonJS({
42724
42724
  }
42725
42725
  }
42726
42726
  function monkeypatch() {
42727
- fs14.realpath = realpath;
42728
- fs14.realpathSync = realpathSync;
42727
+ fs15.realpath = realpath;
42728
+ fs15.realpathSync = realpathSync;
42729
42729
  }
42730
42730
  function unmonkeypatch() {
42731
- fs14.realpath = origRealpath;
42732
- fs14.realpathSync = origRealpathSync;
42731
+ fs15.realpath = origRealpath;
42732
+ fs15.realpathSync = origRealpathSync;
42733
42733
  }
42734
42734
  }
42735
42735
  });
@@ -42906,7 +42906,7 @@ var require_minimatch2 = __commonJS({
42906
42906
  "use strict";
42907
42907
  module2.exports = minimatch;
42908
42908
  minimatch.Minimatch = Minimatch;
42909
- var path12 = function() {
42909
+ var path13 = function() {
42910
42910
  try {
42911
42911
  return require("path");
42912
42912
  } catch (e) {
@@ -42914,7 +42914,7 @@ var require_minimatch2 = __commonJS({
42914
42914
  }() || {
42915
42915
  sep: "/"
42916
42916
  };
42917
- minimatch.sep = path12.sep;
42917
+ minimatch.sep = path13.sep;
42918
42918
  var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
42919
42919
  var expand = require_brace_expansion2();
42920
42920
  var plTypes = {
@@ -43003,8 +43003,8 @@ var require_minimatch2 = __commonJS({
43003
43003
  assertValidPattern(pattern);
43004
43004
  if (!options) options = {};
43005
43005
  pattern = pattern.trim();
43006
- if (!options.allowWindowsEscape && path12.sep !== "/") {
43007
- pattern = pattern.split(path12.sep).join("/");
43006
+ if (!options.allowWindowsEscape && path13.sep !== "/") {
43007
+ pattern = pattern.split(path13.sep).join("/");
43008
43008
  }
43009
43009
  this.options = options;
43010
43010
  this.maxGlobstarRecursion = options.maxGlobstarRecursion !== void 0 ? options.maxGlobstarRecursion : 200;
@@ -43375,8 +43375,8 @@ var require_minimatch2 = __commonJS({
43375
43375
  if (this.empty) return f === "";
43376
43376
  if (f === "/" && partial) return true;
43377
43377
  var options = this.options;
43378
- if (path12.sep !== "/") {
43379
- f = f.split(path12.sep).join("/");
43378
+ if (path13.sep !== "/") {
43379
+ f = f.split(path13.sep).join("/");
43380
43380
  }
43381
43381
  f = f.split(slashSplit);
43382
43382
  this.debug(this.pattern, "split", f);
@@ -43577,12 +43577,12 @@ var require_minimatch2 = __commonJS({
43577
43577
  var require_path_is_absolute = __commonJS({
43578
43578
  "../../node_modules/.pnpm/path-is-absolute@1.0.1/node_modules/path-is-absolute/index.js"(exports2, module2) {
43579
43579
  "use strict";
43580
- function posix(path12) {
43581
- return path12.charAt(0) === "/";
43580
+ function posix(path13) {
43581
+ return path13.charAt(0) === "/";
43582
43582
  }
43583
- function win32(path12) {
43583
+ function win32(path13) {
43584
43584
  var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
43585
- var result = splitDeviceRe.exec(path12);
43585
+ var result = splitDeviceRe.exec(path13);
43586
43586
  var device = result[1] || "";
43587
43587
  var isUnc = Boolean(device && device.charAt(1) !== ":");
43588
43588
  return Boolean(result[2] || isUnc);
@@ -43607,8 +43607,8 @@ var require_common2 = __commonJS({
43607
43607
  function ownProp(obj2, field) {
43608
43608
  return Object.prototype.hasOwnProperty.call(obj2, field);
43609
43609
  }
43610
- var fs14 = require("fs");
43611
- var path12 = require("path");
43610
+ var fs15 = require("fs");
43611
+ var path13 = require("path");
43612
43612
  var minimatch = require_minimatch2();
43613
43613
  var isAbsolute = require_path_is_absolute();
43614
43614
  var Minimatch = minimatch.Minimatch;
@@ -43662,7 +43662,7 @@ var require_common2 = __commonJS({
43662
43662
  self2.stat = !!options.stat;
43663
43663
  self2.noprocess = !!options.noprocess;
43664
43664
  self2.absolute = !!options.absolute;
43665
- self2.fs = options.fs || fs14;
43665
+ self2.fs = options.fs || fs15;
43666
43666
  self2.maxLength = options.maxLength || Infinity;
43667
43667
  self2.cache = options.cache || /* @__PURE__ */ Object.create(null);
43668
43668
  self2.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
@@ -43673,11 +43673,11 @@ var require_common2 = __commonJS({
43673
43673
  if (!ownProp(options, "cwd"))
43674
43674
  self2.cwd = cwd;
43675
43675
  else {
43676
- self2.cwd = path12.resolve(options.cwd);
43676
+ self2.cwd = path13.resolve(options.cwd);
43677
43677
  self2.changedCwd = self2.cwd !== cwd;
43678
43678
  }
43679
- self2.root = options.root || path12.resolve(self2.cwd, "/");
43680
- self2.root = path12.resolve(self2.root);
43679
+ self2.root = options.root || path13.resolve(self2.cwd, "/");
43680
+ self2.root = path13.resolve(self2.root);
43681
43681
  if (process.platform === "win32")
43682
43682
  self2.root = self2.root.replace(/\\/g, "/");
43683
43683
  self2.cwdAbs = isAbsolute(self2.cwd) ? self2.cwd : makeAbs(self2, self2.cwd);
@@ -43759,30 +43759,30 @@ var require_common2 = __commonJS({
43759
43759
  function makeAbs(self2, f) {
43760
43760
  var abs = f;
43761
43761
  if (f.charAt(0) === "/") {
43762
- abs = path12.join(self2.root, f);
43762
+ abs = path13.join(self2.root, f);
43763
43763
  } else if (isAbsolute(f) || f === "") {
43764
43764
  abs = f;
43765
43765
  } else if (self2.changedCwd) {
43766
- abs = path12.resolve(self2.cwd, f);
43766
+ abs = path13.resolve(self2.cwd, f);
43767
43767
  } else {
43768
- abs = path12.resolve(f);
43768
+ abs = path13.resolve(f);
43769
43769
  }
43770
43770
  if (process.platform === "win32")
43771
43771
  abs = abs.replace(/\\/g, "/");
43772
43772
  return abs;
43773
43773
  }
43774
- function isIgnored(self2, path13) {
43774
+ function isIgnored(self2, path14) {
43775
43775
  if (!self2.ignore.length)
43776
43776
  return false;
43777
43777
  return self2.ignore.some(function(item) {
43778
- return item.matcher.match(path13) || !!(item.gmatcher && item.gmatcher.match(path13));
43778
+ return item.matcher.match(path14) || !!(item.gmatcher && item.gmatcher.match(path14));
43779
43779
  });
43780
43780
  }
43781
- function childrenIgnored(self2, path13) {
43781
+ function childrenIgnored(self2, path14) {
43782
43782
  if (!self2.ignore.length)
43783
43783
  return false;
43784
43784
  return self2.ignore.some(function(item) {
43785
- return !!(item.gmatcher && item.gmatcher.match(path13));
43785
+ return !!(item.gmatcher && item.gmatcher.match(path14));
43786
43786
  });
43787
43787
  }
43788
43788
  }
@@ -43799,7 +43799,7 @@ var require_sync = __commonJS({
43799
43799
  var Minimatch = minimatch.Minimatch;
43800
43800
  var Glob = require_glob().Glob;
43801
43801
  var util = require("util");
43802
- var path12 = require("path");
43802
+ var path13 = require("path");
43803
43803
  var assert = require("assert");
43804
43804
  var isAbsolute = require_path_is_absolute();
43805
43805
  var common = require_common2();
@@ -43928,7 +43928,7 @@ var require_sync = __commonJS({
43928
43928
  e = prefix + e;
43929
43929
  }
43930
43930
  if (e.charAt(0) === "/" && !this.nomount) {
43931
- e = path12.join(this.root, e);
43931
+ e = path13.join(this.root, e);
43932
43932
  }
43933
43933
  this._emitMatch(index, e);
43934
43934
  }
@@ -44079,9 +44079,9 @@ var require_sync = __commonJS({
44079
44079
  if (prefix && isAbsolute(prefix) && !this.nomount) {
44080
44080
  var trail = /[\/\\]$/.test(prefix);
44081
44081
  if (prefix.charAt(0) === "/") {
44082
- prefix = path12.join(this.root, prefix);
44082
+ prefix = path13.join(this.root, prefix);
44083
44083
  } else {
44084
- prefix = path12.resolve(this.root, prefix);
44084
+ prefix = path13.resolve(this.root, prefix);
44085
44085
  if (trail)
44086
44086
  prefix += "/";
44087
44087
  }
@@ -44277,7 +44277,7 @@ var require_glob = __commonJS({
44277
44277
  var Minimatch = minimatch.Minimatch;
44278
44278
  var inherits2 = require_inherits();
44279
44279
  var EE = require("events").EventEmitter;
44280
- var path12 = require("path");
44280
+ var path13 = require("path");
44281
44281
  var assert = require("assert");
44282
44282
  var isAbsolute = require_path_is_absolute();
44283
44283
  var globSync = require_sync();
@@ -44559,7 +44559,7 @@ var require_glob = __commonJS({
44559
44559
  e = prefix + e;
44560
44560
  }
44561
44561
  if (e.charAt(0) === "/" && !this.nomount) {
44562
- e = path12.join(this.root, e);
44562
+ e = path13.join(this.root, e);
44563
44563
  }
44564
44564
  this._emitMatch(index, e);
44565
44565
  }
@@ -44748,9 +44748,9 @@ var require_glob = __commonJS({
44748
44748
  if (prefix && isAbsolute(prefix) && !this.nomount) {
44749
44749
  var trail = /[\/\\]$/.test(prefix);
44750
44750
  if (prefix.charAt(0) === "/") {
44751
- prefix = path12.join(this.root, prefix);
44751
+ prefix = path13.join(this.root, prefix);
44752
44752
  } else {
44753
- prefix = path12.resolve(this.root, prefix);
44753
+ prefix = path13.resolve(this.root, prefix);
44754
44754
  if (trail)
44755
44755
  prefix += "/";
44756
44756
  }
@@ -44828,8 +44828,8 @@ var require_glob = __commonJS({
44828
44828
  var require_file = __commonJS({
44829
44829
  "../../node_modules/.pnpm/archiver-utils@2.1.0/node_modules/archiver-utils/file.js"(exports2, module2) {
44830
44830
  "use strict";
44831
- var fs14 = require_graceful_fs();
44832
- var path12 = require("path");
44831
+ var fs15 = require_graceful_fs();
44832
+ var path13 = require("path");
44833
44833
  var flatten = require_lodash10();
44834
44834
  var difference = require_lodash11();
44835
44835
  var union = require_lodash12();
@@ -44854,8 +44854,8 @@ var require_file = __commonJS({
44854
44854
  return result;
44855
44855
  };
44856
44856
  file.exists = function() {
44857
- var filepath = path12.join.apply(path12, arguments);
44858
- return fs14.existsSync(filepath);
44857
+ var filepath = path13.join.apply(path13, arguments);
44858
+ return fs15.existsSync(filepath);
44859
44859
  };
44860
44860
  file.expand = function(...args) {
44861
44861
  var options = isPlainObject(args[0]) ? args.shift() : {};
@@ -44868,12 +44868,12 @@ var require_file = __commonJS({
44868
44868
  });
44869
44869
  if (options.filter) {
44870
44870
  matches = matches.filter(function(filepath) {
44871
- filepath = path12.join(options.cwd || "", filepath);
44871
+ filepath = path13.join(options.cwd || "", filepath);
44872
44872
  try {
44873
44873
  if (typeof options.filter === "function") {
44874
44874
  return options.filter(filepath);
44875
44875
  } else {
44876
- return fs14.statSync(filepath)[options.filter]();
44876
+ return fs15.statSync(filepath)[options.filter]();
44877
44877
  }
44878
44878
  } catch (e) {
44879
44879
  return false;
@@ -44885,7 +44885,7 @@ var require_file = __commonJS({
44885
44885
  file.expandMapping = function(patterns, destBase, options) {
44886
44886
  options = Object.assign({
44887
44887
  rename: function(destBase2, destPath) {
44888
- return path12.join(destBase2 || "", destPath);
44888
+ return path13.join(destBase2 || "", destPath);
44889
44889
  }
44890
44890
  }, options);
44891
44891
  var files = [];
@@ -44893,14 +44893,14 @@ var require_file = __commonJS({
44893
44893
  file.expand(options, patterns).forEach(function(src) {
44894
44894
  var destPath = src;
44895
44895
  if (options.flatten) {
44896
- destPath = path12.basename(destPath);
44896
+ destPath = path13.basename(destPath);
44897
44897
  }
44898
44898
  if (options.ext) {
44899
44899
  destPath = destPath.replace(/(\.[^\/]*)?$/, options.ext);
44900
44900
  }
44901
44901
  var dest = options.rename(destBase, destPath, options);
44902
44902
  if (options.cwd) {
44903
- src = path12.join(options.cwd, src);
44903
+ src = path13.join(options.cwd, src);
44904
44904
  }
44905
44905
  dest = dest.replace(pathSeparatorRe, "/");
44906
44906
  src = src.replace(pathSeparatorRe, "/");
@@ -44982,8 +44982,8 @@ var require_file = __commonJS({
44982
44982
  var require_archiver_utils = __commonJS({
44983
44983
  "../../node_modules/.pnpm/archiver-utils@2.1.0/node_modules/archiver-utils/index.js"(exports2, module2) {
44984
44984
  "use strict";
44985
- var fs14 = require_graceful_fs();
44986
- var path12 = require("path");
44985
+ var fs15 = require_graceful_fs();
44986
+ var path13 = require("path");
44987
44987
  var nutil = require("util");
44988
44988
  var lazystream = require_lazystream();
44989
44989
  var normalizePath = require_normalize_path();
@@ -45031,7 +45031,7 @@ var require_archiver_utils = __commonJS({
45031
45031
  };
45032
45032
  utils.lazyReadStream = function(filepath) {
45033
45033
  return new lazystream.Readable(function() {
45034
- return fs14.createReadStream(filepath);
45034
+ return fs15.createReadStream(filepath);
45035
45035
  });
45036
45036
  };
45037
45037
  utils.normalizeInputSource = function(source) {
@@ -45061,7 +45061,7 @@ var require_archiver_utils = __commonJS({
45061
45061
  callback = base;
45062
45062
  base = dirpath;
45063
45063
  }
45064
- fs14.readdir(dirpath, function(err, list) {
45064
+ fs15.readdir(dirpath, function(err, list) {
45065
45065
  var i = 0;
45066
45066
  var file;
45067
45067
  var filepath;
@@ -45073,11 +45073,11 @@ var require_archiver_utils = __commonJS({
45073
45073
  if (!file) {
45074
45074
  return callback(null, results);
45075
45075
  }
45076
- filepath = path12.join(dirpath, file);
45077
- fs14.stat(filepath, function(err2, stats) {
45076
+ filepath = path13.join(dirpath, file);
45077
+ fs15.stat(filepath, function(err2, stats) {
45078
45078
  results.push({
45079
45079
  path: filepath,
45080
- relative: path12.relative(base, filepath).replace(/\\/g, "/"),
45080
+ relative: path13.relative(base, filepath).replace(/\\/g, "/"),
45081
45081
  stats
45082
45082
  });
45083
45083
  if (stats && stats.isDirectory()) {
@@ -45135,10 +45135,10 @@ var require_error = __commonJS({
45135
45135
  var require_core = __commonJS({
45136
45136
  "../../node_modules/.pnpm/archiver@5.3.2/node_modules/archiver/lib/core.js"(exports2, module2) {
45137
45137
  "use strict";
45138
- var fs14 = require("fs");
45138
+ var fs15 = require("fs");
45139
45139
  var glob = require_readdir_glob();
45140
45140
  var async = require_async();
45141
- var path12 = require("path");
45141
+ var path13 = require("path");
45142
45142
  var util = require_archiver_utils();
45143
45143
  var inherits2 = require("util").inherits;
45144
45144
  var ArchiverError = require_error();
@@ -45199,7 +45199,7 @@ var require_core = __commonJS({
45199
45199
  data.sourcePath = filepath;
45200
45200
  task.data = data;
45201
45201
  this._entriesCount++;
45202
- if (data.stats && data.stats instanceof fs14.Stats) {
45202
+ if (data.stats && data.stats instanceof fs15.Stats) {
45203
45203
  task = this._updateQueueTaskWithStats(task, data.stats);
45204
45204
  if (task) {
45205
45205
  if (data.stats.size) {
@@ -45370,7 +45370,7 @@ var require_core = __commonJS({
45370
45370
  callback();
45371
45371
  return;
45372
45372
  }
45373
- fs14.lstat(task.filepath, function(err, stats) {
45373
+ fs15.lstat(task.filepath, function(err, stats) {
45374
45374
  if (this._state.aborted) {
45375
45375
  setImmediate(callback);
45376
45376
  return;
@@ -45413,10 +45413,10 @@ var require_core = __commonJS({
45413
45413
  task.data.sourceType = "buffer";
45414
45414
  task.source = Buffer.concat([]);
45415
45415
  } else if (stats.isSymbolicLink() && this._moduleSupports("symlink")) {
45416
- var linkPath = fs14.readlinkSync(task.filepath);
45417
- var dirName = path12.dirname(task.filepath);
45416
+ var linkPath = fs15.readlinkSync(task.filepath);
45417
+ var dirName = path13.dirname(task.filepath);
45418
45418
  task.data.type = "symlink";
45419
- task.data.linkname = path12.relative(dirName, path12.resolve(dirName, linkPath));
45419
+ task.data.linkname = path13.relative(dirName, path13.resolve(dirName, linkPath));
45420
45420
  task.data.sourceType = "buffer";
45421
45421
  task.source = Buffer.concat([]);
45422
45422
  } else {
@@ -47046,8 +47046,8 @@ var require_compress_commons = __commonJS({
47046
47046
  var require_file2 = __commonJS({
47047
47047
  "../../node_modules/.pnpm/archiver-utils@3.0.4/node_modules/archiver-utils/file.js"(exports2, module2) {
47048
47048
  "use strict";
47049
- var fs14 = require_graceful_fs();
47050
- var path12 = require("path");
47049
+ var fs15 = require_graceful_fs();
47050
+ var path13 = require("path");
47051
47051
  var flatten = require_lodash10();
47052
47052
  var difference = require_lodash11();
47053
47053
  var union = require_lodash12();
@@ -47072,8 +47072,8 @@ var require_file2 = __commonJS({
47072
47072
  return result;
47073
47073
  };
47074
47074
  file.exists = function() {
47075
- var filepath = path12.join.apply(path12, arguments);
47076
- return fs14.existsSync(filepath);
47075
+ var filepath = path13.join.apply(path13, arguments);
47076
+ return fs15.existsSync(filepath);
47077
47077
  };
47078
47078
  file.expand = function(...args) {
47079
47079
  var options = isPlainObject(args[0]) ? args.shift() : {};
@@ -47086,12 +47086,12 @@ var require_file2 = __commonJS({
47086
47086
  });
47087
47087
  if (options.filter) {
47088
47088
  matches = matches.filter(function(filepath) {
47089
- filepath = path12.join(options.cwd || "", filepath);
47089
+ filepath = path13.join(options.cwd || "", filepath);
47090
47090
  try {
47091
47091
  if (typeof options.filter === "function") {
47092
47092
  return options.filter(filepath);
47093
47093
  } else {
47094
- return fs14.statSync(filepath)[options.filter]();
47094
+ return fs15.statSync(filepath)[options.filter]();
47095
47095
  }
47096
47096
  } catch (e) {
47097
47097
  return false;
@@ -47103,7 +47103,7 @@ var require_file2 = __commonJS({
47103
47103
  file.expandMapping = function(patterns, destBase, options) {
47104
47104
  options = Object.assign({
47105
47105
  rename: function(destBase2, destPath) {
47106
- return path12.join(destBase2 || "", destPath);
47106
+ return path13.join(destBase2 || "", destPath);
47107
47107
  }
47108
47108
  }, options);
47109
47109
  var files = [];
@@ -47111,14 +47111,14 @@ var require_file2 = __commonJS({
47111
47111
  file.expand(options, patterns).forEach(function(src) {
47112
47112
  var destPath = src;
47113
47113
  if (options.flatten) {
47114
- destPath = path12.basename(destPath);
47114
+ destPath = path13.basename(destPath);
47115
47115
  }
47116
47116
  if (options.ext) {
47117
47117
  destPath = destPath.replace(/(\.[^\/]*)?$/, options.ext);
47118
47118
  }
47119
47119
  var dest = options.rename(destBase, destPath, options);
47120
47120
  if (options.cwd) {
47121
- src = path12.join(options.cwd, src);
47121
+ src = path13.join(options.cwd, src);
47122
47122
  }
47123
47123
  dest = dest.replace(pathSeparatorRe, "/");
47124
47124
  src = src.replace(pathSeparatorRe, "/");
@@ -47200,8 +47200,8 @@ var require_file2 = __commonJS({
47200
47200
  var require_archiver_utils2 = __commonJS({
47201
47201
  "../../node_modules/.pnpm/archiver-utils@3.0.4/node_modules/archiver-utils/index.js"(exports2, module2) {
47202
47202
  "use strict";
47203
- var fs14 = require_graceful_fs();
47204
- var path12 = require("path");
47203
+ var fs15 = require_graceful_fs();
47204
+ var path13 = require("path");
47205
47205
  var lazystream = require_lazystream();
47206
47206
  var normalizePath = require_normalize_path();
47207
47207
  var defaults = require_lodash9();
@@ -47248,7 +47248,7 @@ var require_archiver_utils2 = __commonJS({
47248
47248
  };
47249
47249
  utils.lazyReadStream = function(filepath) {
47250
47250
  return new lazystream.Readable(function() {
47251
- return fs14.createReadStream(filepath);
47251
+ return fs15.createReadStream(filepath);
47252
47252
  });
47253
47253
  };
47254
47254
  utils.normalizeInputSource = function(source) {
@@ -47276,7 +47276,7 @@ var require_archiver_utils2 = __commonJS({
47276
47276
  callback = base;
47277
47277
  base = dirpath;
47278
47278
  }
47279
- fs14.readdir(dirpath, function(err, list) {
47279
+ fs15.readdir(dirpath, function(err, list) {
47280
47280
  var i = 0;
47281
47281
  var file;
47282
47282
  var filepath;
@@ -47288,11 +47288,11 @@ var require_archiver_utils2 = __commonJS({
47288
47288
  if (!file) {
47289
47289
  return callback(null, results);
47290
47290
  }
47291
- filepath = path12.join(dirpath, file);
47292
- fs14.stat(filepath, function(err2, stats) {
47291
+ filepath = path13.join(dirpath, file);
47292
+ fs15.stat(filepath, function(err2, stats) {
47293
47293
  results.push({
47294
47294
  path: filepath,
47295
- relative: path12.relative(base, filepath).replace(/\\/g, "/"),
47295
+ relative: path13.relative(base, filepath).replace(/\\/g, "/"),
47296
47296
  stats
47297
47297
  });
47298
47298
  if (stats && stats.isDirectory()) {
@@ -49551,7 +49551,7 @@ var require_worksheet_writer = __commonJS({
49551
49551
  var require_workbook_writer = __commonJS({
49552
49552
  "../../node_modules/.pnpm/exceljs@4.4.0/node_modules/exceljs/lib/stream/xlsx/workbook-writer.js"(exports2, module2) {
49553
49553
  "use strict";
49554
- var fs14 = require("fs");
49554
+ var fs15 = require("fs");
49555
49555
  var Archiver = require_archiver();
49556
49556
  var StreamBuf = require_stream_buf();
49557
49557
  var RelType = require_rel_type();
@@ -49587,7 +49587,7 @@ var require_workbook_writer = __commonJS({
49587
49587
  if (options.stream) {
49588
49588
  this.stream = options.stream;
49589
49589
  } else if (options.filename) {
49590
- this.stream = fs14.createWriteStream(options.filename);
49590
+ this.stream = fs15.createWriteStream(options.filename);
49591
49591
  } else {
49592
49592
  this.stream = new StreamBuf();
49593
49593
  }
@@ -49597,9 +49597,9 @@ var require_workbook_writer = __commonJS({
49597
49597
  get definedNames() {
49598
49598
  return this._definedNames;
49599
49599
  }
49600
- _openStream(path12) {
49600
+ _openStream(path13) {
49601
49601
  const stream = new StreamBuf({ bufSize: 65536, batch: true });
49602
- this.zip.append(stream, { name: path12 });
49602
+ this.zip.append(stream, { name: path13 });
49603
49603
  stream.on("finish", () => {
49604
49604
  stream.emit("zipped");
49605
49605
  });
@@ -50085,7 +50085,7 @@ var require_traverse = __commonJS({
50085
50085
  }(this.value);
50086
50086
  };
50087
50087
  function walk(root, cb, immutable) {
50088
- var path12 = [];
50088
+ var path13 = [];
50089
50089
  var parents = [];
50090
50090
  var alive = true;
50091
50091
  return function walker(node_) {
@@ -50094,11 +50094,11 @@ var require_traverse = __commonJS({
50094
50094
  var state = {
50095
50095
  node,
50096
50096
  node_,
50097
- path: [].concat(path12),
50097
+ path: [].concat(path13),
50098
50098
  parent: parents.slice(-1)[0],
50099
- key: path12.slice(-1)[0],
50100
- isRoot: path12.length === 0,
50101
- level: path12.length,
50099
+ key: path13.slice(-1)[0],
50100
+ isRoot: path13.length === 0,
50101
+ level: path13.length,
50102
50102
  circular: null,
50103
50103
  update: function(x) {
50104
50104
  if (!state.isRoot) {
@@ -50153,7 +50153,7 @@ var require_traverse = __commonJS({
50153
50153
  parents.push(state);
50154
50154
  var keys = Object.keys(state.node);
50155
50155
  keys.forEach(function(key, i2) {
50156
- path12.push(key);
50156
+ path13.push(key);
50157
50157
  if (modifiers.pre) modifiers.pre.call(state, state.node[key], key);
50158
50158
  var child = walker(state.node[key]);
50159
50159
  if (immutable && Object.hasOwnProperty.call(state.node, key)) {
@@ -50162,7 +50162,7 @@ var require_traverse = __commonJS({
50162
50162
  child.isLast = i2 == keys.length - 1;
50163
50163
  child.isFirst = i2 == 0;
50164
50164
  if (modifiers.post) modifiers.post.call(state, child);
50165
- path12.pop();
50165
+ path13.pop();
50166
50166
  });
50167
50167
  parents.pop();
50168
50168
  }
@@ -56633,7 +56633,7 @@ var require_link_reader = __commonJS({
56633
56633
  "../../node_modules/.pnpm/fstream@1.0.12/node_modules/fstream/lib/link-reader.js"(exports2, module2) {
56634
56634
  "use strict";
56635
56635
  module2.exports = LinkReader;
56636
- var fs14 = require_graceful_fs();
56636
+ var fs15 = require_graceful_fs();
56637
56637
  var inherits2 = require_inherits();
56638
56638
  var Reader = require_reader();
56639
56639
  inherits2(LinkReader, Reader);
@@ -56649,7 +56649,7 @@ var require_link_reader = __commonJS({
56649
56649
  }
56650
56650
  LinkReader.prototype._stat = function(currentStat) {
56651
56651
  var self2 = this;
56652
- fs14.readlink(self2._path, function(er, linkpath) {
56652
+ fs15.readlink(self2._path, function(er, linkpath) {
56653
56653
  if (er) return self2.error(er);
56654
56654
  self2.linkpath = self2.props.linkpath = linkpath;
56655
56655
  self2.emit("linkpath", linkpath);
@@ -56673,9 +56673,9 @@ var require_dir_reader = __commonJS({
56673
56673
  "../../node_modules/.pnpm/fstream@1.0.12/node_modules/fstream/lib/dir-reader.js"(exports2, module2) {
56674
56674
  "use strict";
56675
56675
  module2.exports = DirReader;
56676
- var fs14 = require_graceful_fs();
56676
+ var fs15 = require_graceful_fs();
56677
56677
  var inherits2 = require_inherits();
56678
- var path12 = require("path");
56678
+ var path13 = require("path");
56679
56679
  var Reader = require_reader();
56680
56680
  var assert = require("assert").ok;
56681
56681
  inherits2(DirReader, Reader);
@@ -56700,7 +56700,7 @@ var require_dir_reader = __commonJS({
56700
56700
  var self2 = this;
56701
56701
  if (self2._gotEntries) return;
56702
56702
  self2._gotEntries = true;
56703
- fs14.readdir(self2._path, function(er, entries) {
56703
+ fs15.readdir(self2._path, function(er, entries) {
56704
56704
  if (er) return self2.error(er);
56705
56705
  self2.entries = entries;
56706
56706
  self2.emit("entries", entries);
@@ -56730,20 +56730,20 @@ var require_dir_reader = __commonJS({
56730
56730
  }
56731
56731
  return;
56732
56732
  }
56733
- var p = path12.resolve(self2._path, self2.entries[self2._index]);
56733
+ var p = path13.resolve(self2._path, self2.entries[self2._index]);
56734
56734
  assert(p !== self2._path);
56735
56735
  assert(self2.entries[self2._index]);
56736
56736
  self2._currentEntry = p;
56737
- fs14[self2.props.follow ? "stat" : "lstat"](p, function(er, stat2) {
56737
+ fs15[self2.props.follow ? "stat" : "lstat"](p, function(er, stat2) {
56738
56738
  if (er) return self2.error(er);
56739
56739
  var who = self2._proxy || self2;
56740
56740
  stat2.path = p;
56741
- stat2.basename = path12.basename(p);
56742
- stat2.dirname = path12.dirname(p);
56741
+ stat2.basename = path13.basename(p);
56742
+ stat2.dirname = path13.dirname(p);
56743
56743
  var childProps = self2.getChildProps.call(who, stat2);
56744
56744
  childProps.path = p;
56745
- childProps.basename = path12.basename(p);
56746
- childProps.dirname = path12.dirname(p);
56745
+ childProps.basename = path13.basename(p);
56746
+ childProps.dirname = path13.dirname(p);
56747
56747
  var entry = Reader(childProps, stat2);
56748
56748
  self2._currentEntry = entry;
56749
56749
  entry.on("pause", function(who2) {
@@ -56862,7 +56862,7 @@ var require_file_reader = __commonJS({
56862
56862
  "../../node_modules/.pnpm/fstream@1.0.12/node_modules/fstream/lib/file-reader.js"(exports2, module2) {
56863
56863
  "use strict";
56864
56864
  module2.exports = FileReader2;
56865
- var fs14 = require_graceful_fs();
56865
+ var fs15 = require_graceful_fs();
56866
56866
  var inherits2 = require_inherits();
56867
56867
  var Reader = require_reader();
56868
56868
  var EOF = { EOF: true };
@@ -56882,7 +56882,7 @@ var require_file_reader = __commonJS({
56882
56882
  }
56883
56883
  FileReader2.prototype._getStream = function() {
56884
56884
  var self2 = this;
56885
- var stream = self2._stream = fs14.createReadStream(self2._path, self2.props);
56885
+ var stream = self2._stream = fs15.createReadStream(self2._path, self2.props);
56886
56886
  if (self2.props.blksize) {
56887
56887
  stream.bufferSize = self2.props.blksize;
56888
56888
  }
@@ -57005,7 +57005,7 @@ var require_proxy_reader = __commonJS({
57005
57005
  var Reader = require_reader();
57006
57006
  var getType = require_get_type();
57007
57007
  var inherits2 = require_inherits();
57008
- var fs14 = require_graceful_fs();
57008
+ var fs15 = require_graceful_fs();
57009
57009
  inherits2(ProxyReader, Reader);
57010
57010
  function ProxyReader(props) {
57011
57011
  var self2 = this;
@@ -57021,7 +57021,7 @@ var require_proxy_reader = __commonJS({
57021
57021
  var self2 = this;
57022
57022
  var props = self2.props;
57023
57023
  var stat2 = props.follow ? "stat" : "lstat";
57024
- fs14[stat2](props.path, function(er, current) {
57024
+ fs15[stat2](props.path, function(er, current) {
57025
57025
  var type;
57026
57026
  if (er || !current) {
57027
57027
  type = "File";
@@ -57081,10 +57081,10 @@ var require_reader = __commonJS({
57081
57081
  "../../node_modules/.pnpm/fstream@1.0.12/node_modules/fstream/lib/reader.js"(exports2, module2) {
57082
57082
  "use strict";
57083
57083
  module2.exports = Reader;
57084
- var fs14 = require_graceful_fs();
57084
+ var fs15 = require_graceful_fs();
57085
57085
  var Stream = require("stream").Stream;
57086
57086
  var inherits2 = require_inherits();
57087
- var path12 = require("path");
57087
+ var path13 = require("path");
57088
57088
  var getType = require_get_type();
57089
57089
  var hardLinks = Reader.hardLinks = {};
57090
57090
  var Abstract = require_abstract();
@@ -57149,7 +57149,7 @@ var require_reader = __commonJS({
57149
57149
  self2.depth = props.depth = props.depth || 0;
57150
57150
  self2.parent = props.parent || null;
57151
57151
  self2.root = props.root || props.parent && props.parent.root || self2;
57152
- self2._path = self2.path = path12.resolve(props.path);
57152
+ self2._path = self2.path = path13.resolve(props.path);
57153
57153
  if (process.platform === "win32") {
57154
57154
  self2.path = self2._path = self2.path.replace(/\?/g, "_");
57155
57155
  if (self2._path.length >= 260) {
@@ -57157,8 +57157,8 @@ var require_reader = __commonJS({
57157
57157
  self2._path = "\\\\?\\" + self2.path.replace(/\//g, "\\");
57158
57158
  }
57159
57159
  }
57160
- self2.basename = props.basename = path12.basename(self2.path);
57161
- self2.dirname = props.dirname = path12.dirname(self2.path);
57160
+ self2.basename = props.basename = path13.basename(self2.path);
57161
+ self2.dirname = props.dirname = path13.dirname(self2.path);
57162
57162
  props.parent = props.root = null;
57163
57163
  self2.size = props.size;
57164
57164
  self2.filter = typeof props.filter === "function" ? props.filter : null;
@@ -57173,7 +57173,7 @@ var require_reader = __commonJS({
57173
57173
  var props = self2.props;
57174
57174
  var stat2 = props.follow ? "stat" : "lstat";
57175
57175
  if (currentStat) process.nextTick(statCb.bind(null, null, currentStat));
57176
- else fs14[stat2](self2._path, statCb);
57176
+ else fs15[stat2](self2._path, statCb);
57177
57177
  function statCb(er, props_) {
57178
57178
  if (er) return self2.error(er);
57179
57179
  Object.keys(props_).forEach(function(k2) {
@@ -57269,8 +57269,8 @@ var require_rimraf = __commonJS({
57269
57269
  module2.exports = rimraf;
57270
57270
  rimraf.sync = rimrafSync;
57271
57271
  var assert = require("assert");
57272
- var path12 = require("path");
57273
- var fs14 = require("fs");
57272
+ var path13 = require("path");
57273
+ var fs15 = require("fs");
57274
57274
  var glob = void 0;
57275
57275
  try {
57276
57276
  glob = require_glob();
@@ -57293,9 +57293,9 @@ var require_rimraf = __commonJS({
57293
57293
  "readdir"
57294
57294
  ];
57295
57295
  methods.forEach(function(m) {
57296
- options[m] = options[m] || fs14[m];
57296
+ options[m] = options[m] || fs15[m];
57297
57297
  m = m + "Sync";
57298
- options[m] = options[m] || fs14[m];
57298
+ options[m] = options[m] || fs15[m];
57299
57299
  });
57300
57300
  options.maxBusyTries = options.maxBusyTries || 3;
57301
57301
  options.emfileWait = options.emfileWait || 1e3;
@@ -57460,7 +57460,7 @@ var require_rimraf = __commonJS({
57460
57460
  return options.rmdir(p, cb);
57461
57461
  var errState;
57462
57462
  files.forEach(function(f) {
57463
- rimraf(path12.join(p, f), options, function(er2) {
57463
+ rimraf(path13.join(p, f), options, function(er2) {
57464
57464
  if (errState)
57465
57465
  return;
57466
57466
  if (er2)
@@ -57537,7 +57537,7 @@ var require_rimraf = __commonJS({
57537
57537
  assert(p);
57538
57538
  assert(options);
57539
57539
  options.readdirSync(p).forEach(function(f) {
57540
- rimrafSync(path12.join(p, f), options);
57540
+ rimrafSync(path13.join(p, f), options);
57541
57541
  });
57542
57542
  var retries = isWindows ? 100 : 1;
57543
57543
  var i = 0;
@@ -57560,8 +57560,8 @@ var require_rimraf = __commonJS({
57560
57560
  var require_mkdirp = __commonJS({
57561
57561
  "../../node_modules/.pnpm/mkdirp@0.5.6/node_modules/mkdirp/index.js"(exports2, module2) {
57562
57562
  "use strict";
57563
- var path12 = require("path");
57564
- var fs14 = require("fs");
57563
+ var path13 = require("path");
57564
+ var fs15 = require("fs");
57565
57565
  var _0777 = parseInt("0777", 8);
57566
57566
  module2.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
57567
57567
  function mkdirP(p, opts, f, made) {
@@ -57572,7 +57572,7 @@ var require_mkdirp = __commonJS({
57572
57572
  opts = { mode: opts };
57573
57573
  }
57574
57574
  var mode = opts.mode;
57575
- var xfs = opts.fs || fs14;
57575
+ var xfs = opts.fs || fs15;
57576
57576
  if (mode === void 0) {
57577
57577
  mode = _0777;
57578
57578
  }
@@ -57580,7 +57580,7 @@ var require_mkdirp = __commonJS({
57580
57580
  var cb = f || /* istanbul ignore next */
57581
57581
  function() {
57582
57582
  };
57583
- p = path12.resolve(p);
57583
+ p = path13.resolve(p);
57584
57584
  xfs.mkdir(p, mode, function(er) {
57585
57585
  if (!er) {
57586
57586
  made = made || p;
@@ -57588,8 +57588,8 @@ var require_mkdirp = __commonJS({
57588
57588
  }
57589
57589
  switch (er.code) {
57590
57590
  case "ENOENT":
57591
- if (path12.dirname(p) === p) return cb(er);
57592
- mkdirP(path12.dirname(p), opts, function(er2, made2) {
57591
+ if (path13.dirname(p) === p) return cb(er);
57592
+ mkdirP(path13.dirname(p), opts, function(er2, made2) {
57593
57593
  if (er2) cb(er2, made2);
57594
57594
  else mkdirP(p, opts, cb, made2);
57595
57595
  });
@@ -57611,19 +57611,19 @@ var require_mkdirp = __commonJS({
57611
57611
  opts = { mode: opts };
57612
57612
  }
57613
57613
  var mode = opts.mode;
57614
- var xfs = opts.fs || fs14;
57614
+ var xfs = opts.fs || fs15;
57615
57615
  if (mode === void 0) {
57616
57616
  mode = _0777;
57617
57617
  }
57618
57618
  if (!made) made = null;
57619
- p = path12.resolve(p);
57619
+ p = path13.resolve(p);
57620
57620
  try {
57621
57621
  xfs.mkdirSync(p, mode);
57622
57622
  made = made || p;
57623
57623
  } catch (err0) {
57624
57624
  switch (err0.code) {
57625
57625
  case "ENOENT":
57626
- made = sync(path12.dirname(p), opts, made);
57626
+ made = sync(path13.dirname(p), opts, made);
57627
57627
  sync(p, opts, made);
57628
57628
  break;
57629
57629
  // In the case of any other error, just see if there's a dir
@@ -57710,7 +57710,7 @@ var require_dir_writer = __commonJS({
57710
57710
  var Writer = require_writer();
57711
57711
  var inherits2 = require_inherits();
57712
57712
  var mkdir = require_mkdirp();
57713
- var path12 = require("path");
57713
+ var path13 = require("path");
57714
57714
  var collect = require_collect();
57715
57715
  inherits2(DirWriter, Writer);
57716
57716
  function DirWriter(props) {
@@ -57785,7 +57785,7 @@ var require_dir_writer = __commonJS({
57785
57785
  if (entry.parent) {
57786
57786
  pp = pp.substr(entry.parent._path.length + 1);
57787
57787
  }
57788
- props.path = path12.join(self2.path, path12.join("/", pp));
57788
+ props.path = path13.join(self2.path, path13.join("/", pp));
57789
57789
  props.filter = self2.filter;
57790
57790
  Object.keys(entry.props).forEach(function(k) {
57791
57791
  if (!props.hasOwnProperty(k)) {
@@ -57824,10 +57824,10 @@ var require_link_writer = __commonJS({
57824
57824
  "../../node_modules/.pnpm/fstream@1.0.12/node_modules/fstream/lib/link-writer.js"(exports2, module2) {
57825
57825
  "use strict";
57826
57826
  module2.exports = LinkWriter;
57827
- var fs14 = require_graceful_fs();
57827
+ var fs15 = require_graceful_fs();
57828
57828
  var Writer = require_writer();
57829
57829
  var inherits2 = require_inherits();
57830
- var path12 = require("path");
57830
+ var path13 = require("path");
57831
57831
  var rimraf = require_rimraf();
57832
57832
  inherits2(LinkWriter, Writer);
57833
57833
  function LinkWriter(props) {
@@ -57848,9 +57848,9 @@ var require_link_writer = __commonJS({
57848
57848
  var self2 = this;
57849
57849
  var hard = self2.type === "Link" || process.platform === "win32";
57850
57850
  var link = hard ? "link" : "symlink";
57851
- var lp = hard ? path12.resolve(self2.dirname, self2.linkpath) : self2.linkpath;
57851
+ var lp = hard ? path13.resolve(self2.dirname, self2.linkpath) : self2.linkpath;
57852
57852
  if (hard) return clobber(self2, lp, link);
57853
- fs14.readlink(self2._path, function(er, p) {
57853
+ fs15.readlink(self2._path, function(er, p) {
57854
57854
  if (p && p === lp) return finish(self2);
57855
57855
  clobber(self2, lp, link);
57856
57856
  });
@@ -57862,7 +57862,7 @@ var require_link_writer = __commonJS({
57862
57862
  });
57863
57863
  }
57864
57864
  function create(self2, lp, link) {
57865
- fs14[link](lp, self2._path, function(er) {
57865
+ fs15[link](lp, self2._path, function(er) {
57866
57866
  if (er) {
57867
57867
  if ((er.code === "ENOENT" || er.code === "EACCES" || er.code === "EPERM") && process.platform === "win32") {
57868
57868
  self2.ready = true;
@@ -57896,7 +57896,7 @@ var require_file_writer = __commonJS({
57896
57896
  "../../node_modules/.pnpm/fstream@1.0.12/node_modules/fstream/lib/file-writer.js"(exports2, module2) {
57897
57897
  "use strict";
57898
57898
  module2.exports = FileWriter;
57899
- var fs14 = require_graceful_fs();
57899
+ var fs15 = require_graceful_fs();
57900
57900
  var Writer = require_writer();
57901
57901
  var inherits2 = require_inherits();
57902
57902
  var EOF = {};
@@ -57920,7 +57920,7 @@ var require_file_writer = __commonJS({
57920
57920
  if (self2.props.flags) so.flags = self2.props.flags;
57921
57921
  so.mode = Writer.filemode;
57922
57922
  if (self2._old && self2._old.blksize) so.bufferSize = self2._old.blksize;
57923
- self2._stream = fs14.createWriteStream(self2._path, so);
57923
+ self2._stream = fs15.createWriteStream(self2._path, so);
57924
57924
  self2._stream.on("open", function() {
57925
57925
  self2.ready = true;
57926
57926
  self2._buffer.forEach(function(c) {
@@ -57987,7 +57987,7 @@ var require_proxy_writer = __commonJS({
57987
57987
  var getType = require_get_type();
57988
57988
  var inherits2 = require_inherits();
57989
57989
  var collect = require_collect();
57990
- var fs14 = require("fs");
57990
+ var fs15 = require("fs");
57991
57991
  inherits2(ProxyWriter, Writer);
57992
57992
  function ProxyWriter(props) {
57993
57993
  var self2 = this;
@@ -58002,7 +58002,7 @@ var require_proxy_writer = __commonJS({
58002
58002
  var self2 = this;
58003
58003
  var props = self2.props;
58004
58004
  var stat2 = props.follow ? "stat" : "lstat";
58005
- fs14[stat2](props.path, function(er, current) {
58005
+ fs15[stat2](props.path, function(er, current) {
58006
58006
  var type;
58007
58007
  if (er || !current) {
58008
58008
  type = "File";
@@ -58071,11 +58071,11 @@ var require_writer = __commonJS({
58071
58071
  "../../node_modules/.pnpm/fstream@1.0.12/node_modules/fstream/lib/writer.js"(exports2, module2) {
58072
58072
  "use strict";
58073
58073
  module2.exports = Writer;
58074
- var fs14 = require_graceful_fs();
58074
+ var fs15 = require_graceful_fs();
58075
58075
  var inherits2 = require_inherits();
58076
58076
  var rimraf = require_rimraf();
58077
58077
  var mkdir = require_mkdirp();
58078
- var path12 = require("path");
58078
+ var path13 = require("path");
58079
58079
  var umask = process.platform === "win32" ? 0 : process.umask();
58080
58080
  var getType = require_get_type();
58081
58081
  var Abstract = require_abstract();
@@ -58118,7 +58118,7 @@ var require_writer = __commonJS({
58118
58118
  self2.clobber = props.clobber === false ? props.clobber : true;
58119
58119
  self2.parent = props.parent || null;
58120
58120
  self2.root = props.root || props.parent && props.parent.root || self2;
58121
- self2._path = self2.path = path12.resolve(props.path);
58121
+ self2._path = self2.path = path13.resolve(props.path);
58122
58122
  if (process.platform === "win32") {
58123
58123
  self2.path = self2._path = self2.path.replace(/\?/g, "_");
58124
58124
  if (self2._path.length >= 260) {
@@ -58126,8 +58126,8 @@ var require_writer = __commonJS({
58126
58126
  self2._path = "\\\\?\\" + self2.path.replace(/\//g, "\\");
58127
58127
  }
58128
58128
  }
58129
- self2.basename = path12.basename(props.path);
58130
- self2.dirname = path12.dirname(props.path);
58129
+ self2.basename = path13.basename(props.path);
58130
+ self2.dirname = path13.dirname(props.path);
58131
58131
  self2.linkpath = props.linkpath || null;
58132
58132
  props.parent = props.root = null;
58133
58133
  self2.size = props.size;
@@ -58143,7 +58143,7 @@ var require_writer = __commonJS({
58143
58143
  }
58144
58144
  Writer.prototype._create = function() {
58145
58145
  var self2 = this;
58146
- fs14[self2.props.follow ? "stat" : "lstat"](self2._path, function(er) {
58146
+ fs15[self2.props.follow ? "stat" : "lstat"](self2._path, function(er) {
58147
58147
  if (er) {
58148
58148
  return self2.warn("Cannot create " + self2._path + "\nUnsupported type: " + self2.type, "ENOTSUP");
58149
58149
  }
@@ -58156,7 +58156,7 @@ var require_writer = __commonJS({
58156
58156
  var stat2 = props.follow ? "stat" : "lstat";
58157
58157
  var who = self2._proxy || self2;
58158
58158
  if (current) statCb(null, current);
58159
- else fs14[stat2](self2._path, statCb);
58159
+ else fs15[stat2](self2._path, statCb);
58160
58160
  function statCb(er, current2) {
58161
58161
  if (self2.filter && !self2.filter.call(who, who, current2)) {
58162
58162
  self2._aborted = true;
@@ -58180,40 +58180,40 @@ var require_writer = __commonJS({
58180
58180
  }
58181
58181
  };
58182
58182
  function create(self2) {
58183
- mkdir(path12.dirname(self2._path), Writer.dirmode, function(er, made) {
58183
+ mkdir(path13.dirname(self2._path), Writer.dirmode, function(er, made) {
58184
58184
  if (er) return self2.error(er);
58185
58185
  self2._madeDir = made;
58186
58186
  return self2._create();
58187
58187
  });
58188
58188
  }
58189
- function endChmod(self2, want, current, path13, cb) {
58189
+ function endChmod(self2, want, current, path14, cb) {
58190
58190
  var wantMode = want.mode;
58191
58191
  var chmod = want.follow || self2.type !== "SymbolicLink" ? "chmod" : "lchmod";
58192
- if (!fs14[chmod]) return cb();
58192
+ if (!fs15[chmod]) return cb();
58193
58193
  if (typeof wantMode !== "number") return cb();
58194
58194
  var curMode = current.mode & parseInt("0777", 8);
58195
58195
  wantMode = wantMode & parseInt("0777", 8);
58196
58196
  if (wantMode === curMode) return cb();
58197
- fs14[chmod](path13, wantMode, cb);
58197
+ fs15[chmod](path14, wantMode, cb);
58198
58198
  }
58199
- function endChown(self2, want, current, path13, cb) {
58199
+ function endChown(self2, want, current, path14, cb) {
58200
58200
  if (process.platform === "win32") return cb();
58201
58201
  if (!process.getuid || process.getuid() !== 0) return cb();
58202
58202
  if (typeof want.uid !== "number" && typeof want.gid !== "number") return cb();
58203
58203
  if (current.uid === want.uid && current.gid === want.gid) return cb();
58204
58204
  var chown = self2.props.follow || self2.type !== "SymbolicLink" ? "chown" : "lchown";
58205
- if (!fs14[chown]) return cb();
58205
+ if (!fs15[chown]) return cb();
58206
58206
  if (typeof want.uid !== "number") want.uid = current.uid;
58207
58207
  if (typeof want.gid !== "number") want.gid = current.gid;
58208
- fs14[chown](path13, want.uid, want.gid, cb);
58208
+ fs15[chown](path14, want.uid, want.gid, cb);
58209
58209
  }
58210
- function endUtimes(self2, want, current, path13, cb) {
58211
- if (!fs14.utimes || process.platform === "win32") return cb();
58210
+ function endUtimes(self2, want, current, path14, cb) {
58211
+ if (!fs15.utimes || process.platform === "win32") return cb();
58212
58212
  var utimes = want.follow || self2.type !== "SymbolicLink" ? "utimes" : "lutimes";
58213
- if (utimes === "lutimes" && !fs14[utimes]) {
58213
+ if (utimes === "lutimes" && !fs15[utimes]) {
58214
58214
  utimes = "utimes";
58215
58215
  }
58216
- if (!fs14[utimes]) return cb();
58216
+ if (!fs15[utimes]) return cb();
58217
58217
  var curA = current.atime;
58218
58218
  var curM = current.mtime;
58219
58219
  var meA = want.atime;
@@ -58223,7 +58223,7 @@ var require_writer = __commonJS({
58223
58223
  if (!isDate(meA)) meA = new Date(meA);
58224
58224
  if (!isDate(meM)) meA = new Date(meM);
58225
58225
  if (meA.getTime() === curA.getTime() && meM.getTime() === curM.getTime()) return cb();
58226
- fs14[utimes](path13, meA, meM, cb);
58226
+ fs15[utimes](path14, meA, meM, cb);
58227
58227
  }
58228
58228
  Writer.prototype._finish = function() {
58229
58229
  var self2 = this;
@@ -58238,7 +58238,7 @@ var require_writer = __commonJS({
58238
58238
  setProps(self2._old);
58239
58239
  } else {
58240
58240
  var stat2 = self2.props.follow ? "stat" : "lstat";
58241
- fs14[stat2](self2._path, function(er, current) {
58241
+ fs15[stat2](self2._path, function(er, current) {
58242
58242
  if (er) {
58243
58243
  if (er.code === "ENOENT" && (self2.type === "Link" || self2.type === "SymbolicLink") && process.platform === "win32") {
58244
58244
  self2.ready = true;
@@ -58285,7 +58285,7 @@ var require_writer = __commonJS({
58285
58285
  };
58286
58286
  function endMadeDir(self2, p, cb) {
58287
58287
  var made = self2._madeDir;
58288
- var d = path12.dirname(p);
58288
+ var d = path13.dirname(p);
58289
58289
  endMadeDir_(self2, d, function(er) {
58290
58290
  if (er) return cb(er);
58291
58291
  if (d === made) {
@@ -58304,7 +58304,7 @@ var require_writer = __commonJS({
58304
58304
  });
58305
58305
  var todo = 3;
58306
58306
  var errState = null;
58307
- fs14.stat(p, function(er, current) {
58307
+ fs15.stat(p, function(er, current) {
58308
58308
  if (er) return cb(errState = er);
58309
58309
  endChmod(self2, dirProps, current, p, next);
58310
58310
  endChown(self2, dirProps, current, p, next);
@@ -58376,17 +58376,17 @@ var require_extract2 = __commonJS({
58376
58376
  module2.exports = Extract;
58377
58377
  var Parse = require_parse();
58378
58378
  var Writer = require_fstream().Writer;
58379
- var path12 = require("path");
58379
+ var path13 = require("path");
58380
58380
  var stream = require("stream");
58381
58381
  var duplexer2 = require_duplexer2();
58382
58382
  var Promise2 = require_bluebird();
58383
58383
  function Extract(opts) {
58384
- opts.path = path12.resolve(path12.normalize(opts.path));
58384
+ opts.path = path13.resolve(path13.normalize(opts.path));
58385
58385
  var parser = new Parse(opts);
58386
58386
  var outStream = new stream.Writable({ objectMode: true });
58387
58387
  outStream._write = function(entry, encoding, cb) {
58388
58388
  if (entry.type == "Directory") return cb();
58389
- var extractPath = path12.join(opts.path, entry.path);
58389
+ var extractPath = path13.join(opts.path, entry.path);
58390
58390
  if (extractPath.indexOf(opts.path) != 0) {
58391
58391
  return cb();
58392
58392
  }
@@ -59827,7 +59827,7 @@ var require_directory = __commonJS({
59827
59827
  var BufferStream = require_BufferStream();
59828
59828
  var parseExtraField = require_parseExtraField();
59829
59829
  var Buffer2 = require_Buffer();
59830
- var path12 = require("path");
59830
+ var path13 = require("path");
59831
59831
  var Writer = require_fstream().Writer;
59832
59832
  var parseDateTime = require_parseDateTime();
59833
59833
  var signature = Buffer2.alloc(4);
@@ -59904,11 +59904,11 @@ var require_directory = __commonJS({
59904
59904
  source.stream(vars.offsetToStartOfCentralDirectory).pipe(records);
59905
59905
  vars.extract = function(opts) {
59906
59906
  if (!opts || !opts.path) throw new Error("PATH_MISSING");
59907
- opts.path = path12.resolve(path12.normalize(opts.path));
59907
+ opts.path = path13.resolve(path13.normalize(opts.path));
59908
59908
  return vars.files.then(function(files) {
59909
59909
  return Promise2.map(files, function(entry) {
59910
59910
  if (entry.type == "Directory") return;
59911
- var extractPath = path12.join(opts.path, entry.path);
59911
+ var extractPath = path13.join(opts.path, entry.path);
59912
59912
  if (extractPath.indexOf(opts.path) != 0) {
59913
59913
  return;
59914
59914
  }
@@ -59955,7 +59955,7 @@ var require_directory = __commonJS({
59955
59955
  var require_Open = __commonJS({
59956
59956
  "../../node_modules/.pnpm/unzipper@0.10.14/node_modules/unzipper/lib/Open/index.js"(exports2, module2) {
59957
59957
  "use strict";
59958
- var fs14 = require_graceful_fs();
59958
+ var fs15 = require_graceful_fs();
59959
59959
  var Promise2 = require_bluebird();
59960
59960
  var directory = require_directory();
59961
59961
  var Stream = require("stream");
@@ -59978,11 +59978,11 @@ var require_Open = __commonJS({
59978
59978
  file: function(filename, options) {
59979
59979
  var source = {
59980
59980
  stream: function(offset, length) {
59981
- return fs14.createReadStream(filename, { start: offset, end: length && offset + length });
59981
+ return fs15.createReadStream(filename, { start: offset, end: length && offset + length });
59982
59982
  },
59983
59983
  size: function() {
59984
59984
  return new Promise2(function(resolve, reject) {
59985
- fs14.stat(filename, function(err, d) {
59985
+ fs15.stat(filename, function(err, d) {
59986
59986
  if (err)
59987
59987
  reject(err);
59988
59988
  else
@@ -60068,29 +60068,29 @@ var require_unzip2 = __commonJS({
60068
60068
  var require_tmp = __commonJS({
60069
60069
  "../../node_modules/.pnpm/tmp@0.2.6/node_modules/tmp/lib/tmp.js"(exports2, module2) {
60070
60070
  "use strict";
60071
- var fs14 = require("fs");
60072
- var os4 = require("os");
60073
- var path12 = require("path");
60071
+ var fs15 = require("fs");
60072
+ var os5 = require("os");
60073
+ var path13 = require("path");
60074
60074
  var crypto4 = require("crypto");
60075
- var _c = { fs: fs14.constants, os: os4.constants };
60075
+ var _c = { fs: fs15.constants, os: os5.constants };
60076
60076
  var RANDOM_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
60077
60077
  var TEMPLATE_PATTERN = /XXXXXX/;
60078
60078
  var DEFAULT_TRIES = 3;
60079
60079
  var CREATE_FLAGS = (_c.O_CREAT || _c.fs.O_CREAT) | (_c.O_EXCL || _c.fs.O_EXCL) | (_c.O_RDWR || _c.fs.O_RDWR);
60080
- var IS_WIN32 = os4.platform() === "win32";
60080
+ var IS_WIN32 = os5.platform() === "win32";
60081
60081
  var EBADF = _c.EBADF || _c.os.errno.EBADF;
60082
60082
  var ENOENT = _c.ENOENT || _c.os.errno.ENOENT;
60083
60083
  var DIR_MODE = 448;
60084
60084
  var FILE_MODE = 384;
60085
60085
  var EXIT = "exit";
60086
60086
  var _removeObjects = [];
60087
- var FN_RMDIR_SYNC = fs14.rmdirSync.bind(fs14);
60087
+ var FN_RMDIR_SYNC = fs15.rmdirSync.bind(fs15);
60088
60088
  var _gracefulCleanup = false;
60089
60089
  function rimraf(dirPath, callback) {
60090
- return fs14.rm(dirPath, { recursive: true }, callback);
60090
+ return fs15.rm(dirPath, { recursive: true }, callback);
60091
60091
  }
60092
60092
  function FN_RIMRAF_SYNC(dirPath) {
60093
- return fs14.rmSync(dirPath, { recursive: true });
60093
+ return fs15.rmSync(dirPath, { recursive: true });
60094
60094
  }
60095
60095
  function tmpName(options, callback) {
60096
60096
  const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
@@ -60100,7 +60100,7 @@ var require_tmp = __commonJS({
60100
60100
  (function _getUniqueName() {
60101
60101
  try {
60102
60102
  const name = _generateTmpName(sanitizedOptions);
60103
- fs14.stat(name, function(err2) {
60103
+ fs15.stat(name, function(err2) {
60104
60104
  if (!err2) {
60105
60105
  if (tries-- > 0) return _getUniqueName();
60106
60106
  return cb(new Error("Could not get a unique tmp filename, max tries reached " + name));
@@ -60120,7 +60120,7 @@ var require_tmp = __commonJS({
60120
60120
  do {
60121
60121
  const name = _generateTmpName(sanitizedOptions);
60122
60122
  try {
60123
- fs14.statSync(name);
60123
+ fs15.statSync(name);
60124
60124
  } catch (e) {
60125
60125
  return name;
60126
60126
  }
@@ -60131,10 +60131,10 @@ var require_tmp = __commonJS({
60131
60131
  const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
60132
60132
  tmpName(opts, function _tmpNameCreated(err, name) {
60133
60133
  if (err) return cb(err);
60134
- fs14.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
60134
+ fs15.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
60135
60135
  if (err2) return cb(err2);
60136
60136
  if (opts.discardDescriptor) {
60137
- return fs14.close(fd, function _discardCallback(possibleErr) {
60137
+ return fs15.close(fd, function _discardCallback(possibleErr) {
60138
60138
  return cb(possibleErr, name, void 0, _prepareTmpFileRemoveCallback(name, -1, opts, false));
60139
60139
  });
60140
60140
  } else {
@@ -60148,9 +60148,9 @@ var require_tmp = __commonJS({
60148
60148
  const args = _parseArguments(options), opts = args[0];
60149
60149
  const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
60150
60150
  const name = tmpNameSync(opts);
60151
- let fd = fs14.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
60151
+ let fd = fs15.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
60152
60152
  if (opts.discardDescriptor) {
60153
- fs14.closeSync(fd);
60153
+ fs15.closeSync(fd);
60154
60154
  fd = void 0;
60155
60155
  }
60156
60156
  return {
@@ -60163,7 +60163,7 @@ var require_tmp = __commonJS({
60163
60163
  const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
60164
60164
  tmpName(opts, function _tmpNameCreated(err, name) {
60165
60165
  if (err) return cb(err);
60166
- fs14.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
60166
+ fs15.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
60167
60167
  if (err2) return cb(err2);
60168
60168
  cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
60169
60169
  });
@@ -60172,7 +60172,7 @@ var require_tmp = __commonJS({
60172
60172
  function dirSync(options) {
60173
60173
  const args = _parseArguments(options), opts = args[0];
60174
60174
  const name = tmpNameSync(opts);
60175
- fs14.mkdirSync(name, opts.mode || DIR_MODE);
60175
+ fs15.mkdirSync(name, opts.mode || DIR_MODE);
60176
60176
  return {
60177
60177
  name,
60178
60178
  removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
@@ -60186,20 +60186,20 @@ var require_tmp = __commonJS({
60186
60186
  next();
60187
60187
  };
60188
60188
  if (0 <= fdPath[0])
60189
- fs14.close(fdPath[0], function() {
60190
- fs14.unlink(fdPath[1], _handler);
60189
+ fs15.close(fdPath[0], function() {
60190
+ fs15.unlink(fdPath[1], _handler);
60191
60191
  });
60192
- else fs14.unlink(fdPath[1], _handler);
60192
+ else fs15.unlink(fdPath[1], _handler);
60193
60193
  }
60194
60194
  function _removeFileSync(fdPath) {
60195
60195
  let rethrownException = null;
60196
60196
  try {
60197
- if (0 <= fdPath[0]) fs14.closeSync(fdPath[0]);
60197
+ if (0 <= fdPath[0]) fs15.closeSync(fdPath[0]);
60198
60198
  } catch (e) {
60199
60199
  if (!_isEBADF(e) && !_isENOENT(e)) throw e;
60200
60200
  } finally {
60201
60201
  try {
60202
- fs14.unlinkSync(fdPath[1]);
60202
+ fs15.unlinkSync(fdPath[1]);
60203
60203
  } catch (e) {
60204
60204
  if (!_isENOENT(e)) rethrownException = e;
60205
60205
  }
@@ -60215,7 +60215,7 @@ var require_tmp = __commonJS({
60215
60215
  return sync ? removeCallbackSync : removeCallback;
60216
60216
  }
60217
60217
  function _prepareTmpDirRemoveCallback(name, opts, sync) {
60218
- const removeFunction = opts.unsafeCleanup ? rimraf : fs14.rmdir.bind(fs14);
60218
+ const removeFunction = opts.unsafeCleanup ? rimraf : fs15.rmdir.bind(fs15);
60219
60219
  const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
60220
60220
  const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
60221
60221
  const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
@@ -60277,35 +60277,35 @@ var require_tmp = __commonJS({
60277
60277
  return [actualOptions, callback];
60278
60278
  }
60279
60279
  function _resolvePath(name, tmpDir, cb) {
60280
- const pathToResolve = path12.isAbsolute(name) ? name : path12.join(tmpDir, name);
60281
- fs14.stat(pathToResolve, function(err) {
60280
+ const pathToResolve = path13.isAbsolute(name) ? name : path13.join(tmpDir, name);
60281
+ fs15.stat(pathToResolve, function(err) {
60282
60282
  if (err) {
60283
- fs14.realpath(path12.dirname(pathToResolve), function(err2, parentDir) {
60283
+ fs15.realpath(path13.dirname(pathToResolve), function(err2, parentDir) {
60284
60284
  if (err2) return cb(err2);
60285
- cb(null, path12.join(parentDir, path12.basename(pathToResolve)));
60285
+ cb(null, path13.join(parentDir, path13.basename(pathToResolve)));
60286
60286
  });
60287
60287
  } else {
60288
- fs14.realpath(pathToResolve, cb);
60288
+ fs15.realpath(pathToResolve, cb);
60289
60289
  }
60290
60290
  });
60291
60291
  }
60292
60292
  function _resolvePathSync(name, tmpDir) {
60293
- const pathToResolve = path12.isAbsolute(name) ? name : path12.join(tmpDir, name);
60293
+ const pathToResolve = path13.isAbsolute(name) ? name : path13.join(tmpDir, name);
60294
60294
  try {
60295
- fs14.statSync(pathToResolve);
60296
- return fs14.realpathSync(pathToResolve);
60295
+ fs15.statSync(pathToResolve);
60296
+ return fs15.realpathSync(pathToResolve);
60297
60297
  } catch (_err) {
60298
- const parentDir = fs14.realpathSync(path12.dirname(pathToResolve));
60299
- return path12.join(parentDir, path12.basename(pathToResolve));
60298
+ const parentDir = fs15.realpathSync(path13.dirname(pathToResolve));
60299
+ return path13.join(parentDir, path13.basename(pathToResolve));
60300
60300
  }
60301
60301
  }
60302
60302
  function _generateTmpName(opts) {
60303
60303
  const tmpDir = opts.tmpdir;
60304
60304
  if (!_isUndefined(opts.name)) {
60305
- return path12.join(tmpDir, opts.dir, opts.name);
60305
+ return path13.join(tmpDir, opts.dir, opts.name);
60306
60306
  }
60307
60307
  if (!_isUndefined(opts.template)) {
60308
- return path12.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
60308
+ return path13.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
60309
60309
  }
60310
60310
  const name = [
60311
60311
  opts.prefix ? opts.prefix : "tmp",
@@ -60315,19 +60315,19 @@ var require_tmp = __commonJS({
60315
60315
  _randomChars(12),
60316
60316
  opts.postfix ? "-" + opts.postfix : ""
60317
60317
  ].join("");
60318
- return path12.join(tmpDir, opts.dir, name);
60318
+ return path13.join(tmpDir, opts.dir, name);
60319
60319
  }
60320
- function _assertPath(path13) {
60321
- if (path13.includes("..")) {
60320
+ function _assertPath(path14) {
60321
+ if (path14.includes("..")) {
60322
60322
  throw new Error("Relative value not allowed");
60323
60323
  }
60324
- return path13;
60324
+ return path14;
60325
60325
  }
60326
60326
  function _assertOptionsBase(options) {
60327
60327
  if (!_isUndefined(options.name)) {
60328
60328
  const name = options.name;
60329
- if (path12.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);
60330
- const basename = path12.basename(name);
60329
+ if (path13.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);
60330
+ const basename = path13.basename(name);
60331
60331
  if (basename === ".." || basename === "." || basename !== name) {
60332
60332
  throw new Error(`name option must not contain a path, found "${name}".`);
60333
60333
  }
@@ -60351,8 +60351,8 @@ var require_tmp = __commonJS({
60351
60351
  if (_isUndefined(name)) return cb(null);
60352
60352
  _resolvePath(name, tmpDir, function(err, resolvedPath) {
60353
60353
  if (err) return cb(err);
60354
- const relativePath = path12.relative(tmpDir, resolvedPath);
60355
- if (relativePath.startsWith("..") || path12.isAbsolute(relativePath)) {
60354
+ const relativePath = path13.relative(tmpDir, resolvedPath);
60355
+ if (relativePath.startsWith("..") || path13.isAbsolute(relativePath)) {
60356
60356
  return cb(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`));
60357
60357
  }
60358
60358
  cb(null, relativePath);
@@ -60361,8 +60361,8 @@ var require_tmp = __commonJS({
60361
60361
  function _getRelativePathSync(option, name, tmpDir) {
60362
60362
  if (_isUndefined(name)) return;
60363
60363
  const resolvedPath = _resolvePathSync(name, tmpDir);
60364
- const relativePath = path12.relative(tmpDir, resolvedPath);
60365
- if (relativePath.startsWith("..") || path12.isAbsolute(relativePath)) {
60364
+ const relativePath = path13.relative(tmpDir, resolvedPath);
60365
+ if (relativePath.startsWith("..") || path13.isAbsolute(relativePath)) {
60366
60366
  throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`);
60367
60367
  }
60368
60368
  return relativePath;
@@ -60408,10 +60408,10 @@ var require_tmp = __commonJS({
60408
60408
  _gracefulCleanup = true;
60409
60409
  }
60410
60410
  function _getTmpDir(options, cb) {
60411
- return fs14.realpath(options && options.tmpdir || os4.tmpdir(), cb);
60411
+ return fs15.realpath(options && options.tmpdir || os5.tmpdir(), cb);
60412
60412
  }
60413
60413
  function _getTmpDirSync(options) {
60414
- return fs14.realpathSync(options && options.tmpdir || os4.tmpdir());
60414
+ return fs15.realpathSync(options && options.tmpdir || os5.tmpdir());
60415
60415
  }
60416
60416
  process.addListener(EXIT, _garbageCollector);
60417
60417
  Object.defineProperty(module2.exports, "tmpdir", {
@@ -60899,7 +60899,7 @@ var require_hyperlink_reader = __commonJS({
60899
60899
  var require_workbook_reader = __commonJS({
60900
60900
  "../../node_modules/.pnpm/exceljs@4.4.0/node_modules/exceljs/lib/stream/xlsx/workbook-reader.js"(exports2, module2) {
60901
60901
  "use strict";
60902
- var fs14 = require("fs");
60902
+ var fs15 = require("fs");
60903
60903
  var { EventEmitter } = require("events");
60904
60904
  var { PassThrough, Readable } = require_readable2();
60905
60905
  var nodeStream = require("stream");
@@ -60933,7 +60933,7 @@ var require_workbook_reader = __commonJS({
60933
60933
  return input;
60934
60934
  }
60935
60935
  if (typeof input === "string") {
60936
- return fs14.createReadStream(input);
60936
+ return fs15.createReadStream(input);
60937
60937
  }
60938
60938
  throw new Error(`Could not recognise input: ${input}`);
60939
60939
  }
@@ -60998,12 +60998,12 @@ var require_workbook_reader = __commonJS({
60998
60998
  yield* this._parseWorksheet(iterateStream(entry), sheetNo);
60999
60999
  } else {
61000
61000
  await new Promise((resolve, reject) => {
61001
- tmp.file((err, path12, fd, tempFileCleanupCallback) => {
61001
+ tmp.file((err, path13, fd, tempFileCleanupCallback) => {
61002
61002
  if (err) {
61003
61003
  return reject(err);
61004
61004
  }
61005
- waitingWorkSheets.push({ sheetNo, path: path12, tempFileCleanupCallback });
61006
- const tempStream = fs14.createWriteStream(path12);
61005
+ waitingWorkSheets.push({ sheetNo, path: path13, tempFileCleanupCallback });
61006
+ const tempStream = fs15.createWriteStream(path13);
61007
61007
  tempStream.on("error", reject);
61008
61008
  entry.pipe(tempStream);
61009
61009
  return tempStream.on("finish", () => {
@@ -61021,8 +61021,8 @@ var require_workbook_reader = __commonJS({
61021
61021
  }
61022
61022
  entry.autodrain();
61023
61023
  }
61024
- for (const { sheetNo, path: path12, tempFileCleanupCallback } of waitingWorkSheets) {
61025
- let fileStream = fs14.createReadStream(path12);
61024
+ for (const { sheetNo, path: path13, tempFileCleanupCallback } of waitingWorkSheets) {
61025
+ let fileStream = fs15.createReadStream(path13);
61026
61026
  if (!fileStream[Symbol.asyncIterator]) {
61027
61027
  fileStream = fileStream.pipe(new PassThrough());
61028
61028
  }
@@ -61237,7 +61237,7 @@ var require_excel = __commonJS({
61237
61237
  });
61238
61238
 
61239
61239
  // src/cli.ts
61240
- var import_path10 = __toESM(require("path"));
61240
+ var import_path11 = __toESM(require("path"));
61241
61241
 
61242
61242
  // ../../src/lib/daemon/remoteDaemonLoop.ts
61243
61243
  var import_os2 = __toESM(require("os"));
@@ -62948,15 +62948,15 @@ function dependencyBlocker(dependency) {
62948
62948
  };
62949
62949
  }
62950
62950
  function cycleBlocker(cycle) {
62951
- const path12 = cycle.join(" -> ");
62951
+ const path13 = cycle.join(" -> ");
62952
62952
  return {
62953
62953
  kind: "cycle",
62954
62954
  severity: "block",
62955
62955
  source: "system",
62956
62956
  id: "dependency_cycle",
62957
62957
  label: "\u4F9D\u8D56\u5FAA\u73AF",
62958
- message: `\u4EFB\u52A1\u4F9D\u8D56\u51FA\u73B0\u5FAA\u73AF\uFF1A${path12}\uFF0C\u5DF2\u6682\u505C\u81EA\u52A8\u8FD0\u884C\u3002`,
62959
- reason: `\u68C0\u6D4B\u5230\u4F9D\u8D56\u5FAA\u73AF\uFF1A${path12}`,
62958
+ message: `\u4EFB\u52A1\u4F9D\u8D56\u51FA\u73B0\u5FAA\u73AF\uFF1A${path13}\uFF0C\u5DF2\u6682\u505C\u81EA\u52A8\u8FD0\u884C\u3002`,
62959
+ reason: `\u68C0\u6D4B\u5230\u4F9D\u8D56\u5FAA\u73AF\uFF1A${path13}`,
62960
62960
  suggestedActions: [{ kind: "free_text", label: "\u8C03\u6574\u4EFB\u52A1\u4F9D\u8D56\u5173\u7CFB" }]
62961
62961
  };
62962
62962
  }
@@ -63134,8 +63134,8 @@ async function resolveCliPath(cliPath) {
63134
63134
  const { stdout } = await execFileAsync("which", [normalized]);
63135
63135
  return stdout.trim();
63136
63136
  }
63137
- function normalizeWorkingDirectory(path12) {
63138
- return expandHomeDir(path12);
63137
+ function normalizeWorkingDirectory(path13) {
63138
+ return expandHomeDir(path13);
63139
63139
  }
63140
63140
 
63141
63141
  // ../../src/lib/server/claude/traceStore.ts
@@ -71574,9 +71574,9 @@ var runtimeDefinitions = {
71574
71574
  installHint: "\u5B89\u88C5 Gemini CLI \u540E\u786E\u4FDD `gemini` \u547D\u4EE4\u5728 PATH \u4E2D\u53EF\u7528\u3002"
71575
71575
  }
71576
71576
  };
71577
- async function pathExists(path12) {
71577
+ async function pathExists(path13) {
71578
71578
  try {
71579
- await (0, import_promises2.stat)(path12);
71579
+ await (0, import_promises2.stat)(path13);
71580
71580
  return true;
71581
71581
  } catch {
71582
71582
  return false;
@@ -71774,7 +71774,7 @@ async function runRemoteDaemonLoop(input) {
71774
71774
  const wsUrl = toWsUrl(input.serverUrl, input.apiKey);
71775
71775
  appendRuntimeDaemonLog(`\u8FDC\u7A0B daemon \u8FDE\u63A5 ${wsUrl}`);
71776
71776
  const connect = () => new Promise((resolve, reject) => {
71777
- const socket2 = new wrapper_default(wsUrl);
71777
+ const socket2 = new wrapper_default(wsUrl, { perMessageDeflate: false });
71778
71778
  socket2.once("open", () => resolve(socket2));
71779
71779
  socket2.once("error", reject);
71780
71780
  });
@@ -71785,7 +71785,7 @@ async function runRemoteDaemonLoop(input) {
71785
71785
  type: "register",
71786
71786
  machineId: "pending",
71787
71787
  os: osFingerprint(),
71788
- daemonVersion: "0.1.1",
71788
+ daemonVersion: "0.1.3",
71789
71789
  fingerprint: osFingerprint()
71790
71790
  })
71791
71791
  );
@@ -71914,38 +71914,210 @@ async function runRemoteDaemonLoop(input) {
71914
71914
  });
71915
71915
  }
71916
71916
 
71917
- // src/service.ts
71917
+ // src/pathEnv.ts
71918
71918
  var import_fs13 = __toESM(require("fs"));
71919
71919
  var import_os3 = __toESM(require("os"));
71920
71920
  var import_path9 = __toESM(require("path"));
71921
+ function loadMacSystemPaths() {
71922
+ if (process.platform !== "darwin") return [];
71923
+ const dirs = [];
71924
+ const pushFile = (filePath) => {
71925
+ try {
71926
+ const content = import_fs13.default.readFileSync(filePath, "utf8");
71927
+ for (const line of content.split("\n")) {
71928
+ const entry = line.trim();
71929
+ if (entry) dirs.push(entry);
71930
+ }
71931
+ } catch {
71932
+ }
71933
+ };
71934
+ pushFile("/etc/paths");
71935
+ try {
71936
+ for (const name of import_fs13.default.readdirSync("/etc/paths.d")) {
71937
+ pushFile(import_path9.default.join("/etc/paths.d", name));
71938
+ }
71939
+ } catch {
71940
+ }
71941
+ return dirs;
71942
+ }
71943
+ function uniquePaths(paths) {
71944
+ const seen = /* @__PURE__ */ new Set();
71945
+ const result = [];
71946
+ for (const entry of paths) {
71947
+ const normalized = entry.replace(/\/+$/, "") || entry;
71948
+ if (!normalized || seen.has(normalized)) continue;
71949
+ seen.add(normalized);
71950
+ result.push(normalized);
71951
+ }
71952
+ return result;
71953
+ }
71954
+ function collectDaemonPathCandidates(home = import_os3.default.homedir()) {
71955
+ const candidates = [];
71956
+ candidates.push(
71957
+ import_path9.default.join(home, ".local", "bin"),
71958
+ import_path9.default.join(home, "bin"),
71959
+ import_path9.default.join(home, ".npm-global", "bin"),
71960
+ import_path9.default.join(home, ".volta", "bin"),
71961
+ import_path9.default.join(home, ".cargo", "bin"),
71962
+ import_path9.default.join(home, ".deno", "bin"),
71963
+ import_path9.default.join(home, ".bun", "bin"),
71964
+ import_path9.default.join(home, ".local", "share", "pnpm"),
71965
+ import_path9.default.join(home, ".local", "share", "mise", "shims"),
71966
+ import_path9.default.join(home, ".pixi", "bin"),
71967
+ import_path9.default.join(home, ".asdf", "shims"),
71968
+ import_path9.default.join(home, ".pyenv", "shims"),
71969
+ import_path9.default.join(home, ".rbenv", "shims"),
71970
+ import_path9.default.join(home, ".nix-profile", "bin"),
71971
+ import_path9.default.join(home, "go", "bin"),
71972
+ import_path9.default.join(home, "Library", "pnpm"),
71973
+ import_path9.default.join(home, "google-cloud-sdk", "bin"),
71974
+ import_path9.default.join(home, "miniconda3", "bin"),
71975
+ import_path9.default.join(home, "anaconda3", "bin"),
71976
+ import_path9.default.join(home, "miniforge3", "bin")
71977
+ );
71978
+ if (process.env.NVM_BIN) {
71979
+ candidates.push(process.env.NVM_BIN);
71980
+ } else {
71981
+ candidates.push(import_path9.default.join(home, ".nvm", "current", "bin"));
71982
+ }
71983
+ if (process.env.FNM_MULTISHELL_PATH) {
71984
+ candidates.push(process.env.FNM_MULTISHELL_PATH);
71985
+ }
71986
+ candidates.push(import_path9.default.join(home, ".fnm", "aliases", "default", "bin"));
71987
+ if (process.env.PIXI_HOME) {
71988
+ candidates.push(import_path9.default.join(process.env.PIXI_HOME, "bin"));
71989
+ }
71990
+ const npmPrefix = process.env.npm_config_prefix || process.env.NPM_CONFIG_PREFIX;
71991
+ if (npmPrefix) {
71992
+ candidates.push(import_path9.default.join(npmPrefix, "bin"));
71993
+ }
71994
+ const nodeDir = import_path9.default.dirname(process.execPath);
71995
+ candidates.push(nodeDir);
71996
+ if (process.platform === "darwin") {
71997
+ candidates.push(...loadMacSystemPaths());
71998
+ candidates.push(
71999
+ "/opt/homebrew/bin",
72000
+ "/opt/homebrew/sbin",
72001
+ "/usr/local/bin",
72002
+ "/usr/local/sbin",
72003
+ "/opt/local/bin",
72004
+ "/Library/Apple/usr/bin",
72005
+ "/Applications/Visual Studio Code.app/Contents/Resources/app/bin",
72006
+ "/Applications/Cursor.app/Contents/Resources/app/bin"
72007
+ );
72008
+ for (const ver of ["3.9", "3.10", "3.11", "3.12", "3.13"]) {
72009
+ candidates.push(import_path9.default.join(home, "Library", "Python", ver, "bin"));
72010
+ }
72011
+ }
72012
+ if (process.platform === "linux") {
72013
+ candidates.push("/snap/bin", "/usr/local/sbin", "/var/lib/flatpak/exports/bin");
72014
+ }
72015
+ candidates.push("/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin");
72016
+ return candidates;
72017
+ }
72018
+ function buildDaemonPathEnv(installPath, home = import_os3.default.homedir()) {
72019
+ const segments = [];
72020
+ if (installPath?.trim()) {
72021
+ segments.push(...installPath.split(import_path9.default.delimiter).filter(Boolean));
72022
+ }
72023
+ segments.push(...collectDaemonPathCandidates(home));
72024
+ return uniquePaths(segments).join(import_path9.default.delimiter);
72025
+ }
72026
+ var PASSTHROUGH_EXACT = /* @__PURE__ */ new Set([
72027
+ "LANG",
72028
+ "LC_ALL",
72029
+ "LC_CTYPE",
72030
+ "TMPDIR",
72031
+ "SHELL",
72032
+ "XDG_CONFIG_HOME",
72033
+ "XDG_CACHE_HOME",
72034
+ "XDG_DATA_HOME",
72035
+ "SSL_CERT_FILE",
72036
+ "SSL_CERT_DIR",
72037
+ "HTTP_PROXY",
72038
+ "HTTPS_PROXY",
72039
+ "NO_PROXY",
72040
+ "http_proxy",
72041
+ "https_proxy",
72042
+ "no_proxy",
72043
+ "all_proxy"
72044
+ ]);
72045
+ var PASSTHROUGH_PREFIXES = [
72046
+ "ANTHROPIC_",
72047
+ "CLAUDE_",
72048
+ "OPENAI_",
72049
+ "CODEX_",
72050
+ "GEMINI_",
72051
+ "GOOGLE_",
72052
+ "HTTP_",
72053
+ "HTTPS_"
72054
+ ];
72055
+ function collectDaemonServiceEnv(installEnv = process.env, home = import_os3.default.homedir()) {
72056
+ const user = import_os3.default.userInfo();
72057
+ const env2 = {
72058
+ HOME: home,
72059
+ USER: user.username,
72060
+ LOGNAME: user.username,
72061
+ PATH: buildDaemonPathEnv(installEnv.PATH, home),
72062
+ LANG: installEnv.LANG || "en_US.UTF-8"
72063
+ };
72064
+ if (installEnv.LC_ALL) env2.LC_ALL = installEnv.LC_ALL;
72065
+ if (installEnv.LC_CTYPE) env2.LC_CTYPE = installEnv.LC_CTYPE;
72066
+ if (installEnv.TMPDIR) env2.TMPDIR = installEnv.TMPDIR;
72067
+ else if (import_fs13.default.existsSync("/tmp")) env2.TMPDIR = "/tmp";
72068
+ if (installEnv.SHELL) env2.SHELL = installEnv.SHELL;
72069
+ for (const [key, value] of Object.entries(installEnv)) {
72070
+ if (!value) continue;
72071
+ if (PASSTHROUGH_EXACT.has(key) || PASSTHROUGH_PREFIXES.some((prefix) => key.startsWith(prefix))) {
72072
+ env2[key] = value;
72073
+ }
72074
+ }
72075
+ return env2;
72076
+ }
72077
+
72078
+ // src/service.ts
72079
+ var import_fs14 = __toESM(require("fs"));
72080
+ var import_os4 = __toESM(require("os"));
72081
+ var import_path10 = __toESM(require("path"));
71921
72082
  var import_child_process4 = require("child_process");
71922
72083
  var import_util3 = require("util");
71923
72084
  var execFileAsync3 = (0, import_util3.promisify)(import_child_process4.execFile);
71924
72085
  var MAC_LABEL = "com.kiki.daemon";
71925
72086
  var LINUX_UNIT = "kiki-daemon.service";
71926
72087
  function kikiHome() {
71927
- return import_path9.default.join(import_os3.default.homedir(), ".kiki");
72088
+ return import_path10.default.join(import_os4.default.homedir(), ".kiki");
71928
72089
  }
71929
72090
  function logsDir() {
71930
- const dir = import_path9.default.join(kikiHome(), "runtime", "logs");
71931
- import_fs13.default.mkdirSync(dir, { recursive: true });
72091
+ const dir = import_path10.default.join(kikiHome(), "runtime", "logs");
72092
+ import_fs14.default.mkdirSync(dir, { recursive: true });
71932
72093
  return dir;
71933
72094
  }
71934
72095
  function dataDir() {
71935
- const dir = import_path9.default.join(kikiHome(), "data");
71936
- import_fs13.default.mkdirSync(dir, { recursive: true });
72096
+ const dir = import_path10.default.join(kikiHome(), "data");
72097
+ import_fs14.default.mkdirSync(dir, { recursive: true });
71937
72098
  return dir;
71938
72099
  }
71939
72100
  function macPlistPath() {
71940
- return import_path9.default.join(import_os3.default.homedir(), "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
72101
+ return import_path10.default.join(import_os4.default.homedir(), "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
71941
72102
  }
71942
72103
  function linuxUnitPath() {
71943
- return import_path9.default.join(import_os3.default.homedir(), ".config", "systemd", "user", LINUX_UNIT);
72104
+ return import_path10.default.join(import_os4.default.homedir(), ".config", "systemd", "user", LINUX_UNIT);
71944
72105
  }
71945
72106
  function xmlEscape(value) {
71946
72107
  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
71947
72108
  }
72109
+ function resolveServiceEnvironment(ctx) {
72110
+ const base = ctx.environment ?? collectDaemonServiceEnv(process.env);
72111
+ return {
72112
+ ...base,
72113
+ KIKI_DATA_DIR: dataDir(),
72114
+ HOME: base.HOME || import_os4.default.homedir()
72115
+ };
72116
+ }
71948
72117
  function buildMacPlist(ctx) {
72118
+ const serviceEnv = resolveServiceEnvironment(ctx);
72119
+ const envXml = Object.entries(serviceEnv).map(([key, value]) => ` <key>${xmlEscape(key)}</key>
72120
+ <string>${xmlEscape(value)}</string>`).join("\n");
71949
72121
  const args = [
71950
72122
  ctx.nodePath,
71951
72123
  ctx.scriptPath,
@@ -71970,8 +72142,7 @@ ${argXml}
71970
72142
 
71971
72143
  <key>EnvironmentVariables</key>
71972
72144
  <dict>
71973
- <key>KIKI_DATA_DIR</key>
71974
- <string>${xmlEscape(dataDir())}</string>
72145
+ ${envXml}
71975
72146
  </dict>
71976
72147
 
71977
72148
  <key>RunAtLoad</key>
@@ -71981,16 +72152,18 @@ ${argXml}
71981
72152
  <true/>
71982
72153
 
71983
72154
  <key>StandardOutPath</key>
71984
- <string>${xmlEscape(import_path9.default.join(logsDir(), "daemon.stdout.log"))}</string>
72155
+ <string>${xmlEscape(import_path10.default.join(logsDir(), "daemon.stdout.log"))}</string>
71985
72156
 
71986
72157
  <key>StandardErrorPath</key>
71987
- <string>${xmlEscape(import_path9.default.join(logsDir(), "daemon.stderr.log"))}</string>
72158
+ <string>${xmlEscape(import_path10.default.join(logsDir(), "daemon.stderr.log"))}</string>
71988
72159
  </dict>
71989
72160
  </plist>
71990
72161
  `;
71991
72162
  }
71992
72163
  function buildLinuxUnit(ctx) {
71993
72164
  const escape = (value) => value.replaceAll("%", "%%");
72165
+ const serviceEnv = resolveServiceEnvironment(ctx);
72166
+ const envLines = Object.entries(serviceEnv).map(([key, value]) => `Environment=${key}=${escape(value)}`).join("\n");
71994
72167
  const execStart = [ctx.nodePath, ctx.scriptPath, "run", "--server-url", ctx.serverUrl, "--api-key", ctx.apiKey].map((part) => `'${part.replaceAll("'", "'\\''")}'`).join(" ");
71995
72168
  return `[Unit]
71996
72169
  Description=Kiki local execution daemon
@@ -71999,7 +72172,7 @@ Wants=network-online.target
71999
72172
 
72000
72173
  [Service]
72001
72174
  Type=simple
72002
- Environment=KIKI_DATA_DIR=${escape(dataDir())}
72175
+ ${envLines}
72003
72176
  ExecStart=${execStart}
72004
72177
  Restart=always
72005
72178
  RestartSec=5
@@ -72014,8 +72187,8 @@ async function uid() {
72014
72187
  async function installService(ctx) {
72015
72188
  if (process.platform === "darwin") {
72016
72189
  const target = macPlistPath();
72017
- import_fs13.default.mkdirSync(import_path9.default.dirname(target), { recursive: true });
72018
- import_fs13.default.writeFileSync(target, buildMacPlist(ctx), "utf8");
72190
+ import_fs14.default.mkdirSync(import_path10.default.dirname(target), { recursive: true });
72191
+ import_fs14.default.writeFileSync(target, buildMacPlist(ctx), "utf8");
72019
72192
  const id = await uid();
72020
72193
  if (!id) throw new Error("\u65E0\u6CD5\u8BC6\u522B\u5F53\u524D\u7528\u6237\uFF0C\u65E0\u6CD5\u5B89\u88C5 LaunchAgent");
72021
72194
  const domain = `gui/${id}`;
@@ -72026,11 +72199,11 @@ async function installService(ctx) {
72026
72199
  }
72027
72200
  if (process.platform === "linux") {
72028
72201
  const target = linuxUnitPath();
72029
- import_fs13.default.mkdirSync(import_path9.default.dirname(target), { recursive: true });
72030
- import_fs13.default.writeFileSync(target, buildLinuxUnit(ctx), "utf8");
72202
+ import_fs14.default.mkdirSync(import_path10.default.dirname(target), { recursive: true });
72203
+ import_fs14.default.writeFileSync(target, buildLinuxUnit(ctx), "utf8");
72031
72204
  await execFileAsync3("systemctl", ["--user", "daemon-reload"]);
72032
72205
  await execFileAsync3("systemctl", ["--user", "enable", "--now", LINUX_UNIT]);
72033
- await execFileAsync3("loginctl", ["enable-linger", import_os3.default.userInfo().username]).catch(() => void 0);
72206
+ await execFileAsync3("loginctl", ["enable-linger", import_os4.default.userInfo().username]).catch(() => void 0);
72034
72207
  return { kind: "systemd", path: target };
72035
72208
  }
72036
72209
  throw new Error(
@@ -72042,16 +72215,16 @@ async function uninstallService() {
72042
72215
  if (process.platform === "darwin") {
72043
72216
  const target = macPlistPath();
72044
72217
  const id = await uid();
72045
- if (id && import_fs13.default.existsSync(target)) {
72218
+ if (id && import_fs14.default.existsSync(target)) {
72046
72219
  await execFileAsync3("launchctl", ["bootout", `gui/${id}`, target]).catch(() => void 0);
72047
72220
  }
72048
- if (import_fs13.default.existsSync(target)) import_fs13.default.unlinkSync(target);
72221
+ if (import_fs14.default.existsSync(target)) import_fs14.default.unlinkSync(target);
72049
72222
  return { kind: "launchd", path: target };
72050
72223
  }
72051
72224
  if (process.platform === "linux") {
72052
72225
  const target = linuxUnitPath();
72053
72226
  await execFileAsync3("systemctl", ["--user", "disable", "--now", LINUX_UNIT]).catch(() => void 0);
72054
- if (import_fs13.default.existsSync(target)) import_fs13.default.unlinkSync(target);
72227
+ if (import_fs14.default.existsSync(target)) import_fs14.default.unlinkSync(target);
72055
72228
  await execFileAsync3("systemctl", ["--user", "daemon-reload"]).catch(() => void 0);
72056
72229
  return { kind: "systemd", path: target };
72057
72230
  }
@@ -72060,7 +72233,7 @@ async function uninstallService() {
72060
72233
  async function serviceStatus() {
72061
72234
  if (process.platform === "darwin") {
72062
72235
  const target = macPlistPath();
72063
- const installed = import_fs13.default.existsSync(target);
72236
+ const installed = import_fs14.default.existsSync(target);
72064
72237
  let running = false;
72065
72238
  if (installed) {
72066
72239
  const id = await uid();
@@ -72073,7 +72246,7 @@ async function serviceStatus() {
72073
72246
  }
72074
72247
  if (process.platform === "linux") {
72075
72248
  const target = linuxUnitPath();
72076
- const installed = import_fs13.default.existsSync(target);
72249
+ const installed = import_fs14.default.existsSync(target);
72077
72250
  const result = await execFileAsync3("systemctl", ["--user", "is-active", LINUX_UNIT]).catch((error) => error);
72078
72251
  const running = Boolean(result && typeof result.stdout === "string" && result.stdout.trim() === "active");
72079
72252
  return { kind: "systemd", installed, running, path: target };
@@ -72146,7 +72319,7 @@ async function main() {
72146
72319
  if (subcommand === "install") {
72147
72320
  const { serverUrl: serverUrl2, apiKey: apiKey2 } = requireConnectionArgs();
72148
72321
  const scriptPath = __filename;
72149
- if (scriptPath.includes(`${import_path10.default.sep}_npx${import_path10.default.sep}`)) {
72322
+ if (scriptPath.includes(`${import_path11.default.sep}_npx${import_path11.default.sep}`)) {
72150
72323
  console.warn(
72151
72324
  "\u26A0\uFE0F \u68C0\u6D4B\u5230\u901A\u8FC7 npx \u4E34\u65F6\u7F13\u5B58\u8FD0\u884C\uFF0C\u8BE5\u8DEF\u5F84\u53EF\u80FD\u88AB\u6E05\u7406\u5BFC\u81F4\u540E\u53F0\u670D\u52A1\u5931\u6548\u3002\n \u5EFA\u8BAE\u5148\u5168\u5C40\u5B89\u88C5\u518D install\uFF1Anpm i -g @kiki_agent/daemon && kiki-daemon install ..."
72152
72325
  );
@@ -72155,9 +72328,12 @@ async function main() {
72155
72328
  nodePath: process.execPath,
72156
72329
  scriptPath,
72157
72330
  serverUrl: serverUrl2,
72158
- apiKey: apiKey2
72331
+ apiKey: apiKey2,
72332
+ environment: collectDaemonServiceEnv(process.env)
72159
72333
  });
72334
+ const pathDirs = (collectDaemonServiceEnv(process.env).PATH || "").split(import_path11.default.delimiter).length;
72160
72335
  console.log(`\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\u540E\u53F0\u670D\u52A1\uFF08${result.kind}\uFF09\uFF1A${result.path}`);
72336
+ console.log(`\u540E\u53F0 PATH \u5DF2\u5199\u5165 ${pathDirs} \u4E2A\u76EE\u5F55\uFF08\u542B ~/.local/bin\u3001Homebrew \u7B49\u5E38\u89C1\u8DEF\u5F84\uFF09\u3002`);
72161
72337
  console.log("\u73B0\u5728\u53EF\u4EE5\u5173\u95ED\u7EC8\u7AEF\uFF0Cdaemon \u5C06\u5728\u540E\u53F0\u5E38\u9A7B\u5E76\u968F\u5F00\u673A\u81EA\u542F\u3002");
72162
72338
  console.log("\u67E5\u770B\u72B6\u6001\uFF1Akiki-daemon status");
72163
72339
  return;