powerlines 0.23.2 → 0.23.4

package/dist/lib/chunk-S7LLEDQM.cjs

@@ -0,0 +1,1218 @@
+'use strict';
+
+var chunk2NZADVP5_cjs = require('./chunk-2NZADVP5.cjs');
+var chunk4NHFXDTQ_cjs = require('./chunk-4NHFXDTQ.cjs');
+var chunkZBDVQVUK_cjs = require('./chunk-ZBDVQVUK.cjs');
+var chunkBQU53ZNB_cjs = require('./chunk-BQU53ZNB.cjs');
+var chunkUHGGYHSK_cjs = require('./chunk-UHGGYHSK.cjs');
+var chunkB3EE3VHZ_cjs = require('./chunk-B3EE3VHZ.cjs');
+var chunkPYQADZVV_cjs = require('./chunk-PYQADZVV.cjs');
+var chunk7XHBIYIN_cjs = require('./chunk-7XHBIYIN.cjs');
+var chunkJA4HSQRN_cjs = require('./chunk-JA4HSQRN.cjs');
+var chunk3OCI4TH7_cjs = require('./chunk-3OCI4TH7.cjs');
+var chunkISBHXSDH_cjs = require('./chunk-ISBHXSDH.cjs');
+var chunkUSNT2KNT_cjs = require('./chunk-USNT2KNT.cjs');
+var types = require('@storm-software/config-tools/types');
+var getWorkspaceRoot = require('@stryke/fs/get-workspace-root');
+var bundleRequire = require('bundle-require');
+var core = require('@babel/core');
+var console = require('@storm-software/config-tools/logger/console');
+var toArray = require('@stryke/convert/to-array');
+var copyFile = require('@stryke/fs/copy-file');
+var exists = require('@stryke/fs/exists');
+var helpers = require('@stryke/fs/helpers');
+var install = require('@stryke/fs/install');
+var listFiles = require('@stryke/fs/list-files');
+var packageFns = require('@stryke/fs/package-fns');
+var resolve = require('@stryke/fs/resolve');
+var append = require('@stryke/path/append');
+var joinPaths = require('@stryke/path/join-paths');
+var replace = require('@stryke/path/replace');
+var isError = require('@stryke/type-checks/is-error');
+var isFunction = require('@stryke/type-checks/is-function');
+var isNumber = require('@stryke/type-checks/is-number');
+var isPromise = require('@stryke/type-checks/is-promise');
+var isSet = require('@stryke/type-checks/is-set');
+var isSetObject = require('@stryke/type-checks/is-set-object');
+var isSetString = require('@stryke/type-checks/is-set-string');
+var chalk2 = require('chalk');
+var defu = require('defu');
+var Handlebars = require('handlebars');
+var helperPluginUtils = require('@babel/helper-plugin-utils');
+var t = require('@babel/types');
+var ts = require('typescript');
+var _package = require('@stryke/string-format/package');
+var superdiff = require('@donedeal0/superdiff');
+var json = require('@stryke/fs/json');
+var tsconfig = require('@stryke/fs/tsconfig');
+var stormJson = require('@stryke/json/storm-json');
+var filePathFns = require('@stryke/path/file-path-fns');
+var titleCase = require('@stryke/string-format/title-case');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) 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 chalk2__default = /*#__PURE__*/_interopDefault(chalk2);
+var defu__default = /*#__PURE__*/_interopDefault(defu);
+var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
+var t__namespace = /*#__PURE__*/_interopNamespace(t);
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+function resolveModulePath(nodePath, state) {
+  if (!t__namespace.isStringLiteral(nodePath.node)) {
+    return;
+  }
+  const sourcePath = nodePath.node.value;
+  const resolvedPath = state.context?.fs.resolve(sourcePath);
+  if (resolvedPath) {
+    nodePath.replaceWith(t__namespace.stringLiteral(
+      // Remove the file extension if it exists
+      resolvedPath.replace(/\.(?:ts|mts|cts)x?$/, "")
+    ));
+  }
+}
+chunkUSNT2KNT_cjs.__name(resolveModulePath, "resolveModulePath");
+var TRANSFORM_FUNCTIONS = [
+  "require",
+  "require.resolve",
+  "System.import",
+  // Jest methods
+  "jest.genMockFromModule",
+  "jest.mock",
+  "jest.unmock",
+  "jest.doMock",
+  // eslint-disable-next-line @cspell/spellchecker
+  "jest.dontMock",
+  "jest.setMock",
+  "jest.requireActual",
+  "jest.requireMock",
+  // Older Jest methods
+  "require.requireActual",
+  "require.requireMock"
+];
+function matchesPattern(state, calleePath, pattern) {
+  const { node } = calleePath;
+  if (t__namespace.isMemberExpression(node)) {
+    return calleePath.matchesPattern(pattern);
+  }
+  if (!t__namespace.isIdentifier(node) || pattern.includes(".")) {
+    return false;
+  }
+  const name = pattern.split(".")[0];
+  return node.name === name;
+}
+chunkUSNT2KNT_cjs.__name(matchesPattern, "matchesPattern");
+var importVisitors = {
+  CallExpression: /* @__PURE__ */ chunkUSNT2KNT_cjs.__name((nodePath, state) => {
+    if (state.moduleResolverVisited.has(nodePath)) {
+      return;
+    }
+    const calleePath = nodePath.get("callee");
+    if (calleePath && TRANSFORM_FUNCTIONS.some((pattern) => matchesPattern(state, calleePath, pattern)) || t__namespace.isImport(nodePath.node.callee)) {
+      state.moduleResolverVisited.add(nodePath);
+      resolveModulePath(nodePath.get("arguments.0"), state);
+    }
+  }, "CallExpression"),
+  // eslint-disable-next-line ts/naming-convention
+  "ImportDeclaration|ExportDeclaration|ExportAllDeclaration": /* @__PURE__ */ chunkUSNT2KNT_cjs.__name((nodePath, state) => {
+    if (!nodePath || !nodePath.get("source") || state.moduleResolverVisited.has(nodePath)) {
+      return;
+    }
+    state.moduleResolverVisited.add(nodePath);
+    resolveModulePath(nodePath.get("source"), state);
+  }, "ImportDeclaration|ExportDeclaration|ExportAllDeclaration")
+};
+var moduleResolverBabelPlugin = /* @__PURE__ */ chunkUSNT2KNT_cjs.__name((context) => {
+  return helperPluginUtils.declare(/* @__PURE__ */ chunkUSNT2KNT_cjs.__name(function builder(api) {
+    let moduleResolverVisited = /* @__PURE__ */ new Set();
+    return {
+      name: "powerlines:module-resolver",
+      manipulateOptions(opts) {
+        opts.filename ??= "unknown";
+      },
+      pre() {
+        moduleResolverVisited = /* @__PURE__ */ new Set();
+      },
+      visitor: {
+        Program: {
+          enter(programPath, state) {
+            programPath.traverse(importVisitors, {
+              ...state,
+              context,
+              moduleResolverVisited,
+              api
+            });
+          },
+          exit(programPath, state) {
+            programPath.traverse(importVisitors, {
+              ...state,
+              context,
+              moduleResolverVisited,
+              api
+            });
+          }
+        }
+      },
+      post() {
+        moduleResolverVisited.clear();
+      }
+    };
+  }, "builder"));
+}, "moduleResolverBabelPlugin");
+function formatTypes(code) {
+  return code.replace(
+    // eslint-disable-next-line regexp/no-super-linear-backtracking
+    /import\s*(?:type\s*)?\{?[\w,\s]*(?:\}\s*)?from\s*(?:'|")@?[a-zA-Z0-9-\\/.]*(?:'|");?/g,
+    ""
+  ).replaceAll("#private;", "").replace(/__Ω/g, "");
+}
+chunkUSNT2KNT_cjs.__name(formatTypes, "formatTypes");
+async function emitTypes(context, tsconfig, files) {
+  context.log(types.LogLevelLabel.TRACE, "Creating the TypeScript compiler host");
+  const program = ts.createProgram(files, tsconfig.options, ts.createCompilerHost(tsconfig.options));
+  context.log(types.LogLevelLabel.TRACE, `Running the TypeScript compiler for ${context.builtins.length} built-in runtime files.`);
+  let builtinModules = "";
+  const emitResult = program.emit(void 0, (fileName, text, _, __, sourceFiles, _data) => {
+    const sourceFile = sourceFiles?.[0];
+    if (sourceFile?.fileName && !fileName.endsWith(".map")) {
+      if (context.builtins.some((file) => file === sourceFile.fileName || context.fs.metadata[file]?.id && context.fs.metadata[file]?.id === sourceFile.fileName)) {
+        builtinModules += `
+declare module "${context.fs.resolve(sourceFile.fileName)}" {
+    ${text.trim().replace(/^\s*export\s*declare\s*/gm, "export ").replace(/^\s*declare\s*/gm, "")}
+}
+`;
+      }
+    }
+  }, void 0, true);
+  const diagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  const diagnosticMessages = [];
+  diagnostics.forEach((diagnostic) => {
+    if (diagnostic.file) {
+      const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+      const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+      diagnosticMessages.push(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+    } else {
+      const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+      diagnosticMessages.push(message);
+    }
+  });
+  const diagnosticMessage = diagnosticMessages.join("\n");
+  if (diagnosticMessage) {
+    throw new Error(`TypeScript compilation failed: 
+
+${diagnosticMessage.length > 5e3 ? `${diagnosticMessage.slice(0, 5e3)}...` : diagnosticMessage}`);
+  }
+  return formatTypes(builtinModules);
+}
+chunkUSNT2KNT_cjs.__name(emitTypes, "emitTypes");
+async function installPackage(context, packageName, dev = false) {
+  if (!await packageFns.isPackageListed(_package.getPackageName(packageName), {
+    cwd: context.config.projectRoot
+  })) {
+    if (context.config.skipInstalls !== true && !process.env.POWERLINES_LOCAL) {
+      context.log(types.LogLevelLabel.WARN, `The package "${packageName}" is not installed. It will be installed automatically.`);
+      const result = await install.install(packageName, {
+        cwd: context.config.projectRoot,
+        dev
+      });
+      if (isNumber.isNumber(result.exitCode) && result.exitCode > 0) {
+        context.log(types.LogLevelLabel.ERROR, result.stderr);
+        throw new Error(`An error occurred while installing the package "${packageName}"`);
+      }
+    } else {
+      context.log(types.LogLevelLabel.WARN, `The package "${packageName}" is not installed. Since the "skipInstalls" option is set to true, it will not be installed automatically.`);
+    }
+  } else if (_package.hasPackageVersion(packageName) && !process.env.POWERLINES_SKIP_VERSION_CHECK) {
+    const isMatching = await packageFns.doesPackageMatch(_package.getPackageName(packageName), _package.getPackageVersion(packageName), context.config.projectRoot);
+    if (!isMatching) {
+      const packageListing = await packageFns.getPackageListing(_package.getPackageName(packageName), {
+        cwd: context.config.projectRoot
+      });
+      if (!packageListing?.version.startsWith("catalog:") && !packageListing?.version.startsWith("workspace:")) {
+        context.log(types.LogLevelLabel.WARN, `The package "${_package.getPackageName(packageName)}" is installed but does not match the expected version ${_package.getPackageVersion(packageName)} (installed version: ${packageListing?.version || "<Unknown>"}). Please ensure this is intentional before proceeding. Note: You can skip this validation with the "STORM_STACK_SKIP_VERSION_CHECK" environment variable.`);
+      }
+    }
+  }
+}
+chunkUSNT2KNT_cjs.__name(installPackage, "installPackage");
+
+// src/internal/helpers/install-dependencies.ts
+async function installDependencies(context) {
+  context.log(types.LogLevelLabel.TRACE, `Checking and installing missing project dependencies.`);
+  context.dependencies ??= {};
+  context.devDependencies ??= {};
+  if (Object.keys(context.dependencies).length === 0 && Object.keys(context.devDependencies).length === 0) {
+    context.log(types.LogLevelLabel.TRACE, `No dependencies or devDependencies to install. Skipping installation step.`);
+    return;
+  }
+  context.log(types.LogLevelLabel.DEBUG, `The following packages are required: 
+Dependencies: 
+${Object.entries(context.dependencies).map(([name, version]) => `- ${name}@${String(version)}`).join(" \n")}
+
+DevDependencies: 
+${Object.entries(context.devDependencies).map(([name, version]) => `- ${name}@${String(version)}`).join(" \n")}`);
+  await Promise.all([
+    Promise.all(Object.entries(context.dependencies).map(async ([name, version]) => installPackage(context, `${_package.getPackageName(name)}@${String(version)}`, false))),
+    Promise.all(Object.entries(context.devDependencies).map(async ([name, version]) => installPackage(context, `${_package.getPackageName(name)}@${String(version)}`, true)))
+  ]);
+}
+chunkUSNT2KNT_cjs.__name(installDependencies, "installDependencies");
+async function resolveTsconfigChanges(context) {
+  const tsconfig$1 = chunkBQU53ZNB_cjs.getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw);
+  const tsconfigFilePath = chunkBQU53ZNB_cjs.getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
+  const tsconfigJson = await json.readJsonFile(tsconfigFilePath);
+  tsconfigJson.compilerOptions ??= {};
+  const extendedTsconfig = await tsconfig.loadTsConfig(tsconfigFilePath);
+  extendedTsconfig.compilerOptions ??= {};
+  if (tsconfigJson.reflection !== true) {
+    tsconfigJson.reflection = true;
+  }
+  if (tsconfig$1.options.experimentalDecorators !== true) {
+    tsconfigJson.compilerOptions.experimentalDecorators = true;
+  }
+  if (tsconfig$1.options.emitDecoratorMetadata !== true) {
+    tsconfigJson.compilerOptions.emitDecoratorMetadata = true;
+  }
+  if (context.config.output.dts) {
+    const dtsFilePath = context.config.output.dts ? context.config.output.dts.startsWith(context.workspaceConfig.workspaceRoot) ? context.config.output.dts : joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.dts) : joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot, "storm.d.ts");
+    const dtsRelativePath = joinPaths.joinPaths(filePathFns.relativePath(joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot), filePathFns.findFilePath(dtsFilePath)), filePathFns.findFileName(dtsFilePath));
+    if (!tsconfigJson.include?.some((filePattern) => chunkBQU53ZNB_cjs.isIncludeMatchFound(filePattern, [
+      dtsFilePath,
+      dtsRelativePath,
+      "storm.d.ts"
+    ]))) {
+      tsconfigJson.include ??= [];
+      tsconfigJson.include.push(dtsRelativePath.startsWith("./") ? dtsRelativePath.slice(2) : dtsRelativePath);
+    }
+  }
+  if (!tsconfig$1.options.lib?.some((lib) => [
+    "lib.esnext.d.ts",
+    "lib.es2021.d.ts",
+    "lib.es2022.d.ts",
+    "lib.es2023.d.ts"
+  ].includes(lib.toLowerCase()))) {
+    tsconfigJson.compilerOptions.lib ??= [];
+    tsconfigJson.compilerOptions.lib.push("esnext");
+  }
+  if (tsconfig$1.options.module !== ts__default.default.ModuleKind.ESNext) {
+    tsconfigJson.compilerOptions.module = "ESNext";
+  }
+  if (!tsconfig$1.options.target || ![
+    ts__default.default.ScriptTarget.ESNext,
+    ts__default.default.ScriptTarget.ES2024,
+    ts__default.default.ScriptTarget.ES2023,
+    ts__default.default.ScriptTarget.ES2022,
+    ts__default.default.ScriptTarget.ES2021
+  ].includes(tsconfig$1.options.target)) {
+    tsconfigJson.compilerOptions.target = "ESNext";
+  }
+  if (tsconfig$1.options.moduleResolution !== ts__default.default.ModuleResolutionKind.Bundler) {
+    tsconfigJson.compilerOptions.moduleResolution = "Bundler";
+  }
+  if (tsconfig$1.options.moduleDetection !== ts__default.default.ModuleDetectionKind.Force) {
+    tsconfigJson.compilerOptions.moduleDetection = "force";
+  }
+  if (tsconfig$1.options.allowSyntheticDefaultImports !== true) {
+    tsconfigJson.compilerOptions.allowSyntheticDefaultImports = true;
+  }
+  if (tsconfig$1.options.noImplicitOverride !== true) {
+    tsconfigJson.compilerOptions.noImplicitOverride = true;
+  }
+  if (tsconfig$1.options.noUncheckedIndexedAccess !== true) {
+    tsconfigJson.compilerOptions.noUncheckedIndexedAccess = true;
+  }
+  if (tsconfig$1.options.skipLibCheck !== true) {
+    tsconfigJson.compilerOptions.skipLibCheck = true;
+  }
+  if (tsconfig$1.options.resolveJsonModule !== true) {
+    tsconfigJson.compilerOptions.resolveJsonModule = true;
+  }
+  if (tsconfig$1.options.isolatedModules !== true) {
+    tsconfigJson.compilerOptions.isolatedModules = true;
+  }
+  if (tsconfig$1.options.verbatimModuleSyntax !== false) {
+    tsconfigJson.compilerOptions.verbatimModuleSyntax = false;
+  }
+  if (tsconfig$1.options.allowJs !== true) {
+    tsconfigJson.compilerOptions.allowJs = true;
+  }
+  if (tsconfig$1.options.esModuleInterop !== true) {
+    tsconfigJson.compilerOptions.esModuleInterop = true;
+  }
+  if (tsconfig$1.options.declaration !== true) {
+    tsconfigJson.compilerOptions.declaration = true;
+  }
+  if (context.environment.consumer === "client") {
+    if (tsconfig$1.options.jsx !== ts__default.default.JsxEmit.ReactJSX) {
+      tsconfigJson.compilerOptions.jsx = "react-jsx";
+    }
+    if (!tsconfig$1.options.lib?.some((lib) => lib.toLowerCase() !== "dom")) {
+      tsconfigJson.compilerOptions.lib ??= [];
+      tsconfigJson.compilerOptions.lib.push("dom");
+    }
+    if (!tsconfig$1.options.lib?.some((lib) => lib.toLowerCase() !== "dom.iterable")) {
+      tsconfigJson.compilerOptions.lib ??= [];
+      tsconfigJson.compilerOptions.lib.push("dom.iterable");
+    }
+  } else if (context.config.build.platform === "node") {
+    if (!tsconfig$1.options.types?.some((type) => type.toLowerCase() === "node" || type.toLowerCase() === "@types/node")) {
+      tsconfigJson.compilerOptions.types ??= [];
+      tsconfigJson.compilerOptions.types.push("node");
+    }
+  }
+  return tsconfigJson;
+}
+chunkUSNT2KNT_cjs.__name(resolveTsconfigChanges, "resolveTsconfigChanges");
+async function initializeTsconfig(context) {
+  context.log(types.LogLevelLabel.TRACE, "Initializing TypeScript configuration (tsconfig.json) for the Powerlines project.");
+  if (!packageFns.isPackageExists("typescript")) {
+    throw new Error('The TypeScript package is not installed. Please install the package using the command: "npm install typescript --save-dev"');
+  }
+  const tsconfigFilePath = chunkBQU53ZNB_cjs.getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
+  context.tsconfig.originalTsconfigJson = await json.readJsonFile(tsconfigFilePath);
+  context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
+  await context.fs.writeFile(tsconfigFilePath, stormJson.StormJSON.stringify(context.tsconfig.tsconfigJson), {
+    mode: "fs"
+  });
+  context.tsconfig = chunkBQU53ZNB_cjs.getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw, context.tsconfig.originalTsconfigJson);
+}
+chunkUSNT2KNT_cjs.__name(initializeTsconfig, "initializeTsconfig");
+async function resolveTsconfig(context) {
+  const updateTsconfigJson = await json.readJsonFile(context.tsconfig.tsconfigFilePath);
+  if (updateTsconfigJson?.compilerOptions?.types && Array.isArray(updateTsconfigJson.compilerOptions.types) && !updateTsconfigJson.compilerOptions.types.length) {
+    delete updateTsconfigJson.compilerOptions.types;
+  }
+  const result = superdiff.getObjectDiff(context.tsconfig.originalTsconfigJson, updateTsconfigJson, {
+    ignoreArrayOrder: true,
+    showOnly: {
+      statuses: [
+        "added",
+        "deleted",
+        "updated"
+      ],
+      granularity: "deep"
+    }
+  });
+  const changes = [];
+  const getChanges = /* @__PURE__ */ chunkUSNT2KNT_cjs.__name((difference, property) => {
+    if (difference.status === "added" || difference.status === "deleted" || difference.status === "updated") {
+      if (difference.diff) {
+        for (const diff of difference.diff) {
+          getChanges(diff, property ? `${property}.${difference.property}` : difference.property);
+        }
+      } else {
+        changes.push({
+          field: property ? `${property}.${difference.property}` : difference.property,
+          status: difference.status,
+          previous: difference.status === "added" ? "---" : stormJson.StormJSON.stringify(difference.previousValue),
+          current: difference.status === "deleted" ? "---" : stormJson.StormJSON.stringify(difference.currentValue)
+        });
+      }
+    }
+  }, "getChanges");
+  for (const diff of result.diff) {
+    getChanges(diff);
+  }
+  if (changes.length > 0) {
+    context.log(types.LogLevelLabel.WARN, `Updating the following configuration values in "${context.tsconfig.tsconfigFilePath}" file:
+
+    ${changes.map((change, i) => `${chalk2__default.default.bold.whiteBright(`${i + 1}. ${titleCase.titleCase(change.status)} the ${change.field} field: `)}
+    ${chalk2__default.default.red(` - Previous: ${change.previous} `)}
+    ${chalk2__default.default.green(` - Updated: ${change.current} `)}
+  `).join("\n")}
+    `);
+  }
+  await chunk2NZADVP5_cjs.writeFile(context.log, context.tsconfig.tsconfigFilePath, stormJson.StormJSON.stringify(updateTsconfigJson));
+  context.tsconfig = chunkBQU53ZNB_cjs.getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
+  if (!context.tsconfig) {
+    throw new Error("Failed to parse the TypeScript configuration file.");
+  }
+  context.tsconfig.tsconfigJson.compilerOptions ??= {};
+  context.tsconfig.tsconfigJson.compilerOptions.strict = false;
+}
+chunkUSNT2KNT_cjs.__name(resolveTsconfig, "resolveTsconfig");
+
+// src/api.ts
+var PowerlinesAPI = class _PowerlinesAPI {
+  static {
+    chunkUSNT2KNT_cjs.__name(this, "PowerlinesAPI");
+  }
+  /**
+  * The Powerlines context
+  */
+  #context;
+  /**
+  * The Powerlines context
+  */
+  get context() {
+    return this.#context;
+  }
+  /**
+  * Create a new Powerlines API instance
+  *
+  * @param context - The Powerlines context
+  */
+  constructor(context) {
+    this.#context = context;
+  }
+  /**
+  * Initialize the Powerlines API
+  */
+  static async from(workspaceRoot, config) {
+    const api = new _PowerlinesAPI(await chunkUHGGYHSK_cjs.PowerlinesAPIContext.from(workspaceRoot, config));
+    api.#context.$$internal.api = api;
+    for (const plugin of api.context.config.plugins ?? []) {
+      await api.#addPlugin(plugin);
+    }
+    if (api.context.plugins.length === 0) {
+      api.context.log(types.LogLevelLabel.WARN, "No Powerlines plugins were specified in the options. Please ensure this is correct, as it is generally not recommended.");
+    }
+    const pluginConfig = await chunkB3EE3VHZ_cjs.callHook(await api.context.getEnvironment(), "config", {
+      sequential: true,
+      result: "merge"
+    });
+    await api.context.withUserConfig(pluginConfig, {
+      isHighPriority: false
+    });
+    return api;
+  }
+  /**
+  * Prepare the Powerlines API
+  *
+  * @remarks
+  * This method will prepare the Powerlines API for use, initializing any necessary resources.
+  *
+  * @param inlineConfig - The inline configuration for the prepare command
+  */
+  async prepare(inlineConfig = {
+    command: "prepare"
+  }) {
+    this.context.log(types.LogLevelLabel.TRACE, " \u{1F3D7}\uFE0F  Preparing the Powerlines project");
+    this.context.log(types.LogLevelLabel.TRACE, " \u2699\uFE0F  Aggregating configuration options for the Powerlines project");
+    await this.context.withInlineConfig(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      context.log(types.LogLevelLabel.TRACE, `Initializing the processing options for the Powerlines project.`);
+      await this.callPreHook(context, "configResolved");
+      await initializeTsconfig(context);
+      await this.callNormalHook(context, "configResolved");
+      context.log(types.LogLevelLabel.DEBUG, `The configuration provided ${toArray.toArray(context.config.entry).length} entry point(s), Powerlines has found ${context.entry.length} entry files(s) for the ${context.config.title} project${context.entry.length > 0 && context.entry.length < 10 ? `: 
+${context.entry.map((entry) => `- ${entry.input.file || entry.file}${entry.output ? ` -> ${entry.output}` : ""}`).join(" \n")}` : ""}.`);
+      await resolveTsconfig(context);
+      await installDependencies(context);
+      await this.callPostHook(context, "configResolved");
+      if (context.config.build.polyfill) {
+        context.config.build.polyfill = context.config.build.polyfill.map((polyfill) => chunkISBHXSDH_cjs.replacePathTokens(context, polyfill));
+      }
+      context.log(types.LogLevelLabel.TRACE, `Powerlines configuration has been resolved: 
+
+${console.formatLogMessage(context.config)}`);
+      context.fs[chunkPYQADZVV_cjs.__VFS_PATCH__]();
+      await chunk7XHBIYIN_cjs.writeMetaFile(context);
+      context.persistedMeta = context.meta;
+      if (!exists.existsSync(context.cachePath)) {
+        await helpers.createDirectory(context.cachePath);
+      }
+      if (!exists.existsSync(context.dataPath)) {
+        await helpers.createDirectory(context.dataPath);
+      }
+      await this.callPreHook(context, "prepare");
+      await this.callNormalHook(context, "prepare");
+      if (context.config.output.dts !== false) {
+        context.log(types.LogLevelLabel.TRACE, `Preparing the TypeScript definitions for the Powerlines project.`);
+        context.log(types.LogLevelLabel.TRACE, "Transforming built-ins runtime modules files.");
+        const builtinFilePaths = await Promise.all((await context.getBuiltins()).map(async (file) => {
+          const result2 = await core.transformAsync(file.code.toString(), {
+            highlightCode: true,
+            code: true,
+            ast: false,
+            cloneInputAst: false,
+            comments: true,
+            sourceType: "module",
+            configFile: false,
+            babelrc: false,
+            envName: context.config.mode,
+            caller: {
+              name: "powerlines"
+            },
+            ...context.config.transform.babel,
+            filename: file.path,
+            plugins: [
+              [
+                "@babel/plugin-syntax-typescript"
+              ],
+              [
+                moduleResolverBabelPlugin(context)
+              ]
+            ]
+          });
+          if (!result2?.code) {
+            throw new Error(`Powerlines - Generate Types failed to compile ${file.id}`);
+          }
+          context.log(types.LogLevelLabel.TRACE, `Writing transformed built-in runtime file ${file.id}.`);
+          await context.emitBuiltin(result2.code, file.id, file.path);
+          return file.path;
+        }));
+        const typescriptPath = await resolve.resolvePackage("typescript");
+        if (!typescriptPath) {
+          throw new Error("Could not resolve TypeScript package location. Please ensure TypeScript is installed.");
+        }
+        const files = builtinFilePaths.reduce((ret, fileName) => {
+          const formatted = replace.replacePath(fileName, context.workspaceConfig.workspaceRoot);
+          if (!ret.includes(formatted)) {
+            ret.push(formatted);
+          }
+          return ret;
+        }, [
+          joinPaths.joinPaths(typescriptPath, "lib", "lib.esnext.full.d.ts")
+        ]);
+        context.log(types.LogLevelLabel.TRACE, "Parsing TypeScript configuration for the Powerlines project.");
+        const resolvedTsconfig = chunkBQU53ZNB_cjs.getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.tsconfig.tsconfigFilePath, defu__default.default({
+          compilerOptions: {
+            strict: false,
+            noEmit: false,
+            declaration: true,
+            declarationMap: false,
+            emitDeclarationOnly: true,
+            skipLibCheck: true
+          },
+          exclude: [
+            "node_modules",
+            "dist"
+          ],
+          include: files
+        }, context.config.tsconfigRaw ?? {}));
+        resolvedTsconfig.options.configFilePath = joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.tsconfig.tsconfigFilePath);
+        resolvedTsconfig.options.pathsBasePath = context.workspaceConfig.workspaceRoot;
+        resolvedTsconfig.options.suppressOutputPathCheck = true;
+        let generatedTypes = await emitTypes(context, resolvedTsconfig, files);
+        context.log(types.LogLevelLabel.TRACE, `Generating TypeScript declaration file in ${context.config.output.dts}.`);
+        const directives = [];
+        let result = await this.callPreHook(context, "generateTypes", generatedTypes);
+        if (result) {
+          if (isSetObject.isSetObject(result)) {
+            generatedTypes = result.code;
+            if (Array.isArray(result.directives) && result.directives.length > 0) {
+              directives.push(...result.directives);
+            }
+          } else if (isSetString.isSetString(result)) {
+            generatedTypes = result;
+          }
+        }
+        result = await this.callNormalHook(context, "generateTypes", generatedTypes);
+        if (result) {
+          if (isSetObject.isSetObject(result)) {
+            generatedTypes = result.code;
+            if (Array.isArray(result.directives) && result.directives.length > 0) {
+              directives.push(...result.directives);
+            }
+          } else if (isSetString.isSetString(result)) {
+            generatedTypes = result;
+          }
+        }
+        result = await this.callPostHook(context, "generateTypes", generatedTypes);
+        if (result) {
+          if (isSetObject.isSetObject(result)) {
+            generatedTypes = result.code;
+            if (Array.isArray(result.directives) && result.directives.length > 0) {
+              directives.push(...result.directives);
+            }
+          } else if (isSetString.isSetString(result)) {
+            generatedTypes = result;
+          }
+        }
+        await context.fs.writeFile(context.config.output.dts, `${directives ? `${directives.map((directive) => `/// <reference types="${directive}" />`).join("\n")}
+
+` : ""}${chunk4NHFXDTQ_cjs.getFileHeader(context, {
+          directive: null,
+          prettierIgnore: false
+        })}
+
+${formatTypes(generatedTypes)}
+`, {
+          mode: "fs"
+        });
+      }
+      context.tsconfig = chunkBQU53ZNB_cjs.getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
+      if (!context.tsconfig) {
+        throw new Error("Failed to parse the TypeScript configuration file.");
+      }
+      await this.callPostHook(context, "prepare");
+      await chunk7XHBIYIN_cjs.writeMetaFile(context);
+      context.fs[chunkPYQADZVV_cjs.__VFS_REVERT__]();
+    });
+    this.context.log(types.LogLevelLabel.INFO, "Powerlines API has been prepared successfully");
+  }
+  /**
+  * Create a new Powerlines project
+  *
+  * @remarks
+  * This method will create a new Powerlines project in the current directory.
+  *
+  * @param inlineConfig - The inline configuration for the new command
+  * @returns A promise that resolves when the project has been created
+  */
+  async new(inlineConfig) {
+    this.context.log(types.LogLevelLabel.INFO, "\u{1F195} Creating a new Powerlines project");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      context.log(types.LogLevelLabel.TRACE, `Initializing the processing options for the Powerlines project.`);
+      await this.callPreHook(context, "new");
+      const files = await listFiles.listFiles(joinPaths.joinPaths(context.powerlinesPath, "files/common/**/*.hbs"));
+      for (const file of files) {
+        context.log(types.LogLevelLabel.TRACE, `Adding template file: ${file}`);
+        const template = Handlebars__default.default.compile(file);
+        await chunk2NZADVP5_cjs.writeFile(context.log, joinPaths.joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+      }
+      await this.callNormalHook(context, "new");
+      if (context.config.projectType === "application") {
+        const files2 = await listFiles.listFiles(joinPaths.joinPaths(context.powerlinesPath, "files/application/**/*.hbs"));
+        for (const file of files2) {
+          context.log(types.LogLevelLabel.TRACE, `Adding application template file: ${file}`);
+          const template = Handlebars__default.default.compile(file);
+          await chunk2NZADVP5_cjs.writeFile(context.log, joinPaths.joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+        }
+      } else {
+        const files2 = await listFiles.listFiles(joinPaths.joinPaths(context.powerlinesPath, "files/library/**/*.hbs"));
+        for (const file of files2) {
+          context.log(types.LogLevelLabel.TRACE, `Adding library template file: ${file}`);
+          const template = Handlebars__default.default.compile(file);
+          await chunk2NZADVP5_cjs.writeFile(context.log, joinPaths.joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+        }
+      }
+      await this.callPostHook(context, "new");
+    });
+    this.context.log(types.LogLevelLabel.TRACE, "Powerlines - New command completed");
+  }
+  /**
+  * Clean any previously prepared artifacts
+  *
+  * @remarks
+  * This method will remove the previous Powerlines artifacts from the project.
+  *
+  * @param inlineConfig - The inline configuration for the clean command
+  * @returns A promise that resolves when the clean command has completed
+  */
+  async clean(inlineConfig = {
+    command: "clean"
+  }) {
+    this.context.log(types.LogLevelLabel.INFO, "\u{1F9F9} Cleaning the previous Powerlines artifacts");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      this.context.log(types.LogLevelLabel.TRACE, "Cleaning the project's dist and artifacts directories.");
+      await context.fs.rmdir(joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.distPath));
+      await context.fs.rmdir(joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.artifactsFolder));
+      await chunkB3EE3VHZ_cjs.callHook(context, "clean", {
+        sequential: true
+      });
+    });
+    this.context.log(types.LogLevelLabel.TRACE, "Powerlines - Clean command completed");
+  }
+  /**
+  * Lint the project
+  *
+  * @param inlineConfig - The inline configuration for the lint command
+  * @returns A promise that resolves when the lint command has completed
+  */
+  async lint(inlineConfig = {
+    command: "lint"
+  }) {
+    this.context.log(types.LogLevelLabel.INFO, "\u{1F4CB} Linting the Powerlines project");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      if (context.config.lint !== false) {
+        await this.callHook(context, "lint");
+      }
+    });
+    this.context.log(types.LogLevelLabel.TRACE, "Powerlines linting completed");
+  }
+  /**
+  * Build the project
+  *
+  * @remarks
+  * This method will build the Powerlines project, generating the necessary artifacts.
+  *
+  * @param inlineConfig - The inline configuration for the build command
+  * @returns A promise that resolves when the build command has completed
+  */
+  async build(inlineConfig = {
+    command: "build"
+  }) {
+    this.context.log(types.LogLevelLabel.INFO, "\u{1F4E6}  Building the Powerlines project");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      await this.callPreHook(context, "build");
+      await this.callNormalHook(context, "build");
+      if (context.config.output.distPath !== context.config.output.outputPath) {
+        const sourcePath = append.appendPath(context.config.output.distPath, context.workspaceConfig.workspaceRoot);
+        const destinationPath = joinPaths.joinPaths(append.appendPath(context.config.output.outputPath, context.workspaceConfig.workspaceRoot), "dist");
+        if (sourcePath !== destinationPath) {
+          context.log(types.LogLevelLabel.INFO, `Copying build output files from project's build directory (${context.config.output.distPath}) to the workspace's output directory (${context.config.output.outputPath}).`);
+          await copyFile.copyFiles({
+            input: sourcePath,
+            glob: "**/*"
+          }, destinationPath);
+        }
+      }
+      await Promise.all(context.config.output.assets.map(async (asset) => {
+        context.log(types.LogLevelLabel.DEBUG, `Copying asset(s): ${chalk2__default.default.redBright(context.workspaceConfig.workspaceRoot === asset.input ? asset.glob : joinPaths.joinPaths(replace.replacePath(asset.input, context.workspaceConfig.workspaceRoot), asset.glob))} -> ${chalk2__default.default.greenBright(joinPaths.joinPaths(replace.replacePath(asset.output, context.workspaceConfig.workspaceRoot), asset.glob))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk2__default.default.yellowBright(i)).join(", ")})` : ""}`);
+        await copyFile.copyFiles(asset, asset.output);
+      }));
+      await this.callPostHook(context, "build");
+    });
+    this.context.log(types.LogLevelLabel.TRACE, "Powerlines build completed");
+  }
+  /**
+  * Prepare the documentation for the project
+  *
+  * @param inlineConfig - The inline configuration for the docs command
+  * @returns A promise that resolves when the documentation generation has completed
+  */
+  async docs(inlineConfig = {
+    command: "docs"
+  }) {
+    this.context.log(types.LogLevelLabel.INFO, "\u{1F4D3} Generating documentation for the Powerlines project");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      context.log(types.LogLevelLabel.TRACE, "Writing documentation for the Powerlines project artifacts.");
+      await this.prepare(inlineConfig);
+      await this.#executeEnvironments(async (context2) => {
+        await this.callHook(context2, "docs");
+      });
+    });
+    this.#context.log(types.LogLevelLabel.TRACE, "Powerlines documentation generation completed");
+  }
+  /**
+  * Deploy the project source code
+  *
+  * @remarks
+  * This method will prepare and build the Powerlines project, generating the necessary artifacts for the deployment.
+  *
+  * @param inlineConfig - The inline configuration for the deploy command
+  */
+  async deploy(inlineConfig = {
+    command: "deploy"
+  }) {
+    this.context.log(types.LogLevelLabel.INFO, "\u{1F4E6} Deploying the Powerlines project");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      await this.callHook(context, "deploy");
+    });
+    this.context.log(types.LogLevelLabel.TRACE, "Powerlines deploy completed");
+  }
+  /**
+  * Finalization process
+  *
+  * @remarks
+  * This step includes any final processes or clean up required by Powerlines. It will be run after each Powerlines command.
+  *
+  * @returns A promise that resolves when the finalization process has completed
+  */
+  async finalize() {
+    this.context.log(types.LogLevelLabel.TRACE, "Powerlines finalize execution started");
+    await this.#executeEnvironments(async (context) => {
+      await this.callHook(context, "finalize");
+      context.fs[chunkPYQADZVV_cjs.__VFS_REVERT__]();
+      await context.fs.dispose();
+    });
+    this.context.log(types.LogLevelLabel.TRACE, "Powerlines finalize execution completed");
+  }
+  /**
+  * Calls a hook in parallel
+  *
+  * @param hook - The hook to call
+  * @param options - Options for calling the hook
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callHookParallel(hook, options, ...args) {
+    return chunkB3EE3VHZ_cjs.callHook(isSetObject.isSetObject(options?.environment) ? options.environment : await this.#context.getEnvironment(options?.environment), hook, {
+      ...options,
+      sequential: false
+    }, ...args);
+  }
+  /**
+  * Calls a hook in sequence
+  *
+  * @param hook - The hook to call
+  * @param options - Options for calling the hook
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callHookSequential(hook, options, ...args) {
+    return chunkB3EE3VHZ_cjs.callHook(isSetObject.isSetObject(options?.environment) ? options.environment : await this.#context.getEnvironment(options?.environment), hook, {
+      ...options,
+      sequential: true
+    }, ...args);
+  }
+  /**
+  * Calls the `"pre"` ordered hooks in sequence
+  *
+  * @param environment - The environment to use for the hook call
+  * @param hook - The hook to call
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callPreHook(environment, hook, ...args) {
+    return this.callHookSequential(hook, {
+      order: "pre",
+      environment
+    }, ...args);
+  }
+  /**
+  * Calls the `"post"` ordered hooks in sequence
+  *
+  * @param environment - The environment to use for the hook call
+  * @param hook - The hook to call
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callPostHook(environment, hook, ...args) {
+    return this.callHookSequential(hook, {
+      order: "post",
+      environment
+    }, ...args);
+  }
+  /**
+  * Calls a hook in sequence
+  *
+  * @param environment - The environment to use for the hook call
+  * @param hook - The hook to call
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callNormalHook(environment, hook, ...args) {
+    return this.callHookSequential(hook, {
+      order: "normal",
+      environment
+    }, ...args);
+  }
+  /**
+  * Calls the `"pre"` and `"post"` ordered hooks, as well as the normal hooks in sequence
+  *
+  * @param environment - The environment to use for the hook call
+  * @param hook - The hook to call
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callHook(environment, hook, ...args) {
+    return this.callHookSequential(hook, {
+      environment
+    }, ...args);
+  }
+  /**
+  * Dispose of the Powerlines API instance
+  *
+  * @remarks
+  * This method will finalize the Powerlines API instance, cleaning up any resources used.
+  */
+  async [Symbol.asyncDispose]() {
+    await this.finalize();
+  }
+  /**
+  * Get the configured environments
+  *
+  * @returns The configured environments
+  */
+  async #getEnvironments() {
+    if (!this.context.config.environments || Object.keys(this.context.config.environments).length <= 1) {
+      this.context.log(types.LogLevelLabel.DEBUG, "No environments are configured for this Powerlines project. Using the default environment.");
+      return [
+        await this.context.getEnvironment()
+      ];
+    }
+    this.context.log(types.LogLevelLabel.DEBUG, `Found ${Object.keys(this.context.config.environments).length} configured environment(s) for this Powerlines project.`);
+    return (await Promise.all(Object.entries(this.context.config.environments).map(async ([name, config]) => {
+      const environment = await this.context.getEnvironmentSafe(name);
+      if (!environment) {
+        const resolvedEnvironment = await this.callHookParallel("configEnvironment", {
+          environment: name
+        }, name, config);
+        if (resolvedEnvironment) {
+          this.context.environments[name] = await this.context.in(resolvedEnvironment);
+        }
+      }
+      return this.context.environments[name];
+    }))).filter((context) => isSet.isSet(context));
+  }
+  /**
+  * Execute a handler function for each environment
+  *
+  * @param handle - The handler function to execute for each environment
+  */
+  async #executeEnvironments(handle) {
+    await Promise.all((await this.#getEnvironments()).map(async (context) => {
+      return Promise.resolve(handle(context));
+    }));
+  }
+  /**
+  * Add a Powerlines plugin used in the build process
+  *
+  * @param config - The import path of the plugin to add
+  */
+  async #addPlugin(config) {
+    if (config) {
+      const plugin = await this.#initPlugin(config);
+      if (!plugin) {
+        return;
+      }
+      if (plugin.dependsOn) {
+        for (const required of plugin.dependsOn) {
+          await this.#addPlugin(required);
+        }
+      }
+      this.context.log(types.LogLevelLabel.DEBUG, `Successfully initialized the ${chalk2__default.default.bold.cyanBright(plugin.name)} plugin`);
+      await this.context.addPlugin(plugin);
+    }
+  }
+  /**
+  * Initialize a Powerlines plugin
+  *
+  * @param config - The configuration for the plugin
+  * @returns The initialized plugin instance, or null if the plugin was a duplicate
+  * @throws Will throw an error if the plugin cannot be found or is invalid
+  */
+  async #initPlugin(config) {
+    let awaited = config;
+    if (isPromise.isPromiseLike(config)) {
+      awaited = await Promise.resolve(config);
+    }
+    if (!chunkPYQADZVV_cjs.isPluginConfig(awaited)) {
+      throw new Error(`Invalid plugin specified in the configuration - ${JSON.stringify(awaited)}. Please ensure the value is a plugin name, an object with the \`plugin\` and \`props\` properties, or an instance of \`Plugin\`.`);
+    }
+    let plugin;
+    if (chunkPYQADZVV_cjs.isPlugin(awaited)) {
+      plugin = awaited;
+    } else if (isFunction.isFunction(awaited)) {
+      plugin = await Promise.resolve(awaited());
+    } else if (isSetString.isSetString(awaited)) {
+      const resolved = await this.#resolvePlugin(awaited);
+      if (isFunction.isFunction(resolved)) {
+        plugin = await Promise.resolve(resolved());
+      } else {
+        plugin = resolved;
+      }
+    } else if (chunkPYQADZVV_cjs.isPluginConfigTuple(awaited) || chunkPYQADZVV_cjs.isPluginConfigObject(awaited)) {
+      let pluginConfig;
+      let pluginOptions;
+      if (chunkPYQADZVV_cjs.isPluginConfigTuple(awaited)) {
+        pluginConfig = awaited[0];
+        pluginOptions = awaited?.length === 2 ? awaited[1] : void 0;
+      } else {
+        pluginConfig = awaited.plugin;
+        pluginOptions = awaited.options;
+      }
+      if (isSetString.isSetString(pluginConfig)) {
+        const resolved = await this.#resolvePlugin(pluginConfig);
+        if (isFunction.isFunction(resolved)) {
+          plugin = await Promise.resolve(pluginOptions ? resolved(pluginOptions) : resolved());
+        } else {
+          plugin = resolved;
+        }
+      } else if (isFunction.isFunction(pluginConfig)) {
+        plugin = await Promise.resolve(pluginConfig(pluginOptions));
+      } else if (chunkPYQADZVV_cjs.isPlugin(pluginConfig)) {
+        plugin = pluginConfig;
+      }
+    }
+    if (!plugin) {
+      throw new Error(`The plugin configuration ${JSON.stringify(awaited)} is invalid. This configuration must point to a valid Powerlines plugin module.`);
+    }
+    if (!chunkPYQADZVV_cjs.isPlugin(plugin)) {
+      throw new Error(`The plugin option ${JSON.stringify(plugin)} does not export a valid module. This configuration must point to a valid Powerlines plugin module.`);
+    }
+    if (chunkPYQADZVV_cjs.checkDedupe(plugin, this.context.plugins)) {
+      this.context.log(types.LogLevelLabel.TRACE, `Duplicate ${chalk2__default.default.bold.cyanBright(plugin.name)} plugin dependency detected - Skipping initialization.`);
+      return null;
+    }
+    this.context.log(types.LogLevelLabel.TRACE, `Initializing the ${chalk2__default.default.bold.cyanBright(plugin.name)} plugin...`);
+    return plugin;
+  }
+  async #resolvePlugin(pluginPath) {
+    if (pluginPath.startsWith("@") && pluginPath.split("/").filter(Boolean).length > 2) {
+      const splits = pluginPath.split("/").filter(Boolean);
+      pluginPath = `${splits[0]}/${splits[1]}`;
+    }
+    const isInstalled = packageFns.isPackageExists(pluginPath, {
+      paths: [
+        this.context.workspaceConfig.workspaceRoot,
+        this.context.config.projectRoot
+      ]
+    });
+    if (!isInstalled && this.context.config.skipInstalls !== true) {
+      this.#context.log(types.LogLevelLabel.WARN, `The plugin package "${pluginPath}" is not installed. It will be installed automatically.`);
+      const result = await install.install(pluginPath, {
+        cwd: this.context.config.projectRoot
+      });
+      if (isNumber.isNumber(result.exitCode) && result.exitCode > 0) {
+        this.#context.log(types.LogLevelLabel.ERROR, result.stderr);
+        throw new Error(`An error occurred while installing the build plugin package "${pluginPath}" `);
+      }
+    }
+    try {
+      const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(joinPaths.joinPaths(pluginPath, "plugin")));
+      const result = module.plugin ?? module.default;
+      if (!result) {
+        throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
+      }
+      return result;
+    } catch (error) {
+      try {
+        const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(pluginPath));
+        const result = module.plugin ?? module.default;
+        if (!result) {
+          throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
+        }
+        return result;
+      } catch {
+        if (!isInstalled) {
+          throw new Error(`The plugin package "${pluginPath}" is not installed. Please install the package using the command: "npm install ${pluginPath} --save-dev"`);
+        } else {
+          throw new Error(`An error occurred while importing the build plugin package "${pluginPath}":
+${isError.isError(error) ? error.message : String(error)}
+
+Note: Please ensure the plugin package's default export is a class that extends \`Plugin\` with a constructor that excepts a single arguments of type \`PluginOptions\`.`);
+        }
+      }
+    }
+  }
+};
+
+// src/lib/unplugin/factory.ts
+function createUnpluginFactory(variant, decorate) {
+  return (config, meta) => {
+    const log = chunkJA4HSQRN_cjs.createLog("unplugin", config);
+    log(types.LogLevelLabel.DEBUG, "Initializing Unplugin");
+    try {
+      const userConfig = {
+        ...config,
+        variant,
+        unplugin: meta
+      };
+      let api;
+      let resolvePatterns = [];
+      async function buildStart() {
+        log(types.LogLevelLabel.DEBUG, "Powerlines build plugin starting...");
+        const workspaceRoot = getWorkspaceRoot.getWorkspaceRoot(process.cwd());
+        api = await PowerlinesAPI.from(workspaceRoot, userConfig);
+        if (api.context.config.build.skipNodeModulesBundle) {
+          resolvePatterns = bundleRequire.tsconfigPathsToRegExp(api.context.tsconfig.options.paths ?? []);
+        }
+        log(types.LogLevelLabel.DEBUG, "Preparing build artifacts for the Powerlines project...");
+        await api.prepare({
+          command: "build"
+        });
+      }
+      chunkUSNT2KNT_cjs.__name(buildStart, "buildStart");
+      async function resolveId(id, importer, options = {
+        isEntry: false
+      }) {
+        return chunkZBDVQVUK_cjs.handleResolveId(api.context, {
+          id,
+          importer,
+          options
+        }, {
+          skipNodeModulesBundle: api.context.config.build.skipNodeModulesBundle,
+          external: api.context.config.build.external,
+          noExternal: api.context.config.build.noExternal,
+          resolvePatterns
+        });
+      }
+      chunkUSNT2KNT_cjs.__name(resolveId, "resolveId");
+      async function load(id) {
+        const environment = await api.context.getEnvironment();
+        if (id) {
+          const resolvedPath = environment.fs.resolve(id);
+          if (resolvedPath) {
+            return environment.fs.readFile(resolvedPath);
+          }
+        }
+        let result2 = await api.callPreHook(environment, "load", id);
+        if (result2) {
+          return result2;
+        }
+        result2 = await api.callNormalHook(environment, "load", id);
+        if (result2) {
+          return result2;
+        }
+        return api.callPostHook(environment, "load", id);
+      }
+      chunkUSNT2KNT_cjs.__name(load, "load");
+      async function transform(code, id) {
+        const environment = await api.context.getEnvironment();
+        let transformed = code;
+        let result2 = await api.callPreHook(environment, "transform", chunk3OCI4TH7_cjs.getString(transformed), id);
+        if (result2) {
+          transformed = result2;
+        }
+        result2 = await api.callNormalHook(environment, "transform", chunk3OCI4TH7_cjs.getString(transformed), id);
+        if (result2) {
+          transformed = result2;
+        }
+        result2 = await api.callPostHook(environment, "transform", chunk3OCI4TH7_cjs.getString(transformed), id);
+        if (result2) {
+          transformed = result2;
+        }
+        return transformed;
+      }
+      chunkUSNT2KNT_cjs.__name(transform, "transform");
+      async function writeBundle() {
+        log(types.LogLevelLabel.DEBUG, "Finalizing Powerlines project output...");
+        const environment = await api.context.getEnvironment();
+        await api.callHook(environment, "writeBundle");
+      }
+      chunkUSNT2KNT_cjs.__name(writeBundle, "writeBundle");
+      const result = {
+        name: "powerlines",
+        api,
+        resolveId: {
+          filter: {
+            id: {
+              include: [
+                /.*/
+              ]
+            }
+          },
+          handler: resolveId
+        },
+        load: {
+          filter: {
+            id: {
+              include: [
+                /.*/,
+                /^storm:/
+              ]
+            }
+          },
+          handler: load
+        },
+        transform,
+        buildStart,
+        writeBundle
+      };
+      return decorate ? decorate(api, result) : result;
+    } catch (error) {
+      log(types.LogLevelLabel.FATAL, error?.message);
+      throw error;
+    }
+  };
+}
+chunkUSNT2KNT_cjs.__name(createUnpluginFactory, "createUnpluginFactory");
+
+exports.createUnpluginFactory = createUnpluginFactory;