@mtkruto/node 0.0.832 → 0.0.835

package/esm/deps/deno.land/std@0.69.0/fmt/colors.js

@@ -0,0 +1,224 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+/** A module to print ANSI terminal colors. Inspired by chalk, kleur, and colors
+ * on npm.
+ *
+ * ```
+ * import { bgBlue, red, bold } from "https://deno.land/std/fmt/colors.ts";
+ * console.log(bgBlue(red(bold("Hello world!"))));
+ * ```
+ *
+ * This module supports `NO_COLOR` environmental variable disabling any coloring
+ * if `NO_COLOR` is set.
+ *
+ * This module is browser compatible. */
+import * as dntShim from "../../../../_dnt.shims.js";
+const noColor = dntShim.dntGlobalThis.Deno?.noColor ?? true;
+let enabled = !noColor;
+export function setColorEnabled(value) {
+    if (noColor) {
+        return;
+    }
+    enabled = value;
+}
+export function getColorEnabled() {
+    return enabled;
+}
+function code(open, close) {
+    return {
+        open: `\x1b[${open.join(";")}m`,
+        close: `\x1b[${close}m`,
+        regexp: new RegExp(`\\x1b\\[${close}m`, "g"),
+    };
+}
+function run(str, code) {
+    return enabled
+        ? `${code.open}${str.replace(code.regexp, code.open)}${code.close}`
+        : str;
+}
+export function reset(str) {
+    return run(str, code([0], 0));
+}
+export function bold(str) {
+    return run(str, code([1], 22));
+}
+export function dim(str) {
+    return run(str, code([2], 22));
+}
+export function italic(str) {
+    return run(str, code([3], 23));
+}
+export function underline(str) {
+    return run(str, code([4], 24));
+}
+export function inverse(str) {
+    return run(str, code([7], 27));
+}
+export function hidden(str) {
+    return run(str, code([8], 28));
+}
+export function strikethrough(str) {
+    return run(str, code([9], 29));
+}
+export function black(str) {
+    return run(str, code([30], 39));
+}
+export function red(str) {
+    return run(str, code([31], 39));
+}
+export function green(str) {
+    return run(str, code([32], 39));
+}
+export function yellow(str) {
+    return run(str, code([33], 39));
+}
+export function blue(str) {
+    return run(str, code([34], 39));
+}
+export function magenta(str) {
+    return run(str, code([35], 39));
+}
+export function cyan(str) {
+    return run(str, code([36], 39));
+}
+export function white(str) {
+    return run(str, code([37], 39));
+}
+export function gray(str) {
+    return brightBlack(str);
+}
+export function brightBlack(str) {
+    return run(str, code([90], 39));
+}
+export function brightRed(str) {
+    return run(str, code([91], 39));
+}
+export function brightGreen(str) {
+    return run(str, code([92], 39));
+}
+export function brightYellow(str) {
+    return run(str, code([93], 39));
+}
+export function brightBlue(str) {
+    return run(str, code([94], 39));
+}
+export function brightMagenta(str) {
+    return run(str, code([95], 39));
+}
+export function brightCyan(str) {
+    return run(str, code([96], 39));
+}
+export function brightWhite(str) {
+    return run(str, code([97], 39));
+}
+export function bgBlack(str) {
+    return run(str, code([40], 49));
+}
+export function bgRed(str) {
+    return run(str, code([41], 49));
+}
+export function bgGreen(str) {
+    return run(str, code([42], 49));
+}
+export function bgYellow(str) {
+    return run(str, code([43], 49));
+}
+export function bgBlue(str) {
+    return run(str, code([44], 49));
+}
+export function bgMagenta(str) {
+    return run(str, code([45], 49));
+}
+export function bgCyan(str) {
+    return run(str, code([46], 49));
+}
+export function bgWhite(str) {
+    return run(str, code([47], 49));
+}
+export function bgBrightBlack(str) {
+    return run(str, code([100], 49));
+}
+export function bgBrightRed(str) {
+    return run(str, code([101], 49));
+}
+export function bgBrightGreen(str) {
+    return run(str, code([102], 49));
+}
+export function bgBrightYellow(str) {
+    return run(str, code([103], 49));
+}
+export function bgBrightBlue(str) {
+    return run(str, code([104], 49));
+}
+export function bgBrightMagenta(str) {
+    return run(str, code([105], 49));
+}
+export function bgBrightCyan(str) {
+    return run(str, code([106], 49));
+}
+export function bgBrightWhite(str) {
+    return run(str, code([107], 49));
+}
+/* Special Color Sequences */
+function clampAndTruncate(n, max = 255, min = 0) {
+    return Math.trunc(Math.max(Math.min(n, max), min));
+}
+/** Set text color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit */
+export function rgb8(str, color) {
+    return run(str, code([38, 5, clampAndTruncate(color)], 39));
+}
+/** Set background color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit */
+export function bgRgb8(str, color) {
+    return run(str, code([48, 5, clampAndTruncate(color)], 49));
+}
+/** Set text color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ *      rgba24("foo", 0xff00ff);
+ *      rgba24("foo", {r: 255, g: 0, b: 255});
+ */
+export function rgb24(str, color) {
+    if (typeof color === "number") {
+        return run(str, code([38, 2, (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff], 39));
+    }
+    return run(str, code([
+        38,
+        2,
+        clampAndTruncate(color.r),
+        clampAndTruncate(color.g),
+        clampAndTruncate(color.b),
+    ], 39));
+}
+/** Set background color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ *      bgRgba24("foo", 0xff00ff);
+ *      bgRgba24("foo", {r: 255, g: 0, b: 255});
+ */
+export function bgRgb24(str, color) {
+    if (typeof color === "number") {
+        return run(str, code([48, 2, (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff], 49));
+    }
+    return run(str, code([
+        48,
+        2,
+        clampAndTruncate(color.r),
+        clampAndTruncate(color.g),
+        clampAndTruncate(color.b),
+    ], 49));
+}
+// https://github.com/chalk/ansi-regex/blob/2b56fb0c7a07108e5b54241e8faec160d393aedb/index.js
+const ANSI_PATTERN = new RegExp([
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))",
+].join("|"), "g");
+export function stripColor(string) {
+    return string.replace(ANSI_PATTERN, "");
+}

package/esm/deps/raw.githubusercontent.com/MTKruto/debug/master/colors.d.ts

@@ -0,0 +1,3 @@
+export type ColorFunction = (message: string) => string[];
+export declare const colorFunctions: ColorFunction[];
+export declare function generateColor(message: string): ColorFunction;

package/esm/deps/raw.githubusercontent.com/MTKruto/debug/master/colors.js

@@ -0,0 +1,71 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { colors } from "./deps.js";
+// @ts-ignore: lib
+const isBrowser = typeof dntShim.Deno === "undefined" &&
+    // @ts-ignore: lib
+    typeof process === "undefined" && typeof dntShim.dntGlobalThis !== "undefined" &&
+    // @ts-ignore: lib
+    typeof document !== "undefined";
+export const colorFunctions = [
+    (v) => {
+        if (isBrowser) {
+            return [`%c${v}`, "color: red"];
+        }
+        else {
+            return [colors.red(v)];
+        }
+    },
+    (v) => {
+        if (isBrowser) {
+            return [`%c${v}`, "color: green"];
+        }
+        else {
+            return [colors.green(v)];
+        }
+    },
+    (v) => {
+        if (isBrowser) {
+            return [`%c${v}`, "color: yellow"];
+        }
+        else {
+            return [colors.yellow(v)];
+        }
+    },
+    (v) => {
+        if (isBrowser) {
+            return [`%c${v}`, "color: blue"];
+        }
+        else {
+            return [colors.blue(v)];
+        }
+    },
+    (v) => {
+        if (isBrowser) {
+            return [`%c${v}`, "color: magenta"];
+        }
+        else {
+            return [colors.magenta(v)];
+        }
+    },
+    (v) => {
+        if (isBrowser) {
+            return [`%c${v}`, "color: cyan"];
+        }
+        else {
+            return [colors.cyan(v)];
+        }
+    },
+];
+function hashCode(s) {
+    let h = 0;
+    const l = s.length;
+    let i = 0;
+    if (l > 0)
+        while (i < l)
+            h = ((h << 5) - h + s.charCodeAt(i++)) | 0;
+    return h;
+}
+export function generateColor(message) {
+    const hash = Math.abs(hashCode(message));
+    return colorFunctions[hash % colorFunctions.length];
+}

package/esm/deps/raw.githubusercontent.com/MTKruto/debug/master/debug.d.ts

@@ -0,0 +1,22 @@
+import { ColorFunction } from "./colors.js";
+export interface Debug {
+    (fmt: string, ...args: unknown[]): void;
+    self: Debugger;
+}
+export declare class Debugger {
+    manager: DebugManager;
+    ns: string;
+    color: ColorFunction;
+    last: number;
+    enabled: boolean;
+    constructor(manager: DebugManager, namespace: string);
+    log(fmt: string, ...args: unknown[]): void;
+}
+declare class DebugManager {
+    debuggers: Map<string, Debugger>;
+    enabled: RegExp[];
+    constructor(enabled?: RegExp[]);
+}
+export declare function withoutEnv(enabled?: RegExp[] | string): void;
+export declare function debug(namespace: string): Debug;
+export {};

package/esm/deps/raw.githubusercontent.com/MTKruto/debug/master/debug.js

@@ -0,0 +1,112 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { generateColor } from "./colors.js";
+import { format } from "./format.js";
+export class Debugger {
+    constructor(manager, namespace) {
+        Object.defineProperty(this, "manager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "color", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "last", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "enabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.manager = manager;
+        this.ns = namespace;
+        this.color = generateColor(namespace);
+        this.last = 0;
+        this.enabled = manager.enabled.some((r) => r.test(namespace));
+    }
+    log(fmt, ...args) {
+        if (!this.enabled)
+            return;
+        const diff = Date.now() - (this.last || Date.now());
+        fmt = format(fmt, ...args);
+        console.debug(...this.color(this.ns), fmt, ...this.color(`+${diff}ms`));
+        this.last = Date.now();
+    }
+}
+class DebugManager {
+    constructor(enabled) {
+        Object.defineProperty(this, "debuggers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "enabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.debuggers = new Map();
+        this.enabled = enabled ?? [];
+    }
+}
+function extract(opts) {
+    if (!opts || opts.length === 0)
+        return [];
+    opts = opts.replace(/\s/g, "").replace(/\*/g, ".+");
+    return opts.split(",").map((rule) => new RegExp(`^${rule}$`));
+}
+let manager;
+export function withoutEnv(enabled) {
+    if (!enabled)
+        enabled = [];
+    if (typeof enabled === "string")
+        enabled = extract(enabled);
+    manager = new DebugManager(enabled);
+}
+// @ts-ignore: lib
+const isDeno = typeof dntShim.Deno !== "undefined" &&
+    typeof dntShim.dntGlobalThis !== "undefined";
+// @ts-ignore: lib
+const isNode = typeof process !== "undefined" &&
+    typeof dntShim.dntGlobalThis === "undefined";
+function getOpts() {
+    if (isDeno) {
+        // @ts-ignore: lib
+        return dntShim.Deno.env.get("DEBUG");
+    }
+    else if (isNode) {
+        // @ts-ignore: lib
+        return process.env.DEBUG;
+    }
+    else {
+        // @ts-ignore: lib
+        return globalThis.DEBUG;
+    }
+}
+export function debug(namespace) {
+    if (!manager)
+        manager = new DebugManager(extract(getOpts()));
+    const dbg = new Debugger(manager, namespace);
+    manager.debuggers.set(namespace, dbg);
+    const de = Object.assign(dbg.log.bind(dbg), {
+        self: dbg,
+    });
+    return de;
+}

package/esm/deps/raw.githubusercontent.com/MTKruto/debug/master/deps.d.ts

@@ -0,0 +1,2 @@
+export * as colors from "../../../../deno.land/std@0.69.0/fmt/colors.js";
+export { default as inspect } from "object-inspect";

package/esm/deps/raw.githubusercontent.com/MTKruto/debug/master/deps.js

@@ -0,0 +1,2 @@
+export * as colors from "../../../../deno.land/std@0.69.0/fmt/colors.js";
+export { default as inspect } from "object-inspect";

package/esm/deps/raw.githubusercontent.com/MTKruto/debug/master/format.d.ts

@@ -0,0 +1 @@
+export declare function format(f: string, ...args: unknown[]): string;

package/esm/deps/raw.githubusercontent.com/MTKruto/debug/master/format.js

@@ -0,0 +1,39 @@
+import { inspect } from "./deps.js";
+export function format(f, ...args) {
+    let i = 0;
+    const len = args.length;
+    let str = String(f).replace(/%[sdjoO%]/g, (x) => {
+        if (x === "%%")
+            return "%";
+        if (i >= len)
+            return x;
+        switch (x) {
+            case "%s":
+                return String(args[i++]);
+            case "%d":
+                return Number(args[i++]).toString();
+            case "%o":
+                return inspect(args[i++]).split("\n").map((_) => _.trim()).join(" ");
+            case "%O":
+                return inspect(args[i++]);
+            case "%j":
+                try {
+                    return JSON.stringify(args[i++]);
+                }
+                catch {
+                    return "[Circular]";
+                }
+            default:
+                return x;
+        }
+    });
+    for (const x of args.splice(i)) {
+        if (x === null || !(typeof x === "object" && x !== null)) {
+            str += " " + x;
+        }
+        else {
+            str += " " + inspect(x);
+        }
+    }
+    return str;
+}

package/esm/deps/raw.githubusercontent.com/MTKruto/debug/master/mod.d.ts

@@ -0,0 +1 @@
+export * from "./debug.js";

package/esm/deps/raw.githubusercontent.com/MTKruto/debug/master/mod.js

@@ -0,0 +1 @@
+export * from "./debug.js";

package/esm/deps.d.ts

@@ -3,3 +3,5 @@ export { ctr256Decrypt, ctr256Encrypt, factorize, ige256Decrypt, ige256Encrypt,
 export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/master/gzip/gzip.js";
 export { Mutex } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
+import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/master/mod.js";
+export declare const debug: typeof debug_;

package/esm/deps.js

@@ -3,3 +3,5 @@ export { ctr256Decrypt, ctr256Encrypt, factorize, ige256Decrypt, ige256Encrypt,
 export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/master/gzip/gzip.js";
 export { Mutex } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
+import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/master/mod.js";
+export const debug = (v) => debug_(`mtkruto__${v}`);

package/esm/storage/storage.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { DC } from "../transport/transport_provider.js";
 export declare abstract class Storage {
     private _authKeyId;

package/esm/storage/storage_local_storage.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { Storage } from "./storage.js";
 export declare class StorageLocalStorage extends Storage implements Storage {
     private readonly prefix;

package/esm/storage/storage_memory.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { Storage } from "./storage.js";
 export declare class StorageMemory extends Storage implements Storage {
     protected map: Map<string, string>;

package/esm/storage/storage_session_storage.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { Storage } from "./storage.js";
 export declare class StorageSessionStorage extends Storage implements Storage {
     private readonly prefix;

package/esm/transport/transport.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { CTR } from "../utilities/0_crypto.js";
 export declare abstract class Transport {
     protected initialized: boolean;

package/esm/types/0_chat_administrator_rights.d.ts

@@ -0,0 +1,17 @@
+import * as types from "../tl/2_types.js";
+export interface ChatAdministratorRights {
+    isAnonymous: boolean;
+    canManageChat: boolean;
+    canDeleteMessages: boolean;
+    canManageVideoChats: boolean;
+    canRestrictMembers: boolean;
+    canPromoteMembers: boolean;
+    canChangeInfo: boolean;
+    canInviteUsers: boolean;
+    canPostMessages?: boolean;
+    canEditMessages?: boolean;
+    canPinMessages?: boolean;
+    canManageTopics?: boolean;
+}
+export declare function constructChatAdministratorRights(rights_: types.ChatAdminRights): ChatAdministratorRights;
+export declare function chatAdministratorRightsToTlObject(rights: ChatAdministratorRights): types.ChatAdminRights;

package/esm/types/0_chat_administrator_rights.js

@@ -0,0 +1,38 @@
+import * as types from "../tl/2_types.js";
+export function constructChatAdministratorRights(rights_) {
+    const rights = {
+        isAnonymous: rights_.anonymous || false,
+        canManageChat: rights_.other || false,
+        canDeleteMessages: rights_.deleteMessages || false,
+        canManageVideoChats: rights_.manageCall || false,
+        canRestrictMembers: rights_.banUsers || false,
+        canPromoteMembers: rights_.addAdmins || false,
+        canChangeInfo: rights_.changeInfo || false,
+        canInviteUsers: rights_.inviteUsers || false,
+    };
+    if (rights_.postMessages) {
+        rights.canPostMessages = rights_.postMessages;
+    }
+    if (rights_.editMessages) {
+        rights.canEditMessages = rights_.editMessages;
+    }
+    if (rights_.pinMessages) {
+        rights.canPinMessages = rights_.pinMessages;
+    }
+    if (rights_.manageTopics) {
+        rights.canManageTopics = rights_.manageTopics;
+    }
+    return rights;
+}
+export function chatAdministratorRightsToTlObject(rights) {
+    return new types.ChatAdminRights({
+        anonymous: rights.isAnonymous || undefined,
+        other: rights.canManageChat || undefined,
+        deleteMessages: rights.canDeleteMessages || undefined,
+        manageCall: rights.canManageChat || undefined,
+        banUsers: rights.canRestrictMembers || undefined,
+        addAdmins: rights.canPromoteMembers || undefined,
+        changeInfo: rights.canChangeInfo || undefined,
+        inviteUsers: rights.canInviteUsers || undefined,
+    });
+}

package/esm/types/0_chat_photo.d.ts

@@ -0,0 +1,24 @@
+import * as types from "../tl/2_types.js";
+export declare enum ChatPhotoType {
+    Chat = "chat",
+    User = "user"
+}
+export declare namespace ChatPhoto {
+    interface Base {
+        type: ChatPhotoType;
+        hasVideo: boolean;
+        photoId: bigint;
+        strippedThumb?: Uint8Array;
+        dcId: number;
+    }
+    interface User extends Base {
+        type: ChatPhotoType;
+        personal: boolean;
+    }
+    interface Chat extends Base {
+        type: ChatPhotoType;
+    }
+}
+export type ChatPhoto = ChatPhoto.User | ChatPhoto.Chat;
+export declare function constructChatPhoto(photo: types.ChatPhoto): ChatPhoto.Chat;
+export declare function constructChatPhoto(photo: types.UserProfilePhoto): ChatPhoto.User;

package/esm/types/0_chat_photo.js

@@ -0,0 +1,28 @@
+import * as types from "../tl/2_types.js";
+export var ChatPhotoType;
+(function (ChatPhotoType) {
+    ChatPhotoType["Chat"] = "chat";
+    ChatPhotoType["User"] = "user";
+})(ChatPhotoType || (ChatPhotoType = {}));
+export function constructChatPhoto(photo) {
+    const { hasVideo = false, photoId, strippedThumb, dcId } = photo;
+    if (photo instanceof types.ChatPhoto) {
+        return {
+            type: ChatPhotoType.Chat,
+            hasVideo,
+            photoId,
+            strippedThumb,
+            dcId,
+        };
+    }
+    else {
+        return {
+            type: ChatPhotoType.User,
+            personal: photo.personal || false,
+            hasVideo,
+            photoId,
+            strippedThumb,
+            dcId,
+        };
+    }
+}

package/esm/types/0_force_reply.d.ts

@@ -0,0 +1,8 @@
+import * as types from "../tl/2_types.js";
+export interface ForceReply {
+    forceReply: true;
+    inputFieldPlaceholder?: string;
+    selective?: boolean;
+}
+export declare function constructForceReply(replyMarkup_: types.ReplyKeyboardForceReply): ForceReply;
+export declare function forceReplyToTlObject(replyMarkup: ForceReply): types.ReplyKeyboardForceReply;

package/esm/types/0_force_reply.js

@@ -0,0 +1,17 @@
+import * as types from "../tl/2_types.js";
+export function constructForceReply(replyMarkup_) {
+    const replyMarkup = { forceReply: true };
+    if (replyMarkup_.placeholder) {
+        replyMarkup.inputFieldPlaceholder = replyMarkup_.placeholder;
+    }
+    if (replyMarkup_.selective) {
+        replyMarkup.selective = true;
+    }
+    return replyMarkup;
+}
+export function forceReplyToTlObject(replyMarkup) {
+    return new types.ReplyKeyboardForceReply({
+        selective: replyMarkup.selective || undefined,
+        placeholder: replyMarkup.inputFieldPlaceholder,
+    });
+}