@divinevoxel/vlox 0.0.3 → 0.0.5

package/Tools/Brush/Brush.js

@@ -1,19 +1,20 @@
-import { VoxelPalette } from "../../Data/Palettes/VoxelPalette.js";
-import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
-import { VoxelCursor } from "../../Data/Cursor/VoxelCursor.js";
+import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette.js";
+import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
+import { WorldRegister } from "../../World/WorldRegister.js";
 const airId = "dve_air";
-const air = [0, 0, 0, 0, 0];
+const air = [0, 0, 0, 0, 0, 0];
 export class BrushTool {
     data = {
         id: airId,
-        shapeState: 0,
-        secondaryVoxelId: airId,
+        state: 0,
+        secondaryVoxelId: "",
         level: 0,
         levelState: 0,
         mod: 0,
     };
-    dimension;
+    dimension = "main";
     x = 0;
     y = 0;
     z = 0;
@@ -27,9 +28,13 @@ export class BrushTool {
         this.z = z;
         return this;
     }
+    newSector() {
+        WorldRegister.setDimension(this.dimension);
+        WorldRegister.sectors.new(this.x, this.y, this.z);
+    }
     setData(data) {
         this.data.id = data.id ? data.id : airId;
-        this.data.shapeState = data.shapeState ? data.shapeState : 0;
+        this.data.state = data.state ? data.state : 0;
         this.data.secondaryVoxelId = data.secondaryVoxelId
             ? data.secondaryVoxelId
             : airId;
@@ -44,7 +49,7 @@ export class BrushTool {
     setRaw(data) {
         this.voxelCursor.copyRaw(data).process();
         this.data.id = this.voxelCursor.getStringId();
-        this.data.shapeState = this.voxelCursor.getShapeState();
+        this.data.state = this.voxelCursor.getState();
         this.data.levelState = this.voxelCursor.getLevelState();
         this.data.level = this.voxelCursor.getLevel();
         this.voxelCursor.setSecondary(true);
@@ -72,7 +77,7 @@ export class BrushTool {
         return this;
     }
     setShapeState(state) {
-        this.data.shapeState = state;
+        this.data.state = state;
         return this;
     }
     setLevel(level) {
@@ -89,16 +94,18 @@ export class BrushTool {
     }
     clear() {
         this.data.id = "dve_air";
-        this.data.secondaryVoxelId = "dve_air";
+        this.data.secondaryVoxelId = "";
         this.data.level = 0;
         this.data.levelState = 0;
-        this.data.shapeState = 0;
+        this.data.state = 0;
         this.data.mod = 0;
         this.x = 0;
         this.y = 0;
         this.z = 0;
     }
     _paint() {
+        if (!this.dataCursor.inBounds(this.x, this.y, this.z))
+            return false;
         const voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
         if (!voxel)
             return;
@@ -106,17 +113,10 @@ export class BrushTool {
         if (id < 0)
             return false;
         voxel.setId(id);
-        voxel.setShapeState(this.data.shapeState ? this.data.shapeState : 0);
-        const substance = voxel.getSubstance();
-        if (substance > -1 && !voxel.isAir()
-            ? this.substanceData.setSubstance(voxel.getSubstance()).isLiquid()
-            : false) {
-            voxel.setLevel(7);
-        }
+        voxel.setState(this.data.state ? this.data.state : 0);
+        voxel.setLevel(this.data.level);
         voxel.setMod(this.data.mod);
-        if (this.data.secondaryVoxelId &&
-            this.data.secondaryVoxelId != "dve_air" &&
-            voxel.canHaveSecondaryVoxel()) {
+        if (this.data.secondaryVoxelId) {
             const vid = VoxelPalette.ids.getNumberId(this.data.secondaryVoxelId);
             if (vid > 0) {
                 voxel.setSecondary(true);

package/Tools/Data/SubstanceDataTool.d.ts

@@ -1,10 +1,11 @@
-import { SubstanceStruct } from "../../Data/Structs/SubstanceStruct.js";
+import { SubstanceStruct } from "../../Voxels/Structs/SubstanceStruct.js";
 export declare class SubstanceDataTool {
     static tags: typeof SubstanceStruct;
     substanceTagIndex: number;
     setSubstanceFromString(substance: string): this;
     setSubstance(substance: number): this;
     getSubstanceStringId(): string;
+    isSolid(): boolean;
     isLiquid(): boolean;
     isWindAffected(): boolean;
     getParent(): string;

package/Tools/Data/SubstanceDataTool.js

@@ -1,7 +1,7 @@
-import { SubstancePalette } from "../../Data/Palettes/SubstancePalette.js";
-import { SubstanceStruct } from "../../Data/Structs/SubstanceStruct.js";
+import { SubstancePalette } from "../../Voxels/Palettes/SubstancePalette.js";
 import { MappedDataRegister } from "../../Data/Register/MappedDataRegister.js";
-import { SubstanceStructIds } from "../../Voxels/VoxelSubstances.types.js";
+import { SubstanceStructIds } from "../../Voxels/Types/VoxelSubstances.types.js";
+import { SubstanceStruct } from "../../Voxels/Structs/SubstanceStruct.js";
 export class SubstanceDataTool {
     static tags = SubstanceStruct;
     //substance = "";
@@ -25,9 +25,10 @@ export class SubstanceDataTool {
       return SubstanceStruct.instance[SubstanceStructIds.isTransparent] == 1;
     }
   
+   */
     isSolid() {
-      return SubstanceStruct.instance[SubstanceStructIds.isSolid] == 1;
-    } */
+        return SubstanceStruct.instance[SubstanceStructIds.isSolid] == 1;
+    }
     isLiquid() {
         return SubstanceStruct.instance[SubstanceStructIds.isLiquid] == 1;
     }

package/Tools/Tasks/TasksTool.d.ts

@@ -1,92 +1,47 @@
-import { BuildTasks, GenerateTasks, Priorities } from "../../Tasks/Tasks.types";
+import { Thread, ThreadPool } from "@amodx/threads/";
+import { ExplosionTasks, GenerateTasks, VoxelUpdateTasks } from "../../Tasks/Tasks.types";
 import { LocationData } from "../../Math";
-import type { RawVoxelData } from "../../Voxels/Voxel.types.js";
 export type TaskRunModes = "async" | "sync";
+declare class TaskQueue<Data extends any = any, ReturnData extends any = void> {
+    private _task;
+    private _queue;
+    constructor(_task: TaskToolTask<Data, ReturnData>);
+    add(data: Data): void;
+    clear(): void;
+    run(): Promise<unknown>;
+}
+export declare class TaskToolTask<Data extends any = any, ReturnData extends any = void> {
+    id: string | number;
+    private _count;
+    _threads: Thread[];
+    constructor(id: string | number, threads: Thread | ThreadPool);
+    run(data: Data, transfer?: any[] | null, onDone?: (returnData: ReturnData) => void | null): void;
+    runAsync(data: Data, transfer?: any[] | null): Promise<ReturnData>;
+    createQueue(): TaskQueue<Data, ReturnData>;
+}
+declare class VoxelTasks {
+    tool: TaskTool;
+    update: TaskToolTask<VoxelUpdateTasks>;
+    paint: TaskToolTask<VoxelUpdateTasks>;
+    erease: TaskToolTask<LocationData>;
+    constructor(tool: TaskTool);
+}
+declare class BuildTask {
+    tool: TaskTool;
+    section: TaskToolTask<LocationData>;
+    sector: TaskToolTask<LocationData>;
+    constructor(tool: TaskTool);
+}
 export declare class TaskTool {
-    _data: {
-        dimension: string;
-        queue: string;
-    };
-    _thread: string;
-    _priority: Priorities;
-    constructor();
-    setPriority(priority: Priorities): this;
-    setFocalPoint(location: LocationData): this;
-    voxelUpdate: {
-        update: {
-            run: (location: LocationData, raw: RawVoxelData, onDone: (data: any) => void, mode?: TaskRunModes) => void;
-        };
-        erase: {
-            run: (location: LocationData, onDone: (data: any) => void, mode?: TaskRunModes) => void;
-        };
-        paint: {
-            run: (location: LocationData, raw: RawVoxelData, onDone: (data: any) => void, mode?: TaskRunModes) => void;
-        };
-    };
-    build: {
-        chunk: {
-            deferred: {
-                run: (buildTasks: BuildTasks, onDone: (data: any) => void) => void;
-            };
-            queued: {
-                add: (location: LocationData) => void;
-                run: (onDone: Function) => void;
-                runAndAwait: () => Promise<void>;
-            };
-        };
-        column: {
-            queued: {};
-            deferred: {
-                run: (location: LocationData, onDone: (data: any) => void) => void;
-            };
-        };
-    };
-    explosion: {
-        run: (location: LocationData, radius: number, onDone: (data: any) => void) => void;
-    };
-    anaylzer: {
-        update: {
-            run: (location: LocationData, onDone: (data: any) => void) => void;
-        };
-    };
-    propagation: {
-        deferred: {
-            run: (location: LocationData, onDone: (data: any) => void) => void;
-        };
-        queued: {
-            add: (location: LocationData) => void;
-            run: (onDone: Function) => void;
-            runAndAwait: () => Promise<void>;
-        };
-    };
-    generate: {
-        deferred: {
-            run(location: LocationData, data: any, onDone: (data: any) => void): void;
-        };
-        queued: {
-            add: (data: GenerateTasks) => void;
-            run: (onDone: Function) => void;
-            runAndAwait: () => Promise<void>;
-        };
-    };
-    decorate: {
-        deferred: {
-            run: (location: LocationData, data: any, onDone: (data: any) => void) => void;
-        };
-        queued: {
-            add: (data: GenerateTasks) => Promise<void>;
-            run: (onDone: Function) => void;
-            runAndAwait: () => Promise<void>;
-        };
-    };
-    worldSun: {
-        deferred: {
-            run: (location: LocationData, onDone: (data: any) => void) => void;
-        };
-        queued: {
-            add: (location: LocationData) => void;
-            run: (onDone: Function) => void;
-            runAndAwait: () => Promise<void>;
-        };
-    };
+    threads: Thread | ThreadPool;
+    voxel: VoxelTasks;
+    build: BuildTask;
+    explosion: TaskToolTask<ExplosionTasks>;
+    anaylzer: TaskToolTask<LocationData>;
+    propagation: TaskToolTask<LocationData>;
+    generate: TaskToolTask<GenerateTasks>;
+    decorate: TaskToolTask<GenerateTasks>;
+    worldSun: TaskToolTask<LocationData>;
+    constructor(threads: Thread | ThreadPool);
 }
+export {};

package/Tools/Tasks/TasksTool.js

@@ -1,217 +1,102 @@
-import { Threads } from "@amodx/threads/";
-import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
-import { ConstructorRemoteThreadTasks } from "../../Contexts/Constructor/Tasks/ConstructorRemoteThreadTasks.js";
-import { DVEConstructorTasksQueues } from "../../Contexts/Constructor/Tasks/DVEConstructorTasksQueues.js";
+import { Thread } from "@amodx/threads/";
 import { TasksIds } from "../../Tasks/TasksIds.js";
-export class TaskTool {
-    _data = {
-        dimension: "main",
-        queue: "main",
-    };
-    _thread = "";
-    _priority = 0;
-    constructor() {
-        this._thread = Threads.threadName;
+class TaskQueue {
+    _task;
+    _queue = [];
+    constructor(_task) {
+        this._task = _task;
+    }
+    add(data) {
+        this._queue.push(data);
+    }
+    clear() {
+        this._queue.length = 0;
+    }
+    run() {
+        return new Promise((resolve) => {
+            let waitingFor = 0;
+            const onDone = () => {
+                waitingFor--;
+                if (waitingFor <= 0)
+                    resolve(true);
+            };
+            while (this._queue.length) {
+                const data = this._queue.shift();
+                waitingFor++;
+                this._task.run(data, null, onDone);
+            }
+        });
+    }
+}
+export class TaskToolTask {
+    id;
+    _count = 0;
+    _threads;
+    constructor(id, threads) {
+        this.id = id;
+        if (threads instanceof Thread) {
+            this._threads = [threads];
+        }
+        else {
+            this._threads = [...threads.getThreads()];
+        }
+    }
+    run(data, transfer, onDone) {
+        const thread = this._threads[this._count];
+        thread.runTask(this.id, data, transfer, onDone);
+        this._count++;
+        if (this._count >= this._threads.length)
+            this._count = 0;
     }
-    setPriority(priority) {
-        this._priority = priority;
-        return this;
+    runAsync(data, transfer) {
+        return new Promise((resolve) => {
+            this.run(data, transfer, resolve);
+        });
     }
-    setFocalPoint(location) {
-        const [dimesnion, x, y, z] = location;
-        const queueKey = `${dimesnion}-${WorldSpaces.region.getKeyXYZ(x, y, z)}`;
-        DVEConstructorTasksQueues.instance.addQueue(queueKey);
-        this._data.queue = queueKey;
-        this._thread = Threads.threadName;
-        return this;
+    createQueue() {
+        return new TaskQueue(this);
+    }
+}
+class VoxelTasks {
+    tool;
+    update;
+    paint;
+    erease;
+    constructor(tool) {
+        this.tool = tool;
+        this.update = new TaskToolTask(TasksIds.VoxelUpdate, tool.threads);
+        this.paint = new TaskToolTask(TasksIds.VoxelPaint, tool.threads);
+        this.erease = new TaskToolTask(TasksIds.VoxelErease, tool.threads);
+    }
+}
+class BuildTask {
+    tool;
+    section;
+    sector;
+    constructor(tool) {
+        this.tool = tool;
+        this.section = new TaskToolTask(TasksIds.BuildSection, tool.threads);
+        this.sector = new TaskToolTask(TasksIds.BuildSector, tool.threads);
+    }
+}
+export class TaskTool {
+    threads;
+    voxel;
+    build;
+    explosion;
+    anaylzer;
+    propagation;
+    generate;
+    decorate;
+    worldSun;
+    constructor(threads) {
+        this.threads = threads;
+        this.voxel = new VoxelTasks(this);
+        this.build = new BuildTask(this);
+        this.explosion = new TaskToolTask(TasksIds.Explosion, threads);
+        this.propagation = new TaskToolTask(TasksIds.Propagation, threads);
+        this.generate = new TaskToolTask(TasksIds.Generate, threads);
+        this.decorate = new TaskToolTask(TasksIds.Decorate, threads);
+        this.worldSun = new TaskToolTask(TasksIds.WorldSun, threads);
     }
-    voxelUpdate = {
-        update: {
-            run: (location, raw, onDone, mode = "sync") => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.VoxelUpdate, [location, raw, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
-            },
-        },
-        erase: {
-            run: (location, onDone, mode = "sync") => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.VoxelErease, [location, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
-            },
-        },
-        paint: {
-            run: (location, raw, onDone, mode = "sync") => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.VoxelPaint, [location, raw, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
-            },
-        },
-    };
-    build = {
-        chunk: {
-            deferred: {
-                run: (buildTasks, onDone) => {
-                    DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.BuildChunk, {
-                        data: buildTasks,
-                        priority: this._priority,
-                    }, [], onDone, undefined, 0);
-                },
-            },
-            queued: {
-                add: (location) => {
-                    DVEConstructorTasksQueues.instance.getTasks("build-chunk").add({
-                        data: [location, 1],
-                        priority: this._priority,
-                    }, this._data.queue);
-                },
-                run: (onDone) => {
-                    DVEConstructorTasksQueues.instance
-                        .getTasks("build-chunk")
-                        .run(this._data.queue);
-                    DVEConstructorTasksQueues.instance
-                        .getTasks("build-chunk")
-                        .onDone(this._data.queue, onDone);
-                },
-                runAndAwait: async () => {
-                    await DVEConstructorTasksQueues.instance
-                        .getTasks("build-chunk")
-                        .runAndAwait(this._data.queue);
-                },
-            },
-        },
-        column: {
-            queued: {},
-            deferred: {
-                run: (location, onDone) => {
-                    DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.BuildColumn, [location, 1], [], onDone, undefined, 0);
-                },
-            },
-        },
-    };
-    explosion = {
-        run: (location, radius, onDone) => {
-            DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.Explosion, [location, radius, "", ""], [], onDone, undefined, 0);
-        },
-    };
-    anaylzer = {
-        update: {
-            run: (location, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.AnalyzerUpdate, [location, this._data.queue, this._thread], [], onDone, undefined, 0);
-            },
-        },
-    };
-    propagation = {
-        deferred: {
-            run: (location, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.AnalyzerPropagation, [location, this._data.queue, this._thread], [], onDone, undefined, 0);
-            },
-        },
-        queued: {
-            add: (location) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("propagation")
-                    .add([location, this._data.queue, this._thread], this._data.queue);
-            },
-            run: (onDone) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("propagation")
-                    .run(this._data.queue);
-                DVEConstructorTasksQueues.instance
-                    .getTasks("propagation")
-                    .onDone(this._data.queue, onDone);
-            },
-            runAndAwait: async () => {
-                await DVEConstructorTasksQueues.instance
-                    .getTasks("propagation")
-                    .runAndAwait(this._data.queue);
-            },
-        },
-    };
-    generate = {
-        deferred: {
-            run(location, data, onDone) {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.Generate, [location, data], [], onDone, undefined, 0);
-            },
-        },
-        queued: {
-            add: (data) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("generate")
-                    .add(data, this._data.queue);
-            },
-            run: (onDone) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("generate")
-                    .run(this._data.queue);
-                DVEConstructorTasksQueues.instance
-                    .getTasks("generate")
-                    .onDone(this._data.queue, onDone);
-            },
-            runAndAwait: async () => {
-                await DVEConstructorTasksQueues.instance
-                    .getTasks("generate")
-                    .runAndAwait(this._data.queue);
-            },
-        },
-    };
-    decorate = {
-        deferred: {
-            run: (location, data, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.Decorate, [location, data], [], onDone, undefined, 0);
-            },
-        },
-        queued: {
-            add: async (data) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("decorate")
-                    .add(data, this._data.queue);
-            },
-            run: (onDone) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("decorate")
-                    .run(this._data.queue);
-                DVEConstructorTasksQueues.instance
-                    .getTasks("decorate")
-                    .onDone(this._data.queue, onDone);
-            },
-            runAndAwait: async () => {
-                await DVEConstructorTasksQueues.instance
-                    .getTasks("decorate")
-                    .runAndAwait(this._data.queue);
-            },
-        },
-    };
-    worldSun = {
-        deferred: {
-            run: (location, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.WorldSun, [location, this._thread], [], onDone, undefined, 0);
-            },
-        },
-        queued: {
-            add: (location) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("world-sun")
-                    .add([[...location], this._data.queue, this._thread], this._data.queue);
-            },
-            run: (onDone) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("world-sun")
-                    .run(this._data.queue);
-                DVEConstructorTasksQueues.instance
-                    .getTasks("world-sun")
-                    .onDone(this._data.queue, onDone);
-            },
-            runAndAwait: async () => {
-                await DVEConstructorTasksQueues.instance
-                    .getTasks("world-sun")
-                    .runAndAwait(this._data.queue);
-            },
-        },
-    };
 }
-DVEConstructorTasksQueues.onCreated.subscribe("TaskTool", () => {
-    DVEConstructorTasksQueues.instance.registerTasks("world-sun", TasksIds.WorldSun);
-    DVEConstructorTasksQueues.instance.registerTasks("decorate", TasksIds.Decorate);
-    DVEConstructorTasksQueues.instance.registerTasks("generate", TasksIds.Generate);
-    DVEConstructorTasksQueues.instance.registerTasks("propagation", TasksIds.AnalyzerPropagation);
-    const tasks = new TaskTool();
-    Threads.registerTasks(ConstructorRemoteThreadTasks.BuildChunk, (data) => {
-        tasks.setPriority(data.priority);
-        tasks.build.chunk.deferred.run(data.data, () => { });
-    });
-});

package/Util/BinaryObject.d.ts

@@ -0,0 +1,2 @@
+export declare function compressBinaryObject(object: any): Promise<ArrayBuffer>;
+export declare function expandBinaryObject<T = any>(buffer: ArrayBuffer | Uint8Array, useSharedMemory?: boolean): Promise<T>;

package/Util/BinaryObject.js

@@ -0,0 +1,14 @@
+import { BinaryObject } from "@amodx/binary";
+export async function compressBinaryObject(object) {
+    const compressedArrayBuffer = await new Response(new Blob([BinaryObject.objectToBuffer(object)])
+        .stream()
+        .pipeThrough(new CompressionStream("gzip"))).arrayBuffer();
+    return compressedArrayBuffer;
+}
+export async function expandBinaryObject(buffer, useSharedMemory = false) {
+    const decompressedBuffer = await new Response(new Blob([buffer]).stream().pipeThrough(new DecompressionStream("gzip"))).arrayBuffer();
+    BinaryObject.setUseSharedMemory(useSharedMemory);
+    const object = BinaryObject.bufferToObject(decompressedBuffer);
+    BinaryObject.setUseSharedMemory(false);
+    return object;
+}

package/Util/Environment.d.ts

@@ -0,0 +1,4 @@
+export declare class Environment {
+    static isNode(): boolean;
+    static isBrowser(): boolean;
+}

package/Util/Environment.js

@@ -0,0 +1,10 @@
+export class Environment {
+    static isNode() {
+        return (typeof process !== "undefined" &&
+            process.versions &&
+            !!process.versions.node);
+    }
+    static isBrowser() {
+        return !this.isNode();
+    }
+}

package/Util/TypedEventTarget.d.ts

@@ -0,0 +1,5 @@
+export declare class TypedEventTarget<T extends Record<string, any>> extends EventTarget {
+    addEventListener<K extends keyof T>(type: K, listener: ((event: CustomEvent<T[K]>) => void) | EventListenerObject | null, options?: AddEventListenerOptions): void;
+    removeEventListener<K extends keyof T>(type: K, listener: ((event: CustomEvent<T[K]>) => void) | EventListenerObject | null): void;
+    dispatch<K extends keyof T>(type: K, detail: T[K]): boolean;
+}

package/Util/TypedEventTarget.js

@@ -0,0 +1,12 @@
+export class TypedEventTarget extends EventTarget {
+    addEventListener(type, listener, options) {
+        super.addEventListener(type, listener, options);
+    }
+    removeEventListener(type, listener) {
+        super.removeEventListener(type, listener);
+    }
+    dispatch(type, detail) {
+        super.dispatchEvent(new CustomEvent(type, { detail }));
+        return true;
+    }
+}

package/Util/Util.types.d.ts

@@ -1,5 +1,3 @@
-import { CompassDirectionNames } from "../Math/Math.types";
-export type DirectionNames = "up" | "down" | Exclude<CompassDirectionNames, "north-west" | "north-east" | "south-west" | "south-east">;
 export type RecursivePartial<T> = {
     [P in keyof T]?: RecursivePartial<T[P]>;
 };

package/{Data → Voxels}/Cursor/VoxelCursor.d.ts

@@ -1,10 +1,10 @@
-import { PaintVoxelData } from "../../Data/Types/WorldData.types";
-import { VoxelCursorInterface } from "./Interfaces/VoxelCursor.interface";
-import { RawVoxelData } from "../../Voxels/Voxel.types";
+import { VoxelCursorInterface } from "./VoxelCursor.interface";
+import { PaintVoxelData, RawVoxelData } from "../Types/Voxel.types";
 export declare class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data: Partial<PaintVoxelData>, light?: number): RawVoxelData;
     ids: number[];
     light: number[];
+    level: number[];
     state: number[];
     secondary: number[];
     mod: number[];