@andrew_l/tl-pack 0.1.9 → 0.1.82

package/dist/BinaryWriter.js

@@ -0,0 +1,385 @@
+import pako from 'pako';
+import { CORE_TYPES, MAX_BUFFER_SIZE } from './constants.js';
+import { Dictionary } from './dictionary.js';
+import { byteArrayAllocate, coreType, float32, float64, int32, utf8Write, } from './helpers.js';
+const noop = Symbol();
+const NO_CONSTRUCTOR = new Set([CORE_TYPES.BoolFalse, CORE_TYPES.BoolTrue, CORE_TYPES.Null]);
+const SUPPORT_COMPRESSION = new Set([CORE_TYPES.String]);
+export class BinaryWriter {
+    withGzip;
+    target;
+    dictionary;
+    dictionaryExtended;
+    extensions;
+    _last = noop;
+    _repeat;
+    offset;
+    constructor(options) {
+        this.offset = 0;
+        this.extensions = new Map();
+        this.withGzip = !!options && !!options.gzip;
+        this.target = byteArrayAllocate(8192);
+        if (options && options.extensions) {
+            options.extensions.forEach((ext) => {
+                this.extensions.set(ext.token, ext);
+            });
+        }
+        if (!options) {
+            this.dictionary = new Dictionary();
+        }
+        else if (options.dictionary instanceof Dictionary) {
+            this.dictionary = options.dictionary;
+        }
+        else if (Array.isArray(options.dictionary)) {
+            this.dictionary = new Dictionary(options.dictionary);
+        }
+        else {
+            this.dictionary = new Dictionary();
+        }
+        this.dictionaryExtended = new Dictionary(undefined, this.dictionary.size);
+    }
+    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);
+        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;
+    }
+    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.target[this.offset++] = value;
+            this.target[this.offset++] = value >> 8;
+            this.target[this.offset++] = value >> 16;
+            this.target[this.offset++] = value >> 24;
+        }
+        else {
+            this.target[this.offset++] = value;
+            this.target[this.offset++] = value >> 8;
+            this.target[this.offset++] = value >> 16;
+            this.target[this.offset++] = value >> 24;
+        }
+    }
+    writeInt16(value, signed = true) {
+        this.allocate(2);
+        if (signed) {
+            this.target[this.offset++] = value;
+            this.target[this.offset++] = value >> 8;
+        }
+        else {
+            this.target[this.offset++] = value;
+            this.target[this.offset++] = value >> 8;
+        }
+    }
+    writeInt8(value, signed = true) {
+        this.allocate(1);
+        this.target[this.offset++] = value;
+    }
+    writeFloat(value) {
+        this.allocate(4);
+        float32[0] = value;
+        this.writeInt32(int32[0]);
+    }
+    writeDouble(value) {
+        this.allocate(8);
+        float64[0] = value;
+        this.writeInt32(int32[0], false);
+        this.writeInt32(int32[1], false);
+    }
+    writeDate(value) {
+        let timestamp = 0;
+        if (value instanceof Date) {
+            timestamp = value.getTime();
+        }
+        else if (typeof value === 'number') {
+            timestamp = value;
+        }
+        this.writeDouble(timestamp);
+    }
+    writeString(value) {
+        // const compressed = pako.deflateRaw(value, { level: 9 });
+        // this.writeBytes(compressed);
+        const strLength = value.length;
+        let start = this.offset;
+        let require = strLength << 2;
+        if (require < 254) {
+            require += 1;
+            this.offset += 1;
+        }
+        else {
+            require += 4;
+            this.offset += 4;
+        }
+        this.allocate(require);
+        const bytes = utf8Write(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;
+    }
+    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++) {
+            if (value[i] === undefined) {
+                this.writeNull();
+            }
+            else {
+                this.writeObject(value[i]);
+            }
+        }
+    }
+    writeMap(object) {
+        for (const key in object) {
+            if (object[key] === undefined)
+                continue;
+            this._last = noop;
+            this.wireDictionary(key);
+            this.writeObject(object[key]);
+        }
+        this.writeByte(CORE_TYPES.None);
+    }
+    wireDictionary(value) {
+        let idx;
+        if (this.dictionary) {
+            idx = this.dictionary.getIndex(value);
+        }
+        if (idx === undefined) {
+            idx = this.dictionaryExtended.getIndex(value);
+        }
+        if (idx === undefined) {
+            this.dictionaryExtended.maybeInsert(value);
+            this.writeCore(CORE_TYPES.DictValue, value);
+        }
+        else {
+            this.writeCore(CORE_TYPES.DictIndex, idx);
+        }
+    }
+    writeGzip(value) {
+        const compressed = pako.deflateRaw(value, { level: 9 });
+        this.writeBytes(compressed);
+    }
+    encode(value) {
+        this.offset = 0;
+        this._last = noop;
+        this._repeat = undefined;
+        this.target = byteArrayAllocate(256);
+        this.writeObject(value);
+        return this.getBuffer();
+    }
+    startDynamicVector() {
+        this.writeByte(CORE_TYPES.VectorDynamic);
+    }
+    endDynamicVector() {
+        this.writeByte(CORE_TYPES.None);
+    }
+    _writeCustom(value) {
+        const start = this.offset;
+        this.allocate(1);
+        this.offset++;
+        let edgeExt;
+        for (const ext of this.extensions.values()) {
+            if (ext.token === -1) {
+                edgeExt = ext;
+                continue;
+            }
+            ext.encode.call(this, value);
+            const processed = start + 1 < this.offset;
+            if (processed) {
+                const end = this.offset;
+                this.offset = start;
+                this.writeByte(ext.token);
+                this.offset = end;
+                return true;
+            }
+        }
+        this.offset = start;
+        if (edgeExt) {
+            edgeExt.encode.call(this, value);
+            return start < this.offset;
+        }
+        return false;
+    }
+    writeObject(value) {
+        if (value === undefined)
+            return;
+        const constructorId = coreType(value);
+        // console.log('write', {
+        // 	offset: this.offset,
+        // 	constructorId: CORE_TYPES[constructorId],
+        // 	value: String(value),
+        // });
+        if (constructorId === CORE_TYPES.None) {
+            if (this._writeCustom(value)) {
+                return;
+            }
+            throw new TypeError(`Invalid core type of ${value}`);
+        }
+        if (this._last === value) {
+            this.writeRepeat();
+        }
+        else {
+            this._last = value;
+            this._repeat = undefined;
+            this.writeCore(constructorId, value);
+        }
+    }
+    writeObjectGzip(value) {
+        const writer = new BinaryWriter();
+        writer.extensions = this.extensions;
+        writer.dictionary = this.dictionary;
+        writer.dictionaryExtended = this.dictionaryExtended;
+        writer.writeObject(value);
+        this.writeCore(CORE_TYPES.GZIP, writer.getBuffer());
+    }
+    writeCore(constructorId, value) {
+        if (this.withGzip && SUPPORT_COMPRESSION.has(constructorId)) {
+            this.writeObjectGzip(value);
+            return;
+        }
+        else if (!NO_CONSTRUCTOR.has(constructorId)) {
+            this.writeByte(constructorId);
+        }
+        switch (constructorId) {
+            case CORE_TYPES.GZIP: {
+                return this.writeGzip(value);
+            }
+            case CORE_TYPES.DictIndex: {
+                return this.writeLength(value);
+            }
+            case CORE_TYPES.DictValue: {
+                return this.writeString(value);
+            }
+            case CORE_TYPES.BoolFalse: {
+                return this.writeBool(value);
+            }
+            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: {
+                // write short strings into dictionary
+                if (value.length <= 0x10) {
+                    this.offset--;
+                    return this.wireDictionary(value);
+                }
+                return this.writeString(value);
+            }
+            case CORE_TYPES.Vector: {
+                return this.writeVector(value);
+            }
+            case CORE_TYPES.Map: {
+                return this.writeMap(value);
+            }
+        }
+    }
+    writeRepeat() {
+        if (!this._repeat) {
+            this.writeByte(CORE_TYPES.Repeat);
+            this._repeat = { count: 0, offset: this.offset };
+        }
+        this.offset = this._repeat.offset;
+        this._repeat.count++;
+        this.writeLength(this._repeat.count);
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,26 @@
+export declare enum CORE_TYPES {
+    None = 0,
+    Binary = 1,
+    BoolFalse = 2,
+    BoolTrue = 3,
+    Null = 4,
+    Date = 5,
+    Vector = 6,
+    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,
+    Repeat = 20,
+    GZIP = 25
+}
+export declare const HAS_NODE_BUFFER: boolean;
+export declare const MAX_BUFFER_SIZE: number;

package/dist/constants.js

@@ -0,0 +1,27 @@
+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["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["Repeat"] = 20] = "Repeat";
+    CORE_TYPES[CORE_TYPES["GZIP"] = 25] = "GZIP";
+})(CORE_TYPES || (CORE_TYPES = {}));
+export const HAS_NODE_BUFFER = typeof Buffer !== 'undefined';
+export const MAX_BUFFER_SIZE = HAS_NODE_BUFFER ? 0x100000000 : 0x7fd00000;

package/dist/dictionary.d.ts

@@ -0,0 +1,17 @@
+export declare function createDictionary(values?: string[]): Dictionary;
+export declare class Dictionary {
+    private _count;
+    private _map;
+    private _index;
+    private _offset;
+    constructor(values?: string[], offset?: number);
+    get size(): number;
+    /**
+     * Returns inserted index or nothing
+     */
+    maybeInsert(word: string): number | undefined;
+    getValue(index: number): string | undefined;
+    getIndex(value: string): number | undefined;
+    hasValue(value: string): boolean;
+    hasIndex(index: number): boolean;
+}

package/dist/dictionary.js

@@ -0,0 +1,51 @@
+export function createDictionary(values) {
+    return new Dictionary(values);
+}
+export class Dictionary {
+    _count = 0;
+    _map;
+    _index;
+    _offset;
+    constructor(values, offset = 0) {
+        this._index = [];
+        this._map = new Map();
+        this._offset = offset;
+        if (Array.isArray(values) && values.length) {
+            values.forEach((word) => {
+                if (this._map.has(word))
+                    return;
+                this._map.set(word, this._count++);
+                this._index.push(word);
+            });
+        }
+    }
+    get size() {
+        return this._count;
+    }
+    /**
+     * Returns inserted index or nothing
+     */
+    maybeInsert(word) {
+        if (this._map.has(word))
+            return;
+        this._map.set(word, this._count++);
+        this._index.push(word);
+        return this._count + this._offset;
+    }
+    getValue(index) {
+        return this._index[index - this._offset];
+    }
+    getIndex(value) {
+        const idx = this._map.get(value);
+        if (idx === undefined) {
+            return idx;
+        }
+        return idx + this._offset;
+    }
+    hasValue(value) {
+        return this._map.has(value);
+    }
+    hasIndex(index) {
+        return this._index[index - this._offset] !== undefined;
+    }
+}

package/dist/extension.d.ts

@@ -0,0 +1,13 @@
+import type { BinaryReader } from './BinaryReader.js';
+import type { BinaryWriter } from './BinaryWriter.js';
+export type EncodeHandler = (this: BinaryWriter, value: any) => void;
+export type DecodeHandler = (this: BinaryReader) => any;
+export interface TLExtension {
+    token: number;
+    encode: EncodeHandler;
+    decode: DecodeHandler;
+}
+export declare function createExtension(token: number, { encode, decode }: {
+    encode: EncodeHandler;
+    decode: DecodeHandler;
+}): TLExtension;

package/dist/extension.js

@@ -0,0 +1,13 @@
+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 !== -1 && token < 35) {
+        throw new TypeError('Tokens reserved from 0 to 34');
+    }
+    return {
+        token,
+        encode,
+        decode,
+    };
+}

package/dist/helpers.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+import { CORE_TYPES } from './constants.js';
+export declare const int32: Int32Array;
+export declare const float32: Float32Array;
+export declare const float64: Float64Array;
+export declare function byteArrayAllocate(length: number): Buffer | Uint8Array;
+export declare function coreType(value: any): CORE_TYPES;
+export declare function utf8Read(target: Buffer | Uint8Array, length: number, offset: number): string;
+export declare function utf8ReadShort(target: Buffer | Uint8Array, length: number, offset: number): string | undefined;
+export declare const utf8Write: (target: any, value: string, offset: number) => number;
+export declare const utf8WriteShort: (target: any, value: string, offset: number) => number;