@jolibox/sdk 1.1.12 → 1.1.13-beta.2

package/dist/index.js

@@ -0,0 +1,1519 @@
+"use strict";
+
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+(() => {
+  // ../common/dist/index.es.js
+  var k = Object.defineProperty;
+  var ye = Object.defineProperties;
+  var ge = Object.getOwnPropertyDescriptor;
+  var Ee = Object.getOwnPropertyDescriptors;
+  var F = Object.getOwnPropertySymbols;
+  var Te = Object.prototype.hasOwnProperty;
+  var xe = Object.prototype.propertyIsEnumerable;
+  var H = (n, e, t) => e in n ? k(n, e, {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: t
+  }) : n[e] = t;
+  var f = (n, e) => {
+    for (var t in e || (e = {})) Te.call(e, t) && H(n, t, e[t]);
+    if (F) for (var t of F(e)) xe.call(e, t) && H(n, t, e[t]);
+    return n;
+  };
+  var b = (n, e) => ye(n, Ee(e));
+  var Re = (n, e) => {
+    for (var t in e) k(n, t, {
+      get: e[t],
+      enumerable: true
+    });
+  };
+  var I = (n, e, t, r) => {
+    for (var o = r > 1 ? void 0 : r ? ge(e, t) : e, i = n.length - 1, a; i >= 0; i--) (a = n[i]) && (o = (r ? a(e, t, o) : a(o)) || o);
+    return r && o && k(e, t, o), o;
+  };
+  var A = (n, e, t) => new Promise((r, o) => {
+    var i = s => {
+        try {
+          m(t.next(s));
+        } catch (c) {
+          o(c);
+        }
+      },
+      a = s => {
+        try {
+          m(t.throw(s));
+        } catch (c) {
+          o(c);
+        }
+      },
+      m = s => s.done ? r(s.value) : Promise.resolve(s.value).then(i, a);
+    m((t = t.apply(n, e)).next());
+  });
+  if (typeof window != "undefined" && !window.AbortController) {
+    let n = function () {
+      this.signal = new e();
+    };
+    n.prototype.abort = function () {
+      this.signal._aborted = true, typeof this.signal.onabort == "function" && this.signal.onabort(new Event("abort"));
+      let t = new Event("abort");
+      this.signal.dispatchEvent(t);
+    };
+    let e = function () {
+      this._aborted = false, this.aborted = false, this.onabort = null, this._eventListeners = {};
+    };
+    Object.defineProperty(e.prototype, "aborted", {
+      get: function () {
+        return this._aborted;
+      }
+    }), e.prototype.addEventListener = function (t, r) {
+      this._eventListeners[t] || (this._eventListeners[t] = []), this._eventListeners[t].push(r);
+    }, e.prototype.removeEventListener = function (t, r) {
+      if (!this._eventListeners[t]) return;
+      let o = this._eventListeners[t].indexOf(r);
+      o !== -1 && this._eventListeners[t].splice(o, 1);
+    }, e.prototype.dispatchEvent = function (t) {
+      if (this._eventListeners[t.type]) for (let r of this._eventListeners[t.type]) r.call(this, t);
+    }, window.AbortController = n, window.AbortSignal = e;
+  }
+  function K(n) {
+    return new Promise(e => {
+      setTimeout(() => {
+        e();
+      }, n);
+    });
+  }
+  function L(n) {
+    return typeof n == "string";
+  }
+  function he(n) {
+    return typeof n == "object" && n !== null && !Array.isArray(n) && !(n instanceof RegExp) && !(n instanceof Date);
+  }
+  function _e(n) {
+    return typeof n == "undefined";
+  }
+  function M(n) {
+    return _e(n) || n === null;
+  }
+  function S(n) {
+    return typeof n == "function";
+  }
+  function C(n) {
+    let e = n,
+      t = null,
+      r = function () {
+        for (var _len = arguments.length, o = new Array(_len), _key = 0; _key < _len; _key++) {
+          o[_key] = arguments[_key];
+        }
+        return t || (t = new e(...o)), t;
+      };
+    return r.prototype = e.prototype, r;
+  }
+  var ve = (s => (s[s.DEVELOPER_FILE_NOT_FOUND = 0] = "DEVELOPER_FILE_NOT_FOUND", s[s.INTERNAL_IOS_CAN_NOT_FOUND_PKG = 1] = "INTERNAL_IOS_CAN_NOT_FOUND_PKG", s[s.USER_IOS_LOAD_TIMEOUT = 2] = "USER_IOS_LOAD_TIMEOUT", s[s.INTERNAL_IOS_PKG_LOAD_ERROR = 3] = "INTERNAL_IOS_PKG_LOAD_ERROR", s[s.INTERNAL_IOS_PKG_PARSE_FAIL = 4] = "INTERNAL_IOS_PKG_PARSE_FAIL", s[s.USER_IOS_GET_EMPTY_DATA = 5] = "USER_IOS_GET_EMPTY_DATA", s[s.USER_ANDROID_GET_PKG_FAIL = 6] = "USER_ANDROID_GET_PKG_FAIL", s[s.DEVELOPER_ANDROID_PACKAGE_FILE_UNEXPECTED_REQUIRE = 7] = "DEVELOPER_ANDROID_PACKAGE_FILE_UNEXPECTED_REQUIRE", s))(ve || {});
+  var h = class extends Error {
+    constructor(e) {
+      if (typeof e == "string") {
+        super(e), this.priority = "P1";
+        return;
+      }
+      super(e.message), this.priority = "P1", this.stack = e.stack, this.raw = e;
+    }
+  };
+  var u = class extends h {
+    constructor() {
+      super(...arguments);
+      this.kind = "INTERNAL_ERROR";
+    }
+  };
+  var Q = class extends u {
+    constructor() {
+      super(...arguments);
+      this.name = "INTERNAL_JS_MODULE_FETCH_ERROR";
+      this.priority = "P0";
+    }
+  };
+  var X = class extends u {
+    constructor() {
+      super(...arguments);
+      this.name = "INTERNAL_JS_MODULE_EVAL_ERROR";
+      this.priority = "P0";
+    }
+  };
+  function _(n) {
+    return function () {
+      var r, o;
+      ((o = (r = globalThis.VConsole) == null ? void 0 : r[n]) != null ? o : globalThis.console[n])(...arguments);
+    };
+  }
+  var ae = {
+    log: _("log"),
+    warn: _("warn"),
+    info: _("info"),
+    error: _("error"),
+    debug: _("debug")
+  };
+  Object.assign(globalThis, {
+    logger: ae
+  });
+  var de = Symbol.for("Jolibox.canIUseMap");
+  var Ie = {};
+  globalThis[de] = Ie;
+  var Ln = {
+    get config() {
+      return globalThis[de];
+    }
+  };
+  function Dn(n, e, t) {
+    let r = 0;
+    if (n !== e) {
+      let o = n.split("."),
+        i = e.split("."),
+        a = Math.max(o.length, i.length);
+      for (let m = 0; m < a; m++) {
+        let s = parseInt(o[m], 10) || 0,
+          c = parseInt(i[m], 10) || 0;
+        if (s > c) {
+          r = 1;
+          break;
+        } else if (s < c) {
+          r = -1;
+          break;
+        }
+      }
+    }
+    if (!t) return r;
+    switch (t) {
+      case ">":
+        return r > 0;
+      case "<":
+        return r < 0;
+      case "=":
+        return r === 0;
+      case ">=":
+        return r >= 0;
+      case "<=":
+        return r <= 0;
+      default:
+        return false;
+    }
+  }
+  var Ae = (r => (r[r.System = 1e3] = "System", r[r.ErrorTrace = 1001] = "ErrorTrace", r[r.UserDefined = 1002] = "UserDefined", r))(Ae || {});
+  var Ce = (i => (i.MiniGame = "mini-game", i.MiniDrama = "mini-drama", i.App = "app", i.WebSDK = "web-sdk", i.AppSDK = "app-sdk", i))(Ce || {});
+  var Ne = (d => (d[d.App = 0] = "App", d[d.H5 = 1] = "H5", d[d.Weapp = 2] = "Weapp", d[d.Alipay = 3] = "Alipay", d[d.Gcash = 4] = "Gcash", d[d.Dana = 5] = "Dana", d[d.Umma = 6] = "Umma", d[d.WebSDK = 1e3] = "WebSDK", d[d.AppSDK = 1001] = "AppSDK", d[d.Other = 9999] = "Other", d))(Ne || {});
+  var le = ["name", "params"];
+  var Oe = ["name", "type", "location", "target", "extra", "timestamp", "userId"];
+  var we = ["platform", "os", "appVersion", "appId", "model", "brand", "uuid", "jsSdkVersion", "extra"];
+  function O(n, e) {
+    return e.map(t => {
+      if (t === "params" && n[t]) {
+        let r = n[t];
+        return Object.keys(r).reduce((o, i) => (o[i] = String(r[i]), o), {});
+      }
+      return n[t];
+    });
+  }
+  function Pe(n) {
+    let e = n.location ? O(n.location, le) : null,
+      t = n.target ? O(n.target, le) : null;
+    return O(b(f({}, n), {
+      location: e,
+      target: t
+    }), Oe);
+  }
+  function Hn(n) {
+    let e = n.events.map(r => Pe(r)),
+      t = O(n.device, we);
+    return [n.protocolVersion, e, t, n.project];
+  }
+  var me = () => "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, n => {
+    let e = Math.random() * 16 | 0;
+    return (n === "x" ? e : e & 3 | 8).toString(16);
+  });
+  var w = {
+    isiOS: navigator.userAgent.includes("iPhone") || navigator.userAgent.includes("iPod") || navigator.userAgent.includes("iPad") || navigator.userAgent.includes("iPhone OS"),
+    iosVersion: () => {
+      let n = navigator.appVersion.match(/OS (\d+)_(\d+)_?(\d+)?/);
+      return [parseInt(n[1], 10), parseInt(n[2], 10), parseInt(n[3] || "0", 10)];
+    },
+    isAndroid: navigator.userAgent.includes("Android"),
+    isMac: navigator.userAgent.includes("Mac"),
+    isFacebook: navigator.userAgent.includes("FB_IAB"),
+    isPC: !navigator.userAgent.includes("iPhone") && !navigator.userAgent.includes("Android")
+  };
+  var ke = () => w.isiOS ? "iOS" : w.isAndroid ? "Android" : w.isMac ? "Mac" : w.isFacebook ? "Facebook" : "PC";
+  var Le = "device_id";
+  var Me = "advertising_id";
+  var ce = n => (localStorage.getItem(n) || localStorage.setItem(n, me()), localStorage.getItem(n));
+  var Se = () => ce(Le);
+  var Ue = () => ce(Me);
+  var De = n => n.charAt(0).toUpperCase() + n.slice(1);
+  var Ve = () => {
+    var e;
+    let n = new URLSearchParams(window.location.search);
+    return De((e = n.get("utm_source")) != null ? e : "") || "JoliboxSDK";
+  };
+  var Wn = n => {
+    let e = "JoliboxWebSDK",
+      t = ke(),
+      r = navigator.language,
+      o = Se(),
+      i = Ue();
+    return `${e} (${Ve()}${t}; UnknownModel; UnknownSystemVersion; ${r}) uuid/${o} adid/${i} version/${n || ""}`;
+  };
+  var E = class E2 {
+    constructor(e) {
+      this.element = e, this.next = E2.Undefined, this.prev = E2.Undefined;
+    }
+  };
+  E.Undefined = new E(void 0);
+  var l = E;
+  var P = class {
+    constructor() {
+      this._first = l.Undefined;
+      this._last = l.Undefined;
+      this._size = 0;
+    }
+    get size() {
+      return this._size;
+    }
+    isEmpty() {
+      return this._first === l.Undefined;
+    }
+    clear() {
+      let e = this._first;
+      for (; e !== l.Undefined;) {
+        let t = e.next;
+        e.prev = l.Undefined, e.next = l.Undefined, e = t;
+      }
+      this._first = l.Undefined, this._last = l.Undefined, this._size = 0;
+    }
+    unshift(e) {
+      return this._insert(e, false);
+    }
+    push(e) {
+      return this._insert(e, true);
+    }
+    _insert(e, t) {
+      let r = new l(e);
+      if (this._first === l.Undefined) this._first = r, this._last = r;else if (t) {
+        let i = this._last;
+        this._last = r, r.prev = i, i.next = r;
+      } else {
+        let i = this._first;
+        this._first = r, r.next = i, i.prev = r;
+      }
+      this._size += 1;
+      let o = false;
+      return () => {
+        o || (o = true, this._remove(r));
+      };
+    }
+    shift() {
+      if (this._first !== l.Undefined) {
+        let e = this._first.element;
+        return this._remove(this._first), e;
+      }
+    }
+    pop() {
+      if (this._last !== l.Undefined) {
+        let e = this._last.element;
+        return this._remove(this._last), e;
+      }
+    }
+    _remove(e) {
+      if (e.prev !== l.Undefined && e.next !== l.Undefined) {
+        let t = e.prev;
+        t.next = e.next, e.next.prev = t;
+      } else e.prev === l.Undefined && e.next === l.Undefined ? (this._first = l.Undefined, this._last = l.Undefined) : e.next === l.Undefined ? (this._last = this._last.prev, this._last.next = l.Undefined) : e.prev === l.Undefined && (this._first = this._first.next, this._first.prev = l.Undefined);
+      this._size -= 1;
+    }
+    *[Symbol.iterator]() {
+      let e = this._first;
+      for (; e !== l.Undefined;) yield e.element, e = e.next;
+    }
+  };
+  var Fe = 0;
+  var T = class {
+    constructor(e) {
+      this.value = e;
+      this.id = Fe++;
+    }
+  };
+  var p = class {
+    constructor(e) {
+      this.options = e;
+      this._size = 0;
+    }
+    dispose(e) {
+      var t, r;
+      this._disposed || (this._disposed = true, this._listeners && (e ? (this._listeners instanceof T && (this._listeners = [this._listeners]), this._listeners = this._listeners.filter(o => (o == null ? void 0 : o.value) === e)) : (this._listeners = void 0, this._size = 0)), (r = (t = this.options) == null ? void 0 : t.onDidRemoveLastListener) == null || r.call(t));
+    }
+    get event() {
+      var e;
+      return (e = this._event) != null || (this._event = (t, r) => {
+        var i, a, m, s, c, d;
+        if (this._disposed) return () => {
+          console.info("[Jolibox SDK] Emitter is _disposed");
+        };
+        r && (t = t.bind(r));
+        let o = new T(t);
+        this._listeners ? this._listeners instanceof T ? this._listeners = [this._listeners, o] : this._listeners.push(o) : ((a = (i = this.options) == null ? void 0 : i.onWillAddFirstListener) == null || a.call(i, this), this._listeners = o, (s = (m = this.options) == null ? void 0 : m.onDidFirstListener) == null || s.call(m, this)), (d = (c = this.options) == null ? void 0 : c.onDidAddListener) == null || d.call(c, this), this._size++;
+      }), this._event;
+    }
+    _deliver(e, t) {
+      var o;
+      if (!e) return;
+      let r = ((o = this.options) == null ? void 0 : o.onListenerError) || Error.constructor;
+      if (!r) {
+        e.value(t);
+        return;
+      }
+      try {
+        e.value(t);
+      } catch (i) {
+        r(i);
+      }
+    }
+    fire(e) {
+      this._listeners && (this._listeners instanceof T ? this._deliver(this._listeners, e) : this._listeners.forEach(t => this._deliver(t, e)));
+    }
+    hasListeners() {
+      return this._size > 0;
+    }
+  };
+  var v = class {
+    constructor() {
+      this.listeners = /* @__PURE__ */new Map();
+      this.listerHandlerMap = /* @__PURE__ */new WeakMap();
+      this.cachedEventQueue = /* @__PURE__ */new Map();
+    }
+    on(e, t) {
+      var a;
+      let r = (a = this.listeners.get(e)) != null ? a : new p(),
+        o = m => t(...m.args);
+      this.listerHandlerMap.set(t, o), r.event(o), this.listeners.set(e, r);
+      let i = this.cachedEventQueue.get(e);
+      if (i) for (; i.size > 0;) r.fire(f({
+        event: e
+      }, i.shift()));
+    }
+    off(e, t) {
+      let r = this.listeners.get(e);
+      if (r) {
+        let o = this.listerHandlerMap.get(t);
+        r.dispose(o);
+      }
+    }
+    emit(e) {
+      let r = this.listeners.get(e);
+      for (var _len2 = arguments.length, t = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        t[_key2 - 1] = arguments[_key2];
+      }
+      if (r) r.fire({
+        event: e,
+        args: t
+      });else {
+        let o = this.cachedEventQueue.get(e);
+        o || (o = new P(), this.cachedEventQueue.set(e, o)), o.push({
+          args: t
+        });
+      }
+    }
+  };
+  var x = {};
+  Re(x, {
+    None: () => He,
+    filter: () => Ke,
+    once: () => ue,
+    toPromise: () => je
+  });
+  var He = () => {
+    console.log("[Jolibox SDK] None Event");
+  };
+  function je(n) {
+    return new Promise(e => ue(n)(e));
+  }
+  function ue(n) {
+    return function (e) {
+      let t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      let r = false;
+      return n(i => {
+        if (!r) return r = true, e.call(t, i);
+      }, null);
+    };
+  }
+  function Ke(n, e) {
+    return (r => {
+      let o,
+        i = {
+          onWillAddFirstListener() {
+            o = r(a.fire, a);
+          }
+        },
+        a = new p(i);
+      return a.event;
+    })(function (r) {
+      let o = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      return n(i => e(i) && r.call(o, i), null);
+    });
+  }
+  var U = Symbol.for("Jolibox.hostEmitter");
+  var Ge = () => {
+    let n = new v();
+    return globalThis[U] || (globalThis[U] = {
+      on: n.on.bind(n),
+      off: n.off.bind(n),
+      emit: n.emit.bind(n)
+    }), globalThis[U];
+  };
+  var vt = Ge();
+  function pe(n, e) {
+    let t = Math.min(n.length, e.length);
+    for (let r = 0; r < t; r++) Je(n[r], e[r]);
+  }
+  function Je(n, e) {
+    if (L(e)) {
+      if (typeof n !== e) throw new Error(`argument does not match constraint: typeof ${e}`);
+    } else if (S(e)) {
+      try {
+        if (n instanceof e) return;
+      } catch (t) {}
+      if (!M(n) && n.constructor === e || e.length === 1 && e.call(void 0, n) === true) return;
+      throw new Error("[Jolibox SDK]argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true");
+    }
+  }
+  var y = class {
+    constructor() {
+      this._commands = /* @__PURE__ */new Map();
+      this._onDidRegisterCommand = new p();
+      this.onDidRegisterCommand = this._onDidRegisterCommand.event;
+      console.log("[Jolibox SDK] command registry");
+    }
+    registerCommand(e) {
+      if (!e) throw new Error("invalid command");
+      if (e.metadata && Array.isArray(e.metadata.args)) {
+        let o = [];
+        for (let a of e.metadata.args) o.push(a.constraint);
+        let i = e.handler;
+        e.handler = function () {
+          for (var _len3 = arguments.length, a = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+            a[_key3] = arguments[_key3];
+          }
+          return pe(a, o), i(...a);
+        };
+      }
+      let {
+        id: t
+      } = e;
+      this._commands.get(t) && console.info(`[Jolibox SDK] duplicated command is registered ${t}`), this._commands.set(t, e), this._onDidRegisterCommand.fire(t);
+    }
+    getCommand(e) {
+      return this._commands.get(e);
+    }
+    getCommands() {
+      let e = /* @__PURE__ */new Map();
+      for (let t of this._commands.keys()) {
+        let r = this.getCommand(t);
+        r && e.set(t, r);
+      }
+      return e;
+    }
+  };
+  y = I([C], y);
+  var R = class {
+    constructor() {
+      this._onWillExecuteCommand = new p();
+      this.onWillExecuteCommand = this._onWillExecuteCommand.event;
+      this._onDidExecuteCommand = new p();
+      this.onDidExecuteCommand = this._onDidExecuteCommand.event;
+      this.registry = new y();
+      this._starActivation = null;
+    }
+    _activateStar() {
+      return this._starActivation || (this._starActivation = K(3e4)), this._starActivation;
+    }
+    executeCommand(e) {
+      for (var _len4 = arguments.length, t = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+        t[_key4 - 1] = arguments[_key4];
+      }
+      return A(this, null, function* () {
+        return this.registry.getCommand(e) ? this._tryExecuteCommand(e, t) : (yield Promise.all([Promise.race([this._activateStar(), x.toPromise(x.filter(this.registry.onDidRegisterCommand, o => o === e))])]), this._tryExecuteCommand(e, t));
+      });
+    }
+    executeCommandThowErr(e) {
+      if (!!!this.registry.getCommand(e)) throw new Error(`command '${e}' not found`);
+      let o = this.registry.getCommand(e);
+      for (var _len5 = arguments.length, t = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+        t[_key5 - 1] = arguments[_key5];
+      }
+      this._onWillExecuteCommand.fire({
+        commandId: e,
+        args: t
+      });
+      let i = this.invokeFunction(o.handler, ...t);
+      return this._onDidExecuteCommand.fire({
+        commandId: e,
+        args: t
+      }), i;
+    }
+    _tryExecuteCommand(e, t) {
+      let r = this.registry.getCommand(e);
+      if (!r) return Promise.reject(new Error(`command '${e}' not found`));
+      try {
+        this._onWillExecuteCommand.fire({
+          commandId: e,
+          args: t
+        });
+        let o = this.invokeFunction(r.handler, ...t);
+        return this._onDidExecuteCommand.fire({
+          commandId: e,
+          args: t
+        }), Promise.resolve(o);
+      } catch (o) {
+        return Promise.reject(o);
+      }
+    }
+    invokeFunction(e) {
+      let r = false;
+      try {
+        for (var _len6 = arguments.length, t = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {
+          t[_key6 - 1] = arguments[_key6];
+        }
+        return e(...t);
+      } finally {
+        r = true;
+      }
+    }
+  };
+  R = I([C], R);
+  var D = Symbol.for("Jolibox.commands");
+  function qt() {
+    if (globalThis[D]) return globalThis[D];
+    let n = new y(),
+      e = new R(),
+      t = {
+        registerCommand(r, o, i) {
+          n.registerCommand({
+            id: r,
+            handler: o,
+            metadata: i
+          });
+        },
+        executeCommand(r) {
+          for (var _len7 = arguments.length, o = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
+            o[_key7 - 1] = arguments[_key7];
+          }
+          return e.executeCommand(r, ...o);
+        },
+        excuteCommandSync(r) {
+          for (var _len8 = arguments.length, o = new Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {
+            o[_key8 - 1] = arguments[_key8];
+          }
+          return e.executeCommandThowErr(r, ...o);
+        }
+      };
+    return globalThis[D] = t, t;
+  }
+
+  // src/utils/env.ts
+  var testMode = new URLSearchParams(window.location.search).get("joliboxEnv") === "staging";
+
+  // src/utils/event-tracker.ts
+  function getLocation() {
+    const urlParams = new URLSearchParams(window.location.search);
+    const params = {};
+    urlParams.forEach((value, key) => {
+      params[key] = value;
+    });
+    return {
+      name: "GamePage",
+      params
+    };
+  }
+  function getDevice() {
+    return {
+      platform: 1e3,
+      os: "h5",
+      appVersion: "__JOLIBOX_LOCAL_SDK_VERSION__",
+      // mock
+      appId: "1",
+      model: "UnknownModel",
+      brand: "UnknownBrand",
+      uuid: "1",
+      jsSdkVersion: "__JOLIBOX_LOCAL_SDK_VERSION__",
+      // mock
+      extra: {}
+    };
+  }
+  var hostToApiMap = {
+    default: {
+      test: "https://stg-collect.jolibox.com",
+      prod: "https://collect.jolibox.com"
+    },
+    "oss.jolibox.com": {
+      test: "https://stg-collect.jolibox.com",
+      prod: "https://collect.jolibox.com"
+    },
+    "oss.pico-game.com": {
+      test: "https://stg-collect.pico-game.com",
+      prod: "https://collect.pico-game.com"
+    }
+  };
+  var apiBaseURL = () => {
+    const api = hostToApiMap[window.location.host] ?? hostToApiMap.default;
+    return testMode ? api.test : api.prod;
+  };
+  var API_BASE_URL = apiBaseURL();
+  var timeoutFn = ms => {
+    const ctrl = new AbortController();
+    setTimeout(() => ctrl.abort(), ms);
+    return ctrl.signal;
+  };
+  AbortSignal.timeout ??= timeoutFn;
+  var getJoliSource = () => {
+    const urlParams = new URLSearchParams(window.location.search);
+    return urlParams.get("joliSource") ?? null;
+  };
+  var JOLI_SOURCE = getJoliSource();
+  var postToReporter = async data => {
+    try {
+      const reporterHost = API_BASE_URL;
+      const url = `${reporterHost}/report`;
+      const xua = Wn("__JOLIBOX_LOCAL_SDK_VERSION__");
+      const joliSource = JOLI_SOURCE;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (xua) headers["x-user-agent"] = xua;
+      if (joliSource) headers["x-joli-source"] = joliSource;
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(data),
+        signal: timeoutFn(5e3)
+      });
+      return response;
+    } catch (error) {
+      console.error("Error posting to reporter:", error);
+      return null;
+    }
+  };
+  async function trackError(errorData) {
+    try {
+      const errEvent = {
+        name: "globalJsError",
+        type: Ae.ErrorTrace,
+        location: getLocation(),
+        target: null,
+        extra: errorData,
+        timestamp: Date.now(),
+        userId: null
+      };
+      const device = getDevice();
+      const events = [errEvent];
+      const eventPackage = {
+        protocolVersion: "1.0.0",
+        events,
+        device,
+        project: Ce.WebSDK
+      };
+      const serializedEventPackage = Hn(eventPackage);
+      await postToReporter(serializedEventPackage);
+    } catch (error) {
+      console.error("Failed to track error:", error);
+    }
+  }
+
+  // src/events.ts
+  document.addEventListener("DOMContentLoaded", () => vt.emit("onDocumentReady", timeline.startTime));
+  var timelineFactory = () => {
+    let _beginLoad = 0;
+    return {
+      set startTime(time) {
+        _beginLoad = time;
+      },
+      get startTime() {
+        return _beginLoad;
+      }
+    };
+  };
+  var timeline = timelineFactory();
+  var commands = qt();
+  var rejectHandler = event => {
+    commands.executeCommand("ReportSDK.traceSystem", {
+      event: "globalJsError",
+      info: {
+        err: JSON.stringify(event)
+      }
+    }).catch(e => {
+      console.error(`Fallback report: ${e} ${JSON.stringify(event)}`);
+      trackError({
+        err: JSON.stringify({
+          message: e.message,
+          source: e.source,
+          lineno: e.lineno,
+          colno: e.colno,
+          error: e.error
+        })
+      });
+    });
+  };
+  var reportError = rejectHandler;
+  window.addEventListener("unhandledrejection", rejectHandler.bind(void 0));
+  window.addEventListener("error", rejectHandler.bind(void 0));
+  window.onerror = (message, source, lineno, colno, error) => {
+    commands.executeCommand("ReportSDK.traceSystem", {
+      event: "globalJsError",
+      info: {
+        err: JSON.stringify({
+          message,
+          source,
+          lineno,
+          colno,
+          error
+        })
+      }
+    }).catch(e => {
+      trackError({
+        err: JSON.stringify({
+          message,
+          source,
+          lineno,
+          colno,
+          error
+        })
+      });
+    });
+  };
+
+  // src/loader/version.ts
+  var splitSemver = version => {
+    const prerelease = version.split("-")[1];
+    if (prerelease) {
+      version = version.replace(`-${prerelease}`, "");
+    }
+    const build = version.split("+")[1];
+    if (build) {
+      version = version.replace(`+${build}`, "");
+    }
+    const splitted = version.split(".").slice(0, 3);
+    const [major2, minor, patch] = [splitted[0] ?? "0", splitted[1] ?? "0", splitted[2] ?? "0"];
+    return {
+      major: major2,
+      minor,
+      patch,
+      prerelease,
+      build
+    };
+  };
+  var major = version => parseInt(splitSemver(version).major, 10);
+  var compare = (v1, v2) => {
+    const {
+      major: major1,
+      minor: minor1,
+      patch: patch1,
+      prerelease: pre1
+    } = splitSemver(v1);
+    const {
+      major: major2,
+      minor: minor2,
+      patch: patch2,
+      prerelease: pre2
+    } = splitSemver(v2);
+    if (major1 !== major2) {
+      return major1 > major2 ? 1 : -1;
+    }
+    if (minor1 !== minor2) {
+      return minor1 > minor2 ? 1 : -1;
+    }
+    if (patch1 !== patch2) {
+      return patch1 > patch2 ? 1 : -1;
+    }
+    if (pre1 && !pre2) return -1;
+    if (!pre1 && pre2) return 1;
+    if (pre1 && pre2) {
+      return pre1 > pre2 ? 1 : pre1 < pre2 ? -1 : 0;
+    }
+    return 0;
+  };
+
+  // src/utils/report.ts
+  var commands2 = qt();
+  var track = (event, info) => {
+    commands2.executeCommand("ReportSDK.traceSystem", {
+      event,
+      info
+    });
+  };
+  var trackPerformance = (event, duration, extra) => {
+    commands2.executeCommand("ReportSDK.traceSystemTimeline", {
+      event,
+      duration,
+      extra
+    });
+  };
+
+  // src/loader/local-storage.ts
+  function getOriginalLocalStorage() {
+    try {
+      if (window.__joliboxLocalStorage__) {
+        return window.__joliboxLocalStorage__;
+      }
+      let originalDescriptor = Object.getOwnPropertyDescriptor(window, "localStorage");
+      if (originalDescriptor && originalDescriptor.get) {
+        const originalLocalStorage = originalDescriptor.get.call(window);
+        window.__joliboxLocalStorage__ = originalLocalStorage;
+        return originalLocalStorage;
+      }
+      originalDescriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(window), "localStorage");
+      if (originalDescriptor && originalDescriptor.get) {
+        const originalLocalStorage = originalDescriptor.get.call(window);
+        return originalLocalStorage;
+      }
+      const windowProto = Window.prototype;
+      const protoDescriptor = Object.getOwnPropertyDescriptor(windowProto, "localStorage");
+      if (protoDescriptor && protoDescriptor.get) {
+        const protoLocalStorage = protoDescriptor.get.call(window);
+        window.__joliboxLocalStorage__ = protoLocalStorage;
+        return protoLocalStorage;
+      }
+      return localStorage;
+    } catch (e) {
+      console.warn("Failed to get original localStorage, fallback to default implementation", e);
+      return localStorage;
+    }
+  }
+
+  // src/loader/h5.ts
+  var LOCAL_STORE_KEY = "jolibox-sdk-loadermeta";
+  getOriginalLocalStorage();
+  var CURRENT_VERSION_STORE = JSON.parse(window.__joliboxLocalStorage__.getItem(LOCAL_STORE_KEY) ?? "{}");
+  var now = Date.now();
+  var expired = (now2, prev) => now2 > prev && Math.abs(now2 - prev) / (1e3 * 60 * 60 * 24) >= 7;
+  var isLegalScript = str => !/^(Failed to fetch version|Couldn't find the requested file)/.test(str);
+  async function fetchCurrentRemoteScript() {
+    const host = testMode ? "https://stg-api.jolibox.com" : "https://api.jolibox.com";
+    const path = `${host}/api/fe-configs/js-sdk/version-metadata`;
+    try {
+      const response = await fetch(path, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      const {
+        implement_version,
+        bootstrap_version
+      } = await response.json();
+      let currentStore = {
+        ...CURRENT_VERSION_STORE,
+        timestamp: now
+      };
+      if (bootstrap_version) {
+        const {
+          bootstrap_version: currentLocalBootstrapVersion
+        } = CURRENT_VERSION_STORE;
+        if (currentLocalBootstrapVersion && compare(currentLocalBootstrapVersion, bootstrap_version) >= 0) {} else {
+          const currentBootstrapModuleStr = await (await fetch(getBoostrapModuleUrl(bootstrap_version))).text();
+          isLegalScript(currentBootstrapModuleStr) && (currentStore = {
+            ...currentStore,
+            bootstrap_version,
+            bootstrap_script: currentBootstrapModuleStr
+          });
+        }
+      }
+      if (implement_version) {
+        const {
+          implement_version: currentLocalImpelementVersion
+        } = CURRENT_VERSION_STORE;
+        if (currentLocalImpelementVersion && compare(currentLocalImpelementVersion, implement_version) >= 0) {} else {
+          const currentImplementModuleStr = await (await fetch(getImplementModuleUrl(implement_version))).text();
+          isLegalScript(currentImplementModuleStr) && (currentStore = {
+            ...currentStore,
+            implement_version,
+            implement_script: currentImplementModuleStr
+          });
+        }
+      }
+      window.__joliboxLocalStorage__.setItem(LOCAL_STORE_KEY, JSON.stringify(currentStore));
+    } catch (error) {
+      console.warn("Failed to fetch loader metadata: ", error);
+    }
+  }
+  var createLoadImplement = params => {
+    const {
+      currentMajorVersion: currentMajorVersion2,
+      currentVersion: currentVersion2,
+      bootstrapUrl,
+      implementUrl
+    } = params;
+    function fetchCurrentBootstrapModule() {
+      const {
+        bootstrap_version,
+        bootstrap_script,
+        timestamp
+      } = CURRENT_VERSION_STORE;
+      if (bootstrap_version && bootstrap_script && timestamp) {
+        if (!expired(now, timestamp) && major(bootstrap_version) == currentMajorVersion2 && compare(bootstrap_version, currentVersion2) >= 0) {
+          return {
+            script: bootstrap_script,
+            type: "localscript"
+          };
+        }
+      }
+      try {
+        const xhr = new XMLHttpRequest();
+        xhr.open("GET", bootstrapUrl, false);
+        xhr.send();
+        return {
+          script: xhr.responseText,
+          type: "fetch_from_cdn"
+        };
+      } catch (e) {
+        const internalError = new Q(`Bootstrap module faile to fetch ${e}`);
+        trackError({
+          err: `${internalError}`
+        });
+      }
+    }
+    function loadBootstrapModule() {
+      const startToLoad = Date.now();
+      track("jsSdkBegin", {
+        t: startToLoad
+      });
+      timeline.startTime = startToLoad;
+      const {
+        script: currentBootstrapModule,
+        type
+      } = fetchCurrentBootstrapModule() ?? {};
+      if (currentBootstrapModule) {
+        const script = document.createElement("script");
+        script.type = "text/javascript";
+        script.innerHTML = currentBootstrapModule;
+        document.head.appendChild(script);
+        trackPerformance("bootstrapModuleLoaded", Date.now() - startToLoad, {
+          type
+        });
+      }
+    }
+    function evalLocalJSModule(code) {
+      const evalJS = async code2 => {
+        try {
+          const blob = new Blob([code2], {
+            type: "application/javascript"
+          });
+          const blobUrl = URL.createObjectURL(blob);
+          const module = await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))(blobUrl);
+          URL.revokeObjectURL(blobUrl);
+          return module;
+        } catch (error) {
+          const internalError = new X(`implement module evaluate error in h5:${error} `);
+          trackError({
+            err: `${internalError}`
+          });
+        }
+      };
+      evalJS(code);
+    }
+    function loadRemoteImplement() {
+      const implStartLoad = Date.now();
+      const {
+        implement_script,
+        implement_version,
+        timestamp
+      } = CURRENT_VERSION_STORE;
+      if (implement_script && implement_version && timestamp) {
+        if (!expired(now, timestamp) && major(implement_version) == currentMajorVersion2 && compare(implement_version, currentVersion2) >= 0) {
+          evalLocalJSModule(implement_script);
+          trackPerformance("implementModuleLoaded", Date.now() - implStartLoad, {
+            type: "loadscript"
+          });
+          return;
+        }
+      }
+      const asyncScript = document.createElement("script");
+      asyncScript.type = "module";
+      asyncScript.crossOrigin = "anonymous";
+      asyncScript.src = implementUrl;
+      asyncScript.onload = () => {
+        trackPerformance("implementModuleLoaded", Date.now() - implStartLoad, {
+          type: "fetch_from_cdn"
+        });
+      };
+      document.head.appendChild(asyncScript);
+    }
+    return () => {
+      try {
+        loadBootstrapModule();
+        loadRemoteImplement();
+        fetchCurrentRemoteScript();
+      } catch (e) {
+        const internalError = new X(`module evaluate error: ${e}`);
+        trackError({
+          err: `${internalError}`
+        });
+      }
+    };
+  };
+
+  // src/loader/native.ts
+  var createLoadImplement2 = (loadScript2, params) => {
+    const tryLoadScript = url => {
+      const funStr = loadScript2({
+        path: url
+      });
+      if (!funStr) {
+        throw `module ${url} load failed ${funStr}`;
+      }
+      return funStr;
+    };
+    function evalLocalJSModule(code) {
+      const evalJS = async code2 => {
+        try {
+          const blob = new Blob([code2], {
+            type: "application/javascript"
+          });
+          const blobUrl = URL.createObjectURL(blob);
+          const module = await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))(blobUrl);
+          URL.revokeObjectURL(blobUrl);
+          return module;
+        } catch (error) {
+          reportError(new X(`implement module evaluate error in native:${error} `));
+        }
+      };
+      evalJS(code);
+    }
+    return () => {
+      try {
+        const startToLoad = Date.now();
+        track("jsSdkBegin", {
+          t: startToLoad
+        });
+        timeline.startTime = startToLoad;
+        const bootstrapModuleStr = tryLoadScript(params.bootstrapUrl);
+        const script = document.createElement("script");
+        script.type = "text/javascript";
+        script.innerHTML = bootstrapModuleStr;
+        document.head.appendChild(script);
+        trackPerformance("bootstrapModuleLoaded", Date.now() - startToLoad, {
+          type: "native"
+        });
+        const implStartLoad = Date.now();
+        const implModuleStr = tryLoadScript(params.implementUrl);
+        evalLocalJSModule(implModuleStr);
+        trackPerformance("implementModuleLoaded", Date.now() - implStartLoad, {
+          type: "native"
+        });
+      } catch (e) {
+        console.error(`native load script error: ${e}`);
+        reportError(new X(`module load failed ${e}`));
+      }
+    };
+  };
+
+  // src/loader/index.ts
+  var BUILD_VERSION = "__JOLIBOX_LOCAL_SDK_VERSION__";
+  var currentVersion = BUILD_VERSION;
+  var currentMajorVersion = major(currentVersion);
+  var isNative = !!(navigator.userAgent || "").includes("JoliboxPlatformSDK");
+  var loadScript = isNative ? params => {
+    const res = window.prompt("invoke", JSON.stringify({
+      event: "loadScriptSync",
+      paramsString: JSON.stringify(params)
+    }));
+    if (res) {
+      const {
+        data
+      } = JSON.parse(res);
+      return data;
+    }
+    return void 0;
+  } : void 0;
+  var getBoostrapModuleUrl = version => `https://cdn.jsdelivr.net/npm/@jolibox/bootstrap@${version}/dist/index.js`;
+  var getImplementModuleUrl = version => `https://cdn.jsdelivr.net/npm/@jolibox/implement@${version}/dist/index.js`;
+  var checkReleaseVersion = version => {
+    const semverRegex = /^\d+\.\d+\.\d+$/;
+    return semverRegex.test(version);
+  };
+  var fetchVersion = !checkReleaseVersion(currentVersion) ? currentVersion : currentMajorVersion;
+  var IMMEDIATE_SCRIPT_URL = getBoostrapModuleUrl(fetchVersion);
+  var REMOTE_IMPLEMENT_URL = getImplementModuleUrl(fetchVersion);
+  function loadImplement() {
+    if (isNative) {
+      createLoadImplement2(loadScript, {
+        bootstrapUrl: IMMEDIATE_SCRIPT_URL,
+        implementUrl: REMOTE_IMPLEMENT_URL
+      })();
+    } else {
+      createLoadImplement({
+        bootstrapUrl: IMMEDIATE_SCRIPT_URL,
+        implementUrl: REMOTE_IMPLEMENT_URL,
+        currentMajorVersion,
+        currentVersion
+      })();
+    }
+  }
+  loadImplement();
+
+  // src/api/get-system-info.ts
+  var commands3 = qt();
+  function getSystemInfoSync() {
+    return commands3.excuteCommandSync("API.getSystemInfoSync");
+  }
+  function env() {
+    return commands3.excuteCommandSync("API.env");
+  }
+
+  // src/utils/can-i-use.ts
+  function getCanIUseConfig(platform, key) {
+    return Ln.config[platform]?.[key];
+  }
+  function get(obj, path, defaultValue) {
+    const pathArray = Array.isArray(path) ? path : path.replace(/\[(\d+)\]/g, ".$1").split(".");
+    let result = obj;
+    for (const key of pathArray) {
+      if (result && (typeof result === "object" || Array.isArray(result))) {
+        result = result[key];
+      } else {
+        return defaultValue;
+      }
+    }
+    return result === void 0 ? defaultValue : result;
+  }
+
+  // src/api/can-i-use.ts
+  var __VERSION__ = "__JOLIBOX_LOCAL_SDK_VERSION__";
+  function canIUse(schema) {
+    const env2 = env();
+    const platform = env2.data?.deviceInfo?.platform;
+    if (!platform) {
+      return false;
+    }
+    const [name, ...rest] = schema.split(":");
+    const api = getCanIUseConfig(platform == "h5" ? platform : "native", name);
+    if (!api) return false;
+    const apiVersion = api["version"];
+    if (typeof apiVersion !== "string") return false;
+    if (Dn(__VERSION__, apiVersion, "<")) return false;
+    if (rest.length === 0) return true;
+    return checkRest(api, rest) || checkRest(api["properties"], rest);
+  }
+  function checkRest(info, paths) {
+    if (!info) return false;
+    const v2 = get(info, paths);
+    if (!v2) return false;
+    if (he(v2)) return true;
+    if (L(v2)) return Dn(__VERSION__, v2, ">=");
+    return false;
+  }
+
+  // src/api/login.ts
+  var commands4 = qt();
+  async function login() {
+    if (!canIUse("login")) {
+      return {
+        code: "FAILURE",
+        message: "[Jolibox SDK]login is not supported in this platform"
+      };
+    }
+    return await commands4.executeCommand("API.login");
+  }
+  async function checkSession() {
+    if (!canIUse("checkSession")) {
+      return {
+        code: "FAILURE",
+        message: "[Jolibox SDK]checkSession is not supported in this platform"
+      };
+    }
+    return await commands4.executeCommand("API.checkSession");
+  }
+
+  // src/api/request.ts
+  var commands5 = qt();
+  async function request(params) {
+    if (!canIUse("request")) {
+      return {
+        code: "FAILURE",
+        message: "[Jolibox SDK]request is not supported in this platform"
+      };
+    }
+    return await commands5.executeCommand("HttpSDK.request", params);
+  }
+
+  // src/sdks/runtime.ts
+  var FallbackJoliboxRuntime = class {
+    constructor() {
+      /**
+       * Notify the end of the loading, will close the loading splash screen
+       */
+      this.loadFinished = () => {
+        const loadFinishedEvent = new Event("JOLIBOX_RUNTIME_LOAD_FINISHED" /* LOAD_FINISHED */);
+        window.dispatchEvent(loadFinishedEvent);
+      };
+      /**
+       * Notify the progress of the loading, will update the loading splash screen
+       * @param progress - The progress of the loading, should be an integer between 0 and 100
+       */
+      this.notifyLoadProgress = progress => {
+        const detail = Math.ceil(progress);
+        const event = new CustomEvent("JOLIBOX_RUNTIME_LOAD_PROGRESS" /* LOAD_PROGRESS */, {
+          detail
+        });
+        window.dispatchEvent(event);
+      };
+    }
+  };
+  var RuntimeSDK = window.JoliboxRuntime || FallbackJoliboxRuntime;
+
+  // src/sdks/sdk.ts
+  var BaseSDK = class {
+    constructor() {
+      this.commands = qt();
+      this._emitter = new v();
+    }
+    addEventListener(event, callback) {
+      this._emitter.on(event, function () {
+        return callback(arguments.length <= 0 ? undefined : arguments[0]);
+      });
+    }
+    triggerEvent(event, params) {
+      this._emitter.emit(event, params);
+    }
+    canUse(command) {
+      return canIUse(command);
+    }
+    canIUseIfThrow(command) {
+      if (!this.canUse(command)) {
+        return {
+          code: "FAILURE",
+          message: `[Jolibox SDK] ${command} is not supported in this platform`
+        };
+      }
+    }
+  };
+
+  // src/sdks/lifecycle.ts
+  var LIFECYCLE_ON_READY = "LifecycleSDK.onReady";
+  var LifecycleSDK = class extends BaseSDK {
+    constructor() {
+      super();
+    }
+    onReady(callback) {
+      const wrappedOnReady = info => {
+        callback.call(this, info);
+        this.triggerEvent(LIFECYCLE_ON_READY, info);
+      };
+      this.commands.executeCommand("LifecycleSDK.onReady", wrappedOnReady.bind(this));
+    }
+    exit(params) {
+      const errMsg = this.canIUseIfThrow("lifeCycle.exit");
+      if (errMsg) {
+        return errMsg;
+      }
+      this.commands.executeCommand("LifecycleSDK.exit", params.onBeforeExit, params.shouldStay);
+    }
+    onJoliboxHide(params) {
+      this.commands.executeCommand("LifecycleSDK.onJoliboxHide", params.bind(this));
+    }
+    onJoliboxShow(params) {
+      this.commands.executeCommand("LifecycleSDK.onJoliboxShow", params.bind(this));
+    }
+  };
+
+  // src/sdks/storage.ts
+  var StorageSDK = class extends BaseSDK {
+    async getItem(key) {
+      const result = await this.commands.executeCommand("StorageSDK.getItem", key);
+      return result;
+    }
+    async setItem(key, value) {
+      if (key.length > 128) {
+        return {
+          code: "PARAMETER_ERROR",
+          message: "[SDK] cloud storage setItem error: length of key should be less than 128"
+        };
+      }
+      const valueToStore = typeof value == "string" ? value : String(value);
+      if (key.length + valueToStore.length > 1024) {
+        return {
+          code: "PARAMETER_ERROR",
+          message: "[SDK] cloud storage setItem error: length of key and value should be less than 1024"
+        };
+      }
+      return await this.commands.executeCommand("StorageSDK.setItem", key, value);
+    }
+    async removeItem(key) {
+      return this.commands.executeCommand("StorageSDK.removeItem", key);
+    }
+    async clear() {
+      return this.commands.executeCommand("StorageSDK.clear");
+    }
+  };
+
+  // src/sdks/ads.ts
+  var JoliboxAds = class extends BaseSDK {
+    constructor() {
+      super();
+      this.init = config => {
+        this.commands.executeCommand("AdsSDK.init", config);
+      };
+      this.adConfig = params => {
+        this.commands.executeCommand("AdsSDK.adConfig", params);
+      };
+      this.adBreak = params => {
+        this.commands.executeCommand("AdsSDK.adBreak", params);
+      };
+      this.adUnit = params => {
+        this.commands.executeCommand("AdsSDK.adUnit", params);
+      };
+    }
+  };
+
+  // src/sdks/keyboard.ts
+  var KeyboardSDK = class extends BaseSDK {
+    /**
+     * 显示键盘
+     * @param params
+     * @returns
+     */
+    showKeyboard(params) {
+      const errMsg = this.canIUseIfThrow("keyboard.showKeyboard");
+      if (errMsg) {
+        return errMsg;
+      }
+      this.commands.executeCommand("KeyboardSDK.showKeyboard", params);
+    }
+    /**
+     * 更新键盘
+     * @param value
+     * @returns
+     */
+    updateKeyboard(value) {
+      const errMsg = this.canIUseIfThrow("keyboard.updateKeyboard");
+      if (errMsg) {
+        return errMsg;
+      }
+      this.commands.executeCommand("KeyboardSDK.updateKeyboard", {
+        value
+      });
+    }
+    /**
+     * 隐藏键盘
+     * @returns
+     */
+    hideKeyboard() {
+      const errMsg = this.canIUseIfThrow("keyboard.hideKeyboard");
+      if (errMsg) {
+        return errMsg;
+      }
+      this.commands.executeCommand("KeyboardSDK.hideKeyboard");
+    }
+  };
+
+  // src/sdks/task.ts
+  var TaskTrackerSDK = class extends BaseSDK {
+    async onLevelFinished(levelId, result, duration) {
+      const errMsg = this.canIUseIfThrow("TaskTrackerSDK.onLevelFinished");
+      if (errMsg) {
+        return Promise.resolve(errMsg);
+      }
+      return await this.commands.executeCommand("TaskTrackerSDK.levelFinished", levelId, {
+        result,
+        duration
+      });
+    }
+    async onTaskFinished(taskId, duration) {
+      const errMsg = this.canIUseIfThrow("TaskTrackerSDK.onTaskFinished");
+      if (errMsg) {
+        return errMsg;
+      }
+      return await this.commands.executeCommand("TaskTrackerSDK.taskFinished", taskId, {
+        duration
+      });
+    }
+    async onTaskEvent(taskId, params) {
+      const errMsg = this.canIUseIfThrow("TaskTrackerSDK.onTaskEvent");
+      if (errMsg) {
+        return errMsg;
+      }
+      return await this.commands.executeCommand("TaskTrackerSDK.taskEvent", taskId, params);
+    }
+    async onLevelUpgrade(levelId, name) {
+      const errMsg = this.canIUseIfThrow("TaskTrackerSDK.onLevelUpgrade");
+      if (errMsg) {
+        return errMsg;
+      }
+      return await this.commands.executeCommand("TaskTrackerSDK.levelUpgrade", levelId, name);
+    }
+    async onHistoryUserLevel(level) {
+      const errMsg = this.canIUseIfThrow("TaskTrackerSDK.onHistoryUserLevel");
+      if (errMsg) {
+        return errMsg;
+      }
+      return await this.commands.executeCommand("TaskTrackerSDK.historyUserLevel", level);
+    }
+    async onHistoryUserScore(score) {
+      const errMsg = this.canIUseIfThrow("TaskTrackerSDK.onHistoryUserScore");
+      if (errMsg) {
+        return errMsg;
+      }
+      return await this.commands.executeCommand("TaskTrackerSDK.historyUserScore", score);
+    }
+  };
+
+  // src/sdks/router.ts
+  var RouterSDK = class extends BaseSDK {
+    async openSchema(schema) {
+      const errMsg = this.canIUseIfThrow("router.openSchema");
+      if (errMsg) {
+        return errMsg;
+      }
+      return await this.commands.executeCommand("RouterSDK.openSchema", schema);
+    }
+    async openPage(url) {
+      const errMsg = this.canIUseIfThrow("router.openPage");
+      if (errMsg) {
+        return errMsg;
+      }
+      return await this.commands.executeCommand("RouterSDK.openPage", url);
+    }
+    async closePage(webviewId) {
+      const errMsg = this.canIUseIfThrow("router.closePage");
+      if (errMsg) {
+        return errMsg;
+      }
+      return await this.commands.executeCommand("RouterSDK.closePage", webviewId);
+    }
+  };
+
+  // src/index.ts
+  var JoliboxSDK = class {
+    constructor() {
+      this.jssdkVersion = "__JOLIBOX_LOCAL_SDK_VERSION__";
+      this.runtime = new RuntimeSDK();
+      this.ads = new JoliboxAds();
+      this.lifecycle = new LifecycleSDK();
+      this.storage = new StorageSDK();
+      this.keyboard = new KeyboardSDK();
+      this.task = new TaskTrackerSDK();
+      this.router = new RouterSDK();
+      //global API
+      this.getSystemInfoSync = getSystemInfoSync.bind(this);
+      this.canIUse = canIUse.bind(this);
+      this.login = login.bind(this);
+      this.checkSession = checkSession.bind(this);
+      this.request = request.bind(this);
+      window.joliboxsdk = {
+        runtime: this.runtime,
+        ads: this.ads,
+        lifecycle: this.lifecycle,
+        storage: this.storage,
+        keyboard: this.keyboard,
+        task: this.task,
+        router: this.router
+      };
+    }
+  };
+  window.JoliboxSDK = JoliboxSDK;
+})();