@andrew_l/tl-pack 0.1.9 → 0.1.81

package/dist/helpers.js

@@ -0,0 +1,321 @@
+import { CORE_TYPES, HAS_NODE_BUFFER } from './constants.js';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const fromCharCode = String.fromCharCode;
+export const int32 = new Int32Array(2);
+export const float32 = new Float32Array(int32.buffer);
+export const float64 = new Float64Array(int32.buffer);
+export function byteArrayAllocate(length) {
+    if (HAS_NODE_BUFFER) {
+        return Buffer.allocUnsafeSlow(length);
+    }
+    return new Uint8Array(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;
+}
+export function utf8Read(target, length, offset) {
+    let result;
+    if (length < 16) {
+        if ((result = utf8ReadShort(target, length, offset)))
+            return result;
+    }
+    if (length > 64 && decoder)
+        return decoder.decode(target.subarray(offset, (offset += length)));
+    const end = offset + length;
+    const units = [];
+    result = '';
+    while (offset < end) {
+        const byte1 = target[offset++];
+        if ((byte1 & 0x80) === 0) {
+            // 1 byte
+            units.push(byte1);
+        }
+        else if ((byte1 & 0xe0) === 0xc0) {
+            // 2 bytes
+            const byte2 = target[offset++] & 0x3f;
+            units.push(((byte1 & 0x1f) << 6) | byte2);
+        }
+        else if ((byte1 & 0xf0) === 0xe0) {
+            // 3 bytes
+            const byte2 = target[offset++] & 0x3f;
+            const byte3 = target[offset++] & 0x3f;
+            units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
+        }
+        else if ((byte1 & 0xf8) === 0xf0) {
+            // 4 bytes
+            const byte2 = target[offset++] & 0x3f;
+            const byte3 = target[offset++] & 0x3f;
+            const byte4 = target[offset++] & 0x3f;
+            let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
+            if (unit > 0xffff) {
+                unit -= 0x10000;
+                units.push(((unit >>> 10) & 0x3ff) | 0xd800);
+                unit = 0xdc00 | (unit & 0x3ff);
+            }
+            units.push(unit);
+        }
+        else {
+            units.push(byte1);
+        }
+        if (units.length >= 0x1000) {
+            result += fromCharCode.apply(String, units);
+            units.length = 0;
+        }
+    }
+    if (units.length > 0) {
+        result += fromCharCode.apply(String, units);
+    }
+    return result;
+}
+export function utf8ReadShort(target, length, offset) {
+    if (length < 4) {
+        if (length < 2) {
+            if (length === 0)
+                return '';
+            else {
+                let a = target[offset++];
+                if ((a & 0x80) > 1) {
+                    offset -= 1;
+                    return;
+                }
+                return fromCharCode(a);
+            }
+        }
+        else {
+            let a = target[offset++];
+            let b = target[offset++];
+            if ((a & 0x80) > 0 || (b & 0x80) > 0) {
+                offset -= 2;
+                return;
+            }
+            if (length < 3)
+                return fromCharCode(a, b);
+            let c = target[offset++];
+            if ((c & 0x80) > 0) {
+                offset -= 3;
+                return;
+            }
+            return fromCharCode(a, b, c);
+        }
+    }
+    else {
+        let a = target[offset++];
+        let b = target[offset++];
+        let c = target[offset++];
+        let d = target[offset++];
+        if ((a & 0x80) > 0 || (b & 0x80) > 0 || (c & 0x80) > 0 || (d & 0x80) > 0) {
+            offset -= 4;
+            return;
+        }
+        if (length < 6) {
+            if (length === 4)
+                return fromCharCode(a, b, c, d);
+            else {
+                let e = target[offset++];
+                if ((e & 0x80) > 0) {
+                    offset -= 5;
+                    return;
+                }
+                return fromCharCode(a, b, c, d, e);
+            }
+        }
+        else if (length < 8) {
+            let e = target[offset++];
+            let f = target[offset++];
+            if ((e & 0x80) > 0 || (f & 0x80) > 0) {
+                offset -= 6;
+                return;
+            }
+            if (length < 7)
+                return fromCharCode(a, b, c, d, e, f);
+            let g = target[offset++];
+            if ((g & 0x80) > 0) {
+                offset -= 7;
+                return;
+            }
+            return fromCharCode(a, b, c, d, e, f, g);
+        }
+        else {
+            let e = target[offset++];
+            let f = target[offset++];
+            let g = target[offset++];
+            let h = target[offset++];
+            if ((e & 0x80) > 0 || (f & 0x80) > 0 || (g & 0x80) > 0 || (h & 0x80) > 0) {
+                offset -= 8;
+                return;
+            }
+            if (length < 10) {
+                if (length === 8)
+                    return fromCharCode(a, b, c, d, e, f, g, h);
+                else {
+                    let i = target[offset++];
+                    if ((i & 0x80) > 0) {
+                        offset -= 9;
+                        return;
+                    }
+                    return fromCharCode(a, b, c, d, e, f, g, h, i);
+                }
+            }
+            else if (length < 12) {
+                let i = target[offset++];
+                let j = target[offset++];
+                if ((i & 0x80) > 0 || (j & 0x80) > 0) {
+                    offset -= 10;
+                    return;
+                }
+                if (length < 11)
+                    return fromCharCode(a, b, c, d, e, f, g, h, i, j);
+                let k = target[offset++];
+                if ((k & 0x80) > 0) {
+                    offset -= 11;
+                    return;
+                }
+                return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
+            }
+            else {
+                let i = target[offset++];
+                let j = target[offset++];
+                let k = target[offset++];
+                let l = target[offset++];
+                if ((i & 0x80) > 0 || (j & 0x80) > 0 || (k & 0x80) > 0 || (l & 0x80) > 0) {
+                    offset -= 12;
+                    return;
+                }
+                if (length < 14) {
+                    if (length === 12)
+                        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
+                    else {
+                        let m = target[offset++];
+                        if ((m & 0x80) > 0) {
+                            offset -= 13;
+                            return;
+                        }
+                        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
+                    }
+                }
+                else {
+                    let m = target[offset++];
+                    let n = target[offset++];
+                    if ((m & 0x80) > 0 || (n & 0x80) > 0) {
+                        offset -= 14;
+                        return;
+                    }
+                    if (length < 15)
+                        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+                    let o = target[offset++];
+                    if ((o & 0x80) > 0) {
+                        offset -= 15;
+                        return;
+                    }
+                    return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
+                }
+            }
+        }
+    }
+}
+export const utf8Write = HAS_NODE_BUFFER
+    ? function (target, value, offset) {
+        return value.length < 0x40
+            ? utf8WriteShort(target, value, offset)
+            : target.utf8Write(value, offset, 0xffffffff);
+    }
+    : function (target, value, offset) {
+        return value.length < 0x40
+            ? utf8WriteShort(target, value, offset)
+            : encoder.encodeInto(value, target.subarray(offset)).written;
+    };
+export const utf8WriteShort = (target, value, offset) => {
+    let i, c1, c2, strPosition = offset;
+    const strLength = value.length;
+    for (i = 0; i < strLength; i++) {
+        c1 = value.charCodeAt(i);
+        if (c1 < 0x80) {
+            target[strPosition++] = c1;
+        }
+        else if (c1 < 0x800) {
+            target[strPosition++] = (c1 >> 6) | 0xc0;
+            target[strPosition++] = (c1 & 0x3f) | 0x80;
+        }
+        else if ((c1 & 0xfc00) === 0xd800 && ((c2 = value.charCodeAt(i + 1)) & 0xfc00) === 0xdc00) {
+            c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
+            i++;
+            target[strPosition++] = (c1 >> 18) | 0xf0;
+            target[strPosition++] = ((c1 >> 12) & 0x3f) | 0x80;
+            target[strPosition++] = ((c1 >> 6) & 0x3f) | 0x80;
+            target[strPosition++] = (c1 & 0x3f) | 0x80;
+        }
+        else {
+            target[strPosition++] = (c1 >> 12) | 0xe0;
+            target[strPosition++] = ((c1 >> 6) & 0x3f) | 0x80;
+            target[strPosition++] = (c1 & 0x3f) | 0x80;
+        }
+    }
+    return strPosition - offset;
+};
+/** @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.d.ts

@@ -1,28 +1,5 @@
-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 };
+export * from './BinaryWriter.js';
+export * from './BinaryReader.js';
+export * from './constants.js';
+export * from './extension.js';
+export * from './dictionary.js';

package/dist/index.js

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

package/dist/stream.d.ts

@@ -1,20 +1,20 @@
-import { TransformOptions, Transform, TransformCallback } from 'node:stream';
-import { B as BinaryWriterOptions, c as BinaryWriter, b as BinaryReader } from './shared/tl-pack.CdcwN4dG.js';
-
-interface TLEncodeOptions extends BinaryWriterOptions {
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Transform, type TransformCallback, type TransformOptions } from 'stream';
+import { BinaryWriter, BinaryWriterOptions } from './BinaryWriter.js';
+import { BinaryReader } from './BinaryReader.js';
+export interface TLEncodeOptions extends BinaryWriterOptions {
     streamOptions?: TransformOptions;
 }
-declare class TLEncode extends Transform {
+export declare class TLEncode extends Transform {
     writer: BinaryWriter;
     count: number;
     constructor(options?: TLEncodeOptions);
     _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
 }
-declare class TLDecode extends Transform {
+export declare class TLDecode extends Transform {
     reader: BinaryReader;
     private incompleteBuffer;
     constructor(options?: TransformOptions);
     _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
 }
-
-export { TLDecode, TLEncode, type TLEncodeOptions };

package/dist/stream.js

@@ -0,0 +1,67 @@
+import { Transform } from 'stream';
+import { BinaryWriter } from './BinaryWriter.js';
+import { BinaryReader } from './BinaryReader.js';
+import { CORE_TYPES } from './constants.js';
+export class TLEncode extends Transform {
+    writer;
+    count;
+    constructor(options) {
+        const opts = options || {};
+        opts.streamOptions = { writableObjectMode: true, ...(opts.streamOptions || {}) };
+        super(opts.streamOptions);
+        const writer = new BinaryWriter(options);
+        const customFlush = opts.streamOptions.flush;
+        const VECTOR_TYPES = new Uint8Array(2);
+        VECTOR_TYPES[0] = CORE_TYPES.VectorDynamic;
+        VECTOR_TYPES[1] = CORE_TYPES.None;
+        // push a byte about dynamic vector starting
+        this.push(VECTOR_TYPES.subarray(0, 1));
+        this._flush = (callback) => {
+            // push a byte about dynamic vector ending
+            this.push(VECTOR_TYPES.subarray(1, 2));
+            if (customFlush) {
+                customFlush.call(this, callback);
+            }
+            else {
+                callback();
+            }
+        };
+        this.writer = writer;
+        this.count = 0;
+    }
+    _transform(chunk, encoding, callback) {
+        const buff = this.writer.encode(chunk);
+        this.push(buff);
+        this.count++;
+        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

@@ -1,43 +1,54 @@
 {
-  "name": "@andrew_l/tl-pack",
-  "version": "0.1.9",
-  "license": "MIT",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/men232/toolkit.git",
-    "directory": "packages/tl-pack"
-  },
-  "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
-    },
-    "./stream": {
-      "import": "./dist/stream.mjs",
-      "require": "./dist/stream.cjs",
-      "types": "./dist/stream.d.ts"
-    }
-  },
-  "main": "./dist/index.cjs",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "dependencies": {
-    "pako": "^2.1.0",
-    "@andrew_l/toolkit": "0.0.1"
-  },
-  "devDependencies": {
-    "@types/node": "^20.16.10",
-    "@types/pako": "^2.0.3",
-    "typescript": "~5.6.2",
-    "unbuild": "3.0.0-rc.11",
-    "vitest": "^2.1.3"
-  },
-  "scripts": {
-    "build": "unbuild",
-    "test": "vitest run --typecheck",
-    "test:watch": "vitest watch --typecheck"
-  }
-}
+	"name": "@andrew_l/tl-pack",
+	"version": "0.1.81",
+  "description": "Binary serialization library",
+	"type": "module",
+	"scripts": {
+		"dev": "nodemon src/playground.ts",
+		"build": "rm -rf dist && npx tsc"
+	},
+	"keywords": [
+		"tl",
+		"pack",
+		"binary",
+		"buffer",
+		"serialization",
+		"deserialization"
+	],
+	"author": "Andrew L.",
+	"license": "ISC",
+	"files": [
+		"dist/**"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/men232/tl-pack.git"
+	},
+	"bugs": {
+		"url": "https://github.com/men232/tl-pack/issues"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"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",
+		"@types/pako": "^2.0.0",
+		"eslint-config-prettier": "^8.8.0",
+		"nodemon": "^2.0.22",
+		"prettier": "^2.8.8",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.1.5"
+	},
+	"dependencies": {
+		"pako": "^2.1.0"
+	}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-# 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/dist/index.cjs

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

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

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