onejs-core 2.0.21 → 3.0.0

package/bin/oj.js

@@ -36,7 +36,7 @@ function findAssetsDir(startDir, explicit) {
         if (fs.existsSync(explicit) && fs.statSync(explicit).isDirectory()) return explicit
         return null
     }
-    let dir = startDir
+    let dir = path.dirname(startDir) // Up a level, preventing `App/assets` getting returned
     const { root } = path.parse(dir)
     while (dir !== root) {
         const probe = path.join(dir, "Assets")
@@ -80,10 +80,17 @@ async function scanComponents(tarPath) {
     await tar.t({
         file: tarPath,
         onentry: (entry) => {
-            const p = entry.path
+            const p = entry.path.replace(/\\/g, "/")
             if (!p.startsWith("comps/")) return
-            const parts = p.split("/").filter(Boolean) // ["comps","button", ...]
-            if (parts.length >= 2) comps.add(parts[1])
+
+            // Only treat entries inside a top-level folder under comps/
+            // e.g. "comps/button/**" → "button"
+            const rest = p.slice("comps/".length)
+            const firstSlash = rest.indexOf("/")
+            if (firstSlash === -1) return // file directly under comps/ → skip
+
+            const top = rest.slice(0, firstSlash)
+            if (top) comps.add(top)
         },
     })
     return comps
@@ -244,4 +251,4 @@ program
 program.parseAsync().catch((err) => {
     console.error(err)
     process.exit(1)
-})
+})

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

@@ -356,6 +356,8 @@ declare namespace CS {
             public SetColor ($value: UnityEngine.Color) : void
             public SetCursor ($value: UnityEngine.UIElements.Cursor) : void
             public SetDisplay ($value: UnityEngine.UIElements.DisplayStyle) : void
+            public SetFilter ($value: System.Collections.Generic.List$1<UnityEngine.UIElements.FilterFunction>) : void
+            public SetFilter ($value: UnityEngine.UIElements.FilterFunction) : void
             public SetFlexBasis ($value: UnityEngine.UIElements.StyleLength) : void
             public SetFlexDirection ($value: UnityEngine.UIElements.FlexDirection) : void
             public SetFlexGrow ($value: number) : void

package/definitions/Assemblies/UnityEngine.UIElementsModule.d.ts

@@ -21191,6 +21191,189 @@ declare namespace CS {
             public set startValue(value: T);
             public constructor ($drivenField: UnityEngine.UIElements.IValueField$1<T>)
         }
+        /** 
+        The filter parameter declaration for a FilterFunctionDefinition.
+        */
+        class FilterParameterDeclaration extends System.ValueType
+        {
+            protected [__keep_incompatibility]: never;
+            /** 
+            The parameter name, used for display in the UI Builder.
+            */
+            public get name(): string;
+            public set name(value: string);
+            /** 
+            Default value when interpolating between two filters with missing declarations.
+            */
+            public get interpolationDefaultValue(): UnityEngine.UIElements.FilterParameter;
+            public set interpolationDefaultValue(value: UnityEngine.UIElements.FilterParameter);
+        }
+        /** 
+        Represents a filter parameter for a FilterFunctionDefinition.
+        */
+        class FilterParameter extends System.ValueType implements System.IEquatable$1<UnityEngine.UIElements.FilterParameter>
+        {
+            protected [__keep_incompatibility]: never;
+            /** The type of the filter parameter.
+            */
+            public get type(): UnityEngine.UIElements.FilterParameterType;
+            public set type(value: UnityEngine.UIElements.FilterParameterType);
+            /** The float value of the filter parameter.
+            */
+            public get floatValue(): number;
+            public set floatValue(value: number);
+            /** The color value of the filter parameter.
+            */
+            public get colorValue(): UnityEngine.Color;
+            public set colorValue(value: UnityEngine.Color);
+            public static op_Equality ($a: UnityEngine.UIElements.FilterParameter, $b: UnityEngine.UIElements.FilterParameter) : boolean
+            public static op_Inequality ($a: UnityEngine.UIElements.FilterParameter, $b: UnityEngine.UIElements.FilterParameter) : boolean
+            public Equals ($obj: any) : boolean
+            public Equals ($other: UnityEngine.UIElements.FilterParameter) : boolean
+            public constructor ($value: number)
+            public constructor ($value: UnityEngine.Color)
+        }
+        /** 
+        Represents a filter function definition that holds the parameters and effects of a filter.
+        */
+        class FilterFunctionDefinition extends UnityEngine.ScriptableObject
+        {
+            protected [__keep_incompatibility]: never;
+            /** The name of the filter function used for display.
+            */
+            public get filterName(): string;
+            public set filterName(value: string);
+            /** The description of the function parameters.
+            */
+            public get parameters(): System.Array$1<UnityEngine.UIElements.FilterParameterDeclaration>;
+            public set parameters(value: System.Array$1<UnityEngine.UIElements.FilterParameterDeclaration>);
+            /** The post-processing effects applied by the filter function.
+            */
+            public get passes(): System.Array$1<UnityEngine.UIElements.PostProcessingPass>;
+            public set passes(value: System.Array$1<UnityEngine.UIElements.PostProcessingPass>);
+            public constructor ()
+        }
+        /** 
+        Represents a post-processing effect that can be applied to a visual element.
+        This is used as part of a FilterFunctionDefinition.
+        */
+        class PostProcessingPass extends System.ValueType
+        {
+            protected [__keep_incompatibility]: never;
+            /** The material to use for the effect.
+            */
+            public get material(): UnityEngine.Material;
+            public set material(value: UnityEngine.Material);
+            /** The pass index to use in the material.
+            */
+            public get passIndex(): number;
+            public set passIndex(value: number);
+            /** The parameter bindings for the effect.
+            */
+            public get parameterBindings(): System.Array$1<UnityEngine.UIElements.ParameterBinding>;
+            public set parameterBindings(value: System.Array$1<UnityEngine.UIElements.ParameterBinding>);
+            /** The extra margins, in points, required for the effect to write to destination texture.
+            */
+            public get writeMargins(): UnityEngine.UIElements.PostProcessingMargins;
+            public set writeMargins(value: UnityEngine.UIElements.PostProcessingMargins);
+            /** The optional callback to prepare the material property block for the effect.
+            */
+            public get prepareMaterialPropertyBlockCallback(): UnityEngine.UIElements.PostProcessingPass.PrepareMaterialPropertyBlockDelegate;
+            public set prepareMaterialPropertyBlockCallback(value: UnityEngine.UIElements.PostProcessingPass.PrepareMaterialPropertyBlockDelegate);
+            /** The optional callback to compute the required read margins for the effect.
+            */
+            public get computeRequiredReadMarginsCallback(): UnityEngine.UIElements.PostProcessingPass.ComputeRequiredMarginsDelegate;
+            public set computeRequiredReadMarginsCallback(value: UnityEngine.UIElements.PostProcessingPass.ComputeRequiredMarginsDelegate);
+            /** The optional callback to compute the required write margins for the effect.
+            */
+            public get computeRequiredWriteMarginsCallback(): UnityEngine.UIElements.PostProcessingPass.ComputeRequiredMarginsDelegate;
+            public set computeRequiredWriteMarginsCallback(value: UnityEngine.UIElements.PostProcessingPass.ComputeRequiredMarginsDelegate);
+        }
+        /** 
+        Represents a binding of a parameter index to a post-processing material property.
+        */
+        class ParameterBinding extends System.ValueType
+        {
+            protected [__keep_incompatibility]: never;
+            /** The index of the parameter in the filter function.
+            */
+            public get index(): number;
+            public set index(value: number);
+            /** The name of the material property.
+            */
+            public get name(): string;
+            public set name(value: string);
+        }
+        /** 
+        The post-processing margins required by a FilterFunction.
+        */
+        class PostProcessingMargins extends System.ValueType
+        {
+            protected [__keep_incompatibility]: never;
+            /** The left margin value.
+            */
+            public get left(): number;
+            public set left(value: number);
+            /** The top margin value.
+            */
+            public get top(): number;
+            public set top(value: number);
+            /** The right margin value.
+            */
+            public get right(): number;
+            public set right(value: number);
+            /** The bottom margin value.
+            */
+            public get bottom(): number;
+            public set bottom(value: number);
+        }
+        /** 
+        Represents a filter function that holds the definition and parameters of a filter.
+        */
+        class FilterFunction extends System.ValueType implements System.IEquatable$1<UnityEngine.UIElements.FilterFunction>
+        {
+            protected [__keep_incompatibility]: never;
+            /** 
+            The type of the filter function.
+            */
+            public get type(): UnityEngine.UIElements.FilterFunctionType;
+            public set type(value: UnityEngine.UIElements.FilterFunctionType);
+            /** The number of parameters in the filter function.
+            */
+            public get parameterCount(): number;
+            /** 
+            The custom filter function definition, when the filter function type is FilterFunctionType.Custom.
+            */
+            public get customDefinition(): UnityEngine.UIElements.FilterFunctionDefinition;
+            public set customDefinition(value: UnityEngine.UIElements.FilterFunctionDefinition);
+            /** 
+            Adds a parameter to the filter function.
+            * @param $p The parameter to add.
+            */
+            public AddParameter ($p: UnityEngine.UIElements.FilterParameter) : void
+            /** 
+            Sets a parameter to the filter function at the provided index.
+            * @param $index The parameter index.
+            * @param $p The parameter to set.
+            */
+            public SetParameter ($index: number, $p: UnityEngine.UIElements.FilterParameter) : void
+            /** 
+            Gets the parameter at the specified index.
+            * @param $index The parameter index.
+            * @returns The filter parameter at the provided index. 
+            */
+            public GetParameter ($index: number) : UnityEngine.UIElements.FilterParameter
+            /** 
+            Clears all parameters from the filter function.
+            */
+            public ClearParameters () : void
+            public static op_Equality ($lhs: UnityEngine.UIElements.FilterFunction, $rhs: UnityEngine.UIElements.FilterFunction) : boolean
+            public static op_Inequality ($lhs: UnityEngine.UIElements.FilterFunction, $rhs: UnityEngine.UIElements.FilterFunction) : boolean
+            public Equals ($other: UnityEngine.UIElements.FilterFunction) : boolean
+            public Equals ($obj: any) : boolean
+            public constructor ($type: UnityEngine.UIElements.FilterFunctionType)
+            public constructor ($filterDef: UnityEngine.UIElements.FilterFunctionDefinition)
+        }
         interface IFocusRing
         {
             /** 
@@ -22111,6 +22294,16 @@ declare namespace CS {
             public constructor ($mode: UnityEngine.UIElements.EasingMode)
         }
         /** 
+        The filter function type for a FilterFunction .
+        */
+        enum FilterFunctionType
+        { None = 0, Custom = 1, Tint = 2, Opacity = 3, Invert = 4, Grayscale = 5, Sepia = 6, Blur = 7, Contrast = 8, HueRotate = 9, Count = 10 }
+        /** 
+        The type of a filter parameter.
+        */
+        enum FilterParameterType
+        { Float = 0, Color = 1 }
+        /** 
         Describes a VisualElement font.
         */
         class FontDefinition extends System.ValueType implements System.IEquatable$1<UnityEngine.UIElements.FontDefinition>

package/dist/dom/document.d.ts

@@ -1,4 +1,6 @@
+/// <reference path="../../definitions/modules.d.ts" />
 import { DomWrapper } from "./dom";
+import { EventBase } from "UnityEngine/UIElements";
 interface ElementCreationOptions {
     is?: string;
 }
@@ -15,9 +17,14 @@ export declare class DocumentWrapper {
     createElement(tagName: string, options?: ElementCreationOptions): DomWrapper;
     createElementNS(ns: string, tagName: string, options?: ElementCreationOptions): DomWrapper;
     createTextNode(text: string): DomWrapper;
+    createDocumentFragment(): DomWrapper;
     getElementById(id: string): DomWrapper;
     querySelectorAll(selector: string): DomWrapper[];
     elementFromPoint(x: number, y: number): DomWrapper | null;
     elementsFromPoint(x: number, y: number): DomWrapper[];
+    addEventListener(type: string, listener: (event: EventBase) => void, options?: boolean | {
+        once?: boolean;
+    }): void;
+    removeEventListener(type: string, listener: (event: EventBase) => void, useCapture?: boolean): void;
 }
 export {};

package/dist/dom/document.js

@@ -18,6 +18,7 @@ export class DocumentWrapper {
     clearRuntimeStyleSheets() {
         this.#doc.clearRuntimeStyleSheets();
     }
+    // MARK: Create
     createElement(tagName, options) {
         return new DomWrapper(this.#doc.createElement(tagName));
     }
@@ -28,6 +29,10 @@ export class DocumentWrapper {
     createTextNode(text) {
         return new DomWrapper(this.#doc.createTextNode(text));
     }
+    createDocumentFragment() {
+        return this.createElement("div");
+    }
+    // MARK: Query
     getElementById(id) {
         return new DomWrapper(this.#doc.getElementById(id));
     }
@@ -74,4 +79,11 @@ export class DocumentWrapper {
         collect(root);
         return hits; // ordered front‑to‑back (top‑most first)
     }
+    // MARK: Event
+    addEventListener(type, listener, options) {
+        this.body?.addEventListener(type, listener, options);
+    }
+    removeEventListener(type, listener, useCapture) {
+        this.body?.removeEventListener(type, listener, useCapture);
+    }
 }

package/dist/dom/dom.d.ts

@@ -31,19 +31,23 @@ export declare class DomWrapper {
     cachedChildNodes: DomWrapper[] | null;
     boundListeners: WeakMap<WeakKey, any>;
     constructor(dom: CS.OneJS.Dom.Dom);
-    appendChild(child: DomWrapper): void;
+    appendChild(child: DomWrapper): DomWrapper | undefined;
     removeChild(child: DomWrapper): void;
     insertBefore(a: DomWrapper, b: DomWrapper): void;
     insertAfter(a: DomWrapper, b: DomWrapper): void;
-    contains(child: DomWrapper): boolean;
+    before(other: DomWrapper): void;
     clearChildren(): void;
+    setAttribute(name: string, value: any): void;
+    removeAttribute(name: string): void;
+    append(child: DomWrapper): void;
+    cloneNode(deep?: boolean): DomWrapper;
+    remove(): void;
+    contains(child: DomWrapper): boolean;
     focus(): void;
     addEventListener(type: string, listener: (event: EventBase) => void, options?: boolean | {
         once?: boolean;
     }): void;
     removeEventListener(type: string, listener: (event: EventBase) => void, useCapture?: boolean): void;
-    setAttribute(name: string, value: any): void;
-    removeAttribute(name: string): void;
     /**
      * Returns all elements matching the specified selector.
      * Supports basic selectors:

package/dist/dom/dom.js

@@ -48,11 +48,13 @@ export class DomWrapper {
         this.domStyleWrapper = new DomStyleWrapper(dom.style);
         this.domTokenList = new DomTokenList(dom);
     }
+    // MARK: Manipulation
     appendChild(child) {
         if (!child)
             return;
         this.dom.appendChild(child.dom);
         this.cachedChildNodes = null;
+        return child;
     }
     removeChild(child) {
         if (!child)
@@ -68,18 +70,46 @@ export class DomWrapper {
         this.dom.insertAfter(a?._dom, b?._dom);
         this.cachedChildNodes = null;
     }
-    contains(child) {
-        if (!child)
-            return false;
-        return this.dom.contains(child._dom);
+    before(other) {
+        if (this.parentNode) {
+            this.parentNode.insertBefore(other, this);
+        }
     }
     clearChildren() {
         this.dom.clearChildren();
         this.cachedChildNodes = null;
     }
+    setAttribute(name, value) {
+        this.dom.setAttribute(name, value);
+    }
+    removeAttribute(name) {
+        this.dom.removeAttribute(name);
+    }
+    // MARK: Node.prototype
+    append(child) {
+        if (!child)
+            return;
+        this.dom.appendChild(child.dom);
+        this.cachedChildNodes = null;
+    }
+    cloneNode(deep = false) {
+        return this;
+    }
+    remove() {
+        if (this.parentNode) {
+            this.parentNode.removeChild(this);
+        }
+    }
+    // MARK: Misc
+    contains(child) {
+        if (!child)
+            return false;
+        return this.dom.contains(child._dom);
+    }
     focus() {
         this.dom.focus();
     }
+    // MARK: Event
     addEventListener(type, listener, options) {
         let boundListener = this.boundListeners.get(listener);
         if (!boundListener) {
@@ -104,12 +134,6 @@ export class DomWrapper {
             this.boundListeners.delete(listener); // isn't strictly necessary for WeakMap, but still good practice
         }
     }
-    setAttribute(name, value) {
-        this.dom.setAttribute(name, value);
-    }
-    removeAttribute(name) {
-        this.dom.removeAttribute(name);
-    }
     /**
      * Returns all elements matching the specified selector.
      * Supports basic selectors:

package/dist/index.d.ts

@@ -19,4 +19,7 @@ declare global {
         new (...args: any[]): T;
     }, count: number) => CS.System.Array;
     const toJsArray: <T>(csArr: CS.System.Array) => T[];
+    const toCsArray: <T>(jsArr: T[], type: {
+        new (...args: any[]): T;
+    }) => CS.System.Array;
 }

package/dom/document.ts

@@ -1,5 +1,6 @@
 import { Vector2 } from "UnityEngine"
 import { DomWrapper } from "./dom"
+import { EventBase } from "UnityEngine/UIElements"
 
 interface ElementCreationOptions {
     is?: string
@@ -29,6 +30,8 @@ export class DocumentWrapper {
         this.#doc.clearRuntimeStyleSheets()
     }
 
+    // MARK: Create
+
     createElement(tagName: string, options?: ElementCreationOptions): DomWrapper {
         return new DomWrapper(this.#doc.createElement(tagName))
     }
@@ -42,6 +45,12 @@ export class DocumentWrapper {
         return new DomWrapper(this.#doc.createTextNode(text))
     }
 
+    createDocumentFragment(): DomWrapper {
+        return this.createElement("div")
+    }
+
+    // MARK: Query
+
     getElementById(id: string): DomWrapper {
         return new DomWrapper(this.#doc.getElementById(id))
     }
@@ -94,4 +103,14 @@ export class DocumentWrapper {
         collect(root)
         return hits // ordered front‑to‑back (top‑most first)
     }
+
+    // MARK: Event
+
+    addEventListener(type: string, listener: (event: EventBase) => void, options?: boolean | { once?: boolean }) {
+        this.body?.addEventListener(type, listener, options)
+    }
+
+    removeEventListener(type: string, listener: (event: EventBase) => void, useCapture?: boolean) {
+        this.body?.removeEventListener(type, listener, useCapture)
+    }
 }

package/dom/dom.ts

@@ -1,4 +1,4 @@
-import { EventBase } from "UnityEngine/UIElements";
+import { EventBase } from "UnityEngine/UIElements"
 import { DomStyleWrapper } from "./dom-style"
 
 export class DomWrapper {
@@ -6,21 +6,21 @@ export class DomWrapper {
     public get ve(): CS.UnityEngine.UIElements.VisualElement { return this.dom.ve }
     public get childNodes(): DomWrapper[] {
         if (this.cachedChildNodes) return this.cachedChildNodes
-        this.cachedChildNodes = new Array(this.dom.childNodes.Length) as DomWrapper[];
-        var i = this.dom.childNodes.Length;
+        this.cachedChildNodes = new Array(this.dom.childNodes.Length) as DomWrapper[]
+        var i = this.dom.childNodes.Length
         while (i--) {
-            this.cachedChildNodes[i] = new DomWrapper(this.dom.childNodes.get_Item(i));
+            this.cachedChildNodes[i] = new DomWrapper(this.dom.childNodes.get_Item(i))
         }
         return this.cachedChildNodes
     }
     public get firstChild(): DomWrapper | null {
-        return this.dom.firstChild ? new DomWrapper(this.dom.firstChild) : null;
+        return this.dom.firstChild ? new DomWrapper(this.dom.firstChild) : null
     }
     public get parentNode(): DomWrapper | null {
-        return this.dom.parentNode ? new DomWrapper(this.dom.parentNode) : null;
+        return this.dom.parentNode ? new DomWrapper(this.dom.parentNode) : null
     }
     public get nextSibling(): DomWrapper | null {
-        return this.dom.nextSibling ? new DomWrapper(this.dom.nextSibling) : null;
+        return this.dom.nextSibling ? new DomWrapper(this.dom.nextSibling) : null
     }
 
     public get nodeType(): number { return this.dom.nodeType }
@@ -55,10 +55,13 @@ export class DomWrapper {
         this.domTokenList = new DomTokenList(dom)
     }
 
+    // MARK: Manipulation
+
     appendChild(child: DomWrapper) {
         if (!child) return
         this.dom.appendChild(child.dom)
         this.cachedChildNodes = null
+        return child
     }
 
     removeChild(child: DomWrapper) {
@@ -77,9 +80,10 @@ export class DomWrapper {
         this.cachedChildNodes = null
     }
 
-    contains(child: DomWrapper) {
-        if (!child) return false
-        return this.dom.contains(child._dom)
+    before(other: DomWrapper) { // TODO: variable length args
+        if (this.parentNode) {
+            this.parentNode.insertBefore(other, this)
+        }
     }
 
     clearChildren() {
@@ -87,44 +91,71 @@ export class DomWrapper {
         this.cachedChildNodes = null
     }
 
+    setAttribute(name: string, value: any) {
+        this.dom.setAttribute(name, value)
+    }
+
+    removeAttribute(name: string) {
+        this.dom.removeAttribute(name)
+    }
+
+    // MARK: Node.prototype
+
+    append(child: DomWrapper) {
+        if (!child) return
+        this.dom.appendChild(child.dom)
+        this.cachedChildNodes = null
+    }
+
+    cloneNode(deep: boolean = false): DomWrapper {
+        return this
+    }
+
+    remove() {
+        if (this.parentNode) {
+            this.parentNode.removeChild(this)
+        }
+    }
+
+    // MARK: Misc
+
+    contains(child: DomWrapper) {
+        if (!child) return false
+        return this.dom.contains(child._dom)
+    }
+
     focus() {
         this.dom.focus()
     }
 
+    // MARK: Event
+
     addEventListener(type: string, listener: (event: EventBase) => void, options?: boolean | { once?: boolean }) {
-        let boundListener = this.boundListeners.get(listener);
+        let boundListener = this.boundListeners.get(listener)
         if (!boundListener) {
-            boundListener = listener.bind(this);
-            this.boundListeners.set(listener, boundListener);
+            boundListener = listener.bind(this)
+            this.boundListeners.set(listener, boundListener)
         }
 
         if (typeof options === 'object' && options.once) {
             const onceWrapper = (event: EventBase) => {
-                boundListener(event);
-                this.dom.removeEventListener(type, onceWrapper, false);
-            };
-            this.dom.addEventListener(type, onceWrapper, false);
+                boundListener(event)
+                this.dom.removeEventListener(type, onceWrapper, false)
+            }
+            this.dom.addEventListener(type, onceWrapper, false)
         } else {
-            this.dom.addEventListener(type, boundListener, options ? true : false);
+            this.dom.addEventListener(type, boundListener, options ? true : false)
         }
     }
 
     removeEventListener(type: string, listener: (event: EventBase) => void, useCapture?: boolean) {
-        const boundListener = this.boundListeners.get(listener);
+        const boundListener = this.boundListeners.get(listener)
         if (boundListener) {
             this.dom.removeEventListener(type, boundListener, useCapture ? true : false)
-            this.boundListeners.delete(listener); // isn't strictly necessary for WeakMap, but still good practice
+            this.boundListeners.delete(listener) // isn't strictly necessary for WeakMap, but still good practice
         }
     }
 
-    setAttribute(name: string, value: any) {
-        this.dom.setAttribute(name, value)
-    }
-
-    removeAttribute(name: string) {
-        this.dom.removeAttribute(name)
-    }
-
     /**
      * Returns all elements matching the specified selector.
      * Supports basic selectors:
@@ -134,21 +165,21 @@ export class DomWrapper {
      * - Combinations: 'div.myClass#myId'
      */
     querySelectorAll(selector: string): DomWrapper[] {
-        const selectorInfo = parseSelector(selector);
-        const results: DomWrapper[] = [];
+        const selectorInfo = parseSelector(selector)
+        const results: DomWrapper[] = []
 
         function traverse(element: DomWrapper) {
             if (elementMatchesSelector(element, selectorInfo)) {
-                results.push(element);
+                results.push(element)
             }
 
             for (const child of element.childNodes) {
-                traverse(child);
+                traverse(child)
             }
         }
 
-        traverse(this);
-        return results;
+        traverse(this)
+        return results
     }
 
     /**
@@ -156,126 +187,126 @@ export class DomWrapper {
      * Supports the same basic selectors as querySelectorAll.
      */
     querySelector(selector: string): DomWrapper | null {
-        const selectorInfo = parseSelector(selector);
+        const selectorInfo = parseSelector(selector)
 
         function traverse(element: DomWrapper): DomWrapper | null {
             if (elementMatchesSelector(element, selectorInfo)) {
-                return element;
+                return element
             }
 
             for (const child of element.childNodes) {
-                const match = traverse(child);
+                const match = traverse(child)
                 if (match) {
-                    return match;
+                    return match
                 }
             }
 
-            return null;
+            return null
         }
 
-        return traverse(this);
+        return traverse(this)
     }
 }
 
 interface SelectorInfo {
-    tag?: string;
-    id?: string;
-    classes: string[];
+    tag?: string
+    id?: string
+    classes: string[]
 }
 
 function parseSelector(selector: string): SelectorInfo {
     const selectorInfo: SelectorInfo = {
         classes: []
-    };
+    }
 
     // Handle ID
-    const idMatch = selector.match(/#([^.#\s]+)/);
+    const idMatch = selector.match(/#([^.#\s]+)/)
     if (idMatch) {
-        selectorInfo.id = idMatch[1];
-        selector = selector.replace(idMatch[0], '');
+        selectorInfo.id = idMatch[1]
+        selector = selector.replace(idMatch[0], '')
     }
 
     // Handle classes
-    const classMatches = selector.match(/\.([^.#\s]+)/g);
+    const classMatches = selector.match(/\.([^.#\s]+)/g)
     if (classMatches) {
-        selectorInfo.classes = classMatches.map(c => c.substring(1));
-        selector = selector.replace(/\.[^.#\s]+/g, '');
+        selectorInfo.classes = classMatches.map(c => c.substring(1))
+        selector = selector.replace(/\.[^.#\s]+/g, '')
     }
 
     // Handle tag name (what's left after removing id and classes)
-    const tagName = selector.trim();
+    const tagName = selector.trim()
     if (tagName) {
-        selectorInfo.tag = tagName.toLowerCase();
+        selectorInfo.tag = tagName.toLowerCase()
     }
 
-    return selectorInfo;
+    return selectorInfo
 }
 
 function elementMatchesSelector(element: DomWrapper, selectorInfo: SelectorInfo): boolean {
     // Check tag name
     if (selectorInfo.tag && element.ve.GetType().Name.toLowerCase() !== selectorInfo.tag) {
-        return false;
+        return false
     }
 
     // Check ID
     if (selectorInfo.id && element.Id !== selectorInfo.id) {
-        return false;
+        return false
     }
 
     // Check classes
     if (selectorInfo.classes.length > 0) {
-        const elementClasses = element.className.split(' ').filter(c => c);
+        const elementClasses = element.className.split(' ').filter(c => c)
         for (const className of selectorInfo.classes) {
             if (!elementClasses.includes(className)) {
-                return false;
+                return false
             }
         }
     }
 
-    return true;
+    return true
 }
 
 export function querySelectorAll(root: DomWrapper, selector: string): DomWrapper[] {
-    const results: DomWrapper[] = [];
-    const selectorInfo = parseSelector(selector);
+    const results: DomWrapper[] = []
+    const selectorInfo = parseSelector(selector)
 
     function traverse(element: DomWrapper) {
         // Check if current element matches
         if (elementMatchesSelector(element, selectorInfo)) {
-            results.push(element);
+            results.push(element)
         }
 
         // Recursively check children
         for (const child of element.childNodes) {
-            traverse(child);
+            traverse(child)
         }
     }
 
-    traverse(root);
-    return results;
+    traverse(root)
+    return results
 }
 
 export function querySelector(root: DomWrapper, selector: string): DomWrapper | null {
-    const selectorInfo = parseSelector(selector);
+    const selectorInfo = parseSelector(selector)
 
     function traverse(element: DomWrapper): DomWrapper | null {
         // Check if current element matches
         if (elementMatchesSelector(element, selectorInfo)) {
-            return element;
+            return element
         }
 
         // Recursively check children
         for (const child of element.childNodes) {
-            const match = traverse(child);
+            const match = traverse(child)
             if (match) {
-                return match;
+                return match
             }
         }
 
-        return null;
+        return null
     }
 
-    return traverse(root);
+    return traverse(root)
 }
 
 class DomTokenList {

package/index.ts

@@ -44,6 +44,7 @@ declare global {
     }
     const newCsArray: <T>(type: { new(...args: any[]): T }, count: number) => CS.System.Array
     const toJsArray: <T>(csArr: CS.System.Array) => T[]
+    const toCsArray: <T>(jsArr: T[], type: { new(...args: any[]): T }) => CS.System.Array
 }
 
 if (typeof globalThis.___document != "undefined") {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "onejs-core",
     "description": "The JS part of OneJS, a UI framework and Scripting Engine for Unity.",
-    "version": "2.0.21",
+    "version": "3.0.0",
     "repository": {
         "type": "git",
         "url": "https://github.com/Singtaa/onejs-core"