nytra 0.0.3

package/dist/Binson.d.ts

@@ -0,0 +1,14 @@
+import { Reader } from "./Reader.ts";
+import { Writer } from "./Writer.ts";
+export type RegisterFieldOptions = {
+    nullable?: boolean;
+};
+export declare class Binson {
+    #private;
+    static registerField(position: number, targetTypeId?: number | Function, options?: RegisterFieldOptions): (v: undefined, ctx: ClassFieldDecoratorContext) => void;
+    static registerClass(typeId: number): <T extends Function>(decoratedClass: T, ctx: ClassDecoratorContext) => void;
+    static autoguessType(data: unknown): number;
+    static getTypeIdForClass(ctor: Function): number;
+    static encode(data: unknown, type?: number | null, withType?: boolean, writer?: Writer | null): Uint8Array;
+    static decode(data: Uint8Array | Reader, type?: number | null): unknown;
+}

package/dist/Binson.js

@@ -0,0 +1,468 @@
+import { Reader } from "./Reader.js";
+import { Registry } from "./Registry.js";
+import { Writer } from "./Writer.js";
+import { TYPE_ARRAY, TYPE_BIGINT, TYPE_BOOLEAN, TYPE_EXTENSION, TYPE_FLOAT32, TYPE_FLOAT64, TYPE_INT16, TYPE_INT32, TYPE_INT64, TYPE_INT8, TYPE_JSON, TYPE_NULL, TYPE_OBJECT, TYPE_STRING, TYPE_STRING_16_INTERNAL, TYPE_STRING_32_INTERNAL, TYPE_UINT16, TYPE_UINT32, TYPE_UINT64, TYPE_UINT8 } from "./Types.js";
+const MAX_UINT_32 = 2 ** 32;
+const MAX_UINT_16 = 2 ** 16;
+const MAX_UINT_8 = 2 ** 8;
+const MIN_INT_32 = -(2 ** 31);
+const MIN_INT_16 = -(2 ** 15);
+const MIN_INT_8 = -(2 ** 8);
+function createDecoder(cls) {
+    const meta = classMetaStore.get(cls);
+    const fields = meta?.fields;
+    return function (reader) {
+        let obj = {};
+        const nullableFields = fields.filter(([_name, meta]) => meta.options.nullable).map(([name, _meta]) => name);
+        const nullableBytes = Math.ceil(nullableFields.length / 8);
+        const nullableBitfield = nullableBytes > 0 ? reader.readBytes(nullableBytes) : [];
+        const isFieldNull = (index) => {
+            const byteIndex = Math.floor(index / 8);
+            const bitOffset = index % 8;
+            return (nullableBitfield[byteIndex] & (1 << bitOffset)) !== 0;
+        };
+        for (let [name, meta] of fields) {
+            if (nullableBytes > 0 && meta.options.nullable) {
+                const nullIndex = nullableFields.indexOf(name);
+                if (nullIndex !== -1 && isFieldNull(nullIndex)) {
+                    obj[name] = null;
+                    continue;
+                }
+            }
+            if (typeof meta.targetTypeId === "function") {
+                const found = classMetaStore.get(meta.targetTypeId);
+                meta.targetTypeId = found ? found.typeId : TYPE_JSON;
+            }
+            let type = meta.targetTypeId;
+            if (type === TYPE_STRING) {
+                type = reader.readType();
+            }
+            obj[name] = Binson.decode(reader, type);
+        }
+        Object.setPrototypeOf(obj, cls.prototype);
+        return obj;
+    };
+}
+function createEncoder(cls) {
+    const meta = classMetaStore.get(cls);
+    const cachedEncoders = [];
+    const nullableFields = [];
+    let nullableBytes = 0;
+    return function (data, writer) {
+        if (writer === null) {
+            writer = new Writer();
+        }
+        if (cachedEncoders.length == 0) {
+            meta.fields.forEach(([name, fieldMeta]) => {
+                if (fieldMeta.options.nullable) {
+                    nullableFields.push(name);
+                }
+                let typeId = fieldMeta.targetTypeId;
+                if (!typeId) {
+                    cachedEncoders.push({ name: name, encode: null, options: fieldMeta.options });
+                    return;
+                }
+                // Resolve Function → typeId hier, nicht im Loop!
+                if (typeof typeId === 'function') {
+                    const found = classMetaStore.get(typeId);
+                    typeId = found ? found.typeId : TYPE_JSON;
+                }
+                // Encoder-Funktion vorgebunden
+                let encodeFn;
+                if (typeId < 255) {
+                    encodeFn = (value, writer) => Binson.encode(value, typeId, false, writer);
+                }
+                else {
+                    encodeFn = CustomRegistry.getEncoder(typeId);
+                }
+                cachedEncoders.push({ name: name, encode: encodeFn, options: fieldMeta.options });
+            });
+            nullableBytes = Math.ceil(nullableFields.length / 8);
+        }
+        if (nullableBytes > 0) {
+            const nullableBitfield = new Uint8Array(nullableBytes);
+            for (let i = 0; i < nullableFields.length; i++) {
+                const field = nullableFields[i];
+                if (data[field] === null) {
+                    const byteIndex = Math.floor(i / 8);
+                    const bitOffset = i % 8;
+                    nullableBitfield[byteIndex] |= (1 << bitOffset);
+                }
+            }
+            writer.writeBytes(nullableBitfield);
+        }
+        for (const encodeInfo of cachedEncoders) {
+            const value = data[encodeInfo.name];
+            if (value === null && encodeInfo.options.nullable) {
+                continue;
+            }
+            encodeInfo.encode ?
+                encodeInfo.encode(data[encodeInfo.name], writer) :
+                Binson.encode(data[encodeInfo.name], null, true, writer);
+        }
+        return writer.toUint8Array();
+    };
+}
+const classMetaStore = new WeakMap();
+const SYMBOL_FIELDS = Symbol('binson:fields');
+const CustomRegistry = new Registry();
+export class Binson {
+    static registerField(position, targetTypeId, options = {}) {
+        const defaultOpts = {
+            nullable: false
+        };
+        Object.assign(defaultOpts, options);
+        return function (v, ctx) {
+            if (ctx.private) {
+                throw new Error('Only public fields can be registered');
+            }
+            const metadata = ctx.metadata;
+            if (typeof metadata[SYMBOL_FIELDS] === 'undefined') {
+                metadata[SYMBOL_FIELDS] = new Map();
+            }
+            const fieldMeta = {
+                position,
+                targetTypeId,
+                options: defaultOpts
+            };
+            metadata[SYMBOL_FIELDS].set(ctx.name, fieldMeta);
+        };
+    }
+    static registerClass(typeId) {
+        if (typeId < 256 || typeId > 65535) {
+            throw new Error('typeId must be in range of 256 and 65535');
+        }
+        return function (decoratedClass, ctx) {
+            const metadata = ctx.metadata;
+            const fields = metadata[SYMBOL_FIELDS] ?
+                [...metadata[SYMBOL_FIELDS].entries()].sort(([_aName, aMeta], [_bName, bMeta]) => aMeta.position - bMeta.position)
+                : [];
+            classMetaStore.set(decoratedClass, { typeId, fields });
+            CustomRegistry.register(typeId, {
+                encoder: createEncoder(decoratedClass),
+                decoder: createDecoder(decoratedClass)
+            });
+        };
+    }
+    static autoguessType(data) {
+        if (data === null) {
+            return TYPE_NULL;
+        }
+        if (typeof data === 'object') {
+            const ctor = data.constructor;
+            const found = classMetaStore.get(ctor);
+            if (found) {
+                return found.typeId;
+            }
+        }
+        if (Array.isArray(data)) {
+            return TYPE_ARRAY;
+        }
+        if (typeof data === 'object') {
+            return TYPE_OBJECT;
+        }
+        if (typeof data === 'string') {
+            return TYPE_STRING;
+        }
+        if (typeof data === 'boolean') {
+            return TYPE_BOOLEAN;
+        }
+        if (typeof data === 'number') {
+            if (Number.isInteger(data)) {
+                if (data >= 0) {
+                    //unsigned possible
+                    if (data <= MAX_UINT_8) {
+                        return TYPE_UINT8;
+                    }
+                    if (data <= MAX_UINT_16) {
+                        return TYPE_UINT16;
+                    }
+                    if (data <= MAX_UINT_32) {
+                        return TYPE_UINT32;
+                    }
+                    return TYPE_UINT64;
+                }
+                else {
+                    if (data >= MIN_INT_8) {
+                        return TYPE_INT8;
+                    }
+                    if (data >= MIN_INT_16) {
+                        return TYPE_INT16;
+                    }
+                    if (data >= MIN_INT_32) {
+                        return TYPE_INT32;
+                    }
+                    return TYPE_INT64;
+                }
+            }
+            if (Math.fround(data) === data) {
+                return TYPE_FLOAT32;
+            }
+            return TYPE_FLOAT64;
+        }
+        if (typeof data === 'bigint') {
+            return TYPE_BIGINT;
+        }
+        return TYPE_JSON;
+    }
+    static getTypeIdForClass(ctor) {
+        const found = classMetaStore.get(ctor);
+        return found ? found.typeId : TYPE_JSON;
+    }
+    static #TEXT_ENCODER = new TextEncoder();
+    static encode(data, type = null, withType = true, writer = null) {
+        if (writer === null) {
+            writer = new Writer();
+        }
+        if (type === null) {
+            type = this.autoguessType(data);
+        }
+        if (type >= 256) {
+            const encodeFunction = CustomRegistry.getEncoder(type);
+            if (typeof encodeFunction !== 'function') {
+                throw new Error('Unknown type:' + type);
+            }
+            if (withType) {
+                writer.writeUint8(TYPE_EXTENSION);
+                writer.writeUint16(type);
+            }
+            encodeFunction(data, writer);
+            return writer.toUint8Array();
+        }
+        if (type >= TYPE_STRING) { //automatically
+            const str = data;
+            const bytes = this.#TEXT_ENCODER.encode(str);
+            const len = bytes.length;
+            if (len <= 127) {
+                writer.writeUint8(128 + len);
+                writer.writeBytes(bytes);
+                return writer.toUint8Array();
+            }
+            if (len <= 65535) {
+                writer.writeUint8(TYPE_STRING_16_INTERNAL);
+                writer.writeUint16(len);
+                writer.writeBytes(bytes);
+                return writer.toUint8Array();
+            }
+            writer.writeUint8(TYPE_STRING_32_INTERNAL);
+            writer.writeUint32(len);
+            writer.writeBytes(bytes);
+            return writer.toUint8Array();
+        }
+        switch (type) {
+            case TYPE_NULL:
+                writer.writeUint8(TYPE_NULL);
+                return writer.toUint8Array();
+            case TYPE_ARRAY: {
+                if (!Array.isArray(data)) {
+                    throw new Error('Data must be an array');
+                }
+                const arr = data;
+                if (withType)
+                    writer.writeUint8(TYPE_ARRAY);
+                const startIndex = writer.offset;
+                writer.setOffset(startIndex + 4); // reserve space for length
+                for (let value of arr) {
+                    this.encode(value, null, true, writer);
+                }
+                const endIndex = writer.offset;
+                writer.setOffset(startIndex);
+                writer.writeUint32(endIndex - startIndex - 4);
+                writer.setOffset(endIndex);
+                return writer.toUint8Array();
+            }
+            case TYPE_OBJECT: {
+                if (typeof data !== 'object') {
+                    throw new Error('Data must be an array');
+                }
+                const obj = data;
+                if (withType)
+                    writer.writeUint8(TYPE_OBJECT);
+                const startIndex = writer.offset;
+                writer.setOffset(startIndex + 4);
+                let keys = Object.keys(obj);
+                for (let key of keys) {
+                    this.encode(key, TYPE_STRING, true, writer);
+                    this.encode(obj[key], null, true, writer);
+                }
+                const endIndex = writer.offset;
+                writer.setOffset(startIndex);
+                writer.writeUint32(endIndex - startIndex - 4);
+                writer.setOffset(endIndex);
+                return writer.toUint8Array();
+            }
+            case TYPE_UINT8: {
+                if (withType)
+                    writer.writeUint8(TYPE_UINT8);
+                writer.writeUint8(data);
+                return writer.toUint8Array();
+            }
+            case TYPE_UINT16: {
+                if (withType)
+                    writer.writeUint8(TYPE_UINT16);
+                writer.writeUint16(data);
+                return writer.toUint8Array();
+            }
+            case TYPE_UINT32: {
+                if (withType)
+                    writer.writeUint8(TYPE_UINT32);
+                writer.writeUint32(data);
+                return writer.toUint8Array();
+            }
+            case TYPE_UINT64: {
+                if (withType)
+                    writer.writeUint8(TYPE_UINT64);
+                writer.writeUint64(BigInt(data));
+                return writer.toUint8Array();
+            }
+            case TYPE_INT8: {
+                if (withType)
+                    writer.writeUint8(TYPE_INT8);
+                writer.writeInt8(data);
+                return writer.toUint8Array();
+            }
+            case TYPE_INT16: {
+                if (withType)
+                    writer.writeUint8(TYPE_INT16);
+                writer.writeInt16(data);
+                return writer.toUint8Array();
+            }
+            case TYPE_INT32: {
+                if (withType)
+                    writer.writeUint8(TYPE_INT32);
+                writer.writeInt32(data);
+                return writer.toUint8Array();
+            }
+            case TYPE_INT64: {
+                if (withType)
+                    writer.writeUint8(TYPE_INT64);
+                writer.writeInt64(BigInt(data));
+                return writer.toUint8Array();
+            }
+            case TYPE_BOOLEAN: {
+                if (withType)
+                    writer.writeUint8(TYPE_BOOLEAN);
+                writer.writeUint8(data ? 1 : 0);
+                return writer.toUint8Array();
+            }
+            case TYPE_JSON: {
+                return this.encode(JSON.stringify(data), TYPE_STRING, withType, writer);
+            }
+            case TYPE_FLOAT32: {
+                if (withType)
+                    writer.writeUint8(TYPE_FLOAT32);
+                writer.writeFloat32(data);
+                return writer.toUint8Array();
+            }
+            case TYPE_FLOAT64: {
+                if (withType)
+                    writer.writeUint8(TYPE_FLOAT64);
+                writer.writeFloat64(data);
+                return writer.toUint8Array();
+            }
+            case TYPE_BIGINT: {
+                if (withType)
+                    writer.writeUint8(TYPE_BIGINT);
+                writer.writeBigInt(BigInt(data));
+                return writer.toUint8Array();
+            }
+        }
+        throw new Error('Type unknown: ' + type);
+    }
+    static decode(data, type = null) {
+        let reader = data instanceof Reader ? data : new Reader(data);
+        if (type === null)
+            type = reader.readType();
+        if (type > 255) {
+            const decodeFunction = CustomRegistry.getDecoder(type);
+            if (typeof decodeFunction !== 'function') {
+                throw new Error('Unknown type:' + type);
+            }
+            return decodeFunction(reader);
+        }
+        if (type >= TYPE_STRING) {
+            let length = type & 0b01111111;
+            return reader.readString(length);
+        }
+        switch (type) {
+            case TYPE_STRING_16_INTERNAL: {
+                const length = reader.readUINT16();
+                return reader.readString(length);
+            }
+            case TYPE_STRING_32_INTERNAL: {
+                const length = reader.readUINT32();
+                return reader.readString(length);
+            }
+            case TYPE_BOOLEAN: {
+                return reader.readUINT8() !== 0;
+            }
+            case TYPE_JSON: {
+                const json = this.decode(reader);
+                return JSON.parse(json);
+            }
+            case TYPE_UINT8: {
+                return reader.readUINT8();
+            }
+            case TYPE_UINT16: {
+                return reader.readUINT16();
+            }
+            case TYPE_UINT32: {
+                return reader.readUINT32();
+            }
+            case TYPE_UINT64: {
+                return bigintToSafeNumber(reader.readUINT64());
+            }
+            case TYPE_INT8: {
+                return reader.readINT8();
+            }
+            case TYPE_INT16: {
+                return reader.readINT16();
+            }
+            case TYPE_INT32: {
+                return reader.readINT32();
+            }
+            case TYPE_INT64: {
+                return bigintToSafeNumber(reader.readINT64());
+            }
+            case TYPE_FLOAT64: {
+                return reader.readFloat64();
+            }
+            case TYPE_FLOAT32: {
+                return reader.readFloat32();
+            }
+            case TYPE_ARRAY: {
+                const len = reader.readUINT32();
+                const end = reader.offset + len;
+                const targetArray = [];
+                while (reader.offset < end) {
+                    targetArray.push(this.decode(reader));
+                }
+                return targetArray;
+            }
+            case TYPE_OBJECT: {
+                const len = reader.readUINT32();
+                const end = reader.offset + len;
+                const targetObj = {};
+                while (reader.offset < end) {
+                    const key = this.decode(reader);
+                    targetObj[key] = this.decode(reader);
+                }
+                return targetObj;
+            }
+            case TYPE_BIGINT: {
+                return reader.readBigInt();
+            }
+            case TYPE_NULL: {
+                return null;
+            }
+        }
+        throw new Error('Unknown type:' + type);
+    }
+}
+function bigintToSafeNumber(value) {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER) ||
+        value < BigInt(Number.MIN_SAFE_INTEGER)) {
+        return value;
+    }
+    return Number(value);
+}

package/dist/NativeHandlers.d.ts

@@ -0,0 +1,25 @@
+import { Reader } from "./Reader.ts";
+export declare const NativeHandlers: {
+    readonly [x: number]: {
+        encoder: (data: null) => Uint8Array<ArrayBuffer>;
+        decoder: (reader: Reader) => null;
+    } | {
+        encoder: (data: number) => Uint8Array<ArrayBufferLike>;
+        decoder: (reader: Reader) => number;
+    } | {
+        encoder: (data: bigint) => Uint8Array<ArrayBufferLike>;
+        decoder: (reader: Reader) => bigint;
+    } | {
+        encoder: (data: boolean) => Uint8Array<ArrayBuffer>;
+        decoder: (reader: Reader) => boolean;
+    } | {
+        decoder(reader: Reader): object;
+        encoder(data: object): Uint8Array;
+    } | {
+        encoder: (json: unknown) => Uint8Array<ArrayBufferLike>;
+        decoder: (reader: Reader) => any;
+    } | {
+        encoder: (data: string) => Uint8Array<ArrayBufferLike>;
+        decoder: (reader: Reader) => string;
+    };
+};

package/dist/NativeHandlers.js

@@ -0,0 +1,137 @@
+import { Writer } from "./Writer.js";
+import { Binson } from "./Binson.js";
+import { Reader } from "./Reader.js";
+const TRUE = new Uint8Array([1]);
+const FALSE = new Uint8Array([0]);
+export const NativeHandlers = {
+    [Types.NULL]: {
+        encoder: (data) => new Uint8Array(0),
+        decoder: (reader) => null
+    },
+    [Types.UINT8]: {
+        encoder: (data) => new Writer(1).writeUint8(data).toUint8Array(),
+        decoder: (reader) => reader.readUINT8()
+    },
+    [Types.UINT16]: {
+        encoder: (data) => new Writer(2).writeUint16(data).toUint8Array(),
+        decoder: (reader) => reader.readUINT16()
+    },
+    [Types.UINT32]: {
+        encoder: (data) => new Writer(4).writeUint32(data).toUint8Array(),
+        decoder: (reader) => reader.readUINT32()
+    },
+    [Types.UINT64]: {
+        encoder: (data) => new Writer(8).writeUint64(BigInt(data)).toUint8Array(),
+        decoder: (reader) => Number(reader.readUINT64())
+    },
+    [Types.INT8]: {
+        encoder: (data) => new Writer(1).writeUint8(data).toUint8Array(),
+        decoder: (reader) => reader.readINT8()
+    },
+    [Types.INT16]: {
+        encoder: (data) => new Writer(2).writeInt16(data).toUint8Array(),
+        decoder: (reader) => reader.readINT16()
+    },
+    [Types.INT32]: {
+        encoder: (data) => new Writer(4).writeInt32(data).toUint8Array(),
+        decoder: (reader) => reader.readINT32()
+    },
+    [Types.INT64]: {
+        encoder: (data) => new Writer(8).writeInt64(BigInt(data)).toUint8Array(),
+        decoder: (reader) => Number(reader.readINT64())
+    },
+    [Types.FLOAT32]: {
+        encoder: (data) => new Writer(4).writeFloat32(data).toUint8Array(),
+        decoder: (reader) => reader.readFloat32()
+    },
+    [Types.FLOAT64]: {
+        encoder: (data) => new Writer(4).writeFloat32(data).toUint8Array(),
+        decoder: (reader) => reader.readFloat32()
+    },
+    [Types.BIGINT]: {
+        encoder: (data) => new Writer(10).writeBigInt(data).toUint8Array(),
+        decoder: (reader) => reader.readBigInt()
+    },
+    [Types.BOOLEAN]: {
+        encoder: (data) => data ? TRUE : FALSE,
+        decoder: (reader) => reader.readUINT8() > 0
+    },
+    [Types.ARRAY]: {
+        decoder(reader) {
+            let fullData = [];
+            let length = reader.readUINT32();
+            let buffer = reader.readBytes(length);
+            let bufferReader = new Reader(buffer);
+            while (bufferReader.remaining > 0) {
+                fullData.push(Binson.decode(bufferReader));
+            }
+            return fullData;
+        }, encoder(data) {
+            const buffer = flattenUint8Array(data.map(d => Binson.encode(d, null)));
+            const length = new Uint8Array(4);
+            new DataView(length.buffer).setUint32(0, buffer.length, true);
+            const out = new Uint8Array(4 + buffer.length);
+            out.set(length, 0);
+            out.set(buffer, 4);
+            return out;
+        }
+    },
+    [Types.OBJECT]: {
+        decoder(reader) {
+            let fullData = {};
+            let length = reader.readUINT32();
+            let buffer = reader.readBytes(length);
+            let bufferReader = new Reader(buffer);
+            while (bufferReader.remaining > 0) {
+                let key = bufferReader.readString();
+                fullData[key] = Binson.decode(bufferReader);
+            }
+            return fullData;
+        }, encoder(data) {
+            let keys = Object.keys(data);
+            let dataArray = new Array(keys.length * 2);
+            for (let i = 0; i < keys.length; i++) {
+                let key = keys[i];
+                dataArray[i * 2] = Binson.encodeValue(key, Types.STRING);
+                dataArray[i * 2 + 1] = Binson.encode(data[key], null);
+            }
+            let buffer = flattenUint8Array(dataArray);
+            const length = new Uint8Array(4);
+            new DataView(length.buffer).setUint32(0, buffer.length, true);
+            const out = new Uint8Array(4 + buffer.length);
+            out.set(length, 0);
+            out.set(buffer, 4);
+            return out;
+        }
+    },
+    [Types.JSON]: {
+        encoder: (json) => {
+            let data = JSON.stringify(json);
+            const bytes = new TextEncoder().encode(data);
+            return new Writer(2 + bytes.length)
+                .writeString(data)
+                .toUint8Array();
+        },
+        decoder: (reader) => JSON.parse(reader.readString())
+    },
+    [Types.STRING]: {
+        encoder: (data) => {
+            const bytes = new TextEncoder().encode(data);
+            return new Writer(2 + bytes.length)
+                .writeString(data)
+                .toUint8Array();
+        },
+        decoder: (reader) => reader.readString()
+    },
+};
+function flattenUint8Array(chunks) {
+    const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}

package/dist/Reader.d.ts

@@ -0,0 +1,35 @@
+export declare class Reader {
+    #private;
+    /**
+     *
+     * @param {Uint8Array} buffer
+     */
+    constructor(buffer: Uint8Array);
+    /**
+     *
+     * @param {number} length
+     */
+    readBytes(length: number): Uint8Array<ArrayBufferLike>;
+    readUINT8(): number;
+    readUINT16(): number;
+    readUINT32(): number;
+    readUINT64(): bigint;
+    readINT8(): number;
+    readINT16(): number;
+    readINT32(): number;
+    readINT64(): bigint;
+    readFloat32(): number;
+    readFloat64(): number;
+    readString(length: number): string;
+    readBigInt(): bigint;
+    readType(): number;
+    /**
+     * Current read offset
+     */
+    get offset(): number;
+    /**
+     * Number of bytes remaining to read
+     */
+    get remaining(): number;
+    skip(bytes: number): void;
+}

package/dist/Reader.js

@@ -0,0 +1,133 @@
+import { TYPE_EXTENSION } from "./Types.js";
+const LITTLE_ENDIAN = true;
+export class Reader {
+    static #decoder = new TextDecoder();
+    #ind = 0;
+    #data;
+    #dataView;
+    /**
+     *
+     * @param {Uint8Array} buffer
+     */
+    constructor(buffer) {
+        this.#data = buffer;
+        this.#dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    /**
+     *
+     * @param {number} length
+     */
+    readBytes(length) {
+        if (Number.isInteger(length) && length > 0) {
+            const start = this.#ind;
+            const end = start + length;
+            if (end > this.#data.length) {
+                throw new Error('Out of bounds read');
+            }
+            this.#ind = end;
+            return this.#data.subarray(start, end);
+        }
+        throw new Error('Invalid length:' + length);
+    }
+    readUINT8() {
+        return this.#dataView.getUint8(this.#ind++);
+    }
+    readUINT16() {
+        const offset = this.#ind;
+        this.#ind += 2;
+        return this.#dataView.getUint16(offset, LITTLE_ENDIAN);
+    }
+    readUINT32() {
+        const offset = this.#ind;
+        this.#ind += 4;
+        return this.#dataView.getUint32(offset, LITTLE_ENDIAN);
+    }
+    readUINT64() {
+        const offset = this.#ind;
+        this.#ind += 8;
+        return this.#dataView.getBigUint64(offset, LITTLE_ENDIAN);
+    }
+    readINT8() {
+        return this.#dataView.getInt8(this.#ind++);
+    }
+    readINT16() {
+        const offset = this.#ind;
+        this.#ind += 2;
+        return this.#dataView.getInt16(offset, LITTLE_ENDIAN);
+    }
+    readINT32() {
+        const offset = this.#ind;
+        this.#ind += 4;
+        return this.#dataView.getInt32(offset, LITTLE_ENDIAN);
+    }
+    readINT64() {
+        const offset = this.#ind;
+        this.#ind += 8;
+        return this.#dataView.getBigInt64(offset, LITTLE_ENDIAN);
+    }
+    readFloat32() {
+        const offset = this.#ind;
+        this.#ind += 4;
+        return this.#dataView.getFloat32(offset, LITTLE_ENDIAN);
+    }
+    readFloat64() {
+        const offset = this.#ind;
+        this.#ind += 8;
+        return this.#dataView.getFloat64(offset, LITTLE_ENDIAN);
+    }
+    readString(length) {
+        const bytes = this.readBytes(length);
+        return Reader.#decoder.decode(bytes);
+    }
+    readBigInt() {
+        const length = this.readUINT16();
+        const bytes = this.readBytes(length);
+        return uint8ArrayLEToBigint(bytes);
+    }
+    readType() {
+        let type = this.readUINT8();
+        if (type === TYPE_EXTENSION) {
+            type = this.readUINT16();
+        }
+        return type;
+    }
+    /**
+     * Current read offset
+     */
+    get offset() {
+        return this.#ind;
+    }
+    /**
+     * Number of bytes remaining to read
+     */
+    get remaining() {
+        return this.#data.length - this.#ind;
+    }
+    skip(bytes) {
+        this.#ind += bytes;
+    }
+}
+function uint8ArrayLEToBigint(bytes) {
+    const len = bytes.length;
+    if (len === 0)
+        return 0n;
+    const isNegative = (bytes[len - 1] & 0x80) !== 0;
+    let value = 0n;
+    let shift = 0n;
+    if (!isNegative) {
+        for (let i = 0; i < len; i++) {
+            value |= BigInt(bytes[i]) << shift;
+            shift += 8n;
+        }
+        return value;
+    }
+    // two's complement decode without temp allocation
+    let carry = 1;
+    for (let i = 0; i < len; i++) {
+        const t = (bytes[i] ^ 0xff) + carry;
+        carry = t >>> 8; // 0 or 1
+        value |= BigInt(t & 0xff) << shift;
+        shift += 8n;
+    }
+    return -value;
+}

package/dist/Registry.d.ts

@@ -0,0 +1,14 @@
+import type { Reader } from "./Reader.ts";
+import { Writer } from "./Writer.ts";
+export type Encoder<T = unknown> = (data: T, writer: Writer | null) => Uint8Array;
+export type Decoder<T = unknown> = (reader: Reader) => T;
+export type TypeHandler<T = unknown> = {
+    encoder: Encoder<T>;
+    decoder: Decoder<T>;
+};
+export declare class Registry {
+    #private;
+    register<T>(type: number, handler: TypeHandler<T>): void;
+    getDecoder(type: number): Decoder;
+    getEncoder(type: number): Encoder;
+}

package/dist/Registry.js

@@ -0,0 +1,27 @@
+export class Registry {
+    /**
+     *
+     * @type {Map<number, TypeHandler>}
+     */
+    #registry = new Map();
+    register(type, handler) {
+        if (this.#registry.has(type)) {
+            throw new Error('Type already registered:' + type);
+        }
+        this.#registry.set(type, handler);
+    }
+    getDecoder(type) {
+        const decoder = this.#registry.get(type)?.decoder;
+        if (!decoder) {
+            throw new Error('Unknown type: ' + type);
+        }
+        return decoder;
+    }
+    getEncoder(type) {
+        const encoder = this.#registry.get(type)?.encoder;
+        if (!encoder) {
+            throw new Error('Unknown type: ' + type);
+        }
+        return encoder;
+    }
+}

package/dist/Types.d.ts

@@ -0,0 +1 @@
+export declare const TYPE_NULL = 0, TYPE_BOOLEAN = 1, TYPE_ARRAY = 2, TYPE_OBJECT = 3, TYPE_STRING_16_INTERNAL = 4, TYPE_STRING_32_INTERNAL = 5, TYPE_JSON = 9, TYPE_UINT8 = 11, TYPE_UINT16 = 12, TYPE_UINT32 = 13, TYPE_UINT64 = 14, TYPE_INT8 = 21, TYPE_INT16 = 22, TYPE_INT32 = 23, TYPE_INT64 = 24, TYPE_FLOAT32 = 30, TYPE_FLOAT64 = 31, TYPE_BIGINT = 40, TYPE_EXTENSION = 127, TYPE_STRING = 128;

package/dist/Types.js

@@ -0,0 +1,3 @@
+export const TYPE_NULL = 0, TYPE_BOOLEAN = 1, TYPE_ARRAY = 2, TYPE_OBJECT = 3, TYPE_STRING_16_INTERNAL = 4, TYPE_STRING_32_INTERNAL = 5, TYPE_JSON = 9, TYPE_UINT8 = 11, TYPE_UINT16 = 12, TYPE_UINT32 = 13, TYPE_UINT64 = 14, TYPE_INT8 = 21, TYPE_INT16 = 22, TYPE_INT32 = 23, TYPE_INT64 = 24, TYPE_FLOAT32 = 30, TYPE_FLOAT64 = 31, TYPE_BIGINT = 40, TYPE_EXTENSION = 127, 
+//128-255 -> String use 7 bits for length (max 127)
+TYPE_STRING = 128;

package/dist/Writer.d.ts

@@ -0,0 +1,22 @@
+export declare class Writer {
+    #private;
+    static DEFAULT_SIZE: number;
+    setOffset(value: number, automaticallyExpand?: boolean): void;
+    get offset(): number;
+    constructor(initialSize?: number);
+    private ensureCapacity;
+    writeInt8(value: number): this;
+    writeInt16(value: number): this;
+    writeInt32(value: number): this;
+    writeInt64(value: bigint): this;
+    writeUint8(value: number): this;
+    writeUint16(value: number): this;
+    writeUint32(value: number): this;
+    writeUint64(value: bigint): this;
+    writeFloat32(value: number): this;
+    writeFloat64(value: number): this;
+    writeBytes(bytes: Uint8Array): this;
+    writeBigInt(value: bigint): this;
+    toUint8Array(): Uint8Array;
+    get length(): number;
+}

package/dist/Writer.js

@@ -0,0 +1,150 @@
+const LITTLE_ENDIAN = true;
+export class Writer {
+    static DEFAULT_SIZE = 1024;
+    static #encoder = new TextEncoder();
+    #buffer;
+    #view;
+    #offset = 0;
+    setOffset(value, automaticallyExpand = false) {
+        if (value < 0) {
+            throw new Error('Offset cannot be negative');
+        }
+        if (value >= this.#buffer.byteLength) {
+            if (!automaticallyExpand) {
+                throw new Error('Offset out of bounds');
+            }
+            this.ensureCapacity(value - this.#offset);
+        }
+        this.#offset = value;
+    }
+    get offset() {
+        return this.#offset;
+    }
+    constructor(initialSize = Writer.DEFAULT_SIZE) {
+        this.#buffer = new ArrayBuffer(initialSize);
+        this.#view = new DataView(this.#buffer);
+    }
+    ensureCapacity(additionalLength) {
+        const required = this.#offset + additionalLength;
+        if (required <= this.#buffer.byteLength)
+            return;
+        let newLength = this.#buffer.byteLength * 2;
+        while (newLength < required) {
+            newLength *= 2;
+        }
+        const newBuffer = new ArrayBuffer(newLength);
+        // copy old data
+        new Uint8Array(newBuffer).set(new Uint8Array(this.#buffer));
+        this.#buffer = newBuffer;
+        this.#view = new DataView(newBuffer);
+    }
+    writeInt8(value) {
+        this.ensureCapacity(1);
+        this.#view.setInt8(this.#offset, value);
+        this.#offset += 1;
+        return this;
+    }
+    writeInt16(value) {
+        this.ensureCapacity(2);
+        this.#view.setInt16(this.#offset, value, LITTLE_ENDIAN);
+        this.#offset += 2;
+        return this;
+    }
+    writeInt32(value) {
+        this.ensureCapacity(4);
+        this.#view.setInt32(this.#offset, value, LITTLE_ENDIAN);
+        this.#offset += 4;
+        return this;
+    }
+    writeInt64(value) {
+        this.ensureCapacity(8);
+        this.#view.setBigInt64(this.#offset, value, LITTLE_ENDIAN);
+        this.#offset += 8;
+        return this;
+    }
+    writeUint8(value) {
+        this.ensureCapacity(1);
+        this.#view.setUint8(this.#offset, value);
+        this.#offset += 1;
+        return this;
+    }
+    writeUint16(value) {
+        this.ensureCapacity(2);
+        this.#view.setUint16(this.#offset, value, LITTLE_ENDIAN);
+        this.#offset += 2;
+        return this;
+    }
+    writeUint32(value) {
+        this.ensureCapacity(4);
+        this.#view.setUint32(this.#offset, value, LITTLE_ENDIAN);
+        this.#offset += 4;
+        return this;
+    }
+    writeUint64(value) {
+        this.ensureCapacity(8);
+        this.#view.setBigUint64(this.#offset, value, LITTLE_ENDIAN);
+        this.#offset += 8;
+        return this;
+    }
+    writeFloat32(value) {
+        this.ensureCapacity(4);
+        this.#view.setFloat32(this.#offset, value, LITTLE_ENDIAN);
+        this.#offset += 4;
+        return this;
+    }
+    writeFloat64(value) {
+        this.ensureCapacity(8);
+        this.#view.setFloat64(this.#offset, value, LITTLE_ENDIAN);
+        this.#offset += 8;
+        return this;
+    }
+    writeBytes(bytes) {
+        this.ensureCapacity(bytes.length);
+        new Uint8Array(this.#buffer, this.#offset, bytes.length).set(bytes);
+        this.#offset += bytes.length;
+        return this;
+    }
+    writeBigInt(value) {
+        let bytes = bigintToUint8ArrayLE(value);
+        this.writeUint16(bytes.length);
+        this.writeBytes(bytes);
+        return this;
+    }
+    toUint8Array() {
+        return new Uint8Array(this.#buffer, 0, this.#offset);
+    }
+    get length() {
+        return this.#offset;
+    }
+}
+function bigintToUint8ArrayLE(value) {
+    if (value === 0n)
+        return new Uint8Array([0]);
+    const isNegative = value < 0n;
+    // Work in absolute space first if negative
+    let abs = isNegative ? -value : value;
+    // Collect bytes (little-endian magnitude)
+    const bytes = [];
+    while (abs > 0n) {
+        bytes.push(Number(abs & 0xffn));
+        abs >>= 8n;
+    }
+    // Ensure sign bit correctness in the highest byte
+    const signBitSet = (bytes[bytes.length - 1] & 0x80) !== 0;
+    if (isNegative) {
+        // two's complement across variable length
+        let carry = 1;
+        for (let i = 0; i < bytes.length; i++) {
+            const inverted = (~bytes[i] & 0xff) + carry;
+            bytes[i] = inverted & 0xff;
+            carry = inverted > 0xff ? 1 : 0;
+        }
+        if (carry)
+            bytes.push(0xff);
+    }
+    else if (signBitSet) {
+        // prevent misinterpretation as negative
+        bytes.push(0x00);
+    }
+    return new Uint8Array(bytes);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { Binson } from "./Binson.js";
+export * as Types from "./Types.ts";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Binson } from "./Binson.js";
+export * as Types from "./Types.js";

package/package.json

@@ -0,0 +1,27 @@
+{
+  "private": false,
+  "name": "nytra",
+  "version": "0.0.3",
+  "description": "A javascript ES6 Decorator driven library to encode/decode javascript objects to/from binary optimized buffers to reduce payload on network",
+  "license": "MIT",
+  "author": "",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "files": ["dist"],
+  "devDependencies": {
+    "@msgpack/msgpack": "^3.1.3",
+    "@types/bun": "^1.3.13",
+    "typescript": "^6.0.3"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  }
+}