@tailwindcss-mangle/core 2.2.2 → 2.3.0

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import { resolve, isAbsolute } from 'node:path';
+import process from 'node:process';
 import { ClassGenerator, defaultMangleClassFilter, splitCode, makeRegex } from '@tailwindcss-mangle/shared';
 export { ClassGenerator } from '@tailwindcss-mangle/shared';
 import { getConfig } from '@tailwindcss-mangle/config';
@@ -7,26 +8,32 @@ import { sort } from 'fast-sort';
 import micromatch from 'micromatch';
 import postcss from 'postcss';
 import parser from 'postcss-selector-parser';
-import { html, defaultTreeAdapter, parse, serialize } from 'parse5';
-import babel, { transformSync as transformSync$1 } from '@babel/core';
-import { declare } from '@babel/helper-plugin-utils';
+import { Parser } from 'htmlparser2';
 import MagicString from 'magic-string';
 import { jsStringEscape } from '@ast-core/escape';
+import _babelTraverse from '@babel/traverse';
+import { parse } from '@babel/parser';
+import { parse as parse$1 } from '@vue/compiler-sfc';
 
-
-
-// -- Unbuild CommonJS Shims --
-import __cjs_url__ from 'url';
-import __cjs_path__ from 'path';
-import __cjs_mod__ from 'module';
-const __filename = __cjs_url__.fileURLToPath(import.meta.url);
-const __dirname = __cjs_path__.dirname(__filename);
-const require = __cjs_mod__.createRequire(import.meta.url);
-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);
@@ -43,7 +50,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],
@@ -125,7 +132,7 @@ class Context {
     this.classGenerator = new 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) {
@@ -183,7 +190,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);
@@ -197,34 +203,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((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((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
       });
     }
   };
@@ -240,121 +245,10 @@ function cssHandler(rawSource, options) {
   });
 }
 
-({
-    HTML: html.NS.HTML,
-    XML: html.NS.XML,
-    MATHML: html.NS.MATHML,
-    SVG: html.NS.SVG,
-    XLINK: html.NS.XLINK,
-    XMLNS: 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 = defaultTreeAdapter.isElementNode;
-const isCommentNode = defaultTreeAdapter.isCommentNode;
-const isDocumentTypeNode = defaultTreeAdapter.isDocumentTypeNode;
-const isTextNode = 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));
-}
-
-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 = parse(rawSource);
-  traverse(fragment, {
-    element(node) {
-      const attribute = node.attrs.find((x) => x.name === "class");
-      if (attribute) {
-        const array = splitCode(attribute.value, {
-          splitQuote: false
-        });
-        for (const v of array) {
-          if (replaceMap.has(v)) {
-            attribute.value = attribute.value.replace(makeRegex(v), ctx.classGenerator.generateClassName(v).name);
-          }
-        }
-      }
-    }
-  });
-  return serialize(fragment);
+function _interopDefaultCompat(e) {
+  return e && typeof e === "object" && "default" in e ? e.default : e;
 }
-
-const isProd = () => process.env.NODE_ENV === "production";
+const traverse = _interopDefaultCompat(_babelTraverse);
 
 function between(x, min, max, included = false) {
   if (typeof x !== "number") {
@@ -364,7 +258,8 @@ function between(x, min, max, included = false) {
 }
 
 function handleValue$1(options) {
-  const { ctx, id, path, magicString, raw, replaceMap, offset = 0, escape = false, markedArray } = options;
+  const { ctx, id, path, magicString, raw, offset = 0, escape = false, markedArray } = options;
+  const { replaceMap } = ctx;
   const node = path.node;
   let value = raw;
   for (const [s, e] of markedArray) {
@@ -377,7 +272,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);
       }
     }
@@ -390,72 +285,15 @@ function handleValue$1(options) {
     }
   }
 }
-const JsPlugin = 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.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(code) : code;
   let ast;
   try {
-    const file = babel.parseSync(magicString.original, {
+    const file = parse(magicString.original, {
       sourceType: "unambiguous",
-      presets: loadPresets()
+      plugins: ["typescript", "jsx"]
     });
     if (file) {
       ast = file;
@@ -466,7 +304,7 @@ function preProcessJs(options) {
     return code.toString();
   }
   const markedArray = [];
-  babel.traverse(ast, {
+  traverse(ast, {
     CallExpression: {
       enter(p) {
         const callee = p.get("callee");
@@ -502,29 +340,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(code) : code;
   const markArr = [];
   for (const regex of ctx.preserveFunctionRegexs) {
@@ -537,10 +387,10 @@ function preProcessRawCode(options) {
     for (const regExpMatch of allArr) {
       let ast;
       try {
-        ast = babel.parseSync(regExpMatch[0], {
+        ast = parse(regExpMatch[0], {
           sourceType: "unambiguous"
         });
-        ast && babel.traverse(ast, {
+        ast && traverse(ast, {
           StringLiteral: {
             enter(p) {
               const arr2 = sort(splitCode(p.node.value)).desc((x) => x.length);
@@ -580,7 +430,7 @@ function preProcessRawCode(options) {
           break;
         }
       }
-      if (shouldUpdate) {
+      if (shouldUpdate && typeof value === "string") {
         magicString.update(start, end, value);
         markArr.push([start, end]);
       }
@@ -589,13 +439,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) {
+  const { ctx, splitQuote = true } = options;
+  const { replaceMap, classGenerator: clsGen } = ctx;
   const array = splitCode(raw, {
     splitQuote
   });
   let rawString = raw;
+  let needUpdate = false;
   for (const v of array) {
     if (replaceMap.has(v)) {
       let ignoreFlag = false;
@@ -604,58 +455,116 @@ function handleValue(raw, node, options) {
       }
       if (!ignoreFlag) {
         rawString = rawString.replace(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 ? jsStringEscape(rawString) : rawString);
+    }
+  }
   return rawString;
 }
 function jsHandler(rawSource, options) {
-  const result = transformSync$1(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(rawSource) : rawSource;
+  const ast = 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(raw) : raw;
+  const parser = new Parser({
+    onattribute(name, value) {
+      if (name === "class") {
+        const arr = splitCode(value, {
+          splitQuote: false
+        });
+        let rawValue = value;
+        for (const v of arr) {
+          if (replaceMap.has(v)) {
+            rawValue = rawValue.replace(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(raw) : raw;
+  const { descriptor } = parse$1(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();
 }
 
-export { Context, cssHandler, handleValue, htmlHandler, jsHandler, preProcessJs, preProcessRawCode };
+export { Context, cssHandler, handleValue, htmlHandler, jsHandler, preProcessJs, preProcessRawCode, vueHandler };