@andrew_l/tl-pack 0.0.5 → 0.0.7

package/README.md

@@ -0,0 +1,161 @@
+# TLPack for JavaScript/NodeJs
+
+![license](https://img.shields.io/npm/l/%40andrew_l%2Ftl-pack)![npm version](https://img.shields.io/npm/v/%40andrew_l%2Ftl-pack)![npm bundle size](https://img.shields.io/bundlephobia/minzip/%40andrew_l%2Ftl-pack)
+
+This library is another implementation of binary serialization like **MessagePack** inspired by TL (Type Language) developed by old VK team.
+
+You don't needed in schema for data serialization/deserialization unlike official TL implementation at least in this version.
+
+## Benchmark
+
+A bit faster and a bit more compact than **@msgpack/msgpack**
+
+## Synopsis
+
+```javascript
+import { BinaryWriter, BinaryReader } from '@andrew_l/tl-pack';
+
+const writer = new BinaryWriter();
+
+// use to compress this part of data
+// writer.writeObjectGzip
+writer.writeObject({
+  null: null,
+  uint8: 255,
+  uint16: 256,
+  uint32: 65536,
+  int8: -128,
+  int16: -32768,
+  int32: -2147483648,
+  double: 3.14,
+  string: 'Hello world',
+  vector: [1, 2, 3, 4, 5, { text: 'hi' }],
+  map: { foo: 'bar' },
+  date: new Date(),
+});
+
+const reader = new BinaryReader(writer.getBuffer());
+
+console.log(reader.readObject());
+/**
+{
+  null: null,
+  uint8: 255,
+  uint16: 256,
+  uint32: 65536,
+  int8: -128,
+  int16: -32768,
+  int32: -2147483648,
+  double: 3.14,
+  string: 'Hello world',
+  vector: [ 1, 2, 3, 4, 5, { text: 'hi' } ],
+  map: { foo: 'bar' },
+  date: 2023-07-03T12:22:26.000Z
+}
+ */
+```
+
+## Supported Types
+
+| Constructor ID | Byte Size          |
+| -------------- | ------------------ |
+| Binary         | 5 + sizeof(object) |
+| BoolFalse      | 1                  |
+| BoolTrue       | 1                  |
+| Null           | 1                  |
+| Date           | 4                  |
+| Vector         | 5 + n \* sizeof(n) |
+| VectorDynamic  | 2 + n \* sizeof(n) |
+| Int8           | 1                  |
+| Int16          | 2                  |
+| Int32          | 4                  |
+| UInt8          | 1                  |
+| UInt16         | 2                  |
+| UInt32         | 4                  |
+| Float          | 4                  |
+| Double         | 8                  |
+| Map            | 2 + sizeof(object) |
+| String         | 5 + sizeof(object) |
+| GZIP           | 5 + sizeof(object) |
+
+## Stream Example (NodeJs Only)
+
+```javascript
+import { Readable } from 'node:stream';
+import { TLEncode, TLDecode } from '@andrew_l/tl-pack/stream';
+
+const values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+const dataStream = new Readable({ objectMode: true });
+
+dataStream._read = () => {
+  const chunk = values.shift();
+
+  dataStream.push(chunk || null);
+};
+
+const encode = new TLEncode();
+const decode = new TLDecode();
+
+dataStream.pipe(encode).pipe(decode);
+
+decode.on('data', (data) => console.log('stream', data));
+decode.on('error', console.error);
+```
+
+## Custom Types
+
+```javascript
+import mongoose from 'mongoose';
+import { BinaryWriter, BinaryReader, createExtension } from '@andrew_l/tl-pack';
+
+const ObjectId = mongoose.Types.ObjectId;
+
+const extensions = [
+  // Reserving token - 100 for ObjectId types
+  createExtension(100, {
+    encode(value) {
+      if (value?._bsontype === 'ObjectID') {
+        return value.toJSON(); // (string)
+      }
+    },
+    // on client side, you possibly need a decoding as a plain string.
+    decode(value) {
+      return new ObjectId(value);
+    },
+  }),
+];
+
+const writer = new BinaryWriter({ extensions });
+
+writer.writeObject({
+  _id: new Object(),
+  firstName: 'Andrew',
+  lastName: 'L.',
+});
+
+const reader = new BinaryReader(writer.getBuffer(), { extensions });
+
+console.log(reader.readObject());
+/**
+{
+  _id: 64a2be105e19f67e19a71a1d,
+  firstName: 'Andrew',
+  lastName: 'L.'
+}
+ */
+```
+
+## Dictionary
+
+A dictionary is used to replace strings with numeric indexes, which saves the resulting buffer size. In stream mode, the dictionary is grown while the stream is alive.
+
+**Static**
+Dictionary with you initialize a BinaryWriter/BinaryReader.
+
+**Dynamic**
+Dictionary which appends while encoding and decoding keys of an object (Map).
+
+## Production
+
+No way!

package/dist/BinaryReader.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
+import { CORE_TYPES } from './constants.js';
 import { Dictionary } from './dictionary.js';
 import { TLExtension } from './extension.js';
 export interface BinaryReaderOptions {
@@ -7,7 +8,6 @@ export interface BinaryReaderOptions {
 }
 export declare class BinaryReader {
     private target;
-    private targetView;
     private _last?;
     private dictionary?;
     private dictionaryExtended;
@@ -38,18 +38,19 @@ export declare class BinaryReader {
      * @param length {number}
      */
     assertRead(length: number): void;
+    assertConstructor(constructorId: CORE_TYPES): void;
     /**
      * Gets the byte array representing the current buffer as a whole.
      * @returns {Buffer}
      */
-    getBuffer(): Uint8Array | Buffer;
+    getBuffer(): Buffer | Uint8Array;
     readNull(): null;
     readLength(): number;
     readAll(): any[];
     /**
      * @returns {Uint8Array | Buffer}
      */
-    readBytes(): Uint8Array | Buffer;
+    readBytes(): Buffer | Uint8Array;
     /**
      * Reads encoded string.
      * @returns {string}
@@ -82,6 +83,11 @@ export declare class BinaryReader {
      * @returns {any[]}
      */
     readVector(checkConstructor?: boolean): any[];
+    /**
+     * Reads a vector (a list) of objects.
+     * @returns {any[]}
+     */
+    readVectorDynamic(checkConstructor?: boolean): any[];
     /**
      * Tells the current position on the stream.
      * @returns {number}

package/dist/BinaryReader.js

@@ -1,10 +1,9 @@
 import pako from 'pako';
 import { CORE_TYPES } from './constants.js';
 import { Dictionary } from './dictionary.js';
-import { bytesToUtf8 } from './helpers.js';
+import { bytesToUtf8, float32, float64, int32 } from './helpers.js';
 export class BinaryReader {
     target;
-    targetView;
     _last;
     dictionary;
     dictionaryExtended;
@@ -17,7 +16,6 @@ export class BinaryReader {
      */
     constructor(data, options) {
         this.target = data;
-        this.targetView = new DataView(data.buffer, 0, data.length);
         this._last = undefined;
         this.offset = 0;
         this.length = data.length;
@@ -48,35 +46,30 @@ export class BinaryReader {
     }
     readInt32(signed = true) {
         this.assertRead(4);
-        if (signed) {
-            this._last = this.targetView.getInt32(this.offset, true);
-        }
-        else {
-            this._last = this.targetView.getUint32(this.offset, true);
+        this._last =
+            this.target[this.offset++] |
+                (this.target[this.offset++] << 8) |
+                (this.target[this.offset++] << 16) |
+                (this.target[this.offset++] << 24);
+        if (!signed) {
+            this._last = this._last >>> 0;
         }
-        this.offset += 4;
         return this._last;
     }
     readInt16(signed = true) {
         this.assertRead(2);
+        this._last = this.target[this.offset++] | (this.target[this.offset++] << 8);
         if (signed) {
-            this._last = this.targetView.getInt16(this.offset, true);
+            this._last = (this._last << 16) >> 16;
         }
-        else {
-            this._last = this.targetView.getUint16(this.offset, true);
-        }
-        this.offset += 2;
         return this._last;
     }
     readInt8(signed = true) {
         this.assertRead(1);
+        this._last = this.target[this.offset++];
         if (signed) {
-            this._last = this.targetView.getInt8(this.offset);
-        }
-        else {
-            this._last = this.targetView.getUint8(this.offset);
+            this._last = (this._last << 24) >> 24;
         }
-        this.offset += 1;
         return this._last;
     }
     /**
@@ -85,8 +78,8 @@ export class BinaryReader {
      */
     readFloat() {
         this.assertRead(4);
-        this._last = this.targetView.getFloat32(this.offset, true);
-        this.offset += 4;
+        int32[0] = this.readInt32();
+        this._last = float32[0];
         return this._last;
     }
     /**
@@ -95,8 +88,9 @@ export class BinaryReader {
      */
     readDouble() {
         this.assertRead(8);
-        this._last = this.targetView.getFloat64(this.offset, true);
-        this.offset += 8;
+        int32[0] = this.readInt32();
+        int32[1] = this.readInt32();
+        this._last = float64[0];
         return this._last;
     }
     /**
@@ -113,6 +107,12 @@ export class BinaryReader {
             throw err;
         }
     }
+    assertConstructor(constructorId) {
+        const byte = this.readByte();
+        if (byte !== constructorId) {
+            throw new Error(`Invalid constructor code, expected = ${CORE_TYPES[constructorId]}, got = ${CORE_TYPES[byte] || byte}, offset = ${this.offset - 1}`);
+        }
+    }
     /**
      * Gets the byte array representing the current buffer as a whole.
      * @returns {Buffer}
@@ -227,6 +227,8 @@ export class BinaryReader {
                 return false;
             case CORE_TYPES.Vector:
                 return this.readVector(false);
+            case CORE_TYPES.VectorDynamic:
+                return this.readVectorDynamic(false);
             case CORE_TYPES.Null:
                 return null;
             case CORE_TYPES.Binary:
@@ -291,8 +293,8 @@ export class BinaryReader {
         return key;
     }
     readMap(checkConstructor = true) {
-        if (checkConstructor && this.readByte() !== CORE_TYPES.Map) {
-            throw new Error('Invalid constructor code, map was expected');
+        if (checkConstructor) {
+            this.assertConstructor(CORE_TYPES.Map);
         }
         const temp = {};
         let key = this.readDictionary();
@@ -304,7 +306,6 @@ export class BinaryReader {
     }
     decode(value) {
         this.target = value;
-        this.targetView = new DataView(value.buffer, 0, value.length);
         this._last = undefined;
         this.offset = 0;
         this.length = value.length;
@@ -315,8 +316,8 @@ export class BinaryReader {
      * @returns {any[]}
      */
     readVector(checkConstructor = true) {
-        if (checkConstructor && this.readByte() !== CORE_TYPES.Vector) {
-            throw new Error('Invalid constructor code, vector was expected');
+        if (checkConstructor) {
+            this.assertConstructor(CORE_TYPES.Vector);
         }
         const count = this.readLength();
         const temp = [];
@@ -325,6 +326,41 @@ export class BinaryReader {
         }
         return temp;
     }
+    /**
+     * Reads a vector (a list) of objects.
+     * @returns {any[]}
+     */
+    readVectorDynamic(checkConstructor = true) {
+        if (checkConstructor) {
+            this.assertConstructor(CORE_TYPES.VectorDynamic);
+        }
+        const temp = [];
+        let complete = false;
+        while (this.length > this.offset) {
+            const constructorId = this.readByte();
+            if (constructorId === CORE_TYPES.None) {
+                complete = true;
+                break;
+            }
+            const ext = this.extensions.get(constructorId);
+            let value;
+            if (ext) {
+                value = this.readObject();
+                value = ext.decode(value);
+            }
+            else {
+                value = this.readCore(constructorId);
+            }
+            temp.push(value);
+        }
+        if (!complete) {
+            const err = new Error(`DynamicVector incomplete.`);
+            err.incomplete = true;
+            Error.captureStackTrace(err, this.readDictionary);
+            throw err;
+        }
+        return temp;
+    }
     /**
      * Tells the current position on the stream.
      * @returns {number}

package/dist/BinaryWriter.d.ts

@@ -9,16 +9,15 @@ export interface BinaryWriterOptions {
 export declare class BinaryWriter {
     private withGzip;
     private target;
-    private targetView;
     private dictionary?;
     private dictionaryExtended;
     private extensions;
     offset: number;
     constructor(options?: BinaryWriterOptions);
     allocate(size: number): void;
-    makeRoom(end: number): void;
+    private makeRoom;
     get safeEnd(): number;
-    getBuffer(): Uint8Array | Buffer;
+    getBuffer(): Buffer | Uint8Array;
     writeByte(value: number): void;
     writeBool(value: boolean): void;
     writeNull(): void;
@@ -35,7 +34,9 @@ export declare class BinaryWriter {
     writeMap(object: Record<string, any>): void;
     wireDictionary(value: string): void;
     writeGzip(value: any): void;
-    encode(value: any): Uint8Array | Buffer;
+    encode(value: any): Buffer | Uint8Array;
+    startDynamicVector(): void;
+    endDynamicVector(): void;
     private _writeCustom;
     writeObject(value: any): void;
     writeObjectGzip(value: any): void;

package/dist/BinaryWriter.js

@@ -1,7 +1,7 @@
 import pako from 'pako';
 import { CORE_TYPES } from './constants.js';
 import { Dictionary } from './dictionary.js';
-import { coreType } from './helpers.js';
+import { coreType, float32, float64, int32 } from './helpers.js';
 const hasNodeBuffer = typeof Buffer !== 'undefined';
 const MAX_BUFFER_SIZE = hasNodeBuffer ? 0x100000000 : 0x7fd00000;
 const textEncoder = new TextEncoder();
@@ -24,7 +24,6 @@ const SUPPORT_COMPRESSION = new Set([CORE_TYPES.String]);
 export class BinaryWriter {
     withGzip;
     target;
-    targetView;
     dictionary;
     dictionaryExtended;
     extensions;
@@ -34,7 +33,6 @@ export class BinaryWriter {
         this.extensions = new Map();
         this.withGzip = !!options && !!options.gzip;
         this.target = byteArrayAllocate(8192);
-        this.targetView = new DataView(this.target.buffer, 0, this.target.length);
         if (options && options.extensions) {
             options.extensions.forEach((ext) => {
                 this.extensions.set(ext.token, ext);
@@ -85,7 +83,6 @@ export class BinaryWriter {
             newBuffer.set(target.slice(start, end));
         }
         this.target = newBuffer;
-        this.targetView = newView;
     }
     get safeEnd() {
         return this.target.length - 10;
@@ -111,41 +108,43 @@ export class BinaryWriter {
     writeInt32(value, signed = true) {
         this.allocate(4);
         if (signed) {
-            this.targetView.setInt32(this.offset, value, true);
+            this.target[this.offset++] = value;
+            this.target[this.offset++] = value >> 8;
+            this.target[this.offset++] = value >> 16;
+            this.target[this.offset++] = value >> 24;
         }
         else {
-            this.targetView.setUint32(this.offset, value, true);
+            this.target[this.offset++] = value;
+            this.target[this.offset++] = value >> 8;
+            this.target[this.offset++] = value >> 16;
+            this.target[this.offset++] = value >> 24;
         }
-        this.offset += 4;
     }
     writeInt16(value, signed = true) {
         this.allocate(2);
         if (signed) {
-            this.targetView.setInt16(this.offset, value, true);
+            this.target[this.offset++] = value;
+            this.target[this.offset++] = value >> 8;
         }
         else {
-            this.targetView.setUint16(this.offset, value, true);
+            this.target[this.offset++] = value;
+            this.target[this.offset++] = value >> 8;
         }
-        this.offset += 2;
     }
     writeInt8(value, signed = true) {
         this.allocate(1);
-        if (signed) {
-            this.target[this.offset++] = value;
-        }
-        else {
-            this.targetView.setUint8(this.offset++, value);
-        }
+        this.target[this.offset++] = value;
     }
     writeFloat(value) {
         this.allocate(4);
-        this.targetView.setFloat32(this.offset, value, true);
-        this.offset += 4;
+        float32[0] = value;
+        this.writeInt32(int32[0]);
     }
     writeDouble(value) {
         this.allocate(8);
-        this.targetView.setFloat64(this.offset, value, true);
-        this.offset += 8;
+        float64[0] = value;
+        this.writeInt32(int32[0], false);
+        this.writeInt32(int32[1], false);
     }
     writeDate(value) {
         let timestamp = 0;
@@ -247,10 +246,15 @@ export class BinaryWriter {
     encode(value) {
         this.offset = 0;
         this.target = byteArrayAllocate(256);
-        this.targetView = new DataView(this.target.buffer, 0, this.target.length);
         this.writeObject(value);
         return this.getBuffer();
     }
+    startDynamicVector() {
+        this.writeByte(CORE_TYPES.VectorDynamic);
+    }
+    endDynamicVector() {
+        this.writeByte(CORE_TYPES.None);
+    }
     _writeCustom(value) {
         for (const ext of this.extensions.values()) {
             const result = ext.encode(value);
@@ -294,7 +298,6 @@ export class BinaryWriter {
         this.writeCore(CORE_TYPES.GZIP, writer.getBuffer());
     }
     writeCore(constructorId, value) {
-        // console.log('write', { constructorId: CORE_TYPES[constructorId] || constructorId, value });
         if (this.withGzip && SUPPORT_COMPRESSION.has(constructorId)) {
             this.writeObjectGzip(value);
             return;

package/dist/constants.d.ts

@@ -6,17 +6,18 @@ export declare enum CORE_TYPES {
     Null = 4,
     Date = 5,
     Vector = 6,
-    Int32 = 7,
-    Int16 = 8,
-    Int8 = 9,
-    UInt32 = 10,
-    UInt16 = 11,
-    UInt8 = 12,
-    Float = 13,
-    Double = 14,
-    Map = 15,
-    DictValue = 16,
-    DictIndex = 17,
-    String = 18,
-    GZIP = 19
+    VectorDynamic = 7,
+    Int32 = 8,
+    Int16 = 9,
+    Int8 = 10,
+    UInt32 = 11,
+    UInt16 = 12,
+    UInt8 = 13,
+    Float = 14,
+    Double = 15,
+    Map = 16,
+    DictValue = 17,
+    DictIndex = 18,
+    String = 19,
+    GZIP = 25
 }

package/dist/constants.js

@@ -7,17 +7,18 @@ export var CORE_TYPES;
     CORE_TYPES[CORE_TYPES["Null"] = 4] = "Null";
     CORE_TYPES[CORE_TYPES["Date"] = 5] = "Date";
     CORE_TYPES[CORE_TYPES["Vector"] = 6] = "Vector";
-    CORE_TYPES[CORE_TYPES["Int32"] = 7] = "Int32";
-    CORE_TYPES[CORE_TYPES["Int16"] = 8] = "Int16";
-    CORE_TYPES[CORE_TYPES["Int8"] = 9] = "Int8";
-    CORE_TYPES[CORE_TYPES["UInt32"] = 10] = "UInt32";
-    CORE_TYPES[CORE_TYPES["UInt16"] = 11] = "UInt16";
-    CORE_TYPES[CORE_TYPES["UInt8"] = 12] = "UInt8";
-    CORE_TYPES[CORE_TYPES["Float"] = 13] = "Float";
-    CORE_TYPES[CORE_TYPES["Double"] = 14] = "Double";
-    CORE_TYPES[CORE_TYPES["Map"] = 15] = "Map";
-    CORE_TYPES[CORE_TYPES["DictValue"] = 16] = "DictValue";
-    CORE_TYPES[CORE_TYPES["DictIndex"] = 17] = "DictIndex";
-    CORE_TYPES[CORE_TYPES["String"] = 18] = "String";
-    CORE_TYPES[CORE_TYPES["GZIP"] = 19] = "GZIP";
+    CORE_TYPES[CORE_TYPES["VectorDynamic"] = 7] = "VectorDynamic";
+    CORE_TYPES[CORE_TYPES["Int32"] = 8] = "Int32";
+    CORE_TYPES[CORE_TYPES["Int16"] = 9] = "Int16";
+    CORE_TYPES[CORE_TYPES["Int8"] = 10] = "Int8";
+    CORE_TYPES[CORE_TYPES["UInt32"] = 11] = "UInt32";
+    CORE_TYPES[CORE_TYPES["UInt16"] = 12] = "UInt16";
+    CORE_TYPES[CORE_TYPES["UInt8"] = 13] = "UInt8";
+    CORE_TYPES[CORE_TYPES["Float"] = 14] = "Float";
+    CORE_TYPES[CORE_TYPES["Double"] = 15] = "Double";
+    CORE_TYPES[CORE_TYPES["Map"] = 16] = "Map";
+    CORE_TYPES[CORE_TYPES["DictValue"] = 17] = "DictValue";
+    CORE_TYPES[CORE_TYPES["DictIndex"] = 18] = "DictIndex";
+    CORE_TYPES[CORE_TYPES["String"] = 19] = "String";
+    CORE_TYPES[CORE_TYPES["GZIP"] = 25] = "GZIP";
 })(CORE_TYPES || (CORE_TYPES = {}));

package/dist/extension.js

@@ -2,6 +2,9 @@ export function createExtension(token, { encode, decode }) {
     if (token !== -1 && (token > 254 || token < 0 || token << 0 !== token)) {
         throw new TypeError('Token must be a 8 bit number');
     }
+    if (token < 35) {
+        throw new TypeError('Tokens reserved from 0 to 34');
+    }
     return {
         token,
         encode,

package/dist/helpers.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 import { CORE_TYPES } from './constants.js';
-export declare function concatUint8Arrays(arrays: ArrayLike<number>[]): Uint8Array;
+export declare const int32: Int32Array;
+export declare const float32: Float32Array;
+export declare const float64: Float64Array;
 export declare function bytesToUtf8(bytes: Buffer | Uint8Array): string;
 export declare function utf8ToBytes(string: string): Uint8Array;
-export declare function serializeBytes(value: Buffer | Uint8Array | string | any): Uint8Array;
-export declare function serializeLength(value: number): Buffer;
 export declare function coreType(value: any): CORE_TYPES;

package/dist/helpers.js

@@ -1,19 +1,9 @@
 import { CORE_TYPES } from './constants.js';
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
-export function concatUint8Arrays(arrays) {
-    let totalLength = 0;
-    for (const array of arrays) {
-        totalLength += array.length;
-    }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const array of arrays) {
-        result.set(array, offset);
-        offset += array.length;
-    }
-    return result;
-}
+export const int32 = new Int32Array(2);
+export const float32 = new Float32Array(int32.buffer);
+export const float64 = new Float64Array(int32.buffer);
 export function bytesToUtf8(bytes) {
     return textDecoder.decode(bytes);
 }
@@ -22,41 +12,6 @@ export function utf8ToBytes(string) {
     const length = textEncoder.encodeInto(string, buff).written;
     return buff.subarray(0, length);
 }
-export function serializeBytes(value) {
-    let data;
-    if (typeof value === 'string') {
-        data = utf8ToBytes(value);
-    }
-    else if (value instanceof Buffer) {
-        data = value;
-    }
-    else if (value instanceof Uint8Array) {
-        data = value;
-    }
-    else {
-        throw Error(`Bytes or str expected, not ${value.constructor.name}`);
-    }
-    let length = data.length;
-    let header;
-    if (length < 254) {
-        header = new Uint8Array(1);
-        header[0] = length;
-    }
-    else {
-        header = new Uint8Array(4);
-        header[0] = 254;
-        header[1] = length % 256;
-        header[2] = (length >> 8) % 256;
-        header[3] = (length >> 16) % 256;
-    }
-    return concatUint8Arrays([header, data]);
-}
-export function serializeLength(value) {
-    if (value < 254) {
-        return Buffer.from([value]);
-    }
-    return Buffer.from([254, value % 256, (value >> 8) % 256, (value >> 16) % 256]);
-}
 export function coreType(value) {
     switch (typeof value) {
         case 'string': {
@@ -66,23 +21,25 @@ export function coreType(value) {
             return value ? CORE_TYPES.BoolTrue : CORE_TYPES.BoolFalse;
         }
         case 'number': {
-            if (value >= 0 && value <= 255) {
-                return CORE_TYPES.UInt8;
-            }
-            else if (value >= 0 && value <= 65535) {
-                return CORE_TYPES.UInt16;
-            }
-            else if (value >= 0 && value <= 4294967295) {
-                return CORE_TYPES.UInt32;
-            }
-            else if (value >= -128 && value <= 127) {
-                return CORE_TYPES.Int8;
-            }
-            else if (value >= -32768 && value <= 32767) {
-                return CORE_TYPES.Int16;
-            }
-            else if (value >= -2147483648 && value <= 2147483647) {
-                return CORE_TYPES.Int32;
+            if (value >> 0 === value) {
+                if (value >= 0 && value <= 0xff) {
+                    return CORE_TYPES.UInt8;
+                }
+                else if (value >= 0 && value <= 0xffff) {
+                    return CORE_TYPES.UInt16;
+                }
+                else if (value >= 0 && value <= 0xffffffff) {
+                    return CORE_TYPES.UInt32;
+                }
+                else if (value >= -0x80 && value <= 0x7f) {
+                    return CORE_TYPES.Int8;
+                }
+                else if (value >= -0x8000 && value <= 0x7fff) {
+                    return CORE_TYPES.Int16;
+                }
+                else if (value >= -0x80000000 && value <= 0x7fffffff) {
+                    return CORE_TYPES.Int32;
+                }
             }
             return CORE_TYPES.Double;
         }

package/dist/stream.d.ts

@@ -5,7 +5,6 @@ import { BinaryWriter, BinaryWriterOptions } from './BinaryWriter.js';
 import { BinaryReader } from './BinaryReader.js';
 export interface TLEncodeOptions extends BinaryWriterOptions {
     streamOptions?: TransformOptions;
-    writeVectorWhenEmpty?: boolean;
 }
 export declare class TLEncode extends Transform {
     writer: BinaryWriter;

package/dist/stream.js

@@ -1,6 +1,7 @@
 import { Transform } from 'stream';
 import { BinaryWriter } from './BinaryWriter.js';
 import { BinaryReader } from './BinaryReader.js';
+import { CORE_TYPES } from './constants.js';
 export class TLEncode extends Transform {
     writer;
     count;
@@ -10,10 +11,14 @@ export class TLEncode extends Transform {
         super(opts.streamOptions);
         const writer = new BinaryWriter(options);
         const customFlush = opts.streamOptions.flush;
+        const VECTOR_TYPES = new Uint8Array(2);
+        VECTOR_TYPES[0] = CORE_TYPES.VectorDynamic;
+        VECTOR_TYPES[1] = CORE_TYPES.None;
+        // push a byte about dynamic vector starting
+        this.push(VECTOR_TYPES.subarray(0, 1));
         this._flush = (callback) => {
-            if (this.count === 0 && opts.writeVectorWhenEmpty) {
-                this.push(writer.encode([]));
-            }
+            // push a byte about dynamic vector ending
+            this.push(VECTOR_TYPES.subarray(1, 2));
             if (customFlush) {
                 customFlush.call(this, callback);
             }

package/package.json

@@ -1,19 +1,34 @@
 {
 	"name": "@andrew_l/tl-pack",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"description": "",
 	"type": "module",
 	"scripts": {
 		"dev": "nodemon src/playground.ts",
 		"build": "rm -rf dist && npx tsc"
 	},
-	"keywords": [],
+	"keywords": [
+		"tl",
+		"pack",
+		"binary",
+		"buffer",
+		"serialization",
+		"deserialization"
+	],
 	"author": "Andrew L.",
 	"license": "ISC",
-	"types": "./dist",
 	"files": [
 		"dist/**"
 	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/men232/tl-pack.git"
+	},
+	"bugs": {
+		"url": "https://github.com/men232/tl-pack/issues"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"exports": {
 		".": {
 			"import": "./dist/index.js",