@jolibox/implement 1.1.4-beta.4

package/dist/index.native.js

@@ -0,0 +1,3743 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/native/js-bridge/utils.ts
+function isNativeBuffers(x2) {
+  return Boolean(x2?.__nativeBuffers__);
+}
+function unpack(data) {
+  if (typeof data === "string") {
+    try {
+      data = JSON.parse(data);
+    } catch {
+      return {};
+    }
+  }
+  if (typeof data !== "object" || data === null) {
+    return {};
+  }
+  if (!isNativeBuffers(data)) return data;
+  const nativeBuffers = data.__nativeBuffers__;
+  delete data.__nativeBuffers__;
+  if (nativeBuffers) {
+    for (let i = 0; i < nativeBuffers.length; i++) {
+      const item = nativeBuffers[i];
+      if (item) {
+        let tmp;
+        if (item.value) {
+          tmp = item.value;
+        } else if (item.base64) {
+          tmp = decodeFromUi8Base64(item.base64);
+        }
+        if (typeof tmp !== "undefined" && tmp instanceof ArrayBuffer) {
+          data[item.key] = tmp;
+        }
+      }
+    }
+  }
+  return data;
+}
+function pack(_data = {}, useArrayBuffer = false) {
+  const data = _data;
+  const needTransAttrs = [];
+  for (const [key, item] of Object.entries(data)) {
+    if (item !== void 0 && item instanceof ArrayBuffer && item.byteLength !== void 0) {
+      const obj = useArrayBuffer ? { value: item, key } : {
+        base64: encodeToUi8Base64(item),
+        key
+      };
+      needTransAttrs.push(obj);
+      delete data[key];
+    }
+  }
+  if (needTransAttrs.length > 0) {
+    data.__nativeBuffers__ = needTransAttrs;
+  }
+  return data;
+}
+var decodeFromUi8Base64, encodeToUi8Base64;
+var init_utils = __esm({
+  "src/native/js-bridge/utils.ts"() {
+    "use strict";
+    decodeFromUi8Base64 = (string) => {
+      const base64String = atob(string);
+      const len = base64String.length;
+      const ui8aReader = new Uint8Array(len);
+      for (let i = 0; i < len; i++) {
+        ui8aReader[i] = base64String.charCodeAt(i);
+      }
+      return ui8aReader.buffer;
+    };
+    encodeToUi8Base64 = (arrayBuffer) => {
+      let string = "";
+      const ui8aReader = new Uint8Array(arrayBuffer);
+      const len = ui8aReader.byteLength;
+      for (let i = 0; i < len; i++) {
+        string += String.fromCharCode(ui8aReader[i]);
+      }
+      return btoa(string);
+    };
+  }
+});
+
+// ../common/dist/index.es.js
+function M(n2) {
+  return new Promise((e) => {
+    setTimeout(() => {
+      e();
+    }, n2);
+  });
+}
+function b(n2) {
+  return typeof n2 == "string";
+}
+function ie(n2) {
+  return typeof n2 == "object" && n2 !== null && !Array.isArray(n2) && !(n2 instanceof RegExp) && !(n2 instanceof Date);
+}
+function Ce(n2) {
+  return typeof n2 == "object" && Array.isArray(n2);
+}
+function se(n2) {
+  return typeof n2 > "u";
+}
+function N(n2) {
+  return se(n2) || n2 === null;
+}
+function A(n2) {
+  return typeof n2 == "function";
+}
+function Oe(n2) {
+  return ie(n2) && A(n2.then);
+}
+function x(n2) {
+  let e = n2, r = null, t3 = function(...o) {
+    return r || (r = new e(...o)), r;
+  };
+  return t3.prototype = e.prototype, t3;
+}
+function ke(n2, e, r) {
+  if (typeof r != "function") throw new Error("[Jolibox SDK]Customizer must be a function");
+  function t3(o, i) {
+    for (let s in i) if (Object.prototype.hasOwnProperty.call(i, s)) {
+      let l = o[s], a = i[s], c = r(l, a, s, o, i);
+      c !== void 0 ? o[s] = c : U(a) && U(l) ? o[s] = t3({ ...l }, a) : Array.isArray(a) && Array.isArray(l) ? o[s] = [...l, ...a] : o[s] = a;
+    }
+    return o;
+  }
+  return t3(n2, e);
+}
+function U(n2) {
+  return n2 && typeof n2 == "object" && n2.constructor === Object;
+}
+function Le(n2, e) {
+  if (Array.isArray(n2)) return n2.concat(e);
+}
+function Ue(n2, e, r = {}) {
+  let t3 = null, o, i, s, { leading: l = false, trailing: a = true } = r, c = () => (s = n2.apply(i, o), o = void 0, i = void 0, s), I = function(...te) {
+    o = te, i = this;
+    let w = l && !t3;
+    if (t3 && clearTimeout(t3), t3 = setTimeout(() => {
+      t3 = null, a && !w && c();
+    }, e), w) return c();
+  };
+  return I.cancel = () => {
+    t3 && clearTimeout(t3), t3 = null, o = i = void 0;
+  }, I.flush = () => {
+    if (t3) return clearTimeout(t3), t3 = null, c();
+  }, I;
+}
+function de(n2, e) {
+  return (...r) => e(n2, ...r);
+}
+function He(n2) {
+  return (e) => de(e, function(r, ...t3) {
+    if (typeof r == "function") try {
+      return r.apply(this, t3);
+    } catch (o) {
+      n2(new v(`${o}`));
+    }
+  });
+}
+function R(n2) {
+  return (...e) => {
+    (globalThis.VConsole?.[n2] ?? globalThis.console[n2])(...e);
+  };
+}
+function ce(n2) {
+  return new Promise((e) => ee(n2)(e));
+}
+function ee(n2) {
+  return (e, r = null) => {
+    let t3 = false;
+    return n2((i) => {
+      if (!t3) return t3 = true, e.call(r, i);
+    }, null);
+  };
+}
+function pe(n2, e) {
+  return ((t3) => {
+    let o, i = { onWillAddFirstListener() {
+      o = t3(s.fire, s);
+    } }, s = new u(i);
+    return s.event;
+  })((t3, o = null) => n2((i) => e(i) && t3.call(o, i), null));
+}
+function ne(n2, e) {
+  let r = Math.min(n2.length, e.length);
+  for (let t3 = 0; t3 < r; t3++) Ee(n2[t3], e[t3]);
+}
+function Ee(n2, e) {
+  if (b(e)) {
+    if (typeof n2 !== e) throw new Error(`argument does not match constraint: typeof ${e}`);
+  } else if (A(e)) {
+    try {
+      if (n2 instanceof e) return;
+    } catch {
+    }
+    if (!N(n2) && n2.constructor === e || e.length === 1 && e.call(void 0, n2) === 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");
+  }
+}
+function Vn() {
+  if (globalThis[P]) return globalThis[P];
+  let n2 = new p(), e = new y(), r = { registerCommand(t3, o, i) {
+    n2.registerCommand({ id: t3, handler: o, metadata: i });
+  }, executeCommand(t3, ...o) {
+    return e.executeCommand(t3, ...o);
+  }, excuteCommandSync(t3, ...o) {
+    return e.executeCommandThowErr(t3, ...o);
+  } };
+  return globalThis[P] = r, r;
+}
+var k, re, oe, g, L, ae, T, m, f, v, H, J, z, B, $, Q, X, Y, q, Z, me, Be, d, C, le, E, u, _, h, ue, O, fe, En, p, y, P;
+var init_index_es = __esm({
+  "../common/dist/index.es.js"() {
+    "use strict";
+    k = Object.defineProperty;
+    re = Object.getOwnPropertyDescriptor;
+    oe = (n2, e) => {
+      for (var r in e) k(n2, r, { get: e[r], enumerable: true });
+    };
+    g = (n2, e, r, t3) => {
+      for (var o = t3 > 1 ? void 0 : t3 ? re(e, r) : e, i = n2.length - 1, s; i >= 0; i--) (s = n2[i]) && (o = (t3 ? s(e, r, o) : s(o)) || o);
+      return t3 && o && k(e, r, o), o;
+    };
+    L = class {
+      constructor() {
+        this.state = "pending";
+        this.promise = new Promise((e, r) => {
+          this.resolve = (t3) => {
+            this.state === "pending" && (this.state = "fulfilled", e(t3));
+          }, this.reject = (t3) => {
+            this.state === "pending" && (this.state = "rejected", r(t3));
+          };
+        });
+      }
+    };
+    ae = ((a) => (a[a.DEVELOPER_FILE_NOT_FOUND = 0] = "DEVELOPER_FILE_NOT_FOUND", a[a.INTERNAL_IOS_CAN_NOT_FOUND_PKG = 1] = "INTERNAL_IOS_CAN_NOT_FOUND_PKG", a[a.USER_IOS_LOAD_TIMEOUT = 2] = "USER_IOS_LOAD_TIMEOUT", a[a.INTERNAL_IOS_PKG_LOAD_ERROR = 3] = "INTERNAL_IOS_PKG_LOAD_ERROR", a[a.INTERNAL_IOS_PKG_PARSE_FAIL = 4] = "INTERNAL_IOS_PKG_PARSE_FAIL", a[a.USER_IOS_GET_EMPTY_DATA = 5] = "USER_IOS_GET_EMPTY_DATA", a[a.USER_ANDROID_GET_PKG_FAIL = 6] = "USER_ANDROID_GET_PKG_FAIL", a[a.DEVELOPER_ANDROID_PACKAGE_FILE_UNEXPECTED_REQUIRE = 7] = "DEVELOPER_ANDROID_PACKAGE_FILE_UNEXPECTED_REQUIRE", a))(ae || {});
+    T = 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;
+      }
+    };
+    m = class extends T {
+      constructor() {
+        super(...arguments);
+        this.kind = "INTERNAL_ERROR";
+      }
+    };
+    f = class extends T {
+      constructor() {
+        super(...arguments);
+        this.kind = "USER_ERROR";
+      }
+    };
+    v = class extends f {
+      constructor(r, t3, o) {
+        super(r);
+        this.message = r;
+        this.errNo = t3;
+        this.name = "USER_CUSTOM_ERROR";
+        this.errMsg = r, o && (this.extra = Object.assign({}, this.extra, o));
+      }
+    };
+    H = class extends m {
+      constructor() {
+        super(...arguments);
+        this.name = "INTERNAL_SCHEMA_PARSE_ERROR";
+        this.priority = "P0";
+      }
+    };
+    J = class extends m {
+      constructor() {
+        super(...arguments);
+        this.name = "INTERNAL_INVOKE_NATIVE_ERROR";
+      }
+    };
+    z = class extends m {
+      constructor(r, t3, o, i) {
+        super(r);
+        this.errNo = t3;
+        this.name = "INTERNAL_APPLY_NATIVE_ERROR";
+        this.errorType = o, this.errorCode = i;
+      }
+    };
+    B = class extends m {
+      constructor() {
+        super(...arguments);
+        this.name = "INTERNAL_JSCORE_ERROR";
+        this.priority = "P0";
+      }
+    };
+    $ = class extends m {
+      constructor(r, t3) {
+        super(r);
+        this.message = r;
+        this.name = "INTERNAL_CONTEXT_ERROR";
+        this.property = t3;
+      }
+    };
+    Q = class extends T {
+      constructor(r, t3, o, i, s) {
+        super(r);
+        this.message = r;
+        this.code = t3;
+        this.kind = "API_ERROR";
+        this.name = "API_ERROR";
+        o && (this.errorType = o), i !== void 0 && (this.stack = i), s && (this.priority = s);
+      }
+      toJSON() {
+        return { message: this.message, stack: this.stack, name: this.name, code: this.code, errorType: this.errorType };
+      }
+    };
+    X = class extends m {
+      constructor() {
+        super(...arguments);
+        this.name = "INTERNAL_METRIC_REPORT_ERROR";
+      }
+    };
+    Y = class extends m {
+      constructor() {
+        super(...arguments);
+        this.name = "INTERNAL_REPORTER_ERROR";
+      }
+    };
+    q = { log: R("log"), warn: R("warn"), info: R("info"), error: R("error"), debug: R("debug") };
+    Object.assign(globalThis, { logger: q });
+    Z = Symbol.for("Jolibox.canIUseMap");
+    me = {};
+    globalThis[Z] = me;
+    Be = { get config() {
+      return globalThis[Z];
+    } };
+    d = class n {
+      static {
+        this.Undefined = new n(void 0);
+      }
+      constructor(e) {
+        this.element = e, this.next = n.Undefined, this.prev = n.Undefined;
+      }
+    };
+    C = class {
+      constructor() {
+        this._first = d.Undefined;
+        this._last = d.Undefined;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      isEmpty() {
+        return this._first === d.Undefined;
+      }
+      clear() {
+        let e = this._first;
+        for (; e !== d.Undefined; ) {
+          let r = e.next;
+          e.prev = d.Undefined, e.next = d.Undefined, e = r;
+        }
+        this._first = d.Undefined, this._last = d.Undefined, this._size = 0;
+      }
+      unshift(e) {
+        return this._insert(e, false);
+      }
+      push(e) {
+        return this._insert(e, true);
+      }
+      _insert(e, r) {
+        let t3 = new d(e);
+        if (this._first === d.Undefined) this._first = t3, this._last = t3;
+        else if (r) {
+          let i = this._last;
+          this._last = t3, t3.prev = i, i.next = t3;
+        } else {
+          let i = this._first;
+          this._first = t3, t3.next = i, i.prev = t3;
+        }
+        this._size += 1;
+        let o = false;
+        return () => {
+          o || (o = true, this._remove(t3));
+        };
+      }
+      shift() {
+        if (this._first !== d.Undefined) {
+          let e = this._first.element;
+          return this._remove(this._first), e;
+        }
+      }
+      pop() {
+        if (this._last !== d.Undefined) {
+          let e = this._last.element;
+          return this._remove(this._last), e;
+        }
+      }
+      _remove(e) {
+        if (e.prev !== d.Undefined && e.next !== d.Undefined) {
+          let r = e.prev;
+          r.next = e.next, e.next.prev = r;
+        } else e.prev === d.Undefined && e.next === d.Undefined ? (this._first = d.Undefined, this._last = d.Undefined) : e.next === d.Undefined ? (this._last = this._last.prev, this._last.next = d.Undefined) : e.prev === d.Undefined && (this._first = this._first.next, this._first.prev = d.Undefined);
+        this._size -= 1;
+      }
+      *[Symbol.iterator]() {
+        let e = this._first;
+        for (; e !== d.Undefined; ) yield e.element, e = e.next;
+      }
+    };
+    le = 0;
+    E = class {
+      constructor(e) {
+        this.value = e;
+        this.id = le++;
+      }
+    };
+    u = class {
+      constructor(e) {
+        this.options = e;
+        this._size = 0;
+      }
+      dispose(e) {
+        this._disposed || (this._disposed = true, this._listeners && (e ? (this._listeners instanceof E && (this._listeners = [this._listeners]), this._listeners = this._listeners.filter((r) => r?.value === e)) : (this._listeners = void 0, this._size = 0)), this.options?.onDidRemoveLastListener?.());
+      }
+      get event() {
+        return this._event ??= (e, r) => {
+          if (this._disposed) return () => {
+            console.info("[Jolibox SDK] Emitter is _disposed");
+          };
+          r && (e = e.bind(r));
+          let t3 = new E(e);
+          this._listeners ? this._listeners instanceof E ? this._listeners = [this._listeners, t3] : this._listeners.push(t3) : (this.options?.onWillAddFirstListener?.(this), this._listeners = t3, this.options?.onDidFirstListener?.(this)), this.options?.onDidAddListener?.(this), this._size++;
+        }, this._event;
+      }
+      _deliver(e, r) {
+        if (!e) return;
+        let t3 = this.options?.onListenerError || Error.constructor;
+        if (!t3) {
+          e.value(r);
+          return;
+        }
+        try {
+          e.value(r);
+        } catch (o) {
+          t3(o);
+        }
+      }
+      fire(e) {
+        this._listeners && (this._listeners instanceof E ? this._deliver(this._listeners, e) : this._listeners.forEach((r) => this._deliver(r, e)));
+      }
+      hasListeners() {
+        return this._size > 0;
+      }
+    };
+    _ = class {
+      constructor() {
+        this.listeners = /* @__PURE__ */ new Map();
+        this.listerHandlerMap = /* @__PURE__ */ new WeakMap();
+        this.cachedEventQueue = /* @__PURE__ */ new Map();
+      }
+      on(e, r) {
+        let t3 = this.listeners.get(e) ?? new u(), o = (s) => r(...s.args);
+        this.listerHandlerMap.set(r, o), t3.event(o), this.listeners.set(e, t3);
+        let i = this.cachedEventQueue.get(e);
+        if (i) for (; i.size > 0; ) t3.fire({ event: e, ...i.shift() });
+      }
+      off(e, r) {
+        let t3 = this.listeners.get(e);
+        if (t3) {
+          let o = this.listerHandlerMap.get(r);
+          t3.dispose(o);
+        }
+      }
+      emit(e, ...r) {
+        let t3 = this.listeners.get(e);
+        if (t3) t3.fire({ event: e, args: r });
+        else {
+          let o = this.cachedEventQueue.get(e);
+          o || (o = new C(), this.cachedEventQueue.set(e, o)), o.push({ args: r });
+        }
+      }
+    };
+    h = {};
+    oe(h, { None: () => ue, filter: () => pe, once: () => ee, toPromise: () => ce });
+    ue = () => {
+      console.log("[Jolibox SDK] None Event");
+    };
+    O = Symbol.for("Jolibox.hostEmitter");
+    fe = () => {
+      let n2 = new _();
+      return globalThis[O] || (globalThis[O] = { on: n2.on.bind(n2), off: n2.off.bind(n2), emit: n2.emit.bind(n2) }), globalThis[O];
+    };
+    En = fe();
+    p = class {
+      constructor() {
+        this._commands = /* @__PURE__ */ new Map();
+        this._onDidRegisterCommand = new u();
+        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 s of e.metadata.args) o.push(s.constraint);
+          let i = e.handler;
+          e.handler = function(...s) {
+            return ne(s, o), i(...s);
+          };
+        }
+        let { id: r } = e;
+        this._commands.get(r) && console.info(`[Jolibox SDK] duplicated command is registered ${r}`), this._commands.set(r, e), this._onDidRegisterCommand.fire(r);
+      }
+      getCommand(e) {
+        return this._commands.get(e);
+      }
+      getCommands() {
+        let e = /* @__PURE__ */ new Map();
+        for (let r of this._commands.keys()) {
+          let t3 = this.getCommand(r);
+          t3 && e.set(r, t3);
+        }
+        return e;
+      }
+    };
+    p = g([x], p);
+    y = class {
+      constructor() {
+        this._onWillExecuteCommand = new u();
+        this.onWillExecuteCommand = this._onWillExecuteCommand.event;
+        this._onDidExecuteCommand = new u();
+        this.onDidExecuteCommand = this._onDidExecuteCommand.event;
+        this.registry = new p();
+        this._starActivation = null;
+      }
+      _activateStar() {
+        return this._starActivation || (this._starActivation = M(3e4)), this._starActivation;
+      }
+      async executeCommand(e, ...r) {
+        return this.registry.getCommand(e) ? this._tryExecuteCommand(e, r) : (await Promise.all([Promise.race([this._activateStar(), h.toPromise(h.filter(this.registry.onDidRegisterCommand, (o) => o === e))])]), this._tryExecuteCommand(e, r));
+      }
+      executeCommandThowErr(e, ...r) {
+        if (!!!this.registry.getCommand(e)) throw new Error(`command '${e}' not found`);
+        let o = this.registry.getCommand(e);
+        this._onWillExecuteCommand.fire({ commandId: e, args: r });
+        let i = this.invokeFunction(o.handler, ...r);
+        return this._onDidExecuteCommand.fire({ commandId: e, args: r }), i;
+      }
+      _tryExecuteCommand(e, r) {
+        let t3 = this.registry.getCommand(e);
+        if (!t3) return Promise.reject(new Error(`command '${e}' not found`));
+        try {
+          this._onWillExecuteCommand.fire({ commandId: e, args: r });
+          let o = this.invokeFunction(t3.handler, ...r);
+          return this._onDidExecuteCommand.fire({ commandId: e, args: r }), Promise.resolve(o);
+        } catch (o) {
+          return Promise.reject(o);
+        }
+      }
+      invokeFunction(e, ...r) {
+        let t3 = false;
+        try {
+          return e(...r);
+        } finally {
+          t3 = true;
+        }
+      }
+    };
+    y = g([x], y);
+    P = Symbol.for("Jolibox.commands");
+  }
+});
+
+// src/common/report/errors/report/index.ts
+function reportError(error, options = {}) {
+  errorReportCollector.emit("ERROR_REPORT", {
+    error,
+    options
+  });
+}
+var errorReportCollector, errorReportEmitter;
+var init_report = __esm({
+  "src/common/report/errors/report/index.ts"() {
+    "use strict";
+    init_index_es();
+    init_index_es();
+    errorReportCollector = new _();
+    errorReportEmitter = new _();
+    reportError.debounce = Ue(reportError, 50, { leading: true });
+  }
+});
+
+// src/common/report/errors/index.ts
+function formatErrorCode(method, code) {
+  return `[${method}]:${code}`;
+}
+var createAPIError, createUserAPIError;
+var init_errors = __esm({
+  "src/common/report/errors/index.ts"() {
+    "use strict";
+    init_report();
+    init_index_es();
+    init_report();
+    createAPIError = (error, params) => {
+      return new Q(params?.errMsg ?? error.msg ?? "", error.code, error.type);
+    };
+    createUserAPIError = (msg) => {
+      return new v(msg);
+    };
+  }
+});
+
+// src/native/js-bridge/const.ts
+var BUFFER_METHODS, BACKGROUND_FORBIDDEN_METHODS, SYNC_METHODS;
+var init_const = __esm({
+  "src/native/js-bridge/const.ts"() {
+    "use strict";
+    BUFFER_METHODS = [];
+    BACKGROUND_FORBIDDEN_METHODS = [];
+    SYNC_METHODS = ["env", "createRequestTask", "login"];
+  }
+});
+
+// src/native/js-bridge/report.ts
+function createReportInvokeMetrics(jsCore2, onNative2) {
+  if (!monitorHasInitialized) {
+    invokeMonitor = new MetricsMonitor({
+      eventName: "jolibox_invoke",
+      tagNameOrder: ["status", "method", "errNo", "errMsg", "isForeground"],
+      metricName: "duration",
+      reporter(data) {
+        jsCore2.invoke("track", JSON.stringify({ event: "reportMetrics", data }), -1);
+      }
+    });
+    invokeJSToNativeMonitor = new MetricsMonitor({
+      eventName: "jolibox_invoke_js2native",
+      tagNameOrder: ["status", "method", "isForeground"],
+      metricName: "duration",
+      reporter(data) {
+        jsCore2.invoke("track", JSON.stringify({ event: "reportMetrics", data }), -1);
+      }
+    });
+    invokeNativeToJSMonitor = new MetricsMonitor({
+      eventName: "jolibox_invoke_native2js",
+      tagNameOrder: ["status", "method", "isForeground"],
+      metricName: "duration",
+      reporter(data) {
+        jsCore2.invoke("track", JSON.stringify({ event: "reportMetrics", data }), -1);
+      }
+    });
+    onNative2("onJoliboxEnterBackground", () => {
+      invokeMonitor.flush();
+      invokeJSToNativeMonitor.flush();
+      invokeNativeToJSMonitor.flush();
+    });
+    monitorHasInitialized = true;
+  }
+  function report(invokeMetrics) {
+    const {
+      method,
+      args,
+      startTime,
+      isForeground,
+      errMsg = `${method}:fail no errMsg`,
+      errNo = 0,
+      __timing = {
+        receiveJSInvoke: 0,
+        invokeCallback: 0
+      }
+    } = invokeMetrics;
+    const { receiveJSInvoke, invokeCallback } = __timing;
+    const status = errMsg.match(/\S:(\S+)\s?/)?.[1] ?? "fail";
+    invokeMonitor.report({
+      status,
+      method: normalizeMethod2(method, args),
+      errNo: `${errNo}`,
+      errMsg,
+      isForeground,
+      duration: Date.now() - startTime
+    });
+    if (startTime && receiveJSInvoke && invokeCallback) {
+      invokeJSToNativeMonitor.report({
+        status,
+        method,
+        isForeground,
+        duration: Number((receiveJSInvoke - startTime).toFixed(3))
+      });
+      invokeNativeToJSMonitor.report({
+        status,
+        method,
+        isForeground,
+        duration: Number((Date.now() - invokeCallback).toFixed(3))
+      });
+    }
+  }
+  function normalizeMethod2(method, args) {
+    if (method === "callHostMethod" || method === "callHostMethodSync") {
+      if (args?.method) {
+        return `${method}-${args.method}`;
+      }
+    }
+    return method;
+  }
+  return report;
+}
+var getType, MetricsMonitor, monitorHasInitialized, invokeMonitor, invokeJSToNativeMonitor, invokeNativeToJSMonitor;
+var init_report2 = __esm({
+  "src/native/js-bridge/report.ts"() {
+    "use strict";
+    init_index_es();
+    getType = (type) => {
+      if (type === "pv") return type;
+      return "default";
+    };
+    MetricsMonitor = class {
+      constructor(config2) {
+        this.interval = 30;
+        this.lastReportTime = 0;
+        this.cache = {};
+        const { reporter, interval = 30, eventName, tagNameOrder, metricName, type } = config2;
+        this.reporter = reporter;
+        this.interval = interval;
+        this.eventName = eventName;
+        this.tagNameOrder = tagNameOrder;
+        this.metricName = metricName;
+        this.type = getType(type);
+      }
+      report(point) {
+        if (this.type === "pv") {
+          this.addPVPoint(point);
+        } else {
+          this.addPoint(point);
+        }
+        this.tryReport(false);
+      }
+      flush() {
+        this.tryReport(true);
+      }
+      tryReport(force) {
+        if (!Object.keys(this.cache).length) {
+          return;
+        }
+        if (force) {
+          this.reporter(this.processPoints(this.cache));
+          this.clearPoints();
+          return;
+        }
+        this.lastReportTime = this.lastReportTime || Date.now();
+        if (Date.now() - this.lastReportTime >= this.interval * 1e3) {
+          this.reporter(this.processPoints(this.cache));
+          this.clearPoints();
+          this.lastReportTime = Date.now();
+        }
+      }
+      addPoint(point) {
+        const safeSetVal = (target, props, metricName, point2) => {
+          const currentProp = props.shift();
+          if (currentProp) {
+            const currentVal = point2[currentProp];
+            if (!target[currentVal]) target[currentVal] = {};
+            safeSetVal(target[currentVal], props, metricName, point2);
+          } else {
+            if (!target[metricName]) target[metricName] = [];
+            target[metricName].push(point2[metricName]);
+          }
+        };
+        safeSetVal(this.cache, [...this.tagNameOrder], this.metricName, point);
+      }
+      addPVPoint(point) {
+        const safeSetVal = (target, props, metricName, relation) => {
+          const currentProp = props.shift();
+          if (!currentProp && ie(relation)) {
+            throw new X(
+              `report value failed to match tagNameOrder, ${JSON.stringify(originParams)}`
+            );
+          }
+          if (currentProp) {
+            const keys = [];
+            if (ie(relation)) {
+              keys.push(...Object.keys(relation));
+            } else if (b(relation)) {
+              if (props.length > 0) {
+                throw new X(
+                  `report value failed to match tagNameOrder, ${JSON.stringify(originParams)}`
+                );
+              }
+              keys.push(relation);
+            } else {
+              throw new X(
+                `expected metric value to be a string, but got a(n) ${typeof relation}, ${JSON.stringify(
+                  originParams
+                )}`
+              );
+            }
+            keys.forEach((key) => {
+              if (!target[key]) target[key] = {};
+              const value = ie(relation) ? relation[key] : relation;
+              safeSetVal(target[key], [...props], metricName, value);
+            });
+          } else {
+            if (!target[metricName]) {
+              target[metricName] = 1;
+            } else {
+              target[metricName]++;
+            }
+          }
+        };
+        const originParams = {
+          point,
+          metricName: this.metricName,
+          tagNameOrder: this.tagNameOrder
+        };
+        safeSetVal(this.cache, [...this.tagNameOrder], this.metricName, point);
+      }
+      processPoints(points) {
+        return {
+          eventName: this.eventName,
+          tagNameOrder: this.tagNameOrder,
+          metricName: this.metricName,
+          metricAggregateType: this.type === "pv" ? "itoa" : "arr",
+          data: points
+        };
+      }
+      clearPoints() {
+        this.cache = {};
+      }
+    };
+    monitorHasInitialized = false;
+  }
+});
+
+// src/native/js-bridge/invoke.ts
+function createInvoke(jsCore2, onNative2) {
+  let resolveId = 0;
+  let IS_FOREGROUND = true;
+  const resolveMap = /* @__PURE__ */ new Map();
+  const reportInvokeMetrics = createReportInvokeMetrics(jsCore2, onNative2);
+  onNative2("onJoliboxEnterBackground", () => {
+    IS_FOREGROUND = false;
+  });
+  onNative2("onJoliboxEnterForeground", () => {
+    IS_FOREGROUND = true;
+    asyncInvokes.forEach(async ({ method, args, resolve }) => {
+      const res = await invokeNative2(method, args);
+      resolve(res);
+    });
+    asyncInvokes.length = 0;
+  });
+  const invokeHandler2 = (resolveId2, data) => {
+    q.info("----resolveId", resolveId2, data);
+    const resolve = resolveMap.get(Number(resolveId2));
+    if (!resolve) return;
+    const response = unpack(data);
+    resolve(response);
+    resolveMap.delete(Number(resolveId2));
+  };
+  const invokeNative2 = (method, args) => {
+    const startTime = Date.now();
+    const isForeground = `${IS_FOREGROUND}`;
+    resolveId += 1;
+    const deferred = new L();
+    resolveMap.set(resolveId, deferred.resolve);
+    if (!IS_FOREGROUND && BACKGROUND_FORBIDDEN_METHODS.includes(method)) {
+      return new Promise((resolve) => {
+        asyncInvokes.push({ method, args, resolve });
+      });
+    }
+    const basicReportParam = {
+      method,
+      startTime,
+      args,
+      isForeground
+    };
+    const invokeReportParam = {
+      ...basicReportParam,
+      invokeType: "js-bridge"
+    };
+    const useArrayBuffer = !NOT_SUPPORT_ARRAY_BUFFER && BUFFER_METHODS.includes(method);
+    const payload = pack(args, useArrayBuffer);
+    const params = useArrayBuffer ? payload : JSON.stringify(payload);
+    let response;
+    if (method.endsWith("Sync") || SYNC_METHODS.includes(method)) {
+      response = jsCore2.call?.(method, payload, resolveId);
+    } else {
+      if (typeof params === "string") {
+        console.log("-----params", method, resolveId);
+        response = jsCore2.invoke(method, params, resolveId);
+      } else {
+        response = jsCore2.call?.(method, params, resolveId);
+      }
+    }
+    if (response) {
+      try {
+        if (typeof response === "string") {
+          response = JSON.parse(response);
+        }
+        response = unpack(response);
+      } catch (error) {
+        q.error(error);
+      }
+      resolveMap.delete(resolveId);
+      if (response.errorCode) {
+        response.errorCode = formatErrorCode(method, response.errorCode);
+      }
+      reportInvokeMetrics({ ...invokeReportParam, ...response });
+      return response;
+    }
+    if (method.endsWith("Sync")) {
+      resolveMap.delete(resolveId);
+    }
+    return deferred.promise.then((response2) => {
+      if (response2.errorCode) {
+        response2.errorCode = formatErrorCode(method, response2.errorCode);
+      }
+      reportInvokeMetrics({ ...invokeReportParam, ...response2 });
+      return response2;
+    });
+  };
+  const applyNative3 = (method, arg) => {
+    const res = invokeNative2(method, arg);
+    if (Oe(res)) {
+      return res.then(
+        (r) => ifThrowError(
+          method,
+          r
+        )
+      );
+    }
+    return ifThrowError(method, res);
+  };
+  return {
+    invokeNative: invokeNative2,
+    applyNative: applyNative3,
+    invokeHandler: invokeHandler2
+  };
+}
+function ifThrowError(method, res) {
+  if (!ie(res)) {
+    q.warn(`[Jolibox SDK]${method} no response value`);
+    return;
+  }
+  const { errMsg, errNo, errorType, errorCode, ...data } = res;
+  if (errMsg && errMsg !== `${method}:ok`) {
+    throw new z(errMsg, errNo, errorType, errorCode);
+  }
+  return data;
+}
+var asyncInvokes, NOT_SUPPORT_ARRAY_BUFFER;
+var init_invoke = __esm({
+  "src/native/js-bridge/invoke.ts"() {
+    "use strict";
+    init_utils();
+    init_index_es();
+    init_errors();
+    init_const();
+    init_report2();
+    asyncInvokes = [];
+    NOT_SUPPORT_ARRAY_BUFFER = false;
+  }
+});
+
+// src/native/js-bridge/subscribe.ts
+function createSubscribe(jsCore2) {
+  const nativeEmitter = new _();
+  const publishMonitor = new MetricsMonitor({
+    eventName: "jolibox_publish",
+    tagNameOrder: ["type", "event"],
+    metricName: "duration",
+    reporter(data) {
+      jsCore2.invoke("track", JSON.stringify({ event: "reportMetrics", data }), -1);
+    }
+  });
+  nativeEmitter.on("onJoliboxEnterBackground", () => {
+    publishMonitor.flush();
+  });
+  return {
+    onNative: nativeEmitter.on.bind(nativeEmitter),
+    offNative: nativeEmitter.off.bind(nativeEmitter),
+    subscribeHandler(event, data, webviewId) {
+      const unpackedData = unpack(data);
+      let originalParams;
+      if (unpackedData.__extra) {
+        originalParams = unpackedData.params;
+        const { type, startTime } = unpackedData.__extra;
+        publishMonitor.report({
+          type,
+          event,
+          duration: Date.now() - startTime
+          // ms
+        });
+      } else {
+        originalParams = unpackedData;
+      }
+      nativeEmitter.emit(event, originalParams, webviewId);
+    }
+  };
+}
+var init_subscribe = __esm({
+  "src/native/js-bridge/subscribe.ts"() {
+    "use strict";
+    init_index_es();
+    init_utils();
+    init_report2();
+  }
+});
+
+// src/native/js-bridge/js-bridge.ts
+function createBridge(jsCore2) {
+  const { subscribeHandler: subscribeHandler2, onNative: onNative2, offNative: offNative2 } = createSubscribe(jsCore2);
+  const { invokeNative: invokeNative2, invokeHandler: invokeHandler2, applyNative: applyNative3 } = createInvoke(jsCore2, onNative2);
+  return {
+    // 宿主调用
+    invokeHandler: invokeHandler2,
+    subscribeHandler: subscribeHandler2,
+    applyNative: applyNative3,
+    invokeNative: invokeNative2,
+    onNative: onNative2,
+    offNative: offNative2
+  };
+}
+var init_js_bridge = __esm({
+  "src/native/js-bridge/js-bridge.ts"() {
+    "use strict";
+    init_invoke();
+    init_subscribe();
+  }
+});
+
+// src/native/js-bridge/types.ts
+var init_types = __esm({
+  "src/native/js-bridge/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/native/js-bridge/index.ts
+var init_js_bridge2 = __esm({
+  "src/native/js-bridge/index.ts"() {
+    "use strict";
+    init_js_bridge();
+    init_types();
+  }
+});
+
+// src/native/js-core/jolibox-js-core.ts
+var joliboxJSCore, RuntimeLoader, env;
+var init_jolibox_js_core = __esm({
+  "src/native/js-core/jolibox-js-core.ts"() {
+    "use strict";
+    init_index_es();
+    init_report();
+    RuntimeLoader = {
+      trigger() {
+      },
+      exit() {
+        return false;
+      },
+      onReady(fn) {
+        RuntimeLoader.trigger = fn;
+      },
+      doExit(fn) {
+        RuntimeLoader.exit = fn;
+      }
+    };
+    env = () => {
+      const res = window.prompt(
+        "invoke",
+        JSON.stringify({
+          event: "envSync",
+          paramsString: JSON.stringify({})
+        })
+      );
+      if (!res) {
+        reportError(new J(`native env failed`));
+      } else {
+        const { data } = JSON.parse(res);
+        return data ?? void 0;
+      }
+    };
+    if (window.webkit) {
+      const _joliboxJSCore = window.webkit.messageHandlers;
+      const onDocumentReady = (path = "") => {
+        RuntimeLoader.trigger();
+        _joliboxJSCore.onDocumentReady.postMessage({ path });
+      };
+      const doExit = (uuid) => {
+        const shouldInterrupt = RuntimeLoader.exit();
+        _joliboxJSCore.doExit.postMessage({ uuid, shouldInterrupt });
+      };
+      joliboxJSCore = {
+        onDocumentReady,
+        doExit,
+        invoke(method, params, callbackId) {
+          _joliboxJSCore.invoke.postMessage({
+            event: method,
+            paramsString: params,
+            callbackId
+          });
+        },
+        // publish(event, params, webviewIds) {
+        //   const data = normalizeParams(params as Record<string, unknown>, 'joliboxJSCore');
+        //   _joliboxJSCore.publish.postMessage({
+        //     event,
+        //     paramsString: JSON.stringify(data),
+        //     webviewIds: JSON.stringify(webviewIds)
+        //   });
+        // },
+        call(method, params, callbackId) {
+          const res = window.prompt(
+            "invoke",
+            JSON.stringify({
+              event: method,
+              paramsString: JSON.stringify(params),
+              callbackId
+            })
+          );
+          if (res) {
+            return JSON.parse(res);
+          }
+        }
+      };
+      const devCore = { onDocumentReady, env };
+      globalThis.joliboxJSCore = {
+        ...devCore
+      };
+    }
+    if (window.JoliAndroidSDKBridge) {
+      const _joliboxJSCore = window.JoliAndroidSDKBridge;
+      const onDocumentReady = (path = "") => {
+        RuntimeLoader.trigger();
+        _joliboxJSCore.onDocumentReady(JSON.stringify({ path }));
+      };
+      const doExit = (uuid) => {
+        const shouldInterrupt = RuntimeLoader.exit();
+        _joliboxJSCore.doExit(JSON.stringify({ uuid, shouldInterrupt }));
+      };
+      joliboxJSCore = {
+        onDocumentReady,
+        invoke(method, params, callbackId) {
+          _joliboxJSCore.invoke(
+            JSON.stringify({
+              event: method,
+              paramsString: params,
+              callbackId
+            })
+          );
+        },
+        doExit,
+        // publish(event, params, webviewIds) {
+        //   const data = normalizeParams(params as Record<string, unknown>, 'joliboxJSCore');
+        //   _joliboxJSCore.publish({
+        //     event,
+        //     paramsString: JSON.stringify(data),
+        //     webviewIds: JSON.stringify(webviewIds)
+        //   });
+        // },
+        call(method, params, callbackId) {
+          const res = window.prompt(
+            "invoke",
+            JSON.stringify({
+              event: method,
+              paramsString: JSON.stringify(params),
+              callbackId
+            })
+          );
+          if (res) {
+            return JSON.parse(res);
+          }
+        }
+      };
+      const devCore = { onDocumentReady, env };
+      globalThis.joliboxJSCore = {
+        ...devCore
+      };
+    }
+  }
+});
+
+// src/native/js-core/utils.ts
+function normalizeParams(params, type) {
+  return {
+    params,
+    __extra: {
+      startTime: Date.now(),
+      type
+    }
+  };
+}
+var init_utils2 = __esm({
+  "src/native/js-core/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/native/js-core/message-port.ts
+function initMessagePort() {
+  globalThis.onmessage = function(msg) {
+    if (msg.data !== "msg:setup") {
+      return;
+    }
+    [messagePort] = msg.ports;
+    messagePort.onmessage = function(message) {
+      const data = JSON.parse(message.data);
+      if (data[0] === "publish") {
+        globalThis.ttJSBridge.subscribeHandler(data[1], data[2]);
+      } else if (data[0] === "invoke") {
+        globalThis.ttJSBridge.invokeHandler(data[1], data[2]);
+      }
+    };
+    messagePort.publish = function(event, params) {
+      const data = normalizeParams(params, "messagePort");
+      messagePort.postMessage(JSON.stringify(["publish", event, JSON.stringify(data)]));
+    };
+    messagePort.postMessage("msg:setup:ok");
+  };
+}
+var messagePort;
+var init_message_port = __esm({
+  "src/native/js-core/message-port.ts"() {
+    "use strict";
+    init_utils2();
+  }
+});
+
+// src/native/js-core/index.ts
+var init_js_core = __esm({
+  "src/native/js-core/index.ts"() {
+    "use strict";
+    init_jolibox_js_core();
+    init_message_port();
+    init_utils2();
+  }
+});
+
+// src/native/bootstrap/bridge.ts
+var jsCore, core, bridge, invokeHandler, applyNative, invokeNative, onNative, offNative, subscribeHandler;
+var init_bridge = __esm({
+  "src/native/bootstrap/bridge.ts"() {
+    "use strict";
+    init_js_bridge2();
+    init_js_core();
+    init_errors();
+    init_index_es();
+    init_js_core();
+    jsCore = joliboxJSCore;
+    if (!jsCore) {
+      throw new B("No joliboxJScore is found, native bridge not found.");
+    }
+    initMessagePort();
+    core = {
+      ...jsCore
+      // publish(event: string, params: Record<string, unknown>, webviewIds: number[]) {
+      //   if (messagePort) {
+      //     messagePort.publish(event, params);
+      //     return;
+      //   }
+      //   jsCore.publish(event, params, webviewIds);
+      // }
+    };
+    bridge = createBridge(core);
+    ({ invokeHandler } = bridge);
+    ({ applyNative, invokeNative, onNative, offNative, subscribeHandler } = bridge);
+    globalThis.joliboxJSBridge = {
+      callHandler: invokeHandler,
+      invokeHandler,
+      subscribeHandler
+    };
+  }
+});
+
+// src/common/context/url-parse.ts
+var base64UrlDecode, parseUrlQuery;
+var init_url_parse = __esm({
+  "src/common/context/url-parse.ts"() {
+    "use strict";
+    init_index_es();
+    init_report();
+    base64UrlDecode = (input) => {
+      const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+      const padding = base64.length % 4 === 0 ? "" : "=".repeat(4 - base64.length % 4);
+      const jsonStr = atob(base64 + padding);
+      try {
+        return JSON.parse(jsonStr);
+      } catch (e) {
+        return {};
+      }
+    };
+    parseUrlQuery = (url) => {
+      try {
+        const urlObj = new URL(url);
+        const params = urlObj.searchParams;
+        const joli_source = params.get("joliSource")?.split(".");
+        if (joli_source?.length) {
+          const [headerJsonStr, payloadJsonStr, signatureJsonStr] = joli_source;
+          return {
+            headerJson: base64UrlDecode(headerJsonStr),
+            payloadJson: base64UrlDecode(payloadJsonStr),
+            signature: base64UrlDecode(signatureJsonStr)
+          };
+        } else {
+          throw `joli_source is missing`;
+        }
+      } catch (e) {
+        reportError(new H(`${url} not a valid schema: ${e}`));
+        return {
+          headerJson: {},
+          payloadJson: {},
+          signature: {}
+        };
+      }
+    };
+  }
+});
+
+// src/common/http/uuid.ts
+var uuidv4;
+var init_uuid = __esm({
+  "src/common/http/uuid.ts"() {
+    "use strict";
+    uuidv4 = () => {
+      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v2 = c === "x" ? r : r & 3 | 8;
+        return v2.toString(16);
+      });
+    };
+  }
+});
+
+// src/common/http/xua.ts
+var platform, getPlatform, jssdkVersion, getAppVersion, DEVICE_ID, ADVERTISING_ID, getStorage, getDeviceId, getAdvertisingId, firstCharUpperCase, getUtmSource, xUserAgent;
+var init_xua = __esm({
+  "src/common/http/xua.ts"() {
+    "use strict";
+    init_uuid();
+    platform = {
+      isiOS: navigator.userAgent.includes("iPhone") || navigator.userAgent.includes("iPod") || navigator.userAgent.includes("iPad") || navigator.userAgent.includes("iPhone OS"),
+      iosVersion: () => {
+        const v2 = navigator.appVersion.match(/OS (\d+)_(\d+)_?(\d+)?/);
+        return [parseInt(v2[1], 10), parseInt(v2[2], 10), parseInt(v2[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")
+    };
+    getPlatform = () => {
+      if (platform.isiOS) {
+        return "iOS";
+      } else if (platform.isAndroid) {
+        return "Android";
+      } else if (platform.isMac) {
+        return "Mac";
+      } else if (platform.isFacebook) {
+        return "Facebook";
+      } else {
+        return "PC";
+      }
+    };
+    jssdkVersion = "1.1.4-beta.4";
+    getAppVersion = () => {
+      return jssdkVersion;
+    };
+    DEVICE_ID = "device_id";
+    ADVERTISING_ID = "advertising_id";
+    getStorage = (cookieKey) => {
+      if (!localStorage.getItem(cookieKey)) {
+        localStorage.setItem(cookieKey, uuidv4());
+      }
+      return localStorage.getItem(cookieKey);
+    };
+    getDeviceId = () => {
+      return getStorage(DEVICE_ID);
+    };
+    getAdvertisingId = () => {
+      return getStorage(ADVERTISING_ID);
+    };
+    firstCharUpperCase = (chars) => chars.charAt(0).toUpperCase() + chars.slice(1);
+    getUtmSource = () => {
+      const urlParams = new URLSearchParams(window.location.search);
+      return firstCharUpperCase(urlParams.get("utm_source") ?? "") || "JoliboxSDK";
+    };
+    xUserAgent = () => {
+      const applicationName = "JoliboxWebSDK";
+      const thePlatform = getPlatform();
+      const locale = navigator.language;
+      const deviceId = getDeviceId();
+      const adid = getAdvertisingId();
+      const appVersion = getAppVersion();
+      const deviceModel = "UnknownModel";
+      const systemVersion = "UnknownSystemVersion";
+      return `${applicationName} (${getUtmSource()}${thePlatform}; ${deviceModel}; ${systemVersion}; ${locale}) uuid/${deviceId} adid/${adid} version/${appVersion || ""}`;
+    };
+  }
+});
+
+// src/common/context/index.ts
+var defaultEnv, nativeEnv, env2, wrapContext, context;
+var init_context = __esm({
+  "src/common/context/index.ts"() {
+    "use strict";
+    init_index_es();
+    init_url_parse();
+    init_xua();
+    defaultEnv = {
+      deviceInfo: {
+        brand: "",
+        model: "",
+        did: getDeviceId(),
+        pixelRatio: window.devicePixelRatio || 1,
+        platform: "h5",
+        system: "",
+        lang: "zh"
+      },
+      hostInfo: {
+        appName: "",
+        version: getAppVersion(),
+        aid: "",
+        channel: ""
+      },
+      sdkInfo: {
+        nativeSDKVersion: "",
+        jssdkVersion: getAppVersion()
+      },
+      schema: "",
+      platform: "h5"
+    };
+    nativeEnv = globalThis.joliboxJSCore?.env;
+    env2 = Object.assign({}, nativeEnv?.() ?? defaultEnv);
+    wrapContext = () => {
+      const { payloadJson, headerJson } = parseUrlQuery(env2.schema);
+      const defaultSessionId = `${env2.deviceInfo.did}-${(/* @__PURE__ */ new Date()).getTime()}`;
+      const urlParams = new URLSearchParams(window.location.search);
+      const defaultGameID = urlParams.get("appId") ?? urlParams.get("gameId") ?? "";
+      const sessionId = payloadJson.sessionId ?? urlParams.get("sessionId") ?? defaultSessionId;
+      const testAdsMode = !!(payloadJson.testAdsMode ?? urlParams.get("testAdsMode") === "true");
+      const joliboxEnv = payloadJson.joliboxEnv ?? urlParams.get("joliboxEnv") ?? "production";
+      const testMode = joliboxEnv === "staging";
+      return {
+        get testMode() {
+          return testMode;
+        },
+        get testAdsMode() {
+          return testAdsMode;
+        },
+        get joliboxEnv() {
+          return joliboxEnv;
+        },
+        get game_id() {
+          return defaultGameID ?? payloadJson["id"];
+        },
+        get game_version() {
+          return headerJson.ver ?? "";
+        },
+        get platform() {
+          return env2.platform;
+        },
+        get deviceInfo() {
+          return env2.deviceInfo;
+        },
+        get sdkInfo() {
+          return env2.sdkInfo;
+        },
+        get hostInfo() {
+          return env2.hostInfo;
+        },
+        get hostUserInfo() {
+          return env2.hostUserInfo;
+        },
+        get session_id() {
+          return env2.clientSessionId ?? sessionId ?? defaultSessionId;
+        },
+        onEnvConfigChanged: (newConfig) => {
+          ke(env2, newConfig, Le);
+        }
+      };
+    };
+    context = wrapContext();
+  }
+});
+
+// src/common/report/errors/report/listeners.ts
+var reportFlag, hasIn, isBaseError, toCamelCase, innerErrorReport, isUserError;
+var init_listeners = __esm({
+  "src/common/report/errors/report/listeners.ts"() {
+    "use strict";
+    init_index_es();
+    init_report();
+    init_context();
+    init_index_es();
+    reportFlag = false;
+    hasIn = (object, path) => {
+      if (object == null) return false;
+      return path in object;
+    };
+    isBaseError = (error) => {
+      return hasIn(error, "kind");
+    };
+    toCamelCase = (snakeStr) => {
+      const words = snakeStr.toLowerCase().split("_");
+      return words[0] + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+    };
+    innerErrorReport = (error, options = {}, isFromUser) => {
+      const priority = error.priority ?? "P1";
+      const common = {
+        user_id: context.hostUserInfo?.uid ?? "",
+        device_id: context.deviceInfo.did ?? "",
+        timestamp: Date.now(),
+        tag: toCamelCase(error.name)
+      };
+      const reports = { ...common, env: options.environment, isFromUser };
+      if (isFromUser) {
+        errorReportEmitter.emit("GLOBAL_USER_ERROR", error, reports);
+      } else {
+        errorReportEmitter.emit("GLOBAL_ERROR", error, reports);
+      }
+    };
+    isUserError = (error) => {
+      return hasIn(error, "kind") && error["kind"] === "USER_ERROR";
+    };
+    errorReportCollector.on("ERROR_REPORT", ({ error, options }) => {
+      if (reportFlag) return;
+      reportFlag = true;
+      const raw = isBaseError(error) && error.raw ? error.raw : error;
+      try {
+        const isFromUser = isUserError(error);
+        innerErrorReport(error, options, isFromUser);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const reportError2 = new Y(`${message}, origin error: ${raw.message}`);
+        q.error(reportError2);
+        innerErrorReport(
+          new Y(reportError2.message),
+          {
+            environment: options.environment
+          },
+          false
+        );
+      } finally {
+        reportFlag = false;
+      }
+    });
+  }
+});
+
+// src/native/report/errors/index.ts
+var init_errors2 = __esm({
+  "src/native/report/errors/index.ts"() {
+    "use strict";
+    init_listeners();
+    init_errors();
+    init_index_es();
+    init_bridge();
+    errorReportEmitter.on("GLOBAL_ERROR", (error, errorData) => {
+      const extra = {
+        message: error.message,
+        stack: error.stack ?? "",
+        errorType: error.name,
+        source: 0
+      };
+      invokeNative("trackAsync", {
+        event: "reportJsError",
+        data: extra
+      });
+    });
+    errorReportEmitter.on("GLOBAL_USER_ERROR", (error, errorData) => {
+      q.log("UserError", error, errorData);
+    });
+  }
+});
+
+// src/common/report/types.ts
+var init_types2 = __esm({
+  "src/common/report/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/common/report/track.ts
+function createTrack(reportHandler, common) {
+  const track2 = (tag, info, webviewId) => {
+    const data = {
+      tag,
+      ...common,
+      extra: {
+        ...info
+      }
+    };
+    if (tag == "globalJsError") {
+      reportError(new $(JSON.stringify(data), "P0"));
+    } else {
+      reportHandler("systemLog", data, webviewId);
+    }
+  };
+  track2.debounce = Ue(track2, 500, { leading: true });
+  return track2;
+}
+function createTrackPerformance(track2) {
+  const trackPerformance2 = (type, duration, data) => {
+    const length = (data && JSON.stringify(data)) ?? 0;
+    const info = {
+      speed_value_type: type,
+      total_duration: duration
+    };
+    if (length) {
+      Object.assign(info, { extra: length });
+    }
+    track2("joliboxSpeedAnalysis", info);
+  };
+  trackPerformance2.debounce = Ue(trackPerformance2, 500, {
+    leading: true
+  });
+  return trackPerformance2;
+}
+var init_track = __esm({
+  "src/common/report/track.ts"() {
+    "use strict";
+    init_index_es();
+    init_index_es();
+    init_report();
+  }
+});
+
+// src/common/report/create-trace.ts
+function createTracks(reportHandler, common) {
+  const track2 = createTrack(reportHandler, common);
+  const trackPerformance2 = createTrackPerformance(track2);
+  return {
+    track: track2,
+    trackPerformance: trackPerformance2
+  };
+}
+var init_create_trace = __esm({
+  "src/common/report/create-trace.ts"() {
+    "use strict";
+    init_track();
+  }
+});
+
+// src/common/report/base-tracker.ts
+var init_base_tracker = __esm({
+  "src/common/report/base-tracker.ts"() {
+    "use strict";
+    init_context();
+    init_index_es();
+  }
+});
+
+// src/common/report/index.ts
+var init_report3 = __esm({
+  "src/common/report/index.ts"() {
+    "use strict";
+    init_create_trace();
+    init_types2();
+    init_base_tracker();
+  }
+});
+
+// src/common/report/task-track/index.ts
+var TaskTracker;
+var init_task_track = __esm({
+  "src/common/report/task-track/index.ts"() {
+    "use strict";
+    TaskTracker = class {
+      constructor(eventEmitter, interval) {
+        this.lastReportTime = 0;
+        this.visible = true;
+        this.timer = this.createRAFTimer((duration) => {
+          this.reporter({
+            event: "PLAY_GAME",
+            params: {
+              duration: duration / 1e3
+              // second
+            }
+          });
+        });
+        this.interval = interval ?? 10 * 1e3;
+        eventEmitter.on("visible", (visible) => {
+          this.visible = visible;
+        });
+      }
+      start(duration) {
+        this.reporter({
+          event: "OPEN_GAME",
+          params: {
+            timestamp: Date.now(),
+            duration: duration ?? 0 / 1e3
+            // second
+          }
+        });
+        this.timer.start();
+      }
+      close(duration) {
+        this.reporter({
+          event: "CLOSE_GAME",
+          params: {
+            timestamp: Date.now(),
+            duration: duration / 1e3
+            // second
+          }
+        });
+        this.timer.stop();
+      }
+      createRAFTimer(callback) {
+        let lastTime = performance.now();
+        let rafId;
+        let isRunning = false;
+        let totalTime = 0;
+        const tick = (currentTime) => {
+          if (!isRunning) return;
+          const deltaTime = currentTime - lastTime;
+          if (deltaTime >= this.interval) {
+            if (this.visible) {
+              totalTime += deltaTime;
+              callback(totalTime);
+            }
+            lastTime = currentTime;
+          }
+          rafId = requestAnimationFrame(tick);
+        };
+        return {
+          start() {
+            if (!isRunning) {
+              isRunning = true;
+              lastTime = performance.now();
+              rafId = requestAnimationFrame(tick);
+            }
+          },
+          stop() {
+            isRunning = false;
+            if (rafId) {
+              cancelAnimationFrame(rafId);
+            }
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/native/network/types.ts
+var init_types3 = __esm({
+  "src/native/network/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/native/network/report.ts
+function reportNetworkAPI(method, url, options) {
+  const { response, startTime, endTime, requestFrom } = options;
+  const { errMsg = "", profile = {} } = response;
+  const duration = endTime - startTime;
+  const trackData = {
+    duration,
+    request_type: method,
+    url: url.split("?")[0],
+    result: options.state,
+    error_msg: options.state === "fail" ? errMsg : "",
+    socket_reused: profile.socketReused ? 1 : 0,
+    request_from: requestFrom
+  };
+  if (requestFrom === "public" /* PUBLIC */ && requestNumber < requestNumberLimit || requestFrom === "inner" /* INNER */) {
+    trackData.joli_request_number = requestNumber++;
+    setTimeout(() => {
+      track("joliboxNetRequestResult", trackData);
+    }, 500);
+  }
+}
+var requestNumber, requestNumberLimit;
+var init_report4 = __esm({
+  "src/native/network/report.ts"() {
+    "use strict";
+    init_types3();
+    init_report5();
+    requestNumber = 0;
+    requestNumberLimit = 10;
+  }
+});
+
+// src/native/network/create-fetch.ts
+function createFetch(createMethod, operateMethod, options) {
+  const promiseMap = /* @__PURE__ */ new Map();
+  const baseUrl = options?.baseUrl ?? `https://api.jolibox.com`;
+  const type = options?.type ?? "public";
+  const defaultHeaders = options?.defaultHeaders ?? {};
+  onNative("onRequestTaskStateChange", (res) => {
+    if (typeof res.requestTaskId !== "string") return;
+    const task = promiseMap.get(res.requestTaskId);
+    if (!task) return;
+    if (res.state === "success") {
+      const { requestTaskId, state, ...rest } = res;
+      task.resolve(rest);
+      promiseMap.delete(requestTaskId);
+    } else if (res.state === "fail") {
+      const { requestTaskId, state, ...rest } = res;
+      task.reject(rest);
+      promiseMap.delete(requestTaskId);
+    } else {
+      q.warn(`onRequestTaskStateChange unknown event`, res);
+    }
+  });
+  En.on("onLoginComplete", ({ isLogin, token }) => {
+    if (isLogin && token) {
+      defaultHeaders["X-JOLI-TOKEN"] = token;
+    }
+  });
+  const fetch = async (originUrl, options2 = {}) => {
+    const startTime = Date.now();
+    const url = processUrl(originUrl, { ...options2, baseUrl });
+    const {
+      method = "GET",
+      responseType = "text",
+      dataType = "json",
+      timeout,
+      enableCache = false,
+      appendHostCookie = true
+    } = options2;
+    const header = Object.assign({ "content-type": "application/json" }, defaultHeaders, options2.header);
+    const params = {
+      url,
+      method,
+      header,
+      enableCache,
+      responseType,
+      appendHostCookie
+    };
+    if (method == "POST" || method == "PUT") {
+      const data = normalizeData(options2.data, header["content-type"]);
+      params["data"] = data;
+    }
+    if (timeout) {
+      Object.assign(params, { timeout });
+    }
+    const {
+      data: { requestTaskId }
+    } = invokeNative(createMethod, params);
+    if (typeof requestTaskId !== "string") {
+      throw createAPIError({
+        code: -1,
+        msg: "requestTaskId is not a string"
+      });
+    }
+    const report = (state, response) => {
+      reportNetworkAPI("request", url, {
+        state,
+        startTime,
+        endTime: Date.now(),
+        params,
+        response,
+        requestId: requestTaskId,
+        requestFrom: type == "public" ? "public" /* PUBLIC */ : "inner" /* INNER */
+      });
+    };
+    const { resolve, reject, promise } = new L();
+    promiseMap.set(requestTaskId, { resolve, reject });
+    try {
+      const res = await promise;
+      report("success", res);
+      let { data } = res;
+      if (dataType === "json" && typeof data === "string") {
+        data = parseJSON(data);
+      }
+      return {
+        url,
+        timeout,
+        method,
+        response: { ...res, data }
+      };
+    } catch (err) {
+      const error = err;
+      if (ie(error)) {
+        const { errMsg, prefetchDetail, isPrefetch, errNo } = error;
+        if (b(errMsg)) {
+          report("fail", {
+            errMsg,
+            isPrefetch,
+            prefetchDetail
+          });
+          reportError(createAPIError({ code: -1, msg: errMsg }, { errNo, errMsg }));
+        }
+      }
+      throw err;
+    }
+  };
+  return fetch;
+}
+function parseJSON(data) {
+  try {
+    return JSON.parse(data.trim());
+  } catch {
+    return data;
+  }
+}
+function normalizeData(data, contentType = "application/json") {
+  const type = contentType.toLowerCase();
+  if (data === void 0) {
+    return "";
+  }
+  if (typeof data === "string" || data instanceof ArrayBuffer) {
+    return data;
+  }
+  if (type.includes("application/x-www-form-urlencoded")) {
+    return JSON.stringify(data);
+  }
+  if (type.includes("application/json")) {
+    return JSON.stringify(data);
+  }
+  if (typeof data === "object") {
+    return JSON.stringify(data);
+  }
+  return String(data);
+}
+var processUrl;
+var init_create_fetch = __esm({
+  "src/native/network/create-fetch.ts"() {
+    "use strict";
+    init_index_es();
+    init_report4();
+    init_types3();
+    init_bridge();
+    init_report();
+    init_errors();
+    processUrl = (url, options) => {
+      if (/^https?:\/\//.test(url)) {
+        return url;
+      }
+      const query = options?.query;
+      const searchParams = new URLSearchParams(query);
+      const search = searchParams.toString();
+      return options?.baseUrl ? `${options.baseUrl}${url}${search ? `?${search}` : ""}` : `${url}${search ? `?${search}` : ""}`;
+    };
+  }
+});
+
+// src/native/network/index.ts
+var innerFetch;
+var init_network = __esm({
+  "src/native/network/index.ts"() {
+    "use strict";
+    init_xua();
+    init_create_fetch();
+    init_context();
+    innerFetch = createFetch("createRequestTaskSync", "operateRequestTaskSync", {
+      type: "inner",
+      baseUrl: context.testMode ? "https://stg-api.jolibox.com" : "https://api.jolibox.com",
+      defaultHeaders: {
+        "x-user-agent": xUserAgent(),
+        "X-JOLI-TOKEN": context.hostUserInfo?.token ?? ""
+      }
+    });
+  }
+});
+
+// src/native/report/task-tracker.ts
+var NativeTaskTracker;
+var init_task_tracker = __esm({
+  "src/native/report/task-tracker.ts"() {
+    "use strict";
+    init_context();
+    init_task_track();
+    init_network();
+    init_bridge();
+    NativeTaskTracker = class extends TaskTracker {
+      constructor(eventEmitter, interval) {
+        super(eventEmitter, interval);
+        this.gameId = context.game_id;
+        this.sessionId = context.session_id;
+      }
+      async reporter(point) {
+        const { event, params } = point;
+        const reportTasks = [];
+        reportTasks.push(
+          innerFetch(`/api/base/app-event`, {
+            method: "POST",
+            data: {
+              eventType: event,
+              gameInfo: {
+                gameId: this.gameId,
+                sessionId: this.sessionId,
+                ...params
+              }
+            }
+          })
+        );
+        await Promise.all(reportTasks);
+      }
+      async reportToNative(point) {
+        const { event, params } = point;
+        await applyNative("userTrackAsync", {
+          event,
+          params: {
+            ...params
+          },
+          gameId: this.gameId
+        });
+      }
+    };
+  }
+});
+
+// src/native/report/index.ts
+var reportNative, track, trackPerformance, commands, nativeTaskEmitter, taskTracker;
+var init_report5 = __esm({
+  "src/native/report/index.ts"() {
+    "use strict";
+    init_errors2();
+    init_index_es();
+    init_types2();
+    init_report3();
+    init_context();
+    init_task_tracker();
+    init_bridge();
+    reportNative = (event, data, webviewId) => {
+      const _data = data;
+      const originExtra = ie(_data.extra) ? _data.extra : b(_data.extra) ? JSON.parse(_data.extra) : {};
+      const extra = {
+        ...originExtra,
+        source_id: _data.source_id ?? "",
+        source_version: _data.source_version ?? ""
+      };
+      invokeNative("trackAsync", {
+        event,
+        data: extra,
+        webviewId
+      });
+    };
+    ({ track, trackPerformance } = createTracks(reportNative, {
+      type: "app-sdk" /* AppSDK */,
+      platform: "native",
+      jssdk_version: context.sdkInfo?.jssdkVersion ?? "1.0.0",
+      source_id: context.game_id,
+      source_version: context.game_version
+    }));
+    commands = Vn();
+    commands.registerCommand("ReportSDK.traceSystemTimeline", ({ event, duration }) => {
+      trackPerformance(event, duration);
+    });
+    commands.registerCommand("ReportSDK.traceSystem", ({ event, info }) => {
+      track(event, info);
+    });
+    nativeTaskEmitter = new _();
+    taskTracker = new NativeTaskTracker(nativeTaskEmitter);
+  }
+});
+
+// src/common/can-i-use.ts
+function registerCanIUseFactory(platform2) {
+  let configMap = Be.config[platform2];
+  if (!configMap) {
+    configMap = {};
+    Be.config[platform2] = configMap;
+  }
+  return (name, config2) => {
+    if (configMap[name]) {
+      q.warn(`[can i use] ${name} already registered`);
+      return;
+    }
+    configMap[name] = {
+      ...config2
+    };
+  };
+}
+var init_can_i_use = __esm({
+  "src/common/can-i-use.ts"() {
+    "use strict";
+    init_index_es();
+  }
+});
+
+// src/common/api-factory/validator/validate.ts
+function setCollect(flag) {
+  collectError = flag;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  return Object.keys(obj).reduce((acc, key) => {
+    acc[key] = deepClone(obj[key]);
+    return acc;
+  }, {});
+}
+function isNumber(x2) {
+  return typeof x2 === "number";
+}
+function echo(x2) {
+  const s = getType2(x2);
+  switch (s) {
+    case "string":
+      return `"${x2}"`;
+    case "number":
+    case "boolean":
+    case "null":
+    case "undefined":
+      return String(x2);
+    default:
+      return `a(n) ${s}`;
+  }
+}
+function getType2(x2) {
+  if (typeof x2 === "function") return "function";
+  const type = Object.prototype.toString.call(x2).slice(8).slice(0, -1);
+  return type.toLowerCase();
+}
+var collectError, Validator, $number, $boolean, $string, $symbol, $any, $undefined, $null, $function, $enum, $array, $record, $object, $literal, $or, $tuple, $arraybuffer, $typedarray;
+var init_validate = __esm({
+  "src/common/api-factory/validator/validate.ts"() {
+    "use strict";
+    collectError = false;
+    Validator = class {
+      constructor() {
+        this.errors = [];
+        this.hasFallback = false;
+        this.hasDefault = false;
+        this._optional = false;
+      }
+      fail(options) {
+        if (collectError) {
+          if (typeof options === "string") {
+            this.errors.push(options);
+          } else {
+            let message = `${this.path} should be ${options.expect}`;
+            if (this._optional && options.expect !== "undefined") {
+              message += " or undefined, ";
+            } else {
+              message += ", ";
+            }
+            message += `but got ${echo(options.actual)}`;
+            this.errors.push(message);
+          }
+        }
+        return false;
+      }
+      fallback(v2) {
+        this.hasFallback = true;
+        this._fallback = v2;
+        return this;
+      }
+      get fallbackValue() {
+        return deepClone(this._fallback);
+      }
+      default(v2) {
+        this.hasDefault = true;
+        this._default = v2;
+        return this;
+      }
+      get defaultValue() {
+        if (typeof this._default === "function") {
+          return this._default;
+        }
+        return deepClone(this._default);
+      }
+      optional() {
+        this._optional = true;
+        return this;
+      }
+    };
+    $number = class extends Validator {
+      validate(x2) {
+        if (this._optional && x2 === void 0) return true;
+        if (!isNumber(x2)) {
+          return this.fail({ expect: "number", actual: x2 });
+        }
+        if (isNumber(this._min) && x2 < this._min) {
+          return this.fail(`the value of ${this.path} should be greater than or equal to ${this._min}`);
+        }
+        if (isNumber(this._max) && x2 > this._max) {
+          return this.fail(`the value of ${this.path} should be less than or equal to ${this._max}`);
+        }
+        if (isNumber(this._greater) && x2 <= this._greater) {
+          return this.fail(`the value of ${this.path} should be greater than ${this._greater}`);
+        }
+        if (this._isInt && x2 !== Math.floor(x2)) {
+          return this.fail(`the value of ${this.path} should be integer but got ${x2}`);
+        }
+        return true;
+      }
+      min(v2) {
+        this._min = v2;
+        return this;
+      }
+      max(v2) {
+        this._max = v2;
+        return this;
+      }
+      isInt(v2) {
+        this._isInt = v2;
+        return this;
+      }
+      greater(v2) {
+        this._greater = v2;
+        return this;
+      }
+    };
+    $boolean = class extends Validator {
+      validate(x2) {
+        if (this._optional && x2 === void 0) return true;
+        if (typeof x2 !== "boolean") {
+          return this.fail({ expect: "boolean", actual: x2 });
+        }
+        return true;
+      }
+    };
+    $string = class extends Validator {
+      validate(x2) {
+        if (this._optional && x2 === void 0) return true;
+        if (typeof x2 !== "string") {
+          return this.fail({ expect: "string", actual: x2 });
+        }
+        if (isNumber(this._maxLength) && x2.length > this._maxLength) {
+          return this.fail(`the length of ${this.path} should be less than or equal to ${this._maxLength}`);
+        }
+        if (isNumber(this._minLength) && x2.length < this._minLength) {
+          return this.fail(`the length of ${this.path} should be greater than or equal to ${this._minLength}`);
+        }
+        if (typeof this._pattern === "string") {
+          const reg = new RegExp(this._pattern);
+          if (!reg.test(x2)) {
+            return this.fail(`${this.path} should match pattern "${this._pattern}"`);
+          }
+        } else if (this._pattern) {
+          if (!this._pattern.test(x2)) {
+            return this.fail(`${this.path} should match pattern "${this._pattern.toString()}"`);
+          }
+        }
+        return true;
+      }
+      minLength(len) {
+        this._minLength = len;
+        return this;
+      }
+      maxLength(len) {
+        this._maxLength = len;
+        return this;
+      }
+      pattern(patten) {
+        this._pattern = patten;
+        return this;
+      }
+    };
+    $symbol = class extends Validator {
+      validate(x2) {
+        if (this._optional && x2 === void 0) return true;
+        if (typeof x2 !== "symbol") {
+          return this.fail({ expect: "symbol", actual: x2 });
+        }
+        return true;
+      }
+    };
+    $any = class extends Validator {
+      // eslint-disable-next-line class-methods-use-this
+      validate(x2) {
+        return true;
+      }
+    };
+    $undefined = class extends Validator {
+      validate(x2) {
+        if (x2 !== void 0) {
+          return this.fail({ expect: "undefined", actual: x2 });
+        }
+        return true;
+      }
+    };
+    $null = class extends Validator {
+      validate(x2) {
+        if (this._optional && x2 === void 0) return true;
+        if (x2 !== null) {
+          return this.fail({ expect: "null", actual: x2 });
+        }
+        return true;
+      }
+    };
+    $function = class extends Validator {
+      validate(x2) {
+        if (this._optional && x2 === void 0) return true;
+        if (typeof x2 !== "function") {
+          return this.fail({ expect: "function", actual: x2 });
+        }
+        return true;
+      }
+    };
+    $enum = class extends Validator {
+      constructor(..._items) {
+        super();
+        this._items = _items;
+      }
+      validate(x2) {
+        if (this._optional && x2 === void 0) return true;
+        if (!this._items.includes(x2)) {
+          const enums = this._items.map((i) => JSON.stringify(i)).join(", ");
+          return this.fail(`expect ${this.path} to be one of ${enums}, but got ${echo(x2)}`);
+        }
+        return true;
+      }
+    };
+    $array = class extends Validator {
+      constructor(_item) {
+        super();
+        this._item = _item;
+      }
+      validate(x2) {
+        if (this._optional && x2 === void 0) return true;
+        if (!Array.isArray(x2)) {
+          return this.fail({ expect: "array", actual: x2 });
+        }
+        if (isNumber(this._minItems) && x2.length < this._minItems) {
+          return this.fail(`the length of ${this.path} should be greater than or equal to ${this._minItems}`);
+        }
+        if (isNumber(this._maxItems) && x2.length > this._maxItems) {
+          return this.fail(`the length of ${this.path} should be less than or equal to ${this._maxItems}`);
+        }
+        if (isNumber(this._length) && x2.length !== this._length) {
+          return this.fail(`the length of ${this.path} should be equal to ${this._length}`);
+        }
+        const validator = this._item;
+        if (!validator) return true;
+        let result = true;
+        x2.forEach((item, index) => {
+          validator.path = `${this.path}[${index}]`;
+          validator.errors = this.errors;
+          if (item === void 0 && validator.hasDefault) {
+            x2[index] = validator.defaultValue;
+            return;
+          }
+          if (!validator.validate(item)) {
+            if (validator.hasFallback) {
+              x2[index] = validator.fallbackValue;
+            } else {
+              result = false;
+            }
+          }
+        });
+        if (this._uniqueItems) {
+          const map = /* @__PURE__ */ new Map();
+          for (let i in x2) {
+            if (map.has(x2[i])) {
+              result = this.fail(
+                `${this.path} should NOT have duplicate items (${this.path}[${map.get(x2[i])}] and ${this.path}[${i}] are identical)`
+              );
+            } else {
+              map.set(x2[i], i);
+            }
+          }
+        }
+        return result;
+      }
+      minItems(len) {
+        this._minItems = len;
+        return this;
+      }
+      maxItems(len) {
+        this._maxItems = len;
+        return this;
+      }
+      uniqueItems() {
+        this._uniqueItems = true;
+        return this;
+      }
+      length(len) {
+        this._length = len;
+        return this;
+      }
+    };
+    $record = class extends Validator {
+      constructor(_value) {
+        super();
+        this._value = _value;
+      }
+      validate(x2) {
+        if (this._optional && x2 === void 0) return true;
+        const type = getType2(x2);
+        if (type !== "object") {
+          return this.fail({ expect: "object", actual: x2 });
+        }
+        const values = x2;
+        const validator = this._value;
+        validator.errors = this.errors;
+        let result = true;
+        for (const k2 in values) {
+          const value = values[k2];
+          if (/^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/.test(k2)) {
+            validator.path = `${this.path}.${k2}`;
+          } else {
+            validator.path = `${this.path}["${k2}"]`;
+          }
+          if (value === void 0 && validator._optional) {
+            continue;
+          }
+          if (value === void 0 && validator.hasDefault) {
+            values[k2] = validator.defaultValue;
+            continue;
+          }
+          if (!validator.validate(value)) {
+            if (validator.hasFallback) {
+              values[k2] = validator.fallbackValue;
+            } else {
+              result = false;
+            }
+          }
+        }
+        return result;
+      }
+    };
+    $object = class extends Validator {
+      constructor(_object = {}) {
+        super();
+        this._object = _object;
+      }
+      validate(x2) {
+        if (this._optional && x2 === void 0) return true;
+        if (getType2(x2) !== "object") {
+          return this.fail({ expect: "object", actual: x2 });
+        }
+        const values = x2;
+        let result = true;
+        for (const k2 in this._object) {
+          const value = values[k2];
+          const validator = this._object[k2];
+          validator.errors = this.errors;
+          if (/^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/.test(k2)) {
+            validator.path = `${this.path}.${k2}`;
+          } else {
+            validator.path = `${this.path}["${k2}"]`;
+          }
+          if (validator._optional && value === void 0) {
+            continue;
+          }
+          if (value === void 0 && validator.hasDefault) {
+            values[k2] = validator.defaultValue;
+            continue;
+          }
+          if (!validator.validate(value)) {
+            if (validator.hasFallback) {
+              values[k2] = validator.fallbackValue;
+            } else {
+              result = false;
+            }
+          }
+        }
+        return result;
+      }
+    };
+    $literal = class extends Validator {
+      constructor(value) {
+        super();
+        this.value = value;
+      }
+      validate(x2) {
+        if (x2 === void 0 && this._optional) return true;
+        if (x2 !== this.value) {
+          return this.fail({ expect: echo(this.value), actual: x2 });
+        }
+        return true;
+      }
+    };
+    $or = class extends Validator {
+      constructor(..._items) {
+        super();
+        this._items = _items;
+      }
+      validate(x2) {
+        if (x2 === void 0 && this._optional) return true;
+        const orErrors = [];
+        let result = false;
+        const itemLength = this._items.length;
+        for (let i = 0; i < itemLength; i++) {
+          const validator = this._items[i];
+          validator.errors = [];
+          validator.path = this.path;
+          if (!validator.validate(x2)) {
+            orErrors.push(validator.errors.join("; "));
+          } else if (!result) {
+            result = true;
+            break;
+          }
+        }
+        if (!result) {
+          const grouped = orErrors.join("\nor ");
+          this.errors.push(grouped);
+        }
+        return result;
+      }
+    };
+    $tuple = class extends Validator {
+      constructor(..._items) {
+        super();
+        this._items = _items;
+        let optionalCount = 0;
+        let i = _items.length - 1;
+        for (; i >= 0; i--) {
+          const validator = _items[i];
+          if (validator._optional || validator.hasDefault) {
+            optionalCount += 1;
+          } else {
+            break;
+          }
+        }
+        this._minItems = _items.length - optionalCount;
+      }
+      validate(x2) {
+        if (x2 === void 0 && this._optional) return true;
+        if (!Array.isArray(x2)) {
+          return this.fail({ expect: "array", actual: x2 });
+        }
+        if (x2.length < this._minItems) {
+          return this.fail(`the length of ${this.path} should be greater than or equal to ${this._minItems}`);
+        }
+        let result = true;
+        this._items.forEach((validator, index) => {
+          validator.path = `${this.path}[${index}]`;
+          validator.errors = this.errors;
+          const item = x2[index];
+          if (item === void 0 && validator.hasDefault) {
+            x2[index] = validator.defaultValue;
+            return;
+          }
+          if (!validator.validate(x2[index])) {
+            if (validator.hasFallback) {
+              x2[index] = validator._fallback;
+            } else {
+              result = false;
+            }
+          }
+        });
+        return result;
+      }
+    };
+    $arraybuffer = class extends Validator {
+      validate(x2) {
+        if (x2 === void 0 && this._optional) return true;
+        if (x2 instanceof ArrayBuffer) {
+          return true;
+        }
+        return this.fail({ expect: "arraybuffer", actual: x2 });
+      }
+    };
+    $typedarray = class extends Validator {
+      constructor(ctor) {
+        super();
+        this._ctor = ctor;
+      }
+      validate(x2) {
+        if (x2 === void 0 && this._optional) return true;
+        if (x2 instanceof this._ctor) {
+          return true;
+        }
+        return this.fail({ expect: `typedarray of ${this._ctor.name}`, actual: x2 });
+      }
+    };
+  }
+});
+
+// src/common/api-factory/validator/index.ts
+function typeAsserts(validator, x2, path = "param") {
+  validator.errors = [];
+  validator.path = path;
+  setCollect(true);
+  if (!validator.validate(x2)) {
+    const messages = validator.errors.join("\n");
+    validator.errors.length = 0;
+    setCollect(false);
+    throw new TypeError(messages);
+  }
+}
+var t;
+var init_validator = __esm({
+  "src/common/api-factory/validator/index.ts"() {
+    "use strict";
+    init_validate();
+    init_validate();
+    t = {
+      object(schemas) {
+        return new $object(schemas);
+      },
+      array(schema) {
+        return new $array(schema);
+      },
+      tuple(...schemas) {
+        return new $tuple(...schemas);
+      },
+      literal(v2) {
+        return new $literal(v2);
+      },
+      or(...schemas) {
+        return new $or(...schemas);
+      },
+      symbol() {
+        return new $symbol();
+      },
+      record(schema) {
+        return new $record(schema);
+      },
+      function() {
+        return new $function();
+      },
+      boolean() {
+        return new $boolean();
+      },
+      string() {
+        return new $string();
+      },
+      number() {
+        return new $number();
+      },
+      undefined() {
+        return new $undefined();
+      },
+      null() {
+        return new $null();
+      },
+      unknown() {
+        return new $any();
+      },
+      any() {
+        return new $any();
+      },
+      as() {
+        return new $any();
+      },
+      arraybuffer() {
+        return new $arraybuffer();
+      },
+      enum(...values) {
+        return new $enum(...values);
+      },
+      typedarray(ctor) {
+        return new $typedarray(ctor);
+      }
+    };
+  }
+});
+
+// src/common/api-factory/index.ts
+var traceId, createAPIFactory;
+var init_api_factory = __esm({
+  "src/common/api-factory/index.ts"() {
+    "use strict";
+    init_index_es();
+    init_report();
+    init_validator();
+    init_errors();
+    traceId = 1;
+    createAPIFactory = (track2) => {
+      function createSyncAPI2(method, config2) {
+        return (...inputs) => {
+          const startTime = Date.now();
+          const reportExtra = { method, trace_id: traceId };
+          traceId += 1;
+          let status = "SUCCESS";
+          let errMsg = `${method}:ok`;
+          let errNo = 0;
+          try {
+            if (config2.paramsSchema) {
+              try {
+                typeAsserts(config2.paramsSchema, inputs, "params");
+              } catch (err) {
+                const error = err;
+                throw createUserAPIError(`${method}:fail ${error.message}`);
+              }
+            }
+            const res = config2.implement(...inputs);
+            let data = res;
+            let message = `${method}:ok`;
+            if (res && "code" in res) {
+              const {
+                code,
+                data: originData,
+                message: originMessage
+              } = res;
+              status = code;
+              data = originData;
+              message = originMessage;
+            }
+            return {
+              code: status,
+              message,
+              data
+            };
+          } catch (error) {
+            const _error = error;
+            errNo = _error.code ?? _error.errNo ?? 2e3;
+            status = "FAILURE";
+            const msg = _error.message ?? _error.errMsg ?? `${error}`;
+            errMsg = `${method}:${status} ${msg.replace(/^\S+:(fail|cancel)\s?/, "")}`;
+            reportError(new Q(errMsg, errNo));
+            return {
+              code: status,
+              message: errMsg
+            };
+          } finally {
+            const duration = Date.now() - startTime;
+            track2("apiInvoked", { ...reportExtra, duration, status });
+          }
+        };
+      }
+      function createAPI2(method, config2) {
+        return async (..._inputs) => {
+          const inputs = Ce(_inputs) ? _inputs : [_inputs];
+          const startTime = Date.now();
+          const reportExtra = { method, trace_id: traceId };
+          traceId += 1;
+          let message = `${method}:ok`;
+          let status = "SUCCESS";
+          const res = {
+            code: status,
+            message
+          };
+          try {
+            if (config2.paramsSchema) {
+              try {
+                typeAsserts(config2.paramsSchema, inputs, "params");
+              } catch (error) {
+                throw createUserAPIError(error.message);
+              }
+            }
+            const data = await config2.implement(...inputs);
+            let ret = data;
+            if (ret && "code" in ret) {
+              const {
+                code,
+                data: originData,
+                message: originMessage
+              } = ret;
+              status = code;
+              message = originMessage;
+              ret = originData;
+            }
+            Object.assign(res, {
+              code: status,
+              message,
+              data: ret
+            });
+            return res;
+          } catch (error) {
+            const _error = error;
+            const errNo = _error.code ?? _error.errNo ?? 2e3;
+            status = "FAILURE";
+            const msg = _error.message ?? _error.errMsg ?? `${error}`;
+            const errMsg = `${method}:${status} ${msg.replace(/^\S+:(fail|cancel)\s?/, "")}`;
+            Object.assign(res, {
+              code: status,
+              message: errMsg
+            });
+            reportError(new Q(errMsg, errNo));
+            return res;
+          } finally {
+            const duration = Date.now() - startTime;
+            track2("apiInvoked", { ...reportExtra, duration, status });
+          }
+        };
+      }
+      return { createAPI: createAPI2, createSyncAPI: createSyncAPI2 };
+    };
+  }
+});
+
+// src/native/api/base.ts
+var createAPI, createSyncAPI, registerCanIUse;
+var init_base = __esm({
+  "src/native/api/base.ts"() {
+    "use strict";
+    init_can_i_use();
+    init_report5();
+    init_api_factory();
+    init_validator();
+    ({ createAPI, createSyncAPI } = createAPIFactory(track));
+    registerCanIUse = registerCanIUseFactory("native");
+  }
+});
+
+// src/native/api/lifecycle.ts
+var require_lifecycle = __commonJS({
+  "src/native/api/lifecycle.ts"(exports) {
+    "use strict";
+    init_index_es();
+    init_base();
+    init_report();
+    init_bridge();
+    init_report5();
+    var EXIT_GAME = "exitGame";
+    var ON_READY = "onReady";
+    var ON_GAME_SHOW = "onGameShow";
+    var ON_GAME_HIDE = "onGameHide";
+    var commands8 = Vn();
+    var safeCallbackWrapper2 = He(reportError);
+    var exitGame = createAPI(EXIT_GAME, {
+      paramsSchema: t.tuple(t.function()),
+      implement: async (onBeforeExit) => {
+        const safeCallback = safeCallbackWrapper2(onBeforeExit);
+        safeCallback.call(exports);
+        await applyNative("exitAppAsync");
+      }
+    });
+    var onGameShow = createSyncAPI(ON_GAME_SHOW, {
+      paramsSchema: t.tuple(t.function()),
+      implement(callback) {
+        const safeCallback = safeCallbackWrapper2(callback);
+        onNative("onJoliboxEnterForeground", () => {
+          safeCallback.call(this);
+          nativeTaskEmitter.emit("visible", true);
+        });
+      }
+    });
+    var onGameHide = createSyncAPI(ON_GAME_HIDE, {
+      paramsSchema: t.tuple(t.function()),
+      implement(callback) {
+        const safeCallback = safeCallbackWrapper2(callback);
+        onNative("onJoliboxEnterBackground", () => {
+          safeCallback.call(this);
+          nativeTaskEmitter.emit("visible", false);
+        });
+      }
+    });
+    var onReadyHandler = createSyncAPI(ON_READY, {
+      paramsSchema: t.tuple(t.function()),
+      implement(callback) {
+        const safeCallback = safeCallbackWrapper2(callback);
+        En.on("LifecycleEvent.onReady", (info) => {
+          safeCallback(info);
+        });
+      }
+    });
+    commands8.registerCommand("LifecycleSDK.exit", exitGame);
+    commands8.registerCommand("LifecycleSDK.onReady", onReadyHandler);
+    commands8.registerCommand("LifecycleSDK.onJoliboxShow", onGameShow);
+    commands8.registerCommand("LifecycleSDK.onJoliboxHide", onGameHide);
+    registerCanIUse("lifeCycle.exit", {
+      version: "1.0.0"
+      // mock
+    });
+    registerCanIUse("lifeCycle.onReady", {
+      version: "1.0.0"
+      // mock
+    });
+    registerCanIUse("lifeCycle.onGameShow", {
+      version: "1.0.0"
+      // mock
+    });
+    registerCanIUse("lifeCycle.onGameHide", {
+      version: "1.0.0"
+      // mock
+    });
+  }
+});
+
+// src/native/bootstrap/index.ts
+init_bridge();
+init_js_core();
+init_context();
+init_index_es();
+init_report5();
+RuntimeLoader.onReady(() => {
+});
+RuntimeLoader.doExit(() => {
+  track("onBeforeExit", {
+    timestamp: Date.now()
+  });
+  return false;
+});
+function addWebviewReadyListener() {
+  En.on("onDocumentReady", () => {
+    joliboxJSCore?.onDocumentReady(window.location.href);
+    track("onDocumentReady", {
+      start_timestamp,
+      timestamp: Date.now()
+    });
+  });
+}
+function addGameServiceReadyListener() {
+  onNative("onJoliboxServiceReady", ({ runtimeInfo, loadDuration }) => {
+    runtimeInfo && context.onEnvConfigChanged({ hostUserInfo: runtimeInfo });
+    En.emit("LifecycleEvent.onReady", {
+      ...context.hostUserInfo ? context.hostUserInfo : { isLogin: false }
+    });
+    track("joliboxServiceReady", {
+      start_timestamp,
+      timestamp: Date.now()
+    });
+    taskTracker.start(loadDuration);
+  });
+  onNative("onBeforeExit", ({ uuid }) => {
+    joliboxJSCore?.doExit(uuid);
+  });
+}
+var start_timestamp;
+function config() {
+  start_timestamp = Date.now();
+  addGameServiceReadyListener();
+  addWebviewReadyListener();
+}
+
+// src/native/api/get-system-info.ts
+init_index_es();
+init_base();
+init_bridge();
+var commands2 = Vn();
+var API_ENV = "env";
+var API_GET_SYSTEM_SYNC = "getSystemInfoSync";
+var getSystemInfoSync = createSyncAPI(API_GET_SYSTEM_SYNC, {
+  implement: () => {
+    const res = invokeNative("envSync");
+    const { data } = res;
+    return {
+      system: data.deviceInfo.system,
+      platform: data.platform,
+      version: data.sdkInfo.jssdkVersion,
+      pixelRatio: data.deviceInfo.pixelRatio,
+      language: data.deviceInfo.lang
+    };
+  }
+});
+var getEnv = createSyncAPI(API_ENV, {
+  implement: () => {
+    const res = invokeNative("envSync");
+    return res?.data ?? void 0;
+  }
+});
+commands2.registerCommand("API.getSystemInfoSync", getSystemInfoSync);
+commands2.registerCommand("API.env", getEnv);
+registerCanIUse("env", {
+  version: "1.0.0"
+});
+registerCanIUse("getSystemInfoSync", {
+  version: "1.0.0"
+});
+
+// src/native/api/index.ts
+var import_lifecycle = __toESM(require_lifecycle());
+
+// src/native/api/request.ts
+init_errors();
+init_create_fetch();
+init_base();
+
+// src/native/network/utils.ts
+init_index_es();
+function normalizeHeader(header) {
+  const normalized = {};
+  if (!ie(header)) {
+    return normalized;
+  }
+  for (const [_key, value] of Object.entries(header)) {
+    const key = _key.toLocaleLowerCase();
+    if (!value) {
+      normalized[key] = "";
+    } else if (typeof value === "object") {
+      normalized[key] = Object.prototype.toString.call(value);
+    } else {
+      normalized[key] = String(value);
+    }
+  }
+  return normalized;
+}
+function normalizeMethod(method = "GET") {
+  if (method === "") {
+    return "POST";
+  }
+  const _method = method.toUpperCase();
+  if (["GET", "OPTIONS", "HEAD", "POST", "PUT", "DELETE", "TRACE", "CONNECT", "PATCH"].includes(_method)) {
+    return _method;
+  }
+  return "GET";
+}
+function normalizeTimeout(time, unlimited = false) {
+  if (!time) return void 0;
+  if (unlimited || time > 0 && time <= 6e4) return Math.ceil(time);
+  return 6e4;
+}
+function dirtyURL(url, method, data) {
+  if (["POST", "PUT", "PATCH"].includes(method)) return url;
+  if (!ie(data)) return url;
+  const [_url, search = ""] = url.split("?");
+  const query = JSON.stringify({
+    ...JSON.parse(search),
+    ...data
+  });
+  return `${_url}?${query}`;
+}
+
+// src/native/api/request.ts
+init_index_es();
+init_report();
+var LIMIT = 15;
+var publicFetch = createFetch("createRequestTaskSync", "operateRequestTaskSync", {
+  type: "public"
+});
+var activeCount = 0;
+var deferQueue = [];
+var safeCallbackWrapper = He(reportError);
+var remove = (array, predicate) => {
+  const removedElements = array.filter(predicate);
+  const remainingElements = array.filter((item) => !predicate(item));
+  array.length = 0;
+  array.push(...remainingElements);
+  return removedElements;
+};
+var request = (_params) => {
+  const deferred = new L();
+  let teardown = () => {
+  };
+  const _request = createAPI("request", {
+    paramsSchema: t.tuple(
+      t.object({
+        url: t.string(),
+        method: t.string(),
+        header: t.object(),
+        data: t.object().optional(),
+        query: t.object().optional(),
+        dataType: t.string().default("json"),
+        responseType: t.string().default("text"),
+        enableCache: t.boolean().default(false),
+        appendHostCookie: t.boolean().default(true),
+        timeout: t.number().default(3e4),
+        success: t.function(),
+        fail: t.function()
+      })
+    ),
+    implement(params) {
+      const action = async () => {
+        const failCallback = safeCallbackWrapper(params.fail);
+        try {
+          activeCount += 1;
+          if (deferred.state !== "pending") {
+            return;
+          }
+          const { data, dataType, responseType, enableCache, appendHostCookie } = params;
+          const header = normalizeHeader(params.header);
+          const method = normalizeMethod(params.method);
+          const timeout = normalizeTimeout(params.timeout);
+          const url = dirtyURL(params.url, method, data);
+          const successCallback = safeCallbackWrapper(params.success);
+          const _params2 = Object.assign({}, params, {
+            method,
+            header,
+            data: method === "GET" || method === "HEAD" ? void 0 : data,
+            // GET HEAD 请求不需要 data 参数
+            enableCache,
+            query: params.query ?? {},
+            dataType,
+            responseType,
+            appendHostCookie
+          });
+          if (timeout) _params2["timeout"] = timeout;
+          const task = publicFetch(url, _params2);
+          {
+            const { response } = await task;
+            const { code, data: data2, message } = response;
+            deferred.resolve({
+              code: code ?? "SUCCESS",
+              data: data2,
+              message: message ?? "request:ok"
+            });
+            successCallback({
+              code: "SUCCESS",
+              message: "request:ok",
+              data: data2
+            });
+          }
+        } catch (err) {
+          deferred.reject(err);
+          failCallback({
+            code: "FAILURE",
+            message: "httpRequst: failed"
+          });
+        } finally {
+          activeCount -= 1;
+          deferQueue.shift()?.();
+        }
+      };
+      if (activeCount >= LIMIT) {
+        teardown = () => {
+          remove(deferQueue, (i) => i === action);
+        };
+        deferQueue.push(action);
+      } else {
+        void action();
+      }
+      return deferred.promise;
+    }
+  });
+  _request(_params);
+  return {
+    /**
+     *  1. requesting...
+     *  2. not in deferred
+     */
+    abort() {
+      deferred.reject(createAPIError({ code: -1, msg: "request:fail abort" }));
+      teardown();
+    }
+  };
+};
+var commands3 = Vn();
+commands3.registerCommand("HttpSDK.request", request);
+registerCanIUse("request", {
+  version: "1.0.0"
+});
+
+// src/native/api/storage.ts
+init_base();
+init_bridge();
+init_index_es();
+init_network();
+init_context();
+var commands4 = Vn();
+var getStorage2 = createAPI("getLocalStorage", {
+  paramsSchema: t.tuple(t.string()),
+  async implement(key) {
+    const { response } = await innerFetch(`/api/games/user-storage/${context.game_id}`, {
+      method: "GET",
+      responseType: "json",
+      appendHostCookie: true,
+      query: {
+        key
+      }
+    });
+    const {
+      data: { code, message, data: originData }
+    } = await response;
+    if (code === "SUCCESS") {
+      return {
+        code,
+        message,
+        data: originData?.value
+      };
+    }
+    try {
+      const {
+        data: { data, dataType }
+      } = await applyNative("getLocalStorageAsync", { key });
+      const parsedData = parse(data, dataType);
+      return {
+        code,
+        message: `${message}. fallback to native`,
+        data: parsedData
+      };
+    } catch (error) {
+      return {
+        code: "INTERNAL_ERROR",
+        message: "[Jolibox SDK] get local storage failed",
+        data: null
+      };
+    }
+  }
+});
+commands4.registerCommand("StorageSDK.getItem", getStorage2);
+registerCanIUse("storage.getItem", {
+  version: "1.0.0",
+  properties: {
+    key: "1.0.0",
+    value: "1.0.0"
+  }
+});
+var setStorage = createAPI("setStorage", {
+  paramsSchema: t.tuple(t.string(), t.or(t.string(), t.boolean(), t.number())),
+  async implement(key, value) {
+    const gameId = context.game_id;
+    const valueToStore = typeof value == "string" ? value : String(value);
+    const { response } = await innerFetch(`/api/games/user-storage/${gameId}`, {
+      method: "POST",
+      responseType: "json",
+      appendHostCookie: true,
+      data: {
+        key,
+        value: valueToStore
+      }
+    });
+    const {
+      data: { code, message }
+    } = response;
+    const dataType = getType3(value);
+    const data = stringify(value, dataType);
+    await applyNative("setLocalStorageAsync", {
+      key,
+      data,
+      dataType
+    });
+    if (code == "SUCCESS") {
+      return {
+        code,
+        message
+      };
+    } else {
+      return {
+        code,
+        message: `${message}. fallback to native`
+      };
+    }
+  }
+});
+commands4.registerCommand("StorageSDK.setItem", setStorage);
+registerCanIUse("storage.setItem", {
+  version: "1.0.0",
+  properties: {
+    key: "1.0.0",
+    value: "1.0.0"
+  }
+});
+var removeStorage = createAPI("removeStorage", {
+  paramsSchema: t.tuple(t.string()),
+  async implement(key) {
+    const gameId = context.game_id;
+    const { response } = await innerFetch(`/api/games/user-storage/${gameId}/remove`, {
+      method: "POST",
+      responseType: "json",
+      appendHostCookie: true,
+      data: {
+        key
+      }
+    });
+    const {
+      data: { code, message }
+    } = response;
+    await applyNative("removeLocalStorageAsync", { key });
+    if (code === "SUCCESS") {
+      return {
+        code,
+        message
+      };
+    } else {
+      return {
+        code,
+        message: "[Jolibox SDK] remove item succ"
+      };
+    }
+  }
+});
+commands4.registerCommand("StorageSDK.removeItem", removeStorage);
+registerCanIUse("storage.removeItem", {
+  version: "1.0.0",
+  properties: {
+    key: "1.0.0"
+  }
+});
+var clearStorage = createAPI("clearStorage", {
+  async implement() {
+    const gameId = context.game_id;
+    const { response } = await innerFetch(`/api/games/user-storage/${gameId}/clear`, {
+      method: "POST",
+      appendHostCookie: true
+    });
+    applyNative("clearLocalStorageAsync");
+    const {
+      data: { code, message }
+    } = response;
+    if (code === "SUCCESS") {
+      return {
+        code,
+        message
+      };
+    }
+    return {
+      code,
+      message: `${message}.fallback to native`
+    };
+  }
+});
+commands4.registerCommand("StorageSDK.clear", clearStorage);
+registerCanIUse("storage.clear", {
+  version: "1.0.0"
+});
+var getStorageInfo = createAPI("getStorageInfo", {
+  async implement() {
+    const { data } = await applyNative("getStorageInfoAsync");
+    return data;
+  }
+});
+registerCanIUse("getStorageInfo", {
+  version: "1.0.0",
+  success: {
+    keys: "1.0.0",
+    // string[] 本地数据缓存中的所有键名列表，如本地数据则返回空数组
+    currentSize: "1.0.0",
+    // number 当前占用的空间大小，以 KB 为单位
+    limitSize: "1.0.0"
+    // number 存储空间上限，以 KB 为单位，一般来说会返回 10240
+  }
+});
+var getStorageInfoSync = createSyncAPI("getStorageInfoSync", {
+  implement() {
+    return invokeNative("getStorageInfoSync");
+  }
+});
+var DATA_TYPE = [
+  "string",
+  "number",
+  "boolean",
+  "object",
+  ""
+  // 表示不支持的类型
+];
+function getType3(data) {
+  const type = Object.prototype.toString.call(data).split(" ")[1].split("]")[0].toLocaleLowerCase();
+  if (DATA_TYPE.includes(type)) {
+    return type;
+  }
+  return "";
+}
+function parse(str, type) {
+  try {
+    switch (type) {
+      case "string":
+        return str;
+      case "object":
+        return JSON.parse(str);
+      case "number":
+        return parseFloat(str);
+      case "boolean":
+        return str === "true";
+      default:
+        return "";
+    }
+  } catch {
+    return "";
+  }
+}
+function stringify(data, type) {
+  try {
+    switch (type) {
+      case "string":
+      case "number":
+      case "boolean":
+        return `${data}`;
+      case "object":
+        return JSON.stringify(data);
+      default:
+        return "";
+    }
+  } catch {
+    return "";
+  }
+}
+
+// src/native/api/keyboard.ts
+init_index_es();
+init_bridge();
+init_base();
+var showKeyboard = createAPI("showKeyboard", {
+  paramsSchema: t.tuple(
+    t.object({
+      defaultValue: t.string().default(""),
+      multiple: t.boolean().default(false),
+      maxLength: t.unknown().optional().default(1e5)
+    })
+  ),
+  async implement(params) {
+    const maxLength = Math.floor(Number(params.maxLength) ?? 1e5);
+    let { defaultValue } = params;
+    if (defaultValue && maxLength) {
+      defaultValue = defaultValue.slice(0, maxLength);
+    }
+    applyNative("showKeyboardSync", { ...params, defaultValue, maxLength });
+  }
+});
+registerCanIUse("keyboard.showKeyboard", {
+  version: "1.0.0",
+  properties: {
+    params: {
+      defaultValue: "1.0.0",
+      multiple: "1.0.0",
+      confirmHold: "1.0.0",
+      confirmType: "1.0.0",
+      maxLength: "1.0.0"
+    }
+  },
+  success: {
+    errMsg: "1.0.0"
+  }
+});
+var updateKeyboard = createAPI("updateKeyboard", {
+  paramsSchema: t.tuple(
+    t.object({
+      value: t.string()
+    })
+  ),
+  async implement(params) {
+    applyNative("updateKeyboardSync", params);
+  }
+});
+registerCanIUse("keyboard.updateKeyboard", {
+  version: "1.0.0",
+  properties: {
+    params: {
+      value: "1.0.0"
+    }
+  }
+});
+var hideKeyboard = createAPI("hideKeyboard", {
+  async implement() {
+    applyNative("hideKeyboardSync");
+  }
+});
+registerCanIUse("keyboard.hideKeyboard", {
+  version: "1.0.0"
+});
+var commands5 = Vn();
+commands5.registerCommand("KeyboardSDK.showKeyboard", showKeyboard);
+commands5.registerCommand("KeyboardSDK.updateKeyboard", updateKeyboard);
+commands5.registerCommand("KeyboardSDK.hideKeyboard", hideKeyboard);
+
+// src/native/api/task.ts
+init_index_es();
+init_base();
+init_report5();
+var commands6 = Vn();
+var onLevelFinished = createAPI("levelFinished", {
+  paramsSchema: t.tuple(
+    t.string(),
+    t.object({
+      result: t.boolean(),
+      duration: t.number()
+    })
+  ),
+  implement: async (levelId, parmas) => {
+    const { result, duration } = parmas;
+    const tasks = [];
+    tasks.push(
+      taskTracker.reportToNative({
+        event: "LEVEL_FINISHED",
+        params: {
+          levelId,
+          result,
+          duration
+        }
+      })
+    );
+    tasks.push(
+      taskTracker.reporter({
+        event: "COMPLETE_QUEST"
+      })
+    );
+    await Promise.all(tasks);
+  }
+});
+var onTaskFinished = createAPI("taskFinished", {
+  paramsSchema: t.tuple(
+    t.string(),
+    t.object({
+      duration: t.number()
+    })
+  ),
+  implement: async (taskId, params) => {
+    const { duration } = params;
+    return await taskTracker.reportToNative({
+      event: "TASK_FINISHED",
+      params: {
+        duration,
+        taskId
+      }
+    });
+  }
+});
+var onLevelUpgrade = createAPI("levelUpgrade", {
+  paramsSchema: t.tuple(t.string(), t.string()),
+  implement: async (levelId, name) => {
+    const tasks = [];
+    tasks.push(
+      taskTracker.reporter({
+        event: "COMPLETE_QUEST"
+      })
+    );
+    tasks.push(
+      taskTracker.reportToNative({
+        event: "LEVEL_UPGRADE",
+        params: {
+          name,
+          levelId
+        }
+      })
+    );
+    await Promise.all(tasks);
+  }
+});
+var onHistoryUserLevel = createAPI("onHistoryUserLevel", {
+  paramsSchema: t.tuple(t.number()),
+  implement: async (level) => {
+    return await taskTracker.reportToNative({
+      event: "HISTORY_USER_LEVEL",
+      params: {
+        level
+      }
+    });
+  }
+});
+var onHistoryUserScore = createAPI("onHistoryUserScore", {
+  paramsSchema: t.tuple(t.number()),
+  implement: async (score) => {
+    return await taskTracker.reportToNative({
+      event: "HISTORY_USER_SCORE",
+      params: {
+        score
+      }
+    });
+  }
+});
+var onTaskEvent = createAPI("taskEvent", {
+  paramsSchema: t.tuple(
+    t.string(),
+    t.object({
+      tools: t.array(
+        t.object({
+          id: t.string(),
+          name: t.string(),
+          count: t.number(),
+          description: t.string().optional(),
+          price: t.object({
+            amount: t.number(),
+            unit: t.string()
+          }).optional()
+        })
+      ).optional(),
+      awards: t.array(
+        t.object({
+          id: t.string(),
+          name: t.string()
+        })
+      ).optional()
+    })
+  ),
+  implement: async (taskId, params) => {
+    const tasks = [];
+    tasks.push(
+      taskTracker.reportToNative({
+        event: "TASK_EVENT",
+        params: {
+          taskId,
+          ...params
+        }
+      })
+    );
+    if (params.tools?.length ?? 0 > 0) {
+      tasks.push(
+        taskTracker.reporter({
+          event: "USE_GAME_ITEM"
+        })
+      );
+    }
+    await Promise.all(tasks);
+  }
+});
+var onTaskPayment = createAPI("taskPayment", {
+  paramsSchema: t.tuple(
+    t.string(),
+    t.object({
+      id: t.string(),
+      amount: t.number(),
+      unit: t.string()
+    })
+  ),
+  implement: async (taskId, params) => {
+    const tasks = [];
+    tasks.push(
+      taskTracker.reportToNative({
+        event: "TASK_PAYMENT",
+        params: {
+          taskId,
+          params
+        }
+      })
+    );
+    tasks.push(
+      taskTracker.reporter({
+        event: "IN_GAME_PURCHASES"
+      })
+    );
+    await Promise.all(tasks);
+  }
+});
+commands6.registerCommand("TaskTrackerSDK.levelFinished", onLevelFinished);
+commands6.registerCommand("TaskTrackerSDK.taskFinished", onTaskFinished);
+commands6.registerCommand("TaskTrackerSDK.levelUpgrade", onLevelUpgrade);
+commands6.registerCommand("TaskTrackerSDK.historyUserLevel", onHistoryUserLevel);
+commands6.registerCommand("TaskTrackerSDK.historyUserScore", onHistoryUserScore);
+commands6.registerCommand("TaskTrackerSDK.taskEvent", onTaskEvent);
+commands6.registerCommand("TaskTrackerSDK.taskPayment", onTaskPayment);
+registerCanIUse("TaskTrackerSDK.onLevelFinished", {
+  version: "1.0.0",
+  properties: {
+    levelId: "1.0.0",
+    params: {
+      result: "1.0.0",
+      duration: "1.0.0"
+    }
+  }
+});
+registerCanIUse("TaskTrackerSDK.onTaskFinished", {
+  version: "1.0.0",
+  properties: {
+    taskId: "1.0.0",
+    duration: "1.0.0"
+  }
+});
+registerCanIUse("TaskTrackerSDK.onLevelUpgrade", {
+  version: "1.0.0",
+  properties: {
+    levelId: "1.0.0",
+    name: "1.0.0"
+  }
+});
+registerCanIUse("TaskTrackerSDK.onHistoryUserLevel", {
+  version: "1.0.0",
+  properties: {
+    level: "1.0.0"
+  }
+});
+registerCanIUse("TaskTrackerSDK.onHistoryUserScore", {
+  version: "1.0.0",
+  properties: {
+    score: "1.0.0"
+  }
+});
+registerCanIUse("TaskTrackerSDK.onTaskEvent", {
+  version: "1.0.0",
+  properties: {
+    taskId: "1.0.0",
+    params: {
+      tools: {
+        id: "1.0.0",
+        name: "1.0.0",
+        count: "1.0.0",
+        description: "1.0.0",
+        price: {
+          amount: "1.0.0",
+          unit: "1.0.0"
+        }
+      },
+      awards: {
+        id: "1.0.0",
+        name: "1.0.0"
+      }
+    }
+  }
+});
+registerCanIUse("TaskTrackerSDK.onTaskPayment", {
+  version: "1.0.0",
+  properties: {
+    taskId: "1.0.0",
+    params: {
+      amount: "1.0.0",
+      unit: "1.0.0"
+    }
+  }
+});
+
+// src/native/api/login.ts
+init_context();
+init_bridge();
+init_base();
+init_index_es();
+init_errors();
+registerCanIUse("login", {
+  version: "1.0.0",
+  properties: {
+    force: "1.0.0"
+  },
+  success: {
+    errMsg: "1.0.0",
+    code: "1.0.0",
+    token: "1.0.0",
+    isLogin: "1.0.0"
+  }
+});
+registerCanIUse("checkSession", {
+  version: "1.0.0",
+  success: {
+    errMsg: "1.0.0"
+  }
+});
+var login = createAPI("login", {
+  async implement() {
+    const isLogin = await applyNative("checkLoginAsync");
+    if (isLogin) {
+      return { isLogin: true, token: context.hostUserInfo?.token };
+    }
+    onNative("onLoginStateChange", ({ isLogin: isLogin2, token, uuid }) => {
+      if (uuid == loginUUID) {
+        resolve({ isLogin: isLogin2, token });
+      }
+    });
+    const res = invokeNative("loginSync");
+    const {
+      data: { uuid: loginUUID }
+    } = res;
+    if (!loginUUID) {
+      throw createAPIError({
+        code: -1,
+        msg: "login failed"
+      });
+    }
+    const { promise, resolve } = new L();
+    const loginRes = await promise;
+    context.onEnvConfigChanged({ hostUserInfo: loginRes });
+    En.emit("onLoginComplete", loginRes);
+    return loginRes;
+  }
+});
+var checkSession = createAPI("checkSession", {
+  async implement() {
+    const {
+      data: { isLogin }
+    } = await applyNative("checkLoginAsync");
+    return {
+      isLogin
+    };
+  }
+});
+var commands7 = Vn();
+commands7.registerCommand("API.login", login);
+commands7.registerCommand("API.checkSession", checkSession);
+
+// src/index.native.ts
+init_report5();
+config();