@umijs/bundler-webpack 4.2.6-alpha.6 → 4.2.6

package/dist/config/ssrPlugin.d.ts

@@ -0,0 +1,11 @@
+import Config from '../../compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    name?: string;
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+}
+export default function addSSRPlugin(opts: IOpts): void;
+export {};

package/dist/config/ssrPlugin.js

@@ -0,0 +1,98 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/ssrPlugin.ts
+var ssrPlugin_exports = {};
+__export(ssrPlugin_exports, {
+  default: () => addSSRPlugin
+});
+module.exports = __toCommonJS(ssrPlugin_exports);
+var import_webpack = require("@umijs/bundler-webpack/compiled/webpack");
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_constants = require("../constants");
+var PLUGIN_NAME = "SSR_PLUGIN";
+var SSRPlugin = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.manifest = /* @__PURE__ */ new Map();
+  }
+  apply(compiler) {
+    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks.processAssets.tap(PLUGIN_NAME, () => {
+        const publicPath = compiler.options.output.publicPath || "/";
+        const assets = compilation.getAssets().filter((asset) => {
+          if (asset.info.hotModuleReplacement) {
+            return false;
+          }
+          return true;
+        });
+        assets.forEach((asset) => {
+          if (asset.info.sourceFilename) {
+            this.manifest.set(
+              asset.info.sourceFilename,
+              publicPath + asset.name
+            );
+          }
+        });
+        const stats = compilation.getStats().toJson({
+          all: false,
+          assets: true,
+          cachedAssets: true,
+          cachedModules: true
+        });
+        const { assetsByChunkName } = stats;
+        Object.keys(assetsByChunkName).forEach((chunkName) => {
+          assetsByChunkName[chunkName].forEach((filename) => {
+            const ext = (0, import_path.extname)(filename.split(/[?#]/)[0]);
+            if (!filename.includes(".hot-update.")) {
+              this.manifest.set(chunkName + ext, publicPath + filename);
+            }
+          });
+        });
+        const assetsSource = JSON.stringify(
+          {
+            assets: Object.fromEntries(this.manifest)
+          },
+          null,
+          2
+        );
+        if (process.env.NODE_ENV === "production" || this.opts.userConfig.writeToDisk) {
+          compilation.emitAsset(
+            "build-manifest.json",
+            new import_webpack.sources.RawSource(assetsSource, false)
+          );
+        } else {
+          const outputPath = compiler.options.output.path;
+          import_utils.fsExtra.mkdirpSync(outputPath);
+          (0, import_fs.writeFileSync)(
+            (0, import_path.join)(outputPath, "build-manifest.json"),
+            assetsSource,
+            "utf-8"
+          );
+        }
+      });
+    });
+  }
+};
+function addSSRPlugin(opts) {
+  if (opts.userConfig.ssr && opts.name !== import_constants.MFSU_NAME) {
+    opts.config.plugin("ssr-plugin").use(SSRPlugin, [opts]);
+  }
+}

package/dist/config/svgRules.d.ts

@@ -0,0 +1,12 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+    browsers: any;
+    staticPathPrefix: string;
+}
+export declare function addSVGRules(opts: IOpts): Promise<void>;
+export {};

package/dist/config/svgRules.js

@@ -0,0 +1,70 @@
+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/config/svgRules.ts
+var svgRules_exports = {};
+__export(svgRules_exports, {
+  addSVGRules: () => addSVGRules
+});
+module.exports = __toCommonJS(svgRules_exports);
+async function addSVGRules(opts) {
+  const { config, userConfig } = opts;
+  const { svgr, svgo = {} } = userConfig;
+  if (svgr) {
+    const svgrRule = config.module.rule("svgr");
+    svgrRule.test(/\.svg$/).issuer(/\.[jt]sx?$/).type("javascript/auto").use("svgr-loader").loader(require.resolve("../loader/svgr")).options({
+      svgoConfig: {
+        plugins: [
+          {
+            name: "preset-default",
+            params: {
+              overrides: {
+                removeTitle: false
+              }
+            }
+          },
+          "prefixIds"
+        ],
+        ...svgo
+      },
+      ...svgr,
+      svgo: !!svgo
+    }).end().use("url-loader").loader(require.resolve("@umijs/bundler-webpack/compiled/url-loader")).options({
+      limit: userConfig.inlineLimit,
+      fallback: require.resolve("@umijs/bundler-webpack/compiled/file-loader")
+    }).end();
+  }
+  if (svgo !== false) {
+    const svgRule = config.module.rule("svg");
+    svgRule.test(/\.svg$/).use("svgo-loader").loader(require.resolve("@umijs/bundler-webpack/compiled/svgo-loader")).options({ configFile: false, ...svgo }).end();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addSVGRules
+});

package/dist/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const DEFAULT_DEVTOOL = "cheap-module-source-map";
+export declare const DEFAULT_OUTPUT_PATH = "dist";
+export declare const MFSU_NAME = "MFSU";
+export declare enum MESSAGE_TYPE {
+    ok = "ok",
+    warnings = "warnings",
+    errors = "errors",
+    hash = "hash",
+    stillOk = "still-ok",
+    invalid = "invalid"
+}
+export declare const DEFAULT_BROWSER_TARGETS: {
+    chrome: number;
+};
+export declare const DEFAULT_ESBUILD_TARGET_KEYS: string[];

package/dist/constants.js

@@ -0,0 +1,59 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_BROWSER_TARGETS: () => DEFAULT_BROWSER_TARGETS,
+  DEFAULT_DEVTOOL: () => DEFAULT_DEVTOOL,
+  DEFAULT_ESBUILD_TARGET_KEYS: () => DEFAULT_ESBUILD_TARGET_KEYS,
+  DEFAULT_OUTPUT_PATH: () => DEFAULT_OUTPUT_PATH,
+  MESSAGE_TYPE: () => MESSAGE_TYPE,
+  MFSU_NAME: () => MFSU_NAME
+});
+module.exports = __toCommonJS(constants_exports);
+var DEFAULT_DEVTOOL = "cheap-module-source-map";
+var DEFAULT_OUTPUT_PATH = "dist";
+var MFSU_NAME = "MFSU";
+var MESSAGE_TYPE = /* @__PURE__ */ ((MESSAGE_TYPE2) => {
+  MESSAGE_TYPE2["ok"] = "ok";
+  MESSAGE_TYPE2["warnings"] = "warnings";
+  MESSAGE_TYPE2["errors"] = "errors";
+  MESSAGE_TYPE2["hash"] = "hash";
+  MESSAGE_TYPE2["stillOk"] = "still-ok";
+  MESSAGE_TYPE2["invalid"] = "invalid";
+  return MESSAGE_TYPE2;
+})(MESSAGE_TYPE || {});
+var DEFAULT_BROWSER_TARGETS = {
+  chrome: 80
+};
+var DEFAULT_ESBUILD_TARGET_KEYS = [
+  "chrome",
+  "firefox",
+  "edge",
+  "safari"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_BROWSER_TARGETS,
+  DEFAULT_DEVTOOL,
+  DEFAULT_ESBUILD_TARGET_KEYS,
+  DEFAULT_OUTPUT_PATH,
+  MESSAGE_TYPE,
+  MFSU_NAME
+});

package/dist/dev.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { MFSU } from '@umijs/mfsu';
+import type { Worker } from 'worker_threads';
+import webpack from '../compiled/webpack';
+import type { IOpts as IConfigOpts } from './config/config';
+import { IConfig } from './types';
+declare type IOpts = {
+    afterMiddlewares?: any[];
+    beforeMiddlewares?: any[];
+    onDevCompileDone?: Function;
+    onProgress?: Function;
+    onMFSUProgress?: Function;
+    port?: number;
+    host?: string;
+    ip?: string;
+    babelPreset?: any;
+    chainWebpack?: Function;
+    modifyWebpackConfig?: Function;
+    beforeBabelPlugins?: any[];
+    beforeBabelPresets?: any[];
+    extraBabelPlugins?: any[];
+    extraBabelPresets?: any[];
+    cwd: string;
+    rootDir?: string;
+    config: IConfig;
+    entry: Record<string, string>;
+    mfsuStrategy?: 'eager' | 'normal';
+    mfsuInclude?: string[];
+    srcCodeCache?: any;
+    startBuildWorker?: (deps: any[]) => Worker;
+    onBeforeMiddleware?: Function;
+    disableCopy?: boolean;
+} & Pick<IConfigOpts, 'cache' | 'pkg'>;
+export declare function ensureSerializableValue(obj: any): any;
+export declare function dev(opts: IOpts): Promise<void>;
+export declare function setup(opts: IOpts): Promise<{
+    mfsu: MFSU | null;
+    webpackConfig: webpack.Configuration;
+}>;
+export {};

package/dist/dev.js

@@ -0,0 +1,208 @@
+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/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();
+        }
+        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,
+    port: opts.port,
+    host: opts.host
+  });
+  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,
+    port: opts.port,
+    host: opts.host
+  });
+  (_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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dev,
+  ensureSerializableValue,
+  setup
+});

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+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';
+export * from './constants';
+export { webpack };

package/dist/index.js

@@ -0,0 +1,32 @@
+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;
+};
+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;