@bountyboard/arcade-sdk 1.0.0

package/dist/chunk-WCGBR3MI.js

@@ -0,0 +1,805 @@
+// src/protocol.ts
+var VERSION = 1;
+var SDK_MESSAGE_SOURCE = "bb-arcade";
+var HOST_MESSAGE_SOURCE = "bb-arcade-host";
+
+// src/core.ts
+var BOUNTY_BOARD_URL = "https://www.bountyboard.gg/arcade";
+var ADSENSE_CLIENT_ID = "ca-pub-7727110228190547";
+var AD_PLACEMENT_SRC = "https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=" + ADSENSE_CLIENT_ID;
+var AD_PLACEMENT_SCRIPT_ID = "bb-arcade-h5-ads";
+var DEFAULT_AD_LOAD_TIMEOUT_MS = 6e3;
+var SAVE_TIMEOUT_MS = 15e3;
+var INIT_CONFIG_GRACE_MS = 1500;
+var DEFAULT_ALLOW = [
+  "bountyboard.gg",
+  "bountyboard-staging.vercel.app",
+  "localhost",
+  "127.0.0.1"
+];
+var SITELOCK_PUBLIC_KEY_B64 = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6WC8fJweDpfKRcZW9Q9eOLxPXmFCO8R8lY1kfZbuAQt65E0CTu2rM80XfW3nYrSAqO+Eev8gxrGS0bAnNaMDGg==";
+var SITELOCK_MAX_SKEW_MS = 5 * 60 * 1e3;
+function sdkError(code) {
+  const err = new Error(code);
+  err.code = code;
+  return err;
+}
+function b64ToBytes(b64) {
+  const bin = atob(b64);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  return bytes;
+}
+function cleanText(value, fallback, max) {
+  if (typeof value !== "string") return fallback || "";
+  return value.replace(/[^\w:.-]+/g, "_").slice(0, max || 80) || fallback || "";
+}
+function toBoolean(value) {
+  return value === true || value === "true" || value === "1";
+}
+function cleanRewardedSize(value) {
+  return value === "small" || value === "medium" || value === "large" ? value : "";
+}
+function safeCall(fn, arg) {
+  if (typeof fn !== "function") return;
+  try {
+    fn(arg);
+  } catch (err) {
+    setTimeout(function() {
+      throw err;
+    }, 0);
+  }
+}
+function toAllowedHost(value) {
+  const raw = String(value).toLowerCase().trim();
+  if (!raw) return "";
+  try {
+    return new URL(raw.indexOf("//") === -1 ? "https://" + raw : raw).hostname;
+  } catch (err) {
+    return raw;
+  }
+}
+function hostnameAllowed(origin, allowHosts) {
+  if (!origin || origin === "null" || typeof origin !== "string") return false;
+  let host;
+  try {
+    host = new URL(origin).hostname.toLowerCase();
+  } catch (err) {
+    return false;
+  }
+  for (let i = 0; i < allowHosts.length; i++) {
+    const allowed = allowHosts[i];
+    if (host === allowed || host.slice(-(allowed.length + 1)) === "." + allowed) return true;
+  }
+  return false;
+}
+function verifyHostAttestation(att, senderOrigin) {
+  const a = att;
+  if (!a || typeof a.origin !== "string" || typeof a.ts !== "number" || typeof a.sig !== "string")
+    return Promise.resolve(false);
+  if (a.origin !== senderOrigin) return Promise.resolve(false);
+  if (Math.abs(Date.now() - a.ts) > SITELOCK_MAX_SKEW_MS) return Promise.resolve(false);
+  try {
+    return window.crypto.subtle.importKey(
+      "spki",
+      b64ToBytes(SITELOCK_PUBLIC_KEY_B64),
+      { name: "ECDSA", namedCurve: "P-256" },
+      false,
+      ["verify"]
+    ).then(function(key) {
+      return window.crypto.subtle.verify(
+        { name: "ECDSA", hash: "SHA-256" },
+        key,
+        b64ToBytes(a.sig),
+        new TextEncoder().encode(a.origin + ":" + a.ts)
+      );
+    }).then(
+      function(ok) {
+        return ok === true;
+      },
+      function() {
+        return false;
+      }
+    );
+  } catch (err) {
+    return Promise.resolve(false);
+  }
+}
+function sanitizePlayer(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  const name = typeof raw.name === "string" ? raw.name.trim().slice(0, 120) : "";
+  if (!name) return null;
+  const avatarUrl = typeof raw.avatarUrl === "string" && raw.avatarUrl.trim() ? raw.avatarUrl : null;
+  return { name, avatarUrl };
+}
+function createBBArcade() {
+  let adPlacementLoad = null;
+  let adPreloadConfigured = false;
+  let rewardedBreakActive = false;
+  let rewardedBreakSequence = 0;
+  function isLocalAdHost() {
+    try {
+      const protocol = window.location && window.location.protocol;
+      const host = window.location && window.location.hostname;
+      return protocol === "file:" || host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+    } catch (err) {
+      return false;
+    }
+  }
+  const localAdHost = isLocalAdHost();
+  const config = {
+    rewardedAds: {
+      enabled: true,
+      adChannel: "",
+      testMode: localAdHost,
+      loadTimeoutMs: DEFAULT_AD_LOAD_TIMEOUT_MS,
+      preload: false
+    }
+  };
+  const hostConfig = {
+    rewardedAds: {
+      received: false,
+      enabled: localAdHost,
+      adChannel: "",
+      testMode: localAdHost,
+      preload: false
+    }
+  };
+  let hostConfigReceived = false;
+  let hostPlayer = null;
+  let blocked = false;
+  const pending = {};
+  let seq = 0;
+  function post(type, score, extra) {
+    if (blocked) return;
+    const message = { source: SDK_MESSAGE_SOURCE, v: VERSION, type };
+    if (typeof score === "number" && isFinite(score)) message.score = Math.floor(score);
+    if (extra && typeof extra === "object") {
+      const fields = extra;
+      for (const key in fields) {
+        if (Object.prototype.hasOwnProperty.call(fields, key) && fields[key] !== void 0) {
+          message[key] = fields[key];
+        }
+      }
+    }
+    try {
+      window.parent.postMessage(message, "*");
+    } catch (err) {
+    }
+  }
+  function isEmbedded() {
+    try {
+      return window.parent != null && window.parent !== window;
+    } catch (err) {
+      return true;
+    }
+  }
+  function request(type, payload) {
+    return new Promise(function(resolve, reject) {
+      if (blocked) return reject(sdkError("error"));
+      if (!isEmbedded()) return reject(sdkError("unsupported"));
+      const requestId = type + "_" + ++seq + "_" + Date.now();
+      const timer = setTimeout(function() {
+        if (pending[requestId]) {
+          delete pending[requestId];
+          reject(sdkError("error"));
+        }
+      }, SAVE_TIMEOUT_MS);
+      pending[requestId] = { resolve, reject, timer };
+      try {
+        window.parent.postMessage(
+          {
+            source: SDK_MESSAGE_SOURCE,
+            v: VERSION,
+            type,
+            requestId,
+            payload
+          },
+          "*"
+        );
+      } catch (err) {
+        clearTimeout(timer);
+        delete pending[requestId];
+        reject(sdkError("error"));
+      }
+    });
+  }
+  window.addEventListener("message", function(event) {
+    if (event.source !== window.parent) return;
+    const data = event.data;
+    if (!data || data.source !== SDK_MESSAGE_SOURCE) return;
+    if (typeof data.type !== "string" || !data.type.endsWith("_result")) return;
+    const entry = pending[data.requestId];
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    delete pending[data.requestId];
+    if (data.type === "host_result") return entry.resolve({ origin: event.origin });
+    if (data.type === "host_attest_result")
+      return entry.resolve({ origin: event.origin, attestation: data.attestation || null });
+    if (data.type === "experiment_result")
+      return entry.resolve(typeof data.variant === "string" ? data.variant : null);
+    if (data.ok)
+      entry.resolve(
+        data.type === "load_result" ? data.data != null ? data.data : null : data.data
+      );
+    else entry.reject(sdkError(data.code || "error"));
+  });
+  function embeddingOriginSync() {
+    try {
+      if (window.top === window.self) return window.location.origin;
+    } catch (err) {
+    }
+    try {
+      const ancestors = window.location.ancestorOrigins;
+      if (ancestors && ancestors.length && ancestors[0] && ancestors[0] !== "null")
+        return ancestors[0];
+    } catch (err) {
+    }
+    if (document.referrer) {
+      try {
+        return new URL(document.referrer).origin;
+      } catch (err) {
+      }
+    }
+    return null;
+  }
+  function blockHost(options) {
+    if (blocked) return;
+    blocked = true;
+    if (typeof options.onBlocked === "function") {
+      try {
+        options.onBlocked();
+      } catch (err) {
+      }
+      return;
+    }
+    if (options.redirect) {
+      try {
+        window.top.location.href = options.redirect;
+        return;
+      } catch (err) {
+        try {
+          window.location.href = options.redirect;
+          return;
+        } catch (err2) {
+        }
+      }
+    }
+    try {
+      document.documentElement.innerHTML = `<div style="position:fixed;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:14px;font-family:system-ui,-apple-system,sans-serif;background:#1a1206;color:#fff;text-align:center;padding:24px;"><div style="font-size:18px;font-weight:700;">This game isn't available here</div><a href="` + BOUNTY_BOARD_URL + '" target="_blank" rel="noopener" style="display:inline-block;background:#f5b942;color:#1a1206;font-weight:700;font-size:14px;text-decoration:none;padding:10px 20px;border-radius:999px;">Play the original on Bounty Board</a></div>';
+    } catch (err) {
+    }
+  }
+  function lockToHostBestEffort(options, allow) {
+    const origin = embeddingOriginSync();
+    if (origin != null) {
+      if (!hostnameAllowed(origin, allow)) blockHost(options);
+      return;
+    }
+    request("host").then(
+      function(res) {
+        const r = res;
+        if (!hostnameAllowed(r && r.origin, allow)) blockHost(options);
+      },
+      function() {
+        blockHost(options);
+      }
+    );
+  }
+  function lockToHost(options) {
+    const opts = options || {};
+    const allow = DEFAULT_ALLOW.slice();
+    if (opts.allow && opts.allow.length) {
+      for (let i = 0; i < opts.allow.length; i++) {
+        const host = toAllowedHost(opts.allow[i]);
+        if (host) allow.push(host);
+      }
+    }
+    if (opts.signed) {
+      if (!(window.crypto && window.crypto.subtle)) {
+        lockToHostBestEffort(opts, allow);
+        return;
+      }
+      request("host_attest").then(
+        function(res) {
+          const r = res;
+          if (!r || !r.attestation) {
+            lockToHostBestEffort(opts, allow);
+            return;
+          }
+          verifyHostAttestation(r.attestation, r.origin).then(function(ok) {
+            if (!ok || !hostnameAllowed(r.attestation && r.attestation.origin, allow))
+              blockHost(opts);
+          });
+        },
+        function() {
+          blockHost(opts);
+        }
+      );
+      return;
+    }
+    lockToHostBestEffort(opts, allow);
+  }
+  function nextAdBreakId() {
+    rewardedBreakSequence += 1;
+    return [
+      "bbad",
+      Date.now().toString(36),
+      rewardedBreakSequence.toString(36),
+      Math.random().toString(36).slice(2, 10)
+    ].join("_");
+  }
+  function configure(nextConfig) {
+    if (!nextConfig || typeof nextConfig !== "object") return;
+    const rewardedAds = nextConfig.rewardedAds;
+    if (!rewardedAds || typeof rewardedAds !== "object") return;
+    if (rewardedAds.enabled !== void 0) {
+      config.rewardedAds.enabled = rewardedAds.enabled !== false;
+    }
+    if (rewardedAds.adChannel !== void 0) {
+      config.rewardedAds.adChannel = cleanText(rewardedAds.adChannel);
+    }
+    if (rewardedAds.testMode !== void 0) {
+      config.rewardedAds.testMode = toBoolean(rewardedAds.testMode);
+    }
+    if (rewardedAds.preload !== void 0) {
+      config.rewardedAds.preload = toBoolean(rewardedAds.preload);
+    }
+    if (typeof rewardedAds.loadTimeoutMs === "number" && isFinite(rewardedAds.loadTimeoutMs) && rewardedAds.loadTimeoutMs > 0) {
+      config.rewardedAds.loadTimeoutMs = Math.min(15e3, Math.floor(rewardedAds.loadTimeoutMs));
+    }
+    if (config.rewardedAds.preload) preloadRewardedAds();
+  }
+  let configWaiters = [];
+  function notifyConfigReceived() {
+    const waiters = configWaiters;
+    configWaiters = [];
+    for (let i = 0; i < waiters.length; i++) safeCall(waiters[i]);
+  }
+  function applyHostConfig(message) {
+    if (!message || typeof message !== "object") return;
+    const msg = message;
+    if (msg.source !== HOST_MESSAGE_SOURCE || msg.type !== "config") return;
+    hostConfigReceived = true;
+    if (msg.player !== void 0) {
+      hostPlayer = sanitizePlayer(msg.player);
+    }
+    const rewardedAds = msg.rewardedAds;
+    if (rewardedAds && typeof rewardedAds === "object") {
+      hostConfig.rewardedAds.received = true;
+      if (rewardedAds.enabled !== void 0) {
+        hostConfig.rewardedAds.enabled = toBoolean(rewardedAds.enabled);
+      }
+      if (rewardedAds.adChannel !== void 0) {
+        hostConfig.rewardedAds.adChannel = cleanText(rewardedAds.adChannel);
+      }
+      if (rewardedAds.testMode !== void 0) {
+        hostConfig.rewardedAds.testMode = toBoolean(rewardedAds.testMode);
+      }
+      if (rewardedAds.preload !== void 0) {
+        hostConfig.rewardedAds.preload = toBoolean(rewardedAds.preload);
+      }
+      if (hostConfig.rewardedAds.enabled && (hostConfig.rewardedAds.preload || config.rewardedAds.preload)) {
+        preloadRewardedAds();
+      }
+    }
+    notifyConfigReceived();
+  }
+  function areRewardedAdsEnabled() {
+    return config.rewardedAds.enabled !== false && hostConfig.rewardedAds.enabled === true;
+  }
+  function installAdPlacementShim() {
+    const w = window;
+    w.adsbygoogle = w.adsbygoogle || [];
+    if (typeof w.adBreak !== "function") {
+      w.adBreak = function(placement) {
+        w.adsbygoogle.push(placement);
+      };
+    }
+    if (typeof w.adConfig !== "function") {
+      w.adConfig = function(settings) {
+        w.adsbygoogle.push(settings);
+      };
+    }
+  }
+  function ensureAdPlacement(options) {
+    if (typeof document === "undefined") return Promise.resolve(null);
+    installAdPlacementShim();
+    const w = window;
+    if (typeof w.adBreak !== "function") return Promise.resolve(null);
+    if (adPlacementLoad) return adPlacementLoad;
+    adPlacementLoad = new Promise(function(resolve) {
+      let script = document.getElementById(AD_PLACEMENT_SCRIPT_ID);
+      if (!script) {
+        const el = document.createElement("script");
+        el.id = AD_PLACEMENT_SCRIPT_ID;
+        el.async = true;
+        el.src = AD_PLACEMENT_SRC;
+        el.crossOrigin = "anonymous";
+        el.setAttribute("data-ad-client", ADSENSE_CLIENT_ID);
+        if (options.adChannel) el.setAttribute("data-ad-channel", options.adChannel);
+        if (options.testMode) el.setAttribute("data-adbreak-test", "on");
+        (document.head || document.documentElement).appendChild(el);
+        script = el;
+      }
+      resolve(w.adBreak);
+    });
+    return adPlacementLoad;
+  }
+  function requestAdPreload() {
+    const w = window;
+    if (adPreloadConfigured || typeof w.adConfig !== "function") return;
+    adPreloadConfigured = true;
+    try {
+      w.adConfig({ preloadAdBreaks: "on" });
+    } catch (err) {
+    }
+  }
+  function normalizeRewardedOptions(options) {
+    const opts = options && typeof options === "object" ? options : {};
+    const hostHasConfig = hostConfig.rewardedAds.received;
+    return {
+      placement: cleanText(opts.placement || opts.name, "rewarded"),
+      reward: cleanText(opts.reward, "reward"),
+      adBreakId: cleanText(opts.adBreakId, nextAdBreakId(), 128),
+      size: cleanRewardedSize(opts.size),
+      adChannel: cleanText(
+        hostHasConfig ? hostConfig.rewardedAds.adChannel : opts.adChannel || config.rewardedAds.adChannel
+      ),
+      testMode: hostHasConfig ? hostConfig.rewardedAds.testMode : opts.testMode !== void 0 ? toBoolean(opts.testMode) : config.rewardedAds.testMode || hostConfig.rewardedAds.testMode,
+      loadTimeoutMs: typeof opts.loadTimeoutMs === "number" && isFinite(opts.loadTimeoutMs) ? Math.min(15e3, Math.max(1, Math.floor(opts.loadTimeoutMs))) : config.rewardedAds.loadTimeoutMs,
+      beforeReward: opts.beforeReward,
+      adViewed: opts.adViewed,
+      adDismissed: opts.adDismissed,
+      adBreakDone: opts.adBreakDone,
+      onReward: opts.onReward,
+      onDismissed: opts.onDismissed,
+      onDone: opts.onDone,
+      onError: opts.onError,
+      onUnavailable: opts.onUnavailable
+    };
+  }
+  function rewardedAd(rawOptions) {
+    const options = normalizeRewardedOptions(rawOptions);
+    const base = {
+      placement: options.placement,
+      reward: options.reward,
+      adBreakId: options.adBreakId
+    };
+    if (options.size) base.size = options.size;
+    post("rewarded_ad", void 0, Object.assign({ event: "requested" }, base));
+    if (!areRewardedAdsEnabled()) {
+      const disabled = Object.assign(
+        { status: "unavailable", error: "host_disabled" },
+        base
+      );
+      post("rewarded_ad", void 0, Object.assign({ event: "unavailable" }, disabled));
+      safeCall(options.onUnavailable, disabled);
+      safeCall(options.onDone, disabled);
+      return Promise.resolve(disabled);
+    }
+    return ensureAdPlacement(options).then(function(adBreak) {
+      if (typeof adBreak !== "function") {
+        const unavailable = Object.assign(
+          { status: "unavailable", error: "ad_break_unavailable" },
+          base
+        );
+        post("rewarded_ad", void 0, Object.assign({ event: "unavailable" }, unavailable));
+        safeCall(options.onUnavailable, unavailable);
+        safeCall(options.onDone, unavailable);
+        return unavailable;
+      }
+      requestAdPreload();
+      return new Promise(function(resolve) {
+        let resolved = false;
+        let status = "unavailable";
+        let rewardOffered = false;
+        const waitTimer = setTimeout(function() {
+          if (rewardOffered || resolved) return;
+          const timeout = Object.assign(
+            { status: "unavailable", error: "ad_break_timeout" },
+            base
+          );
+          post("rewarded_ad", void 0, Object.assign({ event: "unavailable" }, timeout));
+          safeCall(options.onUnavailable, timeout);
+          done(timeout);
+        }, options.loadTimeoutMs);
+        function done(result) {
+          if (resolved) return;
+          resolved = true;
+          clearTimeout(waitTimer);
+          const finalResult = Object.assign(
+            { status: "unavailable" },
+            base,
+            result || {}
+          );
+          post("rewarded_ad", void 0, Object.assign({ event: "done" }, finalResult));
+          safeCall(options.onDone, finalResult);
+          resolve(finalResult);
+        }
+        function startAd(showAdFn) {
+          if (resolved) return;
+          rewardOffered = true;
+          clearTimeout(waitTimer);
+          status = "ready";
+          let shown = false;
+          function show() {
+            if (shown) return;
+            shown = true;
+            post("rewarded_ad", void 0, Object.assign({ event: "started" }, base));
+            try {
+              showAdFn();
+            } catch (err) {
+              const showError = Object.assign(
+                { status: "error", error: "show_ad_error" },
+                base
+              );
+              post("rewarded_ad", void 0, Object.assign({ event: "error" }, showError));
+              safeCall(options.onError, showError);
+              done(showError);
+            }
+          }
+          post("rewarded_ad", void 0, Object.assign({ event: "ready" }, base));
+          try {
+            if (typeof options.beforeReward === "function") options.beforeReward(show);
+            else show();
+          } catch (err) {
+            const beforeError = Object.assign(
+              { status: "error", error: "before_reward_error" },
+              base
+            );
+            post("rewarded_ad", void 0, Object.assign({ event: "error" }, beforeError));
+            safeCall(options.onError, beforeError);
+            done(beforeError);
+          }
+        }
+        try {
+          adBreak({
+            type: "reward",
+            name: options.placement,
+            size: options.size || void 0,
+            beforeReward: startAd,
+            adViewed: function() {
+              status = "viewed";
+              const viewed = Object.assign({ status }, base);
+              post("rewarded_ad", void 0, Object.assign({ event: "viewed" }, viewed));
+              safeCall(options.adViewed, viewed);
+              safeCall(options.onReward, viewed);
+            },
+            adDismissed: function() {
+              if (status !== "viewed") status = "dismissed";
+              const dismissed = Object.assign({ status }, base);
+              post("rewarded_ad", void 0, Object.assign({ event: "dismissed" }, dismissed));
+              safeCall(options.adDismissed, dismissed);
+              safeCall(options.onDismissed, dismissed);
+            },
+            adBreakDone: function(placementInfo) {
+              const result = rewardOffered || status !== "unavailable" ? { status } : { status: "unavailable", error: "no_rewarded_ad" };
+              if (placementInfo && typeof placementInfo === "object") {
+                result.breakStatus = cleanText(
+                  placementInfo.breakStatus
+                );
+              }
+              if (result.status === "unavailable") {
+                post(
+                  "rewarded_ad",
+                  void 0,
+                  Object.assign({ event: "unavailable" }, base, result)
+                );
+                safeCall(
+                  options.onUnavailable,
+                  Object.assign({ status: "unavailable" }, base, result)
+                );
+              }
+              safeCall(options.adBreakDone, placementInfo);
+              done(result);
+            }
+          });
+        } catch (err) {
+          const error = Object.assign(
+            { status: "error", error: "ad_break_error" },
+            base
+          );
+          post("rewarded_ad", void 0, Object.assign({ event: "error" }, error));
+          safeCall(options.onError, error);
+          done(error);
+        }
+      });
+    });
+  }
+  function preloadRewardedAds(rawOptions) {
+    const options = normalizeRewardedOptions(rawOptions);
+    if (!areRewardedAdsEnabled()) return Promise.resolve(false);
+    return ensureAdPlacement(options).then(function(adBreak) {
+      if (typeof adBreak !== "function") return false;
+      requestAdPreload();
+      return true;
+    });
+  }
+  function whenHostConfig(graceMs) {
+    if (hostConfigReceived || !isEmbedded()) return Promise.resolve();
+    return new Promise(function(resolve) {
+      const timer = setTimeout(resolve, graceMs);
+      configWaiters.push(function() {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+  function getPlayer() {
+    if (blocked) return Promise.resolve(null);
+    return whenHostConfig(INIT_CONFIG_GRACE_MS).then(function() {
+      return hostPlayer ? { name: hostPlayer.name, avatarUrl: hostPlayer.avatarUrl } : null;
+    });
+  }
+  function init(options) {
+    configure(options);
+    post("init");
+    return whenHostConfig(INIT_CONFIG_GRACE_MS);
+  }
+  function ready() {
+    post("ready");
+  }
+  function normalizeRewardedBreakInput(optionsOrOnStart) {
+    if (typeof optionsOrOnStart === "function") return { onStart: optionsOrOnStart };
+    return optionsOrOnStart && typeof optionsOrOnStart === "object" ? optionsOrOnStart : {};
+  }
+  function rewardedBreak(optionsOrOnStart) {
+    const rawOptions = normalizeRewardedBreakInput(optionsOrOnStart);
+    const normalized = normalizeRewardedOptions(rawOptions);
+    const base = {
+      adBreakId: normalized.adBreakId,
+      placement: normalized.placement,
+      reward: normalized.reward
+    };
+    if (normalized.size) base.size = normalized.size;
+    if (rewardedBreakActive) {
+      post(
+        "rewarded_ad",
+        void 0,
+        Object.assign(
+          { event: "unavailable", status: "unavailable", error: "ad_in_progress" },
+          base
+        )
+      );
+      return Promise.resolve(false);
+    }
+    rewardedBreakActive = true;
+    let startCalled = false;
+    return rewardedAd(
+      Object.assign({}, rawOptions, {
+        beforeReward: function(showAd) {
+          if (startCalled) return;
+          startCalled = true;
+          safeCall(rawOptions.onStart);
+          showAd();
+        }
+      })
+    ).then(
+      function(result) {
+        rewardedBreakActive = false;
+        return Boolean(result && result.status === "viewed");
+      },
+      function() {
+        rewardedBreakActive = false;
+        return false;
+      }
+    );
+  }
+  window.addEventListener("message", function(event) {
+    if (event.source !== window.parent) return;
+    if (!hostnameAllowed(event.origin, DEFAULT_ALLOW)) return;
+    applyHostConfig(event.data);
+  });
+  const sdk = {
+    lockToHost,
+    init,
+    configure,
+    preloadRewardedAds,
+    preloadRewardedAd: preloadRewardedAds,
+    ready,
+    gameLoadingFinished: ready,
+    gameplayStart: function() {
+      post("gameplay_start");
+    },
+    gameplayStop: function() {
+      post("gameplay_stop");
+    },
+    submitScore: function(score, opts) {
+      post("score", score, opts && opts.mode === "daily" ? { mode: "daily" } : void 0);
+    },
+    gameOver: function(score, opts) {
+      post("gameover", score, opts && opts.mode === "daily" ? { mode: "daily" } : void 0);
+    },
+    xrSessionStart: function() {
+      post("xr_session_start");
+    },
+    xrSessionEnd: function() {
+      post("xr_session_end");
+    },
+    rewardedAd,
+    showRewardedAd: rewardedAd,
+    rewardedBreak,
+    save: function(blob) {
+      return request("save", String(blob));
+    },
+    load: function() {
+      return request("load");
+    },
+    getPlayer,
+    getVariant: function(key, variants) {
+      const sorted = Array.isArray(variants) ? variants.slice().sort() : [];
+      const fallback = sorted.length > 0 ? sorted[0] : null;
+      if (typeof key !== "string" || !key || sorted.length < 2) {
+        return Promise.resolve(fallback);
+      }
+      return request("experiment", { key, variants: sorted }).then(
+        function(variant) {
+          return typeof variant === "string" ? variant : fallback;
+        },
+        function() {
+          return fallback;
+        }
+      );
+    },
+    version: VERSION
+  };
+  sdk._request = request;
+  return sdk;
+}
+
+// src/inert.ts
+function sdkError2(code) {
+  const err = new Error(code);
+  err.code = code;
+  return err;
+}
+function createInertBBArcade() {
+  const noop = () => {
+  };
+  const unavailable = () => Promise.resolve({
+    status: "unavailable",
+    error: "ad_break_unavailable",
+    placement: "rewarded",
+    reward: "reward",
+    adBreakId: "bbad_inert"
+  });
+  return {
+    lockToHost: noop,
+    init: () => Promise.resolve(),
+    configure: noop,
+    preloadRewardedAds: () => Promise.resolve(false),
+    preloadRewardedAd: () => Promise.resolve(false),
+    ready: noop,
+    gameLoadingFinished: noop,
+    gameplayStart: noop,
+    gameplayStop: noop,
+    submitScore: noop,
+    gameOver: noop,
+    xrSessionStart: noop,
+    xrSessionEnd: noop,
+    rewardedAd: unavailable,
+    showRewardedAd: unavailable,
+    rewardedBreak: () => Promise.resolve(false),
+    save: () => Promise.reject(sdkError2("unsupported")),
+    load: () => Promise.reject(sdkError2("unsupported")),
+    getPlayer: () => Promise.resolve(null),
+    getVariant: (key, variants) => {
+      const sorted = Array.isArray(variants) ? variants.slice().sort() : [];
+      return Promise.resolve(sorted.length > 0 ? sorted[0] : null);
+    },
+    version: VERSION
+  };
+}
+
+// src/index.ts
+var BBArcade = typeof window === "undefined" ? createInertBBArcade() : createBBArcade();
+var src_default = BBArcade;
+
+export {
+  VERSION,
+  BBArcade,
+  src_default
+};
+//# sourceMappingURL=chunk-WCGBR3MI.js.map