@wowlabtech/mini-app-adapter 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2646 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AdapterProvider: () => AdapterProvider,
+  BaseMiniAppAdapter: () => BaseMiniAppAdapter,
+  MaxMiniAppAdapter: () => MaxMiniAppAdapter,
+  ShellMiniAppAdapter: () => ShellMiniAppAdapter,
+  TelegramMiniAppAdapter: () => TelegramMiniAppAdapter,
+  VKMiniAppAdapter: () => VKMiniAppAdapter,
+  WebMiniAppAdapter: () => WebMiniAppAdapter,
+  configureVkPixel: () => configureVkPixel,
+  createAdapter: () => createAdapter,
+  createShellAPI: () => createShellAPI,
+  detectPlatform: () => detectPlatform,
+  getActiveAdapter: () => getActiveAdapter,
+  getPlatform: () => getPlatform,
+  isShell: () => isShell,
+  isShellAndroid: () => isShellAndroid,
+  isShellIOS: () => isShellIOS,
+  readShellPlatform: () => readShellPlatform,
+  requestShellPushPermission: () => requestShellPushPermission,
+  shell: () => shell,
+  storeShellToken: () => storeShellToken,
+  trackConversionEvent: () => trackConversionEvent,
+  trackPixelEvent: () => trackPixelEvent,
+  useAdapterTheme: () => useAdapterTheme,
+  useMiniAppAdapter: () => useMiniAppAdapter,
+  useSafeArea: () => useSafeArea
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/disposables.ts
+var DisposableBag = class {
+  constructor() {
+    __publicField(this, "disposers", /* @__PURE__ */ new Set());
+  }
+  add(disposable) {
+    if (!disposable) {
+      return () => {
+      };
+    }
+    const dispose = typeof disposable === "function" ? disposable : typeof disposable.dispose === "function" ? disposable.dispose.bind(disposable) : void 0;
+    if (!dispose) {
+      return () => {
+      };
+    }
+    let called = false;
+    const wrapped = () => {
+      if (called) {
+        return;
+      }
+      called = true;
+      try {
+        dispose();
+      } catch (error) {
+        console.warn("[tvm-app-adapter] disposable failed:", error);
+      } finally {
+        this.disposers.delete(wrapped);
+      }
+    };
+    this.disposers.add(wrapped);
+    return wrapped;
+  }
+  disposeAll() {
+    for (const disposer of Array.from(this.disposers)) {
+      try {
+        disposer();
+      } catch (error) {
+        console.warn("[tvm-app-adapter] disposeAll failed:", error);
+      }
+    }
+    this.disposers.clear();
+  }
+};
+
+// src/lib/download.ts
+var isClient = typeof window !== "undefined" && typeof document !== "undefined";
+function getFallbackFileName(url, provided) {
+  if (provided && provided.trim().length > 0) {
+    return provided;
+  }
+  try {
+    const parsed = new URL(url);
+    const path = parsed.pathname.split("/").filter(Boolean).pop();
+    if (path) {
+      return path;
+    }
+  } catch {
+  }
+  return "download";
+}
+function triggerAnchorDownload(href, fileName, { targetBlank }) {
+  if (!isClient) {
+    return;
+  }
+  const anchor = document.createElement("a");
+  anchor.href = href;
+  anchor.download = fileName;
+  anchor.rel = "noopener noreferrer";
+  if (targetBlank) {
+    anchor.target = "_blank";
+  }
+  document.body.appendChild(anchor);
+  anchor.click();
+  document.body.removeChild(anchor);
+}
+async function triggerFileDownload(url, fileName, options) {
+  if (!url) {
+    return;
+  }
+  const safeFileName = getFallbackFileName(url, fileName);
+  const preferBlob = options?.preferBlob ?? false;
+  if (!isClient) {
+    if (typeof window !== "undefined") {
+      window.open(url, "_blank", "noopener,noreferrer");
+    }
+    return;
+  }
+  if (preferBlob && typeof fetch === "function") {
+    try {
+      const response = await fetch(url, { credentials: "include" });
+      if (!response.ok) {
+        throw new Error(`Failed to download file: ${response.status}`);
+      }
+      const blob = await response.blob();
+      const objectUrl = URL.createObjectURL(blob);
+      triggerAnchorDownload(objectUrl, safeFileName, { targetBlank: false });
+      setTimeout(() => URL.revokeObjectURL(objectUrl), 3e4);
+      return;
+    } catch (error) {
+      console.warn("[tvm-app-adapter] blob download failed, falling back to direct link:", error);
+    }
+  }
+  triggerAnchorDownload(url, safeFileName, { targetBlank: true });
+}
+
+// src/lib/safeArea.ts
+var SAFE_AREA_EDGES = ["top", "right", "bottom", "left"];
+var DEFAULT_SAFE_AREA = { top: 0, right: 0, bottom: 0, left: 0 };
+function cloneSafeArea(source) {
+  return { ...source };
+}
+function addSafeArea(target, source) {
+  if (!source) {
+    return;
+  }
+  for (const edge of SAFE_AREA_EDGES) {
+    const value = source[edge];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      target[edge] += value;
+    }
+  }
+}
+function applyMinimum(target, source) {
+  if (!source) {
+    return;
+  }
+  for (const edge of SAFE_AREA_EDGES) {
+    const value = source[edge];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      target[edge] = Math.max(target[edge], value);
+    }
+  }
+}
+function areSafeAreasEqual(a, b) {
+  if (!a || !b) {
+    return false;
+  }
+  return SAFE_AREA_EDGES.every((edge) => a[edge] === b[edge]);
+}
+function computeCombinedSafeArea(options = {}) {
+  const safeArea = cloneSafeArea(DEFAULT_SAFE_AREA);
+  addSafeArea(safeArea, options.environment);
+  if (options.viewport) {
+    addSafeArea(safeArea, options.viewport.safeArea);
+    addSafeArea(safeArea, options.viewport.contentSafeArea);
+  }
+  addSafeArea(safeArea, options.additions);
+  applyMinimum(safeArea, options.css);
+  applyMinimum(safeArea, options.minimum);
+  return safeArea;
+}
+function readCssSafeArea() {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return void 0;
+  }
+  const styles = getComputedStyle(document.documentElement);
+  const readEdge = (prop) => {
+    const value = parseFloat(styles.getPropertyValue(prop));
+    return Number.isFinite(value) ? value : 0;
+  };
+  const top = readEdge("--safe-area-inset-top");
+  const right = readEdge("--safe-area-inset-right");
+  const bottom = readEdge("--safe-area-inset-bottom");
+  const left = readEdge("--safe-area-inset-left");
+  if (top || right || bottom || left) {
+    return { top, right, bottom, left };
+  }
+  return void 0;
+}
+function normalizeSafeArea(value) {
+  if (!value) {
+    return void 0;
+  }
+  const safeArea = { ...DEFAULT_SAFE_AREA };
+  addSafeArea(safeArea, value);
+  return safeArea;
+}
+function createSafeAreaWatcher(options) {
+  const targetWindow = options.windowObj ?? (typeof window !== "undefined" ? window : void 0);
+  if (!targetWindow) {
+    return void 0;
+  }
+  let previous = normalizeSafeArea(options.getSafeArea());
+  if (previous) {
+    options.onChange(previous);
+    previous = cloneSafeArea(previous);
+  }
+  const handler = () => {
+    const next = normalizeSafeArea(options.getSafeArea());
+    if (!next) {
+      return;
+    }
+    if (!previous || !areSafeAreasEqual(previous, next)) {
+      options.onChange(next);
+      previous = cloneSafeArea(next);
+    }
+  };
+  handler();
+  const events = options.events ?? ["resize", "orientationchange"];
+  for (const eventName of events) {
+    targetWindow.addEventListener(eventName, handler);
+  }
+  return () => {
+    for (const eventName of events) {
+      targetWindow.removeEventListener(eventName, handler);
+    }
+  };
+}
+
+// src/lib/shell.ts
+var SHELL_PLATFORMS = ["shell_ios", "shell_android"];
+var SHELL_QR_TIMEOUT_MS = 6e4;
+var pushListeners = /* @__PURE__ */ new Set();
+var deepLinkListeners = /* @__PURE__ */ new Set();
+var activeListeners = /* @__PURE__ */ new Set();
+var backgroundListeners = /* @__PURE__ */ new Set();
+var lastPushToken = null;
+var pendingQrRequest = null;
+var DEFAULT_BRIDGE_CONFIG = {
+  platformFlag: "nativePlatform",
+  pushTokenCallback: "nativePushToken",
+  qrResultCallback: "nativeQRResult",
+  deepLinkCallback: "nativeDeepLink",
+  appActiveCallback: "nativeAppActive",
+  appBackgroundCallback: "nativeAppBackground"
+};
+var bridgeConfig = { ...DEFAULT_BRIDGE_CONFIG };
+var installedCallbackNames = {};
+function notifyPushListeners(token) {
+  lastPushToken = token;
+  for (const listener of pushListeners) {
+    try {
+      listener(token);
+    } catch (error) {
+      console.warn("[tvm-app-adapter] push token listener failed:", error);
+    }
+  }
+}
+function isShell(platform) {
+  return SHELL_PLATFORMS.includes(platform);
+}
+function isShellIOS(platform) {
+  return platform === "shell_ios";
+}
+function isShellAndroid(platform) {
+  return platform === "shell_android";
+}
+function readShellPlatform() {
+  const shellWindow = getShellWindow();
+  if (!shellWindow) {
+    return void 0;
+  }
+  const platform = shellWindow[bridgeConfig.platformFlag];
+  if (platform === "shell_ios" || platform === "shell_android") {
+    return platform;
+  }
+  return void 0;
+}
+function createShellAPI(platform) {
+  installGlobalCallbacks();
+  const resolvePlatform = typeof platform === "function" ? platform : () => platform;
+  return {
+    async openNativeQR() {
+      const currentPlatform = resolvePlatform();
+      if (isShell(currentPlatform)) {
+        return openNativeQrViaBridge();
+      }
+      return startHtml5Qrcode();
+    },
+    onPushToken(callback) {
+      pushListeners.add(callback);
+      if (lastPushToken) {
+        queueMicrotask(() => {
+          try {
+            callback(lastPushToken);
+          } catch (error) {
+            console.warn("[tvm-app-adapter] push token listener failed:", error);
+          }
+        });
+      }
+      return () => pushListeners.delete(callback);
+    },
+    onDeepLink(callback) {
+      deepLinkListeners.add(callback);
+      return () => deepLinkListeners.delete(callback);
+    },
+    onAppActive(callback) {
+      activeListeners.add(callback);
+      return () => activeListeners.delete(callback);
+    },
+    onAppBackground(callback) {
+      backgroundListeners.add(callback);
+      return () => backgroundListeners.delete(callback);
+    }
+  };
+}
+var shell = createShellAPI(() => readShellPlatform() ?? "web");
+function storeShellToken(payload) {
+  return sendBridgeCommand({ type: "storeToken", payload });
+}
+function requestShellPushPermission() {
+  return sendBridgeCommand({ type: "requestPushPermission" });
+}
+function getShellWindow() {
+  return typeof window === "undefined" ? null : window;
+}
+function getNativeBridge() {
+  const shellWindow = getShellWindow();
+  if (!shellWindow) {
+    return null;
+  }
+  const bridge2 = shellWindow.NativeBridge;
+  if (!bridge2 || typeof bridge2.postMessage !== "function") {
+    return null;
+  }
+  return bridge2;
+}
+function sendBridgeCommand(command) {
+  const bridge2 = getNativeBridge();
+  if (!bridge2) {
+    return false;
+  }
+  try {
+    bridge2.postMessage(command);
+    return true;
+  } catch (error) {
+    console.warn("[tvm-app-adapter] NativeBridge.postMessage failed:", error);
+    return false;
+  }
+}
+function installGlobalCallbacks() {
+  const shellWindow = getShellWindow();
+  if (!shellWindow) {
+    installedCallbackNames = {};
+    return;
+  }
+  const target = shellWindow;
+  const assignCallback = (key, handler) => {
+    const nextName = bridgeConfig[key];
+    const previousName = installedCallbackNames[key];
+    if (previousName && previousName !== nextName) {
+      delete target[previousName];
+    }
+    installedCallbackNames[key] = nextName;
+    target[nextName] = handler;
+  };
+  assignCallback("pushTokenCallback", (token) => {
+    if (typeof token !== "string") {
+      return;
+    }
+    console.log("[tvm-app-adapter] nativePushToken", token);
+    notifyPushListeners(token);
+  });
+  assignCallback("deepLinkCallback", (path) => {
+    if (typeof path !== "string") {
+      return;
+    }
+    for (const listener of deepLinkListeners) {
+      try {
+        listener(path);
+      } catch (error) {
+        console.warn("[tvm-app-adapter] deep link listener failed:", error);
+      }
+    }
+  });
+  assignCallback("appActiveCallback", () => {
+    for (const listener of activeListeners) {
+      try {
+        listener();
+      } catch (error) {
+        console.warn("[tvm-app-adapter] app active listener failed:", error);
+      }
+    }
+  });
+  assignCallback("appBackgroundCallback", () => {
+    for (const listener of backgroundListeners) {
+      try {
+        listener();
+      } catch (error) {
+        console.warn("[tvm-app-adapter] app background listener failed:", error);
+      }
+    }
+  });
+  assignCallback("qrResultCallback", (value) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    if (!pendingQrRequest) {
+      return;
+    }
+    clearTimeout(pendingQrRequest.timeoutId);
+    pendingQrRequest.resolve(value);
+    pendingQrRequest = null;
+  });
+}
+function openNativeQrViaBridge() {
+  return new Promise((resolve, reject) => {
+    if (pendingQrRequest) {
+      pendingQrRequest.reject(new Error("QR request superseded by a new call."));
+      clearTimeout(pendingQrRequest.timeoutId);
+      pendingQrRequest = null;
+    }
+    if (!sendBridgeCommand({ type: "openNativeQR" })) {
+      reject(new Error("Native bridge is unavailable."));
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      if (pendingQrRequest) {
+        pendingQrRequest.reject(new Error("Native QR request timed out."));
+        pendingQrRequest = null;
+      }
+    }, SHELL_QR_TIMEOUT_MS);
+    pendingQrRequest = { resolve, reject, timeoutId };
+  });
+}
+async function startHtml5Qrcode() {
+  if (typeof document === "undefined") {
+    throw new Error("QR scanning requires a browser environment.");
+  }
+  const [{ Html5Qrcode: Html5Qrcode2 }] = await Promise.all([import("html5-qrcode")]);
+  return new Promise((resolve, reject) => {
+    const elementId = `native-shell-qr-${Date.now()}`;
+    const overlay = document.createElement("div");
+    overlay.style.position = "fixed";
+    overlay.style.inset = "0";
+    overlay.style.background = "rgba(0, 0, 0, 0.9)";
+    overlay.style.display = "flex";
+    overlay.style.flexDirection = "column";
+    overlay.style.alignItems = "center";
+    overlay.style.justifyContent = "center";
+    overlay.style.zIndex = "2147483647";
+    overlay.style.backdropFilter = "blur(2px)";
+    const reader = document.createElement("div");
+    reader.id = elementId;
+    reader.style.width = "280px";
+    reader.style.height = "280px";
+    reader.style.borderRadius = "16px";
+    reader.style.overflow = "hidden";
+    reader.style.position = "relative";
+    const closeButton = document.createElement("button");
+    closeButton.type = "button";
+    closeButton.textContent = "\u2715";
+    closeButton.style.position = "absolute";
+    closeButton.style.top = "16px";
+    closeButton.style.right = "16px";
+    closeButton.style.background = "transparent";
+    closeButton.style.border = "none";
+    closeButton.style.color = "#fff";
+    closeButton.style.fontSize = "28px";
+    closeButton.style.cursor = "pointer";
+    overlay.appendChild(closeButton);
+    overlay.appendChild(reader);
+    document.body.appendChild(overlay);
+    const previousOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    let disposed = false;
+    const scanner = new Html5Qrcode2(elementId);
+    const cleanup = async (result, error) => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      try {
+        await scanner.stop();
+        const maybeClear = scanner.clear;
+        if (typeof maybeClear === "function") {
+          await Promise.resolve(maybeClear.call(scanner));
+        }
+      } catch {
+      }
+      overlay.remove();
+      document.body.style.overflow = previousOverflow;
+      if (typeof result === "string") {
+        resolve(result);
+      } else if (error) {
+        reject(error);
+      } else {
+        reject(new Error("QR scanning was cancelled."));
+      }
+    };
+    closeButton.addEventListener("click", () => {
+      void cleanup(void 0, new Error("QR scanning was cancelled by the user."));
+    });
+    scanner.start(
+      { facingMode: "environment" },
+      { fps: 10, qrbox: { width: 240, height: 240 } },
+      (decodedText) => {
+        void cleanup(decodedText);
+      },
+      () => {
+      }
+    ).catch((error) => {
+      const cause = error instanceof Error ? error : new Error("Unable to start HTML5 QR scanner.");
+      void cleanup(void 0, cause);
+    });
+  });
+}
+
+// src/adapters/baseAdapter.ts
+var BaseMiniAppAdapter = class {
+  constructor(platform, environment) {
+    __publicField(this, "ready", false);
+    __publicField(this, "environment");
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "disposables", new DisposableBag());
+    __publicField(this, "shell");
+    this.shell = createShellAPI(platform);
+    this.environment = {
+      platform,
+      ...environment
+    };
+    if (typeof window !== "undefined") {
+      const resizeHandler = () => this.notifyEnvironmentChanged();
+      window.addEventListener("resize", resizeHandler);
+      this.registerDisposable(() => window.removeEventListener("resize", resizeHandler));
+      if (platform !== "web") {
+        const cleanup = this.applyScrollGuards();
+        if (cleanup) {
+          this.registerDisposable(cleanup);
+        }
+      }
+    }
+  }
+  supports(_capability) {
+    return false;
+  }
+  get platform() {
+    return this.environment.platform;
+  }
+  async init(_options) {
+    this.ready = true;
+  }
+  isReady() {
+    return this.ready;
+  }
+  getEnvironment() {
+    return { ...this.environment };
+  }
+  destroy() {
+    try {
+      this.onDestroy();
+    } finally {
+      this.disposables.disposeAll();
+      this.listeners.clear();
+      this.ready = false;
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async setColors(colors) {
+    if (colors.background) {
+      document.body.style.backgroundColor = colors.background;
+    }
+    if (colors.header) {
+      const meta = document.querySelector('meta[name="theme-color"]');
+      if (meta) {
+        meta.setAttribute("content", colors.header);
+      }
+    }
+  }
+  onBackButton(callback) {
+    const handler = () => callback();
+    window.addEventListener("popstate", handler);
+    return () => window.removeEventListener("popstate", handler);
+  }
+  onPushToken(callback) {
+    return this.shell.onPushToken(callback);
+  }
+  onDeepLink(callback) {
+    return this.shell.onDeepLink(callback);
+  }
+  async openExternalLink(url) {
+    window.open(url, "_blank", "noopener,noreferrer");
+  }
+  async openInternalLink(_url) {
+  }
+  async closeApp() {
+    if (window.history.length > 1) {
+      window.history.back();
+    } else {
+      window.close();
+    }
+  }
+  setBackButtonVisibility(_visible) {
+  }
+  onAppearanceChange(callback) {
+    callback(this.environment.appearance);
+    return () => {
+    };
+  }
+  getInitData() {
+    return void 0;
+  }
+  getLaunchParams() {
+    return void 0;
+  }
+  decodeStartParam(_param) {
+    return void 0;
+  }
+  requestFullscreen() {
+  }
+  getViewportInsets() {
+    return void 0;
+  }
+  shareMessage(_message) {
+    return Promise.resolve();
+  }
+  shareUrl(_url, _text) {
+  }
+  async downloadFile(url, filename) {
+    await triggerFileDownload(url, filename);
+  }
+  shareStory(_mediaUrl, _options) {
+    return Promise.resolve();
+  }
+  trackConversionEvent(_event, _payload) {
+  }
+  trackPixelEvent(_event, _payload) {
+  }
+  copyTextToClipboard(text) {
+    return navigator.clipboard.writeText(text).catch(() => {
+      const textarea = document.createElement("textarea");
+      textarea.value = text;
+      textarea.style.position = "fixed";
+      document.body.appendChild(textarea);
+      textarea.focus();
+      textarea.select();
+      try {
+        document.execCommand("copy");
+      } catch {
+      }
+      document.body.removeChild(textarea);
+    });
+  }
+  computeSafeArea() {
+    const viewportInsets = this.getViewportInsets?.();
+    const cssSafeArea = readCssSafeArea();
+    return computeCombinedSafeArea({
+      environment: this.environment.safeArea,
+      viewport: viewportInsets,
+      css: cssSafeArea
+    });
+  }
+  bindCssVariables(_mapper) {
+  }
+  vibrateImpact(_style) {
+    navigator.vibrate?.(10);
+  }
+  vibrateNotification(_type) {
+    navigator.vibrate?.([10, 30, 10]);
+  }
+  vibrateSelection() {
+    navigator.vibrate?.(5);
+  }
+  onViewHide(_callback) {
+    return () => {
+    };
+  }
+  onViewRestore(_callback) {
+    return () => {
+    };
+  }
+  async showPopup(options) {
+    const message = [options.title, options.message].filter(Boolean).join("\n\n");
+    window.alert(message);
+    const firstButton = options.buttons?.[0];
+    return firstButton?.id ?? "ok";
+  }
+  async scanQRCode(_options) {
+    return null;
+  }
+  async requestPhone() {
+    return null;
+  }
+  async requestNotificationsPermission() {
+    return false;
+  }
+  enableVerticalSwipes() {
+  }
+  disableVerticalSwipes() {
+  }
+  notifyEnvironmentChanged() {
+    for (const listener of this.listeners) {
+      try {
+        listener();
+      } catch (error) {
+        console.warn("[tvm-app-adapter] environment listener failed:", error);
+      }
+    }
+  }
+  onDestroy() {
+  }
+  registerDisposable(disposable) {
+    return this.disposables.add(disposable);
+  }
+  applyScrollGuards() {
+    if (typeof document === "undefined") {
+      return void 0;
+    }
+    const html = document.documentElement;
+    const body = document.body;
+    if (!html || !body) {
+      return void 0;
+    }
+    const prevHtmlOverscroll = html.style.overscrollBehaviorY;
+    const prevBodyOverscroll = body.style.overscrollBehaviorY;
+    const prevBodyTouchAction = body.style.touchAction;
+    html.style.overscrollBehaviorY = "none";
+    body.style.overscrollBehaviorY = "none";
+    body.style.touchAction = "manipulation";
+    return () => {
+      html.style.overscrollBehaviorY = prevHtmlOverscroll;
+      body.style.overscrollBehaviorY = prevBodyOverscroll;
+      body.style.touchAction = prevBodyTouchAction;
+    };
+  }
+};
+
+// src/adapters/maxAdapter.ts
+function getMaxBridge() {
+  return window.WebApp;
+}
+var MaxMiniAppAdapter = class extends BaseMiniAppAdapter {
+  constructor() {
+    super("max");
+    __publicField(this, "backHandlers", /* @__PURE__ */ new Map());
+    __publicField(this, "initData");
+    __publicField(this, "initDataUnsafe");
+  }
+  async init(_options) {
+    if (this.ready) {
+      return;
+    }
+    const bridge2 = getMaxBridge();
+    bridge2?.ready?.();
+    this.initData = bridge2?.initData;
+    this.initDataUnsafe = bridge2?.initDataUnsafe;
+    const environment = {
+      platform: "max",
+      sdkVersion: bridge2?.version,
+      appVersion: bridge2?.version,
+      languageCode: bridge2?.initDataUnsafe?.user?.language_code,
+      isWebView: true
+    };
+    this.environment = environment;
+    this.ready = true;
+  }
+  supports(capability) {
+    const bridge2 = getMaxBridge();
+    switch (capability) {
+      case "haptics":
+        return Boolean(bridge2?.HapticFeedback?.impactOccurred);
+      case "qrScanner":
+        return typeof bridge2?.openCodeReader === "function";
+      case "closeApp":
+        return typeof bridge2?.close === "function";
+      case "backButton":
+        return Boolean(bridge2?.BackButton?.onClick);
+      case "backButtonVisibility":
+        return Boolean(bridge2?.BackButton?.show && bridge2.BackButton.hide);
+      case "requestPhone":
+        if (!bridge2) {
+          return false;
+        }
+        return typeof bridge2.requestPhoneNumber === "function" || typeof window !== "undefined";
+      case "popup":
+        return false;
+      default:
+        return false;
+    }
+  }
+  getInitData() {
+    return this.initData;
+  }
+  getLaunchParams() {
+    return this.initDataUnsafe ?? void 0;
+  }
+  onBackButton(callback) {
+    const bridge2 = getMaxBridge();
+    if (!bridge2?.BackButton?.onClick) {
+      return super.onBackButton(callback);
+    }
+    const wrapped = () => callback();
+    const disposer = bridge2.BackButton.onClick(wrapped);
+    bridge2.BackButton.show?.();
+    const removeFromBag = this.registerDisposable(() => {
+      if (typeof disposer === "function") {
+        disposer();
+      } else {
+        bridge2.BackButton?.offClick?.(wrapped);
+      }
+      this.backHandlers.delete(callback);
+      if (!this.backHandlers.size) {
+        bridge2.BackButton?.hide?.();
+      }
+    });
+    this.backHandlers.set(callback, removeFromBag);
+    return removeFromBag;
+  }
+  setBackButtonVisibility(visible) {
+    const bridge2 = getMaxBridge();
+    if (!bridge2?.BackButton) {
+      return;
+    }
+    visible ? bridge2.BackButton.show?.() : bridge2.BackButton.hide?.();
+  }
+  async openExternalLink(url) {
+    const bridge2 = getMaxBridge();
+    if (bridge2?.openExternalLink) {
+      bridge2.openExternalLink(url);
+      return;
+    }
+    await super.openExternalLink(url);
+  }
+  async closeApp() {
+    const bridge2 = getMaxBridge();
+    if (bridge2?.close) {
+      bridge2.close();
+      return;
+    }
+    await super.closeApp();
+  }
+  vibrateImpact(style) {
+    const bridge2 = getMaxBridge();
+    if (!bridge2?.HapticFeedback?.impactOccurred) {
+      super.vibrateImpact(style);
+      return;
+    }
+    void bridge2.HapticFeedback.impactOccurred(style).catch((error) => {
+      console.warn("[mini-app-template] MAX impact haptic failed:", error);
+    });
+  }
+  vibrateNotification(type) {
+    const bridge2 = getMaxBridge();
+    if (!bridge2?.HapticFeedback?.notificationOccurred) {
+      super.vibrateNotification(type);
+      return;
+    }
+    void bridge2.HapticFeedback.notificationOccurred(type).catch((error) => {
+      console.warn("[mini-app-template] MAX notification haptic failed:", error);
+    });
+  }
+  vibrateSelection() {
+    const bridge2 = getMaxBridge();
+    if (!bridge2?.HapticFeedback?.selectionChanged) {
+      super.vibrateSelection();
+      return;
+    }
+    void bridge2.HapticFeedback.selectionChanged().catch((error) => {
+      console.warn("[mini-app-template] MAX selection haptic failed:", error);
+    });
+  }
+  async scanQRCode(options) {
+    const bridge2 = getMaxBridge();
+    if (!bridge2?.openCodeReader) {
+      return super.scanQRCode(options);
+    }
+    try {
+      const result = await bridge2.openCodeReader(options?.closeOnCapture !== false);
+      return result?.value ?? null;
+    } catch (error) {
+      console.warn("[mini-app-template] MAX QR scanner failed:", error);
+      return null;
+    }
+  }
+  async requestPhone() {
+    const bridge2 = getMaxBridge();
+    if (bridge2?.requestPhoneNumber) {
+      try {
+        const response = await bridge2.requestPhoneNumber();
+        return this.extractPhone(response);
+      } catch (error) {
+        console.warn("[mini-app-template] MAX requestPhone failed:", error);
+        return null;
+      }
+    }
+    return this.requestPhoneViaEvent();
+  }
+  async showPopup(options) {
+    return super.showPopup(options);
+  }
+  async downloadFile(url, filename) {
+    const bridge2 = getMaxBridge();
+    if (bridge2?.downloadFile) {
+      try {
+        await bridge2.downloadFile(url, filename);
+        return;
+      } catch (error) {
+        console.warn("[mini-app-template] MAX downloadFile failed:", error);
+      }
+    }
+    await super.downloadFile(url, filename);
+  }
+  async requestPhoneViaEvent() {
+    if (typeof window === "undefined") {
+      return null;
+    }
+    let providedPromise;
+    const detail = {
+      providePromise: (promise) => {
+        providedPromise = promise;
+      }
+    };
+    window.dispatchEvent(new CustomEvent("WebAppRequestPhone", { detail }));
+    if (!providedPromise) {
+      console.warn("[mini-app-template] MAX requestPhone not handled: native promise missing");
+      return null;
+    }
+    try {
+      const result = await providedPromise;
+      return this.extractPhone(result);
+    } catch (error) {
+      console.warn("[mini-app-template] MAX requestPhone promise rejected:", error);
+      return null;
+    }
+  }
+  extractPhone(data) {
+    if (typeof data === "string") {
+      return data || null;
+    }
+    if (!data || typeof data !== "object") {
+      return null;
+    }
+    const directPhone = data.phone ?? data.phone_number ?? data.phoneNumber;
+    if (typeof directPhone === "string" && directPhone) {
+      return directPhone;
+    }
+    const contact = data.contact;
+    if (contact && typeof contact === "object") {
+      const nested = contact.phone ?? contact.phone_number ?? contact.phoneNumber;
+      if (typeof nested === "string" && nested) {
+        return nested;
+      }
+    }
+    return null;
+  }
+  onDestroy() {
+    this.backHandlers.clear();
+    super.onDestroy();
+  }
+};
+
+// src/adapters/shellAdapter.ts
+var ShellMiniAppAdapter = class extends BaseMiniAppAdapter {
+  constructor(platform) {
+    super(platform, {
+      isWebView: true,
+      hasNativeQR: true,
+      hasPush: true,
+      hasWidgets: true
+    });
+  }
+  supports(capability) {
+    switch (capability) {
+      case "qrScanner":
+        return true;
+      case "notifications":
+        return true;
+      default:
+        return super.supports(capability);
+    }
+  }
+  async scanQRCode() {
+    try {
+      const value = await this.shell.openNativeQR();
+      return value ?? null;
+    } catch (error) {
+      console.warn("[tvm-app-adapter] shell.openNativeQR failed:", error);
+      return null;
+    }
+  }
+  async requestNotificationsPermission() {
+    return requestShellPushPermission();
+  }
+};
+
+// src/adapters/telegramAdapter.ts
+var import_sdk_react = require("@tma.js/sdk-react");
+var import_sdk = require("@tma.js/sdk");
+
+// src/lib/features.ts
+function isFeatureAvailable(feature) {
+  if (typeof feature !== "function") {
+    return false;
+  }
+  const candidate = feature;
+  if (typeof candidate.isAvailable === "function") {
+    try {
+      return candidate.isAvailable();
+    } catch (error) {
+      console.warn("[tvm-app-adapter] feature availability check failed:", error);
+      return false;
+    }
+  }
+  return true;
+}
+function ensureFeature(feature, ...args) {
+  if (!isFeatureAvailable(feature)) {
+    return { ok: false };
+  }
+  try {
+    const value = feature(...args);
+    return { ok: true, value };
+  } catch (error) {
+    console.warn("[tvm-app-adapter] feature call failed:", error);
+    return { ok: false };
+  }
+}
+
+// src/lib/viewport.ts
+async function ensureViewportMounted(options) {
+  const { sdkViewport, fallbackMount } = options;
+  if (sdkViewport?.isSupported?.()) {
+    if (typeof sdkViewport.isMounted === "function" && sdkViewport.isMounted()) {
+      return;
+    }
+    if (typeof sdkViewport.mount === "function") {
+      await sdkViewport.mount();
+    }
+    return;
+  }
+  if (typeof fallbackMount === "function") {
+    await fallbackMount();
+  }
+}
+async function bindViewportCssVars(options) {
+  await ensureViewportMounted(options);
+  if (typeof options.bindCssVars !== "function") {
+    return;
+  }
+  try {
+    options.bindCssVars(options.mapper);
+  } catch (error) {
+    if (error instanceof Error && /css variables are already bound/i.test(error.message)) {
+      return;
+    }
+    throw error;
+  }
+}
+
+// src/adapters/telegramAdapter.ts
+var TelegramMiniAppAdapter = class extends BaseMiniAppAdapter {
+  constructor() {
+    super("telegram");
+    __publicField(this, "backHandlers", /* @__PURE__ */ new Map());
+    __publicField(this, "cssVariablesBound", false);
+    __publicField(this, "appearanceListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "appearanceWatcherDispose");
+    __publicField(this, "viewHideListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "viewRestoreListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "activeWatcherDispose");
+  }
+  async init(options) {
+    if (this.ready) {
+      return;
+    }
+    const debug = Boolean(options?.debug);
+    const eruda = Boolean(options?.eruda);
+    const mockForMacOS = Boolean(options?.mockForMacOS);
+    (0, import_sdk_react.setDebug)(debug);
+    (0, import_sdk_react.init)();
+    if (!import_sdk_react.miniApp.isSupported()) {
+      console.warn("[tvm-app-adapter] miniApp feature is not supported; falling back to limited mode.");
+    }
+    if (eruda) {
+      void import("eruda").then(({ default: erudaInstance }) => {
+        erudaInstance.init();
+        erudaInstance.position({ x: window.innerWidth - 150, y: window.innerHeight - 150 });
+      });
+    }
+    if (mockForMacOS) {
+      let firstThemeSent = false;
+      (0, import_sdk_react.mockTelegramEnv)({
+        onEvent(event, next) {
+          if (event.name === "web_app_request_theme") {
+            let tp = {};
+            if (firstThemeSent) {
+              tp = import_sdk_react.themeParams.state();
+            } else {
+              firstThemeSent = true;
+              tp || (tp = (0, import_sdk_react.retrieveLaunchParams)().tgWebAppThemeParams);
+            }
+            return (0, import_sdk_react.emitEvent)("theme_changed", { theme_params: tp });
+          }
+          if (event.name === "web_app_request_safe_area") {
+            return (0, import_sdk_react.emitEvent)("safe_area_changed", { left: 0, top: 0, right: 0, bottom: 0 });
+          }
+          next();
+        }
+      });
+    }
+    import_sdk_react.initData.restore();
+    import_sdk_react.miniApp.ready();
+    const launchParams = (0, import_sdk_react.retrieveLaunchParams)();
+    let appearance;
+    try {
+      appearance = import_sdk_react.miniApp.isDark() ? "dark" : "light";
+    } catch {
+      appearance = void 0;
+    }
+    const environment = {
+      platform: "telegram",
+      sdkVersion: launchParams.tgWebAppVersion,
+      languageCode: import_sdk_react.initData.user()?.language_code,
+      appearance,
+      isWebView: true
+    };
+    this.environment = environment;
+    this.notifyAppearance(environment.appearance);
+    import_sdk_react.backButton.mount.ifAvailable();
+    if (import_sdk_react.miniApp.mount.isAvailable()) {
+      import_sdk_react.themeParams.mount();
+      import_sdk_react.miniApp.mount();
+      this.bindCssVariables();
+    }
+    await this.prepareViewport();
+    this.setupAppearanceWatcher();
+    this.setupActiveWatcher();
+    this.ready = true;
+  }
+  async setColors(colors) {
+    const fallback = {};
+    if (colors.header) {
+      if (import_sdk_react.miniApp.setHeaderColor.isAvailable()) {
+        const headerColor = import_sdk_react.miniApp.setHeaderColor.supports?.("rgb") ? colors.header : "bg_color";
+        const { ok } = ensureFeature(import_sdk_react.miniApp.setHeaderColor, headerColor);
+        if (!ok) {
+          fallback.header = colors.header;
+        }
+      } else {
+        fallback.header = colors.header;
+      }
+    }
+    if (colors.background) {
+      if (import_sdk_react.miniApp.setBgColor.isAvailable()) {
+        const { ok } = ensureFeature(import_sdk_react.miniApp.setBgColor, colors.background);
+        if (!ok) {
+          fallback.background = colors.background;
+        }
+      } else {
+        fallback.background = colors.background;
+      }
+    }
+    if (colors.footer) {
+      if (import_sdk_react.miniApp.setBgColor.isAvailable()) {
+        const { ok } = ensureFeature(import_sdk_react.miniApp.setBottomBarColorFp, colors.footer);
+        if (!ok) {
+          fallback.footer = colors.footer;
+        }
+      } else {
+        fallback.footer = colors.footer;
+      }
+    }
+    if (fallback.header || fallback.background) {
+      await super.setColors(fallback);
+    }
+  }
+  copyTextToClipboard(text) {
+    return (0, import_sdk.copyTextToClipboard)(text);
+  }
+  onBackButton(callback) {
+    if (!import_sdk_react.backButton.isSupported()) {
+      return super.onBackButton(callback);
+    }
+    const dispose = import_sdk_react.backButton.onClick(() => callback());
+    const removeFromBag = this.registerDisposable(() => {
+      if (typeof dispose === "function") {
+        dispose();
+      }
+      this.backHandlers.delete(callback);
+      if (!this.backHandlers.size) {
+        import_sdk_react.backButton.hide();
+      }
+    });
+    this.backHandlers.set(callback, removeFromBag);
+    return removeFromBag;
+  }
+  async openExternalLink(url) {
+    try {
+      (0, import_sdk_react.openLink)(url, { tryInstantView: true });
+      return;
+    } catch {
+    }
+    await super.openExternalLink(url);
+  }
+  async openInternalLink(url) {
+    (0, import_sdk_react.postEvent)("web_app_open_tg_link", { path_full: url });
+  }
+  enableDebug(state) {
+    try {
+      state ? import_sdk.closingBehavior.enableConfirmation() : import_sdk.closingBehavior.disableConfirmation();
+    } catch {
+    }
+  }
+  supports(capability) {
+    switch (capability) {
+      case "haptics":
+        return isFeatureAvailable(import_sdk_react.hapticFeedback.selectionChanged);
+      case "popup":
+        return isFeatureAvailable(import_sdk_react.popup.show);
+      case "qrScanner":
+        return isFeatureAvailable(import_sdk_react.qrScanner.open);
+      case "closeApp":
+        return isFeatureAvailable(import_sdk_react.miniApp.close);
+      case "backButton":
+        return import_sdk_react.backButton.isSupported();
+      case "backButtonVisibility":
+        return import_sdk_react.backButton.hide.isSupported();
+      case "bindCssVariables":
+        return true;
+      case "requestPhone": {
+        return Boolean(isFeatureAvailable(import_sdk.requestPhoneAccess) || isFeatureAvailable(import_sdk.requestContact));
+      }
+      default:
+        return false;
+    }
+  }
+  bindCssVariables(mapper) {
+    if (this.cssVariablesBound) {
+      return;
+    }
+    try {
+      import_sdk_react.themeParams.bindCssVars(mapper);
+      this.cssVariablesBound = true;
+    } catch (error) {
+      if (error instanceof Error && /css variables are already bound/i.test(error.message)) {
+        this.cssVariablesBound = true;
+        return;
+      }
+      throw error;
+    }
+  }
+  vibrateImpact(style) {
+    if (this.supports("haptics")) {
+      import_sdk_react.hapticFeedback.impactOccurred(style);
+    }
+  }
+  vibrateNotification(type) {
+    if (this.supports("haptics")) {
+      import_sdk_react.hapticFeedback.notificationOccurred(type);
+    }
+  }
+  vibrateSelection() {
+    if (this.supports("haptics")) {
+      import_sdk_react.hapticFeedback.selectionChanged();
+    }
+  }
+  async showPopup(options) {
+    const popupResult = ensureFeature(import_sdk_react.popup.show, {
+      title: options.title,
+      message: options.message,
+      buttons: options.buttons?.map((button) => ({
+        id: button.id,
+        text: button.text ?? button.id,
+        type: button.type ?? "default"
+      }))
+    });
+    if (!popupResult.ok) {
+      return super.showPopup(options);
+    }
+    const response = await popupResult.value;
+    return response ?? null;
+  }
+  async scanQRCode(options) {
+    let result = null;
+    const closeOnCapture = options?.closeOnCapture ?? true;
+    const qrScannerResult = ensureFeature(import_sdk_react.qrScanner.open, {
+      onCaptured: (qr) => {
+        result = qr;
+        if (closeOnCapture) {
+          void ensureFeature(import_sdk_react.qrScanner.close);
+        }
+      }
+    });
+    if (!qrScannerResult.ok) {
+      return super.scanQRCode(options);
+    }
+    await qrScannerResult.value;
+    return result;
+  }
+  async closeApp() {
+    const closeResult = ensureFeature(import_sdk_react.miniApp.close);
+    if (closeResult.ok) {
+      return;
+    }
+    await super.closeApp();
+  }
+  getInitData() {
+    try {
+      return import_sdk_react.initData.raw();
+    } catch {
+      return void 0;
+    }
+  }
+  getLaunchParams() {
+    try {
+      return (0, import_sdk_react.retrieveLaunchParams)();
+    } catch {
+      return void 0;
+    }
+  }
+  decodeStartParam(param) {
+    try {
+      return (0, import_sdk.decodeStartParam)(param);
+    } catch {
+      return void 0;
+    }
+  }
+  requestFullscreen() {
+    void this.requestFullscreenInternal();
+  }
+  getViewportInsets() {
+    try {
+      const safeArea = import_sdk_react.viewport.safeAreaInsets();
+      const contentSafeArea = import_sdk_react.viewport.contentSafeAreaInsets();
+      return {
+        safeArea,
+        contentSafeArea
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  onAppearanceChange(callback) {
+    this.appearanceListeners.add(callback);
+    callback(this.environment.appearance);
+    return () => {
+      this.appearanceListeners.delete(callback);
+    };
+  }
+  setBackButtonVisibility(visible) {
+    if (!import_sdk_react.backButton.isSupported()) {
+      return;
+    }
+    if (visible) {
+      import_sdk_react.backButton.show();
+    } else {
+      import_sdk_react.backButton.hide();
+    }
+  }
+  enableVerticalSwipes() {
+    try {
+      const sdkSwipe = import_sdk.swipeBehavior;
+      if (typeof sdkSwipe.isSupported === "function" && sdkSwipe.isSupported()) {
+        if (typeof sdkSwipe.isMounted === "function" && !sdkSwipe.isMounted()) {
+          sdkSwipe.mount?.();
+        }
+        sdkSwipe.enableVertical?.();
+      } else if (import_sdk.swipeBehavior.enableVertical.isAvailable()) {
+        import_sdk.swipeBehavior.enableVertical();
+      }
+    } catch (error) {
+      console.warn("[tvm-app-adapter] enableVerticalSwipes failed:", error);
+    }
+  }
+  disableVerticalSwipes() {
+    try {
+      const sdkSwipe = import_sdk.swipeBehavior;
+      if (typeof sdkSwipe.isSupported === "function" && sdkSwipe.isSupported()) {
+        if (typeof sdkSwipe.isMounted === "function" && !sdkSwipe.isMounted()) {
+          sdkSwipe.mount?.();
+        }
+        sdkSwipe.disableVertical?.();
+      } else if (import_sdk.swipeBehavior.disableVertical.isAvailable()) {
+        import_sdk.swipeBehavior.disableVertical();
+      }
+    } catch (error) {
+      console.warn("[tvm-app-adapter] disableVerticalSwipes failed:", error);
+    }
+  }
+  onViewHide(callback) {
+    this.viewHideListeners.add(callback);
+    return () => {
+      this.viewHideListeners.delete(callback);
+    };
+  }
+  onViewRestore(callback) {
+    this.viewRestoreListeners.add(callback);
+    return () => {
+      this.viewRestoreListeners.delete(callback);
+    };
+  }
+  shareUrl(url, text) {
+    return (0, import_sdk.shareURL)(url, text);
+  }
+  async downloadFile(url, filename) {
+    const result = ensureFeature(import_sdk.downloadFile, url, filename);
+    if (result.ok) {
+      try {
+        await result.value;
+        return;
+      } catch (error) {
+        console.warn("[tvm-app-adapter] Telegram downloadFile failed:", error);
+      }
+    }
+    await super.downloadFile(url, filename);
+  }
+  async shareStory(mediaUrl, options) {
+    (0, import_sdk.shareStory)(mediaUrl, options);
+  }
+  async requestPhone() {
+    const contactFeature = ensureFeature(import_sdk.requestContact);
+    if (!contactFeature.ok) {
+      return super.requestPhone();
+    }
+    if (import_sdk.requestPhoneAccess) {
+      const accessFeature = ensureFeature(import_sdk.requestPhoneAccess);
+      if (accessFeature.ok) {
+        try {
+          await accessFeature.value;
+        } catch (error) {
+          console.warn("[tvm-app-adapter] Telegram requestPhone access failed:", error);
+        }
+      }
+    }
+    try {
+      const result = await contactFeature.value;
+      if (!result || typeof result !== "object") {
+        return null;
+      }
+      const contact = result.contact;
+      const phone = contact?.phoneNumber ?? contact?.phone_number ?? contact?.phone ?? result.phoneNumber ?? result.phone_number ?? result.phone;
+      return typeof phone === "string" && phone ? phone : null;
+    } catch (error) {
+      console.warn("[tvm-app-adapter] Telegram requestPhone failed:", error);
+      return null;
+    }
+  }
+  setupAppearanceWatcher() {
+    this.appearanceWatcherDispose?.();
+    if (typeof import_sdk_react.themeParams.isDark?.sub === "function") {
+      const disposer = import_sdk_react.themeParams.isDark.sub(() => {
+        const appearance = import_sdk_react.themeParams.isDark() ? "dark" : "light";
+        this.environment.appearance = appearance;
+        this.notifyAppearance(appearance);
+      });
+      this.appearanceWatcherDispose = this.registerDisposable(disposer);
+    }
+  }
+  notifyAppearance(appearance) {
+    for (const listener of this.appearanceListeners) {
+      listener(appearance);
+    }
+  }
+  setupActiveWatcher() {
+    this.activeWatcherDispose?.();
+    const activeSignal = import_sdk_react.miniApp.isActive;
+    const invoke = () => {
+      try {
+        const isActive = import_sdk_react.miniApp.isActive();
+        if (isActive) {
+          this.notifyViewRestore();
+        } else {
+          this.notifyViewHide();
+        }
+      } catch (error) {
+        console.warn("[tvm-app-adapter] miniApp.isActive() failed:", error);
+      }
+    };
+    if (typeof activeSignal?.sub === "function") {
+      const disposer = activeSignal.sub(() => invoke());
+      this.activeWatcherDispose = this.registerDisposable(disposer);
+      invoke();
+      return;
+    }
+    try {
+      invoke();
+    } catch {
+    }
+  }
+  async prepareViewport() {
+    try {
+      await bindViewportCssVars({
+        ...this.getViewportMountOptions(),
+        bindCssVars: typeof import_sdk_react.viewport.bindCssVars === "function" ? import_sdk_react.viewport.bindCssVars : void 0
+      });
+    } catch (error) {
+      console.warn("[tvm-app-adapter] prepareViewport failed:", error);
+    }
+  }
+  async requestFullscreenInternal() {
+    try {
+      const viewportOptions = this.getViewportMountOptions();
+      await ensureViewportMounted(viewportOptions);
+      const { sdkViewport } = viewportOptions;
+      const canUseRaw = typeof sdkViewport.isSupported === "function" ? sdkViewport.isSupported() : false;
+      if (canUseRaw && typeof sdkViewport.requestFullscreen === "function") {
+        await sdkViewport.requestFullscreen();
+      } else if (import_sdk_react.viewport.requestFullscreen && import_sdk_react.viewport.requestFullscreen.isAvailable?.()) {
+        await import_sdk_react.viewport.requestFullscreen();
+      } else {
+        (0, import_sdk_react.postEvent)("web_app_request_fullscreen");
+      }
+      this.disableVerticalSwipes();
+    } catch (error) {
+      console.warn("[tvm-app-adapter] Telegram requestFullscreen failed:", error);
+    }
+  }
+  getViewportMountOptions() {
+    const sdkViewport = import_sdk.viewport;
+    return {
+      sdkViewport,
+      fallbackMount: async () => {
+        if (import_sdk_react.viewport.mount?.isAvailable?.()) {
+          await import_sdk_react.viewport.mount();
+        }
+      }
+    };
+  }
+  notifyViewHide() {
+    for (const listener of this.viewHideListeners) {
+      try {
+        listener();
+      } catch (error) {
+        console.warn("[tvm-app-adapter] onViewHide listener failed:", error);
+      }
+    }
+  }
+  notifyViewRestore() {
+    for (const listener of this.viewRestoreListeners) {
+      try {
+        listener();
+      } catch (error) {
+        console.warn("[tvm-app-adapter] onViewRestore listener failed:", error);
+      }
+    }
+  }
+  onDestroy() {
+    this.appearanceWatcherDispose?.();
+    this.appearanceWatcherDispose = void 0;
+    this.activeWatcherDispose?.();
+    this.activeWatcherDispose = void 0;
+    this.appearanceListeners.clear();
+    this.viewHideListeners.clear();
+    this.viewRestoreListeners.clear();
+    this.backHandlers.clear();
+    super.onDestroy();
+  }
+};
+
+// src/adapters/vkAdapter.ts
+var import_vk_bridge = __toESM(require("@vkontakte/vk-bridge"), 1);
+
+// src/config/vkAnalytics.ts
+var pixelCode = null;
+function setVkPixelCode(next) {
+  if (typeof next !== "string") {
+    pixelCode = null;
+    return;
+  }
+  const normalized = next.trim();
+  pixelCode = normalized || null;
+}
+function getVkPixelCode() {
+  return pixelCode;
+}
+
+// src/lib/bridge.ts
+async function isBridgeMethodSupported(method, supportsAsync) {
+  if (typeof supportsAsync !== "function") {
+    return false;
+  }
+  try {
+    return await supportsAsync(method);
+  } catch (error) {
+    console.warn("[tvm-app-adapter] bridge.supportsAsync failed:", error);
+    return false;
+  }
+}
+
+// src/adapters/vkAdapter.ts
+var ANALYTICS_EVENT_NAME_PATTERN = /^[a-z0-9][a-z0-9_.:-]{0,63}$/i;
+var ANALYTICS_FALLBACK_EVENT = "VK_ANALYTICS_EVENT";
+var VKMiniAppAdapter = class extends BaseMiniAppAdapter {
+  constructor() {
+    super("vk");
+    __publicField(this, "configSafeArea");
+    __publicField(this, "stopViewportTracking");
+    __publicField(this, "supportsAsync", typeof import_vk_bridge.default.supportsAsync === "function" ? import_vk_bridge.default.supportsAsync.bind(import_vk_bridge.default) : void 0);
+    __publicField(this, "pixelCodeWarningShown", false);
+    __publicField(this, "unsubscribe");
+    __publicField(this, "launchParams");
+    __publicField(this, "queryParams");
+    __publicField(this, "viewHideListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "viewRestoreListeners", /* @__PURE__ */ new Set());
+  }
+  computeSafeArea() {
+    const baseSafeArea = this.computeBaseSafeArea();
+    const overlayInsets = this.resolveOverlayInsets();
+    if (overlayInsets) {
+      return computeCombinedSafeArea({
+        environment: baseSafeArea,
+        minimum: overlayInsets
+      });
+    }
+    return baseSafeArea;
+  }
+  async init(_options) {
+    if (this.ready) {
+      return;
+    }
+    const handler = (event) => this.handleBridgeEvent(event);
+    import_vk_bridge.default.subscribe(handler);
+    this.unsubscribe = this.registerDisposable(() => import_vk_bridge.default.unsubscribe(handler));
+    let initialConfig;
+    try {
+      initialConfig = await import_vk_bridge.default.send("VKWebAppGetConfig");
+    } catch (error) {
+      console.warn("[tvm-app-adapter] VKWebAppGetConfig failed:", error);
+    }
+    try {
+      const initResult = await import_vk_bridge.default.send("VKWebAppInit");
+      if (initResult && "result" in initResult && initResult.result === false) {
+        console.warn("[tvm-app-adapter] VKWebAppInit returned result=false.");
+      }
+    } catch (error) {
+      console.error("[tvm-app-adapter] VKWebAppInit failed:", error);
+      this.unsubscribe?.();
+      this.unsubscribe = void 0;
+      throw error;
+    }
+    let launchParams;
+    try {
+      launchParams = await import_vk_bridge.default.send("VKWebAppGetLaunchParams");
+    } catch (error) {
+      console.error("[tvm-app-adapter] VKWebAppGetLaunchParams failed:", error);
+      this.unsubscribe?.();
+      this.unsubscribe = void 0;
+      throw error;
+    }
+    const search = typeof window !== "undefined" ? window.location.search : "";
+    const queryParams = (0, import_vk_bridge.parseURLSearchParamsForGetLaunchParams)(search);
+    this.launchParams = launchParams;
+    this.queryParams = queryParams;
+    this.environment = this.composeEnvironment(launchParams, queryParams, initialConfig);
+    this.configSafeArea = this.environment.safeArea;
+    const combinedSafeArea = this.computeSafeArea();
+    this.environment.safeArea = combinedSafeArea;
+    this.applyAppearance(this.environment.appearance, initialConfig?.scheme);
+    this.notifyEnvironmentChanged();
+    this.ready = true;
+    this.startViewportTracking();
+  }
+  async vibrateImpact(style) {
+    if (await this.supportsBridgeMethod("VKWebAppTapticImpactOccurred")) {
+      import_vk_bridge.default.send("VKWebAppTapticImpactOccurred", { style });
+    }
+  }
+  async vibrateNotification(type) {
+    if (await this.supportsBridgeMethod("VKWebAppTapticNotificationOccurred")) {
+      import_vk_bridge.default.send("VKWebAppTapticNotificationOccurred", { type });
+    }
+  }
+  async vibrateSelection() {
+    if (await this.supportsBridgeMethod("VKWebAppTapticSelectionChanged")) {
+      import_vk_bridge.default.send("VKWebAppTapticSelectionChanged");
+    }
+  }
+  async setColors(colors) {
+    const { header, background } = colors;
+    if (header || background) {
+      const canApplyViewSettings = await this.supportsBridgeMethod("VKWebAppSetViewSettings");
+      if (canApplyViewSettings) {
+        const statusBarStyle = header ? this.resolveStatusBarStyle(header) : this.environment.appearance?.includes("dark") ? "light" : "dark";
+        await import_vk_bridge.default.send("VKWebAppSetViewSettings", {
+          status_bar_style: statusBarStyle,
+          ...header ? { action_bar_color: header } : {},
+          ...background ? { navigation_bar_color: background } : {}
+        });
+      }
+    }
+    await super.setColors(colors);
+  }
+  getEnvironment() {
+    return {
+      ...this.environment,
+      isWebView: import_vk_bridge.default.isWebView()
+    };
+  }
+  getLaunchParams() {
+    if (!this.launchParams) {
+      return void 0;
+    }
+    return {
+      launchParams: this.launchParams,
+      queryParams: this.queryParams
+    };
+  }
+  async supports(capability) {
+    if (capability === "requestPhone") {
+      const [supportsPhoneNumber, supportsPersonalCard] = await Promise.all([
+        this.supportsBridgeMethod("VKWebAppGetPhoneNumber"),
+        this.supportsBridgeMethod("VKWebAppGetPersonalCard")
+      ]);
+      return supportsPhoneNumber || supportsPersonalCard;
+    }
+    if (capability === "notifications") {
+      return this.supportsBridgeMethod("VKWebAppAllowNotifications");
+    }
+    return await super.supports(capability);
+  }
+  async requestPhone() {
+    const [supportsPhoneNumber, supportsPersonalCard] = await Promise.all([
+      this.supportsBridgeMethod("VKWebAppGetPhoneNumber"),
+      this.supportsBridgeMethod("VKWebAppGetPersonalCard")
+    ]);
+    if (!supportsPhoneNumber && !supportsPersonalCard) {
+      return super.requestPhone();
+    }
+    try {
+      if (supportsPhoneNumber) {
+        const result = await import_vk_bridge.default.send("VKWebAppGetPhoneNumber");
+        const phoneNumber = result.phone_number;
+        return typeof phoneNumber === "string" && phoneNumber ? phoneNumber : null;
+      }
+      const card = await import_vk_bridge.default.send("VKWebAppGetPersonalCard", { type: ["phone"] });
+      const phone = card.phone;
+      return typeof phone === "string" && phone ? phone : null;
+    } catch (error) {
+      console.warn("[tvm-app-adapter] VK requestPhone failed:", error);
+      return null;
+    }
+  }
+  async requestNotificationsPermission() {
+    const supported = await this.supportsBridgeMethod("VKWebAppAllowNotifications");
+    if (!supported) {
+      return super.requestNotificationsPermission();
+    }
+    try {
+      const response = await import_vk_bridge.default.send("VKWebAppAllowNotifications");
+      if (response && typeof response === "object" && "result" in response) {
+        return Boolean(response.result);
+      }
+      return true;
+    } catch (error) {
+      console.warn("[tvm-app-adapter] VK allow notifications failed:", error);
+      return false;
+    }
+  }
+  async scanQRCode(options) {
+    const supportsQrScanner = await this.supportsBridgeMethod("VKWebAppOpenCodeReader");
+    if (!supportsQrScanner) {
+      return super.scanQRCode(options);
+    }
+    let result = null;
+    try {
+      const data = await import_vk_bridge.default.send("VKWebAppOpenCodeReader");
+      if (data.code_data) {
+        result = data.code_data;
+      }
+    } catch (error) {
+      console.log(error);
+    }
+    return result;
+  }
+  onViewHide(callback) {
+    this.viewHideListeners.add(callback);
+    return () => {
+      this.viewHideListeners.delete(callback);
+    };
+  }
+  onViewRestore(callback) {
+    this.viewRestoreListeners.add(callback);
+    return () => {
+      this.viewRestoreListeners.delete(callback);
+    };
+  }
+  async shareStory(mediaUrl, _options) {
+    const bridgeOptions = {
+      background_type: "image",
+      url: mediaUrl
+    };
+    await import_vk_bridge.default.send("VKWebAppShowStoryBox", bridgeOptions);
+  }
+  async downloadFile(url, filename) {
+    const supported = await this.supportsBridgeMethod("VKWebAppDownloadFile");
+    if (!supported) {
+      await super.downloadFile(url, filename);
+      return;
+    }
+    try {
+      const response = await import_vk_bridge.default.send("VKWebAppDownloadFile", { url, filename });
+      const result = response?.result;
+      if (result === false) {
+        throw new Error("VKWebAppDownloadFile returned result=false");
+      }
+    } catch (error) {
+      console.warn("[tvm-app-adapter] VK downloadFile failed:", error);
+      await super.downloadFile(url, filename);
+    }
+  }
+  trackConversionEvent(event, payload) {
+    const normalizedEvent = this.normalizeAnalyticsEventName(event);
+    if (!normalizedEvent) {
+      return;
+    }
+    const envelope = {
+      method: "VKWebAppConversionHit",
+      params: {
+        event: normalizedEvent,
+        params: this.normalizeAnalyticsPayload(payload)
+      }
+    };
+    this.dispatchAnalytics(envelope);
+  }
+  trackPixelEvent(event, payload) {
+    const pixelCode2 = getVkPixelCode();
+    if (!pixelCode2) {
+      if (!this.pixelCodeWarningShown) {
+        console.warn("[VKAnalytics] VK pixel code is not configured. Call configureVkPixel() before tracking.");
+        this.pixelCodeWarningShown = true;
+      }
+      return;
+    }
+    const normalizedEvent = this.normalizeAnalyticsEventName(event);
+    if (!normalizedEvent) {
+      return;
+    }
+    const envelope = {
+      method: "VKWebAppRetargetingPixel",
+      params: {
+        pixel_code: pixelCode2,
+        type: normalizedEvent,
+        data: this.normalizeAnalyticsPayload(payload)
+      }
+    };
+    this.pixelCodeWarningShown = false;
+    this.dispatchAnalytics(envelope);
+  }
+  dispatchAnalytics(envelope) {
+    if (typeof import_vk_bridge.default.isWebView === "function") {
+      try {
+        if (!import_vk_bridge.default.isWebView()) {
+          this.emitAnalyticsFallback(envelope);
+          return;
+        }
+      } catch (error) {
+        console.warn("[VKAnalytics] bridge.isWebView check failed:", error);
+        this.emitAnalyticsFallback(envelope);
+        return;
+      }
+    }
+    void this.safeBridgeSend(envelope.method, envelope.params);
+  }
+  emitAnalyticsFallback(envelope) {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const detail = {
+      ...envelope,
+      timestamp: Date.now()
+    };
+    if (typeof window.dispatchEvent === "function" && typeof window.CustomEvent === "function") {
+      window.dispatchEvent(new CustomEvent(ANALYTICS_FALLBACK_EVENT, { detail }));
+      return;
+    }
+    try {
+      window.postMessage({ type: ANALYTICS_FALLBACK_EVENT, detail }, "*");
+    } catch (error) {
+      console.warn("[VKAnalytics] fallback dispatch failed", error);
+    }
+  }
+  normalizeAnalyticsEventName(event) {
+    if (typeof event !== "string") {
+      return null;
+    }
+    const trimmed = event.trim();
+    if (!trimmed || !ANALYTICS_EVENT_NAME_PATTERN.test(trimmed)) {
+      console.warn(`[VKAnalytics] Invalid event name: "${event}"`);
+      return null;
+    }
+    return trimmed;
+  }
+  normalizeAnalyticsPayload(payload) {
+    if (!this.isPlainObject(payload)) {
+      return {};
+    }
+    return { ...payload };
+  }
+  isPlainObject(value) {
+    if (value === null || typeof value !== "object") {
+      return false;
+    }
+    if (Array.isArray(value)) {
+      return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+  }
+  async safeBridgeSend(method, params) {
+    try {
+      const supported = await this.supportsBridgeMethod(method);
+      if (!supported) {
+        return;
+      }
+      await import_vk_bridge.default.send(method, params);
+    } catch (error) {
+      console.warn(`[VKAnalytics] ${method} failed`, error);
+    }
+  }
+  composeEnvironment(launchParams, queryParams, config) {
+    const language = queryParams.vk_language ?? launchParams.vk_language;
+    const platform = queryParams.vk_platform ?? launchParams.vk_platform;
+    const appId = queryParams.vk_app_id ?? launchParams.vk_app_id;
+    const prefersDark = typeof window !== "undefined" && typeof window.matchMedia === "function" ? window.matchMedia("(prefers-color-scheme: dark)").matches : false;
+    const appearance = this.normalizeAppearance(config?.appearance, config?.scheme) ?? (prefersDark ? "dark" : "light");
+    const configSafeArea = this.extractSafeAreaFromConfig(config);
+    return {
+      platform: "vk",
+      sdkVersion: platform ? String(platform) : void 0,
+      appVersion: typeof appId === "number" ? `vk-app-${appId}` : void 0,
+      languageCode: language ? String(language) : void 0,
+      appearance,
+      isWebView: import_vk_bridge.default.isWebView(),
+      safeArea: configSafeArea
+    };
+  }
+  handleBridgeEvent(event) {
+    const { type, data } = event.detail ?? {};
+    if (type === "VKWebAppViewHide") {
+      this.notifyVisibilityListeners(this.viewHideListeners);
+      return;
+    }
+    if (type === "VKWebAppViewRestore") {
+      this.notifyVisibilityListeners(this.viewRestoreListeners);
+      return;
+    }
+    if (type === "VKWebAppUpdateConfig" && data) {
+      const config = data;
+      this.updateEnvironmentFromConfig(config);
+    }
+  }
+  updateEnvironmentFromConfig(config) {
+    if (!this.environment) {
+      return;
+    }
+    const nextAppearance = this.normalizeAppearance(config.appearance, config.scheme);
+    let changed = false;
+    if (nextAppearance && nextAppearance !== this.environment.appearance) {
+      this.environment.appearance = nextAppearance;
+      changed = true;
+    }
+    const prevSafeArea = this.environment.safeArea;
+    const nextSafeArea = this.extractSafeAreaFromConfig(config);
+    if (nextSafeArea) {
+      this.configSafeArea = nextSafeArea;
+      this.environment.safeArea = nextSafeArea;
+    } else {
+      this.configSafeArea = void 0;
+      this.environment.safeArea = void 0;
+    }
+    const combinedSafeArea = this.computeSafeArea() ?? {
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0
+    };
+    const prevForComparison = prevSafeArea;
+    const safeAreaChanged = !prevForComparison || prevForComparison.top !== combinedSafeArea.top || prevForComparison.right !== combinedSafeArea.right || prevForComparison.bottom !== combinedSafeArea.bottom || prevForComparison.left !== combinedSafeArea.left;
+    if (safeAreaChanged) {
+      this.environment.safeArea = combinedSafeArea;
+      changed = true;
+    } else {
+      this.environment.safeArea = prevSafeArea;
+    }
+    this.applyAppearance(this.environment.appearance, config.scheme);
+    if (changed) {
+      this.notifyEnvironmentChanged();
+    }
+  }
+  applyAppearance(appearance, scheme) {
+    if (typeof document === "undefined") {
+      return;
+    }
+    if (appearance) {
+      document.documentElement.dataset.vkAppearance = appearance;
+      document.documentElement.classList.toggle("dark", appearance === "dark");
+    }
+    if (scheme) {
+      document.documentElement.dataset.vkScheme = scheme;
+      if (!appearance) {
+        const normalized = this.normalizeAppearance(void 0, scheme);
+        document.documentElement.classList.toggle("dark", normalized === "dark");
+      }
+    }
+  }
+  resolveStatusBarStyle(color) {
+    const hex = color.replace("#", "");
+    const normalized = hex.length === 3 ? hex.split("").map((symbol) => symbol + symbol).join("") : hex.slice(0, 6);
+    const r = parseInt(normalized.slice(0, 2), 16) / 255;
+    const g = parseInt(normalized.slice(2, 4), 16) / 255;
+    const b = parseInt(normalized.slice(4, 6), 16) / 255;
+    const luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    return luminance > 0.6 ? "dark" : "light";
+  }
+  normalizeAppearance(rawAppearance, scheme) {
+    const normalized = rawAppearance?.toLowerCase();
+    if (normalized === "dark" || normalized === "light") {
+      return normalized;
+    }
+    const normalizedScheme = scheme?.toLowerCase();
+    if (normalizedScheme) {
+      if (normalizedScheme.includes("dark") || normalizedScheme.includes("space_gray")) {
+        return "dark";
+      }
+      return "light";
+    }
+    return void 0;
+  }
+  extractSafeAreaFromConfig(config) {
+    const rawInsets = config && "insets" in config ? config.insets : void 0;
+    if (!rawInsets) {
+      return void 0;
+    }
+    const { top = 0, right = 0, bottom = 0, left = 0 } = rawInsets;
+    const values = [top, right, bottom, left].map((value) => typeof value === "number" ? value : Number(value) || 0);
+    const hasInsets = values.some((value) => value !== 0);
+    if (!hasInsets) {
+      return void 0;
+    }
+    const [nTop, nRight, nBottom, nLeft] = values;
+    return { top: nTop, right: nRight, bottom: nBottom, left: nLeft };
+  }
+  notifyVisibilityListeners(listeners) {
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch (error) {
+        console.warn("[tvm-app-adapter] VK visibility listener failed:", error);
+      }
+    }
+  }
+  computeBaseSafeArea() {
+    return computeCombinedSafeArea({
+      environment: this.configSafeArea,
+      viewport: this.getViewportInsets?.(),
+      css: readCssSafeArea()
+    });
+  }
+  startViewportTracking() {
+    this.stopViewportTracking?.();
+    const dispose = createSafeAreaWatcher({
+      getSafeArea: () => this.computeSafeArea(),
+      onChange: (next) => {
+        this.environment.safeArea = next;
+        this.notifyEnvironmentChanged();
+      }
+    });
+    if (dispose) {
+      this.stopViewportTracking = this.registerDisposable(dispose);
+    }
+  }
+  resolveOverlayInsets() {
+    if (typeof window === "undefined") {
+      return void 0;
+    }
+    if (!import_vk_bridge.default.isWebView()) {
+      return void 0;
+    }
+    if (!this.isLikelyMobilePlatform()) {
+      return void 0;
+    }
+    const viewportWidth = window.innerWidth || document.documentElement?.clientWidth || 0;
+    if (!viewportWidth) {
+      return void 0;
+    }
+    const overlayBreakpoint = 880;
+    if (viewportWidth > overlayBreakpoint) {
+      return void 0;
+    }
+    const orientationQuery = window.matchMedia?.("(orientation: landscape)");
+    const isLandscape = Boolean(orientationQuery?.matches);
+    const top = isLandscape ? 48 : 56;
+    const right = isLandscape ? 72 : 88;
+    return { top, right };
+  }
+  isLikelyMobilePlatform() {
+    const platform = (this.resolveLaunchParam("vk_platform") ?? "").toLowerCase();
+    const device = (this.resolveLaunchParam("vk_viewer_device") ?? "").toLowerCase();
+    const isLayer = this.resolveLaunchParam("vk_is_layer") === "1";
+    if (isLayer) {
+      return false;
+    }
+    const mobilePattern = /(iphone|ipad|ios|android|mobile)/i;
+    const desktopPattern = /(desktop|web|tablet)/i;
+    const matchesMobilePlatform = mobilePattern.test(platform) || mobilePattern.test(device);
+    const matchesDesktopPlatform = desktopPattern.test(platform) || desktopPattern.test(device);
+    if (!matchesMobilePlatform) {
+      return false;
+    }
+    return !matchesDesktopPlatform;
+  }
+  resolveLaunchParam(key) {
+    const queryValue = this.queryParams?.[key];
+    if (typeof queryValue === "string" && queryValue) {
+      return queryValue;
+    }
+    const launchValue = this.launchParams ? this.launchParams[key] : void 0;
+    if (typeof launchValue === "string" && launchValue) {
+      return launchValue;
+    }
+    if (typeof launchValue === "number") {
+      return String(launchValue);
+    }
+    if (typeof launchValue === "boolean") {
+      return launchValue ? "1" : "0";
+    }
+    return void 0;
+  }
+  supportsBridgeMethod(method) {
+    return isBridgeMethodSupported(method, this.supportsAsync);
+  }
+  onDestroy() {
+    this.unsubscribe?.();
+    this.unsubscribe = void 0;
+    this.stopViewportTracking?.();
+    this.stopViewportTracking = void 0;
+    this.viewHideListeners.clear();
+    this.viewRestoreListeners.clear();
+    super.onDestroy();
+  }
+};
+
+// src/adapters/webAdapter.ts
+var import_html5_qrcode = require("html5-qrcode");
+var WebMiniAppAdapter = class extends BaseMiniAppAdapter {
+  constructor() {
+    super("web", {
+      sdkVersion: navigator.userAgent,
+      languageCode: navigator.language,
+      isWebView: false
+    });
+  }
+  async downloadFile(url, filename) {
+    try {
+      await triggerFileDownload(url, filename, { preferBlob: true });
+    } catch (error) {
+      console.warn("[mini-app-template] Web downloadFile fallback:", error);
+      await super.downloadFile(url, filename);
+    }
+  }
+  scanQRCode(_options) {
+    return new Promise(async (resolve) => {
+      if (typeof document === "undefined") {
+        resolve(null);
+        return;
+      }
+      const prevOverflow = document.body.style.overflow;
+      const prevPos = document.body.style.position;
+      const prevTouch = document.body.style.touchAction;
+      const prevWidth = document.body.style.width;
+      const prevHtmlOverflow = document.documentElement.style.overflow;
+      document.body.style.overflow = "hidden";
+      document.body.style.position = "fixed";
+      document.body.style.width = "100%";
+      document.body.style.touchAction = "none";
+      document.documentElement.style.overflow = "hidden";
+      const overlay = document.createElement("div");
+      overlay.id = "qr-overlay";
+      overlay.style.position = "fixed";
+      overlay.style.top = "0";
+      overlay.style.left = "0";
+      overlay.style.right = "0";
+      overlay.style.bottom = "0";
+      overlay.style.zIndex = "999999999";
+      overlay.style.background = "rgba(0,0,0,0.92)";
+      overlay.style.width = "100%";
+      overlay.style.height = "100%";
+      overlay.style.display = "flex";
+      overlay.style.flexDirection = "column";
+      overlay.style.alignItems = "center";
+      overlay.style.justifyContent = "center";
+      overlay.style.overflow = "hidden";
+      overlay.style.backdropFilter = "blur(3px)";
+      document.body.appendChild(overlay);
+      const closeBtn = document.createElement("button");
+      closeBtn.innerText = "\u2715";
+      closeBtn.style.position = "absolute";
+      closeBtn.style.top = "22px";
+      closeBtn.style.right = "22px";
+      closeBtn.style.fontSize = "32px";
+      closeBtn.style.color = "white";
+      closeBtn.style.background = "transparent";
+      closeBtn.style.border = "none";
+      closeBtn.style.cursor = "pointer";
+      closeBtn.style.zIndex = "9999999999";
+      overlay.appendChild(closeBtn);
+      const scanArea = document.createElement("div");
+      scanArea.id = "qr-reader";
+      scanArea.style.width = "300px";
+      scanArea.style.height = "300px";
+      scanArea.style.borderRadius = "18px";
+      scanArea.style.overflow = "hidden";
+      scanArea.style.position = "relative";
+      overlay.appendChild(scanArea);
+      const frame = document.createElement("div");
+      frame.style.position = "absolute";
+      frame.style.top = "0";
+      frame.style.left = "0";
+      frame.style.right = "0";
+      frame.style.bottom = "0";
+      frame.style.border = "3px solid rgba(255,255,255,0.9)";
+      frame.style.borderRadius = "18px";
+      frame.style.pointerEvents = "none";
+      frame.style.zIndex = "10";
+      scanArea.appendChild(frame);
+      const line = document.createElement("div");
+      line.style.position = "absolute";
+      line.style.left = "0";
+      line.style.right = "0";
+      line.style.height = "2px";
+      line.style.background = "rgba(255,255,255,0.85)";
+      line.style.borderRadius = "2px";
+      line.style.animation = "qr-line 2s infinite";
+      line.style.zIndex = "11";
+      scanArea.appendChild(line);
+      const styleTag = document.createElement("style");
+      styleTag.innerHTML = `
+        @keyframes qr-line {
+          0% { top: 0; }
+          50% { top: calc(100% - 2px); }
+          100% { top: 0; }
+        }
+      `;
+      document.head.appendChild(styleTag);
+      const hint = document.createElement("div");
+      hint.innerText = "\u041D\u0430\u0432\u0435\u0434\u0438\u0442\u0435 \u043A\u0430\u043C\u0435\u0440\u0443 \u043D\u0430 QR-\u043A\u043E\u0434";
+      hint.style.color = "white";
+      hint.style.marginTop = "30px";
+      hint.style.fontSize = "17px";
+      hint.style.opacity = "0.9";
+      overlay.appendChild(hint);
+      const scanner = new import_html5_qrcode.Html5Qrcode("qr-reader");
+      let closed = false;
+      const finalize = async (result) => {
+        if (closed) {
+          return;
+        }
+        closed = true;
+        try {
+          await scanner.stop();
+        } catch {
+        }
+        overlay.remove();
+        styleTag.remove();
+        document.body.style.overflow = prevOverflow;
+        document.body.style.position = prevPos;
+        document.body.style.width = prevWidth;
+        document.body.style.touchAction = prevTouch;
+        document.documentElement.style.overflow = prevHtmlOverflow;
+        resolve(result);
+      };
+      const removeFromBag = this.registerDisposable(() => {
+        void finalize(null);
+      });
+      const closeScanner = (result) => {
+        void finalize(result);
+        removeFromBag();
+      };
+      closeBtn.onclick = () => closeScanner(null);
+      try {
+        await scanner.start(
+          { facingMode: "environment" },
+          {
+            fps: 10,
+            qrbox: { width: 250, height: 250 },
+            aspectRatio: 1
+          },
+          (decodedText) => {
+            closeScanner(decodedText);
+          },
+          () => {
+          }
+        );
+      } catch (error) {
+        console.error("QR Start error", error);
+        closeScanner(null);
+      }
+    });
+  }
+};
+
+// src/adapters/index.ts
+function detectPlatform() {
+  if (typeof window === "undefined") {
+    return "web";
+  }
+  const searchParams = new URLSearchParams(window.location.search);
+  const hashParams = (() => {
+    const hash = window.location.hash.startsWith("#") ? window.location.hash.slice(1) : window.location.hash;
+    return new URLSearchParams(hash);
+  })();
+  const getParam = (name) => searchParams.get(name) ?? hashParams.get(name);
+  const hasParam = (...names) => names.some((name) => getParam(name));
+  const shellPlatform = readShellPlatform();
+  if (shellPlatform) {
+    return shellPlatform;
+  }
+  const userAgent = navigator.userAgent.toLowerCase();
+  const hasNativeBridge = typeof window.NativeBridge?.postMessage === "function";
+  if (hasNativeBridge) {
+    if (userAgent.includes("android")) {
+      return "shell_android";
+    }
+    return "shell_ios";
+  }
+  if (window.Telegram?.WebApp || hasParam("tgWebAppPlatform", "tgWebAppVersion", "tgWebAppData", "tgWebAppLanguage") || userAgent.includes("telegram")) {
+    return "telegram";
+  }
+  if (window.WebApp) {
+    return "max";
+  }
+  if (window.MaxMiniApp) {
+    return "max";
+  }
+  if (hasParam("vk_app_id", "vk_platform")) {
+    return "vk";
+  }
+  return "web";
+}
+function createAdapter(input) {
+  const options = normalizeCreateAdapterOptions(input);
+  const platform = options.platform ?? detectPlatform();
+  if (platform === "vk") {
+    setVkPixelCode(options.vk?.pixelCode ?? null);
+  }
+  switch (platform) {
+    case "shell_ios":
+    case "shell_android":
+      return new ShellMiniAppAdapter(platform);
+    case "telegram":
+      return new TelegramMiniAppAdapter();
+    case "vk":
+      return new VKMiniAppAdapter();
+    case "max":
+      return new MaxMiniAppAdapter();
+    default:
+      return new WebMiniAppAdapter();
+  }
+}
+function normalizeCreateAdapterOptions(input) {
+  if (!input) {
+    return {};
+  }
+  if (typeof input === "string") {
+    return { platform: input };
+  }
+  return input;
+}
+
+// src/components/AdapterProvider.tsx
+var import_react = require("react");
+
+// src/registry.ts
+var currentAdapter = null;
+function setActiveAdapter(adapter) {
+  currentAdapter = adapter;
+}
+function getActiveAdapter() {
+  return currentAdapter;
+}
+
+// src/components/AdapterProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var AdapterContext = (0, import_react.createContext)(null);
+function AdapterProvider({ adapter, children }) {
+  const proxiedAdapter = (0, import_react.useMemo)(() => {
+    return new Proxy(adapter, {
+      get(target, prop, receiver) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+    });
+  }, [adapter]);
+  (0, import_react.useEffect)(() => {
+    setActiveAdapter(proxiedAdapter);
+    return () => {
+      setActiveAdapter(null);
+      if (typeof proxiedAdapter.destroy === "function") {
+        try {
+          proxiedAdapter.destroy();
+        } catch (error) {
+          console.warn("[tvm-app-adapter] adapter destroy failed:", error);
+        }
+      }
+    };
+  }, [proxiedAdapter]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AdapterContext.Provider, { value: proxiedAdapter, children });
+}
+function useMiniAppAdapter() {
+  const adapter = (0, import_react.useContext)(AdapterContext);
+  if (!adapter) {
+    throw new Error("useMiniAppAdapter must be used inside <AdapterProvider/>.");
+  }
+  return adapter;
+}
+
+// src/hooks/useAdapterTheme.ts
+var import_react2 = require("react");
+var STORAGE_KEY = "loyalka-theme-preference";
+function useAdapterTheme() {
+  const adapter = useMiniAppAdapter();
+  const [systemPrefersDark, setSystemPrefersDark] = (0, import_react2.useState)(() => {
+    const { appearance: appearance2 } = adapter.getEnvironment();
+    if (adapter.onAppearanceChange && appearance2) {
+      return appearance2 === "dark";
+    }
+    if (typeof window !== "undefined" && window.matchMedia) {
+      return window.matchMedia("(prefers-color-scheme: dark)").matches;
+    }
+    return false;
+  });
+  const [preference, setPreferenceState] = (0, import_react2.useState)(() => {
+    try {
+      const saved = localStorage.getItem(STORAGE_KEY);
+      if (saved === "light" || saved === "dark" || saved === "system") return saved;
+    } catch {
+    }
+    return "system";
+  });
+  (0, import_react2.useEffect)(() => {
+    if (adapter.onAppearanceChange) {
+      return adapter.onAppearanceChange((appearance2) => {
+        if (appearance2) {
+          setSystemPrefersDark(appearance2 === "dark");
+        }
+      });
+    }
+    if (typeof window !== "undefined" && window.matchMedia) {
+      const media = window.matchMedia("(prefers-color-scheme: dark)");
+      const handleChange = (event) => setSystemPrefersDark(event.matches);
+      media.addEventListener("change", handleChange);
+      return () => media.removeEventListener("change", handleChange);
+    }
+    return void 0;
+  }, [adapter]);
+  const isDark = (0, import_react2.useMemo)(() => {
+    if (preference === "dark" || preference === "system" && systemPrefersDark) {
+      return true;
+    }
+    return false;
+  }, [preference, systemPrefersDark]);
+  const appearance = isDark ? "dark" : "light";
+  (0, import_react2.useEffect)(() => {
+    const root = document.documentElement;
+    if (isDark) {
+      root.classList.add("dark");
+    } else {
+      root.classList.remove("dark");
+    }
+  }, [isDark]);
+  const setPreference = (0, import_react2.useCallback)((pref) => {
+    setPreferenceState(pref);
+    try {
+      localStorage.setItem(STORAGE_KEY, pref);
+    } catch {
+    }
+  }, []);
+  const toggle = (0, import_react2.useCallback)(() => {
+    document.documentElement.classList.add("theme-transition");
+    setTimeout(() => {
+      setTimeout(() => {
+        document.documentElement.classList.remove("theme-transition");
+      }, 400);
+    }, 50);
+    const root = document.documentElement;
+    const styles = getComputedStyle(root);
+    const primaryColor = styles.getPropertyValue("--primary").trim();
+    const backgroundColor = styles.getPropertyValue("--background").trim();
+    adapter.setColors({
+      header: primaryColor,
+      background: backgroundColor,
+      footer: backgroundColor
+    });
+    setPreference(preference === "dark" ? "light" : "dark");
+  }, [adapter, preference, setPreference]);
+  return {
+    isDark,
+    appearance,
+    preference,
+    setPreference,
+    toggle
+  };
+}
+
+// src/hooks/useSafeArea.ts
+var import_react3 = require("react");
+var ZERO_SAFE_AREA = {
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0
+};
+function useSafeArea() {
+  const adapter = useMiniAppAdapter();
+  const computeSafeArea = (0, import_react3.useCallback)(
+    () => adapter.computeSafeArea() ?? ZERO_SAFE_AREA,
+    [adapter]
+  );
+  const [safeArea, setSafeArea] = (0, import_react3.useState)(computeSafeArea);
+  (0, import_react3.useEffect)(() => {
+    setSafeArea(computeSafeArea());
+    const unsubscribe = adapter.subscribe?.(() => {
+      setSafeArea(computeSafeArea());
+    });
+    return () => unsubscribe?.();
+  }, [adapter, computeSafeArea]);
+  return safeArea ?? ZERO_SAFE_AREA;
+}
+
+// src/platform.ts
+var cachedPlatform = null;
+function getPlatform() {
+  const adapter = getActiveAdapter();
+  if (adapter) {
+    cachedPlatform = adapter.platform;
+    return adapter.platform;
+  }
+  if (cachedPlatform) {
+    return cachedPlatform;
+  }
+  const detectedPlatform = detectPlatform();
+  cachedPlatform = detectedPlatform;
+  return detectedPlatform;
+}
+
+// src/analytics.ts
+function configureVkPixel(pixelCode2) {
+  setVkPixelCode(pixelCode2);
+}
+function trackConversionEvent(event, payload) {
+  const adapter = resolveVkAdapter();
+  adapter?.trackConversionEvent(event, payload);
+}
+function trackPixelEvent(event, payload) {
+  const adapter = resolveVkAdapter();
+  adapter?.trackPixelEvent(event, payload);
+}
+function resolveVkAdapter() {
+  const adapter = getActiveAdapter();
+  if (adapter) {
+    return adapter.platform === "vk" ? adapter : null;
+  }
+  if (getPlatform() !== "vk") {
+    return null;
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdapterProvider,
+  BaseMiniAppAdapter,
+  MaxMiniAppAdapter,
+  ShellMiniAppAdapter,
+  TelegramMiniAppAdapter,
+  VKMiniAppAdapter,
+  WebMiniAppAdapter,
+  configureVkPixel,
+  createAdapter,
+  createShellAPI,
+  detectPlatform,
+  getActiveAdapter,
+  getPlatform,
+  isShell,
+  isShellAndroid,
+  isShellIOS,
+  readShellPlatform,
+  requestShellPushPermission,
+  shell,
+  storeShellToken,
+  trackConversionEvent,
+  trackPixelEvent,
+  useAdapterTheme,
+  useMiniAppAdapter,
+  useSafeArea
+});
+//# sourceMappingURL=index.cjs.map