make cloneAstNode faster

Turns out that if you keep the exact same structure instead of a spread,
it's even faster!

```
  cloneAstNode() - src/ast.bench.ts > Cloning AST nodes
    1.15x faster than cloneAstNode (with spread)
    33.54x faster than structuredClone()
```

Author: RobinMalfait

packages/tailwindcss/src/ast.bench.ts

@@ -1,5 +1,5 @@
 import { bench, describe } from 'vitest'
-import { cloneAstNode, toCss } from './ast'
+import { cloneAstNode, toCss, type AstNode } from './ast'
 import * as CSS from './css-parser'
 
 const css = String.raw
@@ -34,7 +34,31 @@ describe('Cloning AST nodes', () => {
     ast.map(cloneAstNode)
   })
 
+  bench('cloneAstNode (with spread)', () => {
+    ast.map(cloneAstNodeSpread)
+  })
+
   bench('structuredClone()', () => {
     structuredClone(ast)
   })
 })
+
+function cloneAstNodeSpread<T extends AstNode>(node: T): T {
+  switch (node.kind) {
+    case 'rule':
+    case 'at-rule':
+    case 'at-root':
+      return { ...node, nodes: node.nodes.map(cloneAstNodeSpread) }
+
+    case 'context':
+      return { ...node, context: { ...node.context }, nodes: node.nodes.map(cloneAstNodeSpread) }
+
+    case 'declaration':
+    case 'comment':
+      return { ...node }
+
+    default:
+      node satisfies never
+      throw new Error(`Unknown node kind: ${(node as any).kind}`)
+  }
+}

packages/tailwindcss/src/ast.ts

@@ -125,16 +125,58 @@ export function atRoot(nodes: AstNode[]): AtRoot {
 export function cloneAstNode<T extends AstNode>(node: T): T {
   switch (node.kind) {
     case 'rule':
+      return {
+        kind: node.kind,
+        selector: node.selector,
+        nodes: node.nodes.map(cloneAstNode),
+        src: node.src,
+        dst: node.dst,
+      } satisfies StyleRule as T
+
     case 'at-rule':
+      return {
+        kind: node.kind,
+        name: node.name,
+        params: node.params,
+        nodes: node.nodes.map(cloneAstNode),
+        src: node.src,
+        dst: node.dst,
+      } satisfies AtRule as T
+
     case 'at-root':
-      return { ...node, nodes: node.nodes.map(cloneAstNode) }
+      return {
+        kind: node.kind,
+        nodes: node.nodes.map(cloneAstNode),
+        src: node.src,
+        dst: node.dst,
+      } satisfies AtRoot as T
 
     case 'context':
-      return { ...node, context: { ...node.context }, nodes: node.nodes.map(cloneAstNode) }
+      return {
+        kind: node.kind,
+        context: { ...node.context },
+        nodes: node.nodes.map(cloneAstNode),
+        src: node.src,
+        dst: node.dst,
+      } satisfies Context as T
 
     case 'declaration':
+      return {
+        kind: node.kind,
+        property: node.property,
+        value: node.value,
+        important: node.important,
+        src: node.src,
+        dst: node.dst,
+      } satisfies Declaration as T
+
     case 'comment':
-      return { ...node }
+      return {
+        kind: node.kind,
+        value: node.value,
+        src: node.src,
+        dst: node.dst,
+      } satisfies Comment as T
 
     default:
       node satisfies never