@andrew_l/tl-pack 0.0.2

package/dist/BinaryReader.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare class BinaryReader {
+    private target;
+    private targetView;
+    private _last?;
+    private _dict;
+    offset: number;
+    length: number;
+    /**
+     * Small utility class to read binary data.
+     * @param data {Buffer}
+     */
+    constructor(data: Buffer | Uint8Array);
+    readByte(): number;
+    readInt32(signed?: boolean): number;
+    readInt16(signed?: boolean): number;
+    readInt8(signed?: boolean): number;
+    /**
+     * Reads a real floating point (4 bytes) value.
+     * @returns {number}
+     */
+    readFloat(): number;
+    /**
+     * Reads a real floating point (8 bytes) value.
+     * @returns {BigInteger}
+     */
+    readDouble(): number;
+    /**
+     * Read the given amount of bytes, or -1 to read all remaining.
+     * @param length {number}
+     */
+    assertRead(length: number): void;
+    /**
+     * Gets the byte array representing the current buffer as a whole.
+     * @returns {Buffer}
+     */
+    getBuffer(): Uint8Array | Buffer;
+    readNull(): null;
+    readLength(): number;
+    /**
+     * @returns {Uint8Array | Buffer}
+     */
+    readBytes(): Uint8Array | Buffer;
+    /**
+     * Reads encoded string.
+     * @returns {string}
+     */
+    readString(): string;
+    /**
+     * Reads a boolean value.
+     * @returns {boolean}
+     */
+    readBool(): boolean;
+    /**
+     * Reads and converts Unix time
+     * into a Javascript {Date} object.
+     * @returns {Date}
+     */
+    readDate(): Date;
+    /**
+     * Reads a object.
+     */
+    readObject(): any;
+    readDictionary(): string | null;
+    readMap(checkConstructor?: boolean): Record<string, any>;
+    decode(value: Buffer | Uint8Array): any;
+    /**
+     * Reads a vector (a list) of objects.
+     * @returns {any[]}
+     */
+    readVector(checkConstructor?: boolean): any[];
+    /**
+     * Tells the current position on the stream.
+     * @returns {number}
+     */
+    tellPosition(): number;
+    /**
+     * Sets the current position on the stream.
+     * @param position
+     */
+    setPosition(position: number): void;
+    /**
+     * Seeks the stream position given an offset from the current position.
+     * The offset may be negative.
+     * @param offset
+     */
+    seek(offset: number): void;
+}

package/dist/BinaryReader.js

@@ -0,0 +1,280 @@
+import { CORE_TYPES } from './constants.js';
+import { bytesToUtf8 } from './helpers.js';
+export class BinaryReader {
+    target;
+    targetView;
+    _last;
+    _dict;
+    offset;
+    length;
+    /**
+     * Small utility class to read binary data.
+     * @param data {Buffer}
+     */
+    constructor(data) {
+        this.target = data;
+        this.targetView = new DataView(data.buffer, 0, data.length);
+        this._last = undefined;
+        this._dict = new Map();
+        this.offset = 0;
+        this.length = data.length;
+    }
+    readByte() {
+        this.assertRead(1);
+        this._last = this.target[this.offset++];
+        return this._last;
+    }
+    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.offset += 4;
+        return this._last;
+    }
+    readInt16(signed = true) {
+        this.assertRead(2);
+        if (signed) {
+            this._last = this.targetView.getInt16(this.offset, true);
+        }
+        else {
+            this._last = this.targetView.getUint16(this.offset);
+        }
+        this.offset += 2;
+        return this._last;
+    }
+    readInt8(signed = true) {
+        this.assertRead(1);
+        if (signed) {
+            this._last = this.targetView.getInt8(this.offset);
+        }
+        else {
+            this._last = this.targetView.getInt8(this.offset);
+        }
+        this.offset += 1;
+        return this._last;
+    }
+    /**
+     * Reads a real floating point (4 bytes) value.
+     * @returns {number}
+     */
+    readFloat() {
+        this.assertRead(4);
+        this._last = this.targetView.getFloat32(this.offset, true);
+        this.offset += 4;
+        return this._last;
+    }
+    /**
+     * Reads a real floating point (8 bytes) value.
+     * @returns {BigInteger}
+     */
+    readDouble() {
+        this.assertRead(8);
+        this._last = this.targetView.getFloat64(this.offset, true);
+        this.offset += 8;
+        return this._last;
+    }
+    /**
+     * Read the given amount of bytes, or -1 to read all remaining.
+     * @param length {number}
+     */
+    assertRead(length) {
+        if (this.length < this.offset + +length) {
+            const left = this.target.length - this.offset;
+            const result = this.target.subarray(this.offset, this.offset + left);
+            const err = new Error(`No more data left to read (need ${length}, got ${left}: ${result}); last read ${this._last}`);
+            err.incomplete = true;
+            Error.captureStackTrace(err, this.assertRead);
+            throw err;
+        }
+    }
+    /**
+     * Gets the byte array representing the current buffer as a whole.
+     * @returns {Buffer}
+     */
+    getBuffer() {
+        return this.target;
+    }
+    readNull() {
+        const value = this.readByte();
+        if (value === CORE_TYPES.Null) {
+            return null;
+        }
+        throw new Error(`Invalid boolean code ${value.toString(16)}`);
+    }
+    readLength() {
+        const firstByte = this.readByte();
+        if (firstByte === 254) {
+            return this.readByte() | (this.readByte() << 8) | (this.readByte() << 16);
+        }
+        return firstByte;
+    }
+    /**
+     * @returns {Uint8Array | Buffer}
+     */
+    readBytes() {
+        const length = this.readLength();
+        this.assertRead(length);
+        const bytes = this.target.subarray(this.offset, this.offset + length);
+        this.offset += bytes.length;
+        return bytes;
+    }
+    /**
+     * Reads encoded string.
+     * @returns {string}
+     */
+    readString() {
+        const length = this.readLength();
+        this.assertRead(length);
+        const bytes = this.target.subarray(this.offset, this.offset + length);
+        this.offset += bytes.length;
+        return bytesToUtf8(bytes);
+    }
+    /**
+     * Reads a boolean value.
+     * @returns {boolean}
+     */
+    readBool() {
+        const value = this.readByte();
+        if (value === CORE_TYPES.BoolTrue) {
+            return true;
+        }
+        else if (value === CORE_TYPES.BoolFalse) {
+            return false;
+        }
+        else {
+            throw new Error(`Invalid boolean code ${value.toString(16)}`);
+        }
+    }
+    /**
+     * Reads and converts Unix time
+     * into a Javascript {Date} object.
+     * @returns {Date}
+     */
+    readDate() {
+        const value = this.readDouble();
+        return new Date(value * 1000);
+    }
+    /**
+     * Reads a object.
+     */
+    readObject() {
+        const constructorId = this.readByte();
+        switch (constructorId) {
+            case CORE_TYPES.None:
+                return this.readObject();
+            case CORE_TYPES.BoolTrue:
+                return true;
+            case CORE_TYPES.BoolFalse:
+                return false;
+            case CORE_TYPES.Vector:
+                return this.readVector(false);
+            case CORE_TYPES.Null:
+                return null;
+            case CORE_TYPES.Binary:
+                return this.readBytes();
+            case CORE_TYPES.String:
+                return this.readString();
+            case CORE_TYPES.Date:
+                return this.readDate();
+            case CORE_TYPES.Int32:
+                return this.readInt32();
+            case CORE_TYPES.Int16:
+                return this.readInt16();
+            case CORE_TYPES.Int8:
+                return this.readInt8();
+            case CORE_TYPES.UInt32:
+                return this.readInt32(false);
+            case CORE_TYPES.UInt16:
+                return this.readInt16(false);
+            case CORE_TYPES.UInt8:
+                return this.readInt8(false);
+            case CORE_TYPES.Float:
+                return this.readFloat();
+            case CORE_TYPES.Double:
+                return this.readDouble();
+            case CORE_TYPES.Map:
+                return this.readMap(false);
+        }
+        throw new Error(`Invalid constructor = ${CORE_TYPES[constructorId] || constructorId}, offset = ${this.offset - 1}`);
+    }
+    readDictionary() {
+        const constructorId = this.readByte();
+        switch (constructorId) {
+            case CORE_TYPES.DictIndex: {
+                const idx = this.readLength();
+                return this._dict.get(idx);
+            }
+            case CORE_TYPES.DictValue: {
+                const key = this.readString();
+                this._dict.set(this._dict.size + 1, key);
+                return key;
+            }
+            case CORE_TYPES.None: {
+                return null;
+            }
+        }
+        this.seek(-1);
+        return null;
+    }
+    readMap(checkConstructor = true) {
+        if (checkConstructor && this.readByte() !== CORE_TYPES.Map) {
+            throw new Error('Invalid constructor code, map was expected');
+        }
+        const temp = {};
+        let key = this.readDictionary();
+        while (key !== null) {
+            temp[key] = this.readObject();
+            key = this.readDictionary();
+        }
+        return temp;
+    }
+    decode(value) {
+        this.target = value;
+        this.targetView = new DataView(value.buffer, 0, value.length);
+        this._last = undefined;
+        this.offset = 0;
+        this.length = value.length;
+        return this.readObject();
+    }
+    /**
+     * Reads a vector (a list) of objects.
+     * @returns {any[]}
+     */
+    readVector(checkConstructor = true) {
+        if (checkConstructor && this.readByte() !== CORE_TYPES.Vector) {
+            throw new Error('Invalid constructor code, vector was expected');
+        }
+        const count = this.readLength();
+        const temp = [];
+        for (let i = 0; i < count; i++) {
+            temp.push(this.readObject());
+        }
+        return temp;
+    }
+    /**
+     * Tells the current position on the stream.
+     * @returns {number}
+     */
+    tellPosition() {
+        return this.offset;
+    }
+    /**
+     * Sets the current position on the stream.
+     * @param position
+     */
+    setPosition(position) {
+        this.offset = position;
+    }
+    /**
+     * Seeks the stream position given an offset from the current position.
+     * The offset may be negative.
+     * @param offset
+     */
+    seek(offset) {
+        this.offset += offset;
+    }
+}

package/dist/BinaryWriter.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare class BinaryWriter {
+    private target;
+    private targetView;
+    private dict;
+    offset: number;
+    constructor();
+    allocate(size: number): void;
+    makeRoom(end: number): void;
+    get safeEnd(): number;
+    getBuffer(): Uint8Array | Buffer;
+    writeByte(value: number): void;
+    writeBool(value: boolean): void;
+    writeNull(): void;
+    writeInt32(value: number, signed?: boolean): void;
+    writeInt16(value: number, signed?: boolean): void;
+    writeInt8(value: number, signed?: boolean): void;
+    writeFloat(value: number): void;
+    writeDouble(value: number): void;
+    writeDate(value: number | Date): void;
+    writeString(value: string): void;
+    writeBytes(value: Buffer | Uint8Array): void;
+    writeLength(value: number): void;
+    writeVector(value: Array<any>): void;
+    writeMap(object: Record<string, any>): void;
+    wireDictionary(value: string): void;
+    encode(value: any): Uint8Array | Buffer;
+    writeObject(value: any): void;
+}

package/dist/BinaryWriter.js

@@ -0,0 +1,266 @@
+import { CORE_TYPES } from './constants.js';
+import { coreType } from './helpers.js';
+const hasNodeBuffer = typeof Buffer !== 'undefined';
+const MAX_BUFFER_SIZE = hasNodeBuffer ? 0x100000000 : 0x7fd00000;
+const textEncoder = new TextEncoder();
+const writeUtf8 = hasNodeBuffer
+    ? function (target, value, offset) {
+        const length = target.utf8Write(value, offset, 0xffffffff);
+        return length;
+    }
+    : function (target, value, offset) {
+        return textEncoder.encodeInto(value, target.subarray(offset)).written;
+    };
+function byteArrayAllocate(length) {
+    if (hasNodeBuffer) {
+        return Buffer.allocUnsafeSlow(length);
+    }
+    return new Uint8Array(length);
+}
+export class BinaryWriter {
+    target;
+    targetView;
+    dict;
+    offset;
+    constructor() {
+        this.target = Buffer.alloc(0);
+        this.dict = new Map();
+        this.offset = 0;
+        this.target = byteArrayAllocate(8192);
+        this.targetView = new DataView(this.target.buffer, 0, this.target.length);
+    }
+    allocate(size) {
+        const position = this.offset + size;
+        if (this.safeEnd < position) {
+            this.makeRoom(position);
+        }
+    }
+    makeRoom(end) {
+        let start = 0;
+        let newSize = 0;
+        let target = this.target;
+        if (end > 0x1000000) {
+            // special handling for really large buffers
+            if (end - start > MAX_BUFFER_SIZE)
+                throw new Error('Packed buffer would be larger than maximum buffer size');
+            newSize = Math.min(MAX_BUFFER_SIZE, Math.round(Math.max((end - start) * (end > 0x4000000 ? 1.25 : 2), 0x400000) / 0x1000) *
+                0x1000);
+        }
+        else {
+            // faster handling for smaller buffers
+            newSize = ((Math.max((end - start) << 2, target.length - 1) >> 12) + 1) << 12;
+        }
+        const newBuffer = byteArrayAllocate(newSize);
+        const newView = new DataView(newBuffer.buffer, 0, newSize);
+        end = Math.min(end, target.length);
+        if ('copy' in target) {
+            target.copy(newBuffer, 0, start, end);
+        }
+        else {
+            newBuffer.set(target.slice(start, end));
+        }
+        this.target = newBuffer;
+        this.targetView = newView;
+    }
+    get safeEnd() {
+        return this.target.length - 10;
+    }
+    getBuffer() {
+        return this.target.subarray(0, this.offset);
+    }
+    writeByte(value) {
+        this.allocate(1);
+        this.target[this.offset++] = value;
+    }
+    writeBool(value) {
+        if (value) {
+            this.writeByte(CORE_TYPES.BoolTrue);
+        }
+        else {
+            this.writeByte(CORE_TYPES.BoolFalse);
+        }
+    }
+    writeNull() {
+        this.writeByte(CORE_TYPES.Null);
+    }
+    writeInt32(value, signed = true) {
+        this.allocate(4);
+        if (signed) {
+            this.targetView.setInt32(this.offset, value, true);
+        }
+        else {
+            this.targetView.setUint32(this.offset, value, true);
+        }
+        this.offset += 4;
+    }
+    writeInt16(value, signed = true) {
+        this.allocate(2);
+        if (signed) {
+            this.targetView.setInt16(this.offset, value, true);
+        }
+        else {
+            this.targetView.setUint16(this.offset, value, true);
+        }
+        this.offset += 2;
+    }
+    writeInt8(value, signed = true) {
+        this.allocate(1);
+        this.target[this.offset++] = value;
+    }
+    writeFloat(value) {
+        this.allocate(4);
+        this.targetView.setFloat32(this.offset, value, true);
+        this.offset += 4;
+    }
+    writeDouble(value) {
+        this.allocate(8);
+        this.targetView.setFloat64(this.offset, value, true);
+        this.offset += 8;
+    }
+    writeDate(value) {
+        let timestamp = 0;
+        if (value instanceof Date) {
+            timestamp = Math.floor(value.getTime() / 1000);
+        }
+        else if (typeof value === 'number') {
+            timestamp = value;
+        }
+        this.writeDouble(timestamp);
+    }
+    writeString(value) {
+        let start = this.offset;
+        let require = value.length << 2;
+        if (require < 254) {
+            require += 1;
+            this.offset += 1;
+        }
+        else {
+            require += 4;
+            this.offset += 4;
+        }
+        this.allocate(require);
+        const bytes = writeUtf8(this.target, value, this.offset);
+        if (require < 254) {
+            this.target[start++] = bytes;
+        }
+        else {
+            this.target[start++] = 254;
+            this.target[start++] = bytes % 256;
+            this.target[start++] = (bytes >> 8) % 256;
+            this.target[start++] = (bytes >> 16) % 256;
+        }
+        this.offset += bytes;
+        // this.target.set(bytes, this.offset);
+        // this.offset += bytes.length;
+    }
+    writeBytes(value) {
+        const length = value.length;
+        this.writeLength(length);
+        this.allocate(length);
+        this.target.set(value, this.offset);
+        this.offset += length;
+    }
+    writeLength(value) {
+        if (value < 254) {
+            this.allocate(1);
+            this.target[this.offset++] = value;
+        }
+        else {
+            this.allocate(4);
+            this.target[this.offset++] = 254;
+            this.target[this.offset++] = value % 256;
+            this.target[this.offset++] = (value >> 8) % 256;
+            this.target[this.offset++] = (value >> 16) % 256;
+        }
+    }
+    writeVector(value) {
+        const length = value.length;
+        this.writeLength(length);
+        for (let i = 0; i < length; i++) {
+            this.writeObject(value[i]);
+        }
+    }
+    writeMap(object) {
+        for (const key in object) {
+            this.wireDictionary(key);
+            this.writeObject(object[key]);
+        }
+        this.writeByte(CORE_TYPES.None);
+    }
+    wireDictionary(value) {
+        if (this.dict.has(value)) {
+            const idx = this.dict.get(value);
+            this.writeByte(CORE_TYPES.DictIndex);
+            this.writeLength(idx);
+        }
+        else {
+            const newIndex = this.dict.size + 1;
+            this.dict.set(value, newIndex);
+            this.writeByte(CORE_TYPES.DictValue);
+            this.writeString(value);
+        }
+    }
+    encode(value) {
+        const start = this.offset;
+        this.writeObject(value);
+        const end = this.offset;
+        this.offset = start;
+        return this.target.subarray(start, end);
+    }
+    writeObject(value) {
+        if (value === undefined)
+            return;
+        const constructorId = coreType(value);
+        if (constructorId === CORE_TYPES.None) {
+            throw new TypeError(`Invalid core type of ${typeof value}`);
+        }
+        if (![CORE_TYPES.BoolFalse, CORE_TYPES.BoolTrue, CORE_TYPES.Null].includes(constructorId)) {
+            this.writeByte(constructorId);
+        }
+        switch (constructorId) {
+            case CORE_TYPES.BoolFalse:
+            case CORE_TYPES.BoolTrue: {
+                return this.writeBool(value);
+            }
+            case CORE_TYPES.Date: {
+                return this.writeDate(value);
+            }
+            case CORE_TYPES.Int32: {
+                return this.writeInt32(value);
+            }
+            case CORE_TYPES.Int16: {
+                return this.writeInt16(value);
+            }
+            case CORE_TYPES.Int8: {
+                return this.writeInt8(value);
+            }
+            case CORE_TYPES.UInt32: {
+                return this.writeInt32(value, false);
+            }
+            case CORE_TYPES.UInt16: {
+                return this.writeInt16(value, false);
+            }
+            case CORE_TYPES.UInt8: {
+                return this.writeInt8(value, false);
+            }
+            case CORE_TYPES.Double: {
+                return this.writeDouble(value);
+            }
+            case CORE_TYPES.Float: {
+                return this.writeFloat(value);
+            }
+            case CORE_TYPES.Null: {
+                return this.writeNull();
+            }
+            case CORE_TYPES.String: {
+                return this.writeString(value);
+            }
+            case CORE_TYPES.Vector: {
+                return this.writeVector(value);
+            }
+            case CORE_TYPES.Map: {
+                return this.writeMap(value);
+            }
+        }
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,21 @@
+export declare enum CORE_TYPES {
+    None = 0,
+    Binary = 1,
+    BoolFalse = 2,
+    BoolTrue = 3,
+    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
+}

package/dist/constants.js

@@ -0,0 +1,23 @@
+export var CORE_TYPES;
+(function (CORE_TYPES) {
+    CORE_TYPES[CORE_TYPES["None"] = 0] = "None";
+    CORE_TYPES[CORE_TYPES["Binary"] = 1] = "Binary";
+    CORE_TYPES[CORE_TYPES["BoolFalse"] = 2] = "BoolFalse";
+    CORE_TYPES[CORE_TYPES["BoolTrue"] = 3] = "BoolTrue";
+    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 = {}));
+;

package/dist/helpers.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" resolution-mode="require"/>
+import { CORE_TYPES } from './constants.js';
+export declare function concatUint8Arrays(arrays: ArrayLike<number>[]): Uint8Array;
+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

@@ -0,0 +1,105 @@
+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 function bytesToUtf8(bytes) {
+    return textDecoder.decode(bytes);
+}
+export function utf8ToBytes(string) {
+    const buff = new Uint8Array(string.length << 2);
+    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': {
+            return CORE_TYPES.String;
+        }
+        case 'boolean': {
+            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;
+            }
+            return CORE_TYPES.Double;
+        }
+        case 'object': {
+            if (value === null)
+                return CORE_TYPES.Null;
+            if (value instanceof Date) {
+                return CORE_TYPES.Date;
+            }
+            if (Array.isArray(value)) {
+                return CORE_TYPES.Vector;
+            }
+            // @ts-ignore
+            if (toString.call(value) === '[object Object]') {
+                return CORE_TYPES.Map;
+            }
+        }
+    }
+    return CORE_TYPES.None;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { BinaryWriter } from './BinaryWriter.js';
+export { BinaryReader } from './BinaryReader.js';
+export * from './constants.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { BinaryWriter } from './BinaryWriter.js';
+export { BinaryReader } from './BinaryReader.js';
+export * from './constants.js';

package/dist/stream.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Transform, type TransformCallback, type TransformOptions } from 'stream';
+export declare class TLEncode extends Transform {
+    private writer;
+    constructor(options?: TransformOptions);
+    _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
+}
+export declare class TLDecode extends Transform {
+    private reader;
+    private incompleteBuffer;
+    constructor(options?: TransformOptions);
+    _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
+}

package/dist/stream.js

@@ -0,0 +1,47 @@
+import { Transform } from 'stream';
+import { BinaryWriter } from './BinaryWriter.js';
+import { BinaryReader } from './BinaryReader.js';
+export class TLEncode extends Transform {
+    writer;
+    constructor(options) {
+        if (!options)
+            options = {};
+        options.writableObjectMode = true;
+        super(options);
+        this.writer = new BinaryWriter();
+    }
+    _transform(chunk, encoding, callback) {
+        const buff = this.writer.encode(chunk);
+        this.push(buff);
+        callback();
+    }
+}
+export class TLDecode extends Transform {
+    reader;
+    incompleteBuffer;
+    constructor(options) {
+        if (!options)
+            options = {};
+        options.objectMode = true;
+        super(options);
+        this.incompleteBuffer = null;
+        this.reader = new BinaryReader(new Uint8Array(8192));
+    }
+    _transform(chunk, encoding, callback) {
+        if (this.incompleteBuffer) {
+            chunk = Buffer.concat([this.incompleteBuffer, chunk]);
+            this.incompleteBuffer = null;
+        }
+        try {
+            const value = this.reader.decode(chunk);
+            return callback(null, value);
+        }
+        catch (err) {
+            if (err?.incomplete) {
+                this.incompleteBuffer = chunk;
+                return callback();
+            }
+            return callback(err);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "@andrew_l/tl-pack",
+	"version": "0.0.2",
+	"description": "",
+	"type": "module",
+	"scripts": {
+		"dev": "nodemon src/playground.ts",
+		"build": "rm -rf dist && npx tsc"
+	},
+	"keywords": [],
+	"author": "Andrew L.",
+	"license": "ISC",
+	"types": "./dist",
+	"files": [
+		"dist/**"
+	],
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./stream": {
+			"import": "./dist/stream.js",
+			"types": "./dist/stream.d.ts"
+		}
+	},
+	"devDependencies": {
+		"@types/node": "^20.3.2",
+		"eslint-config-prettier": "^8.8.0",
+		"nodemon": "^2.0.22",
+		"prettier": "^2.8.8",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.1.5"
+	}
+}