@ait-co/devtools 0.0.1

package/dist/mock/index.js

@@ -0,0 +1,696 @@
+import {
+  aitState
+} from "../chunk-YYIIG3JT.js";
+
+// src/mock/auth/index.ts
+function appLogin() {
+  return Promise.resolve({
+    authorizationCode: `mock-auth-${crypto.randomUUID()}`,
+    referrer: aitState.state.environment === "toss" ? "DEFAULT" : "SANDBOX"
+  });
+}
+function getIsTossLoginIntegratedService() {
+  return Promise.resolve(aitState.state.auth.isTossLoginIntegrated);
+}
+function getUserKeyForGame() {
+  if (!aitState.state.auth.userKeyHash) return Promise.resolve(void 0);
+  return Promise.resolve({ hash: aitState.state.auth.userKeyHash, type: "HASH" });
+}
+function appsInTossSignTossCert(_params) {
+  console.log("[ait-devtools] appsInTossSignTossCert called (no-op in mock)");
+  return Promise.resolve();
+}
+
+// src/mock/navigation/index.ts
+function closeView() {
+  console.log("[ait-devtools] closeView called");
+  window.history.back();
+  return Promise.resolve();
+}
+function openURL(url) {
+  console.log("[ait-devtools] openURL:", url);
+  window.open(url, "_blank");
+  return Promise.resolve();
+}
+function share(message) {
+  if (navigator.share) {
+    return navigator.share({ text: message.message }).then(() => {
+    });
+  }
+  console.log("[ait-devtools] share:", message.message);
+  return Promise.resolve();
+}
+function getTossShareLink(path, _ogImageUrl) {
+  return Promise.resolve(`https://toss.im/share/mock${path}`);
+}
+function setIosSwipeGestureEnabled(_options) {
+  console.log("[ait-devtools] setIosSwipeGestureEnabled:", _options.isEnabled);
+  return Promise.resolve();
+}
+function setDeviceOrientation(_options) {
+  console.log("[ait-devtools] setDeviceOrientation:", _options.type);
+  return Promise.resolve();
+}
+function setScreenAwakeMode(options) {
+  console.log("[ait-devtools] setScreenAwakeMode:", options.enabled);
+  return Promise.resolve({ enabled: options.enabled });
+}
+function setSecureScreen(options) {
+  console.log("[ait-devtools] setSecureScreen:", options.enabled);
+  return Promise.resolve({ enabled: options.enabled });
+}
+function requestReview() {
+  console.log("[ait-devtools] requestReview called");
+  return Promise.resolve();
+}
+requestReview.isSupported = () => true;
+function getPlatformOS() {
+  return aitState.state.platform;
+}
+function getOperationalEnvironment() {
+  return aitState.state.environment;
+}
+function getTossAppVersion() {
+  return aitState.state.appVersion;
+}
+function isMinVersionSupported(minVersions) {
+  const platform = aitState.state.platform;
+  const required = platform === "ios" ? minVersions.ios : minVersions.android;
+  if (required === "always") return true;
+  if (required === "never") return false;
+  const current = aitState.state.appVersion.split(".").map(Number);
+  const min = required.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((current[i] ?? 0) > (min[i] ?? 0)) return true;
+    if ((current[i] ?? 0) < (min[i] ?? 0)) return false;
+  }
+  return true;
+}
+function getSchemeUri() {
+  return aitState.state.schemeUri || window.location.pathname;
+}
+function getLocale() {
+  return aitState.state.locale;
+}
+function getDeviceId() {
+  return aitState.state.deviceId;
+}
+function getGroupId() {
+  return aitState.state.groupId;
+}
+function getNetworkStatus() {
+  return Promise.resolve(aitState.state.networkStatus);
+}
+function getServerTime() {
+  return Promise.resolve(Date.now());
+}
+getServerTime.isSupported = () => true;
+var graniteEvent = {
+  addEventListener(event, { onEvent, onError }) {
+    const handler = () => {
+      try {
+        onEvent();
+      } catch (e) {
+        onError?.(e instanceof Error ? e : new Error(String(e)));
+      }
+    };
+    window.addEventListener(`__ait:${event}`, handler);
+    return () => window.removeEventListener(`__ait:${event}`, handler);
+  }
+};
+var appsInTossEvent = {
+  addEventListener(_event, _handlers) {
+    return () => {
+    };
+  }
+};
+var tdsEvent = {
+  addEventListener(event, { onEvent }) {
+    const handler = (e) => {
+      const detail = e.detail;
+      onEvent(detail);
+    };
+    window.addEventListener(`__ait:${event}`, handler);
+    return () => window.removeEventListener(`__ait:${event}`, handler);
+  }
+};
+function onVisibilityChangedByTransparentServiceWeb(eventParams) {
+  const handler = () => eventParams.onEvent(!document.hidden);
+  document.addEventListener("visibilitychange", handler);
+  return () => document.removeEventListener("visibilitychange", handler);
+}
+var env = {
+  getDeploymentId: () => aitState.state.deploymentId
+};
+function getAppsInTossGlobals() {
+  return {
+    deploymentId: aitState.state.deploymentId,
+    brandDisplayName: aitState.state.brand.displayName,
+    brandIcon: aitState.state.brand.icon,
+    brandPrimaryColor: aitState.state.brand.primaryColor
+  };
+}
+var SafeAreaInsets = {
+  get: () => ({ ...aitState.state.safeAreaInsets }),
+  // NOTE: aitState.subscribe에 위임하므로 safeAreaInsets 외 상태 변경에도 콜백이 호출된다.
+  // 실제 SDK는 insets 변경 시에만 호출되지만, mock에서는 간소화를 위해 필터링하지 않는다.
+  subscribe: ({ onEvent }) => {
+    return aitState.subscribe(() => onEvent({ ...aitState.state.safeAreaInsets }));
+  }
+};
+function getSafeAreaInsets() {
+  return aitState.state.safeAreaInsets.top;
+}
+
+// src/mock/proxy.ts
+var WARNED = /* @__PURE__ */ new Set();
+function createMockProxy(moduleName, implementations) {
+  return new Proxy(implementations, {
+    get(target, prop) {
+      if (prop in target) return target[prop];
+      if (typeof prop === "symbol") return void 0;
+      if (!WARNED.has(`${moduleName}.${prop}`)) {
+        console.warn(
+          `[ait-devtools] ${moduleName}.${prop} is not mocked yet. Returning no-op. Please update ait-devtools or file an issue.`
+        );
+        WARNED.add(`${moduleName}.${prop}`);
+      }
+      return async () => void 0;
+    }
+  });
+}
+
+// src/mock/permissions.ts
+function getPermission(name) {
+  return Promise.resolve(aitState.state.permissions[name]);
+}
+function openPermissionDialog(name) {
+  const current = aitState.state.permissions[name];
+  if (current === "allowed") return Promise.resolve("allowed");
+  aitState.patch("permissions", { [name]: "allowed" });
+  return Promise.resolve("allowed");
+}
+function requestPermission(permission) {
+  return openPermissionDialog(permission.name);
+}
+function withPermission(fn, permissionName) {
+  const enhanced = fn;
+  enhanced.getPermission = () => getPermission(permissionName);
+  enhanced.openPermissionDialog = () => openPermissionDialog(permissionName);
+  return enhanced;
+}
+function checkPermission(name, fnName) {
+  const status = aitState.state.permissions[name];
+  if (status === "denied") {
+    throw new Error(`[ait-devtools] ${fnName}: Permission "${name}" is denied. Change it in the DevTools panel.`);
+  }
+}
+
+// src/mock/device/index.ts
+var Storage = createMockProxy("Storage", {
+  getItem: async (key) => {
+    return localStorage.getItem(`__ait_storage:${key}`);
+  },
+  setItem: async (key, value) => {
+    localStorage.setItem(`__ait_storage:${key}`, value);
+  },
+  removeItem: async (key) => {
+    localStorage.removeItem(`__ait_storage:${key}`);
+  },
+  clearItems: async () => {
+    const keys = Object.keys(localStorage).filter((k) => k.startsWith("__ait_storage:"));
+    keys.forEach((k) => localStorage.removeItem(k));
+  }
+});
+var Accuracy = /* @__PURE__ */ ((Accuracy2) => {
+  Accuracy2[Accuracy2["Lowest"] = 1] = "Lowest";
+  Accuracy2[Accuracy2["Low"] = 2] = "Low";
+  Accuracy2[Accuracy2["Balanced"] = 3] = "Balanced";
+  Accuracy2[Accuracy2["High"] = 4] = "High";
+  Accuracy2[Accuracy2["Highest"] = 5] = "Highest";
+  Accuracy2[Accuracy2["BestForNavigation"] = 6] = "BestForNavigation";
+  return Accuracy2;
+})(Accuracy || {});
+function buildLocation() {
+  return {
+    coords: { ...aitState.state.location.coords },
+    timestamp: Date.now(),
+    accessLocation: aitState.state.location.accessLocation
+  };
+}
+var _getCurrentLocation = async (_options) => {
+  checkPermission("geolocation", "getCurrentLocation");
+  return buildLocation();
+};
+var getCurrentLocation = withPermission(_getCurrentLocation, "geolocation");
+function _startUpdateLocation(eventParams) {
+  const { onEvent, options } = eventParams;
+  const interval = Math.max(options.timeInterval, 500);
+  const id = setInterval(() => {
+    const loc = buildLocation();
+    loc.coords.latitude += (Math.random() - 0.5) * 1e-4;
+    loc.coords.longitude += (Math.random() - 0.5) * 1e-4;
+    onEvent(loc);
+  }, interval);
+  return () => clearInterval(id);
+}
+var startUpdateLocation = Object.assign(_startUpdateLocation, {
+  getPermission: () => withPermission(_getCurrentLocation, "geolocation").getPermission(),
+  openPermissionDialog: () => withPermission(_getCurrentLocation, "geolocation").openPermissionDialog()
+});
+var _openCamera = async (options) => {
+  checkPermission("camera", "openCamera");
+  return new Promise((resolve, reject) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = "image/*";
+    input.capture = "environment";
+    input.onchange = () => {
+      const file = input.files?.[0];
+      if (!file) {
+        reject(new Error("No file selected"));
+        return;
+      }
+      const reader = new FileReader();
+      reader.onload = () => {
+        resolve({
+          id: crypto.randomUUID(),
+          dataUri: reader.result
+        });
+      };
+      reader.readAsDataURL(file);
+    };
+    input.click();
+  });
+};
+var openCamera = withPermission(_openCamera, "camera");
+var _fetchAlbumPhotos = async (options) => {
+  checkPermission("photos", "fetchAlbumPhotos");
+  const maxCount = options?.maxCount ?? 10;
+  return new Promise((resolve, reject) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = "image/*";
+    input.multiple = true;
+    input.onchange = async () => {
+      const files = Array.from(input.files ?? []).slice(0, maxCount);
+      if (files.length === 0) {
+        reject(new Error("No files selected"));
+        return;
+      }
+      const results = await Promise.all(
+        files.map((file) => new Promise((res) => {
+          const reader = new FileReader();
+          reader.onload = () => res({ id: crypto.randomUUID(), dataUri: reader.result });
+          reader.readAsDataURL(file);
+        }))
+      );
+      resolve(results);
+    };
+    input.click();
+  });
+};
+var fetchAlbumPhotos = withPermission(_fetchAlbumPhotos, "photos");
+var _fetchContacts = async (options) => {
+  checkPermission("contacts", "fetchContacts");
+  let contacts = aitState.state.contacts;
+  if (options.query?.contains) {
+    const q = options.query.contains.toLowerCase();
+    contacts = contacts.filter((c) => c.name.toLowerCase().includes(q) || c.phoneNumber.includes(q));
+  }
+  const sliced = contacts.slice(options.offset, options.offset + options.size);
+  const nextOffset = options.offset + options.size;
+  return {
+    result: sliced,
+    nextOffset: nextOffset < contacts.length ? nextOffset : null,
+    done: nextOffset >= contacts.length
+  };
+};
+var fetchContacts = withPermission(_fetchContacts, "contacts");
+var _getClipboardText = async () => {
+  checkPermission("clipboard", "getClipboardText");
+  try {
+    return await navigator.clipboard.readText();
+  } catch {
+    return "";
+  }
+};
+var getClipboardText = withPermission(_getClipboardText, "clipboard");
+var _setClipboardText = async (text) => {
+  checkPermission("clipboard", "setClipboardText");
+  await navigator.clipboard.writeText(text);
+};
+var setClipboardText = withPermission(_setClipboardText, "clipboard");
+function generateHapticFeedback(options) {
+  console.log(`[ait-devtools] haptic: ${options.type}`);
+  aitState.logAnalytics({ type: "haptic", params: { hapticType: options.type } });
+  return Promise.resolve();
+}
+function saveBase64Data(params) {
+  const a = document.createElement("a");
+  a.href = `data:${params.mimeType};base64,${params.data}`;
+  a.download = params.fileName;
+  a.click();
+  return Promise.resolve();
+}
+
+// src/mock/iap/index.ts
+var orderCounter = 0;
+function generateOrderId() {
+  return `mock-order-${++orderCounter}-${Date.now()}`;
+}
+function buildOrderResult(sku) {
+  const product = aitState.state.iap.products.find((p) => p.sku === sku);
+  const amountStr = product?.displayAmount?.replace(/[^0-9]/g, "") ?? "1000";
+  return {
+    orderId: generateOrderId(),
+    displayName: product?.displayName ?? "Mock Product",
+    displayAmount: product?.displayAmount ?? "1,000\uC6D0",
+    amount: parseInt(amountStr, 10) || 1e3,
+    currency: "KRW",
+    fraction: 0,
+    miniAppIconUrl: product?.iconUrl || null
+  };
+}
+async function handlePurchase(sku, processProductGrant, onEvent, onError) {
+  const nextResult = aitState.state.iap.nextResult;
+  await new Promise((r) => setTimeout(r, 300));
+  if (nextResult !== "success") {
+    onError({ code: nextResult });
+    return;
+  }
+  const result = buildOrderResult(sku);
+  try {
+    const granted = await processProductGrant({ orderId: result.orderId });
+    if (!granted) {
+      onError({ code: "PRODUCT_NOT_GRANTED_BY_PARTNER" });
+      return;
+    }
+  } catch (e) {
+    onError(e);
+    return;
+  }
+  aitState.patch("iap", {
+    completedOrders: [...aitState.state.iap.completedOrders, {
+      orderId: result.orderId,
+      sku,
+      status: "COMPLETED",
+      date: (/* @__PURE__ */ new Date()).toISOString()
+    }]
+  });
+  await onEvent({ type: "success", data: result });
+}
+var IAP = createMockProxy("IAP", {
+  // 반환되는 cancel 함수는 mock에서는 no-op이다 (실제 SDK는 결제 UI를 닫음)
+  createOneTimePurchaseOrder(params) {
+    const sku = params.options.sku ?? params.options.productId ?? "";
+    handlePurchase(sku, params.options.processProductGrant, params.onEvent, params.onError).catch((e) => console.error("[ait-devtools] IAP unexpected error:", e));
+    return () => {
+    };
+  },
+  createSubscriptionPurchaseOrder(params) {
+    handlePurchase(params.options.sku, params.options.processProductGrant, params.onEvent, params.onError).catch((e) => console.error("[ait-devtools] IAP unexpected error:", e));
+    return () => {
+    };
+  },
+  async getProductItemList() {
+    return {
+      products: aitState.state.iap.products.map((p) => ({
+        ...p,
+        ...p.type === "SUBSCRIPTION" ? { renewalCycle: p.renewalCycle ?? "MONTHLY" } : {}
+      }))
+    };
+  },
+  async getPendingOrders() {
+    return { orders: [...aitState.state.iap.pendingOrders] };
+  },
+  async getCompletedOrRefundedOrders() {
+    return {
+      hasNext: false,
+      nextKey: null,
+      orders: [...aitState.state.iap.completedOrders]
+    };
+  },
+  async completeProductGrant(args) {
+    const idx = aitState.state.iap.pendingOrders.findIndex((o) => o.orderId === args.params.orderId);
+    if (idx !== -1) {
+      const order = aitState.state.iap.pendingOrders[idx];
+      const pendingOrders = aitState.state.iap.pendingOrders.filter((_, i) => i !== idx);
+      const completedOrders = [...aitState.state.iap.completedOrders, {
+        orderId: order.orderId,
+        sku: order.sku,
+        status: "COMPLETED",
+        date: (/* @__PURE__ */ new Date()).toISOString()
+      }];
+      aitState.patch("iap", { pendingOrders, completedOrders });
+    }
+    return true;
+  },
+  async getSubscriptionInfo(_args) {
+    return {
+      subscription: {
+        catalogId: 1,
+        status: "ACTIVE",
+        expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1e3).toISOString(),
+        isAutoRenew: true,
+        gracePeriodExpiresAt: null,
+        isAccessible: true
+      }
+    };
+  }
+});
+function checkoutPayment(options) {
+  const { nextResult, failReason } = aitState.state.payment;
+  console.log("[ait-devtools] checkoutPayment:", options.params.payToken);
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      if (nextResult === "success") {
+        resolve({ success: true });
+      } else {
+        resolve({ success: false, reason: failReason || "Mock payment failed" });
+      }
+    }, 300);
+  });
+}
+
+// src/mock/ads/index.ts
+function withIsSupported(fn) {
+  fn.isSupported = () => true;
+  return fn;
+}
+var GoogleAdMob = createMockProxy("GoogleAdMob", {
+  loadAppsInTossAdMob: withIsSupported((args) => {
+    setTimeout(() => {
+      aitState.patch("ads", { isLoaded: true });
+      args.onEvent({ type: "loaded", data: { adGroupId: args.options?.adGroupId } });
+    }, 200);
+    return () => {
+    };
+  }),
+  showAppsInTossAdMob: withIsSupported((args) => {
+    if (!aitState.state.ads.isLoaded) {
+      args.onError(new Error("Ad not loaded"));
+      return () => {
+      };
+    }
+    setTimeout(() => args.onEvent({ type: "requested" }), 50);
+    setTimeout(() => args.onEvent({ type: "show" }), 100);
+    setTimeout(() => args.onEvent({ type: "impression" }), 150);
+    setTimeout(() => {
+      args.onEvent({ type: "userEarnedReward", data: { unitType: "coins", unitAmount: 10 } });
+    }, 1e3);
+    setTimeout(() => {
+      args.onEvent({ type: "dismissed" });
+      aitState.patch("ads", { isLoaded: false });
+    }, 1500);
+    return () => {
+    };
+  }),
+  isAppsInTossAdMobLoaded: withIsSupported(
+    async (_options) => aitState.state.ads.isLoaded
+  )
+});
+var TossAds = createMockProxy("TossAds", {
+  initialize: withIsSupported((_options) => {
+    console.log("[ait-devtools] TossAds.initialize (mock)");
+  }),
+  attach: withIsSupported((_adGroupId, target, _options) => {
+    const el = typeof target === "string" ? document.querySelector(target) : target;
+    if (el) {
+      const placeholder = document.createElement("div");
+      placeholder.style.cssText = "background:#f0f0f0;border:1px dashed #999;padding:16px;text-align:center;color:#666;font-size:14px;";
+      placeholder.textContent = "[ait-devtools] TossAds Placeholder";
+      el.appendChild(placeholder);
+    }
+  }),
+  attachBanner: withIsSupported((_adGroupId, target, _options) => {
+    const el = typeof target === "string" ? document.querySelector(target) : target;
+    if (el) {
+      const placeholder = document.createElement("div");
+      placeholder.style.cssText = "background:#f0f0f0;border:1px dashed #999;padding:12px;text-align:center;color:#666;font-size:12px;";
+      placeholder.textContent = "[ait-devtools] Banner Ad Placeholder";
+      el.appendChild(placeholder);
+    }
+    return { destroy: () => {
+    } };
+  }),
+  destroy: withIsSupported((_slotId) => {
+  }),
+  destroyAll: withIsSupported(() => {
+  })
+});
+var loadFullScreenAd = withIsSupported((args) => {
+  setTimeout(() => {
+    aitState.patch("ads", { isLoaded: true });
+    args.onEvent({ type: "loaded", data: { adGroupId: args.options?.adGroupId } });
+  }, 200);
+  return () => {
+  };
+});
+var showFullScreenAd = withIsSupported((args) => {
+  if (!aitState.state.ads.isLoaded) {
+    args.onError(new Error("Ad not loaded"));
+    return () => {
+    };
+  }
+  setTimeout(() => args.onEvent({ type: "show" }), 100);
+  setTimeout(() => args.onEvent({ type: "dismissed" }), 1500);
+  return () => {
+  };
+});
+
+// src/mock/game/index.ts
+function grantPromotionReward(params) {
+  console.log("[ait-devtools] grantPromotionReward:", params.params);
+  return Promise.resolve({ key: `mock-reward-${Date.now()}` });
+}
+function grantPromotionRewardForGame(params) {
+  console.log("[ait-devtools] grantPromotionRewardForGame:", params.params);
+  return Promise.resolve({ key: `mock-reward-${Date.now()}` });
+}
+function submitGameCenterLeaderBoardScore(params) {
+  aitState.patch("game", {
+    leaderboardScores: [...aitState.state.game.leaderboardScores, { score: params.score, timestamp: Date.now() }]
+  });
+  return Promise.resolve({ statusCode: "SUCCESS" });
+}
+function getGameCenterGameProfile() {
+  const profile = aitState.state.game.profile;
+  if (!profile) return Promise.resolve({ statusCode: "PROFILE_NOT_FOUND" });
+  return Promise.resolve({
+    statusCode: "SUCCESS",
+    nickname: profile.nickname,
+    profileImageUri: profile.profileImageUri
+  });
+}
+function openGameCenterLeaderboard() {
+  console.log("[ait-devtools] openGameCenterLeaderboard (no-op in browser)");
+  return Promise.resolve();
+}
+function contactsViral(params) {
+  setTimeout(() => {
+    params.onEvent({
+      type: "close",
+      data: {
+        closeReason: "noReward",
+        sentRewardsCount: 0
+      }
+    });
+  }, 500);
+  return () => {
+  };
+}
+
+// src/mock/analytics/index.ts
+var Analytics = {
+  screen: (params) => {
+    aitState.logAnalytics({ type: "screen", params: params ?? {} });
+    return Promise.resolve();
+  },
+  impression: (params) => {
+    aitState.logAnalytics({ type: "impression", params: params ?? {} });
+    return Promise.resolve();
+  },
+  click: (params) => {
+    aitState.logAnalytics({ type: "click", params: params ?? {} });
+    return Promise.resolve();
+  }
+};
+function eventLog(params) {
+  aitState.logAnalytics({ type: params.log_type, params: { log_name: params.log_name, ...params.params } });
+  return Promise.resolve();
+}
+
+// src/mock/partner/index.ts
+var partner = {
+  async addAccessoryButton(options) {
+    console.log("[ait-devtools] partner.addAccessoryButton:", options);
+  },
+  async removeAccessoryButton() {
+    console.log("[ait-devtools] partner.removeAccessoryButton");
+  }
+};
+export {
+  Accuracy,
+  Analytics,
+  GoogleAdMob,
+  IAP,
+  SafeAreaInsets,
+  Storage,
+  TossAds,
+  aitState,
+  appLogin,
+  appsInTossEvent,
+  appsInTossSignTossCert,
+  checkoutPayment,
+  closeView,
+  contactsViral,
+  env,
+  eventLog,
+  fetchAlbumPhotos,
+  fetchContacts,
+  generateHapticFeedback,
+  getAppsInTossGlobals,
+  getClipboardText,
+  getCurrentLocation,
+  getDeviceId,
+  getGameCenterGameProfile,
+  getGroupId,
+  getIsTossLoginIntegratedService,
+  getLocale,
+  getNetworkStatus,
+  getOperationalEnvironment,
+  getPermission,
+  getPlatformOS,
+  getSafeAreaInsets,
+  getSchemeUri,
+  getServerTime,
+  getTossAppVersion,
+  getTossShareLink,
+  getUserKeyForGame,
+  graniteEvent,
+  grantPromotionReward,
+  grantPromotionRewardForGame,
+  isMinVersionSupported,
+  loadFullScreenAd,
+  onVisibilityChangedByTransparentServiceWeb,
+  openCamera,
+  openGameCenterLeaderboard,
+  openPermissionDialog,
+  openURL,
+  partner,
+  requestPermission,
+  requestReview,
+  saveBase64Data,
+  setClipboardText,
+  setDeviceOrientation,
+  setIosSwipeGestureEnabled,
+  setScreenAwakeMode,
+  setSecureScreen,
+  share,
+  showFullScreenAd,
+  startUpdateLocation,
+  submitGameCenterLeaderBoardScore,
+  tdsEvent
+};
+//# sourceMappingURL=index.js.map