@modern-js/module-tools 2.35.1 → 2.37.0

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

@@ -0,0 +1,85 @@
+"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 sassRender_exports = {};
+__export(sassRender_exports, {
+  sassRender: () => sassRender
+});
+module.exports = __toCommonJS(sassRender_exports);
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+var import_utils = require("./utils");
+const sassRender = async function(content, _, stdinDir, options, resolvePathMap, implementation) {
+  const sass = await (0, import_utils.loadProcessor)("sass", this.context.root, implementation);
+  return new Promise((resolve, reject) => {
+    sass.render({
+      data: content,
+      importer: [
+        (url, dir, done) => {
+          if (url.startsWith("data:")) {
+            done({
+              contents: url
+            });
+          }
+          let filePath = null;
+          const baseUrl = import_path.default.basename(url);
+          const dirUrl = import_path.default.dirname(url);
+          const removeUnderScoreBaseUrl = baseUrl.replace(/^_/, "");
+          const prependUnderScoreBaseUrl = `_${removeUnderScoreBaseUrl}`;
+          try {
+            const id = import_path.default.join(dirUrl, prependUnderScoreBaseUrl);
+            filePath = this.css_resolve(id, dir === "stdin" ? stdinDir : resolvePathMap.get(dir));
+          } catch (err) {
+            const id = import_path.default.join(dirUrl, removeUnderScoreBaseUrl);
+            filePath = this.css_resolve(id, dir === "stdin" ? stdinDir : resolvePathMap.get(dir));
+          }
+          resolvePathMap.set(url, import_path.default.dirname(filePath));
+          if (url.startsWith("./")) {
+            resolvePathMap.set(url.replace(/^\.\//, ""), import_path.default.dirname(filePath));
+          }
+          (0, import_utils.rebaseUrls)(filePath, stdinDir, this.css_resolve).then((value) => {
+            done({
+              contents: value.contents || (0, import_fs.readFileSync)(value.file, "utf-8")
+            });
+          });
+        }
+      ],
+      ...options
+    }, (err, res) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(res);
+      }
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sassRender
+});

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { PartialMessage } from 'esbuild';
+import { ICompiler, Source } from '../../../types';
+export type PreprocessRender = (content: string, stdinPath: string, stdinDir: string, preprocessOptions: any, resolvePathMap: Map<string, string>, implementation?: object | string) => Promise<{
+  css: Buffer | string;
+  errors?: PartialMessage[];
+  warnings?: PartialMessage[];
+  map?: Buffer | string;
+}>;
+export declare function transformStyle(this: ICompiler, source: Source): Promise<{
+  code: string;
+  loader: "js" | "css";
+}>;

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

@@ -0,0 +1,101 @@
+"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 transformStyle_exports = {};
+__export(transformStyle_exports, {
+  transformStyle: () => transformStyle
+});
+module.exports = __toCommonJS(transformStyle_exports);
+var import_path = __toESM(require("path"));
+var import_postcssTransformer = require("./postcssTransformer");
+var import_lessRender = require("./lessRender");
+var import_sassRender = require("./sassRender");
+const cssLangs = `\\.(css|less|sass|scss)($|\\?)`;
+const cssLangRE = new RegExp(cssLangs);
+const cssRender = async function(content) {
+  return {
+    css: content
+  };
+};
+const renderMap = {
+  less: import_lessRender.lessRender,
+  sass: import_sassRender.sassRender,
+  scss: import_sassRender.sassRender,
+  css: cssRender
+};
+async function transformStyle(source) {
+  var _source_path_match;
+  const lang = (_source_path_match = source.path.match(cssLangRE)) === null || _source_path_match === void 0 ? void 0 : _source_path_match[1];
+  if (!lang) {
+    throw new Error(`UNSUPPORTED_CSS_LANG: not supported css lang${lang}`);
+  }
+  const { less, sass } = this.config.style;
+  let options;
+  let additionalData;
+  let implementation;
+  if (lang === "less") {
+    options = less === null || less === void 0 ? void 0 : less.lessOptions;
+    additionalData = less === null || less === void 0 ? void 0 : less.additionalData;
+    implementation = less === null || less === void 0 ? void 0 : less.implementation;
+  }
+  if (lang === "scss" || lang === "sass") {
+    options = sass === null || sass === void 0 ? void 0 : sass.sassOptions;
+    additionalData = sass === null || sass === void 0 ? void 0 : sass.additionalData;
+    implementation = sass === null || sass === void 0 ? void 0 : sass.implementation;
+  }
+  const preprocessRender = renderMap[lang];
+  const stdinDir = import_path.default.dirname(source.path);
+  const resolvePathMap = /* @__PURE__ */ new Map();
+  let content = "";
+  if (typeof additionalData === "string") {
+    content = `${additionalData}
+`;
+  } else if (typeof additionalData === "function") {
+    content = `${additionalData(source.path)}
+`;
+  }
+  content += source.code;
+  const renderResult = await preprocessRender.apply(this, [
+    content,
+    source.path,
+    stdinDir,
+    options,
+    resolvePathMap,
+    implementation
+  ]);
+  const css = renderResult.css.toString();
+  const { code, loader } = await (0, import_postcssTransformer.postcssTransformer)(css !== null && css !== void 0 ? css : "", source.path, this);
+  return {
+    code,
+    loader
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformStyle
+});

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

@@ -0,0 +1,18 @@
+/**
+ * make sure load processor in user project root other than root
+ * @param lang
+ * @param root
+ * @returns
+ */
+export declare function loadProcessor(lang: string, root: string, implementation?: object | string): any;
+type CssUrlReplacer = (url: string, importer?: string) => string | Promise<string>;
+/**
+ * relative url() inside \@imported sass and less files must be rebased to use
+ * root file as base.
+ */
+export declare function rebaseUrls(filepath: string, rootDir: string, resolver: (id: string, dir: string) => string): Promise<{
+  file: string;
+  contents?: string;
+}>;
+export declare function rewriteCssUrls(css: string, type: false | string, replacer: CssUrlReplacer): Promise<string>;
+export {};

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

@@ -0,0 +1,130 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  loadProcessor: () => loadProcessor,
+  rebaseUrls: () => rebaseUrls,
+  rewriteCssUrls: () => rewriteCssUrls
+});
+module.exports = __toCommonJS(utils_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("../../../utils");
+const cache = {};
+function loadProcessor(lang, root, implementation) {
+  if (cache[lang]) {
+    return cache[lang];
+  }
+  try {
+    if (typeof implementation === "string") {
+      return cache[lang] = require(implementation);
+    }
+    if (typeof implementation === "object") {
+      return cache[lang] = implementation;
+    }
+    const loadPath = require.resolve(lang, {
+      paths: [
+        root
+      ]
+    });
+    return cache[lang] = require(loadPath);
+  } catch (err) {
+    throw new Error(`${lang} require failed, please install it or use implemention`);
+  }
+}
+const dataUrlRE = /^\s*data:/i;
+const cssUrlRE = RegExp(`(?<=^|[^\\w\\-\\u0080-\\uffff])url\\(\\s*('[^']+'|"[^"]+"|[^'")]+)\\s*\\)`);
+const externalRE = /^(https?:)?\/\//;
+const isDataUrl = (url) => dataUrlRE.test(url);
+const isExternalUrl = (url) => externalRE.test(url);
+async function rebaseUrls(filepath, rootDir, resolver) {
+  const file = import_path.default.resolve(filepath);
+  const fileDir = import_path.default.dirname(file);
+  if (fileDir === rootDir) {
+    return {
+      file
+    };
+  }
+  const content = import_fs.default.readFileSync(file, "utf-8");
+  if (!cssUrlRE.test(content)) {
+    return {
+      file
+    };
+  }
+  try {
+    const rebased = await rewriteCssUrls(content, import_path.default.extname(file).slice(1), (url) => {
+      if (url.startsWith("/")) {
+        return url;
+      }
+      return resolver(url, fileDir);
+    });
+    return {
+      file,
+      contents: rebased
+    };
+  } catch (e) {
+    return {
+      file
+    };
+  }
+}
+function rewriteCssUrls(css, type, replacer) {
+  return asyncReplace(css, cssUrlRE, async (match) => {
+    const matched = match[0];
+    let rawUrl = match[1];
+    let wrap = "";
+    const first = rawUrl[0];
+    if (first === `"` || first === `'`) {
+      wrap = first;
+      rawUrl = rawUrl.slice(1, -1);
+    }
+    if (type === "less" && rawUrl.startsWith("@") || (type === "sass" || type === "scss") && rawUrl.startsWith("$") || isExternalUrl(rawUrl) || isDataUrl(rawUrl) || rawUrl.startsWith("#")) {
+      return matched;
+    }
+    return `url(${wrap}${(0, import_utils.normalizeSlashes)(await replacer(rawUrl))}${wrap})`;
+  });
+}
+async function asyncReplace(input, re, replacer) {
+  let match;
+  let remaining = input;
+  let rewritten = "";
+  while (match = re.exec(remaining)) {
+    rewritten += remaining.slice(0, match.index);
+    rewritten += await replacer(match);
+    remaining = remaining.slice(match.index + match[0].length);
+  }
+  rewritten += remaining;
+  return rewritten;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadProcessor,
+  rebaseUrls,
+  rewriteCssUrls
+});

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

@@ -0,0 +1,9 @@
+import type { ICompiler, ITsconfig } from '../../types';
+export declare const swcTransform: (userTsconfig: ITsconfig) => {
+  name: string;
+  apply(compiler: ICompiler): void;
+};
+export declare const swcRenderChunk: {
+  name: string;
+  apply(compiler: ICompiler): void;
+};

package/dist/builder/feature/swc.js

@@ -0,0 +1,170 @@
+"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 swc_exports = {};
+__export(swc_exports, {
+  swcRenderChunk: () => swcRenderChunk,
+  swcTransform: () => swcTransform
+});
+module.exports = __toCommonJS(swc_exports);
+var import_path = require("path");
+var import_swc_plugins = require("@modern-js/swc-plugins");
+var import_utils = require("../../utils");
+const name = "swc:transform";
+const getSwcTarget = (target) => {
+  const list = [
+    "es3",
+    "es5",
+    "es2015",
+    "es2016",
+    "es2017",
+    "es2018",
+    "es2019",
+    "es2020",
+    "es2021",
+    "es2022"
+  ];
+  if (list.includes(target)) {
+    return target;
+  }
+  if (target === "next") {
+    return "es2022";
+  }
+  if (target === "es6") {
+    return "es2015";
+  }
+  return "es2022";
+};
+const swcTransform = (userTsconfig) => ({
+  name,
+  apply(compiler) {
+    var _userTsconfig_compilerOptions, _userTsconfig_compilerOptions1, _userTsconfig_compilerOptions2;
+    const tsUseDefineForClassFields = userTsconfig === null || userTsconfig === void 0 ? void 0 : (_userTsconfig_compilerOptions = userTsconfig.compilerOptions) === null || _userTsconfig_compilerOptions === void 0 ? void 0 : _userTsconfig_compilerOptions.useDefineForClassFields;
+    var _userTsconfig_compilerOptions_emitDecoratorMetadata;
+    const emitDecoratorMetadata = (_userTsconfig_compilerOptions_emitDecoratorMetadata = userTsconfig === null || userTsconfig === void 0 ? void 0 : (_userTsconfig_compilerOptions1 = userTsconfig.compilerOptions) === null || _userTsconfig_compilerOptions1 === void 0 ? void 0 : _userTsconfig_compilerOptions1.emitDecoratorMetadata) !== null && _userTsconfig_compilerOptions_emitDecoratorMetadata !== void 0 ? _userTsconfig_compilerOptions_emitDecoratorMetadata : false;
+    let useDefineForClassFields;
+    let tsTarget = userTsconfig === null || userTsconfig === void 0 ? void 0 : (_userTsconfig_compilerOptions2 = userTsconfig.compilerOptions) === null || _userTsconfig_compilerOptions2 === void 0 ? void 0 : _userTsconfig_compilerOptions2.target;
+    tsTarget = tsTarget ? tsTarget.toLowerCase() : void 0;
+    if (tsUseDefineForClassFields !== void 0) {
+      useDefineForClassFields = tsUseDefineForClassFields;
+    } else if (tsTarget !== void 0) {
+      useDefineForClassFields = (0, import_utils.tsTargetAtOrAboveES2022)(tsTarget);
+    } else {
+      useDefineForClassFields = true;
+    }
+    const { transformImport, transformLodash, externalHelpers } = compiler.config;
+    compiler.hooks.transform.tapPromise({
+      name
+    }, async (source) => {
+      const { path } = source;
+      const isTs = (0, import_utils.isTsLoader)(source.loader) || (0, import_utils.isTsExt)(path);
+      const enableJsx = source.loader === "tsx" || source.loader === "jsx" || /\.tsx$|\.jsx$/i.test(path);
+      if ((0, import_utils.isJsExt)(path) || (0, import_utils.isJsLoader)(source.loader)) {
+        const { target, jsx } = compiler.config;
+        const swcCompilerOptions = {
+          sourceMaps: Boolean(compiler.config.sourceMap),
+          inputSourceMap: false,
+          swcrc: false,
+          configFile: false,
+          jsc: {
+            parser: isTs ? {
+              syntax: "typescript",
+              tsx: enableJsx,
+              decorators: true
+            } : {
+              syntax: "ecmascript",
+              jsx: enableJsx,
+              decorators: true
+            },
+            transform: {
+              react: {
+                runtime: jsx === "transform" ? "classic" : "automatic"
+              },
+              useDefineForClassFields,
+              legacyDecorator: emitDecoratorMetadata ? true : void 0,
+              decoratorMetadata: emitDecoratorMetadata ? true : void 0
+            },
+            externalHelpers,
+            target: getSwcTarget(target)
+          },
+          isModule: "unknown",
+          extensions: {
+            pluginImport: transformImport,
+            lodash: transformLodash ? {
+              cwd: compiler.context.root,
+              ids: [
+                "lodash",
+                "lodash-es"
+              ]
+            } : void 0
+          }
+        };
+        const swcCompiler = new import_swc_plugins.Compiler(swcCompilerOptions);
+        const result = await swcCompiler.transform((0, import_path.basename)(path), source.code);
+        return {
+          ...source,
+          code: result.code,
+          map: typeof result.map === "string" ? JSON.parse(result.map) : result.map
+        };
+      }
+      return source;
+    });
+  }
+});
+const swcRenderChunk = {
+  name: "swc:renderChunk",
+  apply(compiler) {
+    compiler.hooks.renderChunk.tapPromise({
+      name: "swc:renderChunk"
+    }, async (chunk) => {
+      if (chunk.fileName.endsWith(".js") && chunk.type === "chunk") {
+        const { umdModuleName, format } = compiler.config;
+        const name2 = typeof umdModuleName === "function" ? umdModuleName(chunk.fileName) : umdModuleName;
+        const swcCompiler = new import_swc_plugins.Compiler({
+          sourceMaps: Boolean(compiler.config.sourceMap),
+          inputSourceMap: false,
+          swcrc: false,
+          configFile: false,
+          extensions: {},
+          jsc: {
+            target: getSwcTarget(compiler.config.target),
+            parser: {
+              syntax: "ecmascript"
+            }
+          },
+          module: format === "umd" ? {
+            type: "umd"
+          } : void 0,
+          isModule: "unknown"
+        });
+        const result = await swcCompiler.transform(name2, chunk.contents.toString());
+        return {
+          ...chunk,
+          contents: result.code,
+          map: typeof result.map === "string" ? JSON.parse(result.map) : result.map
+        };
+      }
+      return chunk;
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  swcRenderChunk,
+  swcTransform
+});

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

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

package/dist/builder/feature/terser.js

@@ -0,0 +1,83 @@
+"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 terser_exports = {};
+__export(terser_exports, {
+  minify: () => minify
+});
+module.exports = __toCommonJS(terser_exports);
+var import_utils = require("@modern-js/utils");
+var import_terser = require("terser");
+var import_types = require("../../types");
+var import_utils2 = require("../../utils");
+const name = "terser";
+const apply = (compiler) => {
+  compiler.hooks.renderChunk.tapPromise({
+    name
+  }, async (chunk) => {
+    const { sourceMap, minify: minify2 } = compiler.config;
+    if (chunk.type === import_types.ChunkType.chunk) {
+      const code = chunk.contents.toString();
+      const needSourceMap = Boolean(sourceMap);
+      const terserOptions = resolveTerserOptions(minify2, {
+        sourceMap: Boolean(needSourceMap)
+      });
+      const result = await (0, import_terser.minify)(code, {
+        ...terserOptions,
+        sourceMap: needSourceMap
+      });
+      return {
+        ...chunk,
+        contents: result.code || chunk.contents,
+        map: (0, import_utils2.normalizeSourceMap)(result.map, {
+          needSourceMap
+        })
+      };
+    }
+    return chunk;
+  });
+};
+const minify = {
+  name,
+  apply
+};
+function resolveTerserOptions(terserOptions, { sourceMap }) {
+  return import_utils.lodash.merge({
+    compress: {
+      inline: 2,
+      comparisons: false
+    },
+    format: {
+      keep_quoted_props: true,
+      comments: false
+    },
+    // Return object to avoid redundant `JSON.parse` in remapping
+    sourceMap: sourceMap ? {
+      asObject: true,
+      // `includeSources` is not necessary for minification,
+      // and we can utilize this to reduce the size of the source map.
+      includeSources: false
+    } : false,
+    safari10: true,
+    toplevel: true
+  }, (0, import_utils.isObject)(terserOptions) ? terserOptions : {});
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  minify
+});