@tailwindcss-obfuscator/core 1.0.2 → 1.0.3

package/dist/1-class-strings-finder.d.ts

@@ -0,0 +1,12 @@
+export interface ClassStringMatch {
+    end: number;
+    fullMatch: string;
+    classString: string;
+    start: number;
+}
+/**
+ * Find all class string occurrences in source (className="...", cn("..."), etc.).
+ * Only finds; does not replace or check allowlist.
+ */
+export declare function findClassStrings(code: string): ClassStringMatch[];
+//# sourceMappingURL=1-class-strings-finder.d.ts.map

package/dist/1-class-strings-finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1-class-strings-finder.d.ts","sourceRoot":"","sources":["../src/1-class-strings-finder.ts"],"names":[],"mappings":"AAsDA,MAAM,WAAW,gBAAgB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAqDjE"}

package/dist/1-class-strings-finder.js

@@ -0,0 +1,96 @@
+// src/1-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;
+}
+export {
+  findClassStrings
+};

package/dist/2-obfuscator.d.ts

@@ -0,0 +1,14 @@
+import type { ClassMap } from "./types.ts";
+export declare class Obfuscator {
+    private counter;
+    private readonly map;
+    private readonly prefix;
+    private readonly alphabet;
+    constructor(prefix?: string);
+    private numberToLetters;
+    private generateCode;
+    getObfuscatedClass(originalClass: string): string;
+    getMap(): ClassMap;
+    reset(): void;
+}
+//# sourceMappingURL=2-obfuscator.d.ts.map

package/dist/2-obfuscator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"2-obfuscator.d.ts","sourceRoot":"","sources":["../src/2-obfuscator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,qBAAa,UAAU;IACtB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAuB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgC;gBAE7C,MAAM,SAAO;IAIzB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,YAAY;IAOpB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM;IAWjD,MAAM,IAAI,QAAQ;IAIlB,KAAK,IAAI,IAAI;CAIb"}

package/dist/2-obfuscator.js

@@ -0,0 +1,45 @@
+// src/2-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();
+  }
+}
+export {
+  Obfuscator
+};

package/dist/2-rename-class-strings.d.ts

@@ -0,0 +1,14 @@
+import type { ClassMap } from "./types.ts";
+export declare class Obfuscator {
+    private counter;
+    private readonly map;
+    private readonly prefix;
+    private readonly alphabet;
+    constructor(prefix?: string);
+    private numberToLetters;
+    private generateCode;
+    getObfuscatedClass(originalClass: string): string;
+    getMap(): ClassMap;
+    reset(): void;
+}
+//# sourceMappingURL=2-rename-class-strings.d.ts.map

package/dist/2-rename-class-strings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"2-rename-class-strings.d.ts","sourceRoot":"","sources":["../src/2-rename-class-strings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,qBAAa,UAAU;IACtB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAuB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgC;gBAE7C,MAAM,SAAO;IAIzB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,YAAY;IAOpB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM;IAWjD,MAAM,IAAI,QAAQ;IAIlB,KAAK,IAAI,IAAI;CAIb"}

package/dist/2-rename-class-strings.js

@@ -0,0 +1,45 @@
+// src/2-rename-class-strings.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();
+  }
+}
+export {
+  Obfuscator
+};

package/dist/3-apply-class-names.d.ts

@@ -0,0 +1,18 @@
+import type { ClassMap } from "./types.ts";
+export declare class ApplyClassNames {
+    private allowlist;
+    private readonly obfuscator;
+    constructor(prefix?: string);
+    setAllowlist(allowlist: Set<string>): void;
+    private normalizeClass;
+    private isInAllowlist;
+    private transformClassString;
+    updateJavaScript(code: string, _id: string): {
+        code: string;
+        map: ClassMap;
+    };
+    updateStylesheet(css: string): string;
+    getMap(): Map<string, string>;
+    reset(): void;
+}
+//# sourceMappingURL=3-apply-class-names.d.ts.map

package/dist/3-apply-class-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"3-apply-class-names.d.ts","sourceRoot":"","sources":["../src/3-apply-class-names.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AA6B3C,qBAAa,eAAe;IAC3B,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,aAAa;IAIrB,OAAO,CAAC,oBAAoB;IAY5B,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAA;KAAE;IAwB5E,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAyDrC,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAI7B,KAAK,IAAI,IAAI;CAIb"}

package/dist/3-apply-class-names.js

@@ -0,0 +1,227 @@
+// src/find-class-strings.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/generate-class-names.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/3-apply-class-names.ts
+var RE_WHITESPACE = /\s+/;
+function stripEscapeSequence(str) {
+  return str.replaceAll("\\", "");
+}
+function escapeStringRegexp(str) {
+  return str.replaceAll(/[$*+?[\\\]^{|}]/g, "\\$&").replaceAll("-", "\\x2d").replaceAll("/", "\\/").replaceAll("(", "\\\\(").replaceAll(")", "\\\\)").replaceAll(".", "\\\\.").replaceAll(",", "\\\\,");
+}
+
+class ApplyClassNames {
+  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(" ");
+  }
+  updateJavaScript(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) {
+        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() };
+  }
+  updateStylesheet(css) {
+    const classMap = this.obfuscator.getMap();
+    if (classMap.size === 0) {
+      return css;
+    }
+    let transformed = css;
+    const sortedClasses = Array.from(classMap.entries()).sort((a, b) => b[0].length - a[0].length);
+    for (const [original, obfuscated] of sortedClasses) {
+      const escapedOriginal = escapeStringRegexp(original);
+      const classRegex = new RegExp(`\\.(${escapedOriginal})(?=[\\s\\{\\[\\]\\(\\):,;]|$)`, "g");
+      transformed = transformed.replace(classRegex, `.${obfuscated}`);
+      if (original.endsWith("!")) {
+        const escapedForRegex = escapeStringRegexp(`${original.slice(0, -1)}\\!`);
+        const importantRegex = new RegExp(`\\.${escapedForRegex}(?=[\\s\\{\\[\\]\\(\\):,;]|$)`, "g");
+        transformed = transformed.replace(importantRegex, `.${obfuscated}`);
+      }
+      if (original.includes("[") || original.includes("]") || original.includes(":") || original.includes("/") || original.includes(".") || original.includes(",")) {
+        const cssEscaped = original.replaceAll(/\[/g, "\\[").replaceAll(/\]/g, "\\]").replaceAll(/:/g, "\\:").replaceAll(/\//g, "\\/").replaceAll("(", "\\(").replaceAll(")", "\\)").replaceAll(".", "\\.").replaceAll(",", "\\,");
+        const cssSelector = `.${cssEscaped}`;
+        if (transformed.includes(cssSelector)) {
+          transformed = transformed.replaceAll(cssSelector, `.${obfuscated}`);
+        }
+      }
+    }
+    return transformed;
+  }
+  getMap() {
+    return this.obfuscator.getMap();
+  }
+  reset() {
+    this.allowlist = new Set;
+    this.obfuscator.reset();
+  }
+}
+export {
+  ApplyClassNames
+};

package/dist/3-rewrite-source.d.ts

@@ -0,0 +1,17 @@
+import type { ClassMap } from "./types.ts";
+export declare class RewriteSource {
+    private allowlist;
+    private readonly obfuscator;
+    constructor(prefix?: string);
+    setAllowlist(allowlist: Set<string>): void;
+    private normalizeClass;
+    private isInAllowlist;
+    private transformClassString;
+    transform(code: string, _id: string): {
+        code: string;
+        map: ClassMap;
+    };
+    getMap(): Map<string, string>;
+    reset(): void;
+}
+//# sourceMappingURL=3-rewrite-source.d.ts.map

package/dist/3-rewrite-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"3-rewrite-source.d.ts","sourceRoot":"","sources":["../src/3-rewrite-source.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAc3C,qBAAa,aAAa;IACzB,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,aAAa;IAIrB,OAAO,CAAC,oBAAoB;IAY5B,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAA;KAAE;IAyBrE,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAI7B,KAAK,IAAI,IAAI;CAIb"}