@fgz/wxmini-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1813 @@
+'use strict';
+
+require('reflect-metadata');
+var classTransformer = require('class-transformer');
+var uuid = require('uuid');
+var pako = require('pako');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pako__default = /*#__PURE__*/_interopDefault(pako);
+
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+var Utils = class {
+  static allocUuid() {
+    const uuid$1 = uuid.v4();
+    return "" + uuid$1;
+  }
+  static now() {
+    return (/* @__PURE__ */ new Date()).getTime();
+  }
+  /* 浅拷贝, 克隆第一层引用 */
+  static cloneWithRef(obj) {
+    if (obj == null) return null;
+    return Object.assign(Object.create(Object.getPrototypeOf(obj)), obj);
+  }
+  static createNew(obj) {
+    if (obj == null) return null;
+    return Object.create(Object.getPrototypeOf(obj));
+  }
+  static isStringNotEmpty(str) {
+    return !this.isStringEmpty(str);
+  }
+  static isStringEmpty(str) {
+    return str == null || str === "";
+  }
+  static string2Utf8(str) {
+    if (str == null) return null;
+    return new TextEncoder().encode(str);
+  }
+  static utf8ToString(bytes) {
+    if (bytes == null) return null;
+    return new TextDecoder().decode(bytes);
+  }
+  static concatUint8Arrays(arrays) {
+    let totalLength = 0;
+    for (const array of arrays) {
+      totalLength += array.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const array of arrays) {
+      result.set(array, offset);
+      offset += array.length;
+    }
+    return result;
+  }
+  static async sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  static async pollAsync(fn, timeout = 2e3, interval = 10) {
+    const endTime = Number(/* @__PURE__ */ new Date()) + timeout;
+    return new Promise((resolve, reject) => {
+      const checkCondition = () => {
+        if (fn()) {
+          resolve();
+        } else if (Number(/* @__PURE__ */ new Date()) < endTime) {
+          setTimeout(checkCondition, interval);
+        } else {
+          reject(new Error("Timed out to wait for : " + fn.toString()));
+        }
+      };
+      checkCondition();
+    });
+  }
+  static isNumber(value) {
+    return typeof value === "number" && !isNaN(value);
+  }
+  static isInteger(value) {
+    return Number.isInteger(value);
+  }
+  static isFloat(value) {
+    return this.isNumber(value) && !this.isInteger(value);
+  }
+  static async pollBlock(fn, timeout, interval, msg) {
+    const endTime = Number(/* @__PURE__ */ new Date()) + timeout;
+    while (Number(/* @__PURE__ */ new Date()) < endTime) {
+      const result = fn();
+      if (result) {
+        return Promise.resolve();
+      }
+      await this.sleep(interval);
+    }
+    if (msg == null) msg = "Timed out to wait for : " + fn.toString();
+    return Promise.reject(new Error(msg));
+  }
+  static error(message, ...optionalParams) {
+    console.error(message, optionalParams);
+  }
+  static log(message, ...optionalParams) {
+    console.log(message, optionalParams);
+  }
+  static debug(message, ...optionalParams) {
+    if (this._debug) console.debug(message, optionalParams);
+  }
+  static isInstance(obj, constructor) {
+    return obj instanceof constructor || constructor.name === "Boolean" && typeof obj === "boolean";
+  }
+  static assertNotNull(obj, msg) {
+    if (obj == null) throw new Error(msg ?? "Null value");
+    return obj;
+  }
+  static assertTrue(value, msg) {
+    if (!value) throw new Error(msg ?? "Not true");
+  }
+};
+Utils._debug = true;
+var _Bytes = class _Bytes {
+  /**
+   * Flutter的setInt32，以及Netty等默认都是大端序存储int：[00,00,00,03]
+   */
+  static readInt32(bytes, offset) {
+    if (offset < 0 || offset + 4 > bytes.length) {
+      throw new RangeError("Offset is out of bounds.");
+    }
+    const subArray = Array.from(bytes.slice(offset, offset + 4));
+    return new DataView(new Uint8Array(subArray).buffer).getInt32(0, _Bytes.LittleEndian);
+  }
+  static setInt32Bytes(bytes, offset, num) {
+    const dataView = new DataView(bytes.buffer);
+    dataView.setInt32(offset, num, _Bytes.LittleEndian);
+  }
+  static int32ToBytes(v) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setInt32(0, v);
+    return b;
+  }
+  static stringToBytes(s) {
+    const encoder = new TextEncoder();
+    return encoder.encode(s);
+  }
+};
+// JAVA端解析是大端序(低位靠前,高位靠后) : 0x00, 0x00, 0x01, 0x44 = 300
+_Bytes.LittleEndian = false;
+var Bytes = _Bytes;
+
+// src/cson-core.ts
+var CsonBean = class {
+  constructor() {
+    // 每个子类都会通过构造默认初始化此值（由自动代码生成器负责初始化）
+    this._OBJECT_TYPE_ = "";
+    this.setObjectType(this.getJavaType());
+  }
+  // 所有类都会重载此方法, 以获取子类真正对应的java类
+  getJavaType() {
+    return this._OBJECT_TYPE_;
+  }
+  getSimpleTypeName(removeDtoSuffix) {
+    const type = this.getJavaType();
+    const list = type.split(".");
+    if (list.length > 1) {
+      let last = list[list.length - 1];
+      if (last.endsWith("Dto") && removeDtoSuffix) {
+        return last.substring(0, last.length - 3);
+      }
+      return last;
+    }
+    return type;
+  }
+  getObjectType() {
+    return this._OBJECT_TYPE_;
+  }
+  setObjectType(type) {
+    this._OBJECT_TYPE_ = type;
+    return this;
+  }
+  getExtJsonMap() {
+    return this._extJsonMap;
+  }
+  setExtJsonMap(extMap) {
+    this._extJsonMap = extMap;
+  }
+};
+CsonBean.OBJECT_TYPE_FIELD_NAME = "_OBJECT_TYPE_";
+var CsonPojo = class extends CsonBean {
+};
+var _FeException = class _FeException extends CsonPojo {
+  getJavaType() {
+    return _FeException.JAVA_TYPE;
+  }
+  constructor(err, detail) {
+    super();
+    this.err = err;
+    this.detail = detail;
+  }
+  toString() {
+    let s = this.err;
+    if (Utils.isStringNotEmpty(this.detail)) s += "\n" + this.detail;
+    return `${this.getSimpleTypeName()}:  ${s ?? ""}`;
+  }
+};
+_FeException.JAVA_TYPE = "flutter.rpc.FeException";
+var FeException = _FeException;
+var _FeJavaException = class _FeJavaException extends FeException {
+  getJavaType() {
+    return _FeJavaException.JAVA_TYPE;
+  }
+  constructor(err, detail) {
+    super();
+    this.err = err;
+    this.detail = detail;
+  }
+};
+_FeJavaException.JAVA_TYPE = "flutter.rpc.FeJavaException";
+var FeJavaException = _FeJavaException;
+var _CRpcFeCmd = class _CRpcFeCmd extends CsonPojo {
+  getJavaType() {
+    return _CRpcFeCmd.JAVA_TYPE;
+  }
+};
+_CRpcFeCmd.JAVA_TYPE = "cson.rpc.CRpcFeCmd";
+var CRpcFeCmd = _CRpcFeCmd;
+var _CRpcFeRsp = class _CRpcFeRsp extends CsonPojo {
+  getJavaType() {
+    return _CRpcFeRsp.JAVA_TYPE;
+  }
+};
+_CRpcFeRsp.JAVA_TYPE = "cson.rpc.CRpcFeRsp";
+var CRpcFeRsp = _CRpcFeRsp;
+var _SystemCallback = class _SystemCallback extends CsonPojo {
+  getJavaType() {
+    return _SystemCallback.JAVA_TYPE;
+  }
+};
+_SystemCallback.JAVA_TYPE = "fe.cmn.sys.SystemCallback";
+_SystemCallback.FIELD_timeout = "timeout";
+_SystemCallback.debugChannel = false;
+_SystemCallback.DECLARED_FIELDS = [_SystemCallback.FIELD_timeout];
+var SystemCallback = _SystemCallback;
+var _FePojo = class _FePojo extends CsonPojo {
+  getJavaType() {
+    return _FePojo.JAVA_TYPE;
+  }
+};
+_FePojo.JAVA_TYPE = "fe.cmn.data.FePojo";
+_FePojo.FIELD_userObject = "userObject";
+_FePojo.FIELD_userPojo = "userPojo";
+_FePojo.FIELD_binaryData = "binaryData";
+_FePojo.DECLARED_FIELDS = [_FePojo.FIELD_userObject, _FePojo.FIELD_userPojo, _FePojo.FIELD_binaryData];
+__decorateClass([
+  classTransformer.Transform(FUNC_decodeObject, { toClassOnly: true })
+], _FePojo.prototype, "userPojo");
+__decorateClass([
+  classTransformer.Transform(FUNC_encodeJsonUint8Array, { toPlainOnly: true }),
+  classTransformer.Transform(FUNC_decodeJsonUint8Array, { toClassOnly: true })
+], _FePojo.prototype, "binaryData");
+var FePojo = _FePojo;
+var _NullPojo = class _NullPojo extends FePojo {
+  getJavaType() {
+    return _NullPojo.JAVA_TYPE;
+  }
+};
+_NullPojo.JAVA_TYPE = "fe.cmn.data.NullPojo";
+_NullPojo.DECLARED_FIELDS = [];
+var NullPojo = _NullPojo;
+var _ValuePojo = class _ValuePojo extends FePojo {
+  getJavaType() {
+    return _ValuePojo.JAVA_TYPE;
+  }
+};
+_ValuePojo.JAVA_TYPE = "fe.cmn.data.ValuePojo";
+_ValuePojo.FIELD_value = "value";
+_ValuePojo.DECLARED_FIELDS = [_ValuePojo.FIELD_value];
+var ValuePojo = _ValuePojo;
+var _BinBlock = class _BinBlock extends CsonPojo {
+  getJavaType() {
+    return _BinBlock.JAVA_TYPE;
+  }
+};
+_BinBlock.JAVA_TYPE = "cson.core.BinBlock";
+_BinBlock.FIELD_id = "id";
+_BinBlock.FIELD_start = "start";
+_BinBlock.FIELD_end = "end";
+_BinBlock.FIELD_extByteArray = "extByteArray";
+_BinBlock.DECLARED_FIELDS = [_BinBlock.FIELD_id, _BinBlock.FIELD_start, _BinBlock.FIELD_end, _BinBlock.FIELD_extByteArray];
+__decorateClass([
+  classTransformer.Transform(FUNC_encodeJsonUint8Array, { toPlainOnly: true }),
+  classTransformer.Transform(FUNC_decodeJsonUint8Array, { toClassOnly: true })
+], _BinBlock.prototype, "extByteArray");
+var BinBlock = _BinBlock;
+var _PartitionTable = class _PartitionTable extends CsonPojo {
+  getJavaType() {
+    return _PartitionTable.JAVA_TYPE;
+  }
+};
+_PartitionTable.JAVA_TYPE = "cson.core.PartitionTable";
+_PartitionTable.FIELD_callbackBridgeChannel = "callbackBridgeChannel";
+_PartitionTable.FIELD_bodyLength = "bodyLength";
+_PartitionTable.FIELD_lstBin = "lstBin";
+_PartitionTable.DECLARED_FIELDS = [_PartitionTable.FIELD_callbackBridgeChannel, _PartitionTable.FIELD_bodyLength, _PartitionTable.FIELD_lstBin];
+__decorateClass([
+  classTransformer.Transform(FUNC_decodeListJson, { toClassOnly: true })
+], _PartitionTable.prototype, "lstBin");
+var PartitionTable = _PartitionTable;
+var _FeAbilityExecuteException = class _FeAbilityExecuteException extends FeException {
+  getJavaType() {
+    return _FeAbilityExecuteException.JAVA_TYPE;
+  }
+};
+_FeAbilityExecuteException.JAVA_TYPE = "fe.cmn.exception.FeAbilityExecuteException";
+_FeAbilityExecuteException.FIELD_ability = "ability";
+_FeAbilityExecuteException.DECLARED_FIELDS = [_FeAbilityExecuteException.FIELD_ability];
+__decorateClass([
+  classTransformer.Transform(FUNC_decodeObject, { toClassOnly: true })
+], _FeAbilityExecuteException.prototype, "ability");
+var FeAbilityExecuteException = _FeAbilityExecuteException;
+var _FeWxMiniCmdException = class _FeWxMiniCmdException extends FeAbilityExecuteException {
+  getJavaType() {
+    return _FeWxMiniCmdException.JAVA_TYPE;
+  }
+};
+_FeWxMiniCmdException.JAVA_TYPE = "fe.cmn.exception.FeWxMiniCmdException";
+_FeWxMiniCmdException.FIELD_wxMiniServerUrl = "wxMiniServerUrl";
+_FeWxMiniCmdException.FIELD_wxMiniAppUuid = "wxMiniAppUuid";
+_FeWxMiniCmdException.DECLARED_FIELDS = [_FeWxMiniCmdException.FIELD_wxMiniServerUrl, _FeWxMiniCmdException.FIELD_wxMiniAppUuid];
+var FeWxMiniCmdException = _FeWxMiniCmdException;
+var _WxMiniBridgeCommand = class _WxMiniBridgeCommand extends CsonPojo {
+  getJavaType() {
+    return _WxMiniBridgeCommand.JAVA_TYPE;
+  }
+};
+_WxMiniBridgeCommand.JAVA_TYPE = "wx.mini.server.WxMiniBridgeCommand";
+_WxMiniBridgeCommand.FIELD_debugAppUuid = "debugAppUuid";
+_WxMiniBridgeCommand.FIELD_appId = "appId";
+_WxMiniBridgeCommand.FIELD_cmd = "cmd";
+_WxMiniBridgeCommand.FIELD_params = "params";
+_WxMiniBridgeCommand.FIELD_extHeaders = "extHeaders";
+_WxMiniBridgeCommand.FIELD_waitOnlineTimeoutS = "waitOnlineTimeoutS";
+_WxMiniBridgeCommand.FIELD_timeoutS = "timeoutS";
+_WxMiniBridgeCommand.DECLARED_FIELDS = [_WxMiniBridgeCommand.FIELD_debugAppUuid, _WxMiniBridgeCommand.FIELD_appId, _WxMiniBridgeCommand.FIELD_cmd, _WxMiniBridgeCommand.FIELD_params, _WxMiniBridgeCommand.FIELD_extHeaders, _WxMiniBridgeCommand.FIELD_waitOnlineTimeoutS, _WxMiniBridgeCommand.FIELD_timeoutS];
+__decorateClass([
+  classTransformer.Transform(FUNC_decodeMapJson, { toClassOnly: true })
+], _WxMiniBridgeCommand.prototype, "params");
+__decorateClass([
+  classTransformer.Transform(FUNC_decodeMapJson, { toClassOnly: true })
+], _WxMiniBridgeCommand.prototype, "extHeaders");
+var WxMiniBridgeCommand = _WxMiniBridgeCommand;
+var _WxMiniCommand = class _WxMiniCommand extends SystemCallback {
+  getJavaType() {
+    return _WxMiniCommand.JAVA_TYPE;
+  }
+};
+_WxMiniCommand.JAVA_TYPE = "fe.cmn.weixin.ability.WxMiniCommand";
+_WxMiniCommand.FIELD_debugHttpUrl = "debugHttpUrl";
+_WxMiniCommand.FIELD_debugAppUuid = "debugAppUuid";
+_WxMiniCommand.FIELD_cmd = "cmd";
+_WxMiniCommand.FIELD_params = "params";
+_WxMiniCommand.FIELD_extHeaders = "extHeaders";
+_WxMiniCommand.FIELD_waitOnlineTimeoutS = "waitOnlineTimeoutS";
+_WxMiniCommand.PARAM_URL = "url";
+_WxMiniCommand.PARAM_TITLE = "title";
+_WxMiniCommand.PARAM_ICON_TYPE = "iconType";
+_WxMiniCommand.PARAM_MESSAGE = "message";
+_WxMiniCommand.PARAM_BUTTON = "button";
+_WxMiniCommand.PARAM_REJECT_BUTTON = "rejectButton";
+_WxMiniCommand.PARAM_FILE_PATH = "filePath";
+_WxMiniCommand.DATA_FIELD_IN_MAP = "data";
+_WxMiniCommand.getUserProfile_TITLE = "title";
+_WxMiniCommand.getUserProfile_ICON_TYPE = "iconType";
+_WxMiniCommand.getUserProfile_MESSAGE = "message";
+_WxMiniCommand.getUserProfile_BUTTON = "button";
+_WxMiniCommand.getUserProfile_QUERY_TYPE = "queryType";
+_WxMiniCommand.getUserProfile_ORG_AVATAR_URL64 = "avatarUrl64";
+_WxMiniCommand.getUserProfile_ORG_NICK = "nickName";
+_WxMiniCommand.getPhoneNum_TITLE = "title";
+_WxMiniCommand.getPhoneNum_ICON_TYPE = "iconType";
+_WxMiniCommand.getPhoneNum_MESSAGE = "message";
+_WxMiniCommand.getPhoneNum_BUTTON = "button";
+_WxMiniCommand.getPhoneNum_REJECT_BUTTON = "rejectButton";
+_WxMiniCommand.makePhoneCall_phoneNum = "phoneNum";
+_WxMiniCommand.PARAM_count = "count";
+_WxMiniCommand.PARAM_mediaType = "mediaType";
+_WxMiniCommand.PARAM_sourceType = "sourceType";
+_WxMiniCommand.PARAM_maxDuration = "maxDuration";
+_WxMiniCommand.PARAM_sizeType = "sizeType";
+_WxMiniCommand.PARAM_camera = "camera";
+_WxMiniCommand.MEDIATYPE_image = "image";
+_WxMiniCommand.MEDIATYPE_video = "video";
+_WxMiniCommand.MEDIATYPE_mix = "mix";
+_WxMiniCommand.SOURCETYPE_album = "album";
+_WxMiniCommand.SOURCETYPE_camera = "camera";
+_WxMiniCommand.SIZETYPE_original = "original";
+_WxMiniCommand.SIZETYPE_compressed = "compressed";
+_WxMiniCommand.CAMERA_back = "back";
+_WxMiniCommand.CAMERA_front = "front";
+_WxMiniCommand.PARAM_delta = "delta";
+_WxMiniCommand.PARAM_UPLOAD_FILE_NAME = "fileName";
+_WxMiniCommand.PARAM_UPLOAD_FORM_DATA = "formData";
+_WxMiniCommand.PARAM_SHARE_FILE_NAME = "fileName";
+_WxMiniCommand.PARAM_MAP_JSON = "mapJson";
+_WxMiniCommand.PARAM_APPEND = "append";
+_WxMiniCommand.PARAM_OPENIT = "openIt";
+_WxMiniCommand.PARAM_LOCATION = "location";
+_WxMiniCommand.PARAM_COUNT = "count";
+_WxMiniCommand.PARAM_TYPE = "type";
+_WxMiniCommand.PARAM_EXTENSION = "extension";
+_WxMiniCommand.PARAM_sharePage = "sharePage";
+_WxMiniCommand.PARAM_path = "path";
+_WxMiniCommand.PARAM_style = "style";
+_WxMiniCommand.PARAM_needShowEntrance = "needShowEntrance";
+_WxMiniCommand.PARAM_entrancePath = "entrancePath";
+_WxMiniCommand.CLIP_BOARD_DATA = "data";
+_WxMiniCommand.DECLARED_FIELDS = [_WxMiniCommand.FIELD_debugHttpUrl, _WxMiniCommand.FIELD_debugAppUuid, _WxMiniCommand.FIELD_cmd, _WxMiniCommand.FIELD_params, _WxMiniCommand.FIELD_extHeaders, _WxMiniCommand.FIELD_waitOnlineTimeoutS];
+__decorateClass([
+  classTransformer.Transform(FUNC_decodeMapJson, { toClassOnly: true })
+], _WxMiniCommand.prototype, "params");
+__decorateClass([
+  classTransformer.Transform(FUNC_decodeMapJson, { toClassOnly: true })
+], _WxMiniCommand.prototype, "extHeaders");
+var WxMiniCommand = _WxMiniCommand;
+var _WxMiniConfigDto = class _WxMiniConfigDto extends CsonPojo {
+  getJavaType() {
+    return _WxMiniConfigDto.JAVA_TYPE;
+  }
+};
+_WxMiniConfigDto.JAVA_TYPE = "fe.cmn.weixin.WxMiniConfigDto";
+_WxMiniConfigDto.FIELD_wxMiniServerUrl = "wxMiniServerUrl";
+_WxMiniConfigDto.FIELD_wxMiniAppUuid = "wxMiniAppUuid";
+_WxMiniConfigDto.FIELD_sceneFromWxMiniParams = "sceneFromWxMiniParams";
+_WxMiniConfigDto.FIELD_initalQueryParameters = "initalQueryParameters";
+_WxMiniConfigDto.DECLARED_FIELDS = [_WxMiniConfigDto.FIELD_wxMiniServerUrl, _WxMiniConfigDto.FIELD_wxMiniAppUuid, _WxMiniConfigDto.FIELD_sceneFromWxMiniParams, _WxMiniConfigDto.FIELD_initalQueryParameters];
+__decorateClass([
+  classTransformer.Transform(FUNC_decodeMapJson, { toClassOnly: true })
+], _WxMiniConfigDto.prototype, "initalQueryParameters");
+var WxMiniConfigDto = _WxMiniConfigDto;
+var _QueryWxMiniParam = class _QueryWxMiniParam extends SystemCallback {
+  getJavaType() {
+    return _QueryWxMiniParam.JAVA_TYPE;
+  }
+};
+_QueryWxMiniParam.JAVA_TYPE = "fe.cmn.weixin.ability.QueryWxMiniParam";
+_QueryWxMiniParam.DECLARED_FIELDS = [];
+var QueryWxMiniParam = _QueryWxMiniParam;
+var _QuerySceneFromWxMiniParams = class _QuerySceneFromWxMiniParams extends SystemCallback {
+  getJavaType() {
+    return _QuerySceneFromWxMiniParams.JAVA_TYPE;
+  }
+};
+_QuerySceneFromWxMiniParams.JAVA_TYPE = "fe.cmn.weixin.ability.QuerySceneFromWxMiniParams";
+_QuerySceneFromWxMiniParams.DECLARED_FIELDS = [];
+var QuerySceneFromWxMiniParams = _QuerySceneFromWxMiniParams;
+var _CRpcCallbackCmd = class _CRpcCallbackCmd extends CsonPojo {
+  getJavaType() {
+    return _CRpcCallbackCmd.JAVA_TYPE;
+  }
+};
+_CRpcCallbackCmd.JAVA_TYPE = "flutter.rpc.CRpcCallbackCmd";
+_CRpcCallbackCmd.FIELD_reqId = "reqId";
+_CRpcCallbackCmd.FIELD_data = "data";
+_CRpcCallbackCmd.DECLARED_FIELDS = [_CRpcCallbackCmd.FIELD_reqId, _CRpcCallbackCmd.FIELD_data];
+__decorateClass([
+  classTransformer.Transform(FUNC_decodeObject, { toClassOnly: true })
+], _CRpcCallbackCmd.prototype, "data");
+var CRpcCallbackCmd = _CRpcCallbackCmd;
+var _CRpcCallbackRsp = class _CRpcCallbackRsp extends CsonPojo {
+  getJavaType() {
+    return _CRpcCallbackRsp.JAVA_TYPE;
+  }
+};
+_CRpcCallbackRsp.JAVA_TYPE = "flutter.rpc.CRpcCallbackRsp";
+_CRpcCallbackRsp.FIELD_reqId = "reqId";
+_CRpcCallbackRsp.FIELD_result = "result";
+_CRpcCallbackRsp.DECLARED_FIELDS = [_CRpcCallbackRsp.FIELD_reqId, _CRpcCallbackRsp.FIELD_result];
+__decorateClass([
+  classTransformer.Transform(FUNC_decodeObject, { toClassOnly: true })
+], _CRpcCallbackRsp.prototype, "result");
+var CRpcCallbackRsp = _CRpcCallbackRsp;
+
+// src/cson.ts
+function FUNC_encodeJsonUint8Array({ value }) {
+  if (value instanceof Uint8Array) {
+    const u8 = Cson.putBytes(value);
+    if (u8 == null) return null;
+    return Array.from(u8);
+  }
+  return value;
+}
+function FUNC_decodeJsonUint8Array({ value }) {
+  if (value instanceof Uint8Array) {
+    return Cson.getBytes(value);
+  } else if (value instanceof Object) {
+    Object.values(value);
+    return Cson.getBytes(new Uint8Array(Object.values(value)));
+  }
+  return value;
+}
+function FUNC_decodeMapJson({ value }) {
+  if (value != null) {
+    if (value instanceof Map) {
+      const map = /* @__PURE__ */ new Map();
+      for (const [key, val] of value.entries()) {
+        const obj = Cson.decodeObject(val);
+        map.set(key, obj);
+      }
+      return map;
+    } else if (value instanceof Object) {
+      const map = /* @__PURE__ */ new Map();
+      for (const [key, val] of Object.entries(value)) {
+        const obj = Cson.decodeObject(val);
+        map.set(key, obj);
+      }
+      return map;
+    }
+  }
+  return void 0;
+}
+function FUNC_decodeListJson({ value }) {
+  if (value != null) {
+    if (value instanceof Array) {
+      const lst = new Array();
+      for (const v of value) {
+        const obj = Cson.decodeObject(v);
+        lst.push(obj);
+      }
+      return lst;
+    }
+  }
+  return void 0;
+}
+function FUNC_decodeObject({ value }) {
+  return Cson.decodeObject(value);
+}
+function int32ToBytes(value) {
+  const result = new Uint8Array(4);
+  for (let i = 0; i < 4; i++) {
+    result[i] = value >> 8 * (3 - i) & 255;
+  }
+  return result;
+}
+function bytesToInt32(bytes) {
+  if (bytes.length !== 4) {
+    throw new Error("Input must be a Uint8Array of length 4");
+  }
+  let value = 0;
+  for (let i = 0; i < 4; i++) {
+    value |= bytes[i] << 8 * (3 - i);
+  }
+  return value;
+}
+var _Cson = class _Cson {
+  static _setCache(mapBytes) {
+    this._serialNo = 0;
+    this._mapBytes = mapBytes == null ? /* @__PURE__ */ new Map() : mapBytes;
+  }
+  static putBytes(data) {
+    if (data === null || data.length === 0) return null;
+    const id = ++this._serialNo;
+    this._mapBytes.set(id, data);
+    return int32ToBytes(id);
+  }
+  static getBytes(o) {
+    if (o != null && o.length === 4) {
+      return this._mapBytes.get(bytesToInt32(o)) || null;
+    }
+    return null;
+  }
+  static _clearCache() {
+    this._setCache(null);
+  }
+  static encode(data, outputBytes) {
+    this._clearCache();
+    try {
+      const res = classTransformer.instanceToPlain(data);
+      if (outputBytes && this._mapBytes.size > 0) {
+        this._mapBytes.forEach((value, key) => {
+          outputBytes.set(key, value);
+        });
+      }
+      return JSON.stringify(res);
+    } finally {
+      this._clearCache();
+    }
+  }
+  static decode(targetClass, json, mapBytes) {
+    const normalJsonObj = JSON.parse(json);
+    this._setCache(mapBytes);
+    try {
+      const jO = classTransformer.plainToInstance(targetClass, normalJsonObj);
+      if (Array.isArray(jO)) {
+        throw new Error("Do not support JSON List");
+      }
+      return jO;
+    } finally {
+      this._clearCache();
+    }
+  }
+  static decodeReturn(data, zip) {
+    const mapAttach = /* @__PURE__ */ new Map();
+    const rspJson = _Cson.decodeReturnPayload(data, zip, mapAttach);
+    if (Utils.isStringEmpty(rspJson)) return null;
+    const rspObj = _Cson.decodeJson(rspJson, mapAttach);
+    return rspObj;
+  }
+  static decodeJson(json, mapBytes) {
+    _Cson._setCache(mapBytes);
+    try {
+      let jO;
+      try {
+        jO = JSON.parse(json);
+      } catch (error) {
+        throw new Error("Invalid JSON");
+      }
+      return _Cson.decodeObject(jO);
+    } finally {
+      _Cson._clearCache();
+    }
+  }
+  static decodeObject(org) {
+    try {
+      if (org == null) {
+        return null;
+      } else if (Array.isArray(org)) {
+        const lstRet = [];
+        for (const o of org) {
+          lstRet.push(_Cson.decodeObject(o));
+        }
+        return lstRet;
+      } else if (!(org instanceof Object)) {
+        return org;
+      } else if (typeof org === "object" && org !== null) {
+        if (Utils.isStringNotEmpty(org[CsonBean.OBJECT_TYPE_FIELD_NAME])) {
+          const bean = JavaFactory.newBean(org[CsonBean.OBJECT_TYPE_FIELD_NAME], org);
+          return bean;
+        } else {
+          const type = org[CsonBean.OBJECT_TYPE_FIELD_NAME];
+          return JavaFactory.newBean(type, org);
+        }
+      }
+      return org;
+    } catch (error) {
+      throw new Error("Failed to decode : " + org.toString() + ", Cause:" + error);
+    }
+  }
+  static decodeDynamicList(org) {
+    try {
+      if (org !== null && org.length > 0) {
+        const lstRet = [];
+        for (const o of org) {
+          lstRet.push(_Cson.decodeObject(o));
+        }
+        return lstRet;
+      }
+      return null;
+    } catch (error) {
+      throw new Error(`Failed to decode: ${JSON.stringify(org)}, Cause: ${error}`);
+    }
+  }
+  /**
+   * 返回的是成功结果里的 result json
+   * 同时，参数 mapAttach 是附件二进制包（输出）
+   * 如果返回是异常对象, 则会抛出FeJavaException
+   */
+  static decodeReturnPayload(data, zip, mapAttach) {
+    const sCmd = _Cson.decodeServerPackage(data, zip, mapAttach);
+    if (sCmd === null) return null;
+    const rsp = _Cson.decode(CRpcFeRsp, sCmd, mapAttach);
+    if (Utils.isStringNotEmpty(rsp.error)) {
+      const error = new FeJavaException();
+      error.err = rsp.error.error;
+      error.detail = rsp.error.errorStack;
+      throw error;
+    }
+    return rsp.resultJson;
+  }
+  static decodeServerPackage(data, zip, mapAttach) {
+    if (data === null || data.length === 0) return null;
+    const parLength = Bytes.readInt32(data, 0);
+    const btParTable = data.slice(4, 4 + parLength);
+    const parTable = _Cson.decode(
+      PartitionTable,
+      new TextDecoder().decode(btParTable),
+      null
+    );
+    const bodyStart = 4 + parLength;
+    const btBody = data.slice(bodyStart, bodyStart + (parTable.bodyLength || 0));
+    const attStart = bodyStart + (parTable.bodyLength || 0);
+    parTable.lstBin?.forEach((bk) => {
+      if (bk) {
+        const attBin = data.slice(
+          attStart + (bk.start || 0),
+          attStart + (bk.end !== void 0 ? bk.end + 1 : 0)
+        );
+        if (bk.id !== void 0) {
+          mapAttach.set(bk.id, attBin);
+        }
+      }
+    });
+    let sCmd;
+    if (zip) {
+      const unzipBtBody = pako__default.default.ungzip(btBody);
+      sCmd = new TextDecoder().decode(unzipBtBody);
+    } else {
+      sCmd = new TextDecoder().decode(btBody);
+    }
+    return sCmd;
+  }
+  static getPojoValue(pojo) {
+    if (pojo == null) return null;
+    if (pojo instanceof ValuePojo) return pojo.value;
+    if (pojo instanceof NullPojo) return null;
+    return pojo;
+  }
+};
+_Cson._serialNo = 0;
+_Cson._mapBytes = /* @__PURE__ */ new Map();
+var Cson = _Cson;
+var _JavaFactory = class _JavaFactory {
+  static registPojos(beans) {
+    beans.forEach((v, k) => {
+      _JavaFactory.registPojo(k, v);
+    });
+  }
+  static registPojo(javaType, pojo) {
+    _JavaFactory.CSON_BEANS.set(javaType, pojo);
+  }
+  static getPojoByName(javaType, create = true) {
+    if (javaType === null) return null;
+    const org = _JavaFactory.CSON_BEANS.get(javaType);
+    if (create ?? true) return Utils.cloneWithRef(org);
+    else return org;
+  }
+  static newBean(javaType, json) {
+    let bean = _JavaFactory.getPojoByName(javaType);
+    if (bean == null) {
+      bean = new CsonPojo().setObjectType(javaType);
+      if (json !== null) {
+        bean.setExtJsonMap(json);
+      }
+      return bean;
+    }
+    return classTransformer.plainToClassFromExist(bean, json);
+  }
+};
+_JavaFactory.CSON_BEANS = /* @__PURE__ */ new Map();
+var JavaFactory = _JavaFactory;
+
+// src/pojo-registry.ts
+function registerAllPojos() {
+  const beans = /* @__PURE__ */ new Map([
+    // 基础 RPC 类型
+    [CRpcFeRsp.JAVA_TYPE, new CRpcFeRsp()],
+    [CRpcFeCmd.JAVA_TYPE, new CRpcFeCmd()],
+    [FeException.JAVA_TYPE, new FeException()],
+    [FeJavaException.JAVA_TYPE, new FeJavaException()],
+    // 基础 POJO
+    [SystemCallback.JAVA_TYPE, new SystemCallback()],
+    [FePojo.JAVA_TYPE, new FePojo()],
+    [NullPojo.JAVA_TYPE, new NullPojo()],
+    [ValuePojo.JAVA_TYPE, new ValuePojo()],
+    // 协议相关
+    [BinBlock.JAVA_TYPE, new BinBlock()],
+    [PartitionTable.JAVA_TYPE, new PartitionTable()],
+    [CRpcCallbackCmd.JAVA_TYPE, new CRpcCallbackCmd()],
+    [CRpcCallbackRsp.JAVA_TYPE, new CRpcCallbackRsp()],
+    // 异常类型
+    [FeAbilityExecuteException.JAVA_TYPE, new FeAbilityExecuteException()],
+    [FeWxMiniCmdException.JAVA_TYPE, new FeWxMiniCmdException()],
+    // WxMini 业务类型
+    [WxMiniBridgeCommand.JAVA_TYPE, new WxMiniBridgeCommand()],
+    [WxMiniCommand.JAVA_TYPE, new WxMiniCommand()],
+    [WxMiniConfigDto.JAVA_TYPE, new WxMiniConfigDto()],
+    [QueryWxMiniParam.JAVA_TYPE, new QueryWxMiniParam()],
+    [QuerySceneFromWxMiniParams.JAVA_TYPE, new QuerySceneFromWxMiniParams()]
+  ]);
+  JavaFactory.registPojos(beans);
+}
+
+// src/device-info.ts
+function isWxMiniprogram() {
+  if (typeof window === "undefined" || typeof navigator === "undefined") {
+    return false;
+  }
+  const userAgent = window.navigator.userAgent.toLowerCase();
+  return userAgent.includes("micromessenger") && userAgent.includes("miniprogram");
+}
+function isTouchDevice() {
+  if (typeof window === "undefined") return false;
+  return "ontouchstart" in window || navigator.maxTouchPoints > 0;
+}
+function getPlatform() {
+  if (typeof navigator === "undefined") return "Unknown";
+  const ua = navigator.userAgent;
+  if (/Windows/.test(ua)) return "Windows";
+  if (/Macintosh|Mac OS X/.test(ua)) return "macOS";
+  if (/Linux/.test(ua)) return "Linux";
+  if (/Android/.test(ua)) return "Android";
+  if (/iPhone|iPad|iPod/.test(ua)) return "iOS";
+  return "Unknown";
+}
+function getBrowserName() {
+  if (typeof navigator === "undefined") return "Unknown";
+  const userAgent = navigator.userAgent.toLowerCase();
+  if (userAgent.includes("micromessenger")) return "WeChat";
+  if (userAgent.includes("firefox")) return "Firefox";
+  if (userAgent.includes("edg")) return "Edge (Chromium)";
+  if (userAgent.includes("edge")) return "Edge (Legacy)";
+  if (userAgent.includes("opr") || userAgent.includes("opera")) return "Opera";
+  if (userAgent.includes("trident") || userAgent.includes("msie")) return "Internet Explorer";
+  if (userAgent.includes("chrome")) return "Chrome";
+  if (userAgent.includes("safari")) return "Safari";
+  return "Unknown";
+}
+var PING_SERVICE = "[PING]";
+var PingStatus = /* @__PURE__ */ ((PingStatus2) => {
+  PingStatus2[PingStatus2["success"] = 0] = "success";
+  PingStatus2[PingStatus2["failed"] = 1] = "failed";
+  PingStatus2[PingStatus2["timeout"] = 2] = "timeout";
+  PingStatus2[PingStatus2["none"] = 3] = "none";
+  return PingStatus2;
+})(PingStatus || {});
+var PingResult = class {
+  constructor(status = 3 /* none */, error) {
+    this.status = status;
+    this.error = error;
+  }
+};
+var WebSocketError = class extends Error {
+  constructor(msg) {
+    super(msg);
+  }
+};
+var WebSocketConnectError = class extends Error {
+  constructor(msg, options) {
+    super(msg);
+    this.name = "WebSocketConnectError";
+    this.cause = options?.cause;
+  }
+};
+var clients = /* @__PURE__ */ new Set();
+var _WsClient = class _WsClient {
+  constructor(url) {
+    this.socket = null;
+    this.pingInterval = 5e3;
+    this._reqId = 300;
+    this._mapRpc = /* @__PURE__ */ new Map();
+    this._rpcCodec = new RpcCodec();
+    this.url = url;
+    clients.add(this);
+  }
+  getSocket() {
+    return this.socket;
+  }
+  getUrl() {
+    return this.url;
+  }
+  /**
+   * 设置服务端回调处理器
+   */
+  setCallbackHandler(handler) {
+    this._callbackHandler = handler;
+  }
+  connect(options) {
+    if (!this.socket || !this.isSocketValid()) {
+      this.socket = new WebSocket(this.url);
+      this.socket.onopen = (event) => this.onSocketConnected(event);
+      this.socket.onmessage = (event) => this.onSocketMessage(event);
+      this.socket.onclose = (event) => this.onSocketClose(event);
+      this.socket.onerror = (event) => this.onSocketError(event);
+      if (options?.loopRetry != false) {
+        this.tryStartLoop();
+      }
+    } else {
+      Utils.log("WebSocket is already connected or connecting");
+    }
+  }
+  async blockConnect(options) {
+    this.connect(options);
+    try {
+      await Utils.pollBlock(
+        () => this.isSocketValid(),
+        3e3,
+        100,
+        "Timed out to connect server : " + this.url
+      );
+    } catch (err) {
+      this.close();
+      throw err;
+    }
+  }
+  tryStartLoop() {
+    if (this.intervalId) return;
+    this.intervalId = setInterval(() => this.loopRetryConnect(), this.pingInterval);
+  }
+  close() {
+    clients.delete(this);
+    try {
+      if (this.socket) {
+        this.socket.close();
+      }
+    } catch (err) {
+      Utils.error(err);
+    }
+    if (this.intervalId != null) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+  }
+  loopRetryConnect() {
+    if (this.isSocketValid()) return;
+    Utils.log("Retry connecting : %s ... ", this.url);
+    this.connect();
+  }
+  onSocketConnected(event) {
+    Utils.log("WebSocket is connected : %s (%s)", this.url, event);
+  }
+  onSocketClose(event) {
+    Utils.log("WebSocket is closed : %s (%s)", this.url, event);
+  }
+  isSocketValid() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+  onSocketMessage(event) {
+    if (event.data instanceof Blob) {
+      event.data.arrayBuffer().then((bt) => {
+        this.handleReceivedData(bt);
+      });
+    } else throw new Error("Recieved illegal message : " + event);
+  }
+  static checkConnectionError(bytes) {
+    if (bytes == null) return;
+    const prefixLength = _WsClient.SIM_SERVER_CON_ERROR_HEADER.length;
+    const arrayLength = bytes.length;
+    if (arrayLength < prefixLength) {
+      return;
+    }
+    for (let i = 0; i < prefixLength; i++) {
+      if (bytes[i] !== _WsClient.SIM_SERVER_CON_ERROR_HEADER[i]) {
+        return;
+      }
+    }
+    const body = bytes.subarray(prefixLength);
+    const msg = Utils.utf8ToString(body);
+    throw new WebSocketError(msg ?? "Unknown error message");
+  }
+  wrapSocketErrorBytes(error) {
+    const msg = error + "";
+    const msgBytes = Utils.string2Utf8(msg ?? "Unknown error");
+    return Utils.concatUint8Arrays([_WsClient.SIM_SERVER_CON_ERROR_HEADER, msgBytes]);
+  }
+  onSocketError(error) {
+    for (const req of Array.from(this._mapRpc.keys())) {
+      const func = this._mapRpc.get(req);
+      this._mapRpc.delete(req);
+      const msg = error.type + ":" + this.url + "(" + _WsClient.getWebSocketStateName(this.socket?.readyState) + ")";
+      func?.call(this, this.wrapSocketErrorBytes(msg), true);
+    }
+    Utils.error("WebSocket error : %s", error + "");
+  }
+  async ping(timeout = 5) {
+    return new Promise((resolve, reject) => {
+      const cmd = new CRpcFeCmd();
+      cmd.service = PING_SERVICE;
+      const result = new PingResult();
+      setTimeout(() => {
+        result.status = 2 /* timeout */;
+        resolve(result);
+      }, timeout * 1e3);
+      this.rpcAsync(cmd, null).then((_) => {
+        result.status = 0 /* success */;
+        resolve(result);
+      }).catch((error) => {
+        result.status = 1 /* failed */;
+        result.error = error;
+        resolve(result);
+      });
+    });
+  }
+  rpc(cmd, onAct) {
+    if (!this.isSocketValid())
+      throw new Error("Invalid connection status : " + _WsClient.getWebSocketStateName(this.socket?.readyState));
+    const req = this._reqId++;
+    cmd.reqId = req;
+    const cmdBytes = this._rpcCodec.toBytes(cmd);
+    this._mapRpc.set(req, onAct);
+    const header = _WsClient.buildRpcHeader(req, this._rpcCodec.zipOut);
+    try {
+      this.sendRpcBytes(header, cmdBytes);
+    } catch (err) {
+      if (err instanceof Error) {
+        console.error(err.message);
+      } else {
+        console.error(err);
+      }
+    }
+    return req;
+  }
+  async rpcAsync(cmd, returnType) {
+    return new Promise((resolve, reject) => {
+      this.rpc(cmd, (data, isZip) => {
+        try {
+          const retData = Cson.decodeReturn(data, isZip);
+          if (returnType != null) {
+            if (Utils.isInstance(retData, returnType)) resolve(retData);
+            else
+              reject("Invalid return data type(Desired Type" + returnType + "). Value=" + retData);
+          } else resolve(retData);
+        } catch (error) {
+          if (error instanceof FeException) reject(error);
+          else reject("Failed to decode RPC return data:" + data);
+        }
+      });
+    });
+  }
+  async handleReceivedData(buffer) {
+    const data = new Uint8Array(buffer);
+    const bytes = new Uint8Array(data);
+    const lowVer = new DataView(bytes.buffer, bytes.byteOffset).getInt8(_WsClient._rspZipFlagOffset);
+    const zip = (lowVer & _WsClient._maskZipFlag) > 0;
+    const pkgType = new DataView(bytes.buffer, bytes.byteOffset).getInt8(
+      _WsClient._rspTypeFlagOffset
+    );
+    const req = Bytes.readInt32(bytes, _WsClient._rspReqIdOffset + 4);
+    const body = bytes.slice(_WsClient._rspLength);
+    if (pkgType === _WsClient._typeBinRpcRSP) {
+      const func = this._mapRpc.get(req);
+      if (func != null) {
+        func(body, zip);
+        this._mapRpc.delete(req);
+      } else {
+        Utils.error(`Recieved None Request Response (${req}) ${bytes.byteLength} byte`);
+      }
+    } else if (pkgType === _WsClient._typeBinRpcCallbackReq) {
+      this.callbackFromServer(req, body);
+    }
+  }
+  async callbackFromServer(reqId, cmdByte) {
+    const rsp = new CRpcCallbackRsp();
+    rsp.reqId = reqId;
+    try {
+      const mapAttach = /* @__PURE__ */ new Map();
+      const rspJson = Cson.decodeServerPackage(cmdByte, true, mapAttach);
+      if (Utils.isStringEmpty(rspJson)) return null;
+      const cmd = Cson.decodeJson(rspJson, mapAttach);
+      if (cmd.data != null) {
+        if (this._callbackHandler) {
+          const result = await this._callbackHandler.handleCallback(cmd.data);
+          rsp.result = result == null ? void 0 : result;
+        } else {
+          Utils.log("No callback handler registered, ignoring server callback");
+        }
+      }
+    } catch (error) {
+      Utils.error("Callback error:", error);
+      throw error;
+    } finally {
+      this.sendCallbackRsp(rsp);
+    }
+  }
+  sendMessage(message) {
+    if (this.socket && this.isSocketValid()) {
+      this.socket.send(message);
+    } else {
+      Utils.error("WebSocket is invalid : %s", this.socket?.readyState);
+    }
+  }
+  static getWebSocketStateName(state) {
+    if (state == null) return "NULL";
+    switch (state) {
+      case WebSocket.OPEN:
+        return "OPEN";
+      case WebSocket.CONNECTING:
+        return "CONNECTING";
+      case WebSocket.CLOSING:
+        return "CLOSING";
+      default:
+      case WebSocket.CLOSED:
+        return "CLOSED";
+    }
+  }
+  async sendBinary(data) {
+    await Utils.pollBlock(() => this.isSocketValid(), 5e3, 200);
+    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+      this.socket.send(data);
+    } else {
+      Utils.error("WebSocket is not open");
+    }
+  }
+  async sendRpcBytes(header, bytes) {
+    if (!bytes || bytes.length === 0) return;
+    if (bytes.length <= _WsClient._wsMaxFrame) {
+      const lst = new Uint8Array([...header, _WsClient._wsFlagSingle, ...bytes]);
+      this.sendBinary(lst.buffer);
+      return;
+    }
+    const length = bytes.length;
+    for (let i = 0; i < length; i += _WsClient._wsMaxFrame) {
+      let end = i + _WsClient._wsMaxFrame;
+      let flag = _WsClient._wsFlagEnd;
+      if (i === 0) {
+        flag = _WsClient._wsFlagStart;
+      } else if (end >= length) {
+        flag = _WsClient._wsFlagEnd;
+        end = length;
+      } else {
+        flag = _WsClient._wsFlagContinue;
+      }
+      const lst = new Uint8Array([...header, flag, ...bytes.slice(i, end)]);
+      await this.sendBinary(lst.buffer);
+    }
+  }
+  static buildRpcHeader(reqID, zip) {
+    const bytes = new Uint8Array(_WsClient._reqLength);
+    const header = zip ? _WsClient._wsBinHeaderZip : _WsClient._wsBinHeader;
+    bytes.set(header, 0);
+    Bytes.setInt32Bytes(bytes, this._reqLength - 4, reqID);
+    return bytes;
+  }
+  static buildCallbackRspHeader(reqID) {
+    const bytes = new Uint8Array(_WsClient._reqLength);
+    bytes.set(_WsClient._wsBinHeaderCallbackRSP, 0);
+    Bytes.setInt32Bytes(bytes, this._reqLength - 4, reqID);
+    return bytes;
+  }
+  buildCallbackRspHeader(reqID) {
+    const bytes = new Uint8Array(_WsClient._reqLength);
+    bytes.set(_WsClient._wsBinHeaderCallbackRSP, 0);
+    const dataView = new DataView(bytes.buffer);
+    dataView.setInt32(9, reqID, true);
+    return bytes;
+  }
+  sendCallbackRsp(rsp) {
+    const cmdBytes = this._rpcCodec.toBytes(rsp);
+    const header = this.buildCallbackRspHeader(rsp.reqId);
+    this.sendRpcBytes(header, cmdBytes);
+  }
+};
+// 小版本的0位，标识是否压缩
+_WsClient._maskZipFlag = 1;
+// 四号字节代表返回包类型
+_WsClient._typeBinRpcRSP = 101;
+_WsClient._typeBinRpcCallbackReq = 102;
+_WsClient._typeBinRpcCallbackRsp = 103;
+_WsClient._reqLength = 13;
+_WsClient._rspLength = 13;
+_WsClient._rspZipFlagOffset = 3;
+_WsClient._rspReqIdOffset = 5;
+_WsClient._rspTypeFlagOffset = 4;
+_WsClient._int32Length = 4;
+_WsClient._wsFlagSingle = 0;
+_WsClient._wsFlagStart = 2;
+_WsClient._wsFlagContinue = 3;
+_WsClient._wsFlagEnd = 4;
+_WsClient._wsMaxFrame = 65e3;
+_WsClient._wsBinHeader = new Uint8Array([
+  "L".charCodeAt(0),
+  1,
+  0,
+  0,
+  100
+]);
+_WsClient._wsBinHeaderZip = new Uint8Array(["L".charCodeAt(0), 1, 0, 1, 100]);
+_WsClient._wsBinHeaderCallbackRSP = new Uint8Array([
+  "L".charCodeAt(0),
+  1,
+  0,
+  1,
+  _WsClient._typeBinRpcCallbackRsp
+]);
+_WsClient.SIM_SERVER_CON_ERROR_HEADER = new Uint8Array([128, 0, 0, 128, 33, 77]);
+var WsClient = _WsClient;
+var RpcCodec = class {
+  constructor() {
+    this.zipOut = true;
+  }
+  toBytes(cmd) {
+    const attach = /* @__PURE__ */ new Map();
+    const json = Cson.encode(cmd, attach);
+    let bodyBytes = new TextEncoder().encode(json);
+    if (this.zipOut) {
+      bodyBytes = pako__default.default.gzip(bodyBytes);
+    }
+    const pTable = new PartitionTable();
+    pTable.bodyLength = bodyBytes.length;
+    pTable.lstBin = [];
+    let lstBin = [];
+    let pos = 0;
+    for (const [key, value] of attach) {
+      lstBin = lstBin.concat(Array.from(value));
+      const bk = new BinBlock();
+      bk.id = key;
+      bk.start = pos;
+      const nowlength = lstBin.length;
+      bk.end = nowlength - 1;
+      pos = nowlength;
+      pTable.lstBin.push(bk);
+    }
+    const parJson = Cson.encode(pTable, null);
+    const parBytes = new TextEncoder().encode(parJson);
+    let lstBytes = Array.from(int32ToBytes(parBytes.length));
+    lstBytes = lstBytes.concat(Array.from(parBytes));
+    lstBytes = lstBytes.concat(Array.from(bodyBytes));
+    lstBytes = lstBytes.concat(lstBin);
+    return new Uint8Array(lstBytes);
+  }
+};
+var ws_client_default = WsClient;
+
+// src/rpc-core.ts
+var WsService = class {
+  constructor(wsClient, service) {
+    this.wsClient = wsClient;
+    this.service = service;
+  }
+  getClient() {
+    return this.wsClient;
+  }
+  getServiceName() {
+    return this.service;
+  }
+};
+
+// src/rpc-interface.ts
+var _IWxMiniBridgeService = class _IWxMiniBridgeService extends WsService {
+  constructor(wsClient) {
+    super(wsClient, _IWxMiniBridgeService.SERVICE);
+  }
+  async handleCommand(cmd) {
+    const _cmd = new CRpcFeCmd();
+    _cmd.service = this.getServiceName();
+    _cmd.func = "handleCommand";
+    _cmd.params = [cmd];
+    return this.wsClient.rpcAsync(_cmd, null);
+  }
+};
+_IWxMiniBridgeService.SERVICE = "cell.wx.mini.server.IWxMiniBridgeService";
+_IWxMiniBridgeService.DEFAULT_TIMEOUTS = 30;
+_IWxMiniBridgeService.DEFAULT_WAIT_ONLINE_TIMEOUTS = 10;
+_IWxMiniBridgeService.DECLARED_FIELDS = [];
+var IWxMiniBridgeService = _IWxMiniBridgeService;
+
+// src/wx-mini.ts
+function isWxMiniBridgeCommandResult(obj) {
+  return typeof obj === "object" && obj !== null && "data" in obj && "startTime" in obj && "endTime" in obj && typeof obj.startTime === "number" && typeof obj.endTime === "number";
+}
+var _kBatchExecuteCommand = "PRECMD_BATCH_CMD_HEX";
+var WxMiniBridge = class {
+  _processOneResult(result) {
+    if (typeof result == "string") {
+      try {
+        const jsonMap = JSON.parse(result);
+        if (isWxMiniBridgeCommandResult(jsonMap)) {
+          return jsonMap.data;
+        }
+      } catch (error) {
+      }
+    }
+    return result;
+  }
+  isBatchExecuting(command) {
+    return command.cmd == _kBatchExecuteCommand;
+  }
+  async prepareBridgeClient() {
+    if (!isWxMiniprogram()) {
+      throw new Error("WxMiniCommand can't use out of wxMiniprogram.");
+    }
+    if (this._bridgeClient == void 0) {
+      if (this.bridgeWebSocketUrl == void 0) {
+        throw new Error("The wxMini bridge webSocket url is undefined.");
+      }
+      this._bridgeClient = new ws_client_default(this.bridgeWebSocketUrl);
+      await this._bridgeClient.blockConnect();
+    }
+    return this._bridgeClient;
+  }
+  async handleBridgeCallback(command) {
+    try {
+      let bridgeCommand = new WxMiniBridgeCommand();
+      bridgeCommand.appId = this.appUuid;
+      bridgeCommand.cmd = command.cmd;
+      bridgeCommand.params = command.params;
+      bridgeCommand.timeoutS = command.timeout;
+      bridgeCommand.waitOnlineTimeoutS = command.waitOnlineTimeoutS;
+      let result = await this.handleBridgeCommand(bridgeCommand);
+      if (typeof result == "string") {
+        result = this._processOneResult(result);
+        if (this.isBatchExecuting(command)) {
+          if (typeof result == "string") {
+            result = JSON.parse(result);
+          }
+          result = Object.fromEntries(Object.entries(result).map((value) => [value[0], this._processOneResult(value[1])]));
+          result = JSON.stringify(result);
+        }
+      }
+      return result;
+    } catch (error) {
+      throw this._getWxMiniComdException(error, command);
+    }
+  }
+  async handleBridgeCommand(command) {
+    if (command.appId == void 0) {
+      command.appId = this.appUuid;
+    }
+    let service = new IWxMiniBridgeService(await this.prepareBridgeClient());
+    let result = await service.handleCommand(command);
+    return result;
+  }
+  queryConfig() {
+    const configDto = new WxMiniConfigDto();
+    configDto.wxMiniAppUuid = this.appUuid;
+    configDto.wxMiniServerUrl = this.serverUrl;
+    configDto.sceneFromWxMiniParams = this.sceneFromWxMiniParams;
+    configDto.initalQueryParameters = this.initalQueryParameters;
+    return configDto;
+  }
+  querySceneFromWxMiniParams() {
+    return this.sceneFromWxMiniParams;
+  }
+  /**
+   * 关闭桥接连接
+   */
+  close() {
+    if (this._bridgeClient) {
+      this._bridgeClient.close();
+      this._bridgeClient = void 0;
+    }
+  }
+  _getWxMiniComdException(error, command) {
+    const exception = new FeWxMiniCmdException();
+    exception.ability = command;
+    exception.wxMiniAppUuid = this.appUuid;
+    exception.wxMiniServerUrl = this.serverUrl;
+    if (error instanceof Error) {
+      exception.err = error.message;
+      exception.err = `${error}`;
+    } else {
+      exception.err = `${error}`;
+    }
+    return exception;
+  }
+};
+
+// src/wx-mini-api.ts
+var WxMiniCmd = /* @__PURE__ */ ((WxMiniCmd2) => {
+  WxMiniCmd2["getUserProfile"] = "getUserProfile";
+  WxMiniCmd2["makePhoneCall"] = "makePhoneCall";
+  WxMiniCmd2["chooseMedia"] = "chooseMedia";
+  WxMiniCmd2["readLocalFile"] = "readLocalFile";
+  WxMiniCmd2["getPhoneNum"] = "getPhoneNum";
+  WxMiniCmd2["scanCode"] = "scanCode";
+  WxMiniCmd2["navigateTo"] = "navigateTo";
+  WxMiniCmd2["redirectTo"] = "redirectTo";
+  WxMiniCmd2["reLaunch"] = "reLaunch";
+  WxMiniCmd2["navigateBack"] = "navigateBack";
+  WxMiniCmd2["loginGetCode"] = "loginGetCode";
+  WxMiniCmd2["saveProjectConfigParam"] = "saveProjectConfigParam";
+  WxMiniCmd2["loadProjectConfigParam"] = "loadProjectConfigParam";
+  WxMiniCmd2["downloadFile"] = "downloadFile";
+  WxMiniCmd2["uploadFile"] = "uploadFile";
+  WxMiniCmd2["saveFileToDisk"] = "saveFileToDisk";
+  WxMiniCmd2["shareFileMessage"] = "shareFileMessage";
+  WxMiniCmd2["openDocument"] = "openDocument";
+  WxMiniCmd2["getLocation"] = "getLocation";
+  WxMiniCmd2["openLocation"] = "openLocation";
+  WxMiniCmd2["chooseLocation"] = "chooseLocation";
+  WxMiniCmd2["queryAppGlobalData"] = "queryAppGlobalData";
+  WxMiniCmd2["chooseMessageFile"] = "chooseMessageFile";
+  WxMiniCmd2["setSharePageMessage"] = "setSharePageMessage";
+  WxMiniCmd2["showShareImageMenu"] = "showShareImageMenu";
+  WxMiniCmd2["saveImageToPhotosAlbum"] = "saveImageToPhotosAlbum";
+  WxMiniCmd2["saveVideoToPhotosAlbum"] = "saveVideoToPhotosAlbum";
+  WxMiniCmd2["getClipboardData"] = "getClipboardData";
+  WxMiniCmd2["setClipboardData"] = "setClipboardData";
+  WxMiniCmd2["startAudioRecord"] = "startAudioRecord";
+  WxMiniCmd2["stopAudioRecord"] = "stopAudioRecord";
+  WxMiniCmd2["pauseAudioRecord"] = "pauseAudioRecord";
+  WxMiniCmd2["resumeAudioRecord"] = "resumeAudioRecord";
+  return WxMiniCmd2;
+})(WxMiniCmd || {});
+var DEFAULT_TIMEOUT = 60 * 1e3;
+function buildCmd(cmd, opts, params) {
+  const command = new WxMiniCommand();
+  command.cmd = cmd;
+  command.timeout = opts?.timeout ?? DEFAULT_TIMEOUT;
+  if (params) {
+    command.params = new Map(Object.entries(params));
+  }
+  return command;
+}
+function addParams(cmd, params) {
+  if (!cmd.params) {
+    cmd.params = /* @__PURE__ */ new Map();
+  }
+  for (const [k, v] of Object.entries(params)) {
+    cmd.params.set(k, v ?? null);
+  }
+  return cmd;
+}
+var WxMiniApi = class {
+  constructor(config) {
+    this._bridge = new WxMiniBridge();
+    if (config) {
+      this.configure(config);
+    }
+  }
+  /**
+   * 设置或更新配置
+   * @param config - appUuid 和 bridgeWebSocketUrl
+   */
+  configure(config) {
+    if (config.appUuid !== void 0) {
+      this._bridge.appUuid = config.appUuid;
+    }
+    if (config.bridgeWebSocketUrl !== void 0) {
+      this._bridge.bridgeWebSocketUrl = config.bridgeWebSocketUrl;
+    }
+  }
+  /**
+   * 关闭桥接连接，释放资源
+   */
+  close() {
+    this._bridge.close();
+  }
+  /** 执行一个命令并返回结果 */
+  async execute(command) {
+    return this._bridge.handleBridgeCallback(command);
+  }
+  /** 执行并将结果 JSON 解析为对象 */
+  async executeAs(command) {
+    const result = await this.execute(command);
+    if (typeof result === "string") {
+      return JSON.parse(result);
+    }
+    return result;
+  }
+  // ========================= 用户信息 =========================
+  /**
+   * 通过微信小程序接口, 获取用户信息（昵称/头像等）
+   */
+  async getUserProfile(opts) {
+    const command = buildCmd("getUserProfile" /* getUserProfile */, opts, {
+      [WxMiniCommand.getUserProfile_MESSAGE]: opts.message,
+      [WxMiniCommand.getUserProfile_BUTTON]: opts.buttonLabel,
+      [WxMiniCommand.getUserProfile_QUERY_TYPE]: opts.type ?? "All"
+    });
+    return this.execute(command);
+  }
+  // ========================= 手机号 =========================
+  /**
+   * 通过微信小程序接口，获取用户手机号码
+   */
+  async getPhoneNum(opts) {
+    const command = buildCmd("getPhoneNum" /* getPhoneNum */, opts, {
+      [WxMiniCommand.getPhoneNum_MESSAGE]: opts.message,
+      [WxMiniCommand.getPhoneNum_BUTTON]: opts.buttonLabel,
+      [WxMiniCommand.getPhoneNum_REJECT_BUTTON]: opts.rejectButtonLabel ?? null
+    });
+    return this.execute(command);
+  }
+  // ========================= 拨打电话 =========================
+  /**
+   * 拨打电话
+   */
+  async makePhoneCall(opts) {
+    const command = buildCmd("makePhoneCall" /* makePhoneCall */, opts, {
+      [WxMiniCommand.makePhoneCall_phoneNum]: opts.phoneNum
+    });
+    await this.execute(command);
+  }
+  // ========================= 媒体选择 =========================
+  /**
+   * 调起相机并选取照片/视频
+   */
+  async chooseMedia(opts = {}) {
+    const {
+      count = 2,
+      mediaTypes = [WxMiniCommand.MEDIATYPE_mix],
+      sourceTypes = [WxMiniCommand.SOURCETYPE_album, WxMiniCommand.SOURCETYPE_camera],
+      maxDuration = 30,
+      sizeTypes = [WxMiniCommand.SIZETYPE_compressed, WxMiniCommand.SIZETYPE_original],
+      camera = WxMiniCommand.CAMERA_back
+    } = opts;
+    const command = buildCmd("chooseMedia" /* chooseMedia */, opts, {
+      [WxMiniCommand.PARAM_count]: String(count),
+      [WxMiniCommand.PARAM_mediaType]: JSON.stringify(mediaTypes),
+      [WxMiniCommand.PARAM_sourceType]: JSON.stringify(sourceTypes),
+      [WxMiniCommand.PARAM_maxDuration]: String(maxDuration),
+      [WxMiniCommand.PARAM_sizeType]: JSON.stringify(sizeTypes),
+      [WxMiniCommand.PARAM_camera]: camera
+    });
+    return this.executeAs(command);
+  }
+  // ========================= 扫码 =========================
+  /**
+   * 扫描二维码，返回二维码内容
+   */
+  async scanCode(opts = {}) {
+    const command = buildCmd("scanCode" /* scanCode */, opts);
+    return this.execute(command);
+  }
+  // ========================= 文件操作 =========================
+  /**
+   * 读取本地文件内容
+   * @warning 文件超过 60K 会导致链接中断，适合小文件
+   */
+  async readLocalFile(opts) {
+    const command = buildCmd("readLocalFile" /* readLocalFile */, opts, {
+      [WxMiniCommand.PARAM_FILE_PATH]: opts.filePath
+    });
+    return this.execute(command);
+  }
+  /**
+   * 下载文件，返回临时文件路径
+   */
+  async downloadFile(opts) {
+    const command = buildCmd("downloadFile" /* downloadFile */, opts, {
+      [WxMiniCommand.PARAM_URL]: opts.url
+    });
+    return this.execute(command);
+  }
+  /**
+   * 上传文件到服务器
+   */
+  async uploadFile(opts) {
+    const command = buildCmd("uploadFile" /* uploadFile */, opts, {
+      [WxMiniCommand.PARAM_URL]: opts.url,
+      [WxMiniCommand.PARAM_FILE_PATH]: opts.filePath,
+      [WxMiniCommand.PARAM_UPLOAD_FILE_NAME]: opts.fileName,
+      [WxMiniCommand.PARAM_UPLOAD_FORM_DATA]: opts.formData ? JSON.stringify(opts.formData) : null
+    });
+    return this.execute(command);
+  }
+  /**
+   * 打开预览文档（支持 txt/pdf/excel/word/ppt 等格式）
+   */
+  async openDocument(opts) {
+    const command = buildCmd("openDocument" /* openDocument */, opts, {
+      [WxMiniCommand.PARAM_FILE_PATH]: opts.filePath
+    });
+    await this.execute(command);
+  }
+  /**
+   * 保存图片到相册
+   */
+  async saveImageToPhotosAlbum(opts) {
+    const command = buildCmd("saveImageToPhotosAlbum" /* saveImageToPhotosAlbum */, opts, {
+      [WxMiniCommand.PARAM_FILE_PATH]: opts.filePath
+    });
+    await this.execute(command);
+  }
+  /**
+   * 保存视频到相册
+   */
+  async saveVideoToPhotosAlbum(opts) {
+    const command = buildCmd("saveVideoToPhotosAlbum" /* saveVideoToPhotosAlbum */, opts, {
+      [WxMiniCommand.PARAM_FILE_PATH]: opts.filePath
+    });
+    await this.execute(command);
+  }
+  /**
+   * 分享文件消息（将临时文件分享给他人）
+   */
+  async shareFileMessage(opts) {
+    const command = buildCmd("shareFileMessage" /* shareFileMessage */, opts, {
+      [WxMiniCommand.PARAM_FILE_PATH]: opts.filePath,
+      [WxMiniCommand.PARAM_SHARE_FILE_NAME]: opts.fileName
+    });
+    await this.execute(command);
+  }
+  /**
+   * 从聊天记录中选择文件
+   */
+  async chooseMessageFile(opts) {
+    const command = buildCmd("chooseMessageFile" /* chooseMessageFile */, opts, {
+      [WxMiniCommand.PARAM_COUNT]: String(opts.count),
+      [WxMiniCommand.PARAM_TYPE]: opts.type ?? "all",
+      [WxMiniCommand.PARAM_EXTENSION]: opts.extensions ? JSON.stringify(opts.extensions) : null
+    });
+    return this.executeAs(command);
+  }
+  // ========================= 页面导航 =========================
+  /**
+   * 跳转到小程序内部页面
+   */
+  async navigateTo(opts) {
+    const command = buildCmd("navigateTo" /* navigateTo */, opts, {
+      [WxMiniCommand.PARAM_URL]: opts.path
+    });
+    await this.execute(command);
+  }
+  /**
+   * 关闭当前页面后跳转
+   */
+  async redirectTo(opts) {
+    const command = buildCmd("redirectTo" /* redirectTo */, opts, {
+      [WxMiniCommand.PARAM_URL]: opts.path
+    });
+    await this.execute(command);
+  }
+  /**
+   * 关闭所有页面，打开应用内某页面（清空页面栈）
+   */
+  async reLaunch(opts) {
+    const command = buildCmd("reLaunch" /* reLaunch */, opts, {
+      [WxMiniCommand.PARAM_URL]: opts.path
+    });
+    await this.execute(command);
+  }
+  /**
+   * 关闭当前页面，返回上一页面或多级页面
+   */
+  async navigateBack(opts = {}) {
+    const command = buildCmd("navigateBack" /* navigateBack */, opts, {
+      [WxMiniCommand.PARAM_delta]: String(opts.delta ?? 1)
+    });
+    await this.execute(command);
+  }
+  // ========================= 登录 =========================
+  /**
+   * 调用微信登录，返回登录码 code
+   */
+  async loginGetCode(opts = {}) {
+    const command = buildCmd("loginGetCode" /* loginGetCode */, opts);
+    return this.execute(command);
+  }
+  // ========================= 位置 =========================
+  /**
+   * 获取当前位置（经纬度）
+   */
+  async getLocation(opts = {}) {
+    const command = buildCmd("getLocation" /* getLocation */, opts, {
+      [WxMiniCommand.PARAM_OPENIT]: String(opts.openIt ?? false)
+    });
+    return this.executeAs(command);
+  }
+  /**
+   * 打开地图并定位到指定位置
+   */
+  async openLocation(opts) {
+    const command = buildCmd("openLocation" /* openLocation */, opts, {
+      [WxMiniCommand.PARAM_LOCATION]: JSON.stringify(opts.location)
+    });
+    await this.execute(command);
+  }
+  /**
+   * 打开地图让用户选择位置，返回所选位置坐标
+   */
+  async chooseLocation(opts = {}) {
+    const command = buildCmd("chooseLocation" /* chooseLocation */, opts);
+    addParams(command, {
+      [WxMiniCommand.PARAM_LOCATION]: opts.initLocation ? JSON.stringify(opts.initLocation) : "{}"
+    });
+    return this.executeAs(command);
+  }
+  // ========================= 工程配置 =========================
+  /**
+   * 保存扩展的工程配置参数到小程序本地（页面启动时会自动合并传入）
+   */
+  async saveExtProjectConfig(opts) {
+    const command = buildCmd("saveProjectConfigParam" /* saveProjectConfigParam */, opts, {
+      [WxMiniCommand.PARAM_MAP_JSON]: JSON.stringify(opts.params),
+      [WxMiniCommand.PARAM_APPEND]: String(opts.append)
+    });
+    await this.execute(command);
+  }
+  /**
+   * 读取保存在小程序本地的扩展工程配置参数
+   */
+  async loadExtProjectConfig(opts = {}) {
+    const command = buildCmd("loadProjectConfigParam" /* loadProjectConfigParam */, { timeout: opts.timeout ?? 5e3 });
+    return this.executeAs(command);
+  }
+  // ========================= 应用数据 =========================
+  /**
+   * 查询小程序 App 的 GlobalData
+   */
+  async queryAppGlobalData(opts = {}) {
+    const command = buildCmd("queryAppGlobalData" /* queryAppGlobalData */, opts);
+    return this.executeAs(command);
+  }
+  // ========================= 分享 =========================
+  /**
+   * 设置分享页信息（用于分享转发，全局一份）
+   */
+  async setSharePageMessage(opts) {
+    const command = buildCmd("setSharePageMessage" /* setSharePageMessage */, opts, {
+      [WxMiniCommand.PARAM_sharePage]: JSON.stringify(opts.sharePage)
+    });
+    await this.execute(command);
+  }
+  /**
+   * 显示图片分享菜单
+   */
+  async showShareImageMenu(opts) {
+    const command = buildCmd("showShareImageMenu" /* showShareImageMenu */, opts, {
+      [WxMiniCommand.PARAM_path]: opts.path,
+      [WxMiniCommand.PARAM_style]: opts.style,
+      [WxMiniCommand.PARAM_needShowEntrance]: opts.needShowEntrance,
+      [WxMiniCommand.PARAM_entrancePath]: opts.entrancePath
+    });
+    await this.execute(command);
+  }
+  // ========================= 剪贴板 =========================
+  /**
+   * 读取剪贴板内容
+   */
+  async getClipboardData(opts = {}) {
+    const command = buildCmd("getClipboardData" /* getClipboardData */, opts);
+    return this.execute(command);
+  }
+  /**
+   * 写入剪贴板
+   */
+  async setClipboardData(opts) {
+    const command = buildCmd("setClipboardData" /* setClipboardData */, opts, {
+      [WxMiniCommand.CLIP_BOARD_DATA]: opts.data
+    });
+    await this.execute(command);
+  }
+  // ========================= 录音 =========================
+  /**
+   * 开始录音
+   */
+  async startAudioRecord(opts = {}) {
+    const command = buildCmd("startAudioRecord" /* startAudioRecord */, opts);
+    const { duration, sampleRate, numberOfChannels, encodeBitRate, format, frameSize } = opts;
+    const recOpts = {};
+    if (duration !== void 0) recOpts.duration = duration;
+    if (sampleRate !== void 0) recOpts.sampleRate = sampleRate;
+    if (numberOfChannels !== void 0) recOpts.numberOfChannels = numberOfChannels;
+    if (encodeBitRate !== void 0) recOpts.encodeBitRate = encodeBitRate;
+    if (format !== void 0) recOpts.format = format;
+    if (frameSize !== void 0) recOpts.frameSize = frameSize;
+    if (Object.keys(recOpts).length > 0) {
+      addParams(command, { options: JSON.stringify(recOpts) });
+    }
+    await this.execute(command);
+  }
+  /**
+   * 停止录音，返回录音文件临时路径
+   */
+  async stopAudioRecord(opts = {}) {
+    const command = buildCmd("stopAudioRecord" /* stopAudioRecord */, opts);
+    return this.execute(command);
+  }
+  /**
+   * 暂停录音
+   */
+  async pauseAudioRecord(opts = {}) {
+    const command = buildCmd("pauseAudioRecord" /* pauseAudioRecord */, opts);
+    await this.execute(command);
+  }
+  /**
+   * 继续录音
+   */
+  async resumeAudioRecord(opts = {}) {
+    const command = buildCmd("resumeAudioRecord" /* resumeAudioRecord */, opts);
+    await this.execute(command);
+  }
+};
+
+// src/index.ts
+registerAllPojos();
+
+exports.BinBlock = BinBlock;
+exports.Bytes = Bytes;
+exports.CRpcCallbackCmd = CRpcCallbackCmd;
+exports.CRpcCallbackRsp = CRpcCallbackRsp;
+exports.CRpcFeCmd = CRpcFeCmd;
+exports.CRpcFeRsp = CRpcFeRsp;
+exports.Cson = Cson;
+exports.CsonBean = CsonBean;
+exports.CsonPojo = CsonPojo;
+exports.FeAbilityExecuteException = FeAbilityExecuteException;
+exports.FeException = FeException;
+exports.FeJavaException = FeJavaException;
+exports.FePojo = FePojo;
+exports.FeWxMiniCmdException = FeWxMiniCmdException;
+exports.IWxMiniBridgeService = IWxMiniBridgeService;
+exports.JavaFactory = JavaFactory;
+exports.NullPojo = NullPojo;
+exports.PartitionTable = PartitionTable;
+exports.PingResult = PingResult;
+exports.PingStatus = PingStatus;
+exports.QuerySceneFromWxMiniParams = QuerySceneFromWxMiniParams;
+exports.QueryWxMiniParam = QueryWxMiniParam;
+exports.RpcCodec = RpcCodec;
+exports.SystemCallback = SystemCallback;
+exports.Utils = Utils;
+exports.ValuePojo = ValuePojo;
+exports.WebSocketConnectError = WebSocketConnectError;
+exports.WebSocketError = WebSocketError;
+exports.WsClient = ws_client_default;
+exports.WsService = WsService;
+exports.WxMiniApi = WxMiniApi;
+exports.WxMiniBridge = WxMiniBridge;
+exports.WxMiniBridgeCommand = WxMiniBridgeCommand;
+exports.WxMiniCmd = WxMiniCmd;
+exports.WxMiniCommand = WxMiniCommand;
+exports.WxMiniConfigDto = WxMiniConfigDto;
+exports.clients = clients;
+exports.getBrowserName = getBrowserName;
+exports.getPlatform = getPlatform;
+exports.isTouchDevice = isTouchDevice;
+exports.isWxMiniprogram = isWxMiniprogram;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map