@divinevoxel/vlox 0.0.4 → 0.0.6

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);
-    }
-}

package/Archive/Functions/ArchiveColumn.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,293 +0,0 @@
-import { StringPalette } from "../../Util/StringPalette";
-import { NumberPalette } from "../../Util/NumberPalette";
-import { WorldRegister } from "../../Data/World/WorldRegister";
-import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
-import { VoxelStruct } from "../../Data/Structs/VoxelStruct";
-import { VoxelStructIds } from "../../Voxels/Voxel.types";
-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(chunk.state[i]))
-                archivedChunk.statePalette.register(chunk.state[i]);
-            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(chunk.mod[i]))
-                archivedChunk.modPalette.register(chunk.mod[i]);
-            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(chunk.light[i]))
-                archivedChunk.lightPalette.register(chunk.light[i]);
-            if (firstLight == -1)
-                firstLight = voxelLight;
-            const secondaryId = VoxelStruct.instance[VoxelStructIds.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.chunk.state[i]);
-            if (reMapMod)
-                chunk.mod[i] = chunk.modPalette.getId(chunk.chunk.mod[i]);
-            if (reMapLight)
-                chunk.light[i] = chunk.lightPalette.getId(chunk.chunk.light[i]);
-            if (reMapSecondary)
-                chunk.secondary[i] =
-                    VoxelStruct.instance[VoxelStructIds.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.buffer);
-            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

@@ -1,9 +0,0 @@
-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 {};