@andrew_l/tl-pack 0.1.7 → 0.1.9

package/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2024 Andrew L. <andrew.io.dev@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,15 +2,15 @@
 
 ![license](https://img.shields.io/npm/l/%40andrew_l%2Ftl-pack) ![npm version](https://img.shields.io/npm/v/%40andrew_l%2Ftl-pack) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/%40andrew_l%2Ftl-pack)
 
-This library is another implementation of binary serialization like **MessagePack** inspired by TL (Type Language) developed by old VK team.
-
-You don't needed in schema for data serialization/deserialization unlike official TL implementation at least in this version.
+This library is an alternative binary serialization, like MessagePack, inspired by TL (Type Language) from the original VK team. Unlike official TL, it requires no schema for serialization/deserialization in this version.
 
 ## Benchmark
 
 A bit faster and a bit more compact than **@msgpack/msgpack**
 
-## Synopsis
+⚠️ May not be true
+
+## Example
 
 ```javascript
 import { BinaryWriter, BinaryReader } from '@andrew_l/tl-pack';
@@ -100,7 +100,7 @@ const decode = new TLDecode();
 
 dataStream.pipe(encode).pipe(decode);
 
-decode.on('data', (data) => console.log('stream', data));
+decode.on('data', data => console.log('stream', data));
 decode.on('error', console.error);
 ```
 
@@ -120,9 +120,13 @@ const extensions = [
         this.writeBytes(value.id);
       }
     },
-    // in the browser you possibly need to decode as a plain string
     decode() {
       const bytes = this.readBytes();
+
+      if (IS_BROWSER) {
+        return hex(bytes);
+      }
+
       return new ObjectId(bytes);
     },
   }),
@@ -146,6 +150,24 @@ console.log(reader.readObject());
   lastName: 'L.'
 }
  */
+
+const byteToHex: string[] = [];
+
+for (let n = 0; n <= 0xff; ++n) {
+  const hexOctet = n.toString(16).padStart(2, '0');
+  byteToHex.push(hexOctet);
+}
+
+function hex(arrayBuffer: Uint8Array) {
+  const buff = new Uint8Array(arrayBuffer);
+  const hexOctets = new Array(buff.length);
+
+  for (let i = 0; i < buff.length; ++i) {
+    hexOctets[i] = byteToHex[buff[i]];
+  }
+
+  return hexOctets.join('');
+}
 ```
 
 ## Dictionary

package/dist/index.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+const BinaryWriter = require('./shared/tl-pack.VfbARqWq.cjs');
+const toolkit = require('@andrew_l/toolkit');
+require('pako');
+
+function createExtension(token, { encode, decode }) {
+  toolkit.assert.ok(Math.trunc(token) === token, " Token must be integer value.");
+  toolkit.assert.ok(
+    token >= 0 && token <= 255,
+    "Token must be a 8 bit number. (0 - 255)"
+  );
+  toolkit.assert.ok(token >= 35, "Tokens from 0 to 34 reserved.");
+  return {
+    token,
+    encode,
+    decode
+  };
+}
+
+function tlEncode(value, opts) {
+  return new BinaryWriter.BinaryWriter(opts).writeObject(value).getBuffer();
+}
+function tlDecode(buffer, opts) {
+  return new BinaryWriter.BinaryReader(buffer, opts).readObject();
+}
+
+exports.BinaryReader = BinaryWriter.BinaryReader;
+exports.BinaryWriter = BinaryWriter.BinaryWriter;
+exports.CORE_TYPES = BinaryWriter.CORE_TYPES;
+exports.MAX_BUFFER_SIZE = BinaryWriter.MAX_BUFFER_SIZE;
+exports.createDictionary = BinaryWriter.createDictionary;
+exports.createExtension = createExtension;
+exports.tlDecode = tlDecode;
+exports.tlEncode = tlEncode;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/extension.ts","../src/index.ts"],"sourcesContent":["import { assert } from '@andrew_l/toolkit';\nimport type { BinaryReader } from './BinaryReader';\nimport type { BinaryWriter } from './BinaryWriter';\n\nexport type EncodeHandler = (this: BinaryWriter, value: any) => void;\n\nexport type DecodeHandler = (this: BinaryReader) => any;\n\nexport interface TLExtension {\n  token: number;\n  encode: EncodeHandler;\n  decode: DecodeHandler;\n}\n\nexport function createExtension(\n  token: number,\n  { encode, decode }: { encode: EncodeHandler; decode: DecodeHandler },\n): TLExtension {\n  assert.ok(Math.trunc(token) === token, ' Token must be integer value.');\n\n  assert.ok(\n    token >= 0 && token <= 255,\n    'Token must be a 8 bit number. (0 - 255)',\n  );\n\n  assert.ok(token >= 35, 'Tokens from 0 to 34 reserved.');\n\n  return {\n    token,\n    encode,\n    decode,\n  };\n}\n","import { BinaryReader, type BinaryReaderOptions } from './BinaryReader';\nimport { BinaryWriter, type BinaryWriterOptions } from './BinaryWriter';\n\nexport { BinaryReader, type BinaryReaderOptions } from './BinaryReader';\nexport { BinaryWriter, type BinaryWriterOptions } from './BinaryWriter';\nexport * from './constants';\nexport { createDictionary } from './dictionary';\nexport {\n  createExtension,\n  type DecodeHandler,\n  type EncodeHandler,\n  type TLExtension,\n} from './extension';\n\n/**\n * Encode any value into `Uint8Array`\n *\n * @example\n * const buffer = tlEncode(new Date(0));\n *\n * console.log(buffer); // Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0])\n *\n * @group Main\n */\nexport function tlEncode(\n  value: unknown,\n  opts?: BinaryWriterOptions,\n): Uint8Array {\n  return new BinaryWriter(opts).writeObject(value).getBuffer();\n}\n\n/**\n * Decode value from `Uint8Array`\n *\n * @example\n * const buffer = new Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0]);\n * const value = tlDecode(buffer);\n *\n * console.log(value); // Thu Jan 01 1970 01:00:00 GMT+0100 (Central European Standard Time)\n *\n * @group Main\n */\nexport function tlDecode<T = any>(\n  buffer: Uint8Array,\n  opts?: BinaryReaderOptions,\n): T {\n  return new BinaryReader(buffer, opts).readObject();\n}\n"],"names":["assert","BinaryWriter","BinaryReader"],"mappings":";;;;;;AAcO,SAAS,eACd,CAAA,KAAA,EACA,EAAE,MAAA,EAAQ,QACG,EAAA;AACb,EAAAA,cAAA,CAAO,GAAG,IAAK,CAAA,KAAA,CAAM,KAAK,CAAA,KAAM,OAAO,+BAA+B,CAAA,CAAA;AAEtE,EAAOA,cAAA,CAAA,EAAA;AAAA,IACL,KAAA,IAAS,KAAK,KAAS,IAAA,GAAA;AAAA,IACvB,yCAAA;AAAA,GACF,CAAA;AAEA,EAAOA,cAAA,CAAA,EAAA,CAAG,KAAS,IAAA,EAAA,EAAI,+BAA+B,CAAA,CAAA;AAEtD,EAAO,OAAA;AAAA,IACL,KAAA;AAAA,IACA,MAAA;AAAA,IACA,MAAA;AAAA,GACF,CAAA;AACF;;ACRgB,SAAA,QAAA,CACd,OACA,IACY,EAAA;AACZ,EAAA,OAAO,IAAIC,yBAAa,CAAA,IAAI,EAAE,WAAY,CAAA,KAAK,EAAE,SAAU,EAAA,CAAA;AAC7D,CAAA;AAagB,SAAA,QAAA,CACd,QACA,IACG,EAAA;AACH,EAAA,OAAO,IAAIC,yBAAA,CAAa,MAAQ,EAAA,IAAI,EAAE,UAAW,EAAA,CAAA;AACnD;;;;;;;;;;;"}

package/dist/index.d.cts

@@ -0,0 +1,28 @@
+import { B as BinaryWriterOptions, a as BinaryReaderOptions } from './shared/tl-pack.CdcwN4dG.cjs';
+export { b as BinaryReader, c as BinaryWriter, C as CORE_TYPES, D as DecodeHandler, E as EncodeHandler, M as MAX_BUFFER_SIZE, T as TLExtension, d as createDictionary, e as createExtension } from './shared/tl-pack.CdcwN4dG.cjs';
+
+/**
+ * Encode any value into `Uint8Array`
+ *
+ * @example
+ * const buffer = tlEncode(new Date(0));
+ *
+ * console.log(buffer); // Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0])
+ *
+ * @group Main
+ */
+declare function tlEncode(value: unknown, opts?: BinaryWriterOptions): Uint8Array;
+/**
+ * Decode value from `Uint8Array`
+ *
+ * @example
+ * const buffer = new Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0]);
+ * const value = tlDecode(buffer);
+ *
+ * console.log(value); // Thu Jan 01 1970 01:00:00 GMT+0100 (Central European Standard Time)
+ *
+ * @group Main
+ */
+declare function tlDecode<T = any>(buffer: Uint8Array, opts?: BinaryReaderOptions): T;
+
+export { BinaryReaderOptions, BinaryWriterOptions, tlDecode, tlEncode };

package/dist/index.d.mts

@@ -0,0 +1,28 @@
+import { B as BinaryWriterOptions, a as BinaryReaderOptions } from './shared/tl-pack.CdcwN4dG.mjs';
+export { b as BinaryReader, c as BinaryWriter, C as CORE_TYPES, D as DecodeHandler, E as EncodeHandler, M as MAX_BUFFER_SIZE, T as TLExtension, d as createDictionary, e as createExtension } from './shared/tl-pack.CdcwN4dG.mjs';
+
+/**
+ * Encode any value into `Uint8Array`
+ *
+ * @example
+ * const buffer = tlEncode(new Date(0));
+ *
+ * console.log(buffer); // Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0])
+ *
+ * @group Main
+ */
+declare function tlEncode(value: unknown, opts?: BinaryWriterOptions): Uint8Array;
+/**
+ * Decode value from `Uint8Array`
+ *
+ * @example
+ * const buffer = new Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0]);
+ * const value = tlDecode(buffer);
+ *
+ * console.log(value); // Thu Jan 01 1970 01:00:00 GMT+0100 (Central European Standard Time)
+ *
+ * @group Main
+ */
+declare function tlDecode<T = any>(buffer: Uint8Array, opts?: BinaryReaderOptions): T;
+
+export { BinaryReaderOptions, BinaryWriterOptions, tlDecode, tlEncode };

package/dist/index.d.ts

@@ -1,5 +1,28 @@
-export * from './BinaryWriter.js';
-export * from './BinaryReader.js';
-export * from './constants.js';
-export * from './extension.js';
-export * from './dictionary.js';
+import { B as BinaryWriterOptions, a as BinaryReaderOptions } from './shared/tl-pack.CdcwN4dG.js';
+export { b as BinaryReader, c as BinaryWriter, C as CORE_TYPES, D as DecodeHandler, E as EncodeHandler, M as MAX_BUFFER_SIZE, T as TLExtension, d as createDictionary, e as createExtension } from './shared/tl-pack.CdcwN4dG.js';
+
+/**
+ * Encode any value into `Uint8Array`
+ *
+ * @example
+ * const buffer = tlEncode(new Date(0));
+ *
+ * console.log(buffer); // Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0])
+ *
+ * @group Main
+ */
+declare function tlEncode(value: unknown, opts?: BinaryWriterOptions): Uint8Array;
+/**
+ * Decode value from `Uint8Array`
+ *
+ * @example
+ * const buffer = new Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0]);
+ * const value = tlDecode(buffer);
+ *
+ * console.log(value); // Thu Jan 01 1970 01:00:00 GMT+0100 (Central European Standard Time)
+ *
+ * @group Main
+ */
+declare function tlDecode<T = any>(buffer: Uint8Array, opts?: BinaryReaderOptions): T;
+
+export { BinaryReaderOptions, BinaryWriterOptions, tlDecode, tlEncode };

package/dist/index.mjs

@@ -0,0 +1,28 @@
+import { B as BinaryWriter, a as BinaryReader } from './shared/tl-pack.DnNse4P6.mjs';
+export { C as CORE_TYPES, M as MAX_BUFFER_SIZE, c as createDictionary } from './shared/tl-pack.DnNse4P6.mjs';
+import { assert } from '@andrew_l/toolkit';
+import 'pako';
+
+function createExtension(token, { encode, decode }) {
+  assert.ok(Math.trunc(token) === token, " Token must be integer value.");
+  assert.ok(
+    token >= 0 && token <= 255,
+    "Token must be a 8 bit number. (0 - 255)"
+  );
+  assert.ok(token >= 35, "Tokens from 0 to 34 reserved.");
+  return {
+    token,
+    encode,
+    decode
+  };
+}
+
+function tlEncode(value, opts) {
+  return new BinaryWriter(opts).writeObject(value).getBuffer();
+}
+function tlDecode(buffer, opts) {
+  return new BinaryReader(buffer, opts).readObject();
+}
+
+export { BinaryReader, BinaryWriter, createExtension, tlDecode, tlEncode };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../src/extension.ts","../src/index.ts"],"sourcesContent":["import { assert } from '@andrew_l/toolkit';\nimport type { BinaryReader } from './BinaryReader';\nimport type { BinaryWriter } from './BinaryWriter';\n\nexport type EncodeHandler = (this: BinaryWriter, value: any) => void;\n\nexport type DecodeHandler = (this: BinaryReader) => any;\n\nexport interface TLExtension {\n  token: number;\n  encode: EncodeHandler;\n  decode: DecodeHandler;\n}\n\nexport function createExtension(\n  token: number,\n  { encode, decode }: { encode: EncodeHandler; decode: DecodeHandler },\n): TLExtension {\n  assert.ok(Math.trunc(token) === token, ' Token must be integer value.');\n\n  assert.ok(\n    token >= 0 && token <= 255,\n    'Token must be a 8 bit number. (0 - 255)',\n  );\n\n  assert.ok(token >= 35, 'Tokens from 0 to 34 reserved.');\n\n  return {\n    token,\n    encode,\n    decode,\n  };\n}\n","import { BinaryReader, type BinaryReaderOptions } from './BinaryReader';\nimport { BinaryWriter, type BinaryWriterOptions } from './BinaryWriter';\n\nexport { BinaryReader, type BinaryReaderOptions } from './BinaryReader';\nexport { BinaryWriter, type BinaryWriterOptions } from './BinaryWriter';\nexport * from './constants';\nexport { createDictionary } from './dictionary';\nexport {\n  createExtension,\n  type DecodeHandler,\n  type EncodeHandler,\n  type TLExtension,\n} from './extension';\n\n/**\n * Encode any value into `Uint8Array`\n *\n * @example\n * const buffer = tlEncode(new Date(0));\n *\n * console.log(buffer); // Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0])\n *\n * @group Main\n */\nexport function tlEncode(\n  value: unknown,\n  opts?: BinaryWriterOptions,\n): Uint8Array {\n  return new BinaryWriter(opts).writeObject(value).getBuffer();\n}\n\n/**\n * Decode value from `Uint8Array`\n *\n * @example\n * const buffer = new Uint8Array([5, 0, 0, 0, 0, 0, 0, 0, 0]);\n * const value = tlDecode(buffer);\n *\n * console.log(value); // Thu Jan 01 1970 01:00:00 GMT+0100 (Central European Standard Time)\n *\n * @group Main\n */\nexport function tlDecode<T = any>(\n  buffer: Uint8Array,\n  opts?: BinaryReaderOptions,\n): T {\n  return new BinaryReader(buffer, opts).readObject();\n}\n"],"names":[],"mappings":";;;;;AAcO,SAAS,eACd,CAAA,KAAA,EACA,EAAE,MAAA,EAAQ,QACG,EAAA;AACb,EAAA,MAAA,CAAO,GAAG,IAAK,CAAA,KAAA,CAAM,KAAK,CAAA,KAAM,OAAO,+BAA+B,CAAA,CAAA;AAEtE,EAAO,MAAA,CAAA,EAAA;AAAA,IACL,KAAA,IAAS,KAAK,KAAS,IAAA,GAAA;AAAA,IACvB,yCAAA;AAAA,GACF,CAAA;AAEA,EAAO,MAAA,CAAA,EAAA,CAAG,KAAS,IAAA,EAAA,EAAI,+BAA+B,CAAA,CAAA;AAEtD,EAAO,OAAA;AAAA,IACL,KAAA;AAAA,IACA,MAAA;AAAA,IACA,MAAA;AAAA,GACF,CAAA;AACF;;ACRgB,SAAA,QAAA,CACd,OACA,IACY,EAAA;AACZ,EAAA,OAAO,IAAI,YAAa,CAAA,IAAI,EAAE,WAAY,CAAA,KAAK,EAAE,SAAU,EAAA,CAAA;AAC7D,CAAA;AAagB,SAAA,QAAA,CACd,QACA,IACG,EAAA;AACH,EAAA,OAAO,IAAI,YAAA,CAAa,MAAQ,EAAA,IAAI,EAAE,UAAW,EAAA,CAAA;AACnD;;;;"}

package/dist/shared/tl-pack.CdcwN4dG.d.cts

@@ -0,0 +1,195 @@
+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
+}
+declare const MAX_BUFFER_SIZE = 2144337920;
+
+declare function createDictionary(values?: string[]): Dictionary;
+declare class Dictionary {
+    private _count;
+    private _wordToIndex;
+    private _words;
+    private _offset;
+    constructor(values?: string[], offset?: number);
+    get size(): number;
+    /**
+     * Returns inserted index or nothing
+     */
+    maybeInsert(word: string): number | null;
+    getValue(index: number): string | null;
+    getIndex(value: string): number | null;
+    hasValue(value: string): boolean;
+    hasIndex(index: number): boolean;
+}
+
+interface BinaryWriterOptions {
+    gzip?: boolean;
+    dictionary?: string[] | Dictionary;
+    extensions?: TLExtension[];
+}
+declare class BinaryWriter {
+    private withGzip;
+    private target;
+    private dictionary?;
+    private dictionaryExtended;
+    private extensions;
+    private _last;
+    private _repeat?;
+    offset: number;
+    constructor(options?: BinaryWriterOptions);
+    allocate(size: number): this;
+    private makeRoom;
+    get safeEnd(): number;
+    getBuffer(): Uint8Array;
+    writeByte(value: number): this;
+    writeBool(value: boolean): this;
+    writeNull(): this;
+    writeInt32(value: number, signed?: boolean): this;
+    writeInt16(value: number, signed?: boolean): this;
+    writeInt8(value: number, signed?: boolean): this;
+    writeFloat(value: number): this;
+    writeDouble(value: number): this;
+    writeDate(value: number | Date): this;
+    writeString(value: string): this;
+    writeBytes(value: Uint8Array): this;
+    writeLength(value: number): this;
+    writeVector(value: Array<any>): this;
+    writeMap(object: Record<string, any>): this;
+    wireDictionary(value: string): this;
+    writeGzip(value: Uint8Array | ArrayBuffer): this;
+    encode(value: any): Uint8Array;
+    startDynamicVector(): this;
+    endDynamicVector(): this;
+    private _writeCustom;
+    writeObject(value: any): this;
+    writeObjectGzip(value: any): this;
+    private writeCore;
+    private writeRepeat;
+}
+
+type EncodeHandler = (this: BinaryWriter, value: any) => void;
+type DecodeHandler = (this: BinaryReader) => any;
+interface TLExtension {
+    token: number;
+    encode: EncodeHandler;
+    decode: DecodeHandler;
+}
+declare function createExtension(token: number, { encode, decode }: {
+    encode: EncodeHandler;
+    decode: DecodeHandler;
+}): TLExtension;
+
+interface BinaryReaderOptions {
+    dictionary?: string[] | Dictionary;
+    extensions?: TLExtension[];
+}
+declare class BinaryReader {
+    private target;
+    private _last?;
+    private _lastObject?;
+    private dictionary?;
+    private dictionaryExtended;
+    private extensions;
+    private _repeat?;
+    offset: number;
+    length: number;
+    /**
+     * Small utility class to read binary data.
+     */
+    constructor(data: Uint8Array, options?: BinaryReaderOptions);
+    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;
+    assertConstructor(constructorId: CORE_TYPES): void;
+    /**
+     * Gets the byte array representing the current buffer as a whole.
+     */
+    getBuffer(): Uint8Array;
+    readNull(): null;
+    readLength(): number;
+    readAll(): any[];
+    readBytes(): Uint8Array;
+    /**
+     * Reads encoded string.
+     */
+    readString(): string;
+    /**
+     * Reads a boolean value.
+     */
+    readBool(): boolean;
+    /**
+     * Reads and converts Unix time
+     * into a Javascript {Date} object.
+     */
+    readDate(): Date;
+    /**
+     * Reads a object.
+     */
+    readObject(): any;
+    readObjectGzip(): any;
+    readGzip(): any;
+    private readCore;
+    getDictionaryValue(index: number): string | null;
+    readDictionary(): null | string;
+    readMap(checkConstructor?: boolean): Record<string, any>;
+    decode<T = any>(value: Uint8Array): T;
+    /**
+     * Reads a vector (a list) of objects.
+     */
+    readVector<T = any>(checkConstructor?: boolean): T[];
+    /**
+     * Reads a vector (a list) of objects.
+     */
+    readVectorDynamic<T>(checkConstructor?: boolean): T[];
+    /**
+     * Tells the current position on the stream.
+     */
+    tellPosition(): number;
+    /**
+     * Sets the current position on the stream.
+     */
+    setPosition(position: number): void;
+    /**
+     * Seeks the stream position given an offset from the current position.
+     * The offset may be negative.
+     */
+    seek(offset: number): void;
+}
+
+export { type BinaryWriterOptions as B, CORE_TYPES as C, type DecodeHandler as D, type EncodeHandler as E, MAX_BUFFER_SIZE as M, type TLExtension as T, type BinaryReaderOptions as a, BinaryReader as b, BinaryWriter as c, createDictionary as d, createExtension as e };

package/dist/shared/tl-pack.CdcwN4dG.d.mts

@@ -0,0 +1,195 @@
+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
+}
+declare const MAX_BUFFER_SIZE = 2144337920;
+
+declare function createDictionary(values?: string[]): Dictionary;
+declare class Dictionary {
+    private _count;
+    private _wordToIndex;
+    private _words;
+    private _offset;
+    constructor(values?: string[], offset?: number);
+    get size(): number;
+    /**
+     * Returns inserted index or nothing
+     */
+    maybeInsert(word: string): number | null;
+    getValue(index: number): string | null;
+    getIndex(value: string): number | null;
+    hasValue(value: string): boolean;
+    hasIndex(index: number): boolean;
+}
+
+interface BinaryWriterOptions {
+    gzip?: boolean;
+    dictionary?: string[] | Dictionary;
+    extensions?: TLExtension[];
+}
+declare class BinaryWriter {
+    private withGzip;
+    private target;
+    private dictionary?;
+    private dictionaryExtended;
+    private extensions;
+    private _last;
+    private _repeat?;
+    offset: number;
+    constructor(options?: BinaryWriterOptions);
+    allocate(size: number): this;
+    private makeRoom;
+    get safeEnd(): number;
+    getBuffer(): Uint8Array;
+    writeByte(value: number): this;
+    writeBool(value: boolean): this;
+    writeNull(): this;
+    writeInt32(value: number, signed?: boolean): this;
+    writeInt16(value: number, signed?: boolean): this;
+    writeInt8(value: number, signed?: boolean): this;
+    writeFloat(value: number): this;
+    writeDouble(value: number): this;
+    writeDate(value: number | Date): this;
+    writeString(value: string): this;
+    writeBytes(value: Uint8Array): this;
+    writeLength(value: number): this;
+    writeVector(value: Array<any>): this;
+    writeMap(object: Record<string, any>): this;
+    wireDictionary(value: string): this;
+    writeGzip(value: Uint8Array | ArrayBuffer): this;
+    encode(value: any): Uint8Array;
+    startDynamicVector(): this;
+    endDynamicVector(): this;
+    private _writeCustom;
+    writeObject(value: any): this;
+    writeObjectGzip(value: any): this;
+    private writeCore;
+    private writeRepeat;
+}
+
+type EncodeHandler = (this: BinaryWriter, value: any) => void;
+type DecodeHandler = (this: BinaryReader) => any;
+interface TLExtension {
+    token: number;
+    encode: EncodeHandler;
+    decode: DecodeHandler;
+}
+declare function createExtension(token: number, { encode, decode }: {
+    encode: EncodeHandler;
+    decode: DecodeHandler;
+}): TLExtension;
+
+interface BinaryReaderOptions {
+    dictionary?: string[] | Dictionary;
+    extensions?: TLExtension[];
+}
+declare class BinaryReader {
+    private target;
+    private _last?;
+    private _lastObject?;
+    private dictionary?;
+    private dictionaryExtended;
+    private extensions;
+    private _repeat?;
+    offset: number;
+    length: number;
+    /**
+     * Small utility class to read binary data.
+     */
+    constructor(data: Uint8Array, options?: BinaryReaderOptions);
+    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;
+    assertConstructor(constructorId: CORE_TYPES): void;
+    /**
+     * Gets the byte array representing the current buffer as a whole.
+     */
+    getBuffer(): Uint8Array;
+    readNull(): null;
+    readLength(): number;
+    readAll(): any[];
+    readBytes(): Uint8Array;
+    /**
+     * Reads encoded string.
+     */
+    readString(): string;
+    /**
+     * Reads a boolean value.
+     */
+    readBool(): boolean;
+    /**
+     * Reads and converts Unix time
+     * into a Javascript {Date} object.
+     */
+    readDate(): Date;
+    /**
+     * Reads a object.
+     */
+    readObject(): any;
+    readObjectGzip(): any;
+    readGzip(): any;
+    private readCore;
+    getDictionaryValue(index: number): string | null;
+    readDictionary(): null | string;
+    readMap(checkConstructor?: boolean): Record<string, any>;
+    decode<T = any>(value: Uint8Array): T;
+    /**
+     * Reads a vector (a list) of objects.
+     */
+    readVector<T = any>(checkConstructor?: boolean): T[];
+    /**
+     * Reads a vector (a list) of objects.
+     */
+    readVectorDynamic<T>(checkConstructor?: boolean): T[];
+    /**
+     * Tells the current position on the stream.
+     */
+    tellPosition(): number;
+    /**
+     * Sets the current position on the stream.
+     */
+    setPosition(position: number): void;
+    /**
+     * Seeks the stream position given an offset from the current position.
+     * The offset may be negative.
+     */
+    seek(offset: number): void;
+}
+
+export { type BinaryWriterOptions as B, CORE_TYPES as C, type DecodeHandler as D, type EncodeHandler as E, MAX_BUFFER_SIZE as M, type TLExtension as T, type BinaryReaderOptions as a, BinaryReader as b, BinaryWriter as c, createDictionary as d, createExtension as e };