@core-ease/telegram-kit 3.0.1

package/dist/chunk-FPWYSKK2.mjs

@@ -0,0 +1,3089 @@
+"use client";
+import { __spreadValues } from './chunk-7AARTHNW.mjs';
+
+// src/sdk/_internal/core/utils.ts
+function urlSafeDecode(urlencoded) {
+  try {
+    urlencoded = urlencoded.replace(/\+/g, "%20");
+    return decodeURIComponent(urlencoded);
+  } catch (e) {
+    return urlencoded;
+  }
+}
+function urlParseQueryString(queryString) {
+  const params = {};
+  if (!queryString.length) {
+    return params;
+  }
+  const queryStringParams = queryString.split("&");
+  for (let i = 0; i < queryStringParams.length; i++) {
+    const param = queryStringParams[i].split("=");
+    const paramName = urlSafeDecode(param[0]);
+    const paramValue = param[1] == null ? null : urlSafeDecode(param[1]);
+    params[paramName] = paramValue;
+  }
+  return params;
+}
+function urlParseHashParams(locationHash) {
+  locationHash = locationHash.replace(/^#/, "");
+  const params = {};
+  if (!locationHash.length) {
+    return params;
+  }
+  if (locationHash.indexOf("=") < 0 && locationHash.indexOf("?") < 0) {
+    params._path = urlSafeDecode(locationHash);
+    return params;
+  }
+  const qIndex = locationHash.indexOf("?");
+  if (qIndex >= 0) {
+    const pathParam = locationHash.substr(0, qIndex);
+    params._path = urlSafeDecode(pathParam);
+    locationHash = locationHash.substr(qIndex + 1);
+  }
+  const queryParams = urlParseQueryString(locationHash);
+  for (const k in queryParams) {
+    params[k] = queryParams[k];
+  }
+  return params;
+}
+function urlAppendHashParams(url, addHash) {
+  const ind = url.indexOf("#");
+  if (ind < 0) {
+    return url + "#" + addHash;
+  }
+  const curHash = url.substr(ind + 1);
+  if (curHash.indexOf("=") >= 0 || curHash.indexOf("?") >= 0) {
+    return url + "&" + addHash;
+  }
+  if (curHash.length > 0) {
+    return url + "?" + addHash;
+  }
+  return url + addHash;
+}
+var SESSION_STORAGE_PREFIX = "__telegram__";
+function sessionStorageSet(key, value) {
+  try {
+    window.sessionStorage.setItem(SESSION_STORAGE_PREFIX + key, JSON.stringify(value));
+    return true;
+  } catch (e) {
+  }
+  return false;
+}
+function sessionStorageGet(key) {
+  try {
+    const raw = window.sessionStorage.getItem(SESSION_STORAGE_PREFIX + key);
+    return JSON.parse(raw);
+  } catch (e) {
+  }
+  return null;
+}
+function strTrim(str) {
+  return String(str).replace(/^\s+|\s+$/g, "");
+}
+function byteLength(str) {
+  if (typeof window !== "undefined" && window.Blob) {
+    try {
+      return new Blob([str]).size;
+    } catch (e) {
+    }
+  }
+  let s = str.length;
+  for (let i = str.length - 1; i >= 0; i--) {
+    const code = str.charCodeAt(i);
+    if (code > 127 && code <= 2047) s++;
+    else if (code > 2047 && code <= 65535) s += 2;
+    if (code >= 56320 && code <= 57343) i--;
+  }
+  return s;
+}
+function versionCompare(v1, v2) {
+  const a1 = (typeof v1 === "string" ? v1 : "").replace(/^\s+|\s+$/g, "").split(".");
+  const a2 = (typeof v2 === "string" ? v2 : "").replace(/^\s+|\s+$/g, "").split(".");
+  const len = Math.max(a1.length, a2.length);
+  for (let i = 0; i < len; i++) {
+    const p1 = parseInt(a1[i]) || 0;
+    const p2 = parseInt(a2[i]) || 0;
+    if (p1 == p2) continue;
+    if (p1 > p2) return 1;
+    return -1;
+  }
+  return 0;
+}
+function parseColorToHex(color) {
+  const str = String(color);
+  let match;
+  if (match = /^\s*#([0-9a-f]{6})\s*$/i.exec(str)) {
+    return "#" + match[1].toLowerCase();
+  } else if (match = /^\s*#([0-9a-f])([0-9a-f])([0-9a-f])\s*$/i.exec(str)) {
+    return ("#" + match[1] + match[1] + match[2] + match[2] + match[3] + match[3]).toLowerCase();
+  } else if (match = /^\s*rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+\.{0,1}\d*))?\)\s*$/.exec(str)) {
+    let r = parseInt(match[1]);
+    let g = parseInt(match[2]);
+    let b = parseInt(match[3]);
+    const rHex = (r < 16 ? "0" : "") + r.toString(16);
+    const gHex = (g < 16 ? "0" : "") + g.toString(16);
+    const bHex = (b < 16 ? "0" : "") + b.toString(16);
+    return "#" + rHex + gHex + bHex;
+  }
+  return false;
+}
+function isColorDark(rgb) {
+  let hex = rgb.replace(/[\s#]/g, "");
+  if (hex.length == 3) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+  }
+  const r = parseInt(hex.substr(0, 2), 16);
+  const g = parseInt(hex.substr(2, 2), 16);
+  const b = parseInt(hex.substr(4, 2), 16);
+  const hsp = Math.sqrt(0.299 * (r * r) + 0.587 * (g * g) + 0.114 * (b * b));
+  return hsp < 120;
+}
+function generateRandomId(len, taken) {
+  let tries = 100;
+  const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+  const charsLen = chars.length;
+  while (--tries) {
+    let id = "";
+    for (let i = 0; i < len; i++) {
+      id += chars[Math.floor(Math.random() * charsLen)];
+    }
+    if (!taken(id)) {
+      return id;
+    }
+  }
+  throw new Error("WebAppCallbackIdGenerateFailed");
+}
+
+// src/sdk/_internal/core/webview.ts
+var TelegramWebView = class {
+  constructor() {
+    this.eventHandlers = {};
+    this.handleParentMessage = (event) => {
+      if (event.source !== window.parent) return;
+      let dataParsed;
+      try {
+        dataParsed = JSON.parse(event.data);
+      } catch (e) {
+        return;
+      }
+      if (!dataParsed || !dataParsed.eventType) {
+        return;
+      }
+      if (dataParsed.eventType == "set_custom_style") {
+        if (event.origin === "https://web.telegram.org" && this.iFrameStyleEl) {
+          this.iFrameStyleEl.innerHTML = dataParsed.eventData;
+        }
+      } else if (dataParsed.eventType == "reload_iframe") {
+        try {
+          window.parent.postMessage(JSON.stringify({ eventType: "iframe_will_reload" }), "*");
+        } catch (e) {
+        }
+        location.reload();
+      } else {
+        this.receiveEvent(dataParsed.eventType, dataParsed.eventData);
+      }
+    };
+    /** Dispatches an incoming event to every subscriber of `eventType`. */
+    this.receiveEvent = (eventType, eventData) => {
+      console.log("[@core-ease/telegram-kit:webview] < receiveEvent", eventType, eventData);
+      this.callEventCallbacks(eventType, (callback) => callback(eventType, eventData));
+    };
+    let locationHash = "";
+    try {
+      locationHash = location.hash.toString();
+    } catch (e) {
+    }
+    const parsedParams = urlParseHashParams(locationHash);
+    const storedParams = sessionStorageGet("initParams");
+    if (storedParams) {
+      for (const key in storedParams) {
+        if (typeof parsedParams[key] === "undefined") {
+          parsedParams[key] = storedParams[key];
+        }
+      }
+    }
+    sessionStorageSet("initParams", parsedParams);
+    this.initParams = parsedParams;
+    let isIframe = false;
+    try {
+      isIframe = window.parent != null && window !== window.parent;
+      if (isIframe) {
+        window.addEventListener("message", this.handleParentMessage);
+        this.iFrameStyleEl = document.createElement("style");
+        document.head.appendChild(this.iFrameStyleEl);
+        try {
+          window.parent.postMessage(
+            JSON.stringify({ eventType: "iframe_ready", eventData: { reload_supported: true } }),
+            "*"
+          );
+        } catch (e) {
+        }
+      }
+    } catch (e) {
+    }
+    this.isIframe = isIframe;
+    window.TelegramGameProxy_receiveEvent = this.receiveEvent;
+    window.TelegramGameProxy = { receiveEvent: this.receiveEvent };
+  }
+  /** Sends a named event + payload to the native Telegram client. */
+  postEvent(eventType, callback, eventData = "") {
+    const cb = callback || (() => {
+    });
+    console.log("[@core-ease/telegram-kit:webview] > postEvent", eventType, eventData);
+    if (window.TelegramWebviewProxy !== void 0) {
+      window.TelegramWebviewProxy.postEvent(eventType, JSON.stringify(eventData));
+      cb();
+    } else if (window.external && "notify" in window.external) {
+      window.external.notify(JSON.stringify({ eventType, eventData }));
+      cb();
+    } else if (this.isIframe) {
+      try {
+        const trustedTarget = "*";
+        window.parent.postMessage(JSON.stringify({ eventType, eventData }), trustedTarget);
+        cb();
+      } catch (e) {
+        cb(e);
+      }
+    } else {
+      cb({ notAvailable: true });
+    }
+  }
+  callEventCallbacks(eventType, func) {
+    const handlers = this.eventHandlers[eventType];
+    if (!handlers || !handlers.length) {
+      return;
+    }
+    for (let i = 0; i < handlers.length; i++) {
+      try {
+        func(handlers[i]);
+      } catch (e) {
+      }
+    }
+  }
+  onEvent(eventType, callback) {
+    if (this.eventHandlers[eventType] === void 0) {
+      this.eventHandlers[eventType] = [];
+    }
+    if (this.eventHandlers[eventType].indexOf(callback) === -1) {
+      this.eventHandlers[eventType].push(callback);
+    }
+  }
+  offEvent(eventType, callback) {
+    const handlers = this.eventHandlers[eventType];
+    if (handlers === void 0) {
+      return;
+    }
+    const index = handlers.indexOf(callback);
+    if (index === -1) {
+      return;
+    }
+    handlers.splice(index, 1);
+  }
+};
+var Utils = {
+  urlSafeDecode,
+  urlParseQueryString,
+  urlParseHashParams,
+  urlAppendHashParams,
+  sessionStorageSet,
+  sessionStorageGet
+};
+
+// src/sdk/_internal/core/errors.ts
+var WebAppErrorName = /* @__PURE__ */ ((WebAppErrorName2) => {
+  WebAppErrorName2["MethodUnsupported"] = "WebAppMethodUnsupported";
+  WebAppErrorName2["DataInvalid"] = "WebAppDataInvalid";
+  WebAppErrorName2["InlineModeDisabled"] = "WebAppInlineModeDisabled";
+  WebAppErrorName2["InlineQueryInvalid"] = "WebAppInlineQueryInvalid";
+  WebAppErrorName2["InlineChooseChatTypesInvalid"] = "WebAppInlineChooseChatTypesInvalid";
+  WebAppErrorName2["InlineChooseChatTypeInvalid"] = "WebAppInlineChooseChatTypeInvalid";
+  WebAppErrorName2["TgUrlInvalid"] = "WebAppTgUrlInvalid";
+  WebAppErrorName2["InvoiceUrlInvalid"] = "WebAppInvoiceUrlInvalid";
+  WebAppErrorName2["InvoiceOpened"] = "WebAppInvoiceOpened";
+  WebAppErrorName2["PopupOpened"] = "WebAppPopupOpened";
+  WebAppErrorName2["PopupParamInvalid"] = "WebAppPopupParamInvalid";
+  WebAppErrorName2["ScanQrPopupOpened"] = "WebAppScanQrPopupOpened";
+  WebAppErrorName2["ScanQrPopupParamInvalid"] = "WebAppScanQrPopupParamInvalid";
+  WebAppErrorName2["WriteAccessRequested"] = "WebAppWriteAccessRequested";
+  WebAppErrorName2["ContactRequested"] = "WebAppContactRequested";
+  WebAppErrorName2["DownloadFilePopupOpened"] = "WebAppDownloadFilePopupOpened";
+  WebAppErrorName2["DownloadFileParamInvalid"] = "WebAppDownloadFileParamInvalid";
+  WebAppErrorName2["MediaUrlInvalid"] = "WebAppMediaUrlInvalid";
+  WebAppErrorName2["ShareToStoryParamInvalid"] = "WebAppShareToStoryParamInvalid";
+  WebAppErrorName2["ShareMessageOpened"] = "WebAppShareMessageOpened";
+  WebAppErrorName2["RequestChatOpened"] = "WebAppRequestChatOpened";
+  WebAppErrorName2["EmojiStatusRequested"] = "WebAppEmojiStatusRequested";
+  WebAppErrorName2["EmojiStatusAccessRequested"] = "WebAppEmojiStatusAccessRequested";
+  WebAppErrorName2["HeaderColorInvalid"] = "WebAppHeaderColorInvalid";
+  WebAppErrorName2["HeaderColorKeyInvalid"] = "WebAppHeaderColorKeyInvalid";
+  WebAppErrorName2["BackgroundColorInvalid"] = "WebAppBackgroundColorInvalid";
+  WebAppErrorName2["BottomBarColorInvalid"] = "WebAppBottomBarColorInvalid";
+  WebAppErrorName2["BottomButtonParamInvalid"] = "WebAppBottomButtonParamInvalid";
+  WebAppErrorName2["HapticImpactStyleInvalid"] = "WebAppHapticImpactStyleInvalid";
+  WebAppErrorName2["HapticNotificationTypeInvalid"] = "WebAppHapticNotificationTypeInvalid";
+  WebAppErrorName2["HapticFeedbackTypeInvalid"] = "WebAppHapticFeedbackTypeInvalid";
+  WebAppErrorName2["BiometricManagerNotInited"] = "WebAppBiometricManagerNotInited";
+  WebAppErrorName2["BiometricManagerBiometricsNotAvailable"] = "WebAppBiometricManagerBiometricsNotAvailable";
+  WebAppErrorName2["BiometricManagerAccessRequested"] = "WebAppBiometricManagerAccessRequested";
+  WebAppErrorName2["BiometricManagerBiometricAccessNotGranted"] = "WebAppBiometricManagerBiometricAccessNotGranted";
+  WebAppErrorName2["BiometricManagerAuthenticationRequested"] = "WebAppBiometricManagerAuthenticationRequested";
+  WebAppErrorName2["BiometricManagerTokenInvalid"] = "WebAppBiometricManagerTokenInvalid";
+  WebAppErrorName2["BiometricManagerTokenUpdateRequested"] = "WebAppBiometricManagerTokenUpdateRequested";
+  WebAppErrorName2["BiometricManagerBiometricsAccessNotRequested"] = "WebAppBiometricManagerBiometricsAccessNotRequested";
+  WebAppErrorName2["BiometricRequestAccessParamInvalid"] = "WebAppBiometricRequestAccessParamInvalid";
+  WebAppErrorName2["LocationManagerNotInited"] = "WebAppLocationManagerNotInited";
+  WebAppErrorName2["LocationManagerLocationNotAvailable"] = "WebAppLocationManagerLocationNotAvailable";
+  WebAppErrorName2["LocationManagerLocationAccessNotRequested"] = "WebAppLocationManagerLocationAccessNotRequested";
+  WebAppErrorName2["CallbackIdGenerateFailed"] = "WebAppCallbackIdGenerateFailed";
+  return WebAppErrorName2;
+})(WebAppErrorName || {});
+var WebAppError = class _WebAppError extends Error {
+  constructor(name) {
+    super(name);
+    this.name = name;
+    this.message = name;
+    Object.setPrototypeOf(this, _WebAppError.prototype);
+  }
+};
+function throwWebAppError(name) {
+  throw new WebAppError(name);
+}
+
+// src/sdk/_internal/core/kernel.ts
+var WebAppKernel = class {
+  constructor(webView) {
+    /** Mutable current protocol version reported by the client, e.g. '8.0'. */
+    this._version = "6.0";
+    this.callbacks = {};
+    /** Height (px) reserved by the in-browser debug bottom bar, if active. */
+    this.bottomBarHeightPx = 0;
+    this.onCustomMethodInvoked = (_eventType, eventData) => {
+      var _a;
+      if (eventData.req_id && this.hasCallback(eventData.req_id)) {
+        const entry = this.takeCallback(eventData.req_id);
+        let res = null;
+        let err = null;
+        if (typeof eventData.result !== "undefined") {
+          res = eventData.result;
+        }
+        if (typeof eventData.error !== "undefined") {
+          err = eventData.error;
+        }
+        (_a = entry == null ? void 0 : entry.callback) == null ? void 0 : _a.call(entry, err, res);
+      }
+    };
+    this.webView = webView;
+    this.initParams = webView.initParams;
+    if (this.initParams.tgWebAppVersion) {
+      this._version = this.initParams.tgWebAppVersion;
+    }
+  }
+  get version() {
+    return this._version;
+  }
+  set version(v) {
+    this._version = v;
+  }
+  versionAtLeast(ver) {
+    return versionCompare(this._version, ver) >= 0;
+  }
+  /** Logs + throws `WebAppMethodUnsupported` for a method gated by version. */
+  requireVersion(ver, methodName) {
+    if (!this.versionAtLeast(ver)) {
+      console.error(`[@core-ease/telegram-kit] Method ${methodName} is not supported in version ${this._version}`);
+      throwWebAppError("WebAppMethodUnsupported" /* MethodUnsupported */);
+    }
+  }
+  /** Same as {@link requireVersion} but warns instead of throwing (soft-gated features). */
+  warnIfUnsupported(ver, featureName) {
+    if (!this.versionAtLeast(ver)) {
+      console.warn(`[@core-ease/telegram-kit] ${featureName} is not supported in version ${this._version}`);
+      return false;
+    }
+    return true;
+  }
+  setCssProperty(name, value) {
+    const root = document.documentElement;
+    if (root && root.style && root.style.setProperty) {
+      root.style.setProperty("--tg-" + name, value);
+    }
+  }
+  strTrim(str) {
+    return strTrim(str);
+  }
+  byteLength(str) {
+    return byteLength(str);
+  }
+  /** Dispatches an internal `webview:<eventType>` event to WebApp-level subscribers. */
+  receiveWebViewEvent(eventType, ...args) {
+    this.webView.callEventCallbacks("webview:" + eventType, (callback) => {
+      callback.apply(null, args);
+    });
+  }
+  onWebViewEvent(eventType, callback) {
+    this.webView.onEvent("webview:" + eventType, callback);
+  }
+  offWebViewEvent(eventType, callback) {
+    this.webView.offEvent("webview:" + eventType, callback);
+  }
+  /** Allocates a fresh request id and registers its pending callback. */
+  registerCallback(callback, len = 16) {
+    const id = generateRandomId(len, (candidate) => !!this.callbacks[candidate]);
+    this.callbacks[id] = { callback };
+    return id;
+  }
+  takeCallback(reqId) {
+    const entry = this.callbacks[reqId];
+    if (entry) {
+      delete this.callbacks[reqId];
+    }
+    return entry;
+  }
+  hasCallback(reqId) {
+    return !!this.callbacks[reqId];
+  }
+  /** Generic `web_app_invoke_custom_method` used by CloudStorage, contact lookup, etc. */
+  invokeCustomMethod(method, params, callback) {
+    this.requireVersion("6.9", "invokeCustomMethod");
+    const reqId = this.registerCallback(callback);
+    this.webView.postEvent("web_app_invoke_custom_method", void 0, {
+      req_id: reqId,
+      method,
+      params: params || {}
+    });
+  }
+};
+
+// src/sdk/_internal/theme/theme-manager.ts
+var ThemeManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.themeParams = {};
+    this._colorScheme = "light";
+    this.backgroundColorValue = "bg_color";
+    this.appBackgroundColor = null;
+    this.headerColorKey = "bg_color";
+    this.headerColorValue = null;
+    this.appHeaderColorKey = null;
+    this.appHeaderColorValue = null;
+    this.bottomBarColorValue = "bottom_bar_bg_color";
+    this.appBottomBarColor = null;
+    /** Called after every bottom-bar color update, e.g. to refresh the debug bar. */
+    this.onBottomBarColorApplied = null;
+    const storedTheme = sessionStorageGet("themeParams");
+    const rawTheme = kernel.initParams.tgWebAppThemeParams;
+    if (rawTheme && rawTheme.length) {
+      try {
+        const parsed = JSON.parse(rawTheme);
+        if (parsed) this.setThemeParams(parsed);
+      } catch (e) {
+      }
+    }
+    if (storedTheme) {
+      this.setThemeParams(storedTheme);
+    }
+    const storedColors = sessionStorageGet("defaultColors");
+    const rawColors = kernel.initParams.tgWebAppDefaultColors;
+    if (rawColors && rawColors.length) {
+      try {
+        const parsed = JSON.parse(rawColors);
+        if (parsed) this.setDefaultColors(parsed);
+      } catch (e) {
+      }
+    }
+    if (storedColors) {
+      this.setDefaultColors(storedColors);
+    }
+  }
+  get colorScheme() {
+    return this._colorScheme;
+  }
+  getThemeParams() {
+    return this.themeParams;
+  }
+  setThemeParams(theme) {
+    if (theme.bg_color == "#1c1c1d" && theme.bg_color == theme.secondary_bg_color) {
+      theme.secondary_bg_color = "#2c2c2e";
+    }
+    for (const key in theme) {
+      const color = parseColorToHex(theme[key]);
+      if (color) {
+        this.themeParams[key] = color;
+        if (key == "bg_color") {
+          this._colorScheme = isColorDark(color) ? "dark" : "light";
+          this.kernel.setCssProperty("color-scheme", this._colorScheme);
+        }
+        const cssKey = "theme-" + key.split("_").join("-");
+        this.kernel.setCssProperty(cssKey, color);
+      }
+    }
+    sessionStorageSet("themeParams", this.themeParams);
+  }
+  setDefaultColors(defColors) {
+    if (this._colorScheme == "dark") {
+      if (defColors.bg_dark_color) {
+        this.backgroundColorValue = defColors.bg_dark_color;
+      }
+      if (defColors.header_dark_color) {
+        this.headerColorKey = null;
+        this.headerColorValue = defColors.header_dark_color;
+      }
+    } else {
+      if (defColors.bg_color) {
+        this.backgroundColorValue = defColors.bg_color;
+      }
+      if (defColors.header_color) {
+        this.headerColorKey = null;
+        this.headerColorValue = defColors.header_color;
+      }
+    }
+    sessionStorageSet("defaultColors", defColors);
+  }
+  // ---------------------------------------------------------------------
+  // Header color
+  // ---------------------------------------------------------------------
+  getHeaderColor() {
+    if (this.headerColorKey == "secondary_bg_color") {
+      return this.themeParams.secondary_bg_color;
+    } else if (this.headerColorKey == "bg_color") {
+      return this.themeParams.bg_color;
+    }
+    return this.headerColorValue;
+  }
+  setHeaderColor(color) {
+    if (!this.kernel.warnIfUnsupported("6.1", "Header color")) {
+      return;
+    }
+    if (!this.kernel.versionAtLeast("6.9")) {
+      if (this.themeParams.bg_color && this.themeParams.bg_color == color) {
+        color = "bg_color";
+      } else if (this.themeParams.secondary_bg_color && this.themeParams.secondary_bg_color == color) {
+        color = "secondary_bg_color";
+      }
+    }
+    let headColor = null;
+    let colorKey = null;
+    if (color == "bg_color" || color == "secondary_bg_color") {
+      colorKey = color;
+    } else if (this.kernel.versionAtLeast("6.9")) {
+      headColor = parseColorToHex(color);
+      if (!headColor) {
+        console.error("[@core-ease/telegram-kit] Header color format is invalid", color);
+        throwWebAppError("WebAppHeaderColorInvalid" /* HeaderColorInvalid */);
+      }
+    }
+    if (!this.kernel.versionAtLeast("6.9") && colorKey != "bg_color" && colorKey != "secondary_bg_color") {
+      console.error(
+        "[@core-ease/telegram-kit] Header color key should be one of Telegram.WebApp.themeParams.bg_color, Telegram.WebApp.themeParams.secondary_bg_color, 'bg_color', 'secondary_bg_color'",
+        color
+      );
+      throwWebAppError("WebAppHeaderColorKeyInvalid" /* HeaderColorKeyInvalid */);
+    }
+    this.headerColorKey = colorKey;
+    this.headerColorValue = headColor || null;
+    this.updateHeaderColor();
+  }
+  updateHeaderColor() {
+    if (this.appHeaderColorKey != this.headerColorKey || this.appHeaderColorValue != this.headerColorValue) {
+      this.appHeaderColorKey = this.headerColorKey;
+      this.appHeaderColorValue = this.headerColorValue;
+      if (this.appHeaderColorValue) {
+        this.kernel.webView.postEvent("web_app_set_header_color", void 0, { color: this.appHeaderColorValue });
+      } else {
+        this.kernel.webView.postEvent("web_app_set_header_color", void 0, { color_key: this.appHeaderColorKey });
+      }
+    }
+  }
+  // ---------------------------------------------------------------------
+  // Background color
+  // ---------------------------------------------------------------------
+  getBackgroundColor() {
+    if (this.backgroundColorValue == "secondary_bg_color") {
+      return this.themeParams.secondary_bg_color;
+    } else if (this.backgroundColorValue == "bg_color") {
+      return this.themeParams.bg_color;
+    }
+    return this.backgroundColorValue;
+  }
+  setBackgroundColor(color) {
+    if (!this.kernel.warnIfUnsupported("6.1", "Background color")) {
+      return;
+    }
+    let bgColor;
+    if (color == "bg_color" || color == "secondary_bg_color") {
+      bgColor = color;
+    } else {
+      const parsed = parseColorToHex(color);
+      if (!parsed) {
+        console.error("[@core-ease/telegram-kit] Background color format is invalid", color);
+        throwWebAppError("WebAppBackgroundColorInvalid" /* BackgroundColorInvalid */);
+      }
+      bgColor = parsed;
+    }
+    this.backgroundColorValue = bgColor;
+    this.updateBackgroundColor();
+  }
+  updateBackgroundColor() {
+    const color = this.getBackgroundColor();
+    if (this.appBackgroundColor != color) {
+      this.appBackgroundColor = color != null ? color : null;
+      this.kernel.webView.postEvent("web_app_set_background_color", void 0, { color });
+    }
+  }
+  // ---------------------------------------------------------------------
+  // Bottom bar color
+  // ---------------------------------------------------------------------
+  getBottomBarColor() {
+    if (this.bottomBarColorValue == "bottom_bar_bg_color") {
+      return this.themeParams.bottom_bar_bg_color || this.themeParams.secondary_bg_color || "#ffffff";
+    } else if (this.bottomBarColorValue == "secondary_bg_color") {
+      return this.themeParams.secondary_bg_color;
+    } else if (this.bottomBarColorValue == "bg_color") {
+      return this.themeParams.bg_color;
+    }
+    return this.bottomBarColorValue;
+  }
+  setBottomBarColor(color) {
+    if (!this.kernel.warnIfUnsupported("7.10", "Bottom bar color")) {
+      return;
+    }
+    let bgColor;
+    if (color == "bg_color" || color == "secondary_bg_color" || color == "bottom_bar_bg_color") {
+      bgColor = color;
+    } else {
+      const parsed = parseColorToHex(color);
+      if (!parsed) {
+        console.error("[@core-ease/telegram-kit] Bottom bar color format is invalid", color);
+        throwWebAppError("WebAppBottomBarColorInvalid" /* BottomBarColorInvalid */);
+      }
+      bgColor = parsed;
+    }
+    this.bottomBarColorValue = bgColor;
+    this.updateBottomBarColor();
+  }
+  updateBottomBarColor() {
+    var _a;
+    const color = this.getBottomBarColor();
+    if (this.appBottomBarColor != color) {
+      this.appBottomBarColor = color;
+      this.kernel.webView.postEvent("web_app_set_bottom_bar_color", void 0, { color });
+    }
+    (_a = this.onBottomBarColorApplied) == null ? void 0 : _a.call(this);
+  }
+};
+
+// src/sdk/_internal/theme/viewport-manager.ts
+var ViewportManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.viewportHeightPx = false;
+    this.viewportStableHeightPx = false;
+    this._isExpanded = true;
+    this._safeAreaInset = { top: 0, bottom: 0, left: 0, right: 0 };
+    this._contentSafeAreaInset = { top: 0, bottom: 0, left: 0, right: 0 };
+    this._isFullscreen = false;
+    this._isOrientationLocked = false;
+    this._isClosingConfirmationEnabled = false;
+    this._isVerticalSwipesEnabled = true;
+    this.lastWindowHeight = typeof window !== "undefined" ? window.innerHeight : 0;
+    this.handleViewportChanged = (_eventType, eventData) => {
+      if (eventData.height) {
+        window.removeEventListener("resize", this.onWindowResize);
+        this.setViewportHeight(eventData);
+      }
+    };
+    this.handleSafeAreaChanged = (_eventType, eventData) => {
+      if (eventData) this.setSafeAreaInset(eventData);
+    };
+    this.handleContentSafeAreaChanged = (_eventType, eventData) => {
+      if (eventData) this.setContentSafeAreaInset(eventData);
+    };
+    this.handleFullscreenChanged = (_eventType, eventData) => {
+      this.setFullscreen(eventData.is_fullscreen);
+      this.kernel.receiveWebViewEvent("fullscreenChanged");
+    };
+    this.handleFullscreenFailed = (_eventType, eventData) => {
+      if (eventData.error == "ALREADY_FULLSCREEN" && !this._isFullscreen) {
+        this.setFullscreen(true);
+      }
+      this.kernel.receiveWebViewEvent("fullscreenFailed", { error: eventData.error });
+    };
+    if (kernel.initParams.tgWebAppFullscreen) {
+      this.setFullscreen(true);
+    }
+    const storedFullscreen = sessionStorageGet("isFullscreen");
+    if (storedFullscreen) {
+      this.setFullscreen(storedFullscreen == "yes");
+    }
+    const storedOrientationLock = sessionStorageGet("isOrientationLocked");
+    if (storedOrientationLock) {
+      this.setOrientationLock(storedOrientationLock == "yes");
+    }
+    this.onWindowResize = this.onWindowResize.bind(this);
+  }
+  // ---------------------------------------------------------------------
+  // Getters mirroring the public WebApp properties
+  // ---------------------------------------------------------------------
+  get isExpanded() {
+    return this._isExpanded;
+  }
+  get viewportHeight() {
+    const raw = this.viewportHeightPx === false ? window.innerHeight : this.viewportHeightPx;
+    return raw - this.kernel.bottomBarHeightPx;
+  }
+  get viewportStableHeight() {
+    const raw = this.viewportStableHeightPx === false ? window.innerHeight : this.viewportStableHeightPx;
+    return raw - this.kernel.bottomBarHeightPx;
+  }
+  get safeAreaInset() {
+    return this._safeAreaInset;
+  }
+  get contentSafeAreaInset() {
+    return this._contentSafeAreaInset;
+  }
+  get isFullscreen() {
+    return this._isFullscreen;
+  }
+  get isOrientationLocked() {
+    return this._isOrientationLocked;
+  }
+  get isClosingConfirmationEnabled() {
+    return this._isClosingConfirmationEnabled;
+  }
+  get isVerticalSwipesEnabled() {
+    return this._isVerticalSwipesEnabled;
+  }
+  // ---------------------------------------------------------------------
+  // Viewport height
+  // ---------------------------------------------------------------------
+  /** Re-applies the current viewport CSS vars; call after bottom-bar height changes too. */
+  setViewportHeight(data) {
+    let emitEvent = false;
+    if (typeof data !== "undefined") {
+      this._isExpanded = !!data.is_expanded;
+      this.viewportHeightPx = data.height;
+      if (data.is_state_stable) {
+        this.viewportStableHeightPx = data.height;
+      }
+      emitEvent = true;
+    }
+    const bottomBarHeight = this.kernel.bottomBarHeightPx;
+    const height = this.viewportHeightPx !== false ? this.viewportHeightPx - bottomBarHeight + "px" : bottomBarHeight ? `calc(100vh - ${bottomBarHeight}px)` : "100vh";
+    const stableHeight = this.viewportStableHeightPx !== false ? this.viewportStableHeightPx - bottomBarHeight + "px" : bottomBarHeight ? `calc(100vh - ${bottomBarHeight}px)` : "100vh";
+    this.kernel.setCssProperty("viewport-height", height);
+    this.kernel.setCssProperty("viewport-stable-height", stableHeight);
+    if (emitEvent) {
+      this.kernel.receiveWebViewEvent("viewportChanged", { isStateStable: !!data.is_state_stable });
+    }
+  }
+  onWindowResize() {
+    if (this.lastWindowHeight != window.innerHeight) {
+      this.lastWindowHeight = window.innerHeight;
+      this.kernel.receiveWebViewEvent("viewportChanged", { isStateStable: true });
+    }
+  }
+  // ---------------------------------------------------------------------
+  // Safe area insets
+  // ---------------------------------------------------------------------
+  setSafeAreaInset(data) {
+    if (typeof data !== "undefined") {
+      if (typeof data.top !== "undefined") this._safeAreaInset.top = data.top;
+      if (typeof data.bottom !== "undefined") this._safeAreaInset.bottom = data.bottom;
+      if (typeof data.left !== "undefined") this._safeAreaInset.left = data.left;
+      if (typeof data.right !== "undefined") this._safeAreaInset.right = data.right;
+      this.kernel.receiveWebViewEvent("safeAreaChanged");
+    }
+    this.kernel.setCssProperty("safe-area-inset-top", this._safeAreaInset.top + "px");
+    this.kernel.setCssProperty("safe-area-inset-bottom", this._safeAreaInset.bottom + "px");
+    this.kernel.setCssProperty("safe-area-inset-left", this._safeAreaInset.left + "px");
+    this.kernel.setCssProperty("safe-area-inset-right", this._safeAreaInset.right + "px");
+  }
+  setContentSafeAreaInset(data) {
+    if (typeof data !== "undefined") {
+      if (typeof data.top !== "undefined") this._contentSafeAreaInset.top = data.top;
+      if (typeof data.bottom !== "undefined") this._contentSafeAreaInset.bottom = data.bottom;
+      if (typeof data.left !== "undefined") this._contentSafeAreaInset.left = data.left;
+      if (typeof data.right !== "undefined") this._contentSafeAreaInset.right = data.right;
+      this.kernel.receiveWebViewEvent("contentSafeAreaChanged");
+    }
+    this.kernel.setCssProperty("content-safe-area-inset-top", this._contentSafeAreaInset.top + "px");
+    this.kernel.setCssProperty("content-safe-area-inset-bottom", this._contentSafeAreaInset.bottom + "px");
+    this.kernel.setCssProperty("content-safe-area-inset-left", this._contentSafeAreaInset.left + "px");
+    this.kernel.setCssProperty("content-safe-area-inset-right", this._contentSafeAreaInset.right + "px");
+  }
+  // ---------------------------------------------------------------------
+  // Closing confirmation / vertical swipes
+  // ---------------------------------------------------------------------
+  setClosingConfirmation(needConfirmation) {
+    if (!this.kernel.warnIfUnsupported("6.2", "Closing confirmation")) {
+      return;
+    }
+    this._isClosingConfirmationEnabled = !!needConfirmation;
+    this.kernel.webView.postEvent("web_app_setup_closing_behavior", void 0, {
+      need_confirmation: this._isClosingConfirmationEnabled
+    });
+  }
+  toggleVerticalSwipes(enableSwipes) {
+    if (!this.kernel.warnIfUnsupported("7.7", "Changing swipes behavior")) {
+      return;
+    }
+    this._isVerticalSwipesEnabled = !!enableSwipes;
+    this.kernel.webView.postEvent("web_app_setup_swipe_behavior", void 0, {
+      allow_vertical_swipe: this._isVerticalSwipesEnabled
+    });
+  }
+  // ---------------------------------------------------------------------
+  // Fullscreen
+  // ---------------------------------------------------------------------
+  setFullscreen(isFullscreen) {
+    this._isFullscreen = !!isFullscreen;
+    sessionStorageSet("isFullscreen", this._isFullscreen ? "yes" : "no");
+  }
+  requestFullscreen() {
+    this.kernel.requireVersion("8.0", "requestFullscreen");
+    this.kernel.webView.postEvent("web_app_request_fullscreen");
+  }
+  exitFullscreen() {
+    this.kernel.requireVersion("8.0", "exitFullscreen");
+    this.kernel.webView.postEvent("web_app_exit_fullscreen");
+  }
+  // ---------------------------------------------------------------------
+  // Orientation lock
+  // ---------------------------------------------------------------------
+  setOrientationLock(isLocked) {
+    this._isOrientationLocked = !!isLocked;
+    sessionStorageSet("isOrientationLocked", this._isOrientationLocked ? "yes" : "no");
+  }
+  toggleOrientationLock(locked) {
+    if (!this.kernel.warnIfUnsupported("8.0", "Orientation locking")) {
+      return;
+    }
+    this.setOrientationLock(locked);
+    this.kernel.webView.postEvent("web_app_toggle_orientation_lock", void 0, {
+      locked: this._isOrientationLocked
+    });
+  }
+};
+
+// src/sdk/_internal/ui/back-button.ts
+var BackButton = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this._isVisible = false;
+    this.curButtonState = null;
+    this.handleBackButtonPressed = () => {
+      this.kernel.receiveWebViewEvent("backButtonClicked");
+    };
+    kernel.webView.onEvent("back_button_pressed", this.handleBackButtonPressed);
+  }
+  get isVisible() {
+    return this._isVisible;
+  }
+  set isVisible(val) {
+    this.setParams({ is_visible: val });
+  }
+  checkVersion() {
+    return this.kernel.warnIfUnsupported("6.1", "BackButton");
+  }
+  buttonParams() {
+    return { is_visible: this._isVisible };
+  }
+  updateButton() {
+    const params = this.buttonParams();
+    const state = JSON.stringify(params);
+    if (this.curButtonState === state) {
+      return;
+    }
+    this.curButtonState = state;
+    this.kernel.webView.postEvent("web_app_setup_back_button", void 0, params);
+  }
+  setParams(params) {
+    if (!this.checkVersion()) {
+      return this;
+    }
+    if (typeof params.is_visible !== "undefined") {
+      this._isVisible = !!params.is_visible;
+    }
+    this.updateButton();
+    return this;
+  }
+  onClick(callback) {
+    if (this.checkVersion()) {
+      this.kernel.onWebViewEvent("backButtonClicked", callback);
+    }
+    return this;
+  }
+  offClick(callback) {
+    if (this.checkVersion()) {
+      this.kernel.offWebViewEvent("backButtonClicked", callback);
+    }
+    return this;
+  }
+  show() {
+    return this.setParams({ is_visible: true });
+  }
+  hide() {
+    return this.setParams({ is_visible: false });
+  }
+};
+
+// src/sdk/_internal/ui/bottom-button.ts
+var BottomButton = class {
+  constructor(type, kernel, theme, debugBar) {
+    this.kernel = kernel;
+    this.theme = theme;
+    this.debugBar = debugBar;
+    this.isVisibleValue = false;
+    this.isActiveValue = true;
+    this.hasShineEffectValue = false;
+    this.isProgressVisibleValue = false;
+    this.iconCustomEmojiIdValue = false;
+    this.colorValue = false;
+    this.textColorValue = false;
+    this.positionValue = "left";
+    this.curButtonState = null;
+    this.handlePressed = () => {
+      if (this.isActiveValue) {
+        this.kernel.receiveWebViewEvent(this.webViewEventName);
+      }
+    };
+    this.type = type;
+    this.isMain = type === "main";
+    if (this.isMain) {
+      this.setupEventName = "web_app_setup_main_button";
+      this.nativePressEventName = "main_button_pressed";
+      this.webViewEventName = "mainButtonClicked";
+      this.defaultText = "Continue";
+      this.defaultColor = () => theme.getThemeParams().button_color || "#2481cc";
+      this.defaultTextColor = () => theme.getThemeParams().button_text_color || "#ffffff";
+    } else {
+      this.setupEventName = "web_app_setup_secondary_button";
+      this.nativePressEventName = "secondary_button_pressed";
+      this.webViewEventName = "secondaryButtonClicked";
+      this.defaultText = "Cancel";
+      this.defaultColor = () => theme.getBottomBarColor();
+      this.defaultTextColor = () => theme.getThemeParams().button_color || "#2481cc";
+    }
+    this.textValue = this.defaultText;
+    kernel.webView.onEvent(this.nativePressEventName, this.handlePressed);
+    debugBar.registerButton(type, this.handlePressed);
+  }
+  // ---------------------------------------------------------------------
+  // Public property accessors (mirrors Object.defineProperty in original)
+  // ---------------------------------------------------------------------
+  get iconCustomEmojiId() {
+    return this.iconCustomEmojiIdValue;
+  }
+  set iconCustomEmojiId(val) {
+    this.setParams({ icon_custom_emoji_id: val });
+  }
+  get text() {
+    return this.textValue;
+  }
+  set text(val) {
+    this.setParams({ text: val });
+  }
+  get color() {
+    return this.colorValue || this.defaultColor();
+  }
+  set color(val) {
+    this.setParams({ color: val });
+  }
+  get textColor() {
+    return this.textColorValue || this.defaultTextColor();
+  }
+  set textColor(val) {
+    this.setParams({ text_color: val });
+  }
+  get isVisible() {
+    return this.isVisibleValue;
+  }
+  set isVisible(val) {
+    this.setParams({ is_visible: val });
+  }
+  get isProgressVisible() {
+    return this.isProgressVisibleValue;
+  }
+  get isActive() {
+    return this.isActiveValue;
+  }
+  set isActive(val) {
+    this.setParams({ is_active: val });
+  }
+  get hasShineEffect() {
+    return this.hasShineEffectValue;
+  }
+  set hasShineEffect(val) {
+    this.setParams({ has_shine_effect: val });
+  }
+  get position() {
+    return this.positionValue;
+  }
+  set position(val) {
+    if (!this.isMain) this.setParams({ position: val });
+  }
+  // ---------------------------------------------------------------------
+  // Wire protocol
+  // ---------------------------------------------------------------------
+  buttonParams() {
+    if (!this.isVisibleValue) {
+      return { is_visible: false };
+    }
+    const params = {
+      is_visible: true,
+      is_active: this.isActiveValue,
+      is_progress_visible: this.isProgressVisibleValue,
+      icon_custom_emoji_id: this.iconCustomEmojiIdValue || void 0,
+      text: this.textValue,
+      color: this.color,
+      text_color: this.textColor,
+      has_shine_effect: this.hasShineEffectValue && this.isActiveValue && !this.isProgressVisibleValue
+    };
+    if (!this.isMain) {
+      params.position = this.positionValue;
+    }
+    return params;
+  }
+  updateButton() {
+    const params = this.buttonParams();
+    const state = JSON.stringify(params);
+    if (this.curButtonState === state) {
+      return;
+    }
+    this.curButtonState = state;
+    this.kernel.webView.postEvent(this.setupEventName, void 0, params);
+    if (this.debugBar.enabled) {
+      this.debugBar.updateButtonVisual(this.type, params);
+    }
+  }
+  setParams(params) {
+    if (typeof params.icon_custom_emoji_id !== "undefined") {
+      let emojiId = params.icon_custom_emoji_id;
+      if (emojiId === false || emojiId === null) {
+        emojiId = "";
+      }
+      if (emojiId !== "" && !/^[0-9]{10,20}$/.test(emojiId)) {
+        console.error("[@core-ease/telegram-kit] Bottom button icon custom emoji is invalid", params.icon_custom_emoji_id);
+        throwWebAppError("WebAppBottomButtonParamInvalid" /* BottomButtonParamInvalid */);
+      }
+      this.iconCustomEmojiIdValue = emojiId || false;
+    }
+    if (typeof params.text !== "undefined") {
+      const text = strTrim(params.text);
+      if (!text.length && !this.iconCustomEmojiIdValue) {
+        console.error("[@core-ease/telegram-kit] Bottom button text is required", params.text);
+        throwWebAppError("WebAppBottomButtonParamInvalid" /* BottomButtonParamInvalid */);
+      }
+      if (text.length > 64) {
+        console.error("[@core-ease/telegram-kit] Bottom button text is too long", text);
+        throwWebAppError("WebAppBottomButtonParamInvalid" /* BottomButtonParamInvalid */);
+      }
+      this.textValue = text;
+    }
+    if (typeof params.color !== "undefined") {
+      if (params.color === false || params.color === null) {
+        this.colorValue = false;
+      } else {
+        const color = parseColorToHex(params.color);
+        if (!color) {
+          console.error("[@core-ease/telegram-kit] Bottom button color format is invalid", params.color);
+          throwWebAppError("WebAppBottomButtonParamInvalid" /* BottomButtonParamInvalid */);
+        }
+        this.colorValue = color;
+      }
+    }
+    if (typeof params.text_color !== "undefined") {
+      if (params.text_color === false || params.text_color === null) {
+        this.textColorValue = false;
+      } else {
+        const textColor = parseColorToHex(params.text_color);
+        if (!textColor) {
+          console.error("[@core-ease/telegram-kit] Bottom button text color format is invalid", params.text_color);
+          throwWebAppError("WebAppBottomButtonParamInvalid" /* BottomButtonParamInvalid */);
+        }
+        this.textColorValue = textColor;
+      }
+    }
+    if (typeof params.is_visible !== "undefined") {
+      if (params.is_visible && !this.textValue.length) {
+        console.error("[@core-ease/telegram-kit] Bottom button text is required");
+        throwWebAppError("WebAppBottomButtonParamInvalid" /* BottomButtonParamInvalid */);
+      }
+      this.isVisibleValue = !!params.is_visible;
+    }
+    if (typeof params.has_shine_effect !== "undefined") {
+      this.hasShineEffectValue = !!params.has_shine_effect;
+    }
+    if (!this.isMain && typeof params.position !== "undefined") {
+      if (params.position != "left" && params.position != "right" && params.position != "top" && params.position != "bottom") {
+        console.error("[@core-ease/telegram-kit] Bottom button posiition is invalid", params.position);
+        throwWebAppError("WebAppBottomButtonParamInvalid" /* BottomButtonParamInvalid */);
+      }
+      this.positionValue = params.position;
+    }
+    if (typeof params.is_active !== "undefined") {
+      this.isActiveValue = !!params.is_active;
+    }
+    this.updateButton();
+    return this;
+  }
+  setText(text) {
+    return this.setParams({ text });
+  }
+  onClick(callback) {
+    this.kernel.onWebViewEvent(this.webViewEventName, callback);
+    return this;
+  }
+  offClick(callback) {
+    this.kernel.offWebViewEvent(this.webViewEventName, callback);
+    return this;
+  }
+  show() {
+    return this.setParams({ is_visible: true });
+  }
+  hide() {
+    return this.setParams({ is_visible: false });
+  }
+  enable() {
+    return this.setParams({ is_active: true });
+  }
+  disable() {
+    return this.setParams({ is_active: false });
+  }
+  showProgress(leaveActive) {
+    this.isActiveValue = !!leaveActive;
+    this.isProgressVisibleValue = true;
+    this.updateButton();
+    return this;
+  }
+  hideProgress() {
+    if (!this.isActiveValue) {
+      this.isActiveValue = true;
+    }
+    this.isProgressVisibleValue = false;
+    this.updateButton();
+    return this;
+  }
+};
+
+// src/sdk/_internal/ui/settings-button.ts
+var SettingsButton = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this._isVisible = false;
+    this.curButtonState = null;
+    this.handleSettingsButtonPressed = () => {
+      this.kernel.receiveWebViewEvent("settingsButtonClicked");
+    };
+    kernel.webView.onEvent("settings_button_pressed", this.handleSettingsButtonPressed);
+  }
+  get isVisible() {
+    return this._isVisible;
+  }
+  set isVisible(val) {
+    this.setParams({ is_visible: val });
+  }
+  checkVersion() {
+    return this.kernel.warnIfUnsupported("6.10", "SettingsButton");
+  }
+  buttonParams() {
+    return { is_visible: this._isVisible };
+  }
+  updateButton() {
+    const params = this.buttonParams();
+    const state = JSON.stringify(params);
+    if (this.curButtonState === state) {
+      return;
+    }
+    this.curButtonState = state;
+    this.kernel.webView.postEvent("web_app_setup_settings_button", void 0, params);
+  }
+  setParams(params) {
+    if (!this.checkVersion()) {
+      return this;
+    }
+    if (typeof params.is_visible !== "undefined") {
+      this._isVisible = !!params.is_visible;
+    }
+    this.updateButton();
+    return this;
+  }
+  onClick(callback) {
+    if (this.checkVersion()) {
+      this.kernel.onWebViewEvent("settingsButtonClicked", callback);
+    }
+    return this;
+  }
+  offClick(callback) {
+    if (this.checkVersion()) {
+      this.kernel.offWebViewEvent("settingsButtonClicked", callback);
+    }
+    return this;
+  }
+  show() {
+    return this.setParams({ is_visible: true });
+  }
+  hide() {
+    return this.setParams({ is_visible: false });
+  }
+};
+
+// src/sdk/_internal/ui/debug-bottom-bar.ts
+var SPINNER_SVG = '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewport="0 0 48 48" width="48px" height="48px"><circle cx="50%" cy="50%" stroke="{COLOR}" stroke-width="2.25" stroke-linecap="round" fill="none" stroke-dashoffset="106" r="9" stroke-dasharray="56.52" rotate="-90"><animate attributeName="stroke-dashoffset" attributeType="XML" dur="360s" from="0" to="12500" repeatCount="indefinite"></animate><animateTransform attributeName="transform" attributeType="XML" type="rotate" dur="1s" from="-90 24 24" to="630 24 24" repeatCount="indefinite"></animateTransform></circle></svg>';
+var DebugBottomBar = class {
+  constructor(kernel, getBottomBarColor) {
+    this.kernel = kernel;
+    this.getBottomBarColor = getBottomBarColor;
+    this.container = null;
+    this.buttons = {};
+    /** Invoked whenever the reserved bottom-bar height changes. */
+    this.onHeightChanged = null;
+    this.enabled = !!kernel.initParams.tgWebAppDebug;
+    if (!this.enabled) return;
+    this.container = document.createElement("tg-bottom-bar");
+    const style = {
+      display: "flex",
+      gap: "7px",
+      font: "600 14px/18px sans-serif",
+      width: "100%",
+      background: getBottomBarColor(),
+      position: "fixed",
+      left: "0",
+      right: "0",
+      bottom: "0",
+      margin: "0",
+      padding: "7px",
+      textAlign: "center",
+      boxSizing: "border-box",
+      zIndex: "10000"
+    };
+    Object.assign(this.container.style, style);
+    document.addEventListener("DOMContentLoaded", function onDomLoaded() {
+      document.removeEventListener("DOMContentLoaded", onDomLoaded);
+      document.body.appendChild(this_container());
+    });
+    const this_container = () => this.container;
+    const animStyle = document.createElement("style");
+    animStyle.innerHTML = 'tg-bottom-button.shine { position: relative; overflow: hidden; } tg-bottom-button.shine:before { content:""; position: absolute; top: 0; width: 100%; height: 100%; background: linear-gradient(120deg, transparent, rgba(255, 255, 255, .2), transparent); animation: tg-bottom-button-shine 5s ease-in-out infinite; } @-webkit-keyframes tg-bottom-button-shine { 0% {left: -100%;} 12%,100% {left: 100%}} @keyframes tg-bottom-button-shine { 0% {left: -100%;} 12%,100% {left: 100%}}';
+    this.container.appendChild(animStyle);
+  }
+  /** Creates & registers a debug clone of a Main/Secondary button; returns its element. */
+  registerButton(type, onPressed) {
+    if (!this.enabled || !this.container) return null;
+    const el = document.createElement("tg-bottom-button");
+    const style = {
+      display: "none",
+      width: "100%",
+      height: "44px",
+      borderRadius: "0",
+      background: "no-repeat right center",
+      padding: "13px 15px",
+      textAlign: "center",
+      boxSizing: "border-box"
+    };
+    Object.assign(el.style, style);
+    this.container.appendChild(el);
+    el.addEventListener("click", onPressed, false);
+    this.buttons[type] = { el, isVisible: false, position: "left" };
+    return el;
+  }
+  /** Applies visual state coming from `BottomButton.buttonParams()`. */
+  updateButtonVisual(type, params) {
+    const entry = this.buttons[type];
+    if (!entry) return;
+    const el = entry.el;
+    entry.isVisible = !!params.is_visible;
+    entry.position = params.position || "left";
+    if (params.is_visible) {
+      el.style.display = "block";
+      el.style.opacity = params.is_active ? "1" : "0.8";
+      el.style.cursor = params.is_active ? "pointer" : "auto";
+      el.disabled = !params.is_active;
+      el.innerText = params.text || "";
+      el.className = params.has_shine_effect ? "shine" : "";
+      el.style.backgroundImage = params.is_progress_visible ? `url('data:image/svg+xml,${encodeURIComponent(
+        SPINNER_SVG.replace("{COLOR}", params.text_color || "#ffffff")
+      )}')` : "none";
+      el.style.backgroundColor = params.color || "";
+      el.style.color = params.text_color || "";
+    } else {
+      el.style.display = "none";
+    }
+    this.updateBar();
+  }
+  updateBar() {
+    var _a;
+    if (!this.enabled || !this.container) return;
+    const main = this.buttons.main;
+    const secondary = this.buttons.secondary;
+    let height = 0;
+    if (main && main.isVisible || secondary && secondary.isVisible) {
+      this.container.style.display = "flex";
+      height = 58;
+      if ((main == null ? void 0 : main.isVisible) && (secondary == null ? void 0 : secondary.isVisible)) {
+        if (secondary.position == "top") {
+          this.container.style.flexDirection = "column-reverse";
+          height += 51;
+        } else if (secondary.position == "bottom") {
+          this.container.style.flexDirection = "column";
+          height += 51;
+        } else if (secondary.position == "left") {
+          this.container.style.flexDirection = "row-reverse";
+        } else if (secondary.position == "right") {
+          this.container.style.flexDirection = "row";
+        }
+      }
+    } else {
+      this.container.style.display = "none";
+      height = 0;
+    }
+    this.kernel.bottomBarHeightPx = height;
+    this.container.style.background = this.getBottomBarColor();
+    if (document.documentElement) {
+      document.documentElement.style.boxSizing = "border-box";
+      document.documentElement.style.paddingBottom = height + "px";
+    }
+    (_a = this.onHeightChanged) == null ? void 0 : _a.call(this);
+  }
+  /** Called after the bottom-bar color changes so the debug bar repaints too. */
+  refreshColor() {
+    if (!this.enabled || !this.container) return;
+    this.updateBar();
+  }
+};
+
+// src/sdk/_internal/ui/popup.ts
+var PopupManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.pending = false;
+    this.handlePopupClosed = (_eventType, eventData) => {
+      var _a;
+      if (this.pending) {
+        const popupData = this.pending;
+        this.pending = false;
+        const buttonId = typeof eventData.button_id !== "undefined" ? eventData.button_id : null;
+        (_a = popupData.callback) == null ? void 0 : _a.call(popupData, buttonId);
+        this.kernel.receiveWebViewEvent("popupClosed", { button_id: buttonId });
+      }
+    };
+    kernel.webView.onEvent("popup_closed", this.handlePopupClosed);
+  }
+  showPopup(params, callback) {
+    this.kernel.requireVersion("6.2", "showPopup");
+    if (this.pending) {
+      console.error("[@core-ease/telegram-kit] Popup is already opened");
+      throwWebAppError("WebAppPopupOpened" /* PopupOpened */);
+    }
+    const popupParams = { message: "" };
+    if (typeof params.title !== "undefined") {
+      const title = strTrim(params.title);
+      if (title.length > 64) {
+        console.error("[@core-ease/telegram-kit] Popup title is too long", title);
+        throwWebAppError("WebAppPopupParamInvalid" /* PopupParamInvalid */);
+      }
+      if (title.length > 0) {
+        popupParams.title = title;
+      }
+    }
+    let message = "";
+    if (typeof params.message !== "undefined") {
+      message = strTrim(params.message);
+    }
+    if (!message.length) {
+      console.error("[@core-ease/telegram-kit] Popup message is required", params.message);
+      throwWebAppError("WebAppPopupParamInvalid" /* PopupParamInvalid */);
+    }
+    if (message.length > 256) {
+      console.error("[@core-ease/telegram-kit] Popup message is too long", message);
+      throwWebAppError("WebAppPopupParamInvalid" /* PopupParamInvalid */);
+    }
+    popupParams.message = message;
+    const buttons = [];
+    if (typeof params.buttons !== "undefined") {
+      if (!Array.isArray(params.buttons)) {
+        console.error("[@core-ease/telegram-kit] Popup buttons should be an array", params.buttons);
+        throwWebAppError("WebAppPopupParamInvalid" /* PopupParamInvalid */);
+      }
+      for (const button of params.buttons) {
+        const btn = {};
+        let id = "";
+        if (typeof button.id !== "undefined") {
+          id = String(button.id);
+          if (id.length > 64) {
+            console.error("[@core-ease/telegram-kit] Popup button id is too long", id);
+            throwWebAppError("WebAppPopupParamInvalid" /* PopupParamInvalid */);
+          }
+        }
+        btn.id = id;
+        const buttonType = button.type || "default";
+        btn.type = buttonType;
+        if (buttonType == "ok" || buttonType == "close" || buttonType == "cancel") ; else if (buttonType == "default" || buttonType == "destructive") {
+          let text = "";
+          if (typeof button.text !== "undefined") {
+            text = strTrim(button.text);
+          }
+          if (!text.length) {
+            console.error(`[@core-ease/telegram-kit] Popup button text is required for type ${buttonType}`, button.text);
+            throwWebAppError("WebAppPopupParamInvalid" /* PopupParamInvalid */);
+          }
+          if (text.length > 64) {
+            console.error("[@core-ease/telegram-kit] Popup button text is too long", text);
+            throwWebAppError("WebAppPopupParamInvalid" /* PopupParamInvalid */);
+          }
+          btn.text = text;
+        } else {
+          console.error("[@core-ease/telegram-kit] Popup button type is invalid", buttonType);
+          throwWebAppError("WebAppPopupParamInvalid" /* PopupParamInvalid */);
+        }
+        buttons.push(btn);
+      }
+    } else {
+      buttons.push({ id: "", type: "close" });
+    }
+    if (buttons.length < 1) {
+      console.error("[@core-ease/telegram-kit] Popup should have at least one button");
+      throwWebAppError("WebAppPopupParamInvalid" /* PopupParamInvalid */);
+    }
+    if (buttons.length > 3) {
+      console.error("[@core-ease/telegram-kit] Popup should not have more than 3 buttons");
+      throwWebAppError("WebAppPopupParamInvalid" /* PopupParamInvalid */);
+    }
+    popupParams.buttons = buttons;
+    this.pending = { callback };
+    this.kernel.webView.postEvent("web_app_open_popup", void 0, popupParams);
+  }
+  showAlert(message, callback) {
+    this.showPopup({ message }, callback ? () => callback() : void 0);
+  }
+  showConfirm(message, callback) {
+    this.showPopup(
+      {
+        message,
+        buttons: [
+          { type: "ok", id: "ok" },
+          { type: "cancel" }
+        ]
+      },
+      callback ? (buttonId) => callback(buttonId == "ok") : void 0
+    );
+  }
+};
+
+// src/sdk/_internal/ui/scan-qr.ts
+var ScanQrManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.pending = false;
+    this.handleQrTextReceived = (_eventType, eventData) => {
+      if (this.pending) {
+        const popupData = this.pending;
+        const data = typeof eventData.data !== "undefined" ? eventData.data : null;
+        if (popupData.callback) {
+          if (popupData.callback(data)) {
+            this.pending = false;
+            this.kernel.webView.postEvent("web_app_close_scan_qr_popup", void 0);
+          }
+        }
+        this.kernel.receiveWebViewEvent("qrTextReceived", { data });
+      }
+    };
+    this.handleScanQrPopupClosed = () => {
+      this.pending = false;
+      this.kernel.receiveWebViewEvent("scanQrPopupClosed");
+    };
+    kernel.webView.onEvent("qr_text_received", this.handleQrTextReceived);
+    kernel.webView.onEvent("scan_qr_popup_closed", this.handleScanQrPopupClosed);
+  }
+  showScanQrPopup(params, callback) {
+    this.kernel.requireVersion("6.4", "showScanQrPopup");
+    if (this.pending) {
+      console.error("[@core-ease/telegram-kit] Popup is already opened");
+      throwWebAppError("WebAppScanQrPopupOpened" /* ScanQrPopupOpened */);
+    }
+    const popupParams = {};
+    if (typeof params.text !== "undefined") {
+      const text = strTrim(params.text);
+      if (text.length > 64) {
+        console.error("[@core-ease/telegram-kit] Scan QR popup text is too long", text);
+        throwWebAppError("WebAppScanQrPopupParamInvalid" /* ScanQrPopupParamInvalid */);
+      }
+      if (text.length > 0) {
+        popupParams.text = text;
+      }
+    }
+    this.pending = { callback };
+    this.kernel.webView.postEvent("web_app_open_scan_qr_popup", void 0, popupParams);
+  }
+  closeScanQrPopup() {
+    this.kernel.requireVersion("6.4", "closeScanQrPopup");
+    this.pending = false;
+    this.kernel.webView.postEvent("web_app_close_scan_qr_popup", void 0);
+  }
+};
+
+// src/sdk/_internal/features/haptic-feedback.ts
+var HapticFeedback = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+  }
+  trigger(params) {
+    if (!this.kernel.warnIfUnsupported("6.1", "HapticFeedback")) {
+      return this;
+    }
+    if (params.type == "impact") {
+      if (params.impact_style != "light" && params.impact_style != "medium" && params.impact_style != "heavy" && params.impact_style != "rigid" && params.impact_style != "soft") {
+        console.error("[@core-ease/telegram-kit] Haptic impact style is invalid", params.impact_style);
+        throwWebAppError("WebAppHapticImpactStyleInvalid" /* HapticImpactStyleInvalid */);
+      }
+    } else if (params.type == "notification") {
+      if (params.notification_type != "error" && params.notification_type != "success" && params.notification_type != "warning") {
+        console.error("[@core-ease/telegram-kit] Haptic notification type is invalid", params.notification_type);
+        throwWebAppError("WebAppHapticNotificationTypeInvalid" /* HapticNotificationTypeInvalid */);
+      }
+    } else if (params.type == "selection_change") ; else {
+      console.error("[@core-ease/telegram-kit] Haptic feedback type is invalid", params.type);
+      throwWebAppError("WebAppHapticFeedbackTypeInvalid" /* HapticFeedbackTypeInvalid */);
+    }
+    this.kernel.webView.postEvent("web_app_trigger_haptic_feedback", void 0, params);
+    return this;
+  }
+  impactOccurred(style) {
+    return this.trigger({ type: "impact", impact_style: style });
+  }
+  notificationOccurred(type) {
+    return this.trigger({ type: "notification", notification_type: type });
+  }
+  selectionChanged() {
+    return this.trigger({ type: "selection_change" });
+  }
+};
+
+// src/sdk/_internal/features/cloud-storage.ts
+var CloudStorage = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+  }
+  invoke(method, params, callback) {
+    this.kernel.requireVersion("6.9", "CloudStorage");
+    this.kernel.invokeCustomMethod(method, params, callback);
+    return this;
+  }
+  setItem(key, value, callback) {
+    return this.invoke("saveStorageValue", { key, value }, callback);
+  }
+  getItem(key, callback) {
+    return this.getItems(
+      [key],
+      callback ? (err, res) => err ? callback(err) : callback(null, res == null ? void 0 : res[key]) : void 0
+    );
+  }
+  getItems(keys, callback) {
+    return this.invoke("getStorageValues", { keys }, callback);
+  }
+  removeItem(key, callback) {
+    return this.removeItems([key], callback);
+  }
+  removeItems(keys, callback) {
+    return this.invoke("deleteStorageValues", { keys }, callback);
+  }
+  getKeys(callback) {
+    return this.invoke("getStorageKeys", {}, callback);
+  }
+};
+
+// src/sdk/_internal/features/device-storage.ts
+var DeviceStorage = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.handleEvent = (eventType, eventData) => {
+      var _a;
+      if (!eventData.req_id || !this.kernel.hasCallback(eventData.req_id)) return;
+      const entry = this.kernel.takeCallback(eventData.req_id);
+      let res = null;
+      let err = null;
+      if (eventType == "device_storage_failed") {
+        err = eventData.error || "UNKNOWN_ERROR";
+      } else if (eventType == "device_storage_key_received") {
+        res = eventData.value;
+      } else {
+        res = true;
+      }
+      (_a = entry == null ? void 0 : entry.callback) == null ? void 0 : _a.call(entry, err, res);
+    };
+    kernel.webView.onEvent("device_storage_key_saved", this.handleEvent);
+    kernel.webView.onEvent("device_storage_key_received", this.handleEvent);
+    kernel.webView.onEvent("device_storage_cleared", this.handleEvent);
+    kernel.webView.onEvent("device_storage_failed", this.handleEvent);
+  }
+  invoke(method, params, callback) {
+    this.kernel.requireVersion("9.0", "DeviceStorage");
+    const reqId = this.kernel.registerCallback(callback);
+    this.kernel.webView.postEvent(method, void 0, __spreadValues({ req_id: reqId }, params));
+    return this;
+  }
+  setItem(key, value, callback) {
+    return this.invoke("web_app_device_storage_save_key", { key, value }, callback);
+  }
+  getItem(key, callback) {
+    return this.invoke("web_app_device_storage_get_key", { key }, callback);
+  }
+  removeItem(key, callback) {
+    return this.invoke("web_app_device_storage_save_key", { key, value: null }, callback);
+  }
+  clear(callback) {
+    return this.invoke("web_app_device_storage_clear", {}, callback);
+  }
+};
+
+// src/sdk/_internal/features/secure-storage.ts
+var SecureStorage = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.handleEvent = (eventType, eventData) => {
+      var _a;
+      if (!eventData.req_id || !this.kernel.hasCallback(eventData.req_id)) return;
+      const entry = this.kernel.takeCallback(eventData.req_id);
+      let res = null;
+      let err = null;
+      let canRestore = null;
+      if (eventType == "secure_storage_failed") {
+        err = eventData.error || "UNKNOWN_ERROR";
+      } else if (eventType == "secure_storage_key_received") {
+        res = eventData.value;
+        if (eventData.can_restore) {
+          canRestore = true;
+        }
+      } else if (eventType == "secure_storage_key_restored") {
+        res = eventData.value;
+      } else {
+        res = true;
+      }
+      (_a = entry == null ? void 0 : entry.callback) == null ? void 0 : _a.call(entry, err, res, canRestore);
+    };
+    kernel.webView.onEvent("secure_storage_key_saved", this.handleEvent);
+    kernel.webView.onEvent("secure_storage_key_received", this.handleEvent);
+    kernel.webView.onEvent("secure_storage_key_restored", this.handleEvent);
+    kernel.webView.onEvent("secure_storage_cleared", this.handleEvent);
+    kernel.webView.onEvent("secure_storage_failed", this.handleEvent);
+  }
+  invoke(method, params, callback) {
+    this.kernel.requireVersion("9.0", "SecureStorage");
+    const reqId = this.kernel.registerCallback(callback);
+    this.kernel.webView.postEvent(method, void 0, __spreadValues({ req_id: reqId }, params));
+    return this;
+  }
+  setItem(key, value, callback) {
+    return this.invoke("web_app_secure_storage_save_key", { key, value }, callback);
+  }
+  getItem(key, callback) {
+    return this.invoke("web_app_secure_storage_get_key", { key }, callback);
+  }
+  restoreItem(key, callback) {
+    return this.invoke("web_app_secure_storage_restore_key", { key }, callback);
+  }
+  removeItem(key, callback) {
+    return this.invoke("web_app_secure_storage_save_key", { key, value: null }, callback);
+  }
+  clear(callback) {
+    return this.invoke("web_app_secure_storage_clear", {}, callback);
+  }
+};
+
+// src/sdk/_internal/features/biometric-manager.ts
+var BiometricManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this._isInited = false;
+    this._isBiometricAvailable = false;
+    this._biometricType = "unknown";
+    this._isAccessRequested = false;
+    this._isAccessGranted = false;
+    this._isBiometricTokenSaved = false;
+    this._deviceId = "";
+    this.initCallbacks = [];
+    this.accessRequestState = false;
+    this.authRequestState = false;
+    this.tokenRequestState = false;
+    this.handleInfoReceived = (_eventType, eventData) => {
+      var _a;
+      this._isInited = true;
+      if (eventData.available) {
+        this._isBiometricAvailable = true;
+        this._biometricType = eventData.type || "unknown";
+        if (eventData.access_requested) {
+          this._isAccessRequested = true;
+          this._isAccessGranted = !!eventData.access_granted;
+          this._isBiometricTokenSaved = !!eventData.token_saved;
+        } else {
+          this._isAccessRequested = false;
+          this._isAccessGranted = false;
+          this._isBiometricTokenSaved = false;
+        }
+      } else {
+        this._isBiometricAvailable = false;
+        this._biometricType = "unknown";
+        this._isAccessRequested = false;
+        this._isAccessGranted = false;
+        this._isBiometricTokenSaved = false;
+      }
+      this._deviceId = eventData.device_id || "";
+      if (this.initCallbacks.length > 0) {
+        this.initCallbacks.forEach((cb) => cb());
+        this.initCallbacks = [];
+      }
+      if (this.accessRequestState) {
+        const state = this.accessRequestState;
+        this.accessRequestState = false;
+        (_a = state.callback) == null ? void 0 : _a.call(state, this._isAccessGranted);
+      }
+      this.kernel.receiveWebViewEvent("biometricManagerUpdated");
+    };
+    this.handleAuthRequested = (_eventType, eventData) => {
+      var _a;
+      const isAuthenticated = eventData.status == "authorized";
+      const biometricToken = eventData.token || "";
+      if (this.authRequestState) {
+        const state = this.authRequestState;
+        this.authRequestState = false;
+        (_a = state.callback) == null ? void 0 : _a.call(state, isAuthenticated, isAuthenticated ? biometricToken : null);
+      }
+      this.kernel.receiveWebViewEvent(
+        "biometricAuthRequested",
+        isAuthenticated ? { isAuthenticated: true, biometricToken } : { isAuthenticated: false }
+      );
+    };
+    this.handleTokenUpdated = (_eventType, eventData) => {
+      var _a;
+      let applied = false;
+      if (this._isBiometricAvailable && this._isAccessRequested) {
+        if (eventData.status == "updated") {
+          this._isBiometricTokenSaved = true;
+          applied = true;
+        } else if (eventData.status == "removed") {
+          this._isBiometricTokenSaved = false;
+          applied = true;
+        }
+      }
+      if (this.tokenRequestState) {
+        const state = this.tokenRequestState;
+        this.tokenRequestState = false;
+        (_a = state.callback) == null ? void 0 : _a.call(state, applied);
+      }
+      this.kernel.receiveWebViewEvent("biometricTokenUpdated", { isUpdated: applied });
+    };
+    kernel.webView.onEvent("biometry_info_received", this.handleInfoReceived);
+    kernel.webView.onEvent("biometry_auth_requested", this.handleAuthRequested);
+    kernel.webView.onEvent("biometry_token_updated", this.handleTokenUpdated);
+  }
+  get isInited() {
+    return this._isInited;
+  }
+  get isBiometricAvailable() {
+    return this._isInited && this._isBiometricAvailable;
+  }
+  get biometricType() {
+    return this._biometricType || "unknown";
+  }
+  get isAccessRequested() {
+    return this._isAccessRequested;
+  }
+  get isAccessGranted() {
+    return this._isAccessRequested && this._isAccessGranted;
+  }
+  get isBiometricTokenSaved() {
+    return this._isBiometricTokenSaved;
+  }
+  get deviceId() {
+    return this._deviceId || "";
+  }
+  checkVersion() {
+    return this.kernel.warnIfUnsupported("7.2", "BiometricManager");
+  }
+  checkInit() {
+    if (!this._isInited) {
+      console.error("[@core-ease/telegram-kit] BiometricManager should be inited before using.");
+      throwWebAppError("WebAppBiometricManagerNotInited" /* BiometricManagerNotInited */);
+    }
+    return true;
+  }
+  init(callback) {
+    if (!this.checkVersion()) return this;
+    if (this._isInited) return this;
+    if (callback) this.initCallbacks.push(callback);
+    this.kernel.webView.postEvent("web_app_biometry_get_info");
+    return this;
+  }
+  requestAccess(params, callback) {
+    if (!this.checkVersion()) return this;
+    this.checkInit();
+    if (!this._isBiometricAvailable) {
+      console.error("[@core-ease/telegram-kit] Biometrics is not available on this device.");
+      throwWebAppError("WebAppBiometricManagerBiometricsNotAvailable" /* BiometricManagerBiometricsNotAvailable */);
+    }
+    if (this.accessRequestState) {
+      console.error("[@core-ease/telegram-kit] Access is already requested");
+      throwWebAppError("WebAppBiometricManagerAccessRequested" /* BiometricManagerAccessRequested */);
+    }
+    const popupParams = {};
+    if (typeof params.reason !== "undefined") {
+      const reason = strTrim(params.reason);
+      if (reason.length > 128) {
+        console.error("[@core-ease/telegram-kit] Biometric reason is too long", reason);
+        throwWebAppError("WebAppBiometricRequestAccessParamInvalid" /* BiometricRequestAccessParamInvalid */);
+      }
+      if (reason.length > 0) popupParams.reason = reason;
+    }
+    this.accessRequestState = { callback };
+    this.kernel.webView.postEvent("web_app_biometry_request_access", void 0, popupParams);
+    return this;
+  }
+  authenticate(params, callback) {
+    if (!this.checkVersion()) return this;
+    this.checkInit();
+    if (!this._isBiometricAvailable) {
+      console.error("[@core-ease/telegram-kit] Biometrics is not available on this device.");
+      throwWebAppError("WebAppBiometricManagerBiometricsNotAvailable" /* BiometricManagerBiometricsNotAvailable */);
+    }
+    if (!this.isAccessGranted) {
+      console.error("[@core-ease/telegram-kit] Biometric access was not granted by the user.");
+      throwWebAppError("WebAppBiometricManagerBiometricAccessNotGranted" /* BiometricManagerBiometricAccessNotGranted */);
+    }
+    if (this.authRequestState) {
+      console.error("[@core-ease/telegram-kit] Authentication request is already in progress.");
+      throwWebAppError("WebAppBiometricManagerAuthenticationRequested" /* BiometricManagerAuthenticationRequested */);
+    }
+    const popupParams = {};
+    if (typeof params.reason !== "undefined") {
+      const reason = strTrim(params.reason);
+      if (reason.length > 128) {
+        console.error("[@core-ease/telegram-kit] Biometric reason is too long", reason);
+        throwWebAppError("WebAppBiometricRequestAccessParamInvalid" /* BiometricRequestAccessParamInvalid */);
+      }
+      if (reason.length > 0) popupParams.reason = reason;
+    }
+    this.authRequestState = { callback };
+    this.kernel.webView.postEvent("web_app_biometry_request_auth", void 0, popupParams);
+    return this;
+  }
+  updateBiometricToken(token, callback) {
+    if (!this.checkVersion()) return this;
+    token = token || "";
+    if (token.length > 1024) {
+      console.error("[@core-ease/telegram-kit] Token is too long", token);
+      throwWebAppError("WebAppBiometricManagerTokenInvalid" /* BiometricManagerTokenInvalid */);
+    }
+    this.checkInit();
+    if (!this._isBiometricAvailable) {
+      console.error("[@core-ease/telegram-kit] Biometrics is not available on this device.");
+      throwWebAppError("WebAppBiometricManagerBiometricsNotAvailable" /* BiometricManagerBiometricsNotAvailable */);
+    }
+    if (!this.isAccessGranted) {
+      console.error("[@core-ease/telegram-kit] Biometric access was not granted by the user.");
+      throwWebAppError("WebAppBiometricManagerBiometricAccessNotGranted" /* BiometricManagerBiometricAccessNotGranted */);
+    }
+    if (this.tokenRequestState) {
+      console.error("[@core-ease/telegram-kit] Token request is already in progress.");
+      throwWebAppError("WebAppBiometricManagerTokenUpdateRequested" /* BiometricManagerTokenUpdateRequested */);
+    }
+    this.tokenRequestState = { callback };
+    this.kernel.webView.postEvent("web_app_biometry_update_token", void 0, { token });
+    return this;
+  }
+  openSettings() {
+    if (!this.checkVersion()) return this;
+    this.checkInit();
+    if (!this._isBiometricAvailable) {
+      console.error("[@core-ease/telegram-kit] Biometrics is not available on this device.");
+      throwWebAppError("WebAppBiometricManagerBiometricsNotAvailable" /* BiometricManagerBiometricsNotAvailable */);
+    }
+    if (!this._isAccessRequested) {
+      console.error("[@core-ease/telegram-kit] Biometric access was not requested yet.");
+      throwWebAppError("WebAppBiometricManagerBiometricsAccessNotRequested" /* BiometricManagerBiometricsAccessNotRequested */);
+    }
+    if (this._isAccessGranted) {
+      console.warn("[@core-ease/telegram-kit] Biometric access was granted by the user, no need to go to settings.");
+      return this;
+    }
+    this.kernel.webView.postEvent("web_app_biometry_open_settings");
+    return this;
+  }
+};
+
+// src/sdk/_internal/features/location-manager.ts
+var LocationManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this._isInited = false;
+    this._isLocationAvailable = false;
+    this._isAccessRequested = false;
+    this._isAccessGranted = false;
+    this.initCallbacks = [];
+    this.getRequestCallbacks = [];
+    this.handleLocationChecked = (_eventType, eventData) => {
+      this._isInited = true;
+      if (eventData.available) {
+        this._isLocationAvailable = true;
+        if (eventData.access_requested) {
+          this._isAccessRequested = true;
+          this._isAccessGranted = !!eventData.access_granted;
+        } else {
+          this._isAccessRequested = false;
+          this._isAccessGranted = false;
+        }
+      } else {
+        this._isLocationAvailable = false;
+        this._isAccessRequested = false;
+        this._isAccessGranted = false;
+      }
+      if (this.initCallbacks.length > 0) {
+        this.initCallbacks.forEach((cb) => cb());
+        this.initCallbacks = [];
+      }
+      this.kernel.receiveWebViewEvent("locationManagerUpdated");
+    };
+    this.handleLocationRequested = (_eventType, eventData) => {
+      let locationData = null;
+      if (eventData.available) {
+        locationData = {
+          latitude: eventData.latitude,
+          longitude: eventData.longitude,
+          altitude: null,
+          course: null,
+          speed: null,
+          horizontal_accuracy: null,
+          vertical_accuracy: null,
+          course_accuracy: null,
+          speed_accuracy: null
+        };
+        if (typeof eventData.altitude !== "undefined" && eventData.altitude !== null) {
+          locationData.altitude = eventData.altitude;
+        }
+        if (typeof eventData.course !== "undefined" && eventData.course !== null) {
+          locationData.course = eventData.course % 360;
+        }
+        if (typeof eventData.speed !== "undefined" && eventData.speed !== null) {
+          locationData.speed = eventData.speed;
+        }
+        if (typeof eventData.horizontal_accuracy !== "undefined" && eventData.horizontal_accuracy !== null) {
+          locationData.horizontal_accuracy = eventData.horizontal_accuracy;
+        }
+        if (typeof eventData.vertical_accuracy !== "undefined" && eventData.vertical_accuracy !== null) {
+          locationData.vertical_accuracy = eventData.vertical_accuracy;
+        }
+        if (typeof eventData.course_accuracy !== "undefined" && eventData.course_accuracy !== null) {
+          locationData.course_accuracy = eventData.course_accuracy;
+        }
+        if (typeof eventData.speed_accuracy !== "undefined" && eventData.speed_accuracy !== null) {
+          locationData.speed_accuracy = eventData.speed_accuracy;
+        }
+      }
+      if (!eventData.available || !this._isLocationAvailable || !this._isAccessRequested || !this._isAccessGranted) {
+        this.initCallbacks.push(() => this.locationResponse(locationData));
+        this.kernel.webView.postEvent("web_app_check_location");
+      } else {
+        this.locationResponse(locationData);
+      }
+    };
+    kernel.webView.onEvent("location_checked", this.handleLocationChecked);
+    kernel.webView.onEvent("location_requested", this.handleLocationRequested);
+  }
+  get isInited() {
+    return this._isInited;
+  }
+  get isLocationAvailable() {
+    return this._isInited && this._isLocationAvailable;
+  }
+  get isAccessRequested() {
+    return this._isAccessRequested;
+  }
+  get isAccessGranted() {
+    return this._isAccessRequested && this._isAccessGranted;
+  }
+  locationResponse(response) {
+    if (this.getRequestCallbacks.length > 0) {
+      this.getRequestCallbacks.forEach((cb) => cb(response));
+      this.getRequestCallbacks = [];
+    }
+    if (response !== null) {
+      this.kernel.receiveWebViewEvent("locationRequested", { locationData: response });
+    }
+  }
+  checkVersion() {
+    return this.kernel.warnIfUnsupported("8.0", "LocationManager");
+  }
+  checkInit() {
+    if (!this._isInited) {
+      console.error("[@core-ease/telegram-kit] LocationManager should be inited before using.");
+      throwWebAppError("WebAppLocationManagerNotInited" /* LocationManagerNotInited */);
+    }
+    return true;
+  }
+  init(callback) {
+    if (!this.checkVersion()) return this;
+    if (this._isInited) return this;
+    if (callback) this.initCallbacks.push(callback);
+    this.kernel.webView.postEvent("web_app_check_location");
+    return this;
+  }
+  getLocation(callback) {
+    if (!this.checkVersion()) return this;
+    this.checkInit();
+    if (!this._isLocationAvailable) {
+      console.error("[@core-ease/telegram-kit] Location is not available on this device.");
+      throwWebAppError("WebAppLocationManagerLocationNotAvailable" /* LocationManagerLocationNotAvailable */);
+    }
+    this.getRequestCallbacks.push(callback);
+    this.kernel.webView.postEvent("web_app_request_location");
+    return this;
+  }
+  openSettings() {
+    if (!this.checkVersion()) return this;
+    this.checkInit();
+    if (!this._isLocationAvailable) {
+      console.error("[@core-ease/telegram-kit] Location is not available on this device.");
+      throwWebAppError("WebAppLocationManagerLocationNotAvailable" /* LocationManagerLocationNotAvailable */);
+    }
+    if (!this._isAccessRequested) {
+      console.error("[@core-ease/telegram-kit] Location access was not requested yet.");
+      throwWebAppError("WebAppLocationManagerLocationAccessNotRequested" /* LocationManagerLocationAccessNotRequested */);
+    }
+    if (this._isAccessGranted) {
+      console.warn("[@core-ease/telegram-kit] Location access was granted by the user, no need to go to settings.");
+      return this;
+    }
+    this.kernel.webView.postEvent("web_app_open_location_settings");
+    return this;
+  }
+};
+
+// src/sdk/_internal/features/invoice.ts
+var InvoiceManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.openInvoices = {};
+    this.handleInvoiceClosed = (_eventType, eventData) => {
+      var _a;
+      if (eventData.slug && this.openInvoices[eventData.slug]) {
+        const invoiceData = this.openInvoices[eventData.slug];
+        delete this.openInvoices[eventData.slug];
+        (_a = invoiceData.callback) == null ? void 0 : _a.call(invoiceData, eventData.status);
+        this.kernel.receiveWebViewEvent("invoiceClosed", { url: invoiceData.url, status: eventData.status });
+      }
+    };
+    kernel.webView.onEvent("invoice_closed", this.handleInvoiceClosed);
+  }
+  openInvoice(url, callback) {
+    const a = document.createElement("A");
+    a.href = url;
+    const match = a.pathname.match(/^\/(\$|invoice\/)([A-Za-z0-9\-_=]+)$/);
+    const slug = match == null ? void 0 : match[2];
+    if (a.protocol != "http:" && a.protocol != "https:" || a.hostname != "t.me" || !match || !slug) {
+      console.error("[@core-ease/telegram-kit] Invoice url is invalid", url);
+      throwWebAppError("WebAppInvoiceUrlInvalid" /* InvoiceUrlInvalid */);
+    }
+    this.kernel.requireVersion("6.1", "openInvoice");
+    if (this.openInvoices[slug]) {
+      console.error("[@core-ease/telegram-kit] Invoice is already opened");
+      throwWebAppError("WebAppInvoiceOpened" /* InvoiceOpened */);
+    }
+    this.openInvoices[slug] = { url, callback };
+    this.kernel.webView.postEvent("web_app_open_invoice", void 0, { slug });
+  }
+};
+
+// src/sdk/_internal/features/clipboard.ts
+var ClipboardManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.handleClipboardTextReceived = (_eventType, eventData) => {
+      var _a;
+      if (!eventData.req_id || !this.kernel.hasCallback(eventData.req_id)) return;
+      const entry = this.kernel.takeCallback(eventData.req_id);
+      const data = typeof eventData.data !== "undefined" ? eventData.data : null;
+      (_a = entry == null ? void 0 : entry.callback) == null ? void 0 : _a.call(entry, data);
+      this.kernel.receiveWebViewEvent("clipboardTextReceived", { data });
+    };
+    kernel.webView.onEvent("clipboard_text_received", this.handleClipboardTextReceived);
+  }
+  readTextFromClipboard(callback) {
+    this.kernel.requireVersion("6.4", "readTextFromClipboard");
+    const reqId = this.kernel.registerCallback(callback);
+    this.kernel.webView.postEvent("web_app_read_text_from_clipboard", void 0, { req_id: reqId });
+  }
+};
+
+// src/sdk/_internal/features/custom-method-helpers.ts
+function invokeGetRequestedContact(kernel, callback, timeout) {
+  let reqTo;
+  let fallbackTo;
+  let reqDelay = 0;
+  const reqInvoke = () => {
+    kernel.invokeCustomMethod("getRequestedContact", {}, (_err, res) => {
+      if (typeof res === "string" && res.substr(0, 1) == '"' && res.substr(-1) == '"') {
+        res = JSON.parse(res);
+      }
+      if (res && res.length) {
+        clearTimeout(fallbackTo);
+        callback(res);
+      } else {
+        reqDelay += 50;
+        reqTo = setTimeout(reqInvoke, reqDelay);
+      }
+    });
+  };
+  const fallbackInvoke = () => {
+    clearTimeout(reqTo);
+    callback("");
+  };
+  fallbackTo = setTimeout(fallbackInvoke, timeout);
+  reqInvoke();
+}
+
+// src/sdk/_internal/features/contact.ts
+var ContactManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.writeAccessRequested = false;
+    this.contactRequested = false;
+    this.handleWriteAccessRequested = (_eventType, eventData) => {
+      var _a;
+      if (this.writeAccessRequested) {
+        const requestData = this.writeAccessRequested;
+        this.writeAccessRequested = false;
+        (_a = requestData.callback) == null ? void 0 : _a.call(requestData, eventData.status == "allowed");
+        this.kernel.receiveWebViewEvent("writeAccessRequested", { status: eventData.status });
+      }
+    };
+    this.handlePhoneRequested = (_eventType, eventData) => {
+      var _a;
+      if (!this.contactRequested) return;
+      const requestData = this.contactRequested;
+      this.contactRequested = false;
+      const requestSent = eventData.status == "sent";
+      const webViewEvent = { status: eventData.status };
+      if (requestSent) {
+        invokeGetRequestedContact(this.kernel, (res) => {
+          var _a2;
+          if (res && res.length) {
+            webViewEvent.response = res;
+            webViewEvent.responseUnsafe = urlParseQueryString(res);
+            for (const key in webViewEvent.responseUnsafe) {
+              const val = webViewEvent.responseUnsafe[key];
+              try {
+                if ((val == null ? void 0 : val.substr(0, 1)) == "{" && (val == null ? void 0 : val.substr(-1)) == "}" || (val == null ? void 0 : val.substr(0, 1)) == "[" && (val == null ? void 0 : val.substr(-1)) == "]") {
+                  webViewEvent.responseUnsafe[key] = JSON.parse(val);
+                }
+              } catch (e) {
+              }
+            }
+          }
+          (_a2 = requestData.callback) == null ? void 0 : _a2.call(requestData, requestSent, webViewEvent);
+          this.kernel.receiveWebViewEvent("contactRequested", webViewEvent);
+        }, 3e3);
+      } else {
+        (_a = requestData.callback) == null ? void 0 : _a.call(requestData, requestSent, webViewEvent);
+        this.kernel.receiveWebViewEvent("contactRequested", webViewEvent);
+      }
+    };
+    kernel.webView.onEvent("write_access_requested", this.handleWriteAccessRequested);
+    kernel.webView.onEvent("phone_requested", this.handlePhoneRequested);
+  }
+  requestWriteAccess(callback) {
+    this.kernel.requireVersion("6.9", "requestWriteAccess");
+    if (this.writeAccessRequested) {
+      console.error("[@core-ease/telegram-kit] Write access is already requested");
+      throwWebAppError("WebAppWriteAccessRequested" /* WriteAccessRequested */);
+    }
+    this.writeAccessRequested = { callback };
+    this.kernel.webView.postEvent("web_app_request_write_access");
+  }
+  requestContact(callback) {
+    this.kernel.requireVersion("6.9", "requestContact");
+    if (this.contactRequested) {
+      console.error("[@core-ease/telegram-kit] Contact is already requested");
+      throwWebAppError("WebAppContactRequested" /* ContactRequested */);
+    }
+    this.contactRequested = { callback };
+    this.kernel.webView.postEvent("web_app_request_phone");
+  }
+};
+
+// src/sdk/_internal/features/home-screen.ts
+var HomeScreenManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.statusCallbacks = [];
+    this.handleAdded = () => {
+      this.kernel.receiveWebViewEvent("homeScreenAdded");
+    };
+    this.handleChecked = (_eventType, eventData) => {
+      const status = eventData.status || "unknown";
+      if (this.statusCallbacks.length > 0) {
+        this.statusCallbacks.forEach((cb) => cb(status));
+        this.statusCallbacks = [];
+      }
+      this.kernel.receiveWebViewEvent("homeScreenChecked", { status });
+    };
+    kernel.webView.onEvent("home_screen_added", this.handleAdded);
+    kernel.webView.onEvent("home_screen_checked", this.handleChecked);
+  }
+  addToHomeScreen() {
+    this.kernel.requireVersion("8.0", "addToHomeScreen");
+    this.kernel.webView.postEvent("web_app_add_to_home_screen");
+  }
+  checkHomeScreenStatus(callback) {
+    this.kernel.requireVersion("8.0", "checkHomeScreenStatus");
+    if (callback) this.statusCallbacks.push(callback);
+    this.kernel.webView.postEvent("web_app_check_home_screen");
+  }
+};
+
+// src/sdk/_internal/features/download-file.ts
+var DownloadFileManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.requested = false;
+    this.handleFileDownloadRequested = (_eventType, eventData) => {
+      var _a;
+      if (!this.requested) return;
+      const requestData = this.requested;
+      this.requested = false;
+      const isDownloading = eventData.status == "downloading";
+      (_a = requestData.callback) == null ? void 0 : _a.call(requestData, isDownloading);
+      this.kernel.receiveWebViewEvent("fileDownloadRequested", { status: isDownloading ? "downloading" : "cancelled" });
+    };
+    kernel.webView.onEvent("file_download_requested", this.handleFileDownloadRequested);
+  }
+  downloadFile(params, callback) {
+    this.kernel.requireVersion("8.0", "downloadFile");
+    if (this.requested) {
+      console.error("[@core-ease/telegram-kit] Popup is already opened");
+      throwWebAppError("WebAppDownloadFilePopupOpened" /* DownloadFilePopupOpened */);
+    }
+    const a = document.createElement("A");
+    const dlParams = {};
+    if (!params || !params.url || !params.url.length) {
+      console.error("[@core-ease/telegram-kit] Url is required");
+      throwWebAppError("WebAppDownloadFileParamInvalid" /* DownloadFileParamInvalid */);
+    }
+    a.href = params.url;
+    if (a.protocol != "https:") {
+      console.error("[@core-ease/telegram-kit] Url protocol is not supported", params.url);
+      throwWebAppError("WebAppDownloadFileParamInvalid" /* DownloadFileParamInvalid */);
+    }
+    dlParams.url = a.href;
+    if (!params || !params.file_name || !params.file_name.length) {
+      console.error("[@core-ease/telegram-kit] File name is required");
+      throwWebAppError("WebAppDownloadFileParamInvalid" /* DownloadFileParamInvalid */);
+    }
+    dlParams.file_name = params.file_name;
+    this.requested = { callback };
+    this.kernel.webView.postEvent("web_app_request_file_download", void 0, dlParams);
+  }
+};
+
+// src/sdk/_internal/features/sharing.ts
+var SharingManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.shareMessageOpened = false;
+    this.requestChatOpened = false;
+    this.handlePreparedMessageSent = () => {
+      var _a;
+      if (!this.shareMessageOpened) return;
+      const requestData = this.shareMessageOpened;
+      this.shareMessageOpened = false;
+      (_a = requestData.callback) == null ? void 0 : _a.call(requestData, true);
+      this.kernel.receiveWebViewEvent("shareMessageSent");
+    };
+    this.handlePreparedMessageFailed = (_eventType, eventData) => {
+      var _a;
+      if (!this.shareMessageOpened) return;
+      const requestData = this.shareMessageOpened;
+      this.shareMessageOpened = false;
+      (_a = requestData.callback) == null ? void 0 : _a.call(requestData, false);
+      this.kernel.receiveWebViewEvent("shareMessageFailed", { error: eventData.error });
+    };
+    this.handleRequestedChatSent = () => {
+      var _a;
+      if (!this.requestChatOpened) return;
+      const requestData = this.requestChatOpened;
+      this.requestChatOpened = false;
+      (_a = requestData.callback) == null ? void 0 : _a.call(requestData, true);
+      this.kernel.receiveWebViewEvent("requestedChatSent");
+    };
+    this.handleRequestedChatFailed = (_eventType, eventData) => {
+      var _a;
+      if (!this.requestChatOpened) return;
+      const requestData = this.requestChatOpened;
+      this.requestChatOpened = false;
+      (_a = requestData.callback) == null ? void 0 : _a.call(requestData, false);
+      this.kernel.receiveWebViewEvent("requestedChatFailed", { error: eventData.error });
+    };
+    kernel.webView.onEvent("prepared_message_sent", this.handlePreparedMessageSent);
+    kernel.webView.onEvent("prepared_message_failed", this.handlePreparedMessageFailed);
+    kernel.webView.onEvent("requested_chat_sent", this.handleRequestedChatSent);
+    kernel.webView.onEvent("requested_chat_failed", this.handleRequestedChatFailed);
+  }
+  shareToStory(mediaUrl, params = {}) {
+    this.kernel.requireVersion("7.8", "shareToStory");
+    const a = document.createElement("A");
+    a.href = mediaUrl;
+    if (a.protocol != "http:" && a.protocol != "https:") {
+      console.error("[@core-ease/telegram-kit] Media url protocol is not supported", mediaUrl);
+      throwWebAppError("WebAppMediaUrlInvalid" /* MediaUrlInvalid */);
+    }
+    const shareParams = { media_url: a.href };
+    if (typeof params.text !== "undefined") {
+      const text = strTrim(params.text);
+      if (text.length > 2048) {
+        console.error("[@core-ease/telegram-kit] Text is too long", text);
+        throwWebAppError("WebAppShareToStoryParamInvalid" /* ShareToStoryParamInvalid */);
+      }
+      if (text.length > 0) shareParams.text = text;
+    }
+    if (typeof params.widget_link !== "undefined") {
+      const widgetLinkParam = params.widget_link || {};
+      a.href = widgetLinkParam.url;
+      if (a.protocol != "http:" && a.protocol != "https:") {
+        console.error("[@core-ease/telegram-kit] Link protocol is not supported", widgetLinkParam.url);
+        throwWebAppError("WebAppShareToStoryParamInvalid" /* ShareToStoryParamInvalid */);
+      }
+      const widgetLink = { url: a.href };
+      if (typeof widgetLinkParam.name !== "undefined") {
+        const linkName = strTrim(widgetLinkParam.name);
+        if (linkName.length > 48) {
+          console.error("[@core-ease/telegram-kit] Link name is too long", linkName);
+          throwWebAppError("WebAppShareToStoryParamInvalid" /* ShareToStoryParamInvalid */);
+        }
+        if (linkName.length > 0) widgetLink.name = linkName;
+      }
+      shareParams.widget_link = widgetLink;
+    }
+    this.kernel.webView.postEvent("web_app_share_to_story", void 0, shareParams);
+  }
+  shareMessage(msgId, callback) {
+    this.kernel.requireVersion("8.0", "shareMessage");
+    if (this.shareMessageOpened) {
+      console.error("[@core-ease/telegram-kit] Share message is already opened");
+      throwWebAppError("WebAppShareMessageOpened" /* ShareMessageOpened */);
+    }
+    this.shareMessageOpened = { callback };
+    this.kernel.webView.postEvent("web_app_send_prepared_message", void 0, { id: msgId });
+  }
+  requestChat(reqId, callback) {
+    this.kernel.requireVersion("9.6", "requestChat");
+    if (this.requestChatOpened) {
+      console.error("[@core-ease/telegram-kit] Request chat is already opened");
+      throwWebAppError("WebAppRequestChatOpened" /* RequestChatOpened */);
+    }
+    this.requestChatOpened = { callback };
+    this.kernel.webView.postEvent("web_app_request_chat", void 0, { req_id: reqId });
+  }
+  switchInlineQuery(query, chooseChatTypes, initParams) {
+    this.kernel.requireVersion("6.6", "switchInlineQuery");
+    if (!initParams.tgWebAppBotInline) {
+      console.error(
+        "[@core-ease/telegram-kit] Inline mode is disabled for this bot. Read more about inline mode: https://core.telegram.org/bots/inline"
+      );
+      throwWebAppError("WebAppInlineModeDisabled" /* InlineModeDisabled */);
+    }
+    const q = query || "";
+    if (q.length > 256) {
+      console.error("[@core-ease/telegram-kit] Inline query is too long", q);
+      throwWebAppError("WebAppInlineQueryInvalid" /* InlineQueryInvalid */);
+    }
+    const chatTypes = [];
+    if (chooseChatTypes) {
+      if (!Array.isArray(chooseChatTypes)) {
+        console.error("[@core-ease/telegram-kit] Choose chat types should be an array", chooseChatTypes);
+        throwWebAppError("WebAppInlineChooseChatTypesInvalid" /* InlineChooseChatTypesInvalid */);
+      }
+      const goodTypes = { users: 1, bots: 1, groups: 1, channels: 1 };
+      for (const chatType of chooseChatTypes) {
+        if (!goodTypes[chatType]) {
+          console.error("[@core-ease/telegram-kit] Choose chat type is invalid", chatType);
+          throwWebAppError("WebAppInlineChooseChatTypeInvalid" /* InlineChooseChatTypeInvalid */);
+        }
+        if (goodTypes[chatType] != 2) {
+          goodTypes[chatType] = 2;
+          chatTypes.push(chatType);
+        }
+      }
+    }
+    this.kernel.webView.postEvent("web_app_switch_inline_query", void 0, { query: q, chat_types: chatTypes });
+  }
+};
+
+// src/sdk/_internal/features/emoji-status.ts
+var EmojiStatusManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.setRequested = false;
+    this.accessRequested = false;
+    this.handleSet = () => {
+      var _a;
+      if (!this.setRequested) return;
+      const requestData = this.setRequested;
+      this.setRequested = false;
+      (_a = requestData.callback) == null ? void 0 : _a.call(requestData, true);
+      this.kernel.receiveWebViewEvent("emojiStatusSet");
+    };
+    this.handleFailed = (_eventType, eventData) => {
+      var _a;
+      if (!this.setRequested) return;
+      const requestData = this.setRequested;
+      this.setRequested = false;
+      (_a = requestData.callback) == null ? void 0 : _a.call(requestData, false);
+      this.kernel.receiveWebViewEvent("emojiStatusFailed", { error: eventData.error });
+    };
+    this.handleAccessRequested = (_eventType, eventData) => {
+      var _a;
+      if (!this.accessRequested) return;
+      const requestData = this.accessRequested;
+      this.accessRequested = false;
+      (_a = requestData.callback) == null ? void 0 : _a.call(requestData, eventData.status == "allowed");
+      this.kernel.receiveWebViewEvent("emojiStatusAccessRequested", { status: eventData.status });
+    };
+    kernel.webView.onEvent("emoji_status_set", this.handleSet);
+    kernel.webView.onEvent("emoji_status_failed", this.handleFailed);
+    kernel.webView.onEvent("emoji_status_access_requested", this.handleAccessRequested);
+  }
+  setEmojiStatus(customEmojiId, params = {}, callback) {
+    this.kernel.requireVersion("8.0", "setEmojiStatus");
+    const statusParams = { custom_emoji_id: customEmojiId };
+    if (typeof params.duration !== "undefined") {
+      statusParams.duration = params.duration;
+    }
+    if (this.setRequested) {
+      console.error("[@core-ease/telegram-kit] Emoji status is already requested");
+      throwWebAppError("WebAppEmojiStatusRequested" /* EmojiStatusRequested */);
+    }
+    this.setRequested = { callback };
+    this.kernel.webView.postEvent("web_app_set_emoji_status", void 0, statusParams);
+  }
+  requestEmojiStatusAccess(callback) {
+    this.kernel.requireVersion("8.0", "requestEmojiStatusAccess");
+    if (this.accessRequested) {
+      console.error("[@core-ease/telegram-kit] Emoji status permission is already requested");
+      throwWebAppError("WebAppEmojiStatusAccessRequested" /* EmojiStatusAccessRequested */);
+    }
+    this.accessRequested = { callback };
+    this.kernel.webView.postEvent("web_app_request_emoji_status_access");
+  }
+};
+
+// src/sdk/_internal/features/links.ts
+var LinkManager = class {
+  constructor(kernel) {
+    this.kernel = kernel;
+    /**
+     * Intercepts clicks on in-page `t.me` links while running inside an
+     * iframe (web.telegram.org) and routes them through `openTelegramLink`
+     * instead of letting the browser navigate directly.
+     */
+    this.handleDocumentClick = (e) => {
+      if (e.metaKey || e.ctrlKey) return;
+      let el = e.target;
+      while (el && el.tagName != "A" && el.parentNode) {
+        el = el.parentNode;
+      }
+      if (el && el.tagName == "A" && el.target != "_blank" && (el.protocol == "http:" || el.protocol == "https:") && el.hostname == "t.me") {
+        this.openTelegramLink(el.href);
+        e.preventDefault();
+      }
+    };
+  }
+  openLink(url, options = {}) {
+    const a = document.createElement("A");
+    a.href = url;
+    if (a.protocol != "http:" && a.protocol != "https:") {
+      console.error("[@core-ease/telegram-kit] Url protocol is not supported", url);
+      throwWebAppError("WebAppTgUrlInvalid" /* TgUrlInvalid */);
+    }
+    const resolvedUrl = a.href;
+    if (this.kernel.versionAtLeast("6.1")) {
+      const reqParams = { url: resolvedUrl };
+      if (this.kernel.versionAtLeast("6.4") && options.try_instant_view) {
+        reqParams.try_instant_view = true;
+      }
+      if (this.kernel.versionAtLeast("7.6") && options.try_browser) {
+        reqParams.try_browser = options.try_browser;
+      }
+      this.kernel.webView.postEvent("web_app_open_link", void 0, reqParams);
+    } else {
+      window.open(resolvedUrl, "_blank");
+    }
+  }
+  openTelegramLink(url, options = {}) {
+    const a = document.createElement("A");
+    a.href = url;
+    if (a.protocol != "http:" && a.protocol != "https:") {
+      console.error("[@core-ease/telegram-kit] Url protocol is not supported", url);
+      throwWebAppError("WebAppTgUrlInvalid" /* TgUrlInvalid */);
+    }
+    if (a.hostname != "t.me") {
+      console.error("[@core-ease/telegram-kit] Url host is not supported", url);
+      throwWebAppError("WebAppTgUrlInvalid" /* TgUrlInvalid */);
+    }
+    const pathFull = a.pathname + a.search;
+    if (this.kernel.webView.isIframe || this.kernel.versionAtLeast("6.1")) {
+      const reqParams = { path_full: pathFull };
+      if (options.force_request) {
+        reqParams.force_request = true;
+      }
+      this.kernel.webView.postEvent("web_app_open_tg_link", void 0, reqParams);
+    } else {
+      location.href = "https://t.me" + pathFull;
+    }
+  }
+};
+
+// src/sdk/_internal/sensors/motion-sensor-base.ts
+var MotionSensorBase = class {
+  constructor(kernel, names, initialValues) {
+    this.kernel = kernel;
+    this.names = names;
+    this._isStarted = false;
+    this.startCallbacks = [];
+    this.stopCallbacks = [];
+    this.handleStarted = () => {
+      this._isStarted = true;
+      if (this.startCallbacks.length > 0) {
+        this.startCallbacks.forEach((cb) => cb(true));
+        this.startCallbacks = [];
+      }
+      this.kernel.receiveWebViewEvent(this.names.webViewStarted);
+    };
+    this.handleStopped = () => {
+      this._isStarted = false;
+      if (this.stopCallbacks.length > 0) {
+        this.stopCallbacks.forEach((cb) => cb(true));
+        this.stopCallbacks = [];
+      }
+      this.kernel.receiveWebViewEvent(this.names.webViewStopped);
+    };
+    this.handleChanged = (_eventType, eventData) => {
+      this.values = this.mapChangedPayload(eventData);
+      this.kernel.receiveWebViewEvent(this.names.webViewChanged);
+    };
+    this.handleFailed = (_eventType, eventData) => {
+      if (this.startCallbacks.length > 0) {
+        this.startCallbacks.forEach((cb) => cb(false));
+        this.startCallbacks = [];
+      }
+      this.kernel.receiveWebViewEvent(this.names.webViewFailed, { error: eventData.error });
+    };
+    this.values = initialValues;
+    kernel.webView.onEvent(names.started, this.handleStarted);
+    kernel.webView.onEvent(names.stopped, this.handleStopped);
+    kernel.webView.onEvent(names.changed, this.handleChanged);
+    kernel.webView.onEvent(names.failed, this.handleFailed);
+  }
+  get isStarted() {
+    return this._isStarted;
+  }
+  checkVersion() {
+    return this.kernel.warnIfUnsupported(this.names.minVersion, this.names.displayName);
+  }
+  buildStartParams(refreshRate) {
+    const params = {};
+    const rate = parseInt(String(refreshRate != null ? refreshRate : 1e3));
+    if (isNaN(rate) || rate < 20 || rate > 1e3) {
+      console.warn(`[@core-ease/telegram-kit] ${this.names.displayName} refresh_rate is invalid`, rate);
+    } else {
+      params.refresh_rate = rate;
+    }
+    return params;
+  }
+  doStart(reqParams, callback) {
+    if (callback) this.startCallbacks.push(callback);
+    this.kernel.webView.postEvent(this.names.startCommand, void 0, reqParams);
+  }
+  stop(callback) {
+    if (!this.checkVersion()) return this;
+    if (callback) this.stopCallbacks.push(callback);
+    this.kernel.webView.postEvent(this.names.stopCommand);
+    return this;
+  }
+};
+
+// src/sdk/_internal/sensors/accelerometer.ts
+var Accelerometer = class extends MotionSensorBase {
+  constructor(kernel) {
+    super(
+      kernel,
+      {
+        started: "accelerometer_started",
+        stopped: "accelerometer_stopped",
+        changed: "accelerometer_changed",
+        failed: "accelerometer_failed",
+        webViewStarted: "accelerometerStarted",
+        webViewStopped: "accelerometerStopped",
+        webViewChanged: "accelerometerChanged",
+        webViewFailed: "accelerometerFailed",
+        startCommand: "web_app_start_accelerometer",
+        stopCommand: "web_app_stop_accelerometer",
+        minVersion: "8.0",
+        displayName: "Accelerometer"
+      },
+      { x: null, y: null, z: null }
+    );
+  }
+  mapChangedPayload(eventData) {
+    return { x: eventData.x, y: eventData.y, z: eventData.z };
+  }
+  get x() {
+    return this.values.x;
+  }
+  get y() {
+    return this.values.y;
+  }
+  get z() {
+    return this.values.z;
+  }
+  start(params = {}, callback) {
+    if (!this.checkVersion()) return this;
+    const reqParams = this.buildStartParams(params.refresh_rate);
+    this.doStart(reqParams, callback);
+    return this;
+  }
+};
+
+// src/sdk/_internal/sensors/gyroscope.ts
+var Gyroscope = class extends MotionSensorBase {
+  constructor(kernel) {
+    super(
+      kernel,
+      {
+        started: "gyroscope_started",
+        stopped: "gyroscope_stopped",
+        changed: "gyroscope_changed",
+        failed: "gyroscope_failed",
+        webViewStarted: "gyroscopeStarted",
+        webViewStopped: "gyroscopeStopped",
+        webViewChanged: "gyroscopeChanged",
+        webViewFailed: "gyroscopeFailed",
+        startCommand: "web_app_start_gyroscope",
+        stopCommand: "web_app_stop_gyroscope",
+        minVersion: "8.0",
+        displayName: "Gyroscope"
+      },
+      { x: null, y: null, z: null }
+    );
+  }
+  mapChangedPayload(eventData) {
+    return { x: eventData.x, y: eventData.y, z: eventData.z };
+  }
+  get x() {
+    return this.values.x;
+  }
+  get y() {
+    return this.values.y;
+  }
+  get z() {
+    return this.values.z;
+  }
+  start(params = {}, callback) {
+    if (!this.checkVersion()) return this;
+    const reqParams = this.buildStartParams(params.refresh_rate);
+    this.doStart(reqParams, callback);
+    return this;
+  }
+};
+
+// src/sdk/_internal/sensors/device-orientation.ts
+var DeviceOrientation = class extends MotionSensorBase {
+  constructor(kernel) {
+    super(
+      kernel,
+      {
+        started: "device_orientation_started",
+        stopped: "device_orientation_stopped",
+        changed: "device_orientation_changed",
+        failed: "device_orientation_failed",
+        webViewStarted: "deviceOrientationStarted",
+        webViewStopped: "deviceOrientationStopped",
+        webViewChanged: "deviceOrientationChanged",
+        webViewFailed: "deviceOrientationFailed",
+        startCommand: "web_app_start_device_orientation",
+        stopCommand: "web_app_stop_device_orientation",
+        minVersion: "8.0",
+        displayName: "DeviceOrientation"
+      },
+      { absolute: false, alpha: null, beta: null, gamma: null }
+    );
+  }
+  mapChangedPayload(eventData) {
+    return {
+      absolute: !!eventData.absolute,
+      alpha: eventData.alpha,
+      beta: eventData.beta,
+      gamma: eventData.gamma
+    };
+  }
+  get absolute() {
+    return this.values.absolute;
+  }
+  get alpha() {
+    return this.values.alpha;
+  }
+  get beta() {
+    return this.values.beta;
+  }
+  get gamma() {
+    return this.values.gamma;
+  }
+  start(params = {}, callback) {
+    if (!this.checkVersion()) return this;
+    const reqParams = this.buildStartParams(params.refresh_rate);
+    reqParams.need_absolute = !!params.need_absolute;
+    this.doStart(reqParams, callback);
+    return this;
+  }
+};
+
+// src/sdk/_internal/webapp.ts
+var WebApp = class {
+  constructor(webView) {
+    this.webView = webView;
+    this.webAppInitData = "";
+    this.webAppInitDataUnsafe = {};
+    this.webAppPlatform = "unknown";
+    this.webAppIsActive = true;
+    this.handleThemeChanged = (_eventType, eventData) => {
+      if (eventData.theme_params) {
+        this.theme.setThemeParams(eventData.theme_params);
+        this.MainButton.setParams({});
+        this.SecondaryButton.setParams({});
+        this.theme.updateHeaderColor();
+        this.theme.updateBackgroundColor();
+        this.theme.updateBottomBarColor();
+        this.kernel.receiveWebViewEvent("themeChanged");
+      }
+    };
+    this.handleVisibilityChanged = (_eventType, eventData) => {
+      if (eventData.is_visible) {
+        this.webAppIsActive = true;
+        this.kernel.receiveWebViewEvent("activated");
+      } else {
+        this.webAppIsActive = false;
+        this.kernel.receiveWebViewEvent("deactivated");
+      }
+    };
+    const kernel = new WebAppKernel(webView);
+    this.kernel = kernel;
+    const initParams = webView.initParams;
+    if (initParams.tgWebAppData && initParams.tgWebAppData.length) {
+      this.webAppInitData = initParams.tgWebAppData;
+      const parsed = urlParseQueryString(this.webAppInitData);
+      for (const key in parsed) {
+        const val = parsed[key];
+        try {
+          if ((val == null ? void 0 : val.substr(0, 1)) == "{" && (val == null ? void 0 : val.substr(-1)) == "}" || (val == null ? void 0 : val.substr(0, 1)) == "[" && (val == null ? void 0 : val.substr(-1)) == "]") {
+            parsed[key] = JSON.parse(val);
+          }
+        } catch (e) {
+        }
+      }
+      this.webAppInitDataUnsafe = parsed;
+    }
+    if (initParams.tgWebAppPlatform) {
+      this.webAppPlatform = initParams.tgWebAppPlatform;
+    }
+    this.theme = new ThemeManager(kernel);
+    this.viewport = new ViewportManager(kernel);
+    this.debugBar = new DebugBottomBar(kernel, () => this.theme.getBottomBarColor());
+    this.BackButton = new BackButton(kernel);
+    this.MainButton = new BottomButton("main", kernel, this.theme, this.debugBar);
+    this.SecondaryButton = new BottomButton("secondary", kernel, this.theme, this.debugBar);
+    this.SettingsButton = new SettingsButton(kernel);
+    this.popups = new PopupManager(kernel);
+    this.scanQr = new ScanQrManager(kernel);
+    this.HapticFeedback = new HapticFeedback(kernel);
+    this.CloudStorage = new CloudStorage(kernel);
+    this.DeviceStorage = new DeviceStorage(kernel);
+    this.SecureStorage = new SecureStorage(kernel);
+    this.BiometricManager = new BiometricManager(kernel);
+    this.LocationManager = new LocationManager(kernel);
+    this.invoices = new InvoiceManager(kernel);
+    this.clipboard = new ClipboardManager(kernel);
+    this.contact = new ContactManager(kernel);
+    this.homeScreen = new HomeScreenManager(kernel);
+    this.downloadFileManager = new DownloadFileManager(kernel);
+    this.sharing = new SharingManager(kernel);
+    this.emojiStatus = new EmojiStatusManager(kernel);
+    this.links = new LinkManager(kernel);
+    this.Accelerometer = new Accelerometer(kernel);
+    this.DeviceOrientation = new DeviceOrientation(kernel);
+    this.Gyroscope = new Gyroscope(kernel);
+    this.debugBar.onHeightChanged = () => this.viewport.setViewportHeight();
+    this.theme.onBottomBarColorApplied = () => {
+      this.debugBar.refreshColor();
+      this.SecondaryButton.setParams({});
+    };
+    kernel.webView.onEvent("theme_changed", this.handleThemeChanged);
+    kernel.webView.onEvent("viewport_changed", this.viewport.handleViewportChanged);
+    kernel.webView.onEvent("safe_area_changed", this.viewport.handleSafeAreaChanged);
+    kernel.webView.onEvent("content_safe_area_changed", this.viewport.handleContentSafeAreaChanged);
+    kernel.webView.onEvent("visibility_changed", this.handleVisibilityChanged);
+    kernel.webView.onEvent("fullscreen_changed", this.viewport.handleFullscreenChanged);
+    kernel.webView.onEvent("fullscreen_failed", this.viewport.handleFullscreenFailed);
+    kernel.webView.onEvent("custom_method_invoked", kernel.onCustomMethodInvoked);
+    window.addEventListener("resize", this.viewport.onWindowResize);
+    if (webView.isIframe) {
+      document.addEventListener("click", this.links.handleDocumentClick);
+    }
+    this.theme.updateHeaderColor();
+    this.theme.updateBackgroundColor();
+    this.theme.updateBottomBarColor();
+    this.viewport.setViewportHeight();
+    if (initParams.tgWebAppShowSettings) {
+      this.SettingsButton.show();
+    }
+    kernel.webView.postEvent("web_app_request_theme");
+    kernel.webView.postEvent("web_app_request_viewport");
+    kernel.webView.postEvent("web_app_request_safe_area");
+    kernel.webView.postEvent("web_app_request_content_safe_area");
+  }
+  // -----------------------------------------------------------------------
+  // Public read-only properties
+  // -----------------------------------------------------------------------
+  get initData() {
+    return this.webAppInitData;
+  }
+  get initDataUnsafe() {
+    return this.webAppInitDataUnsafe;
+  }
+  get version() {
+    return this.kernel.version;
+  }
+  get platform() {
+    return this.webAppPlatform;
+  }
+  get colorScheme() {
+    return this.theme.colorScheme;
+  }
+  get themeParams() {
+    return this.theme.getThemeParams();
+  }
+  get isExpanded() {
+    return this.viewport.isExpanded;
+  }
+  get viewportHeight() {
+    return this.viewport.viewportHeight;
+  }
+  get viewportStableHeight() {
+    return this.viewport.viewportStableHeight;
+  }
+  get safeAreaInset() {
+    return this.viewport.safeAreaInset;
+  }
+  get contentSafeAreaInset() {
+    return this.viewport.contentSafeAreaInset;
+  }
+  get isFullscreen() {
+    return this.viewport.isFullscreen;
+  }
+  get isActive() {
+    return this.webAppIsActive;
+  }
+  get isClosingConfirmationEnabled() {
+    return this.viewport.isClosingConfirmationEnabled;
+  }
+  set isClosingConfirmationEnabled(val) {
+    this.viewport.setClosingConfirmation(val);
+  }
+  get isVerticalSwipesEnabled() {
+    return this.viewport.isVerticalSwipesEnabled;
+  }
+  set isVerticalSwipesEnabled(val) {
+    this.viewport.toggleVerticalSwipes(val);
+  }
+  get isOrientationLocked() {
+    return this.viewport.isOrientationLocked;
+  }
+  set isOrientationLocked(val) {
+    this.viewport.toggleOrientationLock(val);
+  }
+  get headerColor() {
+    return this.theme.getHeaderColor();
+  }
+  set headerColor(val) {
+    this.theme.setHeaderColor(val);
+  }
+  get backgroundColor() {
+    return this.theme.getBackgroundColor();
+  }
+  set backgroundColor(val) {
+    this.theme.setBackgroundColor(val);
+  }
+  get bottomBarColor() {
+    return this.theme.getBottomBarColor();
+  }
+  set bottomBarColor(val) {
+    this.theme.setBottomBarColor(val);
+  }
+  // -----------------------------------------------------------------------
+  // Methods
+  // -----------------------------------------------------------------------
+  isVersionAtLeast(ver) {
+    return this.kernel.versionAtLeast(ver);
+  }
+  setHeaderColor(colorKey) {
+    this.headerColor = colorKey;
+  }
+  setBackgroundColor(color) {
+    this.backgroundColor = color;
+  }
+  setBottomBarColor(color) {
+    this.bottomBarColor = color;
+  }
+  enableClosingConfirmation() {
+    this.isClosingConfirmationEnabled = true;
+  }
+  disableClosingConfirmation() {
+    this.isClosingConfirmationEnabled = false;
+  }
+  enableVerticalSwipes() {
+    this.isVerticalSwipesEnabled = true;
+  }
+  disableVerticalSwipes() {
+    this.isVerticalSwipesEnabled = false;
+  }
+  lockOrientation() {
+    this.isOrientationLocked = true;
+  }
+  unlockOrientation() {
+    this.isOrientationLocked = false;
+  }
+  requestFullscreen() {
+    this.viewport.requestFullscreen();
+  }
+  exitFullscreen() {
+    this.viewport.exitFullscreen();
+  }
+  addToHomeScreen() {
+    this.homeScreen.addToHomeScreen();
+  }
+  checkHomeScreenStatus(callback) {
+    this.homeScreen.checkHomeScreenStatus(callback);
+  }
+  onEvent(eventType, callback) {
+    this.kernel.onWebViewEvent(eventType, callback);
+  }
+  offEvent(eventType, callback) {
+    this.kernel.offWebViewEvent(eventType, callback);
+  }
+  sendData(data) {
+    if (!data || !data.length) {
+      console.error("[@core-ease/telegram-kit] Data is required", data);
+      throwWebAppError("WebAppDataInvalid" /* DataInvalid */);
+    }
+    if (byteLength(data) > 4096) {
+      console.error("[@core-ease/telegram-kit] Data is too long", data);
+      throwWebAppError("WebAppDataInvalid" /* DataInvalid */);
+    }
+    this.kernel.webView.postEvent("web_app_data_send", void 0, { data });
+  }
+  switchInlineQuery(query, chooseChatTypes) {
+    this.sharing.switchInlineQuery(query, chooseChatTypes, this.kernel.initParams);
+  }
+  openLink(url, options) {
+    this.links.openLink(url, options);
+  }
+  openTelegramLink(url, options) {
+    this.links.openTelegramLink(url, options);
+  }
+  openInvoice(url, callback) {
+    this.invoices.openInvoice(url, callback);
+  }
+  showPopup(params, callback) {
+    this.popups.showPopup(params, callback);
+  }
+  showAlert(message, callback) {
+    this.popups.showAlert(message, callback);
+  }
+  showConfirm(message, callback) {
+    this.popups.showConfirm(message, callback);
+  }
+  showScanQrPopup(params, callback) {
+    this.scanQr.showScanQrPopup(params, callback);
+  }
+  closeScanQrPopup() {
+    this.scanQr.closeScanQrPopup();
+  }
+  readTextFromClipboard(callback) {
+    this.clipboard.readTextFromClipboard(callback);
+  }
+  requestWriteAccess(callback) {
+    this.contact.requestWriteAccess(callback);
+  }
+  requestContact(callback) {
+    this.contact.requestContact(callback);
+  }
+  downloadFile(params, callback) {
+    this.downloadFileManager.downloadFile(params, callback);
+  }
+  shareToStory(mediaUrl, params) {
+    this.sharing.shareToStory(mediaUrl, params);
+  }
+  shareMessage(msgId, callback) {
+    this.sharing.shareMessage(msgId, callback);
+  }
+  requestChat(reqId, callback) {
+    this.sharing.requestChat(reqId, callback);
+  }
+  setEmojiStatus(customEmojiId, params, callback) {
+    this.emojiStatus.setEmojiStatus(customEmojiId, params, callback);
+  }
+  requestEmojiStatusAccess(callback) {
+    this.emojiStatus.requestEmojiStatusAccess(callback);
+  }
+  invokeCustomMethod(method, params, callback) {
+    this.kernel.invokeCustomMethod(method, params, callback);
+  }
+  hideKeyboard() {
+    this.kernel.webView.postEvent("web_app_hide_keyboard");
+  }
+  ready() {
+    this.kernel.webView.postEvent("web_app_ready");
+  }
+  expand() {
+    this.kernel.webView.postEvent("web_app_expand");
+  }
+  close(options = {}) {
+    const reqParams = {};
+    if (this.kernel.versionAtLeast("7.6") && options.return_back) {
+      reqParams.return_back = true;
+    }
+    this.kernel.webView.postEvent("web_app_close", void 0, reqParams);
+  }
+};
+
+// src/sdk/index.ts
+var SDK_NAME = "@core-ease/telegram-kit";
+var bootstrapped = null;
+function bootstrapTelegramWebApp() {
+  var _a;
+  if (bootstrapped) {
+    return bootstrapped;
+  }
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    throw new Error(`[${SDK_NAME}] bootstrapTelegramWebApp() requires a browser environment (window/document).`);
+  }
+  const webView = new TelegramWebView();
+  const telegram = (_a = window.Telegram) != null ? _a : window.Telegram = {};
+  telegram.WebView = webView;
+  telegram.Utils = Utils;
+  const webApp = new WebApp(webView);
+  telegram.WebApp = webApp;
+  bootstrapped = { webView, webApp };
+  return bootstrapped;
+}
+function isBootstrapped() {
+  return bootstrapped !== null;
+}
+
+export { Accelerometer, BackButton, BiometricManager, BottomButton, ClipboardManager, CloudStorage, ContactManager, DebugBottomBar, DeviceOrientation, DeviceStorage, DownloadFileManager, EmojiStatusManager, Gyroscope, HapticFeedback, HomeScreenManager, InvoiceManager, LinkManager, LocationManager, PopupManager, SDK_NAME, ScanQrManager, SecureStorage, SettingsButton, SharingManager, TelegramWebView, ThemeManager, Utils, ViewportManager, WebApp, WebAppError, WebAppErrorName, WebAppKernel, bootstrapTelegramWebApp, isBootstrapped };