@umijs/bundler-webpack 4.0.0-beta.8 → 4.0.0-canary-20240513.3

package/dist/dev.js

@@ -1,87 +1,204 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dev = void 0;
-const mfsu_1 = require("@umijs/mfsu");
-const webpack_1 = __importDefault(require("../compiled/webpack"));
-const config_1 = require("./config/config");
-const constants_1 = require("./constants");
-const server_1 = require("./server/server");
-const types_1 = require("./types");
-function dev(opts) {
-    var _a;
-    var _b;
-    return __awaiter(this, void 0, void 0, function* () {
-        const enableMFSU = opts.config.mfsu !== false;
-        let mfsu = null;
-        if (enableMFSU) {
-            mfsu = new mfsu_1.MFSU({
-                implementor: webpack_1.default,
-                buildDepWithESBuild: (_a = opts.config.mfsu) === null || _a === void 0 ? void 0 : _a.esbuild,
-            });
+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);
+
+// src/dev.ts
+var dev_exports = {};
+__export(dev_exports, {
+  dev: () => dev,
+  ensureSerializableValue: () => ensureSerializableValue,
+  setup: () => setup
+});
+module.exports = __toCommonJS(dev_exports);
+var import_mfsu = require("@umijs/mfsu");
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_webpack = __toESM(require("../compiled/webpack"));
+var import_constants = require("./constants");
+var import_server = require("./server/server");
+var import_types = require("./types");
+var configModule = (0, import_utils.importLazy)(
+  require.resolve("./config/config")
+);
+function ensureSerializableValue(obj) {
+  return JSON.parse(
+    JSON.stringify(
+      obj,
+      (_key, value) => {
+        if (typeof value === "function" || import_utils.lodash.isRegExp(value)) {
+          return value.toString();
         }
-        const webpackConfig = yield (0, config_1.getConfig)({
-            cwd: opts.cwd,
-            env: types_1.Env.development,
-            entry: opts.entry,
-            userConfig: opts.config,
-            extraBabelPlugins: [
-                ...(opts.beforeBabelPlugins || []),
-                ...((mfsu === null || mfsu === void 0 ? void 0 : mfsu.getBabelPlugins()) || []),
-                ...(opts.extraBabelPlugins || []),
-            ],
-            extraBabelPresets: [
-                ...(opts.beforeBabelPresets || []),
-                ...(opts.extraBabelPresets || []),
-            ],
-            chainWebpack: opts.chainWebpack,
-            modifyWebpackConfig: opts.modifyWebpackConfig,
-            hmr: true,
-            analyze: process.env.ANALYZE,
-        });
-        const depConfig = yield (0, config_1.getConfig)({
-            cwd: opts.cwd,
-            env: types_1.Env.development,
-            entry: opts.entry,
-            userConfig: opts.config,
-            hash: true,
-            staticPathPrefix: mfsu_1.MF_DEP_PREFIX,
-            name: constants_1.MFSU_NAME,
-        });
-        (_b = webpackConfig.resolve).alias || (_b.alias = {});
-        // TODO: REMOVE ME
-        ['@umijs/utils/compiled/strip-ansi', 'react-error-overlay'].forEach((dep) => {
-            // @ts-ignore
-            webpackConfig.resolve.alias[dep] = require.resolve(dep);
-        });
-        mfsu === null || mfsu === void 0 ? void 0 : mfsu.setWebpackConfig({
-            config: webpackConfig,
-            depConfig: depConfig,
-        });
-        yield (0, server_1.createServer)({
-            webpackConfig,
-            userConfig: opts.config,
-            cwd: opts.cwd,
-            beforeMiddlewares: [
-                ...((mfsu === null || mfsu === void 0 ? void 0 : mfsu.getMiddlewares()) || []),
-                ...(opts.beforeMiddlewares || []),
-            ],
-            port: opts.port,
-            host: opts.host,
-            afterMiddlewares: [...(opts.afterMiddlewares || [])],
-            onDevCompileDone: opts.onDevCompileDone,
+        return value;
+      },
+      2
+    )
+  );
+}
+async function dev(opts) {
+  const { mfsu, webpackConfig } = await setup(opts);
+  await (0, import_server.createServer)({
+    webpackConfig,
+    userConfig: opts.config,
+    cwd: opts.cwd,
+    beforeMiddlewares: [
+      ...(mfsu == null ? void 0 : mfsu.getMiddlewares()) || [],
+      ...opts.beforeMiddlewares || []
+    ],
+    port: opts.port,
+    host: opts.host,
+    ip: opts.ip,
+    afterMiddlewares: [...opts.afterMiddlewares || []],
+    onDevCompileDone: opts.onDevCompileDone,
+    onProgress: opts.onProgress,
+    onBeforeMiddleware: opts.onBeforeMiddleware
+  });
+}
+async function setup(opts) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const cacheDirectoryPath = (0, import_path.resolve)(
+    opts.rootDir || opts.cwd,
+    opts.config.cacheDirectoryPath || "node_modules/.cache"
+  );
+  const enableMFSU = opts.config.mfsu !== false;
+  let mfsu = null;
+  if (enableMFSU) {
+    mfsu = new import_mfsu.MFSU({
+      strategy: opts.mfsuStrategy,
+      include: opts.mfsuInclude || [],
+      srcCodeCache: opts.srcCodeCache,
+      implementor: import_webpack.default,
+      buildDepWithESBuild: (_a = opts.config.mfsu) == null ? void 0 : _a.esbuild,
+      depBuildConfig: {
+        extraPostCSSPlugins: ((_b = opts.config) == null ? void 0 : _b.extraPostCSSPlugins) || []
+      },
+      mfName: (_c = opts.config.mfsu) == null ? void 0 : _c.mfName,
+      runtimePublicPath: opts.config.runtimePublicPath,
+      tmpBase: ((_d = opts.config.mfsu) == null ? void 0 : _d.cacheDirectory) || (0, import_path.join)(cacheDirectoryPath, "mfsu"),
+      onMFSUProgress: opts.onMFSUProgress,
+      unMatchLibs: (_e = opts.config.mfsu) == null ? void 0 : _e.exclude,
+      shared: (_f = opts.config.mfsu) == null ? void 0 : _f.shared,
+      remoteAliases: (_g = opts.config.mfsu) == null ? void 0 : _g.remoteAliases,
+      remoteName: (_h = opts.config.mfsu) == null ? void 0 : _h.remoteName,
+      getCacheDependency() {
+        return ensureSerializableValue({
+          version: require("../package.json").version,
+          mfsu: opts.config.mfsu,
+          alias: opts.config.alias,
+          externals: opts.config.externals,
+          theme: opts.config.theme,
+          runtimePublicPath: opts.config.runtimePublicPath,
+          publicPath: opts.config.publicPath,
+          define: opts.config.define
         });
+      },
+      startBuildWorker: opts.startBuildWorker,
+      cwd: opts.cwd
     });
+  }
+  const webpackConfig = await configModule.getConfig({
+    cwd: opts.cwd,
+    rootDir: opts.rootDir,
+    env: import_types.Env.development,
+    entry: opts.entry,
+    userConfig: opts.config,
+    babelPreset: opts.babelPreset,
+    extraBabelPlugins: [
+      ...opts.beforeBabelPlugins || [],
+      ...(mfsu == null ? void 0 : mfsu.getBabelPlugins()) || [],
+      ...opts.extraBabelPlugins || []
+    ],
+    extraBabelPresets: [
+      ...opts.beforeBabelPresets || [],
+      ...opts.extraBabelPresets || []
+    ],
+    extraBabelIncludes: opts.config.extraBabelIncludes,
+    extraEsbuildLoaderHandler: (mfsu == null ? void 0 : mfsu.getEsbuildLoaderHandler()) || [],
+    chainWebpack: opts.chainWebpack,
+    modifyWebpackConfig: opts.modifyWebpackConfig,
+    hmr: process.env.HMR !== "none",
+    analyze: process.env.ANALYZE,
+    cache: opts.cache ? {
+      ...opts.cache,
+      cacheDirectory: (0, import_path.join)(
+        cacheDirectoryPath,
+        opts.mfsuStrategy === "eager" ? "bundler-webpack-eager" : "bundler-webpack"
+      )
+    } : void 0,
+    pkg: opts.pkg,
+    disableCopy: opts.disableCopy
+  });
+  const depConfig = await configModule.getConfig({
+    cwd: opts.cwd,
+    rootDir: opts.rootDir,
+    env: import_types.Env.development,
+    entry: opts.entry,
+    userConfig: { ...opts.config, forkTSChecker: false },
+    disableCopy: true,
+    hash: true,
+    staticPathPrefix: import_mfsu.MF_DEP_PREFIX,
+    name: import_constants.MFSU_NAME,
+    chainWebpack: (_i = opts.config.mfsu) == null ? void 0 : _i.chainWebpack,
+    extraBabelIncludes: opts.config.extraBabelIncludes,
+    cache: {
+      buildDependencies: (_j = opts.cache) == null ? void 0 : _j.buildDependencies,
+      cacheDirectory: (0, import_path.join)(cacheDirectoryPath, "mfsu-deps")
+    },
+    pkg: opts.pkg
+  });
+  (_k = webpackConfig.resolve).alias || (_k.alias = {});
+  ["@umijs/utils/compiled/strip-ansi", "react-error-overlay"].forEach((dep) => {
+    webpackConfig.resolve.alias[dep] = require.resolve(dep);
+  });
+  await (mfsu == null ? void 0 : mfsu.setWebpackConfig({
+    config: webpackConfig,
+    depConfig
+  }));
+  if (mfsu && webpackConfig.cache && typeof webpackConfig.cache === "object" && webpackConfig.cache.type === "filesystem") {
+    const webpackCachePath = (0, import_path.join)(
+      webpackConfig.cache.cacheDirectory,
+      `default-development`,
+      "index.pack"
+    );
+    const mfsuCacheExists = (0, import_fs.existsSync)(mfsu.getCacheFilePath());
+    const webpackCacheExists = (0, import_fs.existsSync)(webpackCachePath);
+    if (webpackCacheExists && !mfsuCacheExists) {
+      import_utils.logger.warn(`Invalidate webpack cache since mfsu cache is missing`);
+      import_utils.rimraf.sync(webpackConfig.cache.cacheDirectory);
+    }
+  }
+  return {
+    mfsu,
+    webpackConfig
+  };
 }
-exports.dev = dev;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dev,
+  ensureSerializableValue,
+  setup
+});

package/dist/index.d.ts

@@ -1,6 +1,10 @@
-export type { RequestHandler } from '../compiled/express';
+import type webpack from '../compiled/webpack';
+import './requireHook';
+export type { RequestHandler, Express, } from '@umijs/bundler-utils/compiled/express';
+export type { Compiler, Stats } from '../compiled/webpack';
 export * from './build';
 export * from './config/config';
 export * from './dev';
 export * from './schema';
-//# sourceMappingURL=index.d.ts.map
+export * from './constants';
+export { webpack };

package/dist/index.js

@@ -1,16 +1,32 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./build"), exports);
-__exportStar(require("./config/config"), exports);
-__exportStar(require("./dev"), exports);
-__exportStar(require("./schema"), exports);
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+var import_requireHook = require("./requireHook");
+__reExport(src_exports, require("./build"), module.exports);
+__reExport(src_exports, require("./config/config"), module.exports);
+__reExport(src_exports, require("./dev"), module.exports);
+__reExport(src_exports, require("./schema"), module.exports);
+__reExport(src_exports, require("./constants"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./build"),
+  ...require("./config/config"),
+  ...require("./dev"),
+  ...require("./schema"),
+  ...require("./constants")
+});

package/dist/loader/svgr.d.ts

@@ -0,0 +1,4 @@
+import { Config } from '@svgr/core';
+import type { LoaderContext } from '../../compiled/webpack';
+declare function svgrLoader(this: LoaderContext<Config>, contents: string): void;
+export default svgrLoader;

package/dist/loader/svgr.js

@@ -0,0 +1,84 @@
+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);
+
+// src/loader/svgr.ts
+var svgr_exports = {};
+__export(svgr_exports, {
+  default: () => svgr_default
+});
+module.exports = __toCommonJS(svgr_exports);
+var import_core = require("@svgr/core");
+var import_plugin_jsx = __toESM(require("@svgr/plugin-jsx"));
+var import_plugin_svgo = __toESM(require("@svgr/plugin-svgo"));
+var import_esbuild = require("@umijs/bundler-utils/compiled/esbuild");
+var import_path = require("path");
+var import_util = require("util");
+var tranformSvg = (0, import_util.callbackify)(
+  async (contents, options, state) => {
+    const jsCode = await (0, import_core.transform)(contents, options, state);
+    const result = await (0, import_esbuild.transform)(jsCode, {
+      loader: "tsx",
+      target: "es2015"
+    });
+    if (!(result == null ? void 0 : result.code)) {
+      throw new Error(`Error while transforming using Esbuild`);
+    }
+    return result.code;
+  }
+);
+function svgrLoader(contents) {
+  this.cacheable && this.cacheable();
+  const callback = this.async();
+  const options = this.getOptions();
+  const previousExport = (() => {
+    if (contents.startsWith("export "))
+      return contents;
+    const exportMatches = contents.match(/^module.exports\s*=\s*(.*)/);
+    return exportMatches ? `export default ${exportMatches[1]}` : null;
+  })();
+  const state = {
+    caller: {
+      name: "svgr-loader",
+      previousExport,
+      defaultPlugins: [import_plugin_svgo.default, import_plugin_jsx.default]
+    },
+    filePath: (0, import_path.normalize)(this.resourcePath)
+  };
+  if (!previousExport) {
+    tranformSvg(contents, options, state, callback);
+  } else {
+    this.fs.readFile(this.resourcePath, (err, result) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+      tranformSvg(String(result), options, state, callback);
+    });
+  }
+}
+var svgr_default = svgrLoader;

package/dist/loader/swc.d.ts

@@ -0,0 +1,4 @@
+import type { LoaderContext } from '../../compiled/webpack';
+import { type SwcOptions } from '../types';
+declare function swcLoader(this: LoaderContext<SwcOptions>, contents: string, inputSourceMap: string | Record<string, any>): void;
+export default swcLoader;

package/dist/loader/swc.js

@@ -0,0 +1,149 @@
+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);
+
+// src/loader/swc.ts
+var swc_exports = {};
+__export(swc_exports, {
+  default: () => swc_default
+});
+module.exports = __toCommonJS(swc_exports);
+var import_core = require("@swc/core");
+var import_types = require("../types");
+var import_utils = require("@umijs/utils");
+function getBaseOpts({ filename }) {
+  const isTSFile = filename.endsWith(".ts");
+  const isTypeScript = isTSFile || filename.endsWith(".tsx");
+  const isDev = process.env.NODE_ENV === import_types.Env.development;
+  const swcOpts = {
+    module: {
+      // @ts-ignore
+      type: "es6",
+      ignoreDynamic: true
+    },
+    jsc: {
+      parser: {
+        syntax: isTypeScript ? "typescript" : "ecmascript",
+        [isTypeScript ? "tsx" : "jsx"]: !isTSFile,
+        dynamicImport: isTypeScript
+      },
+      target: "es2015",
+      transform: {
+        react: {
+          runtime: "automatic",
+          pragma: "React.createElement",
+          pragmaFrag: "React.Fragment",
+          throwIfNamespace: true,
+          development: isDev,
+          useBuiltins: true
+        }
+      }
+    }
+  };
+  return swcOpts;
+}
+function swcLoader(contents, inputSourceMap) {
+  const callback = this.async();
+  const loaderOpts = this.getOptions();
+  if (inputSourceMap && typeof inputSourceMap === "object") {
+    inputSourceMap = JSON.stringify(inputSourceMap);
+  }
+  const {
+    sync = false,
+    parseMap = false,
+    excludeFiles = [],
+    enableAutoCssModulesPlugin = false,
+    mergeConfigs,
+    ...otherOpts
+  } = loaderOpts;
+  const filename = this.resourcePath;
+  const isSkip = excludeFiles.some((pattern) => {
+    if (typeof pattern === "string") {
+      return filename == pattern;
+    }
+    return pattern.test(filename);
+  });
+  if (isSkip) {
+    return callback(
+      null,
+      contents,
+      parseMap ? JSON.parse(inputSourceMap) : inputSourceMap
+    );
+  }
+  let swcOpts = {
+    ...getBaseOpts({
+      filename
+    }),
+    // filename
+    filename,
+    sourceFileName: filename,
+    // source map
+    sourceMaps: this.sourceMap,
+    ...inputSourceMap ? {
+      inputSourceMap
+    } : {},
+    ...otherOpts
+  };
+  if (enableAutoCssModulesPlugin) {
+    swcOpts = (0, import_utils.deepmerge)(swcOpts, {
+      jsc: {
+        experimental: {
+          plugins: [[require.resolve("swc-plugin-auto-css-modules"), {}]]
+        }
+      }
+    });
+  }
+  if (mergeConfigs) {
+    swcOpts = (0, import_utils.deepmerge)(swcOpts, mergeConfigs);
+  }
+  try {
+    if (sync) {
+      const output = (0, import_core.transformSync)(contents, swcOpts);
+      callback(
+        null,
+        output.code,
+        parseMap ? JSON.parse(output.map) : output.map
+      );
+    } else {
+      (0, import_core.transform)(contents, swcOpts).then(
+        (output) => {
+          callback(
+            null,
+            output.code,
+            parseMap ? JSON.parse(output.map) : output.map
+          );
+        },
+        (err) => {
+          callback(err);
+        }
+      );
+    }
+  } catch (e) {
+    callback(e);
+  }
+}
+var swc_default = swcLoader;

package/dist/parcelCSS.d.ts

@@ -0,0 +1,2 @@
+import * as parcelCSS from 'lightningcss';
+export { parcelCSS };

package/dist/parcelCSS.js

@@ -0,0 +1,39 @@
+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);
+
+// src/parcelCSS.ts
+var parcelCSS_exports = {};
+__export(parcelCSS_exports, {
+  parcelCSS: () => parcelCSS
+});
+module.exports = __toCommonJS(parcelCSS_exports);
+var parcelCSS = __toESM(require("lightningcss"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parcelCSS
+});

package/dist/plugins/EsbuildMinifyFix.d.ts

@@ -0,0 +1,8 @@
+import { Compilation, Compiler, sources } from '../../compiled/webpack';
+export declare class EsbuildMinifyFix {
+    private name;
+    constructor();
+    apply(compiler: Compiler): void;
+    private isIIFE;
+    minifyFix(compilation: Compilation, assets: Record<string, sources.Source>): Promise<void>;
+}