@tma.js/sdk 1.5.3 → 2.0.0

package/dist/index.js

@@ -0,0 +1,2998 @@
+var Mt = Object.defineProperty;
+var Lt = (e, t, s) => t in e ? Mt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s;
+var c = (e, t, s) => (Lt(e, typeof t != "symbol" ? t + "" : t, s), s);
+function ct(e, t) {
+  let s;
+  const n = () => {
+    s !== void 0 && t && t(s), s = void 0;
+  };
+  return [() => s === void 0 ? s = e(n) : s, n];
+}
+function ht(e) {
+  const t = L(), { count: s } = t;
+  t.unsubscribe(e), s && !t.count && ae();
+}
+function Bt(e) {
+  return L().subscribe(e), () => ht(e);
+}
+class Ot {
+  constructor(t, s = {}) {
+    this.scope = t, this.options = s;
+  }
+  /**
+   * Prints message into a console in case, logger is currently enabled.
+   * @param level - log level.
+   * @param args - arguments.
+   */
+  print(t, ...s) {
+    const n = /* @__PURE__ */ new Date(), r = Intl.DateTimeFormat("en-GB", {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      fractionalSecondDigits: 3,
+      timeZone: "UTC"
+    }).format(n), { textColor: i, bgColor: o } = this.options, a = "font-weight: bold;padding: 0 5px;border-radius:5px";
+    console[t](
+      `%c${r}%c / %c${this.scope}`,
+      `${a};background-color: lightblue;color:black`,
+      "",
+      `${a};${i ? `color:${i};` : ""}${o ? `background-color:${o}` : ""}`,
+      ...s
+    );
+  }
+  /**
+   * Prints error message into a console.
+   * @param args
+   */
+  error(...t) {
+    this.print("error", ...t);
+  }
+  /**
+   * Prints log message into a console.
+   * @param args
+   */
+  log(...t) {
+    this.print("log", ...t);
+  }
+}
+const D = new Ot("SDK", {
+  bgColor: "forestgreen",
+  textColor: "white"
+});
+let j = !1;
+const nt = ({ event: e, args: [t] }) => {
+  D.log("Event received:", t === void 0 ? { name: e } : { name: e, data: t });
+};
+function es(e) {
+  j !== e && (j = e, e ? Bt(nt) : ht(nt));
+}
+function Ut(...e) {
+  j && D.log(...e);
+}
+class V {
+  constructor() {
+    c(this, "listeners", /* @__PURE__ */ new Map());
+    c(this, "listenersCount", 0);
+    c(this, "subscribeListeners", []);
+  }
+  /**
+   * Removes all event listeners.
+   */
+  clear() {
+    this.listeners.clear(), this.subscribeListeners = [];
+  }
+  /**
+   * Returns count of bound listeners.
+   */
+  get count() {
+    return this.listenersCount + this.subscribeListeners.length;
+  }
+  emit(t, ...s) {
+    this.subscribeListeners.forEach((r) => r({
+      event: t,
+      args: s
+    })), (this.listeners.get(t) || []).forEach(([r, i]) => {
+      r(...s), i && this.off(t, r);
+    });
+  }
+  /**
+   * Adds new event listener.
+   * @param event - event name.
+   * @param listener - event listener.
+   * @param once - should listener be called only once.
+   * @returns Function to remove bound event listener.
+   */
+  on(t, s, n) {
+    let r = this.listeners.get(t);
+    return r || this.listeners.set(t, r = []), r.push([s, n]), this.listenersCount += 1, () => this.off(t, s);
+  }
+  /**
+   * Removes event listener. In case, specified listener was bound several times, it removes
+   * only a single one.
+   * @param event - event name.
+   * @param listener - event listener.
+   */
+  off(t, s) {
+    const n = this.listeners.get(t) || [];
+    for (let r = 0; r < n.length; r += 1)
+      if (s === n[r][0]) {
+        n.splice(r, 1), this.listenersCount -= 1;
+        return;
+      }
+  }
+  /**
+   * Adds a new event listener for all events.
+   * @param listener - event listener.
+   * @returns Function to remove event listener.
+   */
+  subscribe(t) {
+    return this.subscribeListeners.push(t), () => this.unsubscribe(t);
+  }
+  /**
+   * Removes global event listener. In case, specified listener was bound several times, it removes
+   * only a single one.
+   * @param listener - event listener.
+   */
+  unsubscribe(t) {
+    for (let s = 0; s < this.subscribeListeners.length; s += 1)
+      if (this.subscribeListeners[s] === t) {
+        this.subscribeListeners.splice(s, 1);
+        return;
+      }
+  }
+}
+function z(e, t, s) {
+  return window.addEventListener(e, t, s), () => window.removeEventListener(e, t, s);
+}
+class $ extends Error {
+  constructor(t, s, n) {
+    super(s, { cause: n }), this.type = t, Object.setPrototypeOf(this, $.prototype);
+  }
+}
+function u(e, t, s) {
+  return new $(e, t, s);
+}
+const Wt = "ERR_METHOD_UNSUPPORTED", Ht = "ERR_METHOD_PARAMETER_UNSUPPORTED", Gt = "ERR_UNKNOWN_ENV", jt = "ERR_INVOKE_CUSTOM_METHOD_RESPONSE", zt = "ERR_TIMED_OUT", Ft = "ERR_UNEXPECTED_TYPE", pt = "ERR_PARSE", Jt = "ERR_NAVIGATION_LIST_EMPTY", Qt = "ERR_NAVIGATION_CURSOR_INVALID", ss = "ERR_NAVIGATION_ITEM_INVALID", J = "ERR_SSR_INIT", Yt = "ERR_SSR_POST_EVENT", Zt = "ERR_INVALID_PATH_BASE";
+function P() {
+  return u(Ft, "Value has unexpected type");
+}
+class M {
+  constructor(t, s, n) {
+    this.parser = t, this.isOptional = s, this.type = n;
+  }
+  /**
+   * Attempts to parse passed value
+   * @param value - value to parse.
+   * @throws {SDKError} ERR_PARSE
+   * @see ERR_PARSE
+   */
+  parse(t) {
+    if (!(this.isOptional && t === void 0))
+      try {
+        return this.parser(t);
+      } catch (s) {
+        throw u(
+          pt,
+          `Unable to parse value${this.type ? ` as ${this.type}` : ""}`,
+          s
+        );
+      }
+  }
+  optional() {
+    return this.isOptional = !0, this;
+  }
+}
+function S(e, t) {
+  return () => new M(e, !1, t);
+}
+const w = S((e) => {
+  if (typeof e == "boolean")
+    return e;
+  const t = String(e);
+  if (t === "1" || t === "true")
+    return !0;
+  if (t === "0" || t === "false")
+    return !1;
+  throw P();
+}, "boolean");
+function ut(e, t) {
+  const s = {};
+  for (const n in e) {
+    const r = e[n];
+    if (!r)
+      continue;
+    let i, o;
+    if (typeof r == "function" || "parse" in r)
+      i = n, o = typeof r == "function" ? r : r.parse.bind(r);
+    else {
+      const { type: a } = r;
+      i = r.from || n, o = typeof a == "function" ? a : a.parse.bind(a);
+    }
+    try {
+      const a = o(t(i));
+      a !== void 0 && (s[n] = a);
+    } catch (a) {
+      throw u(pt, `Unable to parse field "${n}"`, a);
+    }
+  }
+  return s;
+}
+function Q(e) {
+  let t = e;
+  if (typeof t == "string" && (t = JSON.parse(t)), typeof t != "object" || t === null || Array.isArray(t))
+    throw P();
+  return t;
+}
+function _(e, t) {
+  return new M((s) => {
+    const n = Q(s);
+    return ut(e, (r) => n[r]);
+  }, !1, t);
+}
+const y = S((e) => {
+  if (typeof e == "number")
+    return e;
+  if (typeof e == "string") {
+    const t = Number(e);
+    if (!Number.isNaN(t))
+      return t;
+  }
+  throw P();
+}, "number");
+function Y(e) {
+  return /^#[\da-f]{6}$/i.test(e);
+}
+function Xt(e) {
+  return /^#[\da-f]{3}$/i.test(e);
+}
+function lt(e) {
+  const t = e.replace(/\s/g, "").toLowerCase();
+  if (Y(t))
+    return t;
+  if (Xt(t)) {
+    let n = "#";
+    for (let r = 0; r < 3; r += 1)
+      n += t[1 + r].repeat(2);
+    return n;
+  }
+  const s = t.match(/^rgb\((\d{1,3}),(\d{1,3}),(\d{1,3})\)$/) || t.match(/^rgba\((\d{1,3}),(\d{1,3}),(\d{1,3}),\d{1,3}\)$/);
+  if (!s)
+    throw new Error(`Value "${e}" does not satisfy any of known RGB formats.`);
+  return s.slice(1).reduce((n, r) => {
+    const i = parseInt(r, 10).toString(16);
+    return n + (i.length === 1 ? "0" : "") + i;
+  }, "#");
+}
+const h = S((e) => {
+  if (typeof e == "string" || typeof e == "number")
+    return e.toString();
+  throw P();
+}, "string"), dt = S((e) => lt(h().parse(e)), "rgb");
+function Kt(e) {
+  return _({
+    eventType: h(),
+    eventData: (t) => t
+  }).parse(e);
+}
+function te() {
+  ["TelegramGameProxy_receiveEvent", "TelegramGameProxy", "Telegram"].forEach((e) => {
+    delete window[e];
+  });
+}
+function ee(e, t) {
+  window.dispatchEvent(new MessageEvent("message", {
+    data: JSON.stringify({ eventType: e, eventData: t }),
+    // We specify window.parent to imitate the case, the parent iframe sent us this event.
+    source: window.parent
+  }));
+}
+function se() {
+  [
+    ["TelegramGameProxy_receiveEvent"],
+    // Windows Phone.
+    ["TelegramGameProxy", "receiveEvent"],
+    // Desktop.
+    ["Telegram", "WebView", "receiveEvent"]
+    // Android and iOS.
+  ].forEach((e) => {
+    let t = window;
+    e.forEach((s, n, r) => {
+      if (n === r.length - 1) {
+        t[s] = ee;
+        return;
+      }
+      s in t || (t[s] = {}), t = t[s];
+    });
+  });
+}
+const ne = _({
+  button_id: (e) => e == null ? void 0 : h().parse(e)
+}), re = {
+  clipboard_text_received: _({
+    req_id: h(),
+    data: (e) => e === null ? e : h().optional().parse(e)
+  }),
+  custom_method_invoked: _({
+    req_id: h(),
+    result: (e) => e,
+    error: h().optional()
+  }),
+  invoice_closed: _({
+    slug: h(),
+    status: h()
+  }),
+  phone_requested: _({
+    status: h()
+  }),
+  popup_closed: {
+    parse: (e) => ne.parse(e ?? {})
+  },
+  qr_text_received: _({
+    data: h().optional()
+  }),
+  theme_changed: _({
+    theme_params: (e) => {
+      const t = dt().optional();
+      return Object.entries(Q(e)).reduce((s, [n, r]) => (s[n] = t.parse(r), s), {});
+    }
+  }),
+  viewport_changed: _({
+    height: y(),
+    width: (e) => e == null ? window.innerWidth : y().parse(e),
+    is_state_stable: w(),
+    is_expanded: w()
+  }),
+  write_access_requested: _({
+    status: h()
+  })
+};
+function ie() {
+  const e = new V();
+  se();
+  let t = [
+    // Don't forget to remove created handlers.
+    te,
+    // Add "resize" event listener to make sure, we always have fresh viewport information.
+    // Desktop version of Telegram is sometimes not sending the viewport_changed
+    // event. For example, when the MainButton is shown. That's why we should
+    // add our own listener to make sure, viewport information is always fresh.
+    // Issue: https://github.com/Telegram-Mini-Apps/tma.js/issues/10
+    z("resize", () => {
+      e.emit("viewport_changed", {
+        width: window.innerWidth,
+        height: window.innerHeight,
+        is_state_stable: !0,
+        is_expanded: !0
+      });
+    }),
+    // Add listener, which handles events sent from the Telegram web application and also events
+    // generated by the local emitEvent function.
+    z("message", (s) => {
+      if (s.source !== window.parent)
+        return;
+      let n;
+      try {
+        n = Kt(s.data);
+      } catch {
+        return;
+      }
+      const { eventType: r, eventData: i } = n, o = re[r];
+      try {
+        const a = o ? o.parse(i) : i;
+        e.emit(...a ? [r, a] : [r]);
+      } catch (a) {
+        D.error(
+          `An error occurred processing the "${r}" event from the Telegram application. Please, file an issue here: https://github.com/Telegram-Mini-Apps/tma.js/issues/new/choose`,
+          n,
+          a
+        );
+      }
+    }),
+    // Clear emitter bound events.
+    () => e.clear()
+  ];
+  return [e, () => {
+    t.forEach((s) => s()), t = [];
+  }];
+}
+const [oe, ae] = ct(
+  (e) => {
+    const [t, s] = ie(), n = t.off.bind(t);
+    return t.off = (r, i) => {
+      const { count: o } = t;
+      n(r, i), o && !t.count && e();
+    }, [t, s];
+  },
+  ([, e]) => e()
+);
+function L() {
+  return oe()[0];
+}
+function B(e, t) {
+  L().off(e, t);
+}
+function b(e, t, s) {
+  return L().on(e, t, s);
+}
+function I(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function ce(e, t) {
+  const s = e.split("."), n = t.split("."), r = Math.max(s.length, n.length);
+  for (let i = 0; i < r; i += 1) {
+    const o = parseInt(s[i] || "0", 10), a = parseInt(n[i] || "0", 10);
+    if (o !== a)
+      return o > a ? 1 : -1;
+  }
+  return 0;
+}
+function g(e, t) {
+  return ce(e, t) <= 0;
+}
+function v(e, t, s) {
+  if (typeof s == "string") {
+    if (e === "web_app_open_link" && t === "try_instant_view")
+      return g("6.4", s);
+    if (e === "web_app_set_header_color" && t === "color")
+      return g("6.9", s);
+  }
+  switch (e) {
+    case "web_app_open_tg_link":
+    case "web_app_open_invoice":
+    case "web_app_setup_back_button":
+    case "web_app_set_background_color":
+    case "web_app_set_header_color":
+    case "web_app_trigger_haptic_feedback":
+      return g("6.1", t);
+    case "web_app_open_popup":
+      return g("6.2", t);
+    case "web_app_close_scan_qr_popup":
+    case "web_app_open_scan_qr_popup":
+    case "web_app_read_text_from_clipboard":
+      return g("6.4", t);
+    case "web_app_switch_inline_query":
+      return g("6.7", t);
+    case "web_app_invoke_custom_method":
+    case "web_app_request_write_access":
+    case "web_app_request_phone":
+      return g("6.9", t);
+    case "web_app_setup_settings_button":
+      return g("6.10", t);
+    case "web_app_biometry_get_info":
+    case "web_app_biometry_open_settings":
+    case "web_app_biometry_request_access":
+    case "web_app_biometry_request_auth":
+    case "web_app_biometry_update_token":
+      return g("7.2", t);
+    default:
+      return [
+        "iframe_ready",
+        "iframe_will_reload",
+        "web_app_close",
+        "web_app_data_send",
+        "web_app_expand",
+        "web_app_open_link",
+        "web_app_ready",
+        "web_app_request_theme",
+        "web_app_request_viewport",
+        "web_app_setup_main_button",
+        "web_app_setup_closing_behavior"
+      ].includes(e);
+  }
+}
+function he(e) {
+  return "external" in e && I(e.external) && "notify" in e.external && typeof e.external.notify == "function";
+}
+function pe(e) {
+  return "TelegramWebviewProxy" in e && I(e.TelegramWebviewProxy) && "postEvent" in e.TelegramWebviewProxy && typeof e.TelegramWebviewProxy.postEvent == "function";
+}
+function ue() {
+  try {
+    return window.self !== window.top;
+  } catch {
+    return !0;
+  }
+}
+let _t = "https://web.telegram.org";
+function ns(e) {
+  _t = e;
+}
+function le() {
+  return _t;
+}
+function T(e, t, s) {
+  let n = {}, r;
+  t === void 0 && s === void 0 ? n = {} : t !== void 0 && s !== void 0 ? (n = s, r = t) : t !== void 0 && ("targetOrigin" in t ? n = t : r = t);
+  const { targetOrigin: i = le() } = n;
+  if (Ut("Posting event:", r ? { event: e, data: r } : { event: e }), ue()) {
+    window.parent.postMessage(JSON.stringify({ eventType: e, eventData: r }), i);
+    return;
+  }
+  if (he(window)) {
+    window.external.notify(JSON.stringify({ eventType: e, eventData: r }));
+    return;
+  }
+  if (pe(window)) {
+    window.TelegramWebviewProxy.postEvent(e, JSON.stringify(r));
+    return;
+  }
+  throw u(
+    Gt,
+    "Unable to determine current environment and possible way to send event. You are probably trying to use Mini Apps method outside of Telegram application environment."
+  );
+}
+function de(e) {
+  return (t, s) => {
+    if (!v(t, e))
+      throw u(Wt, `Method "${t}" is unsupported in Mini Apps version ${e}`);
+    if (I(s)) {
+      let n;
+      if (t === "web_app_open_link" && "try_instant_view" in s ? n = "try_instant_view" : t === "web_app_set_header_color" && "color" in s && (n = "color"), n && !v(t, n, e))
+        throw u(
+          Ht,
+          `Parameter "${n}" of "${t}" method is unsupported in Mini Apps version ${e}`
+        );
+    }
+    return T(t, s);
+  };
+}
+function ft(e) {
+  return ({ req_id: t }) => t === e;
+}
+function gt(e) {
+  return u(zt, `Timeout reached: ${e}ms`);
+}
+function bt(e, t) {
+  return Promise.race([
+    typeof e == "function" ? e() : e,
+    new Promise((s, n) => {
+      setTimeout(() => {
+        n(gt(t));
+      }, t);
+    })
+  ]);
+}
+async function f(e) {
+  let t;
+  const s = new Promise((d) => {
+    t = d;
+  }), {
+    method: n,
+    event: r,
+    capture: i,
+    postEvent: o = T,
+    timeout: a
+  } = e, p = (Array.isArray(r) ? r : [r]).map(
+    (d) => b(d, (st) => (!i || i(st)) && t(st))
+  );
+  try {
+    return o(n, e.params), await (a ? bt(s, a) : s);
+  } finally {
+    p.forEach((d) => d());
+  }
+}
+async function R(e, t, s, n = {}) {
+  const {
+    result: r,
+    error: i
+  } = await f({
+    ...n,
+    method: "web_app_invoke_custom_method",
+    event: "custom_method_invoked",
+    params: {
+      method: e,
+      params: t,
+      req_id: s
+    },
+    capture: ft(s)
+  });
+  if (i)
+    throw u(jt, i);
+  return r;
+}
+function F(...e) {
+  return e.map((t) => {
+    if (typeof t == "string")
+      return t;
+    if (I(t))
+      return F(Object.entries(t).map((s) => s[1] && s[0]));
+    if (Array.isArray(t))
+      return F(...t);
+  }).filter(Boolean).join(" ");
+}
+function rs(...e) {
+  return e.reduce((t, s) => (I(s) && Object.entries(s).forEach(([n, r]) => {
+    const i = F(t[n], r);
+    i.length && (t[n] = i);
+  }), t), {});
+}
+function wt(e) {
+  const t = lt(e);
+  return Math.sqrt(
+    [0.299, 0.587, 0.114].reduce((s, n, r) => {
+      const i = parseInt(t.slice(1 + r * 2, 1 + (r + 1) * 2), 16);
+      return s + i * i * n;
+    }, 0)
+  ) < 120;
+}
+class _e {
+  constructor(t) {
+    c(this, "ee", new V());
+    /**
+     * Adds new event listener.
+     */
+    c(this, "on", this.ee.on.bind(this.ee));
+    /**
+     * Removes event listener.
+     */
+    c(this, "off", this.ee.off.bind(this.ee));
+    this.state = t;
+  }
+  /**
+   * Clones current state and returns its copy.
+   */
+  clone() {
+    return { ...this.state };
+  }
+  set(t, s) {
+    Object.entries(typeof t == "string" ? { [t]: s } : t).reduce((r, [i, o]) => this.state[i] === o || o === void 0 ? r : (this.state[i] = o, this.ee.emit(`change:${i}`, o), !0), !1) && this.ee.emit("change", this.state);
+  }
+  /**
+   * Returns value by specified key.
+   * @param key - state key.
+   */
+  get(t) {
+    return this.state[t];
+  }
+}
+class Z {
+  constructor(t) {
+    c(this, "state");
+    /**
+     * Gets the state value.
+     */
+    c(this, "get");
+    /**
+     * Sets the state value.
+     */
+    c(this, "set");
+    /**
+     * Clones the current state.
+     */
+    c(this, "clone");
+    this.state = new _e(t), this.set = this.state.set.bind(this.state), this.get = this.state.get.bind(this.state), this.clone = this.state.clone.bind(this.state);
+  }
+}
+function mt(e, t) {
+  return (s) => v(t[s], e);
+}
+class X extends Z {
+  constructor(s, n, r) {
+    super(s);
+    /**
+     * @returns True, if specified method is supported by the current component.
+     */
+    c(this, "supports");
+    this.supports = mt(n, r);
+  }
+}
+class fe extends X {
+  constructor(s, n, r) {
+    super({ isVisible: s }, n, {
+      show: "web_app_setup_back_button",
+      hide: "web_app_setup_back_button"
+    });
+    /**
+     * Adds a new event listener.
+     * @param event - event to listen.
+     * @param listener - listener to add.
+     */
+    c(this, "on", (s, n) => s === "click" ? b("back_button_pressed", n) : this.state.on(s, n));
+    /**
+     * Removes the event listener.
+     * @param event - event to listen.
+     * @param listener - listener to remove.
+     */
+    c(this, "off", (s, n) => s === "click" ? B("back_button_pressed", n) : this.state.off(s, n));
+    this.postEvent = r;
+  }
+  set isVisible(s) {
+    this.set("isVisible", s), this.postEvent("web_app_setup_back_button", { is_visible: s });
+  }
+  /**
+   * True if BackButton is currently visible.
+   */
+  get isVisible() {
+    return this.get("isVisible");
+  }
+  /**
+   * Hides the BackButton.
+   */
+  hide() {
+    this.isVisible = !1;
+  }
+  /**
+   * Shows the BackButton.
+   */
+  show() {
+    this.isVisible = !0;
+  }
+}
+function E() {
+  return typeof window > "u";
+}
+const yt = S((e) => e instanceof Date ? e : new Date(y().parse(e) * 1e3), "Date");
+function K(e, t) {
+  return new M((s) => {
+    if (typeof s != "string" && !(s instanceof URLSearchParams))
+      throw P();
+    const n = typeof s == "string" ? new URLSearchParams(s) : s;
+    return ut(e, (r) => {
+      const i = n.get(r);
+      return i === null ? void 0 : i;
+    });
+  }, !1, t);
+}
+const ge = _({
+  id: y(),
+  type: h(),
+  title: h(),
+  photoUrl: {
+    type: h().optional(),
+    from: "photo_url"
+  },
+  username: h().optional()
+}, "Chat").optional(), rt = _({
+  addedToAttachmentMenu: {
+    type: w().optional(),
+    from: "added_to_attachment_menu"
+  },
+  allowsWriteToPm: {
+    type: w().optional(),
+    from: "allows_write_to_pm"
+  },
+  firstName: {
+    type: h(),
+    from: "first_name"
+  },
+  id: y(),
+  isBot: {
+    type: w().optional(),
+    from: "is_bot"
+  },
+  isPremium: {
+    type: w().optional(),
+    from: "is_premium"
+  },
+  languageCode: {
+    type: h().optional(),
+    from: "language_code"
+  },
+  lastName: {
+    type: h().optional(),
+    from: "last_name"
+  },
+  photoUrl: {
+    type: h().optional(),
+    from: "photo_url"
+  },
+  username: h().optional()
+}, "User").optional();
+function vt() {
+  return K({
+    authDate: {
+      type: yt(),
+      from: "auth_date"
+    },
+    canSendAfter: {
+      type: y().optional(),
+      from: "can_send_after"
+    },
+    chat: ge,
+    chatInstance: {
+      type: h().optional(),
+      from: "chat_instance"
+    },
+    chatType: {
+      type: h().optional(),
+      from: "chat_type"
+    },
+    hash: h(),
+    queryId: {
+      type: h().optional(),
+      from: "query_id"
+    },
+    receiver: rt,
+    startParam: {
+      type: h().optional(),
+      from: "start_param"
+    },
+    user: rt
+  }, "InitData");
+}
+function be(e) {
+  return e.replace(/_[a-z]/g, (t) => t[1].toUpperCase());
+}
+function we(e) {
+  return e.replace(/[A-Z]/g, (t) => `_${t.toLowerCase()}`);
+}
+const Et = S(
+  (e) => {
+    const t = dt().optional();
+    return Object.entries(Q(e)).reduce((s, [n, r]) => (s[be(n)] = t.parse(r), s), {});
+  },
+  "ThemeParams"
+);
+function Pt(e) {
+  return K({
+    botInline: {
+      type: w().optional(),
+      from: "tgWebAppBotInline"
+    },
+    initData: {
+      type: vt().optional(),
+      from: "tgWebAppData"
+    },
+    initDataRaw: {
+      type: h().optional(),
+      from: "tgWebAppData"
+    },
+    platform: {
+      type: h(),
+      from: "tgWebAppPlatform"
+    },
+    showSettings: {
+      type: w().optional(),
+      from: "tgWebAppShowSettings"
+    },
+    startParam: {
+      type: h().optional(),
+      from: "tgWebAppStartParam"
+    },
+    themeParams: {
+      type: Et(),
+      from: "tgWebAppThemeParams"
+    },
+    version: {
+      type: h(),
+      from: "tgWebAppVersion"
+    }
+  }).parse(e);
+}
+function St(e) {
+  return Pt(
+    e.replace(/^[^?#]*[?#]/, "").replace(/[?#]/g, "&")
+  );
+}
+function me() {
+  return St(window.location.href);
+}
+function xt() {
+  return performance.getEntriesByType("navigation")[0];
+}
+function ye() {
+  const e = xt();
+  if (!e)
+    throw new Error("Unable to get first navigation entry.");
+  return St(e.name);
+}
+function Rt(e) {
+  return `tma.js/${e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`)}`;
+}
+function Ct(e, t) {
+  sessionStorage.setItem(Rt(e), JSON.stringify(t));
+}
+function Tt(e) {
+  const t = sessionStorage.getItem(Rt(e));
+  try {
+    return t ? JSON.parse(t) : void 0;
+  } catch {
+  }
+}
+function ve() {
+  return Pt(Tt("launchParams") || "");
+}
+function Ee(e) {
+  return JSON.stringify(
+    Object.fromEntries(
+      Object.entries(e).map(([t, s]) => [we(t), s])
+    )
+  );
+}
+function Pe(e) {
+  const {
+    initDataRaw: t,
+    themeParams: s,
+    platform: n,
+    version: r,
+    showSettings: i,
+    startParam: o,
+    botInline: a
+  } = e, p = new URLSearchParams();
+  return p.set("tgWebAppPlatform", n), p.set("tgWebAppThemeParams", Ee(s)), p.set("tgWebAppVersion", r), t && p.set("tgWebAppData", t), o && p.set("tgWebAppStartParam", o), typeof i == "boolean" && p.set("tgWebAppShowSettings", i ? "1" : "0"), typeof a == "boolean" && p.set("tgWebAppBotInline", a ? "1" : "0"), p.toString();
+}
+function Se(e) {
+  Ct("launchParams", Pe(e));
+}
+function xe() {
+  for (const e of [
+    // Try to retrieve launch parameters from the current location. This method can return
+    // nothing in case, location was changed and then page was reloaded.
+    me,
+    // Then, try using the lower level API - window.performance.
+    ye,
+    // Finally, try to extract launch parameters from the session storage.
+    ve
+  ])
+    try {
+      const t = e();
+      return Se(t), t;
+    } catch {
+    }
+  throw new Error("Unable to retrieve launch parameters from any known source.");
+}
+function At() {
+  const e = xt();
+  return !!(e && e.type === "reload");
+}
+function Re() {
+  let e = 0;
+  return () => (e += 1).toString();
+}
+const [Ce] = ct(Re);
+function l(e, t) {
+  return ({ ssr: s } = {}) => {
+    let n;
+    if (E()) {
+      if (!s)
+        throw u(
+          J,
+          "ssr.options must be specified to initialize component on the server side"
+        );
+      n = s;
+    } else
+      n = xe();
+    const r = {
+      ...n,
+      postEvent: "version" in n ? de(n.version) : () => {
+        throw u(
+          Yt,
+          "postEvent function is forbidden to be called on the server side."
+        );
+      },
+      createRequestId: Ce()
+    };
+    if (E() || typeof e == "function")
+      return typeof e == "function" ? e(r) : t(r);
+    const i = t({
+      ...r,
+      state: At() ? Tt(e) : void 0
+    }), o = (a) => (a.on("change", (p) => {
+      Ct(e, p);
+    }), a);
+    return i instanceof Promise ? i.then(o) : o(i);
+  };
+}
+const is = l("backButton", ({
+  postEvent: e,
+  version: t,
+  state: s = { isVisible: !1 }
+}) => new fe(s.isVisible, t, e));
+class q extends X {
+  constructor() {
+    super(...arguments);
+    /**
+     * Adds a new event listener.
+     */
+    c(this, "on", this.state.on.bind(this.state));
+    /**
+     * Removes the event listener.
+     */
+    c(this, "off", this.state.off.bind(this.state));
+  }
+}
+function It(e) {
+  const t = e.available ? e : {
+    available: !1,
+    device_id: "",
+    token_saved: !1,
+    access_requested: !1,
+    access_granted: !1,
+    type: ""
+  };
+  return {
+    available: !0,
+    type: t.type,
+    deviceId: t.device_id,
+    tokenSaved: t.token_saved,
+    accessRequested: t.access_requested,
+    accessGranted: t.access_granted
+  };
+}
+class it extends q {
+  constructor({ postEvent: s, version: n, ...r }) {
+    super(r, n, {
+      auth: "web_app_biometry_request_auth",
+      openSettings: "web_app_biometry_open_settings",
+      requestAccess: "web_app_biometry_request_access",
+      updateToken: "web_app_biometry_update_token"
+    });
+    c(this, "postEvent");
+    c(this, "authPromise");
+    c(this, "accessPromise");
+    this.postEvent = s;
+  }
+  /**
+   * Shows whether biometry is available.
+   */
+  get available() {
+    return this.get("available");
+  }
+  /**
+   * Shows whether permission to use biometrics has been granted.
+   */
+  get accessGranted() {
+    return this.get("accessGranted");
+  }
+  /**
+   * Shows whether if permission to use biometrics has been requested.
+   */
+  get accessRequested() {
+    return this.get("accessRequested");
+  }
+  /**
+   * Authenticates the user using biometrics.
+   * @param options - method options.
+   * @since 7.2
+   * @returns Token from the local secure storage, if authentication was successful.
+   */
+  async authenticate({
+    reason: s,
+    ...n
+  }) {
+    return this.authPromise || (this.authPromise = f({
+      ...n,
+      method: "web_app_biometry_request_auth",
+      event: "biometry_auth_requested",
+      postEvent: this.postEvent,
+      params: {
+        // TODO: Check if reason is empty works fine.
+        reason: (s || "").trim()
+      }
+    }).then(({ token: r }) => r).finally(() => this.authPromise = void 0)), this.authPromise;
+  }
+  /**
+   * A unique device identifier that can be used to match the token to the device.
+   */
+  get deviceId() {
+    return this.get("deviceId");
+  }
+  /**
+   * Opens the biometric access settings for bots. Useful when you need to request biometrics
+   * access to users who haven't granted it yet.
+   *
+   * _Note that this method can be called only in response to user interaction with the Mini App
+   * interface (e.g. a click inside the Mini App or on the main button)_.
+   * @since 7.2
+   */
+  openSettings() {
+    this.postEvent("web_app_biometry_open_settings");
+  }
+  /**
+   * Requests permission to use biometrics.
+   * @since 7.2
+   * @returns Promise with true, if access was granted.
+   */
+  requestAccess({ reason: s, ...n } = {}) {
+    return this.accessPromise || (this.accessPromise = f({
+      ...n,
+      postEvent: this.postEvent,
+      method: "web_app_biometry_request_access",
+      event: "biometry_info_received",
+      params: { reason: s || "" }
+    }).then((r) => {
+      const i = It(r);
+      return this.set(i), i.accessGranted;
+    }).finally(() => this.accessPromise = void 0)), this.accessPromise;
+  }
+  /**
+   * The type of biometrics currently available on the device.
+   */
+  get biometryType() {
+    return this.get("biometryType");
+  }
+  /**
+   * Shows whether token was saved previously in the local secure storage.
+   */
+  get tokenSaved() {
+    return this.get("tokenSaved");
+  }
+  /**
+   * Updates the biometric token in a secure storage on the device.
+   * @returns Promise with `true`, if token was updated.
+   */
+  async updateToken({ token: s, ...n } = {}) {
+    return ["removed", "updated"].includes(
+      (await f({
+        ...n,
+        postEvent: this.postEvent,
+        method: "web_app_biometry_update_token",
+        event: "biometry_token_updated",
+        params: { token: s || "" }
+      })).status
+    );
+  }
+}
+async function Te(e) {
+  return It(
+    await f({
+      ...e || {},
+      method: "web_app_biometry_get_info",
+      event: "biometry_info_received"
+    })
+  );
+}
+const os = l("biometryManager", async ({ postEvent: e, version: t, state: s }) => {
+  if (s)
+    return new it({ ...s, version: t, postEvent: e });
+  if (E())
+    throw u(
+      J,
+      "BiometryManager cannot be instantiated on the server side without passing the ssr.state object."
+    );
+  return new it({
+    ...await Te({ timeout: 1e3 }),
+    version: t,
+    postEvent: e
+  });
+});
+class tt extends Z {
+  constructor() {
+    super(...arguments);
+    /**
+     * Adds a new event listener.
+     */
+    c(this, "on", this.state.on.bind(this.state));
+    /**
+     * Removes the event listener.
+     */
+    c(this, "off", this.state.off.bind(this.state));
+  }
+}
+class Ae extends tt {
+  constructor(t, s) {
+    super({ isConfirmationNeeded: t }), this.postEvent = s;
+  }
+  set isConfirmationNeeded(t) {
+    this.set("isConfirmationNeeded", t), this.postEvent("web_app_setup_closing_behavior", { need_confirmation: t });
+  }
+  /**
+   * True, if the confirmation dialog should be shown while the user is trying to close
+   * the Mini App.
+   */
+  get isConfirmationNeeded() {
+    return this.get("isConfirmationNeeded");
+  }
+  /**
+   * Disables the confirmation dialog when closing the Mini App.
+   */
+  disableConfirmation() {
+    this.isConfirmationNeeded = !1;
+  }
+  /**
+   * Enables the confirmation dialog when closing the Mini App.
+   */
+  enableConfirmation() {
+    this.isConfirmationNeeded = !0;
+  }
+}
+const as = l("closingBehavior", ({
+  postEvent: e,
+  state: t = { isConfirmationNeeded: !1 }
+}) => new Ae(t.isConfirmationNeeded, e));
+class et {
+  constructor(t, s) {
+    /**
+     * @returns True, if specified method is supported by the current component.
+     */
+    c(this, "supports");
+    this.supports = mt(t, s);
+  }
+}
+function Ie(e) {
+  if (Array.isArray(e))
+    return e;
+  if (typeof e == "string")
+    try {
+      const t = JSON.parse(e);
+      if (Array.isArray(t))
+        return t;
+    } catch {
+    }
+  throw P();
+}
+class qe extends M {
+  constructor(s, n, r) {
+    super(Ie, n, r);
+    c(this, "itemParser");
+    this.itemParser = typeof s == "function" ? s : s.parse.bind(s);
+  }
+  /**
+   * Attempts to parse passed value
+   * @param value - value to parse.
+   * @throws {SDKError} ERR_PARSE
+   * @see ERR_PARSE
+   */
+  parse(s) {
+    const n = super.parse(s);
+    return n === void 0 ? n : n.map(this.itemParser);
+  }
+  of(s) {
+    return this.itemParser = typeof s == "function" ? s : s.parse.bind(s), this;
+  }
+}
+function ke(e) {
+  return new qe((t) => t, !1, e);
+}
+function ot(e, t) {
+  return Object.fromEntries(e.map((s) => [s, t]));
+}
+class Ne extends et {
+  constructor(t, s, n) {
+    super(t, {
+      delete: "web_app_invoke_custom_method",
+      get: "web_app_invoke_custom_method",
+      getKeys: "web_app_invoke_custom_method",
+      set: "web_app_invoke_custom_method"
+    }), this.createRequestId = s, this.postEvent = n;
+  }
+  /**
+   * Deletes specified key or keys from the cloud storage.
+   * @param keyOrKeys - key or keys to delete.
+   * @param options - request execution options.
+   */
+  async delete(t, s = {}) {
+    const n = Array.isArray(t) ? t : [t];
+    n.length && await R(
+      "deleteStorageValues",
+      { keys: n },
+      this.createRequestId(),
+      { ...s, postEvent: this.postEvent }
+    );
+  }
+  /**
+   * Returns list of all keys presented in the cloud storage.
+   * @param options - request execution options.
+   */
+  async getKeys(t = {}) {
+    return ke().of(h()).parse(
+      await R(
+        "getStorageKeys",
+        {},
+        this.createRequestId(),
+        { ...t, postEvent: this.postEvent }
+      )
+    );
+  }
+  async get(t, s = {}) {
+    const n = Array.isArray(t) ? t : [t];
+    if (!n.length)
+      return ot(n, "");
+    const r = await R(
+      "getStorageValues",
+      { keys: n },
+      this.createRequestId(),
+      { ...s, postEvent: this.postEvent }
+    ), i = _(ot(n, h()), "CloudStorageData").parse(r);
+    return Array.isArray(t) ? i : i[t];
+  }
+  /**
+   * Saves specified value by key.
+   * @param key - storage key.
+   * @param value - storage value.
+   * @param options - request execution options.
+   */
+  async set(t, s, n = {}) {
+    await R(
+      "saveStorageValue",
+      { key: t, value: s },
+      this.createRequestId(),
+      { ...n, postEvent: this.postEvent }
+    );
+  }
+}
+const cs = l(
+  ({ createRequestId: e, postEvent: t, version: s }) => new Ne(s, e, t)
+);
+class De extends et {
+  constructor(t, s) {
+    super(t, {
+      impactOccurred: "web_app_trigger_haptic_feedback",
+      notificationOccurred: "web_app_trigger_haptic_feedback",
+      selectionChanged: "web_app_trigger_haptic_feedback"
+    }), this.postEvent = s;
+  }
+  /**
+   * 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" });
+  }
+}
+const hs = l(
+  ({ version: e, postEvent: t }) => new De(e, t)
+);
+class Ve {
+  constructor(t) {
+    this.initData = t;
+  }
+  /**
+   * @see InitDataParsed.authDate
+   */
+  get authDate() {
+    return this.initData.authDate;
+  }
+  /**
+   * @see InitDataParsed.canSendAfter
+   */
+  get canSendAfter() {
+    return this.initData.canSendAfter;
+  }
+  /**
+   * Date after which it is allowed to call
+   * the [answerWebAppQuery](https://core.telegram.org/bots/api#answerwebappquery) method.
+   */
+  get canSendAfterDate() {
+    const { canSendAfter: t } = this;
+    return t ? new Date(this.authDate.getTime() + t * 1e3) : void 0;
+  }
+  /**
+   * @see InitDataParsed.chat
+   */
+  get chat() {
+    return this.initData.chat;
+  }
+  /**
+   * @see InitDataParsed.chatType
+   */
+  get chatType() {
+    return this.initData.chatType;
+  }
+  /**
+   * @see InitDataParsed.chatInstance
+   */
+  get chatInstance() {
+    return this.initData.chatInstance;
+  }
+  /**
+   * @see InitDataParsed.hash
+   */
+  get hash() {
+    return this.initData.hash;
+  }
+  /**
+   * @see InitDataParsed.queryId
+   */
+  get queryId() {
+    return this.initData.queryId;
+  }
+  /**
+   * @see InitDataParsed.receiver
+   */
+  get receiver() {
+    return this.initData.receiver;
+  }
+  /**
+   * @see InitDataParsed.startParam
+   */
+  get startParam() {
+    return this.initData.startParam;
+  }
+  /**
+   * @see InitDataParsed.user
+   */
+  get user() {
+    return this.initData.user;
+  }
+}
+const ps = l(
+  ({ initData: e }) => e ? new Ve(e) : void 0
+);
+function us(e) {
+  return vt().parse(e);
+}
+class $e extends q {
+  constructor(t, s, n) {
+    super({ isOpened: t }, s, { open: "web_app_open_invoice" }), this.postEvent = n;
+  }
+  set isOpened(t) {
+    this.set("isOpened", t);
+  }
+  /**
+   * True if invoice is currently opened.
+   */
+  get isOpened() {
+    return this.get("isOpened");
+  }
+  async open(t, s) {
+    if (this.isOpened)
+      throw new Error("Invoice is already opened");
+    let n;
+    if (!s)
+      n = t;
+    else {
+      const { hostname: r, pathname: i } = new URL(t, window.location.href);
+      if (r !== "t.me")
+        throw new Error(`Incorrect hostname: ${r}`);
+      const o = i.match(/^\/(\$|invoice\/)([A-Za-z0-9\-_=]+)$/);
+      if (!o)
+        throw new Error('Link pathname has incorrect format. Expected to receive "/invoice/{slug}" or "/${slug}"');
+      [, , n] = o;
+    }
+    this.isOpened = !0;
+    try {
+      return (await f({
+        method: "web_app_open_invoice",
+        event: "invoice_closed",
+        params: { slug: n },
+        postEvent: this.postEvent,
+        capture(i) {
+          return n === i.slug;
+        }
+      })).status;
+    } finally {
+      this.isOpened = !1;
+    }
+  }
+}
+const ls = l(
+  ({ version: e, postEvent: t }) => new $e(!1, e, t)
+);
+class Me extends Z {
+  constructor({ postEvent: s, ...n }) {
+    super(n);
+    c(this, "postEvent");
+    /**
+     * Adds a new event listener.
+     * @param event - event to listen.
+     * @param listener - listener to add.
+     */
+    c(this, "on", (s, n) => s === "click" ? b("main_button_pressed", n) : this.state.on(s, n));
+    /**
+     * Removes the event listener.
+     * @param event - event to listen.
+     * @param listener - listener to remove.
+     */
+    c(this, "off", (s, n) => s === "click" ? B("main_button_pressed", n) : this.state.off(s, n));
+    this.postEvent = s;
+  }
+  /**
+   * Sends current local state to the Telegram application.
+   */
+  commit() {
+    this.text !== "" && this.postEvent("web_app_setup_main_button", {
+      is_visible: this.isVisible,
+      is_active: this.isEnabled,
+      is_progress_visible: this.isLoaderVisible,
+      text: this.text,
+      color: this.backgroundColor,
+      text_color: this.textColor
+    });
+  }
+  set isEnabled(s) {
+    this.setParams({ isEnabled: s });
+  }
+  /**
+   * True if the MainButton is enabled.
+   */
+  get isEnabled() {
+    return this.get("isEnabled");
+  }
+  set isLoaderVisible(s) {
+    this.setParams({ isLoaderVisible: s });
+  }
+  /**
+   * True if the MainButton loader is visible.
+   */
+  get isLoaderVisible() {
+    return this.get("isLoaderVisible");
+  }
+  set isVisible(s) {
+    this.setParams({ isVisible: s });
+  }
+  /**
+   * True if the MainButton is visible.
+   */
+  get isVisible() {
+    return this.get("isVisible");
+  }
+  /**
+   * The MainButton background color.
+   */
+  get backgroundColor() {
+    return this.get("backgroundColor");
+  }
+  /**
+   * The MainButton text.
+   */
+  get text() {
+    return this.get("text");
+  }
+  /**
+   * The MainButton text color.
+   */
+  get textColor() {
+    return this.get("textColor");
+  }
+  /**
+   * Disables the MainButton.
+   * @see Does not work on Android: https://github.com/Telegram-Mini-Apps/issues/issues/1
+   */
+  disable() {
+    return this.isEnabled = !1, this;
+  }
+  /**
+   * Enables the MainButton.
+   */
+  enable() {
+    return this.isEnabled = !0, this;
+  }
+  /**
+   * Hides the MainButton.
+   */
+  hide() {
+    return this.isVisible = !1, this;
+  }
+  /**
+   * Hides the MainButton loading indicator.
+   */
+  hideLoader() {
+    return this.isLoaderVisible = !1, this;
+  }
+  /**
+   * Shows the MainButton.
+   *
+   * Note that opening the Mini App from the attachment menu hides the main button until the
+   * user interacts with the Mini App interface.
+   */
+  show() {
+    return this.isVisible = !0, this;
+  }
+  /**
+   * Shows a loading indicator on the Main Button.
+   */
+  showLoader() {
+    return this.isLoaderVisible = !0, this;
+  }
+  /**
+   * Sets a new MainButton text. Minimal length for the text is 1 symbol, and maximum is 64 symbols.
+   * @param text - a new text.
+   */
+  setText(s) {
+    return this.setParams({ text: s });
+  }
+  /**
+   * Sets a new Main Button text color.
+   * @param textColor - new text color.
+   */
+  setTextColor(s) {
+    return this.setParams({ textColor: s });
+  }
+  /**
+   * Updates current Main Button color.
+   * @param backgroundColor - color to set.
+   */
+  setBackgroundColor(s) {
+    return this.setParams({ backgroundColor: s });
+  }
+  /**
+   * Allows setting multiple Main Button parameters.
+   * @param params - Main Button parameters.
+   */
+  setParams(s) {
+    return this.set(s), this.commit(), this;
+  }
+}
+const ds = l("mainButton", ({
+  postEvent: e,
+  themeParams: t,
+  state: s = {
+    isVisible: !1,
+    isEnabled: !1,
+    text: "",
+    isLoaderVisible: !1,
+    textColor: t.buttonTextColor || "#ffffff",
+    backgroundColor: t.buttonColor || "#000000"
+  }
+}) => new Me({ ...s, postEvent: e }));
+function Le() {
+  return K({
+    contact: _({
+      userId: {
+        type: y(),
+        from: "user_id"
+      },
+      phoneNumber: {
+        type: h(),
+        from: "phone_number"
+      },
+      firstName: {
+        type: h(),
+        from: "first_name"
+      },
+      lastName: {
+        type: h().optional(),
+        from: "last_name"
+      }
+    }),
+    authDate: {
+      type: yt(),
+      from: "auth_date"
+    },
+    hash: h()
+  }, "RequestedContact");
+}
+function qt(e, t) {
+  return (s) => {
+    const [n, r] = t[s];
+    return v(n, r, e);
+  };
+}
+function Be(e) {
+  return new Promise((t) => {
+    setTimeout(t, e);
+  });
+}
+class Oe extends q {
+  constructor({ postEvent: s, createRequestId: n, version: r, botInline: i, ...o }) {
+    super(o, r, {
+      requestPhoneAccess: "web_app_request_phone",
+      requestWriteAccess: "web_app_request_write_access",
+      switchInlineQuery: "web_app_switch_inline_query",
+      setHeaderColor: "web_app_set_header_color",
+      setBackgroundColor: "web_app_set_background_color"
+    });
+    c(this, "botInline");
+    c(this, "postEvent");
+    c(this, "createRequestId");
+    c(this, "requestPhoneAccessPromise");
+    c(this, "requestWriteAccessPromise");
+    /**
+     * Checks if specified method parameter is supported by current component.
+     */
+    c(this, "supportsParam");
+    this.createRequestId = n, this.postEvent = s, this.botInline = i;
+    const a = this.supports.bind(this);
+    this.supports = (p) => a(p) ? p !== "switchInlineQuery" || i : !1, this.supportsParam = qt(r, {
+      "setHeaderColor.color": ["web_app_set_header_color", "color"]
+    });
+  }
+  /**
+   * Attempts to get requested contact.
+   * @param timeout - request timeout.
+   */
+  async getRequestedContact({
+    timeout: s = 1e4
+  } = {}) {
+    return Le().parse(
+      await R(
+        "getRequestedContact",
+        {},
+        this.createRequestId(),
+        { postEvent: this.postEvent, timeout: s }
+      )
+    );
+  }
+  /**
+   * The Mini App background color.
+   * @example "#ffaabb"
+   */
+  get bgColor() {
+    return this.get("bgColor");
+  }
+  /**
+   * Closes the Mini App.
+   */
+  close() {
+    this.postEvent("web_app_close");
+  }
+  /**
+   * The Mini App header color.
+   * @example "#ffaabb"
+   * @example "bg_color"
+   */
+  get headerColor() {
+    return this.get("headerColor");
+  }
+  /**
+   * True if the Mini App is currently launched in bot inline mode.
+   */
+  get isBotInline() {
+    return this.botInline;
+  }
+  /**
+   * True if current Mini App background color is recognized as dark.
+   */
+  get isDark() {
+    return wt(this.bgColor);
+  }
+  /**
+   * Informs the Telegram app that the Mini 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 Mini App shown.
+   *
+   * If the method not called, the placeholder will be hidden only when the page fully loaded.
+   */
+  ready() {
+    this.postEvent("web_app_ready");
+  }
+  /**
+   * Requests current user contact information. In contrary to requestPhoneAccess, this method
+   * returns promise with contact information that rejects in case, user denied access, or request
+   * failed.
+   * @param options - additional options.
+   */
+  async requestContact({ timeout: s = 5e3 } = {}) {
+    try {
+      return await this.getRequestedContact();
+    } catch {
+    }
+    if (await this.requestPhoneAccess() !== "sent")
+      throw new Error("Access denied.");
+    const r = Date.now() + s;
+    let i = 50;
+    return bt(async () => {
+      for (; Date.now() < r; ) {
+        try {
+          return await this.getRequestedContact();
+        } catch {
+        }
+        await Be(i), i += 50;
+      }
+      throw gt(s);
+    }, s);
+  }
+  /**
+   * Requests current user phone access. Method returns promise, which resolves
+   * status of the request. In case, user accepted the request, Mini App bot will receive
+   * the according notification.
+   *
+   * To obtain the retrieved information instead, utilize the `requestContact` method.
+   * @param options - additional options.
+   * @see requestContact
+   */
+  async requestPhoneAccess(s = {}) {
+    return this.requestPhoneAccessPromise || (this.requestPhoneAccessPromise = f({
+      ...s,
+      method: "web_app_request_phone",
+      event: "phone_requested",
+      postEvent: this.postEvent
+    }).then(({ status: n }) => n).finally(() => this.requestPhoneAccessPromise = void 0)), this.requestPhoneAccessPromise;
+  }
+  /**
+   * Requests write message access to current user.
+   * @param options - additional options.
+   */
+  async requestWriteAccess(s = {}) {
+    return this.requestWriteAccessPromise || (this.requestWriteAccessPromise = f({
+      ...s,
+      method: "web_app_request_write_access",
+      event: "write_access_requested",
+      postEvent: this.postEvent
+    }).then(({ status: n }) => n).finally(() => this.requestWriteAccessPromise = void 0)), this.requestWriteAccessPromise;
+  }
+  /**
+   * 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 Mini App closed. See the
+   * field `web_app_data` in the class [Message](https://core.telegram.org/bots/api#message).
+   *
+   * This method is only available for Mini Apps launched via a Keyboard button.
+   * @param data - data to send to bot.
+   * @throws {Error} data has incorrect size.
+   */
+  sendData(s) {
+    const { size: n } = new Blob([s]);
+    if (!n || n > 4096)
+      throw new Error(`Passed data has incorrect size: ${n}`);
+    this.postEvent("web_app_data_send", { data: s });
+  }
+  /**
+   * Updates current Mini App header color.
+   *
+   * @see No effect on desktop: https://github.com/Telegram-Mini-Apps/tma.js/issues/9
+   * @see Works incorrectly in Android: https://github.com/Telegram-Mini-Apps/tma.js/issues/8
+   * @param color - color key or RGB color.
+   */
+  setHeaderColor(s) {
+    this.postEvent("web_app_set_header_color", Y(s) ? { color: s } : { color_key: s }), this.set("headerColor", s);
+  }
+  /**
+   * Updates current Mini App background color.
+   *
+   * @see No effect on desktop: https://github.com/Telegram-Mini-Apps/tma.js/issues/9
+   * @see Works incorrectly in Android: https://github.com/Telegram-Mini-Apps/tma.js/issues/8
+   * @param color - RGB color.
+   */
+  setBgColor(s) {
+    this.postEvent("web_app_set_background_color", { color: s }), this.set("bgColor", s);
+  }
+  /**
+   * Inserts the bot's username and the specified inline query in the current chat's input field.
+   * Query may be empty, in which case only the bot's username will be inserted. The client prompts
+   * the user to choose a specific chat, then opens that chat and inserts the bot's username and
+   * the specified inline query in the input field.
+   * @param text - text which should be inserted in the input after the current bot name. Max
+   * length is 256 symbols.
+   * @param chatTypes - List of chat types which could be chosen to send the message. Could be
+   * empty list.
+   */
+  switchInlineQuery(s, n = []) {
+    if (!this.supports("switchInlineQuery") && !this.isBotInline)
+      throw new Error("Method is unsupported because Mini App should be launched in inline mode.");
+    this.postEvent("web_app_switch_inline_query", { query: s, chat_types: n });
+  }
+}
+const _s = l("miniApp", ({
+  themeParams: e,
+  botInline: t = !1,
+  state: s = {
+    bgColor: e.bgColor || "#ffffff",
+    headerColor: e.headerBgColor || "#000000"
+  },
+  ...n
+}) => new Oe({ ...n, ...s, botInline: t }));
+function Ue(e) {
+  const t = e.message.trim(), s = (e.title || "").trim(), n = e.buttons || [];
+  let r;
+  if (s.length > 64)
+    throw new Error(`Title has incorrect size: ${s.length}`);
+  if (!t.length || t.length > 256)
+    throw new Error(`Message has incorrect size: ${t.length}`);
+  if (n.length > 3)
+    throw new Error(`Buttons have incorrect size: ${n.length}`);
+  return n.length ? r = n.map((i) => {
+    const { id: o = "" } = i;
+    if (o.length > 64)
+      throw new Error(`Button ID has incorrect size: ${o}`);
+    if (!i.type || i.type === "default" || i.type === "destructive") {
+      const a = i.text.trim();
+      if (!a.length || a.length > 64) {
+        const p = i.type || "default";
+        throw new Error(`Button text with type "${p}" has incorrect size: ${i.text.length}`);
+      }
+      return { ...i, text: a, id: o };
+    }
+    return { ...i, id: o };
+  }) : r = [{ type: "close", id: "" }], { title: s, message: t, buttons: r };
+}
+class We extends q {
+  constructor(t, s, n) {
+    super({ isOpened: t }, s, { open: "web_app_open_popup" }), this.postEvent = n;
+  }
+  set isOpened(t) {
+    this.set("isOpened", t);
+  }
+  /**
+   * True if the Popup is opened.
+   */
+  get isOpened() {
+    return this.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.
+   *
+   * @param options - popup parameters.
+   * @throws {Error} Popup is already opened.
+   */
+  async open(t) {
+    if (this.isOpened)
+      throw new Error("Popup is already opened.");
+    this.isOpened = !0;
+    try {
+      const { button_id: s = null } = await f({
+        event: "popup_closed",
+        method: "web_app_open_popup",
+        postEvent: this.postEvent,
+        params: Ue(t)
+      });
+      return s;
+    } finally {
+      this.isOpened = !1;
+    }
+  }
+}
+const fs = l(
+  ({ postEvent: e, version: t }) => new We(!1, t, e)
+);
+class He extends q {
+  constructor(t, s, n) {
+    super({ isOpened: t }, s, {
+      close: "web_app_close_scan_qr_popup",
+      open: "web_app_open_scan_qr_popup"
+    }), this.postEvent = n;
+  }
+  /**
+   * Closes scanner.
+   */
+  close() {
+    this.postEvent("web_app_close_scan_qr_popup"), this.isOpened = !1;
+  }
+  set isOpened(t) {
+    this.set("isOpened", t);
+  }
+  /**
+   * Returns true in case, QR scanner is currently opened.
+   */
+  get isOpened() {
+    return this.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 {
+      return (await f({
+        method: "web_app_open_scan_qr_popup",
+        event: ["qr_text_received", "scan_qr_popup_closed"],
+        postEvent: this.postEvent,
+        params: { text: t }
+      }) || {}).data || null;
+    } finally {
+      this.isOpened = !1;
+    }
+  }
+}
+const gs = l(
+  ({ version: e, postEvent: t }) => new He(!1, e, t)
+);
+class Ge extends X {
+  constructor(s, n, r) {
+    super({ isVisible: s }, n, {
+      show: "web_app_setup_settings_button",
+      hide: "web_app_setup_settings_button"
+    });
+    /**
+     * Adds a new event listener.
+     * @param event - event to listen.
+     * @param listener - listener to add.
+     */
+    c(this, "on", (s, n) => s === "click" ? b("settings_button_pressed", n) : this.state.on(s, n));
+    /**
+     * Removes the event listener.
+     * @param event - event to listen.
+     * @param listener - listener to remove.
+     */
+    c(this, "off", (s, n) => s === "click" ? B("settings_button_pressed", n) : this.state.off(s, n));
+    this.postEvent = r;
+  }
+  set isVisible(s) {
+    this.set("isVisible", s), this.postEvent("web_app_setup_settings_button", { is_visible: s });
+  }
+  /**
+   * True if the SettingsButton is visible.
+   */
+  get isVisible() {
+    return this.get("isVisible");
+  }
+  /**
+   * Hides the SettingsButton.
+   */
+  hide() {
+    this.isVisible = !1;
+  }
+  /**
+   * Shows the SettingsButton.
+   */
+  show() {
+    this.isVisible = !0;
+  }
+}
+const bs = l("settingsButton", ({
+  version: e,
+  postEvent: t,
+  state: s = { isVisible: !1 }
+}) => new Ge(s.isVisible, e, t));
+function kt(e) {
+  return Et().parse(e);
+}
+class je extends tt {
+  /**
+   * @since v6.10
+   */
+  get accentTextColor() {
+    return this.get("accentTextColor");
+  }
+  get bgColor() {
+    return this.get("bgColor");
+  }
+  get buttonColor() {
+    return this.get("buttonColor");
+  }
+  get buttonTextColor() {
+    return this.get("buttonTextColor");
+  }
+  get destructiveTextColor() {
+    return this.get("destructiveTextColor");
+  }
+  /**
+   * Returns the copy of the internal state of the current component instance.
+   */
+  getState() {
+    return this.clone();
+  }
+  /**
+   * @since v6.10
+   */
+  get headerBgColor() {
+    return this.get("headerBgColor");
+  }
+  get hintColor() {
+    return this.get("hintColor");
+  }
+  /**
+   * @returns True in case, current color scheme is recognized as dark. This
+   * value is calculated according to theme bg color.
+   */
+  get isDark() {
+    return !this.bgColor || wt(this.bgColor);
+  }
+  get linkColor() {
+    return this.get("linkColor");
+  }
+  get secondaryBgColor() {
+    return this.get("secondaryBgColor");
+  }
+  /**
+   * @since v6.10
+   */
+  get sectionBgColor() {
+    return this.get("sectionBgColor");
+  }
+  /**
+   * @since v6.10
+   */
+  get sectionHeaderTextColor() {
+    return this.get("sectionHeaderTextColor");
+  }
+  /**
+   * Starts listening to the external theme changes and applies them.
+   * @returns Function to stop listening.
+   */
+  listen() {
+    return b("theme_changed", (t) => {
+      this.set(kt(t.theme_params));
+    });
+  }
+  /**
+   * @since v6.10
+   */
+  get subtitleTextColor() {
+    return this.get("subtitleTextColor");
+  }
+  get textColor() {
+    return this.get("textColor");
+  }
+}
+const ws = l("themeParams", ({ themeParams: e, state: t = e }) => {
+  const s = new je(t);
+  return E() || s.listen(), s;
+});
+function ms(e = {}) {
+  return f({
+    ...e,
+    method: "web_app_request_theme",
+    event: "theme_changed"
+  }).then(kt);
+}
+class ze extends et {
+  constructor(s, n, r) {
+    super(s, { readTextFromClipboard: "web_app_read_text_from_clipboard" });
+    /**
+     * Checks if specified method parameter is supported by current component.
+     */
+    c(this, "supportsParam");
+    this.version = s, this.createRequestId = n, this.postEvent = r, this.supportsParam = qt(s, {
+      "openLink.tryInstantView": ["web_app_open_link", "try_instant_view"]
+    });
+  }
+  /**
+   * Opens a link in an external browser. The Mini App will not be closed.
+   *
+   * Note that this method can be called only in response to the user
+   * interaction with the Mini App interface (e.g. click inside the Mini App
+   * or on the main button).
+   * @param url - URL to be opened.
+   * @param tryInstantView
+   */
+  openLink(s, n) {
+    const r = new URL(s, window.location.href).toString();
+    if (!v("web_app_open_link", this.version)) {
+      window.open(r, "_blank");
+      return;
+    }
+    this.postEvent("web_app_open_link", {
+      url: r,
+      ...typeof n == "boolean" ? { try_instant_view: n } : {}
+    });
+  }
+  /**
+   * Opens a Telegram link inside Telegram app. The Mini 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(s) {
+    const { hostname: n, pathname: r, search: i } = new URL(s, window.location.href);
+    if (n !== "t.me")
+      throw new Error(`URL has not allowed hostname: ${n}. Only "t.me" is allowed`);
+    if (!v("web_app_open_tg_link", this.version)) {
+      window.location.href = s;
+      return;
+    }
+    this.postEvent("web_app_open_tg_link", { path_full: r + i });
+  }
+  /**
+   * 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 s = this.createRequestId(), {
+      data: n = null
+    } = await f({
+      method: "web_app_read_text_from_clipboard",
+      event: "clipboard_text_received",
+      postEvent: this.postEvent,
+      params: { req_id: s },
+      capture: ft(s)
+    });
+    return n;
+  }
+}
+const ys = l(
+  ({ version: e, postEvent: t, createRequestId: s }) => new ze(e, s, t)
+);
+async function Nt(e = {}) {
+  const {
+    is_expanded: t,
+    is_state_stable: s,
+    ...n
+  } = await f({
+    ...e,
+    method: "web_app_request_viewport",
+    event: "viewport_changed"
+  });
+  return { ...n, isExpanded: t, isStateStable: s };
+}
+function x(e) {
+  return e < 0 ? 0 : e;
+}
+class Dt extends tt {
+  constructor({ postEvent: s, stableHeight: n, height: r, width: i, isExpanded: o }) {
+    super({
+      height: x(r),
+      isExpanded: o,
+      stableHeight: x(n),
+      width: x(i)
+    });
+    c(this, "postEvent");
+    this.postEvent = s;
+  }
+  /**
+   * Requests viewport information from the Telegram application and updates current Viewport
+   * instance.
+   * @param options - options to request fresh data.
+   */
+  async sync(s) {
+    const { isStateStable: n, ...r } = await Nt(s);
+    this.set({
+      ...r,
+      stableHeight: n ? r.height : this.get("stableHeight")
+    });
+  }
+  /**
+   * The current height of the **visible area** of the Mini App.
+   *
+   * The application can display just the top part of the Mini App, with its lower part remaining
+   * outside the screen area. From this position, the user can "pull" the Mini App to its
+   * maximum height, while the bot can do the same by calling `expand` method. As the position of
+   * the Mini 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 stableHeight
+   */
+  get height() {
+    return this.get("height");
+  }
+  /**
+   * The height of the visible area of the Mini App in its last stable state.
+   *
+   * The application can display just the top part of the Mini App, with its lower part remaining
+   * outside the screen area. From this position, the user can "pull" the Mini App to its
+   * maximum height, while the application 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 Mini App changes with user gestures or during animations. The value of `stableHeight`
+   * will be updated after all gestures and animations are completed and
+   * the Mini App reaches its final size.
+   *
+   * @see height
+   */
+  get stableHeight() {
+    return this.get("stableHeight");
+  }
+  /**
+   * Starts listening to viewport changes and applies them.
+   * @returns Function to stop listening.
+   */
+  listen() {
+    return b("viewport_changed", (s) => {
+      const {
+        height: n,
+        width: r,
+        is_expanded: i,
+        is_state_stable: o
+      } = s, a = x(n);
+      this.set({
+        height: a,
+        isExpanded: i,
+        width: x(r),
+        ...o ? { stableHeight: a } : {}
+      });
+    });
+  }
+  /**
+   * True if the Mini App is expanded to the maximum available height. Otherwise, if
+   * the Mini App occupies part of the screen and can be expanded to the full height using
+   * `expand` method.
+   * @see expand
+   */
+  get isExpanded() {
+    return this.get("isExpanded");
+  }
+  /**
+   * Current visible area width.
+   */
+  get width() {
+    return this.get("width");
+  }
+  /**
+   * A method that expands the Mini App to the maximum available height. To find out if the Mini
+   * App is expanded to the maximum height, refer to the value of the `isExpanded`.
+   * @see isExpanded
+   */
+  expand() {
+    this.postEvent("web_app_expand"), this.set("isExpanded", !0);
+  }
+  /**
+   * True if the current viewport height is stable and is not going to change in the next moment.
+   */
+  get isStable() {
+    return this.stableHeight === this.height;
+  }
+}
+async function Fe(e, t = {}) {
+  const {
+    height: s,
+    width: n,
+    isExpanded: r,
+    isStateStable: i
+  } = await Nt({ ...t, postEvent: e });
+  return new Dt({
+    postEvent: e,
+    height: s,
+    width: n,
+    isExpanded: r,
+    stableHeight: i ? s : 0
+  });
+}
+function Je({
+  state: e,
+  platform: t,
+  postEvent: s
+}) {
+  let n = !1, r = 0, i = 0, o = 0;
+  return e ? (n = e.isExpanded, r = e.height, i = e.width, o = e.stableHeight) : ["macos", "tdesktop", "unigram", "webk", "weba", "web"].includes(t) && (n = !0, r = window.innerHeight, i = window.innerWidth, o = window.innerHeight), new Dt({
+    postEvent: s,
+    height: r,
+    width: i,
+    stableHeight: o,
+    isExpanded: n
+  });
+}
+const vs = l(
+  "viewport",
+  async (e) => {
+    if (E() && !e.state)
+      throw u(
+        J,
+        "Viewport cannot be instantiated on the server side without passing the ssr.state object."
+      );
+    let t = Je(e);
+    return E() || (t.width === 0 && await Fe(e.postEvent, { timeout: 1e3 }).then((s) => t = s).catch((s) => D.error("Unable to sync viewport state", s)), t.listen()), t;
+  }
+);
+function m(e, t) {
+  document.documentElement.style.setProperty(e, t);
+}
+function Es(e, t, s) {
+  s || (s = (a) => `--tg-${a}-color`);
+  const n = s("header"), r = s("bg"), i = () => {
+    const { headerColor: a } = e;
+    if (Y(a))
+      m(n, a);
+    else {
+      const { bgColor: p, secondaryBgColor: d } = t;
+      a === "bg_color" && p ? m(n, p) : a === "secondary_bg_color" && d && m(n, d);
+    }
+    m(r, e.bgColor);
+  }, o = [
+    t.on("change", i),
+    e.on("change", i)
+  ];
+  return i(), () => o.forEach((a) => a());
+}
+function Ps(e, t) {
+  t || (t = (n) => `--tg-theme-${n.replace(/[A-Z]/g, (r) => `-${r.toLowerCase()}`)}`);
+  const s = () => {
+    Object.entries(e.getState()).forEach(([n, r]) => {
+      r && m(t(n), r);
+    });
+  };
+  return s(), e.on("change", s);
+}
+function Ss(e, t) {
+  t || (t = (d) => `--tg-viewport-${d}`);
+  const [
+    s,
+    n,
+    r
+  ] = ["height", "width", "stable-height"].map((d) => t(d)), i = () => m(s, `${e.height}px`), o = () => m(n, `${e.width}px`), a = () => m(r, `${e.stableHeight}px`), p = [
+    e.on("change:height", i),
+    e.on("change:width", o),
+    e.on("change:stableHeight", a)
+  ];
+  return i(), o(), a(), () => p.forEach((d) => d());
+}
+function xs(e = !0) {
+  const t = [
+    b("reload_iframe", () => {
+      T("iframe_will_reload"), window.location.reload();
+    })
+  ], s = () => t.forEach((n) => n());
+  if (e) {
+    const n = document.createElement("style");
+    n.id = "telegram-custom-styles", document.head.appendChild(n), t.push(
+      b("set_custom_style", (r) => {
+        n.innerHTML = r;
+      }),
+      () => document.head.removeChild(n)
+    );
+  }
+  return T("iframe_ready", { reload_supported: !0 }), s;
+}
+async function Rs() {
+  try {
+    return await f({ method: "web_app_request_theme", event: "theme_changed", timeout: 100 }), !0;
+  } catch {
+    return !1;
+  }
+}
+function Qe(e) {
+  return e instanceof $;
+}
+function Cs(e, t) {
+  return Qe(e) && e.type === t;
+}
+function O(e, t) {
+  let s, n, r;
+  return typeof e == "string" ? s = e : (s = e.pathname === void 0 ? t : e.pathname, n = e.params, r = e.id), Object.freeze({
+    id: r || (Math.random() * 2 ** 14 | 0).toString(16),
+    pathname: s,
+    params: n
+  });
+}
+class Ye {
+  constructor(t, s, n = T) {
+    /**
+     * Navigation history.
+     */
+    c(this, "history");
+    c(this, "ee", new V());
+    /**
+     * True, if current navigator is currently attached.
+     */
+    c(this, "attached", !1);
+    /**
+     * Goes to the previous history item.
+     */
+    c(this, "back", () => this.go(-1));
+    /**
+     * Adds new event listener.
+     */
+    c(this, "on", this.ee.on.bind(this.ee));
+    /**
+     * Removes event listener.
+     */
+    c(this, "off", this.ee.off.bind(this.ee));
+    if (this._index = s, this.postEvent = n, t.length === 0)
+      throw u(Jt, "History should not be empty.");
+    if (s < 0 || s >= t.length)
+      throw u(
+        Qt,
+        "Index should not be zero and higher or equal than history size."
+      );
+    this.history = t.map((r) => O(r, ""));
+  }
+  /**
+   * Allows this navigator to control the `BackButton` visibility state. It also tracks the
+   * `BackButton` clicks and calls the `back` method.
+   */
+  attach() {
+    this.attached || (this.attached = !0, this.sync(), b("back_button_pressed", this.back));
+  }
+  /**
+   * Currently active history item.
+   */
+  get current() {
+    return this.history[this.index];
+  }
+  /**
+   * Prevents current navigator from controlling the BackButton visibility state.
+   */
+  detach() {
+    this.attached = !1, B("back_button_pressed", this.back);
+  }
+  /**
+   * Goes to the next history item.
+   */
+  forward() {
+    this.go(1);
+  }
+  /**
+   * Changes currently active history item index by the specified delta. This method doesn't
+   * change index in case, the updated index points to the non-existing history item. This behavior
+   * is preserved until the `fit` argument is specified.
+   * @param delta - index delta.
+   * @param fit - cuts the delta argument to fit the bounds `[0, history.length - 1]`.
+   */
+  go(t, s) {
+    const n = this.index + t, r = Math.min(
+      Math.max(0, n),
+      this.history.length - 1
+    );
+    (n === r || s) && this.replaceAndMove(r, this.history[r]);
+  }
+  /**
+   * Goes to the specified index. Method does nothing in case, passed index is out of bounds.
+   *
+   * If "fit" option was specified and index is out of bounds, it will be cut to the nearest
+   * bound.
+   * @param index - target index.
+   * @param fit - cuts the index argument to fit the bounds `[0, history.length - 1]`.
+   */
+  goTo(t, s) {
+    this.go(t - this.index, s);
+  }
+  /**
+   * True if navigator has items before the current item.
+   */
+  get hasPrev() {
+    return this.index > 0;
+  }
+  /**
+   * True if navigator has items after the current item.
+   */
+  get hasNext() {
+    return this.index !== this.history.length - 1;
+  }
+  /**
+   * Currently active history item index.
+   */
+  get index() {
+    return this._index;
+  }
+  /**
+   * Adds a new history item removing all after the current one.
+   * @param item - item to add.
+   */
+  push(t) {
+    this.hasNext && this.history.splice(this.index + 1), this.replaceAndMove(this.index + 1, O(t, this.current.pathname));
+  }
+  /**
+   * Replaces the current history item.
+   * @param item - item to replace the current item with.
+   */
+  replace(t) {
+    this.replaceAndMove(this.index, O(t, this.current.pathname));
+  }
+  /**
+   * Sets history item by the specified index.
+   * @param index - history item index to replace.
+   * @param historyItem - history item to set.
+   */
+  replaceAndMove(t, s) {
+    const n = t - this.index;
+    if (!n && this.current === s)
+      return;
+    const r = this.current;
+    if (this.index !== t) {
+      const i = this._index;
+      this._index = t, this.attached && i > 0 != t > 0 && this.sync();
+    }
+    this.history[t] = s, this.ee.emit("change", {
+      navigator: this,
+      from: r,
+      to: this.current,
+      delta: n
+    });
+  }
+  /**
+   * Actualizes the `BackButton` visibility state.
+   */
+  sync() {
+    this.postEvent("web_app_setup_back_button", { is_visible: !!this.index });
+  }
+}
+function U({
+  params: e,
+  ...t
+}) {
+  return { ...e || { hash: "", search: "" }, ...t };
+}
+function A(e, t) {
+  return e.startsWith(t) ? e : `${t}${e}`;
+}
+function k(e) {
+  return new URL(
+    typeof e == "string" ? e : `${e.pathname || ""}${A(e.search || "", "?")}${A(e.hash || "", "#")}`,
+    "http://a"
+  );
+}
+function N(e) {
+  const t = typeof e == "string" ? e.startsWith("/") : !!(e.pathname && e.pathname.startsWith("/")), s = k(e);
+  return `${t ? s.pathname : s.pathname.slice(1)}${s.search}${s.hash}`;
+}
+function W(e, t, s) {
+  let n, r;
+  typeof e == "string" ? n = e : (n = N(e), s = e.state, r = e.id);
+  const { pathname: i, search: o, hash: a } = new URL(n, `http://a${A(t, "/")}`);
+  return { id: r, pathname: i, params: { hash: a, search: o, state: s } };
+}
+async function C(e) {
+  return e === 0 ? !0 : Promise.race([
+    new Promise((t) => {
+      const s = z("popstate", () => {
+        s(), t(!0);
+      });
+      window.history.go(e);
+    }),
+    // Usually, it takes about 1ms to emit this event, but we use some buffer.
+    new Promise((t) => {
+      setTimeout(t, 50, !1);
+    })
+  ]);
+}
+async function Ze() {
+  if (window.history.length <= 1 || (window.history.pushState(null, ""), await C(1 - window.history.length)))
+    return;
+  let t = await C(-1);
+  for (; t; )
+    t = await C(-1);
+}
+function Vt(e) {
+  return k(e).pathname;
+}
+const at = 0, H = 1, G = 2;
+class $t {
+  constructor(t, s, { postEvent: n, hashMode: r, base: i } = {}) {
+    c(this, "navigator");
+    c(this, "ee", new V());
+    c(this, "hashMode");
+    c(this, "base");
+    /**
+     * Shows whether the navigator is currently attached to the browser history.
+     */
+    c(this, "attached", !1);
+    /**
+     * Handles the window "popstate" event.
+     * @param state - event state.
+     */
+    c(this, "onPopState", ({ state: t }) => {
+      if (t === null)
+        return this.push(this.parsePath(window.location.href));
+      t === at ? window.history.forward() : t === H && this.back(), t === G && this.forward();
+    });
+    /**
+     * Underlying navigator change event listener.
+     */
+    c(this, "onNavigatorChange", async ({
+      to: t,
+      from: s,
+      delta: n
+    }) => {
+      this.attached && await this.syncHistory(), this.ee.emit("change", {
+        delta: n,
+        from: U(s),
+        to: U(t),
+        navigator: this
+      });
+    });
+    /**
+     * Adds new event listener.
+     */
+    c(this, "on", this.ee.on.bind(this.ee));
+    /**
+     * Removes event listener.
+     */
+    c(this, "off", this.ee.off.bind(this.ee));
+    this.navigator = new Ye(
+      t.map((o) => W(o, "/")),
+      s,
+      n
+    ), this.navigator.on("change", this.onNavigatorChange), this.hashMode = r, this.base = Vt(i || "");
+  }
+  /**
+   * Attaches current navigator to the browser history allowing navigator to manipulate it.
+   */
+  async attach() {
+    this.attached || (this.attached = !0, this.navigator.attach(), window.addEventListener("popstate", this.onPopState), await this.syncHistory());
+  }
+  /**
+   * Goes back in history by 1.
+   */
+  back() {
+    this.navigator.back();
+  }
+  /**
+   * Detaches current navigator from the browser history.
+   */
+  detach() {
+    this.attached = !1, this.navigator.detach(), window.removeEventListener("popstate", this.onPopState);
+  }
+  /**
+   * Goes forward in history.
+   */
+  forward() {
+    return this.navigator.forward();
+  }
+  /**
+   * Current history cursor.
+   */
+  get index() {
+    return this.navigator.index;
+  }
+  /**
+   * Current history item identifier.
+   */
+  get id() {
+    return this.navigator.current.id;
+  }
+  /**
+   * Changes currently active history item index by the specified delta. This method doesn't
+   * change index in case, the updated index points to the non-existing history item. This behavior
+   * is preserved until the `fit` argument is specified.
+   * @param delta - index delta.
+   * @param fit - cuts the delta argument to fit the bounds `[0, history.length - 1]`.
+   */
+  go(t, s) {
+    return this.navigator.go(t, s);
+  }
+  /**
+   * Goes to the specified index. Method does nothing in case, passed index is out of bounds.
+   *
+   * If "fit" option was specified and index is out of bounds, it will be cut to the nearest
+   * bound.
+   * @param index - target index.
+   * @param fit - cuts the index argument to fit the bounds `[0, history.length - 1]`.
+   */
+  goTo(t, s) {
+    this.navigator.goTo(t, s);
+  }
+  /**
+   * Current history item hash.
+   * @see URL.hash
+   * @example
+   * "", "#my-hash"
+   */
+  get hash() {
+    return (this.navigator.current.params || {}).hash || "";
+  }
+  /**
+   * True if navigator has items before the current item.
+   */
+  get hasPrev() {
+    return this.navigator.hasPrev;
+  }
+  /**
+   * True if navigator has items after the current item.
+   */
+  get hasNext() {
+    return this.navigator.hasNext;
+  }
+  /**
+   * Navigation history.
+   */
+  get history() {
+    return this.navigator.history.map(U);
+  }
+  /**
+   * Path, including pathname, search and hash.
+   * @example Pathname only.
+   * "/pathname"
+   * @example Pathname + search.
+   * "/pathname?search"
+   * @example Pathname + hash.
+   * "/pathname#hash"
+   * @example Pathname + search + hash.
+   * "/pathname?search#hash"
+   */
+  get path() {
+    return N(this);
+  }
+  /**
+   * Current pathname. Always starts with the slash.
+   * @see URL.pathname
+   * @example
+   * "/", "/abc"
+   */
+  get pathname() {
+    return this.navigator.current.pathname;
+  }
+  /**
+   * Depending on the current navigation type, parses incoming path and returns it presented as
+   * an object. In other words, this method parses the passed path and returns object, describing
+   * how the navigator "sees" it.
+   *
+   * @example Hash mode is omitted.
+   * parsePath('/abc?a=1#hash');
+   * // { pathname: '/abc', search: '?a=1', hash: '#hash' }
+   * parsePath('http://example.com/abc?a=1#hash');
+   * // { pathname: '/abc', search: '?a=1', hash: '#hash' }
+   *
+   * @example Hash mode is enabled.
+   * parsePath('/abc?a=1#tma?is=cool#yeah');
+   * // { pathname: '/tma', search: '?is=cool', hash: '#yeah' }
+   * parsePath('http://example.com/abc?a=1#tma?is=cool#yeah');
+   * // { pathname: '/tma', search: '?is=cool', hash: '#yeah' }
+   */
+  parsePath(t) {
+    let s = k(t);
+    return this.hashMode && (s = k(s.hash.slice(1))), {
+      pathname: s.pathname,
+      search: s.search,
+      hash: s.hash
+    };
+  }
+  push(t, s) {
+    const n = W(t, this.path), { state: r = s } = n.params;
+    this.navigator.push({ ...n, params: { ...n.params, state: r } });
+  }
+  replace(t, s) {
+    const n = W(t, this.path), { state: r = s } = n.params;
+    this.navigator.replace({ ...n, params: { ...n.params, state: r } });
+  }
+  /**
+   * Combines the navigator `base` property with the passed path data applying the navigator
+   * navigation mode.
+   * @param value - path presented as string or URLLike.
+   */
+  renderPath(t) {
+    const s = (this.base.length === 1 ? "" : this.base) + A(N(t), "/");
+    return this.hashMode ? A(s.slice(1), this.hashMode === "default" ? "#" : "#/") : s;
+  }
+  /**
+   * Synchronizes current navigator state with browser history.
+   */
+  async syncHistory() {
+    window.removeEventListener("popstate", this.onPopState);
+    const { state: t } = this, s = this.renderPath(this);
+    await Ze(), this.hasPrev && this.hasNext ? (window.history.replaceState(H, ""), window.history.pushState(t, "", s), window.history.pushState(G, ""), await C(-1)) : this.hasPrev ? (window.history.replaceState(H, ""), window.history.pushState(t, "", s)) : this.hasNext ? (window.history.replaceState(t, s), window.history.pushState(G, ""), await C(-1)) : (window.history.replaceState(at, ""), window.history.pushState(t, "", s)), window.addEventListener("popstate", this.onPopState);
+  }
+  /**
+   * Current query parameters.
+   * @see URL.search
+   * @example
+   * "", "?", "?a=1"
+   */
+  get search() {
+    return (this.navigator.current.params || {}).search || "";
+  }
+  /**
+   * Current history item state.
+   */
+  get state() {
+    return (this.navigator.current.params || {}).state;
+  }
+}
+function Xe(e) {
+  e || (e = {});
+  const { href: t, hash: s } = window.location;
+  let n = N(
+    e.hashMode ? s.includes("?") ? s.slice(1) : `?${s.slice(1)}` : t
+  );
+  const r = e.base ? Vt(e.base) : void 0;
+  if (r) {
+    if (!n.startsWith(r))
+      throw u(
+        Zt,
+        `Path "${n}" expected to be starting with "${r}"`
+      );
+    n = n.slice(r.length);
+  }
+  return new $t([n], 0, e);
+}
+function Ts(e) {
+  const t = e.match(/#(.+)/);
+  return t ? t[1] : null;
+}
+function Ke(e, t) {
+  if (At()) {
+    const s = sessionStorage.getItem(e);
+    if (s)
+      try {
+        const { index: n, history: r } = JSON.parse(s);
+        return new $t(r, n, t);
+      } catch (n) {
+        console.error("Unable to restore hash navigator state.", n);
+      }
+  }
+  return Xe(t);
+}
+function As(e, t) {
+  const s = Ke(e, t), n = () => sessionStorage.setItem(e, JSON.stringify({
+    index: s.index,
+    history: s.history
+  }));
+  return s.on("change", n), n(), s;
+}
+export {
+  fe as BackButton,
+  Ye as BasicNavigator,
+  it as BiometryManager,
+  $t as BrowserNavigator,
+  Ae as ClosingBehavior,
+  Ne as CloudStorage,
+  Zt as ERR_INVALID_PATH_BASE,
+  jt as ERR_INVOKE_CUSTOM_METHOD_RESPONSE,
+  Ht as ERR_METHOD_PARAMETER_UNSUPPORTED,
+  Wt as ERR_METHOD_UNSUPPORTED,
+  Jt as ERR_NAVIGATION_HISTORY_EMPTY,
+  Qt as ERR_NAVIGATION_INDEX_INVALID,
+  ss as ERR_NAVIGATION_ITEM_INVALID,
+  pt as ERR_PARSE,
+  J as ERR_SSR_INIT,
+  Yt as ERR_SSR_POST_EVENT,
+  zt as ERR_TIMED_OUT,
+  Ft as ERR_UNEXPECTED_TYPE,
+  Gt as ERR_UNKNOWN_ENV,
+  V as EventEmitter,
+  De as HapticFeedback,
+  Ve as InitData,
+  $e as Invoice,
+  Me as MainButton,
+  Oe as MiniApp,
+  We as Popup,
+  He as QRScanner,
+  $ as SDKError,
+  Ge as SettingsButton,
+  je as ThemeParams,
+  ze as Utils,
+  Dt as Viewport,
+  ke as array,
+  Es as bindMiniAppCSSVars,
+  Ps as bindThemeParamsCSSVars,
+  Ss as bindViewportCSSVars,
+  w as boolean,
+  ft as captureSameReq,
+  F as classNames,
+  ce as compareVersions,
+  Xe as createBrowserNavigatorFromLocation,
+  de as createPostEvent,
+  k as createSafeURL,
+  yt as date,
+  Ts as getHash,
+  Vt as getPathname,
+  is as initBackButton,
+  os as initBiometryManager,
+  as as initClosingBehavior,
+  cs as initCloudStorage,
+  hs as initHapticFeedback,
+  ps as initInitData,
+  ls as initInvoice,
+  ds as initMainButton,
+  _s as initMiniApp,
+  As as initNavigator,
+  fs as initPopup,
+  gs as initQRScanner,
+  bs as initSettingsButton,
+  ws as initThemeParams,
+  ys as initUtils,
+  vs as initViewport,
+  xs as initWeb,
+  R as invokeCustomMethod,
+  wt as isColorDark,
+  ue as isIframe,
+  At as isPageReload,
+  Y as isRGB,
+  Xt as isRGBShort,
+  Qe as isSDKError,
+  Cs as isSDKErrorOfType,
+  Rs as isTMA,
+  _ as json,
+  rs as mergeClassNames,
+  y as number,
+  B as off,
+  b as on,
+  us as parseInitData,
+  Pt as parseLaunchParams,
+  kt as parseThemeParams,
+  T as postEvent,
+  f as request,
+  Te as requestBiometryInfo,
+  ms as requestThemeParams,
+  Nt as requestViewport,
+  xe as retrieveLaunchParams,
+  dt as rgb,
+  K as searchParams,
+  Pe as serializeLaunchParams,
+  Ee as serializeThemeParams,
+  m as setCSSVar,
+  es as setDebug,
+  ns as setTargetOrigin,
+  h as string,
+  Bt as subscribe,
+  v as supports,
+  le as targetOrigin,
+  lt as toRGB,
+  ht as unsubscribe,
+  N as urlToPath,
+  bt as withTimeout
+};
+//# sourceMappingURL=index.js.map