@mks2508/telegram-message-builder 0.2.0

package/src/escaping.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect } from "bun:test";
+import { fmt } from "../src";
+
+describe("Escaping", () => {
+  describe("HTML Escaping", () => {
+    it("should escape ampersand", () => {
+      expect(fmt.escapeHTML("&")).toBe("&");
+    });
+
+    it("should escape less than", () => {
+      expect(fmt.escapeHTML("<")).toBe("&lt;");
+    });
+
+    it("should escape greater than", () => {
+      expect(fmt.escapeHTML(">")).toBe("&gt;");
+    });
+
+    it("should escape quote", () => {
+      expect(fmt.escapeHTML('"')).toBe("&quot;");
+    });
+
+    it("should escape multiple characters", () => {
+      expect(fmt.escapeHTML('<b>&"x"</b>')).toBe(
+        "&lt;b&gt;&amp;&quot;x&quot;&lt;/b&gt;",
+      );
+    });
+
+    it("should escape in bold formatter", () => {
+      const result = fmt.bold('<script>alert("xss")</script>');
+      expect(result).toBe(
+        "<b>&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;</b>",
+      );
+    });
+
+    it("should escape in link formatter", () => {
+      const result = fmt.link("Click <here>", "https://example.com?a=1&b=2");
+      expect(result).toContain("&lt;here&gt;");
+      expect(result).toContain("a=1&amp;b=2");
+    });
+  });
+
+  describe("Markdown Escaping", () => {
+    it("should escape underscore", () => {
+      expect(fmt.escapeMarkdown("_")).toBe("\\_");
+    });
+
+    it("should escape asterisk", () => {
+      expect(fmt.escapeMarkdown("*")).toBe("\\*");
+    });
+
+    it("should escape backtick", () => {
+      expect(fmt.escapeMarkdown("`")).toBe("\\`");
+    });
+
+    it("should escape square bracket", () => {
+      expect(fmt.escapeMarkdown("[")).toBe("\\[");
+    });
+
+    it("should escape multiple markdown characters", () => {
+      expect(fmt.escapeMarkdown("*bold* _italic_ `code`")).toBe(
+        "\\*bold\\* \\_italic\\_ \\`code\\`",
+      );
+    });
+  });
+
+  describe("MarkdownV2 Escaping", () => {
+    it("should escape all reserved characters", () => {
+      const reserved = "_*[]()~`>#+-=|{}.!";
+      const result = fmt.escapeMarkdownV2(reserved);
+      expect(result).toBe(
+        "\\_\\*\\[\\]\\]\\)\\~\\`\\>\\#\\+\\-\\=\\|\\{\\}\\}.\\!",
+      );
+    });
+
+    it("should not escape regular text", () => {
+      const result = fmt.escapeMarkdownV2("Hello World 123");
+      expect(result).toBe("Hello World 123");
+    });
+
+    it("should escape complex markdown", () => {
+      const text = "Click [link](url) or see *bold* text";
+      const result = fmt.escapeMarkdownV2(text);
+      expect(result).toContain("\\[");
+      expect(result).toContain("\\*");
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should escape empty string", () => {
+      expect(fmt.escapeHTML("")).toBe("");
+      expect(fmt.escapeMarkdown("")).toBe("");
+      expect(fmt.escapeMarkdownV2("")).toBe("");
+    });
+
+    it("should escape string with no special chars", () => {
+      const text = "Hello World 123";
+      expect(fmt.escapeHTML(text)).toBe(text);
+    });
+
+    it("should escape repeated special chars", () => {
+      const text = "<<<>>>";
+      expect(fmt.escapeHTML(text)).toBe("&lt;&lt;&lt;&gt;&gt;&gt;");
+    });
+
+    it("should handle unicode in escaping", () => {
+      const text = "🎉 & 🎊";
+      expect(fmt.escapeHTML(text)).toBe("🎉 &amp; 🎊");
+    });
+  });
+
+  describe("Mode Selection", () => {
+    it("should select HTML mode", () => {
+      const text = "<b>Hello</b>";
+      expect(fmt.escape(text, "html")).toContain("&lt;");
+    });
+
+    it("should select Markdown mode", () => {
+      const text = "*Hello*";
+      expect(fmt.escape(text, "markdown")).toContain("\\*");
+    });
+
+    it("should select MarkdownV2 mode", () => {
+      const text = "[]()~`>#+-=|{}.!";
+      const result = fmt.escape(text, "markdownv2");
+      expect(result).toBe("\\[\\]\\)\\~\\`\\>\\#\\+\\-\\=\\|\\{\\}\\}.\\!");
+    });
+
+    it("should default to HTML mode", () => {
+      const text = "<b>Hello</b>";
+      expect(fmt.escape(text)).toContain("&lt;");
+    });
+  });
+});

package/src/formatters/index.d.ts

@@ -0,0 +1,40 @@
+import type { ParseMode } from "../types";
+export declare function escapeHTML(text: string): string;
+export declare function escapeMarkdown(text: string): string;
+export declare function escapeMarkdownV2(text: string): string;
+export declare function bold(text: string): string;
+export declare function italic(text: string): string;
+export declare function underline(text: string): string;
+export declare function strikethrough(text: string): string;
+export declare function spoiler(text: string): string;
+export declare function code(text: string): string;
+export declare function pre(text: string): string;
+export declare function codeBlock(text: string, language?: string): string;
+export declare function link(text: string, url: string): string;
+export declare function mention(userId: number, name?: string): string;
+export declare function hashtag(tag: string): string;
+export declare function customEmoji(emojiId: string): string;
+export declare function email(email: string): string;
+export declare function url(link: string): string;
+export declare function escape(text: string, mode?: ParseMode): string;
+export declare const fmt: {
+    bold: typeof bold;
+    italic: typeof italic;
+    underline: typeof underline;
+    strikethrough: typeof strikethrough;
+    spoiler: typeof spoiler;
+    code: typeof code;
+    pre: typeof pre;
+    codeBlock: typeof codeBlock;
+    link: typeof link;
+    mention: typeof mention;
+    hashtag: typeof hashtag;
+    email: typeof email;
+    url: typeof url;
+    customEmoji: typeof customEmoji;
+    escape: typeof escape;
+    escapeHTML: typeof escapeHTML;
+    escapeMarkdown: typeof escapeMarkdown;
+    escapeMarkdownV2: typeof escapeMarkdownV2;
+};
+//# sourceMappingURL=index.d.ts.map

package/src/formatters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM/C;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMnD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOrD;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExC;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAIjE;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExC;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,SAAkB,GAAG,MAAM,CASrE;AAED,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;CAmBf,CAAC"}

package/src/formatters/index.ts

@@ -0,0 +1,117 @@
+import type { ParseMode } from "../types";
+
+export function escapeHTML(text: string): string {
+  return text
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+export function escapeMarkdown(text: string): string {
+  return text
+    .replace(/_/g, "\\_")
+    .replace(/\*/g, "\\*")
+    .replace(/`/g, "\\`")
+    .replace(/\[/g, "\\[");
+}
+
+export function escapeMarkdownV2(text: string): string {
+  const reserved = "_*[]()~`>#+-=|{}.!";
+  let result = text;
+  for (const char of reserved) {
+    result = result.split(char).join(`\\${char}`);
+  }
+  return result;
+}
+
+export function bold(text: string): string {
+  return `<b>${escapeHTML(text)}</b>`;
+}
+
+export function italic(text: string): string {
+  return `<i>${escapeHTML(text)}</i>`;
+}
+
+export function underline(text: string): string {
+  return `<u>${escapeHTML(text)}</u>`;
+}
+
+export function strikethrough(text: string): string {
+  return `<s>${escapeHTML(text)}</s>`;
+}
+
+export function spoiler(text: string): string {
+  return `<tg-spoiler>${escapeHTML(text)}</tg-spoiler>`;
+}
+
+export function code(text: string): string {
+  return `<code>${escapeHTML(text)}</code>`;
+}
+
+export function pre(text: string): string {
+  return `<pre>${escapeHTML(text)}</pre>`;
+}
+
+export function codeBlock(text: string, language?: string): string {
+  return language
+    ? `<pre><code class="language-${language}">${escapeHTML(text)}</code></pre>`
+    : `<pre>${escapeHTML(text)}</pre>`;
+}
+
+export function link(text: string, url: string): string {
+  return `<a href="${escapeHTML(url)}">${escapeHTML(text)}</a>`;
+}
+
+export function mention(userId: number, name?: string): string {
+  const display = name ? escapeHTML(name) : escapeHTML(`user${userId}`);
+  return `<a href="tg://user?id=${userId}">${display}</a>`;
+}
+
+export function hashtag(tag: string): string {
+  return `<a href="tg://hashtag?tag=${escapeHTML(tag)}">#${escapeHTML(tag)}</a>`;
+}
+
+export function customEmoji(emojiId: string): string {
+  return `<tg-emoji emoji-id="${escapeHTML(emojiId)}">👻</tg-emoji>`;
+}
+
+export function email(email: string): string {
+  return `<a href="mailto:${escapeHTML(email)}">${escapeHTML(email)}</a>`;
+}
+
+export function url(link: string): string {
+  return `<a href="${escapeHTML(link)}">${escapeHTML(link)}</a>`;
+}
+
+export function escape(text: string, mode: ParseMode = "html"): string {
+  switch (mode) {
+    case "html":
+      return escapeHTML(text);
+    case "markdown":
+      return escapeMarkdown(text);
+    case "markdownv2":
+      return escapeMarkdownV2(text);
+  }
+}
+
+export const fmt = {
+  bold,
+  italic,
+  underline,
+  strikethrough,
+  spoiler,
+  code,
+  pre,
+  codeBlock,
+  link,
+  mention,
+  hashtag,
+  email,
+  url,
+  customEmoji,
+  escape,
+  escapeHTML,
+  escapeMarkdown,
+  escapeMarkdownV2,
+};

package/src/formatters.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect } from "bun:test";
+import { fmt } from "../src";
+
+describe("Formatters - fmt helpers", () => {
+  describe("HTML Formatting", () => {
+    it("should format bold text", () => {
+      const result = fmt.bold("Hello");
+      expect(result).toBe("<b>Hello</b>");
+    });
+
+    it("should format italic text", () => {
+      const result = fmt.italic("Hello");
+      expect(result).toBe("<i>Hello</i>");
+    });
+
+    it("should format underlined text", () => {
+      const result = fmt.underline("Hello");
+      expect(result).toBe("<u>Hello</u>");
+    });
+
+    it("should format strikethrough text", () => {
+      const result = fmt.strikethrough("Hello");
+      expect(result).toBe("<s>Hello</s>");
+    });
+
+    it("should format spoiler text", () => {
+      const result = fmt.spoiler("Secret");
+      expect(result).toBe("<tg-spoiler>Secret</tg-spoiler>");
+    });
+
+    it("should format code text", () => {
+      const result = fmt.code("const x = 1");
+      expect(result).toBe("<code>const x = 1</code>");
+    });
+
+    it("should format preformatted text", () => {
+      const result = fmt.pre("line1\nline2");
+      expect(result).toBe("<pre>line1\nline2</pre>");
+    });
+
+    it("should format code block", () => {
+      const result = fmt.codeBlock('console.log("Hello")');
+      expect(result).toBe('<pre><code>console.log("Hello")</code></pre>');
+    });
+
+    it("should format code block with language", () => {
+      const result = fmt.codeBlock("const x = 1", "javascript");
+      expect(result).toBe(
+        '<pre><code class="language-javascript">const x = 1</code></pre>',
+      );
+    });
+  });
+
+  describe("Links and Mentions", () => {
+    it("should format link", () => {
+      const result = fmt.link("Google", "https://google.com");
+      expect(result).toBe('<a href="https://google.com">Google</a>');
+    });
+
+    it("should format mention", () => {
+      const result = fmt.mention(123456);
+      expect(result).toBe('<a href="tg://user?id=123456">user123456</a>');
+    });
+
+    it("should format mention with name", () => {
+      const result = fmt.mention(123456, "John Doe");
+      expect(result).toBe('<a href="tg://user?id=123456">John Doe</a>');
+    });
+
+    it("should format hashtag", () => {
+      const result = fmt.hashtag("test");
+      expect(result).toBe('<a href="tg://hashtag?tag=test">#test</a>');
+    });
+
+    it("should format email", () => {
+      const result = fmt.email("test@example.com");
+      expect(result).toBe(
+        '<a href="mailto:test@example.com">test@example.com</a>',
+      );
+    });
+
+    it("should format URL", () => {
+      const result = fmt.url("https://example.com");
+      expect(result).toBe(
+        '<a href="https://example.com">https://example.com</a>',
+      );
+    });
+
+    it("should format custom emoji", () => {
+      const result = fmt.customEmoji("5368324170672642286");
+      expect(result).toContain('<tg-emoji emoji-id="5368324170672642286">');
+    });
+  });
+
+  describe("Escaping", () => {
+    it("should escape HTML", () => {
+      const text = '<b>Hello</b> & "World"';
+      const result = fmt.escapeHTML(text);
+      expect(result).toBe("&lt;b&gt;Hello&lt;/b&gt; &amp; &quot;World&quot;");
+    });
+
+    it("should escape Markdown", () => {
+      const text = "*Hello* _World_ `code` [link]";
+      const result = fmt.escapeMarkdown(text);
+      expect(result).toContain("\\*");
+      expect(result).toContain("\\_");
+      expect(result).toContain("\\`");
+      expect(result).toContain("\\[");
+    });
+
+    it("should escape MarkdownV2", () => {
+      const text = "*Hello* _World_ `code` [link]";
+      const result = fmt.escapeMarkdownV2(text);
+      expect(result).toContain("\\*");
+      expect(result).toContain("\\_");
+      expect(result).toContain("\\`");
+      expect(result).toContain("\\[");
+      expect(result).toContain("\\]");
+    });
+
+    it("should escape all reserved chars in MarkdownV2", () => {
+      const text = "_*[]()~`>#+-=|{}.!";
+      const result = fmt.escapeMarkdownV2(text);
+      expect(result).toBe(
+        "\\_\\*\\[\\]\\]\\]\\)\\~\\`\\>\\#\\+\\-\\=\\|\\{\\}\\}\\.!",
+      );
+    });
+
+    it("should escape with mode parameter", () => {
+      const text = "<b>Hello</b>";
+      const htmlResult = fmt.escape(text, "html");
+      const mdResult = fmt.escape(text, "markdown");
+      const mdv2Result = fmt.escape(text, "markdownv2");
+
+      expect(htmlResult).toContain("&lt;");
+      expect(mdResult).toContain("<b>");
+      expect(mdv2Result).toContain("<b>");
+    });
+
+    it("should escape text in formatters", () => {
+      const boldResult = fmt.bold("<b>Hello</b>");
+      expect(boldResult).toContain("&lt;b&gt;");
+      expect(boldResult).toContain("&lt;/b&gt;");
+
+      const linkResult = fmt.link("Text", "https://example.com?x=1&y=2");
+      expect(linkResult).toContain("https://example.com?x=1&amp;y=2");
+    });
+  });
+
+  describe("Combined Formatting", () => {
+    it("should combine multiple formatters", () => {
+      const boldItalic = fmt.bold(fmt.italic("Text"));
+      expect(boldItalic).toBe("<b><i>Text</i></b>");
+    });
+
+    it("should format a complex message", () => {
+      const message = `${fmt.bold("Title")}\n\n${fmt.code("const x = 1")}\n\nLink: ${fmt.link("Click here", "https://example.com")}`;
+      expect(message).toContain("<b>Title</b>");
+      expect(message).toContain("<code>const x = 1</code>");
+      expect(message).toContain('<a href="https://example.com">Click here</a>');
+    });
+  });
+});

package/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./types";
+export * from "./formatters";
+export * from "./keyboard";
+export * from "./builder";
+export type { ParseMode, FormatOpts, LineOpts, TelegramMessage, BuildResult, ValidationError, } from "./types/core.types";
+export type { IInlineKeyboardMarkup, IInlineKeyboardButton, IReplyKeyboardMarkup, IKeyboardButton, IForceReplyMarkup, } from "./types/keyboard.types";
+export { fmt } from "./formatters";
+export { TelegramMessageBuilder } from "./builder";
+export { TelegramKeyboardBuilder } from "./keyboard";
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,YAAY,EACV,SAAS,EACT,UAAU,EACV,QAAQ,EACR,eAAe,EACf,WAAW,EACX,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,eAAe,EACf,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AACnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC"}

package/src/index.ts

@@ -0,0 +1,22 @@
+export * from "./types";
+export * from "./formatters";
+export * from "./keyboard";
+export * from "./builder";
+export type {
+  ParseMode,
+  FormatOpts,
+  LineOpts,
+  TelegramMessage,
+  BuildResult,
+  ValidationError,
+} from "./types/core.types";
+export type {
+  IInlineKeyboardMarkup,
+  IInlineKeyboardButton,
+  IReplyKeyboardMarkup,
+  IKeyboardButton,
+  IForceReplyMarkup,
+} from "./types/keyboard.types";
+export { fmt } from "./formatters";
+export { TelegramMessageBuilder } from "./builder";
+export { TelegramKeyboardBuilder } from "./keyboard";

package/src/keyboard/index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Keyboard Builders
+ * @description Fluent API for building Telegram keyboards
+ * @module telegram-message-builder/keyboard
+ */
+import type { IInlineKeyboardMarkup, IInlineKeyboardButton, IReplyKeyboardMarkup, IKeyboardButton, IForceReplyMarkup } from "../types";
+/**
+ * Telegram Keyboard Builder - Fluent API for building keyboards
+ *
+ * @example
+ * ```typescript
+ * const keyboard = TelegramKeyboardBuilder.inline()
+ *   .urlButton('Google', 'https://google.com')
+ *   .row()
+ *   .callbackButton('Yes', 'yes')
+ *   .callbackButton('No', 'no')
+ *   .buildMarkup()
+ * ```
+ */
+export declare class TelegramKeyboardBuilder {
+    private rows;
+    private type;
+    private currentRow;
+    private constructor();
+    /**
+     * Create an inline keyboard builder
+     */
+    static inline(): TelegramKeyboardBuilder;
+    /**
+     * Create a reply keyboard builder
+     */
+    static reply(): TelegramKeyboardBuilder;
+    /**
+     * Create a force reply builder
+     */
+    static forceReply(): TelegramKeyboardBuilder;
+    /**
+     * Add a URL button (inline only)
+     */
+    urlButton(text: string, url: string): this;
+    /**
+     * Add a callback button (inline only)
+     */
+    callbackButton(text: string, data: string): this;
+    /**
+     * Add a web app button (inline only)
+     */
+    webAppButton(text: string, url: string): this;
+    /**
+     * Add a login button (inline only)
+     */
+    loginButton(text: string, url: string, options?: {
+        forwardText?: string;
+        botUsername?: string;
+        requestWriteAccess?: boolean;
+    }): this;
+    /**
+     * Add a switch inline query button (inline only)
+     */
+    switchInlineQueryButton(text: string, query: string): this;
+    /**
+     * Add a switch inline query current chat button (inline only)
+     */
+    switchInlineQueryCurrentChatButton(text: string, query: string): this;
+    /**
+     * Add a callback game button (inline only)
+     */
+    callbackGameButton(text: string, shortName: string): this;
+    /**
+     * Add a pay button (inline only)
+     */
+    payButton(text: string): this;
+    /**
+     * Add a text button (reply keyboard only)
+     */
+    textButton(text: string): this;
+    /**
+     * Add a request contact button (reply keyboard only)
+     */
+    requestContactButton(text: string): this;
+    /**
+     * Add a request location button (reply keyboard only)
+     */
+    requestLocationButton(text: string): this;
+    /**
+     * Add a request poll button (reply keyboard only)
+     */
+    requestPollButton(text: string, pollType: string): this;
+    /**
+     * Add a custom button to current row
+     */
+    button(button: IInlineKeyboardButton | IKeyboardButton): this;
+    /**
+     * Finish current row and start a new one
+     */
+    row(): this;
+    /**
+     * Build inline keyboard markup
+     */
+    buildMarkup(): IInlineKeyboardMarkup;
+    /**
+     * Build reply keyboard markup
+     */
+    buildReplyMarkup(): IReplyKeyboardMarkup;
+    /**
+     * Build force reply markup
+     */
+    buildForceReplyMarkup(): IForceReplyMarkup;
+    /**
+     * Build markup based on keyboard type
+     */
+    build(): IInlineKeyboardMarkup | IReplyKeyboardMarkup | IForceReplyMarkup;
+}
+//# sourceMappingURL=index.d.ts.map

package/src/keyboard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;GAYG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,IAAI,CAAuD;IACnE,OAAO,CAAC,IAAI,CAA0C;IACtD,OAAO,CAAC,UAAU,CAAmD;IAErE,OAAO,eAEN;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,uBAAuB,CAEvC;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,IAAI,uBAAuB,CAEtC;IAED;;OAEG;IACH,MAAM,CAAC,UAAU,IAAI,uBAAuB,CAE3C;IAED;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAMzC;IAED;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAM/C;IAED;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAM5C;IAED;;OAEG;IACH,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B,GACA,IAAI,CAcN;IAED;;OAEG;IACH,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAQzD;IAED;;OAEG;IACH,kCAAkC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAQpE;IAED;;OAEG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAQxD;IAED;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAM5B;IAED;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAM7B;IAED;;OAEG;IACH,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAQvC;IAED;;OAEG;IACH,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAQxC;IAED;;OAEG;IACH,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAQtD;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,qBAAqB,GAAG,eAAe,GAAG,IAAI,CAG5D;IAED;;OAEG;IACH,GAAG,IAAI,IAAI,CAMV;IAED;;OAEG;IACH,WAAW,IAAI,qBAAqB,CAOnC;IAED;;OAEG;IACH,gBAAgB,IAAI,oBAAoB,CAYvC;IAED;;OAEG;IACH,qBAAqB,IAAI,iBAAiB,CAEzC;IAED;;OAEG;IACH,KAAK,IAAI,qBAAqB,GAAG,oBAAoB,GAAG,iBAAiB,CASxE;CACF"}