@modern-js/module-tools 2.35.1 → 2.36.0

package/dist/builder/feature/format-cjs.d.ts

@@ -0,0 +1,5 @@
+import { ICompiler } from '../../types';
+export declare const formatCjs: {
+  name: string;
+  apply: (compiler: ICompiler) => void;
+};

package/dist/builder/feature/format-cjs.js

@@ -0,0 +1,53 @@
+"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 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var format_cjs_exports = {};
+__export(format_cjs_exports, {
+  formatCjs: () => formatCjs
+});
+module.exports = __toCommonJS(format_cjs_exports);
+var import_sucrase = require("sucrase");
+const name = "format-cjs";
+const apply = (compiler) => {
+  compiler.hooks.renderChunk.tapPromise({
+    name
+  }, async (chunk) => {
+    if (chunk.fileName.endsWith(".js") && chunk.type === "chunk") {
+      const code = chunk.contents.toString();
+      const result = (0, import_sucrase.transform)(code, {
+        transforms: [
+          "imports"
+        ]
+      });
+      return {
+        ...chunk,
+        contents: result.code,
+        map: result.sourceMap
+      };
+    }
+    return chunk;
+  });
+};
+const formatCjs = {
+  name,
+  apply
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatCjs
+});

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

@@ -0,0 +1,2 @@
+import { HookList, Context } from '../../types';
+export declare function getInternalList(context: Context): Promise<HookList>;

package/dist/builder/feature/index.js

@@ -0,0 +1,74 @@
+"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 feature_exports = {};
+__export(feature_exports, {
+  getInternalList: () => getInternalList
+});
+module.exports = __toCommonJS(feature_exports);
+var import_dts = require("../../utils/dts");
+var import_format_cjs = require("./format-cjs");
+var import_style = require("./style");
+var import_terser = require("./terser");
+var import_asset = require("./asset");
+async function getInternalList(context) {
+  var _userTsconfig_compilerOptions;
+  const internal = [];
+  const { config } = context;
+  internal.push(import_asset.asset, import_style.css);
+  if (config.buildType === "bundle" && config.format === "cjs" && config.splitting) {
+    internal.push(import_format_cjs.formatCjs);
+  }
+  if (config.buildType === "bundleless") {
+    const { redirect } = await Promise.resolve().then(() => __toESM(require("./redirect")));
+    const { json } = await Promise.resolve().then(() => __toESM(require("./json")));
+    internal.push(redirect, json);
+  }
+  if (config.minify && config.minify !== "esbuild") {
+    internal.push(import_terser.minify);
+  }
+  const userTsconfig = await (0, import_dts.getProjectTsconfig)(context.config.tsconfig);
+  var _userTsconfig_compilerOptions_emitDecoratorMetadata;
+  const emitDecoratorMetadata = (_userTsconfig_compilerOptions_emitDecoratorMetadata = userTsconfig === null || userTsconfig === void 0 ? void 0 : (_userTsconfig_compilerOptions = userTsconfig.compilerOptions) === null || _userTsconfig_compilerOptions === void 0 ? void 0 : _userTsconfig_compilerOptions.emitDecoratorMetadata) !== null && _userTsconfig_compilerOptions_emitDecoratorMetadata !== void 0 ? _userTsconfig_compilerOptions_emitDecoratorMetadata : false;
+  const { transformImport, transformLodash, externalHelpers, format, target } = context.config;
+  const enbaleSwcTransform = transformImport.length > 0 || transformLodash || externalHelpers || emitDecoratorMetadata;
+  const enableSwcRenderChunk = enbaleSwcTransform ? format === "umd" : format === "umd" || target === "es5";
+  if (enbaleSwcTransform) {
+    const { swcTransform } = await Promise.resolve().then(() => __toESM(require("./swc")));
+    internal.push(swcTransform(userTsconfig));
+  }
+  if (enableSwcRenderChunk) {
+    const { swcRenderChunk } = await Promise.resolve().then(() => __toESM(require("./swc")));
+    internal.push(swcRenderChunk);
+  }
+  return internal;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getInternalList
+});

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

@@ -0,0 +1,5 @@
+import { ICompiler } from '../../types';
+export declare const json: {
+  name: string;
+  apply(compiler: ICompiler): void;
+};

package/dist/builder/feature/json.js

@@ -0,0 +1,47 @@
+"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 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var json_exports = {};
+__export(json_exports, {
+  json: () => json
+});
+module.exports = __toCommonJS(json_exports);
+var import_fs = require("fs");
+const isJsonExt = (path) => {
+  return path.endsWith(".json");
+};
+const name = "json";
+const json = {
+  name,
+  apply(compiler) {
+    compiler.hooks.load.tapPromise({
+      name
+    }, async (args) => {
+      if (isJsonExt(args.path)) {
+        return {
+          contents: (0, import_fs.readFileSync)(args.path),
+          loader: "copy"
+        };
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  json
+});

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

@@ -0,0 +1,5 @@
+import { ICompiler } from '../../types';
+export declare const redirect: {
+  name: string;
+  apply(compiler: ICompiler): void;
+};

package/dist/builder/feature/redirect.js

@@ -0,0 +1,217 @@
+"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 redirect_exports = {};
+__export(redirect_exports, {
+  redirect: () => redirect
+});
+module.exports = __toCommonJS(redirect_exports);
+var import_path = require("path");
+var import_napi = require("@ast-grep/napi");
+var import_magic_string = __toESM(require("magic-string"));
+var import_tsconfig_paths = require("@modern-js/utils/tsconfig-paths");
+var import_utils = require("@modern-js/utils");
+var import_file = require("../../constants/file");
+var import_utils2 = require("../../utils");
+var import_asset = require("./asset");
+var import_postcssTransformer = require("./style/postcssTransformer");
+async function redirectImport(compiler, code, modules, aliasRecord, filePath, outputDir, matchPath) {
+  const str = new import_magic_string.default(code);
+  const extensions = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx"
+  ];
+  await Promise.all(modules.map(async (module2) => {
+    if (!module2.name) {
+      return;
+    }
+    const { start, end } = module2;
+    let { name: name2 } = module2;
+    const { redirect: redirect2, asset } = compiler.config;
+    const { alias, style } = redirect2;
+    if (alias) {
+      let absoluteImportPath = matchPath ? matchPath(name2, void 0, void 0, extensions) : void 0;
+      for (const alias2 of Object.keys(aliasRecord)) {
+        if (name2.startsWith(`${alias2}/`)) {
+          absoluteImportPath = (0, import_path.join)(aliasRecord[alias2], name2.slice(alias2.length + 1));
+          break;
+        }
+        if (name2 === alias2) {
+          absoluteImportPath = aliasRecord[alias2];
+          break;
+        }
+      }
+      if (absoluteImportPath) {
+        const relativePath = (0, import_path.relative)((0, import_path.dirname)(filePath), absoluteImportPath);
+        const relativeImportPath = (0, import_utils2.normalizeSlashes)(relativePath.startsWith("..") ? relativePath : `./${relativePath}`);
+        str.overwrite(start, end, relativeImportPath);
+        name2 = relativeImportPath;
+      }
+    }
+    if (style) {
+      const ext = (0, import_path.extname)(name2);
+      const { originalFilePath, query } = (0, import_utils2.resolvePathAndQuery)(name2);
+      if (query.css_virtual) {
+        const replacedName = (0, import_path.basename)(originalFilePath, (0, import_path.extname)(originalFilePath)).replace(".", "_");
+        const base = `${replacedName}.css`;
+        const key = query.hash;
+        const contents = compiler.virtualModule.get(key);
+        const fileName = (0, import_path.join)(outputDir, base);
+        compiler.emitAsset(fileName, {
+          type: "asset",
+          contents,
+          fileName,
+          originalFileName: name2
+        });
+        const relativeImportPath = (0, import_utils2.normalizeSlashes)(`./${base}`);
+        str.overwrite(start, end, relativeImportPath);
+      }
+      if (!name2.startsWith(".")) {
+        return;
+      }
+      if (ext === ".less" || ext === ".sass" || ext === ".scss" || ext === ".css") {
+        var _compiler_config_style_autoModules;
+        if ((0, import_postcssTransformer.isCssModule)(name2, (_compiler_config_style_autoModules = compiler.config.style.autoModules) !== null && _compiler_config_style_autoModules !== void 0 ? _compiler_config_style_autoModules : true)) {
+          str.overwrite(start, end, `${name2.slice(0, -ext.length)}`);
+        } else {
+          str.overwrite(start, end, `${name2.slice(0, -ext.length)}.css`);
+        }
+        return;
+      }
+    }
+    if (redirect2.asset) {
+      if (import_file.assetExt.filter((ext) => name2.endsWith(ext)).length) {
+        const absPath = (0, import_path.resolve)((0, import_path.dirname)(filePath), name2);
+        const svgrResult = await (0, import_asset.loadSvgr)(absPath, asset.svgr);
+        if (svgrResult) {
+          const ext = (0, import_path.extname)(name2);
+          const outputName = `${name2.slice(0, -ext.length)}.js`;
+          str.overwrite(start, end, outputName);
+        } else {
+          const { contents: relativeImportPath } = await import_asset.getAssetContents.apply(compiler, [
+            absPath,
+            outputDir
+          ]);
+          str.overwrite(start, end, `${relativeImportPath}`);
+        }
+      }
+    }
+  }));
+  return str;
+}
+const name = "redirect";
+const redirect = {
+  name,
+  apply(compiler) {
+    let matchPath;
+    if (import_utils.fs.existsSync(compiler.config.tsconfig)) {
+      const result = (0, import_tsconfig_paths.loadConfig)(compiler.config.tsconfig);
+      if (result.resultType === "success") {
+        const { absoluteBaseUrl, paths, mainFields, addMatchAll } = result;
+        matchPath = (0, import_tsconfig_paths.createMatchPath)(absoluteBaseUrl, paths, mainFields, addMatchAll);
+      }
+    }
+    compiler.hooks.transform.tapPromise({
+      name
+    }, async (args) => {
+      if (!(0, import_utils2.isJsExt)(args.path) && !(0, import_utils2.isJsLoader)(args.loader)) {
+        return args;
+      }
+      const { code, path: id } = args;
+      const { format, alias, sourceDir, outDir } = compiler.config;
+      if (!code || format === "iife" || format === "umd") {
+        return args;
+      }
+      const absoluteAlias = Object.entries(alias).reduce((result, [name2, target]) => {
+        if (!(0, import_path.isAbsolute)(target)) {
+          result[name2] = (0, import_path.resolve)(compiler.context.root, target);
+        } else {
+          result[name2] = target;
+        }
+        return result;
+      }, {});
+      let matchModule = [];
+      try {
+        const sgNode = import_napi.js.parse(code).root();
+        const funcPattern = [
+          `require($MATCH)`,
+          `import($MATCH)`
+        ];
+        const staticPattern = [
+          `import $$VAR from '$MATCH'`,
+          `import $$VAR from "$MATCH"`,
+          `import '$MATCH'`,
+          `import "$MATCH"`
+        ];
+        const funcMatchModule = funcPattern.map((p) => {
+          return sgNode.findAll(p);
+        }).flat().map((node) => {
+          const matchNode = node.getMatch("MATCH");
+          return {
+            name: matchNode.text().slice(1, -1),
+            start: matchNode.range().start.index + 1,
+            end: matchNode.range().end.index - 1
+          };
+        });
+        const staticMatchModule = staticPattern.map((p) => sgNode.findAll(p)).flat().map((node) => {
+          const matchNode = node.getMatch("MATCH");
+          return {
+            name: matchNode.text(),
+            start: matchNode.range().start.index,
+            end: matchNode.range().end.index
+          };
+        });
+        matchModule = [
+          ...funcMatchModule,
+          ...staticMatchModule
+        ];
+      } catch (e) {
+        import_utils.logger.error("[parse error]", e);
+      }
+      if (!matchModule.length) {
+        return args;
+      }
+      const outputPath = (0, import_path.resolve)(outDir, (0, import_path.relative)(sourceDir, id));
+      const str = await redirectImport(compiler, code, matchModule, absoluteAlias, id, (0, import_path.dirname)(outputPath), matchPath);
+      return {
+        ...args,
+        code: str.toString(),
+        map: str.generateMap({
+          hires: true,
+          includeContent: true
+        })
+      };
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  redirect
+});

package/dist/builder/feature/style/index.d.ts

@@ -0,0 +1,5 @@
+import { ICompiler } from '../../../types';
+export declare const css: {
+  name: string;
+  apply(compiler: ICompiler): void;
+};

package/dist/builder/feature/style/index.js

@@ -0,0 +1,94 @@
+"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 style_exports = {};
+__export(style_exports, {
+  css: () => css
+});
+module.exports = __toCommonJS(style_exports);
+var import_fs = require("fs");
+var import_safe_identifier = require("safe-identifier");
+var import_utils = require("../../../utils");
+var import_transformStyle = require("./transformStyle");
+const name = "css";
+const css = {
+  name,
+  apply(compiler) {
+    compiler.hooks.load.tapPromise({
+      name
+    }, async (args) => {
+      if ((0, import_utils.isStyleExt)(args.path)) {
+        const { query } = (0, import_utils.resolvePathAndQuery)(args.path);
+        if (query === null || query === void 0 ? void 0 : query.css_virtual) {
+          const key = query.hash;
+          const contents = compiler.virtualModule.get(key);
+          return {
+            contents,
+            loader: "css"
+          };
+        }
+        return {
+          contents: (0, import_fs.readFileSync)(args.path),
+          loader: "css"
+        };
+      }
+    });
+    compiler.hooks.transform.tapPromise({
+      name
+    }, async (source) => {
+      if ((0, import_utils.isStyleExt)(source.path)) {
+        let { code, loader = "css" } = source;
+        const { query } = (0, import_utils.resolvePathAndQuery)(source.path);
+        if (!(query === null || query === void 0 ? void 0 : query.css_virtual)) {
+          ({ code, loader } = await import_transformStyle.transformStyle.apply(compiler, [
+            source
+          ]));
+        }
+        const { style, buildType } = compiler.config;
+        if (style.inject && buildType === "bundle" && loader === "css") {
+          const styleInjectPath = require.resolve("style-inject/dist/style-inject.es").replace(/[\\/]+/g, "/");
+          const cssVariableName = (0, import_safe_identifier.identifier)("css", true);
+          code = `var ${cssVariableName} = ${JSON.stringify(code)};
+import styleInject from '${styleInjectPath}';
+styleInject(${cssVariableName});`;
+          loader = "js";
+        }
+        return {
+          ...source,
+          code,
+          loader
+        };
+      }
+      return source;
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  css
+});

package/dist/builder/feature/style/lessAliasPlugin.d.ts

@@ -0,0 +1,12 @@
+import { ICompiler } from '../../../types';
+interface Options {
+  compiler: ICompiler;
+  stdinDir: string;
+}
+export default class LessAliasesPlugin {
+  compiler: ICompiler;
+  stdinDir: string;
+  constructor(options: Options);
+  install(less: any, pluginManager: any): void;
+}
+export {};

package/dist/builder/feature/style/lessAliasPlugin.js

@@ -0,0 +1,70 @@
+"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 lessAliasPlugin_exports = {};
+__export(lessAliasPlugin_exports, {
+  default: () => LessAliasesPlugin
+});
+module.exports = __toCommonJS(lessAliasPlugin_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_fs = __toESM(require("fs"));
+var import_utils = require("./utils");
+class LessAliasesPlugin {
+  install(less, pluginManager) {
+    const getResolve = (filename, currentDirectory) => {
+      return this.compiler.css_resolve(filename, currentDirectory || this.stdinDir);
+    };
+    class AliasPlugin extends less.FileManager {
+      async loadFile(filename, currentDirectory) {
+        const resolved = getResolve(filename, currentDirectory);
+        const rebasedContents = await (0, import_utils.rebaseUrls)(resolved, this.stdinDir, this.compiler.css_resolve);
+        const contents = rebasedContents.contents ? rebasedContents.contents : import_fs.default.readFileSync(resolved, "utf8");
+        return {
+          filename: resolved,
+          contents
+        };
+      }
+      constructor(options) {
+        super();
+        (0, import_define_property._)(this, "compiler", void 0);
+        this.compiler = options.compiler;
+        this.stdinDir = options.stdinDir;
+      }
+    }
+    pluginManager.addFileManager(new AliasPlugin({
+      compiler: this.compiler,
+      stdinDir: this.stdinDir
+    }));
+  }
+  constructor(options) {
+    (0, import_define_property._)(this, "compiler", void 0);
+    (0, import_define_property._)(this, "stdinDir", void 0);
+    this.compiler = options.compiler;
+    this.stdinDir = options.stdinDir;
+  }
+}

package/dist/builder/feature/style/lessRender.d.ts

@@ -0,0 +1,2 @@
+import { PreprocessRender } from './transformStyle';
+export declare const lessRender: PreprocessRender;

package/dist/builder/feature/style/lessRender.js

@@ -0,0 +1,64 @@
+"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 lessRender_exports = {};
+__export(lessRender_exports, {
+  lessRender: () => lessRender
+});
+module.exports = __toCommonJS(lessRender_exports);
+var import_utils = require("./utils");
+var import_lessAliasPlugin = __toESM(require("./lessAliasPlugin"));
+const lessRender = async function(content, originPath, stdinDir, options, _, implementation) {
+  const less = await (0, import_utils.loadProcessor)("less", this.context.root, implementation);
+  const result = {
+    ...await less.render(content, {
+      relativeUrls: true,
+      filename: originPath,
+      ...options,
+      paths: [
+        ...(options === null || options === void 0 ? void 0 : options.paths) || [
+          "node_modules"
+        ],
+        this.context.root,
+        stdinDir
+      ],
+      plugins: [
+        new import_lessAliasPlugin.default({
+          compiler: this,
+          stdinDir
+        }),
+        ...(options === null || options === void 0 ? void 0 : options.plugins) || []
+      ]
+    })
+  };
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lessRender
+});

package/dist/builder/feature/style/postcssTransformer.d.ts

@@ -0,0 +1,6 @@
+import { ICompiler } from '../../../types';
+export declare const isCssModule: (filePath: string, autoModules: boolean | RegExp) => boolean;
+export declare const postcssTransformer: (css: string, entryPath: string, compilation: ICompiler) => Promise<{
+  code: string;
+  loader: 'js' | 'css';
+}>;