@tma.js/sdk 0.11.3 → 0.11.5

package/dist/index.js

@@ -0,0 +1,1412 @@
+var nt = Object.defineProperty;
+var it = (s, t, e) => t in s ? nt(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var i = (s, t, e) => (it(s, typeof t != "symbol" ? t + "" : t, e), e);
+import { array as at, string as P, json as j, rgb as w, searchParams as ct } from "@tma.js/parsing";
+import { initData as ht } from "@tma.js/init-data";
+import { supports as C, postEvent as l, on as S, off as F, request as g, detectSupportParams as pt, setDebug as ut, setTargetOrigin as lt, isIframe as dt } from "@tma.js/bridge";
+import { compareVersions as gt, isRecord as bt, withTimeout as _t } from "@tma.js/utils";
+import { EventEmitter as f } from "@tma.js/event-emitter";
+import { isColorDark as J, isRGB as ft } from "@tma.js/colors";
+function y(s, t) {
+  return (e) => C(t[e], s);
+}
+function mt(s, t) {
+  return (e) => {
+    const [o, r] = t[e];
+    return C(o, r, s);
+  };
+}
+class b {
+  constructor(t, e) {
+    this.state = t, this.ee = e;
+  }
+  emit(t, e) {
+    this.ee && this.ee.emit(t, e);
+  }
+  internalSet(t, e) {
+    return this.state[t] === e ? !1 : (this.state[t] = e, this.emit(`${t}Changed`, e), !0);
+  }
+  set(t, e) {
+    let o = !1;
+    if (typeof t == "string")
+      o = this.internalSet(t, e);
+    else
+      for (const r in t)
+        this.internalSet(r, t[r]) && (o = !0);
+    o && this.emit("changed");
+  }
+  get(t) {
+    return this.state[t];
+  }
+}
+class wt {
+  constructor(t, e, o = l) {
+    i(this, "ee", new f());
+    i(this, "state");
+    /**
+     * Adds event listener.
+     * @param event - event name.
+     * @param listener - event listener.
+     */
+    i(this, "on", (t, e) => {
+      if (t === "click")
+        return S("back_button_pressed", e);
+      this.ee.on(t, e);
+    });
+    /**
+     * Removes event listener.
+     * @param event - event name.
+     * @param listener - event listener.
+     */
+    i(this, "off", (t, e) => {
+      if (t === "click")
+        return F("back_button_pressed", e);
+      this.ee.off(t, e);
+    });
+    /**
+     * Checks if specified method is supported by current component.
+     */
+    i(this, "supports");
+    this.postEvent = o, this.state = new b({ isVisible: t }, this.ee), this.supports = y(e, {
+      show: "web_app_setup_back_button",
+      hide: "web_app_setup_back_button"
+    });
+  }
+  set isVisible(t) {
+    this.state.set("isVisible", t), this.postEvent("web_app_setup_back_button", { is_visible: t });
+  }
+  /**
+   * True if BackButton is currently visible.
+   */
+  get isVisible() {
+    return this.state.get("isVisible");
+  }
+  /**
+   * Hides the BackButton.
+   */
+  hide() {
+    this.isVisible = !1;
+  }
+  /**
+   * Shows the BackButton.
+   */
+  show() {
+    this.isVisible = !0;
+  }
+}
+class Ct {
+  constructor(t, e = l) {
+    i(this, "ee", new f());
+    i(this, "state");
+    /**
+     * Adds new event listener.
+     */
+    i(this, "on", this.ee.on.bind(this.ee));
+    /**
+     * Removes event listener.
+     */
+    i(this, "off", this.ee.off.bind(this.ee));
+    this.postEvent = e, this.state = new b({ isConfirmationNeeded: t }, this.ee);
+  }
+  set isConfirmationNeeded(t) {
+    this.state.set("isConfirmationNeeded", t), this.postEvent("web_app_setup_closing_behavior", { need_confirmation: t });
+  }
+  /**
+   * Returns true, if the confirmation dialog enabled while the user is trying
+   * to close the Web App.
+   */
+  get isConfirmationNeeded() {
+    return this.state.get("isConfirmationNeeded");
+  }
+  /**
+   * Disables the confirmation dialog while the user is trying to close the
+   * Web App.
+   */
+  disableConfirmation() {
+    this.isConfirmationNeeded = !1;
+  }
+  /**
+   * Enables the confirmation dialog while the user is trying to close the
+   * Web App.
+   */
+  enableConfirmation() {
+    this.isConfirmationNeeded = !0;
+  }
+}
+const yt = at().of(P());
+function M(s, t) {
+  return s.reduce((e, o) => (e[o] = t, e), {});
+}
+class vt {
+  constructor(t, e, o = l) {
+    /**
+     * Checks if specified method is supported by current component.
+     */
+    i(this, "supports");
+    this.createRequestId = e, this.postEvent = o, this.supports = y(t, {
+      deleteKeys: "web_app_invoke_custom_method",
+      getKeys: "web_app_invoke_custom_method",
+      getValues: "web_app_invoke_custom_method",
+      saveValue: "web_app_invoke_custom_method"
+    });
+  }
+  /**
+   * Invokes custom method related to CloudStorage.
+   * @param method - method name.
+   * @param params - method parameters.
+   * @param options - execution options.
+   */
+  async invokeCustomMethod(t, e, o = {}) {
+    const { result: r, error: n } = await g(
+      "web_app_invoke_custom_method",
+      { method: t, params: e, req_id: this.createRequestId() },
+      "custom_method_invoked",
+      { ...o, postEvent: this.postEvent }
+    );
+    if (n)
+      throw new Error(typeof n == "string" ? n : `Unknown error: ${JSON.stringify(n)}`);
+    return r;
+  }
+  /**
+   * Deletes specified keys from the CloudStorage.
+   * @param keys - keys list.
+   * @param options - request execution options.
+   */
+  async deleteKeys(t, e) {
+    t.length !== 0 && await this.invokeCustomMethod("deleteStorageValues", { keys: t }, e);
+  }
+  /**
+   * Returns list of all keys presented in CloudStorage.
+   * @param options - request execution options.
+   */
+  async getKeys(t) {
+    const e = await this.invokeCustomMethod("getStorageKeys", {}, t);
+    return yt.parse(e);
+  }
+  /**
+   * Returns map, where key is one of the specified in keys argument, and value is according
+   * storage value.
+   * @param keys - keys list.
+   * @param options - request execution options.
+   */
+  async getValues(t, e) {
+    if (t.length === 0)
+      return M(t, "");
+    const o = j(
+      M(t, P())
+      // fixme
+    ), r = await this.invokeCustomMethod("getStorageValues", { keys: t }, e);
+    return o.parse(r);
+  }
+  /**
+   * Saves specified value by key.
+   * @param key - storage key.
+   * @param value - storage value.
+   * @param options - request execution options.
+   */
+  async saveValue(t, e, o) {
+    await this.invokeCustomMethod("saveStorageValue", { key: t, value: e }, o);
+  }
+}
+class kt {
+  constructor(t, e = l) {
+    /**
+     * Checks if specified method is supported by current component.
+     */
+    i(this, "supports");
+    this.postEvent = e, this.supports = y(t, {
+      impactOccurred: "web_app_trigger_haptic_feedback",
+      notificationOccurred: "web_app_trigger_haptic_feedback",
+      selectionChanged: "web_app_trigger_haptic_feedback"
+    });
+  }
+  /**
+   * A method tells that an impact occurred. The Telegram app may play the
+   * appropriate haptics based on style value passed.
+   * @param style - impact style.
+   */
+  impactOccurred(t) {
+    this.postEvent("web_app_trigger_haptic_feedback", { type: "impact", impact_style: t });
+  }
+  /**
+   * A method tells that a task or action has succeeded, failed, or produced
+   * a warning. The Telegram app may play the appropriate haptics based on
+   * type value passed.
+   * @param type - notification type.
+   */
+  notificationOccurred(t) {
+    this.postEvent("web_app_trigger_haptic_feedback", {
+      type: "notification",
+      notification_type: t
+    });
+  }
+  /**
+   * A method tells that the user has changed a selection. The Telegram app
+   * may play the appropriate haptics.
+   *
+   * Do not use this feedback when the user makes or confirms a selection;
+   * use it only when the selection changes.
+   */
+  selectionChanged() {
+    this.postEvent("web_app_trigger_haptic_feedback", { type: "selection_change" });
+  }
+}
+class Et {
+  constructor(t, e, o = {}) {
+    i(this, "state");
+    const {
+      chat: r = null,
+      canSendAfter: n = null,
+      user: c = null,
+      queryId: a = null,
+      receiver: p = null,
+      startParam: h = null
+    } = o;
+    this.state = new b({
+      authDate: t,
+      canSendAfter: n,
+      chat: r,
+      user: c,
+      queryId: a,
+      receiver: p,
+      startParam: h,
+      hash: e
+    });
+  }
+  /**
+   * Init data generation date.
+   */
+  get authDate() {
+    return this.state.get("authDate");
+  }
+  /**
+   * Date after which a message can be sent via the answerWebAppQuery
+   * method.
+   * @see https://core.telegram.org/bots/api#answerwebappquery
+   */
+  get canSendAfter() {
+    return this.state.get("canSendAfter");
+  }
+  /**
+   * An object containing data about the chat where the bot was
+   * launched via the attachment menu. Returned for supergroups, channels and
+   * group chats – only for Web Apps launched via the attachment menu.
+   */
+  get chat() {
+    return this.state.get("chat");
+  }
+  /**
+   * A hash of all passed parameters, which the bot server can use to
+   * check their validity.
+   * @see https://core.telegram.org/bots/webapps#validating-data-received-via-the-web-app
+   */
+  get hash() {
+    return this.state.get("hash");
+  }
+  /**
+   * A unique identifier for the Web App session, required for sending
+   * messages via the `answerWebAppQuery` method.
+   * @see https://core.telegram.org/bots/api#answerwebappquery
+   */
+  get queryId() {
+    return this.state.get("queryId");
+  }
+  /**
+   * An object containing data about the chat partner of the current
+   * user in the chat where the bot was launched via the attachment menu.
+   * Returned only for private chats and only for Web Apps launched
+   * via the attachment menu.
+   */
+  get receiver() {
+    return this.state.get("receiver");
+  }
+  /**
+   * The value of the `startattach` parameter, passed via link. Only
+   * returned for Web Apps when launched from the attachment menu via link.
+   */
+  get startParam() {
+    return this.state.get("startParam");
+  }
+  /**
+   * An object containing data about the current user.
+   */
+  get user() {
+    return this.state.get("user");
+  }
+}
+class xt {
+  constructor(t, e, o, r, n, c, a = l) {
+    i(this, "ee", new f());
+    i(this, "state");
+    /**
+     * Adds new event listener.
+     * FIXME: Event 'main_button_pressed' is still being received on Android
+     *  even if the main button is disabled.
+     *  Issue: https://github.com/Telegram-Mini-Apps/tma.js/issues/3
+     * @param event - event name.
+     * @param listener - event listener.
+     */
+    i(this, "on", (t, e) => {
+      if (t === "click")
+        return S("main_button_pressed", e);
+      this.ee.on(t, e);
+    });
+    /**
+     * Removes event listener.
+     * @param event - event name.
+     * @param listener - event listener.
+     */
+    i(this, "off", (t, e) => {
+      if (t === "click")
+        return F("main_button_pressed", e);
+      this.ee.off(t, e);
+    });
+    this.postEvent = a, this.state = new b({
+      backgroundColor: t,
+      isEnabled: e,
+      isVisible: o,
+      isProgressVisible: r,
+      text: n,
+      textColor: c
+    }, this.ee);
+  }
+  set isEnabled(t) {
+    this.state.set("isEnabled", t), this.commit();
+  }
+  /**
+   * Returns true in case, MainButton is currently enabled.
+   */
+  get isEnabled() {
+    return this.state.get("isEnabled");
+  }
+  set isProgressVisible(t) {
+    this.state.set("isProgressVisible", t), this.commit();
+  }
+  /**
+   * Returns true in case, MainButton loading progress is currently visible.
+   */
+  get isProgressVisible() {
+    return this.state.get("isProgressVisible");
+  }
+  set isVisible(t) {
+    this.state.set("isVisible", t), this.commit();
+  }
+  /**
+   * Returns true in case, MainButton is currently visible.
+   */
+  get isVisible() {
+    return this.state.get("isVisible");
+  }
+  /**
+   * Sends current local button state to Telegram application.
+   */
+  commit() {
+    this.text !== "" && this.postEvent("web_app_setup_main_button", {
+      is_visible: this.isVisible,
+      is_active: this.isEnabled,
+      is_progress_visible: this.isProgressVisible,
+      text: this.text,
+      color: this.backgroundColor,
+      text_color: this.textColor
+    });
+  }
+  /**
+   * Returns current main button background color.
+   */
+  get backgroundColor() {
+    return this.state.get("backgroundColor");
+  }
+  /**
+   * Returns current main button text.
+   */
+  get text() {
+    return this.state.get("text");
+  }
+  /**
+   * Returns current main button text color.
+   */
+  get textColor() {
+    return this.state.get("textColor");
+  }
+  /**
+   * Disables button. Returns current button instance for chaining.
+   */
+  disable() {
+    return this.isEnabled = !1, this;
+  }
+  /**
+   * Enables button. Returns current button instance for chaining.
+   */
+  enable() {
+    return this.isEnabled = !0, this;
+  }
+  /**
+   * Hides button. Returns current button instance for chaining.
+   */
+  hide() {
+    return this.isVisible = !1, this;
+  }
+  /**
+   * Hides button progress. Returns current button instance for chaining.
+   */
+  hideProgress() {
+    return this.isProgressVisible = !1, this;
+  }
+  /**
+   * Shows the button. Note that opening the Web App from the attachment
+   * menu hides the main button until the user interacts with the Web App
+   * interface.
+   *
+   * Returns current button instance for chaining.
+   */
+  show() {
+    return this.isVisible = !0, this;
+  }
+  /**
+   * A method to show a loading indicator on the button.
+   * It is recommended to display loading progress if the action tied to the
+   * button may take a long time.
+   *
+   * Returns current button instance for chaining.
+   */
+  showProgress() {
+    return this.isProgressVisible = !0, this;
+  }
+  /**
+   * Sets new main button text. Returns current button instance for chaining.
+   * Minimal length for text is 1 symbol, and maximum is 64 symbols.
+   *
+   * Returns current button instance for chaining.
+   * @param value - new text.
+   */
+  setText(t) {
+    return this.state.set("text", t), this.commit(), this;
+  }
+  /**
+   * Sets new main button text color. Returns current button instance for
+   * chaining.
+   *
+   * Returns current button instance for chaining.
+   * @param value - new text color.
+   */
+  setTextColor(t) {
+    return this.state.set("textColor", t), this.commit(), this;
+  }
+  /**
+   * Updates current button color. Returns current button instance for
+   * chaining.
+   *
+   * Returns current button instance for chaining.
+   * @param value - color to set.
+   */
+  setBackgroundColor(t) {
+    return this.state.set("backgroundColor", t), this.commit(), this;
+  }
+}
+function Pt(s) {
+  const t = s.message.trim(), e = (s.title || "").trim(), o = s.buttons || [];
+  let r;
+  if (e.length > 64)
+    throw new Error(`Title has incorrect size: ${e.length}`);
+  if (t.length === 0 || t.length > 256)
+    throw new Error(`Message has incorrect size: ${t.length}`);
+  if (o.length > 3)
+    throw new Error(`Buttons have incorrect size: ${o.length}`);
+  return o.length === 0 ? r = [{ type: "close", id: "" }] : r = o.map((n) => {
+    const { id: c = "" } = n;
+    if (c.length > 64)
+      throw new Error(`Button ID has incorrect size: ${c}`);
+    if (n.type === void 0 || n.type === "default" || n.type === "destructive") {
+      const a = n.text.trim();
+      if (a.length === 0 || a.length > 64) {
+        const p = n.type || "default";
+        throw new Error(`Button text with type "${p}" has incorrect size: ${n.text.length}`);
+      }
+      return { ...n, text: a, id: c };
+    }
+    return { ...n, id: c };
+  }), { title: e, message: t, buttons: r };
+}
+class Vt {
+  constructor(t, e = l) {
+    i(this, "ee", new f());
+    i(this, "state");
+    /**
+     * Adds new event listener.
+     */
+    i(this, "on", this.ee.on.bind(this.ee));
+    /**
+     * Removes event listener.
+     */
+    i(this, "off", this.ee.off.bind(this.ee));
+    /**
+     * Checks if specified method is supported by current component.
+     */
+    i(this, "supports");
+    this.postEvent = e, this.state = new b({ isOpened: !1 }, this.ee), this.supports = y(t, { open: "web_app_open_popup" });
+  }
+  /**
+   * Shows whether popup is currently opened.
+   */
+  get isOpened() {
+    return this.state.get("isOpened");
+  }
+  /**
+   * A method that shows a native popup described by the `params` argument.
+   * Promise will be resolved when popup is closed. Resolved value will have
+   * an identifier of pressed button.
+   *
+   * In case, user clicked outside the popup or clicked top right popup close
+   * button, null will be returned.
+   *
+   * FIXME: In desktop, this function may work incorrectly.
+   *  Issue: https://github.com/Telegram-Mini-Apps/tma.js/issues/7
+   * @param params - popup parameters.
+   * @throws {Error} Popup is already opened.
+   */
+  async open(t) {
+    if (this.isOpened)
+      throw new Error("Popup is already opened.");
+    this.state.set("isOpened", !0);
+    try {
+      const { button_id: e = null } = await g(
+        "web_app_open_popup",
+        Pt(t),
+        "popup_closed",
+        { postEvent: this.postEvent }
+      );
+      return e;
+    } finally {
+      this.state.set("isOpened", !1);
+    }
+  }
+}
+class St {
+  constructor(t, e = l) {
+    i(this, "ee", new f());
+    i(this, "state");
+    /**
+     * Adds new event listener.
+     */
+    i(this, "on", this.ee.on.bind(this.ee));
+    /**
+     * Removes event listener.
+     */
+    i(this, "off", this.ee.off.bind(this.ee));
+    /**
+     * Checks if specified method is supported by current component.
+     */
+    i(this, "supports");
+    this.postEvent = e, this.state = new b({ isOpened: !1 }, this.ee), this.supports = y(t, {
+      close: "web_app_close_scan_qr_popup",
+      open: "web_app_open_scan_qr_popup"
+    });
+  }
+  /**
+   * Closes scanner.
+   */
+  close() {
+    this.postEvent("web_app_close_scan_qr_popup"), this.isOpened = !1;
+  }
+  set isOpened(t) {
+    this.state.set("isOpened", t);
+  }
+  /**
+   * Returns true in case, QR scanner is currently opened.
+   */
+  get isOpened() {
+    return this.state.get("isOpened");
+  }
+  /**
+   * Opens scanner with specified title shown to user. Method returns promise
+   * with scanned QR content in case, it was scanned. It will contain null in
+   * case, scanner was closed.
+   * @param text - title to display.
+   */
+  async open(t) {
+    if (this.isOpened)
+      throw new Error("QR scanner is already opened.");
+    this.isOpened = !0;
+    try {
+      const e = await g(
+        "web_app_open_scan_qr_popup",
+        { text: t },
+        ["qr_text_received", "scan_qr_popup_closed"],
+        { postEvent: this.postEvent }
+      );
+      return typeof e == "object" && typeof e.data == "string" ? e.data : null;
+    } finally {
+      this.isOpened = !1;
+    }
+  }
+}
+const qt = j({
+  backgroundColor: { type: w().optional(), from: "bg_color" },
+  buttonColor: { type: w().optional(), from: "button_color" },
+  buttonTextColor: { type: w().optional(), from: "button_text_color" },
+  hintColor: { type: w().optional(), from: "hint_color" },
+  linkColor: { type: w().optional(), from: "link_color" },
+  textColor: { type: w().optional(), from: "text_color" },
+  secondaryBackgroundColor: { type: w().optional(), from: "secondary_bg_color" }
+});
+function $(s) {
+  return qt.parse(s);
+}
+function U(s) {
+  const {
+    backgroundColor: t = null,
+    buttonTextColor: e = null,
+    buttonColor: o = null,
+    hintColor: r = null,
+    linkColor: n = null,
+    textColor: c = null,
+    secondaryBackgroundColor: a = null
+  } = s;
+  return {
+    backgroundColor: t,
+    buttonTextColor: e,
+    buttonColor: o,
+    hintColor: r,
+    linkColor: n,
+    textColor: c,
+    secondaryBackgroundColor: a
+  };
+}
+class q {
+  constructor(t) {
+    i(this, "ee", new f());
+    i(this, "state");
+    /**
+     * Adds new event listener.
+     */
+    i(this, "on", this.ee.on.bind(this.ee));
+    /**
+     * Removes event listener.
+     */
+    i(this, "off", this.ee.off.bind(this.ee));
+    this.state = new b(U(t), this.ee);
+  }
+  /**
+   * Requests fresh information about current theme.
+   * FIXME: Be careful using this function in desktop version of Telegram as
+   *  long as method web_app_request_theme does not work on `macos` platform.
+   * @param options - method options.
+   */
+  static async request(t = {}) {
+    const { timeout: e = 1e3, ...o } = t, r = await g("web_app_request_theme", "theme_changed", {
+      ...o,
+      timeout: e
+    });
+    return $(r.theme_params);
+  }
+  /**
+   * Synchronizes specified instance of ThemeParams with the actual value in the native
+   * application.
+   * @param themeParams - ThemeParams instance.
+   */
+  static sync(t) {
+    S("theme_changed", (e) => {
+      t.state.set(U($(e.theme_params)));
+    });
+  }
+  /**
+   * Returns instance of ThemeParams which is synchronized with external
+   * environment.
+   * @param options - method options.
+   */
+  static async synced(t) {
+    const e = await this.request(t), o = new q(e);
+    return this.sync(o), o;
+  }
+  /**
+   * Returns background color.
+   */
+  get backgroundColor() {
+    return this.state.get("backgroundColor");
+  }
+  /**
+   * Returns button color.
+   */
+  get buttonColor() {
+    return this.state.get("buttonColor");
+  }
+  /**
+   * Returns button text color.
+   */
+  get buttonTextColor() {
+    return this.state.get("buttonTextColor");
+  }
+  /**
+   * Returns hint color.
+   */
+  get hintColor() {
+    return this.state.get("hintColor");
+  }
+  /**
+   * Returns true in case, current color scheme is recognized as dark. This
+   * value is calculated according to theme background color.
+   */
+  get isDark() {
+    return this.backgroundColor === null || J(this.backgroundColor);
+  }
+  /**
+   * Returns current link color.
+   */
+  get linkColor() {
+    return this.state.get("linkColor");
+  }
+  /**
+   * Returns secondary background color.
+   */
+  get secondaryBackgroundColor() {
+    return this.state.get("secondaryBackgroundColor");
+  }
+  /**
+   * Returns text color.
+   */
+  get textColor() {
+    return this.state.get("textColor");
+  }
+}
+function x(s) {
+  return s < 0 ? 0 : s;
+}
+class V {
+  constructor(t, e, o, r, n = l) {
+    i(this, "ee", new f());
+    i(this, "state");
+    /**
+     * Adds new event listener.
+     */
+    i(this, "on", this.ee.on.bind(this.ee));
+    /**
+     * Removes event listener.
+     */
+    i(this, "off", this.ee.off.bind(this.ee));
+    this.postEvent = n, this.state = new b({
+      height: x(t),
+      isExpanded: r,
+      stableHeight: x(o),
+      width: x(e)
+    }, this.ee);
+  }
+  /**
+   * Requests fresh information about current viewport.
+   * FIXME: Be careful using this function in desktop version of Telegram as
+   *  long as method web_app_request_viewport does not work on `macos` platform.
+   * @see Issue: https://github.com/Telegram-Mini-Apps/tma.js/issues/5
+   * @param options - method options.
+   */
+  static async request(t = {}) {
+    const { timeout: e = 1e3, ...o } = t, {
+      is_expanded: r,
+      is_state_stable: n,
+      ...c
+    } = await g("web_app_request_viewport", "viewport_changed", {
+      ...o,
+      timeout: e
+    });
+    return { ...c, isExpanded: r, isStateStable: n };
+  }
+  /**
+   * Synchronizes specified instance of Viewport with the actual value in the native
+   * application.
+   * @param viewport - Viewport instance.
+   */
+  static sync(t) {
+    S("viewport_changed", (e) => {
+      const {
+        height: o,
+        width: r,
+        is_expanded: n,
+        is_state_stable: c
+      } = e, a = x(o);
+      t.state.set({
+        height: a,
+        isExpanded: n,
+        width: x(r),
+        stableHeight: c ? a : void 0
+      });
+    });
+  }
+  /**
+   * Returns initialized instance of Viewport which is synchronized with
+   * its actual state in Web Apps.
+   * @param options - method options.
+   */
+  static async synced(t = {}) {
+    const { height: e, isExpanded: o, width: r } = await this.request(t), n = new V(e, r, e, o, t.postEvent);
+    return this.sync(n), n;
+  }
+  /**
+   * The current height of the visible area of the Web App.
+   *
+   * The application can display just the top part of the Web App, with its
+   * lower part remaining outside the screen area. From this position, the
+   * user can "pull" the Web App to its maximum height, while the bot can do
+   * the same by calling `expand` method. As the position of the Web App
+   * changes, the current height value of the visible area will be updated
+   * in real time.
+   *
+   * Please note that the refresh rate of this value is not sufficient
+   * to smoothly follow the lower border of the window. It should not be
+   * used to pin interface elements to the bottom of the visible area. It's
+   * more appropriate to use the value of the `stableHeight`
+   * field for this purpose.
+   *
+   * @see init
+   * @see expand
+   * @see stableHeight
+   */
+  get height() {
+    return this.state.get("height");
+  }
+  /**
+   * The height of the visible area of the Web App in its last stable state.
+   *
+   * The application can display just the top part of the Web App, with its
+   * lower part remaining outside the screen area. From this position,
+   * the user can "pull" the Web App to its maximum height, while the bot can
+   * do the same by calling `expand` method.
+   *
+   * Unlike the value of `height`, the value of `stableHeight`
+   * does not change as the position of the Web App changes with user
+   * gestures or during animations. The value of `stableHeight`
+   * will be updated after all gestures and animations are completed and
+   * the Web App reaches its final size.
+   *
+   * @see init
+   * @see expand
+   * @see height
+   */
+  get stableHeight() {
+    return this.state.get("stableHeight");
+  }
+  /**
+   * Returns true if the Web App is expanded to the maximum available height.
+   * Otherwise, if the Web App occupies part of the screen and can be expanded
+   * to the full height using `expand` method.
+   * @see expand
+   */
+  get isExpanded() {
+    return this.state.get("isExpanded");
+  }
+  /**
+   * Current viewport width.
+   */
+  get width() {
+    return this.state.get("width");
+  }
+  /**
+   * A method that expands the Web App to the maximum available height. To
+   * find out if the Web App is expanded to the maximum height, refer to the
+   * value of the `isExpanded`.
+   * @see isExpanded
+   */
+  expand() {
+    this.state.set("isExpanded", !0), this.postEvent("web_app_expand");
+  }
+  /**
+   * Returns true in case current viewport height is stable and is not going to
+   * change in the next moment.
+   */
+  get isStable() {
+    return this.stableHeight === this.height;
+  }
+}
+function T(s) {
+  const t = document.createElement("a");
+  if (t.href = s, t.protocol !== "http:" && t.protocol !== "https:")
+    throw Error(
+      `URL protocol is not supported by OS, or link has not allowed protocol: ${t.protocol}`
+    );
+  return t.href;
+}
+class Ot {
+  constructor(t, e, o, r, n, c = l) {
+    i(this, "ee", new f());
+    i(this, "state");
+    /**
+     * Adds new event listener.
+     */
+    i(this, "on", this.ee.on.bind(this.ee));
+    /**
+     * Removes event listener.
+     */
+    i(this, "off", this.ee.off.bind(this.ee));
+    /**
+     * Checks if specified method is supported by current component.
+     */
+    i(this, "supports");
+    /**
+     * Checks if specified method parameter is supported by current component.
+     */
+    i(this, "supportsParam");
+    this.currentVersion = o, this.currentPlatform = r, this.createRequestId = n, this.postEvent = c, this.state = new b({
+      backgroundColor: e,
+      headerColor: t
+    }, this.ee), this.supports = y(o, {
+      openInvoice: "web_app_open_invoice",
+      readTextFromClipboard: "web_app_read_text_from_clipboard",
+      setHeaderColor: "web_app_set_header_color",
+      setBackgroundColor: "web_app_set_background_color",
+      requestPhoneAccess: "web_app_request_phone",
+      requestWriteAccess: "web_app_request_write_access"
+    }), this.supportsParam = mt(o, {
+      "setHeaderColor.color": ["web_app_set_header_color", "color"],
+      "openLink.tryInstantView": ["web_app_open_link", "try_instant_view"]
+    });
+  }
+  /**
+   * Returns current application background color.
+   */
+  get backgroundColor() {
+    return this.state.get("backgroundColor");
+  }
+  /**
+   * Returns current application color scheme. This value is
+   * computed based on the current background color.
+   */
+  get colorScheme() {
+    return J(this.backgroundColor) ? "dark" : "light";
+  }
+  /**
+   * Closes the Web App.
+   */
+  close() {
+    this.postEvent("web_app_close");
+  }
+  /**
+   * Returns current application header color.
+   */
+  get headerColor() {
+    return this.state.get("headerColor");
+  }
+  /**
+   * Returns true if passed version is more than or equal to current
+   * Web App version.
+   * @param version - compared version.
+   */
+  isVersionAtLeast(t) {
+    return gt(t, this.version) >= 0;
+  }
+  /**
+   * Opens a link in an external browser. The Web App will not be closed.
+   *
+   * Note that this method can be called only in response to the user
+   * interaction with the Web App interface (e.g. click inside the Web App
+   * or on the main button).
+   * @param url - URL to be opened.
+   * @param tryInstantView
+   */
+  openLink(t, e) {
+    const o = T(t);
+    if (!C("web_app_open_link", this.version)) {
+      window.open(o, "_blank");
+      return;
+    }
+    return this.postEvent("web_app_open_link", {
+      url: o,
+      ...typeof e == "boolean" ? { try_instant_view: e } : {}
+    });
+  }
+  /**
+   * Opens a Telegram link inside Telegram app. The Web App will be closed.
+   * It expects passing link in full format, with hostname "t.me".
+   * @param url - URL to be opened.
+   * @throws {Error} URL has not allowed hostname.
+   */
+  openTelegramLink(t) {
+    const { hostname: e, pathname: o, search: r } = new URL(T(t));
+    if (e !== "t.me")
+      throw new Error(`URL has not allowed hostname: ${e}. Only "t.me" is allowed`);
+    if (!C("web_app_open_tg_link", this.version)) {
+      window.location.href = t;
+      return;
+    }
+    return this.postEvent("web_app_open_tg_link", { path_full: o + r });
+  }
+  /**
+   * Opens an invoice using its url. It expects passing link in full format,
+   * with hostname "t.me".
+   * @param url - invoice URL.
+   */
+  async openInvoice(t) {
+    const { hostname: e, pathname: o } = new URL(T(t));
+    if (e !== "t.me")
+      throw new Error(`Incorrect hostname: ${e}`);
+    const r = o.match(/^\/(\$|invoice\/)([A-Za-z0-9\-_=]+)$/);
+    if (r === null)
+      throw new Error('Link pathname has incorrect format. Expected to receive "/invoice/slug" or "/$slug"');
+    const [, , n] = r;
+    return (await g("web_app_open_invoice", { slug: n }, "invoice_closed", {
+      postEvent: this.postEvent,
+      capture: ({ slug: a }) => n === a
+    })).status;
+  }
+  /**
+   * Returns current Web App platform.
+   */
+  get platform() {
+    return this.currentPlatform;
+  }
+  /**
+   * Informs the Telegram app that the Web App is ready to be displayed.
+   *
+   * It is recommended to call this method as early as possible, as soon as
+   * all essential interface elements loaded. Once this method called,
+   * the loading placeholder is hidden and the Web App shown.
+   *
+   * If the method not called, the placeholder will be hidden only when
+   * the page fully loaded.
+   */
+  ready() {
+    this.postEvent("web_app_ready");
+  }
+  /**
+   * Reads text from clipboard and returns string or null. null is returned
+   * in cases:
+   * - Value in clipboard is not text
+   * - Access to clipboard is not allowed
+   */
+  async readTextFromClipboard() {
+    const { data: t = null } = await g(
+      "web_app_read_text_from_clipboard",
+      { req_id: this.createRequestId() },
+      "clipboard_text_received",
+      { postEvent: this.postEvent }
+    );
+    return t;
+  }
+  /**
+   * Requests current user phone access.
+   */
+  async requestPhoneAccess() {
+    const { status: t } = await g("web_app_request_phone", "phone_requested", {
+      postEvent: this.postEvent
+    });
+    return t;
+  }
+  /**
+   * Requests write message access to current user.
+   */
+  async requestWriteAccess() {
+    const { status: t } = await g("web_app_request_write_access", "write_access_requested", {
+      postEvent: this.postEvent
+    });
+    return t;
+  }
+  /**
+   * A method used to send data to the bot. When this method called, a
+   * service message sent to the bot containing the data of the
+   * length up to 4096 bytes, and the Web App closed. See the field
+   * `web_app_data` in the class Message.
+   *
+   * This method is only available for Web Apps launched via a Keyboard button.
+   * @param data - data to send to bot.
+   * @throws {Error} data has incorrect size.
+   */
+  sendData(t) {
+    const { size: e } = new Blob([t]);
+    if (e === 0 || e > 4096)
+      throw new Error(`Passed data has incorrect size: ${e}`);
+    this.postEvent("web_app_data_send", { data: t });
+  }
+  /**
+   * Updates current application header color.
+   * FIXME: Has no effect on desktop, works incorrectly on Android.
+   *  Issues:
+   *  https://github.com/Telegram-Mini-Apps/tma.js/issues/9
+   *  https://github.com/Telegram-Mini-Apps/tma.js/issues/8
+   * @param color - color key or RGB color.
+   */
+  setHeaderColor(t) {
+    this.postEvent("web_app_set_header_color", ft(t) ? { color: t } : { color_key: t }), this.state.set("headerColor", t);
+  }
+  /**
+   * Updates current application background color.
+   * FIXME: Has no effect on desktop, works incorrectly in Android.
+   *  Issues:
+   *  https://github.com/Telegram-Mini-Apps/tma.js/issues/9
+   *  https://github.com/Telegram-Mini-Apps/tma.js/issues/8
+   * @param color - RGB color.
+   */
+  setBackgroundColor(t) {
+    this.postEvent("web_app_set_background_color", { color: t }), this.state.set("backgroundColor", t);
+  }
+  /**
+   * Current Web App version. This property is used by other components to check if
+   * some functionality is available on current device.
+   */
+  get version() {
+    return this.currentVersion;
+  }
+}
+function G(s) {
+  return `telegram-web-apps-${s}`;
+}
+function v(s, t) {
+  sessionStorage.setItem(G(s), JSON.stringify(t));
+}
+function k(s) {
+  const t = sessionStorage.getItem(G(s));
+  return t ? JSON.parse(t) : null;
+}
+const Bt = ct({
+  version: { type: P(), from: "tgWebAppVersion" },
+  initData: { type: ht.optional(), from: "tgWebAppData" },
+  initDataRaw: { type: P().optional(), from: "tgWebAppData" },
+  platform: { type: P(), from: "tgWebAppPlatform" },
+  themeParams: { type: $, from: "tgWebAppThemeParams" }
+});
+function R(s) {
+  return Bt.parse(s);
+}
+function Q() {
+  const s = [];
+  try {
+    const t = window.location.hash.slice(1), e = R(t);
+    return v("launch-params", t), e;
+  } catch (t) {
+    s.push(t instanceof Error ? t.message : "unknown error");
+  }
+  try {
+    const t = k("launch-params");
+    if (t)
+      return R(t);
+    s.push("Launch params are missing in local storage");
+  } catch (t) {
+    s.push(t instanceof Error ? t.message : "unknown error");
+  }
+  throw new Error(`Unable to extract launch params. Errors: "${s.join('", "')}"`);
+}
+function Z(s, t) {
+  document.documentElement.style.setProperty(s, t);
+}
+function d(s, t) {
+  t !== null && Z(s, t);
+}
+function K(s, t) {
+  Z(s, `${t}px`);
+}
+function At(s) {
+  const {
+    backgroundColor: t,
+    buttonTextColor: e,
+    secondaryBackgroundColor: o,
+    hintColor: r,
+    buttonColor: n,
+    linkColor: c,
+    textColor: a
+  } = s;
+  d("--tg-theme-bg-color", t), d("--tg-theme-button-color", n), d("--tg-theme-button-text-color", e), d("--tg-theme-hint-color", r), d("--tg-theme-link-color", c), d("--tg-theme-secondary-bg-color", o), d("--tg-theme-text-color", a);
+}
+function Tt(s, t) {
+  const { backgroundColor: e, secondaryBackgroundColor: o } = t, { backgroundColor: r, headerColor: n } = s;
+  d("--tg-bg-color", r), d("--tg-header-color", n === "bg_color" ? e : o);
+}
+function $t(s) {
+  const t = () => At(s);
+  s.on("changed", t), t();
+}
+function Rt(s, t) {
+  const e = () => Tt(s, t);
+  t.on("changed", e), s.on("backgroundColorChanged", e), s.on("headerColorChanged", e), e();
+}
+function Ht(s) {
+  const t = () => {
+    K("--tg-viewport-height", s.height);
+  }, e = () => {
+    K("--tg-viewport-stable-height", s.stableHeight);
+  };
+  s.on("heightChanged", t), s.on("stableHeightChanged", e), t(), e();
+}
+function It(s) {
+  return typeof s == "boolean" ? s ? { themeParams: !0, viewport: !0, webApp: !0 } : {} : s;
+}
+function Dt(s, t) {
+  const { isVisible: e = !1 } = k("back-button") || {}, o = new wt(e, s, t);
+  return o.on("isVisibleChanged", () => {
+    v("back-button", { isVisible: o.isVisible });
+  }), o;
+}
+function Wt(s) {
+  const { isConfirmationNeeded: t = !1 } = k("closing-behavior") || {}, e = new Ct(t, s);
+  return e.on("isConfirmationNeededChanged", () => v("closing-behavior", {
+    isConfirmationNeeded: e.isConfirmationNeeded
+  })), e;
+}
+function Lt(s, t, e) {
+  const {
+    backgroundColor: o = s,
+    isEnabled: r = !1,
+    isVisible: n = !1,
+    isProgressVisible: c = !1,
+    textColor: a = t,
+    text: p = ""
+  } = k("main-button") || {}, h = new xt(
+    o,
+    r,
+    n,
+    c,
+    p,
+    a,
+    e
+  ), _ = () => v("main-button", {
+    backgroundColor: h.backgroundColor,
+    isEnabled: h.isEnabled,
+    isVisible: h.isVisible,
+    isProgressVisible: h.isProgressVisible,
+    text: h.text,
+    textColor: h.textColor
+  });
+  return h.on("backgroundColorChanged", _), h.on("isEnabledChanged", _), h.on("isVisibleChanged", _), h.on("isProgressVisibleChanged", _), h.on("textColorChanged", _), h.on("textChanged", _), h;
+}
+class H extends Error {
+  constructor(t, e) {
+    super(`Method "${t}" is not supported in the Web Apps version ${e}.`), Object.setPrototypeOf(this, H.prototype);
+  }
+}
+class I extends Error {
+  constructor(t, e, o) {
+    super(`Parameter "${e}" in method "${t}" is not supported in the Web Apps version ${o}.`), Object.setPrototypeOf(this, I.prototype);
+  }
+}
+function Nt(s, t) {
+  return s ? (e, o) => {
+    if (!C(e, t))
+      throw new H(e, t);
+    return bt(o) && pt(e, o).forEach((r) => {
+      if (!C(e, r, t))
+        throw new I(e, r, t);
+    }), l(e, o);
+  } : l;
+}
+function zt() {
+  let s = 0;
+  return () => (s += 1, s.toString());
+}
+function Mt(s) {
+  const t = new q(s);
+  return q.sync(t), t;
+}
+async function Ut(s, t) {
+  const {
+    height: e = window.innerHeight,
+    stableHeight: o = window.innerHeight,
+    width: r = window.innerWidth,
+    isExpanded: n = !1
+  } = k("viewport") || {}, a = s === "macos" || s === "web" ? (() => {
+    const h = new V(e, r, o, n, t);
+    return V.sync(h), h;
+  })() : await V.synced({ postEvent: t }), p = () => v("viewport", {
+    height: a.height,
+    isExpanded: a.isExpanded,
+    stableHeight: a.stableHeight,
+    width: a.width
+  });
+  return a.on("heightChanged", p), a.on("isExpandedChanged", p), a.on("stableHeightChanged", p), a.on("widthChanged", p), a;
+}
+function Kt(s, t, e, o, r) {
+  const {
+    backgroundColor: n = s,
+    headerColor: c = "bg_color"
+  } = k("web-app") || {}, a = new Ot(
+    c,
+    n,
+    t,
+    e,
+    o,
+    r
+  ), p = () => v("web-app", {
+    backgroundColor: a.backgroundColor,
+    headerColor: a.headerColor
+  });
+  return a.on("backgroundColorChanged", p), a.on("headerColorChanged", p), a;
+}
+async function jt(s = {}) {
+  const {
+    checkCompat: t = !0,
+    cssVars: e = !1,
+    acceptScrollbarStyle: o = !0,
+    acceptCustomStyles: r = o,
+    targetOrigin: n,
+    debug: c = !1,
+    launchParams: a
+  } = s;
+  c && ut(c), typeof n == "string" && lt(n);
+  let p;
+  a ? p = a instanceof URLSearchParams || typeof a == "string" ? R(a) : a : p = Q();
+  const {
+    initData: h,
+    initDataRaw: _,
+    version: m,
+    platform: D,
+    themeParams: W
+  } = p, {
+    backgroundColor: X = "#ffffff",
+    buttonColor: Y = "#000000",
+    buttonTextColor: tt = "#ffffff"
+  } = W, L = zt(), u = Nt(t, m), O = Mt(W), N = Kt(X, m, D, L, u), {
+    themeParams: et,
+    viewport: st,
+    webApp: ot
+  } = It(e);
+  ot && Rt(N, O), et && $t(O);
+  const z = await Ut(D, u);
+  if (st && Ht(z), r && dt()) {
+    const E = document.createElement("style");
+    E.id = "telegram-custom-styles", document.head.appendChild(E), S("set_custom_style", (A) => {
+      E.innerHTML = A;
+    }), u("iframe_ready");
+  }
+  const B = {
+    backButton: Dt(m, u),
+    closingBehavior: Wt(u),
+    cloudStorage: new vt(m, L, u),
+    haptic: new kt(m, u),
+    mainButton: Lt(Y, tt, u),
+    popup: new Vt(m, u),
+    postEvent: u,
+    qrScanner: new St(m, u),
+    themeParams: O,
+    viewport: z,
+    webApp: N
+  };
+  if (h !== void 0) {
+    const { authDate: E, hash: A, ...rt } = h;
+    B.initData = new Et(E, A, rt), B.initDataRaw = _;
+  }
+  return B;
+}
+function te(s = {}) {
+  return _t(jt(s), s.timeout || 1e3);
+}
+function ee() {
+  try {
+    return Q(), !0;
+  } catch {
+    return !1;
+  }
+}
+export {
+  wt as BackButton,
+  Ct as ClosingBehaviour,
+  vt as CloudStorage,
+  kt as HapticFeedback,
+  Et as InitData,
+  xt as MainButton,
+  H as MethodNotSupportedError,
+  Vt as Popup,
+  St as QRScanner,
+  q as ThemeParams,
+  V as Viewport,
+  Ot as WebApp,
+  T as formatURL,
+  te as init,
+  ee as isTWA,
+  R as parseLaunchParams,
+  $ as parseThemeParams,
+  Q as retrieveLaunchParams
+};
+//# sourceMappingURL=index.js.map