@tailwindcss-obfuscator/core 1.0.2 → 1.0.3

package/dist/rewrite-source.js

@@ -0,0 +1,199 @@
+// src/class-strings-finder.ts
+var CN_FUNCTION_NAMES = ["cn", "clsx", "classNames", "twMerge", "cva"];
+function skipQuotedString(code, i) {
+  const quote = code[i];
+  let pos = i + 1;
+  while (pos < code.length && code[pos] !== quote) {
+    if (code[pos] === "\\") {
+      pos += 1;
+    }
+    pos += 1;
+  }
+  return pos + 1;
+}
+function skipToMatchingParen(code, fromIndex) {
+  let depth = 1;
+  let i = fromIndex;
+  while (i < code.length && depth > 0) {
+    if (code[i] === "(") {
+      depth += 1;
+      i += 1;
+    } else if (code[i] === ")") {
+      depth -= 1;
+      i += 1;
+    } else if (code[i] === '"' || code[i] === "'" || code[i] === "`") {
+      i = skipQuotedString(code, i);
+    } else {
+      i += 1;
+    }
+  }
+  return i;
+}
+function findCnCalls(code) {
+  const calls = [];
+  for (const fnName of CN_FUNCTION_NAMES) {
+    const regex = new RegExp(`\\b${fnName}\\s*\\(`, "g");
+    regex.lastIndex = 0;
+    let match = regex.exec(code);
+    while (match !== null) {
+      const start = match.index;
+      const i = skipToMatchingParen(code, start + match[0].length);
+      calls.push({ content: code.slice(start, i), end: i, start });
+      match = regex.exec(code);
+    }
+  }
+  return calls;
+}
+function findClassStrings(code) {
+  const matches = [];
+  const stringRegex = /(['"`])(.*?)\1/g;
+  for (const call of findCnCalls(code)) {
+    stringRegex.lastIndex = 0;
+    let match = stringRegex.exec(call.content);
+    while (match !== null) {
+      const [fullMatch, , classString] = match;
+      matches.push({
+        classString,
+        end: call.start + match.index + fullMatch.length,
+        fullMatch,
+        start: call.start + match.index
+      });
+      match = stringRegex.exec(call.content);
+    }
+  }
+  const jsxClassNameRegex = /className\s*=\s*(?:\{[^}]*["'`]([^"'`]+)["'`][^}]*\}|["'`]([^"'`]+)["'`])/g;
+  const compiledClassNameRegex = /className\s*:\s*(["'`])([^"'`]+)\1/g;
+  for (const { regex, getClassString } of [
+    {
+      getClassString: (m) => m[1] || m[2],
+      regex: jsxClassNameRegex
+    },
+    {
+      getClassString: (m) => m[2],
+      regex: compiledClassNameRegex
+    }
+  ]) {
+    regex.lastIndex = 0;
+    let classMatch = regex.exec(code);
+    while (classMatch !== null) {
+      const [fullMatch] = classMatch;
+      const classString = getClassString(classMatch);
+      if (classString && !CN_FUNCTION_NAMES.some((fn) => fullMatch.includes(`${fn}(`))) {
+        matches.push({
+          classString,
+          end: classMatch.index + fullMatch.length,
+          fullMatch,
+          start: classMatch.index
+        });
+      }
+      classMatch = regex.exec(code);
+    }
+  }
+  return matches;
+}
+
+// src/obfuscator.ts
+class Obfuscator {
+  counter = 0;
+  map = new Map;
+  prefix;
+  alphabet = "abcdefghijklmnopqrstuvwxyz";
+  constructor(prefix = "az") {
+    this.prefix = prefix;
+  }
+  numberToLetters(num) {
+    let result = "";
+    let n = num;
+    const base = this.alphabet.length;
+    do {
+      result = this.alphabet[n % base] + result;
+      n = Math.floor(n / base);
+    } while (n > 0);
+    return result;
+  }
+  generateCode() {
+    const letters = this.numberToLetters(this.counter);
+    const code = letters.padStart(2, "a");
+    this.counter += 1;
+    return this.prefix + code;
+  }
+  getObfuscatedClass(originalClass) {
+    const existing = this.map.get(originalClass);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const obfuscated = this.generateCode();
+    this.map.set(originalClass, obfuscated);
+    return obfuscated;
+  }
+  getMap() {
+    return new Map(this.map);
+  }
+  reset() {
+    this.counter = 0;
+    this.map.clear();
+  }
+}
+
+// src/rewrite-source.ts
+var RE_WHITESPACE = /\s+/;
+function stripEscapeSequence(str) {
+  return str.replaceAll("\\", "");
+}
+
+class RewriteSource {
+  allowlist = new Set;
+  obfuscator;
+  constructor(prefix = "az") {
+    this.obfuscator = new Obfuscator(prefix);
+  }
+  setAllowlist(allowlist) {
+    this.allowlist = allowlist;
+  }
+  normalizeClass(cls) {
+    return stripEscapeSequence(cls);
+  }
+  isInAllowlist(normalized) {
+    return this.allowlist.has(normalized);
+  }
+  transformClassString(classString) {
+    const classes = classString.split(RE_WHITESPACE).filter(Boolean);
+    const transformed = classes.map((cls) => {
+      const normalized = this.normalizeClass(cls);
+      if (!this.isInAllowlist(normalized)) {
+        return cls;
+      }
+      return this.obfuscator.getObfuscatedClass(normalized);
+    });
+    return transformed.join(" ");
+  }
+  transform(code, _id) {
+    const matches = findClassStrings(code);
+    const replacements = [];
+    for (const { start, end, classString, fullMatch } of matches) {
+      const hasAllowlistClass = classString.split(RE_WHITESPACE).some((c) => this.isInAllowlist(this.normalizeClass(c)));
+      if (!hasAllowlistClass) {
+        continue;
+      }
+      const transformed = this.transformClassString(classString);
+      const newContent = fullMatch.replace(classString, transformed);
+      replacements.push({ end, newContent, start });
+    }
+    replacements.sort((a, b) => b.start - a.start);
+    let result = code;
+    for (const { start, end, newContent } of replacements) {
+      result = result.slice(0, start) + newContent + result.slice(end);
+    }
+    return { code: result, map: this.obfuscator.getMap() };
+  }
+  getMap() {
+    return this.obfuscator.getMap();
+  }
+  reset() {
+    this.allowlist = new Set;
+    this.obfuscator.reset();
+  }
+}
+export {
+  RewriteSource
+};

package/dist/transformer.d.ts

@@ -1,12 +1,16 @@
 import type { ClassMap } from "./types.ts";
 export declare class SourceTransformer {
-    private readonly generator;
+    private allowlist;
+    private readonly obfuscator;
+    constructor(prefix?: string);
+    setAllowlist(allowlist: Set<string>): void;
     private normalizeClass;
+    private isTailwindClass;
     private transformClassString;
     private skipToMatchingParen;
     private findCnCalls;
-    private processCnCalls;
-    private processClassNameAttrs;
+    private collectCnCallReplacements;
+    private collectClassNameAttrReplacements;
     transform(code: string, _id: string): {
         code: string;
         map: ClassMap;

package/dist/transformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../src/transformer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AA6C3C,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IAEjD,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,oBAAoB;IAY5B,OAAO,CAAC,mBAAmB;IAmB3B,OAAO,CAAC,WAAW;IAqBnB,OAAO,CAAC,cAAc;IA0BtB,OAAO,CAAC,qBAAqB;IAoC7B,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAA;KAAE;IAOrE,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAI7B,KAAK,IAAI,IAAI;CAGb"}
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../src/transformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AA4B3C,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;gBAE5B,MAAM,SAAO;IAIzB,YAAY,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI;IAI1C,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,oBAAoB;IAY5B,OAAO,CAAC,mBAAmB;IAmB3B,OAAO,CAAC,WAAW;IAqBnB,OAAO,CAAC,yBAAyB;IA4BjC,OAAO,CAAC,gCAAgC;IA0CxC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAA;KAAE;IAarE,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAI7B,KAAK,IAAI,IAAI;CAIb"}

package/dist/transformer.js

@@ -1,10 +1,12 @@
-// src/generator.ts
-var PREFIX = "az";
-
-class CodeGenerator {
+// src/obfuscator.ts
+class Obfuscator {
   counter = 0;
   map = new Map;
+  prefix;
   alphabet = "abcdefghijklmnopqrstuvwxyz";
+  constructor(prefix = "az") {
+    this.prefix = prefix;
+  }
   numberToLetters(num) {
     let result = "";
     let n = num;
@@ -19,7 +21,7 @@ class CodeGenerator {
     const letters = this.numberToLetters(this.counter);
     const code = letters.padStart(2, "a");
     this.counter += 1;
-    return PREFIX + code;
+    return this.prefix + code;
   }
   getObfuscatedClass(originalClass) {
     const existing = this.map.get(originalClass);
@@ -40,30 +42,11 @@ class CodeGenerator {
 }
 
 // src/transformer.ts
-import MagicString from "magic-string";
 var CN_FUNCTION_NAMES = ["cn", "clsx", "classNames", "twMerge", "cva"];
 var RE_WHITESPACE = /\s+/;
-var TAILWIND_CLASS_TEST = /[:-]/;
-var KNOWN_TAILWIND_UTILITIES = new Set([
-  "flex",
-  "grid",
-  "block",
-  "inline",
-  "hidden",
-  "static",
-  "relative",
-  "absolute",
-  "fixed",
-  "sticky",
-  "table",
-  "contents"
-]);
 function stripEscapeSequence(str) {
   return str.replaceAll("\\", "");
 }
-function isTailwindClass(className) {
-  return TAILWIND_CLASS_TEST.test(className) || KNOWN_TAILWIND_UTILITIES.has(className);
-}
 function skipQuotedString(code, i) {
   const quote = code[i];
   let pos = i + 1;
@@ -77,18 +60,28 @@ function skipQuotedString(code, i) {
 }
 
 class SourceTransformer {
-  generator = new CodeGenerator;
+  allowlist = new Set;
+  obfuscator;
+  constructor(prefix = "az") {
+    this.obfuscator = new Obfuscator(prefix);
+  }
+  setAllowlist(allowlist) {
+    this.allowlist = allowlist;
+  }
   normalizeClass(cls) {
     return stripEscapeSequence(cls);
   }
+  isTailwindClass(normalized) {
+    return this.allowlist.has(normalized);
+  }
   transformClassString(classString) {
     const classes = classString.split(RE_WHITESPACE).filter(Boolean);
     const transformed = classes.map((cls) => {
       const normalized = this.normalizeClass(cls);
-      if (!isTailwindClass(normalized)) {
+      if (!this.isTailwindClass(normalized)) {
         return cls;
       }
-      return this.generator.getObfuscatedClass(normalized);
+      return this.obfuscator.getObfuscatedClass(normalized);
     });
     return transformed.join(" ");
   }
@@ -125,7 +118,8 @@ class SourceTransformer {
     }
     return calls;
   }
-  processCnCalls(s, code) {
+  collectCnCallReplacements(code) {
+    const replacements = [];
     const cnCalls = this.findCnCalls(code);
     const stringRegex = /(['"`])(.*?)\1/g;
     for (const call of cnCalls) {
@@ -133,16 +127,22 @@ class SourceTransformer {
       let match = stringRegex.exec(call.content);
       while (match !== null) {
         const [fullMatch, quote, classString] = match;
-        if (classString.split(RE_WHITESPACE).some((c) => isTailwindClass(this.normalizeClass(c)))) {
+        if (classString.split(RE_WHITESPACE).some((c) => this.isTailwindClass(this.normalizeClass(c)))) {
           const transformed = this.transformClassString(classString);
           const startInFile = call.start + match.index;
-          s.overwrite(startInFile, startInFile + fullMatch.length, `${quote}${transformed}${quote}`);
+          replacements.push({
+            end: startInFile + fullMatch.length,
+            newContent: `${quote}${transformed}${quote}`,
+            start: startInFile
+          });
         }
         match = stringRegex.exec(call.content);
       }
     }
+    return replacements;
   }
-  processClassNameAttrs(s, code) {
+  collectClassNameAttrReplacements(code) {
+    const replacements = [];
     const jsxClassNameRegex = /className\s*=\s*(?:\{[^}]*["'`]([^"'`]+)["'`][^}]*\}|["'`]([^"'`]+)["'`])/g;
     const compiledClassNameRegex = /className\s*:\s*(["'`])([^"'`]+)\1/g;
     for (const { regex, getClassString } of [
@@ -160,27 +160,38 @@ class SourceTransformer {
       while (classMatch !== null) {
         const [fullMatch] = classMatch;
         const classString = getClassString(classMatch);
-        if (classString && !CN_FUNCTION_NAMES.some((fn) => fullMatch.includes(`${fn}(`)) && classString.split(RE_WHITESPACE).some((c) => isTailwindClass(this.normalizeClass(c)))) {
+        if (classString && !CN_FUNCTION_NAMES.some((fn) => fullMatch.includes(`${fn}(`)) && classString.split(RE_WHITESPACE).some((c) => this.isTailwindClass(this.normalizeClass(c)))) {
           const transformed = this.transformClassString(classString);
           const startInFile = classMatch.index;
           const newValue = fullMatch.replace(classString, transformed);
-          s.overwrite(startInFile, startInFile + fullMatch.length, newValue);
+          replacements.push({
+            end: startInFile + fullMatch.length,
+            newContent: newValue,
+            start: startInFile
+          });
         }
         classMatch = regex.exec(code);
       }
     }
+    return replacements;
   }
   transform(code, _id) {
-    const s = new MagicString(code);
-    this.processCnCalls(s, code);
-    this.processClassNameAttrs(s, code);
-    return { code: s.toString(), map: this.generator.getMap() };
+    const replacements = [
+      ...this.collectCnCallReplacements(code),
+      ...this.collectClassNameAttrReplacements(code)
+    ].sort((a, b) => b.start - a.start);
+    let result = code;
+    for (const { start, end, newContent } of replacements) {
+      result = result.slice(0, start) + newContent + result.slice(end);
+    }
+    return { code: result, map: this.obfuscator.getMap() };
   }
   getMap() {
-    return this.generator.getMap();
+    return this.obfuscator.getMap();
   }
   reset() {
-    this.generator.reset();
+    this.allowlist = new Set;
+    this.obfuscator.reset();
   }
 }
 export {

package/package.json

@@ -1,27 +1,11 @@
 {
-	"dependencies": {
-		"lightningcss": "^1.31.1",
-		"magic-string": "^0.30.21"
-	},
 	"devDependencies": {
 		"typescript": "^5.9.3"
 	},
 	"exports": {
-		"./compressor": {
-			"import": "./dist/compressor.js",
-			"types": "./dist/compressor.d.ts"
-		},
-		"./css-handler": {
-			"import": "./dist/css-handler.js",
-			"types": "./dist/css-handler.d.ts"
-		},
-		"./transformer": {
-			"import": "./dist/transformer.js",
-			"types": "./dist/transformer.d.ts"
-		},
-		"./types": {
-			"import": "./dist/types.js",
-			"types": "./dist/types.d.ts"
+		"./apply-class-names": {
+			"import": "./dist/apply-class-names.js",
+			"types": "./dist/apply-class-names.d.ts"
 		}
 	},
 	"files": [
@@ -32,9 +16,9 @@
 		"access": "public"
 	},
 	"scripts": {
-		"build": "tsc && bun build src/transformer.ts src/css-handler.ts src/compressor.ts src/generator.ts src/types.ts --outdir=dist --format=esm --external=lightningcss --external=magic-string"
+		"build": "tsc && bun build src/find-class-strings.ts src/generate-class-names.ts src/apply-class-names.ts --outdir=dist --format=esm"
 	},
 	"type": "module",
-	"types": "./dist/transformer.d.ts",
-	"version": "1.0.2"
+	"types": "./dist/apply-class-names.d.ts",
+	"version": "1.0.3"
 }