@synnaxlabs/x 0.44.4 → 0.45.1

package/dist/telem.js

@@ -1,4 +1,4 @@
-import { c as s, D as i, M as t, R as r, S, d as m, b as p, a as T, T as d, g as y, f as l, i as n, e as D, t as o } from "./series-kgnLXSDr.js";
+import { c as s, D as i, M as t, R as r, S, d as m, b as p, a as T, T as d, g as y, f as l, i as n, e as D, t as o } from "./series-W5Aafjeu.js";
 export {
   s as DataType,
   i as Density,

package/dist/{xy-BKIJiLu_.cjs → xy-DWwtHmgn.cjs}

@@ -1 +1 @@
-"use strict";const O=require("zod"),i=require("./base-BLNViP3D.cjs"),z=O.z.union([O.z.number(),i.xy,i.numberCouple,i.dimensions,i.signedDimensions,i.clientXY]),o=(t,n)=>{if(typeof t=="string"){if(n===void 0)throw new Error("The y coordinate must be given.");return t==="x"?{x:n,y:0}:{x:0,y:n}}return typeof t=="number"?{x:t,y:n??t}:Array.isArray(t)?{x:t[0],y:t[1]}:"signedWidth"in t?{x:t.signedWidth,y:t.signedHeight}:"clientX"in t?{x:t.clientX,y:t.clientY}:"width"in t?{x:t.width,y:t.height}:{x:t.x,y:t.y}},x=Object.freeze({x:0,y:0}),P=Object.freeze({x:1,y:1}),q=Object.freeze({x:1/0,y:1/0}),v=Object.freeze({x:NaN,y:NaN}),g=(t,n,e=0)=>{const r=o(t),s=o(n);return e===0?r.x===s.x&&r.y===s.y:Math.abs(r.x-s.x)<=e&&Math.abs(r.y-s.y)<=e},I=t=>g(t,x),b=(t,n,e)=>{const r=o(t),s=o(n,e);return{x:r.x*s.x,y:r.y*s.y}},_=(t,n)=>{const e=o(t);return{x:e.x+n,y:e.y}},j=(t,n)=>{const e=o(t);return{x:e.x,y:e.y+n}},p=(t,n,e,...r)=>{if(typeof n=="string"){if(typeof e!="number")throw new Error("The value must be a number.");return n==="x"?_(t,e):j(t,e)}if(typeof n=="object"&&"x"in n&&typeof n.x=="string"){const s=o(e),c=o(t);return n.x==="left"?s.x=-s.x:n.x==="center"&&(s.x=0),n.y==="top"?s.y=-s.y:n.y==="center"&&(s.y=0),{x:c.x+s.x,y:c.y+s.y}}return[t,n,e??x,...r].reduce((s,c)=>{const y=o(c);return{x:s.x+y.x,y:s.y+y.y}},x)},Z=(t,n,e)=>{const r=o(t);return n==="x"?{x:e,y:r.y}:{x:r.x,y:e}},A=(t,n)=>{const e=o(t),r=o(n);return Math.sqrt((e.x-r.x)**2+(e.y-r.y)**2)},T=(t,n)=>{const e=o(t),r=o(n);return{x:r.x-e.x,y:r.y-e.y}},H=t=>{const n=o(t);return Number.isNaN(n.x)||Number.isNaN(n.y)},R=t=>{const n=o(t);return Number.isFinite(n.x)&&Number.isFinite(n.y)},S=t=>{const n=o(t);return[n.x,n.y]},W=t=>{const n=o(t);return{left:n.x,top:n.y}},w=(t,n=0)=>{const e=o(t);return{x:Number(e.x.toFixed(n)),y:Number(e.y.toFixed(n))}},d=(t,n)=>{const e=o(t),r=o(n);return{x:e.x-r.x,y:e.y-r.y}},N=t=>{const n=o(t),e=Math.hypot(n.x,n.y);return e===0?{x:0,y:0}:{x:-n.y/e,y:n.x/e}},E=t=>{const n=o(t),e=Math.hypot(n.x,n.y);return e===0?{x:0,y:0}:{x:n.x/e,y:n.y/e}},F=(...t)=>{const n=t.reduce((e,r)=>p(e,r),x);return b(n,1/t.length)},C=(t,n)=>{const e=[];for(let r=0;r<t.length;r++){const s=t[r];let c,y,h,u;if(r===0){const a=t[r+1],l=d(a,s);y=N(l),h=y,u=n}else if(r===t.length-1){const a=t[r-1],l=d(s,a);c=N(l),h=c,u=n}else{const a=t[r-1],l=t[r+1],f=d(s,a),m=d(l,s);c=N(f),y=N(m);const Y=Math.acos((f.x*m.x+f.y*m.y)/(Math.hypot(f.x,f.y)*Math.hypot(m.x,m.y))),M=Math.sin(Y/2);M===0?u=n:u=n/M,h=E(F(c,y))}e.push(b(h,u))}return e},D=t=>{const n=o(t);return{x:n.y,y:n.x}},X=t=>{const n=o(t);return{x:Math.round(n.x),y:Math.round(n.y)}},L=Object.freeze(Object.defineProperty({__proto__:null,INFINITY:q,NAN:v,ONE:P,ZERO:x,average:F,calculateMiters:C,clientXY:i.clientXY,construct:o,couple:S,crudeZ:z,css:W,distance:A,equals:g,isFinite:R,isNan:H,isZero:I,normal:N,normalize:E,round:X,scale:b,set:Z,sub:d,swap:D,translate:p,translateX:_,translateY:j,translation:T,truncate:w,xy:i.xy},Symbol.toStringTag,{value:"Module"}));exports.ONE=P;exports.ZERO=x;exports.construct=o;exports.crudeZ=z;exports.equals=g;exports.round=X;exports.translate=p;exports.truncate=w;exports.xy=L;
+"use strict";const O=require("zod"),i=require("./base-KIBsp6TI.cjs"),z=O.z.union([O.z.number(),i.xy,i.numberCouple,i.dimensions,i.signedDimensions,i.clientXY]),o=(t,n)=>{if(typeof t=="string"){if(n===void 0)throw new Error("The y coordinate must be given.");return t==="x"?{x:n,y:0}:{x:0,y:n}}return typeof t=="number"?{x:t,y:n??t}:Array.isArray(t)?{x:t[0],y:t[1]}:"signedWidth"in t?{x:t.signedWidth,y:t.signedHeight}:"clientX"in t?{x:t.clientX,y:t.clientY}:"width"in t?{x:t.width,y:t.height}:{x:t.x,y:t.y}},x=Object.freeze({x:0,y:0}),P=Object.freeze({x:1,y:1}),q=Object.freeze({x:1/0,y:1/0}),v=Object.freeze({x:NaN,y:NaN}),g=(t,n,e=0)=>{const r=o(t),s=o(n);return e===0?r.x===s.x&&r.y===s.y:Math.abs(r.x-s.x)<=e&&Math.abs(r.y-s.y)<=e},I=t=>g(t,x),b=(t,n,e)=>{const r=o(t),s=o(n,e);return{x:r.x*s.x,y:r.y*s.y}},_=(t,n)=>{const e=o(t);return{x:e.x+n,y:e.y}},j=(t,n)=>{const e=o(t);return{x:e.x,y:e.y+n}},p=(t,n,e,...r)=>{if(typeof n=="string"){if(typeof e!="number")throw new Error("The value must be a number.");return n==="x"?_(t,e):j(t,e)}if(typeof n=="object"&&"x"in n&&typeof n.x=="string"){const s=o(e),c=o(t);return n.x==="left"?s.x=-s.x:n.x==="center"&&(s.x=0),n.y==="top"?s.y=-s.y:n.y==="center"&&(s.y=0),{x:c.x+s.x,y:c.y+s.y}}return[t,n,e??x,...r].reduce((s,c)=>{const y=o(c);return{x:s.x+y.x,y:s.y+y.y}},x)},Z=(t,n,e)=>{const r=o(t);return n==="x"?{x:e,y:r.y}:{x:r.x,y:e}},A=(t,n)=>{const e=o(t),r=o(n);return Math.sqrt((e.x-r.x)**2+(e.y-r.y)**2)},T=(t,n)=>{const e=o(t),r=o(n);return{x:r.x-e.x,y:r.y-e.y}},H=t=>{const n=o(t);return Number.isNaN(n.x)||Number.isNaN(n.y)},R=t=>{const n=o(t);return Number.isFinite(n.x)&&Number.isFinite(n.y)},S=t=>{const n=o(t);return[n.x,n.y]},W=t=>{const n=o(t);return{left:n.x,top:n.y}},w=(t,n=0)=>{const e=o(t);return{x:Number(e.x.toFixed(n)),y:Number(e.y.toFixed(n))}},d=(t,n)=>{const e=o(t),r=o(n);return{x:e.x-r.x,y:e.y-r.y}},N=t=>{const n=o(t),e=Math.hypot(n.x,n.y);return e===0?{x:0,y:0}:{x:-n.y/e,y:n.x/e}},E=t=>{const n=o(t),e=Math.hypot(n.x,n.y);return e===0?{x:0,y:0}:{x:n.x/e,y:n.y/e}},F=(...t)=>{const n=t.reduce((e,r)=>p(e,r),x);return b(n,1/t.length)},C=(t,n)=>{const e=[];for(let r=0;r<t.length;r++){const s=t[r];let c,y,h,u;if(r===0){const a=t[r+1],l=d(a,s);y=N(l),h=y,u=n}else if(r===t.length-1){const a=t[r-1],l=d(s,a);c=N(l),h=c,u=n}else{const a=t[r-1],l=t[r+1],f=d(s,a),m=d(l,s);c=N(f),y=N(m);const Y=Math.acos((f.x*m.x+f.y*m.y)/(Math.hypot(f.x,f.y)*Math.hypot(m.x,m.y))),M=Math.sin(Y/2);M===0?u=n:u=n/M,h=E(F(c,y))}e.push(b(h,u))}return e},D=t=>{const n=o(t);return{x:n.y,y:n.x}},X=t=>{const n=o(t);return{x:Math.round(n.x),y:Math.round(n.y)}},L=Object.freeze(Object.defineProperty({__proto__:null,INFINITY:q,NAN:v,ONE:P,ZERO:x,average:F,calculateMiters:C,clientXY:i.clientXY,construct:o,couple:S,crudeZ:z,css:W,distance:A,equals:g,isFinite:R,isNan:H,isZero:I,normal:N,normalize:E,round:X,scale:b,set:Z,sub:d,swap:D,translate:p,translateX:_,translateY:j,translation:T,truncate:w,xy:i.xy},Symbol.toStringTag,{value:"Module"}));exports.ONE=P;exports.ZERO=x;exports.construct=o;exports.crudeZ=z;exports.equals=g;exports.round=X;exports.translate=p;exports.truncate=w;exports.xy=L;

package/dist/{xy-CBuhMaIo.js → xy-DYPw8-8C.js}

@@ -1,5 +1,5 @@
 import { z as b } from "zod";
-import { x as p, n as v, d as I, s as A, i as M } from "./base-BORMP3mH.js";
+import { x as p, n as v, d as I, s as A, j as M } from "./base-DRybODwJ.js";
 const E = b.union([
   b.number(),
   p,

package/dist/xy.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./xy-BKIJiLu_.cjs");exports.xy=e.xy;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./xy-DWwtHmgn.cjs");exports.xy=e.xy;

package/dist/xy.js

@@ -1,4 +1,4 @@
-import { x as r } from "./xy-CBuhMaIo.js";
+import { x as r } from "./xy-DYPw8-8C.js";
 export {
   r as xy
 };

package/dist/zod.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./external-E3ErJeeM.cjs");exports.zod=e.external;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./external-CtHGFcox.cjs");exports.zod=e.external;

package/dist/zod.js

@@ -1,4 +1,4 @@
-import { e as r } from "./external-BM_NS5yM.js";
+import { e as r } from "./external-tyaEMW4S.js";
 export {
   r as zod
 };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@synnaxlabs/x",
-  "version": "0.44.4",
+  "version": "0.45.1",
   "type": "module",
   "description": "Common Utilities for Synnax Labs",
-  "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/go",
+  "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/ts",
   "keywords": [
     "synnax",
     "utilities",
@@ -27,9 +27,9 @@
     "typescript": "^5.8.3",
     "vite": "^7.0.4",
     "vitest": "^3.2.4",
+    "@synnaxlabs/vite-plugin": "^0.43.0",
     "@synnaxlabs/tsconfig": "^0.43.0",
-    "eslint-config-synnaxlabs": "^0.43.0",
-    "@synnaxlabs/vite-plugin": "^0.43.0"
+    "eslint-config-synnaxlabs": "^0.43.0"
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

package/src/caseconv/caseconv.spec.ts

@@ -127,4 +127,34 @@ describe("caseconv", () => {
       });
     });
   });
+  describe("toProperNoun", () => {
+    const SPECS: [string, string][] = [
+      ["fooBar", "Foo Bar"],
+      ["foo_bar", "Foo Bar"],
+      ["foo-bar", "Foo Bar"],
+      ["FooBar", "Foo Bar"],
+      ["foo_bar_baz", "Foo Bar Baz"],
+      ["fooBarBaz", "Foo Bar Baz"],
+      ["foo-bar-baz", "Foo Bar Baz"],
+      ["XMLParser", "XML Parser"],
+      ["parseXMLDocument", "Parse XML Document"],
+      ["IODevice", "IO Device"],
+      ["temperature_sensor", "Temperature Sensor"],
+      ["pressure-gauge", "Pressure Gauge"],
+      ["flowMeter", "Flow Meter"],
+      ["my_custom_symbol", "My Custom Symbol"],
+      ["valve-actuator-v2", "Valve Actuator V2"],
+      ["PIDController", "PID Controller"],
+      ["", ""],
+      ["a", "A"],
+      ["ABC", "ABC"],
+      ["test123value", "Test123value"],
+      ["test_123_value", "Test 123 Value"],
+    ];
+    SPECS.forEach(([input, expected]) => {
+      it(`should convert ${input} to ${expected}`, () => {
+        expect(caseconv.toProperNoun(input)).toBe(expected);
+      });
+    });
+  });
 });

package/src/caseconv/caseconv.ts

@@ -165,3 +165,49 @@ const toKebabStr = (str: string): string =>
  * @returns The converted string in kebab-case
  */
 export const toKebab = createConverter(toKebabStr);
+
+/**
+ * Converts a string to proper noun format.
+ * Handles snake_case, kebab-case, camelCase, and PascalCase.
+ * Capitalizes the first letter of each word.
+ *
+ * @param str - The string to convert
+ * @returns The converted string in proper noun format
+ */
+const toProperNounStr = (str: string): string => {
+  if (str.length === 0) return str;
+  
+  // Replace underscores and hyphens with spaces
+  let result = str.replace(/[_-]/g, " ");
+  
+  // Insert spaces before capital letters (for camelCase/PascalCase)
+  // but not at the start or when there are consecutive capitals
+  result = result.replace(
+    /([a-z0-9])([A-Z])/g,
+    (_, p1: string, p2: string) => `${p1} ${p2}`
+  );
+  
+  // Handle consecutive capitals (e.g., "XMLParser" -> "XML Parser")
+  result = result.replace(
+    /([A-Z]+)([A-Z][a-z])/g,
+    (_, p1: string, p2: string) => `${p1} ${p2}`
+  );
+  
+  // Clean up multiple spaces
+  result = result.replace(/\s+/g, " ").trim();
+  
+  // Capitalize first letter of each word (proper noun format)
+  result = result.replace(/\b\w/g, (char) => char.toUpperCase());
+  
+  return result;
+};
+
+/**
+ * Converts a string to proper noun format.
+ * Handles snake_case, kebab-case, camelCase, and PascalCase.
+ * Each word is capitalized.
+ *
+ * @param str - The string to convert
+ * @returns The converted string in proper noun format
+ */
+export const toProperNoun = createConverter(toProperNounStr);

package/src/color/color.spec.ts

@@ -757,6 +757,46 @@ describe("color.Color", () => {
     });
   });
 
+  describe("fromCSS", () => {
+    test("parses hex colors", () => {
+      expect(color.fromCSS("#ff0000")).toEqual([255, 0, 0, 1]);
+      expect(color.fromCSS("#00ff00")).toEqual([0, 255, 0, 1]);
+      expect(color.fromCSS("#0000ff")).toEqual([0, 0, 255, 1]);
+      expect(color.fromCSS("#f00")).toEqual([255, 0, 0, 1]);
+      expect(color.fromCSS("#0f0")).toEqual([0, 255, 0, 1]);
+      expect(color.fromCSS("#00f")).toEqual([0, 0, 255, 1]);
+    });
+
+    test("parses rgb/rgba colors", () => {
+      expect(color.fromCSS("rgb(255, 0, 0)")).toEqual([255, 0, 0, 1]);
+      expect(color.fromCSS("rgb(0, 255, 0)")).toEqual([0, 255, 0, 1]);
+      expect(color.fromCSS("rgba(0, 0, 255, 0.5)")).toEqual([0, 0, 255, 0.5]);
+      expect(color.fromCSS("rgba(128, 128, 128, 1)")).toEqual([128, 128, 128, 1]);
+    });
+
+    test("parses named colors", () => {
+      expect(color.fromCSS("red")).toEqual([255, 0, 0, 1]);
+      expect(color.fromCSS("green")).toEqual([0, 128, 0, 1]);
+      expect(color.fromCSS("blue")).toEqual([0, 0, 255, 1]);
+      expect(color.fromCSS("black")).toEqual([0, 0, 0, 1]);
+      expect(color.fromCSS("white")).toEqual([255, 255, 255, 1]);
+    });
+
+    test("handles case insensitive input", () => {
+      expect(color.fromCSS("RED")).toEqual([255, 0, 0, 1]);
+      expect(color.fromCSS("Green")).toEqual([0, 128, 0, 1]);
+      expect(color.fromCSS("BLUE")).toEqual([0, 0, 255, 1]);
+    });
+
+    test("returns undefined for invalid input", () => {
+      expect(color.fromCSS("")).toBeUndefined();
+      expect(color.fromCSS("none")).toBeUndefined();
+      expect(color.fromCSS("transparent")).toBeUndefined();
+      expect(color.fromCSS("invalid")).toBeUndefined();
+      expect(color.fromCSS("#gggggg")).toBeUndefined();
+    });
+  });
+
   describe("isZero", () => {
     test("returns true for zero color", () => {
       expect(color.isZero([0, 0, 0, 0])).toBe(true);

package/src/color/color.ts

@@ -282,6 +282,78 @@ const rgbaToHex = (n: number): string => Math.floor(n).toString(16).padStart(2,
 const hexToRgba = (s: string, n: number): number => parseInt(s.slice(n, n + 2), 16);
 const stripHash = (hex: string): string => (hex.startsWith("#") ? hex.slice(1) : hex);
 
+const NAMED: Record<string, string> = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  green: "#008000",
+  blue: "#0000ff",
+  yellow: "#ffff00",
+  cyan: "#00ffff",
+  magenta: "#ff00ff",
+  silver: "#c0c0c0",
+  gray: "#808080",
+  grey: "#808080",
+  maroon: "#800000",
+  olive: "#808000",
+  lime: "#00ff00",
+  aqua: "#00ffff",
+  teal: "#008080",
+  navy: "#000080",
+  fuchsia: "#ff00ff",
+  purple: "#800080",
+  orange: "#ffa500",
+  brown: "#a52a2a",
+  tan: "#d2b48c",
+  gold: "#ffd700",
+  indigo: "#4b0082",
+  violet: "#ee82ee",
+  pink: "#ffc0cb",
+  coral: "#ff7f50",
+  salmon: "#fa8072",
+  khaki: "#f0e68c",
+  crimson: "#dc143c",
+  transparent: "transparent",
+};
+
+/**
+ * Parses a CSS color string into a Color.
+ * Supports hex colors, rgb/rgba functions, and named colors.
+ * @param cssColor - The CSS color string to parse
+ * @returns The parsed color or undefined if invalid
+ */
+export const fromCSS = (cssColor: string): Color | undefined => {
+  if (!cssColor) return undefined;
+  const trimmed = cssColor.trim().toLowerCase();
+  if (trimmed === "transparent" || trimmed === "none") return undefined;
+  if (trimmed.startsWith("#")) {
+    if (trimmed.length === 4) {
+      const r = trimmed[1];
+      const g = trimmed[2];
+      const b = trimmed[3];
+      const expanded = `#${r}${r}${g}${g}${b}${b}`;
+      if (hexZ.safeParse(expanded).success) return fromHex(expanded);
+    }
+    if (
+      (trimmed.length === 7 || trimmed.length === 9) &&
+      hexZ.safeParse(trimmed).success
+    )
+      return fromHex(trimmed);
+    return undefined;
+  }
+  if (trimmed.startsWith("rgb")) {
+    const match = trimmed.match(
+      /rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)/,
+    );
+    if (match) {
+      const [, r, g, b, a] = match;
+      return [parseInt(r), parseInt(g), parseInt(b), a ? parseFloat(a) : 1];
+    }
+  }
+  if (NAMED[trimmed]) return fromHex(NAMED[trimmed]);
+  return undefined;
+};
+
 /** @returns parse a color from an HSLA tuple. */
 export const fromHSLA = (hsla: HSLA): RGBA => {
   hsla = hslaZ.parse(hsla);

package/src/deep/copy.spec.ts

@@ -0,0 +1,148 @@
+// Copyright 2025 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { describe, expect, it } from "vitest";
+
+import { deep } from "@/deep";
+
+describe("copy", () => {
+  it("should deep copy a simple object", () => {
+    const obj = { a: 1, b: 2 };
+    const copied = deep.copy(obj);
+    expect(copied).toEqual(obj);
+    expect(copied).not.toBe(obj);
+  });
+
+  it("should deep copy nested objects", () => {
+    const obj = { a: 1, b: { c: 2, d: { e: 3 } } };
+    const copied = deep.copy(obj);
+    expect(copied).toEqual(obj);
+    expect(copied).not.toBe(obj);
+    expect(copied.b).not.toBe(obj.b);
+    expect(copied.b.d).not.toBe(obj.b.d);
+  });
+
+  it("should deep copy arrays", () => {
+    const obj = { a: [1, 2, 3], b: [{ c: 4 }, { d: 5 }] };
+    const copied = deep.copy(obj);
+    expect(copied).toEqual(obj);
+    expect(copied.a).not.toBe(obj.a);
+    expect(copied.b).not.toBe(obj.b);
+    expect(copied.b[0]).not.toBe(obj.b[0]);
+  });
+
+  it("should handle null values", () => {
+    const obj = { a: null, b: { c: null } };
+    const copied = deep.copy(obj);
+    expect(copied).toEqual(obj);
+    expect(copied).not.toBe(obj);
+  });
+
+  it("should handle undefined values", () => {
+    const obj = { a: undefined, b: { c: undefined } };
+    const copied = deep.copy(obj);
+    expect(copied).toEqual(obj);
+    expect(copied).not.toBe(obj);
+  });
+
+  it("should handle Date objects", () => {
+    const date = new Date("2025-01-01");
+    const obj = { a: date, b: { c: date } };
+    const copied = deep.copy(obj);
+    expect(copied.a).toEqual(date);
+    expect(copied.a).not.toBe(date);
+    expect(copied.b.c).toEqual(date);
+    expect(copied.b.c).not.toBe(date);
+  });
+
+  it("should handle circular references with structuredClone", () => {
+    const obj: any = { a: 1 };
+    obj.circular = obj;
+
+    const copied = deep.copy(obj);
+
+    expect(copied.a).toBe(1);
+    expect(copied.circular).toBe(copied);
+    expect(copied).not.toBe(obj);
+  });
+
+  it("should handle Map objects", () => {
+    const map = new Map([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    const obj = { map };
+    const copied = deep.copy(obj);
+    expect(copied.map).toEqual(map);
+    expect(copied.map).not.toBe(map);
+  });
+
+  it("should handle Set objects", () => {
+    const set = new Set([1, 2, 3]);
+    const obj = { set };
+    const copied = deep.copy(obj);
+    expect(copied.set).toEqual(set);
+    expect(copied.set).not.toBe(set);
+  });
+
+  it("should handle RegExp objects", () => {
+    const regex = /test/gi;
+    const obj = { regex };
+    const copied = deep.copy(obj);
+    expect(copied.regex).toEqual(regex);
+    expect(copied.regex).not.toBe(regex);
+  });
+
+  it("should handle mixed types", () => {
+    const obj = {
+      num: 42,
+      str: "test",
+      bool: true,
+      arr: [1, 2, { nested: "value" }],
+      obj: { a: 1, b: { c: 2 } },
+      date: new Date("2025-01-01"),
+      nil: null,
+      undef: undefined,
+    };
+    const copied = deep.copy(obj);
+    expect(copied).toEqual(obj);
+    expect(copied).not.toBe(obj);
+    expect(copied.arr).not.toBe(obj.arr);
+    expect(copied.obj).not.toBe(obj.obj);
+    expect(copied.date).not.toBe(obj.date);
+  });
+
+  it("should handle empty objects and arrays", () => {
+    const obj = { empty: {}, arr: [] };
+    const copied = deep.copy(obj);
+    expect(copied).toEqual(obj);
+    expect(copied.empty).not.toBe(obj.empty);
+    expect(copied.arr).not.toBe(obj.arr);
+  });
+
+  it("should preserve array length with sparse arrays", () => {
+    // eslint-disable-next-line no-sparse-arrays
+    const arr = [1, , , 4];
+    const copied = deep.copy(arr);
+    expect(copied).toEqual(arr);
+    expect(copied.length).toBe(4);
+    expect(copied[1]).toBeUndefined();
+  });
+
+  it("should handle Uint8Array and other typed arrays", () => {
+    const uint8 = new Uint8Array([1, 2, 3]);
+    const obj = { uint8 };
+    const copied = deep.copy(obj);
+    expect(copied.uint8).toBeDefined();
+    if (copied.uint8 instanceof Uint8Array) {
+      expect(Array.from(copied.uint8)).toEqual([1, 2, 3]);
+      expect(copied.uint8).not.toBe(uint8);
+    } else expect(Array.from(copied.uint8 as Uint8Array)).toEqual([1, 2, 3]);
+  });
+});

package/src/deep/external.ts

@@ -8,9 +8,11 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/deep/copy";
-export * from "@/deep/delete";
 export * from "@/deep/difference";
 export * from "@/deep/equal";
+export * from "@/deep/get";
 export * from "@/deep/merge";
 export * from "@/deep/partial";
 export * from "@/deep/path";
+export * from "@/deep/remove";
+export * from "@/deep/set";

package/src/deep/get.bench.ts

@@ -0,0 +1,170 @@
+// Copyright 2025 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { bench, describe } from "vitest";
+
+import { deep } from "@/deep";
+
+describe("deep.get benchmarks", () => {
+  const shallowObject = {
+    a: 1,
+    b: 2,
+    c: 3,
+    d: 4,
+    e: 5,
+  };
+
+  const nestedObject = {
+    level1: {
+      level2: {
+        level3: {
+          level4: {
+            level5: {
+              value: 42,
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const arrayObject = {
+    items: [
+      { key: "item1", value: 1 },
+      { key: "item2", value: 2 },
+      { key: "item3", value: 3 },
+      { key: "item4", value: 4 },
+      { key: "item5", value: 5 },
+    ],
+  };
+
+  const deeplyNestedArray = {
+    a: [
+      {
+        b: [
+          {
+            c: [{ value: 1 }, { value: 2 }, { value: 3 }],
+          },
+        ],
+      },
+    ],
+  };
+
+  const largeObject: any = {};
+  for (let i = 0; i < 1000; i++)
+    largeObject[`key${i}`] = {
+      nested: {
+        value: i,
+        data: {
+          id: i,
+          name: `name${i}`,
+        },
+      },
+    };
+
+  const veryDeepObject: any = {};
+  let current = veryDeepObject;
+  for (let i = 0; i < 100; i++) {
+    current.next = { level: i };
+    current = current.next;
+  }
+  current.value = "deep";
+
+  const keyedWithPeriods = {
+    channels: [
+      { key: "sensor.temperature.1", reading: 25.5 },
+      { key: "sensor.temperature.2", reading: 26.1 },
+      { key: "sensor.pressure.1", reading: 101.3 },
+      { key: "sensor.pressure.2", reading: 101.5 },
+    ],
+  };
+
+  bench("shallow property access", () => {
+    deep.get(shallowObject, "c");
+  });
+
+  bench("nested property access (5 levels)", () => {
+    deep.get(nestedObject, "level1.level2.level3.level4.level5.value");
+  });
+
+  bench("array index access", () => {
+    deep.get(arrayObject, "items.2");
+  });
+
+  bench("keyed array access", () => {
+    deep.get(arrayObject, "items.item3.value");
+  });
+
+  bench("mixed array and object access", () => {
+    deep.get(deeplyNestedArray, "a.0.b.0.c.1.value");
+  });
+
+  bench("large object property access", () => {
+    deep.get(largeObject, "key500.nested.data.name");
+  });
+
+  bench("very deep path (100 levels)", () => {
+    const path = `${new Array(99).fill("next").join(".")}.value`;
+    deep.get(veryDeepObject, path);
+  });
+
+  bench("optional path that doesn't exist", () => {
+    deep.get(nestedObject, "level1.nonexistent.path", { optional: true });
+  });
+
+  bench("keyed array with periods in keys", () => {
+    deep.get(keyedWithPeriods, "channels.sensor.temperature.1.reading");
+  });
+
+  bench("has() on existing path", () => {
+    deep.has(nestedObject, "level1.level2.level3");
+  });
+
+  bench("has() on non-existing path", () => {
+    deep.has(nestedObject, "level1.level2.nonexistent");
+  });
+
+  bench("has() on keyed array", () => {
+    deep.has(arrayObject, "items.item2");
+  });
+
+  const pathsWith100Keys: any = {};
+  let temp = pathsWith100Keys;
+  for (let i = 0; i < 100; i++) {
+    temp[`key_${i}`] = {};
+    temp = temp[`key_${i}`];
+  }
+  temp.final = "value";
+
+  bench("100 unique keys traversal", () => {
+    const path = Array.from({ length: 100 }, (_, i) => `key_${i}`).join(".");
+    deep.get(pathsWith100Keys, `${path}.final`);
+  });
+
+  bench("repeated get operations (cache test)", () => {
+    for (let i = 0; i < 10; i++)
+      deep.get(nestedObject, "level1.level2.level3.level4.level5.value");
+  });
+
+  bench("get with custom getter function", () => {
+    const obj = {
+      data: {
+        value: () => ({ result: 42 }),
+      },
+    };
+    deep.get(obj, "data.value().result", {
+      optional: false,
+      getter: (obj, key) => {
+        if (key === "value()")
+          return (obj as { value: () => { result: number } }).value();
+        return obj[key];
+      },
+    });
+  });
+});