hassanzohdy/reinforcements/mixed

clone<T>(value: T): T

const a: any = { name: "Ada" };
a.self = a;            // circular
const copy = clone(a);
copy.self === copy;    // true — circular ref preserved
clone(new Date(0));    // new Date instance, same time
clone(/abc/gi);        // new RegExp, same source/flags
clone(new Map([["k", 1]])); // new Map, deep-cloned values
const err = new TypeError("nope");
(err as any).meta = { detail: true };
clone(err).meta;       // { detail: true } — own props preserved

areEqual(a: any, b: any): boolean

areEqual({ a: 1 }, { a: 1 });        // true
areEqual([1, 2, 3], [1, 2, 3]);      // true
areEqual([1, 2, 3], [3, 2, 1]);      // false — order matters
areEqual(new Date(0), new Date(0));  // true
areEqual(/abc/g, /abc/g);            // true
areEqual(new Set([1, 2]), new Set([2, 1])); // true (Set equality)
const a: any = { x: 1 }; a.self = a;
const b: any = { x: 1 }; b.self = b;
areEqual(a, b);                       // true — circular-safe

shuffle<T>(value: T[], options?: { mutate?: boolean }): T[]
shuffle(value: string, options?: { mutate?: boolean }): string

shuffle([1, 2, 3, 4]);                  // e.g. [3, 1, 4, 2]; original untouched
shuffle("hello");                        // e.g. "lehlo"
shuffle(arr, { mutate: true });          // shuffles in place, returns arr

coalesce<T>(...values: Array<T | null | undefined>): T | undefined

coalesce(null, undefined, "first");  // "first"
coalesce(undefined, 0, "x");         // 0
coalesce(undefined, "", "x");        // ""
coalesce(null, undefined);           // undefined