@tgsnake/skema 1.12.0 → 2.0.0-browser.0

package/dist/src/raw/core/primitive/Int.js

@@ -0,0 +1,237 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { TLObject } from '../TLObject.js';
+import { Buffer } from '../../../deps.js';
+import { bufferToBigint as toBigint } from '../../../helpers.js';
+/**
+ * Serializer and deserializer for standard 32-bit (4-byte) signed or unsigned integers.
+ *
+ * @extends TLObject
+ */
+export class Int extends TLObject {
+    /**
+     * The byte size of a standard 32-bit integer (4 bytes).
+     */
+    static SIZE = 4;
+    /**
+     * Serializes a 32-bit integer into a Buffer.
+     *
+     * @param value - The integer value to write (accepts `number` or `bigint`).
+     * @param signed - Set to `true` if the integer is signed; set to `false` if unsigned. Defaults to `true`.
+     * @param little - Set to `true` to write in little-endian format; set to `false` for big-endian. Defaults to `true`.
+     * @returns A Buffer containing the 4-byte representation of the integer.
+     */
+    static write(value, signed = true, little = true) {
+        const buffer = Buffer.alloc(Int.SIZE);
+        if (signed) {
+            if (little) {
+                buffer.writeInt32LE(Number(value));
+            }
+            else {
+                buffer.writeInt32BE(Number(value));
+            }
+        }
+        else {
+            if (little) {
+                buffer.writeUInt32LE(Number(value));
+            }
+            else {
+                buffer.writeUInt32BE(Number(value));
+            }
+        }
+        return buffer;
+    }
+    /**
+     * Reads and decodes a 32-bit integer from a binary stream.
+     *
+     * @param data - The `BytesIO` stream to read the integer from.
+     * @param signed - Set to `true` to parse as a signed integer; set to `false` for unsigned. Defaults to `true`.
+     * @param little - Set to `true` to read in little-endian format; set to `false` for big-endian. Defaults to `true`.
+     * @param size - The exact number of bytes to read from the stream. Defaults to `Int.SIZE`.
+     * @returns A promise resolving to the decoded number.
+     */
+    static async read(data, signed = true, little = true, size = Int.SIZE) {
+        if (signed) {
+            if (little) {
+                return data.readInt32LE(size);
+            }
+            else {
+                return data.readInt32BE(size);
+            }
+        }
+        else {
+            if (little) {
+                return data.readUInt32LE(size);
+            }
+            else {
+                return data.readUInt32BE(size);
+            }
+        }
+    }
+}
+/**
+ * Serializer and deserializer for 64-bit (8-byte) signed or unsigned integers.
+ *
+ * @remarks
+ * In MTProto, 64-bit integers are heavily used for message IDs, session IDs, chat IDs,
+ * and salt values. Because standard JS numbers only support safe integers up to 53 bits,
+ * this class operates on native JavaScript `bigint` values.
+ *
+ * @extends TLObject
+ */
+export class Long extends TLObject {
+    /**
+     * The byte size of a 64-bit long integer (8 bytes).
+     */
+    static SIZE = 8;
+    /**
+     * Reads and decodes a 64-bit integer from a binary stream.
+     *
+     * @param data - The `BytesIO` stream to read the long integer from.
+     * @param signed - Set to `true` to parse as a signed integer; set to `false` for unsigned. Defaults to `true`.
+     * @param little - Set to `true` to read in little-endian format; set to `false` for big-endian. Defaults to `true`.
+     * @param size - The exact number of bytes to read from the stream. Defaults to `Long.SIZE`.
+     * @returns A promise resolving to the decoded native `bigint`.
+     */
+    static async read(data, signed = true, little = true, size = Long.SIZE) {
+        if (signed) {
+            if (little) {
+                return data.readBigInt64LE(size);
+            }
+            else {
+                return data.readBigInt64BE(size);
+            }
+        }
+        else {
+            if (little) {
+                return data.readBigUInt64LE(size);
+            }
+            else {
+                return data.readBigUInt64BE(size);
+            }
+        }
+    }
+    /**
+     * Serializes a 64-bit integer value into a Buffer.
+     *
+     * @param value - The native `bigint` value to serialize.
+     * @param signed - Set to `true` if the integer is signed; set to `false` if unsigned. Defaults to `true`.
+     * @param little - Set to `true` to write in little-endian format; set to `false` for big-endian. Defaults to `true`.
+     * @returns A Buffer containing the 8-byte representation of the 64-bit integer.
+     */
+    static write(value, signed = true, little = true) {
+        const buffer = Buffer.alloc(Long.SIZE);
+        if (signed) {
+            if (little) {
+                buffer.writeBigInt64LE(BigInt(value));
+            }
+            else {
+                buffer.writeBigInt64BE(BigInt(value));
+            }
+        }
+        else {
+            if (little) {
+                buffer.writeBigUInt64LE(BigInt(value));
+            }
+            else {
+                buffer.writeBigUInt64BE(BigInt(value));
+            }
+        }
+        return buffer;
+    }
+}
+/**
+ * Serializer and deserializer for 128-bit (16-byte) integers.
+ *
+ * @remarks
+ * Used in MTProto cryptographic handshakes, secure nonces, and session key generation.
+ * Operates on native JavaScript `bigint` values.
+ *
+ * @extends Long
+ */
+export class Int128 extends Long {
+    /**
+     * The byte size of a 128-bit integer (16 bytes).
+     */
+    static SIZE = 16;
+    /**
+     * Reads and decodes a 128-bit integer from a binary stream.
+     *
+     * @param data - The `BytesIO` stream to read the integer from.
+     * @param signed - Set to `true` to parse as signed; set to `false` for unsigned. Defaults to `true`.
+     * @param little - Set to `true` to read in little-endian format; set to `false` for big-endian. Defaults to `true`.
+     * @param size - The exact number of bytes to read from the stream. Defaults to `Int128.SIZE`.
+     * @returns A promise resolving to the decoded native `bigint`.
+     */
+    static async read(data, signed = true, little = true, size = Int128.SIZE) {
+        return toBigint(data.read(size), little, signed);
+    }
+    /**
+     * Serializes a 128-bit integer into a Buffer.
+     *
+     * @param value - The native `bigint` to serialize.
+     * @param _signed - Unused parameter.
+     * @param _little - Unused parameter.
+     * @returns A Buffer containing the 16-byte representation of the 128-bit integer.
+     */
+    static write(value, _signed = true, _little = true) {
+        const bytesArray = [];
+        for (let i = 0; i < Int128.SIZE; i++) {
+            let shift = value >> BigInt(Long.SIZE * i);
+            shift &= BigInt(255);
+            bytesArray[i] = Number(String(shift));
+        }
+        return Buffer.from(bytesArray);
+    }
+}
+/**
+ * Serializer and deserializer for 256-bit (32-byte) integers.
+ *
+ * @remarks
+ * Extensively used in cryptographic tasks, DH (Diffie-Hellman) parameters, and authorization key hashing.
+ * Operates on native JavaScript `bigint` values.
+ *
+ * @extends Long
+ */
+export class Int256 extends Long {
+    /**
+     * The byte size of a 256-bit integer (32 bytes).
+     */
+    static SIZE = 32;
+    /**
+     * Reads and decodes a 256-bit integer from a binary stream.
+     *
+     * @param data - The `BytesIO` stream to read the integer from.
+     * @param signed - Set to `true` to parse as signed; set to `false` for unsigned. Defaults to `true`.
+     * @param little - Set to `true` to read in little-endian format; set to `false` for big-endian. Defaults to `true`.
+     * @param size - The exact number of bytes to read from the stream. Defaults to `Int256.SIZE`.
+     * @returns A promise resolving to the decoded native `bigint`.
+     */
+    static async read(data, signed = true, little = true, size = Int256.SIZE) {
+        return Int128.read(data, signed, little, size);
+    }
+    /**
+     * Serializes a 256-bit integer into a Buffer.
+     *
+     * @param value - The native `bigint` to serialize.
+     * @param _signed - Unused parameter.
+     * @param _little - Unused parameter.
+     * @returns A Buffer containing the 32-byte representation of the 256-bit integer.
+     */
+    static write(value, _signed = true, _little = true) {
+        const bytesArray = [];
+        for (let i = 0; i < Int256.SIZE; i++) {
+            let shift = value >> BigInt(Long.SIZE * i);
+            shift &= BigInt(255);
+            bytesArray[i] = Number(String(shift));
+        }
+        return Buffer.from(bytesArray);
+    }
+}

package/dist/src/raw/core/primitive/String.d.ts

@@ -0,0 +1,37 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { TLObject } from '../TLObject.js';
+import { BytesIO, Buffer } from '../../../deps.js';
+/**
+ * Serializer and deserializer for UTF-8 encoded strings.
+ *
+ * @remarks
+ * In MTProto, strings are treated as standard UTF-8 text and are packed/aligned using
+ * the same length-prefix and padding logic as the {@link Bytes} primitive class.
+ *
+ * @extends TLObject
+ */
+export declare class String extends TLObject {
+    /**
+     * Serializes a JavaScript string into a UTF-8 length-prefixed and padded Buffer.
+     *
+     * @param value - The input string to serialize.
+     * @returns A Buffer containing the encoded string.
+     */
+    static write(value: string): Buffer;
+    /**
+     * Reads, aligns, and decodes a UTF-8 string from a binary stream.
+     *
+     * @param data - The `BytesIO` stream containing the serialized string.
+     * @param _args - Unused additional parameters.
+     * @returns A promise resolving to the decoded native JavaScript string.
+     */
+    static read(data: BytesIO, ..._args: Array<any>): Promise<string>;
+}

package/dist/src/raw/core/primitive/String.js

@@ -0,0 +1,42 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { TLObject } from '../TLObject.js';
+import { Buffer } from '../../../deps.js';
+import { Bytes } from './Bytes.js';
+/**
+ * Serializer and deserializer for UTF-8 encoded strings.
+ *
+ * @remarks
+ * In MTProto, strings are treated as standard UTF-8 text and are packed/aligned using
+ * the same length-prefix and padding logic as the {@link Bytes} primitive class.
+ *
+ * @extends TLObject
+ */
+export class String extends TLObject {
+    /**
+     * Serializes a JavaScript string into a UTF-8 length-prefixed and padded Buffer.
+     *
+     * @param value - The input string to serialize.
+     * @returns A Buffer containing the encoded string.
+     */
+    static write(value) {
+        return Bytes.write(Buffer.from(value, 'utf8'));
+    }
+    /**
+     * Reads, aligns, and decodes a UTF-8 string from a binary stream.
+     *
+     * @param data - The `BytesIO` stream containing the serialized string.
+     * @param _args - Unused additional parameters.
+     * @returns A promise resolving to the decoded native JavaScript string.
+     */
+    static async read(data, ..._args) {
+        return (await Bytes.read(data)).toString('utf8');
+    }
+}

package/dist/src/raw/core/primitive/Vector.d.ts

@@ -0,0 +1,56 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { TLObject } from '../TLObject.js';
+import { BytesIO, Buffer } from '../../../deps.js';
+/**
+ * Serializer and deserializer for generic, strongly-typed vectors (arrays) of MTProto objects.
+ *
+ * @remarks
+ * In MTProto, vectors can be either "boxed" (serialized with the explicit `Vector.ID` class tag prefix)
+ * or "bare" (serialized directly as an array of items without the leading class ID). This class supports both
+ * boxed serialization/deserialization and bare item parsers.
+ *
+ * @extends TLObject
+ */
+export declare class Vector extends TLObject {
+    /**
+     * The unique class ID identifier representing `Vector` (0x1cb5c415).
+     */
+    static ID: number;
+    /**
+     * Serializes an array of values into an MTProto-boxed vector Buffer.
+     *
+     * @param value - The array of elements to serialize.
+     * @param tl - An optional custom type layer descriptor supplying a dedicated elements `write` method.
+     * @returns A Buffer containing the boxed vector bytes.
+     */
+    static write(value: Array<any>, tl?: any): Buffer;
+    /**
+     * Helper deserializer reading a single "bare" item from a stream based on a calculated element byte size.
+     *
+     * @param data - The `BytesIO` stream to read from.
+     * @param size - The precalculated byte size of a single element.
+     * @returns A promise resolving to the parsed element.
+     */
+    static readBare(data: BytesIO, size: number): Promise<any>;
+    /**
+     * Reads, unpacks, and deserializes a strongly-typed boxed vector from a binary stream.
+     *
+     * @remarks
+     * This method first extracts the element count. If a specialized element parser (`tl`) is provided,
+     * it uses it. Otherwise, it calculates the average element byte size dynamically using the remaining
+     * buffer capacity and delegates bare item parsing to {@link readBare}.
+     *
+     * @param data - The `BytesIO` stream containing the serialized vector.
+     * @param tl - An optional custom type layer descriptor supplying a dedicated elements `read` method.
+     * @returns A promise resolving to an array of parsed elements.
+     */
+    static read(data: BytesIO, tl?: any): Promise<Array<any>>;
+}

package/dist/src/raw/core/primitive/Vector.js

@@ -0,0 +1,93 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { TLObject } from '../TLObject.js';
+import { BytesIO, Buffer } from '../../../deps.js';
+import { Int, Long } from './index.js';
+/**
+ * Serializer and deserializer for generic, strongly-typed vectors (arrays) of MTProto objects.
+ *
+ * @remarks
+ * In MTProto, vectors can be either "boxed" (serialized with the explicit `Vector.ID` class tag prefix)
+ * or "bare" (serialized directly as an array of items without the leading class ID). This class supports both
+ * boxed serialization/deserialization and bare item parsers.
+ *
+ * @extends TLObject
+ */
+export class Vector extends TLObject {
+    /**
+     * The unique class ID identifier representing `Vector` (0x1cb5c415).
+     */
+    static ID = 0x1cb5c415;
+    /**
+     * Serializes an array of values into an MTProto-boxed vector Buffer.
+     *
+     * @param value - The array of elements to serialize.
+     * @param tl - An optional custom type layer descriptor supplying a dedicated elements `write` method.
+     * @returns A Buffer containing the boxed vector bytes.
+     */
+    static write(value, tl) {
+        const bytes = new BytesIO();
+        bytes.write(Int.write(Vector.ID, false));
+        bytes.write(Int.write(value.length));
+        for (const i of value) {
+            if (tl) {
+                bytes.write(tl.write(i));
+            }
+            else {
+                bytes.write(i.write());
+            }
+        }
+        return Buffer.from(bytes.buffer);
+    }
+    /**
+     * Helper deserializer reading a single "bare" item from a stream based on a calculated element byte size.
+     *
+     * @param data - The `BytesIO` stream to read from.
+     * @param size - The precalculated byte size of a single element.
+     * @returns A promise resolving to the parsed element.
+     */
+    static async readBare(data, size) {
+        if (size === 4) {
+            return await Int.read(data);
+        }
+        if (size === 8) {
+            return await Long.read(data);
+        }
+        return await TLObject.read(data);
+    }
+    /**
+     * Reads, unpacks, and deserializes a strongly-typed boxed vector from a binary stream.
+     *
+     * @remarks
+     * This method first extracts the element count. If a specialized element parser (`tl`) is provided,
+     * it uses it. Otherwise, it calculates the average element byte size dynamically using the remaining
+     * buffer capacity and delegates bare item parsing to {@link readBare}.
+     *
+     * @param data - The `BytesIO` stream containing the serialized vector.
+     * @param tl - An optional custom type layer descriptor supplying a dedicated elements `read` method.
+     * @returns A promise resolving to an array of parsed elements.
+     */
+    static async read(data, tl) {
+        const results = [];
+        const count = await Int.read(data);
+        const left = Buffer.byteLength(data.read());
+        const size = count ? left / count : 0;
+        data.seek(-left, 1);
+        for (let i = 0; i < count; i++) {
+            if (tl) {
+                results.push(await tl.read(data));
+            }
+            else {
+                results.push(await Vector.readBare(data, size));
+            }
+        }
+        return results;
+    }
+}

package/dist/src/raw/core/primitive/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+/**
+ * Re-exports all raw primitive encoders/decoders for MTProto integers,
+ * variable-length bytes, floats, strings, booleans, and vectors.
+ */
+export { Int, Long, Int128, Int256 } from './Int.js';
+export { Bytes } from './Bytes.js';
+export { String } from './String.js';
+export { Bool, BoolTrue, BoolFalse } from './Bool.js';
+export { Vector } from './Vector.js';
+export { Double } from './Double.js';
+export { Float } from './Float.js';

package/dist/src/raw/core/primitive/index.js

@@ -0,0 +1,20 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+/**
+ * Re-exports all raw primitive encoders/decoders for MTProto integers,
+ * variable-length bytes, floats, strings, booleans, and vectors.
+ */
+export { Int, Long, Int128, Int256 } from './Int.js';
+export { Bytes } from './Bytes.js';
+export { String } from './String.js';
+export { Bool, BoolTrue, BoolFalse } from './Bool.js';
+export { Vector } from './Vector.js';
+export { Double } from './Double.js';
+export { Float } from './Float.js';

package/dist/src/raw/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+/**
+ * Main exports for compiled TLObjects, zlib packer, MTProto envelopes,
+ * and decrypted secret chat message containers.
+ */
+export { Raw } from './Raw.js';
+export { AllTLObject } from './All.js';
+export { Primitive, TLObject, GzipPacked, Message, MsgContainer } from './core/index.js';
+export { SecretChatMessage, SecretChatMessageService, UpdateSecretChatMessage, TypeTGenerate, } from './UpdateSecretChat.js';

package/dist/src/raw/index.js

@@ -0,0 +1,17 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+/**
+ * Main exports for compiled TLObjects, zlib packer, MTProto envelopes,
+ * and decrypted secret chat message containers.
+ */
+export { Raw } from './Raw.js';
+export { AllTLObject } from './All.js';
+export { Primitive, TLObject, GzipPacked, Message, MsgContainer } from './core/index.js';
+export { SecretChatMessage, SecretChatMessageService, UpdateSecretChatMessage, } from './UpdateSecretChat.js';

package/package.json

@@ -1,50 +1,54 @@
-{
-  "name": "@tgsnake/skema",
-  "version": "1.12.0",
-  "description": "A compiled Telegram TL Schema and Telegram errors Schema into usable JavaScript classes with full TypeScript support",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "packageManager": "yarn@4.9.2",
-  "homepage": "https://tgsnake.js.org",
-  "keywords": [
-    "tgsnake",
-    "mtproto",
-    "telegram"
-  ],
-  "bugs": "https://github.com/tgsnake/skema/issues",
-  "repository": "https://github.com/tgsnake/skema",
-  "author": "butthx",
-  "files": [
-    "dist/**/**"
-  ],
-  "license": "MIT",
-  "engineStrict": true,
-  "engines": {
-    "node": ">=12.0.0",
-    "npm": ">=6.0.0",
-    "yarn": ">=1.0.0",
-    "deno": ">=1.0.0",
-    "bun": ">=1.0.0"
-  },
-  "scripts": {
-    "build": "tsc",
-    "build:api": "node ./generator/api",
-    "build:sync": "node ./generator/sync-tl",
-    "build:error": "node ./generator/error",
-    "build:docs": "typedoc --tsconfig tsconfig.json --out docs src/index.ts",
-    "prepare": "yarn build",
-    "prettier": "NODE_OPTIONS=--max_old_space_size=4096 prettier -w ."
-  },
-  "devDependencies": {
-    "@types/bun": "^1.2.18",
-    "@types/node": "^24.0.13",
-    "prettier": "^3.6.2",
-    "typedoc": "^0.28.7",
-    "typescript": "^5.8.3"
-  },
-  "dependencies": {
-    "@tgsnake/bytesio": "^1.0.0",
-    "@tgsnake/log": "^1.6.4",
-    "big-integer": "^1.6.52"
-  }
-}
+{
+  "name": "@tgsnake/skema",
+  "version": "2.0.0-browser.0",
+  "description": "A compiled Telegram TL Schema and Telegram errors Schema into usable JavaScript classes with full TypeScript support",
+  "main": "dist/mod.js",
+  "types": "dist/mod.d.ts",
+  "type": "module",
+  "packageManager": "yarn@4.9.2",
+  "homepage": "https://tgsnake.js.org",
+  "keywords": [
+    "tgsnake",
+    "mtproto",
+    "telegram"
+  ],
+  "bugs": "https://github.com/tgsnake/skema/issues",
+  "repository": "https://github.com/tgsnake/skema",
+  "author": "butthx",
+  "files": [
+    "dist/**/**"
+  ],
+  "license": "MIT",
+  "engineStrict": true,
+  "engines": {
+    "node": ">=22.0.0",
+    "npm": ">=6.0.0",
+    "yarn": ">=1.0.0",
+    "deno": ">=1.0.0",
+    "bun": ">=1.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:api": "node ./generator/api",
+    "build:sync": "node ./generator/sync-tl",
+    "build:error": "node ./generator/error",
+    "build:jsr": "node ./generator/jsr_version/index.js",
+    "build:docs": "typedoc --tsconfig tsconfig.json --out docs src/index.ts",
+    "prepare": "yarn build",
+    "prettier": "NODE_OPTIONS=--max_old_space_size=4096 prettier -w ."
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/node": "^25.9.1",
+    "prettier": "^3.8.3",
+    "typedoc": "^0.28.19",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "@tgsnake/bytesio": "browser",
+    "@tgsnake/log": "browser",
+    "big-integer": "^1.6.52",
+    "browserify-zlib": "^0.2.0",
+    "buffer": "^6.0.3"
+  }
+}

package/dist/Logger.d.ts

@@ -1,3 +0,0 @@
-import { Logger } from './deps.js';
-declare const log: Logger;
-export { log as Logger };

package/dist/Logger.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = void 0;
-const deps_js_1 = require("./deps.js");
-const log = new deps_js_1.Logger({
-    name: '@tgsnake/skema',
-    level: ['debug'],
-});
-exports.Logger = log;