@divinevoxel/vlox 0.0.0

package/Archive/Functions/ArchiveArea.js

@@ -0,0 +1,315 @@
+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);
+    }
+}

package/Archive/Functions/ArchiveColumn.d.ts

@@ -0,0 +1,8 @@
+import { LocationData } from "../../Math";
+import { ArchivedColumnData } from "../Archive.types";
+type ArchiveColumnData = {
+    version?: number;
+    location: LocationData;
+};
+export default function ArchiveColumn(archiveData: ArchiveColumnData): ArchivedColumnData;
+export {};

package/Archive/Functions/ArchiveColumn.js

@@ -0,0 +1,293 @@
+import { StringPalette } from "../../Interfaces/Data/StringPalette";
+import { NumberPalette } from "../../Interfaces/Data/NumberPalette";
+import { WorldRegister } from "../../Data/World/WorldRegister";
+import { VoxelPalette } from "../../Data/Voxel/VoxelPalette";
+import { VoxelStruct } from "../../Data/Voxel/VoxelStruct";
+import { VoxelTagIDs } from "../../Data/Constants/VoxelTagIds";
+import { Chunk, Column } from "../../Data/World/Classes";
+import { convertToPaletteBuffer } from "./Palettes";
+const getArchiveChunkState = (chunk) => {
+    return {
+        chunk,
+        ids: new Uint16Array(chunk.ids.length),
+        light: new Uint16Array(chunk.light.length),
+        state: new Uint16Array(chunk.state.length),
+        secondary: new Uint16Array(chunk.secondary.length),
+        mod: new Uint16Array(chunk.mod.length),
+        idPalette: new NumberPalette(),
+        lightPalette: new NumberPalette(),
+        statePalette: new NumberPalette(),
+        modPalette: new NumberPalette(),
+        secondaryPalette: new NumberPalette(),
+        secondaryStatePalette: new NumberPalette(),
+        isLightPaletted: false,
+        isSecondaryPaletted: false,
+        isStatePaletted: false,
+        isModPaletted: false,
+        rempaedLight: false,
+        rempaedIds: false,
+        rempaedState: false,
+        rempaedMod: false,
+        rempaedSecondary: false,
+        idsAllTheSame: true,
+        stateAllTheSame: true,
+        lightAllTheSame: true,
+        modAllTheSame: true,
+        secondaryAllTheSame: true,
+    };
+};
+let columnStructInstance;
+let chunkStructInstance;
+export default function ArchiveColumn(archiveData) {
+    WorldRegister.instance.setDimension(archiveData.location[0]);
+    const column = WorldRegister.instance.column.get(archiveData.location[1], archiveData.location[2], archiveData.location[3]);
+    if (!column)
+        throw new Error(`Column at location ${location} does not exist when trying to arhicve it.`);
+    if (!columnStructInstance)
+        columnStructInstance = Column.StateStruct.instantiate();
+    if (!chunkStructInstance)
+        chunkStructInstance = Chunk.StateStruct.instantiate();
+    const idsPalette = new StringPalette();
+    const lightPalette = new NumberPalette();
+    const secondaryPalette = new StringPalette();
+    const statePalette = new NumberPalette();
+    const modPalette = new NumberPalette();
+    const secondaryStatePalette = new NumberPalette();
+    columnStructInstance.setBuffer(column.columnState.buffer);
+    const columnState = columnStructInstance.serialize();
+    const states = [];
+    for (const chunk of column.chunks) {
+        const length = chunk.ids.length;
+        let firstId = -1;
+        let firstMod = -1;
+        let firstState = -1;
+        let firstLight = -1;
+        let firstSecondary = -1;
+        const archivedChunk = getArchiveChunkState(chunk);
+        for (let i = 0; i < length; i++) {
+            const stringId = VoxelPalette.ids.getStringId(chunk.ids[i]);
+            VoxelStruct.setStringVoxel(stringId);
+            const voxelId = !idsPalette.isRegistered(stringId)
+                ? idsPalette.register(stringId)
+                : idsPalette.getNumberId(stringId);
+            if (!archivedChunk.idPalette.isRegistered(voxelId))
+                archivedChunk.idPalette.register(voxelId);
+            if (firstId == -1)
+                firstId = voxelId;
+            const voxelState = !statePalette.isRegistered(chunk.state[i])
+                ? statePalette.register(chunk.state[i])
+                : statePalette.getId(chunk.state[i]);
+            if (!archivedChunk.statePalette.isRegistered(voxelState))
+                archivedChunk.statePalette.register(voxelState);
+            if (firstState == -1)
+                firstState = voxelState;
+            const voxelMod = !modPalette.isRegistered(chunk.mod[i])
+                ? modPalette.register(chunk.mod[i])
+                : modPalette.getId(chunk.mod[i]);
+            if (!archivedChunk.modPalette.isRegistered(voxelMod))
+                archivedChunk.modPalette.register(voxelMod);
+            if (firstMod == -1)
+                firstMod = voxelMod;
+            const voxelLight = !lightPalette.isRegistered(chunk.light[i])
+                ? lightPalette.register(chunk.light[i])
+                : lightPalette.getId(chunk.light[i]);
+            if (!archivedChunk.lightPalette.isRegistered(voxelLight))
+                archivedChunk.lightPalette.register(voxelLight);
+            if (firstLight == -1)
+                firstLight = voxelLight;
+            const secondaryId = VoxelStruct.instance[VoxelTagIDs.canHaveSecondary] == 1 &&
+                VoxelPalette.ids.getStringId(chunk.secondary[i]);
+            const voxelSecondary = secondaryId
+                ? !secondaryPalette.isRegistered(secondaryId)
+                    ? secondaryPalette.register(secondaryId)
+                    : secondaryPalette.getNumberId(secondaryId)
+                : !secondaryStatePalette.isRegistered(chunk.secondary[i])
+                    ? secondaryStatePalette.register(chunk.secondary[i])
+                    : secondaryStatePalette.getId(chunk.secondary[i]);
+            secondaryId
+                ? !archivedChunk.secondaryPalette.isRegistered(voxelSecondary) &&
+                    archivedChunk.secondaryPalette.register(voxelSecondary)
+                : !archivedChunk.secondaryStatePalette.isRegistered(voxelSecondary) &&
+                    archivedChunk.secondaryStatePalette.register(voxelSecondary);
+            if (firstSecondary == -1)
+                firstSecondary = voxelSecondary;
+            if (voxelId != firstId)
+                archivedChunk.idsAllTheSame = false;
+            if (voxelState != firstState)
+                archivedChunk.stateAllTheSame = false;
+            if (voxelMod != firstMod)
+                archivedChunk.modAllTheSame = false;
+            if (voxelLight != firstLight)
+                archivedChunk.lightAllTheSame = false;
+            if (voxelSecondary != firstSecondary)
+                archivedChunk.secondaryAllTheSame = false;
+            archivedChunk.ids[i] = voxelId;
+            archivedChunk.state[i] = voxelState;
+            archivedChunk.mod[i] = voxelMod;
+            archivedChunk.secondary[i] = voxelSecondary;
+            archivedChunk.light[i] = voxelLight;
+        }
+        states.push(archivedChunk);
+    }
+    for (const chunk of states) {
+        const reMapIds = chunk.idPalette.size < idsPalette.size &&
+            chunk.idPalette.size <= 255 &&
+            !chunk.idsAllTheSame;
+        const reMapState = chunk.statePalette.size < statePalette.size &&
+            chunk.statePalette.size <= 255 &&
+            !chunk.stateAllTheSame;
+        const reMapMod = chunk.modPalette.size < modPalette.size &&
+            chunk.modPalette.size <= 255 &&
+            !chunk.modAllTheSame;
+        const reMapLight = chunk.lightPalette.size < lightPalette.size &&
+            chunk.lightPalette.size <= 255 &&
+            !chunk.lightAllTheSame;
+        const reMapSecondary = Math.max(chunk.secondaryPalette.size, chunk.secondaryStatePalette.size) <
+            Math.max(secondaryStatePalette.size, secondaryPalette.size) &&
+            Math.max(chunk.secondaryPalette.size, chunk.secondaryStatePalette.size) <=
+                255 &&
+            !chunk.secondaryAllTheSame;
+        chunk.isLightPaletted =
+            lightPalette.size < 65_535 && chunk.lightPalette.size < 255;
+        chunk.isStatePaletted =
+            statePalette.size < 65_535 && chunk.statePalette.size < 255;
+        chunk.isModPaletted =
+            modPalette.size < 65_535 && chunk.modPalette.size < 255;
+        chunk.isSecondaryPaletted =
+            secondaryStatePalette.size < 65_535 &&
+                chunk.secondaryStatePalette.size < 255 &&
+                chunk.secondaryPalette.size < 255;
+        chunk.rempaedIds = reMapIds;
+        chunk.rempaedLight = reMapLight && chunk.isLightPaletted;
+        chunk.rempaedState = reMapState && chunk.isStatePaletted;
+        chunk.rempaedMod = reMapMod && chunk.isModPaletted;
+        chunk.rempaedSecondary = reMapSecondary && chunk.isSecondaryPaletted;
+        if (!reMapIds && !reMapLight && !reMapSecondary && !reMapState)
+            continue;
+        const length = chunk.chunk.ids.length;
+        for (let i = 0; i < length; i++) {
+            VoxelStruct.setStringVoxel(idsPalette.getStringId(chunk.ids[i]));
+            if (reMapIds)
+                chunk.ids[i] = chunk.idPalette.getId(chunk.ids[i]);
+            if (reMapState)
+                chunk.state[i] = chunk.statePalette.getId(chunk.state[i]);
+            if (reMapMod)
+                chunk.mod[i] = chunk.modPalette.getId(chunk.mod[i]);
+            if (reMapLight)
+                chunk.light[i] = chunk.lightPalette.getId(chunk.light[i]);
+            if (reMapSecondary)
+                chunk.secondary[i] =
+                    VoxelStruct.instance[VoxelTagIDs.canHaveSecondary] == 1
+                        ? chunk.secondaryPalette.getId(chunk.secondary[i])
+                        : chunk.secondaryStatePalette.getId(chunk.secondary[i]);
+        }
+    }
+    return {
+        archiverVersion: 0,
+        version: archiveData.version || 0,
+        location: [...archiveData.location],
+        columnState,
+        buffers: {},
+        keys: {
+            chunkState: [...chunkStructInstance.getKeys()],
+        },
+        palettes: {
+            id: idsPalette._palette,
+            ...(secondaryPalette.size > 0
+                ? {
+                    secondaryId: secondaryPalette._palette,
+                }
+                : {}),
+            ...(lightPalette.size <= 255
+                ? {
+                    light: new Uint16Array(lightPalette._palette),
+                }
+                : {}),
+            ...(statePalette.size <= 255
+                ? {
+                    state: new Uint16Array(statePalette._palette),
+                }
+                : {}),
+            ...(modPalette.size <= 255
+                ? {
+                    mod: new Uint16Array(modPalette._palette),
+                }
+                : {}),
+            ...(secondaryStatePalette.size <= 255
+                ? {
+                    secondaryState: new Uint16Array(secondaryStatePalette._palette),
+                }
+                : {}),
+        },
+        chunks: states.map((archiveChunk) => {
+            chunkStructInstance.setBuffer(archiveChunk.chunk.stateBuffer);
+            const serializeChunkState = chunkStructInstance.serialize();
+            return {
+                palettes: {
+                    ...(archiveChunk.rempaedIds
+                        ? {
+                            id: Uint16Array.from(archiveChunk.idPalette._palette),
+                        }
+                        : {}),
+                    ...(archiveChunk.rempaedState
+                        ? {
+                            state: Uint16Array.from(archiveChunk.statePalette._palette),
+                        }
+                        : {}),
+                    ...(archiveChunk.rempaedMod
+                        ? {
+                            mod: Uint16Array.from(archiveChunk.modPalette._palette),
+                        }
+                        : {}),
+                    ...(archiveChunk.rempaedLight
+                        ? {
+                            light: Uint16Array.from(archiveChunk.lightPalette._palette),
+                        }
+                        : {}),
+                    ...(archiveChunk.rempaedSecondary
+                        ? {
+                            secondaryId: Uint16Array.from(archiveChunk.secondaryPalette._palette),
+                            secondaryState: Uint16Array.from(archiveChunk.secondaryStatePalette._palette),
+                        }
+                        : {}),
+                },
+                buffers: {
+                    id: archiveChunk.idsAllTheSame
+                        ? archiveChunk.ids[0]
+                        : convertToPaletteBuffer(archiveChunk.rempaedIds
+                            ? archiveChunk.idPalette.size
+                            : idsPalette.size, archiveChunk.ids),
+                    light: archiveChunk.lightAllTheSame
+                        ? archiveChunk.light[0]
+                        : archiveChunk.isLightPaletted
+                            ? convertToPaletteBuffer(archiveChunk.rempaedLight
+                                ? archiveChunk.lightPalette.size
+                                : lightPalette.size, archiveChunk.light)
+                            : new Uint16Array(archiveChunk.chunk.light.slice()),
+                    state: archiveChunk.stateAllTheSame
+                        ? archiveChunk.state[0]
+                        : archiveChunk.isStatePaletted
+                            ? convertToPaletteBuffer(archiveChunk.rempaedState
+                                ? archiveChunk.statePalette.size
+                                : statePalette.size, archiveChunk.state)
+                            : new Uint16Array(archiveChunk.chunk.state.slice()),
+                    mod: archiveChunk.modAllTheSame
+                        ? archiveChunk.mod[0]
+                        : archiveChunk.isModPaletted
+                            ? convertToPaletteBuffer(archiveChunk.rempaedMod
+                                ? archiveChunk.modPalette.size
+                                : modPalette.size, archiveChunk.mod)
+                            : new Uint16Array(archiveChunk.chunk.mod.slice()),
+                    secondary: archiveChunk.secondaryAllTheSame
+                        ? archiveChunk.secondary[0]
+                        : archiveChunk.isSecondaryPaletted
+                            ? convertToPaletteBuffer(archiveChunk.rempaedSecondary
+                                ? Math.max(archiveChunk.secondaryStatePalette.size, archiveChunk.secondaryPalette.size)
+                                : Math.max(secondaryStatePalette.size, secondaryPalette.size), archiveChunk.state)
+                            : new Uint16Array(archiveChunk.secondary),
+                },
+                state: Object.entries(serializeChunkState).map((_) => _[1]),
+            };
+        }),
+    };
+}

package/Archive/Functions/ImportColumn.d.ts

@@ -0,0 +1,9 @@
+import { ChunkData, ColumnData } from "../../Data/World/Classes";
+import { ArchivedColumnData } from "../Archive.types";
+type RunData = {
+    version?: number;
+    loadColumnState?: (data: Record<string, any>, column: ColumnData) => void;
+    loadChunkState?: (keys: string[], data: any[], chunk: ChunkData) => void;
+};
+export default function ImportColumn(column: ArchivedColumnData, archiveData: RunData): ColumnData;
+export {};