@mtkruto/node 0.0.832 → 0.0.834

package/esm/client/client.js

@@ -1,4 +1,4 @@
-import { gunzip } from "../deps.js";
+import { debug, gunzip } from "../deps.js";
 import { ackThreshold, DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_INITIAL_DC, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER, MAX_CHANNEL_ID, MAX_CHAT_ID, USERNAME_TTL, ZERO_CHANNEL_ID } from "../constants.js";
 import { bigIntFromBuffer, getRandomBigInt, getRandomId } from "../utilities/0_bigint.js";
 import { parseHtml } from "../utilities/0_html.js";
@@ -16,6 +16,7 @@ import { ClientPlain } from "./client_plain.js";
 import { StorageMemory } from "../storage/storage_memory.js";
 import { sha1 } from "../utilities/0_hash.js";
 import { messageEntityToTlObject } from "../types/0_message_entity.js";
+const d = debug("client");
 export const restartAuth = Symbol();
 export var ParseMode;
 (function (ParseMode) {
@@ -200,7 +201,7 @@ export class Client extends ClientAbstract {
         if (dc == null) {
             await this.storage.setDc(DEFAULT_INITIAL_DC);
         }
-        // logger().debug("Client connected");
+        d("enrypted client connected");
         this.receiveLoop();
         this.pingLoop();
     }
@@ -228,6 +229,7 @@ export class Client extends ClientAbstract {
         if (!this.apiHash) {
             throw new Error("apiHash not set");
         }
+        d("authorizing with %s", typeof params === "string" ? "bot token" : params instanceof types.AuthExportedAuthorization ? "exported authorization" : "AuthorizeUserParams");
         await this.invoke(new functions.InitConnection({
             apiId: this.apiId,
             appVersion: this.appVersion,
@@ -241,6 +243,7 @@ export class Client extends ClientAbstract {
             systemLangCode: this.systemLangCode,
             systemVersion: this.systemVersion,
         }));
+        d("connection inited");
         const handlePassword = async (err) => {
             params = params;
             if (err instanceof types.RPCError && err.errorMessage == "SESSION_PASSWORD_NEEDED") {
@@ -251,6 +254,7 @@ export class Client extends ClientAbstract {
                             const password = typeof params.password === "string" ? params.password : await params.password();
                             const input = await checkPassword(password, ap);
                             await this.invoke(new functions.AuthCheckPassword({ password: input }));
+                            d("authorized as user");
                             break;
                         }
                         catch (err) {
@@ -273,6 +277,7 @@ export class Client extends ClientAbstract {
         };
         try {
             await this.invoke(new functions.UpdatesGetState());
+            d("already authorized");
             return;
         }
         catch (err) {
@@ -285,6 +290,7 @@ export class Client extends ClientAbstract {
         try {
             if (params instanceof types.AuthExportedAuthorization) {
                 await this.invoke(new functions.AuthImportAuthorization({ id: params.id, bytes: params.bytes }));
+                d("authorization imported");
             }
             else if (typeof params == "object") {
                 while (true) {
@@ -300,6 +306,7 @@ export class Client extends ClientAbstract {
                                 phoneNumber,
                                 settings: new types.CodeSettings(),
                             }));
+                            d("verification code sent");
                             if (sentCode instanceof types.AuthSentCode) {
                                 while (true) {
                                     const phoneCode = typeof params.code === "string" ? params.code : await params.code();
@@ -310,6 +317,7 @@ export class Client extends ClientAbstract {
                                         }
                                         else {
                                             signedIn = true;
+                                            d("authorized as user");
                                             break;
                                         }
                                     }
@@ -343,6 +351,7 @@ export class Client extends ClientAbstract {
             }
             else {
                 await this.invoke(new functions.AuthImportBotAuthorization({ apiId: this.apiId, apiHash: this.apiHash, botAuthToken: params, flags: 0 }));
+                d("authorized as bot");
             }
         }
         catch (err) {
@@ -354,6 +363,7 @@ export class Client extends ClientAbstract {
                         newDc += "-test";
                     }
                     await this.reconnect(newDc);
+                    d("migrated to DC%s", newDc);
                     if (typeof params === "object" && phoneNumber != null) {
                         params = Object.assign({}, params);
                         params.phone = phoneNumber;
@@ -394,8 +404,8 @@ export class Client extends ClientAbstract {
             try {
                 decrypted = await decryptMessage(buffer, this.auth.key, this.auth.id, this.sessionId);
             }
-            catch (_err) {
-                // logger().error(`Failed to decrypt message: ${err}`);
+            catch (err) {
+                d("failed to decrypt message: %o", err);
                 continue;
             }
             const messages = decrypted instanceof MessageContainer ? decrypted.messages : [decrypted];
@@ -404,7 +414,7 @@ export class Client extends ClientAbstract {
                 if (body instanceof types.GZIPPacked) {
                     body = new TLReader(gunzip(body.packedData)).readObject();
                 }
-                // logger().debug(`Received ${body.constructor.name}`);
+                d("received %s", body.constructor.name);
                 if (body instanceof types.Updates) {
                     this.processUpdates(body);
                 }
@@ -413,6 +423,12 @@ export class Client extends ClientAbstract {
                     if (result instanceof types.GZIPPacked) {
                         result = new TLReader(gunzip(result.packedData)).readObject();
                     }
+                    if (result instanceof types.RPCError) {
+                        d("RPCResult: %d %s", result.errorCode, result.errorMessage);
+                    }
+                    else {
+                        d("RPCResult: %s", result.constructor.name);
+                    }
                     const promise = this.promises.get(message.body.messageId);
                     if (promise) {
                         if (result instanceof types.RPCError) {
@@ -454,8 +470,8 @@ export class Client extends ClientAbstract {
             try {
                 await this.invoke(new functions.Ping({ pingId: getRandomBigInt(8, true, false) }));
             }
-            catch (_err) {
-                // logger().error(`Failed to invoke ping: ${err}`);
+            catch (err) {
+                d("ping loop error: %o", err);
             }
             await new Promise((r) => setTimeout(r, 60 * 1000));
         }
@@ -471,7 +487,7 @@ export class Client extends ClientAbstract {
         }
         const message = new Message(getMessageId(), seqNo, function_);
         await this.transport.send(await encryptMessage(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
-        // logger().debug(`Invoked ${function_.constructor.name}`);
+        d("invoked %s", function_.constructor.name);
         if (noWait) {
             return;
         }

package/esm/client/client_abstract.d.ts

@@ -7,10 +7,10 @@ export declare abstract class ClientAbstract {
     protected connection: Connection;
     protected transport: Transport;
     private _dcId;
-    protected connected: boolean;
     constructor(transportProvider?: import("../transport/transport_provider.js").TransportProvider);
     get dcId(): number;
     setDc(dc: DC): MaybePromise<void>;
+    get connected(): boolean;
     connect(): Promise<void>;
     reconnect(dc?: DC): Promise<void>;
     disconnect(): Promise<void>;

package/esm/client/client_abstract.js

@@ -27,12 +27,6 @@ export class ClientAbstract {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "connected", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
         const { connection, transport, dcId } = transportProvider({ cdn: false });
         this.connection = connection;
         this.transport = transport;
@@ -48,11 +42,13 @@ export class ClientAbstract {
         this.transport = transport;
         this._dcId = dcId;
     }
+    get connected() {
+        return this.connection.connected;
+    }
     async connect() {
         await initTgCrypto();
         await this.connection.open();
         await this.transport.initialize();
-        this.connected = true;
     }
     async reconnect(dc) {
         await this.disconnect();
@@ -64,6 +60,5 @@ export class ClientAbstract {
     async disconnect() {
         await this.transport.deinitialize();
         await this.connection.close();
-        this.connected = false;
     }
 }

package/esm/client/client_plain.js

@@ -1,4 +1,4 @@
-import { assertEquals, assertInstanceOf, factorize, ige256Decrypt, ige256Encrypt } from "../deps.js";
+import { assertEquals, assertInstanceOf, debug, factorize, ige256Decrypt, ige256Encrypt } from "../deps.js";
 import { publicKeys } from "../constants.js";
 import { bigIntFromBuffer, getRandomBigInt, modExp } from "../utilities/0_bigint.js";
 import { bufferFromBigInt, concat } from "../utilities/0_buffer.js";
@@ -10,6 +10,7 @@ import { ClientDHInnerData, DHGenOK, PQInnerDataDC, ResPQ, ServerDHInnerData, Se
 import { ReqDHParams, ReqPQMulti, SetClientDHParams } from "../tl/3_functions.js";
 import { TLReader } from "../tl/3_tl_reader.js";
 import { ClientAbstract } from "./client_abstract.js";
+const d = debug("auth_key_creation");
 export class ClientPlain extends ClientAbstract {
     async invoke(function_) {
         await this.transport.send(packUnencryptedMessage(function_[serialize]()));
@@ -26,14 +27,14 @@ export class ClientPlain extends ClientAbstract {
     }
     async createAuthKey() {
         const nonce = getRandomBigInt(16, false, true);
-        // logger().debug("Auth key creation started");
+        d("auth key creation started");
         const resPq = await this.invoke(new ReqPQMulti({ nonce }));
         assertInstanceOf(resPq, ResPQ);
         assertEquals(resPq.nonce, nonce);
-        // logger().debug("Got res_pq");
+        d("got res_pq");
         const pq_ = bigIntFromBuffer(resPq.pq, false, false);
         const [p_, q_] = factorize(pq_);
-        // logger().debug("Factorized pq");
+        d("factorized pq");
         const p = bufferFromBigInt(p_, 4, false, false);
         const q = bufferFromBigInt(q_, 4, false, false);
         let publicKeyFingerprint;
@@ -71,7 +72,7 @@ export class ClientPlain extends ClientAbstract {
             encryptedData,
         }));
         assertInstanceOf(dhParams, ServerDHParamsOK);
-        // logger().debug("Got server_DH_params_ok");
+        d("got server_DH_params_ok");
         const newNonce_ = bufferFromBigInt(newNonce, 32, true, true);
         const serverNonce_ = bufferFromBigInt(serverNonce, 16, true, true);
         const tmpAesKey = concat(await sha1(concat(newNonce_, serverNonce_)), (await sha1(concat(serverNonce_, newNonce_))).slice(0, 0 + 12));
@@ -97,12 +98,12 @@ export class ClientPlain extends ClientAbstract {
         encryptedData = ige256Encrypt(dataWithHash, tmpAesKey, tmpAesIv);
         const dhGenOk = await this.invoke(new SetClientDHParams({ nonce, serverNonce, encryptedData }));
         assertInstanceOf(dhGenOk, DHGenOK);
-        // logger().debug("Got dh_gen_ok");
+        d("got dh_gen_ok");
         const serverNonceSlice = serverNonce_.slice(0, 8);
         const salt = newNonce_.slice(0, 0 + 8).map((v, i) => v ^ serverNonceSlice[i]);
         const authKey_ = modExp(gA, b, dhPrime);
         const authKey = bufferFromBigInt(authKey_, 256, false, false);
-        // logger().debug("Auth key created");
+        d("auth key created");
         return {
             authKey,
             salt: bigIntFromBuffer(salt, true, false),

package/esm/connection/connection.d.ts

@@ -1,5 +1,6 @@
 import { MaybePromise } from "../types.js";
 export declare abstract class Connection {
+    abstract get connected(): boolean;
     abstract open(): MaybePromise<void>;
     abstract read(p: Uint8Array): MaybePromise<void>;
     abstract write(p: Uint8Array): MaybePromise<void>;

package/esm/connection/connection_web_socket.d.ts

@@ -6,6 +6,7 @@ export declare class ConnectionWebSocket implements Connection {
     private buffer;
     private nextResolve;
     constructor(url: string | URL);
+    get connected(): boolean;
     open(): Promise<void>;
     read(p: Uint8Array): Promise<void>;
     write(p: Uint8Array): Promise<void>;

package/esm/connection/connection_web_socket.js

@@ -46,6 +46,9 @@ export class ConnectionWebSocket {
         };
         this.webSocket.onerror = console.error;
     }
+    get connected() {
+        return this.webSocket.readyState == dntShim.WebSocket.OPEN;
+    }
     async open() {
         while (this.webSocket.readyState != dntShim.WebSocket.OPEN) {
             if (this.webSocket.readyState == dntShim.WebSocket.CLOSED) {

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

@@ -0,0 +1,77 @@
+/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */
+interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+export declare function setColorEnabled(value: boolean): void;
+export declare function getColorEnabled(): boolean;
+export declare function reset(str: string): string;
+export declare function bold(str: string): string;
+export declare function dim(str: string): string;
+export declare function italic(str: string): string;
+export declare function underline(str: string): string;
+export declare function inverse(str: string): string;
+export declare function hidden(str: string): string;
+export declare function strikethrough(str: string): string;
+export declare function black(str: string): string;
+export declare function red(str: string): string;
+export declare function green(str: string): string;
+export declare function yellow(str: string): string;
+export declare function blue(str: string): string;
+export declare function magenta(str: string): string;
+export declare function cyan(str: string): string;
+export declare function white(str: string): string;
+export declare function gray(str: string): string;
+export declare function brightBlack(str: string): string;
+export declare function brightRed(str: string): string;
+export declare function brightGreen(str: string): string;
+export declare function brightYellow(str: string): string;
+export declare function brightBlue(str: string): string;
+export declare function brightMagenta(str: string): string;
+export declare function brightCyan(str: string): string;
+export declare function brightWhite(str: string): string;
+export declare function bgBlack(str: string): string;
+export declare function bgRed(str: string): string;
+export declare function bgGreen(str: string): string;
+export declare function bgYellow(str: string): string;
+export declare function bgBlue(str: string): string;
+export declare function bgMagenta(str: string): string;
+export declare function bgCyan(str: string): string;
+export declare function bgWhite(str: string): string;
+export declare function bgBrightBlack(str: string): string;
+export declare function bgBrightRed(str: string): string;
+export declare function bgBrightGreen(str: string): string;
+export declare function bgBrightYellow(str: string): string;
+export declare function bgBrightBlue(str: string): string;
+export declare function bgBrightMagenta(str: string): string;
+export declare function bgBrightCyan(str: string): string;
+export declare function bgBrightWhite(str: string): string;
+/** Set text color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit */
+export declare function rgb8(str: string, color: number): string;
+/** Set background color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit */
+export declare function bgRgb8(str: string, color: number): string;
+/** 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 declare function rgb24(str: string, color: number | Rgb): string;
+/** 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 declare function bgRgb24(str: string, color: number | Rgb): string;
+export declare function stripColor(string: string): string;
+export {};

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 {};