@backstage/cli 0.36.0-next.1 → 0.36.0

package/dist/modules/build/lib/config.cjs.js

@@ -1,94 +0,0 @@
-'use strict';
-
-var configLoader = require('@backstage/config-loader');
-var config = require('@backstage/config');
-var cliCommon = require('@backstage/cli-common');
-var getPackages = require('@manypkg/get-packages');
-var cliNode = require('@backstage/cli-node');
-var path = require('node:path');
-
-async function loadCliConfig(options) {
-  const targetDir = options.targetDir ?? cliCommon.targetPaths.dir;
-  const { packages } = await getPackages.getPackages(targetDir);
-  let localPackageNames;
-  if (options.fromPackage) {
-    if (packages.length) {
-      const graph = cliNode.PackageGraph.fromPackages(packages);
-      localPackageNames = Array.from(
-        graph.collectPackageNames([options.fromPackage], (node) => {
-          if (node.name === "@backstage/cli") {
-            return void 0;
-          }
-          return node.localDependencies.keys();
-        })
-      );
-    } else {
-      localPackageNames = [options.fromPackage];
-    }
-  } else {
-    localPackageNames = packages.map((p) => p.packageJson.name);
-  }
-  const schema = await configLoader.loadConfigSchema({
-    dependencies: localPackageNames,
-    packagePaths: [cliCommon.targetPaths.resolveRoot("package.json")]
-  });
-  const source = configLoader.ConfigSources.default({
-    allowMissingDefaultConfig: true,
-    watch: Boolean(options.watch),
-    rootDir: cliCommon.targetPaths.rootDir,
-    argv: options.args.flatMap((t) => ["--config", path.resolve(targetDir, t)])
-  });
-  const appConfigs = await new Promise((resolve, reject) => {
-    async function loadConfigReaderLoop() {
-      let loaded = false;
-      try {
-        const abortController = new AbortController();
-        for await (const { configs } of source.readConfigData({
-          signal: abortController.signal
-        })) {
-          if (loaded) {
-            const newFrontendAppConfigs = schema.process(configs, {
-              visibility: ["frontend"],
-              withFilteredKeys: options.withFilteredKeys,
-              ignoreSchemaErrors: true
-            });
-            options.watch?.(newFrontendAppConfigs);
-          } else {
-            resolve(configs);
-            loaded = true;
-            if (!options.watch) {
-              abortController.abort();
-            }
-          }
-        }
-      } catch (error) {
-        if (loaded) {
-          console.error(`Failed to reload configuration, ${error}`);
-        } else {
-          reject(error);
-        }
-      }
-    }
-    loadConfigReaderLoop();
-  });
-  const configurationLoadedMessage = appConfigs.length ? `Loaded config from ${appConfigs.map((c) => c.context).join(", ")}` : `No configuration files found, running without config`;
-  process.stderr.write(`${configurationLoadedMessage}
-`);
-  const frontendAppConfigs = schema.process(appConfigs, {
-    visibility: ["frontend"],
-    withFilteredKeys: options.withFilteredKeys,
-    ignoreSchemaErrors: true
-  });
-  const frontendConfig = config.ConfigReader.fromConfigs(frontendAppConfigs);
-  const fullConfig = config.ConfigReader.fromConfigs(appConfigs);
-  return {
-    schema,
-    appConfigs,
-    frontendConfig,
-    frontendAppConfigs,
-    fullConfig
-  };
-}
-
-exports.loadCliConfig = loadCliConfig;
-//# sourceMappingURL=config.cjs.js.map

package/dist/modules/build/lib/entryPoints.cjs.js

@@ -1,49 +0,0 @@
-'use strict';
-
-var path = require('node:path');
-
-const defaultIndex = {
-  mount: ".",
-  path: "src/index.ts",
-  name: "index",
-  ext: ".ts"
-};
-const SCRIPT_EXTS = [".js", ".jsx", ".ts", ".tsx"];
-function parseEntryPoint(mount, path$1) {
-  const ext = path.extname(path$1);
-  let name = mount;
-  if (name === ".") {
-    name = "index";
-  } else if (name.startsWith("./")) {
-    name = name.slice(2);
-  }
-  if (name.includes("/") && SCRIPT_EXTS.includes(ext)) {
-    throw new Error(`Mount point '${mount}' may not contain multiple slashes`);
-  }
-  return { mount, path: path$1, name, ext };
-}
-function readEntryPoints(pkg) {
-  const exp = pkg.exports;
-  if (typeof exp === "string") {
-    return [defaultIndex];
-  } else if (exp && typeof exp === "object" && !Array.isArray(exp)) {
-    const entryPoints = new Array();
-    for (const mount of Object.keys(exp)) {
-      const path = exp[mount];
-      if (typeof path !== "string") {
-        throw new Error(
-          `Exports field value must be a string, got '${JSON.stringify(path)}'`
-        );
-      }
-      if (process.env.EXPERIMENTAL_TRIM_NEXT_ENTRY && mount === "./next") {
-        continue;
-      }
-      entryPoints.push(parseEntryPoint(mount, path));
-    }
-    return entryPoints;
-  }
-  return [defaultIndex];
-}
-
-exports.readEntryPoints = readEntryPoints;
-//# sourceMappingURL=entryPoints.cjs.js.map

package/dist/modules/build/lib/ipc/IpcServer.cjs.js

@@ -1,60 +0,0 @@
-'use strict';
-
-var errors = require('@backstage/errors');
-
-const requestType = "@backstage/cli/channel/request";
-const responseType = "@backstage/cli/channel/response";
-class IpcServer {
-  #generation = 1;
-  #methods = /* @__PURE__ */ new Map();
-  addChild(child) {
-    const generation = this.#generation++;
-    const sendMessage = child.send?.bind(child);
-    if (!sendMessage) {
-      return;
-    }
-    const messageListener = (request) => {
-      if (request.type !== requestType) {
-        return;
-      }
-      const handler = this.#methods.get(request.method);
-      if (!handler) {
-        sendMessage({
-          type: responseType,
-          id: request.id,
-          error: {
-            name: "NotFoundError",
-            message: `No handler registered for method ${request.method}`
-          }
-        });
-        return;
-      }
-      Promise.resolve().then(() => handler(request.body, { generation })).then(
-        (response) => sendMessage({
-          type: responseType,
-          id: request.id,
-          body: response
-        })
-      ).catch(
-        (error) => sendMessage({
-          type: responseType,
-          id: request.id,
-          error: errors.serializeError(error)
-        })
-      );
-    };
-    child.addListener("message", messageListener);
-    child.addListener("exit", () => {
-      child.removeListener("message", messageListener);
-    });
-  }
-  registerMethod(method, handler) {
-    if (this.#methods.has(method)) {
-      throw new Error(`A handler is already registered for method ${method}`);
-    }
-    this.#methods.set(method, handler);
-  }
-}
-
-exports.IpcServer = IpcServer;
-//# sourceMappingURL=IpcServer.cjs.js.map

package/dist/modules/build/lib/ipc/ServerDataStore.cjs.js

@@ -1,36 +0,0 @@
-'use strict';
-
-class ServerDataStore {
-  static bind(server) {
-    const store = /* @__PURE__ */ new Map();
-    server.registerMethod(
-      "DevDataStore.save",
-      async (request, { generation }) => {
-        const { key, data } = request;
-        if (!key) {
-          throw new Error("Key is required in DevDataStore.save");
-        }
-        const item = store.get(key);
-        if (!item) {
-          store.set(key, { generation, data });
-          return { saved: true };
-        }
-        if (item.generation > generation) {
-          return { saved: false };
-        }
-        store.set(key, { generation, data });
-        return { saved: true };
-      }
-    );
-    server.registerMethod(
-      "DevDataStore.load",
-      async (request) => {
-        const item = store.get(request.key);
-        return { loaded: Boolean(item), data: item?.data };
-      }
-    );
-  }
-}
-
-exports.ServerDataStore = ServerDataStore;
-//# sourceMappingURL=ServerDataStore.cjs.js.map

package/dist/modules/build/lib/optionsParser.cjs.js

@@ -1,37 +0,0 @@
-'use strict';
-
-function createScriptOptionsParser(anyCmd, commandPath) {
-  let rootCmd = anyCmd;
-  while (rootCmd.parent) {
-    rootCmd = rootCmd.parent;
-  }
-  let targetCmd = rootCmd;
-  for (const name of commandPath) {
-    targetCmd = targetCmd?.commands.find((c) => c.name() === name);
-  }
-  if (!targetCmd) {
-    throw new Error(
-      `Could not find package command '${commandPath.join(" ")}'`
-    );
-  }
-  const cmd = targetCmd;
-  const expectedScript = `backstage-cli ${commandPath.join(" ")}`;
-  return (scriptStr) => {
-    if (!scriptStr || !scriptStr.startsWith(expectedScript)) {
-      return void 0;
-    }
-    const argsStr = scriptStr.slice(expectedScript.length).trim();
-    const currentOpts = cmd._optionValues;
-    const currentStore = cmd._storeOptionsAsProperties;
-    const result = {};
-    cmd._storeOptionsAsProperties = false;
-    cmd._optionValues = result;
-    cmd.parseOptions(argsStr.split(" "));
-    cmd._optionValues = currentOpts;
-    cmd._storeOptionsAsProperties = currentStore;
-    return result;
-  };
-}
-
-exports.createScriptOptionsParser = createScriptOptionsParser;
-//# sourceMappingURL=optionsParser.cjs.js.map

package/dist/modules/build/lib/packager/createDistWorkspace.cjs.js

@@ -1,235 +0,0 @@
-'use strict';
-
-var chalk = require('chalk');
-var fs = require('fs-extra');
-var path = require('node:path');
-var os = require('node:os');
-var tar = require('tar');
-var partition = require('lodash/partition');
-var cliCommon = require('@backstage/cli-common');
-var _package = require('../../../../packages/cli/package.json.cjs.js');
-var packager = require('../builder/packager.cjs.js');
-var types = require('../builder/types.cjs.js');
-var productionPack = require('./productionPack.cjs.js');
-var cliNode = require('@backstage/cli-node');
-var typeDistProject = require('../typeDistProject.cjs.js');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var tar__namespace = /*#__PURE__*/_interopNamespaceCompat(tar);
-var partition__default = /*#__PURE__*/_interopDefaultCompat(partition);
-
-const UNSAFE_PACKAGES = [
-  ...Object.keys(_package.dependencies),
-  ...Object.keys(_package.devDependencies)
-];
-function prefixLogFunc(prefix, out) {
-  return (data) => {
-    for (const line of data.toString("utf8").split(/\r?\n/)) {
-      process[out].write(`${prefix} ${line}
-`);
-    }
-  };
-}
-async function createDistWorkspace(packageNames, options = {}) {
-  const targetDir = options.targetDir ?? await fs__default.default.mkdtemp(path.resolve(os.tmpdir(), "dist-workspace"));
-  const packages = await cliNode.PackageGraph.listTargetPackages();
-  const packageGraph = cliNode.PackageGraph.fromPackages(packages);
-  const targetNames = packageGraph.collectPackageNames(packageNames, (node) => {
-    if (node.packageJson.bundled) {
-      return void 0;
-    }
-    return node.publishedLocalDependencies.keys();
-  });
-  const targets = Array.from(targetNames).map((name) => packageGraph.get(name));
-  if (options.buildDependencies) {
-    const exclude = options.buildExcludes ?? [];
-    const configPaths = options.configPaths ?? [];
-    const toBuild = new Set(
-      targets.map((_) => _.name).filter((name) => !exclude.includes(name))
-    );
-    const standardBuilds = new Array();
-    const customBuild = new Array();
-    for (const pkg of packages) {
-      if (!toBuild.has(pkg.packageJson.name)) {
-        continue;
-      }
-      const role = pkg.packageJson.backstage?.role;
-      if (!role) {
-        console.warn(
-          `Building ${pkg.packageJson.name} separately because it has no role`
-        );
-        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name });
-        continue;
-      }
-      const buildScript = pkg.packageJson.scripts?.build;
-      if (!buildScript) {
-        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name });
-        continue;
-      }
-      if (!buildScript.startsWith("backstage-cli package build")) {
-        console.warn(
-          `Building ${pkg.packageJson.name} separately because it has a custom build script, '${buildScript}'`
-        );
-        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name });
-        continue;
-      }
-      if (cliNode.PackageRoles.getRoleInfo(role).output.includes("bundle")) {
-        console.warn(
-          `Building ${pkg.packageJson.name} separately because it is a bundled package`
-        );
-        const args = buildScript.includes("--config") ? [] : configPaths.map((p) => ["--config", p]).flat();
-        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name, args });
-        continue;
-      }
-      const outputs = packager.getOutputsForRole(role);
-      outputs.delete(types.Output.types);
-      if (outputs.size > 0) {
-        standardBuilds.push({
-          targetDir: pkg.dir,
-          packageJson: pkg.packageJson,
-          outputs,
-          logPrefix: `${chalk__default.default.cyan(
-            path.relative(cliCommon.targetPaths.rootDir, pkg.dir)
-          )}: `,
-          minify: options.minify,
-          workspacePackages: packages
-        });
-      }
-    }
-    await packager.buildPackages(standardBuilds);
-    if (customBuild.length > 0) {
-      await cliNode.runConcurrentTasks({
-        items: customBuild,
-        worker: async ({ name, dir, args }) => {
-          await cliCommon.run(["yarn", "run", "build", ...args || []], {
-            cwd: dir,
-            onStdout: prefixLogFunc(`${name}: `, "stdout"),
-            onStderr: prefixLogFunc(`${name}: `, "stderr")
-          }).waitForExit();
-        }
-      });
-    }
-  }
-  await moveToDistWorkspace(
-    targetDir,
-    targets,
-    Boolean(options.alwaysPack),
-    Boolean(options.enableFeatureDetection)
-  );
-  const files = options.files ?? ["yarn.lock", "package.json"];
-  for (const file of files) {
-    const src = typeof file === "string" ? file : file.src;
-    const dest = typeof file === "string" ? file : file.dest;
-    await fs__default.default.copy(cliCommon.targetPaths.resolveRoot(src), path.resolve(targetDir, dest));
-  }
-  if (options.skeleton) {
-    const skeletonFiles = targets.map((target) => {
-      const dir = path.relative(cliCommon.targetPaths.rootDir, target.dir);
-      return path.join(dir, "package.json");
-    }).sort();
-    await tar__namespace.create(
-      {
-        file: path.resolve(targetDir, options.skeleton),
-        cwd: targetDir,
-        portable: true,
-        noMtime: true,
-        gzip: options.skeleton.endsWith(".gz")
-      },
-      skeletonFiles
-    );
-  }
-  return targetDir;
-}
-const FAST_PACK_SCRIPTS = [
-  void 0,
-  "backstage-cli prepack",
-  "backstage-cli package prepack"
-];
-async function moveToDistWorkspace(workspaceDir, localPackages, alwaysPack, enableFeatureDetection) {
-  const [fastPackPackages, slowPackPackages] = partition__default.default(
-    localPackages,
-    (pkg) => !alwaysPack && FAST_PACK_SCRIPTS.includes(pkg.packageJson.scripts?.prepack)
-  );
-  const featureDetectionProject = fastPackPackages.length > 0 && enableFeatureDetection ? await typeDistProject.createTypeDistProject() : void 0;
-  await Promise.all(
-    fastPackPackages.map(async (target) => {
-      console.log(`Moving ${target.name} into dist workspace`);
-      const outputDir = path.relative(cliCommon.targetPaths.rootDir, target.dir);
-      const absoluteOutputPath = path.resolve(workspaceDir, outputDir);
-      await productionPack.productionPack({
-        packageDir: target.dir,
-        targetDir: absoluteOutputPath,
-        featureDetectionProject
-      });
-    })
-  );
-  async function pack(target, archive) {
-    console.log(`Repacking ${target.name} into dist workspace`);
-    const archivePath = path.resolve(workspaceDir, archive);
-    await cliCommon.run(["yarn", "pack", "--filename", archivePath], {
-      cwd: target.dir
-    }).waitForExit();
-    const outputDir = path.relative(cliCommon.targetPaths.rootDir, target.dir);
-    const absoluteOutputPath = path.resolve(workspaceDir, outputDir);
-    await fs__default.default.ensureDir(absoluteOutputPath);
-    await tar__namespace.extract({
-      file: archivePath,
-      cwd: absoluteOutputPath,
-      strip: 1
-    });
-    await fs__default.default.remove(archivePath);
-    if (target.packageJson.bundled) {
-      const pkgJson = await fs__default.default.readJson(
-        path.resolve(absoluteOutputPath, "package.json")
-      );
-      delete pkgJson.dependencies;
-      delete pkgJson.devDependencies;
-      delete pkgJson.peerDependencies;
-      delete pkgJson.optionalDependencies;
-      await fs__default.default.writeJson(
-        path.resolve(absoluteOutputPath, "package.json"),
-        pkgJson,
-        {
-          spaces: 2
-        }
-      );
-    }
-  }
-  const [unsafePackages, safePackages] = partition__default.default(
-    slowPackPackages,
-    (p) => UNSAFE_PACKAGES.includes(p.name)
-  );
-  for (const target of unsafePackages) {
-    await pack(target, `temp-package.tgz`);
-  }
-  await cliNode.runConcurrentTasks({
-    items: safePackages.map((target, index) => ({ target, index })),
-    worker: async ({ target, index }) => {
-      await pack(target, `temp-package-${index}.tgz`);
-    }
-  });
-}
-
-exports.createDistWorkspace = createDistWorkspace;
-//# sourceMappingURL=createDistWorkspace.cjs.js.map

package/dist/modules/build/lib/packager/productionPack.cjs.js

@@ -1,160 +0,0 @@
-'use strict';
-
-var fs = require('fs-extra');
-var npmPackList = require('npm-packlist');
-var path = require('node:path');
-var entryPoints = require('../entryPoints.cjs.js');
-var typeDistProject = require('../typeDistProject.cjs.js');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var npmPackList__default = /*#__PURE__*/_interopDefaultCompat(npmPackList);
-
-const PKG_PATH = "package.json";
-const PKG_BACKUP_PATH = "package.json-prepack";
-const SKIPPED_KEYS = ["access", "registry", "tag"];
-const SCRIPT_EXTS = [".js", ".jsx", ".ts", ".tsx"];
-async function productionPack(options) {
-  const { packageDir, targetDir } = options;
-  const pkgPath = path.resolve(packageDir, PKG_PATH);
-  const pkgContent = await fs__default.default.readFile(pkgPath, "utf8");
-  const pkg = JSON.parse(pkgContent);
-  if (!targetDir) {
-    await fs__default.default.writeFile(PKG_BACKUP_PATH, pkgContent);
-  }
-  await rewriteEntryPoints(pkg, packageDir, options.featureDetectionProject);
-  const publishConfig = pkg.publishConfig ?? {};
-  for (const key of Object.keys(publishConfig)) {
-    if (!SKIPPED_KEYS.includes(key)) {
-      pkg[key] = publishConfig[key];
-    }
-  }
-  if (pkg.bundled) {
-    delete pkg.dependencies;
-    delete pkg.devDependencies;
-    delete pkg.peerDependencies;
-    delete pkg.optionalDependencies;
-  }
-  if (targetDir) {
-    const filePaths = await npmPackList__default.default({
-      path: packageDir,
-      // This makes sure we use the updated package.json when listing files
-      packageJsonCache: /* @__PURE__ */ new Map([
-        [path.resolve(packageDir, PKG_PATH), pkg]
-      ])
-      // Seems like this parameter type is wrong,
-    });
-    await fs__default.default.ensureDir(targetDir);
-    for (const filePath of filePaths.sort()) {
-      const target = path.resolve(targetDir, filePath);
-      if (filePath === PKG_PATH) {
-        await fs__default.default.writeJson(target, pkg, { encoding: "utf8", spaces: 2 });
-      } else {
-        await fs__default.default.copy(path.resolve(packageDir, filePath), target);
-      }
-    }
-  } else {
-    await fs__default.default.writeJson(pkgPath, pkg, { encoding: "utf8", spaces: 2 });
-  }
-}
-async function revertProductionPack(packageDir) {
-  try {
-    await fs__default.default.move(PKG_BACKUP_PATH, PKG_PATH, { overwrite: true });
-    const pkg = await fs__default.default.readJson(PKG_PATH);
-    const entryPoints$1 = entryPoints.readEntryPoints(pkg);
-    for (const entryPoint of entryPoints$1) {
-      if (entryPoint.mount !== "." && SCRIPT_EXTS.includes(entryPoint.ext)) {
-        await fs__default.default.remove(path.resolve(packageDir, entryPoint.name));
-      }
-    }
-  } catch (error) {
-    console.warn(
-      `Failed to restore package.json, ${error}. Your package will be fine but you may have ended up with some garbage in the repo.`
-    );
-  }
-}
-const EXPORT_MAP = {
-  import: ".esm.js",
-  require: ".cjs.js",
-  types: ".d.ts"
-};
-async function rewriteEntryPoints(pkg, packageDir, featureDetectionProject) {
-  const distPath = path.resolve(packageDir, "dist");
-  if (!await fs__default.default.pathExists(distPath)) {
-    return void 0;
-  }
-  const distFiles = await fs__default.default.readdir(distPath);
-  const outputExports = {};
-  const entryPoints$1 = entryPoints.readEntryPoints(pkg);
-  if (pkg.typesVersions) {
-    pkg.typesVersions = void 0;
-  }
-  for (const entryPoint of entryPoints$1) {
-    if (!SCRIPT_EXTS.includes(entryPoint.ext)) {
-      outputExports[entryPoint.mount] = entryPoint.path.replace(
-        /^(\.\/)?src\//,
-        "./dist/"
-      );
-      continue;
-    }
-    let exp = {};
-    for (const [key, ext] of Object.entries(EXPORT_MAP)) {
-      const name = `${entryPoint.name}${ext}`;
-      if (distFiles.includes(name)) {
-        exp[key] = `./${path.posix.join(`dist`, name)}`;
-      }
-    }
-    if (exp.types) {
-      if (!pkg.typesVersions) {
-        pkg.typesVersions = { "*": {} };
-      }
-      if (entryPoint.name !== "index") {
-        pkg.typesVersions["*"][entryPoint.name] = [
-          `dist/${entryPoint.name}.d.ts`
-        ];
-      }
-    }
-    exp.default = exp.require ?? exp.import;
-    if (exp.types && featureDetectionProject) {
-      const defaultFeatureType = pkg.backstage?.role && typeDistProject.getEntryPointDefaultFeatureType(
-        pkg.backstage?.role,
-        packageDir,
-        featureDetectionProject,
-        exp.types
-      );
-      if (defaultFeatureType) {
-        exp = { backstage: defaultFeatureType, ...exp };
-        pkg.backstage = pkg.backstage ?? {};
-        pkg.backstage.features = pkg.backstage.features ?? {};
-        pkg.backstage.features[entryPoint.mount] = defaultFeatureType;
-      }
-    }
-    if (entryPoint.mount === ".") {
-      if (exp.default) {
-        pkg.main = exp.default;
-      }
-      if (exp.import) {
-        pkg.module = exp.import;
-      }
-      if (exp.types) {
-        pkg.types = exp.types;
-      }
-    }
-    if (Object.keys(exp).length > 0) {
-      outputExports[entryPoint.mount] = exp;
-    }
-  }
-  if (pkg.typesVersions?.["*"]) {
-    pkg.typesVersions["*"]["package.json"] = ["package.json"];
-  }
-  if (pkg.exports) {
-    pkg.exports = outputExports;
-    pkg.exports["./package.json"] = "./package.json";
-  }
-  return void 0;
-}
-
-exports.productionPack = productionPack;
-exports.revertProductionPack = revertProductionPack;
-//# sourceMappingURL=productionPack.cjs.js.map