add cloneCandidate and cloneVariant helpers

These are much faster compared to `structuredClone`. This is again
because we're dealing with simple plain objects.

Author: RobinMalfait

packages/tailwindcss/src/candidate.bench.ts

@@ -1,20 +1,40 @@
 import { Scanner } from '@tailwindcss/oxide'
-import { bench } from 'vitest'
-import { parseCandidate } from './candidate'
+import { bench, describe } from 'vitest'
+import { cloneCandidate, parseCandidate } from './candidate'
 import { buildDesignSystem } from './design-system'
 import { Theme } from './theme'
 
 // FOLDER=path/to/folder vitest bench
 const root = process.env.FOLDER || process.cwd()
 
 // Auto content detection
-const scanner = new Scanner({ sources: [{ base: root, pattern: '**/*' }] })
+const scanner = new Scanner({ sources: [{ base: root, pattern: '**/*', negated: false }] })
 
 const candidates = scanner.scan()
 const designSystem = buildDesignSystem(new Theme())
 
-bench('parseCandidate', () => {
-  for (let candidate of candidates) {
-    Array.from(parseCandidate(candidate, designSystem))
-  }
+describe('parsing', () => {
+  bench('parseCandidate', () => {
+    for (let candidate of candidates) {
+      Array.from(parseCandidate(candidate, designSystem))
+    }
+  })
+})
+
+describe('Candidate cloning', async () => {
+  let parsedCanddiates = candidates.flatMap((candidate) =>
+    Array.from(parseCandidate(candidate, designSystem)),
+  )
+
+  bench('structuredClone', () => {
+    for (let candidate of parsedCanddiates) {
+      structuredClone(candidate)
+    }
+  })
+
+  bench('cloneCandidate', () => {
+    for (let candidate of parsedCanddiates) {
+      cloneCandidate(candidate)
+    }
+  })
 })

packages/tailwindcss/src/candidate.ts

@@ -215,6 +215,60 @@ export type Candidate =
       raw: string
     }
 
+export function cloneCandidate(candidate: Candidate): Candidate {
+  switch (candidate.kind) {
+    case 'arbitrary':
+      return {
+        ...candidate,
+        variants: candidate.variants.map(cloneVariant),
+        modifier: candidate.modifier ? { ...candidate.modifier } : null,
+      }
+
+    case 'static':
+      return { ...candidate, variants: candidate.variants.map(cloneVariant) }
+
+    case 'functional':
+      return {
+        ...candidate,
+        variants: candidate.variants.map(cloneVariant),
+        value: candidate.value ? { ...candidate.value } : null,
+        modifier: candidate.modifier ? { ...candidate.modifier } : null,
+      }
+
+    default:
+      candidate satisfies never
+      throw new Error('Unknown candidate kind')
+  }
+}
+
+export function cloneVariant(variant: Variant): Variant {
+  switch (variant.kind) {
+    case 'arbitrary':
+      return { ...variant }
+
+    case 'static':
+      return { ...variant }
+
+    case 'functional':
+      return {
+        ...variant,
+        value: variant.value ? { ...variant.value } : null,
+        modifier: variant.modifier ? { ...variant.modifier } : null,
+      }
+
+    case 'compound':
+      return {
+        ...variant,
+        variant: cloneVariant(variant.variant),
+        modifier: variant.modifier ? { ...variant.modifier } : null,
+      }
+
+    default:
+      variant satisfies never
+      throw new Error('Unknown variant kind')
+  }
+}
+
 export function* parseCandidate(input: string, designSystem: DesignSystem): Iterable<Candidate> {
   // hover:focus:underline
   // ^^^^^ ^^^^^^           -> Variants

packages/tailwindcss/src/canonicalize-candidates.ts

@@ -1,5 +1,7 @@
 import * as AttributeSelectorParser from './attribute-selector-parser'
 import {
+  cloneCandidate,
+  cloneVariant,
   printModifier,
   type Candidate,
   type CandidateModifier,
@@ -107,7 +109,7 @@ const canonicalizeVariantCache = new DefaultMap((ds: DesignSystem) => {
       for (let current of replacement.splice(0)) {
         // A single variant can result in multiple variants, e.g.:
         // `[&>[data-selected]]:flex` → `*:data-selected:flex`
-        let result = fn(ds, structuredClone(current))
+        let result = fn(ds, cloneVariant(current))
         if (Array.isArray(result)) {
           replacement.push(...result)
           continue
@@ -134,7 +136,7 @@ const UTILITY_CANONICALIZATIONS = [
 const canonicalizeUtilityCache = new DefaultMap((ds: DesignSystem) => {
   return new DefaultMap((rawCandidate: string): string => {
     for (let readonlyCandidate of ds.parseCandidate(rawCandidate)) {
-      let replacement = structuredClone(readonlyCandidate) as Writable<typeof readonlyCandidate>
+      let replacement = cloneCandidate(readonlyCandidate) as Writable<typeof readonlyCandidate>
 
       for (let fn of UTILITY_CANONICALIZATIONS) {
         replacement = fn(ds, replacement)