@modern-js/module-tools 2.35.0 → 2.36.0

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

@@ -0,0 +1,17 @@
+import { ImportKind, Platform } from 'esbuild';
+/**
+ * supports require js plugin in less file
+ */
+export declare const cssExtensions: string[];
+export declare const createResolver: (options: ResolverOptions) => (id: string, dir: string, kind?: ImportKind) => string;
+interface ResolverOptions {
+  platform: Platform;
+  resolveType: 'js' | 'css';
+  extensions: string[];
+  root: string;
+  alias: Record<string, string>;
+  tsconfig: string;
+  mainFields: string[];
+  preferRelative?: boolean;
+}
+export {};

package/dist/builder/esbuild/resolve.js

@@ -0,0 +1,125 @@
+"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 resolve_exports = {};
+__export(resolve_exports, {
+  createResolver: () => createResolver,
+  cssExtensions: () => cssExtensions
+});
+module.exports = __toCommonJS(resolve_exports);
+var import_fs = __toESM(require("fs"));
+var import_enhanced_resolve = require("enhanced-resolve");
+var import_tsconfig_paths_webpack_plugin = __toESM(require("tsconfig-paths-webpack-plugin"));
+const cssExtensions = [
+  ".less",
+  ".css",
+  ".sass",
+  ".scss",
+  ".js"
+];
+function createEnhancedResolve(options) {
+  const plugins = [];
+  const { tsconfig } = options;
+  if (import_fs.default.existsSync(tsconfig)) {
+    plugins.push(new import_tsconfig_paths_webpack_plugin.default({
+      baseUrl: options.root,
+      configFile: tsconfig
+    }));
+  }
+  const resolveOptions = {
+    aliasFields: options.platform === "browser" ? [
+      "browser"
+    ] : [],
+    FileSystem: new import_enhanced_resolve.CachedInputFileSystem(import_fs.default, 4e3),
+    mainFields: options.mainFields,
+    mainFiles: [
+      "index"
+    ],
+    extensions: options.extensions,
+    preferRelative: options.preferRelative,
+    addMatchAll: false,
+    plugins,
+    alias: options.alias
+  };
+  const resolveSync = (dir, id) => import_enhanced_resolve.create.sync({
+    ...resolveOptions,
+    conditionNames: [
+      options.platform,
+      "require",
+      "module"
+    ]
+  })(dir, id);
+  const esmResolveSync = (dir, id) => import_enhanced_resolve.create.sync({
+    ...resolveOptions,
+    conditionNames: [
+      options.platform,
+      "import",
+      "module"
+    ]
+  })(dir, id);
+  return {
+    resolveSync,
+    esmResolveSync
+  };
+}
+const createResolver = (options) => {
+  const resolveCache = /* @__PURE__ */ new Map();
+  const { resolveSync, esmResolveSync } = createEnhancedResolve(options);
+  const resolver = (id, dir, kind) => {
+    const cacheKey = id + dir + (kind || "");
+    const cacheResult = resolveCache.get(cacheKey);
+    if (cacheResult) {
+      return cacheResult;
+    }
+    let result;
+    if (options.resolveType === "js") {
+      if (kind === "import-statement" || kind === "dynamic-import") {
+        result = esmResolveSync(dir, id);
+      } else {
+        result = resolveSync(dir, id);
+      }
+    } else {
+      try {
+        result = resolveSync(dir, id);
+      } catch (err) {
+        result = resolveSync(dir, id.replace(/^~/, ""));
+      }
+    }
+    if (!result) {
+      throw new Error(`can not resolve ${id} from ${dir}`);
+    }
+    resolveCache.set(cacheKey, result);
+    return result;
+  };
+  return resolver;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createResolver,
+  cssExtensions
+});

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

@@ -0,0 +1,16 @@
+import { SourceMap, ISourcemapContext } from '../../types';
+export declare class SourcemapContext implements ISourcemapContext {
+  private enableSourceMap?;
+  private sourceMapChain;
+  private sourceMapDirty;
+  private cachedInlineSourceMap;
+  private cachedSourceMap;
+  private pluginIdMap;
+  constructor(enableSourceMap?: boolean | undefined);
+  private markSourceMapStatus;
+  addSourceMap(pluginId: number, map?: SourceMap): void;
+  getInlineSourceMap(): string;
+  getSourceMap(): SourceMap | undefined;
+  getSourceMapChain(): SourceMap[];
+  genPluginId(name: string): number;
+}

package/dist/builder/esbuild/sourcemap.js

@@ -0,0 +1,86 @@
+"use strict";
+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);
+var sourcemap_exports = {};
+__export(sourcemap_exports, {
+  SourcemapContext: () => SourcemapContext
+});
+module.exports = __toCommonJS(sourcemap_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_utils = require("../../utils");
+class SourcemapContext {
+  markSourceMapStatus(dirty) {
+    this.sourceMapDirty = dirty;
+  }
+  addSourceMap(pluginId, map) {
+    if (this.enableSourceMap && this.sourceMapChain[pluginId] !== map) {
+      this.sourceMapChain[pluginId] = map;
+      this.markSourceMapStatus(true);
+    }
+  }
+  getInlineSourceMap() {
+    if (this.sourceMapDirty && this.enableSourceMap) {
+      const effectMapList = this.getSourceMapChain().reverse();
+      if (effectMapList.length > 0) {
+        this.cachedInlineSourceMap = (0, import_utils.mergeMaps)(effectMapList).toComment();
+      } else {
+        this.cachedInlineSourceMap = "";
+      }
+      this.markSourceMapStatus(false);
+    }
+    return this.cachedInlineSourceMap;
+  }
+  getSourceMap() {
+    if (this.sourceMapDirty && this.enableSourceMap) {
+      const effectMapList = this.getSourceMapChain().reverse();
+      if (effectMapList.length > 0) {
+        this.cachedSourceMap = (0, import_utils.mergeMaps)(effectMapList).toMap();
+      }
+      this.markSourceMapStatus(false);
+    }
+    return this.cachedSourceMap;
+  }
+  getSourceMapChain() {
+    return this.sourceMapChain.filter((m) => Boolean(m && m.mappings));
+  }
+  genPluginId(name) {
+    if (this.pluginIdMap.has(name)) {
+      return this.pluginIdMap.get(name);
+    }
+    const id = this.sourceMapChain.length;
+    this.pluginIdMap.set(name, id);
+    return id;
+  }
+  constructor(enableSourceMap) {
+    (0, import_define_property._)(this, "enableSourceMap", void 0);
+    (0, import_define_property._)(this, "sourceMapChain", void 0);
+    (0, import_define_property._)(this, "sourceMapDirty", void 0);
+    (0, import_define_property._)(this, "cachedInlineSourceMap", void 0);
+    (0, import_define_property._)(this, "cachedSourceMap", void 0);
+    (0, import_define_property._)(this, "pluginIdMap", void 0);
+    this.enableSourceMap = enableSourceMap;
+    this.sourceMapChain = [];
+    this.sourceMapDirty = false;
+    this.cachedInlineSourceMap = "";
+    this.pluginIdMap = /* @__PURE__ */ new Map();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SourcemapContext
+});

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

@@ -0,0 +1,7 @@
+import { ITransformContext, CacheValue } from '../../types';
+import { SourcemapContext } from './sourcemap';
+export declare class TransformContext extends SourcemapContext implements ITransformContext {
+  private cachedTransformResult;
+  addTransformResult(pluginId: number, result: CacheValue): void;
+  getValidCache(pluginId: number, code: string): CacheValue | undefined;
+}

package/dist/builder/esbuild/transform.js

@@ -0,0 +1,45 @@
+"use strict";
+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);
+var transform_exports = {};
+__export(transform_exports, {
+  TransformContext: () => TransformContext
+});
+module.exports = __toCommonJS(transform_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_sourcemap = require("./sourcemap");
+class TransformContext extends import_sourcemap.SourcemapContext {
+  addTransformResult(pluginId, result) {
+    this.cachedTransformResult.set(pluginId, result);
+    this.addSourceMap(pluginId, result.map);
+  }
+  getValidCache(pluginId, code) {
+    const cache = this.cachedTransformResult.get(pluginId);
+    if (cache && cache.originCode === code) {
+      return cache;
+    }
+  }
+  constructor(...args) {
+    super(...args);
+    (0, import_define_property._)(this, "cachedTransformResult", /* @__PURE__ */ new Map());
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransformContext
+});

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

@@ -0,0 +1,2 @@
+import { ICompiler } from '../../types';
+export declare const initWatcher: (compiler: ICompiler) => void;

package/dist/builder/esbuild/watch.js

@@ -0,0 +1,115 @@
+"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 watch_exports = {};
+__export(watch_exports, {
+  initWatcher: () => initWatcher
+});
+module.exports = __toCommonJS(watch_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+const initWatcher = (compiler) => {
+  const { config, api } = compiler;
+  const watch = import_utils.chokidar.watch([
+    compiler.context.root
+  ], {
+    useFsEvents: false,
+    ignored: [
+      "**/node_modules",
+      "**/.gitignore",
+      "**/.git",
+      compiler.config.outDir
+    ],
+    cwd: compiler.context.root
+  });
+  compiler.watcher = watch;
+  let running = false;
+  let needReRun = false;
+  const handleLink = async (filePath, type) => {
+    const { config: config2, context: { root } } = compiler;
+    const { buildType, input, sourceDir } = config2;
+    const absFilePath = import_path.default.resolve(root, filePath);
+    let shouldRebuild = false;
+    if (buildType === "bundleless" && Array.isArray(input)) {
+      if (type === "add") {
+        shouldRebuild = absFilePath.startsWith(sourceDir);
+      } else {
+        shouldRebuild = input.some((item) => item === filePath);
+      }
+    }
+    if (shouldRebuild) {
+      const text = type === "add" ? "added" : "unlinked";
+      import_utils.logger.info(`${import_utils.chalk.underline(filePath)} ${text}`);
+      if (type === "unlink") {
+        input.splice(input.indexOf(filePath), 1);
+      } else {
+        input.push(filePath);
+      }
+      if (running) {
+        needReRun = true;
+      } else {
+        running = true;
+        await compiler.reBuild("link", config2);
+        running = false;
+        if (needReRun) {
+          needReRun = false;
+          await compiler.reBuild("link", config2);
+        }
+      }
+    }
+  };
+  const handleAdd = async (filePath) => {
+    return handleLink(filePath, "add");
+  };
+  const handleUnlink = async (filePath) => {
+    return handleLink(filePath, "unlink");
+  };
+  const handleChange = async (filePath, _events) => {
+    const { context: { root }, watchedFiles } = compiler;
+    if (watchedFiles.has(import_path.default.resolve(root, filePath))) {
+      import_utils.logger.info(`File changed: ${import_utils.chalk.dim(filePath)}`);
+      const runner = api.useHookRunners();
+      runner.buildWatchJs({
+        buildConfig: config
+      });
+      await compiler.reBuild("change", config);
+    }
+  };
+  watch.on("ready", () => {
+    watch.on("change", handleChange);
+    watch.on("add", handleAdd);
+    watch.on("unlink", handleUnlink);
+  });
+  watch.once("restart", () => {
+    watch.removeListener("change", handleChange);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initWatcher
+});

package/dist/builder/esbuild/write-file.d.ts

@@ -0,0 +1,2 @@
+import { ICompiler } from '../../types';
+export declare const writeFile: (compiler: ICompiler) => Promise<void>;

package/dist/builder/esbuild/write-file.js

@@ -0,0 +1,89 @@
+"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 write_file_exports = {};
+__export(write_file_exports, {
+  writeFile: () => writeFile
+});
+module.exports = __toCommonJS(write_file_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_convert_source_map = __toESM(require("convert-source-map"));
+const SOURCE_MAPPING_URL = "sourceMappingURL";
+let preOutputChunk = null;
+function appendSourceMapURLLink(options) {
+  return `${options.code}
+//# ${SOURCE_MAPPING_URL}=${options.filename}.map`;
+}
+function appendSourceMapInline(options) {
+  return `${options.code}
+//# ${SOURCE_MAPPING_URL}=data:application/json;charset=utf-8;base64,${options.map}`;
+}
+function chunkHasChanged(key, chunk) {
+  if (preOutputChunk) {
+    const preChunk = preOutputChunk.get(key);
+    if (preChunk && preChunk.contents === chunk.contents) {
+      return false;
+    }
+  }
+  return true;
+}
+const writeFile = async (compiler) => {
+  for (const [key, value] of compiler.outputChunk.entries()) {
+    if (!chunkHasChanged(key, value)) {
+      continue;
+    }
+    const absPath = import_path.default.resolve(compiler.config.outDir, key);
+    await import_utils.fs.ensureDir(import_path.default.dirname(absPath));
+    if (value.type === "chunk" && value.map) {
+      if (compiler.config.sourceMap === false || compiler.config.sourceMap === "external") {
+        await import_utils.fs.writeFile(absPath, value.contents);
+      } else if (compiler.config.sourceMap === true) {
+        await import_utils.fs.writeFile(absPath, appendSourceMapURLLink({
+          code: value.contents,
+          filename: import_path.default.basename(absPath)
+        }));
+      } else if (compiler.config.sourceMap === "inline") {
+        await import_utils.fs.writeFile(absPath, appendSourceMapInline({
+          code: value.contents,
+          map: import_convert_source_map.default.fromObject(value.map).toBase64()
+        }));
+      }
+      if (compiler.config.sourceMap === true || compiler.config.sourceMap === "external") {
+        await import_utils.fs.writeFile(`${absPath}.map`, JSON.stringify(value.map));
+      }
+    } else {
+      await import_utils.fs.writeFile(absPath, value.contents);
+    }
+  }
+  preOutputChunk = compiler.outputChunk;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  writeFile
+});

package/dist/builder/feature/asset.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { ICompiler, LoadResult, SvgrOptions } from '../../types';
+export declare const asset: {
+  name: string;
+  apply(compiler: ICompiler): void;
+};
+/**
+ *
+ * @param this Compiler
+ * @param assetPath Absolute path of the asset
+ * @param rebaseFrom Absolute path of the file which use asset
+ * @param calledOnLoad called in load hooks
+ * @returns dataurl or path
+ */
+export declare function getAssetContents(this: ICompiler, assetPath: string, rebaseFrom: string, calledOnLoad?: boolean): Promise<{
+  contents: string | Buffer;
+  loader: "copy" | "text";
+}>;
+export declare function loadSvgr(path: string, options: boolean | SvgrOptions): Promise<LoadResult | undefined>;

package/dist/builder/feature/asset.js

@@ -0,0 +1,149 @@
+"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 name2 in all)
+    __defProp(target, name2, { get: all[name2], 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 asset_exports = {};
+__export(asset_exports, {
+  asset: () => asset,
+  getAssetContents: () => getAssetContents,
+  loadSvgr: () => loadSvgr
+});
+module.exports = __toCommonJS(asset_exports);
+var import_path = require("path");
+var import_fs = __toESM(require("fs"));
+var import_pluginutils = require("@rollup/pluginutils");
+var import_core = require("@svgr/core");
+var import_plugin_svgo = __toESM(require("@svgr/plugin-svgo"));
+var import_plugin_jsx = __toESM(require("@svgr/plugin-jsx"));
+var import_file = require("../../constants/file");
+var import_utils = require("../../utils");
+const name = "asset";
+const SVG_REGEXP = /\.svg$/;
+const asset = {
+  name,
+  apply(compiler) {
+    compiler.hooks.load.tapPromise({
+      name
+    }, async (args) => {
+      if (import_file.assetExt.find((ext) => ext === (0, import_path.extname)(args.path))) {
+        const { buildType, outDir, sourceDir, asset: asset2 } = compiler.config;
+        const svgrResult = await loadSvgr(args.path, asset2.svgr);
+        if (svgrResult) {
+          return svgrResult;
+        }
+        const rebaseFrom = buildType === "bundle" ? outDir : (0, import_path.join)(outDir, (0, import_path.relative)(sourceDir, (0, import_path.dirname)(args.path)));
+        const { contents, loader } = await getAssetContents.apply(compiler, [
+          args.path,
+          rebaseFrom,
+          true
+        ]);
+        return {
+          contents,
+          loader
+        };
+      }
+    });
+  }
+};
+function encodeSVG(buffer) {
+  return encodeURIComponent(buffer.toString("utf-8").replace(/[\n\r]/gim, "").replace(/\t/gim, " ").replace(/<!--(.*(?=-->))-->/gim, "").replace(/'/gim, "\\i")).replace(/\(/g, "%28").replace(/\)/g, "%29");
+}
+async function getAssetContents(assetPath, rebaseFrom, calledOnLoad) {
+  const fileContent = await import_fs.default.promises.readFile(assetPath);
+  const { buildType, format, outDir } = this.config;
+  const { limit, path, publicPath } = this.config.asset;
+  const hash = (0, import_utils.getHash)(fileContent, null).slice(0, 8);
+  const outputFileName = (0, import_path.basename)(assetPath).split(".").join(`.${hash}.`);
+  const outputFilePath = (0, import_path.resolve)(outDir, path, outputFileName);
+  const relativePath = (0, import_path.relative)(rebaseFrom, outputFilePath);
+  const normalizedRelativePath = (0, import_utils.normalizeSlashes)(relativePath.startsWith("..") ? relativePath : `./${relativePath}`);
+  const normalizedPublicPath = `${typeof publicPath === "function" ? publicPath(assetPath) : publicPath}${path}/${outputFileName}`;
+  let emitAsset = true;
+  let contents = normalizedPublicPath;
+  let loader = "text";
+  if (buildType === "bundle") {
+    if (fileContent.length <= limit) {
+      const mimetype = (await Promise.resolve().then(() => __toESM(require("@modern-js/utils/mime-types")))).default.lookup(assetPath);
+      const isSVG = mimetype === "image/svg+xml";
+      const data = isSVG ? encodeSVG(fileContent) : fileContent.toString("base64");
+      const encoding = isSVG ? "" : ";base64";
+      contents = `data:${mimetype}${encoding},${data}`;
+      loader = "text";
+      emitAsset = false;
+    } else if ((format === "esm" || format === "cjs") && !publicPath) {
+      contents = calledOnLoad ? fileContent : normalizedRelativePath;
+      loader = calledOnLoad ? "copy" : "text";
+      emitAsset = !calledOnLoad;
+    }
+  } else {
+    contents = normalizedRelativePath;
+  }
+  if (emitAsset) {
+    this.emitAsset(outputFilePath, {
+      type: "asset",
+      fileName: outputFilePath,
+      contents: fileContent,
+      originalFileName: assetPath
+    });
+  }
+  return {
+    contents,
+    loader
+  };
+}
+async function loadSvgr(path, options) {
+  if (!options) {
+    return;
+  }
+  const config = typeof options === "boolean" ? {} : options;
+  const filter = (0, import_pluginutils.createFilter)(config.include || SVG_REGEXP, config.exclude);
+  if (!filter(path)) {
+    return;
+  }
+  const loader = "jsx";
+  const text = import_fs.default.readFileSync(path, "utf8");
+  const jsCode = await (0, import_core.transform)(text, config, {
+    filePath: path,
+    caller: {
+      name: "svgr",
+      defaultPlugins: [
+        import_plugin_svgo.default,
+        import_plugin_jsx.default
+      ]
+    }
+  });
+  return {
+    contents: jsCode,
+    loader
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asset,
+  getAssetContents,
+  loadSvgr
+});