@divinevoxel/vlox 0.0.72 → 0.0.74

package/Models/Rules/VoxelModelManager.js

@@ -1,82 +0,0 @@
-import { StringPalette } from "../../Util/StringPalette";
-import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
-import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
-const addGeo = (modelId, stateId, nodes) => {
-    const registred = [];
-    for (const geoLinkNode of nodes) {
-        const geo = VoxelModelManager.geometry.get(geoLinkNode.geometryId);
-        if (!geo)
-            throw new Error(`Geometry ${geoLinkNode.geometryId} is not registered.`);
-        const newId = getGeometryLinkId(geoLinkNode);
-        if (VoxelModelManager.geometry.has(newId))
-            continue;
-        registred.push([stateId, newId]);
-        if (!VoxelModelManager.geometryPalette.isRegistered(newId))
-            VoxelModelManager.geometryPalette.register(newId);
-        const newData = structuredClone(geo.data);
-        newData.nodes = newData.nodes.map((_) => ({
-            ..._,
-            tranform: {
-                ...(geoLinkNode.position ? { position: geoLinkNode.position } : {}),
-                ...(geoLinkNode.scale ? { scale: geoLinkNode.scale } : {}),
-                ...(geoLinkNode.rotation ? { rotation: geoLinkNode.rotation } : {}),
-                ...(geoLinkNode.rotationPivot
-                    ? { rotationPivot: geoLinkNode.rotationPivot }
-                    : {}),
-                ...(geoLinkNode.flip ? { flip: geoLinkNode.flip } : {}),
-            },
-        }));
-        VoxelModelManager.geometry.set(newId, new VoxelRuleGeometry(newId, newData));
-        continue;
-    }
-    return registred;
-};
-const getGeometryLinkId = (node) => {
-    return `${node.geometryId}${node.position ? `-p${node.position.toString()}` : ""}${node.rotation ? `-r${node.rotation.toString()}` : ""}${node.scale ? `-s${node.scale.toString()}` : ""}`.trim();
-};
-export class VoxelModelManager {
-    static geometryPalette = new StringPalette();
-    static getGeometryLinkId = getGeometryLinkId;
-    static voxels = new Map();
-    static geometry = new Map();
-    static models = new Map();
-    static registerGeometry(...geometry) {
-        for (const geo of geometry) {
-            if (!this.geometryPalette.isRegistered(geo.id))
-                this.geometryPalette.register(geo.id);
-            this.geometry.set(geo.id, new VoxelRuleGeometry(geo.id, {
-                ogData: geo,
-                id: geo.id,
-                nodes: geo.nodes.map((node) => ({
-                    node,
-                    tranform: {},
-                })),
-            }));
-        }
-    }
-    static getGeomtryFromLink(link) {
-        return this.geometry.get(getGeometryLinkId(link));
-    }
-    static registerModels(...models) {
-        for (const model of models) {
-            const rulesModel = new VoxelRulesModoel(model);
-            this.models.set(model.id, rulesModel);
-            for (const stateId in model.shapeStatesNodes) {
-                const nodes = model.shapeStatesNodes[stateId];
-                addGeo(model.id, stateId, nodes).forEach((_) => rulesModel.registerShapeState(..._));
-            }
-            for (const stateId in model.shapeStatesConditonalNodes) {
-                const nodes = model.shapeStatesConditonalNodes[stateId];
-                addGeo(model.id, stateId, nodes).forEach((_) => rulesModel.registerCondiotnalNode(..._));
-            }
-        }
-    }
-    static registerVoxel(id, data) {
-        let voxelModels = this.voxels.get(data.id);
-        if (!voxelModels) {
-            voxelModels = [];
-            this.voxels.set(data.id, voxelModels);
-        }
-        voxelModels.push({ id, data });
-    }
-}

package/Tasks/IWG/Internal/Classes/IWGTaskBase.d.ts

@@ -1,15 +0,0 @@
-import { LocationData } from "../../../../Math/index.js";
-import { DimensionSegment } from "./DimensionSegment.js";
-export type IWGTasksData = {
-    id: string;
-    propagationBlocking?: boolean;
-    run(location: LocationData, onDone: () => void, dimension: DimensionSegment): void;
-};
-export declare class IWGTaskBase {
-    data: IWGTasksData;
-    constructor(data: IWGTasksData);
-    add(dimensionId: string, x: number, y: number, z: number): void;
-    remove(dimensionId: string, x: number, y: number, z: number): void;
-    cancelAll(dimensionId?: string | null): void;
-    runTask(max?: number): void;
-}

package/Tasks/IWG/Internal/Functions/runBuildUpdate.d.ts

@@ -1,2 +0,0 @@
-import { Generator } from "../Classes/Generator";
-export declare function runBuildUpdate(generators: Generator[]): void;

package/Tasks/IWG/Internal/IWGDimensions.d.ts

@@ -1,6 +0,0 @@
-import { DimensionSegment } from "./Classes/DimensionSegment";
-export declare class IWGDimensions {
-    static readonly _dimensions: Map<string, DimensionSegment>;
-    static addDimension(dimensionId: string): void;
-    static getDimension(dimensionId: string): DimensionSegment;
-}

package/Tasks/IWG/Internal/IWGTasks.d.ts

@@ -1,34 +0,0 @@
-export declare class IWGTasks {
-    /**# Load Sectors
-     * ---
-     */
-    static readonly worldLoadTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Generate Sectors
-     * ---
-     */
-    static readonly worldGenTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Decorate Sectors
-     * ---
-     */
-    static readonly worldDecorateTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# World Sun
-     * ---
-     */
-    static readonly worldSunTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# World Propagation
-     * ---
-     */
-    static readonly worldPropagationTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Save Sector
-     * ---
-     */
-    static readonly saveTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Save & Unload Sector
-     * ---
-     */
-    static readonly saveAndUnloadTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Build Task
-     * ---
-     */
-    static readonly buildTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-}

package/Tasks/IWG/Internal/IWGTools.d.ts

@@ -1,8 +0,0 @@
-import { Thread } from "@amodx/threads";
-import { TaskTool } from "../../../Tools/Tasks/TasksTool";
-import { WorldStorageInterface } from "../../../World/Storage/WorldStorage.interface";
-export declare class IWGTools {
-    static taskTool: TaskTool;
-    static worldStorage: WorldStorageInterface | null;
-    static parent: Thread;
-}

package/Textures/TextureAnimations.d.ts

@@ -1,4 +0,0 @@
-import type { TextureArray } from "./TextureArray";
-export declare const TextureAnimationCreator: {
-    createAnimations(texture: TextureArray): void;
-};

package/Textures/TextureAnimations.js

@@ -1,35 +0,0 @@
-export const TextureAnimationCreator = {
-    createAnimations(texture) {
-        if (!texture.paths.size)
-            return;
-        const animaitonUniform = [];
-        let i = 0;
-        for (const anim of texture.animationsMap) {
-            animaitonUniform[anim[0]] = anim[0];
-            let keyCounts = [];
-            const animTime = texture.animationTimes[i];
-            if (animTime.length == 1) {
-                for (let k = 0; k < anim.length; k++) {
-                    keyCounts.push(animTime[0]);
-                }
-            }
-            else {
-                keyCounts = texture.animationTimes[i];
-            }
-            texture.animations.push({
-                uniformIndex: anim[0],
-                keys: anim,
-                currentFrame: 0,
-                currentCount: 0,
-                keyCounts: keyCounts,
-            });
-            i++;
-        }
-        for (let i = 0; i < texture.totalTextures; i++) {
-            if (!animaitonUniform[i]) {
-                animaitonUniform[i] = 0;
-            }
-        }
-        texture.animationUniform = new Float32Array(animaitonUniform);
-    },
-};

package/Textures/TextureArray.d.ts

@@ -1,47 +0,0 @@
-import type { TextureData } from "./Texture.types";
-export declare class TextureArray {
-    id: string;
-    extension: string;
-    totalTextures: number;
-    textureMap: Map<string, TextureData>;
-    textures: TextureData[];
-    textureIndex: Record<string, number>;
-    animationsMap: number[][];
-    animationTimes: number[][];
-    animations: {
-        uniformIndex: number;
-        overlay?: boolean;
-        keys: number[];
-        currentFrame: number;
-        currentCount: number;
-        keyCounts: number[];
-    }[];
-    varyingID: string;
-    animationUniforID: string;
-    animationUniform: Float32Array;
-    paths: Map<string, HTMLImageElement | string | false>;
-    images: HTMLImageElement[];
-    shaderTexture: any | null;
-    textureID: string;
-    attributeID: string;
-    constructor(id: string);
-    /**# clearData
-     * ---
-     * Clear all un-needed data.
-     */
-    clearData(): void;
-    /**# flush
-     * ---
-     * Clear all data.
-     */
-    flush(): void;
-    flushAll(): void;
-    build(): Promise<void>;
-    getTextureIndex(textureId: string, varation?: string): number;
-    addTexture(data: TextureData): void;
-    runAnimations(): void;
-    getTextureIndexMap(): Record<string, number>;
-    _processVariations(textureData: TextureData, paths: Map<string, HTMLImageElement | string | false>, map: Record<string, number>, animations: number[][], textureAnimatioTimes: number[][], extension: string, count: number): number;
-    _getPath(textureData: TextureData, varation: string | undefined, extension: string): string;
-    buildTextureIndex(): false | undefined;
-}

package/Textures/TextureArray.js

@@ -1,202 +0,0 @@
-import { TextureManager } from "./TextureManager.js";
-import { TextureAnimationCreator } from "./TextureAnimations.js";
-import { TextureBuilder } from "./TextureBuilder.js";
-export class TextureArray {
-    id;
-    extension = "png";
-    totalTextures = 0;
-    textureMap = new Map();
-    textures = [];
-    textureIndex = {};
-    animationsMap = [];
-    animationTimes = [];
-    animations = [];
-    varyingID = "";
-    animationUniforID = "";
-    animationUniform = new Float32Array();
-    paths = new Map();
-    images = [];
-    /* actual renderer resource */
-    shaderTexture = null;
-    textureID = "";
-    attributeID = "textureIndex";
-    constructor(id) {
-        this.id = id;
-        this.textureID = id.replace("#", "");
-    }
-    /**# clearData
-     * ---
-     * Clear all un-needed data.
-     */
-    clearData() {
-        this.paths.clear();
-        this.textures = [];
-        this.textureMap.clear();
-        this.textureIndex = {};
-        this.images = [];
-        this.animationsMap = [];
-        this.animationTimes = [];
-    }
-    /**# flush
-     * ---
-     * Clear all data.
-     */
-    flush() {
-        this.clearData();
-        this.images = [];
-        this.animations = [];
-        this.animationTimes = [];
-        this.animationsMap = [];
-        this.textureIndex = {};
-        this.totalTextures = 0;
-    }
-    flushAll() {
-        //  this.materials.clear();
-    }
-    async build() {
-        this.buildTextureIndex();
-        if (this.paths.size) {
-            this.images = await TextureBuilder.createMaterialTexture(this.id, this.paths);
-        }
-        TextureAnimationCreator.createAnimations(this);
-    }
-    getTextureIndex(textureId, varation = "") {
-        let id = textureId;
-        if (varation) {
-            id = `${textureId}:${varation}`;
-        }
-        let uv = -1;
-        uv = this.textureIndex[id];
-        if (uv == -1) {
-            throw new Error(`Texture with id: ${id} does not exists.typeId : ${this.id} `);
-        }
-        return uv;
-    }
-    addTexture(data) {
-        this.textures.push(data);
-        this.textureMap.set(data.id, data);
-    }
-    runAnimations() {
-        for (let i = 0; i < this.animations.length; i++) {
-            const anim = this.animations[i];
-            if (anim.currentCount <= anim.keyCounts[anim.currentFrame]) {
-                anim.currentCount++;
-                continue;
-            }
-            anim.currentCount = 0;
-            if (anim.currentFrame < anim.keys.length - 1) {
-                anim.currentFrame++;
-            }
-            else {
-                anim.currentFrame = 0;
-            }
-            this.animationUniform[anim.uniformIndex] = anim.keys[anim.currentFrame];
-            /*       for (const [key, material] of this.materials) {
-                    material!.setNumberArray(
-                      this.animationUniforID,
-                      this.animationUniform as any
-                    );
-                  } */
-        }
-    }
-    getTextureIndexMap() {
-        return this.textureIndex;
-    }
-    _processVariations(textureData, paths, map, animations, textureAnimatioTimes, extension, count) {
-        if (!textureData.variations)
-            return count;
-        for (const varation of Object.keys(textureData.variations)) {
-            const data = textureData.variations[varation];
-            if (data.frames == 0) {
-                map[`${textureData.id}:${varation}`] = count;
-                const assetPath = this._getPath(textureData, varation, extension);
-                let raw = false;
-                if (data.base64 && !Array.isArray(data.base64)) {
-                    raw = data.base64;
-                }
-                paths.set(assetPath, raw);
-                count++;
-            }
-            else {
-                if (!data.animKeys)
-                    throw new Error("Texture Varation must have supplied animKeys if frames are greater than 0.");
-                for (let i = 1; i <= data.frames; i++) {
-                    map[`${textureData.id}:${varation}-${i}`] = count;
-                    const assetPath = this._getPath(textureData, `${varation}-${i}`, extension);
-                    let raw = false;
-                    if (data.base64) {
-                        raw = data.base64[i - 1];
-                    }
-                    paths.set(assetPath, raw);
-                    count++;
-                }
-                const trueKeys = [];
-                for (let i = 0; i < data.animKeys.length; i++) {
-                    trueKeys.push(map[`${textureData.id}:${varation}-${data.animKeys[i]}`]);
-                }
-                if (data.animKeyFrameTimes) {
-                    textureAnimatioTimes.push(data.animKeyFrameTimes);
-                }
-                if (data.globalFrameTime) {
-                    textureAnimatioTimes.push([data.globalFrameTime]);
-                }
-                animations.push(trueKeys);
-            }
-        }
-        return count;
-    }
-    _getPath(textureData, varation = "default", extension) {
-        return `${textureData.path ? textureData.path : TextureManager.defaultTexturePath}/${textureData.id}/${varation}.${extension}`;
-    }
-    buildTextureIndex() {
-        const texture = this;
-        if (!texture)
-            return false;
-        const extension = texture.extension;
-        let count = 0;
-        const map = this.textureIndex;
-        const paths = this.paths;
-        const animationTimes = this.animationTimes;
-        const animations = this.animationsMap;
-        for (const textureData of this.textures) {
-            if (textureData.frames == 0) {
-                this.textureIndex[`${textureData.id}`] = count;
-                const assetPath = this._getPath(textureData, "default", extension);
-                let raw = false;
-                if (textureData.base64 && !Array.isArray(textureData.base64)) {
-                    raw = textureData.base64;
-                }
-                paths.set(assetPath, raw);
-                count++;
-                count = this._processVariations(textureData, paths, map, animations, animationTimes, extension, count);
-            }
-            else {
-                if (!textureData.animKeys)
-                    throw new Error("Texture must have supplied animKeys if frames are greater than 0.");
-                const rawData = textureData.rawData;
-                for (let i = 1; i <= textureData.frames; i++) {
-                    const assetPath = this._getPath(textureData, `default-${i}`, extension);
-                    let raw = false;
-                    if (textureData.base64) {
-                        raw = textureData.base64[i - 1];
-                    }
-                    paths.set(assetPath, raw);
-                    count++;
-                }
-                const trueKeys = [];
-                for (let i = 0; i < textureData.animKeys.length; i++) {
-                    trueKeys.push(map[`${textureData.id}:default-${textureData.animKeys[i]}`]);
-                }
-                if (textureData.animKeyFrameTimes) {
-                    animationTimes.push(textureData.animKeyFrameTimes);
-                }
-                if (textureData.globalFrameTime) {
-                    animationTimes.push([textureData.globalFrameTime]);
-                }
-                animations.push(trueKeys);
-                count = this._processVariations(textureData, paths, map, animations, animationTimes, extension, count);
-            }
-        }
-        this.totalTextures = count;
-    }
-}

package/Textures/TextureBuilder.d.ts

@@ -1,13 +0,0 @@
-export declare class TextureBuilder {
-    static context: CanvasRenderingContext2D | null;
-    static _textureSize: number;
-    static finalImagWidth: number;
-    static finalImageHeight: number;
-    static _canvas: HTMLCanvasElement;
-    static defineTextureDimensions(textureSize: number): void;
-    static setUpImageCreation(): void;
-    static createMaterialTexture(name: string, images: Map<string, HTMLImageElement | string | false>, width?: number, height?: number): Promise<HTMLImageElement[]>;
-    static getRawData(imageSrc: string): Promise<Uint8ClampedArray>;
-    static getBase64(imageSrc: string): Promise<string>;
-    static loadImage(imgSrcData: string | HTMLImageElement, width?: number, height?: number): Promise<HTMLImageElement>;
-}

package/Textures/TextureBuilder.js

@@ -1,120 +0,0 @@
-export class TextureBuilder {
-    static context = null;
-    static _textureSize = 16;
-    static finalImagWidth = 16;
-    static finalImageHeight = 16;
-    static _canvas = document.createElement("canvas");
-    static defineTextureDimensions(textureSize) {
-        this.finalImagWidth = textureSize < 256 ? 256 : textureSize;
-        this.finalImageHeight = textureSize < 256 ? 256 : textureSize;
-        this._textureSize = textureSize;
-    }
-    static setUpImageCreation() {
-        this._canvas.width = this.finalImagWidth;
-        this._canvas.height = this.finalImageHeight;
-        const context = this._canvas.getContext("2d", { willReadFrequently: true });
-        if (!context) {
-            throw new Error("Context did not load for texture creation.");
-        }
-        document.body.append(this._canvas);
-        /*   this._canvas.setAttribute(
-          "style",
-          `
-        image-rendering: pixelated;
-        position: absolute;
-        border: 1px solid red;
-        z-index: 1000;
-        top: 0;
-    `
-        );
-    
-       */
-        this.context = context;
-    }
-    static async createMaterialTexture(name, images, width = -1, height = -1) {
-        if (width == -1)
-            width = this.finalImagWidth;
-        if (height == -1)
-            height = this.finalImageHeight;
-        this._canvas.width = this.finalImagWidth;
-        this._canvas.height = this.finalImageHeight;
-        const resolvedImages = [];
-        for (const [path, rawData] of images) {
-            const data = await this.loadImage(rawData ? rawData : path, width, height);
-            resolvedImages.push(data);
-        }
-        return resolvedImages;
-    }
-    static async getRawData(imageSrc) {
-        return new Promise((resolve, reject) => {
-            const image = new Image();
-            image.crossOrigin = "Anonymous";
-            image.src = imageSrc;
-            image.onload = () => {
-                if (!this.context) {
-                    return reject(new Error("Context is not set for texture creation."));
-                }
-                this._canvas.width = image.width;
-                this._canvas.height = image.height;
-                this.context.clearRect(0, 0, image.width, image.height);
-                this.context.drawImage(image, 0, 0, image.width, image.height);
-                const imgData = this.context.getImageData(0, 0, image.width, image.height);
-                resolve(imgData.data);
-                this._canvas.width = this.finalImagWidth;
-                this._canvas.height = this.finalImageHeight;
-            };
-            image.onerror = (err) => reject(err);
-        });
-    }
-    static async getBase64(imageSrc) {
-        return new Promise((resolve, reject) => {
-            const image = new Image();
-            image.crossOrigin = "Anonymous";
-            image.src = imageSrc;
-            image.onload = () => {
-                if (!this.context) {
-                    return reject(new Error("Context is not set for texture creation."));
-                }
-                this._canvas.width = image.width;
-                this._canvas.height = image.height;
-                this.context.clearRect(0, 0, image.width, image.height);
-                this.context.drawImage(image, 0, 0, image.width, image.height);
-                resolve(this._canvas.toDataURL("image/png"));
-                this._canvas.width = this.finalImagWidth;
-                this._canvas.height = this.finalImageHeight;
-            };
-            image.onerror = (err) => reject(err);
-        });
-    }
-    static async loadImage(imgSrcData, width = 0, height = 0) {
-        if (!width)
-            width = this.finalImagWidth;
-        if (!height)
-            height = this.finalImageHeight;
-        const ctx = TextureBuilder.context;
-        if (!ctx) {
-            throw new Error("Context is not set for texture creation.");
-        }
-        const prom = new Promise((resolve) => {
-            const image = typeof imgSrcData == "string" ? new Image() : imgSrcData;
-            if (typeof imgSrcData == "string")
-                image.src = imgSrcData;
-            image.onload = () => {
-                ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
-                ctx.imageSmoothingEnabled = false;
-                ctx.save();
-                ctx.translate(0, this._canvas.height);
-                ctx.scale(1, -1);
-                ctx.drawImage(image, 0, 0, this._canvas.width, this._canvas.height);
-                ctx.restore();
-                const dataUrl = this._canvas.toDataURL("image/png");
-                const returnImage = new Image(this._canvas.width, this._canvas.height);
-                returnImage.src = dataUrl;
-                returnImage.onload = () => {
-                    resolve(returnImage);
-                };
-            };
-        });
-        return prom;
-    }
-}

package/Textures/TextureRegister.d.ts

@@ -1,9 +0,0 @@
-import type { TextureTypeUVMap, TextureId } from "./Texture.types";
-export declare class TextureRegister {
-    static textureDataHasBeenSet: boolean;
-    static data: TextureTypeUVMap;
-    static getTextureUV(data: TextureId): number;
-    static setTextureIndex(data: TextureTypeUVMap): void;
-    static releaseTextureData(): void;
-    static isReady(): boolean;
-}

package/Textures/TextureRegister.js

@@ -1,28 +0,0 @@
-export class TextureRegister {
-    static textureDataHasBeenSet = false;
-    static data;
-    static getTextureUV(data) {
-        const [textureType, textureId, varation] = data;
-        let id = textureId;
-        if (varation) {
-            id = `${textureId}:${varation}`;
-        }
-        let uv = -1;
-        uv = this.data[textureType][id];
-        if (uv == -1) {
-            throw new Error(`Texture with id: ${id} does not exists.`);
-        }
-        return uv;
-    }
-    static setTextureIndex(data) {
-        this.textureDataHasBeenSet = true;
-        this.data = data;
-    }
-    static releaseTextureData() {
-        this.data = null;
-        delete this["data"];
-    }
-    static isReady() {
-        return this.textureDataHasBeenSet;
-    }
-}

package/Tools/DataCursor.interface.d.ts

@@ -1,5 +0,0 @@
-import { VoxelCursorInterface } from "../Voxels/Cursor/VoxelCursor.interface";
-export declare abstract class DataCursorInterface {
-    abstract getVoxel(x: number, y: number, z: number): VoxelCursorInterface | null;
-    abstract inBounds(x: number, y: number, z: number): boolean;
-}

package/Tools/DataCursor.interface.js

@@ -1,2 +0,0 @@
-export class DataCursorInterface {
-}

package/Util/Binary/BitArray.js

@@ -1,16 +0,0 @@
-export function getBitValue(data, bitIndex, bitSize) {
-    const mask = 2 ** bitSize - 1;
-    return ((mask << bitIndex) & data) >>> bitIndex;
-}
-export function setBitValue(data, bitIndex, value, bitSize) {
-    const mask = 2 ** bitSize - 1;
-    return (data & ~(mask << bitIndex)) | ((value & mask) << bitIndex);
-}
-export function getBitArrayIndex(data, arrayIndex) {
-    const arrayByteIndex = (arrayIndex / 8) >> 0;
-    return getBitValue(data[arrayByteIndex], arrayIndex - arrayByteIndex * 8, 1);
-}
-export function setBitArrayIndex(data, arrayIndex, value) {
-    const arrayByteIndex = (arrayIndex / 8) >> 0;
-    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], arrayIndex - arrayByteIndex * 8, value, 1);
-}

package/World/Structs/WorldDataStructProperties.d.ts

@@ -1,8 +0,0 @@
-export declare enum WorldDataStructProperties {
-    header = "dve_header",
-    dataType = "dve_data_type",
-    dimensionId = "dve_dimension_id",
-    positionX = "dve_p_x",
-    positionY = "dve_p_y",
-    positionZ = "dve_p_z"
-}

package/World/Structs/WorldDataStructProperties.js

@@ -1,9 +0,0 @@
-export var WorldDataStructProperties;
-(function (WorldDataStructProperties) {
-    WorldDataStructProperties["header"] = "dve_header";
-    WorldDataStructProperties["dataType"] = "dve_data_type";
-    WorldDataStructProperties["dimensionId"] = "dve_dimension_id";
-    WorldDataStructProperties["positionX"] = "dve_p_x";
-    WorldDataStructProperties["positionY"] = "dve_p_y";
-    WorldDataStructProperties["positionZ"] = "dve_p_z";
-})(WorldDataStructProperties || (WorldDataStructProperties = {}));