@mtkruto/browser 0.0.801 → 0.0.821

package/esm/client/client_plain.js

@@ -4,6 +4,7 @@ import { bigIntFromBuffer, getRandomBigInt, modExp } from "../utilities/0_bigint
 import { bufferFromBigInt, concat } from "../utilities/0_buffer.js";
 import { sha1 } from "../utilities/0_hash.js";
 import { rsaPad } from "../utilities/1_auth.js";
+import { serialize } from "../tl/1_tl_object.js";
 import { packUnencryptedMessage, unpackUnencryptedMessage } from "../utilities/1_message.js";
 import { ClientDHInnerData, DHGenOK, PQInnerDataDC, ResPQ, ServerDHInnerData, ServerDHParamsOK } from "../tl/2_types.js";
 import { ReqDHParams, ReqPQMulti, SetClientDHParams } from "../tl/3_functions.js";
@@ -11,7 +12,7 @@ import { TLReader } from "../tl/3_tl_reader.js";
 import { ClientAbstract } from "./client_abstract.js";
 export class ClientPlain extends ClientAbstract {
     async invoke(function_) {
-        await this.transport.send(packUnencryptedMessage(function_.serialize()));
+        await this.transport.send(packUnencryptedMessage(function_[serialize]()));
         const buffer = await this.transport.receive();
         if (buffer.length == 4) {
             const int = bigIntFromBuffer(buffer, true, true);
@@ -60,7 +61,7 @@ export class ClientPlain extends ClientAbstract {
             newNonce,
             nonce,
             serverNonce,
-        }).serialize(), publicKey);
+        })[serialize](), publicKey);
         const dhParams = await this.invoke(new ReqDHParams({
             nonce,
             serverNonce,
@@ -88,7 +89,7 @@ export class ClientPlain extends ClientAbstract {
             serverNonce,
             retryId: 0n,
             gB: bufferFromBigInt(gB, 256, false, false),
-        }).serialize();
+        })[serialize]();
         let dataWithHash = concat(await sha1(data), data);
         while (dataWithHash.length % 16 != 0) {
             dataWithHash = concat(dataWithHash, new Uint8Array(1));

package/esm/connection/connection_web_socket.js

@@ -35,7 +35,9 @@ export class ConnectionWebSocket {
         this.webSocket.onmessage = async (e) => {
             // deno-lint-ignore no-explicit-any
             const data = e.data instanceof Blob ? new Uint8Array(await e.data.arrayBuffer()) : new Uint8Array(e.data);
-            this.buffer.push(...Array.from(data));
+            for (const byte of data) {
+                this.buffer.push(byte);
+            }
             if (this.nextResolve != null && this.buffer.length >= this.nextResolve[0]) {
                 this.nextResolve[1]();
                 this.nextResolve = null;

package/{types → esm}/mod.d.ts

@@ -4,6 +4,7 @@ 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";

package/esm/mod.js

@@ -1,6 +1,7 @@
 import { checkPassword } from "./utilities/1_password.js";
 import { getRandomId } from "./utilities/0_bigint.js";
 export const utils = { checkPassword, 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";

package/{types → esm}/tl/1_tl_object.d.ts

@@ -16,6 +16,8 @@ export declare const id: unique symbol;
 export declare const params: unique symbol;
 export declare const paramDesc: unique symbol;
 export declare const length: unique symbol;
+export declare const serialize: unique symbol;
+export declare const as: unique symbol;
 export declare function isOptionalParam(ntype: string): boolean;
 export declare function analyzeOptionalParam(ntype: string): {
     flagField: string;
@@ -26,11 +28,12 @@ export declare abstract class TLObject {
     protected abstract get [params](): Params;
     protected static get [paramDesc](): ParamDesc;
     get [length](): number;
-    serialize(): Uint8Array;
+    [serialize](): Uint8Array;
+    [as]<T extends TLObjectConstructor<InstanceType<T>>>(constructor: T): InstanceType<T>;
 }
 export type MaybeVectorTLObject = TLObject | Array<MaybeVectorTLObject | TLObject>;
 export interface TLObjectConstructor<T = TLObject> {
-    new (params: Record<string, Param>): T;
+    new (params: any): T;
     [paramDesc]: ParamDesc;
 }
 export declare function isTLObjectConstructor(t: unknown): t is typeof TLObject;

package/esm/tl/1_tl_object.js

@@ -5,6 +5,8 @@ export const id = Symbol("id");
 export const params = Symbol("params");
 export const paramDesc = Symbol("paramDesc");
 export const length = Symbol("length");
+export const serialize = Symbol();
+export const as = Symbol();
 export function isOptionalParam(ntype) {
     return ntype.includes("?");
 }
@@ -22,7 +24,7 @@ function serializeSingleParam(writer, value, type, ntype) {
     if (isTLObjectConstructor(type)) {
         if ((type.name == "TypeX" && value instanceof TLObject) ||
             value instanceof type) {
-            writer.write(value.serialize());
+            writer.write(value[serialize]());
             return;
         }
         else {
@@ -87,10 +89,7 @@ function serializeSingleParam(writer, value, type, ntype) {
             }
             break;
         case "true":
-            if (value === true) {
-                writer.writeInt32(0x997275B5);
-            }
-            else {
+            if (value !== true) {
                 throw new TypeError("Expected true");
             }
     }
@@ -101,9 +100,9 @@ export class TLObject {
         return [];
     }
     get [length]() {
-        return this.serialize().byteLength;
+        return this[serialize]().byteLength;
     }
-    serialize() {
+    [serialize]() {
         const writer = new TLRawWriter();
         writer.writeInt32(this[id], false);
         for (const [value, type, ntype] of this[params]) {
@@ -142,6 +141,14 @@ export class TLObject {
         }
         return writer.buffer;
     }
+    [as](constructor) {
+        if (this instanceof constructor) {
+            return this;
+        }
+        else {
+            throw new TypeError(`Expected ${constructor.name}, got ${this.constructor.name}`);
+        }
+    }
 }
 export function isTLObjectConstructor(t) {
     // deno-lint-ignore no-explicit-any

package/esm/tl/3_tl_reader.js

@@ -1,7 +1,7 @@
 import { TLRawReader } from "./0_tl_raw_reader.js";
 import { paramDesc } from "./1_tl_object.js";
 import { map } from "./2_types.js";
-import { deserialize } from "./3_tl_object_deserializer.js";
+import { deserialize } from "./3_deserialize.js";
 export class TLReader extends TLRawReader {
     readObject(id) {
         if (!id) {

package/esm/tl/3_tl_writer.js

@@ -1,5 +1,6 @@
 import { VECTOR_CONSTRUCTOR } from "../constants.js";
 import { TLRawWriter } from "./0_tl_raw_writer.js";
+import { serialize } from "./1_tl_object.js";
 export class TLWriter extends TLRawWriter {
     writeObject(object) {
         if (Array.isArray(object)) {
@@ -10,7 +11,7 @@ export class TLWriter extends TLRawWriter {
             }
         }
         else {
-            this.write(object.serialize());
+            this.write(object[serialize]());
         }
         return this;
     }

package/esm/tl/5_message.js

@@ -1,4 +1,4 @@
-import { id } from "./1_tl_object.js";
+import { id, serialize } from "./1_tl_object.js";
 import { TLReader } from "./3_tl_reader.js";
 import { TLWriter } from "./3_tl_writer.js";
 import { RPCResult } from "./4_rpc_result.js";
@@ -13,7 +13,7 @@ function calculateLength(object) {
         }
     }
     else {
-        length += object.serialize().length;
+        length += object[serialize]().length;
     }
     return length;
 }

package/esm/utilities/1_message.js

@@ -1,7 +1,7 @@
 import { assertEquals, ige256Decrypt, ige256Encrypt } from "../deps.js";
 import { TLRawReader } from "../tl/0_tl_raw_reader.js";
 import { TLRawWriter } from "../tl/0_tl_raw_writer.js";
-import { id } from "../tl/1_tl_object.js";
+import { id, serialize } from "../tl/1_tl_object.js";
 import { TLReader } from "../tl/3_tl_reader.js";
 import { RPCResult } from "../tl/4_rpc_result.js";
 import { Message } from "../tl/5_message.js";
@@ -34,7 +34,7 @@ export function unpackUnencryptedMessage(buffer) {
     return { messageId, message };
 }
 export async function encryptMessage(message, authKey, authKeyId, salt, sessionId) {
-    const encoded = message.body.serialize();
+    const encoded = message.body[serialize]();
     const payloadWriter = new TLRawWriter();
     payloadWriter.writeInt64(salt);
     payloadWriter.writeInt64(sessionId);

package/package.json

@@ -1,9 +1,8 @@
 {
   "module": "./esm/mod.js",
   "main": "./script/mod.js",
-  "types": "./types/mod.d.ts",
   "name": "@mtkruto/browser",
-  "version": "0.0.801",
+  "version": "0.0.821",
   "description": "MTKruto for browsers",
   "author": "Roj <rojvv@icloud.com>",
   "license": "LGPL-3.0-or-later",
@@ -13,14 +12,8 @@
   },
   "exports": {
     ".": {
-      "import": {
-        "types": "./types/mod.d.ts",
-        "default": "./esm/mod.js"
-      },
-      "require": {
-        "types": "./types/mod.d.ts",
-        "default": "./script/mod.js"
-      }
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
     }
   },
   "dependencies": {

package/script/_dnt.shims.d.ts

@@ -0,0 +1 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;

package/script/client/client.d.ts

@@ -0,0 +1,50 @@
+import { MaybePromise } from "../types.js";
+import * as types from "../tl/2_types.js";
+import * as functions from "../tl/3_functions.js";
+import { ClientAbstract } from "./client_abstract.js";
+import { Session } from "../session/session.js";
+import { DC, TransportProvider } from "../transport/transport_provider.js";
+export interface AuthorizeUserParams<S = string, N = {
+    first: S;
+    last: S;
+}> {
+    phone: S | (() => MaybePromise<S>);
+    code: S | (() => MaybePromise<S>);
+    password: S | (() => MaybePromise<S>);
+    names: N | (() => MaybePromise<N>);
+}
+export type UpdatesHandler = null | ((client: Client, update: types.Updates) => MaybePromise<void>);
+export declare class Client extends ClientAbstract {
+    readonly session: Session;
+    readonly apiId: number;
+    readonly apiHash: string;
+    private sessionId;
+    private state;
+    private promises;
+    private toAcknowledge;
+    updatesHandler: UpdatesHandler;
+    readonly appVersion: string;
+    readonly deviceModel: string;
+    readonly langCode: string;
+    readonly langPack: string;
+    readonly systemLangCode: string;
+    readonly systemVersion: string;
+    constructor(session?: Session, apiId?: number, apiHash?: string, params?: {
+        transportProvider?: TransportProvider;
+        appVersion?: string;
+        deviceModel?: string;
+        langCode?: string;
+        langPack?: string;
+        systemLangCode?: string;
+        systemVersion?: string;
+    });
+    private shouldLoadSession;
+    setDc(dc: DC): void;
+    connect(): Promise<void>;
+    authorize(params: string | types.AuthExportedAuthorization | AuthorizeUserParams): Promise<void>;
+    private receiveLoop;
+    private pingLoop;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait: true): Promise<void>;
+    send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
+}

package/script/client/client_abstract.d.ts

@@ -0,0 +1,16 @@
+import { Connection } from "../connection/connection.js";
+import { Transport } from "../transport/transport.js";
+import { DC } from "../transport/transport_provider.js";
+export declare abstract class ClientAbstract {
+    protected transportProvider: import("../transport/transport_provider.js").TransportProvider;
+    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): void;
+    connect(): Promise<void>;
+    reconnect(dc?: DC): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/script/client/client_plain.d.ts

@@ -0,0 +1,9 @@
+import { Function } from "../tl/3_functions.js";
+import { ClientAbstract } from "./client_abstract.js";
+export declare class ClientPlain extends ClientAbstract {
+    invoke<T extends Function<unknown>>(function_: T): Promise<T["__R"]>;
+    createAuthKey(): Promise<{
+        authKey: Uint8Array;
+        salt: bigint;
+    }>;
+}

package/script/client/client_plain.js

@@ -7,6 +7,7 @@ const _0_bigint_js_1 = require("../utilities/0_bigint.js");
 const _0_buffer_js_1 = require("../utilities/0_buffer.js");
 const _0_hash_js_1 = require("../utilities/0_hash.js");
 const _1_auth_js_1 = require("../utilities/1_auth.js");
+const _1_tl_object_js_1 = require("../tl/1_tl_object.js");
 const _1_message_js_1 = require("../utilities/1_message.js");
 const _2_types_js_1 = require("../tl/2_types.js");
 const _3_functions_js_1 = require("../tl/3_functions.js");
@@ -14,7 +15,7 @@ const _3_tl_reader_js_1 = require("../tl/3_tl_reader.js");
 const client_abstract_js_1 = require("./client_abstract.js");
 class ClientPlain extends client_abstract_js_1.ClientAbstract {
     async invoke(function_) {
-        await this.transport.send((0, _1_message_js_1.packUnencryptedMessage)(function_.serialize()));
+        await this.transport.send((0, _1_message_js_1.packUnencryptedMessage)(function_[_1_tl_object_js_1.serialize]()));
         const buffer = await this.transport.receive();
         if (buffer.length == 4) {
             const int = (0, _0_bigint_js_1.bigIntFromBuffer)(buffer, true, true);
@@ -63,7 +64,7 @@ class ClientPlain extends client_abstract_js_1.ClientAbstract {
             newNonce,
             nonce,
             serverNonce,
-        }).serialize(), publicKey);
+        })[_1_tl_object_js_1.serialize](), publicKey);
         const dhParams = await this.invoke(new _3_functions_js_1.ReqDHParams({
             nonce,
             serverNonce,
@@ -91,7 +92,7 @@ class ClientPlain extends client_abstract_js_1.ClientAbstract {
             serverNonce,
             retryId: 0n,
             gB: (0, _0_buffer_js_1.bufferFromBigInt)(gB, 256, false, false),
-        }).serialize();
+        })[_1_tl_object_js_1.serialize]();
         let dataWithHash = (0, _0_buffer_js_1.concat)(await (0, _0_hash_js_1.sha1)(data), data);
         while (dataWithHash.length % 16 != 0) {
             dataWithHash = (0, _0_buffer_js_1.concat)(dataWithHash, new Uint8Array(1));

package/script/connection/connection.d.ts

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

package/script/connection/connection_web_socket.d.ts

@@ -0,0 +1,13 @@
+import { Connection } from "./connection.js";
+export declare class ConnectionWebSocket implements Connection {
+    private webSocket;
+    private rMutex;
+    private wMutex;
+    private buffer;
+    private nextResolve;
+    constructor(url: string | URL);
+    open(): Promise<void>;
+    read(p: Uint8Array): Promise<void>;
+    write(p: Uint8Array): Promise<void>;
+    close(): void;
+}

package/script/connection/connection_web_socket.js

@@ -38,7 +38,9 @@ class ConnectionWebSocket {
         this.webSocket.onmessage = async (e) => {
             // deno-lint-ignore no-explicit-any
             const data = e.data instanceof Blob ? new Uint8Array(await e.data.arrayBuffer()) : new Uint8Array(e.data);
-            this.buffer.push(...Array.from(data));
+            for (const byte of data) {
+                this.buffer.push(byte);
+            }
             if (this.nextResolve != null && this.buffer.length >= this.nextResolve[0]) {
                 this.nextResolve[1]();
                 this.nextResolve = null;

package/script/constants.d.ts

@@ -0,0 +1,12 @@
+import { DC } from "./transport/transport_provider.js";
+export declare const ackThreshold = 10;
+export declare const publicKeys: Map<bigint, [bigint, bigint]>;
+export declare const VECTOR_CONSTRUCTOR = 481674261;
+export declare const DEFAULT_INITIAL_DC: DC;
+export declare const LAYER = 158;
+export declare const DEFAULT_APP_VERSION = "MTKruto Unstable <v1.0.0";
+export declare const DEFAULT_DEVICE_MODEL = "Krutaya Device";
+export declare const DEFAULT_LANG_CODE = "en";
+export declare const DEFAULT_LANG_PACK = "";
+export declare const DEFAULT_SYSTEM_LANG_CODE = "en";
+export declare const DEFAULT_SYSTEM_VERSION = "1.0";

package/script/deps/deno.land/std@0.186.0/fmt/colors.d.ts

@@ -0,0 +1,270 @@
+/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */
+interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Set changing text color to enabled or disabled
+ * @param value
+ */
+export declare function setColorEnabled(value: boolean): void;
+/** Get whether text color change is enabled or disabled. */
+export declare function getColorEnabled(): boolean;
+/**
+ * Reset the text modified
+ * @param str text to reset
+ */
+export declare function reset(str: string): string;
+/**
+ * Make the text bold.
+ * @param str text to make bold
+ */
+export declare function bold(str: string): string;
+/**
+ * The text emits only a small amount of light.
+ * @param str text to dim
+ */
+export declare function dim(str: string): string;
+/**
+ * Make the text italic.
+ * @param str text to make italic
+ */
+export declare function italic(str: string): string;
+/**
+ * Make the text underline.
+ * @param str text to underline
+ */
+export declare function underline(str: string): string;
+/**
+ * Invert background color and text color.
+ * @param str text to invert its color
+ */
+export declare function inverse(str: string): string;
+/**
+ * Make the text hidden.
+ * @param str text to hide
+ */
+export declare function hidden(str: string): string;
+/**
+ * Put horizontal line through the center of the text.
+ * @param str text to strike through
+ */
+export declare function strikethrough(str: string): string;
+/**
+ * Set text color to black.
+ * @param str text to make black
+ */
+export declare function black(str: string): string;
+/**
+ * Set text color to red.
+ * @param str text to make red
+ */
+export declare function red(str: string): string;
+/**
+ * Set text color to green.
+ * @param str text to make green
+ */
+export declare function green(str: string): string;
+/**
+ * Set text color to yellow.
+ * @param str text to make yellow
+ */
+export declare function yellow(str: string): string;
+/**
+ * Set text color to blue.
+ * @param str text to make blue
+ */
+export declare function blue(str: string): string;
+/**
+ * Set text color to magenta.
+ * @param str text to make magenta
+ */
+export declare function magenta(str: string): string;
+/**
+ * Set text color to cyan.
+ * @param str text to make cyan
+ */
+export declare function cyan(str: string): string;
+/**
+ * Set text color to white.
+ * @param str text to make white
+ */
+export declare function white(str: string): string;
+/**
+ * Set text color to gray.
+ * @param str text to make gray
+ */
+export declare function gray(str: string): string;
+/**
+ * Set text color to bright black.
+ * @param str text to make bright-black
+ */
+export declare function brightBlack(str: string): string;
+/**
+ * Set text color to bright red.
+ * @param str text to make bright-red
+ */
+export declare function brightRed(str: string): string;
+/**
+ * Set text color to bright green.
+ * @param str text to make bright-green
+ */
+export declare function brightGreen(str: string): string;
+/**
+ * Set text color to bright yellow.
+ * @param str text to make bright-yellow
+ */
+export declare function brightYellow(str: string): string;
+/**
+ * Set text color to bright blue.
+ * @param str text to make bright-blue
+ */
+export declare function brightBlue(str: string): string;
+/**
+ * Set text color to bright magenta.
+ * @param str text to make bright-magenta
+ */
+export declare function brightMagenta(str: string): string;
+/**
+ * Set text color to bright cyan.
+ * @param str text to make bright-cyan
+ */
+export declare function brightCyan(str: string): string;
+/**
+ * Set text color to bright white.
+ * @param str text to make bright-white
+ */
+export declare function brightWhite(str: string): string;
+/**
+ * Set background color to black.
+ * @param str text to make its background black
+ */
+export declare function bgBlack(str: string): string;
+/**
+ * Set background color to red.
+ * @param str text to make its background red
+ */
+export declare function bgRed(str: string): string;
+/**
+ * Set background color to green.
+ * @param str text to make its background green
+ */
+export declare function bgGreen(str: string): string;
+/**
+ * Set background color to yellow.
+ * @param str text to make its background yellow
+ */
+export declare function bgYellow(str: string): string;
+/**
+ * Set background color to blue.
+ * @param str text to make its background blue
+ */
+export declare function bgBlue(str: string): string;
+/**
+ *  Set background color to magenta.
+ * @param str text to make its background magenta
+ */
+export declare function bgMagenta(str: string): string;
+/**
+ * Set background color to cyan.
+ * @param str text to make its background cyan
+ */
+export declare function bgCyan(str: string): string;
+/**
+ * Set background color to white.
+ * @param str text to make its background white
+ */
+export declare function bgWhite(str: string): string;
+/**
+ * Set background color to bright black.
+ * @param str text to make its background bright-black
+ */
+export declare function bgBrightBlack(str: string): string;
+/**
+ * Set background color to bright red.
+ * @param str text to make its background bright-red
+ */
+export declare function bgBrightRed(str: string): string;
+/**
+ * Set background color to bright green.
+ * @param str text to make its background bright-green
+ */
+export declare function bgBrightGreen(str: string): string;
+/**
+ * Set background color to bright yellow.
+ * @param str text to make its background bright-yellow
+ */
+export declare function bgBrightYellow(str: string): string;
+/**
+ * Set background color to bright blue.
+ * @param str text to make its background bright-blue
+ */
+export declare function bgBrightBlue(str: string): string;
+/**
+ * Set background color to bright magenta.
+ * @param str text to make its background bright-magenta
+ */
+export declare function bgBrightMagenta(str: string): string;
+/**
+ * Set background color to bright cyan.
+ * @param str text to make its background bright-cyan
+ */
+export declare function bgBrightCyan(str: string): string;
+/**
+ * Set background color to bright white.
+ * @param str text to make its background bright-white
+ */
+export declare function bgBrightWhite(str: string): string;
+/**
+ * Set text color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit colors to
+ * @param color code
+ */
+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
+ * @param str text color to apply paletted 8bit background colors to
+ * @param color code
+ */
+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:
+ *
+ * ```ts
+ *      import { rgb24 } from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";
+ *      rgb24("foo", 0xff00ff);
+ *      rgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+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:
+ *
+ * ```ts
+ *      import { bgRgb24 } from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";
+ *      bgRgb24("foo", 0xff00ff);
+ *      bgRgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function bgRgb24(str: string, color: number | Rgb): string;
+/**
+ * Remove ANSI escape codes from the string.
+ * @param string to remove ANSI escape codes from
+ */
+export declare function stripColor(string: string): string;
+export {};