@divinevoxel/vlox 0.0.73 → 0.0.75

package/Templates/Functions/CreateTemplate.js

@@ -1,134 +0,0 @@
-import { Flat3DIndex, Traverse } from "@amodx/math";
-import { StringPalette } from "../../Util/StringPalette";
-import { VoxelTemplate } from "../VoxelTemplate";
-import { NumberPalette } from "../../Util/NumberPalette";
-import { convertToPaletteBuffer } from "../../Util/Binary/Palettes";
-import { WorldCursor } from "../../World";
-export default function CreateTemplate(dimension, start, end) {
-    const dataTool = new WorldCursor();
-    dataTool.setFocalPoint(dimension, start[0], start[1], start[2]);
-    const index = Flat3DIndex.GetXZYOrder();
-    const [sx, sy, sz] = [
-        end[0] - start[0],
-        end[1] - start[1],
-        end[2] - start[2],
-    ];
-    index.setBounds(sx, sy, sz);
-    const idPalette = new StringPalette();
-    const levelPalette = new NumberPalette();
-    const statePalette = new NumberPalette();
-    const modPalette = new NumberPalette();
-    const secondaryIdPalette = new StringPalette();
-    const secondaryStatePalette = new NumberPalette();
-    const ids = new Uint16Array(index.size);
-    const levels = new Uint8Array(index.size);
-    const states = new Uint16Array(index.size);
-    const mods = new Uint16Array(index.size);
-    const secondarys = new Uint16Array(index.size);
-    let idsAllTheSame = true;
-    let levelAllTheSame = true;
-    let stateAllTheSame = true;
-    let modAllTheSame = true;
-    let secondaryAllTheSame = true;
-    let firstId = -1;
-    let firstLevel = -1;
-    let firstState = -1;
-    let firstMod = -1;
-    let firstSecondary = -1;
-    for (const { x, y, z } of Traverse.FromToVec3(start, [end[0] - 1, end[1] - 1, end[2] - 1], 1)) {
-        const voxel = dataTool.getVoxel(x, y, x);
-        if (!voxel)
-            continue;
-        const vindex = index.getIndexXYZ(x - start[0], y - start[1], z - start[2]);
-        const rawData = voxel.getRaw();
-        const level = rawData[2];
-        const state = rawData[3];
-        const mod = rawData[4];
-        const seoncdary = rawData[5];
-        const stringId = voxel.getStringId();
-        const voxelId = !idPalette.isRegistered(stringId)
-            ? idPalette.register(stringId)
-            : idPalette.getNumberId(stringId);
-        const levelId = !levelPalette.isRegistered(level)
-            ? levelPalette.register(level)
-            : levelPalette.getId(level);
-        const stateId = !statePalette.isRegistered(state)
-            ? statePalette.register(state)
-            : statePalette.getId(state);
-        const modId = !modPalette.isRegistered(mod)
-            ? modPalette.register(mod)
-            : modPalette.getId(mod);
-        let secondaryData = 0;
-        if (voxel.canHaveSecondaryVoxel()) {
-            voxel.setSecondary(true);
-            let secondaryId = voxel.hasSecondaryVoxel()
-                ? voxel.getStringId()
-                : "dve_air";
-            voxel.setSecondary(false);
-            secondaryData = !secondaryIdPalette.isRegistered(secondaryId)
-                ? secondaryIdPalette.register(secondaryId)
-                : secondaryIdPalette.getNumberId(secondaryId);
-        }
-        else {
-            secondaryData = !secondaryStatePalette.isRegistered(seoncdary)
-                ? secondaryStatePalette.register(seoncdary)
-                : secondaryStatePalette.getId(seoncdary);
-        }
-        if (firstId == -1)
-            firstId = voxelId;
-        if (firstLevel == -1)
-            firstLevel = stateId;
-        if (firstState == -1)
-            firstState = stateId;
-        if (firstMod == -1)
-            firstMod = modId;
-        if (firstSecondary == -1)
-            firstSecondary = secondaryData;
-        ids[vindex] = voxelId;
-        levels[vindex] = voxelId;
-        mods[vindex] = modId;
-        states[vindex] = stateId;
-        secondarys[vindex] = secondaryData;
-        if (firstId != voxelId)
-            idsAllTheSame = false;
-        if (firstLevel != levelId)
-            levelAllTheSame = false;
-        if (firstState != stateId)
-            stateAllTheSame = false;
-        if (firstMod != modId)
-            modAllTheSame = false;
-        if (firstSecondary != secondaryData)
-            secondaryAllTheSame = false;
-    }
-    console.log("CREATE VOXEL TEMPLATE", { modPalette, mod: mods });
-    return new VoxelTemplate({
-        templatorVersion: 0,
-        version: 0,
-        size: [sx, sy, sz],
-        palettes: {
-            id: idPalette._palette,
-            level: Uint8Array.from(levelPalette._palette),
-            state: Uint16Array.from(statePalette._palette),
-            mod: Uint16Array.from(modPalette._palette),
-            secondaryId: secondaryIdPalette._palette,
-            secondaryState: Uint16Array.from(secondaryStatePalette._palette),
-        },
-        buffers: {
-            ids: !idsAllTheSame
-                ? convertToPaletteBuffer(idPalette.size, Uint16Array.from(ids), true)
-                : ids[0],
-            level: !levelAllTheSame
-                ? convertToPaletteBuffer(modPalette.size, levels, true)
-                : levels[0],
-            mod: !modAllTheSame
-                ? convertToPaletteBuffer(modPalette.size, Uint16Array.from(mods), true)
-                : mods[0],
-            state: !stateAllTheSame
-                ? convertToPaletteBuffer(statePalette.size, Uint16Array.from(states), true)
-                : states[0],
-            secondary: !secondaryAllTheSame
-                ? convertToPaletteBuffer(Math.max(secondaryIdPalette.size, secondaryStatePalette.size), Uint16Array.from(secondarys), true)
-                : secondarys[0],
-        },
-    });
-}

package/Templates/VoxelTemplate.d.ts

@@ -1,34 +0,0 @@
-import { Flat3DIndex, Vec3Array } from "@amodx/math";
-import { VoxelTemplateData } from "./VoxelTemplates.types";
-import type { RawVoxelData } from "../Voxels/Types/Voxel.types";
-import { StringPalette } from "../Util/StringPalette";
-import { NumberPalette } from "../Util/NumberPalette";
-type TemplateCursor = {
-    position: Vec3Array;
-    raw: RawVoxelData;
-};
-export declare class VoxelTemplate {
-    index: Flat3DIndex;
-    size: Vec3Array;
-    ids: Uint8Array | Uint16Array | number;
-    level: Uint8Array | number;
-    state: Uint8Array | Uint16Array | number;
-    mod: Uint8Array | Uint16Array | number;
-    secondary: Uint8Array | Uint16Array | number;
-    idPalette: StringPalette;
-    levelPalette: NumberPalette;
-    statePalette: NumberPalette;
-    modPalette: NumberPalette;
-    secondaryIdPalette: StringPalette;
-    secondaryStatePalette: NumberPalette;
-    constructor(data: VoxelTemplateData);
-    getIndex(x: number, y: number, z: number): number;
-    getId(index: number): number;
-    getState(index: number): number;
-    getLevel(index: number): number;
-    getMod(index: number): number;
-    getSecondary(id: number, index: number): number;
-    traverse(): Generator<TemplateCursor>;
-    toJSON(): VoxelTemplateData;
-}
-export {};

package/Templates/VoxelTemplate.js

@@ -1,135 +0,0 @@
-import { Flat3DIndex, Traverse } from "@amodx/math";
-import { StringPalette } from "../Util/StringPalette";
-import { NumberPalette } from "../Util/NumberPalette";
-import { getPaletteArray } from "../Util/Binary/Palettes";
-import { VoxelPalettesRegister } from "../Voxels/Data/VoxelPalettesRegister";
-import { VoxelTagsRegister } from "../Voxels/Data/VoxelTagsRegister";
-export class VoxelTemplate {
-    index = Flat3DIndex.GetXZYOrder();
-    size;
-    ids;
-    level;
-    state;
-    mod;
-    secondary;
-    idPalette;
-    levelPalette;
-    statePalette;
-    modPalette;
-    secondaryIdPalette;
-    secondaryStatePalette;
-    constructor(data) {
-        this.size = [...data.size];
-        this.index.setBounds(...data.size);
-        this.idPalette = new StringPalette(data.palettes.id);
-        this.levelPalette = new NumberPalette(data.palettes.level);
-        this.statePalette = new NumberPalette(data.palettes.state);
-        this.modPalette = new NumberPalette(data.palettes.mod);
-        this.secondaryIdPalette = new StringPalette(data.palettes.secondaryId);
-        this.secondaryStatePalette = new NumberPalette(data.palettes.secondaryState);
-        typeof data.buffers.ids == "object"
-            ? (this.ids = getPaletteArray(data.palettes.id.length, data.buffers.ids))
-            : (this.ids = data.buffers.ids);
-        typeof data.buffers.level == "object"
-            ? (this.level = getPaletteArray(data.palettes.level.length, data.buffers.level))
-            : (this.level = data.buffers.level);
-        typeof data.buffers.state == "object"
-            ? (this.state = getPaletteArray(data.palettes.state.length, data.buffers.state))
-            : (this.state = data.buffers.state);
-        typeof data.buffers.mod == "object"
-            ? (this.mod = getPaletteArray(data.palettes.mod.length, data.buffers.mod))
-            : (this.mod = data.buffers.mod);
-        typeof data.buffers.secondary == "object"
-            ? (this.secondary = getPaletteArray(Math.max(data.palettes.secondaryState.length, data.palettes.secondaryId.length), data.buffers.secondary))
-            : (this.secondary = data.buffers.secondary);
-    }
-    getIndex(x, y, z) {
-        return this.index.getIndexXYZ(x, y, z);
-    }
-    getId(index) {
-        const ids = this.ids;
-        return VoxelPalettesRegister.voxels.getNumberId(this.idPalette.getStringId(typeof ids == "number" ? ids : ids[index]));
-    }
-    getState(index) {
-        const state = this.state;
-        return this.statePalette.getValue(typeof state == "number" ? state : state[index]);
-    }
-    getLevel(index) {
-        const mod = this.mod;
-        return this.modPalette.getValue(typeof mod == "number" ? mod : mod[index]);
-    }
-    getMod(index) {
-        const mod = this.mod;
-        return this.modPalette.getValue(typeof mod == "number" ? mod : mod[index]);
-    }
-    getSecondary(id, index) {
-        const secondary = this.secondary;
-        if (VoxelTagsRegister.VoxelTags[id]["dve_can_have_secondary"]) {
-            return VoxelPalettesRegister.voxels.getNumberId(this.secondaryIdPalette.getStringId(typeof secondary == "number" ? secondary : secondary[index]));
-        }
-        return this.secondaryStatePalette.getValue(typeof secondary == "number" ? secondary : secondary[index]);
-    }
-    *traverse() {
-        const end = this.size;
-        const raw = [0, 0, 0, 0, 0, 0];
-        const curosr = {
-            position: [0, 0, 0],
-            raw,
-        };
-        for (const { x, y, z } of Traverse.FromToVec3([0, 0, 0], [end[0] - 1, end[1] - 1, end[2] - 1], 1)) {
-            const vindex = this.index.getIndexXYZ(x, y, z);
-            curosr.position[0] = x;
-            curosr.position[1] = y;
-            curosr.position[2] = z;
-            raw[0] = this.getId(vindex);
-            raw[1] = 0;
-            raw[2] = this.getLevel(vindex);
-            raw[3] = this.getState(vindex);
-            raw[4] = this.getMod(vindex);
-            raw[5] = this.getSecondary(raw[0], vindex);
-            if (raw[0] < 1 && raw[3] < 1)
-                continue;
-            yield curosr;
-        }
-    }
-    toJSON() {
-        return {
-            templatorVersion: 0,
-            version: 0,
-            size: this.size,
-            palettes: {
-                id: this.idPalette._palette,
-                level: Uint8Array.from(this.statePalette._palette),
-                state: Uint16Array.from(this.statePalette._palette),
-                mod: Uint16Array.from(this.modPalette._palette),
-                secondaryId: this.secondaryIdPalette._palette,
-                secondaryState: Uint16Array.from(this.secondaryStatePalette._palette),
-            },
-            buffers: {
-                ids: this.ids instanceof Uint16Array ||
-                    this.ids instanceof Uint8Array ||
-                    typeof this.ids == "number"
-                    ? this.ids
-                    : new Uint8Array(this.ids.buffer),
-                level: this.level instanceof Uint8Array || typeof this.level == "number"
-                    ? this.level
-                    : new Uint8Array(this.level.buffer),
-                mod: this.mod instanceof Uint16Array ||
-                    this.mod instanceof Uint8Array ||
-                    typeof this.mod == "number"
-                    ? this.mod
-                    : new Uint8Array(this.mod.buffer),
-                state: this.state instanceof Uint16Array ||
-                    this.state instanceof Uint8Array ||
-                    typeof this.state == "number"
-                    ? this.state
-                    : new Uint8Array(this.state.buffer),
-                secondary: this.secondary instanceof Uint16Array ||
-                    this.secondary instanceof Uint8Array ||
-                    typeof this.secondary == "number"
-                    ? this.secondary
-                    : new Uint8Array(this.secondary.buffer),
-            },
-        };
-    }
-}

package/Util/Binary/BinaryBuffer.d.ts

@@ -1,29 +0,0 @@
-export type BinaryBufferTypes = 
-/**If the buffer compressed to a single value the type will be a vlaue */
-"value" | "1-bit" | "2-bit" | "4-bit" | "8-bit" | "16-bit";
-export interface BinaryBufferData {
-    type?: BinaryBufferTypes;
-    buffer: number | Uint8Array | Uint16Array;
-}
-export interface BinaryBuffer extends BinaryBufferData {
-}
-export declare class BinaryBuffer {
-    static BytePaletteMax: number;
-    static NibblePaletteMax: number;
-    static HalfNibblePaletteMax: number;
-    static BitPaletteMax: number;
-    static DetermineSubByteArray: (paletteSize: number) => BinaryBufferTypes | null;
-    static CreateBufferForType(type: BinaryBufferTypes, length: number): Uint16Array | Uint8Array;
-    static GetConvertedBufferSize(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
-    static GetIndexLength(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
-    static ReadBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number): number;
-    static SetBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number, value: number): number | void;
-    static Convert(source: Uint8Array | Uint16Array, sourceType: BinaryBufferTypes, destinationType: BinaryBufferTypes): Uint16Array | Uint8Array;
-    static Create(data: Partial<BinaryBufferData>): BinaryBufferData;
-    constructor(data: BinaryBufferData);
-    getValue(index: number): number;
-    toJSON(): {
-        type?: BinaryBufferTypes | undefined;
-        buffer: number | Uint16Array | Uint8Array;
-    };
-}

package/Util/Binary/BinaryBuffer.js

@@ -1,130 +0,0 @@
-import { getBitArrayIndex, getHalfNibbleArrayIndex, getNibbleArrayIndex, setBitArrayIndex, setHalfNibbleArrayIndex, setNibbleArrayIndex, } from "./BinaryArrays";
-const excludeStore = ["16-bit", "8-bit", "value"];
-export class BinaryBuffer {
-    static BytePaletteMax = 256;
-    static NibblePaletteMax = 16;
-    static HalfNibblePaletteMax = 4;
-    static BitPaletteMax = 2;
-    static DetermineSubByteArray = (paletteSize) => {
-        if (paletteSize == BinaryBuffer.BitPaletteMax)
-            return "1-bit";
-        if (paletteSize > BinaryBuffer.BitPaletteMax &&
-            paletteSize <= BinaryBuffer.HalfNibblePaletteMax)
-            return "2-bit";
-        if (paletteSize > BinaryBuffer.HalfNibblePaletteMax &&
-            paletteSize <= BinaryBuffer.NibblePaletteMax)
-            return "4-bit";
-        if (paletteSize > BinaryBuffer.NibblePaletteMax &&
-            paletteSize <= BinaryBuffer.BytePaletteMax)
-            return "8-bit";
-        return null;
-    };
-    static CreateBufferForType(type, length) {
-        if (type == "16-bit")
-            return new Uint16Array(length);
-        if (type == "8-bit")
-            return new Uint8Array(length);
-        if (type == "1-bit")
-            return new Uint8Array(length);
-        if (type == "2-bit")
-            return new Uint8Array(length);
-        if (type == "4-bit")
-            return new Uint8Array(length);
-        return new Uint8Array(length);
-    }
-    static GetConvertedBufferSize(source, type) {
-        if (type == "16-bit" || type == "8-bit")
-            return source.length;
-        if (type == "1-bit")
-            return source.length / 8;
-        if (type == "4-bit")
-            return source.length / 2;
-        if (type == "2-bit")
-            return source.length / 4;
-        if (type == "value")
-            return 1;
-        return source.length;
-    }
-    static GetIndexLength(source, type) {
-        if (type == "16-bit" || type == "8-bit")
-            return source.length;
-        if (type == "1-bit")
-            return source.length * 8;
-        if (type == "4-bit")
-            return source.length * 2;
-        if (type == "2-bit")
-            return source.length * 4;
-        if (type == "value")
-            return 1;
-        return source.length;
-    }
-    static ReadBufferAtIndex(source, type, index) {
-        if (type == "16-bit" || type == "8-bit")
-            return source[index];
-        if (type == "1-bit")
-            return getBitArrayIndex(source, index);
-        if (type == "4-bit")
-            return getNibbleArrayIndex(source, index);
-        if (type == "2-bit")
-            return getHalfNibbleArrayIndex(source, index);
-        return source[index];
-    }
-    static SetBufferAtIndex(source, type, index, value) {
-        if (type == "16-bit" || type == "8-bit") {
-            return (source[index] = value);
-        }
-        if (type == "1-bit")
-            return setBitArrayIndex(source, index, value);
-        if (type == "4-bit")
-            return setNibbleArrayIndex(source, index, value);
-        if (type == "2-bit")
-            return setHalfNibbleArrayIndex(source, index, value);
-        return source[index];
-    }
-    static Convert(source, sourceType, destinationType) {
-        if (sourceType == destinationType ||
-            (sourceType == "16-bit" && destinationType == "8-bit") ||
-            (sourceType == "8-bit" && destinationType == "16-bit")) {
-            const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
-            destination.set(source);
-            return destination;
-        }
-        const length = this.GetIndexLength(source, sourceType);
-        const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
-        for (let i = 0; i < length; i++) {
-            this.SetBufferAtIndex(destination, destinationType, i, this.ReadBufferAtIndex(source, sourceType, i));
-        }
-        return destination;
-    }
-    static Create(data) {
-        return {
-            buffer: 0,
-            ...data,
-        };
-    }
-    constructor(data) {
-        this.buffer = data.buffer;
-        if (data.type) {
-            this.type = data.type;
-        }
-        else {
-            if (typeof data.buffer === "number")
-                this.type = "value";
-            if (data.buffer instanceof Uint16Array)
-                this.type = "16-bit";
-            if (data.buffer instanceof Uint8Array)
-                this.type = "8-bit";
-        }
-    }
-    getValue(index) {
-        if (typeof this.buffer == "number")
-            return this.buffer;
-        return BinaryBuffer.ReadBufferAtIndex(this.buffer, this.type, index);
-    }
-    toJSON() {
-        return {
-            buffer: this.buffer,
-            ...(excludeStore.includes(this.type) ? {} : { type: this.type }),
-        };
-    }
-}

package/Util/Binary/Palettes.d.ts

@@ -1,5 +0,0 @@
-import { BitArray } from "@amodx/binary/Arrays/BitArray";
-import { HalfNibbleArray } from "@amodx/binary/Arrays/HalfNibbleArray";
-import { NibbleArray } from "@amodx/binary/Arrays/NibbleArray";
-export declare const convertToPaletteBuffer: (paletteSize: number, data: any, sharedMemory?: boolean) => Uint16Array | Uint8Array;
-export declare const getPaletteArray: (size: number, buffer: ArrayBufferLike) => ArrayBuffer | NibbleArray | HalfNibbleArray | BitArray;

package/Util/Binary/Palettes.js

@@ -1,46 +0,0 @@
-import { BitArray } from "@amodx/binary/Arrays/BitArray";
-import { HalfNibbleArray } from "@amodx/binary/Arrays/HalfNibbleArray";
-import { NibbleArray } from "@amodx/binary/Arrays/NibbleArray";
-export const convertToPaletteBuffer = (paletteSize, data, sharedMemory = false) => {
-    let buffer = data;
-    if (paletteSize > 15 && paletteSize <= 255) {
-        buffer = Uint8Array.from(data);
-    }
-    else if (paletteSize > 4 && paletteSize <= 15) {
-        buffer = new Uint8Array(data.length / 2);
-        const nibbleArray = new NibbleArray(buffer);
-        for (let i = 0; i < data.length; i++) {
-            nibbleArray[i] = data[i];
-        }
-    }
-    else if (paletteSize > 2 && paletteSize <= 4) {
-        buffer = new Uint8Array(data.length / 4);
-        const halfNibbleArray = new HalfNibbleArray(buffer);
-        for (let i = 0; i < data.length; i++) {
-            halfNibbleArray[i] = data[i];
-        }
-    }
-    else if (paletteSize == 2) {
-        buffer = new Uint8Array(data.length / 8);
-        const bitArray = new BitArray(buffer);
-        for (let i = 0; i < data.length; i++) {
-            bitArray[i] = data[i];
-        }
-    }
-    if (sharedMemory && !(buffer.buffer instanceof SharedArrayBuffer)) {
-        const sharedBuffer = new SharedArrayBuffer(buffer.byteLength);
-        const sharedView = new Uint8Array(sharedBuffer);
-        sharedView.set(buffer);
-        return sharedView;
-    }
-    return buffer;
-};
-export const getPaletteArray = (size, buffer) => {
-    if (size == 2)
-        return new BitArray(buffer);
-    if (size > 2 && size <= 4)
-        return new HalfNibbleArray(buffer);
-    if (size > 4 && size <= 15)
-        return new NibbleArray(buffer);
-    return buffer;
-};

package/Util/LocationVisitedMap.d.ts

@@ -1,9 +0,0 @@
-import { LocationData } from "../Math/index.js";
-export declare class LocationVisitedMap {
-    _map: Map<string, boolean>;
-    get size(): number;
-    has(location: LocationData): boolean;
-    add(location: LocationData): void;
-    remove(location: LocationData): void;
-    clear(): void;
-}

package/Util/LocationVisitedMap.js

@@ -1,18 +0,0 @@
-export class LocationVisitedMap {
-    _map = new Map();
-    get size() {
-        return this._map.size;
-    }
-    has(location) {
-        return this._map.has(location.toString());
-    }
-    add(location) {
-        this._map.set(location.toString(), true);
-    }
-    remove(location) {
-        this._map.delete(location.toString());
-    }
-    clear() {
-        this._map.clear();
-    }
-}

package/Util/VisistedMap.d.ts

@@ -1,10 +0,0 @@
-export declare class VisitedMap {
-    _map: Map<string, boolean>;
-    get size(): number;
-    _getKey(x: number, y: number, z: number): string;
-    inMap(x: number, y: number, z: number): boolean;
-    add(x: number, y: number, z: number): void;
-    remove(x: number, y: number, z: number): void;
-    removeDiffernce(map: VisitedMap): VisitedMap;
-    clear(): void;
-}

package/Util/VisistedMap.js

@@ -1,29 +0,0 @@
-export class VisitedMap {
-    _map = new Map();
-    get size() {
-        return this._map.size;
-    }
-    _getKey(x, y, z) {
-        return `${x}_${y}_${z}`;
-    }
-    inMap(x, y, z) {
-        return this._map.has(this._getKey(x, y, z));
-    }
-    add(x, y, z) {
-        this._map.set(this._getKey(x, y, z), true);
-    }
-    remove(x, y, z) {
-        this._map.delete(this._getKey(x, y, z));
-    }
-    removeDiffernce(map) {
-        for (const [key] of map._map) {
-            if (this._map.has(key)) {
-                this._map.delete(key);
-            }
-        }
-        return map;
-    }
-    clear() {
-        this._map.clear();
-    }
-}

package/Voxels/Data/VoxelTagStates.d.ts

@@ -1,22 +0,0 @@
-import { StateSchema } from "../State/Schema/StateSchema";
-import { StateTreeReader } from "../State/StateTreeReader";
-export type VoxelTagStatesData = Record<string, {
-    tree: any;
-    treePalette: any;
-}>[];
-export declare class VoxelTagStates {
-    static voxelTags: Record<string, {
-        tree: StateTreeReader;
-        treePalette: any[];
-    }>[];
-    static toJSON(): VoxelTagStatesData;
-    static load(data: VoxelTagStatesData): void;
-    static register(voxel: number, id: string, stateSchema: StateSchema, tree: any[], treePalette: any[]): void;
-    static isRegistered(voxel: number, id: string): boolean;
-    static getData(voxel: number, id: string): {
-        tree: StateTreeReader;
-        treePalette: any[];
-    };
-    static getState(voxel: number, id: string, state: number): number;
-    static getValue(voxel: number, id: string, state: number): any;
-}

package/Voxels/Data/VoxelTagStates.js

@@ -1,47 +0,0 @@
-import { VoxelPalettesRegister } from "./VoxelPalettesRegister";
-import { StateSchema } from "../State/Schema/StateSchema";
-import { StateTreeReader } from "../State/StateTreeReader";
-import { SchemaRegister } from "../State/SchemaRegister";
-export class VoxelTagStates {
-    static voxelTags = [];
-    static toJSON() {
-        const data = [];
-        this.voxelTags.forEach((v, index) => {
-            data[index] = Object.fromEntries(Object.keys(v).map((k) => [
-                k,
-                { tree: v[k].tree.tree, treePalette: v[k].treePalette },
-            ]));
-        });
-        return data;
-    }
-    static load(data) {
-        data.forEach((v, index) => {
-            if (!v)
-                return;
-            const stateSceham = new StateSchema(SchemaRegister.modelStaeBaseSchemaData.get(SchemaRegister.voxelModelMap.get(VoxelPalettesRegister.voxels.getStringId(index))));
-            for (const tag in v) {
-                this.register(index, tag, stateSceham, v[tag].tree, v[tag].treePalette);
-            }
-        });
-    }
-    static register(voxel, id, stateSchema, tree, treePalette) {
-        let tags = this.voxelTags[voxel];
-        if (!tags) {
-            tags = {};
-            this.voxelTags[voxel] = tags;
-        }
-        tags[id] = { tree: new StateTreeReader(stateSchema, 0, tree), treePalette };
-    }
-    static isRegistered(voxel, id) {
-        return this.voxelTags[voxel] && this.voxelTags[voxel][id] !== undefined;
-    }
-    static getData(voxel, id) {
-        return this.voxelTags[voxel][id];
-    }
-    static getState(voxel, id, state) {
-        return this.voxelTags[voxel][id].tree.getState(state);
-    }
-    static getValue(voxel, id, state) {
-        return this.voxelTags[voxel][id].treePalette[this.voxelTags[voxel][id].tree.getState(state)];
-    }
-}