@shopify/create-app 3.94.2 → 4.0.0

package/dist/{chunk-LI75HRH4.js → chunk-DWGHKWV5.js}

@@ -13859,4 +13859,4 @@ export {
   debugApis,
   init_prettier
 };
-//# sourceMappingURL=chunk-LI75HRH4.js.map
+//# sourceMappingURL=chunk-DWGHKWV5.js.map

package/dist/chunk-IGDZPTDH.js

@@ -0,0 +1,371 @@
+import {
+  cacheRetrieve,
+  cacheRetrieveOrRepopulate
+} from "./chunk-YUPQUA3D.js";
+import {
+  AbortController,
+  exec
+} from "./chunk-YIHECXVH.js";
+import {
+  runWithTimer
+} from "./chunk-37G3KLO2.js";
+import {
+  AbortError,
+  BugError
+} from "./chunk-JUV7D377.js";
+import {
+  require_semver
+} from "./chunk-6OOTYTVB.js";
+import {
+  fileExists,
+  fileExistsSync,
+  findPathUp,
+  glob,
+  inferPackageManagerForGlobalCLI,
+  outputContent,
+  outputDebug,
+  outputToken,
+  readFile,
+  writeFile
+} from "./chunk-LNOZTAML.js";
+import {
+  dirname,
+  joinPath
+} from "./chunk-ACS6S42W.js";
+import {
+  __toESM,
+  init_cjs_shims
+} from "./chunk-PKR7KJ6P.js";
+
+// ../cli-kit/dist/public/node/node-package-manager.js
+init_cjs_shims();
+
+// ../cli-kit/dist/public/common/json.js
+init_cjs_shims();
+function parseJSON(jsonString, context) {
+  try {
+    return JSON.parse(jsonString);
+  } catch (error) {
+    let errorMessage = error instanceof Error ? error.message : String(error), contextMessage = context ? ` from ${context}` : "";
+    throw new AbortError(`Failed to parse JSON${contextMessage}.
+${errorMessage}`);
+  }
+}
+
+// ../cli-kit/dist/public/node/node-package-manager.js
+var import_semver = __toESM(require_semver(), 1), yarnLockfile = "yarn.lock", npmLockfile = "package-lock.json", pnpmLockfile = "pnpm-lock.yaml", bunLockfile = "bun.lockb", modernBunLockfile = "bun.lock", pnpmWorkspaceFile = "pnpm-workspace.yaml", lockfiles = [yarnLockfile, pnpmLockfile, npmLockfile, bunLockfile, modernBunLockfile], lockfilesByManager = {
+  yarn: [yarnLockfile],
+  npm: [npmLockfile],
+  pnpm: [pnpmLockfile],
+  bun: [bunLockfile, modernBunLockfile],
+  homebrew: [],
+  unknown: []
+}, packageManager = ["yarn", "npm", "pnpm", "bun", "homebrew", "unknown"], UnknownPackageManagerError = class extends AbortError {
+  constructor() {
+    super("Unknown package manager");
+  }
+}, PackageJsonNotFoundError = class extends AbortError {
+  constructor(directory) {
+    super(outputContent`The directory ${outputToken.path(directory)} doesn't have a package.json.`);
+  }
+}, FindUpAndReadPackageJsonNotFoundError = class extends BugError {
+  constructor(directory) {
+    super(outputContent`Couldn't find a a package.json traversing directories from ${outputToken.path(directory)}`);
+  }
+};
+function packageManagerFromUserAgent(env = process.env) {
+  return env.npm_config_user_agent?.includes("yarn") ? "yarn" : env.npm_config_user_agent?.includes("pnpm") ? "pnpm" : env.npm_config_user_agent?.includes("bun") ? "bun" : env.npm_config_user_agent?.includes("npm") ? "npm" : "unknown";
+}
+function hasBunLockfileSync(directory) {
+  return fileExistsSync(joinPath(directory, bunLockfile)) || fileExistsSync(joinPath(directory, modernBunLockfile));
+}
+function normalizePackageManagerForProject(packageManager2) {
+  switch (packageManager2) {
+    case "yarn":
+    case "npm":
+    case "pnpm":
+    case "bun":
+      return packageManager2;
+    case "homebrew":
+    case "unknown":
+      return "npm";
+  }
+}
+function packageManagerBinaryCommand(packageManager2, binary, ...binaryArgs) {
+  switch (packageManager2) {
+    case "npm":
+      return { command: "npm", args: ["exec", "--", binary, ...binaryArgs] };
+    case "pnpm":
+      return { command: "pnpm", args: ["exec", binary, ...binaryArgs] };
+    case "yarn":
+      return { command: "yarn", args: ["run", binary, ...binaryArgs] };
+    case "bun":
+      return { command: "bun", args: ["x", binary, ...binaryArgs] };
+  }
+}
+async function getPackageManager(fromDirectory) {
+  let current = fromDirectory;
+  for (outputDebug(outputContent`Looking for a lockfile in ${outputToken.path(current)}...`); ; ) {
+    if (fileExistsSync(joinPath(current, yarnLockfile)))
+      return "yarn";
+    if (fileExistsSync(joinPath(current, pnpmLockfile)) || fileExistsSync(joinPath(current, pnpmWorkspaceFile)))
+      return "pnpm";
+    if (hasBunLockfileSync(current))
+      return "bun";
+    if (fileExistsSync(joinPath(current, npmLockfile)))
+      return "npm";
+    let parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  let pm = packageManagerFromUserAgent();
+  return pm !== "unknown" ? pm : "npm";
+}
+async function packageManagerBinaryCommandForDirectory(fromDirectory, binary, ...binaryArgs) {
+  let packageManager2 = normalizePackageManagerForProject(await getPackageManager(fromDirectory));
+  return packageManagerBinaryCommand(packageManager2, binary, ...binaryArgs);
+}
+async function installNPMDependenciesRecursively(options) {
+  let packageJsons = await glob(joinPath(options.directory, "**/package.json"), {
+    ignore: [joinPath(options.directory, "node_modules/**/package.json")],
+    cwd: options.directory,
+    onlyFiles: !0,
+    deep: options.deep
+  }), abortController = new AbortController();
+  try {
+    await Promise.all(packageJsons.map(async (packageJsonPath) => {
+      let directory = dirname(packageJsonPath);
+      await installNodeModules({
+        directory,
+        packageManager: options.packageManager,
+        stdout: void 0,
+        stderr: void 0,
+        signal: abortController.signal,
+        args: []
+      });
+    }));
+  } catch (error) {
+    throw abortController.abort(), error;
+  }
+}
+async function installNodeModules(options) {
+  let execOptions = {
+    cwd: options.directory,
+    stdin: void 0,
+    stdout: options.stdout,
+    stderr: options.stderr,
+    signal: options.signal
+  }, args = ["install"];
+  options.args && (args = args.concat(options.args)), await runWithTimer("cmd_all_timing_network_ms")(async () => {
+    await exec(options.packageManager, args, execOptions);
+  });
+}
+async function getPackageName(packageJsonPath) {
+  return (await readAndParsePackageJson(packageJsonPath)).name;
+}
+async function getPackageVersion(packageJsonPath) {
+  return (await readAndParsePackageJson(packageJsonPath)).version;
+}
+async function getDependencies(packageJsonPath) {
+  let packageJsonContent = await readAndParsePackageJson(packageJsonPath), dependencies = packageJsonContent.dependencies ?? {}, devDependencies = packageJsonContent.devDependencies ?? {};
+  return { ...dependencies, ...devDependencies };
+}
+async function usesWorkspaces(appDirectory) {
+  let packageJsonPath = joinPath(appDirectory, "package.json"), packageJsonContent = await readAndParsePackageJson(packageJsonPath), pnpmWorkspacePath = joinPath(appDirectory, pnpmWorkspaceFile);
+  return !!packageJsonContent.workspaces || fileExists(pnpmWorkspacePath);
+}
+async function checkForNewVersion(dependency, currentVersion, { cacheExpiryInHours = 0 } = {}) {
+  let getLatestVersion = async () => (outputDebug(outputContent`Checking if there's a version of ${dependency} newer than ${currentVersion}`), getLatestNPMPackageVersion(dependency)), cacheKey = `npm-package-${dependency}`, lastVersion;
+  try {
+    lastVersion = await cacheRetrieveOrRepopulate(cacheKey, getLatestVersion, cacheExpiryInHours * 3600 * 1e3);
+  } catch {
+    return;
+  }
+  if (lastVersion && new import_semver.SemVer(currentVersion).compare(lastVersion) < 0)
+    return lastVersion;
+}
+function checkForCachedNewVersion(dependency, currentVersion) {
+  let cacheKey = `npm-package-${dependency}`, lastVersion = cacheRetrieve(cacheKey)?.value;
+  if (lastVersion && new import_semver.SemVer(currentVersion).compare(lastVersion) < 0)
+    return lastVersion;
+}
+function versionSatisfies(version, requirements) {
+  return (0, import_semver.satisfies)(version, requirements);
+}
+async function readAndParsePackageJson(packageJsonPath) {
+  if (!await fileExists(packageJsonPath))
+    throw new PackageJsonNotFoundError(dirname(packageJsonPath));
+  return parseJSON(await readFile(packageJsonPath), packageJsonPath);
+}
+async function addNPMDependenciesIfNeeded(dependencies, options) {
+  outputDebug(outputContent`Adding the following dependencies if needed:
+${outputToken.json(dependencies)}
+With options:
+${outputToken.json(options)}
+  `);
+  let packageJsonPath = joinPath(options.directory, "package.json");
+  if (!await fileExists(packageJsonPath))
+    throw new PackageJsonNotFoundError(options.directory);
+  let existingDependencies = Object.keys(await getDependencies(packageJsonPath)), dependenciesToAdd = dependencies.filter((dep) => !existingDependencies.includes(dep.name));
+  dependenciesToAdd.length !== 0 && await addNPMDependencies(dependenciesToAdd, options);
+}
+async function addNPMDependencies(dependencies, options) {
+  let dependenciesWithVersion = dependencies.map((dep) => dep.version ? `${dep.name}@${dep.version}` : dep.name);
+  switch (options.stdout?.write(`Installing ${dependenciesWithVersion.join(" ")} with ${options.packageManager}`), options.packageManager) {
+    case "npm":
+      for (let dep of dependenciesWithVersion)
+        await installDependencies(options, argumentsToAddDependenciesWithNPM(dep, options.type));
+      break;
+    case "yarn":
+      await installDependencies(options, argumentsToAddDependenciesWithYarn(dependenciesWithVersion, options.type, !!options.addToRootDirectory));
+      break;
+    case "pnpm":
+      await installDependencies(options, argumentsToAddDependenciesWithPNPM(dependenciesWithVersion, options.type, !!options.addToRootDirectory));
+      break;
+    case "bun":
+      await installDependencies(options, argumentsToAddDependenciesWithBun(dependenciesWithVersion, options.type)), await installDependencies(options, ["install"]);
+      break;
+    case "homebrew":
+      throw new AbortError("Homebrew can't be used to install project dependencies. Use npm, yarn, pnpm, or bun.");
+    case "unknown":
+      throw new UnknownPackageManagerError();
+  }
+}
+async function installDependencies(options, args) {
+  return runWithTimer("cmd_all_timing_network_ms")(async () => exec(options.packageManager, args, {
+    cwd: options.directory,
+    stdout: options.stdout,
+    stderr: options.stderr,
+    signal: options.signal
+  }));
+}
+async function addNPMDependenciesWithoutVersionIfNeeded(dependencies, options) {
+  await addNPMDependenciesIfNeeded(dependencies.map((dependency) => ({ name: dependency, version: void 0 })), options);
+}
+function argumentsToAddDependenciesWithNPM(dependency, type) {
+  let command = ["install"];
+  switch (command = command.concat(dependency), type) {
+    case "dev":
+      command.push("--save-dev");
+      break;
+    case "peer":
+      command.push("--save-peer");
+      break;
+    case "prod":
+      command.push("--save-prod");
+      break;
+  }
+  return dependency.match(/@\d/g) && command.push("--save-exact"), command;
+}
+function argumentsToAddDependenciesWithYarn(dependencies, type, addAtRoot = !1) {
+  let command = ["add"];
+  switch (addAtRoot && command.push("-W"), command = command.concat(dependencies), type) {
+    case "dev":
+      command.push("--dev");
+      break;
+    case "peer":
+      command.push("--peer");
+      break;
+    case "prod":
+      command.push("--prod");
+      break;
+  }
+  return command;
+}
+function argumentsToAddDependenciesWithPNPM(dependencies, type, addAtRoot = !1) {
+  let command = ["add"];
+  switch (addAtRoot && command.push("-w"), command = command.concat(dependencies), type) {
+    case "dev":
+      command.push("--save-dev");
+      break;
+    case "peer":
+      command.push("--save-peer");
+      break;
+    case "prod":
+      command.push("--save-prod");
+      break;
+  }
+  return command;
+}
+function argumentsToAddDependenciesWithBun(dependencies, type) {
+  let command = ["add"];
+  switch (command = command.concat(dependencies), type) {
+    case "dev":
+      command.push("--development");
+      break;
+    case "peer":
+      command.push("--optional");
+      break;
+    case "prod":
+      break;
+  }
+  return command;
+}
+async function findUpAndReadPackageJson(fromDirectory) {
+  let packageJsonPath = await findPathUp("package.json", { cwd: fromDirectory, type: "file" });
+  if (packageJsonPath) {
+    let packageJson = parseJSON(await readFile(packageJsonPath), packageJsonPath);
+    return { path: packageJsonPath, content: packageJson };
+  } else
+    throw new FindUpAndReadPackageJsonNotFoundError(fromDirectory);
+}
+async function addResolutionOrOverride(directory, dependencies) {
+  let packageManager2 = await getPackageManager(directory), packageJsonPath = joinPath(directory, "package.json"), packageJsonContent = await readAndParsePackageJson(packageJsonPath);
+  packageManager2 === "yarn" && (packageJsonContent.resolutions = packageJsonContent.resolutions ? { ...packageJsonContent.resolutions, ...dependencies } : dependencies), (packageManager2 === "npm" || packageManager2 === "pnpm" || packageManager2 === "bun") && (packageJsonContent.overrides = packageJsonContent.overrides ? { ...packageJsonContent.overrides, ...dependencies } : dependencies), await writeFile(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
+}
+async function getLatestNPMPackageVersion(name) {
+  return outputDebug(outputContent`Getting the latest version of NPM package: ${outputToken.raw(name)}`), runWithTimer("cmd_all_timing_network_ms")(async () => {
+    let { default: latestVersion } = await import("./latest-version-3PFKLJZM.js");
+    return latestVersion(name);
+  });
+}
+async function writePackageJSON(directory, packageJSON) {
+  outputDebug(outputContent`JSON-encoding and writing content to package.json at ${outputToken.path(directory)}...`);
+  let packagePath = joinPath(directory, "package.json");
+  await writeFile(packagePath, JSON.stringify(packageJSON, null, 2));
+}
+function inferPackageManager(optionsPackageManager, env = process.env) {
+  if (optionsPackageManager && packageManager.includes(optionsPackageManager))
+    return optionsPackageManager;
+  let usedPackageManager = packageManagerFromUserAgent(env);
+  if (usedPackageManager !== "unknown")
+    return usedPackageManager;
+  let globalPackageManager = inferPackageManagerForGlobalCLI();
+  return globalPackageManager !== "unknown" ? globalPackageManager : "npm";
+}
+
+export {
+  yarnLockfile,
+  npmLockfile,
+  pnpmLockfile,
+  bunLockfile,
+  pnpmWorkspaceFile,
+  lockfiles,
+  lockfilesByManager,
+  packageManager,
+  UnknownPackageManagerError,
+  PackageJsonNotFoundError,
+  FindUpAndReadPackageJsonNotFoundError,
+  packageManagerFromUserAgent,
+  getPackageManager,
+  packageManagerBinaryCommandForDirectory,
+  installNPMDependenciesRecursively,
+  installNodeModules,
+  getPackageName,
+  getPackageVersion,
+  getDependencies,
+  usesWorkspaces,
+  checkForNewVersion,
+  checkForCachedNewVersion,
+  versionSatisfies,
+  readAndParsePackageJson,
+  addNPMDependenciesIfNeeded,
+  addNPMDependencies,
+  addNPMDependenciesWithoutVersionIfNeeded,
+  findUpAndReadPackageJson,
+  addResolutionOrOverride,
+  writePackageJSON,
+  inferPackageManager
+};
+//# sourceMappingURL=chunk-IGDZPTDH.js.map

package/dist/chunk-JCETIRLI.js

@@ -0,0 +1,30 @@
+import {
+  init_cjs_shims
+} from "./chunk-PKR7KJ6P.js";
+
+// ../cli-kit/dist/private/node/context/deprecations-store.js
+init_cjs_shims();
+var deprecationsStore = {
+  nextDeprecationDate: void 0
+};
+function getNextDeprecationDate() {
+  return deprecationsStore.nextDeprecationDate;
+}
+function setNextDeprecationDate(dates) {
+  if (dates.length < 1)
+    return;
+  let earliestFutureDateTime = earliestDateTimeAfter(Date.now(), dates);
+  if (!earliestFutureDateTime)
+    return;
+  let nextDeprecationDate = getNextDeprecationDate();
+  (!nextDeprecationDate || earliestFutureDateTime < nextDeprecationDate.getTime()) && (deprecationsStore.nextDeprecationDate = new Date(earliestFutureDateTime));
+}
+function earliestDateTimeAfter(afterTime, dates) {
+  return dates.map((date) => date.getTime()).sort().find((time) => time > afterTime);
+}
+
+export {
+  getNextDeprecationDate,
+  setNextDeprecationDate
+};
+//# sourceMappingURL=chunk-JCETIRLI.js.map

package/dist/chunk-JUV7D377.js

@@ -0,0 +1,264 @@
+import {
+  require_lib
+} from "./chunk-UX6FRPFM.js";
+import {
+  TokenizedString,
+  stringifyMessage,
+  tokenItemToString
+} from "./chunk-LNOZTAML.js";
+import {
+  normalizePath
+} from "./chunk-ACS6S42W.js";
+import {
+  __commonJS,
+  __toESM,
+  init_cjs_shims
+} from "./chunk-PKR7KJ6P.js";
+
+// ../../node_modules/.pnpm/ts-error@1.0.6/node_modules/ts-error/lib/helpers.js
+var require_helpers = __commonJS({
+  "../../node_modules/.pnpm/ts-error@1.0.6/node_modules/ts-error/lib/helpers.js"(exports) {
+    "use strict";
+    init_cjs_shims();
+    exports.__esModule = void 0;
+    exports.__esModule = !0;
+    var objectSetPrototypeOfIsDefined = typeof Object.setPrototypeOf == "function", objectGetPrototypeOfIsDefined = typeof Object.getPrototypeOf == "function", objectDefinePropertyIsDefined = typeof Object.defineProperty == "function", objectCreateIsDefined = typeof Object.create == "function", objectHasOwnPropertyIsDefined = typeof Object.prototype.hasOwnProperty == "function", setPrototypeOf = function(target, prototype) {
+      objectSetPrototypeOfIsDefined ? Object.setPrototypeOf(target, prototype) : target.__proto__ = prototype;
+    };
+    exports.setPrototypeOf = setPrototypeOf;
+    var getPrototypeOf = function(target) {
+      return objectGetPrototypeOfIsDefined ? Object.getPrototypeOf(target) : target.__proto__ || target.prototype;
+    };
+    exports.getPrototypeOf = getPrototypeOf;
+    var ie8ObjectDefinePropertyBug = !1, defineProperty = function defineProperty2(target, name, propertyDescriptor) {
+      if (objectDefinePropertyIsDefined && !ie8ObjectDefinePropertyBug)
+        try {
+          Object.defineProperty(target, name, propertyDescriptor);
+        } catch {
+          ie8ObjectDefinePropertyBug = !0, defineProperty2(target, name, propertyDescriptor);
+        }
+      else
+        target[name] = propertyDescriptor.value;
+    };
+    exports.defineProperty = defineProperty;
+    var hasOwnProperty = function(target, name) {
+      return objectHasOwnPropertyIsDefined ? target.hasOwnProperty(target, name) : target[name] === void 0;
+    };
+    exports.hasOwnProperty = hasOwnProperty;
+    var objectCreate = function(prototype, propertyDescriptors) {
+      if (objectCreateIsDefined)
+        return Object.create(prototype, propertyDescriptors);
+      var F = function() {
+      };
+      F.prototype = prototype;
+      var result = new F();
+      if (typeof propertyDescriptors > "u")
+        return result;
+      if (typeof propertyDescriptors == "null")
+        throw new Error("PropertyDescriptors must not be null.");
+      if (typeof propertyDescriptors == "object")
+        for (var key in propertyDescriptors)
+          hasOwnProperty(propertyDescriptors, key) && (result[key] = propertyDescriptors[key].value);
+      return result;
+    };
+    exports.objectCreate = objectCreate;
+  }
+});
+
+// ../../node_modules/.pnpm/ts-error@1.0.6/node_modules/ts-error/lib/cjs.js
+var require_cjs = __commonJS({
+  "../../node_modules/.pnpm/ts-error@1.0.6/node_modules/ts-error/lib/cjs.js"(exports) {
+    "use strict";
+    init_cjs_shims();
+    exports.__esModule = void 0;
+    exports.__esModule = !0;
+    var helpers = require_helpers(), setPrototypeOf = helpers.setPrototypeOf, getPrototypeOf = helpers.getPrototypeOf, defineProperty = helpers.defineProperty, objectCreate = helpers.objectCreate, uglyErrorPrinting = new Error().toString() === "[object Error]", extendableErrorName = "";
+    function ExtendableError2(message) {
+      var originalConstructor = this.constructor, constructorName = originalConstructor.name || (function() {
+        var constructorNameMatch = originalConstructor.toString().match(/^function\s*([^\s(]+)/);
+        return constructorNameMatch === null ? extendableErrorName || "Error" : constructorNameMatch[1];
+      })(), constructorNameIsError = constructorName === "Error", name = constructorNameIsError ? extendableErrorName : constructorName, instance = Error.apply(this, arguments);
+      if (setPrototypeOf(instance, getPrototypeOf(this)), !(instance instanceof originalConstructor) || !(instance instanceof ExtendableError2)) {
+        var instance = this;
+        Error.apply(this, arguments), defineProperty(instance, "message", {
+          configurable: !0,
+          enumerable: !1,
+          value: message,
+          writable: !0
+        });
+      }
+      if (defineProperty(instance, "name", {
+        configurable: !0,
+        enumerable: !1,
+        value: name,
+        writable: !0
+      }), Error.captureStackTrace && Error.captureStackTrace(
+        instance,
+        constructorNameIsError ? ExtendableError2 : originalConstructor
+      ), instance.stack === void 0) {
+        var err = new Error(message);
+        err.name = instance.name, instance.stack = err.stack;
+      }
+      return uglyErrorPrinting && defineProperty(instance, "toString", {
+        configurable: !0,
+        enumerable: !1,
+        value: function() {
+          return (this.name || "Error") + (typeof this.message > "u" ? "" : ": " + this.message);
+        },
+        writable: !0
+      }), instance;
+    }
+    extendableErrorName = ExtendableError2.name || "ExtendableError";
+    ExtendableError2.prototype = objectCreate(Error.prototype, {
+      constructor: {
+        value: Error,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    });
+    exports.ExtendableError = ExtendableError2;
+    exports.default = exports.ExtendableError;
+  }
+});
+
+// ../cli-kit/dist/public/node/error.js
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1), import_ts_error = __toESM(require_cjs(), 1), FatalErrorType;
+(function(FatalErrorType2) {
+  FatalErrorType2[FatalErrorType2.Abort = 0] = "Abort", FatalErrorType2[FatalErrorType2.AbortSilent = 1] = "AbortSilent", FatalErrorType2[FatalErrorType2.Bug = 2] = "Bug";
+})(FatalErrorType || (FatalErrorType = {}));
+var CancelExecution = class extends Error {
+}, FatalError = class extends Error {
+  /**
+   * Creates a new FatalError error.
+   *
+   * @param message - The error message.
+   * @param type - The type of fatal error.
+   * @param tryMessage - The message that recommends next steps to the user.
+   * You can pass a string a {@link TokenizedString} or a {@link TokenItem}
+   * if you need to style the message inside the error Banner component.
+   * @param nextSteps - Message to show as "next steps" with suggestions to solve the issue.
+   * @param customSections - Custom sections to show in the error banner. To be used if nextSteps is not enough.
+   */
+  constructor(message, type, tryMessage = null, nextSteps, customSections) {
+    let messageIsOutputMessage = typeof message == "string" || "value" in message;
+    super(messageIsOutputMessage ? stringifyMessage(message) : tokenItemToString(message)), tryMessage ? tryMessage instanceof TokenizedString ? this.tryMessage = stringifyMessage(tryMessage) : this.tryMessage = tryMessage : this.tryMessage = null, this.type = type, this.nextSteps = nextSteps, this.customSections = customSections, this.skipOclifErrorHandling = !0, messageIsOutputMessage || (this.formattedMessage = message);
+  }
+}, AbortError = class extends FatalError {
+  constructor(message, tryMessage = null, nextSteps, customSections) {
+    super(message, FatalErrorType.Abort, tryMessage, nextSteps, customSections);
+  }
+}, ExternalError = class extends FatalError {
+  constructor(message, command, args, tryMessage = null) {
+    super(message, FatalErrorType.Abort, tryMessage), this.command = command, this.args = args;
+  }
+}, AbortSilentError = class extends FatalError {
+  constructor() {
+    super("", FatalErrorType.AbortSilent);
+  }
+}, BugError = class extends FatalError {
+  constructor(message, tryMessage = null) {
+    super(message, FatalErrorType.Bug, tryMessage);
+  }
+};
+async function handler(error) {
+  let fatal;
+  if (isFatal(error))
+    fatal = error;
+  else if (typeof error == "string")
+    fatal = new BugError(error);
+  else if (error instanceof Error)
+    fatal = new BugError(error.message), fatal.stack = error.stack;
+  else {
+    let maybeError = error;
+    fatal = new BugError(maybeError?.message ?? "Unknown error"), maybeError?.stack && (fatal.stack = maybeError?.stack);
+  }
+  let { renderFatalError } = await import("./ui-2FROV2IT.js");
+  return renderFatalError(fatal), Promise.resolve(error);
+}
+function errorMapper(error) {
+  if (error instanceof import_core.Errors.CLIError) {
+    let mappedError = new AbortError(error.message);
+    return mappedError.stack = error.stack, Promise.resolve(mappedError);
+  } else
+    return Promise.resolve(error);
+}
+function isFatal(error) {
+  try {
+    return Object.prototype.hasOwnProperty.call(error, "type");
+  } catch {
+    return !1;
+  }
+}
+function shouldReportErrorAsUnexpected(error) {
+  if (!isFatal(error)) {
+    if (error instanceof Error) {
+      let message = error.message;
+      return !errorMessageImpliesEnvironmentIssue(message);
+    }
+    return !0;
+  }
+  return error.type === FatalErrorType.Bug;
+}
+function cleanSingleStackTracePath(filePath) {
+  return normalizePath(filePath).replace("file:/", "/").replace(/^\/?[A-Z]:/, "");
+}
+function errorMessageImpliesEnvironmentIssue(message) {
+  return [
+    "EPERM: operation not permitted, scandir",
+    "EPERM: operation not permitted, rename",
+    "EACCES: permission denied",
+    "EPERM: operation not permitted, symlink",
+    "This version of npm supports the following node versions",
+    "EBUSY: resource busy or locked",
+    "ENOTEMPTY: directory not empty",
+    "getaddrinfo ENOTFOUND",
+    "Client network socket disconnected before secure TLS connection was established",
+    "spawn EPERM",
+    "socket hang up",
+    "The user aborted a request.",
+    "write EPIPE",
+    "Unsupported platform"
+  ].some((issueMessage) => message.includes(issueMessage));
+}
+
+// ../../node_modules/.pnpm/mimic-fn@4.0.0/node_modules/mimic-fn/index.js
+init_cjs_shims();
+var copyProperty = (to, from, property, ignoreNonConfigurable) => {
+  if (property === "length" || property === "prototype" || property === "arguments" || property === "caller")
+    return;
+  let toDescriptor = Object.getOwnPropertyDescriptor(to, property), fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
+  !canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable || Object.defineProperty(to, property, fromDescriptor);
+}, canCopyProperty = function(toDescriptor, fromDescriptor) {
+  return toDescriptor === void 0 || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
+}, changePrototype = (to, from) => {
+  let fromPrototype = Object.getPrototypeOf(from);
+  fromPrototype !== Object.getPrototypeOf(to) && Object.setPrototypeOf(to, fromPrototype);
+}, wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/
+${fromBody}`, toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString"), toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name"), changeToString = (to, from, name) => {
+  let withName = name === "" ? "" : `with ${name.trim()}() `, newToString = wrappedToString.bind(null, withName, from.toString());
+  Object.defineProperty(newToString, "name", toStringName), Object.defineProperty(to, "toString", { ...toStringDescriptor, value: newToString });
+};
+function mimicFunction(to, from, { ignoreNonConfigurable = !1 } = {}) {
+  let { name } = to;
+  for (let property of Reflect.ownKeys(from))
+    copyProperty(to, from, property, ignoreNonConfigurable);
+  return changePrototype(to, from), changeToString(to, from, name), to;
+}
+
+export {
+  mimicFunction,
+  CancelExecution,
+  FatalError,
+  AbortError,
+  ExternalError,
+  AbortSilentError,
+  BugError,
+  handler,
+  errorMapper,
+  shouldReportErrorAsUnexpected,
+  cleanSingleStackTracePath,
+  import_ts_error
+};
+//# sourceMappingURL=chunk-JUV7D377.js.map