@tailwindcss-mangle/core 1.2.7 → 2.0.1

package/dist/index.cjs

@@ -4,26 +4,16 @@ const postcss = require('postcss');
 const parser = require('postcss-selector-parser');
 const parse5 = require('parse5');
 const shared = require('@tailwindcss-mangle/shared');
-const t = require('@babel/types');
-const core = require('@babel/core');
+const babel = require('@babel/core');
+const helperPluginUtils = require('@babel/helper-plugin-utils');
+const MagicString = require('magic-string');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      n[k] = e[k];
-    }
-  }
-  n.default = e;
-  return n;
-}
-
 const postcss__default = /*#__PURE__*/_interopDefaultCompat(postcss);
 const parser__default = /*#__PURE__*/_interopDefaultCompat(parser);
-const t__namespace = /*#__PURE__*/_interopNamespaceCompat(t);
+const babel__default = /*#__PURE__*/_interopDefaultCompat(babel);
+const MagicString__default = /*#__PURE__*/_interopDefaultCompat(MagicString);
 
 function isObject(value) {
   return value !== null && typeof value === "object";
@@ -80,64 +70,41 @@ function isVueScoped(s) {
   }
   return false;
 }
-const postcssMangleTailwindcssPlugin = (options) => {
-  const { ignoreVueScoped } = defu(options, {
+const transformSelectorPostcssPlugin = function(options) {
+  const { ignoreVueScoped, replaceMap } = defu(options, {
     ignoreVueScoped: true
   });
-  if (options?.scene === "loader") {
-    let set = /* @__PURE__ */ new Set();
-    if (options && options.runtimeSet) {
-      set = options.runtimeSet;
-    }
-    return {
-      postcssPlugin,
-      Rule(rule) {
-        rule.selector = parser__default((selectors) => {
-          selectors.walkClasses((s) => {
-            if (s.value) {
-              const existed = set.has(s.value);
-              if (existed) {
-                if (ignoreVueScoped && isVueScoped(s)) {
-                  return;
-                }
-                s.value = options.classGenerator.generateClassName(s.value).name;
-              }
+  return {
+    postcssPlugin,
+    async Rule(rule) {
+      await parser__default((selectors) => {
+        selectors.walkClasses((s) => {
+          if (s.value && replaceMap && replaceMap.has(s.value)) {
+            if (ignoreVueScoped && isVueScoped(s)) {
+              return;
             }
-          });
-        }).processSync(rule.selector);
-      }
-    };
-  } else {
-    let newClassMap = {};
-    if (options && options.classGenerator) {
-      newClassMap = options.classGenerator.newClassMap;
-    }
-    return {
-      postcssPlugin,
-      Rule(rule) {
-        rule.selector = parser__default((selectors) => {
-          selectors.walkClasses((s) => {
-            if (s.value) {
-              const hit = newClassMap[s.value];
-              const existed = Boolean(hit);
-              if (existed) {
-                if (ignoreVueScoped && isVueScoped(s)) {
-                  return;
-                }
-                s.value = hit.name;
-              }
+            const v = replaceMap.get(s.value);
+            if (v) {
+              s.value = v;
             }
-          });
-        }).processSync(rule.selector);
-      }
-    };
-  }
+          }
+        });
+      }).transform(rule, {
+        lossless: false,
+        updateSelector: true
+      });
+    }
+  };
 };
-postcssMangleTailwindcssPlugin.postcss = true;
+transformSelectorPostcssPlugin.postcss = true;
 
 function cssHandler(rawSource, options) {
-  const acceptedPlugins = [postcssMangleTailwindcssPlugin(options)];
-  return postcss__default(acceptedPlugins).process(rawSource).css;
+  const acceptedPlugins = [transformSelectorPostcssPlugin(options)];
+  const { file } = options;
+  return postcss__default(acceptedPlugins).process(rawSource, {
+    from: file,
+    to: file
+  });
 }
 
 ({
@@ -234,7 +201,7 @@ function traverse(node, visitor, parent) {
 }
 
 function htmlHandler(rawSource, options) {
-  const { runtimeSet, classGenerator } = options;
+  const { replaceMap, classGenerator } = options;
   const fragment = parse5.parse(rawSource);
   traverse(fragment, {
     element(node) {
@@ -244,7 +211,7 @@ function htmlHandler(rawSource, options) {
           splitQuote: false
         });
         for (const v of array) {
-          if (runtimeSet.has(v)) {
+          if (replaceMap.has(v)) {
             attribute.value = attribute.value.replace(shared.makeRegex(v), classGenerator.generateClassName(v).name);
           }
         }
@@ -256,14 +223,213 @@ function htmlHandler(rawSource, options) {
 
 const isProd = () => process.env.NODE_ENV === "production";
 
-function handleValue(string_, node, options) {
-  const { runtimeSet: set, classGenerator: clsGen, splitQuote = true } = options;
-  const array = shared.splitCode(string_, {
+// >>> INTERFACES <<<
+// >>> HELPERS <<<
+var castComparer = function (comparer) { return function (a, b, order) { return comparer(a, b, order) * order; }; };
+var throwInvalidConfigErrorIfTrue = function (condition, context) {
+    if (condition)
+        throw Error("Invalid sort config: " + context);
+};
+var unpackObjectSorter = function (sortByObj) {
+    var _a = sortByObj || {}, asc = _a.asc, desc = _a.desc;
+    var order = asc ? 1 : -1;
+    var sortBy = (asc || desc);
+    // Validate object config
+    throwInvalidConfigErrorIfTrue(!sortBy, 'Expected `asc` or `desc` property');
+    throwInvalidConfigErrorIfTrue(asc && desc, 'Ambiguous object with `asc` and `desc` config properties');
+    var comparer = sortByObj.comparer && castComparer(sortByObj.comparer);
+    return { order: order, sortBy: sortBy, comparer: comparer };
+};
+// >>> SORTERS <<<
+var multiPropertySorterProvider = function (defaultComparer) {
+    return function multiPropertySorter(sortBy, sortByArr, depth, order, comparer, a, b) {
+        var valA;
+        var valB;
+        if (typeof sortBy === 'string') {
+            valA = a[sortBy];
+            valB = b[sortBy];
+        }
+        else if (typeof sortBy === 'function') {
+            valA = sortBy(a);
+            valB = sortBy(b);
+        }
+        else {
+            var objectSorterConfig = unpackObjectSorter(sortBy);
+            return multiPropertySorter(objectSorterConfig.sortBy, sortByArr, depth, objectSorterConfig.order, objectSorterConfig.comparer || defaultComparer, a, b);
+        }
+        var equality = comparer(valA, valB, order);
+        if ((equality === 0 || (valA == null && valB == null)) &&
+            sortByArr.length > depth) {
+            return multiPropertySorter(sortByArr[depth], sortByArr, depth + 1, order, comparer, a, b);
+        }
+        return equality;
+    };
+};
+function getSortStrategy(sortBy, comparer, order) {
+    // Flat array sorter
+    if (sortBy === undefined || sortBy === true) {
+        return function (a, b) { return comparer(a, b, order); };
+    }
+    // Sort list of objects by single object key
+    if (typeof sortBy === 'string') {
+        throwInvalidConfigErrorIfTrue(sortBy.includes('.'), 'String syntax not allowed for nested properties.');
+        return function (a, b) { return comparer(a[sortBy], b[sortBy], order); };
+    }
+    // Sort list of objects by single function sorter
+    if (typeof sortBy === 'function') {
+        return function (a, b) { return comparer(sortBy(a), sortBy(b), order); };
+    }
+    // Sort by multiple properties
+    if (Array.isArray(sortBy)) {
+        var multiPropSorter_1 = multiPropertySorterProvider(comparer);
+        return function (a, b) { return multiPropSorter_1(sortBy[0], sortBy, 1, order, comparer, a, b); };
+    }
+    // Unpack object config to get actual sorter strategy
+    var objectSorterConfig = unpackObjectSorter(sortBy);
+    return getSortStrategy(objectSorterConfig.sortBy, objectSorterConfig.comparer || comparer, objectSorterConfig.order);
+}
+var sortArray = function (order, ctx, sortBy, comparer) {
+    var _a;
+    if (!Array.isArray(ctx)) {
+        return ctx;
+    }
+    // Unwrap sortBy if array with only 1 value to get faster sort strategy
+    if (Array.isArray(sortBy) && sortBy.length < 2) {
+        _a = sortBy, sortBy = _a[0];
+    }
+    return ctx.sort(getSortStrategy(sortBy, comparer, order));
+};
+function createNewSortInstance(opts) {
+    var comparer = castComparer(opts.comparer);
+    return function (arrayToSort) {
+        var ctx = Array.isArray(arrayToSort) && !opts.inPlaceSorting
+            ? arrayToSort.slice()
+            : arrayToSort;
+        return {
+            asc: function (sortBy) {
+                return sortArray(1, ctx, sortBy, comparer);
+            },
+            desc: function (sortBy) {
+                return sortArray(-1, ctx, sortBy, comparer);
+            },
+            by: function (sortBy) {
+                return sortArray(1, ctx, sortBy, comparer);
+            },
+        };
+    };
+}
+var defaultComparer = function (a, b, order) {
+    if (a == null)
+        return order;
+    if (b == null)
+        return -order;
+    if (typeof a !== typeof b) {
+        return typeof a < typeof b ? -1 : 1;
+    }
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+};
+var sort = createNewSortInstance({
+    comparer: defaultComparer,
+});
+createNewSortInstance({
+    comparer: defaultComparer,
+    inPlaceSorting: true,
+});
+
+function handleValue$1(options) {
+  const { addToUsedBy, id, magicString, node, raw, replaceMap, offset = 0 } = options;
+  let value = raw;
+  const arr = sort(shared.splitCode(value)).desc((x) => x.length);
+  for (const str of arr) {
+    if (replaceMap.has(str)) {
+      addToUsedBy(str, id);
+      const v = replaceMap.get(str);
+      if (v) {
+        value = value.replaceAll(str, v);
+      }
+    }
+  }
+  if (typeof node.start === "number" && typeof node.end === "number" && value) {
+    magicString.update(node.start + offset, node.end - offset, value);
+  }
+}
+const plugin = helperPluginUtils.declare((api, options) => {
+  api.assertVersion(7);
+  const { magicString, replaceMap, id, addToUsedBy } = options;
+  return {
+    visitor: {
+      StringLiteral: {
+        enter(p) {
+          const node = p.node;
+          handleValue$1({
+            addToUsedBy,
+            id,
+            magicString,
+            node,
+            raw: node.value,
+            replaceMap,
+            offset: 1
+          });
+        }
+      },
+      TemplateElement: {
+        enter(p) {
+          const node = p.node;
+          handleValue$1({
+            addToUsedBy,
+            id,
+            magicString,
+            node,
+            raw: node.value.raw,
+            replaceMap,
+            offset: 0
+          });
+        }
+      }
+    }
+  };
+});
+function preProcessJs(options) {
+  const { code, replaceMap, id, addToUsedBy } = options;
+  const magicString = new MagicString__default(code);
+  babel__default.transformSync(code, {
+    presets: [
+      // ['@babel/preset-react', {}],
+      [
+        require("@babel/preset-typescript"),
+        {
+          allExtensions: true,
+          isTSX: true
+        }
+      ]
+    ],
+    plugins: [
+      [
+        plugin,
+        {
+          magicString,
+          replaceMap,
+          id,
+          addToUsedBy
+        }
+      ]
+    ]
+  });
+  return magicString.toString();
+}
+
+function handleValue(raw, node, options) {
+  const { replaceMap, classGenerator: clsGen, splitQuote = true } = options;
+  const array = shared.splitCode(raw, {
     splitQuote
   });
-  let rawString = string_;
+  let rawString = raw;
   for (const v of array) {
-    if (set.has(v)) {
+    if (replaceMap.has(v)) {
       let ignoreFlag = false;
       if (Array.isArray(node.leadingComments)) {
         ignoreFlag = node.leadingComments.findIndex((x) => x.value.includes("tw-mangle") && x.value.includes("ignore")) > -1;
@@ -276,7 +442,7 @@ function handleValue(string_, node, options) {
   return rawString;
 }
 function jsHandler(rawSource, options) {
-  const result = core.transformSync(rawSource, {
+  const result = babel.transformSync(rawSource, {
     babelrc: false,
     ast: true,
     plugins: [
@@ -297,12 +463,18 @@ function jsHandler(rawSource, options) {
             },
             CallExpression: {
               enter(p) {
-                const n = p.node;
-                if (t__namespace.isIdentifier(n.callee) && n.callee.name === "eval" && t__namespace.isStringLiteral(n.arguments[0])) {
-                  const res = jsHandler(n.arguments[0].value, options);
-                  if (res.code) {
-                    n.arguments[0].value = res.code;
-                  }
+                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;
+                        }
+                      }
+                    }
+                  });
                 }
               }
             }
@@ -323,3 +495,4 @@ exports.cssHandler = cssHandler;
 exports.handleValue = handleValue;
 exports.htmlHandler = htmlHandler;
 exports.jsHandler = jsHandler;
+exports.preProcessJs = preProcessJs;

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import * as postcss_lib_no_work_result from 'postcss/lib/no-work-result';
+import postcss from 'postcss';
 import { ClassGenerator } from '@tailwindcss-mangle/shared';
 export { ClassGenerator } from '@tailwindcss-mangle/shared';
 import { StringLiteral, TemplateElement } from '@babel/types';
@@ -5,7 +7,7 @@ import { BabelFileResult } from '@babel/core';
 
 interface IClassGeneratorContextItem {
     name: string;
-    usedBy: any[];
+    usedBy: string[];
 }
 interface IClassGeneratorOptions {
     reserveClassName?: (string | RegExp)[];
@@ -17,8 +19,8 @@ interface IClassGeneratorOptions {
     classPrefix?: string;
 }
 interface IHandlerOptions {
-    runtimeSet: Set<string>;
     classGenerator: ClassGenerator;
+    replaceMap: Map<string, string>;
 }
 interface IHtmlHandlerOptions extends IHandlerOptions {
 }
@@ -27,8 +29,8 @@ interface IJsHandlerOptions extends IHandlerOptions {
     minified?: boolean;
 }
 interface ICssHandlerOptions extends IHandlerOptions {
-    scene?: 'loader' | 'process';
     ignoreVueScoped?: boolean;
+    file?: string;
 }
 interface ClassSetOutputOptions {
     filename: string;
@@ -47,11 +49,18 @@ interface Options {
     classMapOutput?: boolean | ClassMapOutputOptions;
 }
 
-declare function cssHandler(rawSource: string, options: ICssHandlerOptions): string;
+declare function cssHandler(rawSource: string, options: ICssHandlerOptions): postcss.LazyResult | postcss_lib_no_work_result.default;
 
 declare function htmlHandler(rawSource: string, options: IHtmlHandlerOptions): string;
 
-declare function handleValue(string_: string, node: StringLiteral | TemplateElement, options: IJsHandlerOptions): string;
+declare function preProcessJs(options: {
+    code: string;
+    replaceMap: Map<string, string>;
+    id: string;
+    addToUsedBy: (key: string, file: string) => void;
+}): string;
+
+declare function handleValue(raw: string, node: StringLiteral | TemplateElement, options: IJsHandlerOptions): string;
 declare function jsHandler(rawSource: string, options: IJsHandlerOptions): BabelFileResult;
 
-export { ClassMapOutputOptions, ClassSetOutputOptions, IClassGeneratorContextItem, IClassGeneratorOptions, ICssHandlerOptions, IHandlerOptions, IHtmlHandlerOptions, IJsHandlerOptions, Options, cssHandler, handleValue, htmlHandler, jsHandler };
+export { ClassMapOutputOptions, ClassSetOutputOptions, IClassGeneratorContextItem, IClassGeneratorOptions, ICssHandlerOptions, IHandlerOptions, IHtmlHandlerOptions, IJsHandlerOptions, Options, cssHandler, handleValue, htmlHandler, jsHandler, preProcessJs };

package/dist/index.mjs

@@ -3,9 +3,19 @@ import parser from 'postcss-selector-parser';
 import { html, defaultTreeAdapter, parse, serialize } from 'parse5';
 import { splitCode, makeRegex } from '@tailwindcss-mangle/shared';
 export { ClassGenerator } from '@tailwindcss-mangle/shared';
-import * as t from '@babel/types';
-import { transformSync } from '@babel/core';
+import babel, { transformSync } from '@babel/core';
+import { declare } from '@babel/helper-plugin-utils';
+import MagicString from 'magic-string';
 
+
+
+// -- 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";
 }
@@ -61,64 +71,41 @@ function isVueScoped(s) {
   }
   return false;
 }
-const postcssMangleTailwindcssPlugin = (options) => {
-  const { ignoreVueScoped } = defu(options, {
+const transformSelectorPostcssPlugin = function(options) {
+  const { ignoreVueScoped, replaceMap } = defu(options, {
     ignoreVueScoped: true
   });
-  if (options?.scene === "loader") {
-    let set = /* @__PURE__ */ new Set();
-    if (options && options.runtimeSet) {
-      set = options.runtimeSet;
-    }
-    return {
-      postcssPlugin,
-      Rule(rule) {
-        rule.selector = parser((selectors) => {
-          selectors.walkClasses((s) => {
-            if (s.value) {
-              const existed = set.has(s.value);
-              if (existed) {
-                if (ignoreVueScoped && isVueScoped(s)) {
-                  return;
-                }
-                s.value = options.classGenerator.generateClassName(s.value).name;
-              }
+  return {
+    postcssPlugin,
+    async Rule(rule) {
+      await parser((selectors) => {
+        selectors.walkClasses((s) => {
+          if (s.value && replaceMap && replaceMap.has(s.value)) {
+            if (ignoreVueScoped && isVueScoped(s)) {
+              return;
             }
-          });
-        }).processSync(rule.selector);
-      }
-    };
-  } else {
-    let newClassMap = {};
-    if (options && options.classGenerator) {
-      newClassMap = options.classGenerator.newClassMap;
-    }
-    return {
-      postcssPlugin,
-      Rule(rule) {
-        rule.selector = parser((selectors) => {
-          selectors.walkClasses((s) => {
-            if (s.value) {
-              const hit = newClassMap[s.value];
-              const existed = Boolean(hit);
-              if (existed) {
-                if (ignoreVueScoped && isVueScoped(s)) {
-                  return;
-                }
-                s.value = hit.name;
-              }
+            const v = replaceMap.get(s.value);
+            if (v) {
+              s.value = v;
             }
-          });
-        }).processSync(rule.selector);
-      }
-    };
-  }
+          }
+        });
+      }).transform(rule, {
+        lossless: false,
+        updateSelector: true
+      });
+    }
+  };
 };
-postcssMangleTailwindcssPlugin.postcss = true;
+transformSelectorPostcssPlugin.postcss = true;
 
 function cssHandler(rawSource, options) {
-  const acceptedPlugins = [postcssMangleTailwindcssPlugin(options)];
-  return postcss(acceptedPlugins).process(rawSource).css;
+  const acceptedPlugins = [transformSelectorPostcssPlugin(options)];
+  const { file } = options;
+  return postcss(acceptedPlugins).process(rawSource, {
+    from: file,
+    to: file
+  });
 }
 
 ({
@@ -215,7 +202,7 @@ function traverse(node, visitor, parent) {
 }
 
 function htmlHandler(rawSource, options) {
-  const { runtimeSet, classGenerator } = options;
+  const { replaceMap, classGenerator } = options;
   const fragment = parse(rawSource);
   traverse(fragment, {
     element(node) {
@@ -225,7 +212,7 @@ function htmlHandler(rawSource, options) {
           splitQuote: false
         });
         for (const v of array) {
-          if (runtimeSet.has(v)) {
+          if (replaceMap.has(v)) {
             attribute.value = attribute.value.replace(makeRegex(v), classGenerator.generateClassName(v).name);
           }
         }
@@ -237,14 +224,213 @@ function htmlHandler(rawSource, options) {
 
 const isProd = () => process.env.NODE_ENV === "production";
 
-function handleValue(string_, node, options) {
-  const { runtimeSet: set, classGenerator: clsGen, splitQuote = true } = options;
-  const array = splitCode(string_, {
+// >>> INTERFACES <<<
+// >>> HELPERS <<<
+var castComparer = function (comparer) { return function (a, b, order) { return comparer(a, b, order) * order; }; };
+var throwInvalidConfigErrorIfTrue = function (condition, context) {
+    if (condition)
+        throw Error("Invalid sort config: " + context);
+};
+var unpackObjectSorter = function (sortByObj) {
+    var _a = sortByObj || {}, asc = _a.asc, desc = _a.desc;
+    var order = asc ? 1 : -1;
+    var sortBy = (asc || desc);
+    // Validate object config
+    throwInvalidConfigErrorIfTrue(!sortBy, 'Expected `asc` or `desc` property');
+    throwInvalidConfigErrorIfTrue(asc && desc, 'Ambiguous object with `asc` and `desc` config properties');
+    var comparer = sortByObj.comparer && castComparer(sortByObj.comparer);
+    return { order: order, sortBy: sortBy, comparer: comparer };
+};
+// >>> SORTERS <<<
+var multiPropertySorterProvider = function (defaultComparer) {
+    return function multiPropertySorter(sortBy, sortByArr, depth, order, comparer, a, b) {
+        var valA;
+        var valB;
+        if (typeof sortBy === 'string') {
+            valA = a[sortBy];
+            valB = b[sortBy];
+        }
+        else if (typeof sortBy === 'function') {
+            valA = sortBy(a);
+            valB = sortBy(b);
+        }
+        else {
+            var objectSorterConfig = unpackObjectSorter(sortBy);
+            return multiPropertySorter(objectSorterConfig.sortBy, sortByArr, depth, objectSorterConfig.order, objectSorterConfig.comparer || defaultComparer, a, b);
+        }
+        var equality = comparer(valA, valB, order);
+        if ((equality === 0 || (valA == null && valB == null)) &&
+            sortByArr.length > depth) {
+            return multiPropertySorter(sortByArr[depth], sortByArr, depth + 1, order, comparer, a, b);
+        }
+        return equality;
+    };
+};
+function getSortStrategy(sortBy, comparer, order) {
+    // Flat array sorter
+    if (sortBy === undefined || sortBy === true) {
+        return function (a, b) { return comparer(a, b, order); };
+    }
+    // Sort list of objects by single object key
+    if (typeof sortBy === 'string') {
+        throwInvalidConfigErrorIfTrue(sortBy.includes('.'), 'String syntax not allowed for nested properties.');
+        return function (a, b) { return comparer(a[sortBy], b[sortBy], order); };
+    }
+    // Sort list of objects by single function sorter
+    if (typeof sortBy === 'function') {
+        return function (a, b) { return comparer(sortBy(a), sortBy(b), order); };
+    }
+    // Sort by multiple properties
+    if (Array.isArray(sortBy)) {
+        var multiPropSorter_1 = multiPropertySorterProvider(comparer);
+        return function (a, b) { return multiPropSorter_1(sortBy[0], sortBy, 1, order, comparer, a, b); };
+    }
+    // Unpack object config to get actual sorter strategy
+    var objectSorterConfig = unpackObjectSorter(sortBy);
+    return getSortStrategy(objectSorterConfig.sortBy, objectSorterConfig.comparer || comparer, objectSorterConfig.order);
+}
+var sortArray = function (order, ctx, sortBy, comparer) {
+    var _a;
+    if (!Array.isArray(ctx)) {
+        return ctx;
+    }
+    // Unwrap sortBy if array with only 1 value to get faster sort strategy
+    if (Array.isArray(sortBy) && sortBy.length < 2) {
+        _a = sortBy, sortBy = _a[0];
+    }
+    return ctx.sort(getSortStrategy(sortBy, comparer, order));
+};
+function createNewSortInstance(opts) {
+    var comparer = castComparer(opts.comparer);
+    return function (arrayToSort) {
+        var ctx = Array.isArray(arrayToSort) && !opts.inPlaceSorting
+            ? arrayToSort.slice()
+            : arrayToSort;
+        return {
+            asc: function (sortBy) {
+                return sortArray(1, ctx, sortBy, comparer);
+            },
+            desc: function (sortBy) {
+                return sortArray(-1, ctx, sortBy, comparer);
+            },
+            by: function (sortBy) {
+                return sortArray(1, ctx, sortBy, comparer);
+            },
+        };
+    };
+}
+var defaultComparer = function (a, b, order) {
+    if (a == null)
+        return order;
+    if (b == null)
+        return -order;
+    if (typeof a !== typeof b) {
+        return typeof a < typeof b ? -1 : 1;
+    }
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+};
+var sort = createNewSortInstance({
+    comparer: defaultComparer,
+});
+createNewSortInstance({
+    comparer: defaultComparer,
+    inPlaceSorting: true,
+});
+
+function handleValue$1(options) {
+  const { addToUsedBy, id, magicString, node, raw, replaceMap, offset = 0 } = options;
+  let value = raw;
+  const arr = sort(splitCode(value)).desc((x) => x.length);
+  for (const str of arr) {
+    if (replaceMap.has(str)) {
+      addToUsedBy(str, id);
+      const v = replaceMap.get(str);
+      if (v) {
+        value = value.replaceAll(str, v);
+      }
+    }
+  }
+  if (typeof node.start === "number" && typeof node.end === "number" && value) {
+    magicString.update(node.start + offset, node.end - offset, value);
+  }
+}
+const plugin = declare((api, options) => {
+  api.assertVersion(7);
+  const { magicString, replaceMap, id, addToUsedBy } = options;
+  return {
+    visitor: {
+      StringLiteral: {
+        enter(p) {
+          const node = p.node;
+          handleValue$1({
+            addToUsedBy,
+            id,
+            magicString,
+            node,
+            raw: node.value,
+            replaceMap,
+            offset: 1
+          });
+        }
+      },
+      TemplateElement: {
+        enter(p) {
+          const node = p.node;
+          handleValue$1({
+            addToUsedBy,
+            id,
+            magicString,
+            node,
+            raw: node.value.raw,
+            replaceMap,
+            offset: 0
+          });
+        }
+      }
+    }
+  };
+});
+function preProcessJs(options) {
+  const { code, replaceMap, id, addToUsedBy } = options;
+  const magicString = new MagicString(code);
+  babel.transformSync(code, {
+    presets: [
+      // ['@babel/preset-react', {}],
+      [
+        require("@babel/preset-typescript"),
+        {
+          allExtensions: true,
+          isTSX: true
+        }
+      ]
+    ],
+    plugins: [
+      [
+        plugin,
+        {
+          magicString,
+          replaceMap,
+          id,
+          addToUsedBy
+        }
+      ]
+    ]
+  });
+  return magicString.toString();
+}
+
+function handleValue(raw, node, options) {
+  const { replaceMap, classGenerator: clsGen, splitQuote = true } = options;
+  const array = splitCode(raw, {
     splitQuote
   });
-  let rawString = string_;
+  let rawString = raw;
   for (const v of array) {
-    if (set.has(v)) {
+    if (replaceMap.has(v)) {
       let ignoreFlag = false;
       if (Array.isArray(node.leadingComments)) {
         ignoreFlag = node.leadingComments.findIndex((x) => x.value.includes("tw-mangle") && x.value.includes("ignore")) > -1;
@@ -278,12 +464,18 @@ function jsHandler(rawSource, options) {
             },
             CallExpression: {
               enter(p) {
-                const n = p.node;
-                if (t.isIdentifier(n.callee) && n.callee.name === "eval" && t.isStringLiteral(n.arguments[0])) {
-                  const res = jsHandler(n.arguments[0].value, options);
-                  if (res.code) {
-                    n.arguments[0].value = res.code;
-                  }
+                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;
+                        }
+                      }
+                    }
+                  });
                 }
               }
             }
@@ -299,4 +491,4 @@ function jsHandler(rawSource, options) {
   return result;
 }
 
-export { cssHandler, handleValue, htmlHandler, jsHandler };
+export { cssHandler, handleValue, htmlHandler, jsHandler, preProcessJs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailwindcss-mangle/core",
-  "version": "1.2.7",
+  "version": "2.0.1",
   "description": "The core of tailwindcss-mangle",
   "exports": {
     ".": {
@@ -36,12 +36,15 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
+    "@babel/helper-plugin-utils": "^7.22.5",
+    "@babel/preset-typescript": "^7.22.5",
     "@babel/core": "^7.22.10",
     "@babel/types": "^7.22.10",
     "parse5": "^7.1.2",
     "postcss": "^8.4.27",
     "postcss-selector-parser": "^6.0.13",
-    "@tailwindcss-mangle/shared": "^1.2.7"
+    "magic-string": "^0.30.2",
+    "@tailwindcss-mangle/shared": "^2.0.0"
   },
   "devDependencies": {
     "@parse5/tools": "^0.2.0",
@@ -54,7 +57,7 @@
   },
   "scripts": {
     "build": "unbuild",
-    "test": "vitest run",
+    "test": "vitest run --coverage.enabled",
     "test:dev": "vitest",
     "coverage": "vitest run --coverage"
   }