onejs-core 1.0.29 → 1.0.32

package/definitions/Assemblies/OneJS.Runtime.d.ts

@@ -155,8 +155,8 @@ declare namespace CS {
         class WebApi extends System.Object
         {
             protected [__keep_incompatibility]: never;
-            public getText ($uri: string, $callback: System.Action$1<string>) : UnityEngine.Coroutine
-            public getImage ($url: string, $callback: System.Action$1<UnityEngine.Texture2D>) : UnityEngine.Coroutine
+            public getText ($uri: string, $callback: System.Action$1<string>, $headersJson?: string) : UnityEngine.Coroutine
+            public getImage ($url: string, $callback: System.Action$1<UnityEngine.Texture2D>, $headersJson?: string, $forceRefresh?: boolean) : UnityEngine.Coroutine
             public constructor ()
         }
         class Runner extends UnityEngine.MonoBehaviour
@@ -478,6 +478,9 @@ declare namespace CS {
             public static FindTypesInNamespace ($namespaceName: string) : System.Collections.Generic.List$1<System.Type>
             public constructor ()
         }
+        class TypeUtil {
+            public static GetType(obj: any): System.Type; // More reliable to use this than `obj.GetType()` for puerts blittable types
+        }
         class FloatConvUtil extends System.Object
         {
             protected [__keep_incompatibility]: never;

package/definitions/jsx.d.ts

@@ -66,6 +66,9 @@ type TransitionStartEvent = CS.UnityEngine.UIElements.TransitionStartEvent;
 type ValidateCommandEvent = CS.UnityEngine.UIElements.ValidateCommandEvent;
 type VectorImage = CS.UnityEngine.UIElements.VectorImage;
 type WheelEvent = CS.UnityEngine.UIElements.WheelEvent;
+type ContextualMenuPopulateEvent = CS.UnityEngine.UIElements.ContextualMenuPopulateEvent;
+
+type TwoPaneSplitViewOrientation = CS.UnityEngine.UIElements.TwoPaneSplitViewOrientation;
 
 declare global {
     export namespace JSX {
@@ -129,7 +132,7 @@ declare global {
             onMouseLeaveWindow?: (e: MouseLeaveWindowEvent) => void
             onMouseOver?: (e: MouseOverEvent) => void
             onMouseOut?: (e: MouseOutEvent) => void
-            // onContextualMenuPopulate?: (e: ContextualMenuPopulateEvent) => void
+            onContextualMenuPopulate?: (e: ContextualMenuPopulateEvent) => void
             onNavigationMove?: (e: NavigationMoveEvent) => void
             // onNavigationTab?: (e: NavigationTabEvent) => void
             onNavigationCancel?: (e: NavigationCancelEvent) => void
@@ -315,6 +318,7 @@ declare global {
             "high-limit"?: number
             "min-value"?: number
             "max-value"?: number
+            value?: Vector2
         }
 
         interface EnumField extends BaseField<number> {
@@ -465,6 +469,12 @@ declare global {
             value?: string
         }
 
+        interface TwoPaneSplitView extends VisualElement {
+            fixedPaneIndex?: number
+            fixedPaneInitialDimension?: number
+            orientation?: TwoPaneSplitViewOrientation
+        }
+
         /**
          * OneJS Elements
          */
@@ -530,6 +540,8 @@ declare global {
             popupwindow: PopupWindow
             dropdownfield: DropdownField
 
+            "twopane-splitview": TwoPaneSplitView
+
             // /* OneJS Custom */
             img: Img
             gradientrect: GradientRect

package/definitions/proto-overrides.d.ts

@@ -1,5 +1,4 @@
 
-
 declare namespace CS.UnityEngine {
     interface GameObject {
         GetComp<T>(type: { new(): T }): T
@@ -10,4 +9,34 @@ declare namespace CS.UnityEngine {
         GetComp<T>(type: { new(): T }): T
         AddComp<T>(type: { new(): T }): T
     }
+}
+
+type CSArray = CS.System.Array
+
+declare namespace CS.System {
+    interface Array {
+        get<T>(index: number): T
+        set<T>(index: number, value: T): void
+        toJsArray<T>(): T[]
+        at<T>(index: number): T
+        forEach<T>(callbackfn: (value: T, index: number, array: CSArray) => void): void
+        map<T, U>(type: { new(...args: any[]): U }, callbackfn: (value: T, index: number, array: CSArray) => U): CSArray
+        filter<T>(callbackfn: (value: T, index: number, array: CSArray) => boolean): CSArray
+        reduce<T>(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: CSArray) => T): T
+        reduceRight<T>(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: CSArray) => T): T
+        find<T>(predicate: (value: T, index: number, array: CSArray) => boolean): T
+        findIndex<T>(predicate: (value: T, index: number, array: CSArray) => boolean): number
+        indexOf<T>(searchElement: T, fromIndex?: number): number
+        lastIndexOf<T>(searchElement: T, fromIndex?: number): number
+        some<T>(callbackfn: (value: T, index: number, array: CSArray) => boolean): boolean
+        every<T>(callbackfn: (value: T, index: number, array: CSArray) => boolean): boolean
+        slice<T>(start?: number, end?: number): CSArray
+        concat<T>(...items: CSArray[]): T[]
+        join(separator?: string): string
+        sort<T>(compareFn?: (a: T, b: T) => number): CSArray
+        reverse(): CSArray
+        includes<T>(searchElement: T, fromIndex?: number): boolean
+        fill<T>(value: T, start?: number, end?: number): CSArray
+        copyWithin<T>(target: number, start: number, end?: number): CSArray
+    }
 }

package/dist/csharp/index.d.ts

@@ -0,0 +1,3 @@
+export declare function newArray<T>(type: {
+    new (): T;
+}, count: any): CS.System.Array;

package/dist/csharp/index.js

@@ -0,0 +1,3 @@
+export function newArray(type, count) {
+    return CS.System.Array.CreateInstance(puer.$typeof(type), count);
+}

package/dist/index.d.ts

@@ -18,4 +18,8 @@ declare global {
         nodeType: number;
         ve: CS.UnityEngine.UIElements.VisualElement;
     }
+    const newCsArray: <T>(type: {
+        new (...args: any[]): T;
+    }, count: number) => CS.System.Array;
+    const toJsArray: <T>(csArr: CS.System.Array) => T[];
 }

package/dist/index.js

@@ -38,3 +38,4 @@ if (typeof ___document != "undefined") {
     // @ts-ignore
     globalThis.document = new DocumentWrapper(___document);
 }
+// puer.$extension(CS.UnityEngine.UIElements.VisualElement, CS.UnityEngine.UIElements.VisualElementExtensions)

package/dist/math/index.d.ts

@@ -0,0 +1,86 @@
+/// <reference path="../../definitions/modules.d.ts" />
+import { Matrix4x4, Quaternion, Vector2, Vector2Int, Vector3, Vector3Int, Vector4, Color } from "UnityEngine";
+type CSArray = CS.System.Array;
+export declare function vec2(x: number, y: number): Vector2;
+export declare function vec2i(x: number, y: number): Vector2Int;
+export declare function vec3(x: number, y: number, z: number): Vector3;
+export declare function vec3i(x: number, y: number, z: number): Vector3Int;
+export declare function vec4(x: number, y: number, z: number, w: number): Vector4;
+export declare function quat(): Quaternion;
+export declare function quat(x: number, y: number, z: number, w: number): Quaternion;
+export declare function euler(x: number, y: number, z: number): Quaternion;
+export declare function mat4x4(): Matrix4x4;
+export declare function mat4x4(a: Vector4, b: Vector4, c: Vector4, d: Vector4): Matrix4x4;
+export declare function mat4x4(a: number[][]): Matrix4x4;
+export declare function trs(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4x4;
+export declare function floatArray(...items: number[]): CSArray;
+export declare function vec2Array(...items: number[][]): CSArray;
+export declare function vec2iArray(...items: number[][]): CSArray;
+export declare function vec3Array(...items: number[][]): CSArray;
+export declare function vec3iArray(...items: number[][]): CSArray;
+export declare function vec4Array(...items: number[][]): CSArray;
+export declare function add(a: Vector2, b: Vector2): Vector2;
+export declare function add(a: Vector3, b: Vector3): Vector3;
+export declare function add(a: Vector2Int, b: Vector2Int): Vector2Int;
+export declare function add(a: Vector3Int, b: Vector3Int): Vector3Int;
+export declare function add(a: Vector4, b: Vector4): Vector4;
+export declare function sub(a: Vector2, b: Vector2): Vector2;
+export declare function sub(a: Vector3, b: Vector3): Vector3;
+export declare function sub(a: Vector2Int, b: Vector2Int): Vector2Int;
+export declare function sub(a: Vector3Int, b: Vector3Int): Vector3Int;
+export declare function sub(a: Vector4, b: Vector4): Vector4;
+export declare function neg(a: Vector2): Vector2;
+export declare function neg(a: Vector3): Vector3;
+export declare function neg(a: Vector2Int): Vector2Int;
+export declare function neg(a: Vector3Int): Vector3Int;
+export declare function neg(a: Vector4): Vector4;
+export declare function mul(a: Vector2, b: number): Vector2;
+export declare function mul(a: number, b: Vector2): Vector3;
+export declare function mul(a: Vector3, b: number): Vector3;
+export declare function mul(a: number, b: Vector3): Vector3;
+export declare function mul(a: Vector2Int, b: number): Vector2Int;
+export declare function mul(a: number, b: Vector2Int): Vector2Int;
+export declare function mul(a: Vector3Int, b: number): Vector3Int;
+export declare function mul(a: number, b: Vector3Int): Vector3Int;
+export declare function mul(a: Vector4, b: number): Vector4;
+export declare function mul(a: number, b: Vector4): Vector4;
+export declare function mul(a: Quaternion, b: Quaternion): Quaternion;
+export declare function mul(a: Quaternion, b: Vector3): Vector3;
+export declare function mul(a: Matrix4x4, b: Matrix4x4): Matrix4x4;
+export declare function mul(a: Matrix4x4, b: Vector4): Vector4;
+export declare function div(a: Vector2, b: number): Vector2;
+export declare function div(a: Vector3, b: number): Vector3;
+export declare function div(a: Vector2Int, b: number): Vector2Int;
+export declare function div(a: Vector3Int, b: number): Vector3Int;
+export declare function eq(a: Vector2, b: Vector2): boolean;
+export declare function eq(a: Vector3, b: Vector3): boolean;
+export declare function eq(a: Vector2Int, b: Vector2Int): boolean;
+export declare function eq(a: Vector3Int, b: Vector3Int): boolean;
+export declare function eq(a: Quaternion, b: Quaternion): boolean;
+export declare function dot(a: Vector2, b: Vector2): number;
+export declare function dot(a: Vector3, b: Vector3): number;
+export declare function dot(a: Vector4, b: Vector4): number;
+export declare function dot(a: Quaternion, b: Quaternion): number;
+export declare function clamp(a: Vector2, min: Vector2, max: Vector2): Vector2;
+export declare function clamp(a: Vector3, min: Vector3, max: Vector3): Vector3;
+export declare function clamp(a: Vector2Int, min: Vector2Int, max: Vector2Int): Vector2Int;
+export declare function clamp(a: Vector3Int, min: Vector3Int, max: Vector3Int): Vector3Int;
+export declare function clamp(a: Vector4, min: Vector4, max: Vector4): Vector4;
+export declare function clamp01(a: Vector2): Vector2;
+export declare function clamp01(a: Vector3): Vector3;
+export declare function clamp01(a: Vector4): Vector4;
+export declare function distance(a: Vector2, b: Vector2): number;
+export declare function distance(a: Vector3, b: Vector3): number;
+export declare function distance(a: Vector2Int, b: Vector2Int): number;
+export declare function distance(a: Vector3Int, b: Vector3Int): number;
+export declare function distance(a: Vector4, b: Vector4): number;
+export declare function normalize(a: Vector2): Vector2;
+export declare function normalize(a: Vector3): Vector3;
+export declare function normalize(a: Vector4): Vector4;
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function lerp(a: Vector2, b: Vector2, t: number): Vector2;
+export declare function lerp(a: Vector3, b: Vector3, t: number): Vector3;
+export declare function lerp(a: Vector4, b: Vector4, t: number): Vector4;
+export declare function lerp(a: Quaternion, b: Quaternion, t: number): Quaternion;
+export declare function lerp(a: Color, b: Color, t: number): Color;
+export {};

package/dist/math/index.js

@@ -0,0 +1,361 @@
+import { Matrix4x4, Quaternion, Vector2, Vector2Int, Vector3, Vector3Int, Vector4, Color } from "UnityEngine";
+const getType = CS.OneJS.Utils.TypeUtil.GetType;
+const { $typeof } = puer;
+// MARK: - Vectors
+export function vec2(x, y) {
+    return new Vector2(x, y);
+}
+export function vec2i(x, y) {
+    return new Vector2Int(x, y);
+}
+export function vec3(x, y, z) {
+    return new Vector3(x, y, z);
+}
+export function vec3i(x, y, z) {
+    return new Vector3Int(x, y, z);
+}
+export function vec4(x, y, z, w) {
+    return new Vector4(x, y, z, w);
+}
+export function quat(x, y, z, w) {
+    if (x === undefined && y === undefined && z === undefined && w === undefined) {
+        return Quaternion.identity;
+    }
+    if (x !== undefined && y !== undefined && z !== undefined && w !== undefined) {
+        return new Quaternion(x, y, z, w);
+    }
+    throw new Error("Invalid arguments: either no arguments or exactly four numbers.");
+}
+export function euler(x, y, z) {
+    return Quaternion.Euler(x, y, z);
+}
+export function mat4x4(a, b, c, d) {
+    if (a === undefined && b === undefined && c === undefined && d === undefined) {
+        return Matrix4x4.identity;
+    }
+    if (a instanceof Vector4 && b instanceof Vector4 && c instanceof Vector4 && d instanceof Vector4) {
+        return new Matrix4x4(a, b, c, d);
+    }
+    if (Array.isArray(a) && a.length === 4 && a.every(v => Array.isArray(v) && v.length === 4)) {
+        return new Matrix4x4(vec4(a[0][0], a[0][1], a[0][2], a[0][3]), vec4(a[1][0], a[1][1], a[1][2], a[1][3]), vec4(a[2][0], a[2][1], a[2][2], a[2][3]), vec4(a[3][0], a[3][1], a[3][2], a[3][3]));
+    }
+    throw new Error("Invalid arguments: either no arguments, four Vector4s or a 4x4 array of numbers.");
+}
+export function trs(translation, rotation, scale) {
+    return Matrix4x4.TRS(translation, rotation, scale);
+}
+// MARK: - Arrays
+export function floatArray(...items) {
+    const result = newCsArray(CS.System.Single, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, items[i]);
+    }
+    return result;
+}
+export function vec2Array(...items) {
+    const result = newCsArray(Vector2, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, vec2(items[i][0], items[i][1]));
+    }
+    return result;
+}
+export function vec2iArray(...items) {
+    const result = newCsArray(Vector2Int, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, vec2i(items[i][0], items[i][1]));
+    }
+    return result;
+}
+export function vec3Array(...items) {
+    const result = newCsArray(Vector3, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, vec3(items[i][0], items[i][1], items[i][2]));
+    }
+    return result;
+}
+export function vec3iArray(...items) {
+    const result = newCsArray(Vector3Int, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, vec3i(items[i][0], items[i][1], items[i][2]));
+    }
+    return result;
+}
+export function vec4Array(...items) {
+    const result = newCsArray(Vector4, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, vec4(items[i][0], items[i][1], items[i][2], items[i][3]));
+    }
+    return result;
+}
+export function add(a, b) {
+    function isBothOfType(type) {
+        return getType(a) == $typeof(type) && getType(b) == $typeof(type);
+    }
+    if (isBothOfType(Vector2)) {
+        return Vector2.op_Addition(a, b);
+    }
+    else if (isBothOfType(Vector2Int)) {
+        return Vector2Int.op_Addition(a, b);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.op_Addition(a, b);
+    }
+    else if (isBothOfType(Vector3Int)) {
+        return Vector3Int.op_Addition(a, b);
+    }
+    else if (isBothOfType(Vector4)) {
+        return Vector4.op_Addition(a, b);
+    }
+    throw new Error("Unsupported types for add operation");
+}
+export function sub(a, b) {
+    function isBothOfType(type) {
+        return getType(a) == $typeof(type) && getType(b) == $typeof(type);
+    }
+    if (isBothOfType(Vector2)) {
+        return Vector2.op_Subtraction(a, b);
+    }
+    else if (isBothOfType(Vector2Int)) {
+        return Vector2Int.op_Subtraction(a, b);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.op_Subtraction(a, b);
+    }
+    else if (isBothOfType(Vector3Int)) {
+        return Vector3Int.op_Subtraction(a, b);
+    }
+    else if (isBothOfType(Vector4)) {
+        return Vector4.op_Subtraction(a, b);
+    }
+    throw new Error("Unsupported types for sub operation");
+}
+export function neg(a) {
+    if (getType(a) == $typeof(Vector2)) {
+        return Vector2.op_UnaryNegation(a);
+    }
+    else if (getType(a) == $typeof(Vector2Int)) {
+        return Vector2Int.op_UnaryNegation(a);
+    }
+    else if (getType(a) == $typeof(Vector3)) {
+        return Vector3.op_UnaryNegation(a);
+    }
+    else if (getType(a) == $typeof(Vector3Int)) {
+        return Vector3Int.op_UnaryNegation(a);
+    }
+    else if (getType(a) == $typeof(Vector4)) {
+        return Vector4.op_UnaryNegation(a);
+    }
+    throw new Error("Unsupported types for neg operation");
+}
+export function mul(a, b) {
+    if (isOfType(a, Quaternion) && isOfType(b, Quaternion)) {
+        return Quaternion.op_Multiply(a, b);
+    }
+    if (isOfType(a, Quaternion) && isOfType(b, Vector3)) {
+        return Quaternion.op_Multiply(a, b);
+    }
+    if (isOfType(a, Matrix4x4) && isOfType(b, Matrix4x4)) {
+        return Matrix4x4.op_Multiply(a, b);
+    }
+    if (isOfType(a, Matrix4x4) && isOfType(b, Vector4)) {
+        return Matrix4x4.op_Multiply(a, b);
+    }
+    if (typeof b === 'number') {
+        if (getType(a) == $typeof(Vector2)) {
+            return Vector2.op_Multiply(a, b);
+        }
+        else if (getType(a) == $typeof(Vector2Int)) {
+            return Vector2Int.op_Multiply(a, b);
+        }
+        else if (getType(a) == $typeof(Vector3)) {
+            return Vector3.op_Multiply(a, b);
+        }
+        else if (getType(a) == $typeof(Vector3Int)) {
+            return Vector3Int.op_Multiply(a, b);
+        }
+        else if (getType(a) == $typeof(Vector4)) {
+            return Vector4.op_Multiply(a, b);
+        }
+    }
+    else if (typeof a === 'number') {
+        if (getType(b) == $typeof(Vector2)) {
+            return Vector2.op_Multiply(b, a);
+        }
+        else if (getType(b) == $typeof(Vector2Int)) {
+            return Vector2Int.op_Multiply(b, a);
+        }
+        else if (getType(b) == $typeof(Vector3)) {
+            return Vector3.op_Multiply(b, a);
+        }
+        else if (getType(b) == $typeof(Vector3Int)) {
+            return Vector3Int.op_Multiply(b, a);
+        }
+        else if (getType(b) == $typeof(Vector4)) {
+            return Vector4.op_Multiply(b, a);
+        }
+    }
+    throw new Error("Unsupported types for mul operation");
+}
+export function div(a, b) {
+    if (typeof b === 'number') {
+        if (getType(a) == $typeof(Vector2)) {
+            return Vector2.op_Division(a, b);
+        }
+        else if (getType(a) == $typeof(Vector2Int)) {
+            return Vector2Int.op_Division(a, b);
+        }
+        else if (getType(a) == $typeof(Vector3)) {
+            return Vector3.op_Division(a, b);
+        }
+        else if (getType(a) == $typeof(Vector3Int)) {
+            return Vector3Int.op_Division(a, b);
+        }
+    }
+    throw new Error("Unsupported types for div operation");
+}
+export function eq(a, b) {
+    function isBothOfType(type) {
+        return getType(a) == $typeof(type) && getType(b) == $typeof(type);
+    }
+    if (isBothOfType(Vector2)) {
+        return Vector2.op_Equality(a, b);
+    }
+    else if (isBothOfType(Vector2Int)) {
+        return Vector2Int.op_Equality(a, b);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.op_Equality(a, b);
+    }
+    else if (isBothOfType(Vector3Int)) {
+        return Vector3Int.op_Equality(a, b);
+    }
+    else if (isBothOfType(Quaternion)) {
+        return Quaternion.op_Equality(a, b);
+    }
+    throw new Error("Unsupported types for eq operation");
+}
+export function dot(a, b) {
+    function isBothOfType(type) {
+        return isOfType(a, type) && isOfType(b, type);
+    }
+    if (isBothOfType(Vector2)) {
+        return Vector2.Dot(a, b);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.Dot(a, b);
+    }
+    else if (isBothOfType(Vector4)) {
+        return Vector4.Dot(a, b);
+    }
+    else if (isBothOfType(Quaternion)) {
+        return Quaternion.Dot(a, b);
+    }
+    throw new Error("Unsupported types for dot operation");
+}
+export function clamp(a, min, max) {
+    function isAllOfType(type) {
+        return isOfType(a, type) && isOfType(min, type) && isOfType(max, type);
+    }
+    if (isAllOfType(Vector2)) {
+        return vec2(Math.min(Math.max(a.x, min.x), max.x), Math.min(Math.max(a.y, min.y), max.y));
+    }
+    else if (isAllOfType(Vector3)) {
+        return vec3(Math.min(Math.max(a.x, min.x), max.x), Math.min(Math.max(a.y, min.y), max.y), Math.min(Math.max(a.z, min.z), max.z));
+    }
+    else if (isAllOfType(Vector2Int)) {
+        return vec2i(Math.min(Math.max(a.x, min.x), max.x), Math.min(Math.max(a.y, min.y), max.y));
+    }
+    else if (isAllOfType(Vector3Int)) {
+        return vec3i(Math.min(Math.max(a.x, min.x), max.x), Math.min(Math.max(a.y, min.y), max.y), Math.min(Math.max(a.z, min.z), max.z));
+    }
+    else if (isAllOfType(Vector4)) {
+        return vec4(Math.min(Math.max(a.x, min.x), max.x), Math.min(Math.max(a.y, min.y), max.y), Math.min(Math.max(a.z, min.z), max.z), Math.min(Math.max(a.w, min.w), max.w));
+    }
+    throw new Error("Unsupported types for clamp operation");
+}
+export function clamp01(a) {
+    if (isOfType(a, Vector2)) {
+        return vec2(Math.min(Math.max(a.x, 0), 1), Math.min(Math.max(a.y, 0), 1));
+    }
+    else if (isOfType(a, Vector3)) {
+        return vec3(Math.min(Math.max(a.x, 0), 1), Math.min(Math.max(a.y, 0), 1), Math.min(Math.max(a.z, 0), 1));
+    }
+    else if (isOfType(a, Vector4)) {
+        return vec4(Math.min(Math.max(a.x, 0), 1), Math.min(Math.max(a.y, 0), 1), Math.min(Math.max(a.z, 0), 1), Math.min(Math.max(a.w, 0), 1));
+    }
+    throw new Error("Unsupported types for clamp01 operation");
+}
+export function distance(a, b) {
+    function isBothOfType(type) {
+        return isOfType(a, type) && isOfType(b, type);
+    }
+    if (isBothOfType(Vector2)) {
+        return Vector2.Distance(a, b);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.Distance(a, b);
+    }
+    else if (isBothOfType(Vector2Int)) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    else if (isBothOfType(Vector3Int)) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+        const dz = a.z - b.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    else if (isBothOfType(Vector4)) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+        const dz = a.z - b.z;
+        const dw = a.w - b.w;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz + dw * dw);
+    }
+    throw new Error("Unsupported types for distance operation");
+}
+export function normalize(a) {
+    if (isOfType(a, Vector2)) {
+        const magnitude = Math.sqrt(a.x * a.x + a.y * a.y);
+        if (magnitude < 1e-6) {
+            return vec2(0, 0);
+        }
+        return vec2(a.x / magnitude, a.y / magnitude);
+    }
+    else if (isOfType(a, Vector3)) {
+        return Vector3.Normalize(a);
+    }
+    else if (isOfType(a, Vector4)) {
+        return Vector4.Normalize(a);
+    }
+    throw new Error("Unsupported types for normalize operation");
+}
+export function lerp(a, b, t) {
+    function isBothOfType(type) {
+        return isOfType(a, type) && isOfType(b, type);
+    }
+    if (typeof a === 'number' && typeof b === 'number') {
+        return a + (b - a) * t;
+    }
+    else if (isBothOfType(Vector2)) {
+        return Vector2.Lerp(a, b, t);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.Lerp(a, b, t);
+    }
+    else if (isBothOfType(Vector4)) {
+        return vec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t);
+    }
+    else if (isBothOfType(Quaternion)) {
+        return Quaternion.Lerp(a, b, t);
+    }
+    else if (isBothOfType(Color)) {
+        return Color.Lerp(a, b, t);
+    }
+    throw new Error("Unsupported types for lerp operation");
+}
+// MARK: - Utilities
+function isOfType(obj, type) {
+    return getType(obj) == $typeof(type);
+}

package/index.ts

@@ -44,10 +44,14 @@ declare global {
         nodeType: number
         ve: CS.UnityEngine.UIElements.VisualElement
     }
+    const newCsArray: <T>(type: { new(...args: any[]): T }, count: number) => CS.System.Array
+    const toJsArray: <T>(csArr: CS.System.Array) => T[]
 }
 
 // @ts-ignore
 if (typeof ___document != "undefined") {
     // @ts-ignore
     globalThis.document = new DocumentWrapper(___document)
-}
+}
+
+// puer.$extension(CS.UnityEngine.UIElements.VisualElement, CS.UnityEngine.UIElements.VisualElementExtensions)