@storm-software/workspace-tools 1.45.2 → 1.46.0

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 (19) hide show
  1. package/CHANGELOG.md +14 -0
  2. package/README.md +32 -2
  3. package/index.js +5070 -3314
  4. package/meta.json +1 -1
  5. package/package.json +3 -3
  6. package/src/base/index.js +3606 -1311
  7. package/src/executors/design-tokens/executor.js +3073 -973
  8. package/src/executors/tsup/executor.js +4446 -3253
  9. package/src/executors/tsup-browser/executor.js +4457 -3264
  10. package/src/executors/tsup-neutral/executor.js +4457 -3264
  11. package/src/executors/tsup-node/executor.js +4457 -3264
  12. package/src/executors/typia/executor.js +2412 -312
  13. package/src/generators/browser-library/generator.js +3596 -1298
  14. package/src/generators/config-schema/generator.js +2481 -383
  15. package/src/generators/init/init.js +49 -49
  16. package/src/generators/neutral-library/generator.js +3596 -1298
  17. package/src/generators/node-library/generator.js +3596 -1298
  18. package/src/generators/preset/generator.js +2489 -389
  19. package/src/utils/index.js +21 -36
package/src/executors/typia/executor.js CHANGED
@@ -33,7 +33,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
33
33
  var require_resolve_from = __commonJS({
34
34
  "node_modules/.pnpm/resolve-from@4.0.0/node_modules/resolve-from/index.js"(exports, module2) {
35
35
  "use strict";
36
- var path = require("path");
36
+ var path3 = require("path");
37
37
  var Module = require("module");
38
38
  var fs = require("fs");
39
39
  var resolveFrom = (fromDir, moduleId, silent) => {
@@ -47,14 +47,14 @@ var require_resolve_from = __commonJS({
47
47
  fromDir = fs.realpathSync(fromDir);
48
48
  } catch (err) {
49
49
  if (err.code === "ENOENT") {
50
- fromDir = path.resolve(fromDir);
50
+ fromDir = path3.resolve(fromDir);
51
51
  } else if (silent) {
52
52
  return null;
53
53
  } else {
54
54
  throw err;
55
55
  }
56
56
  }
57
- const fromFile = path.join(fromDir, "noop.js");
57
+ const fromFile = path3.join(fromDir, "noop.js");
58
58
  const resolveFileName = () => Module._resolveFilename(moduleId, {
59
59
  id: fromFile,
60
60
  filename: fromFile,
@@ -126,7 +126,7 @@ var require_parent_module = __commonJS({
126
126
  var require_import_fresh = __commonJS({
127
127
  "node_modules/.pnpm/import-fresh@3.3.0/node_modules/import-fresh/index.js"(exports, module2) {
128
128
  "use strict";
129
- var path = require("path");
129
+ var path3 = require("path");
130
130
  var resolveFrom = require_resolve_from();
131
131
  var parentModule = require_parent_module();
132
132
  module2.exports = (moduleId) => {
@@ -134,7 +134,7 @@ var require_import_fresh = __commonJS({
134
134
  throw new TypeError("Expected a string");
135
135
  }
136
136
  const parentPath = parentModule(__filename);
137
- const cwd = parentPath ? path.dirname(parentPath) : __dirname;
137
+ const cwd = parentPath ? path3.dirname(parentPath) : __dirname;
138
138
  const filePath = resolveFrom(cwd, moduleId);
139
139
  const oldModule = require.cache[filePath];
140
140
  if (oldModule && oldModule.parent) {
@@ -1576,15 +1576,15 @@ var require_route = __commonJS({
1576
1576
  };
1577
1577
  }
1578
1578
  function wrapConversion(toModel, graph) {
1579
- var path = [graph[toModel].parent, toModel];
1579
+ var path3 = [graph[toModel].parent, toModel];
1580
1580
  var fn = conversions[graph[toModel].parent][toModel];
1581
1581
  var cur = graph[toModel].parent;
1582
1582
  while (graph[cur].parent) {
1583
- path.unshift(graph[cur].parent);
1583
+ path3.unshift(graph[cur].parent);
1584
1584
  fn = link(conversions[graph[cur].parent][cur], fn);
1585
1585
  cur = graph[cur].parent;
1586
1586
  }
1587
- fn.conversion = path;
1587
+ fn.conversion = path3;
1588
1588
  return fn;
1589
1589
  }
1590
1590
  module2.exports = function(fromModel) {
@@ -1824,7 +1824,7 @@ var require_has_flag = __commonJS({
1824
1824
  var require_supports_color = __commonJS({
1825
1825
  "node_modules/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js"(exports, module2) {
1826
1826
  "use strict";
1827
- var os = require("os");
1827
+ var os2 = require("os");
1828
1828
  var hasFlag = require_has_flag();
1829
1829
  var env = process.env;
1830
1830
  var forceColor;
@@ -1862,7 +1862,7 @@ var require_supports_color = __commonJS({
1862
1862
  }
1863
1863
  const min = forceColor ? 1 : 0;
1864
1864
  if (process.platform === "win32") {
1865
- const osRelease = os.release().split(".");
1865
+ const osRelease = os2.release().split(".");
1866
1866
  if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
1867
1867
  return Number(osRelease[2]) >= 14931 ? 3 : 2;
1868
1868
  }
@@ -4726,7 +4726,7 @@ var require_loader = __commonJS({
4726
4726
  iterator(documents[index]);
4727
4727
  }
4728
4728
  }
4729
- function load(input, options) {
4729
+ function load2(input, options) {
4730
4730
  var documents = loadDocuments(input, options);
4731
4731
  if (documents.length === 0) {
4732
4732
  return void 0;
@@ -4736,7 +4736,7 @@ var require_loader = __commonJS({
4736
4736
  throw new YAMLException("expected a single document in the stream, but found more");
4737
4737
  }
4738
4738
  module2.exports.loadAll = loadAll;
4739
- module2.exports.load = load;
4739
+ module2.exports.load = load2;
4740
4740
  }
4741
4741
  });
4742
4742
 
@@ -5552,7 +5552,7 @@ ${error.message}`;
5552
5552
  return typescript.sys.fileExists(fileName);
5553
5553
  });
5554
5554
  if (filePath !== void 0) {
5555
- const { config, error } = typescript.readConfigFile(filePath, (path) => typescript.sys.readFile(path));
5555
+ const { config, error } = typescript.readConfigFile(filePath, (path3) => typescript.sys.readFile(path3));
5556
5556
  if (error) {
5557
5557
  throw new Error(`Error in ${filePath}: ${error.messageText.toString()}`);
5558
5558
  }
@@ -5675,42 +5675,42 @@ var require_defaults = __commonJS({
5675
5675
  var require_env_paths = __commonJS({
5676
5676
  "node_modules/.pnpm/env-paths@2.2.1/node_modules/env-paths/index.js"(exports, module2) {
5677
5677
  "use strict";
5678
- var path = require("path");
5679
- var os = require("os");
5680
- var homedir = os.homedir();
5681
- var tmpdir = os.tmpdir();
5678
+ var path3 = require("path");
5679
+ var os2 = require("os");
5680
+ var homedir = os2.homedir();
5681
+ var tmpdir = os2.tmpdir();
5682
5682
  var { env } = process;
5683
5683
  var macos = (name) => {
5684
- const library = path.join(homedir, "Library");
5684
+ const library = path3.join(homedir, "Library");
5685
5685
  return {
5686
- data: path.join(library, "Application Support", name),
5687
- config: path.join(library, "Preferences", name),
5688
- cache: path.join(library, "Caches", name),
5689
- log: path.join(library, "Logs", name),
5690
- temp: path.join(tmpdir, name)
5686
+ data: path3.join(library, "Application Support", name),
5687
+ config: path3.join(library, "Preferences", name),
5688
+ cache: path3.join(library, "Caches", name),
5689
+ log: path3.join(library, "Logs", name),
5690
+ temp: path3.join(tmpdir, name)
5691
5691
  };
5692
5692
  };
5693
5693
  var windows = (name) => {
5694
- const appData = env.APPDATA || path.join(homedir, "AppData", "Roaming");
5695
- const localAppData = env.LOCALAPPDATA || path.join(homedir, "AppData", "Local");
5694
+ const appData = env.APPDATA || path3.join(homedir, "AppData", "Roaming");
5695
+ const localAppData = env.LOCALAPPDATA || path3.join(homedir, "AppData", "Local");
5696
5696
  return {
5697
5697
  // Data/config/cache/log are invented by me as Windows isn't opinionated about this
5698
- data: path.join(localAppData, name, "Data"),
5699
- config: path.join(appData, name, "Config"),
5700
- cache: path.join(localAppData, name, "Cache"),
5701
- log: path.join(localAppData, name, "Log"),
5702
- temp: path.join(tmpdir, name)
5698
+ data: path3.join(localAppData, name, "Data"),
5699
+ config: path3.join(appData, name, "Config"),
5700
+ cache: path3.join(localAppData, name, "Cache"),
5701
+ log: path3.join(localAppData, name, "Log"),
5702
+ temp: path3.join(tmpdir, name)
5703
5703
  };
5704
5704
  };
5705
5705
  var linux = (name) => {
5706
- const username = path.basename(homedir);
5706
+ const username = path3.basename(homedir);
5707
5707
  return {
5708
- data: path.join(env.XDG_DATA_HOME || path.join(homedir, ".local", "share"), name),
5709
- config: path.join(env.XDG_CONFIG_HOME || path.join(homedir, ".config"), name),
5710
- cache: path.join(env.XDG_CACHE_HOME || path.join(homedir, ".cache"), name),
5708
+ data: path3.join(env.XDG_DATA_HOME || path3.join(homedir, ".local", "share"), name),
5709
+ config: path3.join(env.XDG_CONFIG_HOME || path3.join(homedir, ".config"), name),
5710
+ cache: path3.join(env.XDG_CACHE_HOME || path3.join(homedir, ".cache"), name),
5711
5711
  // https://wiki.debian.org/XDGBaseDirectorySpecification#state
5712
- log: path.join(env.XDG_STATE_HOME || path.join(homedir, ".local", "state"), name),
5713
- temp: path.join(tmpdir, username, name)
5712
+ log: path3.join(env.XDG_STATE_HOME || path3.join(homedir, ".local", "state"), name),
5713
+ temp: path3.join(tmpdir, username, name)
5714
5714
  };
5715
5715
  };
5716
5716
  var envPaths = (name, options) => {
@@ -5783,11 +5783,11 @@ var require_util = __commonJS({
5783
5783
  return result;
5784
5784
  }
5785
5785
  exports.emplace = emplace;
5786
- function getPropertyByPath(source, path) {
5787
- if (typeof path === "string" && Object.prototype.hasOwnProperty.call(source, path)) {
5788
- return source[path];
5786
+ function getPropertyByPath(source, path3) {
5787
+ if (typeof path3 === "string" && Object.prototype.hasOwnProperty.call(source, path3)) {
5788
+ return source[path3];
5789
5789
  }
5790
- const parsedPath = typeof path === "string" ? path.split(".") : path;
5790
+ const parsedPath = typeof path3 === "string" ? path3.split(".") : path3;
5791
5791
  return parsedPath.reduce((previous, key) => {
5792
5792
  if (previous === void 0) {
5793
5793
  return previous;
@@ -5800,9 +5800,9 @@ var require_util = __commonJS({
5800
5800
  return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== void 0));
5801
5801
  }
5802
5802
  exports.removeUndefinedValuesFromObject = removeUndefinedValuesFromObject;
5803
- async function isDirectory(path) {
5803
+ async function isDirectory(path3) {
5804
5804
  try {
5805
- const stat = await fs_1.promises.stat(path);
5805
+ const stat = await fs_1.promises.stat(path3);
5806
5806
  return stat.isDirectory();
5807
5807
  } catch (e) {
5808
5808
  if (e.code === "ENOENT") {
@@ -5812,9 +5812,9 @@ var require_util = __commonJS({
5812
5812
  }
5813
5813
  }
5814
5814
  exports.isDirectory = isDirectory;
5815
- function isDirectorySync(path) {
5815
+ function isDirectorySync(path3) {
5816
5816
  try {
5817
- const stat = fs_1.default.statSync(path);
5817
+ const stat = fs_1.default.statSync(path3);
5818
5818
  return stat.isDirectory();
5819
5819
  } catch (e) {
5820
5820
  if (e.code === "ENOENT") {
@@ -5912,7 +5912,7 @@ var require_ExplorerBase = __commonJS({
5912
5912
  const idx = importStack.indexOf(fullPath);
5913
5913
  if (idx !== -1) {
5914
5914
  throw new Error(`Circular import detected:
5915
- ${[...importStack, fullPath].map((path, i) => `${i + 1}. ${path}`).join("\n")} (same as ${idx + 1}.)`);
5915
+ ${[...importStack, fullPath].map((path3, i) => `${i + 1}. ${path3}`).join("\n")} (same as ${idx + 1}.)`);
5916
5916
  }
5917
5917
  }
5918
5918
  }
@@ -5999,13 +5999,13 @@ var require_Explorer = __commonJS({
5999
5999
  var Explorer = class extends ExplorerBase_js_1.ExplorerBase {
6000
6000
  async load(filepath) {
6001
6001
  filepath = path_1.default.resolve(filepath);
6002
- const load = async () => {
6002
+ const load2 = async () => {
6003
6003
  return await this.config.transform(await this.#readConfiguration(filepath));
6004
6004
  };
6005
6005
  if (this.loadCache) {
6006
- return await (0, util_js_1.emplace)(this.loadCache, filepath, load);
6006
+ return await (0, util_js_1.emplace)(this.loadCache, filepath, load2);
6007
6007
  }
6008
- return await load();
6008
+ return await load2();
6009
6009
  }
6010
6010
  async search(from = "") {
6011
6011
  if (this.config.metaConfigFilePath) {
@@ -6097,9 +6097,9 @@ var require_Explorer = __commonJS({
6097
6097
  throw error;
6098
6098
  }
6099
6099
  }
6100
- async #fileExists(path) {
6100
+ async #fileExists(path3) {
6101
6101
  try {
6102
- await promises_1.default.stat(path);
6102
+ await promises_1.default.stat(path3);
6103
6103
  return true;
6104
6104
  } catch (e) {
6105
6105
  return false;
@@ -6157,13 +6157,13 @@ var require_ExplorerSync = __commonJS({
6157
6157
  var ExplorerSync = class extends ExplorerBase_js_1.ExplorerBase {
6158
6158
  load(filepath) {
6159
6159
  filepath = path_1.default.resolve(filepath);
6160
- const load = () => {
6160
+ const load2 = () => {
6161
6161
  return this.config.transform(this.#readConfiguration(filepath));
6162
6162
  };
6163
6163
  if (this.loadCache) {
6164
- return (0, util_js_1.emplace)(this.loadCache, filepath, load);
6164
+ return (0, util_js_1.emplace)(this.loadCache, filepath, load2);
6165
6165
  }
6166
- return load();
6166
+ return load2();
6167
6167
  }
6168
6168
  search(from = "") {
6169
6169
  if (this.config.metaConfigFilePath) {
@@ -6255,9 +6255,9 @@ var require_ExplorerSync = __commonJS({
6255
6255
  throw error;
6256
6256
  }
6257
6257
  }
6258
- #fileExists(path) {
6258
+ #fileExists(path3) {
6259
6259
  try {
6260
- fs_1.default.statSync(path);
6260
+ fs_1.default.statSync(path3);
6261
6261
  return true;
6262
6262
  } catch (e) {
6263
6263
  return false;
@@ -6339,7 +6339,7 @@ var require_dist = __commonJS({
6339
6339
  var Explorer_js_1 = require_Explorer();
6340
6340
  var ExplorerSync_js_1 = require_ExplorerSync();
6341
6341
  var util_1 = require_util();
6342
- var identity = function identity2(x) {
6342
+ var identity2 = function identity3(x) {
6343
6343
  return x;
6344
6344
  };
6345
6345
  function getUserDefinedOptionsFromMetaConfig() {
@@ -6350,7 +6350,7 @@ var require_dist = __commonJS({
6350
6350
  ignoreEmptySearchPlaces: false,
6351
6351
  applyPackagePropertyPathToConfiguration: true,
6352
6352
  loaders: defaults_1.defaultLoaders,
6353
- transform: identity,
6353
+ transform: identity2,
6354
6354
  cache: true,
6355
6355
  metaConfigFilePath: null,
6356
6356
  mergeImportArrays: true,
@@ -6377,7 +6377,7 @@ var require_dist = __commonJS({
6377
6377
  };
6378
6378
  }
6379
6379
  function getResolvedSearchPlaces(moduleName, toolDefinedSearchPlaces, userConfiguredOptions) {
6380
- const userConfiguredSearchPlaces = userConfiguredOptions.searchPlaces?.map((path) => path.replace("{name}", moduleName));
6380
+ const userConfiguredSearchPlaces = userConfiguredOptions.searchPlaces?.map((path3) => path3.replace("{name}", moduleName));
6381
6381
  if (userConfiguredOptions.mergeSearchPlaces) {
6382
6382
  return [...userConfiguredSearchPlaces ?? [], ...toolDefinedSearchPlaces];
6383
6383
  }
@@ -6422,7 +6422,7 @@ var require_dist = __commonJS({
6422
6422
  searchPlaces: (0, defaults_1.getDefaultSearchPlaces)(moduleName),
6423
6423
  ignoreEmptySearchPlaces: true,
6424
6424
  cache: true,
6425
- transform: identity,
6425
+ transform: identity2,
6426
6426
  loaders: defaults_1.defaultLoaders,
6427
6427
  metaConfigFilePath: null,
6428
6428
  mergeImportArrays: true,
@@ -6438,7 +6438,7 @@ var require_dist = __commonJS({
6438
6438
  searchPlaces: (0, defaults_1.getDefaultSearchPlacesSync)(moduleName),
6439
6439
  ignoreEmptySearchPlaces: true,
6440
6440
  cache: true,
6441
- transform: identity,
6441
+ transform: identity2,
6442
6442
  loaders: defaults_1.defaultLoadersSync,
6443
6443
  metaConfigFilePath: null,
6444
6444
  mergeImportArrays: true,
@@ -7344,15 +7344,15 @@ var require_route2 = __commonJS({
7344
7344
  };
7345
7345
  }
7346
7346
  function wrapConversion(toModel, graph) {
7347
- const path = [graph[toModel].parent, toModel];
7347
+ const path3 = [graph[toModel].parent, toModel];
7348
7348
  let fn = conversions[graph[toModel].parent][toModel];
7349
7349
  let cur = graph[toModel].parent;
7350
7350
  while (graph[cur].parent) {
7351
- path.unshift(graph[cur].parent);
7351
+ path3.unshift(graph[cur].parent);
7352
7352
  fn = link(conversions[graph[cur].parent][cur], fn);
7353
7353
  cur = graph[cur].parent;
7354
7354
  }
7355
- fn.conversion = path;
7355
+ fn.conversion = path3;
7356
7356
  return fn;
7357
7357
  }
7358
7358
  module2.exports = function(fromModel) {
@@ -7467,7 +7467,7 @@ var require_ansi_styles2 = __commonJS({
7467
7467
  });
7468
7468
  };
7469
7469
  var colorConvert;
7470
- var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
7470
+ var makeDynamicStyles = (wrap, targetSpace, identity2, isBackground) => {
7471
7471
  if (colorConvert === void 0) {
7472
7472
  colorConvert = require_color_convert2();
7473
7473
  }
@@ -7476,7 +7476,7 @@ var require_ansi_styles2 = __commonJS({
7476
7476
  for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
7477
7477
  const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
7478
7478
  if (sourceSpace === targetSpace) {
7479
- styles[name] = wrap(identity, offset);
7479
+ styles[name] = wrap(identity2, offset);
7480
7480
  } else if (typeof suite === "object") {
7481
7481
  styles[name] = wrap(suite[targetSpace], offset);
7482
7482
  }
@@ -7592,7 +7592,7 @@ var require_has_flag2 = __commonJS({
7592
7592
  var require_supports_color2 = __commonJS({
7593
7593
  "node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module2) {
7594
7594
  "use strict";
7595
- var os = require("os");
7595
+ var os2 = require("os");
7596
7596
  var tty = require("tty");
7597
7597
  var hasFlag = require_has_flag2();
7598
7598
  var { env } = process;
@@ -7640,7 +7640,7 @@ var require_supports_color2 = __commonJS({
7640
7640
  return min;
7641
7641
  }
7642
7642
  if (process.platform === "win32") {
7643
- const osRelease = os.release().split(".");
7643
+ const osRelease = os2.release().split(".");
7644
7644
  if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
7645
7645
  return Number(osRelease[2]) >= 14931 ? 3 : 2;
7646
7646
  }
@@ -8021,6 +8021,543 @@ var require_source = __commonJS({
8021
8021
  }
8022
8022
  });
8023
8023
 
8024
+ // node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
8025
+ var require_windows = __commonJS({
8026
+ "node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
8027
+ module2.exports = isexe;
8028
+ isexe.sync = sync;
8029
+ var fs = require("fs");
8030
+ function checkPathExt(path3, options) {
8031
+ var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
8032
+ if (!pathext) {
8033
+ return true;
8034
+ }
8035
+ pathext = pathext.split(";");
8036
+ if (pathext.indexOf("") !== -1) {
8037
+ return true;
8038
+ }
8039
+ for (var i = 0; i < pathext.length; i++) {
8040
+ var p = pathext[i].toLowerCase();
8041
+ if (p && path3.substr(-p.length).toLowerCase() === p) {
8042
+ return true;
8043
+ }
8044
+ }
8045
+ return false;
8046
+ }
8047
+ function checkStat(stat, path3, options) {
8048
+ if (!stat.isSymbolicLink() && !stat.isFile()) {
8049
+ return false;
8050
+ }
8051
+ return checkPathExt(path3, options);
8052
+ }
8053
+ function isexe(path3, options, cb) {
8054
+ fs.stat(path3, function(er, stat) {
8055
+ cb(er, er ? false : checkStat(stat, path3, options));
8056
+ });
8057
+ }
8058
+ function sync(path3, options) {
8059
+ return checkStat(fs.statSync(path3), path3, options);
8060
+ }
8061
+ }
8062
+ });
8063
+
8064
+ // node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
8065
+ var require_mode = __commonJS({
8066
+ "node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
8067
+ module2.exports = isexe;
8068
+ isexe.sync = sync;
8069
+ var fs = require("fs");
8070
+ function isexe(path3, options, cb) {
8071
+ fs.stat(path3, function(er, stat) {
8072
+ cb(er, er ? false : checkStat(stat, options));
8073
+ });
8074
+ }
8075
+ function sync(path3, options) {
8076
+ return checkStat(fs.statSync(path3), options);
8077
+ }
8078
+ function checkStat(stat, options) {
8079
+ return stat.isFile() && checkMode(stat, options);
8080
+ }
8081
+ function checkMode(stat, options) {
8082
+ var mod = stat.mode;
8083
+ var uid = stat.uid;
8084
+ var gid = stat.gid;
8085
+ var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
8086
+ var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
8087
+ var u = parseInt("100", 8);
8088
+ var g = parseInt("010", 8);
8089
+ var o = parseInt("001", 8);
8090
+ var ug = u | g;
8091
+ var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
8092
+ return ret;
8093
+ }
8094
+ }
8095
+ });
8096
+
8097
+ // node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
8098
+ var require_isexe = __commonJS({
8099
+ "node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
8100
+ var fs = require("fs");
8101
+ var core;
8102
+ if (process.platform === "win32" || global.TESTING_WINDOWS) {
8103
+ core = require_windows();
8104
+ } else {
8105
+ core = require_mode();
8106
+ }
8107
+ module2.exports = isexe;
8108
+ isexe.sync = sync;
8109
+ function isexe(path3, options, cb) {
8110
+ if (typeof options === "function") {
8111
+ cb = options;
8112
+ options = {};
8113
+ }
8114
+ if (!cb) {
8115
+ if (typeof Promise !== "function") {
8116
+ throw new TypeError("callback not provided");
8117
+ }
8118
+ return new Promise(function(resolve, reject) {
8119
+ isexe(path3, options || {}, function(er, is) {
8120
+ if (er) {
8121
+ reject(er);
8122
+ } else {
8123
+ resolve(is);
8124
+ }
8125
+ });
8126
+ });
8127
+ }
8128
+ core(path3, options || {}, function(er, is) {
8129
+ if (er) {
8130
+ if (er.code === "EACCES" || options && options.ignoreErrors) {
8131
+ er = null;
8132
+ is = false;
8133
+ }
8134
+ }
8135
+ cb(er, is);
8136
+ });
8137
+ }
8138
+ function sync(path3, options) {
8139
+ try {
8140
+ return core.sync(path3, options || {});
8141
+ } catch (er) {
8142
+ if (options && options.ignoreErrors || er.code === "EACCES") {
8143
+ return false;
8144
+ } else {
8145
+ throw er;
8146
+ }
8147
+ }
8148
+ }
8149
+ }
8150
+ });
8151
+
8152
+ // node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
8153
+ var require_which = __commonJS({
8154
+ "node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports, module2) {
8155
+ var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
8156
+ var path3 = require("path");
8157
+ var COLON = isWindows ? ";" : ":";
8158
+ var isexe = require_isexe();
8159
+ var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
8160
+ var getPathInfo = (cmd, opt) => {
8161
+ const colon = opt.colon || COLON;
8162
+ const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
8163
+ // windows always checks the cwd first
8164
+ ...isWindows ? [process.cwd()] : [],
8165
+ ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
8166
+ "").split(colon)
8167
+ ];
8168
+ const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
8169
+ const pathExt = isWindows ? pathExtExe.split(colon) : [""];
8170
+ if (isWindows) {
8171
+ if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
8172
+ pathExt.unshift("");
8173
+ }
8174
+ return {
8175
+ pathEnv,
8176
+ pathExt,
8177
+ pathExtExe
8178
+ };
8179
+ };
8180
+ var which = (cmd, opt, cb) => {
8181
+ if (typeof opt === "function") {
8182
+ cb = opt;
8183
+ opt = {};
8184
+ }
8185
+ if (!opt)
8186
+ opt = {};
8187
+ const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
8188
+ const found = [];
8189
+ const step = (i) => new Promise((resolve, reject) => {
8190
+ if (i === pathEnv.length)
8191
+ return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
8192
+ const ppRaw = pathEnv[i];
8193
+ const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
8194
+ const pCmd = path3.join(pathPart, cmd);
8195
+ const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
8196
+ resolve(subStep(p, i, 0));
8197
+ });
8198
+ const subStep = (p, i, ii) => new Promise((resolve, reject) => {
8199
+ if (ii === pathExt.length)
8200
+ return resolve(step(i + 1));
8201
+ const ext = pathExt[ii];
8202
+ isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
8203
+ if (!er && is) {
8204
+ if (opt.all)
8205
+ found.push(p + ext);
8206
+ else
8207
+ return resolve(p + ext);
8208
+ }
8209
+ return resolve(subStep(p, i, ii + 1));
8210
+ });
8211
+ });
8212
+ return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
8213
+ };
8214
+ var whichSync = (cmd, opt) => {
8215
+ opt = opt || {};
8216
+ const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
8217
+ const found = [];
8218
+ for (let i = 0; i < pathEnv.length; i++) {
8219
+ const ppRaw = pathEnv[i];
8220
+ const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
8221
+ const pCmd = path3.join(pathPart, cmd);
8222
+ const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
8223
+ for (let j = 0; j < pathExt.length; j++) {
8224
+ const cur = p + pathExt[j];
8225
+ try {
8226
+ const is = isexe.sync(cur, { pathExt: pathExtExe });
8227
+ if (is) {
8228
+ if (opt.all)
8229
+ found.push(cur);
8230
+ else
8231
+ return cur;
8232
+ }
8233
+ } catch (ex) {
8234
+ }
8235
+ }
8236
+ }
8237
+ if (opt.all && found.length)
8238
+ return found;
8239
+ if (opt.nothrow)
8240
+ return null;
8241
+ throw getNotFoundError(cmd);
8242
+ };
8243
+ module2.exports = which;
8244
+ which.sync = whichSync;
8245
+ }
8246
+ });
8247
+
8248
+ // node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
8249
+ var require_path_key = __commonJS({
8250
+ "node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js"(exports, module2) {
8251
+ "use strict";
8252
+ var pathKey2 = (options = {}) => {
8253
+ const environment = options.env || process.env;
8254
+ const platform = options.platform || process.platform;
8255
+ if (platform !== "win32") {
8256
+ return "PATH";
8257
+ }
8258
+ return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
8259
+ };
8260
+ module2.exports = pathKey2;
8261
+ module2.exports.default = pathKey2;
8262
+ }
8263
+ });
8264
+
8265
+ // node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/resolveCommand.js
8266
+ var require_resolveCommand = __commonJS({
8267
+ "node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module2) {
8268
+ "use strict";
8269
+ var path3 = require("path");
8270
+ var which = require_which();
8271
+ var getPathKey = require_path_key();
8272
+ function resolveCommandAttempt(parsed, withoutPathExt) {
8273
+ const env = parsed.options.env || process.env;
8274
+ const cwd = process.cwd();
8275
+ const hasCustomCwd = parsed.options.cwd != null;
8276
+ const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
8277
+ if (shouldSwitchCwd) {
8278
+ try {
8279
+ process.chdir(parsed.options.cwd);
8280
+ } catch (err) {
8281
+ }
8282
+ }
8283
+ let resolved;
8284
+ try {
8285
+ resolved = which.sync(parsed.command, {
8286
+ path: env[getPathKey({ env })],
8287
+ pathExt: withoutPathExt ? path3.delimiter : void 0
8288
+ });
8289
+ } catch (e) {
8290
+ } finally {
8291
+ if (shouldSwitchCwd) {
8292
+ process.chdir(cwd);
8293
+ }
8294
+ }
8295
+ if (resolved) {
8296
+ resolved = path3.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
8297
+ }
8298
+ return resolved;
8299
+ }
8300
+ function resolveCommand(parsed) {
8301
+ return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
8302
+ }
8303
+ module2.exports = resolveCommand;
8304
+ }
8305
+ });
8306
+
8307
+ // node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/escape.js
8308
+ var require_escape = __commonJS({
8309
+ "node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/escape.js"(exports, module2) {
8310
+ "use strict";
8311
+ var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
8312
+ function escapeCommand(arg) {
8313
+ arg = arg.replace(metaCharsRegExp, "^$1");
8314
+ return arg;
8315
+ }
8316
+ function escapeArgument(arg, doubleEscapeMetaChars) {
8317
+ arg = `${arg}`;
8318
+ arg = arg.replace(/(\\*)"/g, '$1$1\\"');
8319
+ arg = arg.replace(/(\\*)$/, "$1$1");
8320
+ arg = `"${arg}"`;
8321
+ arg = arg.replace(metaCharsRegExp, "^$1");
8322
+ if (doubleEscapeMetaChars) {
8323
+ arg = arg.replace(metaCharsRegExp, "^$1");
8324
+ }
8325
+ return arg;
8326
+ }
8327
+ module2.exports.command = escapeCommand;
8328
+ module2.exports.argument = escapeArgument;
8329
+ }
8330
+ });
8331
+
8332
+ // node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
8333
+ var require_shebang_regex = __commonJS({
8334
+ "node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js"(exports, module2) {
8335
+ "use strict";
8336
+ module2.exports = /^#!(.*)/;
8337
+ }
8338
+ });
8339
+
8340
+ // node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
8341
+ var require_shebang_command = __commonJS({
8342
+ "node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js"(exports, module2) {
8343
+ "use strict";
8344
+ var shebangRegex = require_shebang_regex();
8345
+ module2.exports = (string = "") => {
8346
+ const match = string.match(shebangRegex);
8347
+ if (!match) {
8348
+ return null;
8349
+ }
8350
+ const [path3, argument] = match[0].replace(/#! ?/, "").split(" ");
8351
+ const binary = path3.split("/").pop();
8352
+ if (binary === "env") {
8353
+ return argument;
8354
+ }
8355
+ return argument ? `${binary} ${argument}` : binary;
8356
+ };
8357
+ }
8358
+ });
8359
+
8360
+ // node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/readShebang.js
8361
+ var require_readShebang = __commonJS({
8362
+ "node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
8363
+ "use strict";
8364
+ var fs = require("fs");
8365
+ var shebangCommand = require_shebang_command();
8366
+ function readShebang(command) {
8367
+ const size = 150;
8368
+ const buffer = Buffer.alloc(size);
8369
+ let fd;
8370
+ try {
8371
+ fd = fs.openSync(command, "r");
8372
+ fs.readSync(fd, buffer, 0, size, 0);
8373
+ fs.closeSync(fd);
8374
+ } catch (e) {
8375
+ }
8376
+ return shebangCommand(buffer.toString());
8377
+ }
8378
+ module2.exports = readShebang;
8379
+ }
8380
+ });
8381
+
8382
+ // node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/parse.js
8383
+ var require_parse = __commonJS({
8384
+ "node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/parse.js"(exports, module2) {
8385
+ "use strict";
8386
+ var path3 = require("path");
8387
+ var resolveCommand = require_resolveCommand();
8388
+ var escape = require_escape();
8389
+ var readShebang = require_readShebang();
8390
+ var isWin = process.platform === "win32";
8391
+ var isExecutableRegExp = /\.(?:com|exe)$/i;
8392
+ var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
8393
+ function detectShebang(parsed) {
8394
+ parsed.file = resolveCommand(parsed);
8395
+ const shebang = parsed.file && readShebang(parsed.file);
8396
+ if (shebang) {
8397
+ parsed.args.unshift(parsed.file);
8398
+ parsed.command = shebang;
8399
+ return resolveCommand(parsed);
8400
+ }
8401
+ return parsed.file;
8402
+ }
8403
+ function parseNonShell(parsed) {
8404
+ if (!isWin) {
8405
+ return parsed;
8406
+ }
8407
+ const commandFile = detectShebang(parsed);
8408
+ const needsShell = !isExecutableRegExp.test(commandFile);
8409
+ if (parsed.options.forceShell || needsShell) {
8410
+ const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
8411
+ parsed.command = path3.normalize(parsed.command);
8412
+ parsed.command = escape.command(parsed.command);
8413
+ parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
8414
+ const shellCommand = [parsed.command].concat(parsed.args).join(" ");
8415
+ parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
8416
+ parsed.command = process.env.comspec || "cmd.exe";
8417
+ parsed.options.windowsVerbatimArguments = true;
8418
+ }
8419
+ return parsed;
8420
+ }
8421
+ function parse(command, args, options) {
8422
+ if (args && !Array.isArray(args)) {
8423
+ options = args;
8424
+ args = null;
8425
+ }
8426
+ args = args ? args.slice(0) : [];
8427
+ options = Object.assign({}, options);
8428
+ const parsed = {
8429
+ command,
8430
+ args,
8431
+ options,
8432
+ file: void 0,
8433
+ original: {
8434
+ command,
8435
+ args
8436
+ }
8437
+ };
8438
+ return options.shell ? parsed : parseNonShell(parsed);
8439
+ }
8440
+ module2.exports = parse;
8441
+ }
8442
+ });
8443
+
8444
+ // node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/enoent.js
8445
+ var require_enoent = __commonJS({
8446
+ "node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/enoent.js"(exports, module2) {
8447
+ "use strict";
8448
+ var isWin = process.platform === "win32";
8449
+ function notFoundError(original, syscall) {
8450
+ return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
8451
+ code: "ENOENT",
8452
+ errno: "ENOENT",
8453
+ syscall: `${syscall} ${original.command}`,
8454
+ path: original.command,
8455
+ spawnargs: original.args
8456
+ });
8457
+ }
8458
+ function hookChildProcess(cp, parsed) {
8459
+ if (!isWin) {
8460
+ return;
8461
+ }
8462
+ const originalEmit = cp.emit;
8463
+ cp.emit = function(name, arg1) {
8464
+ if (name === "exit") {
8465
+ const err = verifyENOENT(arg1, parsed, "spawn");
8466
+ if (err) {
8467
+ return originalEmit.call(cp, "error", err);
8468
+ }
8469
+ }
8470
+ return originalEmit.apply(cp, arguments);
8471
+ };
8472
+ }
8473
+ function verifyENOENT(status, parsed) {
8474
+ if (isWin && status === 1 && !parsed.file) {
8475
+ return notFoundError(parsed.original, "spawn");
8476
+ }
8477
+ return null;
8478
+ }
8479
+ function verifyENOENTSync(status, parsed) {
8480
+ if (isWin && status === 1 && !parsed.file) {
8481
+ return notFoundError(parsed.original, "spawnSync");
8482
+ }
8483
+ return null;
8484
+ }
8485
+ module2.exports = {
8486
+ hookChildProcess,
8487
+ verifyENOENT,
8488
+ verifyENOENTSync,
8489
+ notFoundError
8490
+ };
8491
+ }
8492
+ });
8493
+
8494
+ // node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/index.js
8495
+ var require_cross_spawn = __commonJS({
8496
+ "node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/index.js"(exports, module2) {
8497
+ "use strict";
8498
+ var cp = require("child_process");
8499
+ var parse = require_parse();
8500
+ var enoent = require_enoent();
8501
+ function spawn(command, args, options) {
8502
+ const parsed = parse(command, args, options);
8503
+ const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
8504
+ enoent.hookChildProcess(spawned, parsed);
8505
+ return spawned;
8506
+ }
8507
+ function spawnSync(command, args, options) {
8508
+ const parsed = parse(command, args, options);
8509
+ const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
8510
+ result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
8511
+ return result;
8512
+ }
8513
+ module2.exports = spawn;
8514
+ module2.exports.spawn = spawn;
8515
+ module2.exports.sync = spawnSync;
8516
+ module2.exports._parse = parse;
8517
+ module2.exports._enoent = enoent;
8518
+ }
8519
+ });
8520
+
8521
+ // node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js
8522
+ var require_merge_stream = __commonJS({
8523
+ "node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js"(exports, module2) {
8524
+ "use strict";
8525
+ var { PassThrough } = require("stream");
8526
+ module2.exports = function() {
8527
+ var sources = [];
8528
+ var output = new PassThrough({ objectMode: true });
8529
+ output.setMaxListeners(0);
8530
+ output.add = add;
8531
+ output.isEmpty = isEmpty;
8532
+ output.on("unpipe", remove);
8533
+ Array.prototype.slice.call(arguments).forEach(add);
8534
+ return output;
8535
+ function add(source) {
8536
+ if (Array.isArray(source)) {
8537
+ source.forEach(add);
8538
+ return this;
8539
+ }
8540
+ sources.push(source);
8541
+ source.once("end", remove.bind(null, source));
8542
+ source.once("error", output.emit.bind(output, "error"));
8543
+ source.pipe(output, { end: false });
8544
+ return this;
8545
+ }
8546
+ function isEmpty() {
8547
+ return sources.length == 0;
8548
+ }
8549
+ function remove(source) {
8550
+ sources = sources.filter(function(it) {
8551
+ return it !== source;
8552
+ });
8553
+ if (!sources.length && output.readable) {
8554
+ output.end();
8555
+ }
8556
+ }
8557
+ };
8558
+ }
8559
+ });
8560
+
8024
8561
  // node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js
8025
8562
  var require_universalify = __commonJS({
8026
8563
  "node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js"(exports) {
@@ -8054,7 +8591,7 @@ var require_universalify = __commonJS({
8054
8591
  // node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
8055
8592
  var require_polyfills = __commonJS({
8056
8593
  "node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module2) {
8057
- var constants = require("constants");
8594
+ var constants3 = require("constants");
8058
8595
  var origCwd = process.cwd;
8059
8596
  var cwd = null;
8060
8597
  var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -8079,7 +8616,7 @@ var require_polyfills = __commonJS({
8079
8616
  var chdir;
8080
8617
  module2.exports = patch;
8081
8618
  function patch(fs) {
8082
- if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
8619
+ if (constants3.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
8083
8620
  patchLchmod(fs);
8084
8621
  }
8085
8622
  if (!fs.lutimes) {
@@ -8104,7 +8641,7 @@ var require_polyfills = __commonJS({
8104
8641
  fs.fstatSync = statFixSync(fs.fstatSync);
8105
8642
  fs.lstatSync = statFixSync(fs.lstatSync);
8106
8643
  if (fs.chmod && !fs.lchmod) {
8107
- fs.lchmod = function(path, mode, cb) {
8644
+ fs.lchmod = function(path3, mode, cb) {
8108
8645
  if (cb)
8109
8646
  process.nextTick(cb);
8110
8647
  };
@@ -8112,7 +8649,7 @@ var require_polyfills = __commonJS({
8112
8649
  };
8113
8650
  }
8114
8651
  if (fs.chown && !fs.lchown) {
8115
- fs.lchown = function(path, uid, gid, cb) {
8652
+ fs.lchown = function(path3, uid, gid, cb) {
8116
8653
  if (cb)
8117
8654
  process.nextTick(cb);
8118
8655
  };
@@ -8183,10 +8720,10 @@ var require_polyfills = __commonJS({
8183
8720
  };
8184
8721
  }(fs.readSync);
8185
8722
  function patchLchmod(fs2) {
8186
- fs2.lchmod = function(path, mode, callback) {
8723
+ fs2.lchmod = function(path3, mode, callback) {
8187
8724
  fs2.open(
8188
- path,
8189
- constants.O_WRONLY | constants.O_SYMLINK,
8725
+ path3,
8726
+ constants3.O_WRONLY | constants3.O_SYMLINK,
8190
8727
  mode,
8191
8728
  function(err, fd) {
8192
8729
  if (err) {
@@ -8203,8 +8740,8 @@ var require_polyfills = __commonJS({
8203
8740
  }
8204
8741
  );
8205
8742
  };
8206
- fs2.lchmodSync = function(path, mode) {
8207
- var fd = fs2.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
8743
+ fs2.lchmodSync = function(path3, mode) {
8744
+ var fd = fs2.openSync(path3, constants3.O_WRONLY | constants3.O_SYMLINK, mode);
8208
8745
  var threw = true;
8209
8746
  var ret;
8210
8747
  try {
@@ -8224,9 +8761,9 @@ var require_polyfills = __commonJS({
8224
8761
  };
8225
8762
  }
8226
8763
  function patchLutimes(fs2) {
8227
- if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
8228
- fs2.lutimes = function(path, at, mt, cb) {
8229
- fs2.open(path, constants.O_SYMLINK, function(er, fd) {
8764
+ if (constants3.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
8765
+ fs2.lutimes = function(path3, at, mt, cb) {
8766
+ fs2.open(path3, constants3.O_SYMLINK, function(er, fd) {
8230
8767
  if (er) {
8231
8768
  if (cb)
8232
8769
  cb(er);
@@ -8240,8 +8777,8 @@ var require_polyfills = __commonJS({
8240
8777
  });
8241
8778
  });
8242
8779
  };
8243
- fs2.lutimesSync = function(path, at, mt) {
8244
- var fd = fs2.openSync(path, constants.O_SYMLINK);
8780
+ fs2.lutimesSync = function(path3, at, mt) {
8781
+ var fd = fs2.openSync(path3, constants3.O_SYMLINK);
8245
8782
  var ret;
8246
8783
  var threw = true;
8247
8784
  try {
@@ -8377,12 +8914,12 @@ var require_legacy_streams = __commonJS({
8377
8914
  ReadStream,
8378
8915
  WriteStream
8379
8916
  };
8380
- function ReadStream(path, options) {
8917
+ function ReadStream(path3, options) {
8381
8918
  if (!(this instanceof ReadStream))
8382
- return new ReadStream(path, options);
8919
+ return new ReadStream(path3, options);
8383
8920
  Stream.call(this);
8384
8921
  var self = this;
8385
- this.path = path;
8922
+ this.path = path3;
8386
8923
  this.fd = null;
8387
8924
  this.readable = true;
8388
8925
  this.paused = false;
@@ -8428,11 +8965,11 @@ var require_legacy_streams = __commonJS({
8428
8965
  self._read();
8429
8966
  });
8430
8967
  }
8431
- function WriteStream(path, options) {
8968
+ function WriteStream(path3, options) {
8432
8969
  if (!(this instanceof WriteStream))
8433
- return new WriteStream(path, options);
8970
+ return new WriteStream(path3, options);
8434
8971
  Stream.call(this);
8435
- this.path = path;
8972
+ this.path = path3;
8436
8973
  this.fd = null;
8437
8974
  this.writable = true;
8438
8975
  this.flags = "w";
@@ -8506,7 +9043,7 @@ var require_graceful_fs = __commonJS({
8506
9043
  gracefulQueue = "___graceful-fs.queue";
8507
9044
  previousSymbol = "___graceful-fs.previous";
8508
9045
  }
8509
- function noop() {
9046
+ function noop2() {
8510
9047
  }
8511
9048
  function publishQueue(context, queue2) {
8512
9049
  Object.defineProperty(context, gracefulQueue, {
@@ -8515,7 +9052,7 @@ var require_graceful_fs = __commonJS({
8515
9052
  }
8516
9053
  });
8517
9054
  }
8518
- var debug = noop;
9055
+ var debug = noop2;
8519
9056
  if (util2.debuglog)
8520
9057
  debug = util2.debuglog("gfs4");
8521
9058
  else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
@@ -8571,18 +9108,18 @@ var require_graceful_fs = __commonJS({
8571
9108
  function patch(fs2) {
8572
9109
  polyfills(fs2);
8573
9110
  fs2.gracefulify = patch;
8574
- fs2.createReadStream = createReadStream;
8575
- fs2.createWriteStream = createWriteStream;
9111
+ fs2.createReadStream = createReadStream2;
9112
+ fs2.createWriteStream = createWriteStream2;
8576
9113
  var fs$readFile = fs2.readFile;
8577
9114
  fs2.readFile = readFile;
8578
- function readFile(path, options, cb) {
9115
+ function readFile(path3, options, cb) {
8579
9116
  if (typeof options === "function")
8580
9117
  cb = options, options = null;
8581
- return go$readFile(path, options, cb);
8582
- function go$readFile(path2, options2, cb2, startTime) {
8583
- return fs$readFile(path2, options2, function(err) {
9118
+ return go$readFile(path3, options, cb);
9119
+ function go$readFile(path4, options2, cb2, startTime) {
9120
+ return fs$readFile(path4, options2, function(err) {
8584
9121
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
8585
- enqueue([go$readFile, [path2, options2, cb2], err, startTime || Date.now(), Date.now()]);
9122
+ enqueue([go$readFile, [path4, options2, cb2], err, startTime || Date.now(), Date.now()]);
8586
9123
  else {
8587
9124
  if (typeof cb2 === "function")
8588
9125
  cb2.apply(this, arguments);
@@ -8592,14 +9129,14 @@ var require_graceful_fs = __commonJS({
8592
9129
  }
8593
9130
  var fs$writeFile = fs2.writeFile;
8594
9131
  fs2.writeFile = writeFile;
8595
- function writeFile(path, data, options, cb) {
9132
+ function writeFile(path3, data, options, cb) {
8596
9133
  if (typeof options === "function")
8597
9134
  cb = options, options = null;
8598
- return go$writeFile(path, data, options, cb);
8599
- function go$writeFile(path2, data2, options2, cb2, startTime) {
8600
- return fs$writeFile(path2, data2, options2, function(err) {
9135
+ return go$writeFile(path3, data, options, cb);
9136
+ function go$writeFile(path4, data2, options2, cb2, startTime) {
9137
+ return fs$writeFile(path4, data2, options2, function(err) {
8601
9138
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
8602
- enqueue([go$writeFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
9139
+ enqueue([go$writeFile, [path4, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
8603
9140
  else {
8604
9141
  if (typeof cb2 === "function")
8605
9142
  cb2.apply(this, arguments);
@@ -8610,14 +9147,14 @@ var require_graceful_fs = __commonJS({
8610
9147
  var fs$appendFile = fs2.appendFile;
8611
9148
  if (fs$appendFile)
8612
9149
  fs2.appendFile = appendFile;
8613
- function appendFile(path, data, options, cb) {
9150
+ function appendFile(path3, data, options, cb) {
8614
9151
  if (typeof options === "function")
8615
9152
  cb = options, options = null;
8616
- return go$appendFile(path, data, options, cb);
8617
- function go$appendFile(path2, data2, options2, cb2, startTime) {
8618
- return fs$appendFile(path2, data2, options2, function(err) {
9153
+ return go$appendFile(path3, data, options, cb);
9154
+ function go$appendFile(path4, data2, options2, cb2, startTime) {
9155
+ return fs$appendFile(path4, data2, options2, function(err) {
8619
9156
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
8620
- enqueue([go$appendFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
9157
+ enqueue([go$appendFile, [path4, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
8621
9158
  else {
8622
9159
  if (typeof cb2 === "function")
8623
9160
  cb2.apply(this, arguments);
@@ -8648,31 +9185,31 @@ var require_graceful_fs = __commonJS({
8648
9185
  var fs$readdir = fs2.readdir;
8649
9186
  fs2.readdir = readdir;
8650
9187
  var noReaddirOptionVersions = /^v[0-5]\./;
8651
- function readdir(path, options, cb) {
9188
+ function readdir(path3, options, cb) {
8652
9189
  if (typeof options === "function")
8653
9190
  cb = options, options = null;
8654
- var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path2, options2, cb2, startTime) {
8655
- return fs$readdir(path2, fs$readdirCallback(
8656
- path2,
9191
+ var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path4, options2, cb2, startTime) {
9192
+ return fs$readdir(path4, fs$readdirCallback(
9193
+ path4,
8657
9194
  options2,
8658
9195
  cb2,
8659
9196
  startTime
8660
9197
  ));
8661
- } : function go$readdir2(path2, options2, cb2, startTime) {
8662
- return fs$readdir(path2, options2, fs$readdirCallback(
8663
- path2,
9198
+ } : function go$readdir2(path4, options2, cb2, startTime) {
9199
+ return fs$readdir(path4, options2, fs$readdirCallback(
9200
+ path4,
8664
9201
  options2,
8665
9202
  cb2,
8666
9203
  startTime
8667
9204
  ));
8668
9205
  };
8669
- return go$readdir(path, options, cb);
8670
- function fs$readdirCallback(path2, options2, cb2, startTime) {
9206
+ return go$readdir(path3, options, cb);
9207
+ function fs$readdirCallback(path4, options2, cb2, startTime) {
8671
9208
  return function(err, files) {
8672
9209
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
8673
9210
  enqueue([
8674
9211
  go$readdir,
8675
- [path2, options2, cb2],
9212
+ [path4, options2, cb2],
8676
9213
  err,
8677
9214
  startTime || Date.now(),
8678
9215
  Date.now()
@@ -8743,7 +9280,7 @@ var require_graceful_fs = __commonJS({
8743
9280
  enumerable: true,
8744
9281
  configurable: true
8745
9282
  });
8746
- function ReadStream(path, options) {
9283
+ function ReadStream(path3, options) {
8747
9284
  if (this instanceof ReadStream)
8748
9285
  return fs$ReadStream.apply(this, arguments), this;
8749
9286
  else
@@ -8763,7 +9300,7 @@ var require_graceful_fs = __commonJS({
8763
9300
  }
8764
9301
  });
8765
9302
  }
8766
- function WriteStream(path, options) {
9303
+ function WriteStream(path3, options) {
8767
9304
  if (this instanceof WriteStream)
8768
9305
  return fs$WriteStream.apply(this, arguments), this;
8769
9306
  else
@@ -8781,22 +9318,22 @@ var require_graceful_fs = __commonJS({
8781
9318
  }
8782
9319
  });
8783
9320
  }
8784
- function createReadStream(path, options) {
8785
- return new fs2.ReadStream(path, options);
9321
+ function createReadStream2(path3, options) {
9322
+ return new fs2.ReadStream(path3, options);
8786
9323
  }
8787
- function createWriteStream(path, options) {
8788
- return new fs2.WriteStream(path, options);
9324
+ function createWriteStream2(path3, options) {
9325
+ return new fs2.WriteStream(path3, options);
8789
9326
  }
8790
9327
  var fs$open = fs2.open;
8791
9328
  fs2.open = open;
8792
- function open(path, flags, mode, cb) {
9329
+ function open(path3, flags, mode, cb) {
8793
9330
  if (typeof mode === "function")
8794
9331
  cb = mode, mode = null;
8795
- return go$open(path, flags, mode, cb);
8796
- function go$open(path2, flags2, mode2, cb2, startTime) {
8797
- return fs$open(path2, flags2, mode2, function(err, fd) {
9332
+ return go$open(path3, flags, mode, cb);
9333
+ function go$open(path4, flags2, mode2, cb2, startTime) {
9334
+ return fs$open(path4, flags2, mode2, function(err, fd) {
8798
9335
  if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
8799
- enqueue([go$open, [path2, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
9336
+ enqueue([go$open, [path4, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
8800
9337
  else {
8801
9338
  if (typeof cb2 === "function")
8802
9339
  cb2.apply(this, arguments);
@@ -8979,10 +9516,10 @@ var require_fs = __commonJS({
8979
9516
  var require_utils = __commonJS({
8980
9517
  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module2) {
8981
9518
  "use strict";
8982
- var path = require("path");
9519
+ var path3 = require("path");
8983
9520
  module2.exports.checkPath = function checkPath(pth) {
8984
9521
  if (process.platform === "win32") {
8985
- const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ""));
9522
+ const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path3.parse(pth).root, ""));
8986
9523
  if (pathHasInvalidWinCharacters) {
8987
9524
  const error = new Error(`Path contains invalid characters: ${pth}`);
8988
9525
  error.code = "EINVAL";
@@ -9047,8 +9584,8 @@ var require_path_exists = __commonJS({
9047
9584
  "use strict";
9048
9585
  var u = require_universalify().fromPromise;
9049
9586
  var fs = require_fs();
9050
- function pathExists(path) {
9051
- return fs.access(path).then(() => true).catch(() => false);
9587
+ function pathExists(path3) {
9588
+ return fs.access(path3).then(() => true).catch(() => false);
9052
9589
  }
9053
9590
  module2.exports = {
9054
9591
  pathExists: u(pathExists),
@@ -9063,8 +9600,8 @@ var require_utimes = __commonJS({
9063
9600
  "use strict";
9064
9601
  var fs = require_fs();
9065
9602
  var u = require_universalify().fromPromise;
9066
- async function utimesMillis(path, atime, mtime) {
9067
- const fd = await fs.open(path, "r+");
9603
+ async function utimesMillis(path3, atime, mtime) {
9604
+ const fd = await fs.open(path3, "r+");
9068
9605
  let closeErr = null;
9069
9606
  try {
9070
9607
  await fs.futimes(fd, atime, mtime);
@@ -9079,8 +9616,8 @@ var require_utimes = __commonJS({
9079
9616
  throw closeErr;
9080
9617
  }
9081
9618
  }
9082
- function utimesMillisSync(path, atime, mtime) {
9083
- const fd = fs.openSync(path, "r+");
9619
+ function utimesMillisSync(path3, atime, mtime) {
9620
+ const fd = fs.openSync(path3, "r+");
9084
9621
  fs.futimesSync(fd, atime, mtime);
9085
9622
  return fs.closeSync(fd);
9086
9623
  }
@@ -9096,7 +9633,7 @@ var require_stat = __commonJS({
9096
9633
  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/stat.js"(exports, module2) {
9097
9634
  "use strict";
9098
9635
  var fs = require_fs();
9099
- var path = require("path");
9636
+ var path3 = require("path");
9100
9637
  var u = require_universalify().fromPromise;
9101
9638
  function getStats(src, dest, opts) {
9102
9639
  const statFunc = opts.dereference ? (file) => fs.stat(file, { bigint: true }) : (file) => fs.lstat(file, { bigint: true });
@@ -9126,8 +9663,8 @@ var require_stat = __commonJS({
9126
9663
  const { srcStat, destStat } = await getStats(src, dest, opts);
9127
9664
  if (destStat) {
9128
9665
  if (areIdentical(srcStat, destStat)) {
9129
- const srcBaseName = path.basename(src);
9130
- const destBaseName = path.basename(dest);
9666
+ const srcBaseName = path3.basename(src);
9667
+ const destBaseName = path3.basename(dest);
9131
9668
  if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
9132
9669
  return { srcStat, destStat, isChangingCase: true };
9133
9670
  }
@@ -9149,8 +9686,8 @@ var require_stat = __commonJS({
9149
9686
  const { srcStat, destStat } = getStatsSync(src, dest, opts);
9150
9687
  if (destStat) {
9151
9688
  if (areIdentical(srcStat, destStat)) {
9152
- const srcBaseName = path.basename(src);
9153
- const destBaseName = path.basename(dest);
9689
+ const srcBaseName = path3.basename(src);
9690
+ const destBaseName = path3.basename(dest);
9154
9691
  if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
9155
9692
  return { srcStat, destStat, isChangingCase: true };
9156
9693
  }
@@ -9169,9 +9706,9 @@ var require_stat = __commonJS({
9169
9706
  return { srcStat, destStat };
9170
9707
  }
9171
9708
  async function checkParentPaths(src, srcStat, dest, funcName) {
9172
- const srcParent = path.resolve(path.dirname(src));
9173
- const destParent = path.resolve(path.dirname(dest));
9174
- if (destParent === srcParent || destParent === path.parse(destParent).root)
9709
+ const srcParent = path3.resolve(path3.dirname(src));
9710
+ const destParent = path3.resolve(path3.dirname(dest));
9711
+ if (destParent === srcParent || destParent === path3.parse(destParent).root)
9175
9712
  return;
9176
9713
  let destStat;
9177
9714
  try {
@@ -9187,9 +9724,9 @@ var require_stat = __commonJS({
9187
9724
  return checkParentPaths(src, srcStat, destParent, funcName);
9188
9725
  }
9189
9726
  function checkParentPathsSync(src, srcStat, dest, funcName) {
9190
- const srcParent = path.resolve(path.dirname(src));
9191
- const destParent = path.resolve(path.dirname(dest));
9192
- if (destParent === srcParent || destParent === path.parse(destParent).root)
9727
+ const srcParent = path3.resolve(path3.dirname(src));
9728
+ const destParent = path3.resolve(path3.dirname(dest));
9729
+ if (destParent === srcParent || destParent === path3.parse(destParent).root)
9193
9730
  return;
9194
9731
  let destStat;
9195
9732
  try {
@@ -9208,8 +9745,8 @@ var require_stat = __commonJS({
9208
9745
  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
9209
9746
  }
9210
9747
  function isSrcSubdir(src, dest) {
9211
- const srcArr = path.resolve(src).split(path.sep).filter((i) => i);
9212
- const destArr = path.resolve(dest).split(path.sep).filter((i) => i);
9748
+ const srcArr = path3.resolve(src).split(path3.sep).filter((i) => i);
9749
+ const destArr = path3.resolve(dest).split(path3.sep).filter((i) => i);
9213
9750
  return srcArr.every((cur, i) => destArr[i] === cur);
9214
9751
  }
9215
9752
  function errMsg(src, dest, funcName) {
@@ -9234,7 +9771,7 @@ var require_copy = __commonJS({
9234
9771
  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy.js"(exports, module2) {
9235
9772
  "use strict";
9236
9773
  var fs = require_fs();
9237
- var path = require("path");
9774
+ var path3 = require("path");
9238
9775
  var { mkdirs } = require_mkdirs();
9239
9776
  var { pathExists } = require_path_exists();
9240
9777
  var { utimesMillis } = require_utimes();
@@ -9257,7 +9794,7 @@ var require_copy = __commonJS({
9257
9794
  const include = await runFilter(src, dest, opts);
9258
9795
  if (!include)
9259
9796
  return;
9260
- const destParent = path.dirname(dest);
9797
+ const destParent = path3.dirname(dest);
9261
9798
  const dirExists = await pathExists(destParent);
9262
9799
  if (!dirExists) {
9263
9800
  await mkdirs(destParent);
@@ -9318,8 +9855,8 @@ var require_copy = __commonJS({
9318
9855
  }
9319
9856
  const items = await fs.readdir(src);
9320
9857
  await Promise.all(items.map(async (item) => {
9321
- const srcItem = path.join(src, item);
9322
- const destItem = path.join(dest, item);
9858
+ const srcItem = path3.join(src, item);
9859
+ const destItem = path3.join(dest, item);
9323
9860
  const include = await runFilter(srcItem, destItem, opts);
9324
9861
  if (!include)
9325
9862
  return;
@@ -9333,7 +9870,7 @@ var require_copy = __commonJS({
9333
9870
  async function onLink(destStat, src, dest, opts) {
9334
9871
  let resolvedSrc = await fs.readlink(src);
9335
9872
  if (opts.dereference) {
9336
- resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
9873
+ resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
9337
9874
  }
9338
9875
  if (!destStat) {
9339
9876
  return fs.symlink(resolvedSrc, dest);
@@ -9347,7 +9884,7 @@ var require_copy = __commonJS({
9347
9884
  throw e;
9348
9885
  }
9349
9886
  if (opts.dereference) {
9350
- resolvedDest = path.resolve(process.cwd(), resolvedDest);
9887
+ resolvedDest = path3.resolve(process.cwd(), resolvedDest);
9351
9888
  }
9352
9889
  if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
9353
9890
  throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -9367,7 +9904,7 @@ var require_copy_sync = __commonJS({
9367
9904
  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module2) {
9368
9905
  "use strict";
9369
9906
  var fs = require_graceful_fs();
9370
- var path = require("path");
9907
+ var path3 = require("path");
9371
9908
  var mkdirsSync = require_mkdirs().mkdirsSync;
9372
9909
  var utimesMillisSync = require_utimes().utimesMillisSync;
9373
9910
  var stat = require_stat();
@@ -9389,7 +9926,7 @@ var require_copy_sync = __commonJS({
9389
9926
  stat.checkParentPathsSync(src, srcStat, dest, "copy");
9390
9927
  if (opts.filter && !opts.filter(src, dest))
9391
9928
  return;
9392
- const destParent = path.dirname(dest);
9929
+ const destParent = path3.dirname(dest);
9393
9930
  if (!fs.existsSync(destParent))
9394
9931
  mkdirsSync(destParent);
9395
9932
  return getStats(destStat, src, dest, opts);
@@ -9460,8 +9997,8 @@ var require_copy_sync = __commonJS({
9460
9997
  fs.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
9461
9998
  }
9462
9999
  function copyDirItem(item, src, dest, opts) {
9463
- const srcItem = path.join(src, item);
9464
- const destItem = path.join(dest, item);
10000
+ const srcItem = path3.join(src, item);
10001
+ const destItem = path3.join(dest, item);
9465
10002
  if (opts.filter && !opts.filter(srcItem, destItem))
9466
10003
  return;
9467
10004
  const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
@@ -9470,7 +10007,7 @@ var require_copy_sync = __commonJS({
9470
10007
  function onLink(destStat, src, dest, opts) {
9471
10008
  let resolvedSrc = fs.readlinkSync(src);
9472
10009
  if (opts.dereference) {
9473
- resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
10010
+ resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
9474
10011
  }
9475
10012
  if (!destStat) {
9476
10013
  return fs.symlinkSync(resolvedSrc, dest);
@@ -9484,7 +10021,7 @@ var require_copy_sync = __commonJS({
9484
10021
  throw err;
9485
10022
  }
9486
10023
  if (opts.dereference) {
9487
- resolvedDest = path.resolve(process.cwd(), resolvedDest);
10024
+ resolvedDest = path3.resolve(process.cwd(), resolvedDest);
9488
10025
  }
9489
10026
  if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
9490
10027
  throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -9521,11 +10058,11 @@ var require_remove = __commonJS({
9521
10058
  "use strict";
9522
10059
  var fs = require_graceful_fs();
9523
10060
  var u = require_universalify().fromCallback;
9524
- function remove(path, callback) {
9525
- fs.rm(path, { recursive: true, force: true }, callback);
10061
+ function remove(path3, callback) {
10062
+ fs.rm(path3, { recursive: true, force: true }, callback);
9526
10063
  }
9527
- function removeSync2(path) {
9528
- fs.rmSync(path, { recursive: true, force: true });
10064
+ function removeSync2(path3) {
10065
+ fs.rmSync(path3, { recursive: true, force: true });
9529
10066
  }
9530
10067
  module2.exports = {
9531
10068
  remove: u(remove),
@@ -9540,7 +10077,7 @@ var require_empty = __commonJS({
9540
10077
  "use strict";
9541
10078
  var u = require_universalify().fromPromise;
9542
10079
  var fs = require_fs();
9543
- var path = require("path");
10080
+ var path3 = require("path");
9544
10081
  var mkdir = require_mkdirs();
9545
10082
  var remove = require_remove();
9546
10083
  var emptyDir = u(async function emptyDir2(dir) {
@@ -9550,7 +10087,7 @@ var require_empty = __commonJS({
9550
10087
  } catch {
9551
10088
  return mkdir.mkdirs(dir);
9552
10089
  }
9553
- return Promise.all(items.map((item) => remove.remove(path.join(dir, item))));
10090
+ return Promise.all(items.map((item) => remove.remove(path3.join(dir, item))));
9554
10091
  });
9555
10092
  function emptyDirSync(dir) {
9556
10093
  let items;
@@ -9560,7 +10097,7 @@ var require_empty = __commonJS({
9560
10097
  return mkdir.mkdirsSync(dir);
9561
10098
  }
9562
10099
  items.forEach((item) => {
9563
- item = path.join(dir, item);
10100
+ item = path3.join(dir, item);
9564
10101
  remove.removeSync(item);
9565
10102
  });
9566
10103
  }
@@ -9578,7 +10115,7 @@ var require_file = __commonJS({
9578
10115
  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/file.js"(exports, module2) {
9579
10116
  "use strict";
9580
10117
  var u = require_universalify().fromPromise;
9581
- var path = require("path");
10118
+ var path3 = require("path");
9582
10119
  var fs = require_fs();
9583
10120
  var mkdir = require_mkdirs();
9584
10121
  async function createFile(file) {
@@ -9589,7 +10126,7 @@ var require_file = __commonJS({
9589
10126
  }
9590
10127
  if (stats && stats.isFile())
9591
10128
  return;
9592
- const dir = path.dirname(file);
10129
+ const dir = path3.dirname(file);
9593
10130
  let dirStats = null;
9594
10131
  try {
9595
10132
  dirStats = await fs.stat(dir);
@@ -9616,7 +10153,7 @@ var require_file = __commonJS({
9616
10153
  }
9617
10154
  if (stats && stats.isFile())
9618
10155
  return;
9619
- const dir = path.dirname(file);
10156
+ const dir = path3.dirname(file);
9620
10157
  try {
9621
10158
  if (!fs.statSync(dir).isDirectory()) {
9622
10159
  fs.readdirSync(dir);
@@ -9641,7 +10178,7 @@ var require_link = __commonJS({
9641
10178
  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/link.js"(exports, module2) {
9642
10179
  "use strict";
9643
10180
  var u = require_universalify().fromPromise;
9644
- var path = require("path");
10181
+ var path3 = require("path");
9645
10182
  var fs = require_fs();
9646
10183
  var mkdir = require_mkdirs();
9647
10184
  var { pathExists } = require_path_exists();
@@ -9661,7 +10198,7 @@ var require_link = __commonJS({
9661
10198
  }
9662
10199
  if (dstStat && areIdentical(srcStat, dstStat))
9663
10200
  return;
9664
- const dir = path.dirname(dstpath);
10201
+ const dir = path3.dirname(dstpath);
9665
10202
  const dirExists = await pathExists(dir);
9666
10203
  if (!dirExists) {
9667
10204
  await mkdir.mkdirs(dir);
@@ -9682,7 +10219,7 @@ var require_link = __commonJS({
9682
10219
  err.message = err.message.replace("lstat", "ensureLink");
9683
10220
  throw err;
9684
10221
  }
9685
- const dir = path.dirname(dstpath);
10222
+ const dir = path3.dirname(dstpath);
9686
10223
  const dirExists = fs.existsSync(dir);
9687
10224
  if (dirExists)
9688
10225
  return fs.linkSync(srcpath, dstpath);
@@ -9700,12 +10237,12 @@ var require_link = __commonJS({
9700
10237
  var require_symlink_paths = __commonJS({
9701
10238
  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module2) {
9702
10239
  "use strict";
9703
- var path = require("path");
10240
+ var path3 = require("path");
9704
10241
  var fs = require_fs();
9705
10242
  var { pathExists } = require_path_exists();
9706
10243
  var u = require_universalify().fromPromise;
9707
10244
  async function symlinkPaths(srcpath, dstpath) {
9708
- if (path.isAbsolute(srcpath)) {
10245
+ if (path3.isAbsolute(srcpath)) {
9709
10246
  try {
9710
10247
  await fs.lstat(srcpath);
9711
10248
  } catch (err) {
@@ -9717,8 +10254,8 @@ var require_symlink_paths = __commonJS({
9717
10254
  toDst: srcpath
9718
10255
  };
9719
10256
  }
9720
- const dstdir = path.dirname(dstpath);
9721
- const relativeToDst = path.join(dstdir, srcpath);
10257
+ const dstdir = path3.dirname(dstpath);
10258
+ const relativeToDst = path3.join(dstdir, srcpath);
9722
10259
  const exists = await pathExists(relativeToDst);
9723
10260
  if (exists) {
9724
10261
  return {
@@ -9734,11 +10271,11 @@ var require_symlink_paths = __commonJS({
9734
10271
  }
9735
10272
  return {
9736
10273
  toCwd: srcpath,
9737
- toDst: path.relative(dstdir, srcpath)
10274
+ toDst: path3.relative(dstdir, srcpath)
9738
10275
  };
9739
10276
  }
9740
10277
  function symlinkPathsSync(srcpath, dstpath) {
9741
- if (path.isAbsolute(srcpath)) {
10278
+ if (path3.isAbsolute(srcpath)) {
9742
10279
  const exists2 = fs.existsSync(srcpath);
9743
10280
  if (!exists2)
9744
10281
  throw new Error("absolute srcpath does not exist");
@@ -9747,8 +10284,8 @@ var require_symlink_paths = __commonJS({
9747
10284
  toDst: srcpath
9748
10285
  };
9749
10286
  }
9750
- const dstdir = path.dirname(dstpath);
9751
- const relativeToDst = path.join(dstdir, srcpath);
10287
+ const dstdir = path3.dirname(dstpath);
10288
+ const relativeToDst = path3.join(dstdir, srcpath);
9752
10289
  const exists = fs.existsSync(relativeToDst);
9753
10290
  if (exists) {
9754
10291
  return {
@@ -9761,7 +10298,7 @@ var require_symlink_paths = __commonJS({
9761
10298
  throw new Error("relative srcpath does not exist");
9762
10299
  return {
9763
10300
  toCwd: srcpath,
9764
- toDst: path.relative(dstdir, srcpath)
10301
+ toDst: path3.relative(dstdir, srcpath)
9765
10302
  };
9766
10303
  }
9767
10304
  module2.exports = {
@@ -9811,7 +10348,7 @@ var require_symlink = __commonJS({
9811
10348
  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module2) {
9812
10349
  "use strict";
9813
10350
  var u = require_universalify().fromPromise;
9814
- var path = require("path");
10351
+ var path3 = require("path");
9815
10352
  var fs = require_fs();
9816
10353
  var { mkdirs, mkdirsSync } = require_mkdirs();
9817
10354
  var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
@@ -9835,7 +10372,7 @@ var require_symlink = __commonJS({
9835
10372
  const relative = await symlinkPaths(srcpath, dstpath);
9836
10373
  srcpath = relative.toDst;
9837
10374
  const toType = await symlinkType(relative.toCwd, type);
9838
- const dir = path.dirname(dstpath);
10375
+ const dir = path3.dirname(dstpath);
9839
10376
  if (!await pathExists(dir)) {
9840
10377
  await mkdirs(dir);
9841
10378
  }
@@ -9856,7 +10393,7 @@ var require_symlink = __commonJS({
9856
10393
  const relative = symlinkPathsSync(srcpath, dstpath);
9857
10394
  srcpath = relative.toDst;
9858
10395
  type = symlinkTypeSync(relative.toCwd, type);
9859
- const dir = path.dirname(dstpath);
10396
+ const dir = path3.dirname(dstpath);
9860
10397
  const exists = fs.existsSync(dir);
9861
10398
  if (exists)
9862
10399
  return fs.symlinkSync(srcpath, dstpath, type);
@@ -9947,7 +10484,7 @@ var require_jsonfile = __commonJS({
9947
10484
  return obj;
9948
10485
  }
9949
10486
  var readFile = universalify.fromPromise(_readFile);
9950
- function readFileSync2(file, options = {}) {
10487
+ function readFileSync3(file, options = {}) {
9951
10488
  if (typeof options === "string") {
9952
10489
  options = { encoding: options };
9953
10490
  }
@@ -9979,7 +10516,7 @@ var require_jsonfile = __commonJS({
9979
10516
  }
9980
10517
  var jsonfile = {
9981
10518
  readFile,
9982
- readFileSync: readFileSync2,
10519
+ readFileSync: readFileSync3,
9983
10520
  writeFile,
9984
10521
  writeFileSync
9985
10522
  };
@@ -10008,18 +10545,18 @@ var require_output_file = __commonJS({
10008
10545
  "use strict";
10009
10546
  var u = require_universalify().fromPromise;
10010
10547
  var fs = require_fs();
10011
- var path = require("path");
10548
+ var path3 = require("path");
10012
10549
  var mkdir = require_mkdirs();
10013
10550
  var pathExists = require_path_exists().pathExists;
10014
10551
  async function outputFile(file, data, encoding = "utf-8") {
10015
- const dir = path.dirname(file);
10552
+ const dir = path3.dirname(file);
10016
10553
  if (!await pathExists(dir)) {
10017
10554
  await mkdir.mkdirs(dir);
10018
10555
  }
10019
10556
  return fs.writeFile(file, data, encoding);
10020
10557
  }
10021
10558
  function outputFileSync(file, ...args) {
10022
- const dir = path.dirname(file);
10559
+ const dir = path3.dirname(file);
10023
10560
  if (!fs.existsSync(dir)) {
10024
10561
  mkdir.mkdirsSync(dir);
10025
10562
  }
@@ -10083,7 +10620,7 @@ var require_move = __commonJS({
10083
10620
  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move.js"(exports, module2) {
10084
10621
  "use strict";
10085
10622
  var fs = require_fs();
10086
- var path = require("path");
10623
+ var path3 = require("path");
10087
10624
  var { copy } = require_copy2();
10088
10625
  var { remove } = require_remove();
10089
10626
  var { mkdirp } = require_mkdirs();
@@ -10093,8 +10630,8 @@ var require_move = __commonJS({
10093
10630
  const overwrite = opts.overwrite || opts.clobber || false;
10094
10631
  const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
10095
10632
  await stat.checkParentPaths(src, srcStat, dest, "move");
10096
- const destParent = path.dirname(dest);
10097
- const parsedParentPath = path.parse(destParent);
10633
+ const destParent = path3.dirname(dest);
10634
+ const parsedParentPath = path3.parse(destParent);
10098
10635
  if (parsedParentPath.root !== destParent) {
10099
10636
  await mkdirp(destParent);
10100
10637
  }
@@ -10135,7 +10672,7 @@ var require_move_sync = __commonJS({
10135
10672
  "node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move-sync.js"(exports, module2) {
10136
10673
  "use strict";
10137
10674
  var fs = require_graceful_fs();
10138
- var path = require("path");
10675
+ var path3 = require("path");
10139
10676
  var copySync = require_copy2().copySync;
10140
10677
  var removeSync2 = require_remove().removeSync;
10141
10678
  var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -10146,12 +10683,12 @@ var require_move_sync = __commonJS({
10146
10683
  const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
10147
10684
  stat.checkParentPathsSync(src, srcStat, dest, "move");
10148
10685
  if (!isParentRoot(dest))
10149
- mkdirpSync(path.dirname(dest));
10686
+ mkdirpSync(path3.dirname(dest));
10150
10687
  return doRename(src, dest, overwrite, isChangingCase);
10151
10688
  }
10152
10689
  function isParentRoot(dest) {
10153
- const parent = path.dirname(dest);
10154
- const parsedPath = path.parse(parent);
10690
+ const parent = path3.dirname(dest);
10691
+ const parsedPath = path3.parse(parent);
10155
10692
  return parsedPath.root === parent;
10156
10693
  }
10157
10694
  function doRename(src, dest, overwrite, isChangingCase) {
@@ -14523,7 +15060,7 @@ var require_iterate_metadata_intersection = __commonJS({
14523
15060
  var _b2 = __read(_a2, 1), c2 = _b2[0];
14524
15061
  return c2.size() === 1 && (c2.atomics.length === 1 || c2.constants.length === 1 && c2.constants[0].type === "boolean" || c2.arrays.length === 1);
14525
15062
  });
14526
- var constants = children.filter(function(m2) {
15063
+ var constants3 = children.filter(function(m2) {
14527
15064
  return m2.size() === m2.constants.map(function(c2) {
14528
15065
  return c2.values.length;
14529
15066
  }).reduce(function(a, b) {
@@ -14553,7 +15090,7 @@ var require_iterate_metadata_intersection = __commonJS({
14553
15090
  return a.type.name;
14554
15091
  });
14555
15092
  }).flat());
14556
- if (atomics.size + arrays.size > 1 || individuals.length + objects.length + constants.length !== children.length) {
15093
+ if (atomics.size + arrays.size > 1 || individuals.length + objects.length + constants3.length !== children.length) {
14557
15094
  errors.push({
14558
15095
  name: children.map(function(c2) {
14559
15096
  return c2.getName();
@@ -14562,9 +15099,9 @@ var require_iterate_metadata_intersection = __commonJS({
14562
15099
  messages: ["nonsensible intersection"]
14563
15100
  });
14564
15101
  return true;
14565
- } else if (atomics.size === 0 && arrays.size === 0 && constants.length) {
15102
+ } else if (atomics.size === 0 && arrays.size === 0 && constants3.length) {
14566
15103
  try {
14567
- for (var constants_1 = __values(constants), constants_1_1 = constants_1.next(); !constants_1_1.done; constants_1_1 = constants_1.next()) {
15104
+ for (var constants_1 = __values(constants3), constants_1_1 = constants_1.next(); !constants_1_1.done; constants_1_1 = constants_1.next()) {
14568
15105
  var m = constants_1_1.value;
14569
15106
  try {
14570
15107
  for (var _e = (e_2 = void 0, __values(m.templates)), _f = _e.next(); !_f.done; _f = _e.next()) {
@@ -20122,14 +20659,14 @@ var require_AssertProgrammer = __commonJS({
20122
20659
  object: assert_object(equals)(project)(importer),
20123
20660
  numeric: true
20124
20661
  })(project)(importer).combiner(explore);
20125
- var path = explore.postfix ? "_path + ".concat(explore.postfix) : "_path";
20662
+ var path3 = explore.postfix ? "_path + ".concat(explore.postfix) : "_path";
20126
20663
  return function(logic) {
20127
20664
  return function(input, binaries, expected) {
20128
20665
  return logic === "and" ? binaries.map(function(binary) {
20129
- return binary.combined ? binary.expression : typescript_1.default.factory.createLogicalOr(binary.expression, create_guard_call(importer)(explore.source === "top" ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createIdentifier("_exceptionable"))(typescript_1.default.factory.createIdentifier(path), expected, input));
20666
+ return binary.combined ? binary.expression : typescript_1.default.factory.createLogicalOr(binary.expression, create_guard_call(importer)(explore.source === "top" ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createIdentifier("_exceptionable"))(typescript_1.default.factory.createIdentifier(path3), expected, input));
20130
20667
  }).reduce(typescript_1.default.factory.createLogicalAnd) : typescript_1.default.factory.createLogicalOr(binaries.map(function(binary) {
20131
20668
  return binary.expression;
20132
- }).reduce(typescript_1.default.factory.createLogicalOr), create_guard_call(importer)(explore.source === "top" ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createIdentifier("_exceptionable"))(typescript_1.default.factory.createIdentifier(path), expected, input));
20669
+ }).reduce(typescript_1.default.factory.createLogicalOr), create_guard_call(importer)(explore.source === "top" ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createIdentifier("_exceptionable"))(typescript_1.default.factory.createIdentifier(path3), expected, input));
20133
20670
  };
20134
20671
  };
20135
20672
  };
@@ -20179,11 +20716,11 @@ var require_AssertProgrammer = __commonJS({
20179
20716
  };
20180
20717
  var create_guard_call = function(importer) {
20181
20718
  return function(exceptionable) {
20182
- return function(path, expected, value) {
20719
+ return function(path3, expected, value) {
20183
20720
  return typescript_1.default.factory.createCallExpression(importer.use("guard"), void 0, [
20184
20721
  exceptionable !== null && exceptionable !== void 0 ? exceptionable : typescript_1.default.factory.createIdentifier("_exceptionable"),
20185
20722
  typescript_1.default.factory.createObjectLiteralExpression([
20186
- typescript_1.default.factory.createPropertyAssignment("path", path),
20723
+ typescript_1.default.factory.createPropertyAssignment("path", path3),
20187
20724
  typescript_1.default.factory.createPropertyAssignment("expected", typescript_1.default.factory.createStringLiteral(expected)),
20188
20725
  typescript_1.default.factory.createPropertyAssignment("value", value)
20189
20726
  ], true)
@@ -21617,14 +22154,14 @@ var require_ValidateProgrammer = __commonJS({
21617
22154
  object: validate_object(equals)(project)(importer),
21618
22155
  numeric: true
21619
22156
  })(project)(importer).combiner(explore);
21620
- var path = explore.postfix ? "_path + ".concat(explore.postfix) : "_path";
22157
+ var path3 = explore.postfix ? "_path + ".concat(explore.postfix) : "_path";
21621
22158
  return function(logic) {
21622
22159
  return function(input, binaries, expected) {
21623
22160
  return logic === "and" ? binaries.map(function(binary) {
21624
- return binary.combined ? binary.expression : typescript_1.default.factory.createLogicalOr(binary.expression, create_report_call(explore.source === "top" ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createIdentifier("_exceptionable"))(typescript_1.default.factory.createIdentifier(path), expected, input));
22161
+ return binary.combined ? binary.expression : typescript_1.default.factory.createLogicalOr(binary.expression, create_report_call(explore.source === "top" ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createIdentifier("_exceptionable"))(typescript_1.default.factory.createIdentifier(path3), expected, input));
21625
22162
  }).reduce(typescript_1.default.factory.createLogicalAnd) : typescript_1.default.factory.createLogicalOr(binaries.map(function(binary) {
21626
22163
  return binary.expression;
21627
- }).reduce(typescript_1.default.factory.createLogicalOr), create_report_call(explore.source === "top" ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createIdentifier("_exceptionable"))(typescript_1.default.factory.createIdentifier(path), expected, input));
22164
+ }).reduce(typescript_1.default.factory.createLogicalOr), create_report_call(explore.source === "top" ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createIdentifier("_exceptionable"))(typescript_1.default.factory.createIdentifier(path3), expected, input));
21628
22165
  };
21629
22166
  };
21630
22167
  };
@@ -21678,11 +22215,11 @@ var require_ValidateProgrammer = __commonJS({
21678
22215
  ], true);
21679
22216
  };
21680
22217
  var create_report_call = function(exceptionable) {
21681
- return function(path, expected, value) {
22218
+ return function(path3, expected, value) {
21682
22219
  return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("$report"), void 0, [
21683
22220
  exceptionable !== null && exceptionable !== void 0 ? exceptionable : typescript_1.default.factory.createIdentifier("_exceptionable"),
21684
22221
  typescript_1.default.factory.createObjectLiteralExpression([
21685
- typescript_1.default.factory.createPropertyAssignment("path", path),
22222
+ typescript_1.default.factory.createPropertyAssignment("path", path3),
21686
22223
  typescript_1.default.factory.createPropertyAssignment("expected", typescript_1.default.factory.createStringLiteral(expected)),
21687
22224
  typescript_1.default.factory.createPropertyAssignment("value", value)
21688
22225
  ], true)
@@ -32819,7 +33356,7 @@ ${chalk.bold.hex(config?.colors?.fatal ? config.colors.fatal : "#1fb2a6")(">")}
32819
33356
  return (message) => {
32820
33357
  console.error(
32821
33358
  `
32822
- ${chalk.bold.hex(config?.colors?.error ? config.colors.error : "#7d1a1a")(">")} ${chalk.bold.bgHex(config?.colors?.error ? config.colors.error : "#7d1a1a").white(" \u{1F6D1} Error ")} ${chalk.hex(
33359
+ ${chalk.bold.hex(config?.colors?.error ? config.colors.error : "#7d1a1a")(">")} ${chalk.bold.bgHex(config?.colors?.error ? config.colors.error : "#7d1a1a").white(" \u2718 Error ")} ${chalk.hex(
32823
33360
  config?.colors?.error ? config.colors.error : "#7d1a1a"
32824
33361
  )(message)}
32825
33362
  `
@@ -32830,7 +33367,7 @@ ${chalk.bold.hex(config?.colors?.error ? config.colors.error : "#7d1a1a")(">")}
32830
33367
  return (message) => {
32831
33368
  console.warn(
32832
33369
  `
32833
- ${chalk.bold.hex(config?.colors?.warning ? config.colors.warning : "#fcc419")(">")} ${chalk.bold.bgHex(config?.colors?.warning ? config.colors.warning : "#fcc419").white(" \u26A0\uFE0F Warn ")} ${chalk.hex(
33370
+ ${chalk.bold.hex(config?.colors?.warning ? config.colors.warning : "#fcc419")(">")} ${chalk.bold.bgHex(config?.colors?.warning ? config.colors.warning : "#fcc419").white(" ! Warn ")} ${chalk.hex(
32834
33371
  config?.colors?.warning ? config.colors.warning : "#fcc419"
32835
33372
  )(message)}
32836
33373
  `
@@ -32841,9 +33378,9 @@ ${chalk.bold.hex(config?.colors?.warning ? config.colors.warning : "#fcc419")(">
32841
33378
  return (message) => {
32842
33379
  console.info(
32843
33380
  `
32844
- ${chalk.bold.hex(config?.colors?.info ? config.colors.info : "#0ea5e9")(">")} ${chalk.bold.bgHex(config?.colors?.info ? config.colors.info : "#0ea5e9").white(" \u{1F4EC} Info ")} ${chalk.hex(
32845
- config?.colors?.info ? config.colors.info : "#0ea5e9"
32846
- )(message)}
33381
+ ${chalk.bold.hex(config?.colors?.info ? config.colors.info : "#0ea5e9")(">")} ${chalk.bold.bgHex(config?.colors?.info ? config.colors.info : "#0ea5e9").white(" \u2139 Info ")} ${chalk.hex(config?.colors?.info ? config.colors.info : "#0ea5e9")(
33382
+ message
33383
+ )}
32847
33384
  `
32848
33385
  );
32849
33386
  };
@@ -32852,7 +33389,7 @@ ${chalk.bold.hex(config?.colors?.info ? config.colors.info : "#0ea5e9")(">")} ${
32852
33389
  return (message) => {
32853
33390
  console.info(
32854
33391
  `
32855
- ${chalk.bold.hex(config?.colors?.success ? config.colors.success : "#087f5b")(">")} ${chalk.bold.bgHex(config?.colors?.success ? config.colors.success : "#087f5b").white(" \u{1F389} Success ")} ${chalk.hex(
33392
+ ${chalk.bold.hex(config?.colors?.success ? config.colors.success : "#087f5b")(">")} ${chalk.bold.bgHex(config?.colors?.success ? config.colors.success : "#087f5b").white(" \u221A Success ")} ${chalk.hex(
32856
33393
  config?.colors?.success ? config.colors.success : "#087f5b"
32857
33394
  )(message)}
32858
33395
  `
@@ -32925,12 +33462,9 @@ var getConfigFile = async (filePath) => {
32925
33462
  }
32926
33463
  }
32927
33464
  if (!cosmiconfigResult || Object.keys(cosmiconfigResult).length === 0 || cosmiconfigResult.isEmpty || !cosmiconfigResult.filepath) {
32928
- console.warn(
32929
- "No Storm config file found in the current workspace. Please ensure this is the expected behavior - you can add a `storm.config.js` file to the root of your workspace if it is not."
32930
- );
32931
33465
  writeWarning(
32932
- { logLevel: "error" },
32933
- "No Storm config file found in the current workspace. Please ensure this is the expected behavior - you can add a `storm.config.js` file to the root of your workspace if it is not."
33466
+ { logLevel: "all" },
33467
+ "No Storm config file found in the current workspace. Please ensure this is the expected behavior - you can add a `storm.config.js` file to the root of your workspace if it is not.\n"
32934
33468
  );
32935
33469
  return void 0;
32936
33470
  }
@@ -33357,8 +33891,8 @@ function getErrorMap() {
33357
33891
  return overrideErrorMap;
33358
33892
  }
33359
33893
  var makeIssue = (params) => {
33360
- const { data, path, errorMaps, issueData } = params;
33361
- const fullPath = [...path, ...issueData.path || []];
33894
+ const { data, path: path3, errorMaps, issueData } = params;
33895
+ const fullPath = [...path3, ...issueData.path || []];
33362
33896
  const fullIssue = {
33363
33897
  ...issueData,
33364
33898
  path: fullPath
@@ -33456,11 +33990,11 @@ var errorUtil;
33456
33990
  errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
33457
33991
  })(errorUtil || (errorUtil = {}));
33458
33992
  var ParseInputLazyPath = class {
33459
- constructor(parent, value, path, key) {
33993
+ constructor(parent, value, path3, key) {
33460
33994
  this._cachedPath = [];
33461
33995
  this.parent = parent;
33462
33996
  this.data = value;
33463
- this._path = path;
33997
+ this._path = path3;
33464
33998
  this._key = key;
33465
33999
  }
33466
34000
  get path() {
@@ -36646,7 +37180,7 @@ var StormConfigSchema = objectType({
36646
37180
  );
36647
37181
 
36648
37182
  // packages/config-tools/src/utilities/get-default-config.ts
36649
- var DefaultColorConfig = {
37183
+ var DEFAULT_COLOR_CONFIG = {
36650
37184
  primary: "#1fb2a6",
36651
37185
  background: "#1d232a",
36652
37186
  success: "#087f5b",
@@ -36655,7 +37189,7 @@ var DefaultColorConfig = {
36655
37189
  error: "#990000",
36656
37190
  fatal: "#7d1a1a"
36657
37191
  };
36658
- var DefaultStormConfig = {
37192
+ var DEFAULT_STORM_CONFIG = {
36659
37193
  name: "storm",
36660
37194
  namespace: "storm-software",
36661
37195
  license: "Apache License 2.0",
@@ -36673,15 +37207,15 @@ var DefaultStormConfig = {
36673
37207
  ci: true,
36674
37208
  configFile: null,
36675
37209
  runtimeVersion: "1.0.0",
36676
- colors: { ...DefaultColorConfig },
37210
+ colors: { ...DEFAULT_COLOR_CONFIG },
36677
37211
  extensions: {}
36678
37212
  };
36679
37213
  var getDefaultConfig = (config = {}, root) => {
36680
37214
  let name = "storm-workspace";
36681
37215
  let namespace = "storm-software";
36682
37216
  let repository = "https://github.com/storm-software/storm-ops";
36683
- let license = DefaultStormConfig.license;
36684
- let homepage = DefaultStormConfig.homepage;
37217
+ let license = DEFAULT_STORM_CONFIG.license;
37218
+ let homepage = DEFAULT_STORM_CONFIG.homepage;
36685
37219
  const workspaceRoot = findWorkspaceRoot(root);
36686
37220
  if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(workspaceRoot, "package.json"))) {
36687
37221
  const file = (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(workspaceRoot, "package.json"), {
@@ -36707,21 +37241,1648 @@ var getDefaultConfig = (config = {}, root) => {
36707
37241
  }
36708
37242
  }
36709
37243
  return StormConfigSchema.parse({
36710
- ...DefaultStormConfig,
37244
+ ...DEFAULT_STORM_CONFIG,
36711
37245
  ...config,
36712
- colors: { ...DefaultColorConfig, ...config.colors },
37246
+ colors: { ...DEFAULT_COLOR_CONFIG, ...config.colors },
36713
37247
  workspaceRoot,
36714
37248
  name,
36715
37249
  namespace,
36716
37250
  repository,
36717
- license: license ?? DefaultStormConfig.license,
36718
- homepage: homepage ?? DefaultStormConfig.homepage,
37251
+ license: license ?? DEFAULT_STORM_CONFIG.license,
37252
+ homepage: homepage ?? DEFAULT_STORM_CONFIG.homepage,
36719
37253
  extensions: {
36720
37254
  ...config.extensions
36721
37255
  }
36722
37256
  });
36723
37257
  };
36724
37258
 
37259
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/index.js
37260
+ var import_node_buffer2 = require("node:buffer");
37261
+ var import_node_path4 = __toESM(require("node:path"), 1);
37262
+ var import_node_child_process3 = __toESM(require("node:child_process"), 1);
37263
+ var import_node_process4 = __toESM(require("node:process"), 1);
37264
+ var import_cross_spawn = __toESM(require_cross_spawn(), 1);
37265
+
37266
+ // node_modules/.pnpm/strip-final-newline@3.0.0/node_modules/strip-final-newline/index.js
37267
+ function stripFinalNewline(input) {
37268
+ const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
37269
+ const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
37270
+ if (input[input.length - 1] === LF) {
37271
+ input = input.slice(0, -1);
37272
+ }
37273
+ if (input[input.length - 1] === CR) {
37274
+ input = input.slice(0, -1);
37275
+ }
37276
+ return input;
37277
+ }
37278
+
37279
+ // node_modules/.pnpm/npm-run-path@5.1.0/node_modules/npm-run-path/index.js
37280
+ var import_node_process = __toESM(require("node:process"), 1);
37281
+ var import_node_path3 = __toESM(require("node:path"), 1);
37282
+ var import_node_url = __toESM(require("node:url"), 1);
37283
+
37284
+ // node_modules/.pnpm/path-key@4.0.0/node_modules/path-key/index.js
37285
+ function pathKey(options = {}) {
37286
+ const {
37287
+ env = process.env,
37288
+ platform = process.platform
37289
+ } = options;
37290
+ if (platform !== "win32") {
37291
+ return "PATH";
37292
+ }
37293
+ return Object.keys(env).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
37294
+ }
37295
+
37296
+ // node_modules/.pnpm/npm-run-path@5.1.0/node_modules/npm-run-path/index.js
37297
+ function npmRunPath(options = {}) {
37298
+ const {
37299
+ cwd = import_node_process.default.cwd(),
37300
+ path: path_ = import_node_process.default.env[pathKey()],
37301
+ execPath = import_node_process.default.execPath
37302
+ } = options;
37303
+ let previous;
37304
+ const cwdString = cwd instanceof URL ? import_node_url.default.fileURLToPath(cwd) : cwd;
37305
+ let cwdPath = import_node_path3.default.resolve(cwdString);
37306
+ const result = [];
37307
+ while (previous !== cwdPath) {
37308
+ result.push(import_node_path3.default.join(cwdPath, "node_modules/.bin"));
37309
+ previous = cwdPath;
37310
+ cwdPath = import_node_path3.default.resolve(cwdPath, "..");
37311
+ }
37312
+ result.push(import_node_path3.default.resolve(cwdString, execPath, ".."));
37313
+ return [...result, path_].join(import_node_path3.default.delimiter);
37314
+ }
37315
+ function npmRunPathEnv({ env = import_node_process.default.env, ...options } = {}) {
37316
+ env = { ...env };
37317
+ const path3 = pathKey({ env });
37318
+ options.path = env[path3];
37319
+ env[path3] = npmRunPath(options);
37320
+ return env;
37321
+ }
37322
+
37323
+ // node_modules/.pnpm/mimic-fn@4.0.0/node_modules/mimic-fn/index.js
37324
+ var copyProperty = (to, from, property, ignoreNonConfigurable) => {
37325
+ if (property === "length" || property === "prototype") {
37326
+ return;
37327
+ }
37328
+ if (property === "arguments" || property === "caller") {
37329
+ return;
37330
+ }
37331
+ const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
37332
+ const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
37333
+ if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
37334
+ return;
37335
+ }
37336
+ Object.defineProperty(to, property, fromDescriptor);
37337
+ };
37338
+ var canCopyProperty = function(toDescriptor, fromDescriptor) {
37339
+ return toDescriptor === void 0 || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
37340
+ };
37341
+ var changePrototype = (to, from) => {
37342
+ const fromPrototype = Object.getPrototypeOf(from);
37343
+ if (fromPrototype === Object.getPrototypeOf(to)) {
37344
+ return;
37345
+ }
37346
+ Object.setPrototypeOf(to, fromPrototype);
37347
+ };
37348
+ var wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/
37349
+ ${fromBody}`;
37350
+ var toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString");
37351
+ var toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name");
37352
+ var changeToString = (to, from, name) => {
37353
+ const withName = name === "" ? "" : `with ${name.trim()}() `;
37354
+ const newToString = wrappedToString.bind(null, withName, from.toString());
37355
+ Object.defineProperty(newToString, "name", toStringName);
37356
+ Object.defineProperty(to, "toString", { ...toStringDescriptor, value: newToString });
37357
+ };
37358
+ function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
37359
+ const { name } = to;
37360
+ for (const property of Reflect.ownKeys(from)) {
37361
+ copyProperty(to, from, property, ignoreNonConfigurable);
37362
+ }
37363
+ changePrototype(to, from);
37364
+ changeToString(to, from, name);
37365
+ return to;
37366
+ }
37367
+
37368
+ // node_modules/.pnpm/onetime@6.0.0/node_modules/onetime/index.js
37369
+ var calledFunctions = /* @__PURE__ */ new WeakMap();
37370
+ var onetime = (function_, options = {}) => {
37371
+ if (typeof function_ !== "function") {
37372
+ throw new TypeError("Expected a function");
37373
+ }
37374
+ let returnValue;
37375
+ let callCount = 0;
37376
+ const functionName = function_.displayName || function_.name || "<anonymous>";
37377
+ const onetime2 = function(...arguments_) {
37378
+ calledFunctions.set(onetime2, ++callCount);
37379
+ if (callCount === 1) {
37380
+ returnValue = function_.apply(this, arguments_);
37381
+ function_ = null;
37382
+ } else if (options.throw === true) {
37383
+ throw new Error(`Function \`${functionName}\` can only be called once`);
37384
+ }
37385
+ return returnValue;
37386
+ };
37387
+ mimicFunction(onetime2, function_);
37388
+ calledFunctions.set(onetime2, callCount);
37389
+ return onetime2;
37390
+ };
37391
+ onetime.callCount = (function_) => {
37392
+ if (!calledFunctions.has(function_)) {
37393
+ throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
37394
+ }
37395
+ return calledFunctions.get(function_);
37396
+ };
37397
+ var onetime_default = onetime;
37398
+
37399
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/error.js
37400
+ var import_node_process2 = __toESM(require("node:process"), 1);
37401
+
37402
+ // node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/main.js
37403
+ var import_node_os2 = require("node:os");
37404
+
37405
+ // node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/realtime.js
37406
+ var getRealtimeSignals = () => {
37407
+ const length = SIGRTMAX - SIGRTMIN + 1;
37408
+ return Array.from({ length }, getRealtimeSignal);
37409
+ };
37410
+ var getRealtimeSignal = (value, index) => ({
37411
+ name: `SIGRT${index + 1}`,
37412
+ number: SIGRTMIN + index,
37413
+ action: "terminate",
37414
+ description: "Application-specific signal (realtime)",
37415
+ standard: "posix"
37416
+ });
37417
+ var SIGRTMIN = 34;
37418
+ var SIGRTMAX = 64;
37419
+
37420
+ // node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/signals.js
37421
+ var import_node_os = require("node:os");
37422
+
37423
+ // node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/core.js
37424
+ var SIGNALS = [
37425
+ {
37426
+ name: "SIGHUP",
37427
+ number: 1,
37428
+ action: "terminate",
37429
+ description: "Terminal closed",
37430
+ standard: "posix"
37431
+ },
37432
+ {
37433
+ name: "SIGINT",
37434
+ number: 2,
37435
+ action: "terminate",
37436
+ description: "User interruption with CTRL-C",
37437
+ standard: "ansi"
37438
+ },
37439
+ {
37440
+ name: "SIGQUIT",
37441
+ number: 3,
37442
+ action: "core",
37443
+ description: "User interruption with CTRL-\\",
37444
+ standard: "posix"
37445
+ },
37446
+ {
37447
+ name: "SIGILL",
37448
+ number: 4,
37449
+ action: "core",
37450
+ description: "Invalid machine instruction",
37451
+ standard: "ansi"
37452
+ },
37453
+ {
37454
+ name: "SIGTRAP",
37455
+ number: 5,
37456
+ action: "core",
37457
+ description: "Debugger breakpoint",
37458
+ standard: "posix"
37459
+ },
37460
+ {
37461
+ name: "SIGABRT",
37462
+ number: 6,
37463
+ action: "core",
37464
+ description: "Aborted",
37465
+ standard: "ansi"
37466
+ },
37467
+ {
37468
+ name: "SIGIOT",
37469
+ number: 6,
37470
+ action: "core",
37471
+ description: "Aborted",
37472
+ standard: "bsd"
37473
+ },
37474
+ {
37475
+ name: "SIGBUS",
37476
+ number: 7,
37477
+ action: "core",
37478
+ description: "Bus error due to misaligned, non-existing address or paging error",
37479
+ standard: "bsd"
37480
+ },
37481
+ {
37482
+ name: "SIGEMT",
37483
+ number: 7,
37484
+ action: "terminate",
37485
+ description: "Command should be emulated but is not implemented",
37486
+ standard: "other"
37487
+ },
37488
+ {
37489
+ name: "SIGFPE",
37490
+ number: 8,
37491
+ action: "core",
37492
+ description: "Floating point arithmetic error",
37493
+ standard: "ansi"
37494
+ },
37495
+ {
37496
+ name: "SIGKILL",
37497
+ number: 9,
37498
+ action: "terminate",
37499
+ description: "Forced termination",
37500
+ standard: "posix",
37501
+ forced: true
37502
+ },
37503
+ {
37504
+ name: "SIGUSR1",
37505
+ number: 10,
37506
+ action: "terminate",
37507
+ description: "Application-specific signal",
37508
+ standard: "posix"
37509
+ },
37510
+ {
37511
+ name: "SIGSEGV",
37512
+ number: 11,
37513
+ action: "core",
37514
+ description: "Segmentation fault",
37515
+ standard: "ansi"
37516
+ },
37517
+ {
37518
+ name: "SIGUSR2",
37519
+ number: 12,
37520
+ action: "terminate",
37521
+ description: "Application-specific signal",
37522
+ standard: "posix"
37523
+ },
37524
+ {
37525
+ name: "SIGPIPE",
37526
+ number: 13,
37527
+ action: "terminate",
37528
+ description: "Broken pipe or socket",
37529
+ standard: "posix"
37530
+ },
37531
+ {
37532
+ name: "SIGALRM",
37533
+ number: 14,
37534
+ action: "terminate",
37535
+ description: "Timeout or timer",
37536
+ standard: "posix"
37537
+ },
37538
+ {
37539
+ name: "SIGTERM",
37540
+ number: 15,
37541
+ action: "terminate",
37542
+ description: "Termination",
37543
+ standard: "ansi"
37544
+ },
37545
+ {
37546
+ name: "SIGSTKFLT",
37547
+ number: 16,
37548
+ action: "terminate",
37549
+ description: "Stack is empty or overflowed",
37550
+ standard: "other"
37551
+ },
37552
+ {
37553
+ name: "SIGCHLD",
37554
+ number: 17,
37555
+ action: "ignore",
37556
+ description: "Child process terminated, paused or unpaused",
37557
+ standard: "posix"
37558
+ },
37559
+ {
37560
+ name: "SIGCLD",
37561
+ number: 17,
37562
+ action: "ignore",
37563
+ description: "Child process terminated, paused or unpaused",
37564
+ standard: "other"
37565
+ },
37566
+ {
37567
+ name: "SIGCONT",
37568
+ number: 18,
37569
+ action: "unpause",
37570
+ description: "Unpaused",
37571
+ standard: "posix",
37572
+ forced: true
37573
+ },
37574
+ {
37575
+ name: "SIGSTOP",
37576
+ number: 19,
37577
+ action: "pause",
37578
+ description: "Paused",
37579
+ standard: "posix",
37580
+ forced: true
37581
+ },
37582
+ {
37583
+ name: "SIGTSTP",
37584
+ number: 20,
37585
+ action: "pause",
37586
+ description: 'Paused using CTRL-Z or "suspend"',
37587
+ standard: "posix"
37588
+ },
37589
+ {
37590
+ name: "SIGTTIN",
37591
+ number: 21,
37592
+ action: "pause",
37593
+ description: "Background process cannot read terminal input",
37594
+ standard: "posix"
37595
+ },
37596
+ {
37597
+ name: "SIGBREAK",
37598
+ number: 21,
37599
+ action: "terminate",
37600
+ description: "User interruption with CTRL-BREAK",
37601
+ standard: "other"
37602
+ },
37603
+ {
37604
+ name: "SIGTTOU",
37605
+ number: 22,
37606
+ action: "pause",
37607
+ description: "Background process cannot write to terminal output",
37608
+ standard: "posix"
37609
+ },
37610
+ {
37611
+ name: "SIGURG",
37612
+ number: 23,
37613
+ action: "ignore",
37614
+ description: "Socket received out-of-band data",
37615
+ standard: "bsd"
37616
+ },
37617
+ {
37618
+ name: "SIGXCPU",
37619
+ number: 24,
37620
+ action: "core",
37621
+ description: "Process timed out",
37622
+ standard: "bsd"
37623
+ },
37624
+ {
37625
+ name: "SIGXFSZ",
37626
+ number: 25,
37627
+ action: "core",
37628
+ description: "File too big",
37629
+ standard: "bsd"
37630
+ },
37631
+ {
37632
+ name: "SIGVTALRM",
37633
+ number: 26,
37634
+ action: "terminate",
37635
+ description: "Timeout or timer",
37636
+ standard: "bsd"
37637
+ },
37638
+ {
37639
+ name: "SIGPROF",
37640
+ number: 27,
37641
+ action: "terminate",
37642
+ description: "Timeout or timer",
37643
+ standard: "bsd"
37644
+ },
37645
+ {
37646
+ name: "SIGWINCH",
37647
+ number: 28,
37648
+ action: "ignore",
37649
+ description: "Terminal window size changed",
37650
+ standard: "bsd"
37651
+ },
37652
+ {
37653
+ name: "SIGIO",
37654
+ number: 29,
37655
+ action: "terminate",
37656
+ description: "I/O is available",
37657
+ standard: "other"
37658
+ },
37659
+ {
37660
+ name: "SIGPOLL",
37661
+ number: 29,
37662
+ action: "terminate",
37663
+ description: "Watched event",
37664
+ standard: "other"
37665
+ },
37666
+ {
37667
+ name: "SIGINFO",
37668
+ number: 29,
37669
+ action: "ignore",
37670
+ description: "Request for process information",
37671
+ standard: "other"
37672
+ },
37673
+ {
37674
+ name: "SIGPWR",
37675
+ number: 30,
37676
+ action: "terminate",
37677
+ description: "Device running out of power",
37678
+ standard: "systemv"
37679
+ },
37680
+ {
37681
+ name: "SIGSYS",
37682
+ number: 31,
37683
+ action: "core",
37684
+ description: "Invalid system call",
37685
+ standard: "other"
37686
+ },
37687
+ {
37688
+ name: "SIGUNUSED",
37689
+ number: 31,
37690
+ action: "terminate",
37691
+ description: "Invalid system call",
37692
+ standard: "other"
37693
+ }
37694
+ ];
37695
+
37696
+ // node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/signals.js
37697
+ var getSignals = () => {
37698
+ const realtimeSignals = getRealtimeSignals();
37699
+ const signals2 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
37700
+ return signals2;
37701
+ };
37702
+ var normalizeSignal = ({
37703
+ name,
37704
+ number: defaultNumber,
37705
+ description,
37706
+ action,
37707
+ forced = false,
37708
+ standard
37709
+ }) => {
37710
+ const {
37711
+ signals: { [name]: constantSignal }
37712
+ } = import_node_os.constants;
37713
+ const supported = constantSignal !== void 0;
37714
+ const number = supported ? constantSignal : defaultNumber;
37715
+ return { name, number, description, supported, action, forced, standard };
37716
+ };
37717
+
37718
+ // node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/main.js
37719
+ var getSignalsByName = () => {
37720
+ const signals2 = getSignals();
37721
+ return Object.fromEntries(signals2.map(getSignalByName));
37722
+ };
37723
+ var getSignalByName = ({
37724
+ name,
37725
+ number,
37726
+ description,
37727
+ supported,
37728
+ action,
37729
+ forced,
37730
+ standard
37731
+ }) => [name, { name, number, description, supported, action, forced, standard }];
37732
+ var signalsByName = getSignalsByName();
37733
+ var getSignalsByNumber = () => {
37734
+ const signals2 = getSignals();
37735
+ const length = SIGRTMAX + 1;
37736
+ const signalsA = Array.from(
37737
+ { length },
37738
+ (value, number) => getSignalByNumber(number, signals2)
37739
+ );
37740
+ return Object.assign({}, ...signalsA);
37741
+ };
37742
+ var getSignalByNumber = (number, signals2) => {
37743
+ const signal = findSignalByNumber(number, signals2);
37744
+ if (signal === void 0) {
37745
+ return {};
37746
+ }
37747
+ const { name, description, supported, action, forced, standard } = signal;
37748
+ return {
37749
+ [number]: {
37750
+ name,
37751
+ number,
37752
+ description,
37753
+ supported,
37754
+ action,
37755
+ forced,
37756
+ standard
37757
+ }
37758
+ };
37759
+ };
37760
+ var findSignalByNumber = (number, signals2) => {
37761
+ const signal = signals2.find(({ name }) => import_node_os2.constants.signals[name] === number);
37762
+ if (signal !== void 0) {
37763
+ return signal;
37764
+ }
37765
+ return signals2.find((signalA) => signalA.number === number);
37766
+ };
37767
+ var signalsByNumber = getSignalsByNumber();
37768
+
37769
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/error.js
37770
+ var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
37771
+ if (timedOut) {
37772
+ return `timed out after ${timeout} milliseconds`;
37773
+ }
37774
+ if (isCanceled) {
37775
+ return "was canceled";
37776
+ }
37777
+ if (errorCode !== void 0) {
37778
+ return `failed with ${errorCode}`;
37779
+ }
37780
+ if (signal !== void 0) {
37781
+ return `was killed with ${signal} (${signalDescription})`;
37782
+ }
37783
+ if (exitCode !== void 0) {
37784
+ return `failed with exit code ${exitCode}`;
37785
+ }
37786
+ return "failed";
37787
+ };
37788
+ var makeError = ({
37789
+ stdout,
37790
+ stderr,
37791
+ all,
37792
+ error,
37793
+ signal,
37794
+ exitCode,
37795
+ command,
37796
+ escapedCommand,
37797
+ timedOut,
37798
+ isCanceled,
37799
+ killed,
37800
+ parsed: { options: { timeout, cwd = import_node_process2.default.cwd() } }
37801
+ }) => {
37802
+ exitCode = exitCode === null ? void 0 : exitCode;
37803
+ signal = signal === null ? void 0 : signal;
37804
+ const signalDescription = signal === void 0 ? void 0 : signalsByName[signal].description;
37805
+ const errorCode = error && error.code;
37806
+ const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
37807
+ const execaMessage = `Command ${prefix}: ${command}`;
37808
+ const isError = Object.prototype.toString.call(error) === "[object Error]";
37809
+ const shortMessage = isError ? `${execaMessage}
37810
+ ${error.message}` : execaMessage;
37811
+ const message = [shortMessage, stderr, stdout].filter(Boolean).join("\n");
37812
+ if (isError) {
37813
+ error.originalMessage = error.message;
37814
+ error.message = message;
37815
+ } else {
37816
+ error = new Error(message);
37817
+ }
37818
+ error.shortMessage = shortMessage;
37819
+ error.command = command;
37820
+ error.escapedCommand = escapedCommand;
37821
+ error.exitCode = exitCode;
37822
+ error.signal = signal;
37823
+ error.signalDescription = signalDescription;
37824
+ error.stdout = stdout;
37825
+ error.stderr = stderr;
37826
+ error.cwd = cwd;
37827
+ if (all !== void 0) {
37828
+ error.all = all;
37829
+ }
37830
+ if ("bufferedData" in error) {
37831
+ delete error.bufferedData;
37832
+ }
37833
+ error.failed = true;
37834
+ error.timedOut = Boolean(timedOut);
37835
+ error.isCanceled = isCanceled;
37836
+ error.killed = killed && !timedOut;
37837
+ return error;
37838
+ };
37839
+
37840
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/stdio.js
37841
+ var aliases = ["stdin", "stdout", "stderr"];
37842
+ var hasAlias = (options) => aliases.some((alias) => options[alias] !== void 0);
37843
+ var normalizeStdio = (options) => {
37844
+ if (!options) {
37845
+ return;
37846
+ }
37847
+ const { stdio } = options;
37848
+ if (stdio === void 0) {
37849
+ return aliases.map((alias) => options[alias]);
37850
+ }
37851
+ if (hasAlias(options)) {
37852
+ throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
37853
+ }
37854
+ if (typeof stdio === "string") {
37855
+ return stdio;
37856
+ }
37857
+ if (!Array.isArray(stdio)) {
37858
+ throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
37859
+ }
37860
+ const length = Math.max(stdio.length, aliases.length);
37861
+ return Array.from({ length }, (value, index) => stdio[index]);
37862
+ };
37863
+
37864
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/kill.js
37865
+ var import_node_os3 = __toESM(require("node:os"), 1);
37866
+
37867
+ // node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
37868
+ var signals = [];
37869
+ signals.push("SIGHUP", "SIGINT", "SIGTERM");
37870
+ if (process.platform !== "win32") {
37871
+ signals.push(
37872
+ "SIGALRM",
37873
+ "SIGABRT",
37874
+ "SIGVTALRM",
37875
+ "SIGXCPU",
37876
+ "SIGXFSZ",
37877
+ "SIGUSR2",
37878
+ "SIGTRAP",
37879
+ "SIGSYS",
37880
+ "SIGQUIT",
37881
+ "SIGIOT"
37882
+ // should detect profiler and enable/disable accordingly.
37883
+ // see #21
37884
+ // 'SIGPROF'
37885
+ );
37886
+ }
37887
+ if (process.platform === "linux") {
37888
+ signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
37889
+ }
37890
+
37891
+ // node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
37892
+ var processOk = (process7) => !!process7 && typeof process7 === "object" && typeof process7.removeListener === "function" && typeof process7.emit === "function" && typeof process7.reallyExit === "function" && typeof process7.listeners === "function" && typeof process7.kill === "function" && typeof process7.pid === "number" && typeof process7.on === "function";
37893
+ var kExitEmitter = Symbol.for("signal-exit emitter");
37894
+ var global2 = globalThis;
37895
+ var ObjectDefineProperty = Object.defineProperty.bind(Object);
37896
+ var Emitter = class {
37897
+ emitted = {
37898
+ afterExit: false,
37899
+ exit: false
37900
+ };
37901
+ listeners = {
37902
+ afterExit: [],
37903
+ exit: []
37904
+ };
37905
+ count = 0;
37906
+ id = Math.random();
37907
+ constructor() {
37908
+ if (global2[kExitEmitter]) {
37909
+ return global2[kExitEmitter];
37910
+ }
37911
+ ObjectDefineProperty(global2, kExitEmitter, {
37912
+ value: this,
37913
+ writable: false,
37914
+ enumerable: false,
37915
+ configurable: false
37916
+ });
37917
+ }
37918
+ on(ev, fn) {
37919
+ this.listeners[ev].push(fn);
37920
+ }
37921
+ removeListener(ev, fn) {
37922
+ const list = this.listeners[ev];
37923
+ const i = list.indexOf(fn);
37924
+ if (i === -1) {
37925
+ return;
37926
+ }
37927
+ if (i === 0 && list.length === 1) {
37928
+ list.length = 0;
37929
+ } else {
37930
+ list.splice(i, 1);
37931
+ }
37932
+ }
37933
+ emit(ev, code, signal) {
37934
+ if (this.emitted[ev]) {
37935
+ return false;
37936
+ }
37937
+ this.emitted[ev] = true;
37938
+ let ret = false;
37939
+ for (const fn of this.listeners[ev]) {
37940
+ ret = fn(code, signal) === true || ret;
37941
+ }
37942
+ if (ev === "exit") {
37943
+ ret = this.emit("afterExit", code, signal) || ret;
37944
+ }
37945
+ return ret;
37946
+ }
37947
+ };
37948
+ var SignalExitBase = class {
37949
+ };
37950
+ var signalExitWrap = (handler) => {
37951
+ return {
37952
+ onExit(cb, opts) {
37953
+ return handler.onExit(cb, opts);
37954
+ },
37955
+ load() {
37956
+ return handler.load();
37957
+ },
37958
+ unload() {
37959
+ return handler.unload();
37960
+ }
37961
+ };
37962
+ };
37963
+ var SignalExitFallback = class extends SignalExitBase {
37964
+ onExit() {
37965
+ return () => {
37966
+ };
37967
+ }
37968
+ load() {
37969
+ }
37970
+ unload() {
37971
+ }
37972
+ };
37973
+ var SignalExit = class extends SignalExitBase {
37974
+ // "SIGHUP" throws an `ENOSYS` error on Windows,
37975
+ // so use a supported signal instead
37976
+ /* c8 ignore start */
37977
+ #hupSig = process4.platform === "win32" ? "SIGINT" : "SIGHUP";
37978
+ /* c8 ignore stop */
37979
+ #emitter = new Emitter();
37980
+ #process;
37981
+ #originalProcessEmit;
37982
+ #originalProcessReallyExit;
37983
+ #sigListeners = {};
37984
+ #loaded = false;
37985
+ constructor(process7) {
37986
+ super();
37987
+ this.#process = process7;
37988
+ this.#sigListeners = {};
37989
+ for (const sig of signals) {
37990
+ this.#sigListeners[sig] = () => {
37991
+ const listeners = this.#process.listeners(sig);
37992
+ let { count } = this.#emitter;
37993
+ const p = process7;
37994
+ if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
37995
+ count += p.__signal_exit_emitter__.count;
37996
+ }
37997
+ if (listeners.length === count) {
37998
+ this.unload();
37999
+ const ret = this.#emitter.emit("exit", null, sig);
38000
+ const s = sig === "SIGHUP" ? this.#hupSig : sig;
38001
+ if (!ret)
38002
+ process7.kill(process7.pid, s);
38003
+ }
38004
+ };
38005
+ }
38006
+ this.#originalProcessReallyExit = process7.reallyExit;
38007
+ this.#originalProcessEmit = process7.emit;
38008
+ }
38009
+ onExit(cb, opts) {
38010
+ if (!processOk(this.#process)) {
38011
+ return () => {
38012
+ };
38013
+ }
38014
+ if (this.#loaded === false) {
38015
+ this.load();
38016
+ }
38017
+ const ev = opts?.alwaysLast ? "afterExit" : "exit";
38018
+ this.#emitter.on(ev, cb);
38019
+ return () => {
38020
+ this.#emitter.removeListener(ev, cb);
38021
+ if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
38022
+ this.unload();
38023
+ }
38024
+ };
38025
+ }
38026
+ load() {
38027
+ if (this.#loaded) {
38028
+ return;
38029
+ }
38030
+ this.#loaded = true;
38031
+ this.#emitter.count += 1;
38032
+ for (const sig of signals) {
38033
+ try {
38034
+ const fn = this.#sigListeners[sig];
38035
+ if (fn)
38036
+ this.#process.on(sig, fn);
38037
+ } catch (_) {
38038
+ }
38039
+ }
38040
+ this.#process.emit = (ev, ...a) => {
38041
+ return this.#processEmit(ev, ...a);
38042
+ };
38043
+ this.#process.reallyExit = (code) => {
38044
+ return this.#processReallyExit(code);
38045
+ };
38046
+ }
38047
+ unload() {
38048
+ if (!this.#loaded) {
38049
+ return;
38050
+ }
38051
+ this.#loaded = false;
38052
+ signals.forEach((sig) => {
38053
+ const listener = this.#sigListeners[sig];
38054
+ if (!listener) {
38055
+ throw new Error("Listener not defined for signal: " + sig);
38056
+ }
38057
+ try {
38058
+ this.#process.removeListener(sig, listener);
38059
+ } catch (_) {
38060
+ }
38061
+ });
38062
+ this.#process.emit = this.#originalProcessEmit;
38063
+ this.#process.reallyExit = this.#originalProcessReallyExit;
38064
+ this.#emitter.count -= 1;
38065
+ }
38066
+ #processReallyExit(code) {
38067
+ if (!processOk(this.#process)) {
38068
+ return 0;
38069
+ }
38070
+ this.#process.exitCode = code || 0;
38071
+ this.#emitter.emit("exit", this.#process.exitCode, null);
38072
+ return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
38073
+ }
38074
+ #processEmit(ev, ...args) {
38075
+ const og = this.#originalProcessEmit;
38076
+ if (ev === "exit" && processOk(this.#process)) {
38077
+ if (typeof args[0] === "number") {
38078
+ this.#process.exitCode = args[0];
38079
+ }
38080
+ const ret = og.call(this.#process, ev, ...args);
38081
+ this.#emitter.emit("exit", this.#process.exitCode, null);
38082
+ return ret;
38083
+ } else {
38084
+ return og.call(this.#process, ev, ...args);
38085
+ }
38086
+ }
38087
+ };
38088
+ var process4 = globalThis.process;
38089
+ var {
38090
+ /**
38091
+ * Called when the process is exiting, whether via signal, explicit
38092
+ * exit, or running out of stuff to do.
38093
+ *
38094
+ * If the global process object is not suitable for instrumentation,
38095
+ * then this will be a no-op.
38096
+ *
38097
+ * Returns a function that may be used to unload signal-exit.
38098
+ */
38099
+ onExit,
38100
+ /**
38101
+ * Load the listeners. Likely you never need to call this, unless
38102
+ * doing a rather deep integration with signal-exit functionality.
38103
+ * Mostly exposed for the benefit of testing.
38104
+ *
38105
+ * @internal
38106
+ */
38107
+ load,
38108
+ /**
38109
+ * Unload the listeners. Likely you never need to call this, unless
38110
+ * doing a rather deep integration with signal-exit functionality.
38111
+ * Mostly exposed for the benefit of testing.
38112
+ *
38113
+ * @internal
38114
+ */
38115
+ unload
38116
+ } = signalExitWrap(processOk(process4) ? new SignalExit(process4) : new SignalExitFallback());
38117
+
38118
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/kill.js
38119
+ var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
38120
+ var spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
38121
+ const killResult = kill(signal);
38122
+ setKillTimeout(kill, signal, options, killResult);
38123
+ return killResult;
38124
+ };
38125
+ var setKillTimeout = (kill, signal, options, killResult) => {
38126
+ if (!shouldForceKill(signal, options, killResult)) {
38127
+ return;
38128
+ }
38129
+ const timeout = getForceKillAfterTimeout(options);
38130
+ const t = setTimeout(() => {
38131
+ kill("SIGKILL");
38132
+ }, timeout);
38133
+ if (t.unref) {
38134
+ t.unref();
38135
+ }
38136
+ };
38137
+ var shouldForceKill = (signal, { forceKillAfterTimeout }, killResult) => isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
38138
+ var isSigterm = (signal) => signal === import_node_os3.default.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
38139
+ var getForceKillAfterTimeout = ({ forceKillAfterTimeout = true }) => {
38140
+ if (forceKillAfterTimeout === true) {
38141
+ return DEFAULT_FORCE_KILL_TIMEOUT;
38142
+ }
38143
+ if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
38144
+ throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
38145
+ }
38146
+ return forceKillAfterTimeout;
38147
+ };
38148
+ var spawnedCancel = (spawned, context) => {
38149
+ const killResult = spawned.kill();
38150
+ if (killResult) {
38151
+ context.isCanceled = true;
38152
+ }
38153
+ };
38154
+ var timeoutKill = (spawned, signal, reject) => {
38155
+ spawned.kill(signal);
38156
+ reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
38157
+ };
38158
+ var setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
38159
+ if (timeout === 0 || timeout === void 0) {
38160
+ return spawnedPromise;
38161
+ }
38162
+ let timeoutId;
38163
+ const timeoutPromise = new Promise((resolve, reject) => {
38164
+ timeoutId = setTimeout(() => {
38165
+ timeoutKill(spawned, killSignal, reject);
38166
+ }, timeout);
38167
+ });
38168
+ const safeSpawnedPromise = spawnedPromise.finally(() => {
38169
+ clearTimeout(timeoutId);
38170
+ });
38171
+ return Promise.race([timeoutPromise, safeSpawnedPromise]);
38172
+ };
38173
+ var validateTimeout = ({ timeout }) => {
38174
+ if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
38175
+ throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
38176
+ }
38177
+ };
38178
+ var setExitHandler = async (spawned, { cleanup, detached }, timedPromise) => {
38179
+ if (!cleanup || detached) {
38180
+ return timedPromise;
38181
+ }
38182
+ const removeExitHandler = onExit(() => {
38183
+ spawned.kill();
38184
+ });
38185
+ return timedPromise.finally(() => {
38186
+ removeExitHandler();
38187
+ });
38188
+ };
38189
+
38190
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/pipe.js
38191
+ var import_node_fs3 = require("node:fs");
38192
+ var import_node_child_process = require("node:child_process");
38193
+
38194
+ // node_modules/.pnpm/is-stream@3.0.0/node_modules/is-stream/index.js
38195
+ function isStream(stream) {
38196
+ return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
38197
+ }
38198
+ function isWritableStream(stream) {
38199
+ return isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
38200
+ }
38201
+
38202
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/pipe.js
38203
+ var isExecaChildProcess = (target) => target instanceof import_node_child_process.ChildProcess && typeof target.then === "function";
38204
+ var pipeToTarget = (spawned, streamName, target) => {
38205
+ if (typeof target === "string") {
38206
+ spawned[streamName].pipe((0, import_node_fs3.createWriteStream)(target));
38207
+ return spawned;
38208
+ }
38209
+ if (isWritableStream(target)) {
38210
+ spawned[streamName].pipe(target);
38211
+ return spawned;
38212
+ }
38213
+ if (!isExecaChildProcess(target)) {
38214
+ throw new TypeError("The second argument must be a string, a stream or an Execa child process.");
38215
+ }
38216
+ if (!isWritableStream(target.stdin)) {
38217
+ throw new TypeError("The target child process's stdin must be available.");
38218
+ }
38219
+ spawned[streamName].pipe(target.stdin);
38220
+ return target;
38221
+ };
38222
+ var addPipeMethods = (spawned) => {
38223
+ if (spawned.stdout !== null) {
38224
+ spawned.pipeStdout = pipeToTarget.bind(void 0, spawned, "stdout");
38225
+ }
38226
+ if (spawned.stderr !== null) {
38227
+ spawned.pipeStderr = pipeToTarget.bind(void 0, spawned, "stderr");
38228
+ }
38229
+ if (spawned.all !== void 0) {
38230
+ spawned.pipeAll = pipeToTarget.bind(void 0, spawned, "all");
38231
+ }
38232
+ };
38233
+
38234
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/stream.js
38235
+ var import_node_fs4 = require("node:fs");
38236
+ var import_promises = require("node:timers/promises");
38237
+
38238
+ // node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/contents.js
38239
+ var getStreamContents = async (stream, { init, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
38240
+ if (!isAsyncIterable(stream)) {
38241
+ throw new Error("The first argument must be a Readable, a ReadableStream, or an async iterable.");
38242
+ }
38243
+ const state = init();
38244
+ state.length = 0;
38245
+ try {
38246
+ for await (const chunk of stream) {
38247
+ const chunkType = getChunkType(chunk);
38248
+ const convertedChunk = convertChunk[chunkType](chunk, state);
38249
+ appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
38250
+ }
38251
+ appendFinalChunk({ state, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer });
38252
+ return finalize(state);
38253
+ } catch (error) {
38254
+ error.bufferedData = finalize(state);
38255
+ throw error;
38256
+ }
38257
+ };
38258
+ var appendFinalChunk = ({ state, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }) => {
38259
+ const convertedChunk = getFinalChunk(state);
38260
+ if (convertedChunk !== void 0) {
38261
+ appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
38262
+ }
38263
+ };
38264
+ var appendChunk = ({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer }) => {
38265
+ const chunkSize = getSize(convertedChunk);
38266
+ const newLength = state.length + chunkSize;
38267
+ if (newLength <= maxBuffer) {
38268
+ addNewChunk(convertedChunk, state, addChunk, newLength);
38269
+ return;
38270
+ }
38271
+ const truncatedChunk = truncateChunk(convertedChunk, maxBuffer - state.length);
38272
+ if (truncatedChunk !== void 0) {
38273
+ addNewChunk(truncatedChunk, state, addChunk, maxBuffer);
38274
+ }
38275
+ throw new MaxBufferError();
38276
+ };
38277
+ var addNewChunk = (convertedChunk, state, addChunk, newLength) => {
38278
+ state.contents = addChunk(convertedChunk, state, newLength);
38279
+ state.length = newLength;
38280
+ };
38281
+ var isAsyncIterable = (stream) => typeof stream === "object" && stream !== null && typeof stream[Symbol.asyncIterator] === "function";
38282
+ var getChunkType = (chunk) => {
38283
+ const typeOfChunk = typeof chunk;
38284
+ if (typeOfChunk === "string") {
38285
+ return "string";
38286
+ }
38287
+ if (typeOfChunk !== "object" || chunk === null) {
38288
+ return "others";
38289
+ }
38290
+ if (globalThis.Buffer?.isBuffer(chunk)) {
38291
+ return "buffer";
38292
+ }
38293
+ const prototypeName = objectToString.call(chunk);
38294
+ if (prototypeName === "[object ArrayBuffer]") {
38295
+ return "arrayBuffer";
38296
+ }
38297
+ if (prototypeName === "[object DataView]") {
38298
+ return "dataView";
38299
+ }
38300
+ if (Number.isInteger(chunk.byteLength) && Number.isInteger(chunk.byteOffset) && objectToString.call(chunk.buffer) === "[object ArrayBuffer]") {
38301
+ return "typedArray";
38302
+ }
38303
+ return "others";
38304
+ };
38305
+ var { toString: objectToString } = Object.prototype;
38306
+ var MaxBufferError = class extends Error {
38307
+ name = "MaxBufferError";
38308
+ constructor() {
38309
+ super("maxBuffer exceeded");
38310
+ }
38311
+ };
38312
+
38313
+ // node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/utils.js
38314
+ var identity = (value) => value;
38315
+ var noop = () => void 0;
38316
+ var getContentsProp = ({ contents }) => contents;
38317
+ var throwObjectStream = (chunk) => {
38318
+ throw new Error(`Streams in object mode are not supported: ${String(chunk)}`);
38319
+ };
38320
+ var getLengthProp = (convertedChunk) => convertedChunk.length;
38321
+
38322
+ // node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/array-buffer.js
38323
+ async function getStreamAsArrayBuffer(stream, options) {
38324
+ return getStreamContents(stream, arrayBufferMethods, options);
38325
+ }
38326
+ var initArrayBuffer = () => ({ contents: new ArrayBuffer(0) });
38327
+ var useTextEncoder = (chunk) => textEncoder.encode(chunk);
38328
+ var textEncoder = new TextEncoder();
38329
+ var useUint8Array = (chunk) => new Uint8Array(chunk);
38330
+ var useUint8ArrayWithOffset = (chunk) => new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
38331
+ var truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
38332
+ var addArrayBufferChunk = (convertedChunk, { contents, length: previousLength }, length) => {
38333
+ const newContents = hasArrayBufferResize() ? resizeArrayBuffer(contents, length) : resizeArrayBufferSlow(contents, length);
38334
+ new Uint8Array(newContents).set(convertedChunk, previousLength);
38335
+ return newContents;
38336
+ };
38337
+ var resizeArrayBufferSlow = (contents, length) => {
38338
+ if (length <= contents.byteLength) {
38339
+ return contents;
38340
+ }
38341
+ const arrayBuffer = new ArrayBuffer(getNewContentsLength(length));
38342
+ new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
38343
+ return arrayBuffer;
38344
+ };
38345
+ var resizeArrayBuffer = (contents, length) => {
38346
+ if (length <= contents.maxByteLength) {
38347
+ contents.resize(length);
38348
+ return contents;
38349
+ }
38350
+ const arrayBuffer = new ArrayBuffer(length, { maxByteLength: getNewContentsLength(length) });
38351
+ new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
38352
+ return arrayBuffer;
38353
+ };
38354
+ var getNewContentsLength = (length) => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR));
38355
+ var SCALE_FACTOR = 2;
38356
+ var finalizeArrayBuffer = ({ contents, length }) => hasArrayBufferResize() ? contents : contents.slice(0, length);
38357
+ var hasArrayBufferResize = () => "resize" in ArrayBuffer.prototype;
38358
+ var arrayBufferMethods = {
38359
+ init: initArrayBuffer,
38360
+ convertChunk: {
38361
+ string: useTextEncoder,
38362
+ buffer: useUint8Array,
38363
+ arrayBuffer: useUint8Array,
38364
+ dataView: useUint8ArrayWithOffset,
38365
+ typedArray: useUint8ArrayWithOffset,
38366
+ others: throwObjectStream
38367
+ },
38368
+ getSize: getLengthProp,
38369
+ truncateChunk: truncateArrayBufferChunk,
38370
+ addChunk: addArrayBufferChunk,
38371
+ getFinalChunk: noop,
38372
+ finalize: finalizeArrayBuffer
38373
+ };
38374
+
38375
+ // node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/buffer.js
38376
+ async function getStreamAsBuffer(stream, options) {
38377
+ if (!("Buffer" in globalThis)) {
38378
+ throw new Error("getStreamAsBuffer() is only supported in Node.js");
38379
+ }
38380
+ try {
38381
+ return arrayBufferToNodeBuffer(await getStreamAsArrayBuffer(stream, options));
38382
+ } catch (error) {
38383
+ if (error.bufferedData !== void 0) {
38384
+ error.bufferedData = arrayBufferToNodeBuffer(error.bufferedData);
38385
+ }
38386
+ throw error;
38387
+ }
38388
+ }
38389
+ var arrayBufferToNodeBuffer = (arrayBuffer) => globalThis.Buffer.from(arrayBuffer);
38390
+
38391
+ // node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/string.js
38392
+ async function getStreamAsString(stream, options) {
38393
+ return getStreamContents(stream, stringMethods, options);
38394
+ }
38395
+ var initString = () => ({ contents: "", textDecoder: new TextDecoder() });
38396
+ var useTextDecoder = (chunk, { textDecoder }) => textDecoder.decode(chunk, { stream: true });
38397
+ var addStringChunk = (convertedChunk, { contents }) => contents + convertedChunk;
38398
+ var truncateStringChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
38399
+ var getFinalStringChunk = ({ textDecoder }) => {
38400
+ const finalChunk = textDecoder.decode();
38401
+ return finalChunk === "" ? void 0 : finalChunk;
38402
+ };
38403
+ var stringMethods = {
38404
+ init: initString,
38405
+ convertChunk: {
38406
+ string: identity,
38407
+ buffer: useTextDecoder,
38408
+ arrayBuffer: useTextDecoder,
38409
+ dataView: useTextDecoder,
38410
+ typedArray: useTextDecoder,
38411
+ others: throwObjectStream
38412
+ },
38413
+ getSize: getLengthProp,
38414
+ truncateChunk: truncateStringChunk,
38415
+ addChunk: addStringChunk,
38416
+ getFinalChunk: getFinalStringChunk,
38417
+ finalize: getContentsProp
38418
+ };
38419
+
38420
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/stream.js
38421
+ var import_merge_stream = __toESM(require_merge_stream(), 1);
38422
+ var validateInputOptions = (input) => {
38423
+ if (input !== void 0) {
38424
+ throw new TypeError("The `input` and `inputFile` options cannot be both set.");
38425
+ }
38426
+ };
38427
+ var getInputSync = ({ input, inputFile }) => {
38428
+ if (typeof inputFile !== "string") {
38429
+ return input;
38430
+ }
38431
+ validateInputOptions(input);
38432
+ return (0, import_node_fs4.readFileSync)(inputFile);
38433
+ };
38434
+ var handleInputSync = (options) => {
38435
+ const input = getInputSync(options);
38436
+ if (isStream(input)) {
38437
+ throw new TypeError("The `input` option cannot be a stream in sync mode");
38438
+ }
38439
+ return input;
38440
+ };
38441
+ var getInput = ({ input, inputFile }) => {
38442
+ if (typeof inputFile !== "string") {
38443
+ return input;
38444
+ }
38445
+ validateInputOptions(input);
38446
+ return (0, import_node_fs4.createReadStream)(inputFile);
38447
+ };
38448
+ var handleInput = (spawned, options) => {
38449
+ const input = getInput(options);
38450
+ if (input === void 0) {
38451
+ return;
38452
+ }
38453
+ if (isStream(input)) {
38454
+ input.pipe(spawned.stdin);
38455
+ } else {
38456
+ spawned.stdin.end(input);
38457
+ }
38458
+ };
38459
+ var makeAllStream = (spawned, { all }) => {
38460
+ if (!all || !spawned.stdout && !spawned.stderr) {
38461
+ return;
38462
+ }
38463
+ const mixed = (0, import_merge_stream.default)();
38464
+ if (spawned.stdout) {
38465
+ mixed.add(spawned.stdout);
38466
+ }
38467
+ if (spawned.stderr) {
38468
+ mixed.add(spawned.stderr);
38469
+ }
38470
+ return mixed;
38471
+ };
38472
+ var getBufferedData = async (stream, streamPromise) => {
38473
+ if (!stream || streamPromise === void 0) {
38474
+ return;
38475
+ }
38476
+ await (0, import_promises.setTimeout)(0);
38477
+ stream.destroy();
38478
+ try {
38479
+ return await streamPromise;
38480
+ } catch (error) {
38481
+ return error.bufferedData;
38482
+ }
38483
+ };
38484
+ var getStreamPromise = (stream, { encoding, buffer, maxBuffer }) => {
38485
+ if (!stream || !buffer) {
38486
+ return;
38487
+ }
38488
+ if (encoding === "utf8" || encoding === "utf-8") {
38489
+ return getStreamAsString(stream, { maxBuffer });
38490
+ }
38491
+ if (encoding === null || encoding === "buffer") {
38492
+ return getStreamAsBuffer(stream, { maxBuffer });
38493
+ }
38494
+ return applyEncoding(stream, maxBuffer, encoding);
38495
+ };
38496
+ var applyEncoding = async (stream, maxBuffer, encoding) => {
38497
+ const buffer = await getStreamAsBuffer(stream, { maxBuffer });
38498
+ return buffer.toString(encoding);
38499
+ };
38500
+ var getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
38501
+ const stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer });
38502
+ const stderrPromise = getStreamPromise(stderr, { encoding, buffer, maxBuffer });
38503
+ const allPromise = getStreamPromise(all, { encoding, buffer, maxBuffer: maxBuffer * 2 });
38504
+ try {
38505
+ return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
38506
+ } catch (error) {
38507
+ return Promise.all([
38508
+ { error, signal: error.signal, timedOut: error.timedOut },
38509
+ getBufferedData(stdout, stdoutPromise),
38510
+ getBufferedData(stderr, stderrPromise),
38511
+ getBufferedData(all, allPromise)
38512
+ ]);
38513
+ }
38514
+ };
38515
+
38516
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/promise.js
38517
+ var nativePromisePrototype = (/* @__PURE__ */ (async () => {
38518
+ })()).constructor.prototype;
38519
+ var descriptors = ["then", "catch", "finally"].map((property) => [
38520
+ property,
38521
+ Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
38522
+ ]);
38523
+ var mergePromise = (spawned, promise) => {
38524
+ for (const [property, descriptor] of descriptors) {
38525
+ const value = typeof promise === "function" ? (...args) => Reflect.apply(descriptor.value, promise(), args) : descriptor.value.bind(promise);
38526
+ Reflect.defineProperty(spawned, property, { ...descriptor, value });
38527
+ }
38528
+ };
38529
+ var getSpawnedPromise = (spawned) => new Promise((resolve, reject) => {
38530
+ spawned.on("exit", (exitCode, signal) => {
38531
+ resolve({ exitCode, signal });
38532
+ });
38533
+ spawned.on("error", (error) => {
38534
+ reject(error);
38535
+ });
38536
+ if (spawned.stdin) {
38537
+ spawned.stdin.on("error", (error) => {
38538
+ reject(error);
38539
+ });
38540
+ }
38541
+ });
38542
+
38543
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/command.js
38544
+ var import_node_buffer = require("node:buffer");
38545
+ var import_node_child_process2 = require("node:child_process");
38546
+ var normalizeArgs = (file, args = []) => {
38547
+ if (!Array.isArray(args)) {
38548
+ return [file];
38549
+ }
38550
+ return [file, ...args];
38551
+ };
38552
+ var NO_ESCAPE_REGEXP = /^[\w.-]+$/;
38553
+ var escapeArg = (arg) => {
38554
+ if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
38555
+ return arg;
38556
+ }
38557
+ return `"${arg.replaceAll('"', '\\"')}"`;
38558
+ };
38559
+ var joinCommand = (file, args) => normalizeArgs(file, args).join(" ");
38560
+ var getEscapedCommand = (file, args) => normalizeArgs(file, args).map((arg) => escapeArg(arg)).join(" ");
38561
+ var SPACES_REGEXP = / +/g;
38562
+ var parseExpression = (expression) => {
38563
+ const typeOfExpression = typeof expression;
38564
+ if (typeOfExpression === "string") {
38565
+ return expression;
38566
+ }
38567
+ if (typeOfExpression === "number") {
38568
+ return String(expression);
38569
+ }
38570
+ if (typeOfExpression === "object" && expression !== null && !(expression instanceof import_node_child_process2.ChildProcess) && "stdout" in expression) {
38571
+ const typeOfStdout = typeof expression.stdout;
38572
+ if (typeOfStdout === "string") {
38573
+ return expression.stdout;
38574
+ }
38575
+ if (import_node_buffer.Buffer.isBuffer(expression.stdout)) {
38576
+ return expression.stdout.toString();
38577
+ }
38578
+ throw new TypeError(`Unexpected "${typeOfStdout}" stdout in template expression`);
38579
+ }
38580
+ throw new TypeError(`Unexpected "${typeOfExpression}" in template expression`);
38581
+ };
38582
+ var concatTokens = (tokens, nextTokens, isNew) => isNew || tokens.length === 0 || nextTokens.length === 0 ? [...tokens, ...nextTokens] : [
38583
+ ...tokens.slice(0, -1),
38584
+ `${tokens.at(-1)}${nextTokens[0]}`,
38585
+ ...nextTokens.slice(1)
38586
+ ];
38587
+ var parseTemplate = ({ templates, expressions, tokens, index, template }) => {
38588
+ const templateString = template ?? templates.raw[index];
38589
+ const templateTokens = templateString.split(SPACES_REGEXP).filter(Boolean);
38590
+ const newTokens = concatTokens(
38591
+ tokens,
38592
+ templateTokens,
38593
+ templateString.startsWith(" ")
38594
+ );
38595
+ if (index === expressions.length) {
38596
+ return newTokens;
38597
+ }
38598
+ const expression = expressions[index];
38599
+ const expressionTokens = Array.isArray(expression) ? expression.map((expression2) => parseExpression(expression2)) : [parseExpression(expression)];
38600
+ return concatTokens(
38601
+ newTokens,
38602
+ expressionTokens,
38603
+ templateString.endsWith(" ")
38604
+ );
38605
+ };
38606
+ var parseTemplates = (templates, expressions) => {
38607
+ let tokens = [];
38608
+ for (const [index, template] of templates.entries()) {
38609
+ tokens = parseTemplate({ templates, expressions, tokens, index, template });
38610
+ }
38611
+ return tokens;
38612
+ };
38613
+
38614
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/verbose.js
38615
+ var import_node_util = require("node:util");
38616
+ var import_node_process3 = __toESM(require("node:process"), 1);
38617
+ var verboseDefault = (0, import_node_util.debuglog)("execa").enabled;
38618
+ var padField = (field, padding) => String(field).padStart(padding, "0");
38619
+ var getTimestamp = () => {
38620
+ const date = /* @__PURE__ */ new Date();
38621
+ return `${padField(date.getHours(), 2)}:${padField(date.getMinutes(), 2)}:${padField(date.getSeconds(), 2)}.${padField(date.getMilliseconds(), 3)}`;
38622
+ };
38623
+ var logCommand = (escapedCommand, { verbose }) => {
38624
+ if (!verbose) {
38625
+ return;
38626
+ }
38627
+ import_node_process3.default.stderr.write(`[${getTimestamp()}] ${escapedCommand}
38628
+ `);
38629
+ };
38630
+
38631
+ // node_modules/.pnpm/execa@8.0.1/node_modules/execa/index.js
38632
+ var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
38633
+ var getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
38634
+ const env = extendEnv ? { ...import_node_process4.default.env, ...envOption } : envOption;
38635
+ if (preferLocal) {
38636
+ return npmRunPathEnv({ env, cwd: localDir, execPath });
38637
+ }
38638
+ return env;
38639
+ };
38640
+ var handleArguments = (file, args, options = {}) => {
38641
+ const parsed = import_cross_spawn.default._parse(file, args, options);
38642
+ file = parsed.command;
38643
+ args = parsed.args;
38644
+ options = parsed.options;
38645
+ options = {
38646
+ maxBuffer: DEFAULT_MAX_BUFFER,
38647
+ buffer: true,
38648
+ stripFinalNewline: true,
38649
+ extendEnv: true,
38650
+ preferLocal: false,
38651
+ localDir: options.cwd || import_node_process4.default.cwd(),
38652
+ execPath: import_node_process4.default.execPath,
38653
+ encoding: "utf8",
38654
+ reject: true,
38655
+ cleanup: true,
38656
+ all: false,
38657
+ windowsHide: true,
38658
+ verbose: verboseDefault,
38659
+ ...options
38660
+ };
38661
+ options.env = getEnv(options);
38662
+ options.stdio = normalizeStdio(options);
38663
+ if (import_node_process4.default.platform === "win32" && import_node_path4.default.basename(file, ".exe") === "cmd") {
38664
+ args.unshift("/q");
38665
+ }
38666
+ return { file, args, options, parsed };
38667
+ };
38668
+ var handleOutput = (options, value, error) => {
38669
+ if (typeof value !== "string" && !import_node_buffer2.Buffer.isBuffer(value)) {
38670
+ return error === void 0 ? void 0 : "";
38671
+ }
38672
+ if (options.stripFinalNewline) {
38673
+ return stripFinalNewline(value);
38674
+ }
38675
+ return value;
38676
+ };
38677
+ function execa(file, args, options) {
38678
+ const parsed = handleArguments(file, args, options);
38679
+ const command = joinCommand(file, args);
38680
+ const escapedCommand = getEscapedCommand(file, args);
38681
+ logCommand(escapedCommand, parsed.options);
38682
+ validateTimeout(parsed.options);
38683
+ let spawned;
38684
+ try {
38685
+ spawned = import_node_child_process3.default.spawn(parsed.file, parsed.args, parsed.options);
38686
+ } catch (error) {
38687
+ const dummySpawned = new import_node_child_process3.default.ChildProcess();
38688
+ const errorPromise = Promise.reject(makeError({
38689
+ error,
38690
+ stdout: "",
38691
+ stderr: "",
38692
+ all: "",
38693
+ command,
38694
+ escapedCommand,
38695
+ parsed,
38696
+ timedOut: false,
38697
+ isCanceled: false,
38698
+ killed: false
38699
+ }));
38700
+ mergePromise(dummySpawned, errorPromise);
38701
+ return dummySpawned;
38702
+ }
38703
+ const spawnedPromise = getSpawnedPromise(spawned);
38704
+ const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
38705
+ const processDone = setExitHandler(spawned, parsed.options, timedPromise);
38706
+ const context = { isCanceled: false };
38707
+ spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
38708
+ spawned.cancel = spawnedCancel.bind(null, spawned, context);
38709
+ const handlePromise = async () => {
38710
+ const [{ error, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
38711
+ const stdout = handleOutput(parsed.options, stdoutResult);
38712
+ const stderr = handleOutput(parsed.options, stderrResult);
38713
+ const all = handleOutput(parsed.options, allResult);
38714
+ if (error || exitCode !== 0 || signal !== null) {
38715
+ const returnedError = makeError({
38716
+ error,
38717
+ exitCode,
38718
+ signal,
38719
+ stdout,
38720
+ stderr,
38721
+ all,
38722
+ command,
38723
+ escapedCommand,
38724
+ parsed,
38725
+ timedOut,
38726
+ isCanceled: context.isCanceled || (parsed.options.signal ? parsed.options.signal.aborted : false),
38727
+ killed: spawned.killed
38728
+ });
38729
+ if (!parsed.options.reject) {
38730
+ return returnedError;
38731
+ }
38732
+ throw returnedError;
38733
+ }
38734
+ return {
38735
+ command,
38736
+ escapedCommand,
38737
+ exitCode: 0,
38738
+ stdout,
38739
+ stderr,
38740
+ all,
38741
+ failed: false,
38742
+ timedOut: false,
38743
+ isCanceled: false,
38744
+ killed: false
38745
+ };
38746
+ };
38747
+ const handlePromiseOnce = onetime_default(handlePromise);
38748
+ handleInput(spawned, parsed.options);
38749
+ spawned.all = makeAllStream(spawned, parsed.options);
38750
+ addPipeMethods(spawned);
38751
+ mergePromise(spawned, handlePromiseOnce);
38752
+ return spawned;
38753
+ }
38754
+ function execaSync(file, args, options) {
38755
+ const parsed = handleArguments(file, args, options);
38756
+ const command = joinCommand(file, args);
38757
+ const escapedCommand = getEscapedCommand(file, args);
38758
+ logCommand(escapedCommand, parsed.options);
38759
+ const input = handleInputSync(parsed.options);
38760
+ let result;
38761
+ try {
38762
+ result = import_node_child_process3.default.spawnSync(parsed.file, parsed.args, { ...parsed.options, input });
38763
+ } catch (error) {
38764
+ throw makeError({
38765
+ error,
38766
+ stdout: "",
38767
+ stderr: "",
38768
+ all: "",
38769
+ command,
38770
+ escapedCommand,
38771
+ parsed,
38772
+ timedOut: false,
38773
+ isCanceled: false,
38774
+ killed: false
38775
+ });
38776
+ }
38777
+ const stdout = handleOutput(parsed.options, result.stdout, result.error);
38778
+ const stderr = handleOutput(parsed.options, result.stderr, result.error);
38779
+ if (result.error || result.status !== 0 || result.signal !== null) {
38780
+ const error = makeError({
38781
+ stdout,
38782
+ stderr,
38783
+ error: result.error,
38784
+ signal: result.signal,
38785
+ exitCode: result.status,
38786
+ command,
38787
+ escapedCommand,
38788
+ parsed,
38789
+ timedOut: result.error && result.error.code === "ETIMEDOUT",
38790
+ isCanceled: false,
38791
+ killed: result.signal !== null
38792
+ });
38793
+ if (!parsed.options.reject) {
38794
+ return error;
38795
+ }
38796
+ throw error;
38797
+ }
38798
+ return {
38799
+ command,
38800
+ escapedCommand,
38801
+ exitCode: 0,
38802
+ stdout,
38803
+ stderr,
38804
+ failed: false,
38805
+ timedOut: false,
38806
+ isCanceled: false,
38807
+ killed: false
38808
+ };
38809
+ }
38810
+ var normalizeScriptStdin = ({ input, inputFile, stdio }) => input === void 0 && inputFile === void 0 && stdio === void 0 ? { stdin: "inherit" } : {};
38811
+ var normalizeScriptOptions = (options = {}) => ({
38812
+ preferLocal: true,
38813
+ ...normalizeScriptStdin(options),
38814
+ ...options
38815
+ });
38816
+ function create$(options) {
38817
+ function $2(templatesOrOptions, ...expressions) {
38818
+ if (!Array.isArray(templatesOrOptions)) {
38819
+ return create$({ ...options, ...templatesOrOptions });
38820
+ }
38821
+ const [file, ...args] = parseTemplates(templatesOrOptions, expressions);
38822
+ return execa(file, args, normalizeScriptOptions(options));
38823
+ }
38824
+ $2.sync = (templates, ...expressions) => {
38825
+ if (!Array.isArray(templates)) {
38826
+ throw new TypeError("Please use $(options).sync`command` instead of $.sync(options)`command`.");
38827
+ }
38828
+ const [file, ...args] = parseTemplates(templates, expressions);
38829
+ return execaSync(file, args, normalizeScriptOptions(options));
38830
+ };
38831
+ return $2;
38832
+ }
38833
+ var $ = create$();
38834
+
38835
+ // packages/config-tools/src/env/get-env.ts
38836
+ var getConfigEnv = () => {
38837
+ const prefix = "STORM_";
38838
+ let config = {
38839
+ name: process.env[`${prefix}NAME`],
38840
+ namespace: process.env[`${prefix}NAMESPACE`],
38841
+ owner: process.env[`${prefix}OWNER`],
38842
+ worker: process.env[`${prefix}WORKER`],
38843
+ organization: process.env[`${prefix}ORGANIZATION`],
38844
+ packageManager: process.env[`${prefix}PACKAGE_MANAGER`],
38845
+ license: process.env[`${prefix}LICENSE`],
38846
+ homepage: process.env[`${prefix}HOMEPAGE`],
38847
+ timezone: process.env[`${prefix}TIMEZONE`] ?? process.env.TZ,
38848
+ locale: process.env[`${prefix}LOCALE`] ?? process.env.LOCALE,
38849
+ configFile: process.env[`${prefix}CONFIG_FILE`],
38850
+ workspaceRoot: process.env[`${prefix}WORKSPACE_ROOT`],
38851
+ packageDirectory: process.env[`${prefix}PACKAGE_DIRECTORY`],
38852
+ buildDirectory: process.env[`${prefix}BUILD_DIRECTORY`],
38853
+ runtimeVersion: process.env[`${prefix}RUNTIME_VERSION`],
38854
+ runtimeDirectory: process.env[`${prefix}RUNTIME_DIRECTORY`],
38855
+ env: process.env[`${prefix}ENV`] ?? process.env.NODE_ENV ?? process.env.ENVIRONMENT,
38856
+ ci: process.env[`${prefix}CI`] !== void 0 ? Boolean(
38857
+ process.env[`${prefix}CI`] ?? process.env.CI ?? process.env.CONTINUOUS_INTEGRATION
38858
+ ) : void 0,
38859
+ colors: {
38860
+ primary: process.env[`${prefix}COLOR_PRIMARY`],
38861
+ background: process.env[`${prefix}COLOR_BACKGROUND`],
38862
+ success: process.env[`${prefix}COLOR_SUCCESS`],
38863
+ info: process.env[`${prefix}COLOR_INFO`],
38864
+ warning: process.env[`${prefix}COLOR_WARNING`],
38865
+ error: process.env[`${prefix}COLOR_ERROR`],
38866
+ fatal: process.env[`${prefix}COLOR_FATAL`]
38867
+ },
38868
+ repository: process.env[`${prefix}REPOSITORY`],
38869
+ branch: process.env[`${prefix}BRANCH`],
38870
+ preMajor: process.env[`${prefix}PRE_MAJOR`] !== void 0 ? Boolean(process.env[`${prefix}PRE_MAJOR`]) : void 0,
38871
+ logLevel: process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== void 0 ? Number.isSafeInteger(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) ? getLogLevelLabel(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) : process.env[`${prefix}LOG_LEVEL`] : void 0
38872
+ };
38873
+ const serializedConfig = process.env[`${prefix}CONFIG`];
38874
+ if (serializedConfig) {
38875
+ const parsed = JSON.parse(serializedConfig);
38876
+ config = {
38877
+ ...config,
38878
+ ...parsed,
38879
+ colors: { ...config.colors, ...parsed.colors },
38880
+ extensions: { ...config.extensions, ...parsed.extensions }
38881
+ };
38882
+ }
38883
+ return config;
38884
+ };
38885
+
36725
38886
  // packages/config-tools/src/env/set-env.ts
36726
38887
  var setExtensionEnv = (extensionName, extension) => {
36727
38888
  for (const key of Object.keys(extension ?? {})) {
@@ -36856,57 +39017,6 @@ var setConfigEnv = (config) => {
36856
39017
  }
36857
39018
  };
36858
39019
 
36859
- // packages/config-tools/src/env/get-env.ts
36860
- var getConfigEnv = () => {
36861
- const prefix = "STORM_";
36862
- let config = {
36863
- name: process.env[`${prefix}NAME`],
36864
- namespace: process.env[`${prefix}NAMESPACE`],
36865
- owner: process.env[`${prefix}OWNER`],
36866
- worker: process.env[`${prefix}WORKER`],
36867
- organization: process.env[`${prefix}ORGANIZATION`],
36868
- packageManager: process.env[`${prefix}PACKAGE_MANAGER`],
36869
- license: process.env[`${prefix}LICENSE`],
36870
- homepage: process.env[`${prefix}HOMEPAGE`],
36871
- timezone: process.env[`${prefix}TIMEZONE`] ?? process.env.TZ,
36872
- locale: process.env[`${prefix}LOCALE`] ?? process.env.LOCALE,
36873
- configFile: process.env[`${prefix}CONFIG_FILE`],
36874
- workspaceRoot: process.env[`${prefix}WORKSPACE_ROOT`],
36875
- packageDirectory: process.env[`${prefix}PACKAGE_DIRECTORY`],
36876
- buildDirectory: process.env[`${prefix}BUILD_DIRECTORY`],
36877
- runtimeVersion: process.env[`${prefix}RUNTIME_VERSION`],
36878
- runtimeDirectory: process.env[`${prefix}RUNTIME_DIRECTORY`],
36879
- env: process.env[`${prefix}ENV`] ?? process.env.NODE_ENV ?? process.env.ENVIRONMENT,
36880
- ci: process.env[`${prefix}CI`] !== void 0 ? Boolean(
36881
- process.env[`${prefix}CI`] ?? process.env.CI ?? process.env.CONTINUOUS_INTEGRATION
36882
- ) : void 0,
36883
- colors: {
36884
- primary: process.env[`${prefix}COLOR_PRIMARY`],
36885
- background: process.env[`${prefix}COLOR_BACKGROUND`],
36886
- success: process.env[`${prefix}COLOR_SUCCESS`],
36887
- info: process.env[`${prefix}COLOR_INFO`],
36888
- warning: process.env[`${prefix}COLOR_WARNING`],
36889
- error: process.env[`${prefix}COLOR_ERROR`],
36890
- fatal: process.env[`${prefix}COLOR_FATAL`]
36891
- },
36892
- repository: process.env[`${prefix}REPOSITORY`],
36893
- branch: process.env[`${prefix}BRANCH`],
36894
- preMajor: process.env[`${prefix}PRE_MAJOR`] !== void 0 ? Boolean(process.env[`${prefix}PRE_MAJOR`]) : void 0,
36895
- logLevel: process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== void 0 ? Number.isSafeInteger(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) ? getLogLevelLabel(Number.parseInt(process.env[`${prefix}LOG_LEVEL`])) : process.env[`${prefix}LOG_LEVEL`] : void 0
36896
- };
36897
- const serializedConfig = process.env[`${prefix}CONFIG`];
36898
- if (serializedConfig) {
36899
- const parsed = JSON.parse(serializedConfig);
36900
- config = {
36901
- ...config,
36902
- ...parsed,
36903
- colors: { ...config.colors, ...parsed.colors },
36904
- extensions: { ...config.extensions, ...parsed.extensions }
36905
- };
36906
- }
36907
- return config;
36908
- };
36909
-
36910
39020
  // packages/config-tools/src/create-storm-config.ts
36911
39021
  var loadStormConfig = async (workspaceRoot) => {
36912
39022
  let config = {};
@@ -36963,14 +39073,11 @@ var applyWorkspaceExecutorTokens = (option, tokenizerOptions) => {
36963
39073
  if (tokenizerOptions.config) {
36964
39074
  const configKeys = Object.keys(tokenizerOptions.config);
36965
39075
  if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
36966
- configKeys.forEach((configKey) => {
39076
+ for (const configKey of configKeys) {
36967
39077
  if (result.includes(`{${configKey}}`)) {
36968
- result = result.replaceAll(
36969
- `{${configKey}}`,
36970
- tokenizerOptions.config[configKey]
36971
- );
39078
+ result = result.replaceAll(`{${configKey}}`, tokenizerOptions.config[configKey]);
36972
39079
  }
36973
- });
39080
+ }
36974
39081
  }
36975
39082
  }
36976
39083
  if (result.includes("{projectName}")) {
@@ -36991,29 +39098,22 @@ var applyWorkspaceExecutorTokens = (option, tokenizerOptions) => {
36991
39098
  return result;
36992
39099
  };
36993
39100
  var applyWorkspaceTokens = (options, config, tokenizerFn) => {
36994
- let result = options;
39101
+ const result = options;
36995
39102
  if (!result) {
36996
39103
  return {};
36997
39104
  }
36998
- return Object.keys(options).reduce(
36999
- (ret, option) => {
37000
- if (typeof options[option] === "string") {
37001
- ret[option] = tokenizerFn(options[option], config);
37002
- } else if (Array.isArray(options[option])) {
37003
- ret[option] = options[option].map(
37004
- (item) => typeof item === "string" ? tokenizerFn(item, config) : item
37005
- );
37006
- } else if (typeof options[option] === "object") {
37007
- ret[option] = applyWorkspaceTokens(
37008
- options[option],
37009
- config,
37010
- tokenizerFn
37011
- );
37012
- }
37013
- return ret;
37014
- },
37015
- {}
37016
- );
39105
+ return Object.keys(options).reduce((ret, option) => {
39106
+ if (typeof options[option] === "string") {
39107
+ ret[option] = tokenizerFn(options[option], config);
39108
+ } else if (Array.isArray(options[option])) {
39109
+ ret[option] = options[option].map(
39110
+ (item) => typeof item === "string" ? tokenizerFn(item, config) : item
39111
+ );
39112
+ } else if (typeof options[option] === "object") {
39113
+ ret[option] = applyWorkspaceTokens(options[option], config, tokenizerFn);
39114
+ }
39115
+ return ret;
39116
+ }, {});
37017
39117
  };
37018
39118
 
37019
39119
  // packages/workspace-tools/src/base/base-executor.ts