@divinevoxel/vlox 0.0.74 → 0.0.75

package/Tools/Tasks/TasksTool.d.ts

@@ -1,48 +1,77 @@
 import { Thread, ThreadPool } from "@amodx/threads/";
-import { ExplosionTasks, GenerateTasks, VoxelUpdateTasks } from "../../Tasks/Tasks.types";
+import { PaintVoxelTemplateTask, PaintVoxelTask, EraseVoxelTask, EraseVoxelTemplateTask, PaintVoxelPathTask, EraseVoxelPathTask } from "../../Tasks/Tasks.types";
 import { LocationData } from "../../Math";
+import { SectionSnapShotTransferData } from "../../World/SnapShot/SectionSnapShot";
 export type TaskRunModes = "async" | "sync";
+interface ITask<Data> {
+    run(data: Data, transfer: any[] | null, onDone?: (data: any) => void): void;
+}
 declare class TaskQueue<Data extends any = any, ReturnData extends any = void> {
     private _task;
     private _queue;
-    constructor(_task: TaskToolTask<Data, ReturnData>);
+    constructor(_task: ITask<Data>);
     add(data: Data): void;
     clear(): void;
     run(): Promise<unknown>;
 }
-export declare class TaskToolTask<Data extends any = any, ReturnData extends any = void> {
-    id: string | number;
+export declare class LocationTaskToolTask implements ITask<LocationData> {
+    id: string;
     private _count;
     _threads: Thread[];
-    constructor(id: string | number, threads: Thread | ThreadPool);
+    constructor(id: string, threads: Thread | ThreadPool);
+    run(location: LocationData, transfer?: any[] | null, onDone?: (data: any) => void, thread?: Thread): void;
+    runAsync(location: LocationData): Promise<void>;
+    createQueue(): TaskQueue<LocationData, void>;
+}
+export declare class TaskToolTask<Data extends any = any, ReturnData extends any = void> implements ITask<Data> {
+    id: string;
+    private _count;
+    _threads: Thread[];
+    constructor(id: string, threads: Thread | ThreadPool);
     run(data: Data, transfer?: any[] | null, onDone?: (returnData: ReturnData) => void | null): void;
     runAsync(data: Data, transfer?: any[] | null): Promise<ReturnData>;
-    createQueue(): TaskQueue<Data, ReturnData>;
+    createQueue(): TaskQueue<Data, void>;
 }
 declare class VoxelTasks {
     tool: TaskTool;
-    update: TaskToolTask<VoxelUpdateTasks>;
-    paint: TaskToolTask<VoxelUpdateTasks>;
-    erease: TaskToolTask<LocationData>;
-    logic: TaskToolTask<LocationData>;
+    paint: TaskToolTask<PaintVoxelTask>;
+    paintTemplate: TaskToolTask<PaintVoxelTemplateTask>;
+    paintPath: TaskToolTask<PaintVoxelPathTask>;
+    erase: TaskToolTask<EraseVoxelTask>;
+    eraseTemplate: TaskToolTask<EraseVoxelTemplateTask>;
+    erasePath: TaskToolTask<EraseVoxelPathTask>;
     constructor(tool: TaskTool);
 }
 declare class BuildTask {
     tool: TaskTool;
-    section: TaskToolTask<LocationData>;
-    sector: TaskToolTask<LocationData>;
+    sectionSnapShot: TaskToolTask<SectionSnapShotTransferData>;
+    section: LocationTaskToolTask;
+    sector: LocationTaskToolTask;
+    constructor(tool: TaskTool);
+}
+declare class SimulationTasks {
+    tool: TaskTool;
+    logic: LocationTaskToolTask;
+    propagation: LocationTaskToolTask;
+    constructor(tool: TaskTool);
+}
+declare class GenerationTasks {
+    tool: TaskTool;
+    propagation: LocationTaskToolTask;
+    generate: LocationTaskToolTask;
+    decorate: LocationTaskToolTask;
+    worldSun: LocationTaskToolTask;
     constructor(tool: TaskTool);
 }
 export declare class TaskTool {
-    threads: Thread | ThreadPool;
+    meshers: Thread | ThreadPool;
+    generators: Thread | ThreadPool;
     voxel: VoxelTasks;
     build: BuildTask;
-    explosion: TaskToolTask<ExplosionTasks>;
-    anaylzer: TaskToolTask<LocationData>;
-    propagation: TaskToolTask<LocationData>;
-    generate: TaskToolTask<GenerateTasks>;
-    decorate: TaskToolTask<GenerateTasks>;
-    worldSun: TaskToolTask<LocationData>;
-    constructor(threads: Thread | ThreadPool);
+    generation: GenerationTasks;
+    simulation: SimulationTasks;
+    constructor(meshers: Thread | ThreadPool, generators: Thread | ThreadPool);
+    getMesher(): Thread;
+    getGenerator(): Thread;
 }
 export {};

package/Tools/Tasks/TasksTool.js

@@ -1,5 +1,6 @@
-import { Thread } from "@amodx/threads/";
+import { Thread, Threads } from "@amodx/threads/";
 import { TasksIds } from "../../Tasks/TasksIds.js";
+import { setLocationData } from "../../Util/LocationData";
 class TaskQueue {
     _task;
     _queue = [];
@@ -28,6 +29,36 @@ class TaskQueue {
         });
     }
 }
+export class LocationTaskToolTask {
+    id;
+    _count = 0;
+    _threads;
+    constructor(id, threads) {
+        this.id = id;
+        if (threads instanceof Thread) {
+            this._threads = [threads];
+        }
+        else {
+            this._threads = [...threads.getThreads()];
+        }
+    }
+    run(location, transfer, onDone, thread = this._threads[this._count]) {
+        const view = Threads.createBinaryTask(16);
+        setLocationData(view, location);
+        thread.runBinaryTask(this.id, view, onDone);
+        this._count++;
+        if (this._count >= this._threads.length)
+            this._count = 0;
+    }
+    runAsync(location) {
+        return new Promise((resolve) => {
+            this.run(location, null, resolve);
+        });
+    }
+    createQueue() {
+        return new TaskQueue(this);
+    }
+}
 export class TaskToolTask {
     id;
     _count = 0;
@@ -59,46 +90,79 @@ export class TaskToolTask {
 }
 class VoxelTasks {
     tool;
-    update;
     paint;
-    erease;
-    logic;
+    paintTemplate;
+    paintPath;
+    erase;
+    eraseTemplate;
+    erasePath;
     constructor(tool) {
         this.tool = tool;
-        this.update = new TaskToolTask(TasksIds.VoxelUpdate, tool.threads);
-        this.paint = new TaskToolTask(TasksIds.VoxelPaint, tool.threads);
-        this.erease = new TaskToolTask(TasksIds.VoxelErease, tool.threads);
-        this.logic = new TaskToolTask(TasksIds.LogicUpdate, tool.threads);
+        this.paint = new TaskToolTask(TasksIds.PaintVoxel, tool.generators);
+        this.paintTemplate = new TaskToolTask(TasksIds.PaintVoxelTemplate, tool.generators);
+        this.paintPath = new TaskToolTask(TasksIds.PaintVoxelPath, tool.generators);
+        this.erase = new TaskToolTask(TasksIds.EraseVoxel, tool.generators);
+        this.eraseTemplate = new TaskToolTask(TasksIds.EraseVoxelTemplate, tool.generators);
+        this.erasePath = new TaskToolTask(TasksIds.EraseVoxelPath, tool.generators);
     }
 }
 class BuildTask {
     tool;
+    sectionSnapShot;
     section;
     sector;
     constructor(tool) {
         this.tool = tool;
-        this.section = new TaskToolTask(TasksIds.BuildSection, tool.threads);
-        this.sector = new TaskToolTask(TasksIds.BuildSector, tool.threads);
+        this.section = new LocationTaskToolTask(TasksIds.BuildSection, tool.meshers);
+        this.sectionSnapShot = new TaskToolTask(TasksIds.BuildSectionSnapShot, tool.meshers);
+        this.sector = new LocationTaskToolTask(TasksIds.BuildSector, tool.meshers);
     }
 }
-export class TaskTool {
-    threads;
-    voxel;
-    build;
-    explosion;
-    anaylzer;
+class SimulationTasks {
+    tool;
+    logic;
+    propagation;
+    constructor(tool) {
+        this.tool = tool;
+    }
+}
+class GenerationTasks {
+    tool;
     propagation;
     generate;
     decorate;
     worldSun;
-    constructor(threads) {
-        this.threads = threads;
+    constructor(tool) {
+        this.tool = tool;
+        this.propagation = new LocationTaskToolTask(TasksIds.WorldPropagation, tool.generators);
+        this.generate = new LocationTaskToolTask(TasksIds.Generate, tool.generators);
+        this.decorate = new LocationTaskToolTask(TasksIds.Decorate, tool.generators);
+        this.worldSun = new LocationTaskToolTask(TasksIds.WorldSun, tool.generators);
+    }
+}
+export class TaskTool {
+    meshers;
+    generators;
+    voxel;
+    build;
+    generation;
+    simulation;
+    constructor(meshers, generators) {
+        this.meshers = meshers;
+        this.generators = generators;
         this.voxel = new VoxelTasks(this);
         this.build = new BuildTask(this);
-        this.explosion = new TaskToolTask(TasksIds.Explosion, threads);
-        this.propagation = new TaskToolTask(TasksIds.Propagation, threads);
-        this.generate = new TaskToolTask(TasksIds.Generate, threads);
-        this.decorate = new TaskToolTask(TasksIds.Decorate, threads);
-        this.worldSun = new TaskToolTask(TasksIds.WorldSun, threads);
+        this.generation = new GenerationTasks(this);
+        this.simulation = new SimulationTasks(this);
+    }
+    getMesher() {
+        if (this.meshers instanceof Thread)
+            return this.meshers;
+        return this.meshers.nextThread();
+    }
+    getGenerator() {
+        if (this.generators instanceof Thread)
+            return this.generators;
+        return this.generators.nextThread();
     }
 }

package/Util/Binary/BinaryArrays.d.ts

@@ -1,5 +1,7 @@
 export declare function getBitArrayIndex(data: Uint8Array, arrayIndex: number): number;
 export declare function setBitArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;
+export declare function getBitAtomicArrayIndex(data: Uint8Array, arrayIndex: number): number;
+export declare function setBitAtomicArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;
 export declare function getNibbleArrayIndex(data: Uint8Array, arrayIndex: number): number;
 export declare function setNibbleArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;
 export declare function getHalfNibbleArrayIndex(data: Uint8Array, arrayIndex: number): number;

package/Util/Binary/BinaryArrays.js

@@ -9,6 +9,21 @@ export function setBitArrayIndex(data, arrayIndex, value) {
     const bitPosition = arrayIndex % 8;
     data[arrayByteIndex] = setBitValue(data[arrayByteIndex], bitPosition, value & 1, 1);
 }
+export function getBitAtomicArrayIndex(data, arrayIndex) {
+    const arrayByteIndex = Math.floor(arrayIndex / 8);
+    const bitPosition = arrayIndex % 8;
+    return getBitValue(Atomics.load(data, arrayByteIndex), bitPosition, 1);
+}
+export function setBitAtomicArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = Math.floor(arrayIndex / 8);
+    const bitPosition = arrayIndex % 8;
+    // Load current byte atomically
+    let byte = Atomics.load(data, arrayByteIndex);
+    // Modify the bit
+    byte = setBitValue(byte, bitPosition, value & 1, 1);
+    // Store it back atomically
+    Atomics.store(data, arrayByteIndex, byte);
+}
 export function getNibbleArrayIndex(data, arrayIndex) {
     return getBitValue(data[(arrayIndex / 2) >> 0], arrayIndex % 2 === 0 ? 4 : 0, 4);
 }

package/Util/Binary/BinaryFunctions.d.ts

@@ -1,3 +1,6 @@
 export declare function getBitValue(data: number, bitIndex: number, bitSize: number): number;
 export declare function setBitValue(data: number, bitIndex: number, value: number, bitSize: number): number;
 export declare function forceMultipleOf2(n: number): number;
+export declare function forceMultipleOf4(n: number): number;
+export declare function bitsNeeded(n: number): number;
+export declare function nextPowerOf2(n: number): number;

package/Util/Binary/BinaryFunctions.js

@@ -9,3 +9,21 @@ export function setBitValue(data, bitIndex, value, bitSize) {
 export function forceMultipleOf2(n) {
     return n % 2 === 0 ? n : n + 1;
 }
+export function forceMultipleOf4(n) {
+    return n % 4 === 0 ? n : n + (4 - (n % 4));
+}
+export function bitsNeeded(n) {
+    if (n < 0)
+        throw new Error("Input must be a non-negative integer.");
+    let bits = 0;
+    while (n > 0) {
+        bits++;
+        n >>= 1;
+    }
+    return bits;
+}
+export function nextPowerOf2(n) {
+    if (n <= 1)
+        return 1;
+    return 2 ** Math.ceil(Math.log2(n));
+}

package/Util/BinaryBuffer/BinaryBuffer.d.ts

@@ -0,0 +1,30 @@
+import { BinaryBufferConstants, BinaryBufferData, BinaryBufferFormat } from "./BinaryBuffer.types";
+import { ConvertBinaryBuffer, DetermineSubByteArrayForBinaryBuffer, GetBinaryBufferIndexLength, GetConvertedBinaryBufferSize } from "./Functions/BinaryBufferConvert";
+import { BinaryBufferFromJSON, BinaryBufferToJSON } from "./Functions/BinaryBufferJSON";
+import { ReadBufferAtIndex, SetBufferAtIndex } from "./Functions/BinaryBufferRead";
+import BinaryBufferToTypedArray from "./Functions/BinaryBufferToTypedArray";
+export interface BinaryBuffer extends BinaryBufferData {
+}
+export declare class BinaryBuffer {
+    static Constants: typeof BinaryBufferConstants;
+    static Compare(buffer1: BinaryBufferData, buffer2: BinaryBufferData): boolean;
+    static ToJSON: typeof BinaryBufferToJSON;
+    static FromJSON: typeof BinaryBufferFromJSON;
+    static ToTypedArray: typeof BinaryBufferToTypedArray;
+    static ReadBufferAtIndex: typeof ReadBufferAtIndex;
+    static SetBufferAtIndex: typeof SetBufferAtIndex;
+    static DetermineSubByteArray: typeof DetermineSubByteArrayForBinaryBuffer;
+    static GetConvertedBufferSize: typeof GetConvertedBinaryBufferSize;
+    static GetIndexLength: typeof GetBinaryBufferIndexLength;
+    static Convert: typeof ConvertBinaryBuffer;
+    static Create(data: Partial<BinaryBufferData>): BinaryBufferData;
+    bufferView: Uint8Array | Uint16Array;
+    constructor(data: BinaryBufferData);
+    isValue: boolean;
+    getValue(index: number): number;
+    toJSON(): {
+        buffer: number | ArrayBuffer | SharedArrayBuffer;
+        length: number;
+        type: BinaryBufferFormat;
+    };
+}

package/Util/BinaryBuffer/BinaryBuffer.js

@@ -0,0 +1,78 @@
+import { BinaryBufferConstants, BinaryBufferFormat, } from "./BinaryBuffer.types";
+import { ConvertBinaryBuffer, DetermineSubByteArrayForBinaryBuffer, GetBinaryBufferIndexLength, GetConvertedBinaryBufferSize, } from "./Functions/BinaryBufferConvert";
+import { BinaryBufferFromJSON, BinaryBufferToJSON, } from "./Functions/BinaryBufferJSON";
+import { ReadBufferAtIndex, SetBufferAtIndex, } from "./Functions/BinaryBufferRead";
+import BinaryBufferToTypedArray from "./Functions/BinaryBufferToTypedArray";
+export class BinaryBuffer {
+    static Constants = BinaryBufferConstants;
+    static Compare(buffer1, buffer2) {
+        if (buffer1.format != buffer2.format)
+            return false;
+        if (buffer1.byteLength != buffer2.byteLength)
+            return false;
+        if (typeof buffer1.buffer == "number" && buffer1.buffer == buffer2.buffer)
+            return true;
+        if (typeof buffer1.buffer == "number" || typeof buffer2.buffer == "number")
+            return false;
+        if (buffer1.buffer.byteLength != buffer2.buffer.byteLength)
+            return false;
+        const view1 = new Uint8Array(buffer1.buffer);
+        const view2 = new Uint8Array(buffer2.buffer);
+        let i = view1.length;
+        while (i--) {
+            if (view1[i] != view2[i])
+                return false;
+        }
+        return true;
+    }
+    static ToJSON = BinaryBufferToJSON;
+    static FromJSON = BinaryBufferFromJSON;
+    static ToTypedArray = BinaryBufferToTypedArray;
+    static ReadBufferAtIndex = ReadBufferAtIndex;
+    static SetBufferAtIndex = SetBufferAtIndex;
+    static DetermineSubByteArray = DetermineSubByteArrayForBinaryBuffer;
+    static GetConvertedBufferSize = GetConvertedBinaryBufferSize;
+    static GetIndexLength = GetBinaryBufferIndexLength;
+    static Convert = ConvertBinaryBuffer;
+    static Create(data) {
+        const bufferData = {
+            buffer: 0,
+            byteLength: 0,
+            format: BinaryBufferFormat.Uint8,
+            ...data,
+        };
+        if (!bufferData.byteLength && typeof bufferData.buffer !== "number") {
+            bufferData.byteLength = bufferData.buffer.byteLength;
+        }
+        return bufferData;
+    }
+    bufferView;
+    constructor(data) {
+        this.buffer = data.buffer;
+        this.format = data.format;
+        if (typeof this.buffer !== "number") {
+            if (this.format == BinaryBufferFormat.Uint16) {
+                this.bufferView = new Uint16Array(this.buffer);
+            }
+            else {
+                this.bufferView = new Uint8Array(this.buffer);
+            }
+        }
+        else {
+            this.isValue = true;
+        }
+    }
+    isValue = false;
+    getValue(index) {
+        if (this.isValue)
+            return this.buffer;
+        return ReadBufferAtIndex(this.bufferView, this.format, index);
+    }
+    toJSON() {
+        return {
+            buffer: this.buffer,
+            length: this.byteLength,
+            type: this.format,
+        };
+    }
+}

package/Util/BinaryBuffer/BinaryBuffer.types.d.ts

@@ -0,0 +1,37 @@
+export declare enum BinaryBufferFormat {
+    BitArray = "bit",
+    HalfNibbleArray = "half-nibble",
+    NibbleArray = "nibble",
+    Buffer = "buffer",
+    Uint8 = "uint8",
+    Uint16 = "uint16",
+    Uint32 = "uint32",
+    Int8 = "int8",
+    Int16 = "int16",
+    Int32 = "int32",
+    Float32 = "float32",
+    Float64 = "float64"
+}
+export declare enum BinaryBufferCompresedTypes {
+    Gzip = "gzip",
+    Deflate = "deflate",
+    DeflateRaw = "deflate-raw"
+}
+export declare enum BinaryBufferConstants {
+    ByteArrayMax = 256,
+    NibbleArrayMax = 16,
+    HalfNibbleArrayMax = 4,
+    BitArrayMax = 2
+}
+export interface BinaryBufferData {
+    format: BinaryBufferFormat;
+    byteLength: number;
+    buffer: number | ArrayBuffer | SharedArrayBuffer;
+}
+export interface JSONBinaryBufferData {
+    format: BinaryBufferFormat;
+    base64?: string;
+    value?: number | null;
+    byteLength: number;
+    compression?: BinaryBufferCompresedTypes;
+}

package/Util/BinaryBuffer/BinaryBuffer.types.js

@@ -0,0 +1,28 @@
+export var BinaryBufferFormat;
+(function (BinaryBufferFormat) {
+    BinaryBufferFormat["BitArray"] = "bit";
+    BinaryBufferFormat["HalfNibbleArray"] = "half-nibble";
+    BinaryBufferFormat["NibbleArray"] = "nibble";
+    BinaryBufferFormat["Buffer"] = "buffer";
+    BinaryBufferFormat["Uint8"] = "uint8";
+    BinaryBufferFormat["Uint16"] = "uint16";
+    BinaryBufferFormat["Uint32"] = "uint32";
+    BinaryBufferFormat["Int8"] = "int8";
+    BinaryBufferFormat["Int16"] = "int16";
+    BinaryBufferFormat["Int32"] = "int32";
+    BinaryBufferFormat["Float32"] = "float32";
+    BinaryBufferFormat["Float64"] = "float64";
+})(BinaryBufferFormat || (BinaryBufferFormat = {}));
+export var BinaryBufferCompresedTypes;
+(function (BinaryBufferCompresedTypes) {
+    BinaryBufferCompresedTypes["Gzip"] = "gzip";
+    BinaryBufferCompresedTypes["Deflate"] = "deflate";
+    BinaryBufferCompresedTypes["DeflateRaw"] = "deflate-raw";
+})(BinaryBufferCompresedTypes || (BinaryBufferCompresedTypes = {}));
+export var BinaryBufferConstants;
+(function (BinaryBufferConstants) {
+    BinaryBufferConstants[BinaryBufferConstants["ByteArrayMax"] = 256] = "ByteArrayMax";
+    BinaryBufferConstants[BinaryBufferConstants["NibbleArrayMax"] = 16] = "NibbleArrayMax";
+    BinaryBufferConstants[BinaryBufferConstants["HalfNibbleArrayMax"] = 4] = "HalfNibbleArrayMax";
+    BinaryBufferConstants[BinaryBufferConstants["BitArrayMax"] = 2] = "BitArrayMax";
+})(BinaryBufferConstants || (BinaryBufferConstants = {}));

package/Util/BinaryBuffer/Functions/BinaryBufferConvert.d.ts

@@ -0,0 +1,5 @@
+import { BinaryBufferFormat } from "../BinaryBuffer.types";
+export declare function DetermineSubByteArrayForBinaryBuffer(paletteSize: number): BinaryBufferFormat | null;
+export declare function GetConvertedBinaryBufferSize(source: Uint8Array | Uint16Array, format: BinaryBufferFormat): number;
+export declare function GetBinaryBufferIndexLength(source: Uint8Array | Uint16Array, format: BinaryBufferFormat): number;
+export declare function ConvertBinaryBuffer(source: Uint8Array | Uint16Array, sourceType: BinaryBufferFormat, destinationType: BinaryBufferFormat): Uint16Array | Uint8Array;

package/Util/BinaryBuffer/Functions/BinaryBufferConvert.js

@@ -0,0 +1,60 @@
+import { BinaryBufferConstants, BinaryBufferFormat, } from "../BinaryBuffer.types";
+import { ReadBufferAtIndex, SetBufferAtIndex } from "./BinaryBufferRead";
+export function DetermineSubByteArrayForBinaryBuffer(paletteSize) {
+    if (paletteSize == BinaryBufferConstants.BitArrayMax)
+        return BinaryBufferFormat.BitArray;
+    if (paletteSize > BinaryBufferConstants.BitArrayMax &&
+        paletteSize <= BinaryBufferConstants.HalfNibbleArrayMax)
+        return BinaryBufferFormat.HalfNibbleArray;
+    if (paletteSize > BinaryBufferConstants.HalfNibbleArrayMax &&
+        paletteSize <= BinaryBufferConstants.NibbleArrayMax)
+        return BinaryBufferFormat.NibbleArray;
+    if (paletteSize > BinaryBufferConstants.NibbleArrayMax &&
+        paletteSize <= BinaryBufferConstants.ByteArrayMax)
+        return BinaryBufferFormat.Uint8;
+    return null;
+}
+function CreateBufferForType(type, length) {
+    if (type == BinaryBufferFormat.Uint16)
+        return new Uint16Array(length);
+    return new Uint8Array(length);
+}
+export function GetConvertedBinaryBufferSize(source, format) {
+    if (format == BinaryBufferFormat.Uint16 || format == BinaryBufferFormat.Uint8)
+        return source.length;
+    if (format == BinaryBufferFormat.BitArray)
+        return source.length / 8;
+    if (format == BinaryBufferFormat.HalfNibbleArray)
+        return source.length / 4;
+    if (format == BinaryBufferFormat.NibbleArray)
+        return source.length / 2;
+    return source.length;
+}
+export function GetBinaryBufferIndexLength(source, format) {
+    if (format == BinaryBufferFormat.Uint16 || format == BinaryBufferFormat.Uint8)
+        return source.length;
+    if (format == BinaryBufferFormat.BitArray)
+        return source.length * 8;
+    if (format == BinaryBufferFormat.HalfNibbleArray)
+        return source.length * 4;
+    if (format == BinaryBufferFormat.NibbleArray)
+        return source.length * 2;
+    return source.length;
+}
+export function ConvertBinaryBuffer(source, sourceType, destinationType) {
+    if (sourceType == destinationType ||
+        (sourceType == BinaryBufferFormat.Uint16 &&
+            destinationType == BinaryBufferFormat.Uint8) ||
+        (sourceType == BinaryBufferFormat.Uint8 &&
+            destinationType == BinaryBufferFormat.Uint16)) {
+        const destination = CreateBufferForType(destinationType, GetConvertedBinaryBufferSize(source, destinationType));
+        destination.set(source);
+        return destination;
+    }
+    const length = GetBinaryBufferIndexLength(source, sourceType);
+    const destination = CreateBufferForType(destinationType, GetConvertedBinaryBufferSize(source, destinationType));
+    for (let i = 0; i < length; i++) {
+        SetBufferAtIndex(destination, destinationType, i, ReadBufferAtIndex(source, sourceType, i));
+    }
+    return destination;
+}

package/Util/BinaryBuffer/Functions/BinaryBufferJSON.d.ts

@@ -0,0 +1,3 @@
+import { BinaryBufferCompresedTypes, BinaryBufferData, JSONBinaryBufferData } from "../BinaryBuffer.types";
+export declare function BinaryBufferFromJSON(data: JSONBinaryBufferData): Promise<BinaryBufferData>;
+export declare function BinaryBufferToJSON(data: BinaryBufferData, compression?: boolean | BinaryBufferCompresedTypes): Promise<JSONBinaryBufferData>;

package/Util/BinaryBuffer/Functions/BinaryBufferJSON.js

@@ -0,0 +1,64 @@
+import { BinaryBufferCompresedTypes, } from "../BinaryBuffer.types";
+export async function BinaryBufferFromJSON(data) {
+    let raw;
+    if (data.base64) {
+        let binary = atob(data.base64);
+        raw = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            raw[i] = binary.charCodeAt(i);
+        }
+        if (data.compression) {
+            const ds = new DecompressionStream(data.compression);
+            const writer = ds.writable.getWriter();
+            writer.write(raw);
+            writer.close();
+            const decompressed = await new Response(ds.readable).arrayBuffer();
+            raw = new Uint8Array(decompressed);
+        }
+    }
+    else if (typeof data.value == "number") {
+        raw = data.value;
+    }
+    else {
+        throw new Error(`Error converting binary buffer json. `);
+    }
+    return {
+        format: data.format,
+        byteLength: data.byteLength,
+        buffer: typeof raw === "number" ? raw : raw.buffer,
+    };
+}
+export async function BinaryBufferToJSON(data, compression) {
+    if (typeof data.buffer === "number") {
+        return {
+            format: data.format,
+            byteLength: data.byteLength,
+            value: data.buffer,
+        };
+    }
+    const input = new Uint8Array(data.buffer);
+    let bufferToEncode = input;
+    if (compression) {
+        compression =
+            typeof compression == "boolean"
+                ? BinaryBufferCompresedTypes.Gzip
+                : compression;
+        const cs = new CompressionStream(compression);
+        const writer = cs.writable.getWriter();
+        writer.write(input);
+        writer.close();
+        const compressedBuffer = await new Response(cs.readable).arrayBuffer();
+        bufferToEncode = new Uint8Array(compressedBuffer);
+    }
+    let binary = "";
+    for (let i = 0; i < bufferToEncode.length; i++) {
+        binary += String.fromCharCode(bufferToEncode[i]);
+    }
+    const base64 = btoa(binary);
+    return {
+        format: data.format,
+        byteLength: data.byteLength,
+        base64: base64,
+        ...(compression ? { compression } : {}),
+    };
+}

package/Util/BinaryBuffer/Functions/BinaryBufferRead.d.ts

@@ -0,0 +1,3 @@
+import { BinaryBufferFormat } from "../BinaryBuffer.types";
+export declare function ReadBufferAtIndex(source: Uint8Array | Uint16Array, format: BinaryBufferFormat, index: number): number;
+export declare function SetBufferAtIndex(source: Uint8Array | Uint16Array, format: BinaryBufferFormat, index: number, value: number): number | void;

package/Util/BinaryBuffer/Functions/BinaryBufferRead.js

@@ -0,0 +1,26 @@
+import { BinaryBufferFormat } from "../BinaryBuffer.types";
+import { getBitArrayIndex, getHalfNibbleArrayIndex, getNibbleArrayIndex, setBitArrayIndex, setHalfNibbleArrayIndex, setNibbleArrayIndex, } from "../../Binary/BinaryArrays";
+export function ReadBufferAtIndex(source, format, index) {
+    if (format == BinaryBufferFormat.Uint16 || format == BinaryBufferFormat.Uint8)
+        return source[index];
+    if (format == BinaryBufferFormat.BitArray)
+        return getBitArrayIndex(source, index);
+    if (format == BinaryBufferFormat.NibbleArray)
+        return getNibbleArrayIndex(source, index);
+    if (format == BinaryBufferFormat.HalfNibbleArray)
+        return getHalfNibbleArrayIndex(source, index);
+    return source[index];
+}
+export function SetBufferAtIndex(source, format, index, value) {
+    if (format == BinaryBufferFormat.Uint16 ||
+        format == BinaryBufferFormat.Uint8) {
+        return (source[index] = value);
+    }
+    if (format == BinaryBufferFormat.BitArray)
+        return setBitArrayIndex(source, index, value);
+    if (format == BinaryBufferFormat.NibbleArray)
+        return setNibbleArrayIndex(source, index, value);
+    if (format == BinaryBufferFormat.HalfNibbleArray)
+        return setHalfNibbleArrayIndex(source, index, value);
+    return source[index];
+}

package/Util/BinaryBuffer/Functions/BinaryBufferToTypedArray.d.ts

@@ -0,0 +1,2 @@
+import { BinaryBufferData } from "../BinaryBuffer.types";
+export default function BinaryBufferToTypedArray(buffer: BinaryBufferData): Uint16Array | Uint8Array | undefined;