@tailwindcss-mangle/core 2.2.2 → 2.3.0

package/dist/index.cjs

@@ -2,32 +2,49 @@
 
 const fs = require('node:fs');
 const node_path = require('node:path');
+const process = require('node:process');
 const shared = require('@tailwindcss-mangle/shared');
 const config = require('@tailwindcss-mangle/config');
 const fastSort = require('fast-sort');
 const micromatch = require('micromatch');
 const postcss = require('postcss');
 const parser = require('postcss-selector-parser');
-const parse5 = require('parse5');
-const babel = require('@babel/core');
-const helperPluginUtils = require('@babel/helper-plugin-utils');
+const htmlparser2 = require('htmlparser2');
 const MagicString = require('magic-string');
 const escape = require('@ast-core/escape');
+const _babelTraverse = require('@babel/traverse');
+const parser$1 = require('@babel/parser');
+const compilerSfc = require('@vue/compiler-sfc');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
 const micromatch__default = /*#__PURE__*/_interopDefaultCompat(micromatch);
 const postcss__default = /*#__PURE__*/_interopDefaultCompat(postcss);
 const parser__default = /*#__PURE__*/_interopDefaultCompat(parser);
-const babel__default = /*#__PURE__*/_interopDefaultCompat(babel);
 const MagicString__default = /*#__PURE__*/_interopDefaultCompat(MagicString);
+const _babelTraverse__default = /*#__PURE__*/_interopDefaultCompat(_babelTraverse);
 
-function isObject(value) {
-  return value !== null && typeof value === "object";
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
 }
+
 function _defu(baseObject, defaults, namespace = ".", merger) {
-  if (!isObject(defaults)) {
+  if (!isPlainObject(defaults)) {
     return _defu(baseObject, {}, namespace, merger);
   }
   const object = Object.assign({}, defaults);
@@ -44,7 +61,7 @@ function _defu(baseObject, defaults, namespace = ".", merger) {
     }
     if (Array.isArray(value) && Array.isArray(object[key])) {
       object[key] = [...value, ...object[key]];
-    } else if (isObject(value) && isObject(object[key])) {
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
       object[key] = _defu(
         value,
         object[key],
@@ -126,7 +143,7 @@ class Context {
     this.classGenerator = new shared.ClassGenerator(this.options.classGenerator);
     this.preserveFunctionSet = new Set(this.options?.preserveFunction ?? []);
     this.preserveFunctionRegexs = [...this.preserveFunctionSet.values()].map((x) => {
-      return new RegExp(escapeStringRegexp(x) + "\\(([^)]*)\\)", "g");
+      return new RegExp(`${escapeStringRegexp(x)}\\(([^)]*)\\)`, "g");
     });
   }
   isInclude(file) {
@@ -162,9 +179,9 @@ class Context {
     if (_classList) {
       this.loadClassSet(_classList);
     } else {
-      let jsonPath = this.options.classListPath ?? node_path.resolve(process.cwd(), config$1?.patch?.output?.filename);
+      let jsonPath = this.options.classListPath ?? node_path.resolve(process__default.cwd(), config$1?.patch?.output?.filename);
       if (!node_path.isAbsolute(jsonPath)) {
-        jsonPath = node_path.resolve(configCwd ?? process.cwd(), jsonPath);
+        jsonPath = node_path.resolve(configCwd ?? process__default.cwd(), jsonPath);
       }
       if (jsonPath && fs__default.existsSync(jsonPath)) {
         const rawClassList = fs__default.readFileSync(jsonPath, "utf8");
@@ -184,7 +201,6 @@ class Context {
 }
 
 const postcssPlugin = "postcss-mangle-tailwindcss-plugin";
-const clonedKey = "__tw_mangle_cloned__";
 function isVueScoped(s) {
   if (s.parent) {
     const index = s.parent.nodes.indexOf(s);
@@ -198,34 +214,33 @@ function isVueScoped(s) {
   return false;
 }
 const transformSelectorPostcssPlugin = function(options) {
-  const { ignoreVueScoped, replaceMap, ctx } = defu(options, {
+  const { ignoreVueScoped, ctx } = defu(options, {
     ignoreVueScoped: true
   });
+  const replaceMap = ctx.replaceMap;
   return {
     postcssPlugin,
-    async Rule(rule) {
-      if (rule[clonedKey]) {
-        return;
-      }
-      await parser__default((selectors) => {
-        selectors.walkClasses((s) => {
-          if (s.value && replaceMap && replaceMap.has(s.value)) {
-            if (ignoreVueScoped && isVueScoped(s)) {
-              return;
-            }
-            const v = replaceMap.get(s.value);
-            if (v) {
-              if (ctx.isPreserveClass(s.value)) {
-                const r = rule.cloneBefore();
-                r[clonedKey] = true;
+    Once(root) {
+      root.walkRules((rule) => {
+        parser__default((selectors) => {
+          selectors.walkClasses((s) => {
+            if (s.value && replaceMap && replaceMap.has(s.value)) {
+              if (ignoreVueScoped && isVueScoped(s)) {
+                return;
+              }
+              const v = replaceMap.get(s.value);
+              if (v) {
+                if (ctx.isPreserveClass(s.value)) {
+                  rule.cloneBefore();
+                }
+                s.value = v;
               }
-              s.value = v;
             }
-          }
+          });
+        }).transformSync(rule, {
+          lossless: false,
+          updateSelector: true
         });
-      }).transform(rule, {
-        lossless: false,
-        updateSelector: true
       });
     }
   };
@@ -241,121 +256,10 @@ function cssHandler(rawSource, options) {
   });
 }
 
-({
-    HTML: parse5.html.NS.HTML,
-    XML: parse5.html.NS.XML,
-    MATHML: parse5.html.NS.MATHML,
-    SVG: parse5.html.NS.SVG,
-    XLINK: parse5.html.NS.XLINK,
-    XMLNS: parse5.html.NS.XMLNS
-});
-
-/**
- * Determines if a given node is a document or not
- * @param {Node} node Node to test
- * @return {boolean}
- */
-function isDocument(node) {
-    return node.nodeName === '#document';
-}
-/**
- * Determines if a given node is a document fragment or not
- * @param {Node} node Node to test
- * @return {boolean}
- */
-function isDocumentFragment(node) {
-    return node.nodeName === '#document-fragment';
-}
-/**
- * Determines if a given node is a template node or not
- * @param {Node} node Node to test
- * @return {boolean}
- */
-function isTemplateNode(node) {
-    return node.nodeName === 'template';
-}
-const isElementNode = parse5.defaultTreeAdapter.isElementNode;
-const isCommentNode = parse5.defaultTreeAdapter.isCommentNode;
-const isDocumentTypeNode = parse5.defaultTreeAdapter.isDocumentTypeNode;
-const isTextNode = parse5.defaultTreeAdapter.isTextNode;
-/**
- * Determines if a given node is a parent or not
- * @param {Node} node Node to test
- * @return {boolean}
- */
-function isParentNode(node) {
-    return (isDocument(node) ||
-        isDocumentFragment(node) ||
-        isElementNode(node) ||
-        isTemplateNode(node));
+function _interopDefaultCompat$1(e) {
+  return e && typeof e === "object" && "default" in e ? e.default : e;
 }
-
-parse5.defaultTreeAdapter.appendChild;
-
-/**
- * Traverses the tree of a given node
- * @param {Node} node Node to traverse
- * @param {Visitor} visitor Visitor to apply
- * @param {ParentNode=} parent Parent node of the current node
- * @return {void}
- */
-function traverse(node, visitor, parent) {
-    const shouldVisitChildren = typeof visitor['pre:node'] !== 'function' ||
-        visitor['pre:node'](node, parent) !== false;
-    if (shouldVisitChildren && isParentNode(node)) {
-        for (const child of node.childNodes) {
-            traverse(child, visitor, node);
-        }
-    }
-    if (typeof visitor.node === 'function') {
-        visitor.node(node, parent);
-    }
-    if (typeof visitor.document === 'function' && isDocument(node)) {
-        visitor.document(node);
-    }
-    if (typeof visitor.documentFragment === 'function' &&
-        isDocumentFragment(node)) {
-        visitor.documentFragment(node, parent);
-    }
-    if (typeof visitor.element === 'function' && isElementNode(node)) {
-        visitor.element(node, parent);
-    }
-    if (typeof visitor.template === 'function' && isTemplateNode(node)) {
-        visitor.template(node, parent);
-    }
-    if (typeof visitor.comment === 'function' && isCommentNode(node)) {
-        visitor.comment(node, parent);
-    }
-    if (typeof visitor.text === 'function' && isTextNode(node)) {
-        visitor.text(node, parent);
-    }
-    if (typeof visitor.documentType === 'function' && isDocumentTypeNode(node)) {
-        visitor.documentType(node, parent);
-    }
-}
-
-function htmlHandler(rawSource, options) {
-  const { replaceMap, ctx } = options;
-  const fragment = parse5.parse(rawSource);
-  traverse(fragment, {
-    element(node) {
-      const attribute = node.attrs.find((x) => x.name === "class");
-      if (attribute) {
-        const array = shared.splitCode(attribute.value, {
-          splitQuote: false
-        });
-        for (const v of array) {
-          if (replaceMap.has(v)) {
-            attribute.value = attribute.value.replace(shared.makeRegex(v), ctx.classGenerator.generateClassName(v).name);
-          }
-        }
-      }
-    }
-  });
-  return parse5.serialize(fragment);
-}
-
-const isProd = () => process.env.NODE_ENV === "production";
+const traverse = _interopDefaultCompat$1(_babelTraverse__default);
 
 function between(x, min, max, included = false) {
   if (typeof x !== "number") {
@@ -365,7 +269,8 @@ function between(x, min, max, included = false) {
 }
 
 function handleValue$1(options) {
-  const { ctx, id, path, magicString, raw, replaceMap, offset = 0, escape: escape$1 = false, markedArray } = options;
+  const { ctx, id, path, magicString, raw, offset = 0, escape: escape$1 = false, markedArray } = options;
+  const { replaceMap } = ctx;
   const node = path.node;
   let value = raw;
   for (const [s, e] of markedArray) {
@@ -378,7 +283,7 @@ function handleValue$1(options) {
     if (replaceMap.has(str)) {
       ctx.addToUsedBy(str, id);
       const v = replaceMap.get(str);
-      if (v) {
+      if (v && typeof v === "string") {
         value = value.replaceAll(str, v);
       }
     }
@@ -391,72 +296,15 @@ function handleValue$1(options) {
     }
   }
 }
-const JsPlugin = helperPluginUtils.declare((api, options) => {
-  api.assertVersion(7);
-  const { magicString, replaceMap, id, ctx, markedArray } = options;
-  return {
-    visitor: {
-      StringLiteral: {
-        exit(p) {
-          const opts = {
-            ctx,
-            id,
-            magicString,
-            path: p,
-            raw: p.node.value,
-            replaceMap,
-            offset: 1,
-            escape: true,
-            markedArray
-          };
-          handleValue$1(opts);
-        }
-      },
-      TemplateElement: {
-        exit(p) {
-          const opts = {
-            ctx,
-            id,
-            magicString,
-            path: p,
-            raw: p.node.value.raw,
-            replaceMap,
-            offset: 0,
-            escape: false,
-            markedArray
-          };
-          handleValue$1(opts);
-        }
-      }
-    }
-  };
-});
-function transformSync(ast, code, plugins, filename) {
-  babel__default.transformFromAstSync(ast, code, {
-    presets: loadPresets(),
-    plugins,
-    filename
-  });
-}
-function loadPresets() {
-  return [
-    [
-      require("@babel/preset-typescript"),
-      {
-        allExtensions: true,
-        isTSX: true
-      }
-    ]
-  ];
-}
 function preProcessJs(options) {
-  const { code, replaceMap, id, ctx } = options;
+  const { code, id, ctx } = options;
+  const { replaceMap } = ctx;
   const magicString = typeof code === "string" ? new MagicString__default(code) : code;
   let ast;
   try {
-    const file = babel__default.parseSync(magicString.original, {
+    const file = parser$1.parse(magicString.original, {
       sourceType: "unambiguous",
-      presets: loadPresets()
+      plugins: ["typescript", "jsx"]
     });
     if (file) {
       ast = file;
@@ -467,7 +315,7 @@ function preProcessJs(options) {
     return code.toString();
   }
   const markedArray = [];
-  babel__default.traverse(ast, {
+  traverse(ast, {
     CallExpression: {
       enter(p) {
         const callee = p.get("callee");
@@ -503,29 +351,41 @@ function preProcessJs(options) {
           });
         }
       }
-    }
-  });
-  transformSync(
-    ast,
-    magicString.original,
-    [
-      [
-        JsPlugin,
-        {
-          magicString,
-          replaceMap,
+    },
+    StringLiteral: {
+      exit(p) {
+        handleValue$1({
+          ctx,
           id,
+          magicString,
+          path: p,
+          raw: p.node.value,
+          offset: 1,
+          escape: true,
+          markedArray
+        });
+      }
+    },
+    TemplateElement: {
+      exit(p) {
+        handleValue$1({
           ctx,
+          id,
+          magicString,
+          path: p,
+          raw: p.node.value.raw,
+          offset: 0,
+          escape: false,
           markedArray
-        }
-      ]
-    ],
-    id
-  );
+        });
+      }
+    }
+  });
   return magicString.toString();
 }
 function preProcessRawCode(options) {
-  const { code, replaceMap, ctx } = options;
+  const { code, ctx } = options;
+  const { replaceMap } = ctx;
   const magicString = typeof code === "string" ? new MagicString__default(code) : code;
   const markArr = [];
   for (const regex of ctx.preserveFunctionRegexs) {
@@ -538,10 +398,10 @@ function preProcessRawCode(options) {
     for (const regExpMatch of allArr) {
       let ast;
       try {
-        ast = babel__default.parseSync(regExpMatch[0], {
+        ast = parser$1.parse(regExpMatch[0], {
           sourceType: "unambiguous"
         });
-        ast && babel__default.traverse(ast, {
+        ast && traverse(ast, {
           StringLiteral: {
             enter(p) {
               const arr2 = fastSort.sort(shared.splitCode(p.node.value)).desc((x) => x.length);
@@ -581,7 +441,7 @@ function preProcessRawCode(options) {
           break;
         }
       }
-      if (shouldUpdate) {
+      if (shouldUpdate && typeof value === "string") {
         magicString.update(start, end, value);
         markArr.push([start, end]);
       }
@@ -590,13 +450,14 @@ function preProcessRawCode(options) {
   return magicString.toString();
 }
 
-function handleValue(raw, node, options) {
-  const { replaceMap, ctx, splitQuote = true } = options;
-  const clsGen = ctx.classGenerator;
+function handleValue(raw, node, options, ms, offset, escape$1) {
+  const { ctx, splitQuote = true } = options;
+  const { replaceMap, classGenerator: clsGen } = ctx;
   const array = shared.splitCode(raw, {
     splitQuote
   });
   let rawString = raw;
+  let needUpdate = false;
   for (const v of array) {
     if (replaceMap.has(v)) {
       let ignoreFlag = false;
@@ -605,58 +466,116 @@ function handleValue(raw, node, options) {
       }
       if (!ignoreFlag) {
         rawString = rawString.replace(shared.makeRegex(v), clsGen.generateClassName(v).name);
+        needUpdate = true;
       }
     }
   }
+  if (needUpdate && typeof node.start === "number" && typeof node.end === "number") {
+    const start = node.start + offset;
+    const end = node.end - offset;
+    if (start < end && raw !== rawString) {
+      ms.update(start, end, escape$1 ? escape.jsStringEscape(rawString) : rawString);
+    }
+  }
   return rawString;
 }
 function jsHandler(rawSource, options) {
-  const result = babel.transformSync(rawSource, {
-    babelrc: false,
-    ast: true,
-    plugins: [
-      () => {
-        return {
-          visitor: {
-            StringLiteral: {
-              enter(p) {
-                const n = p.node;
-                n.value = handleValue(n.value, n, options);
-              }
-            },
-            TemplateElement: {
-              enter(p) {
-                const n = p.node;
-                n.value.raw = handleValue(n.value.raw, n, options);
-              }
-            },
-            CallExpression: {
-              enter(p) {
-                const calleePath = p.get("callee");
-                if (calleePath.isIdentifier() && calleePath.node.name === "eval") {
-                  p.traverse({
-                    StringLiteral: {
-                      enter(s) {
-                        const res = jsHandler(s.node.value, options);
-                        if (res.code) {
-                          s.node.value = res.code;
-                        }
-                      }
-                    }
-                  });
-                }
-              }
-            }
-            // noScope: true
+  const ms = typeof rawSource === "string" ? new MagicString__default(rawSource) : rawSource;
+  const ast = parser$1.parse(ms.original, {
+    sourceType: "unambiguous",
+    plugins: ["typescript", "jsx"]
+  });
+  traverse(ast, {
+    StringLiteral: {
+      enter(p) {
+        const n = p.node;
+        handleValue(n.value, n, options, ms, 1, true);
+      }
+    },
+    TemplateElement: {
+      enter(p) {
+        const n = p.node;
+        handleValue(n.value.raw, n, options, ms, 0, false);
+      }
+    }
+    // CallExpression: {
+    //   enter(p: NodePath<CallExpression>) {
+    //     const calleePath = p.get('callee')
+    //     if (calleePath.isIdentifier() && calleePath.node.name === 'eval') {
+    //       p.traverse({
+    //         StringLiteral: {
+    //           enter(s) {
+    //             // ___CSS_LOADER_EXPORT___
+    //             const res = jsHandler(s.node.value, options)
+    //             if (res.code) {
+    //               s.node.value = res.code
+    //             }
+    //           },
+    //         },
+    //       })
+    //     }
+    //   },
+    // },
+  });
+  return {
+    code: ms.toString(),
+    get map() {
+      return ms.generateMap();
+    }
+  };
+}
+
+function htmlHandler(raw, options) {
+  const { ctx, isVue } = options;
+  const { replaceMap } = ctx;
+  const ms = typeof raw === "string" ? new MagicString__default(raw) : raw;
+  const parser = new htmlparser2.Parser({
+    onattribute(name, value) {
+      if (name === "class") {
+        const arr = shared.splitCode(value, {
+          splitQuote: false
+        });
+        let rawValue = value;
+        for (const v of arr) {
+          if (replaceMap.has(v)) {
+            rawValue = rawValue.replace(shared.makeRegex(v), ctx.classGenerator.generateClassName(v).name);
           }
-        };
+        }
+        ms.update(parser.startIndex + name.length + 2, parser.endIndex - 1, rawValue);
+      }
+      if (isVue) {
+        if (name === ":class") {
+          const { code } = jsHandler(value, {
+            ctx
+          });
+          ms.update(parser.startIndex + name.length + 2, parser.endIndex - 1, code);
+        }
       }
-    ],
-    minified: options.minified ?? isProd(),
-    sourceMaps: false,
-    configFile: false
+    }
   });
-  return result;
+  parser.write(ms.original);
+  parser.end();
+  return ms.toString();
+}
+
+function vueHandler(raw, options) {
+  const { ctx } = options;
+  const ms = typeof raw === "string" ? new MagicString__default(raw) : raw;
+  const { descriptor } = compilerSfc.parse(ms.original);
+  const { template, scriptSetup, script } = descriptor;
+  if (template) {
+    const code = htmlHandler(template.content, { ctx, isVue: true });
+    ms.update(template.loc.start.offset, template.loc.end.offset, code);
+  }
+  if (script) {
+    const x = jsHandler(script.content, { ctx });
+    ms.update(script.loc.start.offset, script.loc.end.offset, x.code);
+  }
+  if (scriptSetup) {
+    const x = jsHandler(scriptSetup.content, { ctx });
+    ms.update(scriptSetup.loc.start.offset, scriptSetup.loc.end.offset, x.code);
+  }
+  return ms.toString();
 }
 
 exports.ClassGenerator = shared.ClassGenerator;
@@ -667,3 +586,4 @@ exports.htmlHandler = htmlHandler;
 exports.jsHandler = jsHandler;
 exports.preProcessJs = preProcessJs;
 exports.preProcessRawCode = preProcessRawCode;
+exports.vueHandler = vueHandler;