xatriumcss 1.0.25 → 1.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xatriumcss",
-    "version": "1.0.25",
+    "version": "1.0.26",
     "description": "Ultra-fast utility-first CSS framework",
     "main": "./src/index.js",
     "files": [
@@ -34,8 +34,9 @@
     ],
     "dependencies": {
         "@parcel/watcher": "^2.4.0",
-        "glob": "^10.5.0",
-        "@xatriumcss/oxide": "^4.1.18"
+        "@tailwindcss/oxide": "^4.1.18",
+        "esbuild": "^0.27.2",
+        "glob": "^10.5.0"
     },
     "devDependencies": {
         "@napi-rs/cli": "^2.18.0"

package/src/cli.js

@@ -89,7 +89,6 @@ function formatTime(nanoseconds) {
         process.exit(1);
     }
 
-    // Watch mode
     // Watch mode
     if (args['--watch']) {
         console.log('\n👀 Watch mode enabled\n');

package/src/collectClasses.js

@@ -1,97 +1,7 @@
 import fs from 'fs';
-import { glob } from 'glob';
 import path from 'path';
 
-let nativeScanner;
-try {
-  const module = await import('@xatriumcss/oxide');
-  nativeScanner = module.default || module;
-  console.log("using native scanner");
-} catch (e) {
-  console.log("using fallback scanner");
-  console.log("ERROR:", e.message);
-  nativeScanner = null;
-}
-
-function smartSplitNoBrace(str, ...splitChars) {
-    if (splitChars.length === 0) splitChars = [' '];
-
-    const result = [];
-    let current = '';
-    let bracketDepth = 0;
-    let parenDepth = 0;
-    let braceDepth = 0;
-    let inQuote = null;
-
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        const prevChar = str[i - 1];
-
-        // Handle quotes (not escaped)
-        if ((char === "'" || char === '"') && prevChar !== '\\') {
-            if (!inQuote) {
-                inQuote = char;
-            } else if (inQuote === char) {
-                inQuote = null;
-            }
-            current += char;
-            continue;
-        }
-
-        // Track depths only when not in quotes
-        if (!inQuote) {
-            if (char === '[') bracketDepth++;
-            if (char === ']' && bracketDepth > 0) bracketDepth--;
-            if (char === '(') parenDepth++;
-            if (char === ')' && parenDepth > 0) parenDepth--;
-
-            // Track brace depth with prefix check
-            if (char === '{') {
-                // Check if there's content in current token (means there's a prefix)
-                const hasPrefix = current.trim().length > 0;
-
-                // Always increment brace depth
-                braceDepth++;
-
-                // But if there's a prefix, we're in "keep together" mode
-                // The depth will prevent splitting until we hit the closing }
-            }
-
-            if (char === '}' && braceDepth > 0) {
-                braceDepth--;
-            }
-        }
-
-        // ✅ Split on specified characters only if all depths are 0 and not in quotes
-        let shouldSplit = false;
-        if (bracketDepth === 0 && parenDepth === 0 && braceDepth === 0) {
-            // Check single character splits
-            if (splitChars.includes(char)) {
-                shouldSplit = true;
-            }
-            // Check multi-character splits (like "::")
-            for (let splitStr of splitChars) {
-                if (splitStr.length > 1 && str.slice(i, i + splitStr.length) === splitStr) {
-                    shouldSplit = true;
-                    i += splitStr.length - 1; // Skip ahead
-                    break;
-                }
-            }
-        }
-
-        if (shouldSplit) {
-            if (current) result.push(current);
-            current = '';
-        } else {
-            current += char;
-        }
-    }
-
-    if (current) result.push(current);
-    return result;
-}
-
-function collectClasses(contentPaths) {
+export async function collectClasses(contentPaths) {
   const sourceConfig = global.xatriumSourceConfig || {
     basePath: null,
     disableAuto: false,
@@ -99,411 +9,239 @@ function collectClasses(contentPaths) {
     ignorePaths: []
   };
 
-  // Use native scanner if available
-  if (nativeScanner) {
-    try {
-      // Build paths array
-      let pathsArray = sourceConfig.disableAuto 
-        ? sourceConfig.explicitPaths 
-        : [...(Array.isArray(contentPaths) ? contentPaths : [contentPaths]), ...sourceConfig.explicitPaths];
-      
-      // Filter out any null/undefined values
-      pathsArray = pathsArray.filter(p => p != null);
-      
-      if (pathsArray.length === 0) {
-        console.warn('⚠️  No valid patterns to scan, falling back to JS scanner');
-        throw new Error('No patterns provided');
-      }
-      
-      // Convert patterns to SourceEntry format
-      const sources = [];
-      
-      // Add positive patterns
-      pathsArray.forEach(pattern => {
-        sources.push({
-          base: process.cwd(),
-          pattern: pattern,
-          negated: false
-        });
-      });
-      
-      // Add negative patterns (ignore paths)
-      sourceConfig.ignorePaths.forEach(pattern => {
-        sources.push({
-          base: process.cwd(),
-          pattern: pattern,
-          negated: true
-        });
-      });
-      
-      console.log('🚀 Using native scanner (Rust) for file discovery');
-      console.log('📋 Patterns:', pathsArray);
-      
-      // Create scanner with options
-      let scanner;
-      try {
-        scanner = new nativeScanner.Scanner({ sources });
-      } catch (error) {
-        console.warn('⚠️  Native scanner failed, falling back to JS:', error.message);
-      }
-      
-      // Get the files that were matched by the scanner
-      const files = scanner.files;
-      
-      if (!files || files.length === 0) {
-        console.warn('⚠️  Native scanner found no files');
-        throw new Error('No files found');
-      }
-      
-      console.log(`📄 Native scanner found ${files.length} files`);
-      
-      // Read files and extract quoted strings manually to preserve grouping
-      const quotedStrings = scanner.scan();  // Rust does EVERYTHING!
-      
-      console.log(`✅ Extracted ${quotedStrings.length} quoted strings from files`);
-      return processClasses(quotedStrings);
-    } catch (error) {
-      console.warn('⚠️  Native scanner failed, falling back to JS:', error.message);
+  try {
+    let pathsArray = sourceConfig.disableAuto
+      ? sourceConfig.explicitPaths
+      : [
+          ...(Array.isArray(contentPaths) ? contentPaths : [contentPaths]),
+          ...sourceConfig.explicitPaths,
+        ];
+
+    pathsArray = pathsArray.filter(Boolean);
+
+    if (sourceConfig.ignorePaths?.length) {
+      const ignoreSet = new Set(
+        sourceConfig.ignorePaths.map(p => p.toLowerCase())
+      );
+      pathsArray = pathsArray.filter(
+        p => !ignoreSet.has(p.toLowerCase())
+      );
     }
-  }
-  
-  // Fallback to JavaScript implementation
-  return collectClassesJS(contentPaths);
-}
 
-function processClasses(rawClasses) {
-  // Additional safety check
-  if (!rawClasses || !Array.isArray(rawClasses)) {
-    console.warn('⚠️  processClasses received invalid input:', typeof rawClasses);
-    return [];
-  }
+    if (pathsArray.length === 0) {
+      console.warn('⚠️ No valid patterns to scan');
+      return [];
+    }
 
-  const allClasses = new Set();
-  
-  rawClasses.forEach(part => {
-    // Ensure part is a string
-    if (typeof part !== 'string') {
-      console.warn('⚠️  Skipping non-string class:', typeof part, part);
-      return;
+    console.log('🚀 Using streaming scanner (blazing fast)');
+    console.log('📋 Raw patterns:', pathsArray);
+
+    const resolvedPaths = pathsArray.map(p => path.resolve(p));
+    const files = await scanFiles(resolvedPaths, sourceConfig.ignorePaths);
+
+    console.log(`📄 Found ${files.length} files to scan`);
+
+    if (files.length === 0) {
+      return [];
     }
 
-    let cls = part.trim();
-    if (!cls) return;
-
-    // Normalize whitespace to single spaces, but preserve inside ( [ { " '
-    let normalizedCls = "";
-    let parenDepth = 0;
-    let bracketDepth = 0;
-    let braceDepth = 0;
-    let inSingleQuote = false;
-    let inDoubleQuote = false;
-
-    for (let i = 0; i < cls.length; i++) {
-      const char = cls[i];
-
-      // Track quote state
-      if (char === "'" && !inDoubleQuote) inSingleQuote = !inSingleQuote;
-      else if (char === '"' && !inSingleQuote) inDoubleQuote = !inDoubleQuote;
-
-      const inQuotes = inSingleQuote || inDoubleQuote;
-
-      // Track bracket depths (only if not in quotes)
-      if (!inQuotes) {
-        if (char === "(") parenDepth++;
-        else if (char === ")") parenDepth--;
-        else if (char === "[") bracketDepth++;
-        else if (char === "]") bracketDepth--;
-        else if (char === "{") braceDepth++;
-        else if (char === "}") braceDepth--;
-      }
+    const allClasses = await extractClassesFromFiles(files);
+    
+    console.log(`✅ Extracted ${allClasses.length} classes`);
+    return allClasses;
+  } catch (error) {
+    console.error('❌ Error during class collection:', error.message);
+    return [];
+  }
+}
 
-      const insideGroup = parenDepth > 0 || bracketDepth > 0 || braceDepth > 0 || inQuotes;
+async function scanFiles(patterns, ignorePaths = []) {
+  const files = new Set();
+  const ignoreSet = new Set(ignorePaths.map(p => p.toLowerCase()));
 
-      // Normalize whitespace only when NOT inside groups
-      if (/\s/.test(char)) {
-        if (insideGroup) {
-          normalizedCls += char;
-        } else {
-          // Collapse consecutive whitespace to single space
-          if (normalizedCls.length > 0 && !/\s/.test(normalizedCls[normalizedCls.length - 1])) {
-            normalizedCls += " ";
+  for (const pattern of patterns) {
+    if (pattern.includes('*') || pattern.includes('?')) {
+      const dir = path.dirname(pattern);
+      const glob = path.basename(pattern);
+      
+      try {
+        const matched = await globWalk(dir, glob);
+        matched.forEach(f => {
+          const lowerF = f.toLowerCase();
+          if (!ignoreSet.has(lowerF)) {
+            files.add(f);
           }
+        });
+      } catch (err) {
+        console.warn(`⚠️ Error scanning ${pattern}:`, err.message);
+      }
+    } else {
+      if (fs.existsSync(pattern)) {
+        const lowerP = pattern.toLowerCase();
+        if (!ignoreSet.has(lowerP)) {
+          files.add(pattern);
         }
-      } else {
-        normalizedCls += char;
       }
     }
+  }
 
-    normalizedCls = normalizedCls.trim();
-    const innerParts = smartSplitNoBrace(normalizedCls, " ");
-
-    const spawnShorthandRegex = /^(.*?:)?spawn-((?:from|to|back|half|\[[^\]]+\])(?:\/(?:from|to|back|half|\[[^\]]+\]))*):(.+)$/;
-    const scrollShorthandRegex = /^(.*?:)?scroll-((?:from|to|back|half|\[[^\]]+\])(?:\/(?:from|to|back|half|\[[^\]]+\]))*):(.+)$/;
-    const scrollPrefixRegex = /^(.*?:)?scroll:(.+)$/;
-
-    // Group by prefix for spawn/scroll classes
-    const spawnByPrefix = {};
-    const scrollByPrefix = {};
-    const nonShorthandParts = [];
-
-    innerParts.forEach(part => {
-      if (spawnShorthandRegex.test(part)) {
-        const match = part.match(spawnShorthandRegex);
-        const prefix = match[1] || ''; // Empty string for no prefix
+  return Array.from(files);
+}
 
-        if (!spawnByPrefix[prefix]) {
-          spawnByPrefix[prefix] = [];
-        }
-        spawnByPrefix[prefix].push(part);
-      } else if (scrollShorthandRegex.test(part) || scrollPrefixRegex.test(part)) {
-        const match = part.match(scrollShorthandRegex) || part.match(scrollPrefixRegex);
-        const prefix = match[1] || ''; // Empty string for no prefix
+async function globWalk(dir, pattern) {
+  const files = [];
+  const regexPattern = globToRegex(pattern);
 
-        if (!scrollByPrefix[prefix]) {
-          scrollByPrefix[prefix] = [];
+  function walk(currentPath) {
+    try {
+      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        
+        if (entry.isFile() && regexPattern.test(entry.name)) {
+          files.push(fullPath);
+        } else if (entry.isDirectory() && !entry.name.startsWith('.')) {
+          walk(fullPath);
         }
-        scrollByPrefix[prefix].push(part);
-      } else {
-        nonShorthandParts.push(part);
       }
-    });
-
-    // Add non-shorthand classes normally
-    nonShorthandParts.forEach(c => allClasses.add(c));
+    } catch (err) {
+      // Silently ignore permission errors
+    }
+  }
 
-    // Add spawn classes grouped by prefix
-    Object.values(spawnByPrefix).forEach(group => {
-      if (group.length > 0) {
-        allClasses.add(group.join(' '));
-      }
-    });
+  if (fs.existsSync(dir)) {
+    walk(dir);
+  }
 
-    // Add scroll classes grouped by prefix
-    Object.values(scrollByPrefix).forEach(group => {
-      if (group.length > 0) {
-        allClasses.add(group.join(' '));
-      }
-    });
-  });
+  return files;
+}
 
-  // Group and sort motion classes by prefix length
-  const motionRegex = /^(.*?)motion-\[([^\]]+)\]:/;
-  const motionByName = {};
-  const nonMotionClasses = [];
+function globToRegex(glob) {
+  let regexStr = glob
+    .replace(/\./g, '\\.')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\?/g, '.');
+  
+  return new RegExp(`^${regexStr}$`);
+}
 
-  Array.from(allClasses).forEach(cls => {
-    const match = cls.match(motionRegex);
-    if (match) {
-      const prefix = match[1]; // Everything before "motion-["
-      const animName = match[2];
+async function extractClassesFromFiles(filePaths) {
+  const allClasses = new Set();
+  const start = performance.now();
 
-      if (!motionByName[animName]) {
-        motionByName[animName] = [];
-      }
+  // Process all files in parallel with sync reads
+  filePaths.forEach((filePath) => {
+    try {
+      const fileContent = fs.readFileSync(filePath, 'utf8');
+      const parts = extractQuotedStringsSync(fileContent);
 
-      motionByName[animName].push({
-        cls: cls,
-        prefix: prefix,
-        prefixLength: prefix.length
+      parts.forEach(part => {
+        const classes = processClassString(part);
+        classes.forEach(cls => allClasses.add(cls));
       });
-    } else {
-      nonMotionClasses.push(cls);
+    } catch (err) {
+      console.warn(`⚠️ Error reading file ${filePath}:`, err.message);
     }
   });
 
-  // Sort each animation's classes by prefix length (shortest first)
-  const sortedMotionClasses = [];
-  Object.values(motionByName).forEach(group => {
-    group.sort((a, b) => a.prefixLength - b.prefixLength);
-    sortedMotionClasses.push(...group.map(item => item.cls));
-  });
+  const elapsed = performance.now() - start;
+  console.log(`⚡ Extraction time: ${elapsed.toFixed(2)}ms`);
 
-  // Rebuild allClasses: non-motion first, then sorted motion
-  allClasses.clear();
-  nonMotionClasses.forEach(c => allClasses.add(c));
-  sortedMotionClasses.forEach(c => allClasses.add(c));
-
-  return Array.from(allClasses);
+  return sortMotionClasses(Array.from(allClasses));
 }
 
-function collectClassesJS(contentPaths) {
-  const allClasses = new Set();
-  
-  // Get source configuration
-  const sourceConfig = global.xatriumSourceConfig || {
-    basePath: null,
-    disableAuto: false,
-    explicitPaths: [],
-    ignorePaths: []
-  };
+function extractQuotedStringsSync(content) {
+  const result = [];
+  let current = '';
+  let quoteChar = null;
+  let escaped = false;
 
-  let pathsArray = [];
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
 
-  // If source(none) is set, only use explicit paths
-  if (sourceConfig.disableAuto) {
-    pathsArray = sourceConfig.explicitPaths;
-    console.log('🔒 Auto-detection disabled - using explicit paths only:', pathsArray);
-  } else {
-    // Use provided contentPaths or defaults
-    pathsArray = Array.isArray(contentPaths) ? contentPaths : (contentPaths ? [contentPaths] : []);
-    
-    // Add explicit paths from @source directives
-    if (sourceConfig.explicitPaths.length > 0) {
-      pathsArray = [...pathsArray, ...sourceConfig.explicitPaths];
-      console.log('➕ Added explicit paths:', sourceConfig.explicitPaths);
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
     }
-  }
 
-  // Apply base path if set
-  if (sourceConfig.basePath) {
-    pathsArray = pathsArray.map(p => {
-      const resolved = path.resolve(path.dirname(process.cwd()), sourceConfig.basePath, p);
-      return resolved;
-    });
-    console.log('📂 Applied base path:', sourceConfig.basePath);
-  }
-
-  console.log('🔍 Scanning paths:', pathsArray);
+    if (char === '\\') {
+      current += char;
+      escaped = true;
+      continue;
+    }
 
-  // Scan all files matching the patterns
-  let files = [];
-  pathsArray.forEach(pattern => {
-    try {
-      const matches = glob.sync(pattern, {
-        ignore: sourceConfig.ignorePaths.length > 0 ? sourceConfig.ignorePaths : undefined
-      });
-      files.push(...matches);
-      
-      if (sourceConfig.ignorePaths.length > 0) {
-        console.log(`🚫 Ignoring paths:`, sourceConfig.ignorePaths);
+    if (!quoteChar && (char === '"' || char === "'" || char === '`')) {
+      quoteChar = char;
+    } else if (char === quoteChar) {
+      if (current) {
+        result.push(current);
       }
-    } catch (err) {
-      console.error(`❌ Error scanning pattern ${pattern}:`, err.message);
+      current = '';
+      quoteChar = null;
+    } else if (quoteChar) {
+      current += char;
     }
-  });
-
-  console.log(`📄 Found ${files.length} files to scan`);
-
-  if (files.length === 0) {
-    return [];
   }
 
-  files.forEach(filePath => {
-    const fileContent = fs.readFileSync(filePath, 'utf8');
-
-    // Grab only strings inside single quotes, double quotes, or backticks
-    const parts = Array.from(fileContent.matchAll(/(['"`])(.*?)\1/gs), m => m[2]);
-
-    parts.forEach(part => {
-      let cls = part.trim();
-      if (!cls) return;
-
-      // Normalize whitespace to single spaces, but preserve inside ( [ { " '
-      let normalizedCls = "";
-      let parenDepth = 0;
-      let bracketDepth = 0;
-      let braceDepth = 0;
-      let inSingleQuote = false;
-      let inDoubleQuote = false;
-
-      for (let i = 0; i < cls.length; i++) {
-        const char = cls[i];
-
-        // Track quote state
-        if (char === "'" && !inDoubleQuote) inSingleQuote = !inSingleQuote;
-        else if (char === '"' && !inSingleQuote) inDoubleQuote = !inDoubleQuote;
-
-        const inQuotes = inSingleQuote || inDoubleQuote;
-
-        // Track bracket depths (only if not in quotes)
-        if (!inQuotes) {
-          if (char === "(") parenDepth++;
-          else if (char === ")") parenDepth--;
-          else if (char === "[") bracketDepth++;
-          else if (char === "]") bracketDepth--;
-          else if (char === "{") braceDepth++;
-          else if (char === "}") braceDepth--;
-        }
-
-        const insideGroup = parenDepth > 0 || bracketDepth > 0 || braceDepth > 0 || inQuotes;
-
-        // Normalize whitespace only when NOT inside groups
-        if (/\s/.test(char)) {
-          if (insideGroup) {
-            normalizedCls += char;
-          } else {
-            // Collapse consecutive whitespace to single space
-            if (normalizedCls.length > 0 && !/\s/.test(normalizedCls[normalizedCls.length - 1])) {
-              normalizedCls += " ";
-            }
-          }
-        } else {
-          normalizedCls += char;
-        }
-      }
+  return result;
+}
 
-      normalizedCls = normalizedCls.trim();
-      const innerParts = smartSplitNoBrace(normalizedCls, " ");
+function processClassString(classStr) {
+  let cls = classStr.trim();
+  if (!cls) return [];
 
-      const spawnShorthandRegex = /^(.*?:)?spawn-((?:from|to|back|half|\[[^\]]+\])(?:\/(?:from|to|back|half|\[[^\]]+\]))*):(.+)$/;
-      const scrollShorthandRegex = /^(.*?:)?scroll-((?:from|to|back|half|\[[^\]]+\])(?:\/(?:from|to|back|half|\[[^\]]+\]))*):(.+)$/;
-      const scrollPrefixRegex = /^(.*?:)?scroll:(.+)$/;
+  // Fast path: if no spaces, return as-is
+  if (!cls.includes(' ')) {
+    return [cls];
+  }
 
-      // Group by prefix for spawn/scroll classes
-      const spawnByPrefix = {};
-      const scrollByPrefix = {};
-      const nonShorthandParts = [];
+  // Only use smartSplit if there are spaces
+  const parts = smartSplit(cls, ' ');
+  return parts.filter(p => p.length > 0);
+}
 
-      innerParts.forEach(part => {
-        if (spawnShorthandRegex.test(part)) {
-          const match = part.match(spawnShorthandRegex);
-          const prefix = match[1] || ''; // Empty string for no prefix
+function smartSplit(str, delimiter = ' ') {
+  const result = [];
+  let current = '';
+  let bracketDepth = 0;
+  let parenDepth = 0;
+  let braceDepth = 0;
 
-          if (!spawnByPrefix[prefix]) {
-            spawnByPrefix[prefix] = [];
-          }
-          spawnByPrefix[prefix].push(part);
-        } else if (scrollShorthandRegex.test(part) || scrollPrefixRegex.test(part)) {
-          const match = part.match(scrollShorthandRegex) || part.match(scrollPrefixRegex);
-          const prefix = match[1] || ''; // Empty string for no prefix
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
 
-          if (!scrollByPrefix[prefix]) {
-            scrollByPrefix[prefix] = [];
-          }
-          scrollByPrefix[prefix].push(part);
-        } else {
-          nonShorthandParts.push(part);
-        }
-      });
+    if (char === '[') bracketDepth++;
+    else if (char === ']' && bracketDepth > 0) bracketDepth--;
+    else if (char === '(') parenDepth++;
+    else if (char === ')' && parenDepth > 0) parenDepth--;
+    else if (char === '{') braceDepth++;
+    else if (char === '}' && braceDepth > 0) braceDepth--;
 
-      // Add non-shorthand classes normally
-      nonShorthandParts.forEach(c => allClasses.add(c));
+    const shouldSplit = bracketDepth === 0 && parenDepth === 0 && braceDepth === 0 && char === delimiter;
 
-      // Add spawn classes grouped by prefix
-      Object.values(spawnByPrefix).forEach(group => {
-        if (group.length > 0) {
-          allClasses.add(group.join(' '));
-        }
-      });
+    if (shouldSplit) {
+      if (current) result.push(current);
+      current = '';
+    } else {
+      current += char;
+    }
+  }
 
-      // Add scroll classes grouped by prefix
-      Object.values(scrollByPrefix).forEach(group => {
-        if (group.length > 0) {
-          allClasses.add(group.join(' '));
-        }
-      });
-    });
-  });
+  if (current) result.push(current);
+  return result;
+}
 
-  // Group and sort motion classes by prefix length
+function sortMotionClasses(classes) {
   const motionRegex = /^(.*?)motion-\[([^\]]+)\]:/;
   const motionByName = {};
   const nonMotionClasses = [];
 
-  Array.from(allClasses).forEach(cls => {
+  classes.forEach(cls => {
     const match = cls.match(motionRegex);
     if (match) {
-      const prefix = match[1]; // Everything before "motion-["
+      const prefix = match[1];
       const animName = match[2];
 
       if (!motionByName[animName]) {
@@ -511,8 +249,8 @@ function collectClassesJS(contentPaths) {
       }
 
       motionByName[animName].push({
-        cls: cls,
-        prefix: prefix,
+        cls,
+        prefix,
         prefixLength: prefix.length
       });
     } else {
@@ -520,19 +258,11 @@ function collectClassesJS(contentPaths) {
     }
   });
 
-  // Sort each animation's classes by prefix length (shortest first)
-  const sortedMotionClasses = [];
+  const sortedMotion = [];
   Object.values(motionByName).forEach(group => {
     group.sort((a, b) => a.prefixLength - b.prefixLength);
-    sortedMotionClasses.push(...group.map(item => item.cls));
+    sortedMotion.push(...group.map(item => item.cls));
   });
 
-  // Rebuild allClasses: non-motion first, then sorted motion
-  allClasses.clear();
-  nonMotionClasses.forEach(c => allClasses.add(c));
-  sortedMotionClasses.forEach(c => allClasses.add(c));
-
-  return Array.from(allClasses);
-}
-
-export default collectClasses;
+  return [...nonMotionClasses, ...sortedMotion];
+}

package/src/parser.js

@@ -12989,20 +12989,6 @@ function _parseClassInternal(cls, isFromGrouped = false, needed, isGlobal) {
         return buildParsed(null, valueArray)
     }
 
-    if (cls === "viewport" || cls === "max-viewport" || cls === "min-viewport") {
-        let widthProp = "width";
-        let heightProp = "height";
-
-        if (cls === "max-viewport") {
-            widthProp = "max-width";
-            heightProp = "max-height";
-        } else if (cls === "min-viewport") {
-            widthProp = "min-width";
-            heightProp = "min-height";
-        }
-        return buildParsed(null, [{ prop: widthProp, value: "100vw" + importantSuffix }, { prop: heightProp, value: "100vh" + importantSuffix }])
-    }
-
     if (cls === "subpixel-antialiased") {
         return buildParsed(null, [{ prop: "-webkit-font-smoothing", value: `auto${importantSuffix}` }, { prop: "-moz-osx-font-smoothing", value: `auto${importantSuffix}` }])
     }
@@ -13061,7 +13047,7 @@ function _parseClassInternal(cls, isFromGrouped = false, needed, isGlobal) {
         prop = "visibility";
         value = "hidden";
         cssValue = "hidden";
-        return buildParsed(prop, cssValue)
+        return buildParsed(prop, value)
     }
 
     if (cls === "sr-only") {