@divinevoxel/vlox 0.0.3 → 0.0.5

package/World/WorldSpaces.d.ts

@@ -0,0 +1,34 @@
+import { Vec3Array, Vector3Like } from "@amodx/math";
+declare class SectorSpace {
+    static power2Axes: Vector3Like;
+    static bounds: Vector3Like;
+    static volumne: number;
+    static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
+    static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
+}
+declare class SectionSpace {
+    static power2Axes: Vector3Like;
+    static bounds: Vector3Like;
+    static volumne: number;
+    static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
+    static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
+    static getIndex(x: number, y: number, z: number): number;
+}
+declare class VoxelSpace {
+    static bounds: Vector3Like;
+    static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
+    static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
+    static getIndex(x: number, y: number, z: number): number;
+}
+declare class Hash {
+    static hashVec3(vector3: Vector3Like): string;
+    static hashVec3Array(vector3: Vec3Array): string;
+    static hashXYZ(x: number, y: number, z: number): string;
+}
+export declare class WorldSpaces {
+    static hash: typeof Hash;
+    static sector: typeof SectorSpace;
+    static section: typeof SectionSpace;
+    static voxel: typeof VoxelSpace;
+}
+export {};

package/World/WorldSpaces.js

@@ -0,0 +1,96 @@
+//types
+import { EngineSettings } from "../Settings/EngineSettings.js";
+import { Vector3Like } from "@amodx/math";
+import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, } from "../Math/Indexing.js";
+const tempPosition = Vector3Like.Create();
+const tempPosition2 = Vector3Like.Create();
+class SectorSpace {
+    static power2Axes = Vector3Like.Create();
+    static bounds = Vector3Like.Create();
+    static volumne = 0;
+    static getPosition(x, y, z, refPosition = Vector3Like.Create()) {
+        CubeHashVec3(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
+        return refPosition;
+    }
+    static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
+        CubeHashVec3Array(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
+        return refPosition;
+    }
+}
+class SectionSpace {
+    static power2Axes = Vector3Like.Create();
+    static bounds = Vector3Like.Create();
+    static volumne = 0;
+    static getPosition(x, y, z, refPosition = Vector3Like.Create()) {
+        CubeHashVec3(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, refPosition);
+        return refPosition;
+    }
+    static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
+        CubeHashVec3Array(x, y, z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z, refPosition);
+        return refPosition;
+    }
+    static getIndex(x, y, z) {
+        SectionSpace.getPosition(x, y, z, tempPosition);
+        SectorSpace.getPosition(x, y, z, tempPosition2);
+        return (tempPosition.y - tempPosition2.y) / SectionSpace.bounds.y;
+    }
+}
+class VoxelSpace {
+    static bounds = Vector3Like.Create();
+    static getPosition(x, y, z, refPosition = Vector3Like.Create()) {
+        CubeHashVec3(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, refPosition);
+        refPosition.x = x - refPosition.x;
+        refPosition.y = y - refPosition.y;
+        refPosition.z = z - refPosition.z;
+        return refPosition;
+    }
+    static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
+        CubeHashVec3Array(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, refPosition);
+        refPosition[0] = x - refPosition[0];
+        refPosition[1] = y - refPosition[1];
+        refPosition[2] = z - refPosition[2];
+        return refPosition;
+    }
+    static getIndex(x, y, z) {
+        const position = this.getPosition(x, y, z, tempPosition);
+        return GetYXZOrderArrayIndex(position.x, position.y, position.z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z);
+    }
+}
+class Hash {
+    static hashVec3(vector3) {
+        return `${vector3.x}-${vector3.y}-${vector3.z}`;
+    }
+    static hashVec3Array(vector3) {
+        return `${vector3[0]}-${vector3[1]}-${vector3[2]}`;
+    }
+    static hashXYZ(x, y, z) {
+        return `${x}-${y}-${z}`;
+    }
+}
+export class WorldSpaces {
+    static hash = Hash;
+    static sector = SectorSpace;
+    static section = SectionSpace;
+    static voxel = VoxelSpace;
+}
+EngineSettings.addEventListener("synced", (event) => {
+    event.detail.settings;
+    SectorSpace.power2Axes.x = EngineSettings.settings.sectors.sectorXPow2;
+    SectorSpace.power2Axes.y = EngineSettings.settings.sectors.sectorYPow2;
+    SectorSpace.power2Axes.z = EngineSettings.settings.sectors.sectorZPow2;
+    SectorSpace.bounds.x = 1 << SectorSpace.power2Axes.x;
+    SectorSpace.bounds.y = 1 << SectorSpace.power2Axes.y;
+    SectorSpace.bounds.z = 1 << SectorSpace.power2Axes.z;
+    SectionSpace.power2Axes.x = EngineSettings.settings.sections.sectionXPow2;
+    SectionSpace.power2Axes.y = EngineSettings.settings.sections.sectionYPow2;
+    SectionSpace.power2Axes.z = EngineSettings.settings.sections.sectionZPow2;
+    SectionSpace.bounds.x = 1 << SectionSpace.power2Axes.x;
+    SectionSpace.bounds.y = 1 << SectionSpace.power2Axes.y;
+    SectionSpace.bounds.z = 1 << SectionSpace.power2Axes.z;
+    SectionSpace.volumne =
+        SectionSpace.bounds.x * SectionSpace.bounds.y * SectionSpace.bounds.z;
+    SectorSpace.volumne =
+        (SectorSpace.bounds.x / SectionSpace.bounds.x) *
+            (SectorSpace.bounds.y / SectionSpace.bounds.y) *
+            (SectorSpace.bounds.z / SectionSpace.bounds.z);
+});

package/World/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Section/Section.js";
+export * from "./Sector/Sector.js";
+export * from "./Dimension/Dimension.js";
+export * from "./Cursor/WorldCursor.js";

package/World/index.js

@@ -0,0 +1,4 @@
+export * from "./Section/Section.js";
+export * from "./Sector/Sector.js";
+export * from "./Dimension/Dimension.js";
+export * from "./Cursor/WorldCursor.js";

package/index.d.ts

@@ -1 +1 @@
-export * from "./Voxels/Voxel.types";
+export * from "./Voxels/Types/Voxel.types";

package/index.js

@@ -1 +1 @@
-export * from "./Voxels/Voxel.types";
+export * from "./Voxels/Types/Voxel.types";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.03",
+  "version": "0.0.05",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,15 +20,9 @@
     "url": "https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"
   },
   "dependencies": {
-    "@amodx/meshing": "latest",
-    "@dvegames/vlox": "latest",
-    "@dvegames/vlox-tools": "latest",
     "@amodx/math": "latest",
     "@amodx/binary": "latest",
-    "@amodx/threads": "latest",
-    "@amodx/indexdb": "latest",
-    "@amodx/controls": "latest",
-    "@amodx/rng": "latest"
+    "@amodx/threads": "latest"
   },
   "publishConfig": {
     "access": "public"

package/Archive/Archive.types.d.ts

@@ -1,176 +0,0 @@
-import { Vec3Array } from "@amodx/math";
-import { LocationData } from "../Math";
-/**
- * Interface for an archived column.
- */
-export interface ArchivedColumnData {
-    /** Number representing the version of the archiver used. */
-    archiverVersion: number;
-    /** Number representing the version of the column data. */
-    version: number;
-    /** The location of the column in the world. */
-    location: LocationData;
-    /** Record of the column's state, storing dynamic or user-defined data. */
-    columnState: Record<string, any>;
-    /** The palette data used within the column. */
-    palettes: ArchivedColumnPaletteData;
-    /** Placeholder for future buffer data. */
-    buffers: ArchivedColumnBuffersData;
-    /** Keys associated with chunk states and other objects. */
-    keys: ArchivedColumnKeysData;
-    /** Array of archived chunk data within the column. */
-    chunks: ArchivedChunkData[];
-}
-/**
- * Interface for the palettes of an archived column.
- */
-export interface ArchivedColumnPaletteData {
-    /** Array of strings representing the unique identifiers for the primary voxel types in the column. */
-    id: string[];
-    /** Optional array of strings for the secondary voxel types, providing additional data for complex structures. */
-    secondaryId?: string[];
-    /** Optional Uint16Array representing the state of voxels, indicating specific conditions or variations. */
-    state?: Uint16Array;
-    /** Optional Uint16Array representing the mod state of voxels, indicating specific conditions or variations. */
-    mod?: Uint16Array;
-    /** Optional Uint16Array representing light levels for each voxel in the column. */
-    light?: Uint16Array;
-    /** Optional Uint16Array representing the state of secondary voxels. */
-    secondaryState?: Uint16Array;
-}
-/**
- * Interface for the keys of an archived column.
- */
-export interface ArchivedColumnKeysData {
-    /** Array of strings that are the keys for the chunk state struct.  */
-    chunkState: string[];
-}
-/**
- * Placeholder interface for future buffer data in a column.
- */
-export interface ArchivedColumnBuffersData {
-}
-/**
- * Interface for an archived chunk.
- */
-export interface ArchivedChunkData {
-    /** Array representing the chunk's state, holding dynamic or user-defined data. */
-    state: any[];
-    /** Palette data used within the chunk. */
-    palettes: ArchivedChunkPaletteData;
-    /** Buffer data for the chunk, holding voxel type identifiers, light data, state, and secondary state. */
-    buffers: ArchivedChunkBuffers;
-}
-/**
- * Interface representing the palette data for a single chunk in the voxel engine.
- */
-export interface ArchivedChunkPaletteData {
-    /** Optional Uint16Array representing the voxel type identifiers within the chunk. */
-    id?: Uint16Array;
-    /** Optional Uint16Array for storing light data. */
-    light?: Uint16Array;
-    /** Optional Uint16Array for secondary voxel type identifiers. */
-    secondaryId?: Uint16Array;
-    /** Optional Uint16Array for storing voxel states within the chunk. */
-    state?: Uint16Array;
-    /** Optional Uint16Array for storing mod data. */
-    mod?: Uint16Array;
-    /** Optional Uint16Array for storing states of secondary voxels. */
-    secondaryState?: Uint16Array;
-}
-/**
- * Interface representing the buffer data for a chunk.
- */
-export interface ArchivedChunkBuffers {
-    /** The buffer for voxel type identifiers, which could be a Uint16Array, Uint8Array, or a single number if all voxels are the same. */
-    id: Uint16Array | Uint8Array | number;
-    /** The buffer for light data, which could be a Uint16Array, Uint8Array, or a single number if all light values are the same. */
-    light: Uint16Array | Uint8Array | number;
-    /** The buffer for voxel states, which could be a Uint16Array, Uint8Array, or a single number if all states are the same. */
-    state: Uint16Array | Uint8Array | number;
-    /** The buffer for voxel mod states, which could be a Uint16Array, Uint8Array, or a single number if all states are the same. */
-    mod: Uint16Array | Uint8Array | number;
-    /** The buffer for secondary voxel data, which could be a Uint16Array, Uint8Array, or a single number if all secondary data is the same. */
-    secondary: Uint16Array | Uint8Array | number;
-}
-/**
- * Interface for an archived area.
- */
-export interface ArchivedAreaData {
-    /** Number representing the version of the archiver used. */
-    archiverVersion: number;
-    /** Number representing the version of the area data. */
-    version: number;
-    /** String representing the dimension or world type the area belongs to. */
-    dimension: string;
-    /** The palette maps for the area, including voxel, light, and state data. */
-    maps: ArchivedAreaMapData;
-    /** Keys associated with column and chunk states and other objects. */
-    keys: ArchivedAreaKeysData;
-    /** Array of archived column data within the area. */
-    columns: ArchivedAreaColumnData[];
-}
-/**
- * Interface for an archived area maps.
- */
-export interface ArchivedAreaMapData {
-    /** Record mapping voxel IDs to string identifiers. */
-    id: Record<string, string>;
-    /** Record mapping string IDs to arrays of voxel identifiers. */
-    idPalette: Record<string, string[]>;
-    /** Record mapping string IDs to arrays of secondary voxel identifiers. */
-    secondaryIdPalette: Record<string, string[]>;
-    /** Record mapping string IDs to Uint16Arrays of light data. */
-    lightPalette: Record<string, Uint16Array>;
-    /** Record mapping string IDs to Uint16Arrays of voxel states. */
-    statePalette: Record<string, Uint16Array>;
-    /** Record mapping string IDs to Uint16Arrays of voxel mods. */
-    modPalette: Record<string, Uint16Array>;
-    /** Record mapping string IDs to Uint16Arrays of secondary voxel states. */
-    secondaryStatePalette: Record<string, Uint16Array>;
-    /** Record mapping chunk identifiers to `ArchivedChunkData`. */
-    chunk: Record<string, ArchivedChunkData>;
-    /** Record mapping column state identifiers to arrays of state data. */
-    columnState: Record<string, any[]>;
-}
-/**
- * Interface representing the keys associated with column and chunk states within an area.
- */
-export interface ArchivedAreaKeysData {
-    /** Array of strings that are the keys for the column state struct.  */
-    columnState: string[];
-    /** Array of strings that are the keys for the chunk state struct.  */
-    chunkState: string[];
-}
-/**
- * Interface representing the palette data for a column within an area.
- */
-export interface ArchivedAreaColumnPaletteData {
-    /** Array of strings representing the unique identifiers for the primary voxel types in the column. */
-    id: string[];
-    /** Optional array of strings for secondary voxel types. */
-    secondary?: string[];
-    /** Optional Uint16Array representing the state of voxels in the column. */
-    state?: Uint16Array;
-    /** Optional Uint16Array representing the mod of voxels in the column. */
-    mod?: Uint16Array;
-    /** Optional Uint16Array representing light levels for each voxel in the column. */
-    light?: Uint16Array;
-    /** Optional Uint16Array representing the state of secondary voxels. */
-    secondaryState?: Uint16Array;
-}
-/**
- * Interface representing the archived data for a column within an area.
- */
-export interface ArchivedAreaColumnData {
-    /** A Vec3Array representing the position of the column within the area. */
-    position: Vec3Array;
-    /** The state data for the column, either as an array or a reference string. */
-    columnState: any[] | string;
-    /** Buffer data for the column. */
-    buffers: ArchivedColumnBuffersData;
-    /** The palette data used within the column. */
-    palettes: ArchivedAreaColumnPaletteData;
-    /** Array of archived chunk data or references to chunk data. */
-    chunks: (ArchivedChunkData | string)[];
-}

package/Archive/Functions/ArchiveArea.d.ts

@@ -1,10 +0,0 @@
-import { ArchivedAreaColumnData, ArchivedAreaData, ArchivedColumnData } from "../Archive.types";
-type RunData = {
-    dimension: string;
-    columns: ArchivedColumnData[];
-    version?: number;
-};
-export default function CreateArchiveArea(archiveData: RunData): ArchivedAreaData;
-export declare function CreateColumnFromArea(area: ArchivedAreaData, column: ArchivedAreaColumnData): ArchivedColumnData;
-export declare function CreateColumnsFromArea(area: ArchivedAreaData): Generator<ArchivedColumnData>;
-export {};

package/Archive/Functions/ArchiveArea.js

@@ -1,315 +0,0 @@
-import { BinaryObject } from "@amodx/binary";
-import { Column } from "../../Data/World/Classes";
-const charset = "0123456789ABCDEF";
-function uint16To4CharString(value) {
-    if (value < 0 || value > 0xffff) {
-        throw new RangeError("Value must be a 16-bit unsigned integer.");
-    }
-    const chars = [];
-    for (let i = 0; i < 4; i++) {
-        const charCode = (value >> (i * 4)) & 0x0f;
-        chars.unshift(charset[charCode]);
-    }
-    const result = chars.join("").replace(/^0+(?!$)/, "");
-    return result;
-}
-let columnStructInstance;
-const processPalettes = (archiveData) => {
-    const allRegistered = new Set();
-    archiveData.columns.forEach((_) => {
-        _.palettes.id.forEach((_) => {
-            allRegistered.add(_);
-        });
-        _.palettes.secondaryId &&
-            _.palettes.secondaryId.forEach((_) => {
-                allRegistered.add(_);
-            });
-    });
-    let count = 0;
-    const idMap = {};
-    const idRecord = {};
-    for (const voxelId of allRegistered) {
-        const newId = uint16To4CharString(count);
-        idMap[voxelId] = newId;
-        idRecord[newId] = voxelId;
-        count++;
-    }
-    archiveData.columns.forEach((_) => {
-        _.palettes.id.forEach((id, index) => {
-            _.palettes.id[index] = idMap[id];
-        });
-        _.palettes.secondaryId &&
-            _.palettes.secondaryId.forEach((id, index) => {
-                _.palettes.secondaryId[index] = idMap[id];
-            });
-    });
-    return idRecord;
-};
-const hashBuffer = (buffer) => {
-    const data = new Uint8Array(buffer);
-    let hash = "";
-    for (let i = 0; i < data.length; i++) {
-        hash += data[i].toString(16).padStart(2, "0");
-    }
-    return hash;
-};
-const processChunks = (archiveData) => {
-    const chunMap = {};
-    const created = new Map();
-    const maped = new Map();
-    const binaryObjects = new Map();
-    let count = 0;
-    const process = (object) => {
-        if (typeof object == "string")
-            return object;
-        let binaryObject = binaryObjects.get(object);
-        if (!binaryObject) {
-            binaryObject = BinaryObject.objectToBuffer(object);
-            binaryObjects.set(object, binaryObject);
-        }
-        let hash = hashBuffer(binaryObject);
-        if (maped.has(hash))
-            return maped.get(hash);
-        if (created.has(hash) && created.get(hash) == 0) {
-            created.set(hash, 1);
-            const id = uint16To4CharString(count);
-            chunMap[id] = object;
-            maped.set(hash, id);
-            count++;
-            return id;
-        }
-        if (!created.has(hash)) {
-            created.set(hash, 0);
-        }
-        return object;
-    };
-    archiveData.columns.forEach((_) => {
-        _.chunks = _.chunks.map((_) => process(_));
-    });
-    created.clear();
-    archiveData.columns.forEach((_) => {
-        _.chunks = _.chunks.map((_) => process(_));
-    });
-    return chunMap;
-};
-const processColumnStates = (archiveData) => {
-    const columnStateMap = {};
-    const created = new Map();
-    const maped = new Map();
-    const binaryObjects = new Map();
-    let count = 0;
-    const columnStateKeys = columnStructInstance.getKeys();
-    const process = (column) => {
-        if (typeof column.columnState == "string")
-            return column.columnState;
-        if (!Array.isArray(column.columnState)) {
-            const columnState = [];
-            for (let i = 0; i < columnStateKeys.length; i++) {
-                columnState[i] = column.columnState[columnStateKeys[i]];
-            }
-            column.columnState = columnState;
-        }
-        let binaryObject = binaryObjects.get(column.columnState);
-        if (!binaryObject) {
-            binaryObject = BinaryObject.objectToBuffer(column.columnState);
-            binaryObjects.set(column.columnState, binaryObject);
-        }
-        let hash = hashBuffer(binaryObject);
-        if (maped.has(hash)) {
-            column.columnState = maped.get(hash);
-            return;
-        }
-        if (created.has(hash) && created.get(hash) == 0) {
-            created.set(hash, 1);
-            const id = uint16To4CharString(count);
-            columnStateMap[id] = column.columnState;
-            maped.set(hash, id);
-            count++;
-            column.columnState = id;
-            return id;
-        }
-        if (!created.has(hash)) {
-            created.set(hash, 0);
-        }
-        return column.columnState;
-    };
-    archiveData.columns.forEach((_) => {
-        process(_);
-    });
-    created.clear();
-    archiveData.columns.forEach((_) => {
-        process(_);
-    });
-    return columnStateMap;
-};
-const getPaletteMaps = (archiveData) => {
-    const createPaletteMaps = (paletteType, paletteMap, paletteIdsMap) => {
-        const created = new Map();
-        let count = 0;
-        archiveData.columns.forEach((column) => {
-            const palette = column.palettes[paletteType];
-            if (!palette)
-                return;
-            if (typeof palette == "string")
-                return;
-            const hash = paletteType === "id" || paletteType === "secondaryId"
-                ? JSON.stringify(palette)
-                : hashBuffer(palette);
-            if (paletteIdsMap.has(hash)) {
-                column.palettes[paletteType] = paletteIdsMap.get(hash);
-                return;
-            }
-            if (created.has(hash) && created.get(hash) === 0) {
-                created.set(hash, 1);
-                const id = uint16To4CharString(count);
-                paletteMap[id] = palette;
-                paletteIdsMap.set(hash, id);
-                count++;
-                column.palettes[paletteType] = id;
-                return id;
-            }
-            if (!created.has(hash)) {
-                created.set(hash, 0);
-            }
-        });
-    };
-    const lightPalette = {};
-    const lightPaletteIdMap = new Map();
-    createPaletteMaps("light", lightPalette, lightPaletteIdMap);
-    createPaletteMaps("light", lightPalette, lightPaletteIdMap);
-    const statePalette = {};
-    const statePaletteIdsMap = new Map();
-    createPaletteMaps("state", statePalette, statePaletteIdsMap);
-    createPaletteMaps("state", statePalette, statePaletteIdsMap);
-    const modPalette = {};
-    const modPaletteIdsMap = new Map();
-    createPaletteMaps("mod", modPalette, modPaletteIdsMap);
-    createPaletteMaps("mod", modPalette, modPaletteIdsMap);
-    const secondaryStatePalette = {};
-    const secondaryStatePaletteIdsMap = new Map();
-    createPaletteMaps("secondaryState", secondaryStatePalette, secondaryStatePaletteIdsMap);
-    createPaletteMaps("secondaryState", secondaryStatePalette, secondaryStatePaletteIdsMap);
-    const idPalette = {};
-    const idsPaletteIdsMap = new Map();
-    createPaletteMaps("id", idPalette, idsPaletteIdsMap);
-    createPaletteMaps("id", idPalette, idsPaletteIdsMap);
-    const secondaryIdPalette = {};
-    const secondaryIdsPaletteIdsMap = new Map();
-    createPaletteMaps("secondaryId", secondaryIdPalette, secondaryIdsPaletteIdsMap);
-    createPaletteMaps("secondaryId", secondaryIdPalette, secondaryIdsPaletteIdsMap);
-    return {
-        idPalette,
-        secondaryIdPalette,
-        lightPalette,
-        statePalette,
-        secondaryStatePalette,
-        modPalette,
-    };
-};
-export default function CreateArchiveArea(archiveData) {
-    if (!columnStructInstance)
-        columnStructInstance = Column.StateStruct.instantiate();
-    const columnStateKeys = columnStructInstance.getKeys();
-    return {
-        dimension: archiveData.dimension,
-        archiverVersion: 0,
-        version: archiveData.version || 0,
-        keys: {
-            columnState: columnStateKeys,
-            chunkState: archiveData.columns[0].keys.chunkState,
-        },
-        maps: {
-            columnState: processColumnStates(archiveData),
-            id: processPalettes(archiveData),
-            chunk: processChunks(archiveData),
-            ...getPaletteMaps(archiveData),
-        },
-        columns: archiveData.columns.map((column) => {
-            return {
-                position: [column.location[1], column.location[2], column.location[3]],
-                columnState: column.columnState,
-                buffers: column.buffers,
-                palettes: {
-                    id: column.palettes.id,
-                    ...(column.palettes.secondaryId
-                        ? {
-                            secondaryIds: column.palettes.secondaryId,
-                        }
-                        : {}),
-                    ...(column.palettes.light
-                        ? {
-                            light: column.palettes.light,
-                        }
-                        : {}),
-                    ...(column.palettes.secondaryState
-                        ? {
-                            secondaryState: column.palettes.secondaryState,
-                        }
-                        : {}),
-                    ...(column.palettes.state
-                        ? {
-                            state: column.palettes.state,
-                        }
-                        : {}),
-                    ...(column.palettes.mod
-                        ? {
-                            mod: column.palettes.mod,
-                        }
-                        : {}),
-                },
-                chunks: column.chunks,
-            };
-        }),
-    };
-}
-export function CreateColumnFromArea(area, column) {
-    const columnState = {};
-    const currentState = typeof column.columnState == "string"
-        ? area.maps.columnState[column.columnState]
-        : column.columnState;
-    for (let i = 0; i < area.keys.columnState.length; i++) {
-        columnState[area.keys.columnState[i]] = currentState[i];
-    }
-    return {
-        archiverVersion: area.archiverVersion,
-        version: area.version,
-        location: [area.dimension, ...column.position],
-        palettes: {
-            id: (typeof column.palettes.id == "string"
-                ? area.maps.idPalette[column.palettes.id]
-                : column.palettes.id).map((_) => area.maps.id[_]),
-            light: typeof column.palettes.light == "string"
-                ? area.maps.lightPalette[column.palettes.light]
-                : column.palettes.light,
-            secondaryId: column.palettes.secondary
-                ? (typeof column.palettes.secondary == "string"
-                    ? area.maps.secondaryIdPalette[column.palettes.secondary]
-                    : column.palettes.secondary).map((_) => area.maps.id[_])
-                : undefined,
-            secondaryState: typeof column.palettes.secondaryState == "string"
-                ? area.maps.secondaryStatePalette[column.palettes.secondaryState]
-                : column.palettes.secondaryState,
-            state: typeof column.palettes.state == "string"
-                ? area.maps.statePalette[column.palettes.state]
-                : column.palettes.state,
-            mod: typeof column.palettes.mod == "string"
-                ? area.maps.statePalette[column.palettes.mod]
-                : column.palettes.mod,
-        },
-        buffers: column.buffers,
-        columnState,
-        keys: {
-            chunkState: area.keys.chunkState,
-        },
-        chunks: column.chunks.map((_) => {
-            if (typeof _ == "string")
-                return area.maps.chunk[_];
-            return _;
-        }),
-    };
-}
-export function* CreateColumnsFromArea(area) {
-    for (const column of area.columns) {
-        yield CreateColumnFromArea(area, column);
-    }
-}