@andrew_l/tl-pack 0.1.7 → 0.1.9

package/dist/BinaryWriter.js

@@ -1,397 +0,0 @@
-import pako from 'pako';
-import { CORE_TYPES } from './constants.js';
-import { Dictionary } from './dictionary.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();
-const noop = Symbol();
-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);
-}
-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);
-        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;
-    }
-    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);
-        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;
-    }
-    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 < 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: {
-                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

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

package/dist/constants.js

@@ -1,25 +0,0 @@
-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 = {}));

package/dist/dictionary.d.ts

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

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

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

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

@@ -1,8 +0,0 @@
-/// <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 bytesToUtf8(bytes: Buffer | Uint8Array): string;
-export declare function utf8ToBytes(string: string): Uint8Array;
-export declare function coreType(value: any): CORE_TYPES;

package/dist/helpers.js

@@ -1,83 +0,0 @@
-import { CORE_TYPES } from './constants.js';
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-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);
-}
-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 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) {
-                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;
-        }
-        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;
-            }
-            if (isPlainObject(value)) {
-                return CORE_TYPES.Map;
-            }
-        }
-    }
-    return CORE_TYPES.None;
-}
-/** @ts-ignore */
-const isObject = (val) => toString.call(val) === '[object Object]';
-function isPlainObject(value) {
-    let ctor, prot;
-    if (!isObject(value))
-        return false;
-    // If it has modified constructor
-    ctor = value.constructor;
-    if (ctor === undefined)
-        return true;
-    // If it has modified prototype
-    prot = ctor.prototype;
-    if (isObject(prot) === false)
-        return false;
-    // If constructor does not have an Object-specific method
-    // eslint-disable-next-line no-prototype-builtins
-    if (prot.hasOwnProperty('isPrototypeOf') === false) {
-        return false;
-    }
-    // Most likely a plain Object
-    return true;
-}

package/dist/index.js

@@ -1,5 +0,0 @@
-export * from './BinaryWriter.js';
-export * from './BinaryReader.js';
-export * from './constants.js';
-export * from './extension.js';
-export * from './dictionary.js';