@keq-request/cli 5.0.0-alpha.29 → 5.0.0-alpha.31

package/dist/chunk-JX74ZR2O.cjs

@@ -0,0 +1,670 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkOC36G3PFcjs = require('./chunk-OC36G3PF.cjs');
+
+
+
+
+
+
+
+
+var _chunk7HHTHYRAcjs = require('./chunk-7HHTHYRA.cjs');
+
+// src/compiler/compiler.ts
+var _listr2 = require('listr2');
+var _tapable = require('tapable');
+
+// src/compiler/tasks/setup/index.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _path = require('path'); var path3 = _interopRequireWildcard(_path);
+var _cosmiconfig = require('cosmiconfig');
+
+// src/utils/ignore-matcher.ts
+var _ramda = require('ramda'); var R = _interopRequireWildcard(_ramda); var R2 = _interopRequireWildcard(_ramda); var R3 = _interopRequireWildcard(_ramda);
+
+var IgnoreMatcher = class _IgnoreMatcher {
+  
+  constructor(rules) {
+    this.rules = rules;
+  }
+  static async read(filepath) {
+    let content = await _fsextra2.default.readFile(filepath, "utf-8");
+    content = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/#.*$/gm, "").replace(/\n+/g, "\n").trim();
+    let rules = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+      const matched = line.match(/^(!)?\s*([^\s/]+)\s+([^\s/]+)\s+([^\s]+)$/);
+      if (!matched) throw new Error(`Invalid ignore rule: "${line}"`);
+      const [, flag, moduleName, operationMethod, operationPathname] = matched;
+      return {
+        persist: true,
+        ignore: !flag,
+        moduleName,
+        operationMethod: operationMethod.toLowerCase(),
+        operationPathname
+      };
+    });
+    rules = R.sortBy(
+      R.prop("ignore"),
+      rules
+    );
+    rules = R.uniqWith(
+      (a, b) => a.moduleName === b.moduleName && a.operationMethod === b.operationMethod && a.operationPathname === b.operationPathname,
+      rules
+    );
+    return new _IgnoreMatcher(rules);
+  }
+  async write(filepath) {
+    const ruleGroups = R.compose(
+      R.groupBy((rule) => rule.moduleName),
+      R.reverse,
+      R.uniqWith(
+        (a, b) => a.moduleName === b.moduleName && a.operationMethod === b.operationMethod && a.operationPathname === b.operationPathname
+      ),
+      R.filter((rule) => rule.persist)
+    )(this.rules);
+    const content = Object.entries(ruleGroups).sort((a, b) => {
+      const aModuleName = a[0];
+      const bModuleName = b[0];
+      if (aModuleName === "*") return -1;
+      if (bModuleName === "*") return 1;
+      return aModuleName.localeCompare(bModuleName);
+    }).map(([, rules]) => (rules || []).sort((a, b) => {
+      if (a.ignore !== b.ignore) return a.ignore ? -1 : 1;
+      if (a.operationMethod === "*") return -1;
+      if (b.operationMethod === "*") return 1;
+      if (a.operationPathname === "*") return -1;
+      if (b.operationPathname === "*") return 1;
+      if (a.operationMethod !== b.operationMethod) return a.operationMethod.localeCompare(b.operationMethod);
+      if (a.operationPathname !== b.operationPathname) return a.operationPathname.localeCompare(b.operationPathname);
+      return 0;
+    }).map((rule) => `${rule.ignore ? "" : "! "}${rule.moduleName} ${rule.operationMethod.toUpperCase()} ${rule.operationPathname}`).join("\n")).join("\n\n");
+    await _fsextra2.default.writeFile(filepath, content, "utf-8");
+  }
+  append(rule) {
+    this.rules.unshift(rule);
+  }
+  // if operation is ignored, return true
+  isOperationIgnored(operationDefinition) {
+    const moduleName = operationDefinition.module.name;
+    const operationMethod = operationDefinition.method.toLowerCase();
+    const operationPathname = operationDefinition.pathname;
+    for (const rule of this.rules) {
+      if (rule.moduleName !== "*" && rule.moduleName !== moduleName) continue;
+      if (rule.operationMethod !== "*" && rule.operationMethod !== operationMethod) continue;
+      if (rule.operationPathname !== "*" && rule.operationPathname !== operationPathname) continue;
+      return rule.ignore;
+    }
+    return false;
+  }
+  isModuleIgnored(moduleDefinition) {
+    const moduleName = moduleDefinition.name;
+    for (const rule of this.rules) {
+      if (!rule.ignore) {
+        if (rule.moduleName === "*" || rule.moduleName === moduleName) return false;
+        continue;
+      }
+      if (rule.operationMethod !== "*") continue;
+      if (rule.operationPathname !== "*") continue;
+      if (rule.moduleName === "*" || rule.moduleName === moduleName) return true;
+    }
+    return false;
+  }
+};
+
+// src/compiler/tasks/setup/utils/find-nearest-package-json.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+
+function findNearestPackageJson(startDir = process.cwd()) {
+  let dir = startDir;
+  while (true) {
+    const pkgPath = path3.default.join(dir, "package.json");
+    if (_fs2.default.existsSync(pkgPath)) {
+      const json = JSON.parse(_fs2.default.readFileSync(pkgPath, "utf8"));
+      return { json, path: pkgPath };
+    }
+    const parent = path3.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/compiler/tasks/setup/utils/get-project-module-system.ts
+function getProjectModuleSystem(pkgInfo) {
+  if (!_optionalChain([pkgInfo, 'optionalAccess', _2 => _2.json])) return "cjs";
+  const { json } = pkgInfo;
+  if (json.type === "module") return "esm";
+  return "cjs";
+}
+
+// src/compiler/tasks/setup/utils/parse-runtime-config.ts
+var _value = require('@sinclair/typebox/value');
+
+// src/types/address.ts
+var _typebox = require('@sinclair/typebox');
+var Address = _typebox.Type.Object({
+  url: _typebox.Type.String(),
+  headers: _typebox.Type.Optional(_typebox.Type.Record(_typebox.Type.String(), _typebox.Type.String(), { default: {} })),
+  encoding: _typebox.Type.Optional(
+    _typebox.Type.Union([
+      _typebox.Type.Literal("utf8"),
+      _typebox.Type.Literal("ascii")
+    ], { default: "utf8" })
+  )
+});
+
+// src/types/runtime-config.ts
+
+
+
+// src/utils/is-valid-url.ts
+var URL_REGEX = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/(?:[^\s@]+@)?[^\s/:?#]*(?::\d+)?(?:\/[^\s?#]*)?(?:\?[^\s#]*)?(?:#[^\s]*)?$/;
+function isValidURL(url) {
+  return URL_REGEX.test(url);
+}
+
+// src/types/runtime-config.ts
+var Modules = _typebox.Type.Transform(
+  _typebox.Type.Record(
+    _typebox.Type.String(),
+    _typebox.Type.Union([_typebox.Type.String(), Address])
+  )
+).Decode((value) => {
+  const keys = Object.keys(value);
+  for (const key of keys) {
+    if (!/^[A-Za-z_][A-Za-z0-9_$]*$/.test(key)) {
+      throw new Error(`Module name "${key}" is not valid. It must start with a letter or underscore, and can only contain letters, numbers, and underscores.`);
+    }
+  }
+  const keysGroupByLowerCase = R2.groupBy(R2.toLower, keys);
+  for (const groupKey in keysGroupByLowerCase) {
+    const keys2 = keysGroupByLowerCase[groupKey] || [];
+    if (keys2.length > 1) {
+      throw new Error(`Module names ${keys2.map((name) => `"${name}"`).join(", ")} are case-insensitively duplicated.`);
+    }
+  }
+  for (const key in value) {
+    const url = typeof value[key] === "string" ? value[key] : value[key].url;
+    if (isValidURL(url)) continue;
+    throw new Error(`The ${JSON.stringify(url)} of module "${key}" is not a valid URL.`);
+  }
+  return R2.map(
+    (item) => typeof item !== "string" ? item : { url: item, headers: {}, encoding: "utf8" },
+    value
+  );
+}).Encode((value) => value);
+var RawConfig = _typebox.Type.Object({
+  /**
+   * Whether to generate ES Module code
+   *
+   * If not specified, the module system will be inferred from the nearest package.json "type" field
+   * or defaults to "cjs" if no package.json is found.
+   */
+  esm: _typebox.Type.Optional(_typebox.Type.Boolean({ default: false })),
+  /**
+   * Output directory for generated files
+   */
+  outdir: _typebox.Type.String({ default: `${process.cwd()}/api` }),
+  /**
+   * File naming style for generated files
+   */
+  fileNamingStyle: _typebox.Type.Enum(_chunk7HHTHYRAcjs.FileNamingStyle, { default: "snakeCase" /* snakeCase */ }),
+  /**
+   * OpenAPI/Swagger document sources
+   *
+   * A map of module names to their document URLs or Address objects.
+   * The module name must be a valid JavaScript identifier.
+   */
+  modules: Modules,
+  /**
+   * Enable debug mode to output detailed logs during compilation
+   */
+  debug: _typebox.Type.Optional(_typebox.Type.Boolean({ default: false })),
+  /**
+   * Whether to tolerate wrong openapi/swagger structure
+   */
+  tolerant: _typebox.Type.Optional(_typebox.Type.Boolean({ default: false })),
+  /**
+   * Translators to transform generated code
+   *
+   * Used to customize the code generation process for different frameworks or patterns.
+   * Can be a single translator or an array of translators.
+   */
+  translators: _typebox.Type.Optional(
+    _typebox.Type.Transform(
+      _typebox.Type.Union([
+        _typebox.Type.Unsafe(_typebox.Type.Any()),
+        _typebox.Type.Array(_typebox.Type.Unsafe(_typebox.Type.Any()))
+      ], { default: [] })
+    ).Decode((value) => {
+      if (value === void 0) return [];
+      if (Array.isArray(value)) return value;
+      return [value];
+    }).Encode((value) => value)
+  ),
+  /**
+   * Plugins to extend code generation functionality
+   *
+   * An array of plugin instances that can hook into various stages of the compilation process,
+   * such as code transformation, formatting, linting, or custom file generation.
+   */
+  plugins: _typebox.Type.Optional(_typebox.Type.Array(_typebox.Type.Unsafe(_typebox.Type.Any()), { default: [] }))
+});
+
+// src/compiler/tasks/setup/utils/parse-runtime-config.ts
+function parseRuntimeConfig(data) {
+  try {
+    const originalPlugins = typeof data === "object" && data !== null && "plugins" in data ? data.plugins : void 0;
+    const originTranslators = typeof data === "object" && data !== null && "translators" in data ? data.translators : void 0;
+    const parsed = _value.Value.Parse(RawConfig, data);
+    if (originalPlugins !== void 0) {
+      parsed.plugins = originalPlugins;
+    }
+    if (originTranslators !== void 0) {
+      parsed.translators = originTranslators;
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error) {
+      error.message = `Invalid Config: ${error.message}`;
+    }
+    throw error;
+  }
+}
+
+// src/compiler/tasks/setup/index.ts
+var explore = _cosmiconfig.cosmiconfig.call(void 0, "keq");
+function main(compiler, options) {
+  return {
+    task: async (context, task) => {
+      const result = _optionalChain([options, 'optionalAccess', _3 => _3.config]) ? await explore.load(options.config) : await explore.search();
+      if (!result || "isEmpty" in result && result.isEmpty) {
+        throw new Error("Cannot find config file.");
+      }
+      const rc = parseRuntimeConfig(result.config);
+      if (_optionalChain([options, 'optionalAccess', _4 => _4.debug])) {
+        await _fsextra2.default.ensureDir(".keq");
+        rc.debug = true;
+      }
+      rc.tolerant = Boolean(rc.tolerant);
+      if (!rc.translators || !rc.translators.length) {
+        rc.translators = [new (0, _chunkOC36G3PFcjs.MicroFunctionTranslator)()];
+      }
+      const packageJsonInfo = findNearestPackageJson();
+      if (packageJsonInfo) {
+        const moduleSystem = getProjectModuleSystem(packageJsonInfo);
+        rc.esm = moduleSystem === "esm";
+      }
+      context.rc = rc;
+      let matcher = new IgnoreMatcher([]);
+      if (result.filepath) {
+        const ignoreFilepath = path3.default.resolve(path3.default.dirname(result.filepath), ".keqignore");
+        if (await _fsextra2.default.exists(ignoreFilepath)) {
+          matcher = await IgnoreMatcher.read(ignoreFilepath);
+        }
+      }
+      const ignoreRules = options.ignore === false ? [] : _optionalChain([options, 'access', _5 => _5.ignore, 'optionalAccess', _6 => _6.rules]) || [];
+      for (const rule of ignoreRules) {
+        matcher.append({
+          persist: !!rule.persist,
+          ignore: rule.ignore,
+          moduleName: rule.moduleName,
+          operationMethod: rule.operationMethod,
+          operationPathname: rule.operationPathname
+        });
+      }
+      context.matcher = matcher;
+      await compiler.hooks.setup.promise(task);
+    }
+  };
+}
+function createSetupTask(compiler, options) {
+  return {
+    title: "Setup",
+    enabled: _optionalChain([options, 'optionalAccess', _7 => _7.enabled]),
+    skip: _optionalChain([options, 'optionalAccess', _8 => _8.skip]),
+    task: (context, task) => task.newListr(
+      [
+        main(compiler, options),
+        {
+          task: (context2, task2) => compiler.hooks.afterSetup.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
+
+// src/compiler/tasks/download/index.ts
+
+var _openapiparser = require('@scalar/openapi-parser');
+function main2(compiler, options) {
+  return {
+    task: (context, task) => {
+      if (!context.rc || !context.matcher) {
+        throw new Error("Please run setup task first.");
+      }
+      const rc = context.rc;
+      const matcher = context.matcher;
+      context.documents = [];
+      return task.newListr(
+        Object.entries(rc.modules).map(([moduleName, address]) => new (0, _chunk7HHTHYRAcjs.ModuleDefinition)(moduleName, address)).map((moduleDefinition) => ({
+          title: moduleDefinition.name,
+          task: async (ctx, task2) => {
+            if (_optionalChain([options, 'optionalAccess', _9 => _9.skipIgnoredModules]) && matcher.isModuleIgnored(moduleDefinition)) {
+              task2.skip(`(${moduleDefinition.name}) is ignored`);
+              return;
+            }
+            task2.output = `Downloaded from ${moduleDefinition.address.url}`;
+            const content = await compiler.hooks.download.promise(moduleDefinition.address, moduleDefinition, task2);
+            if (!content) {
+              throw new (0, _chunk7HHTHYRAcjs.Exception)(moduleDefinition, `Cannot download document from ${moduleDefinition.address.url}`);
+            }
+            const spec = JSON.parse(content);
+            const { valid, errors } = await _openapiparser.validate.call(void 0, spec);
+            if (!valid) {
+              const message = `${moduleDefinition.name} module openapi/swagger file does not conform to the openapi specifications or have grammatical errors, which may cause unexpected errors: 
+${_optionalChain([errors, 'optionalAccess', _10 => _10.map, 'call', _11 => _11((e) => `  - ${e.message}`), 'access', _12 => _12.join, 'call', _13 => _13("\n")])}`;
+              task2.output = message;
+            }
+            _chunk7HHTHYRAcjs.OpenapiUtils.dereferenceOperation(spec);
+            const document = new (0, _chunk7HHTHYRAcjs.ApiDocumentV3_1)(
+              spec,
+              moduleDefinition
+            );
+            _optionalChain([ctx, 'access', _14 => _14.documents, 'optionalAccess', _15 => _15.push, 'call', _16 => _16(document)]);
+          }
+        })),
+        {
+          concurrent: true,
+          exitOnError: false,
+          collectErrors: "minimal",
+          rendererOptions: {
+            collapseSubtasks: false,
+            // collapseSkips: false,
+            suffixSkips: true,
+            timer: _listr2.PRESET_TIMER
+          }
+        }
+      );
+    }
+  };
+}
+function createDownloadTask(compiler, options) {
+  return {
+    title: "Download",
+    enabled: _optionalChain([options, 'optionalAccess', _17 => _17.enabled]),
+    skip: _optionalChain([options, 'optionalAccess', _18 => _18.skip]),
+    task: (_, task) => task.newListr(
+      [
+        main2(compiler, options),
+        {
+          task: (context, task2) => compiler.hooks.afterDownload.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
+
+// src/compiler/tasks/persist/index.ts
+
+
+function createPersistArtifactTask() {
+  return {
+    title: "Write files",
+    task: async (context, task) => {
+      if (!context.rc) throw new Error("Please run setup task first.");
+      if (!context.artifacts || context.artifacts.length === 0) {
+        task.skip("No compiled artifacts to persist.");
+        return;
+      }
+      const rc = context.rc;
+      const artifacts = context.artifacts;
+      const total = artifacts.length;
+      let completed = 0;
+      const files = await Promise.all(artifacts.map(async (artifact) => {
+        const realpath = `./${path3.join(rc.outdir, artifact.filepath)}`;
+        await _fsextra2.default.ensureFile(realpath);
+        await _fsextra2.default.writeFile(realpath, artifact.renderer());
+        completed += 1;
+        task.output = `Persisted ${completed}/${total} files`;
+        return new (0, _chunk7HHTHYRAcjs.Asset)(path3.resolve(realpath));
+      }));
+      context.assets = files;
+    }
+  };
+}
+function createPersistIgnoreTask() {
+  return {
+    title: "Update .keqignore",
+    task: async (context, task) => {
+      if (!context.matcher) throw new Error("Please run setup task first.");
+      const matcher = context.matcher;
+      await matcher.write(".keqignore");
+    }
+  };
+}
+function main3() {
+  return {
+    task: (context, task) => task.newListr(
+      [
+        createPersistArtifactTask(),
+        createPersistIgnoreTask()
+      ],
+      {
+        concurrent: true,
+        rendererOptions: {
+          collapseSubtasks: true
+        }
+      }
+    )
+  };
+}
+function createPersistTask(compiler, options) {
+  return {
+    title: "Persist",
+    enabled: _optionalChain([options, 'optionalAccess', _19 => _19.enabled]),
+    skip: _optionalChain([options, 'optionalAccess', _20 => _20.skip]),
+    task: (context, task) => task.newListr(
+      [
+        main3(),
+        {
+          task: (context2, task2) => compiler.hooks.afterPersist.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
+
+// src/compiler/tasks/compile/index.ts
+function main4(compiler) {
+  return {
+    task: async (context, task) => {
+      if (!context.rc) throw new Error("Please run setup task first.");
+      if (!context.documents) throw new Error("Please run shaking task first.");
+      context.artifacts = [];
+      await compiler.hooks.compile.promise(task);
+    }
+  };
+}
+function createCompileTask(compiler, options) {
+  return {
+    title: "Compile",
+    enabled: _optionalChain([options, 'optionalAccess', _21 => _21.enabled]),
+    skip: _optionalChain([options, 'optionalAccess', _22 => _22.skip]),
+    task: (context, task) => task.newListr(
+      [
+        {
+          task: (context2, task2) => compiler.hooks.beforeCompile.promise(task2)
+        },
+        main4(compiler),
+        {
+          task: (context2, task2) => compiler.hooks.afterCompile.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
+
+// src/compiler/intercepter/print-information.ts
+function proxyTaskWrapper(pluginName, task) {
+  return new Proxy(task, {
+    set(target, prop2, value) {
+      if (prop2 !== "output") {
+        return Reflect.set(target, prop2, value);
+      }
+      target.output = `[Plugin: ${pluginName}] ${value}`;
+      return true;
+    }
+  });
+}
+function printInformation(taskIndex) {
+  return {
+    register: (tap) => {
+      const fn = tap.fn;
+      if (tap.type === "promise") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
+      }
+      if (tap.type === "sync") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
+      }
+      if (tap.type === "async") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
+      }
+      return tap;
+    }
+  };
+}
+
+// src/compiler/intercepter/perfect-error-message.ts
+
+function perfectErrorMessage() {
+  return {
+    register: (tap) => {
+      const fn = tap.fn;
+      function prefix(err) {
+        if (err instanceof Error) {
+          err.message = `[Plugin: ${tap.name}] ${err.message}`;
+        }
+      }
+      if (tap.type === "promise") {
+        tap.fn = async (...args) => {
+          try {
+            return await fn(...args);
+          } catch (err) {
+            prefix(err);
+            throw err;
+          }
+        };
+      }
+      if (tap.type === "sync") {
+        tap.fn = (...args) => {
+          try {
+            return fn(...args);
+          } catch (err) {
+            prefix(err);
+            throw err;
+          }
+        };
+      }
+      if (tap.type === "async") {
+        tap.fn = (...args) => {
+          const callback = R3.last(args);
+          return fn(...R3.init(args), (err, result) => {
+            prefix(err);
+            return callback(err, result);
+          });
+        };
+      }
+      return tap;
+    }
+  };
+}
+
+// src/compiler/compiler.ts
+var Compiler = (_class = class {
+  constructor(options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.options = options;
+    for (const hook of Object.values(this.hooks)) {
+      hook.intercept(perfectErrorMessage());
+    }
+    this.hooks.afterSetup.intercept(printInformation(0));
+    this.hooks.afterPersist.intercept(printInformation(0));
+    new (0, _chunk7HHTHYRAcjs.InitializePlugin)({
+      build: options.build,
+      interactive: options.interactive,
+      includes: options.includes
+    }).apply(this);
+  }
+  __init() {this.context = {}}
+  __init2() {this.hooks = {
+    setup: new (0, _tapable.AsyncParallelHook)(["task"]),
+    afterSetup: new (0, _tapable.AsyncSeriesHook)(["task"]),
+    beforeDownload: new (0, _tapable.AsyncSeriesHook)(["task"]),
+    download: new (0, _tapable.AsyncSeriesBailHook)(["address", "moduleDefinition", "task"]),
+    afterDownload: new (0, _tapable.AsyncSeriesHook)(["task"]),
+    beforeCompile: new (0, _tapable.AsyncSeriesHook)(["task"]),
+    compile: new (0, _tapable.AsyncParallelHook)(["task"]),
+    afterCompile: new (0, _tapable.AsyncSeriesHook)(["task"]),
+    beforePersist: new (0, _tapable.AsyncSeriesHook)(["task"]),
+    persist: new (0, _tapable.AsyncParallelHook)(["task"]),
+    afterPersist: new (0, _tapable.AsyncSeriesHook)(["task"]),
+    done: new (0, _tapable.SyncHook)()
+  }}
+  async run() {
+    const options = this.options;
+    const tasks = new (0, _listr2.Listr)(
+      [
+        createSetupTask(this, options),
+        createDownloadTask(this, { skipIgnoredModules: !options.interactive }),
+        createCompileTask(this, { enabled: !!options.build }),
+        createPersistTask(this, { enabled: !!options.persist })
+      ],
+      {
+        concurrent: false,
+        renderer: options.silent ? "silent" : "default",
+        rendererOptions: {
+          suffixSkips: true,
+          collapseSubtasks: false,
+          collapseErrors: false
+        }
+      }
+    );
+    await tasks.run(this.context);
+    await this.hooks.done.promise();
+  }
+}, _class);
+
+
+
+exports.Compiler = Compiler;
+//# sourceMappingURL=chunk-JX74ZR2O.cjs.map