@modern-js/upgrade 2.67.6 → 2.67.7

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 +669 -601
  2. package/package.json +5 -5
package/dist/index.js CHANGED
@@ -1038,7 +1038,7 @@ var require_command = __commonJS({
1038
1038
  "use strict";
1039
1039
  var EventEmitter3 = require("events").EventEmitter;
1040
1040
  var childProcess = require("child_process");
1041
- var path8 = require("path");
1041
+ var path9 = require("path");
1042
1042
  var fs2 = require("fs");
1043
1043
  var process2 = require("process");
1044
1044
  var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -1877,10 +1877,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
1877
1877
  let launchWithNode = false;
1878
1878
  const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
1879
1879
  function findFile(baseDir, baseName) {
1880
- const localBin = path8.resolve(baseDir, baseName);
1880
+ const localBin = path9.resolve(baseDir, baseName);
1881
1881
  if (fs2.existsSync(localBin))
1882
1882
  return localBin;
1883
- if (sourceExt.includes(path8.extname(baseName)))
1883
+ if (sourceExt.includes(path9.extname(baseName)))
1884
1884
  return void 0;
1885
1885
  const foundExt = sourceExt.find((ext) => fs2.existsSync(`${localBin}${ext}`));
1886
1886
  if (foundExt)
@@ -1898,19 +1898,19 @@ Expecting one of '${allowedValues.join("', '")}'`);
1898
1898
  } catch (err) {
1899
1899
  resolvedScriptPath = this._scriptPath;
1900
1900
  }
1901
- executableDir = path8.resolve(path8.dirname(resolvedScriptPath), executableDir);
1901
+ executableDir = path9.resolve(path9.dirname(resolvedScriptPath), executableDir);
1902
1902
  }
1903
1903
  if (executableDir) {
1904
1904
  let localFile = findFile(executableDir, executableFile);
1905
1905
  if (!localFile && !subcommand._executableFile && this._scriptPath) {
1906
- const legacyName = path8.basename(this._scriptPath, path8.extname(this._scriptPath));
1906
+ const legacyName = path9.basename(this._scriptPath, path9.extname(this._scriptPath));
1907
1907
  if (legacyName !== this._name) {
1908
1908
  localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
1909
1909
  }
1910
1910
  }
1911
1911
  executableFile = localFile || executableFile;
1912
1912
  }
1913
- launchWithNode = sourceExt.includes(path8.extname(executableFile));
1913
+ launchWithNode = sourceExt.includes(path9.extname(executableFile));
1914
1914
  let proc;
1915
1915
  if (process2.platform !== "win32") {
1916
1916
  if (launchWithNode) {
@@ -2705,7 +2705,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
2705
2705
  * @return {Command}
2706
2706
  */
2707
2707
  nameFromFilename(filename) {
2708
- this._name = path8.basename(filename, path8.extname(filename));
2708
+ this._name = path9.basename(filename, path9.extname(filename));
2709
2709
  return this;
2710
2710
  }
2711
2711
  /**
@@ -2719,10 +2719,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
2719
2719
  * @param {string} [path]
2720
2720
  * @return {string|Command}
2721
2721
  */
2722
- executableDir(path9) {
2723
- if (path9 === void 0)
2722
+ executableDir(path10) {
2723
+ if (path10 === void 0)
2724
2724
  return this._executableDir;
2725
- this._executableDir = path9;
2725
+ this._executableDir = path10;
2726
2726
  return this;
2727
2727
  }
2728
2728
  /**
@@ -4249,11 +4249,11 @@ var require_lodash = __commonJS({
4249
4249
  return isFunction2(object[key]);
4250
4250
  });
4251
4251
  }
4252
- function baseGet(object, path8) {
4253
- path8 = castPath(path8, object);
4254
- var index = 0, length = path8.length;
4252
+ function baseGet(object, path9) {
4253
+ path9 = castPath(path9, object);
4254
+ var index = 0, length = path9.length;
4255
4255
  while (object != null && index < length) {
4256
- object = object[toKey(path8[index++])];
4256
+ object = object[toKey(path9[index++])];
4257
4257
  }
4258
4258
  return index && index == length ? object : undefined2;
4259
4259
  }
@@ -4317,10 +4317,10 @@ var require_lodash = __commonJS({
4317
4317
  });
4318
4318
  return accumulator;
4319
4319
  }
4320
- function baseInvoke(object, path8, args) {
4321
- path8 = castPath(path8, object);
4322
- object = parent(object, path8);
4323
- var func = object == null ? object : object[toKey(last(path8))];
4320
+ function baseInvoke(object, path9, args) {
4321
+ path9 = castPath(path9, object);
4322
+ object = parent(object, path9);
4323
+ var func = object == null ? object : object[toKey(last(path9))];
4324
4324
  return func == null ? undefined2 : apply(func, object, args);
4325
4325
  }
4326
4326
  function baseIsArguments(value) {
@@ -4476,13 +4476,13 @@ var require_lodash = __commonJS({
4476
4476
  return object === source || baseIsMatch(object, source, matchData);
4477
4477
  };
4478
4478
  }
4479
- function baseMatchesProperty(path8, srcValue) {
4480
- if (isKey(path8) && isStrictComparable(srcValue)) {
4481
- return matchesStrictComparable(toKey(path8), srcValue);
4479
+ function baseMatchesProperty(path9, srcValue) {
4480
+ if (isKey(path9) && isStrictComparable(srcValue)) {
4481
+ return matchesStrictComparable(toKey(path9), srcValue);
4482
4482
  }
4483
4483
  return function(object) {
4484
- var objValue = get2(object, path8);
4485
- return objValue === undefined2 && objValue === srcValue ? hasIn(object, path8) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
4484
+ var objValue = get2(object, path9);
4485
+ return objValue === undefined2 && objValue === srcValue ? hasIn(object, path9) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
4486
4486
  };
4487
4487
  }
4488
4488
  function baseMerge(object, source, srcIndex, customizer, stack) {
@@ -4579,23 +4579,23 @@ var require_lodash = __commonJS({
4579
4579
  });
4580
4580
  }
4581
4581
  function basePick(object, paths) {
4582
- return basePickBy(object, paths, function(value, path8) {
4583
- return hasIn(object, path8);
4582
+ return basePickBy(object, paths, function(value, path9) {
4583
+ return hasIn(object, path9);
4584
4584
  });
4585
4585
  }
4586
4586
  function basePickBy(object, paths, predicate) {
4587
4587
  var index = -1, length = paths.length, result2 = {};
4588
4588
  while (++index < length) {
4589
- var path8 = paths[index], value = baseGet(object, path8);
4590
- if (predicate(value, path8)) {
4591
- baseSet(result2, castPath(path8, object), value);
4589
+ var path9 = paths[index], value = baseGet(object, path9);
4590
+ if (predicate(value, path9)) {
4591
+ baseSet(result2, castPath(path9, object), value);
4592
4592
  }
4593
4593
  }
4594
4594
  return result2;
4595
4595
  }
4596
- function basePropertyDeep(path8) {
4596
+ function basePropertyDeep(path9) {
4597
4597
  return function(object) {
4598
- return baseGet(object, path8);
4598
+ return baseGet(object, path9);
4599
4599
  };
4600
4600
  }
4601
4601
  function basePullAll(array, values2, iteratee2, comparator) {
@@ -4669,14 +4669,14 @@ var require_lodash = __commonJS({
4669
4669
  var array = values(collection);
4670
4670
  return shuffleSelf(array, baseClamp(n, 0, array.length));
4671
4671
  }
4672
- function baseSet(object, path8, value, customizer) {
4672
+ function baseSet(object, path9, value, customizer) {
4673
4673
  if (!isObject3(object)) {
4674
4674
  return object;
4675
4675
  }
4676
- path8 = castPath(path8, object);
4677
- var index = -1, length = path8.length, lastIndex = length - 1, nested = object;
4676
+ path9 = castPath(path9, object);
4677
+ var index = -1, length = path9.length, lastIndex = length - 1, nested = object;
4678
4678
  while (nested != null && ++index < length) {
4679
- var key = toKey(path8[index]), newValue = value;
4679
+ var key = toKey(path9[index]), newValue = value;
4680
4680
  if (key === "__proto__" || key === "constructor" || key === "prototype") {
4681
4681
  return object;
4682
4682
  }
@@ -4684,7 +4684,7 @@ var require_lodash = __commonJS({
4684
4684
  var objValue = nested[key];
4685
4685
  newValue = customizer ? customizer(objValue, key, nested) : undefined2;
4686
4686
  if (newValue === undefined2) {
4687
- newValue = isObject3(objValue) ? objValue : isIndex(path8[index + 1]) ? [] : {};
4687
+ newValue = isObject3(objValue) ? objValue : isIndex(path9[index + 1]) ? [] : {};
4688
4688
  }
4689
4689
  }
4690
4690
  assignValue(nested, key, newValue);
@@ -4850,13 +4850,13 @@ var require_lodash = __commonJS({
4850
4850
  }
4851
4851
  return result2;
4852
4852
  }
4853
- function baseUnset(object, path8) {
4854
- path8 = castPath(path8, object);
4855
- object = parent(object, path8);
4856
- return object == null || delete object[toKey(last(path8))];
4853
+ function baseUnset(object, path9) {
4854
+ path9 = castPath(path9, object);
4855
+ object = parent(object, path9);
4856
+ return object == null || delete object[toKey(last(path9))];
4857
4857
  }
4858
- function baseUpdate(object, path8, updater, customizer) {
4859
- return baseSet(object, path8, updater(baseGet(object, path8)), customizer);
4858
+ function baseUpdate(object, path9, updater, customizer) {
4859
+ return baseSet(object, path9, updater(baseGet(object, path9)), customizer);
4860
4860
  }
4861
4861
  function baseWhile(array, predicate, isDrop, fromRight) {
4862
4862
  var length = array.length, index = fromRight ? length : -1;
@@ -5739,11 +5739,11 @@ var require_lodash = __commonJS({
5739
5739
  var match = source.match(reWrapDetails);
5740
5740
  return match ? match[1].split(reSplitDetails) : [];
5741
5741
  }
5742
- function hasPath(object, path8, hasFunc) {
5743
- path8 = castPath(path8, object);
5744
- var index = -1, length = path8.length, result2 = false;
5742
+ function hasPath(object, path9, hasFunc) {
5743
+ path9 = castPath(path9, object);
5744
+ var index = -1, length = path9.length, result2 = false;
5745
5745
  while (++index < length) {
5746
- var key = toKey(path8[index]);
5746
+ var key = toKey(path9[index]);
5747
5747
  if (!(result2 = object != null && hasFunc(object, key))) {
5748
5748
  break;
5749
5749
  }
@@ -5945,8 +5945,8 @@ var require_lodash = __commonJS({
5945
5945
  return apply(func, this, otherArgs);
5946
5946
  };
5947
5947
  }
5948
- function parent(object, path8) {
5949
- return path8.length < 2 ? object : baseGet(object, baseSlice(path8, 0, -1));
5948
+ function parent(object, path9) {
5949
+ return path9.length < 2 ? object : baseGet(object, baseSlice(path9, 0, -1));
5950
5950
  }
5951
5951
  function reorder(array, indexes) {
5952
5952
  var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array);
@@ -6581,10 +6581,10 @@ var require_lodash = __commonJS({
6581
6581
  }
6582
6582
  return isString3(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
6583
6583
  }
6584
- var invokeMap = baseRest(function(collection, path8, args) {
6585
- var index = -1, isFunc = typeof path8 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
6584
+ var invokeMap = baseRest(function(collection, path9, args) {
6585
+ var index = -1, isFunc = typeof path9 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
6586
6586
  baseEach(collection, function(value) {
6587
- result2[++index] = isFunc ? apply(path8, value, args) : baseInvoke(value, path8, args);
6587
+ result2[++index] = isFunc ? apply(path9, value, args) : baseInvoke(value, path9, args);
6588
6588
  });
6589
6589
  return result2;
6590
6590
  });
@@ -7236,15 +7236,15 @@ var require_lodash = __commonJS({
7236
7236
  function functionsIn(object) {
7237
7237
  return object == null ? [] : baseFunctions(object, keysIn(object));
7238
7238
  }
7239
- function get2(object, path8, defaultValue) {
7240
- var result2 = object == null ? undefined2 : baseGet(object, path8);
7239
+ function get2(object, path9, defaultValue) {
7240
+ var result2 = object == null ? undefined2 : baseGet(object, path9);
7241
7241
  return result2 === undefined2 ? defaultValue : result2;
7242
7242
  }
7243
- function has(object, path8) {
7244
- return object != null && hasPath(object, path8, baseHas);
7243
+ function has(object, path9) {
7244
+ return object != null && hasPath(object, path9, baseHas);
7245
7245
  }
7246
- function hasIn(object, path8) {
7247
- return object != null && hasPath(object, path8, baseHasIn);
7246
+ function hasIn(object, path9) {
7247
+ return object != null && hasPath(object, path9, baseHasIn);
7248
7248
  }
7249
7249
  var invert = createInverter(function(result2, value, key) {
7250
7250
  if (value != null && typeof value.toString != "function") {
@@ -7297,10 +7297,10 @@ var require_lodash = __commonJS({
7297
7297
  return result2;
7298
7298
  }
7299
7299
  var isDeep = false;
7300
- paths = arrayMap(paths, function(path8) {
7301
- path8 = castPath(path8, object);
7302
- isDeep || (isDeep = path8.length > 1);
7303
- return path8;
7300
+ paths = arrayMap(paths, function(path9) {
7301
+ path9 = castPath(path9, object);
7302
+ isDeep || (isDeep = path9.length > 1);
7303
+ return path9;
7304
7304
  });
7305
7305
  copyObject(object, getAllKeysIn(object), result2);
7306
7306
  if (isDeep) {
@@ -7326,19 +7326,19 @@ var require_lodash = __commonJS({
7326
7326
  return [prop];
7327
7327
  });
7328
7328
  predicate = getIteratee(predicate);
7329
- return basePickBy(object, props, function(value, path8) {
7330
- return predicate(value, path8[0]);
7329
+ return basePickBy(object, props, function(value, path9) {
7330
+ return predicate(value, path9[0]);
7331
7331
  });
7332
7332
  }
7333
- function result(object, path8, defaultValue) {
7334
- path8 = castPath(path8, object);
7335
- var index = -1, length = path8.length;
7333
+ function result(object, path9, defaultValue) {
7334
+ path9 = castPath(path9, object);
7335
+ var index = -1, length = path9.length;
7336
7336
  if (!length) {
7337
7337
  length = 1;
7338
7338
  object = undefined2;
7339
7339
  }
7340
7340
  while (++index < length) {
7341
- var value = object == null ? undefined2 : object[toKey(path8[index])];
7341
+ var value = object == null ? undefined2 : object[toKey(path9[index])];
7342
7342
  if (value === undefined2) {
7343
7343
  index = length;
7344
7344
  value = defaultValue;
@@ -7347,12 +7347,12 @@ var require_lodash = __commonJS({
7347
7347
  }
7348
7348
  return object;
7349
7349
  }
7350
- function set(object, path8, value) {
7351
- return object == null ? object : baseSet(object, path8, value);
7350
+ function set(object, path9, value) {
7351
+ return object == null ? object : baseSet(object, path9, value);
7352
7352
  }
7353
- function setWith(object, path8, value, customizer) {
7353
+ function setWith(object, path9, value, customizer) {
7354
7354
  customizer = typeof customizer == "function" ? customizer : undefined2;
7355
- return object == null ? object : baseSet(object, path8, value, customizer);
7355
+ return object == null ? object : baseSet(object, path9, value, customizer);
7356
7356
  }
7357
7357
  var toPairs = createToPairs(keys);
7358
7358
  var toPairsIn = createToPairs(keysIn);
@@ -7374,15 +7374,15 @@ var require_lodash = __commonJS({
7374
7374
  });
7375
7375
  return accumulator;
7376
7376
  }
7377
- function unset(object, path8) {
7378
- return object == null ? true : baseUnset(object, path8);
7377
+ function unset(object, path9) {
7378
+ return object == null ? true : baseUnset(object, path9);
7379
7379
  }
7380
- function update(object, path8, updater) {
7381
- return object == null ? object : baseUpdate(object, path8, castFunction(updater));
7380
+ function update(object, path9, updater) {
7381
+ return object == null ? object : baseUpdate(object, path9, castFunction(updater));
7382
7382
  }
7383
- function updateWith(object, path8, updater, customizer) {
7383
+ function updateWith(object, path9, updater, customizer) {
7384
7384
  customizer = typeof customizer == "function" ? customizer : undefined2;
7385
- return object == null ? object : baseUpdate(object, path8, castFunction(updater), customizer);
7385
+ return object == null ? object : baseUpdate(object, path9, castFunction(updater), customizer);
7386
7386
  }
7387
7387
  function values(object) {
7388
7388
  return object == null ? [] : baseValues(object, keys(object));
@@ -7763,17 +7763,17 @@ var require_lodash = __commonJS({
7763
7763
  function matches(source) {
7764
7764
  return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
7765
7765
  }
7766
- function matchesProperty(path8, srcValue) {
7767
- return baseMatchesProperty(path8, baseClone(srcValue, CLONE_DEEP_FLAG));
7766
+ function matchesProperty(path9, srcValue) {
7767
+ return baseMatchesProperty(path9, baseClone(srcValue, CLONE_DEEP_FLAG));
7768
7768
  }
7769
- var method = baseRest(function(path8, args) {
7769
+ var method = baseRest(function(path9, args) {
7770
7770
  return function(object) {
7771
- return baseInvoke(object, path8, args);
7771
+ return baseInvoke(object, path9, args);
7772
7772
  };
7773
7773
  });
7774
7774
  var methodOf = baseRest(function(object, args) {
7775
- return function(path8) {
7776
- return baseInvoke(object, path8, args);
7775
+ return function(path9) {
7776
+ return baseInvoke(object, path9, args);
7777
7777
  };
7778
7778
  });
7779
7779
  function mixin(object, source, options) {
@@ -7820,12 +7820,12 @@ var require_lodash = __commonJS({
7820
7820
  var over = createOver(arrayMap);
7821
7821
  var overEvery = createOver(arrayEvery);
7822
7822
  var overSome = createOver(arraySome);
7823
- function property(path8) {
7824
- return isKey(path8) ? baseProperty(toKey(path8)) : basePropertyDeep(path8);
7823
+ function property(path9) {
7824
+ return isKey(path9) ? baseProperty(toKey(path9)) : basePropertyDeep(path9);
7825
7825
  }
7826
7826
  function propertyOf(object) {
7827
- return function(path8) {
7828
- return object == null ? undefined2 : baseGet(object, path8);
7827
+ return function(path9) {
7828
+ return object == null ? undefined2 : baseGet(object, path9);
7829
7829
  };
7830
7830
  }
7831
7831
  var range = createRange();
@@ -8278,12 +8278,12 @@ var require_lodash = __commonJS({
8278
8278
  LazyWrapper.prototype.findLast = function(predicate) {
8279
8279
  return this.reverse().find(predicate);
8280
8280
  };
8281
- LazyWrapper.prototype.invokeMap = baseRest(function(path8, args) {
8282
- if (typeof path8 == "function") {
8281
+ LazyWrapper.prototype.invokeMap = baseRest(function(path9, args) {
8282
+ if (typeof path9 == "function") {
8283
8283
  return new LazyWrapper(this);
8284
8284
  }
8285
8285
  return this.map(function(value) {
8286
- return baseInvoke(value, path8, args);
8286
+ return baseInvoke(value, path9, args);
8287
8287
  });
8288
8288
  });
8289
8289
  LazyWrapper.prototype.reject = function(predicate) {
@@ -8407,10 +8407,10 @@ var require_lodash2 = __commonJS({
8407
8407
  }
8408
8408
  });
8409
8409
 
8410
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/logger/constants.js
8410
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/logger/constants.js
8411
8411
  var LoggerLevel;
8412
8412
  var init_constants = __esm({
8413
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/logger/constants.js"() {
8413
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/logger/constants.js"() {
8414
8414
  "use strict";
8415
8415
  (function(LoggerLevel2) {
8416
8416
  LoggerLevel2["Error"] = "error";
@@ -9296,15 +9296,15 @@ var require_route = __commonJS({
9296
9296
  };
9297
9297
  }
9298
9298
  function wrapConversion(toModel, graph) {
9299
- const path8 = [graph[toModel].parent, toModel];
9299
+ const path9 = [graph[toModel].parent, toModel];
9300
9300
  let fn = conversions[graph[toModel].parent][toModel];
9301
9301
  let cur = graph[toModel].parent;
9302
9302
  while (graph[cur].parent) {
9303
- path8.unshift(graph[cur].parent);
9303
+ path9.unshift(graph[cur].parent);
9304
9304
  fn = link(conversions[graph[cur].parent][cur], fn);
9305
9305
  cur = graph[cur].parent;
9306
9306
  }
9307
- fn.conversion = path8;
9307
+ fn.conversion = path9;
9308
9308
  return fn;
9309
9309
  }
9310
9310
  module2.exports = function(fromModel) {
@@ -9973,10 +9973,10 @@ var require_source = __commonJS({
9973
9973
  }
9974
9974
  });
9975
9975
 
9976
- // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/chalk.js
9976
+ // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/chalk.js
9977
9977
  var import_chalk;
9978
9978
  var init_chalk = __esm({
9979
- "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/chalk.js"() {
9979
+ "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/chalk.js"() {
9980
9980
  "use strict";
9981
9981
  import_chalk = __toESM(require_source());
9982
9982
  }
@@ -10730,10 +10730,10 @@ var require_src = __commonJS({
10730
10730
  }
10731
10731
  });
10732
10732
 
10733
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/logger/index.js
10733
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/logger/index.js
10734
10734
  var import_debug, Logger;
10735
10735
  var init_logger = __esm({
10736
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/logger/index.js"() {
10736
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/logger/index.js"() {
10737
10737
  "use strict";
10738
10738
  init_chalk();
10739
10739
  import_debug = __toESM(require_src());
@@ -11302,7 +11302,7 @@ var require_minimatch = __commonJS({
11302
11302
  "use strict";
11303
11303
  module2.exports = minimatch;
11304
11304
  minimatch.Minimatch = Minimatch;
11305
- var path8 = function() {
11305
+ var path9 = function() {
11306
11306
  try {
11307
11307
  return require("path");
11308
11308
  } catch (e) {
@@ -11310,7 +11310,7 @@ var require_minimatch = __commonJS({
11310
11310
  }() || {
11311
11311
  sep: "/"
11312
11312
  };
11313
- minimatch.sep = path8.sep;
11313
+ minimatch.sep = path9.sep;
11314
11314
  var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
11315
11315
  var expand = require_brace_expansion();
11316
11316
  var plTypes = {
@@ -11401,8 +11401,8 @@ var require_minimatch = __commonJS({
11401
11401
  if (!options)
11402
11402
  options = {};
11403
11403
  pattern = pattern.trim();
11404
- if (!options.allowWindowsEscape && path8.sep !== "/") {
11405
- pattern = pattern.split(path8.sep).join("/");
11404
+ if (!options.allowWindowsEscape && path9.sep !== "/") {
11405
+ pattern = pattern.split(path9.sep).join("/");
11406
11406
  }
11407
11407
  this.options = options;
11408
11408
  this.set = [];
@@ -11779,8 +11779,8 @@ var require_minimatch = __commonJS({
11779
11779
  if (f === "/" && partial)
11780
11780
  return true;
11781
11781
  var options = this.options;
11782
- if (path8.sep !== "/") {
11783
- f = f.split(path8.sep).join("/");
11782
+ if (path9.sep !== "/") {
11783
+ f = f.split(path9.sep).join("/");
11784
11784
  }
11785
11785
  f = f.split(slashSplit);
11786
11786
  this.debug(this.pattern, "split", f);
@@ -11940,12 +11940,12 @@ var require_inherits = __commonJS({
11940
11940
  var require_path_is_absolute = __commonJS({
11941
11941
  "../../../node_modules/.pnpm/path-is-absolute@1.0.1/node_modules/path-is-absolute/index.js"(exports, module2) {
11942
11942
  "use strict";
11943
- function posix(path8) {
11944
- return path8.charAt(0) === "/";
11943
+ function posix(path9) {
11944
+ return path9.charAt(0) === "/";
11945
11945
  }
11946
- function win32(path8) {
11946
+ function win32(path9) {
11947
11947
  var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
11948
- var result = splitDeviceRe.exec(path8);
11948
+ var result = splitDeviceRe.exec(path9);
11949
11949
  var device = result[1] || "";
11950
11950
  var isUnc = Boolean(device && device.charAt(1) !== ":");
11951
11951
  return Boolean(result[2] || isUnc);
@@ -11971,7 +11971,7 @@ var require_common2 = __commonJS({
11971
11971
  return Object.prototype.hasOwnProperty.call(obj, field);
11972
11972
  }
11973
11973
  var fs2 = require("fs");
11974
- var path8 = require("path");
11974
+ var path9 = require("path");
11975
11975
  var minimatch = require_minimatch();
11976
11976
  var isAbsolute = require_path_is_absolute();
11977
11977
  var Minimatch = minimatch.Minimatch;
@@ -12036,11 +12036,11 @@ var require_common2 = __commonJS({
12036
12036
  if (!ownProp(options, "cwd"))
12037
12037
  self2.cwd = cwd;
12038
12038
  else {
12039
- self2.cwd = path8.resolve(options.cwd);
12039
+ self2.cwd = path9.resolve(options.cwd);
12040
12040
  self2.changedCwd = self2.cwd !== cwd;
12041
12041
  }
12042
- self2.root = options.root || path8.resolve(self2.cwd, "/");
12043
- self2.root = path8.resolve(self2.root);
12042
+ self2.root = options.root || path9.resolve(self2.cwd, "/");
12043
+ self2.root = path9.resolve(self2.root);
12044
12044
  if (process.platform === "win32")
12045
12045
  self2.root = self2.root.replace(/\\/g, "/");
12046
12046
  self2.cwdAbs = isAbsolute(self2.cwd) ? self2.cwd : makeAbs(self2, self2.cwd);
@@ -12121,30 +12121,30 @@ var require_common2 = __commonJS({
12121
12121
  function makeAbs(self2, f) {
12122
12122
  var abs = f;
12123
12123
  if (f.charAt(0) === "/") {
12124
- abs = path8.join(self2.root, f);
12124
+ abs = path9.join(self2.root, f);
12125
12125
  } else if (isAbsolute(f) || f === "") {
12126
12126
  abs = f;
12127
12127
  } else if (self2.changedCwd) {
12128
- abs = path8.resolve(self2.cwd, f);
12128
+ abs = path9.resolve(self2.cwd, f);
12129
12129
  } else {
12130
- abs = path8.resolve(f);
12130
+ abs = path9.resolve(f);
12131
12131
  }
12132
12132
  if (process.platform === "win32")
12133
12133
  abs = abs.replace(/\\/g, "/");
12134
12134
  return abs;
12135
12135
  }
12136
- function isIgnored(self2, path9) {
12136
+ function isIgnored(self2, path10) {
12137
12137
  if (!self2.ignore.length)
12138
12138
  return false;
12139
12139
  return self2.ignore.some(function(item) {
12140
- return item.matcher.match(path9) || !!(item.gmatcher && item.gmatcher.match(path9));
12140
+ return item.matcher.match(path10) || !!(item.gmatcher && item.gmatcher.match(path10));
12141
12141
  });
12142
12142
  }
12143
- function childrenIgnored(self2, path9) {
12143
+ function childrenIgnored(self2, path10) {
12144
12144
  if (!self2.ignore.length)
12145
12145
  return false;
12146
12146
  return self2.ignore.some(function(item) {
12147
- return !!(item.gmatcher && item.gmatcher.match(path9));
12147
+ return !!(item.gmatcher && item.gmatcher.match(path10));
12148
12148
  });
12149
12149
  }
12150
12150
  }
@@ -12161,7 +12161,7 @@ var require_sync = __commonJS({
12161
12161
  var Minimatch = minimatch.Minimatch;
12162
12162
  var Glob = require_glob().Glob;
12163
12163
  var util3 = require("util");
12164
- var path8 = require("path");
12164
+ var path9 = require("path");
12165
12165
  var assert = require("assert");
12166
12166
  var isAbsolute = require_path_is_absolute();
12167
12167
  var common = require_common2();
@@ -12287,7 +12287,7 @@ var require_sync = __commonJS({
12287
12287
  e = prefix + e;
12288
12288
  }
12289
12289
  if (e.charAt(0) === "/" && !this.nomount) {
12290
- e = path8.join(this.root, e);
12290
+ e = path9.join(this.root, e);
12291
12291
  }
12292
12292
  this._emitMatch(index, e);
12293
12293
  }
@@ -12436,9 +12436,9 @@ var require_sync = __commonJS({
12436
12436
  if (prefix && isAbsolute(prefix) && !this.nomount) {
12437
12437
  var trail = /[\/\\]$/.test(prefix);
12438
12438
  if (prefix.charAt(0) === "/") {
12439
- prefix = path8.join(this.root, prefix);
12439
+ prefix = path9.join(this.root, prefix);
12440
12440
  } else {
12441
- prefix = path8.resolve(this.root, prefix);
12441
+ prefix = path9.resolve(this.root, prefix);
12442
12442
  if (trail)
12443
12443
  prefix += "/";
12444
12444
  }
@@ -12637,7 +12637,7 @@ var require_glob = __commonJS({
12637
12637
  var Minimatch = minimatch.Minimatch;
12638
12638
  var inherits2 = require_inherits();
12639
12639
  var EE = require("events").EventEmitter;
12640
- var path8 = require("path");
12640
+ var path9 = require("path");
12641
12641
  var assert = require("assert");
12642
12642
  var isAbsolute = require_path_is_absolute();
12643
12643
  var globSync = require_sync();
@@ -12918,7 +12918,7 @@ var require_glob = __commonJS({
12918
12918
  e = prefix + e;
12919
12919
  }
12920
12920
  if (e.charAt(0) === "/" && !this.nomount) {
12921
- e = path8.join(this.root, e);
12921
+ e = path9.join(this.root, e);
12922
12922
  }
12923
12923
  this._emitMatch(index, e);
12924
12924
  }
@@ -13105,9 +13105,9 @@ var require_glob = __commonJS({
13105
13105
  if (prefix && isAbsolute(prefix) && !this.nomount) {
13106
13106
  var trail = /[\/\\]$/.test(prefix);
13107
13107
  if (prefix.charAt(0) === "/") {
13108
- prefix = path8.join(this.root, prefix);
13108
+ prefix = path9.join(this.root, prefix);
13109
13109
  } else {
13110
- prefix = path8.resolve(this.root, prefix);
13110
+ prefix = path9.resolve(this.root, prefix);
13111
13111
  if (trail)
13112
13112
  prefix += "/";
13113
13113
  }
@@ -13181,10 +13181,10 @@ var require_glob = __commonJS({
13181
13181
  }
13182
13182
  });
13183
13183
 
13184
- // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/glob.js
13184
+ // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/glob.js
13185
13185
  var import_glob;
13186
13186
  var init_glob = __esm({
13187
- "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/glob.js"() {
13187
+ "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/glob.js"() {
13188
13188
  "use strict";
13189
13189
  import_glob = __toESM(require_glob());
13190
13190
  }
@@ -13274,7 +13274,7 @@ var require_polyfills = __commonJS({
13274
13274
  fs2.fstatSync = statFixSync(fs2.fstatSync);
13275
13275
  fs2.lstatSync = statFixSync(fs2.lstatSync);
13276
13276
  if (fs2.chmod && !fs2.lchmod) {
13277
- fs2.lchmod = function(path8, mode, cb) {
13277
+ fs2.lchmod = function(path9, mode, cb) {
13278
13278
  if (cb)
13279
13279
  process.nextTick(cb);
13280
13280
  };
@@ -13282,7 +13282,7 @@ var require_polyfills = __commonJS({
13282
13282
  };
13283
13283
  }
13284
13284
  if (fs2.chown && !fs2.lchown) {
13285
- fs2.lchown = function(path8, uid, gid, cb) {
13285
+ fs2.lchown = function(path9, uid, gid, cb) {
13286
13286
  if (cb)
13287
13287
  process.nextTick(cb);
13288
13288
  };
@@ -13353,9 +13353,9 @@ var require_polyfills = __commonJS({
13353
13353
  };
13354
13354
  }(fs2.readSync);
13355
13355
  function patchLchmod(fs3) {
13356
- fs3.lchmod = function(path8, mode, callback) {
13356
+ fs3.lchmod = function(path9, mode, callback) {
13357
13357
  fs3.open(
13358
- path8,
13358
+ path9,
13359
13359
  constants.O_WRONLY | constants.O_SYMLINK,
13360
13360
  mode,
13361
13361
  function(err, fd) {
@@ -13373,8 +13373,8 @@ var require_polyfills = __commonJS({
13373
13373
  }
13374
13374
  );
13375
13375
  };
13376
- fs3.lchmodSync = function(path8, mode) {
13377
- var fd = fs3.openSync(path8, constants.O_WRONLY | constants.O_SYMLINK, mode);
13376
+ fs3.lchmodSync = function(path9, mode) {
13377
+ var fd = fs3.openSync(path9, constants.O_WRONLY | constants.O_SYMLINK, mode);
13378
13378
  var threw = true;
13379
13379
  var ret;
13380
13380
  try {
@@ -13395,8 +13395,8 @@ var require_polyfills = __commonJS({
13395
13395
  }
13396
13396
  function patchLutimes(fs3) {
13397
13397
  if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
13398
- fs3.lutimes = function(path8, at, mt, cb) {
13399
- fs3.open(path8, constants.O_SYMLINK, function(er, fd) {
13398
+ fs3.lutimes = function(path9, at, mt, cb) {
13399
+ fs3.open(path9, constants.O_SYMLINK, function(er, fd) {
13400
13400
  if (er) {
13401
13401
  if (cb)
13402
13402
  cb(er);
@@ -13410,8 +13410,8 @@ var require_polyfills = __commonJS({
13410
13410
  });
13411
13411
  });
13412
13412
  };
13413
- fs3.lutimesSync = function(path8, at, mt) {
13414
- var fd = fs3.openSync(path8, constants.O_SYMLINK);
13413
+ fs3.lutimesSync = function(path9, at, mt) {
13414
+ var fd = fs3.openSync(path9, constants.O_SYMLINK);
13415
13415
  var ret;
13416
13416
  var threw = true;
13417
13417
  try {
@@ -13548,12 +13548,12 @@ var require_legacy_streams = __commonJS({
13548
13548
  ReadStream,
13549
13549
  WriteStream
13550
13550
  };
13551
- function ReadStream(path8, options) {
13551
+ function ReadStream(path9, options) {
13552
13552
  if (!(this instanceof ReadStream))
13553
- return new ReadStream(path8, options);
13553
+ return new ReadStream(path9, options);
13554
13554
  Stream.call(this);
13555
13555
  var self2 = this;
13556
- this.path = path8;
13556
+ this.path = path9;
13557
13557
  this.fd = null;
13558
13558
  this.readable = true;
13559
13559
  this.paused = false;
@@ -13599,11 +13599,11 @@ var require_legacy_streams = __commonJS({
13599
13599
  self2._read();
13600
13600
  });
13601
13601
  }
13602
- function WriteStream(path8, options) {
13602
+ function WriteStream(path9, options) {
13603
13603
  if (!(this instanceof WriteStream))
13604
- return new WriteStream(path8, options);
13604
+ return new WriteStream(path9, options);
13605
13605
  Stream.call(this);
13606
- this.path = path8;
13606
+ this.path = path9;
13607
13607
  this.fd = null;
13608
13608
  this.writable = true;
13609
13609
  this.flags = "w";
@@ -13747,14 +13747,14 @@ var require_graceful_fs = __commonJS({
13747
13747
  fs3.createWriteStream = createWriteStream;
13748
13748
  var fs$readFile = fs3.readFile;
13749
13749
  fs3.readFile = readFile;
13750
- function readFile(path8, options, cb) {
13750
+ function readFile(path9, options, cb) {
13751
13751
  if (typeof options === "function")
13752
13752
  cb = options, options = null;
13753
- return go$readFile(path8, options, cb);
13754
- function go$readFile(path9, options2, cb2, startTime) {
13755
- return fs$readFile(path9, options2, function(err) {
13753
+ return go$readFile(path9, options, cb);
13754
+ function go$readFile(path10, options2, cb2, startTime) {
13755
+ return fs$readFile(path10, options2, function(err) {
13756
13756
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
13757
- enqueue([go$readFile, [path9, options2, cb2], err, startTime || Date.now(), Date.now()]);
13757
+ enqueue([go$readFile, [path10, options2, cb2], err, startTime || Date.now(), Date.now()]);
13758
13758
  else {
13759
13759
  if (typeof cb2 === "function")
13760
13760
  cb2.apply(this, arguments);
@@ -13764,14 +13764,14 @@ var require_graceful_fs = __commonJS({
13764
13764
  }
13765
13765
  var fs$writeFile = fs3.writeFile;
13766
13766
  fs3.writeFile = writeFile;
13767
- function writeFile(path8, data, options, cb) {
13767
+ function writeFile(path9, data, options, cb) {
13768
13768
  if (typeof options === "function")
13769
13769
  cb = options, options = null;
13770
- return go$writeFile(path8, data, options, cb);
13771
- function go$writeFile(path9, data2, options2, cb2, startTime) {
13772
- return fs$writeFile(path9, data2, options2, function(err) {
13770
+ return go$writeFile(path9, data, options, cb);
13771
+ function go$writeFile(path10, data2, options2, cb2, startTime) {
13772
+ return fs$writeFile(path10, data2, options2, function(err) {
13773
13773
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
13774
- enqueue([go$writeFile, [path9, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
13774
+ enqueue([go$writeFile, [path10, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
13775
13775
  else {
13776
13776
  if (typeof cb2 === "function")
13777
13777
  cb2.apply(this, arguments);
@@ -13782,14 +13782,14 @@ var require_graceful_fs = __commonJS({
13782
13782
  var fs$appendFile = fs3.appendFile;
13783
13783
  if (fs$appendFile)
13784
13784
  fs3.appendFile = appendFile;
13785
- function appendFile(path8, data, options, cb) {
13785
+ function appendFile(path9, data, options, cb) {
13786
13786
  if (typeof options === "function")
13787
13787
  cb = options, options = null;
13788
- return go$appendFile(path8, data, options, cb);
13789
- function go$appendFile(path9, data2, options2, cb2, startTime) {
13790
- return fs$appendFile(path9, data2, options2, function(err) {
13788
+ return go$appendFile(path9, data, options, cb);
13789
+ function go$appendFile(path10, data2, options2, cb2, startTime) {
13790
+ return fs$appendFile(path10, data2, options2, function(err) {
13791
13791
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
13792
- enqueue([go$appendFile, [path9, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
13792
+ enqueue([go$appendFile, [path10, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
13793
13793
  else {
13794
13794
  if (typeof cb2 === "function")
13795
13795
  cb2.apply(this, arguments);
@@ -13820,31 +13820,31 @@ var require_graceful_fs = __commonJS({
13820
13820
  var fs$readdir = fs3.readdir;
13821
13821
  fs3.readdir = readdir;
13822
13822
  var noReaddirOptionVersions = /^v[0-5]\./;
13823
- function readdir(path8, options, cb) {
13823
+ function readdir(path9, options, cb) {
13824
13824
  if (typeof options === "function")
13825
13825
  cb = options, options = null;
13826
- var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path9, options2, cb2, startTime) {
13827
- return fs$readdir(path9, fs$readdirCallback(
13828
- path9,
13826
+ var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path10, options2, cb2, startTime) {
13827
+ return fs$readdir(path10, fs$readdirCallback(
13828
+ path10,
13829
13829
  options2,
13830
13830
  cb2,
13831
13831
  startTime
13832
13832
  ));
13833
- } : function go$readdir2(path9, options2, cb2, startTime) {
13834
- return fs$readdir(path9, options2, fs$readdirCallback(
13835
- path9,
13833
+ } : function go$readdir2(path10, options2, cb2, startTime) {
13834
+ return fs$readdir(path10, options2, fs$readdirCallback(
13835
+ path10,
13836
13836
  options2,
13837
13837
  cb2,
13838
13838
  startTime
13839
13839
  ));
13840
13840
  };
13841
- return go$readdir(path8, options, cb);
13842
- function fs$readdirCallback(path9, options2, cb2, startTime) {
13841
+ return go$readdir(path9, options, cb);
13842
+ function fs$readdirCallback(path10, options2, cb2, startTime) {
13843
13843
  return function(err, files) {
13844
13844
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
13845
13845
  enqueue([
13846
13846
  go$readdir,
13847
- [path9, options2, cb2],
13847
+ [path10, options2, cb2],
13848
13848
  err,
13849
13849
  startTime || Date.now(),
13850
13850
  Date.now()
@@ -13915,7 +13915,7 @@ var require_graceful_fs = __commonJS({
13915
13915
  enumerable: true,
13916
13916
  configurable: true
13917
13917
  });
13918
- function ReadStream(path8, options) {
13918
+ function ReadStream(path9, options) {
13919
13919
  if (this instanceof ReadStream)
13920
13920
  return fs$ReadStream.apply(this, arguments), this;
13921
13921
  else
@@ -13935,7 +13935,7 @@ var require_graceful_fs = __commonJS({
13935
13935
  }
13936
13936
  });
13937
13937
  }
13938
- function WriteStream(path8, options) {
13938
+ function WriteStream(path9, options) {
13939
13939
  if (this instanceof WriteStream)
13940
13940
  return fs$WriteStream.apply(this, arguments), this;
13941
13941
  else
@@ -13953,22 +13953,22 @@ var require_graceful_fs = __commonJS({
13953
13953
  }
13954
13954
  });
13955
13955
  }
13956
- function createReadStream(path8, options) {
13957
- return new fs3.ReadStream(path8, options);
13956
+ function createReadStream(path9, options) {
13957
+ return new fs3.ReadStream(path9, options);
13958
13958
  }
13959
- function createWriteStream(path8, options) {
13960
- return new fs3.WriteStream(path8, options);
13959
+ function createWriteStream(path9, options) {
13960
+ return new fs3.WriteStream(path9, options);
13961
13961
  }
13962
13962
  var fs$open = fs3.open;
13963
13963
  fs3.open = open;
13964
- function open(path8, flags, mode, cb) {
13964
+ function open(path9, flags, mode, cb) {
13965
13965
  if (typeof mode === "function")
13966
13966
  cb = mode, mode = null;
13967
- return go$open(path8, flags, mode, cb);
13968
- function go$open(path9, flags2, mode2, cb2, startTime) {
13969
- return fs$open(path9, flags2, mode2, function(err, fd) {
13967
+ return go$open(path9, flags, mode, cb);
13968
+ function go$open(path10, flags2, mode2, cb2, startTime) {
13969
+ return fs$open(path10, flags2, mode2, function(err, fd) {
13970
13970
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
13971
- enqueue([go$open, [path9, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
13971
+ enqueue([go$open, [path10, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
13972
13972
  else {
13973
13973
  if (typeof cb2 === "function")
13974
13974
  cb2.apply(this, arguments);
@@ -14133,10 +14133,10 @@ var require_fs2 = __commonJS({
14133
14133
  var require_utils = __commonJS({
14134
14134
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module2) {
14135
14135
  "use strict";
14136
- var path8 = require("path");
14136
+ var path9 = require("path");
14137
14137
  module2.exports.checkPath = function checkPath(pth) {
14138
14138
  if (process.platform === "win32") {
14139
- const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path8.parse(pth).root, ""));
14139
+ const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path9.parse(pth).root, ""));
14140
14140
  if (pathHasInvalidWinCharacters) {
14141
14141
  const error = new Error(`Path contains invalid characters: ${pth}`);
14142
14142
  error.code = "EINVAL";
@@ -14201,8 +14201,8 @@ var require_path_exists = __commonJS({
14201
14201
  "use strict";
14202
14202
  var u = require_universalify().fromPromise;
14203
14203
  var fs2 = require_fs2();
14204
- function pathExists(path8) {
14205
- return fs2.access(path8).then(() => true).catch(() => false);
14204
+ function pathExists(path9) {
14205
+ return fs2.access(path9).then(() => true).catch(() => false);
14206
14206
  }
14207
14207
  module2.exports = {
14208
14208
  pathExists: u(pathExists),
@@ -14216,8 +14216,8 @@ var require_utimes = __commonJS({
14216
14216
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/util/utimes.js"(exports, module2) {
14217
14217
  "use strict";
14218
14218
  var fs2 = require_graceful_fs();
14219
- function utimesMillis(path8, atime, mtime, callback) {
14220
- fs2.open(path8, "r+", (err, fd) => {
14219
+ function utimesMillis(path9, atime, mtime, callback) {
14220
+ fs2.open(path9, "r+", (err, fd) => {
14221
14221
  if (err)
14222
14222
  return callback(err);
14223
14223
  fs2.futimes(fd, atime, mtime, (futimesErr) => {
@@ -14228,8 +14228,8 @@ var require_utimes = __commonJS({
14228
14228
  });
14229
14229
  });
14230
14230
  }
14231
- function utimesMillisSync(path8, atime, mtime) {
14232
- const fd = fs2.openSync(path8, "r+");
14231
+ function utimesMillisSync(path9, atime, mtime) {
14232
+ const fd = fs2.openSync(path9, "r+");
14233
14233
  fs2.futimesSync(fd, atime, mtime);
14234
14234
  return fs2.closeSync(fd);
14235
14235
  }
@@ -14245,7 +14245,7 @@ var require_stat = __commonJS({
14245
14245
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/util/stat.js"(exports, module2) {
14246
14246
  "use strict";
14247
14247
  var fs2 = require_fs2();
14248
- var path8 = require("path");
14248
+ var path9 = require("path");
14249
14249
  var util3 = require("util");
14250
14250
  function getStats(src, dest, opts) {
14251
14251
  const statFunc = opts.dereference ? (file) => fs2.stat(file, { bigint: true }) : (file) => fs2.lstat(file, { bigint: true });
@@ -14278,8 +14278,8 @@ var require_stat = __commonJS({
14278
14278
  const { srcStat, destStat } = stats;
14279
14279
  if (destStat) {
14280
14280
  if (areIdentical(srcStat, destStat)) {
14281
- const srcBaseName = path8.basename(src);
14282
- const destBaseName = path8.basename(dest);
14281
+ const srcBaseName = path9.basename(src);
14282
+ const destBaseName = path9.basename(dest);
14283
14283
  if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
14284
14284
  return cb(null, { srcStat, destStat, isChangingCase: true });
14285
14285
  }
@@ -14302,8 +14302,8 @@ var require_stat = __commonJS({
14302
14302
  const { srcStat, destStat } = getStatsSync(src, dest, opts);
14303
14303
  if (destStat) {
14304
14304
  if (areIdentical(srcStat, destStat)) {
14305
- const srcBaseName = path8.basename(src);
14306
- const destBaseName = path8.basename(dest);
14305
+ const srcBaseName = path9.basename(src);
14306
+ const destBaseName = path9.basename(dest);
14307
14307
  if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
14308
14308
  return { srcStat, destStat, isChangingCase: true };
14309
14309
  }
@@ -14322,9 +14322,9 @@ var require_stat = __commonJS({
14322
14322
  return { srcStat, destStat };
14323
14323
  }
14324
14324
  function checkParentPaths(src, srcStat, dest, funcName, cb) {
14325
- const srcParent = path8.resolve(path8.dirname(src));
14326
- const destParent = path8.resolve(path8.dirname(dest));
14327
- if (destParent === srcParent || destParent === path8.parse(destParent).root)
14325
+ const srcParent = path9.resolve(path9.dirname(src));
14326
+ const destParent = path9.resolve(path9.dirname(dest));
14327
+ if (destParent === srcParent || destParent === path9.parse(destParent).root)
14328
14328
  return cb();
14329
14329
  fs2.stat(destParent, { bigint: true }, (err, destStat) => {
14330
14330
  if (err) {
@@ -14339,9 +14339,9 @@ var require_stat = __commonJS({
14339
14339
  });
14340
14340
  }
14341
14341
  function checkParentPathsSync(src, srcStat, dest, funcName) {
14342
- const srcParent = path8.resolve(path8.dirname(src));
14343
- const destParent = path8.resolve(path8.dirname(dest));
14344
- if (destParent === srcParent || destParent === path8.parse(destParent).root)
14342
+ const srcParent = path9.resolve(path9.dirname(src));
14343
+ const destParent = path9.resolve(path9.dirname(dest));
14344
+ if (destParent === srcParent || destParent === path9.parse(destParent).root)
14345
14345
  return;
14346
14346
  let destStat;
14347
14347
  try {
@@ -14360,8 +14360,8 @@ var require_stat = __commonJS({
14360
14360
  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
14361
14361
  }
14362
14362
  function isSrcSubdir(src, dest) {
14363
- const srcArr = path8.resolve(src).split(path8.sep).filter((i) => i);
14364
- const destArr = path8.resolve(dest).split(path8.sep).filter((i) => i);
14363
+ const srcArr = path9.resolve(src).split(path9.sep).filter((i) => i);
14364
+ const destArr = path9.resolve(dest).split(path9.sep).filter((i) => i);
14365
14365
  return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true);
14366
14366
  }
14367
14367
  function errMsg(src, dest, funcName) {
@@ -14383,7 +14383,7 @@ var require_copy = __commonJS({
14383
14383
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/copy/copy.js"(exports, module2) {
14384
14384
  "use strict";
14385
14385
  var fs2 = require_graceful_fs();
14386
- var path8 = require("path");
14386
+ var path9 = require("path");
14387
14387
  var mkdirs = require_mkdirs().mkdirs;
14388
14388
  var pathExists = require_path_exists().pathExists;
14389
14389
  var utimesMillis = require_utimes().utimesMillis;
@@ -14419,7 +14419,7 @@ var require_copy = __commonJS({
14419
14419
  });
14420
14420
  }
14421
14421
  function checkParentDir(destStat, src, dest, opts, cb) {
14422
- const destParent = path8.dirname(dest);
14422
+ const destParent = path9.dirname(dest);
14423
14423
  pathExists(destParent, (err, dirExists) => {
14424
14424
  if (err)
14425
14425
  return cb(err);
@@ -14551,8 +14551,8 @@ var require_copy = __commonJS({
14551
14551
  return copyDirItem(items, item, src, dest, opts, cb);
14552
14552
  }
14553
14553
  function copyDirItem(items, item, src, dest, opts, cb) {
14554
- const srcItem = path8.join(src, item);
14555
- const destItem = path8.join(dest, item);
14554
+ const srcItem = path9.join(src, item);
14555
+ const destItem = path9.join(dest, item);
14556
14556
  stat.checkPaths(srcItem, destItem, "copy", opts, (err, stats) => {
14557
14557
  if (err)
14558
14558
  return cb(err);
@@ -14569,7 +14569,7 @@ var require_copy = __commonJS({
14569
14569
  if (err)
14570
14570
  return cb(err);
14571
14571
  if (opts.dereference) {
14572
- resolvedSrc = path8.resolve(process.cwd(), resolvedSrc);
14572
+ resolvedSrc = path9.resolve(process.cwd(), resolvedSrc);
14573
14573
  }
14574
14574
  if (!destStat) {
14575
14575
  return fs2.symlink(resolvedSrc, dest, cb);
@@ -14581,7 +14581,7 @@ var require_copy = __commonJS({
14581
14581
  return cb(err2);
14582
14582
  }
14583
14583
  if (opts.dereference) {
14584
- resolvedDest = path8.resolve(process.cwd(), resolvedDest);
14584
+ resolvedDest = path9.resolve(process.cwd(), resolvedDest);
14585
14585
  }
14586
14586
  if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
14587
14587
  return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`));
@@ -14610,7 +14610,7 @@ var require_copy_sync = __commonJS({
14610
14610
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module2) {
14611
14611
  "use strict";
14612
14612
  var fs2 = require_graceful_fs();
14613
- var path8 = require("path");
14613
+ var path9 = require("path");
14614
14614
  var mkdirsSync = require_mkdirs().mkdirsSync;
14615
14615
  var utimesMillisSync = require_utimes().utimesMillisSync;
14616
14616
  var stat = require_stat();
@@ -14633,7 +14633,7 @@ var require_copy_sync = __commonJS({
14633
14633
  function handleFilterAndCopy(destStat, src, dest, opts) {
14634
14634
  if (opts.filter && !opts.filter(src, dest))
14635
14635
  return;
14636
- const destParent = path8.dirname(dest);
14636
+ const destParent = path9.dirname(dest);
14637
14637
  if (!fs2.existsSync(destParent))
14638
14638
  mkdirsSync(destParent);
14639
14639
  return getStats(destStat, src, dest, opts);
@@ -14709,15 +14709,15 @@ var require_copy_sync = __commonJS({
14709
14709
  fs2.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
14710
14710
  }
14711
14711
  function copyDirItem(item, src, dest, opts) {
14712
- const srcItem = path8.join(src, item);
14713
- const destItem = path8.join(dest, item);
14712
+ const srcItem = path9.join(src, item);
14713
+ const destItem = path9.join(dest, item);
14714
14714
  const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
14715
14715
  return startCopy(destStat, srcItem, destItem, opts);
14716
14716
  }
14717
14717
  function onLink(destStat, src, dest, opts) {
14718
14718
  let resolvedSrc = fs2.readlinkSync(src);
14719
14719
  if (opts.dereference) {
14720
- resolvedSrc = path8.resolve(process.cwd(), resolvedSrc);
14720
+ resolvedSrc = path9.resolve(process.cwd(), resolvedSrc);
14721
14721
  }
14722
14722
  if (!destStat) {
14723
14723
  return fs2.symlinkSync(resolvedSrc, dest);
@@ -14731,7 +14731,7 @@ var require_copy_sync = __commonJS({
14731
14731
  throw err;
14732
14732
  }
14733
14733
  if (opts.dereference) {
14734
- resolvedDest = path8.resolve(process.cwd(), resolvedDest);
14734
+ resolvedDest = path9.resolve(process.cwd(), resolvedDest);
14735
14735
  }
14736
14736
  if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
14737
14737
  throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -14767,7 +14767,7 @@ var require_rimraf = __commonJS({
14767
14767
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/remove/rimraf.js"(exports, module2) {
14768
14768
  "use strict";
14769
14769
  var fs2 = require_graceful_fs();
14770
- var path8 = require("path");
14770
+ var path9 = require("path");
14771
14771
  var assert = require("assert");
14772
14772
  var isWindows = process.platform === "win32";
14773
14773
  function defaults2(options) {
@@ -14915,7 +14915,7 @@ var require_rimraf = __commonJS({
14915
14915
  if (n === 0)
14916
14916
  return options.rmdir(p, cb);
14917
14917
  files.forEach((f) => {
14918
- rimraf(path8.join(p, f), options, (er2) => {
14918
+ rimraf(path9.join(p, f), options, (er2) => {
14919
14919
  if (errState) {
14920
14920
  return;
14921
14921
  }
@@ -14981,7 +14981,7 @@ var require_rimraf = __commonJS({
14981
14981
  function rmkidsSync(p, options) {
14982
14982
  assert(p);
14983
14983
  assert(options);
14984
- options.readdirSync(p).forEach((f) => rimrafSync(path8.join(p, f), options));
14984
+ options.readdirSync(p).forEach((f) => rimrafSync(path9.join(p, f), options));
14985
14985
  if (isWindows) {
14986
14986
  const startTime = Date.now();
14987
14987
  do {
@@ -15008,15 +15008,15 @@ var require_remove = __commonJS({
15008
15008
  var fs2 = require_graceful_fs();
15009
15009
  var u = require_universalify().fromCallback;
15010
15010
  var rimraf = require_rimraf();
15011
- function remove(path8, callback) {
15011
+ function remove(path9, callback) {
15012
15012
  if (fs2.rm)
15013
- return fs2.rm(path8, { recursive: true, force: true }, callback);
15014
- rimraf(path8, callback);
15013
+ return fs2.rm(path9, { recursive: true, force: true }, callback);
15014
+ rimraf(path9, callback);
15015
15015
  }
15016
- function removeSync(path8) {
15016
+ function removeSync(path9) {
15017
15017
  if (fs2.rmSync)
15018
- return fs2.rmSync(path8, { recursive: true, force: true });
15019
- rimraf.sync(path8);
15018
+ return fs2.rmSync(path9, { recursive: true, force: true });
15019
+ rimraf.sync(path9);
15020
15020
  }
15021
15021
  module2.exports = {
15022
15022
  remove: u(remove),
@@ -15031,7 +15031,7 @@ var require_empty = __commonJS({
15031
15031
  "use strict";
15032
15032
  var u = require_universalify().fromPromise;
15033
15033
  var fs2 = require_fs2();
15034
- var path8 = require("path");
15034
+ var path9 = require("path");
15035
15035
  var mkdir = require_mkdirs();
15036
15036
  var remove = require_remove();
15037
15037
  var emptyDir = u(function emptyDir2(dir) {
@@ -15042,7 +15042,7 @@ var require_empty = __commonJS({
15042
15042
  } catch (e) {
15043
15043
  return mkdir.mkdirs(dir);
15044
15044
  }
15045
- return Promise.all(items.map((item) => remove.remove(path8.join(dir, item))));
15045
+ return Promise.all(items.map((item) => remove.remove(path9.join(dir, item))));
15046
15046
  });
15047
15047
  });
15048
15048
  function emptyDirSync(dir) {
@@ -15053,7 +15053,7 @@ var require_empty = __commonJS({
15053
15053
  return mkdir.mkdirsSync(dir);
15054
15054
  }
15055
15055
  items.forEach((item) => {
15056
- item = path8.join(dir, item);
15056
+ item = path9.join(dir, item);
15057
15057
  remove.removeSync(item);
15058
15058
  });
15059
15059
  }
@@ -15071,7 +15071,7 @@ var require_file = __commonJS({
15071
15071
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/ensure/file.js"(exports, module2) {
15072
15072
  "use strict";
15073
15073
  var u = require_universalify().fromCallback;
15074
- var path8 = require("path");
15074
+ var path9 = require("path");
15075
15075
  var fs2 = require_graceful_fs();
15076
15076
  var mkdir = require_mkdirs();
15077
15077
  function createFile(file, callback) {
@@ -15085,7 +15085,7 @@ var require_file = __commonJS({
15085
15085
  fs2.stat(file, (err, stats) => {
15086
15086
  if (!err && stats.isFile())
15087
15087
  return callback();
15088
- const dir = path8.dirname(file);
15088
+ const dir = path9.dirname(file);
15089
15089
  fs2.stat(dir, (err2, stats2) => {
15090
15090
  if (err2) {
15091
15091
  if (err2.code === "ENOENT") {
@@ -15116,7 +15116,7 @@ var require_file = __commonJS({
15116
15116
  }
15117
15117
  if (stats && stats.isFile())
15118
15118
  return;
15119
- const dir = path8.dirname(file);
15119
+ const dir = path9.dirname(file);
15120
15120
  try {
15121
15121
  if (!fs2.statSync(dir).isDirectory()) {
15122
15122
  fs2.readdirSync(dir);
@@ -15141,7 +15141,7 @@ var require_link = __commonJS({
15141
15141
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/ensure/link.js"(exports, module2) {
15142
15142
  "use strict";
15143
15143
  var u = require_universalify().fromCallback;
15144
- var path8 = require("path");
15144
+ var path9 = require("path");
15145
15145
  var fs2 = require_graceful_fs();
15146
15146
  var mkdir = require_mkdirs();
15147
15147
  var pathExists = require_path_exists().pathExists;
@@ -15162,7 +15162,7 @@ var require_link = __commonJS({
15162
15162
  }
15163
15163
  if (dstStat && areIdentical(srcStat, dstStat))
15164
15164
  return callback(null);
15165
- const dir = path8.dirname(dstpath);
15165
+ const dir = path9.dirname(dstpath);
15166
15166
  pathExists(dir, (err2, dirExists) => {
15167
15167
  if (err2)
15168
15168
  return callback(err2);
@@ -15191,7 +15191,7 @@ var require_link = __commonJS({
15191
15191
  err.message = err.message.replace("lstat", "ensureLink");
15192
15192
  throw err;
15193
15193
  }
15194
- const dir = path8.dirname(dstpath);
15194
+ const dir = path9.dirname(dstpath);
15195
15195
  const dirExists = fs2.existsSync(dir);
15196
15196
  if (dirExists)
15197
15197
  return fs2.linkSync(srcpath, dstpath);
@@ -15209,11 +15209,11 @@ var require_link = __commonJS({
15209
15209
  var require_symlink_paths = __commonJS({
15210
15210
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module2) {
15211
15211
  "use strict";
15212
- var path8 = require("path");
15212
+ var path9 = require("path");
15213
15213
  var fs2 = require_graceful_fs();
15214
15214
  var pathExists = require_path_exists().pathExists;
15215
15215
  function symlinkPaths(srcpath, dstpath, callback) {
15216
- if (path8.isAbsolute(srcpath)) {
15216
+ if (path9.isAbsolute(srcpath)) {
15217
15217
  return fs2.lstat(srcpath, (err) => {
15218
15218
  if (err) {
15219
15219
  err.message = err.message.replace("lstat", "ensureSymlink");
@@ -15225,8 +15225,8 @@ var require_symlink_paths = __commonJS({
15225
15225
  });
15226
15226
  });
15227
15227
  } else {
15228
- const dstdir = path8.dirname(dstpath);
15229
- const relativeToDst = path8.join(dstdir, srcpath);
15228
+ const dstdir = path9.dirname(dstpath);
15229
+ const relativeToDst = path9.join(dstdir, srcpath);
15230
15230
  return pathExists(relativeToDst, (err, exists) => {
15231
15231
  if (err)
15232
15232
  return callback(err);
@@ -15243,7 +15243,7 @@ var require_symlink_paths = __commonJS({
15243
15243
  }
15244
15244
  return callback(null, {
15245
15245
  toCwd: srcpath,
15246
- toDst: path8.relative(dstdir, srcpath)
15246
+ toDst: path9.relative(dstdir, srcpath)
15247
15247
  });
15248
15248
  });
15249
15249
  }
@@ -15252,7 +15252,7 @@ var require_symlink_paths = __commonJS({
15252
15252
  }
15253
15253
  function symlinkPathsSync(srcpath, dstpath) {
15254
15254
  let exists;
15255
- if (path8.isAbsolute(srcpath)) {
15255
+ if (path9.isAbsolute(srcpath)) {
15256
15256
  exists = fs2.existsSync(srcpath);
15257
15257
  if (!exists)
15258
15258
  throw new Error("absolute srcpath does not exist");
@@ -15261,8 +15261,8 @@ var require_symlink_paths = __commonJS({
15261
15261
  toDst: srcpath
15262
15262
  };
15263
15263
  } else {
15264
- const dstdir = path8.dirname(dstpath);
15265
- const relativeToDst = path8.join(dstdir, srcpath);
15264
+ const dstdir = path9.dirname(dstpath);
15265
+ const relativeToDst = path9.join(dstdir, srcpath);
15266
15266
  exists = fs2.existsSync(relativeToDst);
15267
15267
  if (exists) {
15268
15268
  return {
@@ -15275,7 +15275,7 @@ var require_symlink_paths = __commonJS({
15275
15275
  throw new Error("relative srcpath does not exist");
15276
15276
  return {
15277
15277
  toCwd: srcpath,
15278
- toDst: path8.relative(dstdir, srcpath)
15278
+ toDst: path9.relative(dstdir, srcpath)
15279
15279
  };
15280
15280
  }
15281
15281
  }
@@ -15327,7 +15327,7 @@ var require_symlink = __commonJS({
15327
15327
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module2) {
15328
15328
  "use strict";
15329
15329
  var u = require_universalify().fromCallback;
15330
- var path8 = require("path");
15330
+ var path9 = require("path");
15331
15331
  var fs2 = require_fs2();
15332
15332
  var _mkdirs = require_mkdirs();
15333
15333
  var mkdirs = _mkdirs.mkdirs;
@@ -15365,7 +15365,7 @@ var require_symlink = __commonJS({
15365
15365
  symlinkType(relative.toCwd, type, (err2, type2) => {
15366
15366
  if (err2)
15367
15367
  return callback(err2);
15368
- const dir = path8.dirname(dstpath);
15368
+ const dir = path9.dirname(dstpath);
15369
15369
  pathExists(dir, (err3, dirExists) => {
15370
15370
  if (err3)
15371
15371
  return callback(err3);
@@ -15395,7 +15395,7 @@ var require_symlink = __commonJS({
15395
15395
  const relative = symlinkPathsSync(srcpath, dstpath);
15396
15396
  srcpath = relative.toDst;
15397
15397
  type = symlinkTypeSync(relative.toCwd, type);
15398
- const dir = path8.dirname(dstpath);
15398
+ const dir = path9.dirname(dstpath);
15399
15399
  const exists = fs2.existsSync(dir);
15400
15400
  if (exists)
15401
15401
  return fs2.symlinkSync(srcpath, dstpath, type);
@@ -15553,7 +15553,7 @@ var require_output_file = __commonJS({
15553
15553
  "use strict";
15554
15554
  var u = require_universalify().fromCallback;
15555
15555
  var fs2 = require_graceful_fs();
15556
- var path8 = require("path");
15556
+ var path9 = require("path");
15557
15557
  var mkdir = require_mkdirs();
15558
15558
  var pathExists = require_path_exists().pathExists;
15559
15559
  function outputFile(file, data, encoding, callback) {
@@ -15561,7 +15561,7 @@ var require_output_file = __commonJS({
15561
15561
  callback = encoding;
15562
15562
  encoding = "utf8";
15563
15563
  }
15564
- const dir = path8.dirname(file);
15564
+ const dir = path9.dirname(file);
15565
15565
  pathExists(dir, (err, itDoes) => {
15566
15566
  if (err)
15567
15567
  return callback(err);
@@ -15575,7 +15575,7 @@ var require_output_file = __commonJS({
15575
15575
  });
15576
15576
  }
15577
15577
  function outputFileSync(file, ...args) {
15578
- const dir = path8.dirname(file);
15578
+ const dir = path9.dirname(file);
15579
15579
  if (fs2.existsSync(dir)) {
15580
15580
  return fs2.writeFileSync(file, ...args);
15581
15581
  }
@@ -15642,7 +15642,7 @@ var require_move = __commonJS({
15642
15642
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/move/move.js"(exports, module2) {
15643
15643
  "use strict";
15644
15644
  var fs2 = require_graceful_fs();
15645
- var path8 = require("path");
15645
+ var path9 = require("path");
15646
15646
  var copy = require_copy2().copy;
15647
15647
  var remove = require_remove().remove;
15648
15648
  var mkdirp = require_mkdirs().mkdirp;
@@ -15663,7 +15663,7 @@ var require_move = __commonJS({
15663
15663
  return cb(err2);
15664
15664
  if (isParentRoot(dest))
15665
15665
  return doRename(src, dest, overwrite, isChangingCase, cb);
15666
- mkdirp(path8.dirname(dest), (err3) => {
15666
+ mkdirp(path9.dirname(dest), (err3) => {
15667
15667
  if (err3)
15668
15668
  return cb(err3);
15669
15669
  return doRename(src, dest, overwrite, isChangingCase, cb);
@@ -15672,8 +15672,8 @@ var require_move = __commonJS({
15672
15672
  });
15673
15673
  }
15674
15674
  function isParentRoot(dest) {
15675
- const parent = path8.dirname(dest);
15676
- const parsedPath = path8.parse(parent);
15675
+ const parent = path9.dirname(dest);
15676
+ const parsedPath = path9.parse(parent);
15677
15677
  return parsedPath.root === parent;
15678
15678
  }
15679
15679
  function doRename(src, dest, overwrite, isChangingCase, cb) {
@@ -15723,7 +15723,7 @@ var require_move_sync = __commonJS({
15723
15723
  "../../../node_modules/.pnpm/fs-extra@10.0.1/node_modules/fs-extra/lib/move/move-sync.js"(exports, module2) {
15724
15724
  "use strict";
15725
15725
  var fs2 = require_graceful_fs();
15726
- var path8 = require("path");
15726
+ var path9 = require("path");
15727
15727
  var copySync = require_copy2().copySync;
15728
15728
  var removeSync = require_remove().removeSync;
15729
15729
  var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -15734,12 +15734,12 @@ var require_move_sync = __commonJS({
15734
15734
  const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
15735
15735
  stat.checkParentPathsSync(src, srcStat, dest, "move");
15736
15736
  if (!isParentRoot(dest))
15737
- mkdirpSync(path8.dirname(dest));
15737
+ mkdirpSync(path9.dirname(dest));
15738
15738
  return doRename(src, dest, overwrite, isChangingCase);
15739
15739
  }
15740
15740
  function isParentRoot(dest) {
15741
- const parent = path8.dirname(dest);
15742
- const parsedPath = path8.parse(parent);
15741
+ const parent = path9.dirname(dest);
15742
+ const parsedPath = path9.parse(parent);
15743
15743
  return parsedPath.root === parent;
15744
15744
  }
15745
15745
  function doRename(src, dest, overwrite, isChangingCase) {
@@ -15794,19 +15794,19 @@ var require_lib = __commonJS({
15794
15794
  }
15795
15795
  });
15796
15796
 
15797
- // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/fs-extra.js
15797
+ // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/fs-extra.js
15798
15798
  var import_fs_extra;
15799
15799
  var init_fs_extra = __esm({
15800
- "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/fs-extra.js"() {
15800
+ "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/fs-extra.js"() {
15801
15801
  "use strict";
15802
15802
  import_fs_extra = __toESM(require_lib());
15803
15803
  }
15804
15804
  });
15805
15805
 
15806
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/materials/constants.js
15806
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/materials/constants.js
15807
15807
  var IMAGE_EXT_LIST;
15808
15808
  var init_constants2 = __esm({
15809
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/materials/constants.js"() {
15809
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/materials/constants.js"() {
15810
15810
  "use strict";
15811
15811
  IMAGE_EXT_LIST = [
15812
15812
  ".jpg",
@@ -15823,10 +15823,10 @@ var init_constants2 = __esm({
15823
15823
  }
15824
15824
  });
15825
15825
 
15826
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/materials/FsResource.js
15826
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/materials/FsResource.js
15827
15827
  var import_path, FS_RESOURCE, FsResource;
15828
15828
  var init_FsResource = __esm({
15829
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/materials/FsResource.js"() {
15829
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/materials/FsResource.js"() {
15830
15830
  "use strict";
15831
15831
  import_path = __toESM(require("path"));
15832
15832
  init_fs_extra();
@@ -15857,10 +15857,10 @@ var init_FsResource = __esm({
15857
15857
  }
15858
15858
  });
15859
15859
 
15860
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/materials/FsMaterial.js
15860
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/materials/FsMaterial.js
15861
15861
  var import_path2, promisifyGlob, FsMaterial;
15862
15862
  var init_FsMaterial = __esm({
15863
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/materials/FsMaterial.js"() {
15863
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/materials/FsMaterial.js"() {
15864
15864
  "use strict";
15865
15865
  import_path2 = __toESM(require("path"));
15866
15866
  init_glob();
@@ -15893,11 +15893,11 @@ var init_FsMaterial = __esm({
15893
15893
  }
15894
15894
  });
15895
15895
 
15896
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/fsExists.js
15897
- function fsExists(path8) {
15896
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/fsExists.js
15897
+ function fsExists(path9) {
15898
15898
  return __async(this, null, function* () {
15899
15899
  try {
15900
- yield import_fs_extra.default.access(path8);
15900
+ yield import_fs_extra.default.access(path9);
15901
15901
  return true;
15902
15902
  } catch (e) {
15903
15903
  return false;
@@ -15905,26 +15905,26 @@ function fsExists(path8) {
15905
15905
  });
15906
15906
  }
15907
15907
  var init_fsExists = __esm({
15908
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/fsExists.js"() {
15908
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/fsExists.js"() {
15909
15909
  "use strict";
15910
15910
  init_fs_extra();
15911
15911
  }
15912
15912
  });
15913
15913
 
15914
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/nodeRequire.js
15914
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/nodeRequire.js
15915
15915
  var nodeRequire;
15916
15916
  var init_nodeRequire = __esm({
15917
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/nodeRequire.js"() {
15917
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/nodeRequire.js"() {
15918
15918
  "use strict";
15919
- nodeRequire = (path8) => {
15919
+ nodeRequire = (path9) => {
15920
15920
  try {
15921
- const module2 = __non_webpack_require__(path8);
15921
+ const module2 = __non_webpack_require__(path9);
15922
15922
  if (module2 === null || module2 === void 0 ? void 0 : module2.default) {
15923
15923
  return module2.default;
15924
15924
  }
15925
15925
  return module2;
15926
15926
  } catch (error) {
15927
- const module2 = require(path8);
15927
+ const module2 = require(path9);
15928
15928
  if (module2 === null || module2 === void 0 ? void 0 : module2.default) {
15929
15929
  return module2.default;
15930
15930
  }
@@ -15941,7 +15941,7 @@ var require_windows = __commonJS({
15941
15941
  module2.exports = isexe;
15942
15942
  isexe.sync = sync;
15943
15943
  var fs2 = require("fs");
15944
- function checkPathExt(path8, options) {
15944
+ function checkPathExt(path9, options) {
15945
15945
  var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
15946
15946
  if (!pathext) {
15947
15947
  return true;
@@ -15952,25 +15952,25 @@ var require_windows = __commonJS({
15952
15952
  }
15953
15953
  for (var i = 0; i < pathext.length; i++) {
15954
15954
  var p = pathext[i].toLowerCase();
15955
- if (p && path8.substr(-p.length).toLowerCase() === p) {
15955
+ if (p && path9.substr(-p.length).toLowerCase() === p) {
15956
15956
  return true;
15957
15957
  }
15958
15958
  }
15959
15959
  return false;
15960
15960
  }
15961
- function checkStat(stat, path8, options) {
15961
+ function checkStat(stat, path9, options) {
15962
15962
  if (!stat.isSymbolicLink() && !stat.isFile()) {
15963
15963
  return false;
15964
15964
  }
15965
- return checkPathExt(path8, options);
15965
+ return checkPathExt(path9, options);
15966
15966
  }
15967
- function isexe(path8, options, cb) {
15968
- fs2.stat(path8, function(er, stat) {
15969
- cb(er, er ? false : checkStat(stat, path8, options));
15967
+ function isexe(path9, options, cb) {
15968
+ fs2.stat(path9, function(er, stat) {
15969
+ cb(er, er ? false : checkStat(stat, path9, options));
15970
15970
  });
15971
15971
  }
15972
- function sync(path8, options) {
15973
- return checkStat(fs2.statSync(path8), path8, options);
15972
+ function sync(path9, options) {
15973
+ return checkStat(fs2.statSync(path9), path9, options);
15974
15974
  }
15975
15975
  }
15976
15976
  });
@@ -15982,13 +15982,13 @@ var require_mode = __commonJS({
15982
15982
  module2.exports = isexe;
15983
15983
  isexe.sync = sync;
15984
15984
  var fs2 = require("fs");
15985
- function isexe(path8, options, cb) {
15986
- fs2.stat(path8, function(er, stat) {
15985
+ function isexe(path9, options, cb) {
15986
+ fs2.stat(path9, function(er, stat) {
15987
15987
  cb(er, er ? false : checkStat(stat, options));
15988
15988
  });
15989
15989
  }
15990
- function sync(path8, options) {
15991
- return checkStat(fs2.statSync(path8), options);
15990
+ function sync(path9, options) {
15991
+ return checkStat(fs2.statSync(path9), options);
15992
15992
  }
15993
15993
  function checkStat(stat, options) {
15994
15994
  return stat.isFile() && checkMode(stat, options);
@@ -16022,7 +16022,7 @@ var require_isexe = __commonJS({
16022
16022
  }
16023
16023
  module2.exports = isexe;
16024
16024
  isexe.sync = sync;
16025
- function isexe(path8, options, cb) {
16025
+ function isexe(path9, options, cb) {
16026
16026
  if (typeof options === "function") {
16027
16027
  cb = options;
16028
16028
  options = {};
@@ -16032,7 +16032,7 @@ var require_isexe = __commonJS({
16032
16032
  throw new TypeError("callback not provided");
16033
16033
  }
16034
16034
  return new Promise(function(resolve, reject) {
16035
- isexe(path8, options || {}, function(er, is) {
16035
+ isexe(path9, options || {}, function(er, is) {
16036
16036
  if (er) {
16037
16037
  reject(er);
16038
16038
  } else {
@@ -16041,7 +16041,7 @@ var require_isexe = __commonJS({
16041
16041
  });
16042
16042
  });
16043
16043
  }
16044
- core(path8, options || {}, function(er, is) {
16044
+ core(path9, options || {}, function(er, is) {
16045
16045
  if (er) {
16046
16046
  if (er.code === "EACCES" || options && options.ignoreErrors) {
16047
16047
  er = null;
@@ -16051,9 +16051,9 @@ var require_isexe = __commonJS({
16051
16051
  cb(er, is);
16052
16052
  });
16053
16053
  }
16054
- function sync(path8, options) {
16054
+ function sync(path9, options) {
16055
16055
  try {
16056
- return core.sync(path8, options || {});
16056
+ return core.sync(path9, options || {});
16057
16057
  } catch (er) {
16058
16058
  if (options && options.ignoreErrors || er.code === "EACCES") {
16059
16059
  return false;
@@ -16070,7 +16070,7 @@ var require_which = __commonJS({
16070
16070
  "../../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports, module2) {
16071
16071
  "use strict";
16072
16072
  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
16073
- var path8 = require("path");
16073
+ var path9 = require("path");
16074
16074
  var COLON = isWindows ? ";" : ":";
16075
16075
  var isexe = require_isexe();
16076
16076
  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -16108,7 +16108,7 @@ var require_which = __commonJS({
16108
16108
  return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
16109
16109
  const ppRaw = pathEnv[i];
16110
16110
  const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
16111
- const pCmd = path8.join(pathPart, cmd);
16111
+ const pCmd = path9.join(pathPart, cmd);
16112
16112
  const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
16113
16113
  resolve(subStep(p, i, 0));
16114
16114
  });
@@ -16135,7 +16135,7 @@ var require_which = __commonJS({
16135
16135
  for (let i = 0; i < pathEnv.length; i++) {
16136
16136
  const ppRaw = pathEnv[i];
16137
16137
  const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
16138
- const pCmd = path8.join(pathPart, cmd);
16138
+ const pCmd = path9.join(pathPart, cmd);
16139
16139
  const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
16140
16140
  for (let j = 0; j < pathExt.length; j++) {
16141
16141
  const cur = p + pathExt[j];
@@ -16183,7 +16183,7 @@ var require_path_key = __commonJS({
16183
16183
  var require_resolveCommand = __commonJS({
16184
16184
  "../../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module2) {
16185
16185
  "use strict";
16186
- var path8 = require("path");
16186
+ var path9 = require("path");
16187
16187
  var which = require_which();
16188
16188
  var getPathKey = require_path_key();
16189
16189
  function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -16201,7 +16201,7 @@ var require_resolveCommand = __commonJS({
16201
16201
  try {
16202
16202
  resolved = which.sync(parsed.command, {
16203
16203
  path: env[getPathKey({ env })],
16204
- pathExt: withoutPathExt ? path8.delimiter : void 0
16204
+ pathExt: withoutPathExt ? path9.delimiter : void 0
16205
16205
  });
16206
16206
  } catch (e) {
16207
16207
  } finally {
@@ -16210,7 +16210,7 @@ var require_resolveCommand = __commonJS({
16210
16210
  }
16211
16211
  }
16212
16212
  if (resolved) {
16213
- resolved = path8.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
16213
+ resolved = path9.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
16214
16214
  }
16215
16215
  return resolved;
16216
16216
  }
@@ -16264,8 +16264,8 @@ var require_shebang_command = __commonJS({
16264
16264
  if (!match) {
16265
16265
  return null;
16266
16266
  }
16267
- const [path8, argument] = match[0].replace(/#! ?/, "").split(" ");
16268
- const binary = path8.split("/").pop();
16267
+ const [path9, argument] = match[0].replace(/#! ?/, "").split(" ");
16268
+ const binary = path9.split("/").pop();
16269
16269
  if (binary === "env") {
16270
16270
  return argument;
16271
16271
  }
@@ -16300,7 +16300,7 @@ var require_readShebang = __commonJS({
16300
16300
  var require_parse = __commonJS({
16301
16301
  "../../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js"(exports, module2) {
16302
16302
  "use strict";
16303
- var path8 = require("path");
16303
+ var path9 = require("path");
16304
16304
  var resolveCommand = require_resolveCommand();
16305
16305
  var escape = require_escape();
16306
16306
  var readShebang = require_readShebang();
@@ -16325,7 +16325,7 @@ var require_parse = __commonJS({
16325
16325
  const needsShell = !isExecutableRegExp.test(commandFile);
16326
16326
  if (parsed.options.forceShell || needsShell) {
16327
16327
  const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
16328
- parsed.command = path8.normalize(parsed.command);
16328
+ parsed.command = path9.normalize(parsed.command);
16329
16329
  parsed.command = escape.command(parsed.command);
16330
16330
  parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
16331
16331
  const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -16457,7 +16457,7 @@ var require_strip_final_newline = __commonJS({
16457
16457
  var require_npm_run_path = __commonJS({
16458
16458
  "../../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js"(exports, module2) {
16459
16459
  "use strict";
16460
- var path8 = require("path");
16460
+ var path9 = require("path");
16461
16461
  var pathKey = require_path_key();
16462
16462
  var npmRunPath = (options) => {
16463
16463
  options = __spreadValues({
@@ -16466,16 +16466,16 @@ var require_npm_run_path = __commonJS({
16466
16466
  execPath: process.execPath
16467
16467
  }, options);
16468
16468
  let previous;
16469
- let cwdPath = path8.resolve(options.cwd);
16469
+ let cwdPath = path9.resolve(options.cwd);
16470
16470
  const result = [];
16471
16471
  while (previous !== cwdPath) {
16472
- result.push(path8.join(cwdPath, "node_modules/.bin"));
16472
+ result.push(path9.join(cwdPath, "node_modules/.bin"));
16473
16473
  previous = cwdPath;
16474
- cwdPath = path8.resolve(cwdPath, "..");
16474
+ cwdPath = path9.resolve(cwdPath, "..");
16475
16475
  }
16476
- const execPathDir = path8.resolve(options.cwd, options.execPath, "..");
16476
+ const execPathDir = path9.resolve(options.cwd, options.execPath, "..");
16477
16477
  result.push(execPathDir);
16478
- return result.concat(options.path).join(path8.delimiter);
16478
+ return result.concat(options.path).join(path9.delimiter);
16479
16479
  };
16480
16480
  module2.exports = npmRunPath;
16481
16481
  module2.exports.default = npmRunPath;
@@ -16484,9 +16484,9 @@ var require_npm_run_path = __commonJS({
16484
16484
  env: process.env
16485
16485
  }, options);
16486
16486
  const env = __spreadValues({}, options.env);
16487
- const path9 = pathKey({ env });
16488
- options.path = env[path9];
16489
- env[path9] = module2.exports(options);
16487
+ const path10 = pathKey({ env });
16488
+ options.path = env[path10];
16489
+ env[path10] = module2.exports(options);
16490
16490
  return env;
16491
16491
  };
16492
16492
  }
@@ -17670,7 +17670,7 @@ var require_command2 = __commonJS({
17670
17670
  var require_execa = __commonJS({
17671
17671
  "../../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/index.js"(exports, module2) {
17672
17672
  "use strict";
17673
- var path8 = require("path");
17673
+ var path9 = require("path");
17674
17674
  var childProcess = require("child_process");
17675
17675
  var crossSpawn = require_cross_spawn();
17676
17676
  var stripFinalNewline = require_strip_final_newline();
@@ -17711,7 +17711,7 @@ var require_execa = __commonJS({
17711
17711
  }, options);
17712
17712
  options.env = getEnv(options);
17713
17713
  options.stdio = normalizeStdio(options);
17714
- if (process.platform === "win32" && path8.basename(file, ".exe") === "cmd") {
17714
+ if (process.platform === "win32" && path9.basename(file, ".exe") === "cmd") {
17715
17715
  args.unshift("/q");
17716
17716
  }
17717
17717
  return { file, args, options, parsed };
@@ -17892,16 +17892,16 @@ var require_execa = __commonJS({
17892
17892
  }
17893
17893
  });
17894
17894
 
17895
- // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/execa.js
17895
+ // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/execa.js
17896
17896
  var import_execa;
17897
17897
  var init_execa = __esm({
17898
- "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/execa.js"() {
17898
+ "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/execa.js"() {
17899
17899
  "use strict";
17900
17900
  import_execa = __toESM(require_execa());
17901
17901
  }
17902
17902
  });
17903
17903
 
17904
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/packageManager.js
17904
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/packageManager.js
17905
17905
  function canUseYarn() {
17906
17906
  return __async(this, null, function* () {
17907
17907
  try {
@@ -17986,7 +17986,7 @@ function runInstall(targetDir, registryUrl, logger) {
17986
17986
  }
17987
17987
  var import_path3;
17988
17988
  var init_packageManager = __esm({
17989
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/packageManager.js"() {
17989
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/packageManager.js"() {
17990
17990
  "use strict";
17991
17991
  import_path3 = __toESM(require("path"));
17992
17992
  init_execa();
@@ -17994,7 +17994,7 @@ var init_packageManager = __esm({
17994
17994
  }
17995
17995
  });
17996
17996
 
17997
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/timeoutPromise.js
17997
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/timeoutPromise.js
17998
17998
  function timeoutPromise(promise, ms, reason = "Operation") {
17999
17999
  return __async(this, null, function* () {
18000
18000
  let timeoutId = null;
@@ -18018,15 +18018,15 @@ function timeoutPromise(promise, ms, reason = "Operation") {
18018
18018
  });
18019
18019
  }
18020
18020
  var init_timeoutPromise = __esm({
18021
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/timeoutPromise.js"() {
18021
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/timeoutPromise.js"() {
18022
18022
  "use strict";
18023
18023
  }
18024
18024
  });
18025
18025
 
18026
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/constants.js
18026
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/constants.js
18027
18027
  var NPM_API_TIMEOUT, CATCHE_VALIDITY_PREIOD;
18028
18028
  var init_constants3 = __esm({
18029
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/constants.js"() {
18029
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/constants.js"() {
18030
18030
  "use strict";
18031
18031
  NPM_API_TIMEOUT = 3e4;
18032
18032
  CATCHE_VALIDITY_PREIOD = 7 * 24 * 3600 * 1e3;
@@ -20518,10 +20518,10 @@ var require_semver2 = __commonJS({
20518
20518
  }
20519
20519
  });
20520
20520
 
20521
- // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/semver.js
20521
+ // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/semver.js
20522
20522
  var import_semver;
20523
20523
  var init_semver = __esm({
20524
- "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/semver.js"() {
20524
+ "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/semver.js"() {
20525
20525
  "use strict";
20526
20526
  import_semver = __toESM(require_semver2());
20527
20527
  }
@@ -29849,11 +29849,11 @@ var require_mime_types = __commonJS({
29849
29849
  }
29850
29850
  return exts[0];
29851
29851
  }
29852
- function lookup(path8) {
29853
- if (!path8 || typeof path8 !== "string") {
29852
+ function lookup(path9) {
29853
+ if (!path9 || typeof path9 !== "string") {
29854
29854
  return false;
29855
29855
  }
29856
- var extension2 = extname("x." + path8).toLowerCase().substr(1);
29856
+ var extension2 = extname("x." + path9).toLowerCase().substr(1);
29857
29857
  if (!extension2) {
29858
29858
  return false;
29859
29859
  }
@@ -30968,7 +30968,7 @@ var require_form_data = __commonJS({
30968
30968
  "use strict";
30969
30969
  var CombinedStream = require_combined_stream();
30970
30970
  var util3 = require("util");
30971
- var path8 = require("path");
30971
+ var path9 = require("path");
30972
30972
  var http2 = require("http");
30973
30973
  var https2 = require("https");
30974
30974
  var parseUrl = require("url").parse;
@@ -31096,11 +31096,11 @@ var require_form_data = __commonJS({
31096
31096
  FormData3.prototype._getContentDisposition = function(value, options) {
31097
31097
  var filename, contentDisposition;
31098
31098
  if (typeof options.filepath === "string") {
31099
- filename = path8.normalize(options.filepath).replace(/\\/g, "/");
31099
+ filename = path9.normalize(options.filepath).replace(/\\/g, "/");
31100
31100
  } else if (options.filename || value.name || value.path) {
31101
- filename = path8.basename(options.filename || value.name || value.path);
31101
+ filename = path9.basename(options.filename || value.name || value.path);
31102
31102
  } else if (value.readable && Object.prototype.hasOwnProperty.call(value, "httpVersion")) {
31103
- filename = path8.basename(value.client._httpMessage.path || "");
31103
+ filename = path9.basename(value.client._httpMessage.path || "");
31104
31104
  }
31105
31105
  if (filename) {
31106
31106
  contentDisposition = 'filename="' + filename + '"';
@@ -31297,10 +31297,10 @@ function isVisitable(thing) {
31297
31297
  function removeBrackets(key) {
31298
31298
  return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
31299
31299
  }
31300
- function renderKey(path8, key, dots) {
31301
- if (!path8)
31300
+ function renderKey(path9, key, dots) {
31301
+ if (!path9)
31302
31302
  return key;
31303
- return path8.concat(key).map(function each(token, i) {
31303
+ return path9.concat(key).map(function each(token, i) {
31304
31304
  token = removeBrackets(token);
31305
31305
  return !dots && i ? "[" + token + "]" : token;
31306
31306
  }).join(dots ? "." : "");
@@ -31343,9 +31343,9 @@ function toFormData(obj, formData, options) {
31343
31343
  }
31344
31344
  return value;
31345
31345
  }
31346
- function defaultVisitor(value, key, path8) {
31346
+ function defaultVisitor(value, key, path9) {
31347
31347
  let arr = value;
31348
- if (value && !path8 && typeof value === "object") {
31348
+ if (value && !path9 && typeof value === "object") {
31349
31349
  if (utils_default.endsWith(key, "{}")) {
31350
31350
  key = metaTokens ? key : key.slice(0, -2);
31351
31351
  value = JSON.stringify(value);
@@ -31364,7 +31364,7 @@ function toFormData(obj, formData, options) {
31364
31364
  if (isVisitable(value)) {
31365
31365
  return true;
31366
31366
  }
31367
- formData.append(renderKey(path8, key, dots), convertValue(value));
31367
+ formData.append(renderKey(path9, key, dots), convertValue(value));
31368
31368
  return false;
31369
31369
  }
31370
31370
  const stack = [];
@@ -31373,11 +31373,11 @@ function toFormData(obj, formData, options) {
31373
31373
  convertValue,
31374
31374
  isVisitable
31375
31375
  });
31376
- function build(value, path8) {
31376
+ function build(value, path9) {
31377
31377
  if (utils_default.isUndefined(value))
31378
31378
  return;
31379
31379
  if (stack.indexOf(value) !== -1) {
31380
- throw Error("Circular reference detected in " + path8.join("."));
31380
+ throw Error("Circular reference detected in " + path9.join("."));
31381
31381
  }
31382
31382
  stack.push(value);
31383
31383
  utils_default.forEach(value, function each(el, key) {
@@ -31385,11 +31385,11 @@ function toFormData(obj, formData, options) {
31385
31385
  formData,
31386
31386
  el,
31387
31387
  utils_default.isString(key) ? key.trim() : key,
31388
- path8,
31388
+ path9,
31389
31389
  exposedHelpers
31390
31390
  );
31391
31391
  if (result === true) {
31392
- build(el, path8 ? path8.concat(key) : [key]);
31392
+ build(el, path9 ? path9.concat(key) : [key]);
31393
31393
  }
31394
31394
  });
31395
31395
  stack.pop();
@@ -31663,7 +31663,7 @@ var init_platform = __esm({
31663
31663
  // ../../../node_modules/.pnpm/axios@1.8.4_debug@4.3.7/node_modules/axios/lib/helpers/toURLEncodedForm.js
31664
31664
  function toURLEncodedForm(data, options) {
31665
31665
  return toFormData_default(data, new platform_default.classes.URLSearchParams(), Object.assign({
31666
- visitor: function(value, key, path8, helpers) {
31666
+ visitor: function(value, key, path9, helpers) {
31667
31667
  if (platform_default.isNode && utils_default.isBuffer(value)) {
31668
31668
  this.append(key, value.toString("base64"));
31669
31669
  return false;
@@ -31700,12 +31700,12 @@ function arrayToObject(arr) {
31700
31700
  return obj;
31701
31701
  }
31702
31702
  function formDataToJSON(formData) {
31703
- function buildPath(path8, value, target, index) {
31704
- let name = path8[index++];
31703
+ function buildPath(path9, value, target, index) {
31704
+ let name = path9[index++];
31705
31705
  if (name === "__proto__")
31706
31706
  return true;
31707
31707
  const isNumericKey = Number.isFinite(+name);
31708
- const isLast = index >= path8.length;
31708
+ const isLast = index >= path9.length;
31709
31709
  name = !name && utils_default.isArray(target) ? target.length : name;
31710
31710
  if (isLast) {
31711
31711
  if (utils_default.hasOwnProp(target, name)) {
@@ -31718,7 +31718,7 @@ function formDataToJSON(formData) {
31718
31718
  if (!target[name] || !utils_default.isObject(target[name])) {
31719
31719
  target[name] = [];
31720
31720
  }
31721
- const result = buildPath(path8, value, target[name], index);
31721
+ const result = buildPath(path9, value, target[name], index);
31722
31722
  if (result && utils_default.isArray(target[name])) {
31723
31723
  target[name] = arrayToObject(target[name]);
31724
31724
  }
@@ -33610,9 +33610,9 @@ var init_http = __esm({
33610
33610
  auth = urlUsername + ":" + urlPassword;
33611
33611
  }
33612
33612
  auth && headers.delete("authorization");
33613
- let path8;
33613
+ let path9;
33614
33614
  try {
33615
- path8 = buildURL(
33615
+ path9 = buildURL(
33616
33616
  parsed.pathname + parsed.search,
33617
33617
  config.params,
33618
33618
  config.paramsSerializer
@@ -33630,7 +33630,7 @@ var init_http = __esm({
33630
33630
  false
33631
33631
  );
33632
33632
  const options = {
33633
- path: path8,
33633
+ path: path9,
33634
33634
  method,
33635
33635
  headers: headers.toJSON(),
33636
33636
  agents: { http: config.httpAgent, https: config.httpsAgent },
@@ -33878,10 +33878,10 @@ var init_cookies = __esm({
33878
33878
  cookies_default = platform_default.hasStandardBrowserEnv ? (
33879
33879
  // Standard browser envs support document.cookie
33880
33880
  {
33881
- write(name, value, expires, path8, domain, secure) {
33881
+ write(name, value, expires, path9, domain, secure) {
33882
33882
  const cookie = [name + "=" + encodeURIComponent(value)];
33883
33883
  utils_default.isNumber(expires) && cookie.push("expires=" + new Date(expires).toGMTString());
33884
- utils_default.isString(path8) && cookie.push("path=" + path8);
33884
+ utils_default.isString(path9) && cookie.push("path=" + path9);
33885
33885
  utils_default.isString(domain) && cookie.push("domain=" + domain);
33886
33886
  secure === true && cookie.push("secure");
33887
33887
  document.cookie = cookie.join("; ");
@@ -37080,10 +37080,10 @@ var require_header = __commonJS({
37080
37080
  }
37081
37081
  const prefixSize = this.ctime || this.atime ? 130 : 155;
37082
37082
  const split = splitPrefix(this.path || "", prefixSize);
37083
- const path8 = split[0];
37083
+ const path9 = split[0];
37084
37084
  const prefix = split[1];
37085
37085
  this.needPax = split[2];
37086
- this.needPax = encString(buf, off, 100, path8) || this.needPax;
37086
+ this.needPax = encString(buf, off, 100, path9) || this.needPax;
37087
37087
  this.needPax = encNumber(buf, off + 100, 8, this.mode) || this.needPax;
37088
37088
  this.needPax = encNumber(buf, off + 108, 8, this.uid) || this.needPax;
37089
37089
  this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax;
@@ -37193,7 +37193,7 @@ var require_pax = __commonJS({
37193
37193
  "../../../node_modules/.pnpm/tar@6.2.1/node_modules/tar/lib/pax.js"(exports, module2) {
37194
37194
  "use strict";
37195
37195
  var Header = require_header();
37196
- var path8 = require("path");
37196
+ var path9 = require("path");
37197
37197
  var Pax = class {
37198
37198
  constructor(obj, global2) {
37199
37199
  this.atime = obj.atime || null;
@@ -37228,7 +37228,7 @@ var require_pax = __commonJS({
37228
37228
  // XXX split the path
37229
37229
  // then the path should be PaxHeader + basename, but less than 99,
37230
37230
  // prepend with the dirname
37231
- path: ("PaxHeader/" + path8.basename(this.path)).slice(0, 99),
37231
+ path: ("PaxHeader/" + path9.basename(this.path)).slice(0, 99),
37232
37232
  mode: this.mode || 420,
37233
37233
  uid: this.uid || null,
37234
37234
  gid: this.gid || null,
@@ -37361,16 +37361,16 @@ var require_strip_absolute_path = __commonJS({
37361
37361
  "../../../node_modules/.pnpm/tar@6.2.1/node_modules/tar/lib/strip-absolute-path.js"(exports, module2) {
37362
37362
  "use strict";
37363
37363
  var { isAbsolute, parse } = require("path").win32;
37364
- module2.exports = (path8) => {
37364
+ module2.exports = (path9) => {
37365
37365
  let r = "";
37366
- let parsed = parse(path8);
37367
- while (isAbsolute(path8) || parsed.root) {
37368
- const root = path8.charAt(0) === "/" && path8.slice(0, 4) !== "//?/" ? "/" : parsed.root;
37369
- path8 = path8.slice(root.length);
37366
+ let parsed = parse(path9);
37367
+ while (isAbsolute(path9) || parsed.root) {
37368
+ const root = path9.charAt(0) === "/" && path9.slice(0, 4) !== "//?/" ? "/" : parsed.root;
37369
+ path9 = path9.slice(root.length);
37370
37370
  r += root;
37371
- parsed = parse(path8);
37371
+ parsed = parse(path9);
37372
37372
  }
37373
- return [r, path8];
37373
+ return [r, path9];
37374
37374
  };
37375
37375
  }
37376
37376
  });
@@ -37408,15 +37408,15 @@ var require_write_entry = __commonJS({
37408
37408
  var Pax = require_pax();
37409
37409
  var Header = require_header();
37410
37410
  var fs2 = require("fs");
37411
- var path8 = require("path");
37411
+ var path9 = require("path");
37412
37412
  var normPath = require_normalize_windows_path();
37413
37413
  var stripSlash = require_strip_trailing_slashes();
37414
- var prefixPath = (path9, prefix) => {
37414
+ var prefixPath = (path10, prefix) => {
37415
37415
  if (!prefix) {
37416
- return normPath(path9);
37416
+ return normPath(path10);
37417
37417
  }
37418
- path9 = normPath(path9).replace(/^\.(\/|$)/, "");
37419
- return stripSlash(prefix) + "/" + path9;
37418
+ path10 = normPath(path10).replace(/^\.(\/|$)/, "");
37419
+ return stripSlash(prefix) + "/" + path10;
37420
37420
  };
37421
37421
  var maxReadSize = 16 * 1024 * 1024;
37422
37422
  var PROCESS = Symbol("process");
@@ -37487,7 +37487,7 @@ var require_write_entry = __commonJS({
37487
37487
  this.path = winchars.decode(this.path.replace(/\\/g, "/"));
37488
37488
  p = p.replace(/\\/g, "/");
37489
37489
  }
37490
- this.absolute = normPath(opt.absolute || path8.resolve(this.cwd, p));
37490
+ this.absolute = normPath(opt.absolute || path9.resolve(this.cwd, p));
37491
37491
  if (this.path === "") {
37492
37492
  this.path = "./";
37493
37493
  }
@@ -37542,8 +37542,8 @@ var require_write_entry = __commonJS({
37542
37542
  [MODE](mode) {
37543
37543
  return modeFix(mode, this.type === "Directory", this.portable);
37544
37544
  }
37545
- [PREFIX](path9) {
37546
- return prefixPath(path9, this.prefix);
37545
+ [PREFIX](path10) {
37546
+ return prefixPath(path10, this.prefix);
37547
37547
  }
37548
37548
  [HEADER]() {
37549
37549
  if (this.type === "Directory" && this.portable) {
@@ -37606,7 +37606,7 @@ var require_write_entry = __commonJS({
37606
37606
  }
37607
37607
  [HARDLINK](linkpath) {
37608
37608
  this.type = "Link";
37609
- this.linkpath = normPath(path8.relative(this.cwd, linkpath));
37609
+ this.linkpath = normPath(path9.relative(this.cwd, linkpath));
37610
37610
  this.stat.size = 0;
37611
37611
  this[HEADER]();
37612
37612
  this.end();
@@ -37837,8 +37837,8 @@ var require_write_entry = __commonJS({
37837
37837
  super.write(this.header.block);
37838
37838
  readEntry.pipe(this);
37839
37839
  }
37840
- [PREFIX](path9) {
37841
- return prefixPath(path9, this.prefix);
37840
+ [PREFIX](path10) {
37841
+ return prefixPath(path10, this.prefix);
37842
37842
  }
37843
37843
  [MODE](mode) {
37844
37844
  return modeFix(mode, this.type === "Directory", this.portable);
@@ -37870,8 +37870,8 @@ var require_pack = __commonJS({
37870
37870
  "../../../node_modules/.pnpm/tar@6.2.1/node_modules/tar/lib/pack.js"(exports, module2) {
37871
37871
  "use strict";
37872
37872
  var PackJob = class {
37873
- constructor(path9, absolute) {
37874
- this.path = path9 || "./";
37873
+ constructor(path10, absolute) {
37874
+ this.path = path10 || "./";
37875
37875
  this.absolute = absolute;
37876
37876
  this.entry = null;
37877
37877
  this.stat = null;
@@ -37910,7 +37910,7 @@ var require_pack = __commonJS({
37910
37910
  var WRITE = Symbol("write");
37911
37911
  var ONDRAIN = Symbol("ondrain");
37912
37912
  var fs2 = require("fs");
37913
- var path8 = require("path");
37913
+ var path9 = require("path");
37914
37914
  var warner = require_warn_mixin();
37915
37915
  var normPath = require_normalize_windows_path();
37916
37916
  var Pack = warner(class Pack extends Minipass {
@@ -37974,31 +37974,31 @@ var require_pack = __commonJS({
37974
37974
  [WRITE](chunk) {
37975
37975
  return super.write(chunk);
37976
37976
  }
37977
- add(path9) {
37978
- this.write(path9);
37977
+ add(path10) {
37978
+ this.write(path10);
37979
37979
  return this;
37980
37980
  }
37981
- end(path9) {
37982
- if (path9) {
37983
- this.write(path9);
37981
+ end(path10) {
37982
+ if (path10) {
37983
+ this.write(path10);
37984
37984
  }
37985
37985
  this[ENDED] = true;
37986
37986
  this[PROCESS]();
37987
37987
  return this;
37988
37988
  }
37989
- write(path9) {
37989
+ write(path10) {
37990
37990
  if (this[ENDED]) {
37991
37991
  throw new Error("write after end");
37992
37992
  }
37993
- if (path9 instanceof ReadEntry) {
37994
- this[ADDTARENTRY](path9);
37993
+ if (path10 instanceof ReadEntry) {
37994
+ this[ADDTARENTRY](path10);
37995
37995
  } else {
37996
- this[ADDFSENTRY](path9);
37996
+ this[ADDFSENTRY](path10);
37997
37997
  }
37998
37998
  return this.flowing;
37999
37999
  }
38000
38000
  [ADDTARENTRY](p) {
38001
- const absolute = normPath(path8.resolve(this.cwd, p.path));
38001
+ const absolute = normPath(path9.resolve(this.cwd, p.path));
38002
38002
  if (!this.filter(p.path, p)) {
38003
38003
  p.resume();
38004
38004
  } else {
@@ -38011,7 +38011,7 @@ var require_pack = __commonJS({
38011
38011
  this[PROCESS]();
38012
38012
  }
38013
38013
  [ADDFSENTRY](p) {
38014
- const absolute = normPath(path8.resolve(this.cwd, p));
38014
+ const absolute = normPath(path9.resolve(this.cwd, p));
38015
38015
  this[QUEUE].push(new PackJob(p, absolute));
38016
38016
  this[PROCESS]();
38017
38017
  }
@@ -38281,16 +38281,16 @@ var require_fs_minipass = __commonJS({
38281
38281
  var _defaultFlag = Symbol("_defaultFlag");
38282
38282
  var _errored = Symbol("_errored");
38283
38283
  var ReadStream = class extends MiniPass {
38284
- constructor(path8, opt) {
38284
+ constructor(path9, opt) {
38285
38285
  opt = opt || {};
38286
38286
  super(opt);
38287
38287
  this.readable = true;
38288
38288
  this.writable = false;
38289
- if (typeof path8 !== "string")
38289
+ if (typeof path9 !== "string")
38290
38290
  throw new TypeError("path must be a string");
38291
38291
  this[_errored] = false;
38292
38292
  this[_fd] = typeof opt.fd === "number" ? opt.fd : null;
38293
- this[_path] = path8;
38293
+ this[_path] = path9;
38294
38294
  this[_readSize] = opt.readSize || 16 * 1024 * 1024;
38295
38295
  this[_reading] = false;
38296
38296
  this[_size] = typeof opt.size === "number" ? opt.size : Infinity;
@@ -38427,7 +38427,7 @@ var require_fs_minipass = __commonJS({
38427
38427
  }
38428
38428
  };
38429
38429
  var WriteStream = class extends EE {
38430
- constructor(path8, opt) {
38430
+ constructor(path9, opt) {
38431
38431
  opt = opt || {};
38432
38432
  super(opt);
38433
38433
  this.readable = false;
@@ -38437,7 +38437,7 @@ var require_fs_minipass = __commonJS({
38437
38437
  this[_ended] = false;
38438
38438
  this[_needDrain] = false;
38439
38439
  this[_queue] = [];
38440
- this[_path] = path8;
38440
+ this[_path] = path9;
38441
38441
  this[_fd] = typeof opt.fd === "number" ? opt.fd : null;
38442
38442
  this[_mode] = opt.mode === void 0 ? 438 : opt.mode;
38443
38443
  this[_pos] = typeof opt.start === "number" ? opt.start : null;
@@ -39041,7 +39041,7 @@ var require_list = __commonJS({
39041
39041
  var Parser = require_parse3();
39042
39042
  var fs2 = require("fs");
39043
39043
  var fsm = require_fs_minipass();
39044
- var path8 = require("path");
39044
+ var path9 = require("path");
39045
39045
  var stripSlash = require_strip_trailing_slashes();
39046
39046
  module2.exports = (opt_, files, cb) => {
39047
39047
  if (typeof opt_ === "function") {
@@ -39083,8 +39083,8 @@ var require_list = __commonJS({
39083
39083
  const map = new Map(files.map((f) => [stripSlash(f), true]));
39084
39084
  const filter2 = opt.filter;
39085
39085
  const mapHas = (file, r) => {
39086
- const root = r || path8.parse(file).root || ".";
39087
- const ret = file === root ? false : map.has(file) ? map.get(file) : mapHas(path8.dirname(file), root);
39086
+ const root = r || path9.parse(file).root || ".";
39087
+ const ret = file === root ? false : map.has(file) ? map.get(file) : mapHas(path9.dirname(file), root);
39088
39088
  map.set(file, ret);
39089
39089
  return ret;
39090
39090
  };
@@ -39155,7 +39155,7 @@ var require_create = __commonJS({
39155
39155
  var Pack = require_pack();
39156
39156
  var fsm = require_fs_minipass();
39157
39157
  var t = require_list();
39158
- var path8 = require("path");
39158
+ var path9 = require("path");
39159
39159
  module2.exports = (opt_, files, cb) => {
39160
39160
  if (typeof files === "function") {
39161
39161
  cb = files;
@@ -39202,7 +39202,7 @@ var require_create = __commonJS({
39202
39202
  files.forEach((file) => {
39203
39203
  if (file.charAt(0) === "@") {
39204
39204
  t({
39205
- file: path8.resolve(p.cwd, file.slice(1)),
39205
+ file: path9.resolve(p.cwd, file.slice(1)),
39206
39206
  sync: true,
39207
39207
  noResume: true,
39208
39208
  onentry: (entry) => p.add(entry)
@@ -39218,7 +39218,7 @@ var require_create = __commonJS({
39218
39218
  const file = files.shift();
39219
39219
  if (file.charAt(0) === "@") {
39220
39220
  return t({
39221
- file: path8.resolve(p.cwd, file.slice(1)),
39221
+ file: path9.resolve(p.cwd, file.slice(1)),
39222
39222
  noResume: true,
39223
39223
  onentry: (entry) => p.add(entry)
39224
39224
  }).then((_) => addFilesAsync(p, files));
@@ -39250,7 +39250,7 @@ var require_replace = __commonJS({
39250
39250
  var fs2 = require("fs");
39251
39251
  var fsm = require_fs_minipass();
39252
39252
  var t = require_list();
39253
- var path8 = require("path");
39253
+ var path9 = require("path");
39254
39254
  var Header = require_header();
39255
39255
  module2.exports = (opt_, files, cb) => {
39256
39256
  const opt = hlo(opt_);
@@ -39428,7 +39428,7 @@ var require_replace = __commonJS({
39428
39428
  files.forEach((file) => {
39429
39429
  if (file.charAt(0) === "@") {
39430
39430
  t({
39431
- file: path8.resolve(p.cwd, file.slice(1)),
39431
+ file: path9.resolve(p.cwd, file.slice(1)),
39432
39432
  sync: true,
39433
39433
  noResume: true,
39434
39434
  onentry: (entry) => p.add(entry)
@@ -39444,7 +39444,7 @@ var require_replace = __commonJS({
39444
39444
  const file = files.shift();
39445
39445
  if (file.charAt(0) === "@") {
39446
39446
  return t({
39447
- file: path8.resolve(p.cwd, file.slice(1)),
39447
+ file: path9.resolve(p.cwd, file.slice(1)),
39448
39448
  noResume: true,
39449
39449
  onentry: (entry) => p.add(entry)
39450
39450
  }).then((_) => addFilesAsync(p, files));
@@ -39483,7 +39483,7 @@ var require_update = __commonJS({
39483
39483
  if (!opt.mtimeCache) {
39484
39484
  opt.mtimeCache = /* @__PURE__ */ new Map();
39485
39485
  }
39486
- opt.filter = filter2 ? (path8, stat) => filter2(path8, stat) && !(opt.mtimeCache.get(path8) > stat.mtime) : (path8, stat) => !(opt.mtimeCache.get(path8) > stat.mtime);
39486
+ opt.filter = filter2 ? (path9, stat) => filter2(path9, stat) && !(opt.mtimeCache.get(path9) > stat.mtime) : (path9, stat) => !(opt.mtimeCache.get(path9) > stat.mtime);
39487
39487
  };
39488
39488
  }
39489
39489
  });
@@ -39523,28 +39523,28 @@ var require_path_arg = __commonJS({
39523
39523
  "use strict";
39524
39524
  var platform = process.env.__TESTING_MKDIRP_PLATFORM__ || process.platform;
39525
39525
  var { resolve, parse } = require("path");
39526
- var pathArg = (path8) => {
39527
- if (/\0/.test(path8)) {
39526
+ var pathArg = (path9) => {
39527
+ if (/\0/.test(path9)) {
39528
39528
  throw Object.assign(
39529
39529
  new TypeError("path must be a string without null bytes"),
39530
39530
  {
39531
- path: path8,
39531
+ path: path9,
39532
39532
  code: "ERR_INVALID_ARG_VALUE"
39533
39533
  }
39534
39534
  );
39535
39535
  }
39536
- path8 = resolve(path8);
39536
+ path9 = resolve(path9);
39537
39537
  if (platform === "win32") {
39538
39538
  const badWinChars = /[*|"<>?:]/;
39539
- const { root } = parse(path8);
39540
- if (badWinChars.test(path8.substr(root.length))) {
39539
+ const { root } = parse(path9);
39540
+ if (badWinChars.test(path9.substr(root.length))) {
39541
39541
  throw Object.assign(new Error("Illegal characters in path."), {
39542
- path: path8,
39542
+ path: path9,
39543
39543
  code: "EINVAL"
39544
39544
  });
39545
39545
  }
39546
39546
  }
39547
- return path8;
39547
+ return path9;
39548
39548
  };
39549
39549
  module2.exports = pathArg;
39550
39550
  }
@@ -39555,20 +39555,20 @@ var require_find_made = __commonJS({
39555
39555
  "../../../node_modules/.pnpm/mkdirp@1.0.4/node_modules/mkdirp/lib/find-made.js"(exports, module2) {
39556
39556
  "use strict";
39557
39557
  var { dirname } = require("path");
39558
- var findMade = (opts, parent, path8 = void 0) => {
39559
- if (path8 === parent)
39558
+ var findMade = (opts, parent, path9 = void 0) => {
39559
+ if (path9 === parent)
39560
39560
  return Promise.resolve();
39561
39561
  return opts.statAsync(parent).then(
39562
- (st) => st.isDirectory() ? path8 : void 0,
39562
+ (st) => st.isDirectory() ? path9 : void 0,
39563
39563
  // will fail later
39564
39564
  (er) => er.code === "ENOENT" ? findMade(opts, dirname(parent), parent) : void 0
39565
39565
  );
39566
39566
  };
39567
- var findMadeSync = (opts, parent, path8 = void 0) => {
39568
- if (path8 === parent)
39567
+ var findMadeSync = (opts, parent, path9 = void 0) => {
39568
+ if (path9 === parent)
39569
39569
  return void 0;
39570
39570
  try {
39571
- return opts.statSync(parent).isDirectory() ? path8 : void 0;
39571
+ return opts.statSync(parent).isDirectory() ? path9 : void 0;
39572
39572
  } catch (er) {
39573
39573
  return er.code === "ENOENT" ? findMadeSync(opts, dirname(parent), parent) : void 0;
39574
39574
  }
@@ -39582,21 +39582,21 @@ var require_mkdirp_manual = __commonJS({
39582
39582
  "../../../node_modules/.pnpm/mkdirp@1.0.4/node_modules/mkdirp/lib/mkdirp-manual.js"(exports, module2) {
39583
39583
  "use strict";
39584
39584
  var { dirname } = require("path");
39585
- var mkdirpManual = (path8, opts, made) => {
39585
+ var mkdirpManual = (path9, opts, made) => {
39586
39586
  opts.recursive = false;
39587
- const parent = dirname(path8);
39588
- if (parent === path8) {
39589
- return opts.mkdirAsync(path8, opts).catch((er) => {
39587
+ const parent = dirname(path9);
39588
+ if (parent === path9) {
39589
+ return opts.mkdirAsync(path9, opts).catch((er) => {
39590
39590
  if (er.code !== "EISDIR")
39591
39591
  throw er;
39592
39592
  });
39593
39593
  }
39594
- return opts.mkdirAsync(path8, opts).then(() => made || path8, (er) => {
39594
+ return opts.mkdirAsync(path9, opts).then(() => made || path9, (er) => {
39595
39595
  if (er.code === "ENOENT")
39596
- return mkdirpManual(parent, opts).then((made2) => mkdirpManual(path8, opts, made2));
39596
+ return mkdirpManual(parent, opts).then((made2) => mkdirpManual(path9, opts, made2));
39597
39597
  if (er.code !== "EEXIST" && er.code !== "EROFS")
39598
39598
  throw er;
39599
- return opts.statAsync(path8).then((st) => {
39599
+ return opts.statAsync(path9).then((st) => {
39600
39600
  if (st.isDirectory())
39601
39601
  return made;
39602
39602
  else
@@ -39606,12 +39606,12 @@ var require_mkdirp_manual = __commonJS({
39606
39606
  });
39607
39607
  });
39608
39608
  };
39609
- var mkdirpManualSync = (path8, opts, made) => {
39610
- const parent = dirname(path8);
39609
+ var mkdirpManualSync = (path9, opts, made) => {
39610
+ const parent = dirname(path9);
39611
39611
  opts.recursive = false;
39612
- if (parent === path8) {
39612
+ if (parent === path9) {
39613
39613
  try {
39614
- return opts.mkdirSync(path8, opts);
39614
+ return opts.mkdirSync(path9, opts);
39615
39615
  } catch (er) {
39616
39616
  if (er.code !== "EISDIR")
39617
39617
  throw er;
@@ -39620,15 +39620,15 @@ var require_mkdirp_manual = __commonJS({
39620
39620
  }
39621
39621
  }
39622
39622
  try {
39623
- opts.mkdirSync(path8, opts);
39624
- return made || path8;
39623
+ opts.mkdirSync(path9, opts);
39624
+ return made || path9;
39625
39625
  } catch (er) {
39626
39626
  if (er.code === "ENOENT")
39627
- return mkdirpManualSync(path8, opts, mkdirpManualSync(parent, opts, made));
39627
+ return mkdirpManualSync(path9, opts, mkdirpManualSync(parent, opts, made));
39628
39628
  if (er.code !== "EEXIST" && er.code !== "EROFS")
39629
39629
  throw er;
39630
39630
  try {
39631
- if (!opts.statSync(path8).isDirectory())
39631
+ if (!opts.statSync(path9).isDirectory())
39632
39632
  throw er;
39633
39633
  } catch (_) {
39634
39634
  throw er;
@@ -39646,30 +39646,30 @@ var require_mkdirp_native = __commonJS({
39646
39646
  var { dirname } = require("path");
39647
39647
  var { findMade, findMadeSync } = require_find_made();
39648
39648
  var { mkdirpManual, mkdirpManualSync } = require_mkdirp_manual();
39649
- var mkdirpNative = (path8, opts) => {
39649
+ var mkdirpNative = (path9, opts) => {
39650
39650
  opts.recursive = true;
39651
- const parent = dirname(path8);
39652
- if (parent === path8)
39653
- return opts.mkdirAsync(path8, opts);
39654
- return findMade(opts, path8).then((made) => opts.mkdirAsync(path8, opts).then(() => made).catch((er) => {
39651
+ const parent = dirname(path9);
39652
+ if (parent === path9)
39653
+ return opts.mkdirAsync(path9, opts);
39654
+ return findMade(opts, path9).then((made) => opts.mkdirAsync(path9, opts).then(() => made).catch((er) => {
39655
39655
  if (er.code === "ENOENT")
39656
- return mkdirpManual(path8, opts);
39656
+ return mkdirpManual(path9, opts);
39657
39657
  else
39658
39658
  throw er;
39659
39659
  }));
39660
39660
  };
39661
- var mkdirpNativeSync = (path8, opts) => {
39661
+ var mkdirpNativeSync = (path9, opts) => {
39662
39662
  opts.recursive = true;
39663
- const parent = dirname(path8);
39664
- if (parent === path8)
39665
- return opts.mkdirSync(path8, opts);
39666
- const made = findMadeSync(opts, path8);
39663
+ const parent = dirname(path9);
39664
+ if (parent === path9)
39665
+ return opts.mkdirSync(path9, opts);
39666
+ const made = findMadeSync(opts, path9);
39667
39667
  try {
39668
- opts.mkdirSync(path8, opts);
39668
+ opts.mkdirSync(path9, opts);
39669
39669
  return made;
39670
39670
  } catch (er) {
39671
39671
  if (er.code === "ENOENT")
39672
- return mkdirpManualSync(path8, opts);
39672
+ return mkdirpManualSync(path9, opts);
39673
39673
  else
39674
39674
  throw er;
39675
39675
  }
@@ -39701,21 +39701,21 @@ var require_mkdirp = __commonJS({
39701
39701
  var { mkdirpNative, mkdirpNativeSync } = require_mkdirp_native();
39702
39702
  var { mkdirpManual, mkdirpManualSync } = require_mkdirp_manual();
39703
39703
  var { useNative, useNativeSync } = require_use_native();
39704
- var mkdirp = (path8, opts) => {
39705
- path8 = pathArg(path8);
39704
+ var mkdirp = (path9, opts) => {
39705
+ path9 = pathArg(path9);
39706
39706
  opts = optsArg(opts);
39707
- return useNative(opts) ? mkdirpNative(path8, opts) : mkdirpManual(path8, opts);
39707
+ return useNative(opts) ? mkdirpNative(path9, opts) : mkdirpManual(path9, opts);
39708
39708
  };
39709
- var mkdirpSync = (path8, opts) => {
39710
- path8 = pathArg(path8);
39709
+ var mkdirpSync = (path9, opts) => {
39710
+ path9 = pathArg(path9);
39711
39711
  opts = optsArg(opts);
39712
- return useNativeSync(opts) ? mkdirpNativeSync(path8, opts) : mkdirpManualSync(path8, opts);
39712
+ return useNativeSync(opts) ? mkdirpNativeSync(path9, opts) : mkdirpManualSync(path9, opts);
39713
39713
  };
39714
39714
  mkdirp.sync = mkdirpSync;
39715
- mkdirp.native = (path8, opts) => mkdirpNative(pathArg(path8), optsArg(opts));
39716
- mkdirp.manual = (path8, opts) => mkdirpManual(pathArg(path8), optsArg(opts));
39717
- mkdirp.nativeSync = (path8, opts) => mkdirpNativeSync(pathArg(path8), optsArg(opts));
39718
- mkdirp.manualSync = (path8, opts) => mkdirpManualSync(pathArg(path8), optsArg(opts));
39715
+ mkdirp.native = (path9, opts) => mkdirpNative(pathArg(path9), optsArg(opts));
39716
+ mkdirp.manual = (path9, opts) => mkdirpManual(pathArg(path9), optsArg(opts));
39717
+ mkdirp.nativeSync = (path9, opts) => mkdirpNativeSync(pathArg(path9), optsArg(opts));
39718
+ mkdirp.manualSync = (path9, opts) => mkdirpManualSync(pathArg(path9), optsArg(opts));
39719
39719
  module2.exports = mkdirp;
39720
39720
  }
39721
39721
  });
@@ -39725,46 +39725,46 @@ var require_chownr = __commonJS({
39725
39725
  "../../../node_modules/.pnpm/chownr@2.0.0/node_modules/chownr/chownr.js"(exports, module2) {
39726
39726
  "use strict";
39727
39727
  var fs2 = require("fs");
39728
- var path8 = require("path");
39728
+ var path9 = require("path");
39729
39729
  var LCHOWN = fs2.lchown ? "lchown" : "chown";
39730
39730
  var LCHOWNSYNC = fs2.lchownSync ? "lchownSync" : "chownSync";
39731
39731
  var needEISDIRHandled = fs2.lchown && !process.version.match(/v1[1-9]+\./) && !process.version.match(/v10\.[6-9]/);
39732
- var lchownSync = (path9, uid, gid) => {
39732
+ var lchownSync = (path10, uid, gid) => {
39733
39733
  try {
39734
- return fs2[LCHOWNSYNC](path9, uid, gid);
39734
+ return fs2[LCHOWNSYNC](path10, uid, gid);
39735
39735
  } catch (er) {
39736
39736
  if (er.code !== "ENOENT")
39737
39737
  throw er;
39738
39738
  }
39739
39739
  };
39740
- var chownSync = (path9, uid, gid) => {
39740
+ var chownSync = (path10, uid, gid) => {
39741
39741
  try {
39742
- return fs2.chownSync(path9, uid, gid);
39742
+ return fs2.chownSync(path10, uid, gid);
39743
39743
  } catch (er) {
39744
39744
  if (er.code !== "ENOENT")
39745
39745
  throw er;
39746
39746
  }
39747
39747
  };
39748
- var handleEISDIR = needEISDIRHandled ? (path9, uid, gid, cb) => (er) => {
39748
+ var handleEISDIR = needEISDIRHandled ? (path10, uid, gid, cb) => (er) => {
39749
39749
  if (!er || er.code !== "EISDIR")
39750
39750
  cb(er);
39751
39751
  else
39752
- fs2.chown(path9, uid, gid, cb);
39752
+ fs2.chown(path10, uid, gid, cb);
39753
39753
  } : (_, __, ___, cb) => cb;
39754
- var handleEISDirSync = needEISDIRHandled ? (path9, uid, gid) => {
39754
+ var handleEISDirSync = needEISDIRHandled ? (path10, uid, gid) => {
39755
39755
  try {
39756
- return lchownSync(path9, uid, gid);
39756
+ return lchownSync(path10, uid, gid);
39757
39757
  } catch (er) {
39758
39758
  if (er.code !== "EISDIR")
39759
39759
  throw er;
39760
- chownSync(path9, uid, gid);
39760
+ chownSync(path10, uid, gid);
39761
39761
  }
39762
- } : (path9, uid, gid) => lchownSync(path9, uid, gid);
39762
+ } : (path10, uid, gid) => lchownSync(path10, uid, gid);
39763
39763
  var nodeVersion = process.version;
39764
- var readdir = (path9, options, cb) => fs2.readdir(path9, options, cb);
39765
- var readdirSync = (path9, options) => fs2.readdirSync(path9, options);
39764
+ var readdir = (path10, options, cb) => fs2.readdir(path10, options, cb);
39765
+ var readdirSync = (path10, options) => fs2.readdirSync(path10, options);
39766
39766
  if (/^v4\./.test(nodeVersion))
39767
- readdir = (path9, options, cb) => fs2.readdir(path9, cb);
39767
+ readdir = (path10, options, cb) => fs2.readdir(path10, cb);
39768
39768
  var chown = (cpath, uid, gid, cb) => {
39769
39769
  fs2[LCHOWN](cpath, uid, gid, handleEISDIR(cpath, uid, gid, (er) => {
39770
39770
  cb(er && er.code !== "ENOENT" ? er : null);
@@ -39772,21 +39772,21 @@ var require_chownr = __commonJS({
39772
39772
  };
39773
39773
  var chownrKid = (p, child, uid, gid, cb) => {
39774
39774
  if (typeof child === "string")
39775
- return fs2.lstat(path8.resolve(p, child), (er, stats) => {
39775
+ return fs2.lstat(path9.resolve(p, child), (er, stats) => {
39776
39776
  if (er)
39777
39777
  return cb(er.code !== "ENOENT" ? er : null);
39778
39778
  stats.name = child;
39779
39779
  chownrKid(p, stats, uid, gid, cb);
39780
39780
  });
39781
39781
  if (child.isDirectory()) {
39782
- chownr(path8.resolve(p, child.name), uid, gid, (er) => {
39782
+ chownr(path9.resolve(p, child.name), uid, gid, (er) => {
39783
39783
  if (er)
39784
39784
  return cb(er);
39785
- const cpath = path8.resolve(p, child.name);
39785
+ const cpath = path9.resolve(p, child.name);
39786
39786
  chown(cpath, uid, gid, cb);
39787
39787
  });
39788
39788
  } else {
39789
- const cpath = path8.resolve(p, child.name);
39789
+ const cpath = path9.resolve(p, child.name);
39790
39790
  chown(cpath, uid, gid, cb);
39791
39791
  }
39792
39792
  };
@@ -39816,7 +39816,7 @@ var require_chownr = __commonJS({
39816
39816
  var chownrKidSync = (p, child, uid, gid) => {
39817
39817
  if (typeof child === "string") {
39818
39818
  try {
39819
- const stats = fs2.lstatSync(path8.resolve(p, child));
39819
+ const stats = fs2.lstatSync(path9.resolve(p, child));
39820
39820
  stats.name = child;
39821
39821
  child = stats;
39822
39822
  } catch (er) {
@@ -39827,8 +39827,8 @@ var require_chownr = __commonJS({
39827
39827
  }
39828
39828
  }
39829
39829
  if (child.isDirectory())
39830
- chownrSync(path8.resolve(p, child.name), uid, gid);
39831
- handleEISDirSync(path8.resolve(p, child.name), uid, gid);
39830
+ chownrSync(path9.resolve(p, child.name), uid, gid);
39831
+ handleEISDirSync(path9.resolve(p, child.name), uid, gid);
39832
39832
  };
39833
39833
  var chownrSync = (p, uid, gid) => {
39834
39834
  let children;
@@ -39857,13 +39857,13 @@ var require_mkdir = __commonJS({
39857
39857
  "use strict";
39858
39858
  var mkdirp = require_mkdirp();
39859
39859
  var fs2 = require("fs");
39860
- var path8 = require("path");
39860
+ var path9 = require("path");
39861
39861
  var chownr = require_chownr();
39862
39862
  var normPath = require_normalize_windows_path();
39863
39863
  var SymlinkError = class extends Error {
39864
- constructor(symlink, path9) {
39864
+ constructor(symlink, path10) {
39865
39865
  super("Cannot extract through symbolic link");
39866
- this.path = path9;
39866
+ this.path = path10;
39867
39867
  this.symlink = symlink;
39868
39868
  }
39869
39869
  get name() {
@@ -39871,9 +39871,9 @@ var require_mkdir = __commonJS({
39871
39871
  }
39872
39872
  };
39873
39873
  var CwdError = class extends Error {
39874
- constructor(path9, code) {
39875
- super(code + ": Cannot cd into '" + path9 + "'");
39876
- this.path = path9;
39874
+ constructor(path10, code) {
39875
+ super(code + ": Cannot cd into '" + path10 + "'");
39876
+ this.path = path10;
39877
39877
  this.code = code;
39878
39878
  }
39879
39879
  get name() {
@@ -39925,7 +39925,7 @@ var require_mkdir = __commonJS({
39925
39925
  if (preserve) {
39926
39926
  return mkdirp(dir, { mode }).then((made) => done(null, made), done);
39927
39927
  }
39928
- const sub = normPath(path8.relative(cwd, dir));
39928
+ const sub = normPath(path9.relative(cwd, dir));
39929
39929
  const parts = sub.split("/");
39930
39930
  mkdir_(cwd, parts, mode, cache, unlink, cwd, null, done);
39931
39931
  };
@@ -39934,7 +39934,7 @@ var require_mkdir = __commonJS({
39934
39934
  return cb(null, created);
39935
39935
  }
39936
39936
  const p = parts.shift();
39937
- const part = normPath(path8.resolve(base + "/" + p));
39937
+ const part = normPath(path9.resolve(base + "/" + p));
39938
39938
  if (cGet(cache, part)) {
39939
39939
  return mkdir_(part, parts, mode, cache, unlink, cwd, created, cb);
39940
39940
  }
@@ -40010,11 +40010,11 @@ var require_mkdir = __commonJS({
40010
40010
  if (preserve) {
40011
40011
  return done(mkdirp.sync(dir, mode));
40012
40012
  }
40013
- const sub = normPath(path8.relative(cwd, dir));
40013
+ const sub = normPath(path9.relative(cwd, dir));
40014
40014
  const parts = sub.split("/");
40015
40015
  let created = null;
40016
40016
  for (let p = parts.shift(), part = cwd; p && (part += "/" + p); p = parts.shift()) {
40017
- part = normPath(path8.resolve(part));
40017
+ part = normPath(path9.resolve(part));
40018
40018
  if (cGet(cache, part)) {
40019
40019
  continue;
40020
40020
  }
@@ -40071,12 +40071,12 @@ var require_path_reservations = __commonJS({
40071
40071
  module2.exports = () => {
40072
40072
  const queues = /* @__PURE__ */ new Map();
40073
40073
  const reservations = /* @__PURE__ */ new Map();
40074
- const getDirs = (path8) => {
40075
- const dirs = path8.split("/").slice(0, -1).reduce((set, path9) => {
40074
+ const getDirs = (path9) => {
40075
+ const dirs = path9.split("/").slice(0, -1).reduce((set, path10) => {
40076
40076
  if (set.length) {
40077
- path9 = join(set[set.length - 1], path9);
40077
+ path10 = join(set[set.length - 1], path10);
40078
40078
  }
40079
- set.push(path9 || "/");
40079
+ set.push(path10 || "/");
40080
40080
  return set;
40081
40081
  }, []);
40082
40082
  return dirs;
@@ -40088,8 +40088,8 @@ var require_path_reservations = __commonJS({
40088
40088
  throw new Error("function does not have any path reservations");
40089
40089
  }
40090
40090
  return {
40091
- paths: res.paths.map((path8) => queues.get(path8)),
40092
- dirs: [...res.dirs].map((path8) => queues.get(path8))
40091
+ paths: res.paths.map((path9) => queues.get(path9)),
40092
+ dirs: [...res.dirs].map((path9) => queues.get(path9))
40093
40093
  };
40094
40094
  };
40095
40095
  const check = (fn) => {
@@ -40110,11 +40110,11 @@ var require_path_reservations = __commonJS({
40110
40110
  }
40111
40111
  const { paths, dirs } = reservations.get(fn);
40112
40112
  const next = /* @__PURE__ */ new Set();
40113
- paths.forEach((path8) => {
40114
- const q = queues.get(path8);
40113
+ paths.forEach((path9) => {
40114
+ const q = queues.get(path9);
40115
40115
  assert.equal(q[0], fn);
40116
40116
  if (q.length === 1) {
40117
- queues.delete(path8);
40117
+ queues.delete(path9);
40118
40118
  } else {
40119
40119
  q.shift();
40120
40120
  if (typeof q[0] === "function") {
@@ -40145,13 +40145,13 @@ var require_path_reservations = __commonJS({
40145
40145
  return stripSlashes(join(normalize(p))).toLowerCase();
40146
40146
  });
40147
40147
  const dirs = new Set(
40148
- paths.map((path8) => getDirs(path8)).reduce((a, b) => a.concat(b))
40148
+ paths.map((path9) => getDirs(path9)).reduce((a, b) => a.concat(b))
40149
40149
  );
40150
40150
  reservations.set(fn, { dirs, paths });
40151
- paths.forEach((path8) => {
40152
- const q = queues.get(path8);
40151
+ paths.forEach((path9) => {
40152
+ const q = queues.get(path9);
40153
40153
  if (!q) {
40154
- queues.set(path8, [fn]);
40154
+ queues.set(path9, [fn]);
40155
40155
  } else {
40156
40156
  q.push(fn);
40157
40157
  }
@@ -40196,7 +40196,7 @@ var require_unpack = __commonJS({
40196
40196
  var Parser = require_parse3();
40197
40197
  var fs2 = require("fs");
40198
40198
  var fsm = require_fs_minipass();
40199
- var path8 = require("path");
40199
+ var path9 = require("path");
40200
40200
  var mkdir = require_mkdir();
40201
40201
  var wc = require_winchars();
40202
40202
  var pathReservations = require_path_reservations();
@@ -40234,34 +40234,34 @@ var require_unpack = __commonJS({
40234
40234
  var platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
40235
40235
  var isWindows = platform === "win32";
40236
40236
  var DEFAULT_MAX_DEPTH = 1024;
40237
- var unlinkFile = (path9, cb) => {
40237
+ var unlinkFile = (path10, cb) => {
40238
40238
  if (!isWindows) {
40239
- return fs2.unlink(path9, cb);
40239
+ return fs2.unlink(path10, cb);
40240
40240
  }
40241
- const name = path9 + ".DELETE." + crypto2.randomBytes(16).toString("hex");
40242
- fs2.rename(path9, name, (er) => {
40241
+ const name = path10 + ".DELETE." + crypto2.randomBytes(16).toString("hex");
40242
+ fs2.rename(path10, name, (er) => {
40243
40243
  if (er) {
40244
40244
  return cb(er);
40245
40245
  }
40246
40246
  fs2.unlink(name, cb);
40247
40247
  });
40248
40248
  };
40249
- var unlinkFileSync = (path9) => {
40249
+ var unlinkFileSync = (path10) => {
40250
40250
  if (!isWindows) {
40251
- return fs2.unlinkSync(path9);
40251
+ return fs2.unlinkSync(path10);
40252
40252
  }
40253
- const name = path9 + ".DELETE." + crypto2.randomBytes(16).toString("hex");
40254
- fs2.renameSync(path9, name);
40253
+ const name = path10 + ".DELETE." + crypto2.randomBytes(16).toString("hex");
40254
+ fs2.renameSync(path10, name);
40255
40255
  fs2.unlinkSync(name);
40256
40256
  };
40257
40257
  var uint32 = (a, b, c) => a === a >>> 0 ? a : b === b >>> 0 ? b : c;
40258
- var cacheKeyNormalize = (path9) => stripSlash(normPath(normalize(path9))).toLowerCase();
40258
+ var cacheKeyNormalize = (path10) => stripSlash(normPath(normalize(path10))).toLowerCase();
40259
40259
  var pruneCache = (cache, abs) => {
40260
40260
  abs = cacheKeyNormalize(abs);
40261
- for (const path9 of cache.keys()) {
40262
- const pnorm = cacheKeyNormalize(path9);
40261
+ for (const path10 of cache.keys()) {
40262
+ const pnorm = cacheKeyNormalize(path10);
40263
40263
  if (pnorm === abs || pnorm.indexOf(abs + "/") === 0) {
40264
- cache.delete(path9);
40264
+ cache.delete(path10);
40265
40265
  }
40266
40266
  }
40267
40267
  };
@@ -40320,7 +40320,7 @@ var require_unpack = __commonJS({
40320
40320
  this.noMtime = !!opt.noMtime;
40321
40321
  this.preservePaths = !!opt.preservePaths;
40322
40322
  this.unlink = !!opt.unlink;
40323
- this.cwd = normPath(path8.resolve(opt.cwd || process.cwd()));
40323
+ this.cwd = normPath(path9.resolve(opt.cwd || process.cwd()));
40324
40324
  this.strip = +opt.strip || 0;
40325
40325
  this.processUmask = opt.noChmod ? 0 : process.umask();
40326
40326
  this.umask = typeof opt.umask === "number" ? opt.umask : this.processUmask;
@@ -40388,10 +40388,10 @@ var require_unpack = __commonJS({
40388
40388
  });
40389
40389
  }
40390
40390
  }
40391
- if (path8.isAbsolute(entry.path)) {
40392
- entry.absolute = normPath(path8.resolve(entry.path));
40391
+ if (path9.isAbsolute(entry.path)) {
40392
+ entry.absolute = normPath(path9.resolve(entry.path));
40393
40393
  } else {
40394
- entry.absolute = normPath(path8.resolve(this.cwd, entry.path));
40394
+ entry.absolute = normPath(path9.resolve(this.cwd, entry.path));
40395
40395
  }
40396
40396
  if (!this.preservePaths && entry.absolute.indexOf(this.cwd + "/") !== 0 && entry.absolute !== this.cwd) {
40397
40397
  this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", {
@@ -40406,9 +40406,9 @@ var require_unpack = __commonJS({
40406
40406
  return false;
40407
40407
  }
40408
40408
  if (this.win32) {
40409
- const { root: aRoot } = path8.win32.parse(entry.absolute);
40409
+ const { root: aRoot } = path9.win32.parse(entry.absolute);
40410
40410
  entry.absolute = aRoot + wc.encode(entry.absolute.slice(aRoot.length));
40411
- const { root: pRoot } = path8.win32.parse(entry.path);
40411
+ const { root: pRoot } = path9.win32.parse(entry.path);
40412
40412
  entry.path = pRoot + wc.encode(entry.path.slice(pRoot.length));
40413
40413
  }
40414
40414
  return true;
@@ -40575,7 +40575,7 @@ var require_unpack = __commonJS({
40575
40575
  this[LINK](entry, entry.linkpath, "symlink", done);
40576
40576
  }
40577
40577
  [HARDLINK](entry, done) {
40578
- const linkpath = normPath(path8.resolve(this.cwd, entry.linkpath));
40578
+ const linkpath = normPath(path9.resolve(this.cwd, entry.linkpath));
40579
40579
  this[LINK](entry, linkpath, "link", done);
40580
40580
  }
40581
40581
  [PEND]() {
@@ -40630,7 +40630,7 @@ var require_unpack = __commonJS({
40630
40630
  };
40631
40631
  const start = () => {
40632
40632
  if (entry.absolute !== this.cwd) {
40633
- const parent = normPath(path8.dirname(entry.absolute));
40633
+ const parent = normPath(path9.dirname(entry.absolute));
40634
40634
  if (parent !== this.cwd) {
40635
40635
  return this[MKDIR](parent, this.dmode, (er) => {
40636
40636
  if (er) {
@@ -40733,7 +40733,7 @@ var require_unpack = __commonJS({
40733
40733
  this[CHECKED_CWD] = true;
40734
40734
  }
40735
40735
  if (entry.absolute !== this.cwd) {
40736
- const parent = normPath(path8.dirname(entry.absolute));
40736
+ const parent = normPath(path9.dirname(entry.absolute));
40737
40737
  if (parent !== this.cwd) {
40738
40738
  const mkParent = this[MKDIR](parent, this.dmode);
40739
40739
  if (mkParent) {
@@ -40889,7 +40889,7 @@ var require_extract = __commonJS({
40889
40889
  var Unpack = require_unpack();
40890
40890
  var fs2 = require("fs");
40891
40891
  var fsm = require_fs_minipass();
40892
- var path8 = require("path");
40892
+ var path9 = require("path");
40893
40893
  var stripSlash = require_strip_trailing_slashes();
40894
40894
  module2.exports = (opt_, files, cb) => {
40895
40895
  if (typeof opt_ === "function") {
@@ -40921,8 +40921,8 @@ var require_extract = __commonJS({
40921
40921
  const map = new Map(files.map((f) => [stripSlash(f), true]));
40922
40922
  const filter2 = opt.filter;
40923
40923
  const mapHas = (file, r) => {
40924
- const root = r || path8.parse(file).root || ".";
40925
- const ret = file === root ? false : map.has(file) ? map.get(file) : mapHas(path8.dirname(file), root);
40924
+ const root = r || path9.parse(file).root || ".";
40925
+ const ret = file === root ? false : map.has(file) ? map.get(file) : mapHas(path9.dirname(file), root);
40926
40926
  map.set(file, ret);
40927
40927
  return ret;
40928
40928
  };
@@ -40986,25 +40986,30 @@ var require_tar = __commonJS({
40986
40986
  }
40987
40987
  });
40988
40988
 
40989
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmRegistry.js
40989
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmRegistry.js
40990
40990
  function getNpmRegistry() {
40991
40991
  return __async(this, null, function* () {
40992
- const { stdout } = yield (0, import_execa.default)("npm", [
40993
- "config",
40994
- "get",
40995
- "registry"
40996
- ]);
40997
- return stdout.replace(/\/$/, "") || "https://registry.npmjs.org";
40992
+ try {
40993
+ const { stdout } = yield (0, import_execa.default)("npm", [
40994
+ "config",
40995
+ "get",
40996
+ "registry",
40997
+ "--no-workspaces"
40998
+ ]);
40999
+ return stdout.replace(/\/$/, "") || "https://registry.npmjs.org";
41000
+ } catch (error) {
41001
+ return "https://registry.npmjs.org";
41002
+ }
40998
41003
  });
40999
41004
  }
41000
41005
  var init_getNpmRegistry = __esm({
41001
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmRegistry.js"() {
41006
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmRegistry.js"() {
41002
41007
  "use strict";
41003
41008
  init_execa();
41004
41009
  }
41005
41010
  });
41006
41011
 
41007
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmPackageInfo.js
41012
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmPackageInfo.js
41008
41013
  function getNpmPackageInfoWithCommand(pkgName, pkgVersion, options) {
41009
41014
  return __async(this, null, function* () {
41010
41015
  const { registryUrl } = options || {};
@@ -41055,7 +41060,7 @@ function getNpmPackageInfo(pkgName, pkgVersion, options) {
41055
41060
  }
41056
41061
  var NpmPackageInfoCache;
41057
41062
  var init_getNpmPackageInfo = __esm({
41058
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmPackageInfo.js"() {
41063
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmPackageInfo.js"() {
41059
41064
  "use strict";
41060
41065
  init_constants3();
41061
41066
  init_execa();
@@ -41066,7 +41071,7 @@ var init_getNpmPackageInfo = __esm({
41066
41071
  }
41067
41072
  });
41068
41073
 
41069
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmTarballUrl.js
41074
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmTarballUrl.js
41070
41075
  function getNpmTarballUrl(pkgName, pkgVersion, options) {
41071
41076
  return __async(this, null, function* () {
41072
41077
  const packageInfo = yield getNpmPackageInfo(pkgName, pkgVersion, options);
@@ -41074,13 +41079,13 @@ function getNpmTarballUrl(pkgName, pkgVersion, options) {
41074
41079
  });
41075
41080
  }
41076
41081
  var init_getNpmTarballUrl = __esm({
41077
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmTarballUrl.js"() {
41082
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmTarballUrl.js"() {
41078
41083
  "use strict";
41079
41084
  init_getNpmPackageInfo();
41080
41085
  }
41081
41086
  });
41082
41087
 
41083
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmVersion.js
41088
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmVersion.js
41084
41089
  function getNpmVersion(packageName, options) {
41085
41090
  return __async(this, null, function* () {
41086
41091
  const { version = "latest" } = options || {};
@@ -41089,13 +41094,13 @@ function getNpmVersion(packageName, options) {
41089
41094
  });
41090
41095
  }
41091
41096
  var init_getNpmVersion = __esm({
41092
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmVersion.js"() {
41097
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getNpmVersion.js"() {
41093
41098
  "use strict";
41094
41099
  init_getNpmPackageInfo();
41095
41100
  }
41096
41101
  });
41097
41102
 
41098
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/downloadPackage.js
41103
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/downloadPackage.js
41099
41104
  function getGeneratorVersion(_0) {
41100
41105
  return __async(this, arguments, function* (pkgName, pkgVersion = "latest", options = {}) {
41101
41106
  const cacheKey = `${pkgName}@${pkgVersion}`;
@@ -41146,39 +41151,95 @@ function isValidCache(cacheDir, pkgName) {
41146
41151
  return false;
41147
41152
  });
41148
41153
  }
41149
- function downloadAndDecompressTargz(tarballPkg, targetDir) {
41154
+ function downloadAndDecompressTargz(tarballPkg, targetDir, options) {
41150
41155
  return __async(this, null, function* () {
41151
- const response = yield axios_default({
41152
- method: "get",
41153
- url: tarballPkg,
41154
- responseType: "stream",
41155
- adapter: "http"
41156
- });
41157
- if (response.status !== 200) {
41158
- throw new Error(`download tar package get bad status code: ${response.status}`);
41156
+ const { pkgName, pkgVersion, registryUrl, logger } = options || {};
41157
+ try {
41158
+ const response = yield axios_default({
41159
+ method: "get",
41160
+ url: tarballPkg,
41161
+ responseType: "stream",
41162
+ adapter: "http"
41163
+ });
41164
+ if (response.status !== 200) {
41165
+ throw new Error(`download tar package get bad status code: ${response.status}`);
41166
+ }
41167
+ const randomId = Math.floor(Math.random() * 1e4);
41168
+ const tempTgzFilePath = `${import_os.default.tmpdir()}/temp-${randomId}.tgz`;
41169
+ const dest = import_fs_extra.default.createWriteStream(tempTgzFilePath);
41170
+ yield new Promise((resolve, reject) => {
41171
+ response.data.pipe(dest);
41172
+ response.data.on("error", (err) => {
41173
+ reject(err);
41174
+ });
41175
+ dest.on("finish", () => {
41176
+ resolve();
41177
+ });
41178
+ });
41179
+ yield new Promise((resolve, reject) => {
41180
+ import_fs_extra.default.createReadStream(tempTgzFilePath).pipe(import_tar.default.x({
41181
+ strip: 1,
41182
+ C: `${targetDir}`
41183
+ })).on("finish", () => {
41184
+ resolve();
41185
+ }).on("error", (err) => {
41186
+ reject(err);
41187
+ });
41188
+ });
41189
+ yield import_fs_extra.default.remove(tempTgzFilePath);
41190
+ } catch (error) {
41191
+ logger === null || logger === void 0 ? void 0 : logger.warn(`Failed to download with axios: ${error.message}, trying npm pack as fallback`);
41192
+ if (!pkgName || !pkgVersion) {
41193
+ throw new Error("Package name and version are required for npm pack fallback");
41194
+ }
41195
+ yield downloadWithNpmPack(pkgName, pkgVersion, targetDir, {
41196
+ registryUrl,
41197
+ logger
41198
+ });
41159
41199
  }
41200
+ });
41201
+ }
41202
+ function downloadWithNpmPack(pkgName, pkgVersion, targetDir, options) {
41203
+ return __async(this, null, function* () {
41204
+ const { registryUrl, logger } = options || {};
41160
41205
  const randomId = Math.floor(Math.random() * 1e4);
41161
- const tempTgzFilePath = `${import_os.default.tmpdir()}/temp-${randomId}.tgz`;
41162
- const dest = import_fs_extra.default.createWriteStream(tempTgzFilePath);
41163
- yield new Promise((resolve, reject) => {
41164
- response.data.pipe(dest);
41165
- response.data.on("error", (err) => {
41166
- reject(err);
41167
- });
41168
- dest.on("finish", () => {
41169
- resolve();
41206
+ const tempDir = `${import_os.default.tmpdir()}/npm-pack-${randomId}`;
41207
+ yield import_fs_extra.default.mkdirp(tempDir);
41208
+ try {
41209
+ const params = [
41210
+ "pack",
41211
+ `${pkgName}@${pkgVersion}`
41212
+ ];
41213
+ if (registryUrl) {
41214
+ params.push("--registry");
41215
+ params.push(registryUrl);
41216
+ }
41217
+ logger === null || logger === void 0 ? void 0 : logger.debug(`Executing npm pack: npm ${params.join(" ")}`);
41218
+ const { stdout } = yield (0, import_execa.default)("npm", params, {
41219
+ cwd: tempDir,
41220
+ env: __spreadProps(__spreadValues({}, process.env), {
41221
+ // Avoid npm workspace related issues
41222
+ npm_config_workspaces: "false"
41223
+ })
41170
41224
  });
41171
- });
41172
- yield new Promise((resolve, reject) => {
41173
- import_fs_extra.default.createReadStream(tempTgzFilePath).pipe(import_tar.default.x({
41174
- strip: 1,
41175
- C: `${targetDir}`
41176
- })).on("finish", () => {
41177
- resolve();
41178
- }).on("error", (err) => {
41179
- reject(err);
41225
+ const tarballFileName = stdout.trim();
41226
+ const tarballPath = import_path4.default.join(tempDir, tarballFileName);
41227
+ if (!(yield fsExists(tarballPath))) {
41228
+ throw new Error(`npm pack failed: tarball file ${tarballPath} not found`);
41229
+ }
41230
+ yield new Promise((resolve, reject) => {
41231
+ import_fs_extra.default.createReadStream(tarballPath).pipe(import_tar.default.x({
41232
+ strip: 1,
41233
+ C: targetDir
41234
+ })).on("finish", () => {
41235
+ resolve();
41236
+ }).on("error", (err) => {
41237
+ reject(err);
41238
+ });
41180
41239
  });
41181
- });
41240
+ } finally {
41241
+ yield import_fs_extra.default.remove(tempDir);
41242
+ }
41182
41243
  });
41183
41244
  }
41184
41245
  function downloadPackage(_0) {
@@ -41214,7 +41275,12 @@ function downloadPackage(_0) {
41214
41275
  });
41215
41276
  logger === null || logger === void 0 ? void 0 : logger.timing(`🕒 get ${pkgName}@${version} tarball url`, true);
41216
41277
  logger === null || logger === void 0 ? void 0 : logger.timing(`🕒 download ${pkgName}@${version} tarball`);
41217
- yield downloadAndDecompressTargz(tarballPkg, targetDir);
41278
+ yield downloadAndDecompressTargz(tarballPkg, targetDir, {
41279
+ pkgName,
41280
+ pkgVersion: version,
41281
+ registryUrl,
41282
+ logger
41283
+ });
41218
41284
  logger === null || logger === void 0 ? void 0 : logger.timing(`🕒 download ${pkgName}@${version} tarball`, true);
41219
41285
  if (install) {
41220
41286
  logger === null || logger === void 0 ? void 0 : logger.timing(`🕒 install ${pkgName}@${version}`);
@@ -41229,12 +41295,14 @@ function downloadPackage(_0) {
41229
41295
  return targetDir;
41230
41296
  });
41231
41297
  }
41232
- var import_os, import_tar, GeneratorVersionMap;
41298
+ var import_os, import_path4, import_tar, GeneratorVersionMap;
41233
41299
  var init_downloadPackage = __esm({
41234
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/downloadPackage.js"() {
41300
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/downloadPackage.js"() {
41235
41301
  "use strict";
41236
41302
  import_os = __toESM(require("os"));
41303
+ import_path4 = __toESM(require("path"));
41237
41304
  init_constants3();
41305
+ init_execa();
41238
41306
  init_fs_extra();
41239
41307
  init_semver();
41240
41308
  init_axios2();
@@ -41247,7 +41315,7 @@ var init_downloadPackage = __esm({
41247
41315
  }
41248
41316
  });
41249
41317
 
41250
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getPackageInfo.js
41318
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getPackageInfo.js
41251
41319
  function getPackageInfo(packageName) {
41252
41320
  if (!packageName) {
41253
41321
  throw new Error("package is not exisit");
@@ -41271,15 +41339,15 @@ function getPackageInfo(packageName) {
41271
41339
  };
41272
41340
  }
41273
41341
  var init_getPackageInfo = __esm({
41274
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getPackageInfo.js"() {
41342
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getPackageInfo.js"() {
41275
41343
  "use strict";
41276
41344
  init_semver();
41277
41345
  }
41278
41346
  });
41279
41347
 
41280
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/index.js
41348
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/index.js
41281
41349
  var init_utils3 = __esm({
41282
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/index.js"() {
41350
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/index.js"() {
41283
41351
  "use strict";
41284
41352
  init_nodeRequire();
41285
41353
  init_downloadPackage();
@@ -41287,17 +41355,17 @@ var init_utils3 = __esm({
41287
41355
  }
41288
41356
  });
41289
41357
 
41290
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getGeneratorDir.js
41358
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getGeneratorDir.js
41291
41359
  function getGeneratorDir(generator) {
41292
41360
  return __async(this, null, function* () {
41293
41361
  let result = generator;
41294
41362
  const isDirectory = (yield import_fs_extra.default.stat(generator)).isDirectory();
41295
41363
  if (!isDirectory) {
41296
- result = import_path4.default.dirname(generator);
41364
+ result = import_path5.default.dirname(generator);
41297
41365
  }
41298
41366
  let times = 0;
41299
- while (times < MaxTimes && !(yield fsExists(import_path4.default.join(result, "package.json")))) {
41300
- result = import_path4.default.join(result, "../");
41367
+ while (times < MaxTimes && !(yield fsExists(import_path5.default.join(result, "package.json")))) {
41368
+ result = import_path5.default.join(result, "../");
41301
41369
  times++;
41302
41370
  }
41303
41371
  if (times >= MaxTimes) {
@@ -41306,11 +41374,11 @@ function getGeneratorDir(generator) {
41306
41374
  return result;
41307
41375
  });
41308
41376
  }
41309
- var import_path4, MaxTimes;
41377
+ var import_path5, MaxTimes;
41310
41378
  var init_getGeneratorDir = __esm({
41311
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/utils/getGeneratorDir.js"() {
41379
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/utils/getGeneratorDir.js"() {
41312
41380
  "use strict";
41313
- import_path4 = __toESM(require("path"));
41381
+ import_path5 = __toESM(require("path"));
41314
41382
  init_fs_extra();
41315
41383
  init_fsExists();
41316
41384
  MaxTimes = 5;
@@ -46804,22 +46872,22 @@ var require_ora = __commonJS({
46804
46872
  }
46805
46873
  });
46806
46874
 
46807
- // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/ora.js
46875
+ // ../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/ora.js
46808
46876
  var import_ora;
46809
46877
  var init_ora = __esm({
46810
- "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.7/node_modules/@modern-js/codesmith-utils/dist/esm/ora.js"() {
46878
+ "../../../node_modules/.pnpm/@modern-js+codesmith-utils@2.6.8/node_modules/@modern-js/codesmith-utils/dist/esm/ora.js"() {
46811
46879
  "use strict";
46812
46880
  import_ora = __toESM(require_ora());
46813
46881
  }
46814
46882
  });
46815
46883
 
46816
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/generator/index.js
46817
- var import_events2, import_path5, GeneratorCore;
46884
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/generator/index.js
46885
+ var import_events2, import_path6, GeneratorCore;
46818
46886
  var init_generator = __esm({
46819
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/generator/index.js"() {
46887
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/generator/index.js"() {
46820
46888
  "use strict";
46821
46889
  import_events2 = require("events");
46822
- import_path5 = __toESM(require("path"));
46890
+ import_path6 = __toESM(require("path"));
46823
46891
  init_FsMaterial();
46824
46892
  init_utils3();
46825
46893
  init_getGeneratorDir();
@@ -46926,9 +46994,9 @@ check path: ${import_chalk.default.blue.underline(generator)} exist a package.js
46926
46994
  (_this_logger = this.logger) === null || _this_logger === void 0 ? void 0 : (_this_logger_timing = _this_logger.timing) === null || _this_logger_timing === void 0 ? void 0 : _this_logger_timing.call(_this_logger, `🕒 LoadGenerator ${generator}`);
46927
46995
  let generatorPath = generator;
46928
46996
  if (generator.startsWith("file:")) {
46929
- generatorPath = import_path5.default.join(this.basePath, generator.slice(5));
46997
+ generatorPath = import_path6.default.join(this.basePath, generator.slice(5));
46930
46998
  }
46931
- const loadGeneratorPromise = import_path5.default.isAbsolute(generatorPath) ? this.loadLocalGenerator(generatorPath) : this.loadRemoteGenerator(generator);
46999
+ const loadGeneratorPromise = import_path6.default.isAbsolute(generatorPath) ? this.loadLocalGenerator(generatorPath) : this.loadRemoteGenerator(generator);
46932
47000
  const { generatorPkg, pkgJson, materialKey } = yield loadGeneratorPromise;
46933
47001
  if (!generatorPkg || !pkgJson || !materialKey) {
46934
47002
  return {};
@@ -46987,7 +47055,7 @@ check path: ${import_chalk.default.blue.underline(generator)} exist a package.js
46987
47055
  const subContext = __spreadProps(__spreadValues({}, this._context), {
46988
47056
  config: __spreadValues(__spreadValues({}, this._context.config), config),
46989
47057
  materials: __spreadProps(__spreadValues({}, this._context.materials), {
46990
- default: new FsMaterial(import_path5.default.resolve(this.outputPath, relativePwdPath))
47058
+ default: new FsMaterial(import_path6.default.resolve(this.outputPath, relativePwdPath))
46991
47059
  }),
46992
47060
  current: {
46993
47061
  material: generatorPkg
@@ -46995,7 +47063,7 @@ check path: ${import_chalk.default.blue.underline(generator)} exist a package.js
46995
47063
  });
46996
47064
  const preOutputPath = this.outputPath;
46997
47065
  const preBasePath = this.basePath;
46998
- this.setOutputPath(import_path5.default.resolve(this.outputPath, relativePwdPath || ""));
47066
+ this.setOutputPath(import_path6.default.resolve(this.outputPath, relativePwdPath || ""));
46999
47067
  this.setbasePath(subContext.current.material.basePath);
47000
47068
  spinner.stop();
47001
47069
  yield generatorScript(subContext, this);
@@ -47021,8 +47089,8 @@ check path: ${import_chalk.default.blue.underline(generator)} exist a package.js
47021
47089
  constructor({ logger, materialsManager, outputPath }) {
47022
47090
  this.output = {
47023
47091
  fs: (file, content, options) => __async(this, null, function* () {
47024
- const filePath = import_path5.default.resolve(this.outputPath, file.toString());
47025
- yield import_fs_extra.default.mkdirp(import_path5.default.dirname(filePath));
47092
+ const filePath = import_path6.default.resolve(this.outputPath, file.toString());
47093
+ yield import_fs_extra.default.mkdirp(import_path6.default.dirname(filePath));
47026
47094
  yield import_fs_extra.default.writeFile(filePath, content, options);
47027
47095
  })
47028
47096
  };
@@ -47043,17 +47111,17 @@ check path: ${import_chalk.default.blue.underline(generator)} exist a package.js
47043
47111
  }
47044
47112
  });
47045
47113
 
47046
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/materials/index.js
47047
- var import_path6, MaterialsManager;
47114
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/materials/index.js
47115
+ var import_path7, MaterialsManager;
47048
47116
  var init_materials = __esm({
47049
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/materials/index.js"() {
47117
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/materials/index.js"() {
47050
47118
  "use strict";
47051
- import_path6 = __toESM(require("path"));
47119
+ import_path7 = __toESM(require("path"));
47052
47120
  init_utils3();
47053
47121
  init_FsMaterial();
47054
47122
  MaterialsManager = class {
47055
47123
  loadLocalGenerator(generator) {
47056
- if (!import_path6.default.isAbsolute(generator)) {
47124
+ if (!import_path7.default.isAbsolute(generator)) {
47057
47125
  return Promise.reject(new Error("only support absolute local path"));
47058
47126
  }
47059
47127
  const fsMaterial = new FsMaterial(generator);
@@ -47117,12 +47185,12 @@ var init_materials = __esm({
47117
47185
  }
47118
47186
  });
47119
47187
 
47120
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/codesmith/index.js
47121
- var import_path7, CodeSmith;
47188
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/codesmith/index.js
47189
+ var import_path8, CodeSmith;
47122
47190
  var init_codesmith = __esm({
47123
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/codesmith/index.js"() {
47191
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/codesmith/index.js"() {
47124
47192
  "use strict";
47125
- import_path7 = __toESM(require("path"));
47193
+ import_path8 = __toESM(require("path"));
47126
47194
  init_generator();
47127
47195
  init_logger();
47128
47196
  init_constants();
@@ -47138,7 +47206,7 @@ var init_codesmith = __esm({
47138
47206
  materialsManager: this.materialsManager,
47139
47207
  outputPath: pwd || process.cwd()
47140
47208
  });
47141
- this.core.addMaterial("default", new FsMaterial(import_path7.default.resolve(pwd || process.cwd())));
47209
+ this.core.addMaterial("default", new FsMaterial(import_path8.default.resolve(pwd || process.cwd())));
47142
47210
  try {
47143
47211
  for (const task of tasks) {
47144
47212
  yield this.runTask(task);
@@ -47188,9 +47256,9 @@ var init_codesmith = __esm({
47188
47256
  }
47189
47257
  });
47190
47258
 
47191
- // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/index.js
47259
+ // ../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/index.js
47192
47260
  var init_esm_node = __esm({
47193
- "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.7/node_modules/@modern-js/codesmith/dist/esm-node/index.js"() {
47261
+ "../../../node_modules/.pnpm/@modern-js+codesmith@2.6.8/node_modules/@modern-js/codesmith/dist/esm-node/index.js"() {
47194
47262
  "use strict";
47195
47263
  init_codesmith();
47196
47264
  init_utils3();