nytra 0.0.4 → 0.0.6

package/dist/Nytra.d.ts

@@ -1,8 +1,11 @@
 import { Reader } from "./Reader.ts";
 import { Writer } from "./Writer.ts";
+type TypedArrayRegisterFieldOptions = {
+    typedArrayTargetTypeId?: number | Function;
+};
 export type RegisterFieldOptions = {
     nullable?: boolean;
-};
+} & TypedArrayRegisterFieldOptions;
 export declare class Nytra {
     #private;
     static registerField(position: number, targetTypeId?: number | Function, options?: RegisterFieldOptions): (v: undefined, ctx: ClassFieldDecoratorContext) => void;
@@ -12,3 +15,4 @@ export declare class Nytra {
     static encode(data: unknown, type?: number | null, withType?: boolean, writer?: Writer | null): Uint8Array;
     static decode(data: Uint8Array | Reader, type?: number | null): unknown;
 }
+export {};

package/dist/Nytra.js

@@ -1,7 +1,7 @@
 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";
+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_TYPED_ARRAY, 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;
@@ -34,6 +34,17 @@ function createDecoder(cls) {
                 meta.targetTypeId = found ? found.typeId : TYPE_JSON;
             }
             let type = meta.targetTypeId;
+            if (type === TYPE_TYPED_ARRAY) {
+                const targetType = typeof meta.options.typedArrayTargetTypeId === 'function' ? classMetaStore.get(meta.options.typedArrayTargetTypeId)?.typeId : meta.options.typedArrayTargetTypeId;
+                const size = reader.readUINT32();
+                const end = reader.offset + size;
+                let data = [];
+                while (reader.offset < end) {
+                    data.push(Nytra.decode(reader, targetType === TYPE_STRING ? null : targetType));
+                }
+                obj[name] = data;
+                continue;
+            }
             if (type === TYPE_STRING) {
                 type = reader.readType();
             }
@@ -43,6 +54,35 @@ function createDecoder(cls) {
         return obj;
     };
 }
+function createTypedArrayEncoder(targetType) {
+    if (typeof targetType === 'function') {
+        const meta = classMetaStore.get(targetType);
+        if (!meta) {
+            throw new Error(`Cannot convert object type ${targetType}`);
+        }
+        targetType = meta ? meta.typeId : TYPE_JSON;
+        meta.typeId;
+    }
+    return function (data, writer) {
+        if (!Array.isArray(data)) {
+            throw new Error('Data must be an array');
+        }
+        if (writer === null) {
+            writer = new Writer();
+        }
+        const arr = data;
+        const startIndex = writer.offset;
+        writer.setOffset(startIndex + 4); // reserve space for length
+        for (let value of arr) {
+            Nytra.encode(value, targetType, false, writer);
+        }
+        const endIndex = writer.offset;
+        writer.setOffset(startIndex);
+        writer.writeUint32(endIndex - startIndex - 4);
+        writer.setOffset(endIndex);
+        return writer.toUint8Array();
+    };
+}
 function createEncoder(cls) {
     const meta = classMetaStore.get(cls);
     const cachedEncoders = [];
@@ -69,7 +109,14 @@ function createEncoder(cls) {
                 }
                 // Encoder-Funktion vorgebunden
                 let encodeFn;
-                if (typeId < 255) {
+                if (typeId === TYPE_TYPED_ARRAY) {
+                    if (typeof fieldMeta.options.typedArrayTargetTypeId === 'function') {
+                        const typeId = classMetaStore.get(fieldMeta.options.typedArrayTargetTypeId)?.typeId;
+                        fieldMeta.options.typedArrayTargetTypeId = typeId;
+                    }
+                    encodeFn = createTypedArrayEncoder(fieldMeta.options.typedArrayTargetTypeId);
+                }
+                else if (typeId < 255) {
                     encodeFn = (value, writer) => Nytra.encode(value, typeId, false, writer);
                 }
                 else {
@@ -107,11 +154,15 @@ const classMetaStore = new WeakMap();
 const SYMBOL_FIELDS = Symbol('Nytra:fields');
 const CustomRegistry = new Registry();
 export class Nytra {
-    static registerField(position, targetTypeId, options = {}) {
+    static registerField(position, targetTypeId, options) {
         const defaultOpts = {
-            nullable: false
+            nullable: false,
+            typedArrayTargetTypeId: -1,
         };
         Object.assign(defaultOpts, options);
+        if (targetTypeId === TYPE_TYPED_ARRAY && defaultOpts.typedArrayTargetTypeId === -1) {
+            throw new Error('You must provide options.typedArrayTargetTypeId if you want to register a typed array field');
+        }
         return function (v, ctx) {
             if (ctx.private) {
                 throw new Error('Only public fields can be registered');
@@ -430,6 +481,16 @@ export class Nytra {
             case TYPE_FLOAT32: {
                 return reader.readFloat32();
             }
+            case TYPE_TYPED_ARRAY: {
+                const type = reader.readType();
+                const len = reader.readUINT32();
+                const end = reader.offset + len;
+                const targetArray = [];
+                while (reader.offset < end) {
+                    targetArray.push(this.decode(reader, type));
+                }
+                return targetArray;
+            }
             case TYPE_ARRAY: {
                 const len = reader.readUINT32();
                 const end = reader.offset + len;

package/dist/Registry.js

@@ -1,8 +1,4 @@
 export class Registry {
-    /**
-     *
-     * @type {Map<number, TypeHandler>}
-     */
     #registry = new Map();
     register(type, handler) {
         if (this.#registry.has(type)) {

package/dist/Types.d.ts

@@ -1 +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;
+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_TYPED_ARRAY = 50, TYPE_EXTENSION = 127, TYPE_STRING = 128;

package/dist/Types.js

@@ -1,3 +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, 
+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_TYPED_ARRAY = 50, TYPE_EXTENSION = 127, 
 //128-255 -> String use 7 bits for length (max 127)
 TYPE_STRING = 128;

package/dist/Writer.d.ts

@@ -5,6 +5,7 @@ export declare class Writer {
     get offset(): number;
     constructor(initialSize?: number);
     private ensureCapacity;
+    writeType(type: number): this;
     writeInt8(value: number): this;
     writeInt16(value: number): this;
     writeInt32(value: number): this;

package/dist/Writer.js

@@ -1,3 +1,4 @@
+import { TYPE_EXTENSION } from "./Types.js";
 const LITTLE_ENDIAN = true;
 export class Writer {
     static DEFAULT_SIZE = 1024;
@@ -38,6 +39,13 @@ export class Writer {
         this.#buffer = newBuffer;
         this.#view = new DataView(newBuffer);
     }
+    writeType(type) {
+        if (type <= 255) {
+            return this.writeUint8(type);
+        }
+        this.writeUint8(TYPE_EXTENSION);
+        return this.writeUint16(type);
+    }
     writeInt8(value) {
         this.ensureCapacity(1);
         this.#view.setInt8(this.#offset, value);

package/package.json

@@ -1,10 +1,21 @@
 {
   "private": false,
   "name": "nytra",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "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": "",
+  "author": {
+    "name": "Kapsonfire",
+    "email": "kapsonfire@googlemail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nytra-lib/nytra-js.git"
+  },
+  "homepage": "https://github.com/nytra-lib/nytra-js#readme",
+  "bugs": {
+    "url": "https://github.com/nytra-lib/nytra-js/issues"
+  },
   "type": "module",
   "main": "index.js",
   "scripts": {

package/dist/Binson.d.ts

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

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

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

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