@andrew_l/tl-pack 0.0.6 → 0.0.8

package/README.md

@@ -1,6 +1,6 @@
-# TLPack for JavaScript/NodeJs
+# TLPack for JavaScript/NodeJs <!-- omit in toc -->
 
-![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)
+![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.
 
@@ -20,23 +20,39 @@ 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(),
+  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
@@ -73,9 +89,9 @@ const values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 const dataStream = new Readable({ objectMode: true });
 
 dataStream._read = () => {
-	const chunk = values.shift();
+  const chunk = values.shift();
 
-	dataStream.push(chunk || null);
+  dataStream.push(chunk || null);
 };
 
 const encode = new TLEncode();
@@ -96,31 +112,38 @@ 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);
-		},
-	}),
+  // 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.',
+  _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

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,13 +1,20 @@
 {
 	"name": "@andrew_l/tl-pack",
-	"version": "0.0.6",
+	"version": "0.0.8",
 	"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",
 	"files": [