@divinevoxel/vlox 0.0.73 → 0.0.75

package/World/Archive/Functions/Area/ArchiveArea.d.ts

@@ -0,0 +1,8 @@
+import { ArchivedAreaData, ArchivedSectorData } from "../../Types/index";
+type RunData = {
+    dimension: number;
+    sectors: ArchivedSectorData[];
+    version?: number;
+};
+export default function CreateArchiveArea(archiveData: RunData): ArchivedAreaData;
+export {};

package/World/Archive/Functions/Area/ArchiveArea.js

@@ -0,0 +1,65 @@
+import { WorldRegister } from "../../../WorldRegister";
+import { getBaseData } from "../Shared/index";
+function SectorToArchivedAreaSector(sector) {
+    const palettes = {
+        id: [],
+        voxelPalette: sector.palettes.voxelPalette,
+        ...(sector.palettes.level ? { level: sector.palettes.level } : {}),
+        ...(sector.palettes.light
+            ? {
+                light: {
+                    ...(sector.palettes.light.sun
+                        ? { sun: sector.palettes.light.sun }
+                        : {}),
+                    ...(sector.palettes.light.red
+                        ? { red: sector.palettes.light.red }
+                        : {}),
+                    ...(sector.palettes.light.green
+                        ? { green: sector.palettes.light.green }
+                        : {}),
+                    ...(sector.palettes.light.blue
+                        ? { blue: sector.palettes.light.blue }
+                        : {}),
+                },
+            }
+            : {}),
+    };
+    for (let i = 0; i < sector.palettes.voxels.length; i++) {
+        palettes.id.push(sector.palettes.voxels[i].id);
+    }
+    return {
+        position: sector.position,
+        flags: sector.flags,
+        timestamps: sector.timestamps,
+        palettes,
+        sections: sector.sections,
+        duplicates: sector.duplicates,
+    };
+}
+export default function CreateArchiveArea(archiveData) {
+    const sectors = [];
+    const palettes = {
+        voxelSchemas: {},
+        voxelStateSchemas: {},
+    };
+    for (const sector of archiveData.sectors) {
+        for (const key in sector.palettes.stateSchemas) {
+            palettes.voxelStateSchemas[key] = sector.palettes.stateSchemas[key];
+        }
+        for (let i = 0; i < sector.palettes.voxels.length; i++) {
+            const voxelData = sector.palettes.voxels[i];
+            palettes.voxelSchemas[voxelData.id] = {};
+            if (voxelData.modSchema)
+                palettes.voxelSchemas[voxelData.id].modSchema = voxelData.modSchema;
+            if (voxelData.stateSchemaId)
+                palettes.voxelSchemas[voxelData.id].stateSchemaId =
+                    voxelData.stateSchemaId;
+        }
+        sectors.push(SectorToArchivedAreaSector(sector));
+    }
+    return {
+        ...getBaseData(WorldRegister.dimensions.get(archiveData.dimension)?.id || "main"),
+        palettes,
+        sectors,
+    };
+}

package/World/Archive/Functions/{ArchiveArea.d.ts → Area/ImportArea.d.ts}

@@ -1,10 +1,3 @@
-import { ArchivedAreaSectorData, ArchivedAreaData, ArchivedSectorData } from "../Archive.types";
-type RunData = {
-    dimension: string;
-    sectors: ArchivedSectorData[];
-    version?: number;
-};
-export default function CreateArchiveArea(archiveData: RunData): ArchivedAreaData;
+import { ArchivedAreaSectorData, ArchivedAreaData, ArchivedSectorData } from "../../Types/index";
 export declare function CreateSectorFromArea(area: ArchivedAreaData, sector: ArchivedAreaSectorData): ArchivedSectorData;
 export declare function CreateSectorsFromArea(area: ArchivedAreaData): Generator<ArchivedSectorData>;
-export {};

package/World/Archive/Functions/Area/ImportArea.js

@@ -0,0 +1,59 @@
+export function CreateSectorFromArea(area, sector) {
+    const palettes = {
+        voxels: [],
+        voxelPalette: sector.palettes.voxelPalette,
+        stateSchemas: {},
+        ...(sector.palettes.level ? { level: sector.palettes.level } : {}),
+        ...(sector.palettes.light
+            ? {
+                light: {
+                    ...(sector.palettes.light.sun
+                        ? { sun: sector.palettes.light.sun }
+                        : {}),
+                    ...(sector.palettes.light.red
+                        ? { red: sector.palettes.light.red }
+                        : {}),
+                    ...(sector.palettes.light.green
+                        ? { green: sector.palettes.light.green }
+                        : {}),
+                    ...(sector.palettes.light.blue
+                        ? { blue: sector.palettes.light.blue }
+                        : {}),
+                },
+            }
+            : {}),
+    };
+    for (let i = 0; i < sector.palettes.id.length; i++) {
+        const id = sector.palettes.id[i];
+        const schemas = area.palettes.voxelSchemas[id];
+        palettes.voxels.push({
+            id,
+            ...(schemas?.modSchema ? { modSchema: schemas.modSchema } : {}),
+            ...(schemas?.stateSchemaId
+                ? { stateSchemaId: schemas.stateSchemaId }
+                : {}),
+        });
+        if (schemas?.stateSchemaId) {
+            palettes.stateSchemas[schemas.stateSchemaId] =
+                area.palettes.voxelStateSchemas[schemas.stateSchemaId];
+        }
+    }
+    // console.warn("imported sector", sector.palettes, palettes);
+    return {
+        dimension: area.dimension,
+        formatVersion: area.engineVersion,
+        engineVersion: area.engineVersion,
+        dataKey: area.dataKey,
+        position: sector.position,
+        flags: sector.flags,
+        timestamps: sector.timestamps,
+        duplicates: sector.duplicates,
+        palettes,
+        sections: sector.sections,
+    };
+}
+export function* CreateSectorsFromArea(area) {
+    for (const sector of area.sectors) {
+        yield CreateSectorFromArea(area, sector);
+    }
+}

package/World/Archive/Functions/JSON/ExportArchivedAreaJSON.d.ts

@@ -0,0 +1,2 @@
+import { ArchivedAreaData, ArchivedAreaJSONData } from "../../Types/index";
+export default function ExportArchivedAreaJSON(data: ArchivedAreaData): Promise<ArchivedAreaJSONData>;

package/World/Archive/Functions/JSON/ExportArchivedAreaJSON.js

@@ -0,0 +1,100 @@
+import { BinaryBuffer, BinaryBufferCompresedTypes, } from "../../../../Util/BinaryBuffer";
+import { lightSegments } from "../Shared/LightSegments";
+async function ConvertSection(section, parentObject, parentObjectKey) {
+    const jsonSection = {
+        buffers: {},
+    };
+    if (section.flags)
+        jsonSection.flags = section.flags;
+    if (section.palettes) {
+        const palettes = {};
+        if (section.palettes.id)
+            palettes.id = await BinaryBuffer.ToJSON(section.palettes.id);
+        if (section.palettes.level)
+            palettes.level = await BinaryBuffer.ToJSON(section.palettes.level);
+        if (section.palettes.secondary)
+            palettes.secondary = await BinaryBuffer.ToJSON(section.palettes.secondary);
+        for (const segment of lightSegments) {
+            if (section.palettes?.light?.[segment]) {
+                palettes.light ??= {};
+                palettes.light[segment] = await BinaryBuffer.ToJSON(section.palettes.light[segment]);
+            }
+        }
+        jsonSection.palettes = palettes;
+    }
+    if (section.buffers.id) {
+        jsonSection.buffers.id = await BinaryBuffer.ToJSON(section.buffers.id, BinaryBufferCompresedTypes.Gzip);
+    }
+    if (section.buffers.level) {
+        jsonSection.buffers.level = await BinaryBuffer.ToJSON(section.buffers.level, BinaryBufferCompresedTypes.Gzip);
+    }
+    for (const segment of lightSegments) {
+        if (section.buffers.light?.[segment]) {
+            jsonSection.buffers.light ??= {};
+            jsonSection.buffers.light[segment] = await BinaryBuffer.ToJSON(section.buffers.light[segment], BinaryBufferCompresedTypes.Gzip);
+        }
+    }
+    if (section.buffers.secondary) {
+        jsonSection.buffers.secondary = await BinaryBuffer.ToJSON(section.buffers.secondary, BinaryBufferCompresedTypes.Gzip);
+    }
+    parentObject[parentObjectKey] = jsonSection;
+}
+async function ConvertSector(sector, sectorArray, index) {
+    const palettes = {
+        id: sector.palettes.id,
+        voxelPalette: await BinaryBuffer.ToJSON(sector.palettes.voxelPalette),
+        light: {},
+    };
+    if (sector.palettes.level) {
+        palettes.level = await BinaryBuffer.ToJSON(sector.palettes.level);
+    }
+    if (sector.palettes.light) {
+        palettes.light = {};
+        for (const segment of lightSegments) {
+            if (sector.palettes.light[segment]) {
+                palettes.light[segment] = await BinaryBuffer.ToJSON(sector.palettes.light[segment]);
+            }
+        }
+    }
+    const jsonSector = {
+        position: sector.position,
+        flags: sector.flags,
+        timestamps: sector.timestamps,
+        palettes,
+        sections: [],
+        duplicates: {
+            sections: {},
+        },
+    };
+    const proms = [];
+    for (let i = 0; i < sector.sections.length; i++) {
+        const section = sector.sections[i];
+        if (typeof section === "string") {
+            jsonSector.sections[i] = section;
+            continue;
+        }
+        proms.push(ConvertSection(section, jsonSector.sections, i));
+    }
+    for (const key in sector.duplicates.sections) {
+        const section = sector.duplicates.sections[key];
+        proms.push(ConvertSection(section, jsonSector.duplicates.sections, key));
+    }
+    await Promise.all(proms);
+    sectorArray[index] = jsonSector;
+}
+export default async function ExportArchivedAreaJSON(data) {
+    const archivedData = {
+        dimension: data.dimension,
+        engineVersion: data.engineVersion,
+        formatVersion: data.formatVersion,
+        dataKey: data.dataKey,
+        palettes: data.palettes,
+        sectors: [],
+    };
+    const proms = [];
+    for (let i = 0; i < data.sectors.length; i++) {
+        proms.push(ConvertSector(data.sectors[i], archivedData.sectors, i));
+    }
+    await Promise.all(proms);
+    return archivedData;
+}

package/World/Archive/Functions/JSON/ImportArchivedAreaJSON.d.ts

@@ -0,0 +1,2 @@
+import { ArchivedAreaData, ArchivedAreaJSONData } from "../../Types/index";
+export default function ImportArchivedAreaJSON(data: ArchivedAreaJSONData): Promise<ArchivedAreaData>;

package/World/Archive/Functions/JSON/ImportArchivedAreaJSON.js

@@ -0,0 +1,100 @@
+import { BinaryBuffer } from "../../../../Util/BinaryBuffer";
+import { lightSegments } from "../Shared/LightSegments";
+async function ConvertSection(jsonSection, parentObject, parentObjectKey) {
+    const section = {
+        buffers: {},
+    };
+    if (jsonSection.flags)
+        section.flags = jsonSection.flags;
+    if (jsonSection.palettes) {
+        const palettes = {};
+        if (jsonSection.palettes.id)
+            palettes.id = await BinaryBuffer.FromJSON(jsonSection.palettes.id);
+        if (jsonSection.palettes.level)
+            palettes.level = await BinaryBuffer.FromJSON(jsonSection.palettes.level);
+        if (jsonSection.palettes.secondary)
+            palettes.secondary = await BinaryBuffer.FromJSON(jsonSection.palettes.secondary);
+        for (const segment of lightSegments) {
+            if (jsonSection.palettes?.light?.[segment]) {
+                palettes.light ??= {};
+                palettes.light[segment] = await BinaryBuffer.FromJSON(jsonSection.palettes.light[segment]);
+            }
+        }
+        section.palettes = palettes;
+    }
+    if (jsonSection.buffers.id) {
+        section.buffers.id = await BinaryBuffer.FromJSON(jsonSection.buffers.id);
+    }
+    if (jsonSection.buffers.level) {
+        section.buffers.level = await BinaryBuffer.FromJSON(jsonSection.buffers.level);
+    }
+    for (const segment of lightSegments) {
+        if (jsonSection.buffers.light?.[segment]) {
+            section.buffers.light ??= {};
+            section.buffers.light[segment] = await BinaryBuffer.FromJSON(jsonSection.buffers.light[segment]);
+        }
+    }
+    if (jsonSection.buffers.secondary) {
+        section.buffers.secondary = await BinaryBuffer.FromJSON(jsonSection.buffers.secondary);
+    }
+    parentObject[parentObjectKey] = section;
+}
+async function ConvertSector(jsonSector, sectorArray, index) {
+    const palettes = {
+        id: jsonSector.palettes.id,
+        voxelPalette: await BinaryBuffer.FromJSON(jsonSector.palettes.voxelPalette),
+        light: {},
+    };
+    if (jsonSector.palettes.level) {
+        palettes.level = await BinaryBuffer.FromJSON(jsonSector.palettes.level);
+    }
+    if (jsonSector.palettes.light) {
+        palettes.light = {};
+        for (const segment of lightSegments) {
+            if (jsonSector.palettes.light[segment]) {
+                palettes.light[segment] = await BinaryBuffer.FromJSON(jsonSector.palettes.light[segment]);
+            }
+        }
+    }
+    const sector = {
+        position: jsonSector.position,
+        flags: jsonSector.flags,
+        timestamps: jsonSector.timestamps,
+        palettes,
+        sections: [],
+        duplicates: {
+            sections: {},
+        },
+    };
+    const proms = [];
+    for (let i = 0; i < jsonSector.sections.length; i++) {
+        const section = jsonSector.sections[i];
+        if (typeof section === "string") {
+            sector.sections[i] = section;
+            continue;
+        }
+        proms.push(ConvertSection(section, sector.sections, i));
+    }
+    for (const key in jsonSector.duplicates.sections) {
+        const section = jsonSector.duplicates.sections[key];
+        proms.push(ConvertSection(section, sector.duplicates.sections, key));
+    }
+    await Promise.all(proms);
+    sectorArray[index] = sector;
+}
+export default async function ImportArchivedAreaJSON(data) {
+    const archivedData = {
+        dimension: data.dimension,
+        engineVersion: data.engineVersion,
+        formatVersion: data.formatVersion,
+        dataKey: data.dataKey,
+        palettes: data.palettes,
+        sectors: [],
+    };
+    const proms = [];
+    for (let i = 0; i < data.sectors.length; i++) {
+        proms.push(ConvertSector(data.sectors[i], archivedData.sectors, i));
+    }
+    await Promise.all(proms);
+    return archivedData;
+}

package/World/Archive/Functions/Sector/ArchiveSector.d.ts

@@ -0,0 +1,7 @@
+import { LocationData } from "../../../../Math";
+import { ArchivedSectorData } from "../../Types/index";
+type ArchiveSectorProps = {
+    location: LocationData;
+};
+export default function ArchiveSector(archiveData: ArchiveSectorProps): ArchivedSectorData;
+export {};

package/World/Archive/Functions/Sector/ArchiveSector.js

@@ -0,0 +1,209 @@
+import { WorldRegister } from "../../../../World/WorldRegister";
+import { VoxelTagsRegister } from "../../../../Voxels/Data/VoxelTagsRegister";
+import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
+import { BinaryBuffer, BinaryBufferConstants, BinaryBufferFormat, } from "../../../../Util/BinaryBuffer/index";
+import { getBaseData, lightSegments, lightSemgnetGet } from "../Shared/index";
+import { ProcessedSection, SectorPalette } from "../../Classes/ArchiveClasses";
+import { CreateArchivedSection } from "./CreateArchivedSection";
+import { RemoveDuplicateSections } from "./RemoveDuplicateSections";
+import { VoxelPalettesRegister } from "../../../../Voxels/Data/VoxelPalettesRegister";
+const lightData = new VoxelLightData();
+export default function ArchiveSector(archiveData) {
+    const sector = WorldRegister.sectors.get(archiveData.location[0], archiveData.location[1], archiveData.location[2], archiveData.location[3]);
+    if (!sector)
+        throw new Error(`Sector at location ${location} does not exist when trying to arhicve it.`);
+    const sectorPalettes = new SectorPalette();
+    const processedSections = [];
+    for (let sectionIndex = 0; sectionIndex < sector.sections.length; sectionIndex++) {
+        const section = sector.sections[sectionIndex];
+        const processedSection = new ProcessedSection(section);
+        const firstId = section.ids[0];
+        const firstLight = section.light[0];
+        const firstLevel = section.level[0];
+        const firstSecondary = section.secondary[0];
+        const firstLightLevels = {
+            sun: lightData.getS(firstLight),
+            red: lightData.getR(firstLight),
+            green: lightData.getG(firstLight),
+            blue: lightData.getB(firstLight),
+        };
+        const length = section.ids.length;
+        for (let i = 0; i < length; i++) {
+            const voxelId = sectorPalettes.voxels.register(section.ids[i]);
+            processedSection.voxels.value = voxelId;
+            if (!processedSection.palettes.voxels.isRegistered(voxelId))
+                processedSection.palettes.voxels.register(voxelId);
+            let voxelSecondary = 0;
+            if (VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxels[section.ids[i]][0]]["dve_can_have_secondary"]) {
+                voxelSecondary = sectorPalettes.voxels.register(section.secondary[i]);
+                if (!processedSection.palettes.secondaryVoxels.isRegistered(voxelSecondary))
+                    processedSection.palettes.secondaryVoxels.register(voxelSecondary);
+            }
+            const voxelLevel = !sectorPalettes.level.isRegistered(section.level[i])
+                ? sectorPalettes.level.register(section.level[i])
+                : sectorPalettes.level.getId(section.level[i]);
+            if (!processedSection.palettes.level.isRegistered(section.level[i]))
+                processedSection.palettes.level.register(section.level[i]);
+            for (let l = 0; l < lightSegments.length; l++) {
+                const segment = lightSegments[l];
+                const light = lightSemgnetGet[segment](section.light[i]);
+                if (light != firstLightLevels[segment])
+                    processedSection.light[segment].allTheSame = false;
+                processedSection.light[segment].value = light;
+                const voxelLight = !sectorPalettes.light[segment].isRegistered(light)
+                    ? sectorPalettes.light[segment].register(light)
+                    : sectorPalettes.light[segment].getId(light);
+                if (!processedSection.palettes.light[segment].isRegistered(light))
+                    processedSection.palettes.light[segment].register(light);
+                processedSection.light[segment].buffer[i] = voxelLight;
+            }
+            if (section.ids[i] != firstId)
+                processedSection.voxels.allTheSame = false;
+            if (section.level[i] != firstLevel)
+                processedSection.level.allTheSame = false;
+            if (section.secondary[i] != firstSecondary)
+                processedSection.secondaryVoxels.allTheSame = false;
+            processedSection.voxels.buffer[i] = voxelId;
+            processedSection.level.buffer[i] = voxelLevel;
+            processedSection.secondaryVoxels.buffer[i] = voxelSecondary;
+        }
+        processedSections[sectionIndex] = processedSection;
+    }
+    let neededPalettes = {
+        level: false,
+        light: {
+            sun: false,
+            red: false,
+            green: false,
+            blue: false,
+        },
+    };
+    for (const archivedSection of processedSections) {
+        //ids
+        archivedSection.voxels.isPaletted =
+            sectorPalettes.voxels.size <= BinaryBufferConstants.ByteArrayMax ||
+                archivedSection.palettes.voxels.size <=
+                    BinaryBufferConstants.ByteArrayMax;
+        archivedSection.voxels.remapped =
+            sectorPalettes.voxels.size > BinaryBufferConstants.ByteArrayMax &&
+                archivedSection.palettes.voxels.size <=
+                    BinaryBufferConstants.ByteArrayMax &&
+                !archivedSection.voxels.allTheSame;
+        //level
+        archivedSection.level.isPaletted =
+            sectorPalettes.level.size <= BinaryBufferConstants.NibbleArrayMax &&
+                archivedSection.palettes.level.size <=
+                    BinaryBufferConstants.NibbleArrayMax;
+        archivedSection.level.remapped =
+            sectorPalettes.level.size > BinaryBufferConstants.NibbleArrayMax &&
+                archivedSection.palettes.level.size <=
+                    BinaryBufferConstants.NibbleArrayMax &&
+                !archivedSection.level.allTheSame;
+        if (archivedSection.level.isPaletted && !archivedSection.level.remapped) {
+            neededPalettes.level = true;
+        }
+        for (const semgnet of lightSegments) {
+            archivedSection.light[semgnet].isPaletted =
+                sectorPalettes.light[semgnet].size <=
+                    BinaryBufferConstants.HalfNibbleArrayMax ||
+                    archivedSection.palettes.light[semgnet].size <=
+                        BinaryBufferConstants.HalfNibbleArrayMax;
+            archivedSection.light[semgnet].remapped =
+                sectorPalettes.light[semgnet].size >
+                    BinaryBufferConstants.HalfNibbleArrayMax &&
+                    archivedSection.palettes.light[semgnet].size <=
+                        BinaryBufferConstants.HalfNibbleArrayMax &&
+                    !archivedSection.light[semgnet].allTheSame;
+            if (archivedSection.light[semgnet].isPaletted &&
+                !archivedSection.light[semgnet].remapped) {
+                neededPalettes.light[semgnet] = true;
+            }
+        }
+        //secondary
+        archivedSection.secondaryVoxels.isPaletted =
+            sectorPalettes.voxels.size <= BinaryBufferConstants.ByteArrayMax ||
+                archivedSection.palettes.secondaryVoxels.size <=
+                    BinaryBufferConstants.ByteArrayMax;
+        archivedSection.secondaryVoxels.remapped =
+            sectorPalettes.voxels.size > BinaryBufferConstants.ByteArrayMax &&
+                archivedSection.palettes.secondaryVoxels.size <=
+                    BinaryBufferConstants.ByteArrayMax &&
+                !archivedSection.secondaryVoxels.allTheSame;
+        if (!archivedSection.voxels.remapped &&
+            !archivedSection.light.sun.remapped &&
+            !archivedSection.light.red.remapped &&
+            !archivedSection.light.green.remapped &&
+            !archivedSection.light.blue.remapped &&
+            !archivedSection.secondaryVoxels.remapped &&
+            !archivedSection.level.remapped)
+            continue;
+        const length = archivedSection.original.ids.length;
+        for (let i = 0; i < length; i++) {
+            let secondary = false;
+            if (VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxels[archivedSection.original.ids[i]][0]]["dve_can_have_secondary"] &&
+                archivedSection.original.secondary[i] !== 0) {
+                secondary = true;
+            }
+            let voxelId = archivedSection.voxels.buffer[i];
+            if (archivedSection.voxels.remapped)
+                archivedSection.voxels.buffer[i] =
+                    archivedSection.palettes.voxels.getId(voxelId);
+            for (let l = 0; l < lightSegments.length; l++) {
+                const segment = lightSegments[l];
+                if (archivedSection.light[segment].remapped) {
+                    archivedSection.light[segment].buffer[i] =
+                        archivedSection.palettes.light[segment].getId(lightSemgnetGet[segment](archivedSection.original.light[i]));
+                }
+            }
+            if (archivedSection.level.remapped)
+                archivedSection.level.buffer[i] = archivedSection.palettes.level.getId(archivedSection.original.level[i]);
+            if (archivedSection.secondaryVoxels.remapped) {
+                if (secondary) {
+                    archivedSection.secondaryVoxels.buffer[i] =
+                        archivedSection.palettes.secondaryVoxels.getId(voxelId);
+                }
+            }
+        }
+    }
+    const palettes = {
+        ...sectorPalettes.voxels.toJSON(),
+    };
+    const sections = [];
+    for (let sectionIndex = 0; sectionIndex < processedSections.length; sectionIndex++) {
+        sections[sectionIndex] = CreateArchivedSection(processedSections[sectionIndex], sectorPalettes);
+    }
+    if (neededPalettes.level &&
+        !(sectorPalettes.level.size == 1 && sectorPalettes.level._palette[0] == 0)) {
+        palettes.level = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint8,
+            buffer: new Uint8Array(sectorPalettes.level._palette).buffer,
+        });
+    }
+    for (const segment of lightSegments) {
+        if (neededPalettes.light[segment]) {
+            if (sectorPalettes.light[segment].size == 1 &&
+                sectorPalettes.light[segment]._palette[0] == 0)
+                continue;
+            palettes.light ??= {};
+            palettes.light[segment] = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint8,
+                buffer: new Uint8Array(sectorPalettes.light[segment]._palette).buffer,
+            });
+        }
+    }
+    const archivedSector = {
+        ...getBaseData(WorldRegister.dimensions.get(archiveData.location[0]).id || "main"),
+        position: {
+            x: archiveData.location[1],
+            y: archiveData.location[2],
+            z: archiveData.location[3],
+        },
+        flags: sector.storeFlags(),
+        timestamps: sector.storeTimestamps(),
+        palettes,
+        duplicates: {},
+        sections,
+    };
+    RemoveDuplicateSections(archivedSector);
+    return archivedSector;
+}

package/World/Archive/Functions/Sector/CreateArchivedSection.d.ts

@@ -0,0 +1,3 @@
+import { ArchivedSectionData } from "../../Types/index";
+import { ProcessedSection, SectorPalette } from "../../Classes/ArchiveClasses";
+export declare function CreateArchivedSection(archiveSection: ProcessedSection, sectorPalettes: SectorPalette): ArchivedSectionData;