@core-ease/telegram-kit 3.0.1

package/dist/engine-BDm1_hzn.d.ts

@@ -0,0 +1,382 @@
+import * as React from 'react';
+
+interface LottieKeyframe {
+    t: number;
+    s?: number[];
+    e?: number[];
+    i?: {
+        x: number | number[];
+        y: number | number[];
+    };
+    o?: {
+        x: number | number[];
+        y: number | number[];
+    };
+    h?: 0 | 1;
+    to?: number[];
+    ti?: number[];
+}
+interface AnimatedProperty {
+    a: 0 | 1;
+    k: number[] | number | LottieKeyframe[];
+    ix?: number;
+    x?: string;
+}
+interface MultiDimensional extends AnimatedProperty {
+}
+interface ScalarProperty extends AnimatedProperty {
+}
+interface ShapeProperty {
+    a: 0 | 1;
+    k: ShapeKeyframeValue | ShapeAnimKeyframe[];
+}
+interface ShapeKeyframeValue {
+    c: boolean;
+    v: number[][];
+    i: number[][];
+    o: number[][];
+}
+interface ShapeAnimKeyframe {
+    t: number;
+    s?: ShapeKeyframeValue[];
+    e?: ShapeKeyframeValue[];
+    i?: {
+        x: number | number[];
+        y: number | number[];
+    };
+    o?: {
+        x: number | number[];
+        y: number | number[];
+    };
+    h?: 0 | 1;
+}
+interface Transform {
+    a?: MultiDimensional;
+    p?: MultiDimensional & {
+        s?: boolean;
+        x?: AnimatedProperty;
+        y?: AnimatedProperty;
+    };
+    s?: MultiDimensional;
+    r?: ScalarProperty;
+    o?: ScalarProperty;
+    sk?: ScalarProperty;
+    sa?: ScalarProperty;
+}
+interface GradientColor {
+    p: number;
+    k: AnimatedProperty;
+}
+interface ShapeItemBase {
+    ty: string;
+    nm?: string;
+    hd?: boolean;
+}
+interface ShapePathItem extends ShapeItemBase {
+    ty: "sh";
+    ks: ShapeProperty;
+}
+interface ShapeRectItem extends ShapeItemBase {
+    ty: "rc";
+    p: MultiDimensional;
+    s: MultiDimensional;
+    r: ScalarProperty;
+}
+interface ShapeEllipseItem extends ShapeItemBase {
+    ty: "el";
+    p: MultiDimensional;
+    s: MultiDimensional;
+}
+interface ShapeStarItem extends ShapeItemBase {
+    ty: "sr";
+    p: MultiDimensional;
+    or: ScalarProperty;
+    os: ScalarProperty;
+    ir?: ScalarProperty;
+    is?: ScalarProperty;
+    r: ScalarProperty;
+    pt: ScalarProperty;
+    sy: 1 | 2;
+}
+interface ShapeFillItem extends ShapeItemBase {
+    ty: "fl";
+    c: MultiDimensional;
+    o: ScalarProperty;
+    r?: number;
+}
+interface ShapeGradientFillItem extends ShapeItemBase {
+    ty: "gf";
+    o: ScalarProperty;
+    s: MultiDimensional;
+    e: MultiDimensional;
+    t: 1 | 2;
+    g: GradientColor;
+    h?: ScalarProperty;
+    a?: ScalarProperty;
+}
+interface ShapeStrokeItem extends ShapeItemBase {
+    ty: "st";
+    c: MultiDimensional;
+    o: ScalarProperty;
+    w: ScalarProperty;
+    lc?: number;
+    lj?: number;
+    ml?: number;
+    d?: Array<{
+        n: string;
+        v: AnimatedProperty;
+    }>;
+}
+interface ShapeGradientStrokeItem extends ShapeItemBase {
+    ty: "gs";
+    o: ScalarProperty;
+    s: MultiDimensional;
+    e: MultiDimensional;
+    t: 1 | 2;
+    g: GradientColor;
+    w: ScalarProperty;
+    h?: ScalarProperty;
+    a?: ScalarProperty;
+    lc?: number;
+    lj?: number;
+    ml?: number;
+    d?: Array<{
+        n: string;
+        v: AnimatedProperty;
+    }>;
+}
+interface ShapeGroupItem extends ShapeItemBase {
+    ty: "gr";
+    it: ShapeItem[];
+}
+interface ShapeTrimItem extends ShapeItemBase {
+    ty: "tm";
+    s: ScalarProperty;
+    e: ScalarProperty;
+    o: ScalarProperty;
+    m?: 1 | 2;
+}
+interface ShapeRepeaterItem extends ShapeItemBase {
+    ty: "rp";
+    c: ScalarProperty;
+    o: ScalarProperty;
+    tr: {
+        p: MultiDimensional;
+        a: MultiDimensional;
+        s: MultiDimensional;
+        r: ScalarProperty;
+        so?: ScalarProperty;
+        eo?: ScalarProperty;
+    };
+}
+interface ShapeMergeItem extends ShapeItemBase {
+    ty: "mm";
+    mm: number;
+}
+interface ShapeTransformItem extends ShapeItemBase, Transform {
+    ty: "tr";
+}
+type ShapeItem = ShapePathItem | ShapeRectItem | ShapeEllipseItem | ShapeStarItem | ShapeFillItem | ShapeGradientFillItem | ShapeStrokeItem | ShapeGradientStrokeItem | ShapeGroupItem | ShapeTrimItem | ShapeRepeaterItem | ShapeMergeItem | ShapeTransformItem;
+interface MaskProperty {
+    inv: boolean;
+    mode: "a" | "s" | "i" | "l" | "d" | "n";
+    pt: ShapeProperty;
+    o: ScalarProperty;
+}
+interface LottieLayer {
+    ty: number;
+    ind?: number;
+    parent?: number;
+    nm?: string;
+    ip: number;
+    op: number;
+    st: number;
+    sr?: number;
+    ks: Transform;
+    shapes?: ShapeItem[];
+    refId?: string;
+    w?: number;
+    h?: number;
+    sc?: string;
+    sw?: number;
+    sh?: number;
+    masksProperties?: MaskProperty[];
+    tt?: number;
+    td?: number;
+    bm?: number;
+    hd?: boolean;
+    ao?: number;
+    tm?: AnimatedProperty;
+}
+interface LottieAsset {
+    id: string;
+    layers?: LottieLayer[];
+    w?: number;
+    h?: number;
+    u?: string;
+    p?: string;
+    e?: number;
+}
+interface LottieAnimation {
+    v: string;
+    fr: number;
+    ip: number;
+    op: number;
+    w: number;
+    h: number;
+    nm?: string;
+    ddd?: number;
+    assets?: LottieAsset[];
+    layers: LottieLayer[];
+    markers?: Array<{
+        tm: number;
+        cm: string;
+        dr: number;
+    }>;
+    tgs?: number;
+}
+
+type PlayerState = "loading" | "playing" | "paused" | "stopped" | "frozen" | "error" | "destroyed";
+type PlayMode = "normal" | "bounce";
+interface PlayerEventMap {
+    ready: void;
+    play: void;
+    pause: void;
+    stop: void;
+    complete: void;
+    loop: void;
+    frame: {
+        frame: number;
+        progress: number;
+    };
+    error: {
+        errors?: string[];
+    };
+    destroyed: void;
+}
+type Listener<K extends keyof PlayerEventMap> = (detail: PlayerEventMap[K]) => void;
+interface AnimationOptions {
+    canvas: HTMLCanvasElement;
+    loop: boolean | number;
+    autoplay: boolean;
+    speed: number;
+    direction: 1 | -1;
+    mode: PlayMode;
+    segments?: [number, number];
+}
+declare class LottieAnimationController {
+    private doc;
+    private canvas;
+    private ctx;
+    private state;
+    private currentFrame;
+    private direction;
+    private speed;
+    private loop;
+    private mode;
+    private loopsCompleted;
+    private segment;
+    private rafHandle;
+    private lastTs;
+    private shapeScratch;
+    private listeners;
+    constructor(options: AnimationOptions);
+    on<K extends keyof PlayerEventMap>(event: K, fn: Listener<K>): () => void;
+    private emit;
+    setDocument(doc: LottieAnimation): void;
+    setError(errors?: string[]): void;
+    private getBounds;
+    resize(width: number, height: number): void;
+    setSegment(segment: [number, number] | null): void;
+    play(): void;
+    pause(): void;
+    freeze(): void;
+    unfreeze(): void;
+    stop(): void;
+    destroy(): void;
+    togglePlay(): void;
+    setSpeed(speed: number): void;
+    setDirection(direction: 1 | -1): void;
+    setLoop(loop: boolean | number): void;
+    setMode(mode: PlayMode): void;
+    getCurrentFrame(): number;
+    getState(): PlayerState;
+    getTotalFrames(): number;
+    seek(value: number | string): void;
+    private startLoop;
+    private stopLoop;
+    private advance;
+    private finishPlayback;
+    private emitFrameEvent;
+    private getShapeScratch;
+    private renderCurrentFrame;
+}
+
+type TgsSource = string | ArrayBuffer | Uint8Array | LottieAnimation | Record<string, unknown>;
+declare function loadTgsSource(src: TgsSource): Promise<LottieAnimation>;
+
+interface AnimationPlayerHandle {
+    play(): void;
+    pause(): void;
+    stop(): void;
+    togglePlay(): void;
+    seek(value: number | string): void;
+    setSpeed(speed: number): void;
+    setDirection(direction: 1 | -1): void;
+    setLoop(loop: boolean | number): void;
+    setMode(mode: PlayMode): void;
+    setSegment(segment: [number, number] | null): void;
+    getCurrentFrame(): number;
+    getTotalFrames(): number;
+    getState(): PlayerState;
+    getAnimationData(): LottieAnimation | null;
+    getCanvas(): HTMLCanvasElement | null;
+}
+interface AnimationPlayerBaseProps {
+    src: TgsSource;
+    autoplay?: boolean;
+    loop?: boolean | number;
+    speed?: number;
+    direction?: 1 | -1;
+    mode?: PlayMode;
+    segments?: [number, number];
+    hover?: boolean;
+    pauseWhenOffscreen?: boolean;
+    width?: number | string;
+    height?: number | string;
+    className?: string;
+    style?: React.CSSProperties;
+    ariaLabel?: string;
+    onReady?: () => void;
+    onPlay?: () => void;
+    onPause?: () => void;
+    onStop?: () => void;
+    onComplete?: () => void;
+    onLoop?: () => void;
+    onFrame?: (info: {
+        frame: number;
+        progress: number;
+    }) => void;
+    onError?: (errors?: string[]) => void;
+    validate?: (doc: LottieAnimation) => string[];
+}
+
+interface EngineImageCache {
+    get(key: string): HTMLImageElement | undefined;
+    set(key: string, img: HTMLImageElement): void;
+}
+interface RenderOptions {
+    ctx: CanvasRenderingContext2D;
+    canvasWidth: number;
+    canvasHeight: number;
+    imageCache: EngineImageCache;
+    onAssetLoaded?: () => void;
+    warnOnce: (key: string, message: string) => void;
+    getShapeScratch?: (w: number, h: number) => {
+        canvas: HTMLCanvasElement | OffscreenCanvas;
+        ctx: CanvasRenderingContext2D;
+    };
+}
+declare function renderDocumentFrame(doc: LottieAnimation, frame: number, opts: RenderOptions): void;
+
+export { type AnimationPlayerBaseProps as A, type LottieAnimation as L, type PlayMode as P, type TgsSource as T, LottieAnimationController as a, type PlayerState as b, type AnimationPlayerHandle as c, loadTgsSource as l, renderDocumentFrame as r };

package/dist/format/index.d.mts

@@ -0,0 +1,61 @@
+declare class TelegramFormattedText {
+    readonly raw: string;
+    constructor(raw: string);
+    toString(): string;
+}
+type TextPart = string | TelegramFormattedText;
+declare function escapeMarkdownV2(text: string): string;
+declare function escapeMarkdownV2Code(text: string): string;
+declare function escapeMarkdownV2LinkUrl(url: string): string;
+declare function escapeHTML(text: string): string;
+declare function escapeHTMLAttribute(text: string): string;
+declare const md: {
+    escape: typeof escapeMarkdownV2;
+    escapeCode: typeof escapeMarkdownV2Code;
+    escapeLinkUrl: typeof escapeMarkdownV2LinkUrl;
+    text: (...parts: TextPart[]) => TelegramFormattedText;
+    bold: (...parts: TextPart[]) => TelegramFormattedText;
+    italic: (...parts: TextPart[]) => TelegramFormattedText;
+    underline: (...parts: TextPart[]) => TelegramFormattedText;
+    strikethrough: (...parts: TextPart[]) => TelegramFormattedText;
+    spoiler: (...parts: TextPart[]) => TelegramFormattedText;
+    code: (text: string) => TelegramFormattedText;
+    pre: (text: string, language?: string) => TelegramFormattedText;
+    link: (url: string, ...parts: TextPart[]) => TelegramFormattedText;
+    mentionUser: (userId: number, ...parts: TextPart[]) => TelegramFormattedText;
+    customEmoji: (emojiId: string, fallbackEmoji: string) => TelegramFormattedText;
+    raw: (raw: string) => TelegramFormattedText;
+};
+declare const html: {
+    escape: typeof escapeHTML;
+    escapeAttribute: typeof escapeHTMLAttribute;
+    text: (...parts: TextPart[]) => TelegramFormattedText;
+    bold: (...parts: TextPart[]) => TelegramFormattedText;
+    italic: (...parts: TextPart[]) => TelegramFormattedText;
+    underline: (...parts: TextPart[]) => TelegramFormattedText;
+    strikethrough: (...parts: TextPart[]) => TelegramFormattedText;
+    spoiler: (...parts: TextPart[]) => TelegramFormattedText;
+    code: (text: string) => TelegramFormattedText;
+    pre: (text: string, language?: string) => TelegramFormattedText;
+    link: (url: string, ...parts: TextPart[]) => TelegramFormattedText;
+    mentionUser: (userId: number, ...parts: TextPart[]) => TelegramFormattedText;
+    blockquote: (...parts: TextPart[]) => TelegramFormattedText;
+    expandableBlockquote: (...parts: TextPart[]) => TelegramFormattedText;
+    customEmoji: (emojiId: string, fallbackEmoji: string) => TelegramFormattedText;
+    raw: (rawHtml: string) => TelegramFormattedText;
+};
+declare const TELEGRAM_TEXT_LIMITS: {
+    readonly MESSAGE: 4096;
+    readonly CAPTION: 1024;
+    readonly BUTTON_TEXT: 64;
+    readonly CALLBACK_DATA: 64;
+    readonly START_PARAMETER: 64;
+    readonly BOT_DESCRIPTION: 512;
+    readonly BOT_SHORT_DESCRIPTION: 120;
+    readonly CHAT_TITLE: 128;
+    readonly POLL_QUESTION: 300;
+    readonly POLL_OPTION: 100;
+};
+declare function truncateText(text: string, maxLength: number, ellipsis?: string): string;
+
+export { TELEGRAM_TEXT_LIMITS, TelegramFormattedText, escapeHTML, escapeHTMLAttribute, escapeMarkdownV2, escapeMarkdownV2Code, escapeMarkdownV2LinkUrl, html, md, truncateText };

package/dist/format/index.d.ts

@@ -0,0 +1,61 @@
+declare class TelegramFormattedText {
+    readonly raw: string;
+    constructor(raw: string);
+    toString(): string;
+}
+type TextPart = string | TelegramFormattedText;
+declare function escapeMarkdownV2(text: string): string;
+declare function escapeMarkdownV2Code(text: string): string;
+declare function escapeMarkdownV2LinkUrl(url: string): string;
+declare function escapeHTML(text: string): string;
+declare function escapeHTMLAttribute(text: string): string;
+declare const md: {
+    escape: typeof escapeMarkdownV2;
+    escapeCode: typeof escapeMarkdownV2Code;
+    escapeLinkUrl: typeof escapeMarkdownV2LinkUrl;
+    text: (...parts: TextPart[]) => TelegramFormattedText;
+    bold: (...parts: TextPart[]) => TelegramFormattedText;
+    italic: (...parts: TextPart[]) => TelegramFormattedText;
+    underline: (...parts: TextPart[]) => TelegramFormattedText;
+    strikethrough: (...parts: TextPart[]) => TelegramFormattedText;
+    spoiler: (...parts: TextPart[]) => TelegramFormattedText;
+    code: (text: string) => TelegramFormattedText;
+    pre: (text: string, language?: string) => TelegramFormattedText;
+    link: (url: string, ...parts: TextPart[]) => TelegramFormattedText;
+    mentionUser: (userId: number, ...parts: TextPart[]) => TelegramFormattedText;
+    customEmoji: (emojiId: string, fallbackEmoji: string) => TelegramFormattedText;
+    raw: (raw: string) => TelegramFormattedText;
+};
+declare const html: {
+    escape: typeof escapeHTML;
+    escapeAttribute: typeof escapeHTMLAttribute;
+    text: (...parts: TextPart[]) => TelegramFormattedText;
+    bold: (...parts: TextPart[]) => TelegramFormattedText;
+    italic: (...parts: TextPart[]) => TelegramFormattedText;
+    underline: (...parts: TextPart[]) => TelegramFormattedText;
+    strikethrough: (...parts: TextPart[]) => TelegramFormattedText;
+    spoiler: (...parts: TextPart[]) => TelegramFormattedText;
+    code: (text: string) => TelegramFormattedText;
+    pre: (text: string, language?: string) => TelegramFormattedText;
+    link: (url: string, ...parts: TextPart[]) => TelegramFormattedText;
+    mentionUser: (userId: number, ...parts: TextPart[]) => TelegramFormattedText;
+    blockquote: (...parts: TextPart[]) => TelegramFormattedText;
+    expandableBlockquote: (...parts: TextPart[]) => TelegramFormattedText;
+    customEmoji: (emojiId: string, fallbackEmoji: string) => TelegramFormattedText;
+    raw: (rawHtml: string) => TelegramFormattedText;
+};
+declare const TELEGRAM_TEXT_LIMITS: {
+    readonly MESSAGE: 4096;
+    readonly CAPTION: 1024;
+    readonly BUTTON_TEXT: 64;
+    readonly CALLBACK_DATA: 64;
+    readonly START_PARAMETER: 64;
+    readonly BOT_DESCRIPTION: 512;
+    readonly BOT_SHORT_DESCRIPTION: 120;
+    readonly CHAT_TITLE: 128;
+    readonly POLL_QUESTION: 300;
+    readonly POLL_OPTION: 100;
+};
+declare function truncateText(text: string, maxLength: number, ellipsis?: string): string;
+
+export { TELEGRAM_TEXT_LIMITS, TelegramFormattedText, escapeHTML, escapeHTMLAttribute, escapeMarkdownV2, escapeMarkdownV2Code, escapeMarkdownV2LinkUrl, html, md, truncateText };

package/dist/format/index.js

@@ -0,0 +1,121 @@
+'use strict';
+
+// src/utils/format.ts
+var TelegramFormattedText = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  toString() {
+    return this.raw;
+  }
+};
+function isFragment(part) {
+  return part instanceof TelegramFormattedText;
+}
+function joinParts(parts, escape) {
+  return parts.map((part) => isFragment(part) ? part.raw : escape(part)).join("");
+}
+var MARKDOWN_V2_RESERVED = /[_*[\]()~`>#+\-=|{}.!\\]/g;
+var MARKDOWN_V2_CODE_RESERVED = /[`\\]/g;
+var MARKDOWN_V2_LINK_URL_RESERVED = /[)\\]/g;
+function escapeMarkdownV2(text) {
+  return text.replace(MARKDOWN_V2_RESERVED, (ch) => `\\${ch}`);
+}
+function escapeMarkdownV2Code(text) {
+  return text.replace(MARKDOWN_V2_CODE_RESERVED, (ch) => `\\${ch}`);
+}
+function escapeMarkdownV2LinkUrl(url) {
+  return url.replace(MARKDOWN_V2_LINK_URL_RESERVED, (ch) => `\\${ch}`);
+}
+function createMarkdownV2Formatter() {
+  const wrap = (raw) => new TelegramFormattedText(raw);
+  const t = (parts) => joinParts(parts, escapeMarkdownV2);
+  return {
+    escape: escapeMarkdownV2,
+    escapeCode: escapeMarkdownV2Code,
+    escapeLinkUrl: escapeMarkdownV2LinkUrl,
+    text: (...parts) => wrap(t(parts)),
+    bold: (...parts) => wrap(`*${t(parts)}*`),
+    italic: (...parts) => wrap(`_${t(parts)}_`),
+    underline: (...parts) => wrap(`__${t(parts)}__`),
+    strikethrough: (...parts) => wrap(`~${t(parts)}~`),
+    spoiler: (...parts) => wrap(`||${t(parts)}||`),
+    code: (text) => wrap(`\`${escapeMarkdownV2Code(text)}\``),
+    pre: (text, language) => wrap(`\`\`\`${language != null ? language : ""}
+${escapeMarkdownV2Code(text)}
+\`\`\``),
+    link: (url, ...parts) => wrap(`[${t(parts)}](${escapeMarkdownV2LinkUrl(url)})`),
+    mentionUser: (userId, ...parts) => wrap(`[${t(parts)}](tg://user?id=${userId})`),
+    customEmoji: (emojiId, fallbackEmoji) => wrap(`![${escapeMarkdownV2(fallbackEmoji)}](tg://emoji?id=${emojiId})`),
+    raw: (raw) => wrap(raw)
+  };
+}
+function escapeHTML(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHTMLAttribute(text) {
+  return escapeHTML(text).replace(/"/g, "&quot;");
+}
+function createHtmlFormatter() {
+  const wrap = (raw) => new TelegramFormattedText(raw);
+  const t = (parts) => joinParts(parts, escapeHTML);
+  return {
+    escape: escapeHTML,
+    escapeAttribute: escapeHTMLAttribute,
+    text: (...parts) => wrap(t(parts)),
+    bold: (...parts) => wrap(`<b>${t(parts)}</b>`),
+    italic: (...parts) => wrap(`<i>${t(parts)}</i>`),
+    underline: (...parts) => wrap(`<u>${t(parts)}</u>`),
+    strikethrough: (...parts) => wrap(`<s>${t(parts)}</s>`),
+    spoiler: (...parts) => wrap(`<tg-spoiler>${t(parts)}</tg-spoiler>`),
+    code: (text) => wrap(`<code>${escapeHTML(text)}</code>`),
+    pre: (text, language) => wrap(
+      language ? `<pre><code class="language-${escapeHTMLAttribute(language)}">${escapeHTML(text)}</code></pre>` : `<pre>${escapeHTML(text)}</pre>`
+    ),
+    link: (url, ...parts) => wrap(`<a href="${escapeHTMLAttribute(url)}">${t(parts)}</a>`),
+    mentionUser: (userId, ...parts) => wrap(`<a href="tg://user?id=${userId}">${t(parts)}</a>`),
+    blockquote: (...parts) => wrap(`<blockquote>${t(parts)}</blockquote>`),
+    expandableBlockquote: (...parts) => wrap(`<blockquote expandable>${t(parts)}</blockquote>`),
+    customEmoji: (emojiId, fallbackEmoji) => wrap(`<tg-emoji emoji-id="${escapeHTMLAttribute(emojiId)}">${escapeHTML(fallbackEmoji)}</tg-emoji>`),
+    raw: (rawHtml) => wrap(rawHtml)
+  };
+}
+var md = createMarkdownV2Formatter();
+var html = createHtmlFormatter();
+var TELEGRAM_TEXT_LIMITS = {
+  MESSAGE: 4096,
+  CAPTION: 1024,
+  BUTTON_TEXT: 64,
+  CALLBACK_DATA: 64,
+  START_PARAMETER: 64,
+  BOT_DESCRIPTION: 512,
+  BOT_SHORT_DESCRIPTION: 120,
+  CHAT_TITLE: 128,
+  POLL_QUESTION: 300,
+  POLL_OPTION: 100
+};
+function isHighSurrogate(code) {
+  return code >= 55296 && code <= 56319;
+}
+function isLowSurrogate(code) {
+  return code >= 56320 && code <= 57343;
+}
+function truncateText(text, maxLength, ellipsis = "\u2026") {
+  if (text.length <= maxLength) return text;
+  let cut = Math.max(0, maxLength - ellipsis.length);
+  if (cut > 0 && isHighSurrogate(text.charCodeAt(cut - 1)) && isLowSurrogate(text.charCodeAt(cut))) {
+    cut -= 1;
+  }
+  return text.slice(0, cut) + ellipsis;
+}
+
+exports.TELEGRAM_TEXT_LIMITS = TELEGRAM_TEXT_LIMITS;
+exports.TelegramFormattedText = TelegramFormattedText;
+exports.escapeHTML = escapeHTML;
+exports.escapeHTMLAttribute = escapeHTMLAttribute;
+exports.escapeMarkdownV2 = escapeMarkdownV2;
+exports.escapeMarkdownV2Code = escapeMarkdownV2Code;
+exports.escapeMarkdownV2LinkUrl = escapeMarkdownV2LinkUrl;
+exports.html = html;
+exports.md = md;
+exports.truncateText = truncateText;