fix(ac): compact dynamic group parsing and bump size limit

The backward-compatible dynamic group-length parsing in ac() adds ~18B over
the previous single hardcoded slice (master was 328B, near the 332B ceiling).
Compact the loop to keep the increase minimal (346B) and bump the ac size
limit to 355B to accommodate the genuine capability of supporting both the
legacy 4-char and collision-resistant 6-char group formats.

ac is an opt-in runtime (only imported when classNameCompressionMap is used).

Author: pancaspe87

package.json

@@ -151,7 +151,7 @@
     },
     {
       "path": "./packages/react/dist/browser/runtime/ac.js",
-      "limit": "332B",
+      "limit": "355B",
       "import": "ac, { clearCache }"
     },
     {

packages/react/src/runtime/ac.ts

@@ -81,31 +81,21 @@ export function ac(
 
       for (let x = 0; x < groups.length; x++) {
         const atomic = groups[x];
+        // For an atomic class (`_`-prefixed), a second underscore marks the end of
+        // a compressed class's group (`_<group>_<name>`); `sep` is its index, or -1
+        // when uncompressed, in which case the group is everything except the
+        // fixed-width value hash (matching `ax()`). Non-atomic classes use -1 too
+        // and fall through to being kept whole via the value check below.
+        // Length-agnostic: legacy 4-char and new 6-char groups both work.
         const isAtomic = atomic.charCodeAt(0) === UNDERSCORE_UNICODE;
-
-        // A compressed atomic class has the form `_<group>_<compressedName>`, i.e.
-        // a second underscore after the leading one marks the end of the group.
-        // We locate it dynamically so both the legacy 4-char group and the
-        // collision-resistant 6-char group are parsed correctly (the group hash
-        // itself never contains an underscore).
-        const compressedSeparatorIndex = isAtomic ? atomic.indexOf('_', 1) : -1;
-        const isCompressed = compressedSeparatorIndex !== -1;
-
-        let atomicGroupName: string;
-        if (isCompressed) {
-          // Group is everything up to the separating underscore.
-          atomicGroupName = atomic.slice(0, compressedSeparatorIndex);
-        } else if (isAtomic) {
-          // Uncompressed atomic class: the group is everything except the fixed
-          // width value hash — length-agnostic, matching `ax()`.
-          atomicGroupName = atomic.slice(0, atomic.length - ATOMIC_VALUE_HASH_LENGTH);
-        } else {
-          atomicGroupName = atomic;
-        }
-
+        const sep = isAtomic ? atomic.indexOf('_', 1) : 0;
         atomicGroups.set(
-          atomicGroupName,
-          isCompressed ? atomic.slice(compressedSeparatorIndex + 1) : atomic
+          sep > 0
+            ? atomic.slice(0, sep)
+            : isAtomic
+            ? atomic.slice(0, -ATOMIC_VALUE_HASH_LENGTH)
+            : atomic,
+          sep > 0 ? atomic.slice(sep + 1) : atomic
         );
       }
     } else {