# Clone

The `Clone` macro generates a `clone()` method for deep copying objects. This is analogous to Rust's
`Clone` trait, providing a way to create independent copies of values.

## Generated Output

| Type       | Generated Code                                  | Description                                                     |
| ---------- | ----------------------------------------------- | --------------------------------------------------------------- |
| Class      | `classNameClone(value)` + `static clone(value)` | Standalone function + static wrapper method                     |
| Enum       | `enumNameClone(value): EnumName`                | Standalone function (enums are primitives, returns value as-is) |
| Interface  | `ifaceNameClone(value): InterfaceName`          | Standalone function creating a new object literal               |
| Type Alias | `typeNameClone(value): TypeName`                | Standalone function with spread copy for objects                |

Names use **camelCase** conversion (e.g., `Point` -> `pointClone`).

## Cloning Strategy

The generated clone is **type-aware** when a type registry is available:

- **Primitives** (`string`, `number`, `boolean`, `bigint`): Copied by value
- **`Date`**: Deep cloned via `new Date(x.getTime())`
- **Arrays**: Spread copy `[...arr]`, or deep map if element type has `Clone`
- **`Map`/`Set`**: New collection, deep copy if value type has `Clone`
- **Objects with `@derive(Clone)`**: Deep cloned via their standalone clone function
- **Optional fields**: Null-checked -- `null`/`undefined` pass through unchanged
- **Other objects**: Shallow copy (reference)

## Example

```typescript before
/** @derive(Clone) */
class Point {
    x: number;
    y: number;
}
```

```typescript after
class Point {
    x: number;
    y: number;

    static clone(value: Point): Point {
        return pointClone(value);
    }
}

export function pointClone(value: Point): Point {
    const cloned = Object.create(Object.getPrototypeOf(value));
    cloned.x = value.x;
    cloned.y = value.y;
    return cloned;
}
```

## Implementation Notes

- **Classes**: Uses `Object.create(Object.getPrototypeOf(value))` to preserve the prototype chain,
  ensuring `instanceof` checks work correctly
- **Enums**: Simply returns the value (enums are primitives in TypeScript)
- **Interfaces/Type Aliases**: Creates new object literals with spread operator for union/tuple
  types, or field-by-field copy for object types