semantic-release-lerna 2.4.0 → 2.4.1

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/index.js +454 -1057
  2. package/package.json +3 -7
package/dist/index.js CHANGED
@@ -1,6 +1,5 @@
1
1
 
2
2
  import { createRequire as _createRequire_ } from "node:module";
3
-
4
3
  const require = _createRequire_(import.meta.url);
5
4
 
6
5
  var __create = Object.create;
@@ -44,12 +43,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
44
43
  var require_temp_dir = __commonJS({
45
44
  "node_modules/tempy/node_modules/temp-dir/index.js"(exports, module) {
46
45
  "use strict";
47
- var fs7 = __require("fs");
46
+ var fs6 = __require("fs");
48
47
  var os3 = __require("os");
49
48
  var tempDirectorySymbol = Symbol.for("__RESOLVED_TEMP_DIRECTORY__");
50
49
  if (!global[tempDirectorySymbol]) {
51
50
  Object.defineProperty(global, tempDirectorySymbol, {
52
- value: fs7.realpathSync(os3.tmpdir())
51
+ value: fs6.realpathSync(os3.tmpdir())
53
52
  });
54
53
  }
55
54
  module.exports = global[tempDirectorySymbol];
@@ -1195,15 +1194,15 @@ var require_route = __commonJS({
1195
1194
  };
1196
1195
  }
1197
1196
  function wrapConversion(toModel, graph) {
1198
- var path19 = [graph[toModel].parent, toModel];
1197
+ var path18 = [graph[toModel].parent, toModel];
1199
1198
  var fn = conversions[graph[toModel].parent][toModel];
1200
1199
  var cur = graph[toModel].parent;
1201
1200
  while (graph[cur].parent) {
1202
- path19.unshift(graph[cur].parent);
1201
+ path18.unshift(graph[cur].parent);
1203
1202
  fn = link(conversions[graph[cur].parent][cur], fn);
1204
1203
  cur = graph[cur].parent;
1205
1204
  }
1206
- fn.conversion = path19;
1205
+ fn.conversion = path18;
1207
1206
  return fn;
1208
1207
  }
1209
1208
  module.exports = function(fromModel) {
@@ -5097,13 +5096,13 @@ var require_hosts = __commonJS({
5097
5096
  var defaults2 = {
5098
5097
  sshtemplate: ({ domain, user, project, committish }) => `git@${domain}:${user}/${project}.git${maybeJoin("#", committish)}`,
5099
5098
  sshurltemplate: ({ domain, user, project, committish }) => `git+ssh://git@${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
5100
- edittemplate: ({ domain, user, project, committish, editpath, path: path19 }) => `https://${domain}/${user}/${project}${maybeJoin("/", editpath, "/", maybeEncode(committish || "HEAD"), "/", path19)}`,
5099
+ edittemplate: ({ domain, user, project, committish, editpath, path: path18 }) => `https://${domain}/${user}/${project}${maybeJoin("/", editpath, "/", maybeEncode(committish || "HEAD"), "/", path18)}`,
5101
5100
  browsetemplate: ({ domain, user, project, committish, treepath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}`,
5102
- browsetreetemplate: ({ domain, user, project, committish, treepath, path: path19, fragment, hashformat }) => `https://${domain}/${user}/${project}/${treepath}/${maybeEncode(committish || "HEAD")}/${path19}${maybeJoin("#", hashformat(fragment || ""))}`,
5103
- browseblobtemplate: ({ domain, user, project, committish, blobpath, path: path19, fragment, hashformat }) => `https://${domain}/${user}/${project}/${blobpath}/${maybeEncode(committish || "HEAD")}/${path19}${maybeJoin("#", hashformat(fragment || ""))}`,
5101
+ browsetreetemplate: ({ domain, user, project, committish, treepath, path: path18, fragment, hashformat }) => `https://${domain}/${user}/${project}/${treepath}/${maybeEncode(committish || "HEAD")}/${path18}${maybeJoin("#", hashformat(fragment || ""))}`,
5102
+ browseblobtemplate: ({ domain, user, project, committish, blobpath, path: path18, fragment, hashformat }) => `https://${domain}/${user}/${project}/${blobpath}/${maybeEncode(committish || "HEAD")}/${path18}${maybeJoin("#", hashformat(fragment || ""))}`,
5104
5103
  docstemplate: ({ domain, user, project, treepath, committish }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}#readme`,
5105
5104
  httpstemplate: ({ auth, domain, user, project, committish }) => `git+https://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
5106
- filetemplate: ({ domain, user, project, committish, path: path19 }) => `https://${domain}/${user}/${project}/raw/${maybeEncode(committish || "HEAD")}/${path19}`,
5105
+ filetemplate: ({ domain, user, project, committish, path: path18 }) => `https://${domain}/${user}/${project}/raw/${maybeEncode(committish || "HEAD")}/${path18}`,
5107
5106
  shortcuttemplate: ({ type: type2, user, project, committish }) => `${type2}:${user}/${project}${maybeJoin("#", committish)}`,
5108
5107
  pathtemplate: ({ user, project, committish }) => `${user}/${project}${maybeJoin("#", committish)}`,
5109
5108
  bugstemplate: ({ domain, user, project }) => `https://${domain}/${user}/${project}/issues`,
@@ -5118,7 +5117,7 @@ var require_hosts = __commonJS({
5118
5117
  treepath: "tree",
5119
5118
  blobpath: "blob",
5120
5119
  editpath: "edit",
5121
- filetemplate: ({ auth, user, project, committish, path: path19 }) => `https://${maybeJoin(auth, "@")}raw.githubusercontent.com/${user}/${project}/${maybeEncode(committish || "HEAD")}/${path19}`,
5120
+ filetemplate: ({ auth, user, project, committish, path: path18 }) => `https://${maybeJoin(auth, "@")}raw.githubusercontent.com/${user}/${project}/${maybeEncode(committish || "HEAD")}/${path18}`,
5122
5121
  gittemplate: ({ auth, domain, user, project, committish }) => `git://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
5123
5122
  tarballtemplate: ({ domain, user, project, committish }) => `https://codeload.${domain}/${user}/${project}/tar.gz/${maybeEncode(committish || "HEAD")}`,
5124
5123
  extract: (url2) => {
@@ -5144,7 +5143,7 @@ var require_hosts = __commonJS({
5144
5143
  treepath: "src",
5145
5144
  blobpath: "src",
5146
5145
  editpath: "?mode=edit",
5147
- edittemplate: ({ domain, user, project, committish, treepath, path: path19, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish || "HEAD"), "/", path19, editpath)}`,
5146
+ edittemplate: ({ domain, user, project, committish, treepath, path: path18, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish || "HEAD"), "/", path18, editpath)}`,
5148
5147
  tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/get/${maybeEncode(committish || "HEAD")}.tar.gz`,
5149
5148
  extract: (url2) => {
5150
5149
  let [, user, project, aux] = url2.pathname.split("/", 4);
@@ -5169,11 +5168,11 @@ var require_hosts = __commonJS({
5169
5168
  httpstemplate: ({ auth, domain, user, project, committish }) => `git+https://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
5170
5169
  tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/repository/archive.tar.gz?ref=${maybeEncode(committish || "HEAD")}`,
5171
5170
  extract: (url2) => {
5172
- const path19 = url2.pathname.slice(1);
5173
- if (path19.includes("/-/") || path19.includes("/archive.tar.gz")) {
5171
+ const path18 = url2.pathname.slice(1);
5172
+ if (path18.includes("/-/") || path18.includes("/archive.tar.gz")) {
5174
5173
  return;
5175
5174
  }
5176
- const segments = path19.split("/");
5175
+ const segments = path18.split("/");
5177
5176
  let project = segments.pop();
5178
5177
  if (project.endsWith(".git")) {
5179
5178
  project = project.slice(0, -4);
@@ -5193,11 +5192,11 @@ var require_hosts = __commonJS({
5193
5192
  sshurltemplate: ({ domain, project, committish }) => `git+ssh://git@${domain}/${project}.git${maybeJoin("#", committish)}`,
5194
5193
  edittemplate: ({ domain, user, project, committish, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", maybeEncode(committish))}/${editpath}`,
5195
5194
  browsetemplate: ({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`,
5196
- browsetreetemplate: ({ domain, project, committish, path: path19, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path19))}`,
5197
- browseblobtemplate: ({ domain, project, committish, path: path19, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path19))}`,
5195
+ browsetreetemplate: ({ domain, project, committish, path: path18, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path18))}`,
5196
+ browseblobtemplate: ({ domain, project, committish, path: path18, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path18))}`,
5198
5197
  docstemplate: ({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`,
5199
5198
  httpstemplate: ({ domain, project, committish }) => `git+https://${domain}/${project}.git${maybeJoin("#", committish)}`,
5200
- filetemplate: ({ user, project, committish, path: path19 }) => `https://gist.githubusercontent.com/${user}/${project}/raw${maybeJoin("/", maybeEncode(committish))}/${path19}`,
5199
+ filetemplate: ({ user, project, committish, path: path18 }) => `https://gist.githubusercontent.com/${user}/${project}/raw${maybeJoin("/", maybeEncode(committish))}/${path18}`,
5201
5200
  shortcuttemplate: ({ type: type2, project, committish }) => `${type2}:${project}${maybeJoin("#", committish)}`,
5202
5201
  pathtemplate: ({ project, committish }) => `${project}${maybeJoin("#", committish)}`,
5203
5202
  bugstemplate: ({ domain, project }) => `https://${domain}/${project}`,
@@ -5229,7 +5228,7 @@ var require_hosts = __commonJS({
5229
5228
  domain: "git.sr.ht",
5230
5229
  treepath: "tree",
5231
5230
  blobpath: "tree",
5232
- filetemplate: ({ domain, user, project, committish, path: path19 }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || "HEAD"}/${path19}`,
5231
+ filetemplate: ({ domain, user, project, committish, path: path18 }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || "HEAD"}/${path18}`,
5233
5232
  httpstemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
5234
5233
  tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/archive/${maybeEncode(committish) || "HEAD"}.tar.gz`,
5235
5234
  bugstemplate: ({ user, project }) => null,
@@ -5480,25 +5479,25 @@ var require_lib4 = __commonJS({
5480
5479
  sshurl(opts) {
5481
5480
  return this.#fill(this.sshurltemplate, opts);
5482
5481
  }
5483
- browse(path19, ...args) {
5484
- if (typeof path19 !== "string") {
5485
- return this.#fill(this.browsetemplate, path19);
5482
+ browse(path18, ...args) {
5483
+ if (typeof path18 !== "string") {
5484
+ return this.#fill(this.browsetemplate, path18);
5486
5485
  }
5487
5486
  if (typeof args[0] !== "string") {
5488
- return this.#fill(this.browsetreetemplate, { ...args[0], path: path19 });
5487
+ return this.#fill(this.browsetreetemplate, { ...args[0], path: path18 });
5489
5488
  }
5490
- return this.#fill(this.browsetreetemplate, { ...args[1], fragment: args[0], path: path19 });
5489
+ return this.#fill(this.browsetreetemplate, { ...args[1], fragment: args[0], path: path18 });
5491
5490
  }
5492
5491
  // If the path is known to be a file, then browseFile should be used. For some hosts
5493
5492
  // the url is the same as browse, but for others like GitHub a file can use both `/tree/`
5494
5493
  // and `/blob/` in the path. When using a default committish of `HEAD` then the `/tree/`
5495
5494
  // path will redirect to a specific commit. Using the `/blob/` path avoids this and
5496
5495
  // does not redirect to a different commit.
5497
- browseFile(path19, ...args) {
5496
+ browseFile(path18, ...args) {
5498
5497
  if (typeof args[0] !== "string") {
5499
- return this.#fill(this.browseblobtemplate, { ...args[0], path: path19 });
5498
+ return this.#fill(this.browseblobtemplate, { ...args[0], path: path18 });
5500
5499
  }
5501
- return this.#fill(this.browseblobtemplate, { ...args[1], fragment: args[0], path: path19 });
5500
+ return this.#fill(this.browseblobtemplate, { ...args[1], fragment: args[0], path: path18 });
5502
5501
  }
5503
5502
  docs(opts) {
5504
5503
  return this.#fill(this.docstemplate, opts);
@@ -5521,11 +5520,11 @@ var require_lib4 = __commonJS({
5521
5520
  tarball(opts) {
5522
5521
  return this.#fill(this.tarballtemplate, { ...opts, noCommittish: false });
5523
5522
  }
5524
- file(path19, opts) {
5525
- return this.#fill(this.filetemplate, { ...opts, path: path19 });
5523
+ file(path18, opts) {
5524
+ return this.#fill(this.filetemplate, { ...opts, path: path18 });
5526
5525
  }
5527
- edit(path19, opts) {
5528
- return this.#fill(this.edittemplate, { ...opts, path: path19 });
5526
+ edit(path18, opts) {
5527
+ return this.#fill(this.edittemplate, { ...opts, path: path18 });
5529
5528
  }
5530
5529
  getDefaultRepresentation() {
5531
5530
  return this.default;
@@ -6480,8 +6479,8 @@ var require_windows = __commonJS({
6480
6479
  "node_modules/isexe/windows.js"(exports, module) {
6481
6480
  module.exports = isexe;
6482
6481
  isexe.sync = sync;
6483
- var fs7 = __require("fs");
6484
- function checkPathExt(path19, options) {
6482
+ var fs6 = __require("fs");
6483
+ function checkPathExt(path18, options) {
6485
6484
  var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
6486
6485
  if (!pathext) {
6487
6486
  return true;
@@ -6492,25 +6491,25 @@ var require_windows = __commonJS({
6492
6491
  }
6493
6492
  for (var i = 0; i < pathext.length; i++) {
6494
6493
  var p = pathext[i].toLowerCase();
6495
- if (p && path19.substr(-p.length).toLowerCase() === p) {
6494
+ if (p && path18.substr(-p.length).toLowerCase() === p) {
6496
6495
  return true;
6497
6496
  }
6498
6497
  }
6499
6498
  return false;
6500
6499
  }
6501
- function checkStat(stat, path19, options) {
6500
+ function checkStat(stat, path18, options) {
6502
6501
  if (!stat.isSymbolicLink() && !stat.isFile()) {
6503
6502
  return false;
6504
6503
  }
6505
- return checkPathExt(path19, options);
6504
+ return checkPathExt(path18, options);
6506
6505
  }
6507
- function isexe(path19, options, cb) {
6508
- fs7.stat(path19, function(er, stat) {
6509
- cb(er, er ? false : checkStat(stat, path19, options));
6506
+ function isexe(path18, options, cb) {
6507
+ fs6.stat(path18, function(er, stat) {
6508
+ cb(er, er ? false : checkStat(stat, path18, options));
6510
6509
  });
6511
6510
  }
6512
- function sync(path19, options) {
6513
- return checkStat(fs7.statSync(path19), path19, options);
6511
+ function sync(path18, options) {
6512
+ return checkStat(fs6.statSync(path18), path18, options);
6514
6513
  }
6515
6514
  }
6516
6515
  });
@@ -6520,14 +6519,14 @@ var require_mode = __commonJS({
6520
6519
  "node_modules/isexe/mode.js"(exports, module) {
6521
6520
  module.exports = isexe;
6522
6521
  isexe.sync = sync;
6523
- var fs7 = __require("fs");
6524
- function isexe(path19, options, cb) {
6525
- fs7.stat(path19, function(er, stat) {
6522
+ var fs6 = __require("fs");
6523
+ function isexe(path18, options, cb) {
6524
+ fs6.stat(path18, function(er, stat) {
6526
6525
  cb(er, er ? false : checkStat(stat, options));
6527
6526
  });
6528
6527
  }
6529
- function sync(path19, options) {
6530
- return checkStat(fs7.statSync(path19), options);
6528
+ function sync(path18, options) {
6529
+ return checkStat(fs6.statSync(path18), options);
6531
6530
  }
6532
6531
  function checkStat(stat, options) {
6533
6532
  return stat.isFile() && checkMode(stat, options);
@@ -6551,7 +6550,7 @@ var require_mode = __commonJS({
6551
6550
  // node_modules/isexe/index.js
6552
6551
  var require_isexe = __commonJS({
6553
6552
  "node_modules/isexe/index.js"(exports, module) {
6554
- var fs7 = __require("fs");
6553
+ var fs6 = __require("fs");
6555
6554
  var core2;
6556
6555
  if (process.platform === "win32" || global.TESTING_WINDOWS) {
6557
6556
  core2 = require_windows();
@@ -6560,7 +6559,7 @@ var require_isexe = __commonJS({
6560
6559
  }
6561
6560
  module.exports = isexe;
6562
6561
  isexe.sync = sync;
6563
- function isexe(path19, options, cb) {
6562
+ function isexe(path18, options, cb) {
6564
6563
  if (typeof options === "function") {
6565
6564
  cb = options;
6566
6565
  options = {};
@@ -6570,7 +6569,7 @@ var require_isexe = __commonJS({
6570
6569
  throw new TypeError("callback not provided");
6571
6570
  }
6572
6571
  return new Promise(function(resolve, reject) {
6573
- isexe(path19, options || {}, function(er, is) {
6572
+ isexe(path18, options || {}, function(er, is) {
6574
6573
  if (er) {
6575
6574
  reject(er);
6576
6575
  } else {
@@ -6579,7 +6578,7 @@ var require_isexe = __commonJS({
6579
6578
  });
6580
6579
  });
6581
6580
  }
6582
- core2(path19, options || {}, function(er, is) {
6581
+ core2(path18, options || {}, function(er, is) {
6583
6582
  if (er) {
6584
6583
  if (er.code === "EACCES" || options && options.ignoreErrors) {
6585
6584
  er = null;
@@ -6589,9 +6588,9 @@ var require_isexe = __commonJS({
6589
6588
  cb(er, is);
6590
6589
  });
6591
6590
  }
6592
- function sync(path19, options) {
6591
+ function sync(path18, options) {
6593
6592
  try {
6594
- return core2.sync(path19, options || {});
6593
+ return core2.sync(path18, options || {});
6595
6594
  } catch (er) {
6596
6595
  if (options && options.ignoreErrors || er.code === "EACCES") {
6597
6596
  return false;
@@ -6607,7 +6606,7 @@ var require_isexe = __commonJS({
6607
6606
  var require_which = __commonJS({
6608
6607
  "node_modules/which/which.js"(exports, module) {
6609
6608
  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
6610
- var path19 = __require("path");
6609
+ var path18 = __require("path");
6611
6610
  var COLON = isWindows ? ";" : ":";
6612
6611
  var isexe = require_isexe();
6613
6612
  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -6645,7 +6644,7 @@ var require_which = __commonJS({
6645
6644
  return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
6646
6645
  const ppRaw = pathEnv[i];
6647
6646
  const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
6648
- const pCmd = path19.join(pathPart, cmd);
6647
+ const pCmd = path18.join(pathPart, cmd);
6649
6648
  const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
6650
6649
  resolve(subStep(p, i, 0));
6651
6650
  });
@@ -6672,7 +6671,7 @@ var require_which = __commonJS({
6672
6671
  for (let i = 0; i < pathEnv.length; i++) {
6673
6672
  const ppRaw = pathEnv[i];
6674
6673
  const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
6675
- const pCmd = path19.join(pathPart, cmd);
6674
+ const pCmd = path18.join(pathPart, cmd);
6676
6675
  const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
6677
6676
  for (let j = 0; j < pathExt.length; j++) {
6678
6677
  const cur = p + pathExt[j];
@@ -6720,7 +6719,7 @@ var require_path_key = __commonJS({
6720
6719
  var require_resolveCommand = __commonJS({
6721
6720
  "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
6722
6721
  "use strict";
6723
- var path19 = __require("path");
6722
+ var path18 = __require("path");
6724
6723
  var which = require_which();
6725
6724
  var getPathKey = require_path_key();
6726
6725
  function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -6738,7 +6737,7 @@ var require_resolveCommand = __commonJS({
6738
6737
  try {
6739
6738
  resolved = which.sync(parsed.command, {
6740
6739
  path: env[getPathKey({ env })],
6741
- pathExt: withoutPathExt ? path19.delimiter : void 0
6740
+ pathExt: withoutPathExt ? path18.delimiter : void 0
6742
6741
  });
6743
6742
  } catch (e) {
6744
6743
  } finally {
@@ -6747,7 +6746,7 @@ var require_resolveCommand = __commonJS({
6747
6746
  }
6748
6747
  }
6749
6748
  if (resolved) {
6750
- resolved = path19.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
6749
+ resolved = path18.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
6751
6750
  }
6752
6751
  return resolved;
6753
6752
  }
@@ -6801,8 +6800,8 @@ var require_shebang_command = __commonJS({
6801
6800
  if (!match2) {
6802
6801
  return null;
6803
6802
  }
6804
- const [path19, argument] = match2[0].replace(/#! ?/, "").split(" ");
6805
- const binary2 = path19.split("/").pop();
6803
+ const [path18, argument] = match2[0].replace(/#! ?/, "").split(" ");
6804
+ const binary2 = path18.split("/").pop();
6806
6805
  if (binary2 === "env") {
6807
6806
  return argument;
6808
6807
  }
@@ -6815,16 +6814,16 @@ var require_shebang_command = __commonJS({
6815
6814
  var require_readShebang = __commonJS({
6816
6815
  "node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
6817
6816
  "use strict";
6818
- var fs7 = __require("fs");
6817
+ var fs6 = __require("fs");
6819
6818
  var shebangCommand = require_shebang_command();
6820
6819
  function readShebang(command) {
6821
6820
  const size = 150;
6822
6821
  const buffer = Buffer.alloc(size);
6823
6822
  let fd;
6824
6823
  try {
6825
- fd = fs7.openSync(command, "r");
6826
- fs7.readSync(fd, buffer, 0, size, 0);
6827
- fs7.closeSync(fd);
6824
+ fd = fs6.openSync(command, "r");
6825
+ fs6.readSync(fd, buffer, 0, size, 0);
6826
+ fs6.closeSync(fd);
6828
6827
  } catch (e) {
6829
6828
  }
6830
6829
  return shebangCommand(buffer.toString());
@@ -6837,7 +6836,7 @@ var require_readShebang = __commonJS({
6837
6836
  var require_parse3 = __commonJS({
6838
6837
  "node_modules/cross-spawn/lib/parse.js"(exports, module) {
6839
6838
  "use strict";
6840
- var path19 = __require("path");
6839
+ var path18 = __require("path");
6841
6840
  var resolveCommand = require_resolveCommand();
6842
6841
  var escape2 = require_escape();
6843
6842
  var readShebang = require_readShebang();
@@ -6862,7 +6861,7 @@ var require_parse3 = __commonJS({
6862
6861
  const needsShell = !isExecutableRegExp.test(commandFile);
6863
6862
  if (parsed.options.forceShell || needsShell) {
6864
6863
  const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
6865
- parsed.command = path19.normalize(parsed.command);
6864
+ parsed.command = path18.normalize(parsed.command);
6866
6865
  parsed.command = escape2.command(parsed.command);
6867
6866
  parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
6868
6867
  const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -7245,9 +7244,9 @@ var require_strip_json_comments = __commonJS({
7245
7244
  var require_utils = __commonJS({
7246
7245
  "node_modules/rc/lib/utils.js"(exports) {
7247
7246
  "use strict";
7248
- var fs7 = __require("fs");
7247
+ var fs6 = __require("fs");
7249
7248
  var ini = require_ini();
7250
- var path19 = __require("path");
7249
+ var path18 = __require("path");
7251
7250
  var stripJsonComments = require_strip_json_comments();
7252
7251
  var parse2 = exports.parse = function(content) {
7253
7252
  if (/^\s*{/.test(content))
@@ -7261,10 +7260,10 @@ var require_utils = __commonJS({
7261
7260
  for (var i in args)
7262
7261
  if ("string" !== typeof args[i])
7263
7262
  return;
7264
- var file2 = path19.join.apply(null, args);
7263
+ var file2 = path18.join.apply(null, args);
7265
7264
  var content;
7266
7265
  try {
7267
- return fs7.readFileSync(file2, "utf-8");
7266
+ return fs6.readFileSync(file2, "utf-8");
7268
7267
  } catch (err) {
7269
7268
  return;
7270
7269
  }
@@ -7299,15 +7298,15 @@ var require_utils = __commonJS({
7299
7298
  return obj;
7300
7299
  };
7301
7300
  var find = exports.find = function() {
7302
- var rel = path19.join.apply(null, [].slice.call(arguments));
7301
+ var rel = path18.join.apply(null, [].slice.call(arguments));
7303
7302
  function find2(start, rel2) {
7304
- var file2 = path19.join(start, rel2);
7303
+ var file2 = path18.join(start, rel2);
7305
7304
  try {
7306
- fs7.statSync(file2);
7305
+ fs6.statSync(file2);
7307
7306
  return file2;
7308
7307
  } catch (err) {
7309
- if (path19.dirname(start) !== start)
7310
- return find2(path19.dirname(start), rel2);
7308
+ if (path18.dirname(start) !== start)
7309
+ return find2(path18.dirname(start), rel2);
7311
7310
  }
7312
7311
  }
7313
7312
  return find2(process.cwd(), rel);
@@ -7675,571 +7674,6 @@ var require_nerf_dart = __commonJS({
7675
7674
  }
7676
7675
  });
7677
7676
 
7678
- // node_modules/imurmurhash/imurmurhash.js
7679
- var require_imurmurhash = __commonJS({
7680
- "node_modules/imurmurhash/imurmurhash.js"(exports, module) {
7681
- (function() {
7682
- var cache;
7683
- function MurmurHash3(key, seed) {
7684
- var m = this instanceof MurmurHash3 ? this : cache;
7685
- m.reset(seed);
7686
- if (typeof key === "string" && key.length > 0) {
7687
- m.hash(key);
7688
- }
7689
- if (m !== this) {
7690
- return m;
7691
- }
7692
- }
7693
- ;
7694
- MurmurHash3.prototype.hash = function(key) {
7695
- var h1, k1, i, top, len;
7696
- len = key.length;
7697
- this.len += len;
7698
- k1 = this.k1;
7699
- i = 0;
7700
- switch (this.rem) {
7701
- case 0:
7702
- k1 ^= len > i ? key.charCodeAt(i++) & 65535 : 0;
7703
- case 1:
7704
- k1 ^= len > i ? (key.charCodeAt(i++) & 65535) << 8 : 0;
7705
- case 2:
7706
- k1 ^= len > i ? (key.charCodeAt(i++) & 65535) << 16 : 0;
7707
- case 3:
7708
- k1 ^= len > i ? (key.charCodeAt(i) & 255) << 24 : 0;
7709
- k1 ^= len > i ? (key.charCodeAt(i++) & 65280) >> 8 : 0;
7710
- }
7711
- this.rem = len + this.rem & 3;
7712
- len -= this.rem;
7713
- if (len > 0) {
7714
- h1 = this.h1;
7715
- while (1) {
7716
- k1 = k1 * 11601 + (k1 & 65535) * 3432906752 & 4294967295;
7717
- k1 = k1 << 15 | k1 >>> 17;
7718
- k1 = k1 * 13715 + (k1 & 65535) * 461832192 & 4294967295;
7719
- h1 ^= k1;
7720
- h1 = h1 << 13 | h1 >>> 19;
7721
- h1 = h1 * 5 + 3864292196 & 4294967295;
7722
- if (i >= len) {
7723
- break;
7724
- }
7725
- k1 = key.charCodeAt(i++) & 65535 ^ (key.charCodeAt(i++) & 65535) << 8 ^ (key.charCodeAt(i++) & 65535) << 16;
7726
- top = key.charCodeAt(i++);
7727
- k1 ^= (top & 255) << 24 ^ (top & 65280) >> 8;
7728
- }
7729
- k1 = 0;
7730
- switch (this.rem) {
7731
- case 3:
7732
- k1 ^= (key.charCodeAt(i + 2) & 65535) << 16;
7733
- case 2:
7734
- k1 ^= (key.charCodeAt(i + 1) & 65535) << 8;
7735
- case 1:
7736
- k1 ^= key.charCodeAt(i) & 65535;
7737
- }
7738
- this.h1 = h1;
7739
- }
7740
- this.k1 = k1;
7741
- return this;
7742
- };
7743
- MurmurHash3.prototype.result = function() {
7744
- var k1, h1;
7745
- k1 = this.k1;
7746
- h1 = this.h1;
7747
- if (k1 > 0) {
7748
- k1 = k1 * 11601 + (k1 & 65535) * 3432906752 & 4294967295;
7749
- k1 = k1 << 15 | k1 >>> 17;
7750
- k1 = k1 * 13715 + (k1 & 65535) * 461832192 & 4294967295;
7751
- h1 ^= k1;
7752
- }
7753
- h1 ^= this.len;
7754
- h1 ^= h1 >>> 16;
7755
- h1 = h1 * 51819 + (h1 & 65535) * 2246770688 & 4294967295;
7756
- h1 ^= h1 >>> 13;
7757
- h1 = h1 * 44597 + (h1 & 65535) * 3266445312 & 4294967295;
7758
- h1 ^= h1 >>> 16;
7759
- return h1 >>> 0;
7760
- };
7761
- MurmurHash3.prototype.reset = function(seed) {
7762
- this.h1 = typeof seed === "number" ? seed : 0;
7763
- this.rem = this.k1 = this.len = 0;
7764
- return this;
7765
- };
7766
- cache = new MurmurHash3();
7767
- if (typeof module != "undefined") {
7768
- module.exports = MurmurHash3;
7769
- } else {
7770
- this.MurmurHash3 = MurmurHash3;
7771
- }
7772
- })();
7773
- }
7774
- });
7775
-
7776
- // node_modules/signal-exit/signals.js
7777
- var require_signals = __commonJS({
7778
- "node_modules/signal-exit/signals.js"(exports, module) {
7779
- module.exports = [
7780
- "SIGABRT",
7781
- "SIGALRM",
7782
- "SIGHUP",
7783
- "SIGINT",
7784
- "SIGTERM"
7785
- ];
7786
- if (process.platform !== "win32") {
7787
- module.exports.push(
7788
- "SIGVTALRM",
7789
- "SIGXCPU",
7790
- "SIGXFSZ",
7791
- "SIGUSR2",
7792
- "SIGTRAP",
7793
- "SIGSYS",
7794
- "SIGQUIT",
7795
- "SIGIOT"
7796
- // should detect profiler and enable/disable accordingly.
7797
- // see #21
7798
- // 'SIGPROF'
7799
- );
7800
- }
7801
- if (process.platform === "linux") {
7802
- module.exports.push(
7803
- "SIGIO",
7804
- "SIGPOLL",
7805
- "SIGPWR",
7806
- "SIGSTKFLT",
7807
- "SIGUNUSED"
7808
- );
7809
- }
7810
- }
7811
- });
7812
-
7813
- // node_modules/signal-exit/index.js
7814
- var require_signal_exit = __commonJS({
7815
- "node_modules/signal-exit/index.js"(exports, module) {
7816
- var process8 = global.process;
7817
- var processOk2 = function(process9) {
7818
- return process9 && typeof process9 === "object" && typeof process9.removeListener === "function" && typeof process9.emit === "function" && typeof process9.reallyExit === "function" && typeof process9.listeners === "function" && typeof process9.kill === "function" && typeof process9.pid === "number" && typeof process9.on === "function";
7819
- };
7820
- if (!processOk2(process8)) {
7821
- module.exports = function() {
7822
- return function() {
7823
- };
7824
- };
7825
- } else {
7826
- assert = __require("assert");
7827
- signals2 = require_signals();
7828
- isWin = /^win/i.test(process8.platform);
7829
- EE = __require("events");
7830
- if (typeof EE !== "function") {
7831
- EE = EE.EventEmitter;
7832
- }
7833
- if (process8.__signal_exit_emitter__) {
7834
- emitter = process8.__signal_exit_emitter__;
7835
- } else {
7836
- emitter = process8.__signal_exit_emitter__ = new EE();
7837
- emitter.count = 0;
7838
- emitter.emitted = {};
7839
- }
7840
- if (!emitter.infinite) {
7841
- emitter.setMaxListeners(Infinity);
7842
- emitter.infinite = true;
7843
- }
7844
- module.exports = function(cb, opts) {
7845
- if (!processOk2(global.process)) {
7846
- return function() {
7847
- };
7848
- }
7849
- assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
7850
- if (loaded === false) {
7851
- load3();
7852
- }
7853
- var ev = "exit";
7854
- if (opts && opts.alwaysLast) {
7855
- ev = "afterexit";
7856
- }
7857
- var remove = function() {
7858
- emitter.removeListener(ev, cb);
7859
- if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
7860
- unload2();
7861
- }
7862
- };
7863
- emitter.on(ev, cb);
7864
- return remove;
7865
- };
7866
- unload2 = function unload3() {
7867
- if (!loaded || !processOk2(global.process)) {
7868
- return;
7869
- }
7870
- loaded = false;
7871
- signals2.forEach(function(sig) {
7872
- try {
7873
- process8.removeListener(sig, sigListeners[sig]);
7874
- } catch (er) {
7875
- }
7876
- });
7877
- process8.emit = originalProcessEmit;
7878
- process8.reallyExit = originalProcessReallyExit;
7879
- emitter.count -= 1;
7880
- };
7881
- module.exports.unload = unload2;
7882
- emit = function emit2(event, code, signal) {
7883
- if (emitter.emitted[event]) {
7884
- return;
7885
- }
7886
- emitter.emitted[event] = true;
7887
- emitter.emit(event, code, signal);
7888
- };
7889
- sigListeners = {};
7890
- signals2.forEach(function(sig) {
7891
- sigListeners[sig] = function listener() {
7892
- if (!processOk2(global.process)) {
7893
- return;
7894
- }
7895
- var listeners = process8.listeners(sig);
7896
- if (listeners.length === emitter.count) {
7897
- unload2();
7898
- emit("exit", null, sig);
7899
- emit("afterexit", null, sig);
7900
- if (isWin && sig === "SIGHUP") {
7901
- sig = "SIGINT";
7902
- }
7903
- process8.kill(process8.pid, sig);
7904
- }
7905
- };
7906
- });
7907
- module.exports.signals = function() {
7908
- return signals2;
7909
- };
7910
- loaded = false;
7911
- load3 = function load4() {
7912
- if (loaded || !processOk2(global.process)) {
7913
- return;
7914
- }
7915
- loaded = true;
7916
- emitter.count += 1;
7917
- signals2 = signals2.filter(function(sig) {
7918
- try {
7919
- process8.on(sig, sigListeners[sig]);
7920
- return true;
7921
- } catch (er) {
7922
- return false;
7923
- }
7924
- });
7925
- process8.emit = processEmit;
7926
- process8.reallyExit = processReallyExit;
7927
- };
7928
- module.exports.load = load3;
7929
- originalProcessReallyExit = process8.reallyExit;
7930
- processReallyExit = function processReallyExit2(code) {
7931
- if (!processOk2(global.process)) {
7932
- return;
7933
- }
7934
- process8.exitCode = code || /* istanbul ignore next */
7935
- 0;
7936
- emit("exit", process8.exitCode, null);
7937
- emit("afterexit", process8.exitCode, null);
7938
- originalProcessReallyExit.call(process8, process8.exitCode);
7939
- };
7940
- originalProcessEmit = process8.emit;
7941
- processEmit = function processEmit2(ev, arg) {
7942
- if (ev === "exit" && processOk2(global.process)) {
7943
- if (arg !== void 0) {
7944
- process8.exitCode = arg;
7945
- }
7946
- var ret = originalProcessEmit.apply(this, arguments);
7947
- emit("exit", process8.exitCode, null);
7948
- emit("afterexit", process8.exitCode, null);
7949
- return ret;
7950
- } else {
7951
- return originalProcessEmit.apply(this, arguments);
7952
- }
7953
- };
7954
- }
7955
- var assert;
7956
- var signals2;
7957
- var isWin;
7958
- var EE;
7959
- var emitter;
7960
- var unload2;
7961
- var emit;
7962
- var sigListeners;
7963
- var loaded;
7964
- var load3;
7965
- var originalProcessReallyExit;
7966
- var processReallyExit;
7967
- var originalProcessEmit;
7968
- var processEmit;
7969
- }
7970
- });
7971
-
7972
- // node_modules/is-typedarray/index.js
7973
- var require_is_typedarray = __commonJS({
7974
- "node_modules/is-typedarray/index.js"(exports, module) {
7975
- module.exports = isTypedArray;
7976
- isTypedArray.strict = isStrictTypedArray;
7977
- isTypedArray.loose = isLooseTypedArray;
7978
- var toString2 = Object.prototype.toString;
7979
- var names = {
7980
- "[object Int8Array]": true,
7981
- "[object Int16Array]": true,
7982
- "[object Int32Array]": true,
7983
- "[object Uint8Array]": true,
7984
- "[object Uint8ClampedArray]": true,
7985
- "[object Uint16Array]": true,
7986
- "[object Uint32Array]": true,
7987
- "[object Float32Array]": true,
7988
- "[object Float64Array]": true
7989
- };
7990
- function isTypedArray(arr) {
7991
- return isStrictTypedArray(arr) || isLooseTypedArray(arr);
7992
- }
7993
- function isStrictTypedArray(arr) {
7994
- return arr instanceof Int8Array || arr instanceof Int16Array || arr instanceof Int32Array || arr instanceof Uint8Array || arr instanceof Uint8ClampedArray || arr instanceof Uint16Array || arr instanceof Uint32Array || arr instanceof Float32Array || arr instanceof Float64Array;
7995
- }
7996
- function isLooseTypedArray(arr) {
7997
- return names[toString2.call(arr)];
7998
- }
7999
- }
8000
- });
8001
-
8002
- // node_modules/typedarray-to-buffer/index.js
8003
- var require_typedarray_to_buffer = __commonJS({
8004
- "node_modules/typedarray-to-buffer/index.js"(exports, module) {
8005
- var isTypedArray = require_is_typedarray().strict;
8006
- module.exports = function typedarrayToBuffer(arr) {
8007
- if (isTypedArray(arr)) {
8008
- var buf = Buffer.from(arr.buffer);
8009
- if (arr.byteLength !== arr.buffer.byteLength) {
8010
- buf = buf.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);
8011
- }
8012
- return buf;
8013
- } else {
8014
- return Buffer.from(arr);
8015
- }
8016
- };
8017
- }
8018
- });
8019
-
8020
- // node_modules/write-file-atomic/index.js
8021
- var require_write_file_atomic = __commonJS({
8022
- "node_modules/write-file-atomic/index.js"(exports, module) {
8023
- "use strict";
8024
- module.exports = writeFile;
8025
- module.exports.sync = writeFileSync;
8026
- module.exports._getTmpname = getTmpname;
8027
- module.exports._cleanupOnExit = cleanupOnExit;
8028
- var fs7 = __require("fs");
8029
- var MurmurHash3 = require_imurmurhash();
8030
- var onExit2 = require_signal_exit();
8031
- var path19 = __require("path");
8032
- var isTypedArray = require_is_typedarray();
8033
- var typedArrayToBuffer = require_typedarray_to_buffer();
8034
- var { promisify: promisify3 } = __require("util");
8035
- var activeFiles = {};
8036
- var threadId = function getId() {
8037
- try {
8038
- const workerThreads = __require("worker_threads");
8039
- return workerThreads.threadId;
8040
- } catch (e) {
8041
- return 0;
8042
- }
8043
- }();
8044
- var invocations = 0;
8045
- function getTmpname(filename) {
8046
- return filename + "." + MurmurHash3(__filename).hash(String(process.pid)).hash(String(threadId)).hash(String(++invocations)).result();
8047
- }
8048
- function cleanupOnExit(tmpfile) {
8049
- return () => {
8050
- try {
8051
- fs7.unlinkSync(typeof tmpfile === "function" ? tmpfile() : tmpfile);
8052
- } catch (_) {
8053
- }
8054
- };
8055
- }
8056
- function serializeActiveFile(absoluteName) {
8057
- return new Promise((resolve) => {
8058
- if (!activeFiles[absoluteName])
8059
- activeFiles[absoluteName] = [];
8060
- activeFiles[absoluteName].push(resolve);
8061
- if (activeFiles[absoluteName].length === 1)
8062
- resolve();
8063
- });
8064
- }
8065
- function isChownErrOk(err) {
8066
- if (err.code === "ENOSYS") {
8067
- return true;
8068
- }
8069
- const nonroot = !process.getuid || process.getuid() !== 0;
8070
- if (nonroot) {
8071
- if (err.code === "EINVAL" || err.code === "EPERM") {
8072
- return true;
8073
- }
8074
- }
8075
- return false;
8076
- }
8077
- async function writeFileAsync(filename, data, options = {}) {
8078
- if (typeof options === "string") {
8079
- options = { encoding: options };
8080
- }
8081
- let fd;
8082
- let tmpfile;
8083
- const removeOnExitHandler = onExit2(cleanupOnExit(() => tmpfile));
8084
- const absoluteName = path19.resolve(filename);
8085
- try {
8086
- await serializeActiveFile(absoluteName);
8087
- const truename = await promisify3(fs7.realpath)(filename).catch(() => filename);
8088
- tmpfile = getTmpname(truename);
8089
- if (!options.mode || !options.chown) {
8090
- const stats = await promisify3(fs7.stat)(truename).catch(() => {
8091
- });
8092
- if (stats) {
8093
- if (options.mode == null) {
8094
- options.mode = stats.mode;
8095
- }
8096
- if (options.chown == null && process.getuid) {
8097
- options.chown = { uid: stats.uid, gid: stats.gid };
8098
- }
8099
- }
8100
- }
8101
- fd = await promisify3(fs7.open)(tmpfile, "w", options.mode);
8102
- if (options.tmpfileCreated) {
8103
- await options.tmpfileCreated(tmpfile);
8104
- }
8105
- if (isTypedArray(data)) {
8106
- data = typedArrayToBuffer(data);
8107
- }
8108
- if (Buffer.isBuffer(data)) {
8109
- await promisify3(fs7.write)(fd, data, 0, data.length, 0);
8110
- } else if (data != null) {
8111
- await promisify3(fs7.write)(fd, String(data), 0, String(options.encoding || "utf8"));
8112
- }
8113
- if (options.fsync !== false) {
8114
- await promisify3(fs7.fsync)(fd);
8115
- }
8116
- await promisify3(fs7.close)(fd);
8117
- fd = null;
8118
- if (options.chown) {
8119
- await promisify3(fs7.chown)(tmpfile, options.chown.uid, options.chown.gid).catch((err) => {
8120
- if (!isChownErrOk(err)) {
8121
- throw err;
8122
- }
8123
- });
8124
- }
8125
- if (options.mode) {
8126
- await promisify3(fs7.chmod)(tmpfile, options.mode).catch((err) => {
8127
- if (!isChownErrOk(err)) {
8128
- throw err;
8129
- }
8130
- });
8131
- }
8132
- await promisify3(fs7.rename)(tmpfile, truename);
8133
- } finally {
8134
- if (fd) {
8135
- await promisify3(fs7.close)(fd).catch(
8136
- /* istanbul ignore next */
8137
- () => {
8138
- }
8139
- );
8140
- }
8141
- removeOnExitHandler();
8142
- await promisify3(fs7.unlink)(tmpfile).catch(() => {
8143
- });
8144
- activeFiles[absoluteName].shift();
8145
- if (activeFiles[absoluteName].length > 0) {
8146
- activeFiles[absoluteName][0]();
8147
- } else
8148
- delete activeFiles[absoluteName];
8149
- }
8150
- }
8151
- function writeFile(filename, data, options, callback) {
8152
- if (options instanceof Function) {
8153
- callback = options;
8154
- options = {};
8155
- }
8156
- const promise = writeFileAsync(filename, data, options);
8157
- if (callback) {
8158
- promise.then(callback, callback);
8159
- }
8160
- return promise;
8161
- }
8162
- function writeFileSync(filename, data, options) {
8163
- if (typeof options === "string")
8164
- options = { encoding: options };
8165
- else if (!options)
8166
- options = {};
8167
- try {
8168
- filename = fs7.realpathSync(filename);
8169
- } catch (ex) {
8170
- }
8171
- const tmpfile = getTmpname(filename);
8172
- if (!options.mode || !options.chown) {
8173
- try {
8174
- const stats = fs7.statSync(filename);
8175
- options = Object.assign({}, options);
8176
- if (!options.mode) {
8177
- options.mode = stats.mode;
8178
- }
8179
- if (!options.chown && process.getuid) {
8180
- options.chown = { uid: stats.uid, gid: stats.gid };
8181
- }
8182
- } catch (ex) {
8183
- }
8184
- }
8185
- let fd;
8186
- const cleanup = cleanupOnExit(tmpfile);
8187
- const removeOnExitHandler = onExit2(cleanup);
8188
- let threw = true;
8189
- try {
8190
- fd = fs7.openSync(tmpfile, "w", options.mode || 438);
8191
- if (options.tmpfileCreated) {
8192
- options.tmpfileCreated(tmpfile);
8193
- }
8194
- if (isTypedArray(data)) {
8195
- data = typedArrayToBuffer(data);
8196
- }
8197
- if (Buffer.isBuffer(data)) {
8198
- fs7.writeSync(fd, data, 0, data.length, 0);
8199
- } else if (data != null) {
8200
- fs7.writeSync(fd, String(data), 0, String(options.encoding || "utf8"));
8201
- }
8202
- if (options.fsync !== false) {
8203
- fs7.fsyncSync(fd);
8204
- }
8205
- fs7.closeSync(fd);
8206
- fd = null;
8207
- if (options.chown) {
8208
- try {
8209
- fs7.chownSync(tmpfile, options.chown.uid, options.chown.gid);
8210
- } catch (err) {
8211
- if (!isChownErrOk(err)) {
8212
- throw err;
8213
- }
8214
- }
8215
- }
8216
- if (options.mode) {
8217
- try {
8218
- fs7.chmodSync(tmpfile, options.mode);
8219
- } catch (err) {
8220
- if (!isChownErrOk(err)) {
8221
- throw err;
8222
- }
8223
- }
8224
- }
8225
- fs7.renameSync(tmpfile, filename);
8226
- threw = false;
8227
- } finally {
8228
- if (fd) {
8229
- try {
8230
- fs7.closeSync(fd);
8231
- } catch (ex) {
8232
- }
8233
- }
8234
- removeOnExitHandler();
8235
- if (threw) {
8236
- cleanup();
8237
- }
8238
- }
8239
- }
8240
- }
8241
- });
8242
-
8243
7677
  // node_modules/builtins/builtins.json
8244
7678
  var require_builtins = __commonJS({
8245
7679
  "node_modules/builtins/builtins.json"(exports, module) {
@@ -10721,7 +10155,7 @@ var require_npa = __commonJS({
10721
10155
  var HostedGit;
10722
10156
  var semver3;
10723
10157
  var path_;
10724
- function path19() {
10158
+ function path18() {
10725
10159
  if (!path_)
10726
10160
  path_ = __require("path");
10727
10161
  return path_;
@@ -10866,7 +10300,7 @@ var require_npa = __commonJS({
10866
10300
  function resolvePath(where, spec) {
10867
10301
  if (isAbsolutePath.test(spec))
10868
10302
  return spec;
10869
- return path19().resolve(where, spec);
10303
+ return path18().resolve(where, spec);
10870
10304
  }
10871
10305
  function isAbsolute(dir) {
10872
10306
  if (dir[0] === "/")
@@ -10891,7 +10325,7 @@ var require_npa = __commonJS({
10891
10325
  if (isAbsolute(spec)) {
10892
10326
  res.saveSpec = "file:" + spec;
10893
10327
  } else {
10894
- res.saveSpec = "file:" + path19().relative(where, res.fetchSpec);
10328
+ res.saveSpec = "file:" + path18().relative(where, res.fetchSpec);
10895
10329
  }
10896
10330
  }
10897
10331
  return res;
@@ -15072,6 +14506,202 @@ var require_has_color = __commonJS({
15072
14506
  }
15073
14507
  });
15074
14508
 
14509
+ // node_modules/signal-exit/signals.js
14510
+ var require_signals = __commonJS({
14511
+ "node_modules/signal-exit/signals.js"(exports, module) {
14512
+ module.exports = [
14513
+ "SIGABRT",
14514
+ "SIGALRM",
14515
+ "SIGHUP",
14516
+ "SIGINT",
14517
+ "SIGTERM"
14518
+ ];
14519
+ if (process.platform !== "win32") {
14520
+ module.exports.push(
14521
+ "SIGVTALRM",
14522
+ "SIGXCPU",
14523
+ "SIGXFSZ",
14524
+ "SIGUSR2",
14525
+ "SIGTRAP",
14526
+ "SIGSYS",
14527
+ "SIGQUIT",
14528
+ "SIGIOT"
14529
+ // should detect profiler and enable/disable accordingly.
14530
+ // see #21
14531
+ // 'SIGPROF'
14532
+ );
14533
+ }
14534
+ if (process.platform === "linux") {
14535
+ module.exports.push(
14536
+ "SIGIO",
14537
+ "SIGPOLL",
14538
+ "SIGPWR",
14539
+ "SIGSTKFLT",
14540
+ "SIGUNUSED"
14541
+ );
14542
+ }
14543
+ }
14544
+ });
14545
+
14546
+ // node_modules/signal-exit/index.js
14547
+ var require_signal_exit = __commonJS({
14548
+ "node_modules/signal-exit/index.js"(exports, module) {
14549
+ var process8 = global.process;
14550
+ var processOk2 = function(process9) {
14551
+ return process9 && typeof process9 === "object" && typeof process9.removeListener === "function" && typeof process9.emit === "function" && typeof process9.reallyExit === "function" && typeof process9.listeners === "function" && typeof process9.kill === "function" && typeof process9.pid === "number" && typeof process9.on === "function";
14552
+ };
14553
+ if (!processOk2(process8)) {
14554
+ module.exports = function() {
14555
+ return function() {
14556
+ };
14557
+ };
14558
+ } else {
14559
+ assert = __require("assert");
14560
+ signals2 = require_signals();
14561
+ isWin = /^win/i.test(process8.platform);
14562
+ EE = __require("events");
14563
+ if (typeof EE !== "function") {
14564
+ EE = EE.EventEmitter;
14565
+ }
14566
+ if (process8.__signal_exit_emitter__) {
14567
+ emitter = process8.__signal_exit_emitter__;
14568
+ } else {
14569
+ emitter = process8.__signal_exit_emitter__ = new EE();
14570
+ emitter.count = 0;
14571
+ emitter.emitted = {};
14572
+ }
14573
+ if (!emitter.infinite) {
14574
+ emitter.setMaxListeners(Infinity);
14575
+ emitter.infinite = true;
14576
+ }
14577
+ module.exports = function(cb, opts) {
14578
+ if (!processOk2(global.process)) {
14579
+ return function() {
14580
+ };
14581
+ }
14582
+ assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
14583
+ if (loaded === false) {
14584
+ load3();
14585
+ }
14586
+ var ev = "exit";
14587
+ if (opts && opts.alwaysLast) {
14588
+ ev = "afterexit";
14589
+ }
14590
+ var remove = function() {
14591
+ emitter.removeListener(ev, cb);
14592
+ if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
14593
+ unload2();
14594
+ }
14595
+ };
14596
+ emitter.on(ev, cb);
14597
+ return remove;
14598
+ };
14599
+ unload2 = function unload3() {
14600
+ if (!loaded || !processOk2(global.process)) {
14601
+ return;
14602
+ }
14603
+ loaded = false;
14604
+ signals2.forEach(function(sig) {
14605
+ try {
14606
+ process8.removeListener(sig, sigListeners[sig]);
14607
+ } catch (er) {
14608
+ }
14609
+ });
14610
+ process8.emit = originalProcessEmit;
14611
+ process8.reallyExit = originalProcessReallyExit;
14612
+ emitter.count -= 1;
14613
+ };
14614
+ module.exports.unload = unload2;
14615
+ emit = function emit2(event, code, signal) {
14616
+ if (emitter.emitted[event]) {
14617
+ return;
14618
+ }
14619
+ emitter.emitted[event] = true;
14620
+ emitter.emit(event, code, signal);
14621
+ };
14622
+ sigListeners = {};
14623
+ signals2.forEach(function(sig) {
14624
+ sigListeners[sig] = function listener() {
14625
+ if (!processOk2(global.process)) {
14626
+ return;
14627
+ }
14628
+ var listeners = process8.listeners(sig);
14629
+ if (listeners.length === emitter.count) {
14630
+ unload2();
14631
+ emit("exit", null, sig);
14632
+ emit("afterexit", null, sig);
14633
+ if (isWin && sig === "SIGHUP") {
14634
+ sig = "SIGINT";
14635
+ }
14636
+ process8.kill(process8.pid, sig);
14637
+ }
14638
+ };
14639
+ });
14640
+ module.exports.signals = function() {
14641
+ return signals2;
14642
+ };
14643
+ loaded = false;
14644
+ load3 = function load4() {
14645
+ if (loaded || !processOk2(global.process)) {
14646
+ return;
14647
+ }
14648
+ loaded = true;
14649
+ emitter.count += 1;
14650
+ signals2 = signals2.filter(function(sig) {
14651
+ try {
14652
+ process8.on(sig, sigListeners[sig]);
14653
+ return true;
14654
+ } catch (er) {
14655
+ return false;
14656
+ }
14657
+ });
14658
+ process8.emit = processEmit;
14659
+ process8.reallyExit = processReallyExit;
14660
+ };
14661
+ module.exports.load = load3;
14662
+ originalProcessReallyExit = process8.reallyExit;
14663
+ processReallyExit = function processReallyExit2(code) {
14664
+ if (!processOk2(global.process)) {
14665
+ return;
14666
+ }
14667
+ process8.exitCode = code || /* istanbul ignore next */
14668
+ 0;
14669
+ emit("exit", process8.exitCode, null);
14670
+ emit("afterexit", process8.exitCode, null);
14671
+ originalProcessReallyExit.call(process8, process8.exitCode);
14672
+ };
14673
+ originalProcessEmit = process8.emit;
14674
+ processEmit = function processEmit2(ev, arg) {
14675
+ if (ev === "exit" && processOk2(global.process)) {
14676
+ if (arg !== void 0) {
14677
+ process8.exitCode = arg;
14678
+ }
14679
+ var ret = originalProcessEmit.apply(this, arguments);
14680
+ emit("exit", process8.exitCode, null);
14681
+ emit("afterexit", process8.exitCode, null);
14682
+ return ret;
14683
+ } else {
14684
+ return originalProcessEmit.apply(this, arguments);
14685
+ }
14686
+ };
14687
+ }
14688
+ var assert;
14689
+ var signals2;
14690
+ var isWin;
14691
+ var EE;
14692
+ var emitter;
14693
+ var unload2;
14694
+ var emit;
14695
+ var sigListeners;
14696
+ var loaded;
14697
+ var load3;
14698
+ var originalProcessReallyExit;
14699
+ var processReallyExit;
14700
+ var originalProcessEmit;
14701
+ var processEmit;
14702
+ }
14703
+ });
14704
+
15075
14705
  // node_modules/@lerna/validation-error/node_modules/gauge/lib/spin.js
15076
14706
  var require_spin = __commonJS({
15077
14707
  "node_modules/@lerna/validation-error/node_modules/gauge/lib/spin.js"(exports, module) {
@@ -16173,7 +15803,7 @@ var require_path = __commonJS({
16173
15803
  Object.defineProperty(exports, "__esModule", { value: true });
16174
15804
  exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
16175
15805
  var os3 = __require("os");
16176
- var path19 = __require("path");
15806
+ var path18 = __require("path");
16177
15807
  var IS_WINDOWS_PLATFORM = os3.platform() === "win32";
16178
15808
  var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
16179
15809
  var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
@@ -16185,7 +15815,7 @@ var require_path = __commonJS({
16185
15815
  }
16186
15816
  exports.unixify = unixify;
16187
15817
  function makeAbsolute(cwd, filepath) {
16188
- return path19.resolve(cwd, filepath);
15818
+ return path18.resolve(cwd, filepath);
16189
15819
  }
16190
15820
  exports.makeAbsolute = makeAbsolute;
16191
15821
  function removeLeadingDotSegment(entry) {
@@ -17506,7 +17136,7 @@ var require_braces = __commonJS({
17506
17136
  var require_constants3 = __commonJS({
17507
17137
  "node_modules/picomatch/lib/constants.js"(exports, module) {
17508
17138
  "use strict";
17509
- var path19 = __require("path");
17139
+ var path18 = __require("path");
17510
17140
  var WIN_SLASH = "\\\\/";
17511
17141
  var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
17512
17142
  var DOT_LITERAL = "\\.";
@@ -17676,7 +17306,7 @@ var require_constants3 = __commonJS({
17676
17306
  /* | */
17677
17307
  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
17678
17308
  /* \uFEFF */
17679
- SEP: path19.sep,
17309
+ SEP: path18.sep,
17680
17310
  /**
17681
17311
  * Create EXTGLOB_CHARS
17682
17312
  */
@@ -17703,7 +17333,7 @@ var require_constants3 = __commonJS({
17703
17333
  var require_utils3 = __commonJS({
17704
17334
  "node_modules/picomatch/lib/utils.js"(exports) {
17705
17335
  "use strict";
17706
- var path19 = __require("path");
17336
+ var path18 = __require("path");
17707
17337
  var win32 = process.platform === "win32";
17708
17338
  var {
17709
17339
  REGEX_BACKSLASH,
@@ -17732,7 +17362,7 @@ var require_utils3 = __commonJS({
17732
17362
  if (options && typeof options.windows === "boolean") {
17733
17363
  return options.windows;
17734
17364
  }
17735
- return win32 === true || path19.sep === "\\";
17365
+ return win32 === true || path18.sep === "\\";
17736
17366
  };
17737
17367
  exports.escapeLast = (input, char, lastIdx) => {
17738
17368
  const idx = input.lastIndexOf(char, lastIdx);
@@ -18880,7 +18510,7 @@ var require_parse5 = __commonJS({
18880
18510
  var require_picomatch = __commonJS({
18881
18511
  "node_modules/picomatch/lib/picomatch.js"(exports, module) {
18882
18512
  "use strict";
18883
- var path19 = __require("path");
18513
+ var path18 = __require("path");
18884
18514
  var scan = require_scan2();
18885
18515
  var parse2 = require_parse5();
18886
18516
  var utils = require_utils3();
@@ -18966,7 +18596,7 @@ var require_picomatch = __commonJS({
18966
18596
  };
18967
18597
  picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
18968
18598
  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
18969
- return regex.test(path19.basename(input));
18599
+ return regex.test(path18.basename(input));
18970
18600
  };
18971
18601
  picomatch.isMatch = (str2, patterns, options) => picomatch(patterns, options)(str2);
18972
18602
  picomatch.parse = (pattern, options) => {
@@ -19196,7 +18826,7 @@ var require_pattern = __commonJS({
19196
18826
  "use strict";
19197
18827
  Object.defineProperty(exports, "__esModule", { value: true });
19198
18828
  exports.removeDuplicateSlashes = exports.matchAny = exports.convertPatternsToRe = exports.makeRe = exports.getPatternParts = exports.expandBraceExpansion = exports.expandPatternsWithBraceExpansion = exports.isAffectDepthOfReadingPattern = exports.endsWithSlashGlobStar = exports.hasGlobStar = exports.getBaseDirectory = exports.isPatternRelatedToParentDirectory = exports.getPatternsOutsideCurrentDirectory = exports.getPatternsInsideCurrentDirectory = exports.getPositivePatterns = exports.getNegativePatterns = exports.isPositivePattern = exports.isNegativePattern = exports.convertToNegativePattern = exports.convertToPositivePattern = exports.isDynamicPattern = exports.isStaticPattern = void 0;
19199
- var path19 = __require("path");
18829
+ var path18 = __require("path");
19200
18830
  var globParent = require_glob_parent();
19201
18831
  var micromatch = require_micromatch();
19202
18832
  var GLOBSTAR2 = "**";
@@ -19291,7 +18921,7 @@ var require_pattern = __commonJS({
19291
18921
  }
19292
18922
  exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
19293
18923
  function isAffectDepthOfReadingPattern(pattern) {
19294
- const basename = path19.basename(pattern);
18924
+ const basename = path18.basename(pattern);
19295
18925
  return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
19296
18926
  }
19297
18927
  exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
@@ -19388,10 +19018,10 @@ var require_utils4 = __commonJS({
19388
19018
  exports.array = array;
19389
19019
  var errno = require_errno();
19390
19020
  exports.errno = errno;
19391
- var fs7 = require_fs();
19392
- exports.fs = fs7;
19393
- var path19 = require_path();
19394
- exports.path = path19;
19021
+ var fs6 = require_fs();
19022
+ exports.fs = fs6;
19023
+ var path18 = require_path();
19024
+ exports.path = path18;
19395
19025
  var pattern = require_pattern();
19396
19026
  exports.pattern = pattern;
19397
19027
  var stream2 = require_stream2();
@@ -19503,8 +19133,8 @@ var require_async = __commonJS({
19503
19133
  "use strict";
19504
19134
  Object.defineProperty(exports, "__esModule", { value: true });
19505
19135
  exports.read = void 0;
19506
- function read(path19, settings, callback) {
19507
- settings.fs.lstat(path19, (lstatError, lstat) => {
19136
+ function read(path18, settings, callback) {
19137
+ settings.fs.lstat(path18, (lstatError, lstat) => {
19508
19138
  if (lstatError !== null) {
19509
19139
  callFailureCallback(callback, lstatError);
19510
19140
  return;
@@ -19513,7 +19143,7 @@ var require_async = __commonJS({
19513
19143
  callSuccessCallback(callback, lstat);
19514
19144
  return;
19515
19145
  }
19516
- settings.fs.stat(path19, (statError, stat) => {
19146
+ settings.fs.stat(path18, (statError, stat) => {
19517
19147
  if (statError !== null) {
19518
19148
  if (settings.throwErrorOnBrokenSymbolicLink) {
19519
19149
  callFailureCallback(callback, statError);
@@ -19545,13 +19175,13 @@ var require_sync = __commonJS({
19545
19175
  "use strict";
19546
19176
  Object.defineProperty(exports, "__esModule", { value: true });
19547
19177
  exports.read = void 0;
19548
- function read(path19, settings) {
19549
- const lstat = settings.fs.lstatSync(path19);
19178
+ function read(path18, settings) {
19179
+ const lstat = settings.fs.lstatSync(path18);
19550
19180
  if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
19551
19181
  return lstat;
19552
19182
  }
19553
19183
  try {
19554
- const stat = settings.fs.statSync(path19);
19184
+ const stat = settings.fs.statSync(path18);
19555
19185
  if (settings.markSymbolicLink) {
19556
19186
  stat.isSymbolicLink = () => true;
19557
19187
  }
@@ -19573,12 +19203,12 @@ var require_fs2 = __commonJS({
19573
19203
  "use strict";
19574
19204
  Object.defineProperty(exports, "__esModule", { value: true });
19575
19205
  exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
19576
- var fs7 = __require("fs");
19206
+ var fs6 = __require("fs");
19577
19207
  exports.FILE_SYSTEM_ADAPTER = {
19578
- lstat: fs7.lstat,
19579
- stat: fs7.stat,
19580
- lstatSync: fs7.lstatSync,
19581
- statSync: fs7.statSync
19208
+ lstat: fs6.lstat,
19209
+ stat: fs6.stat,
19210
+ lstatSync: fs6.lstatSync,
19211
+ statSync: fs6.statSync
19582
19212
  };
19583
19213
  function createFileSystemAdapter(fsMethods) {
19584
19214
  if (fsMethods === void 0) {
@@ -19595,12 +19225,12 @@ var require_settings = __commonJS({
19595
19225
  "node_modules/@nodelib/fs.stat/out/settings.js"(exports) {
19596
19226
  "use strict";
19597
19227
  Object.defineProperty(exports, "__esModule", { value: true });
19598
- var fs7 = require_fs2();
19228
+ var fs6 = require_fs2();
19599
19229
  var Settings = class {
19600
19230
  constructor(_options = {}) {
19601
19231
  this._options = _options;
19602
19232
  this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
19603
- this.fs = fs7.createFileSystemAdapter(this._options.fs);
19233
+ this.fs = fs6.createFileSystemAdapter(this._options.fs);
19604
19234
  this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
19605
19235
  this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
19606
19236
  }
@@ -19622,17 +19252,17 @@ var require_out = __commonJS({
19622
19252
  var sync = require_sync();
19623
19253
  var settings_1 = require_settings();
19624
19254
  exports.Settings = settings_1.default;
19625
- function stat(path19, optionsOrSettingsOrCallback, callback) {
19255
+ function stat(path18, optionsOrSettingsOrCallback, callback) {
19626
19256
  if (typeof optionsOrSettingsOrCallback === "function") {
19627
- async.read(path19, getSettings(), optionsOrSettingsOrCallback);
19257
+ async.read(path18, getSettings(), optionsOrSettingsOrCallback);
19628
19258
  return;
19629
19259
  }
19630
- async.read(path19, getSettings(optionsOrSettingsOrCallback), callback);
19260
+ async.read(path18, getSettings(optionsOrSettingsOrCallback), callback);
19631
19261
  }
19632
19262
  exports.stat = stat;
19633
- function statSync(path19, optionsOrSettings) {
19263
+ function statSync(path18, optionsOrSettings) {
19634
19264
  const settings = getSettings(optionsOrSettings);
19635
- return sync.read(path19, settings);
19265
+ return sync.read(path18, settings);
19636
19266
  }
19637
19267
  exports.statSync = statSync;
19638
19268
  function getSettings(settingsOrOptions = {}) {
@@ -19758,8 +19388,8 @@ var require_utils5 = __commonJS({
19758
19388
  "use strict";
19759
19389
  Object.defineProperty(exports, "__esModule", { value: true });
19760
19390
  exports.fs = void 0;
19761
- var fs7 = require_fs3();
19762
- exports.fs = fs7;
19391
+ var fs6 = require_fs3();
19392
+ exports.fs = fs6;
19763
19393
  }
19764
19394
  });
19765
19395
 
@@ -19851,16 +19481,16 @@ var require_async2 = __commonJS({
19851
19481
  return;
19852
19482
  }
19853
19483
  const tasks = names.map((name) => {
19854
- const path19 = common2.joinPathSegments(directory, name, settings.pathSegmentSeparator);
19484
+ const path18 = common2.joinPathSegments(directory, name, settings.pathSegmentSeparator);
19855
19485
  return (done) => {
19856
- fsStat.stat(path19, settings.fsStatSettings, (error, stats) => {
19486
+ fsStat.stat(path18, settings.fsStatSettings, (error, stats) => {
19857
19487
  if (error !== null) {
19858
19488
  done(error);
19859
19489
  return;
19860
19490
  }
19861
19491
  const entry = {
19862
19492
  name,
19863
- path: path19,
19493
+ path: path18,
19864
19494
  dirent: utils.fs.createDirentFromStats(name, stats)
19865
19495
  };
19866
19496
  if (settings.stats) {
@@ -19954,14 +19584,14 @@ var require_fs4 = __commonJS({
19954
19584
  "use strict";
19955
19585
  Object.defineProperty(exports, "__esModule", { value: true });
19956
19586
  exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
19957
- var fs7 = __require("fs");
19587
+ var fs6 = __require("fs");
19958
19588
  exports.FILE_SYSTEM_ADAPTER = {
19959
- lstat: fs7.lstat,
19960
- stat: fs7.stat,
19961
- lstatSync: fs7.lstatSync,
19962
- statSync: fs7.statSync,
19963
- readdir: fs7.readdir,
19964
- readdirSync: fs7.readdirSync
19589
+ lstat: fs6.lstat,
19590
+ stat: fs6.stat,
19591
+ lstatSync: fs6.lstatSync,
19592
+ statSync: fs6.statSync,
19593
+ readdir: fs6.readdir,
19594
+ readdirSync: fs6.readdirSync
19965
19595
  };
19966
19596
  function createFileSystemAdapter(fsMethods) {
19967
19597
  if (fsMethods === void 0) {
@@ -19978,15 +19608,15 @@ var require_settings2 = __commonJS({
19978
19608
  "node_modules/@nodelib/fs.scandir/out/settings.js"(exports) {
19979
19609
  "use strict";
19980
19610
  Object.defineProperty(exports, "__esModule", { value: true });
19981
- var path19 = __require("path");
19611
+ var path18 = __require("path");
19982
19612
  var fsStat = require_out();
19983
- var fs7 = require_fs4();
19613
+ var fs6 = require_fs4();
19984
19614
  var Settings = class {
19985
19615
  constructor(_options = {}) {
19986
19616
  this._options = _options;
19987
19617
  this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
19988
- this.fs = fs7.createFileSystemAdapter(this._options.fs);
19989
- this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path19.sep);
19618
+ this.fs = fs6.createFileSystemAdapter(this._options.fs);
19619
+ this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path18.sep);
19990
19620
  this.stats = this._getValue(this._options.stats, false);
19991
19621
  this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
19992
19622
  this.fsStatSettings = new fsStat.Settings({
@@ -20013,17 +19643,17 @@ var require_out2 = __commonJS({
20013
19643
  var sync = require_sync2();
20014
19644
  var settings_1 = require_settings2();
20015
19645
  exports.Settings = settings_1.default;
20016
- function scandir(path19, optionsOrSettingsOrCallback, callback) {
19646
+ function scandir(path18, optionsOrSettingsOrCallback, callback) {
20017
19647
  if (typeof optionsOrSettingsOrCallback === "function") {
20018
- async.read(path19, getSettings(), optionsOrSettingsOrCallback);
19648
+ async.read(path18, getSettings(), optionsOrSettingsOrCallback);
20019
19649
  return;
20020
19650
  }
20021
- async.read(path19, getSettings(optionsOrSettingsOrCallback), callback);
19651
+ async.read(path18, getSettings(optionsOrSettingsOrCallback), callback);
20022
19652
  }
20023
19653
  exports.scandir = scandir;
20024
- function scandirSync(path19, optionsOrSettings) {
19654
+ function scandirSync(path18, optionsOrSettings) {
20025
19655
  const settings = getSettings(optionsOrSettings);
20026
- return sync.read(path19, settings);
19656
+ return sync.read(path18, settings);
20027
19657
  }
20028
19658
  exports.scandirSync = scandirSync;
20029
19659
  function getSettings(settingsOrOptions = {}) {
@@ -20551,7 +20181,7 @@ var require_settings3 = __commonJS({
20551
20181
  "node_modules/@nodelib/fs.walk/out/settings.js"(exports) {
20552
20182
  "use strict";
20553
20183
  Object.defineProperty(exports, "__esModule", { value: true });
20554
- var path19 = __require("path");
20184
+ var path18 = __require("path");
20555
20185
  var fsScandir = require_out2();
20556
20186
  var Settings = class {
20557
20187
  constructor(_options = {}) {
@@ -20561,7 +20191,7 @@ var require_settings3 = __commonJS({
20561
20191
  this.deepFilter = this._getValue(this._options.deepFilter, null);
20562
20192
  this.entryFilter = this._getValue(this._options.entryFilter, null);
20563
20193
  this.errorFilter = this._getValue(this._options.errorFilter, null);
20564
- this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path19.sep);
20194
+ this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path18.sep);
20565
20195
  this.fsScandirSettings = new fsScandir.Settings({
20566
20196
  followSymbolicLinks: this._options.followSymbolicLinks,
20567
20197
  fs: this._options.fs,
@@ -20623,7 +20253,7 @@ var require_reader2 = __commonJS({
20623
20253
  "node_modules/fast-glob/out/readers/reader.js"(exports) {
20624
20254
  "use strict";
20625
20255
  Object.defineProperty(exports, "__esModule", { value: true });
20626
- var path19 = __require("path");
20256
+ var path18 = __require("path");
20627
20257
  var fsStat = require_out();
20628
20258
  var utils = require_utils4();
20629
20259
  var Reader = class {
@@ -20636,7 +20266,7 @@ var require_reader2 = __commonJS({
20636
20266
  });
20637
20267
  }
20638
20268
  _getFullEntryPath(filepath) {
20639
- return path19.resolve(this._settings.cwd, filepath);
20269
+ return path18.resolve(this._settings.cwd, filepath);
20640
20270
  }
20641
20271
  _makeEntry(stats, pattern) {
20642
20272
  const entry = {
@@ -21030,7 +20660,7 @@ var require_provider = __commonJS({
21030
20660
  "node_modules/fast-glob/out/providers/provider.js"(exports) {
21031
20661
  "use strict";
21032
20662
  Object.defineProperty(exports, "__esModule", { value: true });
21033
- var path19 = __require("path");
20663
+ var path18 = __require("path");
21034
20664
  var deep_1 = require_deep();
21035
20665
  var entry_1 = require_entry();
21036
20666
  var error_1 = require_error2();
@@ -21044,7 +20674,7 @@ var require_provider = __commonJS({
21044
20674
  this.entryTransformer = new entry_2.default(this._settings);
21045
20675
  }
21046
20676
  _getRootDirectory(task) {
21047
- return path19.resolve(this._settings.cwd, task.base);
20677
+ return path18.resolve(this._settings.cwd, task.base);
21048
20678
  }
21049
20679
  _getReaderOptions(task) {
21050
20680
  const basePath = task.base === "." ? "" : task.base;
@@ -21225,16 +20855,16 @@ var require_settings4 = __commonJS({
21225
20855
  "use strict";
21226
20856
  Object.defineProperty(exports, "__esModule", { value: true });
21227
20857
  exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
21228
- var fs7 = __require("fs");
20858
+ var fs6 = __require("fs");
21229
20859
  var os3 = __require("os");
21230
20860
  var CPU_COUNT = Math.max(os3.cpus().length, 1);
21231
20861
  exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
21232
- lstat: fs7.lstat,
21233
- lstatSync: fs7.lstatSync,
21234
- stat: fs7.stat,
21235
- statSync: fs7.statSync,
21236
- readdir: fs7.readdir,
21237
- readdirSync: fs7.readdirSync
20862
+ lstat: fs6.lstat,
20863
+ lstatSync: fs6.lstatSync,
20864
+ stat: fs6.stat,
20865
+ statSync: fs6.statSync,
20866
+ readdir: fs6.readdir,
20867
+ readdirSync: fs6.readdirSync
21238
20868
  };
21239
20869
  var Settings = class {
21240
20870
  constructor(_options = {}) {
@@ -21385,13 +21015,13 @@ var require_path_type = __commonJS({
21385
21015
  "node_modules/path-type/index.js"(exports) {
21386
21016
  "use strict";
21387
21017
  var { promisify: promisify3 } = __require("util");
21388
- var fs7 = __require("fs");
21018
+ var fs6 = __require("fs");
21389
21019
  async function isType(fsStatType, statsMethodName, filePath) {
21390
21020
  if (typeof filePath !== "string") {
21391
21021
  throw new TypeError(`Expected a string, got ${typeof filePath}`);
21392
21022
  }
21393
21023
  try {
21394
- const stats = await promisify3(fs7[fsStatType])(filePath);
21024
+ const stats = await promisify3(fs6[fsStatType])(filePath);
21395
21025
  return stats[statsMethodName]();
21396
21026
  } catch (error) {
21397
21027
  if (error.code === "ENOENT") {
@@ -21405,7 +21035,7 @@ var require_path_type = __commonJS({
21405
21035
  throw new TypeError(`Expected a string, got ${typeof filePath}`);
21406
21036
  }
21407
21037
  try {
21408
- return fs7[fsStatType](filePath)[statsMethodName]();
21038
+ return fs6[fsStatType](filePath)[statsMethodName]();
21409
21039
  } catch (error) {
21410
21040
  if (error.code === "ENOENT") {
21411
21041
  return false;
@@ -21426,15 +21056,15 @@ var require_path_type = __commonJS({
21426
21056
  var require_dir_glob = __commonJS({
21427
21057
  "node_modules/dir-glob/index.js"(exports, module) {
21428
21058
  "use strict";
21429
- var path19 = __require("path");
21059
+ var path18 = __require("path");
21430
21060
  var pathType = require_path_type();
21431
21061
  var getExtensions = (extensions) => extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0];
21432
21062
  var getPath2 = (filepath, cwd) => {
21433
21063
  const pth = filepath[0] === "!" ? filepath.slice(1) : filepath;
21434
- return path19.isAbsolute(pth) ? pth : path19.join(cwd, pth);
21064
+ return path18.isAbsolute(pth) ? pth : path18.join(cwd, pth);
21435
21065
  };
21436
21066
  var addExtensions = (file, extensions) => {
21437
- if (path19.extname(file)) {
21067
+ if (path18.extname(file)) {
21438
21068
  return `**/${file}`;
21439
21069
  }
21440
21070
  return `**/${file}.${getExtensions(extensions)}`;
@@ -21447,15 +21077,15 @@ var require_dir_glob = __commonJS({
21447
21077
  throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
21448
21078
  }
21449
21079
  if (options.files && options.extensions) {
21450
- return options.files.map((x) => path19.posix.join(directory, addExtensions(x, options.extensions)));
21080
+ return options.files.map((x) => path18.posix.join(directory, addExtensions(x, options.extensions)));
21451
21081
  }
21452
21082
  if (options.files) {
21453
- return options.files.map((x) => path19.posix.join(directory, `**/${x}`));
21083
+ return options.files.map((x) => path18.posix.join(directory, `**/${x}`));
21454
21084
  }
21455
21085
  if (options.extensions) {
21456
- return [path19.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
21086
+ return [path18.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
21457
21087
  }
21458
- return [path19.posix.join(directory, "**")];
21088
+ return [path18.posix.join(directory, "**")];
21459
21089
  };
21460
21090
  module.exports = async (input, options) => {
21461
21091
  options = {
@@ -21701,17 +21331,17 @@ var require_ignore = __commonJS({
21701
21331
  var throwError2 = (message, Ctor) => {
21702
21332
  throw new Ctor(message);
21703
21333
  };
21704
- var checkPath = (path19, originalPath, doThrow) => {
21705
- if (!isString2(path19)) {
21334
+ var checkPath = (path18, originalPath, doThrow) => {
21335
+ if (!isString2(path18)) {
21706
21336
  return doThrow(
21707
21337
  `path must be a string, but got \`${originalPath}\``,
21708
21338
  TypeError
21709
21339
  );
21710
21340
  }
21711
- if (!path19) {
21341
+ if (!path18) {
21712
21342
  return doThrow(`path must not be empty`, TypeError);
21713
21343
  }
21714
- if (checkPath.isNotRelative(path19)) {
21344
+ if (checkPath.isNotRelative(path18)) {
21715
21345
  const r = "`path.relative()`d";
21716
21346
  return doThrow(
21717
21347
  `path should be a ${r} string, but got "${originalPath}"`,
@@ -21720,7 +21350,7 @@ var require_ignore = __commonJS({
21720
21350
  }
21721
21351
  return true;
21722
21352
  };
21723
- var isNotRelative = (path19) => REGEX_TEST_INVALID_PATH.test(path19);
21353
+ var isNotRelative = (path18) => REGEX_TEST_INVALID_PATH.test(path18);
21724
21354
  checkPath.isNotRelative = isNotRelative;
21725
21355
  checkPath.convert = (p) => p;
21726
21356
  var Ignore = class {
@@ -21779,7 +21409,7 @@ var require_ignore = __commonJS({
21779
21409
  // setting `checkUnignored` to `false` could reduce additional
21780
21410
  // path matching.
21781
21411
  // @returns {TestResult} true if a file is ignored
21782
- _testOne(path19, checkUnignored) {
21412
+ _testOne(path18, checkUnignored) {
21783
21413
  let ignored = false;
21784
21414
  let unignored = false;
21785
21415
  this._rules.forEach((rule) => {
@@ -21787,7 +21417,7 @@ var require_ignore = __commonJS({
21787
21417
  if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
21788
21418
  return;
21789
21419
  }
21790
- const matched = rule.regex.test(path19);
21420
+ const matched = rule.regex.test(path18);
21791
21421
  if (matched) {
21792
21422
  ignored = !negative;
21793
21423
  unignored = negative;
@@ -21800,24 +21430,24 @@ var require_ignore = __commonJS({
21800
21430
  }
21801
21431
  // @returns {TestResult}
21802
21432
  _test(originalPath, cache, checkUnignored, slices) {
21803
- const path19 = originalPath && checkPath.convert(originalPath);
21433
+ const path18 = originalPath && checkPath.convert(originalPath);
21804
21434
  checkPath(
21805
- path19,
21435
+ path18,
21806
21436
  originalPath,
21807
21437
  this._allowRelativePaths ? RETURN_FALSE : throwError2
21808
21438
  );
21809
- return this._t(path19, cache, checkUnignored, slices);
21439
+ return this._t(path18, cache, checkUnignored, slices);
21810
21440
  }
21811
- _t(path19, cache, checkUnignored, slices) {
21812
- if (path19 in cache) {
21813
- return cache[path19];
21441
+ _t(path18, cache, checkUnignored, slices) {
21442
+ if (path18 in cache) {
21443
+ return cache[path18];
21814
21444
  }
21815
21445
  if (!slices) {
21816
- slices = path19.split(SLASH);
21446
+ slices = path18.split(SLASH);
21817
21447
  }
21818
21448
  slices.pop();
21819
21449
  if (!slices.length) {
21820
- return cache[path19] = this._testOne(path19, checkUnignored);
21450
+ return cache[path18] = this._testOne(path18, checkUnignored);
21821
21451
  }
21822
21452
  const parent = this._t(
21823
21453
  slices.join(SLASH) + SLASH,
@@ -21825,24 +21455,24 @@ var require_ignore = __commonJS({
21825
21455
  checkUnignored,
21826
21456
  slices
21827
21457
  );
21828
- return cache[path19] = parent.ignored ? parent : this._testOne(path19, checkUnignored);
21458
+ return cache[path18] = parent.ignored ? parent : this._testOne(path18, checkUnignored);
21829
21459
  }
21830
- ignores(path19) {
21831
- return this._test(path19, this._ignoreCache, false).ignored;
21460
+ ignores(path18) {
21461
+ return this._test(path18, this._ignoreCache, false).ignored;
21832
21462
  }
21833
21463
  createFilter() {
21834
- return (path19) => !this.ignores(path19);
21464
+ return (path18) => !this.ignores(path18);
21835
21465
  }
21836
21466
  filter(paths) {
21837
21467
  return makeArray(paths).filter(this.createFilter());
21838
21468
  }
21839
21469
  // @returns {TestResult}
21840
- test(path19) {
21841
- return this._test(path19, this._testCache, true);
21470
+ test(path18) {
21471
+ return this._test(path18, this._testCache, true);
21842
21472
  }
21843
21473
  };
21844
21474
  var factory = (options) => new Ignore(options);
21845
- var isPathValid = (path19) => checkPath(path19 && checkPath.convert(path19), path19, RETURN_FALSE);
21475
+ var isPathValid = (path18) => checkPath(path18 && checkPath.convert(path18), path18, RETURN_FALSE);
21846
21476
  factory.isPathValid = isPathValid;
21847
21477
  factory.default = factory;
21848
21478
  module.exports = factory;
@@ -21853,7 +21483,7 @@ var require_ignore = __commonJS({
21853
21483
  const makePosix = (str2) => /^\\\\\?\\/.test(str2) || /["<>|\u0000-\u001F]+/u.test(str2) ? str2 : str2.replace(/\\/g, "/");
21854
21484
  checkPath.convert = makePosix;
21855
21485
  const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
21856
- checkPath.isNotRelative = (path19) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path19) || isNotRelative(path19);
21486
+ checkPath.isNotRelative = (path18) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path18) || isNotRelative(path18);
21857
21487
  }
21858
21488
  }
21859
21489
  });
@@ -21862,13 +21492,13 @@ var require_ignore = __commonJS({
21862
21492
  var require_slash = __commonJS({
21863
21493
  "node_modules/slash/index.js"(exports, module) {
21864
21494
  "use strict";
21865
- module.exports = (path19) => {
21866
- const isExtendedLengthPath = /^\\\\\?\\/.test(path19);
21867
- const hasNonAscii = /[^\u0000-\u0080]+/.test(path19);
21495
+ module.exports = (path18) => {
21496
+ const isExtendedLengthPath = /^\\\\\?\\/.test(path18);
21497
+ const hasNonAscii = /[^\u0000-\u0080]+/.test(path18);
21868
21498
  if (isExtendedLengthPath || hasNonAscii) {
21869
- return path19;
21499
+ return path18;
21870
21500
  }
21871
- return path19.replace(/\\/g, "/");
21501
+ return path18.replace(/\\/g, "/");
21872
21502
  };
21873
21503
  }
21874
21504
  });
@@ -21878,8 +21508,8 @@ var require_gitignore = __commonJS({
21878
21508
  "node_modules/globby/gitignore.js"(exports, module) {
21879
21509
  "use strict";
21880
21510
  var { promisify: promisify3 } = __require("util");
21881
- var fs7 = __require("fs");
21882
- var path19 = __require("path");
21511
+ var fs6 = __require("fs");
21512
+ var path18 = __require("path");
21883
21513
  var fastGlob = require_out4();
21884
21514
  var gitIgnore = require_ignore();
21885
21515
  var slash = require_slash();
@@ -21889,15 +21519,15 @@ var require_gitignore = __commonJS({
21889
21519
  "**/coverage/**",
21890
21520
  "**/.git"
21891
21521
  ];
21892
- var readFileP = promisify3(fs7.readFile);
21522
+ var readFileP = promisify3(fs6.readFile);
21893
21523
  var mapGitIgnorePatternTo = (base) => (ignore) => {
21894
21524
  if (ignore.startsWith("!")) {
21895
- return "!" + path19.posix.join(base, ignore.slice(1));
21525
+ return "!" + path18.posix.join(base, ignore.slice(1));
21896
21526
  }
21897
- return path19.posix.join(base, ignore);
21527
+ return path18.posix.join(base, ignore);
21898
21528
  };
21899
21529
  var parseGitIgnore = (content, options) => {
21900
- const base = slash(path19.relative(options.cwd, path19.dirname(options.fileName)));
21530
+ const base = slash(path18.relative(options.cwd, path18.dirname(options.fileName)));
21901
21531
  return content.split(/\r?\n/).filter(Boolean).filter((line) => !line.startsWith("#")).map(mapGitIgnorePatternTo(base));
21902
21532
  };
21903
21533
  var reduceIgnore = (files) => {
@@ -21912,19 +21542,19 @@ var require_gitignore = __commonJS({
21912
21542
  };
21913
21543
  var ensureAbsolutePathForCwd = (cwd, p) => {
21914
21544
  cwd = slash(cwd);
21915
- if (path19.isAbsolute(p)) {
21545
+ if (path18.isAbsolute(p)) {
21916
21546
  if (slash(p).startsWith(cwd)) {
21917
21547
  return p;
21918
21548
  }
21919
21549
  throw new Error(`Path ${p} is not in cwd ${cwd}`);
21920
21550
  }
21921
- return path19.join(cwd, p);
21551
+ return path18.join(cwd, p);
21922
21552
  };
21923
21553
  var getIsIgnoredPredecate = (ignores, cwd) => {
21924
- return (p) => ignores.ignores(slash(path19.relative(cwd, ensureAbsolutePathForCwd(cwd, p.path || p))));
21554
+ return (p) => ignores.ignores(slash(path18.relative(cwd, ensureAbsolutePathForCwd(cwd, p.path || p))));
21925
21555
  };
21926
21556
  var getFile = async (file, cwd) => {
21927
- const filePath = path19.join(cwd, file);
21557
+ const filePath = path18.join(cwd, file);
21928
21558
  const content = await readFileP(filePath, "utf8");
21929
21559
  return {
21930
21560
  cwd,
@@ -21933,8 +21563,8 @@ var require_gitignore = __commonJS({
21933
21563
  };
21934
21564
  };
21935
21565
  var getFileSync = (file, cwd) => {
21936
- const filePath = path19.join(cwd, file);
21937
- const content = fs7.readFileSync(filePath, "utf8");
21566
+ const filePath = path18.join(cwd, file);
21567
+ const content = fs6.readFileSync(filePath, "utf8");
21938
21568
  return {
21939
21569
  cwd,
21940
21570
  filePath,
@@ -22018,7 +21648,7 @@ var require_stream_utils = __commonJS({
22018
21648
  var require_globby = __commonJS({
22019
21649
  "node_modules/globby/index.js"(exports, module) {
22020
21650
  "use strict";
22021
- var fs7 = __require("fs");
21651
+ var fs6 = __require("fs");
22022
21652
  var arrayUnion = require_array_union();
22023
21653
  var merge2 = require_merge2();
22024
21654
  var fastGlob = require_out4();
@@ -22038,7 +21668,7 @@ var require_globby = __commonJS({
22038
21668
  }
22039
21669
  let stat;
22040
21670
  try {
22041
- stat = fs7.statSync(options.cwd);
21671
+ stat = fs6.statSync(options.cwd);
22042
21672
  } catch {
22043
21673
  return;
22044
21674
  }
@@ -22046,7 +21676,7 @@ var require_globby = __commonJS({
22046
21676
  throw new Error("The `cwd` option must be a path to a directory");
22047
21677
  }
22048
21678
  };
22049
- var getPathString = (p) => p.stats instanceof fs7.Stats ? p.path : p;
21679
+ var getPathString = (p) => p.stats instanceof fs6.Stats ? p.path : p;
22050
21680
  var generateGlobTasks = (patterns, taskOptions) => {
22051
21681
  patterns = arrayUnion([].concat(patterns));
22052
21682
  assertPatternsInput(patterns);
@@ -31110,7 +30740,7 @@ var require_node2 = __commonJS({
31110
30740
  "node_modules/debug/src/node.js"(exports, module) {
31111
30741
  var tty = __require("tty");
31112
30742
  var util = __require("util");
31113
- exports.init = init2;
30743
+ exports.init = init;
31114
30744
  exports.log = log4;
31115
30745
  exports.formatArgs = formatArgs;
31116
30746
  exports.save = save;
@@ -31259,7 +30889,7 @@ var require_node2 = __commonJS({
31259
30889
  function load3() {
31260
30890
  return process.env.DEBUG;
31261
30891
  }
31262
- function init2(debug2) {
30892
+ function init(debug2) {
31263
30893
  debug2.inspectOpts = {};
31264
30894
  const keys = Object.keys(exports.inspectOpts);
31265
30895
  for (let i = 0; i < keys.length; i++) {
@@ -31873,9 +31503,9 @@ function npmRunPath(options = {}) {
31873
31503
  }
31874
31504
  function npmRunPathEnv({ env = process2.env, ...options } = {}) {
31875
31505
  env = { ...env };
31876
- const path19 = pathKey({ env });
31877
- options.path = env[path19];
31878
- env[path19] = npmRunPath(options);
31506
+ const path18 = pathKey({ env });
31507
+ options.path = env[path18];
31508
+ env[path18] = npmRunPath(options);
31879
31509
  return env;
31880
31510
  }
31881
31511
 
@@ -32795,11 +32425,11 @@ import { createReadStream, readFileSync } from "node:fs";
32795
32425
  import { setTimeout as setTimeout2 } from "node:timers/promises";
32796
32426
 
32797
32427
  // node_modules/get-stream/source/contents.js
32798
- var getStreamContents = async (stream2, { init: init2, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
32428
+ var getStreamContents = async (stream2, { init, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
32799
32429
  if (!isAsyncIterable(stream2)) {
32800
32430
  throw new Error("The first argument must be a Readable, a ReadableStream, or an async iterable.");
32801
32431
  }
32802
- const state = init2();
32432
+ const state = init();
32803
32433
  state.length = 0;
32804
32434
  try {
32805
32435
  for await (const chunk of stream2) {
@@ -33479,234 +33109,17 @@ async function verifyGit(context) {
33479
33109
  }
33480
33110
 
33481
33111
  // src/prepare.js
33482
- import path14 from "node:path";
33483
- import fs5 from "node:fs/promises";
33112
+ import path13 from "node:path";
33113
+ import fs4 from "node:fs/promises";
33484
33114
  import { existsSync as existsSync2 } from "node:fs";
33485
33115
  import { format as format2 } from "node:util";
33486
- import npmVersion from "libnpmversion";
33487
-
33488
- // node_modules/write-json-file/index.js
33489
- var import_write_file_atomic = __toESM(require_write_file_atomic(), 1);
33490
- import path8 from "node:path";
33491
- import fs3, { promises as fsPromises2 } from "node:fs";
33492
-
33493
- // node_modules/write-json-file/node_modules/is-plain-obj/index.js
33494
- function isPlainObject(value) {
33495
- if (typeof value !== "object" || value === null) {
33496
- return false;
33497
- }
33498
- const prototype = Object.getPrototypeOf(value);
33499
- return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
33500
- }
33501
-
33502
- // node_modules/write-json-file/node_modules/sort-keys/index.js
33503
- function sortKeys(object, options = {}) {
33504
- if (!isPlainObject(object) && !Array.isArray(object)) {
33505
- throw new TypeError("Expected a plain object or array");
33506
- }
33507
- const { deep, compare } = options;
33508
- const seenInput = [];
33509
- const seenOutput = [];
33510
- const deepSortArray = (array) => {
33511
- const seenIndex = seenInput.indexOf(array);
33512
- if (seenIndex !== -1) {
33513
- return seenOutput[seenIndex];
33514
- }
33515
- const result = [];
33516
- seenInput.push(array);
33517
- seenOutput.push(result);
33518
- result.push(...array.map((item) => {
33519
- if (Array.isArray(item)) {
33520
- return deepSortArray(item);
33521
- }
33522
- if (isPlainObject(item)) {
33523
- return _sortKeys(item);
33524
- }
33525
- return item;
33526
- }));
33527
- return result;
33528
- };
33529
- const _sortKeys = (object2) => {
33530
- const seenIndex = seenInput.indexOf(object2);
33531
- if (seenIndex !== -1) {
33532
- return seenOutput[seenIndex];
33533
- }
33534
- const result = {};
33535
- const keys = Object.keys(object2).sort(compare);
33536
- seenInput.push(object2);
33537
- seenOutput.push(result);
33538
- for (const key of keys) {
33539
- const value = object2[key];
33540
- let newValue;
33541
- if (deep && Array.isArray(value)) {
33542
- newValue = deepSortArray(value);
33543
- } else {
33544
- newValue = deep && isPlainObject(value) ? _sortKeys(value) : value;
33545
- }
33546
- Object.defineProperty(result, key, {
33547
- ...Object.getOwnPropertyDescriptor(object2, key),
33548
- value: newValue
33549
- });
33550
- }
33551
- return result;
33552
- };
33553
- if (Array.isArray(object)) {
33554
- return deep ? deepSortArray(object) : object.slice();
33555
- }
33556
- return _sortKeys(object);
33557
- }
33558
-
33559
- // node_modules/write-json-file/node_modules/detect-indent/index.js
33560
- var INDENT_REGEX = /^(?:( )+|\t+)/;
33561
- var INDENT_TYPE_SPACE = "space";
33562
- var INDENT_TYPE_TAB = "tab";
33563
- function makeIndentsMap(string, ignoreSingleSpaces) {
33564
- const indents = /* @__PURE__ */ new Map();
33565
- let previousSize = 0;
33566
- let previousIndentType;
33567
- let key;
33568
- for (const line of string.split(/\n/g)) {
33569
- if (!line) {
33570
- continue;
33571
- }
33572
- let indent;
33573
- let indentType;
33574
- let use;
33575
- let weight;
33576
- let entry;
33577
- const matches = line.match(INDENT_REGEX);
33578
- if (matches === null) {
33579
- previousSize = 0;
33580
- previousIndentType = "";
33581
- } else {
33582
- indent = matches[0].length;
33583
- indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
33584
- if (ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && indent === 1) {
33585
- continue;
33586
- }
33587
- if (indentType !== previousIndentType) {
33588
- previousSize = 0;
33589
- }
33590
- previousIndentType = indentType;
33591
- use = 1;
33592
- weight = 0;
33593
- const indentDifference = indent - previousSize;
33594
- previousSize = indent;
33595
- if (indentDifference === 0) {
33596
- use = 0;
33597
- weight = 1;
33598
- } else {
33599
- const absoluteIndentDifference = indentDifference > 0 ? indentDifference : -indentDifference;
33600
- key = encodeIndentsKey(indentType, absoluteIndentDifference);
33601
- }
33602
- entry = indents.get(key);
33603
- entry = entry === void 0 ? [1, 0] : [entry[0] + use, entry[1] + weight];
33604
- indents.set(key, entry);
33605
- }
33606
- }
33607
- return indents;
33608
- }
33609
- function encodeIndentsKey(indentType, indentAmount) {
33610
- const typeCharacter = indentType === INDENT_TYPE_SPACE ? "s" : "t";
33611
- return typeCharacter + String(indentAmount);
33612
- }
33613
- function decodeIndentsKey(indentsKey) {
33614
- const keyHasTypeSpace = indentsKey[0] === "s";
33615
- const type2 = keyHasTypeSpace ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
33616
- const amount = Number(indentsKey.slice(1));
33617
- return { type: type2, amount };
33618
- }
33619
- function getMostUsedKey(indents) {
33620
- let result;
33621
- let maxUsed = 0;
33622
- let maxWeight = 0;
33623
- for (const [key, [usedCount, weight]] of indents) {
33624
- if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
33625
- maxUsed = usedCount;
33626
- maxWeight = weight;
33627
- result = key;
33628
- }
33629
- }
33630
- return result;
33631
- }
33632
- function makeIndentString(type2, amount) {
33633
- const indentCharacter = type2 === INDENT_TYPE_SPACE ? " " : " ";
33634
- return indentCharacter.repeat(amount);
33635
- }
33636
- function detectIndent(string) {
33637
- if (typeof string !== "string") {
33638
- throw new TypeError("Expected a string");
33639
- }
33640
- let indents = makeIndentsMap(string, true);
33641
- if (indents.size === 0) {
33642
- indents = makeIndentsMap(string, false);
33643
- }
33644
- const keyOfMostUsedIndent = getMostUsedKey(indents);
33645
- let type2;
33646
- let amount = 0;
33647
- let indent = "";
33648
- if (keyOfMostUsedIndent !== void 0) {
33649
- ({ type: type2, amount } = decodeIndentsKey(keyOfMostUsedIndent));
33650
- indent = makeIndentString(type2, amount);
33651
- }
33652
- return {
33653
- amount,
33654
- type: type2,
33655
- indent
33656
- };
33657
- }
33658
-
33659
- // node_modules/write-json-file/index.js
33660
- var init = (function_, filePath, data, options) => {
33661
- if (!filePath) {
33662
- throw new TypeError("Expected a filepath");
33663
- }
33664
- if (data === void 0) {
33665
- throw new TypeError("Expected data to stringify");
33666
- }
33667
- options = {
33668
- indent: " ",
33669
- sortKeys: false,
33670
- ...options
33671
- };
33672
- if (options.sortKeys && isPlainObject(data)) {
33673
- data = sortKeys(data, {
33674
- deep: true,
33675
- compare: typeof options.sortKeys === "function" ? options.sortKeys : void 0
33676
- });
33677
- }
33678
- return function_(filePath, data, options);
33679
- };
33680
- var main = async (filePath, data, options) => {
33681
- let { indent } = options;
33682
- let trailingNewline = "\n";
33683
- try {
33684
- const file = await fsPromises2.readFile(filePath, "utf8");
33685
- if (!file.endsWith("\n")) {
33686
- trailingNewline = "";
33687
- }
33688
- if (options.detectIndent) {
33689
- indent = detectIndent(file).indent;
33690
- }
33691
- } catch (error) {
33692
- if (error.code !== "ENOENT") {
33693
- throw error;
33694
- }
33695
- }
33696
- const json2 = JSON.stringify(data, options.replacer, indent);
33697
- return (0, import_write_file_atomic.default)(filePath, `${json2}${trailingNewline}`, { mode: options.mode, chown: false });
33698
- };
33699
- async function writeJsonFile(filePath, data, options) {
33700
- await fsPromises2.mkdir(path8.dirname(filePath), { recursive: true });
33701
- await init(main, filePath, data, options);
33702
- }
33703
-
33704
- // src/prepare.js
33705
33116
  var import_parse = __toESM(require_parse(), 1);
33117
+ import npmVersion from "libnpmversion";
33118
+ import { writeJsonFile as writeJsonFile2 } from "write-json-file";
33706
33119
 
33707
33120
  // src/lerna/package.js
33708
33121
  var import_npm_package_arg = __toESM(require_npa(), 1);
33709
- import path9 from "node:path";
33122
+ import path8 from "node:path";
33710
33123
  var PKG = Symbol("pkg");
33711
33124
  var _location = Symbol("location");
33712
33125
  var _resolved = Symbol("resolved");
@@ -33719,7 +33132,7 @@ var Package = class {
33719
33132
  * @param {string} [rootPath]
33720
33133
  */
33721
33134
  constructor(pkg, location, rootPath = location) {
33722
- const resolved = import_npm_package_arg.default.resolve(pkg.name, `file:${path9.relative(rootPath, location)}`, rootPath);
33135
+ const resolved = import_npm_package_arg.default.resolve(pkg.name, `file:${path8.relative(rootPath, location)}`, rootPath);
33723
33136
  this.name = pkg.name;
33724
33137
  this[PKG] = pkg;
33725
33138
  Object.defineProperty(this, PKG, { enumerable: false, writable: true });
@@ -33745,10 +33158,10 @@ var Package = class {
33745
33158
  return this[_scripts];
33746
33159
  }
33747
33160
  get manifestLocation() {
33748
- return path9.join(this.location, "package.json");
33161
+ return path8.join(this.location, "package.json");
33749
33162
  }
33750
33163
  get nodeModulesLocation() {
33751
- return path9.join(this.location, "node_modules");
33164
+ return path8.join(this.location, "node_modules");
33752
33165
  }
33753
33166
  // accessors
33754
33167
  get version() {
@@ -33795,9 +33208,9 @@ var Package = class {
33795
33208
  // src/lerna/project.js
33796
33209
  var import_validation_error = __toESM(require_validation_error(), 1);
33797
33210
  var import_globby = __toESM(require_globby(), 1);
33798
- import fs4 from "node:fs";
33211
+ import fs3 from "node:fs";
33799
33212
  import fsp from "node:fs/promises";
33800
- import path10 from "node:path";
33213
+ import path9 from "node:path";
33801
33214
  import { cosmiconfigSync } from "cosmiconfig";
33802
33215
 
33803
33216
  // node_modules/js-yaml/dist/js-yaml.mjs
@@ -36460,15 +35873,16 @@ var safeDump = renamed("safeDump", "dump");
36460
35873
  // src/lerna/project.js
36461
35874
  var import_npmlog = __toESM(require_log2(), 1);
36462
35875
  var import_p_map = __toESM(require_p_map(), 1);
35876
+ import { writeJsonFile } from "write-json-file";
36463
35877
  var PACKAGE_GLOB = "packages/*";
36464
35878
  async function loadJsonFile(filePath) {
36465
35879
  return JSON.parse(await fsp.readFile(filePath, "utf-8"));
36466
35880
  }
36467
35881
  function loadJsonFileSync(filePath) {
36468
- return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
35882
+ return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
36469
35883
  }
36470
35884
  function normalize(results) {
36471
- return results.map((fp) => path10.normalize(fp));
35885
+ return results.map((fp) => path9.normalize(fp));
36472
35886
  }
36473
35887
  function getGlobOpts(rootPath, packageConfigs) {
36474
35888
  const globOpts = {
@@ -36499,7 +35913,7 @@ function makeFileFinder(rootPath, packageConfigs) {
36499
35913
  const promise = (0, import_p_map.default)(
36500
35914
  Array.from(packageConfigs).sort(),
36501
35915
  (globPath) => {
36502
- let chain = (0, import_globby.default)(path10.posix.join(globPath, fileName), options);
35916
+ let chain = (0, import_globby.default)(path9.posix.join(globPath, fileName), options);
36503
35917
  chain = chain.then((results) => results.sort());
36504
35918
  chain = chain.then(normalize);
36505
35919
  if (fileMapper) {
@@ -36527,7 +35941,7 @@ var Project = class {
36527
35941
  config: {},
36528
35942
  configNotFound: true,
36529
35943
  // path.resolve(".", ...) starts from process.cwd()
36530
- filepath: path10.resolve(cwd || ".", "lerna.json")
35944
+ filepath: path9.resolve(cwd || ".", "lerna.json")
36531
35945
  };
36532
35946
  }
36533
35947
  return obj;
@@ -36545,7 +35959,7 @@ var Project = class {
36545
35959
  this.config = loaded.config;
36546
35960
  this.configNotFound = loaded.configNotFound;
36547
35961
  this.rootConfigLocation = loaded.filepath;
36548
- this.rootPath = path10.dirname(loaded.filepath);
35962
+ this.rootPath = path9.dirname(loaded.filepath);
36549
35963
  import_npmlog.default.verbose("rootPath", this.rootPath);
36550
35964
  }
36551
35965
  get version() {
@@ -36555,13 +35969,13 @@ var Project = class {
36555
35969
  this.config.version = val;
36556
35970
  }
36557
35971
  get packageConfigs() {
36558
- const pnpmConfigLocation = path10.join(this.rootPath, "pnpm-workspace.yaml");
36559
- if (fs4.existsSync(pnpmConfigLocation)) {
35972
+ const pnpmConfigLocation = path9.join(this.rootPath, "pnpm-workspace.yaml");
35973
+ if (fs3.existsSync(pnpmConfigLocation)) {
36560
35974
  import_npmlog.default.verbose(
36561
35975
  "packageConfigs",
36562
35976
  "Package manager 'pnpm' detected. Resolving packages using 'pnpm-workspace.yaml'."
36563
35977
  );
36564
- const configContent = fs4.readFileSync(pnpmConfigLocation);
35978
+ const configContent = fs3.readFileSync(pnpmConfigLocation);
36565
35979
  const { packages } = load2(configContent);
36566
35980
  if (!packages) {
36567
35981
  throw new import_validation_error.ValidationError(
@@ -36571,15 +35985,15 @@ var Project = class {
36571
35985
  }
36572
35986
  return packages;
36573
35987
  }
36574
- const npmConfigLocation = path10.join(this.rootPath, "package.json");
36575
- if (fs4.existsSync(npmConfigLocation)) {
35988
+ const npmConfigLocation = path9.join(this.rootPath, "package.json");
35989
+ if (fs3.existsSync(npmConfigLocation)) {
36576
35990
  const { workspaces } = loadJsonFileSync(npmConfigLocation);
36577
35991
  if (workspaces) {
36578
35992
  return workspaces;
36579
35993
  }
36580
35994
  }
36581
- const lernaConfigLocation = path10.join(this.rootPath, "lerna.json");
36582
- if (fs4.existsSync(lernaConfigLocation)) {
35995
+ const lernaConfigLocation = path9.join(this.rootPath, "lerna.json");
35996
+ if (fs3.existsSync(lernaConfigLocation)) {
36583
35997
  const { packages } = loadJsonFileSync(lernaConfigLocation);
36584
35998
  if (packages) {
36585
35999
  return packages;
@@ -36597,7 +36011,7 @@ var Project = class {
36597
36011
  getPackages() {
36598
36012
  const fileFinder = makeFileFinder(this.rootPath, this.packageConfigs);
36599
36013
  const mapper = (packageConfigPath) => loadJsonFile(packageConfigPath).then(
36600
- (packageJson) => new Package(packageJson, path10.dirname(packageConfigPath), this.rootPath)
36014
+ (packageJson) => new Package(packageJson, path9.dirname(packageConfigPath), this.rootPath)
36601
36015
  );
36602
36016
  return fileFinder("package.json", (filePaths) => (0, import_p_map.default)(filePaths, mapper, { concurrency: 50 }));
36603
36017
  }
@@ -36820,7 +36234,7 @@ function hasTags(opts) {
36820
36234
  }
36821
36235
 
36822
36236
  // src/utils/make-diff-predicate.js
36823
- import path12 from "node:path/posix";
36237
+ import path11 from "node:path/posix";
36824
36238
  var import_npmlog3 = __toESM(require_log2(), 1);
36825
36239
 
36826
36240
  // node_modules/minimatch/dist/mjs/index.js
@@ -37492,11 +36906,11 @@ var qmarksTestNoExtDot = ([$0]) => {
37492
36906
  return (f) => f.length === len && f !== "." && f !== "..";
37493
36907
  };
37494
36908
  var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
37495
- var path11 = {
36909
+ var path10 = {
37496
36910
  win32: { sep: "\\" },
37497
36911
  posix: { sep: "/" }
37498
36912
  };
37499
- var sep = defaultPlatform === "win32" ? path11.win32.sep : path11.posix.sep;
36913
+ var sep = defaultPlatform === "win32" ? path10.win32.sep : path10.posix.sep;
37500
36914
  minimatch.sep = sep;
37501
36915
  var GLOBSTAR = Symbol("globstar **");
37502
36916
  minimatch.GLOBSTAR = GLOBSTAR;
@@ -38184,7 +37598,7 @@ function makeDiffPredicate(committish, execOpts, ignorePatterns = []) {
38184
37598
  }
38185
37599
  function diffSinceIn(committish, location, opts) {
38186
37600
  const args = ["diff", "--name-only", committish];
38187
- const formattedLocation = path12.relative(opts.cwd, location);
37601
+ const formattedLocation = path11.relative(opts.cwd, location);
38188
37602
  if (formattedLocation) {
38189
37603
  args.push("--", formattedLocation);
38190
37604
  }
@@ -38266,7 +37680,7 @@ async function getChangedPackages(latch, context) {
38266
37680
  }
38267
37681
 
38268
37682
  // src/utils/package-manager-commands.js
38269
- import path13 from "node:path";
37683
+ import path12 from "node:path";
38270
37684
  import { existsSync } from "node:fs";
38271
37685
  var packageManagerConfigurations = [
38272
37686
  {
@@ -38292,7 +37706,7 @@ var packageManagerConfigurations = [
38292
37706
  }
38293
37707
  ];
38294
37708
  function getPackageManagerFromLockFile(location) {
38295
- return packageManagerConfigurations.find(({ lockFile }) => existsSync(path13.join(location, lockFile)))?.packageManager ?? "npm";
37709
+ return packageManagerConfigurations.find(({ lockFile }) => existsSync(path12.join(location, lockFile)))?.packageManager ?? "npm";
38296
37710
  }
38297
37711
  function getLockFileFromPackageManager(packageManager) {
38298
37712
  return packageManagerConfiguration(packageManager).lockFile;
@@ -38314,8 +37728,8 @@ function getUpdateLockFileCommand(packageManager, npmrc2) {
38314
37728
  }
38315
37729
 
38316
37730
  // src/prepare.js
38317
- async function readJson(path19) {
38318
- return JSON.parse(await fs5.readFile(path19));
37731
+ async function readJson(path18) {
37732
+ return JSON.parse(await fs4.readFile(path18));
38319
37733
  }
38320
37734
  async function updateLernaJson(basePath, context) {
38321
37735
  const {
@@ -38352,7 +37766,7 @@ async function updateLockfile(npmrc2, pkg, context) {
38352
37766
  const { env, stdout, stderr, logger } = context;
38353
37767
  const packageManager = getPackageManagerFromLockFile(pkg.location);
38354
37768
  const packageFile = getLockFileFromPackageManager(packageManager);
38355
- if (!existsSync2(path14.join(pkg.location, packageFile))) {
37769
+ if (!existsSync2(path13.join(pkg.location, packageFile))) {
38356
37770
  return;
38357
37771
  }
38358
37772
  const [command, ...options] = getUpdateLockFileCommand(packageManager, npmrc2);
@@ -38398,7 +37812,7 @@ async function updatePackageDependencies(pkg, newVersion, currentVersions) {
38398
37812
  bumpDependency(pkgData.dependencies || {}, newVersion, currentVersions);
38399
37813
  bumpDependency(pkgData.devDependencies || {}, newVersion, currentVersions);
38400
37814
  bumpDependency(pkgData.peerDependencies || {}, newVersion, currentVersions);
38401
- await writeJsonFile(pkg.manifestLocation, pkgData, { indent: 2, detectIndent: true });
37815
+ await writeJsonFile2(pkg.manifestLocation, pkgData, { indent: 2, detectIndent: true });
38402
37816
  }
38403
37817
  async function getCurrentVersion(pkg) {
38404
37818
  const pkgData = await readJson(pkg.manifestLocation);
@@ -38410,8 +37824,8 @@ async function prepare_default(npmrc2, pluginConfig, context) {
38410
37824
  nextRelease: { version },
38411
37825
  logger
38412
37826
  } = context;
38413
- const basePath = pluginConfig.pkgRoot ? path14.resolve(cwd, pluginConfig.pkgRoot) : cwd;
38414
- const rootPkg = new Package(readJson(path14.join(basePath, "package.json")), basePath);
37827
+ const basePath = pluginConfig.pkgRoot ? path13.resolve(cwd, pluginConfig.pkgRoot) : cwd;
37828
+ const rootPkg = new Package(readJson(path13.join(basePath, "package.json")), basePath);
38415
37829
  const { rootVersion = true } = pluginConfig;
38416
37830
  const changed = await getChangedPackages(pluginConfig.latch, { cwd, logger, version });
38417
37831
  if (changed.length === 0) {
@@ -38439,9 +37853,6 @@ async function prepare_default(npmrc2, pluginConfig, context) {
38439
37853
  }
38440
37854
  }
38441
37855
 
38442
- // src/publish.js
38443
- import { createRequire } from "node:module";
38444
-
38445
37856
  // src/get-channel.js
38446
37857
  var import_semver2 = __toESM(require_semver2(), 1);
38447
37858
  function get_channel_default(channel) {
@@ -38666,8 +38077,7 @@ async function publish_default(npmrc2, config, pkg, context) {
38666
38077
  const registry = get_registry_default(pkg, context);
38667
38078
  const distTag = get_channel_default(channel);
38668
38079
  logger.log("Publishing version %s to npm registry", version);
38669
- const require2 = createRequire(import.meta.url);
38670
- const lerna = require2.resolve("lerna/cli");
38080
+ const lerna = __require.resolve("lerna/cli");
38671
38081
  const result = execa(
38672
38082
  "node",
38673
38083
  // prettier-ignore
@@ -38752,16 +38162,16 @@ import writer from "conventional-changelog-writer";
38752
38162
  import filter2 from "conventional-commits-filter";
38753
38163
 
38754
38164
  // node_modules/read-pkg-up/index.js
38755
- import path18 from "node:path";
38165
+ import path17 from "node:path";
38756
38166
 
38757
38167
  // node_modules/read-pkg-up/node_modules/find-up/index.js
38758
- import path16 from "node:path";
38168
+ import path15 from "node:path";
38759
38169
  import { fileURLToPath as fileURLToPath3 } from "node:url";
38760
38170
 
38761
38171
  // node_modules/read-pkg-up/node_modules/locate-path/index.js
38762
38172
  import process7 from "node:process";
38763
- import path15 from "node:path";
38764
- import fs6, { promises as fsPromises3 } from "node:fs";
38173
+ import path14 from "node:path";
38174
+ import fs5, { promises as fsPromises2 } from "node:fs";
38765
38175
  import { fileURLToPath as fileURLToPath2 } from "node:url";
38766
38176
 
38767
38177
  // node_modules/read-pkg-up/node_modules/yocto-queue/index.js
@@ -38921,10 +38331,10 @@ async function locatePath(paths, {
38921
38331
  } = {}) {
38922
38332
  checkType(type2);
38923
38333
  cwd = toPath2(cwd);
38924
- const statFunction = allowSymlinks ? fsPromises3.stat : fsPromises3.lstat;
38334
+ const statFunction = allowSymlinks ? fsPromises2.stat : fsPromises2.lstat;
38925
38335
  return pLocate(paths, async (path_) => {
38926
38336
  try {
38927
- const stat = await statFunction(path15.resolve(cwd, path_));
38337
+ const stat = await statFunction(path14.resolve(cwd, path_));
38928
38338
  return matchType(type2, stat);
38929
38339
  } catch {
38930
38340
  return false;
@@ -38936,9 +38346,9 @@ async function locatePath(paths, {
38936
38346
  var toPath3 = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath3(urlOrPath) : urlOrPath;
38937
38347
  var findUpStop = Symbol("findUpStop");
38938
38348
  async function findUpMultiple(name, options = {}) {
38939
- let directory = path16.resolve(toPath3(options.cwd) || "");
38940
- const { root } = path16.parse(directory);
38941
- const stopAt = path16.resolve(directory, options.stopAt || root);
38349
+ let directory = path15.resolve(toPath3(options.cwd) || "");
38350
+ const { root } = path15.parse(directory);
38351
+ const stopAt = path15.resolve(directory, options.stopAt || root);
38942
38352
  const limit = options.limit || Number.POSITIVE_INFINITY;
38943
38353
  const paths = [name].flat();
38944
38354
  const runMatcher = async (locateOptions) => {
@@ -38958,12 +38368,12 @@ async function findUpMultiple(name, options = {}) {
38958
38368
  break;
38959
38369
  }
38960
38370
  if (foundPath) {
38961
- matches.push(path16.resolve(directory, foundPath));
38371
+ matches.push(path15.resolve(directory, foundPath));
38962
38372
  }
38963
38373
  if (directory === stopAt || matches.length >= limit) {
38964
38374
  break;
38965
38375
  }
38966
- directory = path16.dirname(directory);
38376
+ directory = path15.dirname(directory);
38967
38377
  }
38968
38378
  return matches;
38969
38379
  }
@@ -38973,8 +38383,8 @@ async function findUp(name, options = {}) {
38973
38383
  }
38974
38384
 
38975
38385
  // node_modules/read-pkg-up/node_modules/read-pkg/index.js
38976
- import fsPromises4 from "node:fs/promises";
38977
- import path17 from "node:path";
38386
+ import fsPromises3 from "node:fs/promises";
38387
+ import path16 from "node:path";
38978
38388
  import { fileURLToPath as fileURLToPath4 } from "node:url";
38979
38389
 
38980
38390
  // node_modules/read-pkg-up/node_modules/parse-json/index.js
@@ -39097,7 +38507,7 @@ function parseJson2(string, reviver, filename) {
39097
38507
  // node_modules/read-pkg-up/node_modules/read-pkg/index.js
39098
38508
  var import_normalize_package_data2 = __toESM(require_normalize(), 1);
39099
38509
  var toPath4 = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath4(urlOrPath) : urlOrPath;
39100
- var getPackagePath2 = (cwd) => path17.resolve(toPath4(cwd) ?? ".", "package.json");
38510
+ var getPackagePath2 = (cwd) => path16.resolve(toPath4(cwd) ?? ".", "package.json");
39101
38511
  var _readPackage2 = (file, normalize2) => {
39102
38512
  const json2 = typeof file === "string" ? parseJson2(file) : file;
39103
38513
  if (normalize2) {
@@ -39106,7 +38516,7 @@ var _readPackage2 = (file, normalize2) => {
39106
38516
  return json2;
39107
38517
  };
39108
38518
  async function readPackage2({ cwd, normalize: normalize2 = true } = {}) {
39109
- const packageFile = await fsPromises4.readFile(getPackagePath2(cwd), "utf8");
38519
+ const packageFile = await fsPromises3.readFile(getPackagePath2(cwd), "utf8");
39110
38520
  return _readPackage2(packageFile, normalize2);
39111
38521
  }
39112
38522
 
@@ -39117,7 +38527,7 @@ async function readPackageUp(options) {
39117
38527
  return;
39118
38528
  }
39119
38529
  return {
39120
- packageJson: await readPackage2({ ...options, cwd: path18.dirname(filePath) }),
38530
+ packageJson: await readPackage2({ ...options, cwd: path17.dirname(filePath) }),
39121
38531
  path: filePath
39122
38532
  };
39123
38533
  }
@@ -39149,12 +38559,12 @@ async function generateNotes(pluginConfig, context) {
39149
38559
  }
39150
38560
  return parsedCommit;
39151
38561
  }
39152
- const [match2, auth, host, path19] = (
38562
+ const [match2, auth, host, path18] = (
39153
38563
  /* eslint-disable-next-line security/detect-unsafe-regex -- technical debt */
39154
38564
  /^(?!.+:\/\/)(?:(?<auth>.*)@)?(?<host>.*?):(?<path>.*)$/.exec(repositoryUrl) || []
39155
38565
  );
39156
38566
  const authString = auth ? `${auth}@` : "";
39157
- const url2 = new URL(match2 ? `ssh://${authString}${host}/${path19}` : repositoryUrl);
38567
+ const url2 = new URL(match2 ? `ssh://${authString}${host}/${path18}` : repositoryUrl);
39158
38568
  const { hostname, pathname } = url2;
39159
38569
  let { port, protocol } = url2;
39160
38570
  port = protocol.includes("ssh") ? "" : port;
@@ -39316,19 +38726,6 @@ deep-extend/lib/deep-extend.js:
39316
38726
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
39317
38727
  *)
39318
38728
 
39319
- imurmurhash/imurmurhash.js:
39320
- (**
39321
- * @preserve
39322
- * JS Implementation of incremental MurmurHash3 (r150) (as of May 10, 2013)
39323
- *
39324
- * @author <a href="mailto:jensyt@gmail.com">Jens Taylor</a>
39325
- * @see http://github.com/homebrewing/brauhaus-diff
39326
- * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
39327
- * @see http://github.com/garycourt/murmurhash-js
39328
- * @author <a href="mailto:aappleby@gmail.com">Austin Appleby</a>
39329
- * @see http://sites.google.com/site/murmurhash/
39330
- *)
39331
-
39332
38729
  is-extglob/index.js:
39333
38730
  (*!
39334
38731
  * is-extglob <https://github.com/jonschlinkert/is-extglob>