@amodx/ncs 0.0.22 → 0.0.23

package/Components/Component.types.d.ts

@@ -67,8 +67,9 @@ export type ComponentRegisterData<ComponentSchema extends object = any, Data ext
      * It is up to the graph though when it gets called.
      *
      * @param component - The instance of the component being updated.
+     * @param delta - The time since the last update
      */
-    update?(component: ComponentCursor<ComponentSchema, Data, Shared>): void;
+    update?(component: ComponentCursor<ComponentSchema, Data, Shared>, delta: number): void;
     /**
      * Optional disposal function for the component.
      *

package/Components/ComponentArray.d.ts

@@ -24,7 +24,7 @@ export declare class ComponentArray {
     constructor(graph: Graph, numberTypeId: number);
     addComponent(node: number, schema: any | null, schemaView: string | null): number;
     removeComponent(index: number): number | null;
-    update(): void;
+    update(delta: number): void;
     init(index: number): boolean;
 }
 export {};

package/Components/ComponentArray.js

@@ -60,7 +60,7 @@ export class ComponentArray {
             this.schemaArray.removeData(index);
         return nodeIndex;
     }
-    update() {
+    update(delta) {
         const update = this.proto.update;
         if (!update)
             return;
@@ -68,7 +68,7 @@ export class ComponentArray {
             if (this._disposed[i])
                 continue;
             this._componentCursor.setInstance(this._nodeCursor.setNode(this.graph, this._node[i]), this.numberTypeId, i);
-            update(this._componentCursor);
+            update(this._componentCursor, delta);
         }
     }
     init(index) {

package/Components/ComponentCursor.d.ts

@@ -5,6 +5,9 @@ import { ComponentArray } from "./ComponentArray";
 export declare class ComponentCursor<ComponentSchema extends object = {}, Data extends any = any, Shared extends any = any> {
     static Get(): ComponentCursor<{}, any, any>;
     static Retrun(cursor: ComponentCursor): boolean;
+    /**The index of the parent node in the node array */
+    get nodeIndex(): number;
+    /**The index in the component array */
     get index(): number;
     get type(): string;
     get shared(): Shared;
@@ -23,5 +26,5 @@ export declare class ComponentCursor<ComponentSchema extends object = {}, Data e
     dispose(): void;
     returnCursor(): boolean;
     cloneCursor(cursor?: ComponentCursor, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
-    update(): void;
+    update(delta: number): void;
 }

package/Components/ComponentCursor.js

@@ -11,6 +11,11 @@ export class ComponentCursor {
     static Retrun(cursor) {
         return NCSPools.componentCursor.addItem(cursor);
     }
+    /**The index of the parent node in the node array */
+    get nodeIndex() {
+        return this.node.index;
+    }
+    /**The index in the component array */
     get index() {
         return this._index;
     }
@@ -66,7 +71,7 @@ export class ComponentCursor {
         newCursor.setInstance(newNodeCursor, this.typeId, this._index);
         return newCursor;
     }
-    update() {
-        this.__proto.update && this.__proto.update(this);
+    update(delta) {
+        this.__proto.update && this.__proto.update(this, delta);
     }
 }

package/Data/serializeComponent.js

@@ -10,7 +10,7 @@ export function serializeComponentData(data) {
 export function serializeComponent(component) {
     return {
         type: component.type,
-        ...(component.schema ? { schema: component.schema.toJSON() } : {}),
+        ...(component.schema?.__cursor?.data ? { schema: component.schema.toJSON() } : {}),
         ...(component.schema?.__view && component.schema?.__view.id !== "default"
             ? { schemaViewId: component.schema.__view.id }
             : {}),

package/Data/serializeNode.js

@@ -1,9 +1,35 @@
 import { NodeId } from "../Nodes/NodeId";
-import { createRemoteComponent, serializeComponent, } from "./serializeComponent";
+import { createRemoteComponent, serializeComponent, serializeComponentData, } from "./serializeComponent";
+import { NCSRegister } from "../Register/NCSRegister";
 export function serializeNodeData(data) {
-    return {
+    const nodeData = {
         name: data[1],
     };
+    if (typeof data[0] == "string") {
+        nodeData.id = data[0];
+    }
+    if (typeof data[0] == "bigint") {
+        nodeData.id = NodeId.ToHexString(data[0]);
+    }
+    if (data[2]) {
+        nodeData.components = [];
+        for (const comp of data[2]) {
+            nodeData.components.push(serializeComponentData(comp));
+        }
+    }
+    if (data[3]) {
+        nodeData.tags = [];
+        for (const tag of data[3]) {
+            nodeData.tags.push(NCSRegister.tags.get(tag).id);
+        }
+    }
+    if (data[4]) {
+        nodeData.children = [];
+        for (const child of data[4]) {
+            nodeData.children.push(serializeNodeData(child));
+        }
+    }
+    return nodeData;
 }
 /** Serialize the node data as is for storage*/
 export function serializeNode(node) {

package/Graphs/Graph.d.ts

@@ -18,5 +18,6 @@ export declare class Graph {
     getNodeFromId(id: bigint | string, cursor?: NodeCursor): NodeCursor;
     addNode(data: CreateNodeData, parent?: number, cursor?: NodeCursor): NodeCursor;
     removeNode(index: number): boolean;
+    private _lastTime;
     update(): void;
 }

package/Graphs/Graph.js

@@ -3,11 +3,9 @@ import { NodeArray } from "../Nodes/NodeArray";
 import { NodeCursor } from "../Nodes/NodeCursor";
 import { ContextArray } from "../Contexts/ContextArray";
 import { NCSPools } from "../Pools/NCSPools";
-const parentCursor = NodeCursor.Get();
-const nodeCursor = NodeCursor.Get();
 function createNode(graph, data, parent) {
     const newNode = graph._nodes.addNode(typeof data[0] == "string" ? NodeId.FromString(data[0]) : data[0], parent, data[1]);
-    nodeCursor.graph = graph;
+    const nodeCursor = NodeCursor.Get();
     nodeCursor.setNode(graph, newNode);
     if (data[2]?.length) {
         for (let i = 0; i < data[2].length; i++) {
@@ -20,8 +18,10 @@ function createNode(graph, data, parent) {
         }
     }
     if (parent >= 0) {
+        const parentCursor = NodeCursor.Get();
         parentCursor.setNode(graph, parent);
         parentCursor.addChild(nodeCursor);
+        parentCursor.returnCursor();
     }
     if (data[4]?.length) {
         for (let i = 0; i < data[4].length; i++) {
@@ -49,23 +49,25 @@ export class Graph {
         const rootIndex = this._nodes.addNode(null, -1, "root");
         this.root.setNode(this, rootIndex);
     }
-    getNode(index, cursor = nodeCursor) {
+    getNode(index, cursor = NodeCursor.Get()) {
         const parentIndex = this._nodes._parents[index];
         if (typeof parentIndex === "undefined")
-            throw new Error(`Node with index ${index} does not exist`);
+            throw new Error(`NCS: Node with index ${index} does not exist`);
         cursor.setNode(this, index);
         return cursor;
     }
-    getNodeFromId(id, cursor = nodeCursor) {
+    getNodeFromId(id, cursor = NodeCursor.Get()) {
         if (typeof id == "string")
             id = NodeId.FromString(id);
         const nodeIndex = this._nodes._idMap.get(id);
         if (typeof nodeIndex === "undefined")
-            throw new Error(`Node with id ${id} does not exist`);
+            throw new Error(`NCS: Node with id ${id} does not exist`);
         cursor.setNode(this, nodeIndex);
         return cursor;
     }
-    addNode(data, parent = this.root.index, cursor = nodeCursor) {
+    addNode(data, parent = this.root.index, cursor = NodeCursor.Get()) {
+        if (typeof parent !== "number")
+            throw new Error(`NCS: Passed in invalid parent ${parent} in graph.addNode`);
         const newNode = createNode(this, data, parent);
         if (newNode.hasComponents) {
             const components = newNode.components.components;
@@ -82,6 +84,7 @@ export class Graph {
             }
         }
         newNode.toRef(cursor);
+        newNode.returnCursor();
         return cursor;
     }
     removeNode(index) {
@@ -90,12 +93,20 @@ export class Graph {
             return false;
         return true;
     }
+    _lastTime = 0;
     update() {
+        if (this._lastTime == 0) {
+            this._lastTime = performance.now();
+            return;
+        }
+        const current = performance.now();
+        const delta = current - this._lastTime;
+        this._lastTime = current;
         for (let i = 0; i < this._updatingComponents.length; i++) {
-            this._updatingComponents[i].update();
+            this._updatingComponents[i].update(delta);
         }
         for (let i = 0; i < this._systems.length; i++) {
-            this._systems[i].update();
+            this._systems[i].update(delta);
         }
     }
 }

package/NCS.d.ts

@@ -12,7 +12,14 @@ import { deserializeComponentData } from "./Data/deserializeComponent";
 import { cloneNode, copyNode, createRemoteNode, serializeNode, serializeNodeData } from "./Data/serializeNode";
 import { deserializeNodeData } from "./Data/deserializeNode";
 import { ExtractSchemaClass, SchemaCreateData, SchemaProperty } from "./Schema/Schema.types";
+import { NodeCursor } from "./Nodes/NodeCursor";
+import { ComponentCursor } from "./Components/ComponentCursor";
+import { SerializedNodeData } from "./Data/SerializedData.types";
 export declare const NCS: {
+    Debug: {
+        logNode(node: NodeCursor): void;
+        output(node: NodeCursor): [index: number, data: SerializedNodeData];
+    };
     /** Create a graph. */
     createGraph(): Graph;
     /** Create node data to add a node to a graph. */
@@ -31,30 +38,30 @@ export declare const NCS: {
     registerSystem: typeof registerSystem;
     /** Register a component for use with NCS. */
     registerComponent: <Data extends unknown = any, Shared extends unknown = any, ComponentSchema extends object = any>(data: import("./Components/Component.types").ComponentRegisterData<ComponentSchema, Data, Shared>) => import("./Components/Component.types").ComponentRegisterData<ComponentSchema, Data, Shared> & {
-        getNodes(grpah: Graph): Generator<import(".").NodeCursor>;
-        getComponents(grpah: Graph): Generator<import(".").ComponentCursor<ComponentSchema, Data, Shared>, any, any>;
-        set(node: import(".").NodeCursor, componentSchema?: import("./Util/Util.types").Nullable<Partial<ComponentSchema>> | undefined, schemaCursor?: import("./Util/Util.types").Nullable<import("./Schema/Schema.types").SchemaCursor<ComponentSchema>> | undefined, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
-        has(node: import(".").NodeCursor): boolean;
-        get(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
-        getRequired(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
-        getChild(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
-        getRequiredChild(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
-        getParent(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
-        getRequiredParent(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
-        getAll(node: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>[] | null;
-        remove(node: import(".").NodeCursor): boolean;
-        removeAll(node: import(".").NodeCursor): boolean;
+        getNodes(grpah: Graph): Generator<NodeCursor>;
+        getComponents(grpah: Graph): Generator<ComponentCursor<ComponentSchema, Data, Shared>, any, any>;
+        set(node: NodeCursor, componentSchema?: import("./Util/Util.types").Nullable<Partial<ComponentSchema>> | undefined, schemaCursor?: import("./Util/Util.types").Nullable<import("./Schema/Schema.types").SchemaCursor<ComponentSchema>> | undefined, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined): ComponentCursor<ComponentSchema, Data, Shared>;
+        has(node: NodeCursor): boolean;
+        get(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared> | null;
+        getRequired(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
+        getChild(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared> | null;
+        getRequiredChild(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
+        getParent(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared> | null;
+        getRequiredParent(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
+        getAll(node: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>[] | null;
+        remove(node: NodeCursor): boolean;
+        removeAll(node: NodeCursor): boolean;
         nodeData: {
-            get(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema> | null;
-            set(node: import(".").SerializedNodeData, componentSchema?: Partial<ComponentSchema> | undefined): void;
-            getAll(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema>[] | null;
-            remove(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema> | null;
-            removeAll(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema>[] | null;
+            get(node: SerializedNodeData): import("./Data/SerializedData.types").SerializedComponentData<ComponentSchema> | null;
+            set(node: SerializedNodeData, componentSchema?: Partial<ComponentSchema> | undefined): void;
+            getAll(node: SerializedNodeData): import("./Data/SerializedData.types").SerializedComponentData<ComponentSchema>[] | null;
+            remove(node: SerializedNodeData): import("./Data/SerializedData.types").SerializedComponentData<ComponentSchema> | null;
+            removeAll(node: SerializedNodeData): import("./Data/SerializedData.types").SerializedComponentData<ComponentSchema>[] | null;
         };
         type: string;
         typeId: number;
         data: import("./Components/Component.types").ComponentRegisterData<ComponentSchema, Data, Shared>;
-        default: import(".").ComponentCursor<ComponentSchema, Data, Shared>;
+        default: ComponentCursor<ComponentSchema, Data, Shared>;
     } & ((schema?: Partial<ComponentSchema> | null | undefined, schemaView?: string | null) => CreateComponentData<ComponentSchema>);
     /** Register a context for use with NCS. */
     registerContext: typeof registerContext;

package/NCS.js

@@ -12,6 +12,7 @@ import { deserializeComponentData } from "./Data/deserializeComponent";
 import { cloneNode, copyNode, createRemoteNode, serializeNode, serializeNodeData, } from "./Data/serializeNode";
 import { deserializeNodeData } from "./Data/deserializeNode";
 import { SchemaProperty, } from "./Schema/Schema.types";
+import { ComponentCursor } from "./Components/ComponentCursor";
 function traverseCreateSchema(obj, parent) {
     parent.children ??= [];
     for (const key in obj) {
@@ -45,7 +46,21 @@ function traverseCreateSchema(obj, parent) {
     }
     return parent;
 }
+const Debug = {
+    logNode(node) {
+        console.log("log node", node.index);
+        const temp = ComponentCursor.Get();
+        for (const comp of node.traverseComponents(temp)) {
+            console.log(comp.type, comp.schema && comp.schema.toJSON());
+        }
+        temp.returnCursor();
+    },
+    output(node) {
+        return [node.index, serializeNode(node)];
+    },
+};
 export const NCS = {
+    Debug,
     /** Create a graph. */
     createGraph() {
         return new Graph();

package/Nodes/NodeArray.d.ts

@@ -18,6 +18,7 @@ export declare class NodeArray {
     _disposed: boolean[];
     _enabled: boolean[];
     _hasObservers: boolean[];
+    private _count;
     addNode(id: bigint | null, parent: number, name: string): number;
     removeNode(slot: number): boolean;
     addNodeId(index: number, id: bigint): void;

package/Nodes/NodeArray.js

@@ -26,10 +26,13 @@ export class NodeArray {
     _disposed = [];
     _enabled = [];
     _hasObservers = [];
+    _count = 0;
     addNode(id, parent, name) {
-        let slot = this._freeSlots.length
-            ? this._freeSlots.shift()
-            : this._parents.length;
+        let slot = this._freeSlots.shift();
+        if (slot === undefined) {
+            slot = this._count;
+            this._count++;
+        }
         id && this.addNodeId(slot, id);
         this._parents[slot] = parent;
         this._names[slot] = name;
@@ -39,25 +42,28 @@ export class NodeArray {
         return slot;
     }
     removeNode(slot) {
-        if (this._parents[slot] === undefined)
+        if (this._parents[slot] === -1)
             return false;
         this._freeSlots.push(slot);
         this._indexMap[slot] && this.removeNodeId(this._indexMap[slot]);
-        this._parents[slot] = -1;
+        this._parents[slot] = 0;
         this._names[slot] = "";
         this._disposed[slot] = true;
         this._enabled[slot] = false;
         this._hasObservers[slot] = false;
-        for (let i = 0; i < observerValues.length; i++) {
-            const observer = this._observers[i][slot];
+        for (let j = 0; j < observerValues.length; j++) {
+            const key = observerValues[j];
+            const observer = this._observers[key]?.[slot];
             if (observer !== undefined) {
+                observer.clear();
                 NCSPools.observers.addItem(observer);
-                this._events[i][slot] = undefined;
+                this._observers[key][slot] = undefined;
             }
         }
         for (let i = 0; i < this._eventPalette.size; i++) {
             const observer = this._events[i][slot];
             if (observer !== undefined) {
+                observer.clear();
                 NCSPools.observers.addItem(observer);
                 this._events[i][slot] = undefined;
             }

package/Nodes/NodeComponents.js

@@ -3,7 +3,6 @@ import { NodeCursor } from "./NodeCursor";
 import { NCSRegister } from "../Register/NCSRegister";
 import { ComponentArray } from "../Components/ComponentArray";
 import { NCSPools } from "../Pools/NCSPools";
-const defaultCursor = ComponentCursor.Get();
 export class NodeComponents {
     static Get() {
         const cursor = NCSPools.nodeComponents.get();
@@ -23,10 +22,12 @@ export class NodeComponents {
         if (!this.components)
             return;
         const components = this.components;
+        const tempCursor = ComponentCursor.Get();
         for (let i = 0; i < components.length; i += 2) {
-            defaultCursor.setInstance(this.node, components[i], components[i + 1]);
-            defaultCursor.dispose();
+            tempCursor.setInstance(this.node, components[i], components[i + 1]);
+            tempCursor.dispose();
         }
+        tempCursor.returnCursor();
     }
     add(comp) {
         if (!this.components) {
@@ -63,13 +64,15 @@ export class NodeComponents {
         NCSPools.createComponentData.addItem(comp);
         this.components.push(typeId, componentIndex);
         compArray.observers.nodeAdded.notify(this.node.index);
+        const temp = ComponentCursor.Get();
         if (this.node.hasObservers) {
-            defaultCursor.setInstance(this.node, typeId, componentIndex);
+            temp.setInstance(this.node, typeId, componentIndex);
             this.node.observers.isComponentAddedSet &&
-                this.node.observers.componentAdded.notify(defaultCursor);
+                this.node.observers.componentAdded.notify(temp);
             this.node.observers.isComponentsUpdatedSet &&
-                this.node.observers.componentsUpdated.notify(defaultCursor);
+                this.node.observers.componentsUpdated.notify(temp);
         }
+        temp.returnCursor();
         return componentIndex;
     }
     remove(type) {
@@ -88,15 +91,17 @@ export class NodeComponents {
         }
         if (removeIndex == -1)
             return;
-        defaultCursor.setInstance(this.node, numberId, removeComponentIndex);
+        const temp = ComponentCursor.Get();
+        temp.setInstance(this.node, numberId, removeComponentIndex);
         this.components.splice(removeIndex, 2);
         if (this.node.hasObservers) {
             this.node.observers.isComponentRemovedSet &&
-                this.node.observers.componentRemoved.notify(defaultCursor);
+                this.node.observers.componentRemoved.notify(temp);
             this.node.observers.isComponentsUpdatedSet &&
-                this.node.observers.componentsUpdated.notify(defaultCursor);
+                this.node.observers.componentsUpdated.notify(temp);
         }
-        defaultCursor.dispose();
+        temp.dispose();
+        temp.returnCursor();
         return true;
     }
     has(type) {
@@ -118,8 +123,7 @@ export class NodeComponents {
         const numberId = NCSRegister.components.idPalette.getNumberId(type);
         for (let i = 0; i < components.length; i += 2) {
             if (components[i] == numberId) {
-                if (nodeCursor !== this.node)
-                    this.node.cloneCursor(nodeCursor);
+                nodeCursor.setNode(this.node.graph, this.node.index);
                 cursor.setInstance(nodeCursor, numberId, components[i + 1]);
                 return cursor;
             }
@@ -146,38 +150,49 @@ export class NodeComponents {
         if (!components)
             return false;
         const numberId = NCSRegister.components.idPalette.getNumberId(type);
+        const tempCursor = ComponentCursor.Get();
         for (let i = components.length; i > 0; i -= 2) {
             if (components[i] == numberId) {
-                defaultCursor.setInstance(this.node, components[i], components[i + 1]);
+                tempCursor.setInstance(this.node, components[i], components[i + 1]);
                 this.components.splice(i, 2);
                 if (this.node.hasObservers) {
                     this.node.observers.isComponentRemovedSet &&
-                        this.node.observers.componentRemoved.notify(defaultCursor);
+                        this.node.observers.componentRemoved.notify(tempCursor);
                     this.node.observers.isComponentsUpdatedSet &&
-                        this.node.observers.componentsUpdated.notify(defaultCursor);
+                        this.node.observers.componentsUpdated.notify(tempCursor);
                 }
             }
         }
+        tempCursor.returnCursor();
         return true;
     }
     getChild(type, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
-        for (const child of this.node.traverseChildren()) {
+        const tempCursor = NodeCursor.Get();
+        for (const child of this.node.traverseChildren(tempCursor)) {
             if (!child.components)
                 continue;
+            nodeCursor.setNode(this.node.graph, child.index);
             const found = child.components.get(type, cursor, nodeCursor);
-            if (found)
+            if (found) {
+                tempCursor.returnCursor();
                 return found;
+            }
         }
+        tempCursor.returnCursor();
         return null;
     }
     getParent(type, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
-        for (const parent of this.node.traverseParents()) {
+        const tempCursor = NodeCursor.Get();
+        for (const parent of this.node.traverseParents(tempCursor)) {
             if (!parent.components)
                 continue;
             const found = parent.components.get(type, cursor, nodeCursor);
-            if (found)
+            if (found) {
+                tempCursor.returnCursor();
                 return found;
+            }
         }
+        tempCursor.returnCursor();
         return null;
     }
 }

package/Nodes/NodeCursor.d.ts

@@ -13,7 +13,6 @@ export declare class NodeCursor {
     static Retrun(cursor: NodeCursor): void;
     clear(events: boolean, context: boolean, observers: boolean, compoents: boolean, tags: boolean): void;
     get index(): number;
-    get parentIndex(): number;
     get id(): bigint | null;
     get name(): string;
     private _events;
@@ -50,16 +49,17 @@ export declare class NodeCursor {
     /** Traverse all the node's parents */
     traverseParents(cursor?: NodeCursor): Generator<NodeCursor>;
     /** Traverse all the node's components */
-    traverseComponents(cursor?: ComponentCursor<{}, any, any>): Generator<ComponentCursor>;
+    traverseComponents(cursor?: ComponentCursor): Generator<ComponentCursor>;
     /** Traverse all the node's tags */
     traverseTags(cursor?: TagCursor): Generator<TagCursor>;
     dispose(): void;
     hasChild(node: NodeCursor): boolean;
     parentTo(nodeToParentTo: NodeCursor): void;
     getChild(index: number, cursor?: NodeCursor): NodeCursor | null;
-    addChild(node: NodeCursor): void;
-    removeChild(index: number): number | null | undefined;
-    addUniqueId(): bigint;
+    getChildIndex(node: NodeCursor | number): number;
+    addChild(node: NodeCursor): number;
+    removeChild(index: number): number | undefined;
+    uniqueId(): bigint;
     returnCursor(): void;
     cloneCursor(cursor?: NodeCursor): NodeCursor;
 }

package/Nodes/NodeCursor.js

@@ -15,17 +15,20 @@ export class NodeCursor {
         return cursor;
     }
     static Retrun(cursor) {
-        cursor.clear(cursor.hasEvents, cursor.hasContexts, cursor.hasObservers, cursor.hasComponents, cursor.hasTags);
+        if (cursor.index !== -1) {
+            cursor.clear(cursor.hasEvents, cursor.hasContexts, cursor.hasObservers, cursor.hasComponents, cursor.hasTags);
+        }
         NCSPools.nodeCursor.addItem(cursor);
     }
     clear(events, context, observers, compoents, tags) {
+        this._index = -1;
         if (events && this._events) {
             NodeEvents.Retrun(this._events);
             this._events = null;
         }
-        if (context && this._components) {
-            NodeComponents.Retrun(this._components);
-            this._components = null;
+        if (context && this._context) {
+            NodeContext.Retrun(this._context);
+            this._context = null;
         }
         if (observers && this._observers) {
             NodeObservers.Retrun(this._observers);
@@ -43,9 +46,6 @@ export class NodeCursor {
     get index() {
         return this._index;
     }
-    get parentIndex() {
-        return this.arrays._parents[this._index];
-    }
     get id() {
         return this.graph._nodes._indexMap[this.index] || null;
     }
@@ -132,7 +132,7 @@ export class NodeCursor {
     get isDisposed() {
         return this.arrays._disposed[this._index];
     }
-    _index = 0;
+    _index = -1;
     constructor() { }
     setNode(graph, index) {
         this._index = index;
@@ -170,21 +170,39 @@ export class NodeCursor {
         return cursor.setNode(this.graph, this.index);
     }
     /** Traverse the node's direct children */
-    *children(cursor = nodeCursor) {
+    *children(cursor) {
         const array = this.childrenArray;
         if (!array)
             return false;
+        const templChildArray = NCSPools.numberArray.get() || [];
         for (let i = 0; i < array.length; i++) {
-            cursor.setNode(this.graph, array[i]);
+            templChildArray[i] = array[i];
+        }
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = NodeCursor.Get();
+        }
+        for (let i = 0; i < templChildArray.length; i++) {
+            cursor.setNode(this.graph, templChildArray[i]);
             yield cursor;
         }
+        templChildArray.length = 0;
+        NCSPools.numberArray.addItem(templChildArray);
+        if (usedTemp)
+            cursor.returnCursor();
         return true;
     }
     /** Traverse all the node's descendants */
-    *traverseChildren(cursor = nodeCursor) {
+    *traverseChildren(cursor) {
         if (!this.childrenArray)
             return false;
         const children = [this.childrenArray];
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = NodeCursor.Get();
+        }
         while (children.length) {
             const childrenArray = children.shift();
             if (!childrenArray)
@@ -197,39 +215,63 @@ export class NodeCursor {
                 }
             }
         }
+        if (usedTemp)
+            cursor.returnCursor();
         return true;
     }
     /** Traverse all the node's parents */
-    *traverseParents(cursor = nodeCursor) {
+    *traverseParents(cursor) {
         let parent = this.parent;
         if (parent === undefined || parent < 0)
             return false;
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = NodeCursor.Get();
+        }
         while (true) {
             cursor.setNode(this.graph, parent);
             yield cursor;
             parent = this.arrays._parents[cursor._index];
-            if (parent === undefined || parent < 0)
+            if (parent === undefined || parent < 0) {
+                if (usedTemp)
+                    cursor.returnCursor();
                 return true;
+            }
         }
     }
     /** Traverse all the node's components */
-    *traverseComponents(cursor = componentCursor) {
+    *traverseComponents(cursor) {
         const components = this.components.components;
-        if (!components)
+        if (!components || !components.length)
             return false;
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = ComponentCursor.Get();
+        }
         for (let i = 0; i < components.length; i += 2) {
             yield cursor.setInstance(this, components[i], components[i + 1]);
         }
+        if (usedTemp)
+            cursor.returnCursor();
         return true;
     }
     /** Traverse all the node's tags */
-    *traverseTags(cursor = tagCursor) {
+    *traverseTags(cursor) {
         const tags = this.tags.tags;
         if (!this.tags)
             return false;
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = TagCursor.Get();
+        }
         for (let i = 0; i < tags.length; i += 2) {
             yield cursor.setTag(this, tags[i], tags[i + 1]);
         }
+        if (usedTemp)
+            cursor.returnCursor();
         return true;
     }
     dispose() {
@@ -238,10 +280,6 @@ export class NodeCursor {
         this.hasObservers &&
             this.observers.isDisposedSet &&
             this.observers.disposed.notify(this);
-        if (this.parent !== undefined) {
-            nodeCursor.setNode(this.graph, this.parent);
-            nodeCursor.removeChild(this.index);
-        }
         if (this.arrays._components[this._index]?.length) {
             this.components.dispose();
         }
@@ -249,10 +287,25 @@ export class NodeCursor {
             this.tags.dispose();
         }
         if (this.childrenArray) {
-            for (let i = 0; i < this.childrenArray.length; i++) {
-                nodeCursor.setNode(this.graph, this.childrenArray[i]);
-                nodeCursor.dispose();
+            const templChildArray = NCSPools.numberArray.get() || [];
+            const children = this.childrenArray;
+            for (let i = 0; i < children.length; i++) {
+                templChildArray[i] = children[i];
+            }
+            const tempCursor = NodeCursor.Get();
+            for (let i = 0; i < templChildArray.length; i++) {
+                tempCursor.setNode(this.graph, templChildArray[i]);
+                tempCursor.dispose();
             }
+            tempCursor.returnCursor();
+            templChildArray.length = 0;
+            NCSPools.numberArray.addItem(templChildArray);
+        }
+        if (this.parent > -1) {
+            const tempCursor = NodeCursor.Get();
+            tempCursor.setNode(this.graph, this.parent);
+            tempCursor.removeChild(tempCursor.getChildIndex(this.index));
+            tempCursor.returnCursor();
         }
         this.graph.removeNode(this.index);
         this.clear(this.hasEvents, this.hasContexts, this.hasObservers, this.hasComponents, this.hasTags);
@@ -267,17 +320,21 @@ export class NodeCursor {
         return false;
     }
     parentTo(nodeToParentTo) {
+        if (this.index == nodeToParentTo.index)
+            throw new Error(`NCS: Tried to parent node ${this.index} ${this.name} to itself`);
         if (nodeToParentTo.hasChild(this))
             return;
-        if (this.parent !== undefined) {
-            nodeCursor.setNode(this.graph, this.parent);
-            nodeCursor.removeChild(this.index);
+        const tempCursor = NodeCursor.Get();
+        if (this.parent > -1) {
+            tempCursor.setNode(this.graph, this.parent);
+            tempCursor.removeChild(tempCursor.getChildIndex(this.index));
         }
         nodeToParentTo.addChild(this);
         this.parent = nodeToParentTo.index;
         this.hasObservers &&
             this.observers.isParentedSet &&
-            nodeToParentTo.observers.parented.notify(nodeCursor);
+            nodeToParentTo.observers.parented.notify(tempCursor);
+        tempCursor.returnCursor();
     }
     getChild(index, cursor = NodeCursor.Get()) {
         const childrenArray = this.childrenArray;
@@ -285,9 +342,18 @@ export class NodeCursor {
             return null;
         return cursor.setNode(this.graph, childrenArray[index]);
     }
+    getChildIndex(node) {
+        let index = typeof node == "number" ? node : node.index;
+        for (let i = 0; i < this.childrenArray.length; i++) {
+            if (this.childrenArray[i] == index) {
+                return i;
+            }
+        }
+        return -1;
+    }
     addChild(node) {
         if (this.hasChild(node))
-            return;
+            return this.getChildIndex(node);
         if (!this.childrenArray) {
             this.arrays._children[this._index] = NCSPools.numberArray.get() || [];
         }
@@ -297,40 +363,39 @@ export class NodeCursor {
             this.observers.isChildAddedSet &&
                 this.observers.childAdded.notify(node);
             this.observers.isChildrenUpdatedSet &&
-                this.observers.childrenUpdated.notify(node);
+                this.observers.childrenUpdated.notify(this);
         }
         if (node.hasObservers) {
             node.observers.isParentedSet && node.observers.parented.notify(node);
         }
+        return this.childrenArray.length - 1;
     }
     removeChild(index) {
-        if (!this.childrenArray)
+        if (!this.childrenArray || !this.childrenArray[index])
             return;
-        for (let i = 0; i < this.childrenArray.length; i++) {
-            if (this.childrenArray[i] == index) {
-                const child = this.childrenArray.splice(i, 1)[0];
-                nodeCursor.setNode(this.graph, child);
-                if (this.hasObservers) {
-                    this.hasObservers &&
-                        this.observers.isChildRemovedSet &&
-                        this.observers.childRemoved.notify(nodeCursor);
-                    this.hasObservers &&
-                        this.observers.isChildrenUpdatedSet &&
-                        this.observers.childrenUpdated.notify(nodeCursor);
-                }
-                if (nodeCursor.hasObservers) {
-                    nodeCursor.observers.isRemovedFromParentSet &&
-                        nodeCursor.observers.removedFromParent.notify(nodeCursor);
-                }
-                return child;
-            }
+        const child = this.childrenArray.splice(index, 1)[0];
+        const tempCursor = NodeCursor.Get();
+        tempCursor.setNode(this.graph, child);
+        if (this.hasObservers) {
+            this.hasObservers &&
+                this.observers.isChildRemovedSet &&
+                this.observers.childRemoved.notify(tempCursor);
+            this.hasObservers &&
+                this.observers.isChildrenUpdatedSet &&
+                this.observers.childrenUpdated.notify(this);
+        }
+        if (tempCursor.hasObservers) {
+            tempCursor.observers.isRemovedFromParentSet &&
+                tempCursor.observers.removedFromParent.notify(tempCursor);
         }
-        return null;
+        tempCursor.returnCursor();
+        return child;
     }
-    addUniqueId() {
+    uniqueId() {
         let id = this.graph._nodes._indexMap[this.index];
-        if (!id)
-            id = NodeId.Create();
+        if (id)
+            return id;
+        id = NodeId.Create();
         this.graph._nodes.addNodeId(this.index, id);
         return id;
     }
@@ -343,6 +408,3 @@ export class NodeCursor {
         return newCursor;
     }
 }
-const componentCursor = ComponentCursor.Get();
-const tagCursor = TagCursor.Get();
-const nodeCursor = NodeCursor.Get();

package/Nodes/NodeTags.js

@@ -1,7 +1,7 @@
+import { TagArray } from "../Tags/TagArray";
 import { NCSPools } from "../Pools/NCSPools";
 import { NCSRegister } from "../Register/NCSRegister";
 import { TagCursor } from "../Tags/TagCursor";
-const tagCursor = TagCursor.Get();
 export class NodeTags {
     node;
     static Get() {
@@ -18,41 +18,63 @@ export class NodeTags {
     }
     constructor() { }
     dispose() {
+        const tempCursor = TagCursor.Get();
         for (let i = 0; i < this.tags.length; i += 2) {
-            tagCursor.setTag(this.node, this.tags[i], this.tags[i + 1]);
-            tagCursor.dispose();
+            tempCursor.setTag(this.node, this.tags[i], this.tags[i + 1]);
+            tempCursor.dispose();
         }
     }
-    add(id, cursor = tagCursor) {
-        const newTag = this.node.graph._tags[id].addTag(this.node.index);
+    add(id, cursor) {
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = TagCursor.Get();
+        }
+        let tagArray = this.node.graph._tags[id];
+        if (!tagArray) {
+            tagArray = new TagArray(NCSRegister.tags.get(id).id);
+            this.node.graph._tags[id] = tagArray;
+        }
+        const newTag = tagArray.addTag(this.node.index);
+        if (!this.node.arrays._tags[this.node.index]) {
+            this.node.arrays._tags[this.node.index] =
+                NCSPools.numberArray.get() || [];
+        }
         this.tags.push(id, newTag);
         cursor.setTag(this.node, id, newTag);
         if (this.node.hasObservers) {
             this.node.observers.isTagsAddedSet &&
                 this.node.observers.tagsAdded.notify(cursor);
         }
+        if (usedTemp)
+            cursor.returnCursor();
         return cursor;
     }
     remove(id) {
         const tagId = NCSRegister.tags.idPalette.getNumberId(id);
         const tags = this.tags;
+        const tempCursor = TagCursor.Get();
         for (let i = 0; i < tags.length; i++) {
             if (tags[i] == tagId) {
-                tagCursor.setTag(this.node, tagId, tags[i]);
-                tagCursor.dispose();
+                tempCursor.setTag(this.node, tagId, tags[i]);
+                tempCursor.dispose();
                 this.tags.splice(i, 2);
                 this.node.hasObservers &&
                     this.node.observers.isTagsRemovedSet &&
-                    this.node.observers.tagsRemoved.notify(tagCursor);
+                    this.node.observers.tagsRemoved.notify(tempCursor);
                 this.node.hasObservers &&
                     this.node.observers.isTagsUpdatedSet &&
                     this.node.observers.tagsUpdated.notify(0);
-                return true;
+                {
+                    tempCursor.returnCursor();
+                    return true;
+                }
             }
         }
+        tempCursor.returnCursor();
         return false;
     }
-    get(type, cursor = tagCursor) {
+    get(type, cursor = TagCursor.Get()) {
         const tagId = NCSRegister.tags.idPalette.getNumberId(type);
         const tags = this.tags;
         for (let i = 0; i < tags.length; i += 2) {
@@ -63,7 +85,7 @@ export class NodeTags {
         }
         return null;
     }
-    getChild(type, cursor = tagCursor) {
+    getChild(type, cursor = TagCursor.Get()) {
         for (const child of this.node.traverseChildren()) {
             const found = child.tags.get(type, cursor);
             if (found)
@@ -81,7 +103,7 @@ export class NodeTags {
         }
         return tags;
     }
-    getParent(type, cursor = tagCursor) {
+    getParent(type, cursor = TagCursor.Get()) {
         for (const parent of this.node.traverseParents()) {
             const found = parent.tags.get(type, cursor);
             if (found)
@@ -91,12 +113,14 @@ export class NodeTags {
     }
     getAllParents(type) {
         const tags = [];
+        const temp = TagCursor.Get();
         for (const child of this.node.traverseParents()) {
-            const found = child.tags.get(type, tagCursor);
+            const found = child.tags.get(type, temp);
             if (found) {
                 tags.push(TagCursor.Get().setTag(this.node, found.typeId, found.index));
             }
         }
+        temp.returnCursor();
         return tags;
     }
 }

package/Register/NCSRegister.js

@@ -11,7 +11,7 @@ class ItemRegister {
             ? this.items[this.idPalette.getNumberId(id)]
             : this.items[id];
         if (!item)
-            throw new Error(`[${this.itemtype}]: Entry with id ${id} does not exist`);
+            throw new Error(`NCS: [${this.itemtype}]: Entry with id ${id} does not exist`);
         return item;
     }
     has(id) {

package/Register/registerComponent.js

@@ -24,7 +24,6 @@ export const registerComponent = (data) => {
                 nodeCursor.setNode(graph, array._node[i]);
                 yield nodeCursor;
             }
-            NodeCursor.Retrun(nodeCursor);
             return true;
         },
         *getComponents(graph, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
@@ -36,8 +35,6 @@ export const registerComponent = (data) => {
                 cursor.setInstance(nodeCursor, typeId, i);
                 yield cursor;
             }
-            ComponentCursor.Retrun(cursor);
-            NodeCursor.Retrun(nodeCursor);
             return true;
         },
         set(node, schema, schemaView, cursor = ComponentCursor.Get()) {
@@ -55,7 +52,7 @@ export const registerComponent = (data) => {
         getRequired(node, cursor, nodeCursor) {
             const found = node.components.get(data.type, cursor, nodeCursor);
             if (!found)
-                throw new Error(`Node [${node.name}] does not have required component [${data.type}].`);
+                throw new Error(`NCS: Node [${node.name}] does not have required component [${data.type}].`);
             return found;
         },
         getChild(node, cursor, nodeCursor) {
@@ -64,7 +61,7 @@ export const registerComponent = (data) => {
         getRequiredChild(node, cursor, nodeCursor) {
             const comp = node.components.getChild(data.type, cursor, nodeCursor);
             if (!comp)
-                throw new Error(`Node [${node.name}] does not have a child with required component [${data.type}].`);
+                throw new Error(`NCS: Node [${node.name}] does not have a child with required component [${data.type}].`);
             return comp;
         },
         getParent(node, cursor, nodeCursor) {
@@ -73,7 +70,7 @@ export const registerComponent = (data) => {
         getRequiredParent(node, cursor, nodeCursor) {
             const comp = node.components.getParent(data.type, cursor, nodeCursor);
             if (!comp)
-                throw new Error(`Node [${node.name}] does not have a parent with required component [${data.type}].`);
+                throw new Error(`NCS: Node [${node.name}] does not have a parent with required component [${data.type}].`);
             return comp;
         },
         getAll(node) {

package/Register/registerContext.js

@@ -27,7 +27,7 @@ export function registerContext(data) {
         getRequired: (parent) => {
             const found = parent.context.get(data.type);
             if (!found)
-                throw new Error(`Could not find required context type: ${data.type}`);
+                throw new Error(`NCS: Could not find required context type: ${data.type}`);
             return found;
         },
         remove: (parent) => {

package/Register/registerTag.js

@@ -1,17 +1,43 @@
 import { NCSRegister } from "./NCSRegister";
+import { NodeCursor } from "../Nodes/NodeCursor";
 import { TagCursor } from "../Tags/TagCursor";
 import { Tag } from "../Tags/Tag";
 export function registerTag(data) {
     const tag = new Tag(null, data);
     const typeId = NCSRegister.tags.register(data.id, tag);
-    // const map = TagInstanceMap.registerTag(tag.id);
     const createTag = () => {
         return typeId;
     };
     return Object.assign(createTag, data, {
         tag,
         data,
-        // getNodes: (graph: Graph) => map.getNodes(graph),
+        *getNodes(graph, nodeCursor = NodeCursor.Get()) {
+            const array = graph._tags[typeId];
+            if (!array)
+                return false;
+            for (let i = 0; i < array._node.length; i++) {
+                const slot = array._node[i];
+                if (slot < 0)
+                    continue;
+                nodeCursor.setNode(graph, array._node[i]);
+                yield nodeCursor;
+            }
+            return true;
+        },
+        *getTags(graph, cursor = TagCursor.Get(), nodeCursor = NodeCursor.Get()) {
+            const array = graph._tags[typeId];
+            if (!array)
+                return false;
+            for (let i = 0; i < array._node.length; i++) {
+                const slot = array._node[i];
+                if (slot < 0)
+                    continue;
+                nodeCursor.setNode(graph, slot);
+                cursor.setTag(nodeCursor, typeId, i);
+                yield cursor;
+            }
+            return true;
+        },
         // getTags: (graph: Graph) => map.getItems(graph),
         getChild(parent, cursor) {
             return parent.tags.getChild(data.id, cursor);

package/Schema/Schema.js

@@ -191,7 +191,7 @@ export class Schema {
             view = new SchemaView(this, data.id, meta, byteOffsets, byteSize, data, this._binaryObjectCursorClass);
         }
         if (!view)
-            throw new Error(`Invalid data`);
+            throw new Error(`NCS: Invalid data`);
         const viewIndex = this.viewIdPalettew.register(data.id);
         this.views[viewIndex] = view;
         return view;

package/Schema/SchemaView.js

@@ -103,7 +103,7 @@ export class SchemaView {
             }
             return current;
         }
-        throw new Error(`Invalid create data`);
+        throw new Error(`NCS: Invalid create data`);
     }
     createCursor() {
         return new this._cursorClass(this, this.meta, this._createData, this.byteOffset);

package/Systems/System.types.d.ts

@@ -12,5 +12,5 @@ export type SystemRegisterData = {
     /**
      * The update function  of the system.
      */
-    update(system: SystemInstance): void;
+    update(system: SystemInstance, delta: number): void;
 };

package/Systems/SystemInstance.d.ts

@@ -8,6 +8,6 @@ export declare class SystemInstance {
     queries: QueryInstance[];
     node: NodeCursor;
     constructor(graph: Graph, proto: SystemRegisterData);
-    update(): void;
+    update(delta: number): void;
     dispose(): void;
 }

package/Systems/SystemInstance.js

@@ -12,8 +12,8 @@ export class SystemInstance {
         }
         this.graph._systems.push(this);
     }
-    update() {
-        this.proto.update(this);
+    update(delta) {
+        this.proto.update(this, delta);
     }
     dispose() {
         for (let i = 0; i < this.graph._systems.length; i++) {

package/Tags/TagCursor.d.ts

@@ -17,4 +17,5 @@ export declare class TagCursor {
     setTag(node: NodeCursor, type: number, index: number): this;
     dispose(): true | null;
     toJSON(): string;
+    returnCursor(): void;
 }

package/Tags/TagCursor.js

@@ -42,4 +42,7 @@ export class TagCursor {
     toJSON() {
         return this.id;
     }
+    returnCursor() {
+        TagCursor.Retrun(this);
+    }
 }

package/package.json

@@ -1,27 +1 @@
-{
-  "name": "@amodx/ncs",
-  "version": "0.0.22",
-  "module": "index.js",
-  "types": "index.d.ts",
-  "type": "module",
-  "description": "NCS (Node Component System) is a library for the base of any NCS/ECS system.",
-  "keywords": [],
-  "scripts": {
-    "build": "mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cd ./src && npx tsc",
-    "compile": "cd ./src && npx tsc --watch"
-  },
-  "repository": {
-    "url": "git+https://github.com/Amodx/Libraries.git"
-  },
-  "bugs": {
-    "url": "https://github.com/Amodx/Libraries/issues"
-  },
-  "homepage": "https://github.com/Amodx/Libraries",
-  "author": "Amodx",
-  "license": "MIT",
-  "devDependencies": {},
-  "main": "index.js",
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{"name":"@amodx/ncs","version":"0.0.23","module":"index.js","types":"index.d.ts","type":"module","description":"NCS (Node Component System) is a library for the base of any NCS/ECS system.","keywords":[],"scripts":{"build":"mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cd ./src && npx tsc","compile":"cd ./src && npx tsc --watch"},"repository":{"url":"git+https://github.com/Amodx/Libraries.git"},"bugs":{"url":"https://github.com/Amodx/Libraries/issues"},"homepage":"https://github.com/Amodx/Libraries","author":"Amodx","license":"MIT","devDependencies":{},"main":"index.js","publishConfig":{"access":"public"}}