function deepClone<T>(
  originalData: T,
  options?: Options
): DeepReadwrite<T>

import { deepClone } from "@visulima/deep-clone";

const original = {
  name: "Alice",
  age: 30,
  nested: { city: "NYC" }
};

const cloned = deepClone(original);
cloned.nested.city = "LA";

console.log(original.nested.city); // "NYC" (unchanged)
console.log(cloned.nested.city);   // "LA"

interface Options {
  strict?: boolean;
  handler?: Partial<HandlerMap>;
}

import { deepClone } from "@visulima/deep-clone";

const obj = { visible: "enumerable" };
Object.defineProperty(obj, "hidden", {
  value: "non-enumerable",
  enumerable: false
});

// Loose mode (default)
const loose = deepClone(obj);
console.log(loose.hidden); // undefined

// Strict mode
const strict = deepClone(obj, { strict: true });
console.log(strict.hidden); // "non-enumerable"

type InternalHandler<T> = (object: T, state: State) => T;

interface HandlerMap {
  Array: InternalHandler<unknown[]>;
  ArrayBuffer: InternalHandler<ArrayBuffer>;
  Blob: InternalHandler<Blob>;
  DataView: InternalHandler<DataView>;
  Date: InternalHandler<Date>;
  Error: InternalHandler<Error>;
  Function: InternalHandler<Function>;
  Map: InternalHandler<Map<unknown, unknown>>;
  Object: InternalHandler<Record<string, unknown>>;
  Promise: InternalHandler<Promise<unknown>>;
  RegExp: InternalHandler<RegExp>;
  Set: InternalHandler<Set<unknown>>;
  SharedArrayBuffer: InternalHandler<SharedArrayBuffer>;
  WeakMap: InternalHandler<WeakMap<any, unknown>>;
  WeakSet: InternalHandler<WeakSet<any>>;
}

import { deepClone } from "@visulima/deep-clone";
import type { State } from "@visulima/deep-clone";

const cloned = deepClone(data, {
  handler: {
    Date: (date: Date, _state: State) => {
      // Clone to current time instead of original time
      return new Date();
    },
    Array: (array: unknown[], state: State) => {
      // Custom array cloning (e.g., filter nulls)
      const filtered = array.filter(item => item !== null);
      return filtered.map(item => state.clone(item, state));
    }
  }
});

interface State {
  cache: WeakMap<any, any>;
  clone: (value: any, state: State) => any;
}

import { deepClone } from "@visulima/deep-clone";
import type { State } from "@visulima/deep-clone";

const cloned = deepClone(data, {
  handler: {
    Object: (obj: Record<PropertyKey, unknown>, state: State) => {
      // Create empty object
      const copy = {} as Record<PropertyKey, unknown>;

      // Clone each property using state.clone
      for (const key in obj) {
        copy[key] = state.clone(obj[key], state);
      }

      return copy;
    }
  }
});

function copyOwnProperties<T extends object>(object: T): T

import { copyOwnProperties } from "@visulima/deep-clone/utils";

const original = {
  name: "Alice",
  age: 30,
  address: { city: "NYC" }
};

const copy = copyOwnProperties(original);
copy.age = 31;
copy.address.city = "LA";

console.log(original.age);          // 30 (unchanged)
console.log(original.address.city); // "LA" (changed! shallow copy)

function getCleanClone<T extends object>(object: T): T

import { getCleanClone } from "@visulima/deep-clone/utils";

class User {
  name: string = "";
  age: number = 0;

  greet() {
    return `Hello, ${this.name}!`;
  }
}

const user = new User();
user.name = "Alice";
user.age = 30;

const clean = getCleanClone(user);

console.log(clean.name);             // "" (empty)
console.log(clean.age);              // 0 (default)
console.log(clean.greet());          // "Hello, !" (method exists)
console.log(clean instanceof User);  // true

type DeepReadwrite<T> = T extends object | []
  ? { -readonly [P in keyof T]: DeepReadwrite<T[P]> }
  : T

import { deepClone } from "@visulima/deep-clone";

interface ReadonlyData {
  readonly id: number;
  readonly config: {
    readonly enabled: boolean;
  };
}

const data: ReadonlyData = {
  id: 1,
  config: { enabled: true }
};

// TypeScript error: Cannot assign to 'id' because it is a read-only property
// data.id = 2;

const cloned = deepClone(data);

// OK! DeepReadwrite removes readonly
cloned.id = 2;
cloned.config.enabled = false;

import { deepClone } from "@visulima/deep-clone";

try {
  deepClone(new Promise(resolve => resolve(1)));
} catch (error) {
  console.log(error.message);
  // "Promise objects cannot be cloned"
}

import { deepClone } from "@visulima/deep-clone";

try {
  const weakMap = new WeakMap();
  deepClone(weakMap);
} catch (error) {
  console.log(error instanceof TypeError); // true
  console.log(error.message);              // "WeakMap objects cannot be cloned"
}

import { deepClone } from "@visulima/deep-clone";

const obj: any = { name: "circular" };
obj.self = obj; // Circular reference

const cloned = deepClone(obj); // No error!
console.log(cloned.self === cloned); // true