@mtkruto/node 0.0.820 → 0.0.822

package/script/deps/deno.land/std@0.186.0/testing/asserts.d.ts

@@ -0,0 +1,284 @@
+export declare class AssertionError extends Error {
+    name: string;
+    constructor(message: string);
+}
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ */
+export declare function equal(c: unknown, d: unknown): boolean;
+/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;
+/** Make an assertion, error will be thrown if `expr` have truthy value. */
+type Falsy = false | 0 | 0n | "" | null | undefined;
+export declare function assertFalse(expr: unknown, msg?: string): asserts expr is Falsy;
+/**
+ * Make an assertion that `actual` and `expected` are equal, deeply. If not
+ * deeply equal, then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("example", function (): void {
+ *   assertEquals("world", "world");
+ *   assertEquals({ hello: "world" }, { hello: "world" });
+ * });
+ * ```
+ */
+export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are not equal, deeply.
+ * If not then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * assertNotEquals<number>(1, 2)
+ * ```
+ */
+export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are strictly equal. If
+ * not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("isStrictlyEqual", function (): void {
+ *   const a = {};
+ *   const b = a;
+ *   assertStrictEquals(a, b);
+ * });
+ *
+ * // This test fails
+ * Deno.test("isNotStrictlyEqual", function (): void {
+ *   const a = {};
+ *   const b = {};
+ *   assertStrictEquals(a, b);
+ * });
+ * ```
+ */
+export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
+/**
+ * Make an assertion that `actual` and `expected` are not strictly equal.
+ * If the values are strictly equal then throw.
+ *
+ * ```ts
+ * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * assertNotStrictEquals(1, 1)
+ * ```
+ */
+export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers through
+ * a given tolerance. It can be used to take into account IEEE-754 double-precision
+ * floating-point representation limitations.
+ * If the values are not almost equal then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertAlmostEquals, assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * assertAlmostEquals(0.1, 0.2);
+ *
+ * // Using a custom tolerance value
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16);
+ * assertThrows(() => assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17));
+ * ```
+ */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
+type AnyConstructor = new (...args: any[]) => any;
+type GetConstructorType<T extends AnyConstructor> = T extends new (...args: any) => infer C ? C : never;
+/**
+ * Make an assertion that `obj` is an instance of `type`.
+ * If not then throw.
+ */
+export declare function assertInstanceOf<T extends AnyConstructor>(actual: unknown, expectedType: T, msg?: string): asserts actual is GetConstructorType<T>;
+/**
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ */
+export declare function assertNotInstanceOf<A, T>(actual: A, unexpectedType: new (...args: any[]) => T, msg?: string): asserts actual is Exclude<A, T>;
+/**
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ */
+export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ */
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
+/**
+ * Make an assertion that `actual` includes the `expected` values.
+ * If not then an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertArrayIncludes } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * assertArrayIncludes<number>([1, 2], [2])
+ * ```
+ */
+export declare function assertArrayIncludes<T>(actual: ArrayLike<T>, expected: ArrayLike<T>, msg?: string): void;
+/**
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ */
+export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ */
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
+/**
+ * Make an assertion that `actual` object is a subset of `expected` object, deeply.
+ * If not, then throw.
+ */
+export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>, msg?: string): void;
+/**
+ * Forcefully throws a failed assertion
+ */
+export declare function fail(msg?: string): never;
+/**
+ * Make an assertion that `error` is an `Error`.
+ * If not then an error will be thrown.
+ * An error class and a string that should be included in the
+ * error message can also be asserted.
+ */
+export declare function assertIsError<E extends Error = Error>(error: unknown, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): asserts error is E;
+/**
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws.
+ *
+ * @example
+ * ```ts
+ * import { assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("doesThrow", function (): void {
+ *   assertThrows((): void => {
+ *     throw new TypeError("hello world!");
+ *   });
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", function (): void {
+ *   assertThrows((): void => {
+ *     console.log("Hello world");
+ *   });
+ * });
+ * ```
+ */
+export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
+/**
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws. An error class and a string that should be included in the
+ * error message can also be asserted.
+ *
+ * @example
+ *
+ * ```ts
+ * import { assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("doesThrow", function (): void {
+ *   assertThrows((): void => {
+ *     throw new TypeError("hello world!");
+ *   }, TypeError);
+ *   assertThrows(
+ *     (): void => {
+ *       throw new TypeError("hello world!");
+ *     },
+ *     TypeError,
+ *     "hello",
+ *   );
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", function (): void {
+ *   assertThrows((): void => {
+ *     console.log("Hello world");
+ *   });
+ * });
+ * ```
+ */
+export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ *
+ * @example
+ * ```ts
+ * import { assertRejects } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("doesThrow", async function () {
+ *   await assertRejects(
+ *     async () => {
+ *       throw new TypeError("hello world!");
+ *     },
+ *   );
+ *   await assertRejects(
+ *     async () => {
+ *       return Promise.reject(new Error());
+ *     },
+ *   );
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", async function () {
+ *   await assertRejects(
+ *     async () => {
+ *       console.log("Hello world");
+ *     },
+ *   );
+ * });
+ * ```
+ */
+export declare function assertRejects(fn: () => PromiseLike<unknown>, msg?: string): Promise<unknown>;
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ * If it does not, then it throws. An error class and a string that should be
+ * included in the error message can also be asserted.
+ *
+ * @example
+ * ```ts
+ * import { assertRejects } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("doesThrow", async function () {
+ *   await assertRejects(async () => {
+ *     throw new TypeError("hello world!");
+ *   }, TypeError);
+ *   await assertRejects(
+ *     async () => {
+ *       throw new TypeError("hello world!");
+ *     },
+ *     TypeError,
+ *     "hello",
+ *   );
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", async function () {
+ *   await assertRejects(
+ *     async () => {
+ *       console.log("Hello world");
+ *     },
+ *   );
+ * });
+ * ```
+ */
+export declare function assertRejects<E extends Error = Error>(fn: () => PromiseLike<unknown>, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;
+/** Use this to stub out methods that will throw when invoked. */
+export declare function unimplemented(msg?: string): never;
+/** Use this to assert unreachable code. */
+export declare function unreachable(): never;
+export {};

package/script/deps/deno.land/x/crc32@v0.2.0/mod.d.ts

@@ -0,0 +1,15 @@
+export declare function crc32(arr: Uint8Array | string): string;
+export declare class Crc32Stream {
+    #private;
+    private bytes;
+    private poly;
+    private crc;
+    private encoder;
+    constructor();
+    get crc32(): string;
+    reset(): void;
+    append(arr: Uint8Array | string): string;
+}
+export declare function numberToHex(n: number): string;
+export declare function hexToUint8Array(str: string): Uint8Array;
+export declare function uint8ArrayToHex(bytes: Uint8Array): string;

package/script/deps/deno.land/x/tgcrypto@0.1.3/mod.d.ts

@@ -0,0 +1,47 @@
+export declare function init(): Promise<void>;
+/**
+ * Performs IGE-256 encryption.
+ *
+ * @param data The unencrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 32-byte initialization vector
+ */
+export declare function ige256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+/**
+ * Performs IGE-256 decryption.
+ *
+ * @param data The encrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 32-byte initialization vector
+ */
+export declare function ige256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+/**
+ * Performs CTR-256 encryption.
+ *
+ * @param data The data, larger than a byte
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ * @param state 1-byte state
+ */
+export declare function ctr256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): [Uint8Array, Uint8Array, Uint8Array];
+/**
+ * Alias of `ctr256Encrypt`
+ */
+export declare function ctr256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): [Uint8Array, Uint8Array, Uint8Array];
+/**
+ * Performs CBC-256 encryption.
+ *
+ * @param data The unencrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ */
+export declare function cbc256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+/**
+ * Performs CBC-256 decryption.
+ *
+ * @param data The encrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ */
+export declare function cbc256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+export declare function factorize(pq: bigint): [bigint, bigint];

package/script/deps/deno.land/x/tgcrypto@0.1.3/tgcrypto.d.ts

@@ -0,0 +1,2 @@
+export default Module;
+declare function Module(Module?: {}): any;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/gzip/gzip.d.ts

@@ -0,0 +1,16 @@
+export declare const DEFAULT_LEVEL = 6;
+export declare function putLong(n: number, arr: number[]): void;
+interface Options {
+    level?: number;
+    timestamp?: number;
+    name?: string;
+}
+export declare function getHeader(options?: Options): Uint8Array;
+export declare function gzip(bytes: Uint8Array, options?: Options): Uint8Array;
+export declare function gunzip(bytes: Uint8Array): Uint8Array;
+export declare function checkHeader(arr: number[]): void;
+export declare function checkTail(arr: number[]): {
+    crc32: number;
+    size: number;
+};
+export {};

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/utils/uint8.d.ts

@@ -0,0 +1 @@
+export declare function concatUint8Array(arr: Uint8Array[]): Uint8Array;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/deflate.d.ts

@@ -0,0 +1,29 @@
+import * as zlibDeflate from "./zlib/deflate.js";
+import ZStream from "./zlib/zstream.js";
+import STATUS from "./zlib/status.js";
+export interface DeflateOptions {
+    level?: number;
+    method?: number;
+    chunkSize?: number;
+    windowBits?: number;
+    memLevel?: number;
+    strategy?: number;
+    to?: string;
+    raw?: boolean;
+    gzip?: boolean;
+    dictionary?: Uint8Array;
+    header?: zlibDeflate.Header;
+}
+export declare class Deflate {
+    err: STATUS;
+    msg: string;
+    ended: boolean;
+    strm: ZStream;
+    _dict_set: boolean;
+    options: any;
+    constructor(options?: DeflateOptions);
+    push(data: Uint8Array, mode: boolean | number): Uint8Array;
+}
+export declare function deflate(input: Uint8Array, options?: DeflateOptions): Uint8Array;
+export declare function deflateRaw(input: Uint8Array, options?: DeflateOptions): Uint8Array;
+export declare function gzip(input: Uint8Array, options?: DeflateOptions): Uint8Array;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/inflate.d.ts

@@ -0,0 +1,23 @@
+import STATUS from "./zlib/status.js";
+import ZStream from "./zlib/zstream.js";
+import GZheader from "./zlib/gzheader.js";
+export interface InflateOptions {
+    windowBits?: number;
+    dictionary?: Uint8Array;
+    chunkSize?: number;
+    to?: string;
+    raw?: boolean;
+}
+export declare class Inflate {
+    err: STATUS;
+    msg: string;
+    ended: boolean;
+    strm: ZStream;
+    options: any;
+    header: GZheader;
+    constructor(options: InflateOptions);
+    push(data: Uint8Array, mode: boolean | number): Uint8Array;
+}
+export declare function inflate(input: Uint8Array, options?: InflateOptions): Uint8Array;
+export declare function inflateRaw(input: Uint8Array, options?: InflateOptions): Uint8Array;
+export declare const gunzip: typeof inflate;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/mod.d.ts

@@ -0,0 +1,2 @@
+export * from "./deflate.js";
+export * from "./inflate.js";

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/adler32.d.ts

@@ -0,0 +1 @@
+export default function adler32(adler: any, buf: any, len: any, pos: any): number;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/crc32.d.ts

@@ -0,0 +1,2 @@
+export declare function makeTable(): number[];
+export declare function crc32(crc: any, buf: any, len: any, pos: any): number;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/deflate.d.ts

@@ -0,0 +1,78 @@
+import { CODE } from "./messages.js";
+import type ZStream from "./zstream.js";
+import STATUS from "./status.js";
+export interface Header {
+    text: boolean;
+    time: number;
+    os: number;
+    extra: string[];
+    name: string;
+    comment: string;
+    hcrc: boolean;
+}
+export declare class DeflateState {
+    strm: ZStream | null;
+    status: number;
+    pending_buf: any;
+    pending_buf_size: number;
+    pending_out: number;
+    pending: number;
+    wrap: number;
+    gzhead: Header | null;
+    gzindex: number;
+    method: number;
+    last_flush: number;
+    w_size: number;
+    w_bits: number;
+    w_mask: number;
+    window: any;
+    window_size: number;
+    prev: any;
+    head: any;
+    ins_h: number;
+    hash_size: number;
+    hash_bits: number;
+    hash_mask: number;
+    hash_shift: number;
+    block_start: number;
+    match_length: number;
+    prev_match: number;
+    match_available: number;
+    strstart: number;
+    match_start: number;
+    lookahead: number;
+    prev_length: number;
+    max_chain_length: number;
+    max_lazy_match: number;
+    level: number;
+    strategy: number;
+    good_match: number;
+    nice_match: number;
+    dyn_ltree: Uint16Array;
+    dyn_dtree: Uint16Array;
+    bl_tree: Uint16Array;
+    l_desc: null;
+    d_desc: null;
+    bl_desc: null;
+    bl_count: Uint16Array;
+    heap: Uint16Array;
+    heap_len: number;
+    heap_max: number;
+    depth: Uint16Array;
+    l_buf: number;
+    lit_bufsize: number;
+    last_lit: number;
+    d_buf: number;
+    opt_len: number;
+    static_len: number;
+    matches: number;
+    insert: number;
+    bi_buf: number;
+    bi_valid: number;
+    constructor();
+}
+export declare function deflateSetHeader(strm: ZStream, head: Header): 0 | -2;
+export declare function deflateInit2(strm: ZStream, level: number, method: number, windowBits: number, memLevel: number, strategy: number): CODE;
+export declare function deflate(strm: ZStream, flush: number): CODE | -2 | STATUS.Z_NO_FLUSH | STATUS.Z_PARTIAL_FLUSH;
+export declare function deflateEnd(strm: ZStream): any;
+export declare function deflateSetDictionary(strm: ZStream, dictionary: Uint8Array): any;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/gzheader.d.ts

@@ -0,0 +1,12 @@
+export default class GZheader {
+    text: number;
+    time: number;
+    xflags: number;
+    os: number;
+    extra: any;
+    extra_len: number;
+    name: string;
+    comment: string;
+    hcrc: number;
+    done: boolean;
+}

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/inffast.d.ts

@@ -0,0 +1 @@
+export default function inflate_fast(strm: any, start: number): void;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/inflate.d.ts

@@ -0,0 +1,47 @@
+import type ZStream from "./zstream.js";
+export declare class InflateState {
+    mode: number;
+    last: boolean;
+    wrap: number;
+    havedict: boolean;
+    flags: number;
+    dmax: number;
+    check: number;
+    total: number;
+    head: null;
+    wbits: number;
+    wsize: number;
+    whave: number;
+    wnext: number;
+    window: null;
+    hold: number;
+    bits: number;
+    length: number;
+    offset: number;
+    extra: number;
+    lencode: null;
+    distcode: null;
+    lenbits: number;
+    distbits: number;
+    ncode: number;
+    nlen: number;
+    ndist: number;
+    have: number;
+    next: null;
+    lens: Uint16Array;
+    work: Uint16Array;
+    lendyn: null;
+    distdyn: null;
+    sane: number;
+    back: number;
+    was: number;
+}
+export declare function inflateResetKeep(strm: ZStream): 0 | -2;
+export declare function inflateReset(strm: ZStream): 0 | -2;
+export declare function inflateReset2(strm: any, windowBits: any): 0 | -2;
+export declare function inflateInit2(strm: ZStream, windowBits: any): number;
+export declare function inflateInit(strm: ZStream): number;
+export declare function inflate(strm: ZStream, flush: any): number;
+export declare function inflateEnd(strm: ZStream): 0 | -2;
+export declare function inflateGetHeader(strm: ZStream, head: any): 0 | -2;
+export declare function inflateSetDictionary(strm: ZStream, dictionary: any): 0 | -2 | -3 | -4;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/inftrees.d.ts

@@ -0,0 +1 @@
+export default function inflate_table(type: any, lens: any, lens_index: any, codes: any, table: any, table_index: any, work: any, opts: any): 0 | 1 | -1;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/messages.d.ts

@@ -0,0 +1,12 @@
+export declare const message: {
+    2: string;
+    1: string;
+    0: string;
+    "-1": string;
+    "-2": string;
+    "-3": string;
+    "-4": string;
+    "-5": string;
+    "-6": string;
+};
+export type CODE = 2 | 1 | 0 | "-1" | "-2" | "-3" | "-4" | "-5" | "-6";

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/status.d.ts

@@ -0,0 +1,30 @@
+declare enum STATUS {
+    Z_NO_FLUSH = 0,
+    Z_PARTIAL_FLUSH = 1,
+    Z_SYNC_FLUSH = 2,
+    Z_FULL_FLUSH = 3,
+    Z_FINISH = 4,
+    Z_BLOCK = 5,
+    Z_TREES = 6,
+    Z_OK = 0,
+    Z_STREAM_END = 1,
+    Z_NEED_DICT = 2,
+    Z_ERRNO = -1,
+    Z_STREAM_ERROR = -2,
+    Z_DATA_ERROR = -3,
+    Z_BUF_ERROR = -5,
+    Z_NO_COMPRESSION = 0,
+    Z_BEST_SPEED = 1,
+    Z_BEST_COMPRESSION = 9,
+    Z_DEFAULT_COMPRESSION = -1,
+    Z_FILTERED = 1,
+    Z_HUFFMAN_ONLY = 2,
+    Z_RLE = 3,
+    Z_FIXED = 4,
+    Z_DEFAULT_STRATEGY = 0,
+    Z_BINARY = 0,
+    Z_TEXT = 1,
+    Z_UNKNOWN = 2,
+    Z_DEFLATED = 8
+}
+export default STATUS;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/trees.d.ts

@@ -0,0 +1,5 @@
+export declare function _tr_init(s: any): void;
+export declare function _tr_stored_block(s: any, buf: any, stored_len: any, last: any): void;
+export declare function _tr_align(s: any): void;
+export declare function _tr_flush_block(s: any, buf: any, stored_len: any, last: any): void;
+export declare function _tr_tally(s: any, dist: any, lc: any): boolean;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/zstream.d.ts

@@ -0,0 +1,14 @@
+export default class ZStream {
+    input: Uint8Array | null;
+    next_in: number;
+    avail_in: number;
+    total_in: number;
+    output: Uint8Array | null;
+    next_out: number;
+    avail_out: number;
+    total_out: number;
+    msg: string;
+    state: any;
+    data_type: number;
+    adler: number;
+}

package/script/deps.d.ts

@@ -0,0 +1,4 @@
+export * from "./deps/deno.land/std@0.186.0/testing/asserts.js";
+export { ctr256Decrypt, ctr256Encrypt, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.1.3/mod.js";
+export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/master/gzip/gzip.js";
+export { Mutex } from "async-mutex";

package/script/mod.d.ts

@@ -0,0 +1,24 @@
+import { checkPassword } from "./utilities/1_password.js";
+import { getRandomId } from "./utilities/0_bigint.js";
+export declare const utils: {
+    checkPassword: typeof checkPassword;
+    getRandomId: typeof getRandomId;
+};
+export { as } from "./tl/1_tl_object.js";
+export * as types from "./tl/2_types.js";
+export * as functions from "./tl/3_functions.js";
+export * from "./tl/4_rpc_result.js";
+export * from "./tl/5_message.js";
+export * from "./tl/6_message_container.js";
+export * from "./client/client_plain.js";
+export * from "./client/client.js";
+export * from "./session/session.js";
+export * from "./session/session_memory.js";
+export * from "./session/session_local_storage.js";
+export * from "./transport/transport_abridged.js";
+export * from "./transport/transport_intermediate.js";
+export * from "./transport/transport.js";
+export * from "./transport/transport_provider.js";
+export * from "./connection/connection.js";
+export * from "./connection/connection_web_socket.js";
+export { DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_INITIAL_DC, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER } from "./constants.js";