@modern-js/module-tools 2.35.1 → 2.36.0

package/dist/builder/esbuild/adapter.js

@@ -0,0 +1,275 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var adapter_exports = {};
+__export(adapter_exports, {
+  adapterPlugin: () => adapterPlugin
+});
+module.exports = __toCommonJS(adapter_exports);
+var import_path = require("path");
+var import_module = __toESM(require("module"));
+var import_picomatch = __toESM(require("picomatch"));
+var import_utils = require("@modern-js/utils");
+var import_pluginutils = require("@rollup/pluginutils");
+var import_utils2 = require("../../utils");
+var import_loader = require("../../constants/loader");
+var import_debug = require("../../debug");
+var import_write_file = require("./write-file");
+const globalNamespace = "globals";
+const HTTP_PATTERNS = /^(https?:)?\/\//;
+const DATAURL_PATTERNS = /^data:/;
+const HASH_PATTERNS = /#[^#]+$/;
+const DATAURL_JAVASCRIPT_PATTERNS = /^data:text\/javascript/;
+const adapterPlugin = (compiler) => {
+  const { context } = compiler;
+  const { config, root } = context;
+  return {
+    name: "esbuild:adapter",
+    setup(build) {
+      build.onStart(async () => {
+        compiler.outputChunk = /* @__PURE__ */ new Map();
+      });
+      build.onResolve({
+        filter: /.*/
+      }, async (args) => {
+        if (args.kind === "url-token") {
+          return {
+            path: args.path,
+            external: true
+          };
+        }
+        for (const [key] of Object.entries(config.umdGlobals)) {
+          const isMatch = (0, import_picomatch.default)(key);
+          if (isMatch(args.path)) {
+            (0, import_debug.debugResolve)("resolve umdGlobals:", key);
+            return {
+              path: args.path,
+              namespace: globalNamespace
+            };
+          }
+        }
+        if (/^node:/.test(args.path)) {
+          return {
+            path: args.path.slice(5),
+            external: true
+          };
+        }
+        if (DATAURL_JAVASCRIPT_PATTERNS.test(args.path)) {
+          return {
+            path: args.path,
+            namespace: "dataurl"
+          };
+        }
+        const isUrl = (source) => HTTP_PATTERNS.test(source) || DATAURL_PATTERNS.test(source) || HASH_PATTERNS.test(source);
+        if (isUrl(args.path)) {
+          return {
+            path: args.path,
+            external: true
+          };
+        }
+        const { externals, sideEffects: userSideEffects } = config;
+        const regExternal = externals.filter((item) => !(0, import_utils.isString)(item));
+        const externalList = externals.filter(import_utils.isString).concat(config.platform === "node" ? import_module.default.builtinModules : []);
+        const externalMap = externalList.reduce((map, item) => {
+          map.set(item, true);
+          return map;
+        }, /* @__PURE__ */ new Map());
+        const getIsExternal = (name) => {
+          if (externalMap.get(name)) {
+            return true;
+          }
+          if (regExternal.some((reg) => reg.test(name))) {
+            return true;
+          }
+          return false;
+        };
+        const getSideEffects = async (filePath, isExternal2) => {
+          let pkgPath = "";
+          let sideEffects2 = userSideEffects;
+          let moduleSideEffects = true;
+          if (typeof userSideEffects === "undefined") {
+            let curDir = (0, import_path.dirname)(filePath);
+            try {
+              while (curDir !== (0, import_path.dirname)(curDir)) {
+                if (import_utils.fs.existsSync((0, import_path.resolve)(curDir, "package.json"))) {
+                  pkgPath = (0, import_path.resolve)(curDir, "package.json");
+                  break;
+                }
+                curDir = (0, import_path.dirname)(curDir);
+              }
+              sideEffects2 = JSON.parse(import_utils.fs.readFileSync(pkgPath, "utf-8")).sideEffects;
+            } catch (err) {
+            }
+            if (!pkgPath) {
+              return void 0;
+            }
+          }
+          if (typeof sideEffects2 === "boolean") {
+            moduleSideEffects = sideEffects2;
+          } else if (Array.isArray(sideEffects2)) {
+            moduleSideEffects = (0, import_pluginutils.createFilter)(sideEffects2.map((glob) => {
+              if (typeof glob === "string") {
+                if (!glob.includes("/")) {
+                  return `**/${glob}`;
+                }
+              }
+              return glob;
+            }), null, pkgPath ? {
+              resolve: (0, import_path.dirname)(pkgPath)
+            } : void 0)(filePath);
+          } else if (typeof sideEffects2 === "function") {
+            moduleSideEffects = sideEffects2(filePath, isExternal2);
+          }
+          return moduleSideEffects;
+        };
+        const getResultPath = (id, dir2, kind) => {
+          return id.endsWith(".css") ? compiler.css_resolve(id, dir2) : compiler.node_resolve(id, dir2, kind);
+        };
+        const { originalFilePath, rawQuery } = (0, import_utils2.resolvePathAndQuery)(args.path);
+        const suffix = (rawQuery !== null && rawQuery !== void 0 ? rawQuery : "").length > 0 ? `?${rawQuery}` : "";
+        const isExternal = getIsExternal(originalFilePath);
+        var _args_resolveDir;
+        const dir = (_args_resolveDir = args.resolveDir) !== null && _args_resolveDir !== void 0 ? _args_resolveDir : args.importer ? (0, import_path.dirname)(args.importer) : root;
+        const sideEffects = await getSideEffects(originalFilePath, isExternal);
+        const result = {
+          path: isExternal ? args.path : getResultPath(originalFilePath, dir, args.kind),
+          external: isExternal,
+          namespace: isExternal ? void 0 : "file",
+          sideEffects,
+          suffix
+        };
+        (0, import_debug.debugResolve)("onResolve args:", args);
+        (0, import_debug.debugResolve)("onResolve result:", result);
+        return result;
+      });
+      build.onLoad({
+        filter: /.*/
+      }, async (args) => {
+        if (args.namespace === globalNamespace) {
+          const value = config.umdGlobals[args.path];
+          return {
+            contents: `module.exports = (typeof globalThis !== "undefined" ? globalThis : Function('return this')() || global || self)[${JSON.stringify(value)}]`
+          };
+        }
+        if (args.suffix) {
+          args.path += args.suffix;
+        }
+        if (args.namespace !== "file") {
+          return;
+        }
+        compiler.addWatchFile(args.path);
+        let result = await compiler.hooks.load.promise(args);
+        if (!result) {
+          if (DATAURL_JAVASCRIPT_PATTERNS.test(args.path)) {
+            return;
+          }
+          result = {
+            contents: await import_utils.fs.promises.readFile(args.path)
+          };
+        }
+        if (!result.contents || result.loader === "copy") {
+          return result;
+        }
+        const context2 = compiler.getTransformContext(args.path);
+        context2.addSourceMap(context2.genPluginId("adapter"), result.map);
+        const transformResult = await compiler.hooks.transform.promise({
+          code: result.contents.toString(),
+          path: args.path,
+          loader: result.loader
+        });
+        const ext = (0, import_path.extname)(args.path);
+        var _transformResult_loader;
+        const loader = (_transformResult_loader = transformResult.loader) !== null && _transformResult_loader !== void 0 ? _transformResult_loader : import_loader.loaderMap[ext];
+        const inlineSourceMap = context2.getInlineSourceMap();
+        var _result_resolveDir;
+        return {
+          contents: transformResult.code + inlineSourceMap,
+          loader,
+          resolveDir: (_result_resolveDir = result.resolveDir) !== null && _result_resolveDir !== void 0 ? _result_resolveDir : (0, import_path.dirname)(args.path)
+        };
+      });
+      build.onEnd(async (result) => {
+        if (result.errors.length) {
+          return;
+        }
+        const { outputs } = result.metafile;
+        const needSourceMap = Boolean(config.sourceMap);
+        for (const [key, value] of Object.entries(outputs)) {
+          var _result_outputFiles, _result_outputFiles1;
+          if (key.endsWith(".map")) {
+            continue;
+          }
+          const absPath = (0, import_path.resolve)(root, key);
+          const item = (_result_outputFiles = result.outputFiles) === null || _result_outputFiles === void 0 ? void 0 : _result_outputFiles.find((x) => x.path === absPath);
+          const mapping = (_result_outputFiles1 = result.outputFiles) === null || _result_outputFiles1 === void 0 ? void 0 : _result_outputFiles1.find((x) => x.path.endsWith(".map") && x.path.replace(/\.map$/, "") === absPath);
+          if (!item) {
+            continue;
+          }
+          if (absPath.endsWith(".js")) {
+            compiler.emitAsset(absPath, {
+              type: "chunk",
+              contents: item.text,
+              map: (0, import_utils2.normalizeSourceMap)(mapping === null || mapping === void 0 ? void 0 : mapping.text, {
+                needSourceMap
+              }),
+              fileName: absPath,
+              entryPoint: value === null || value === void 0 ? void 0 : value.entryPoint
+            });
+          } else {
+            compiler.emitAsset(absPath, {
+              type: "asset",
+              contents: Buffer.from(item.contents),
+              fileName: absPath,
+              entryPoint: value === null || value === void 0 ? void 0 : value.entryPoint
+            });
+          }
+        }
+        for (const [key, value] of compiler.outputChunk.entries()) {
+          const context2 = compiler.getSourcemapContext(value.fileName);
+          if (value.type === "chunk" && config.sourceMap) {
+            context2.addSourceMap(context2.genPluginId("adapter"), value.map);
+          }
+          const processedResult = await compiler.hooks.renderChunk.promise(value);
+          if (processedResult.type === "chunk" && config.sourceMap) {
+            processedResult.map = context2.getSourceMap();
+          }
+          compiler.outputChunk.set(key, processedResult);
+        }
+        if (config.metafile) {
+          const now = Date.now();
+          compiler.emitAsset((0, import_path.resolve)(config.outDir, `metafile-${now}.json`), JSON.stringify(result.metafile, null, 2));
+        }
+        await (0, import_write_file.writeFile)(compiler);
+      });
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  adapterPlugin
+});

package/dist/builder/esbuild/hook.d.ts

@@ -0,0 +1,4 @@
+import * as tapable from 'tapable';
+import { Source, Chunk, ICompiler } from '../../types';
+export declare function createTransformHook(compiler: ICompiler): tapable.AsyncSeriesWaterfallHook<Source, tapable.UnsetAdditionalOptions>;
+export declare function createRenderChunkHook(compiler: ICompiler): tapable.AsyncSeriesWaterfallHook<Chunk, tapable.UnsetAdditionalOptions>;

package/dist/builder/esbuild/hook.js

@@ -0,0 +1,103 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hook_exports = {};
+__export(hook_exports, {
+  createRenderChunkHook: () => createRenderChunkHook,
+  createTransformHook: () => createTransformHook
+});
+module.exports = __toCommonJS(hook_exports);
+var import_util = require("util");
+var tapable = __toESM(require("tapable"));
+function createTransformHook(compiler) {
+  const hook = new tapable.AsyncSeriesWaterfallHook([
+    "args"
+  ]);
+  if (!compiler.config.transformCache) {
+    return hook;
+  }
+  const originTapPromise = hook.tapPromise;
+  let hook_fn_id = 1;
+  const cacheFn = (options, fn) => {
+    fn.id = hook_fn_id++;
+    originTapPromise.call(hook, options, async (args) => {
+      const originCode = args.code;
+      const { id } = fn;
+      const context = compiler.getTransformContext(args.path);
+      const cache = context.getValidCache(id, args.code);
+      if (cache) {
+        return cache;
+      }
+      delete args.map;
+      const result = await fn(args);
+      context.addTransformResult(id, {
+        ...result,
+        originCode
+      });
+      return result;
+    });
+  };
+  hook.tap = cacheFn;
+  hook.tapPromise = cacheFn;
+  return hook;
+}
+function createRenderChunkHook(compiler) {
+  const hook = new tapable.AsyncSeriesWaterfallHook([
+    "chunk"
+  ]);
+  if (!compiler.context.config.sourceMap) {
+    return hook;
+  }
+  const originTapPromise = hook.tapPromise;
+  let hook_fn_id = 1;
+  const wrapper = (options, fn) => {
+    fn.id = hook_fn_id++;
+    originTapPromise.call(hook, options, async (chunk) => {
+      const context = compiler.getSourcemapContext(chunk.fileName);
+      if (chunk.type === "chunk") {
+        delete chunk.map;
+      }
+      const result = await fn(chunk);
+      if (chunk.type === "chunk") {
+        context.addSourceMap(fn.id, result.map);
+      }
+      return result;
+    });
+  };
+  hook.tap = wrapper;
+  hook.tapPromise = wrapper;
+  hook.tapAsync = function(options, fn) {
+    wrapper(options, (0, import_util.promisify)(fn));
+  };
+  return hook;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRenderChunkHook,
+  createTransformHook
+});

package/dist/builder/esbuild/index.d.ts

@@ -0,0 +1,35 @@
+import { BuildResult, BuildOptions, BuildContext, ImportKind } from 'esbuild';
+import { FSWatcher } from '@modern-js/utils';
+import { BaseBuildConfig, BuilderHooks, Chunk, ICompiler, ModuleTools, PluginAPI, Context, HookList } from '../../types';
+import { TransformContext } from './transform';
+import { SourcemapContext } from './sourcemap';
+export declare class EsbuildCompiler implements ICompiler {
+  instance?: BuildContext;
+  result?: BuildResult;
+  hookList?: HookList;
+  reBuildCount: number;
+  buildOptions: BuildOptions;
+  context: Context;
+  config: BaseBuildConfig;
+  hooks: BuilderHooks;
+  api: PluginAPI<ModuleTools>;
+  outputChunk: Map<string, Chunk>;
+  watchedFiles: Set<string>;
+  css_resolve: (id: string, dir: string) => string;
+  node_resolve: (id: string, dir: string, kind: ImportKind) => string;
+  watcher?: FSWatcher;
+  virtualModule: Map<string, string>;
+  private transformContextMap;
+  private sourcemapContextMap;
+  constructor(context: Context);
+  init(): Promise<void>;
+  addWatchFile(id: string): void;
+  convertConfigToEsbuild(config: BaseBuildConfig): BuildOptions;
+  getTransformContext(path: string): TransformContext;
+  getSourcemapContext(path: string): SourcemapContext;
+  emitAsset(name: string, chunk: string | Chunk): void;
+  close(): Promise<void>;
+  build(): Promise<void>;
+  reBuild(type: 'link' | 'change', config: BaseBuildConfig): Promise<void>;
+}
+export declare const createCompiler: (context: Context) => Promise<EsbuildCompiler>;

package/dist/builder/esbuild/index.js

@@ -0,0 +1,268 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var esbuild_exports = {};
+__export(esbuild_exports, {
+  EsbuildCompiler: () => EsbuildCompiler,
+  createCompiler: () => createCompiler
+});
+module.exports = __toCommonJS(esbuild_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_esbuild = require("esbuild");
+var tapable = __toESM(require("tapable"));
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("../../utils");
+var import_feature = require("../feature");
+var import_build = require("../../constants/build");
+var import_adapter = require("./adapter");
+var import_transform = require("./transform");
+var import_sourcemap = require("./sourcemap");
+var import_hook = require("./hook");
+var import_resolve = require("./resolve");
+var import_watch = require("./watch");
+class EsbuildCompiler {
+  async init() {
+    if (this.context.watch) {
+      (0, import_watch.initWatcher)(this);
+    }
+    const internal = await (0, import_feature.getInternalList)(this.context);
+    const user = this.config.hooks;
+    this.hookList = [
+      ...user,
+      ...internal
+    ];
+    await Promise.all(this.hookList.map((item) => item.apply(this)));
+  }
+  addWatchFile(id) {
+    if (!this.watchedFiles.has(id)) {
+      var _this_watcher_add, _this_watcher;
+      (_this_watcher = this.watcher) === null || _this_watcher === void 0 ? void 0 : (_this_watcher_add = _this_watcher.add) === null || _this_watcher_add === void 0 ? void 0 : _this_watcher_add.call(_this_watcher, id);
+      this.watchedFiles.add(id);
+    }
+  }
+  convertConfigToEsbuild(config) {
+    const { input, buildType, define, target, sourceMap, platform, splitting, outDir, sourceDir, minify, jsx, esbuildOptions, format, asset, tsconfig, banner, footer } = config;
+    const bundle = buildType === "bundle";
+    const entryNames = bundle ? "[name]" : "[dir]/[name]";
+    const absWorkingDir = this.context.root;
+    let esbuildFormat = format === "umd" ? "esm" : format;
+    if (bundle && format === "cjs" && splitting) {
+      esbuildFormat = "esm";
+    }
+    const esbuildTarget = target === "es5" ? void 0 : target;
+    const jsExtensions = [
+      ".jsx",
+      ".tsx",
+      ".js",
+      ".ts",
+      ".json"
+    ];
+    const buildOptions = {
+      banner: import_utils.lodash.pick(banner, [
+        "js",
+        "css"
+      ]),
+      footer: import_utils.lodash.pick(footer, [
+        "js",
+        "css"
+      ]),
+      entryPoints: input,
+      metafile: true,
+      define,
+      bundle: buildType === "bundle",
+      format: esbuildFormat,
+      target: esbuildTarget,
+      sourcemap: sourceMap ? "external" : false,
+      resolveExtensions: jsExtensions,
+      splitting,
+      charset: "utf8",
+      logLimit: 5,
+      absWorkingDir,
+      platform,
+      tsconfig: import_utils.fs.existsSync(tsconfig) ? tsconfig : void 0,
+      write: false,
+      logLevel: "silent",
+      outdir: outDir,
+      outbase: sourceDir,
+      entryNames,
+      plugins: [
+        (0, import_adapter.adapterPlugin)(this)
+      ],
+      minify: minify === "esbuild",
+      jsx,
+      supported: {
+        "dynamic-import": buildType === "bundle" || format !== "cjs"
+      },
+      assetNames: `${asset.path}/[name].[hash]`
+    };
+    return esbuildOptions(buildOptions);
+  }
+  getTransformContext(path) {
+    if (this.transformContextMap.has(path)) {
+      return this.transformContextMap.get(path);
+    }
+    const context2 = new import_transform.TransformContext(Boolean(this.context.config.sourceMap));
+    this.transformContextMap.set(path, context2);
+    return context2;
+  }
+  getSourcemapContext(path) {
+    if (this.sourcemapContextMap.has(path)) {
+      return this.sourcemapContextMap.get(path);
+    }
+    const context2 = new import_sourcemap.SourcemapContext(Boolean(this.context.config.sourceMap));
+    this.sourcemapContextMap.set(path, context2);
+    return context2;
+  }
+  emitAsset(name, chunk) {
+    if (typeof chunk === "string") {
+      this.outputChunk.set(name, {
+        type: "asset",
+        contents: chunk,
+        fileName: name
+      });
+    } else {
+      this.outputChunk.set(name, chunk);
+    }
+  }
+  async close() {
+    try {
+      var _this_instance, _this_instance1;
+      await ((_this_instance = this.instance) === null || _this_instance === void 0 ? void 0 : _this_instance.cancel());
+      await ((_this_instance1 = this.instance) === null || _this_instance1 === void 0 ? void 0 : _this_instance1.dispose());
+    } catch (err) {
+    }
+  }
+  async build() {
+    const { buildOptions, context: { watch } } = this;
+    try {
+      if (watch) {
+        this.instance = await (0, import_esbuild.context)(buildOptions);
+        this.result = await this.instance.rebuild();
+      } else {
+        this.result = await (0, import_esbuild.build)(buildOptions);
+      }
+      if (this.result.warnings.length) {
+        const warnings = this.result.warnings.filter((warning) => {
+          if (warning.text.includes(`This call to "require" will not be bundled because`) || warning.text.includes(`Indirect calls to "require" will not be bundled`) || warning.text.includes(`Converting "require" to "esm" is currently not supported`)) {
+            return false;
+          }
+          return true;
+        });
+        const messages = await (0, import_esbuild.formatMessages)(warnings, {
+          kind: "warning"
+        });
+        messages.forEach((m) => {
+          import_utils.logger.warn(m);
+        });
+      }
+    } catch (error) {
+      if (watch) {
+        var _this_instance;
+        (_this_instance = this.instance) === null || _this_instance === void 0 ? void 0 : _this_instance.cancel();
+        import_utils.logger.error(error);
+      } else {
+        throw error;
+      }
+    }
+  }
+  async reBuild(type, config) {
+    const { instance } = this;
+    try {
+      const start = Date.now();
+      if (type === "link") {
+        await this.build();
+      } else {
+        this.result = await (instance === null || instance === void 0 ? void 0 : instance.rebuild());
+      }
+      const time = import_utils.chalk.gray(`(${Date.now() - start}ms)`);
+      import_utils.logger.success((0, import_utils2.withLogTitle)(config.buildType, `Build ${config.format},${config.target} files ${time}`));
+    } catch (error) {
+      import_utils.logger.error(error);
+    }
+  }
+  constructor(context2) {
+    (0, import_define_property._)(this, "instance", void 0);
+    (0, import_define_property._)(this, "result", void 0);
+    (0, import_define_property._)(this, "hookList", void 0);
+    (0, import_define_property._)(this, "reBuildCount", void 0);
+    (0, import_define_property._)(this, "buildOptions", void 0);
+    (0, import_define_property._)(this, "context", void 0);
+    (0, import_define_property._)(this, "config", void 0);
+    (0, import_define_property._)(this, "hooks", void 0);
+    (0, import_define_property._)(this, "api", void 0);
+    (0, import_define_property._)(this, "outputChunk", /* @__PURE__ */ new Map());
+    (0, import_define_property._)(this, "watchedFiles", /* @__PURE__ */ new Set());
+    (0, import_define_property._)(this, "css_resolve", void 0);
+    (0, import_define_property._)(this, "node_resolve", void 0);
+    (0, import_define_property._)(this, "watcher", void 0);
+    (0, import_define_property._)(this, "virtualModule", /* @__PURE__ */ new Map());
+    (0, import_define_property._)(this, "transformContextMap", /* @__PURE__ */ new Map());
+    (0, import_define_property._)(this, "sourcemapContextMap", /* @__PURE__ */ new Map());
+    const { api, config, root } = context2;
+    this.reBuildCount = 0;
+    this.context = context2;
+    this.api = api;
+    this.config = config;
+    this.buildOptions = this.convertConfigToEsbuild(config);
+    this.hooks = Object.freeze({
+      load: new tapable.AsyncSeriesBailHook([
+        "loadArgs"
+      ]),
+      transform: (0, import_hook.createTransformHook)(this),
+      renderChunk: (0, import_hook.createRenderChunkHook)(this)
+    });
+    const resolveOptions = {
+      root,
+      platform: config.platform,
+      alias: config.alias,
+      tsconfig: config.tsconfig,
+      mainFields: config.resolve.mainFields
+    };
+    this.css_resolve = (0, import_resolve.createResolver)({
+      ...resolveOptions,
+      resolveType: "css",
+      extensions: import_build.cssExtensions,
+      preferRelative: true
+    });
+    this.node_resolve = (0, import_resolve.createResolver)({
+      ...resolveOptions,
+      resolveType: "js",
+      extensions: config.resolve.jsExtensions
+    });
+  }
+}
+const createCompiler = async (context2) => {
+  const compiler = new EsbuildCompiler(context2);
+  await compiler.init();
+  return compiler;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EsbuildCompiler,
+  createCompiler
+});