@divinevoxel/vlox 0.0.71 → 0.0.73

package/World/Sector/Sector.js

@@ -1,13 +1,18 @@
-import { RemoteBinaryStruct } from "@amodx/binary/";
 import { Section } from "../Section/Section.js";
 import { WorldSpaces } from "../WorldSpaces";
-function forceMultipleOf2(n) {
-    return n % 2 === 0 ? n : n + 1;
-}
+import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays.js";
+import { SectorState, SectorStateDefaultBitFlags } from "./SectorState.js";
+import { forceMultipleOf2 } from "../../Util/Binary/BinaryFunctions.js";
 export class Sector {
-    static StateStruct = new RemoteBinaryStruct("sector-tags");
+    position;
+    static FlagIds = SectorState.Flags;
+    static TimeStampIds = SectorState.TimeStamps;
     static GetHeaderSize() {
-        return forceMultipleOf2(Sector.StateStruct.structSize);
+        return forceMultipleOf2(
+        //12 bytes fot flags
+        12 +
+            //12 * 4 bytes for time stamps
+            12 * 4);
     }
     static GetBufferSize() {
         const totalSections = WorldSpaces.sector.bounds.y / WorldSpaces.section.bounds.y;
@@ -15,45 +20,111 @@ export class Sector {
     }
     static CreateNew() {
         const buffer = new SharedArrayBuffer(this.GetBufferSize());
-        Sector.StateStruct.setBuffer(buffer);
-        Sector.StateStruct.setProperty("dve_is_stored", 0);
+        const flagArray = new Uint8Array(buffer, 0, 12);
+        const timeStampArray = new Uint32Array(buffer, 12, 12);
         const sections = [];
-        const totalSections = WorldSpaces.sector.bounds.y / WorldSpaces.section.bounds.y;
+        const totalSections = WorldSpaces.sector.sectionVolumne;
         for (let i = 0; i < totalSections; i++) {
             sections[i] = Section.CreateNew(i, buffer);
         }
         return {
-            position: [0, 0, 0],
             buffer,
+            flagArray,
+            timeStampArray,
             sections,
         };
     }
     sections = [];
     bufferView;
-    sectorState;
-    position;
-    constructor(data) {
-        this.position = data.position;
-        this.sectorState = new DataView(data.buffer);
+    constructor(data, position) {
+        this.position = position;
+        this.flagArray = data.flagArray;
+        this.timeStampArray = data.timeStampArray;
         this.buffer = data.buffer;
         this.bufferView = new Uint8Array(data.buffer);
         for (let i = 0; i < data.sections.length; i++) {
             this.sections[i] = new Section(this, i, data.sections[i]);
         }
     }
-    getSection(y) {
-        const ry = y - this.position[1];
-        const index = ry / WorldSpaces.section.bounds.y;
-        return this.sections[index];
+    getSection(x, y, z) {
+        return this.sections[WorldSpaces.section.getIndex(x, y, z)];
+    }
+    setBitFlag(index, value) {
+        setBitArrayIndex(this.flagArray, index, value ? 1 : 0);
+    }
+    getBitFlag(index) {
+        return getBitArrayIndex(this.flagArray, index) == 1;
+    }
+    setStored(stored) {
+        this.setBitFlag(SectorStateDefaultBitFlags.isStored, stored);
+    }
+    isStored() {
+        return this.getBitFlag(SectorStateDefaultBitFlags.isStored);
+    }
+    setTimeStamp(index, value) {
+        this.timeStampArray[index] = value;
+    }
+    getTimeStamp(index) {
+        return this.timeStampArray[index];
+    }
+    *getRenerableSections() {
+        for (const section of this.sections) {
+            const [min, max] = section.getMinMax();
+            if (min == Infinity || max == -Infinity)
+                continue;
+            yield section;
+        }
+    }
+    anySectionDirty() {
+        for (let i = 0; i < this.sections.length; i++) {
+            if (this.sections[i].isDirty() && !this.sections[i].isInProgress())
+                return true;
+        }
+        return false;
+    }
+    storeFlags() {
+        const stored = {};
+        for (const key in SectorState.StoredFlags) {
+            stored[key] = this.getBitFlag(SectorState.StoredFlags[key]);
+        }
+        return stored;
+    }
+    loadFlags(flags) {
+        for (const flag in flags) {
+            const storedIndex = SectorState.StoredFlags[flag];
+            if (storedIndex === undefined) {
+                console.warn(`${flag} does not exist on stored flags for sector`);
+                continue;
+            }
+            this.setBitFlag(storedIndex, flags[flag]);
+        }
+    }
+    storeTimestamps() {
+        const stored = {};
+        for (const key in SectorState.StoredTimeStamps) {
+            stored[key] = this.getTimeStamp(SectorState.StoredTimeStamps[key]);
+        }
+        return stored;
+    }
+    loadTimestamps(stored) {
+        for (const timeStamp in stored) {
+            const storedIndex = SectorState.StoredTimeStamps[timeStamp];
+            if (storedIndex === undefined) {
+                console.warn(`${timeStamp} does not exist on stored timestamps for sector`);
+                continue;
+            }
+            this.setTimeStamp(storedIndex, stored[timeStamp]);
+        }
     }
     toJSON() {
         const sections = [];
         for (const section of this.sections) {
-            sections.push(section.serialize());
+            sections.push(section.toJSON());
         }
         return {
-            position: this.position,
             buffer: this.buffer,
+            flagArray: this.flagArray,
+            timeStampArray: this.timeStampArray,
             sections,
         };
     }

package/World/Sector/SectorHeightMap.js

@@ -1,5 +1,4 @@
 import { $2dMooreNeighborhood } from "../../Math/CardinalNeighbors";
-import { SectionHeightMap } from "../Section/SectionHeightMap";
 import { WorldRegister } from "../WorldRegister";
 import { WorldSpaces } from "../WorldSpaces";
 export class SectorHeightMap {
@@ -32,12 +31,11 @@ export class SectorHeightMap {
             const section = sector.sections[i];
             if (!section)
                 continue;
-            SectionHeightMap.setSection(section);
-            const sectionPOS = y + i * WorldSpaces.section.bounds.y;
-            let [sectionMin, sectionMax] = SectionHeightMap.getMinMax();
+            const sectionPOS = section.getPosition();
+            let [sectionMin, sectionMax] = section.getMinMax();
             if (Math.abs(sectionMax) == Infinity)
                 continue;
-            sectionMax = sectionPOS + sectionMax;
+            sectionMax = sectionPOS[1] + sectionMax;
             if (maxHeight < sectionMax) {
                 maxHeight = sectionMax;
             }

package/World/Sector/SectorState.d.ts

@@ -0,0 +1,21 @@
+export declare enum SectorStateDefaultBitFlags {
+    isWorldGenDone = 0,
+    isWorldDecorDone = 1,
+    isWorldPropagationDone = 2,
+    isWorldSunDone = 3,
+    isDirty = 4,
+    isStored = 5
+}
+export declare enum SectorStateDefaultTimeStamps {
+    lastSaveTimestamp = 0
+}
+export declare class SectorState {
+    /**The default bit flags for secotrs */
+    static Flags: typeof SectorStateDefaultBitFlags;
+    /**An array of bit flags tht are preserved when the sector is stored */
+    static StoredFlags: Record<string, number>;
+    /**The default  timestamps for secotrs */
+    static TimeStamps: typeof SectorStateDefaultTimeStamps;
+    /**An array of bit timestamps tht are preserved when the sector is stored */
+    static StoredTimeStamps: Record<string, number>;
+}

package/World/Sector/SectorState.js

@@ -0,0 +1,28 @@
+export var SectorStateDefaultBitFlags;
+(function (SectorStateDefaultBitFlags) {
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldGenDone"] = 0] = "isWorldGenDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldDecorDone"] = 1] = "isWorldDecorDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldPropagationDone"] = 2] = "isWorldPropagationDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldSunDone"] = 3] = "isWorldSunDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isDirty"] = 4] = "isDirty";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isStored"] = 5] = "isStored";
+})(SectorStateDefaultBitFlags || (SectorStateDefaultBitFlags = {}));
+export var SectorStateDefaultTimeStamps;
+(function (SectorStateDefaultTimeStamps) {
+    SectorStateDefaultTimeStamps[SectorStateDefaultTimeStamps["lastSaveTimestamp"] = 0] = "lastSaveTimestamp";
+})(SectorStateDefaultTimeStamps || (SectorStateDefaultTimeStamps = {}));
+export class SectorState {
+    /**The default bit flags for secotrs */
+    static Flags = SectorStateDefaultBitFlags;
+    /**An array of bit flags tht are preserved when the sector is stored */
+    static StoredFlags = {
+        dve_is_world_gen_done: SectorStateDefaultBitFlags.isWorldGenDone,
+        dve_is_world_decoration_done: SectorStateDefaultBitFlags.isWorldDecorDone,
+        dve_is_world_progation_done: SectorStateDefaultBitFlags.isWorldPropagationDone,
+        dve_is_world_sun_done: SectorStateDefaultBitFlags.isWorldSunDone,
+    };
+    /**The default  timestamps for secotrs */
+    static TimeStamps = SectorStateDefaultTimeStamps;
+    /**An array of bit timestamps tht are preserved when the sector is stored */
+    static StoredTimeStamps = {};
+}

package/World/WorldRegister.d.ts

@@ -19,9 +19,13 @@ declare class WorldRegisterDimensions {
 declare class WorldRegisterSectors {
     static setSecotrPool(enabled: boolean): void;
     static add(dimensionId: string, x: number, y: number, z: number, sector: SectorData): Sector;
+    static addAt(location: LocationData, sector: SectorData): Sector;
     static new(dimensionId: string, x: number, y: number, z: number): boolean;
+    static newAt(location: LocationData): boolean;
     static get(dimensionId: string, x: number, y: number, z: number): false | Sector;
+    static getAt(location: LocationData): false | Sector;
     static remove(dimensionId: string, x: number, y: number, z: number): boolean;
+    static removeAt(location: LocationData): boolean;
 }
 export declare class WorldRegister {
     static _dimensions: Map<string, Dimension>;

package/World/WorldRegister.js

@@ -35,6 +35,7 @@ class SectorPool {
     }
     static returnSector(secotr) {
         secotr.bufferView.fill(0);
+        this._secotrs.push(secotr.toJSON());
     }
 }
 class WorldRegisterSectors {
@@ -46,21 +47,26 @@ class WorldRegisterSectors {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
             dimension = WorldRegister.dimensions.add(dimensionId);
-        WorldSpaces.sector.getPositionVec3Array(x, y, z, sector.position);
-        const newSector = new Sector(sector);
+        const newSector = new Sector(sector, WorldSpaces.sector.getPositionVec3Array(x, y, z));
         dimension.sectors.set(WorldSpaces.hash.hashVec3Array(newSector.position), newSector);
         return newSector;
     }
+    static addAt(location, sector) {
+        return this.add(...location, sector);
+    }
     static new(dimensionId, x, y, z) {
         if (this.get(dimensionId, x, y, z))
             return false;
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
             dimension = WorldRegister.dimensions.add(dimensionId);
-        const sector = this.add(dimensionId, x, y, z, Sector.CreateNew());
+        const sector = this.add(dimensionId, x, y, z, SectorPool.getSector());
         WorldDataHooks.sectors.onNew([dimensionId, x, y, z], sector);
         return true;
     }
+    static newAt(location) {
+        return this.new(...location);
+    }
     static get(dimensionId, x, y, z) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
@@ -68,6 +74,9 @@ class WorldRegisterSectors {
         const sector = dimension.sectors.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition)));
         return sector || false;
     }
+    static getAt(location) {
+        return this.get(...location);
+    }
     static remove(dimensionId, x, y, z) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
@@ -83,6 +92,9 @@ class WorldRegisterSectors {
         dimension.sectors.delete(sectorKey);
         return true;
     }
+    static removeAt(location) {
+        return this.remove(...location);
+    }
 }
 export class WorldRegister {
     static _dimensions = new Map();

package/World/WorldSpaces.d.ts

@@ -23,6 +23,8 @@ declare class SectorSpace {
     static power2Axes: Vector3Like;
     static bounds: Vector3Like;
     static volumne: number;
+    static sectionBounds: Vector3Like;
+    static sectionVolumne: number;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
 }
@@ -33,12 +35,16 @@ declare class SectionSpace {
     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;
+    static getPositionFromIndex(index: number, refPosition?: Vector3Like): Vector3Like;
+    static getPositionFromIndexVec3Array(index: number, refPosition?: Vec3Array): Vec3Array;
 }
 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 getPositionFromIndex(index: number, refPosition?: Vector3Like): Vector3Like;
     static getIndex(x: number, y: number, z: number): number;
+    static getIndexFromPosition(x: number, y: number, z: number): number;
 }
 declare class Hash {
     static hashVec3(vector3: Vector3Like): string;

package/World/WorldSpaces.js

@@ -1,7 +1,7 @@
 //types
 import { EngineSettings } from "../Settings/EngineSettings.js";
 import { Vector3Like } from "@amodx/math";
-import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, } from "../Math/Indexing.js";
+import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, GetYXZOrderArrayPositionVec3, GetYXZOrderArrayPositionVec3Array, } from "../Math/Indexing.js";
 const tempPosition = Vector3Like.Create();
 const tempPosition2 = Vector3Like.Create();
 class WorldBounds {
@@ -57,6 +57,8 @@ class SectorSpace {
     static power2Axes = Vector3Like.Create();
     static bounds = Vector3Like.Create();
     static volumne = 0;
+    static sectionBounds = Vector3Like.Create();
+    static sectionVolumne = 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;
@@ -81,7 +83,13 @@ class SectionSpace {
     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;
+        return GetYXZOrderArrayIndex((tempPosition.x - tempPosition2.x) / SectionSpace.bounds.x, (tempPosition.y - tempPosition2.y) / SectionSpace.bounds.y, (tempPosition.z - tempPosition2.z) / SectionSpace.bounds.z, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z);
+    }
+    static getPositionFromIndex(index, refPosition = Vector3Like.Create()) {
+        return GetYXZOrderArrayPositionVec3(index, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z, refPosition);
+    }
+    static getPositionFromIndexVec3Array(index, refPosition = [0, 0, 0]) {
+        return GetYXZOrderArrayPositionVec3Array(index, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z, refPosition);
     }
 }
 class VoxelSpace {
@@ -100,10 +108,16 @@ class VoxelSpace {
         refPosition[2] = z - refPosition[2];
         return refPosition;
     }
+    static getPositionFromIndex(index, refPosition = Vector3Like.Create()) {
+        return GetYXZOrderArrayPositionVec3(index, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z, 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);
     }
+    static getIndexFromPosition(x, y, z) {
+        return GetYXZOrderArrayIndex(x, y, z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z);
+    }
 }
 class Hash {
     static hashVec3(vector3) {
@@ -132,6 +146,8 @@ EngineSettings.addEventListener("synced", (event) => {
     SectorSpace.bounds.x = 1 << SectorSpace.power2Axes.x;
     SectorSpace.bounds.y = 1 << SectorSpace.power2Axes.y;
     SectorSpace.bounds.z = 1 << SectorSpace.power2Axes.z;
+    SectorSpace.volumne =
+        SectorSpace.bounds.x * SectorSpace.bounds.y * SectorSpace.bounds.z;
     SectionSpace.power2Axes.x = settings.sections.power2Size.x;
     SectionSpace.power2Axes.y = settings.sections.power2Size.y;
     SectionSpace.power2Axes.z = settings.sections.power2Size.z;
@@ -140,8 +156,11 @@ EngineSettings.addEventListener("synced", (event) => {
     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);
+    SectorSpace.sectionBounds.x = SectorSpace.bounds.x / SectionSpace.bounds.x;
+    SectorSpace.sectionBounds.y = SectorSpace.bounds.y / SectionSpace.bounds.y;
+    SectorSpace.sectionBounds.z = SectorSpace.bounds.z / SectionSpace.bounds.z;
+    SectorSpace.sectionVolumne =
+        SectorSpace.sectionBounds.x *
+            SectorSpace.sectionBounds.y *
+            SectorSpace.sectionBounds.z;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.71",
+  "version": "0.0.73",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",

package/Data/Cursor/DataCursor.interface.d.ts

@@ -1,5 +0,0 @@
-import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
-export declare abstract class DataCursorInterface {
-    abstract getVoxel(x: number, y: number, z: number): VoxelCursorInterface | null;
-    abstract inBounds(x: number, y: number, z: number): boolean;
-}

package/Data/Cursor/DataCursor.interface.js

@@ -1,2 +0,0 @@
-export class DataCursorInterface {
-}

package/Data/Register/MappedDataRegister.d.ts

@@ -1,5 +0,0 @@
-import { MappedRegisterBase } from "./MappedRegisterBase.js";
-export declare class MappedDataRegister {
-    static stringMaps: MappedRegisterBase<string>;
-    static objectMaps: MappedRegisterBase<any>;
-}

package/Data/Register/MappedDataRegister.js

@@ -1,9 +0,0 @@
-import { MappedRegisterBase } from "./MappedRegisterBase.js";
-export class MappedDataRegister {
-    static stringMaps = new MappedRegisterBase();
-    static objectMaps = new MappedRegisterBase();
-}
-MappedDataRegister.stringMaps.addSegment("voxel");
-MappedDataRegister.objectMaps.addSegment("voxel");
-MappedDataRegister.stringMaps.addSegment("substance");
-MappedDataRegister.objectMaps.addSegment("substance");

package/Data/Register/MappedRegisterBase.d.ts

@@ -1,14 +0,0 @@
-declare class MappedRegisterSegment<Data> extends EventTarget {
-    entries: Map<string, Data[]>;
-    onEntryAdded(id: string, run: (data: Data[]) => void): void;
-    add(id: string, data: Data[]): void;
-    get(id: string): Data[] | undefined;
-}
-export declare class MappedRegisterBase<Data> {
-    segments: Map<string, MappedRegisterSegment<Data>>;
-    addSegment(id: string): MappedRegisterSegment<Data>;
-    getSegment(id: string): MappedRegisterSegment<Data>;
-    sync(segment: string, id: string, value: Data[]): void;
-    get(segment: string, id: string, index: number): Data | null;
-}
-export {};

package/Data/Register/MappedRegisterBase.js

@@ -1,50 +0,0 @@
-const getSyncId = (id) => `entry-synced-${id}`;
-class MappedRegisterSegment extends EventTarget {
-    entries = new Map();
-    onEntryAdded(id, run) {
-        const entrySyncedId = getSyncId(id);
-        const listener = () => {
-            run(this.entries.get(id));
-            this.removeEventListener(entrySyncedId, listener);
-        };
-        this.addEventListener(entrySyncedId, listener);
-    }
-    add(id, data) {
-        this.entries.set(id, data);
-        this.dispatchEvent(new Event(getSyncId(id)));
-    }
-    get(id) {
-        return this.entries.get(id);
-    }
-}
-export class MappedRegisterBase {
-    segments = new Map();
-    addSegment(id) {
-        if (this.segments.has(id))
-            return this.segments.get(id);
-        const newSegment = new MappedRegisterSegment();
-        this.segments.set(id, newSegment);
-        return newSegment;
-    }
-    getSegment(id) {
-        const segment = this.segments.get(id);
-        if (!segment)
-            throw new Error(`Segment with id ${id} does not exist`);
-        return segment;
-    }
-    sync(segment, id, value) {
-        const segmentMap = this.addSegment(segment);
-        segmentMap.add(id, value);
-        return;
-    }
-    get(segment, id, index) {
-        const segmentMap = this.segments.get(segment);
-        if (!segmentMap)
-            return null;
-        const mapped = segmentMap.get(id);
-        if (!mapped) {
-            return null;
-        }
-        return mapped[index];
-    }
-}

package/Data/Structs/StructBuilder.d.ts

@@ -1,34 +0,0 @@
-import type { TagBuilderNodes } from "Data/Structs/StructBuilder.types.js";
-import { BinaryStructData, BinraryStructBase } from "@amodx/binary/";
-import { BinaryStruct } from "@amodx/binary/";
-export declare class StructBuilder {
-    id: string;
-    dataSegment: string;
-    _built: boolean;
-    _nodeMap: Map<string, TagBuilderNodes>;
-    _stringMaps: Map<string, {
-        count: number;
-        found: Record<string, number>;
-        map: string[];
-        allowedComms: string[];
-    }>;
-    _objectMaps: Map<string, {
-        count: number;
-        found: Record<string, number>;
-        map: any[];
-        allowedComms: string[];
-    }>;
-    _defaults: Map<string, number>;
-    _initData: BinaryStructData;
-    constructor(id: string, dataSegment: string);
-    addNode(node: TagBuilderNodes | TagBuilderNodes[]): void;
-    getNode(id: string): TagBuilderNodes | undefined;
-    setDefaults(tagManager: BinraryStructBase): void;
-    hasNode(id: string): boolean;
-    setNode(id: string, value: any, tagManager: BinraryStructBase): false | undefined;
-    build(totalTagIndexes?: number): BinaryStruct;
-    getMaps(): {
-        objectMaps: Record<string, any[]>;
-        stringMaps: Record<string, string[]>;
-    };
-}