'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var platformAdaptersNode = require('@leancloud/platform-adapters-node');
var protobufLight = _interopDefault(require('protobufjs/dist/protobuf-light'));
var EventEmitter = _interopDefault(require('eventemitter3'));
var d = _interopDefault(require('debug'));
var shuffle = _interopDefault(require('lodash/shuffle'));
var values = _interopDefault(require('lodash/values'));
var StateMachine = _interopDefault(require('javascript-state-machine'));
var isPlainObject = _interopDefault(require('lodash/isPlainObject'));
var promiseTimeout = require('promise-timeout');
var uuid = _interopDefault(require('uuid/v4'));
var base64Arraybuffer = require('base64-arraybuffer');
var remove = _interopDefault(require('lodash/remove'));
var isEmpty = _interopDefault(require('lodash/isEmpty'));
var cloneDeep = _interopDefault(require('lodash/cloneDeep'));
var find = _interopDefault(require('lodash/find'));
var get = _interopDefault(require('lodash/get'));

var messageCompiled = protobufLight.newBuilder({})['import']({
  package: 'push_server.messages2',
  syntax: 'proto2',
  options: {
    objc_class_prefix: 'AVIM'
  },
  messages: [{
    name: 'JsonObjectMessage',
    syntax: 'proto2',
    fields: [{
      rule: 'required',
      type: 'string',
      name: 'data',
      id: 1
    }]
  }, {
    name: 'UnreadTuple',
    syntax: 'proto2',
    fields: [{
      rule: 'required',
      type: 'string',
      name: 'cid',
      id: 1
    }, {
      rule: 'required',
      type: 'int32',
      name: 'unread',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 'mid',
      id: 3
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'timestamp',
      id: 4
    }, {
      rule: 'optional',
      type: 'string',
      name: 'from',
      id: 5
    }, {
      rule: 'optional',
      type: 'string',
      name: 'data',
      id: 6
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'patchTimestamp',
      id: 7
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'mentioned',
      id: 8
    }, {
      rule: 'optional',
      type: 'bytes',
      name: 'binaryMsg',
      id: 9
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'convType',
      id: 10
    }]
  }, {
    name: 'LogItem',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'from',
      id: 1
    }, {
      rule: 'optional',
      type: 'string',
      name: 'data',
      id: 2
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'timestamp',
      id: 3
    }, {
      rule: 'optional',
      type: 'string',
      name: 'msgId',
      id: 4
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'ackAt',
      id: 5
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'readAt',
      id: 6
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'patchTimestamp',
      id: 7
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'mentionAll',
      id: 8
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'mentionPids',
      id: 9
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'bin',
      id: 10
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'convType',
      id: 11
    }]
  }, {
    name: 'ConvMemberInfo',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'pid',
      id: 1
    }, {
      rule: 'optional',
      type: 'string',
      name: 'role',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 'infoId',
      id: 3
    }]
  }, {
    name: 'DataCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'repeated',
      type: 'string',
      name: 'ids',
      id: 1
    }, {
      rule: 'repeated',
      type: 'JsonObjectMessage',
      name: 'msg',
      id: 2
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'offline',
      id: 3
    }]
  }, {
    name: 'SessionCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'int64',
      name: 't',
      id: 1
    }, {
      rule: 'optional',
      type: 'string',
      name: 'n',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 's',
      id: 3
    }, {
      rule: 'optional',
      type: 'string',
      name: 'ua',
      id: 4
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'r',
      id: 5
    }, {
      rule: 'optional',
      type: 'string',
      name: 'tag',
      id: 6
    }, {
      rule: 'optional',
      type: 'string',
      name: 'deviceId',
      id: 7
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'sessionPeerIds',
      id: 8
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'onlineSessionPeerIds',
      id: 9
    }, {
      rule: 'optional',
      type: 'string',
      name: 'st',
      id: 10
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'stTtl',
      id: 11
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'code',
      id: 12
    }, {
      rule: 'optional',
      type: 'string',
      name: 'reason',
      id: 13
    }, {
      rule: 'optional',
      type: 'string',
      name: 'deviceToken',
      id: 14
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'sp',
      id: 15
    }, {
      rule: 'optional',
      type: 'string',
      name: 'detail',
      id: 16
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'lastUnreadNotifTime',
      id: 17
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'lastPatchTime',
      id: 18
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'configBitmap',
      id: 19
    }]
  }, {
    name: 'ErrorCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'required',
      type: 'int32',
      name: 'code',
      id: 1
    }, {
      rule: 'required',
      type: 'string',
      name: 'reason',
      id: 2
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'appCode',
      id: 3
    }, {
      rule: 'optional',
      type: 'string',
      name: 'detail',
      id: 4
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'pids',
      id: 5
    }, {
      rule: 'optional',
      type: 'string',
      name: 'appMsg',
      id: 6
    }]
  }, {
    name: 'DirectCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'msg',
      id: 1
    }, {
      rule: 'optional',
      type: 'string',
      name: 'uid',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 'fromPeerId',
      id: 3
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'timestamp',
      id: 4
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'offline',
      id: 5
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'hasMore',
      id: 6
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'toPeerIds',
      id: 7
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'r',
      id: 10
    }, {
      rule: 'optional',
      type: 'string',
      name: 'cid',
      id: 11
    }, {
      rule: 'optional',
      type: 'string',
      name: 'id',
      id: 12
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'transient',
      id: 13
    }, {
      rule: 'optional',
      type: 'string',
      name: 'dt',
      id: 14
    }, {
      rule: 'optional',
      type: 'string',
      name: 'roomId',
      id: 15
    }, {
      rule: 'optional',
      type: 'string',
      name: 'pushData',
      id: 16
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'will',
      id: 17
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'patchTimestamp',
      id: 18
    }, {
      rule: 'optional',
      type: 'bytes',
      name: 'binaryMsg',
      id: 19
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'mentionPids',
      id: 20
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'mentionAll',
      id: 21
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'convType',
      id: 22
    }]
  }, {
    name: 'AckCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'int32',
      name: 'code',
      id: 1
    }, {
      rule: 'optional',
      type: 'string',
      name: 'reason',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 'mid',
      id: 3
    }, {
      rule: 'optional',
      type: 'string',
      name: 'cid',
      id: 4
    }, {
      rule: 'optional',
      type: 'int64',
      name: 't',
      id: 5
    }, {
      rule: 'optional',
      type: 'string',
      name: 'uid',
      id: 6
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'fromts',
      id: 7
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'tots',
      id: 8
    }, {
      rule: 'optional',
      type: 'string',
      name: 'type',
      id: 9
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'ids',
      id: 10
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'appCode',
      id: 11
    }, {
      rule: 'optional',
      type: 'string',
      name: 'appMsg',
      id: 12
    }]
  }, {
    name: 'UnreadCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'repeated',
      type: 'UnreadTuple',
      name: 'convs',
      id: 1
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'notifTime',
      id: 2
    }]
  }, {
    name: 'ConvCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'repeated',
      type: 'string',
      name: 'm',
      id: 1
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'transient',
      id: 2
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'unique',
      id: 3
    }, {
      rule: 'optional',
      type: 'string',
      name: 'cid',
      id: 4
    }, {
      rule: 'optional',
      type: 'string',
      name: 'cdate',
      id: 5
    }, {
      rule: 'optional',
      type: 'string',
      name: 'initBy',
      id: 6
    }, {
      rule: 'optional',
      type: 'string',
      name: 'sort',
      id: 7
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'limit',
      id: 8
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'skip',
      id: 9
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'flag',
      id: 10
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'count',
      id: 11
    }, {
      rule: 'optional',
      type: 'string',
      name: 'udate',
      id: 12
    }, {
      rule: 'optional',
      type: 'int64',
      name: 't',
      id: 13
    }, {
      rule: 'optional',
      type: 'string',
      name: 'n',
      id: 14
    }, {
      rule: 'optional',
      type: 'string',
      name: 's',
      id: 15
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'statusSub',
      id: 16
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'statusPub',
      id: 17
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'statusTTL',
      id: 18
    }, {
      rule: 'optional',
      type: 'string',
      name: 'uniqueId',
      id: 19
    }, {
      rule: 'optional',
      type: 'string',
      name: 'targetClientId',
      id: 20
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'maxReadTimestamp',
      id: 21
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'maxAckTimestamp',
      id: 22
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'queryAllMembers',
      id: 23
    }, {
      rule: 'repeated',
      type: 'MaxReadTuple',
      name: 'maxReadTuples',
      id: 24
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'cids',
      id: 25
    }, {
      rule: 'optional',
      type: 'ConvMemberInfo',
      name: 'info',
      id: 26
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'tempConv',
      id: 27
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'tempConvTTL',
      id: 28
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'tempConvIds',
      id: 29
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'allowedPids',
      id: 30
    }, {
      rule: 'repeated',
      type: 'ErrorCommand',
      name: 'failedPids',
      id: 31
    }, {
      rule: 'optional',
      type: 'string',
      name: 'next',
      id: 40
    }, {
      rule: 'optional',
      type: 'JsonObjectMessage',
      name: 'results',
      id: 100
    }, {
      rule: 'optional',
      type: 'JsonObjectMessage',
      name: 'where',
      id: 101
    }, {
      rule: 'optional',
      type: 'JsonObjectMessage',
      name: 'attr',
      id: 103
    }, {
      rule: 'optional',
      type: 'JsonObjectMessage',
      name: 'attrModified',
      id: 104
    }]
  }, {
    name: 'RoomCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'roomId',
      id: 1
    }, {
      rule: 'optional',
      type: 'string',
      name: 's',
      id: 2
    }, {
      rule: 'optional',
      type: 'int64',
      name: 't',
      id: 3
    }, {
      rule: 'optional',
      type: 'string',
      name: 'n',
      id: 4
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'transient',
      id: 5
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'roomPeerIds',
      id: 6
    }, {
      rule: 'optional',
      type: 'string',
      name: 'byPeerId',
      id: 7
    }]
  }, {
    name: 'LogsCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'cid',
      id: 1
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'l',
      id: 2
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'limit',
      id: 3
    }, {
      rule: 'optional',
      type: 'int64',
      name: 't',
      id: 4
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'tt',
      id: 5
    }, {
      rule: 'optional',
      type: 'string',
      name: 'tmid',
      id: 6
    }, {
      rule: 'optional',
      type: 'string',
      name: 'mid',
      id: 7
    }, {
      rule: 'optional',
      type: 'string',
      name: 'checksum',
      id: 8
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'stored',
      id: 9
    }, {
      rule: 'optional',
      type: 'QueryDirection',
      name: 'direction',
      id: 10,
      options: {
        default: 'OLD'
      }
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'tIncluded',
      id: 11
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'ttIncluded',
      id: 12
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'lctype',
      id: 13
    }, {
      rule: 'repeated',
      type: 'LogItem',
      name: 'logs',
      id: 105
    }],
    enums: [{
      name: 'QueryDirection',
      syntax: 'proto2',
      values: [{
        name: 'OLD',
        id: 1
      }, {
        name: 'NEW',
        id: 2
      }]
    }]
  }, {
    name: 'RcpCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'id',
      id: 1
    }, {
      rule: 'optional',
      type: 'string',
      name: 'cid',
      id: 2
    }, {
      rule: 'optional',
      type: 'int64',
      name: 't',
      id: 3
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'read',
      id: 4
    }, {
      rule: 'optional',
      type: 'string',
      name: 'from',
      id: 5
    }]
  }, {
    name: 'ReadTuple',
    syntax: 'proto2',
    fields: [{
      rule: 'required',
      type: 'string',
      name: 'cid',
      id: 1
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'timestamp',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 'mid',
      id: 3
    }]
  }, {
    name: 'MaxReadTuple',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'pid',
      id: 1
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'maxAckTimestamp',
      id: 2
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'maxReadTimestamp',
      id: 3
    }]
  }, {
    name: 'ReadCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'cid',
      id: 1
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'cids',
      id: 2
    }, {
      rule: 'repeated',
      type: 'ReadTuple',
      name: 'convs',
      id: 3
    }]
  }, {
    name: 'PresenceCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'StatusType',
      name: 'status',
      id: 1
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'sessionPeerIds',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 'cid',
      id: 3
    }]
  }, {
    name: 'ReportCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'bool',
      name: 'initiative',
      id: 1
    }, {
      rule: 'optional',
      type: 'string',
      name: 'type',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 'data',
      id: 3
    }]
  }, {
    name: 'PatchItem',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'cid',
      id: 1
    }, {
      rule: 'optional',
      type: 'string',
      name: 'mid',
      id: 2
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'timestamp',
      id: 3
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'recall',
      id: 4
    }, {
      rule: 'optional',
      type: 'string',
      name: 'data',
      id: 5
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'patchTimestamp',
      id: 6
    }, {
      rule: 'optional',
      type: 'string',
      name: 'from',
      id: 7
    }, {
      rule: 'optional',
      type: 'bytes',
      name: 'binaryMsg',
      id: 8
    }, {
      rule: 'optional',
      type: 'bool',
      name: 'mentionAll',
      id: 9
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'mentionPids',
      id: 10
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'patchCode',
      id: 11
    }, {
      rule: 'optional',
      type: 'string',
      name: 'patchReason',
      id: 12
    }]
  }, {
    name: 'PatchCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'repeated',
      type: 'PatchItem',
      name: 'patches',
      id: 1
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'lastPatchTime',
      id: 2
    }]
  }, {
    name: 'PubsubCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'cid',
      id: 1
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'cids',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 'topic',
      id: 3
    }, {
      rule: 'optional',
      type: 'string',
      name: 'subtopic',
      id: 4
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'topics',
      id: 5
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'subtopics',
      id: 6
    }, {
      rule: 'optional',
      type: 'JsonObjectMessage',
      name: 'results',
      id: 7
    }]
  }, {
    name: 'BlacklistCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'string',
      name: 'srcCid',
      id: 1
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'toPids',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 'srcPid',
      id: 3
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'toCids',
      id: 4
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'limit',
      id: 5
    }, {
      rule: 'optional',
      type: 'string',
      name: 'next',
      id: 6
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'blockedPids',
      id: 8
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'blockedCids',
      id: 9
    }, {
      rule: 'repeated',
      type: 'string',
      name: 'allowedPids',
      id: 10
    }, {
      rule: 'repeated',
      type: 'ErrorCommand',
      name: 'failedPids',
      id: 11
    }, {
      rule: 'optional',
      type: 'int64',
      name: 't',
      id: 12
    }, {
      rule: 'optional',
      type: 'string',
      name: 'n',
      id: 13
    }, {
      rule: 'optional',
      type: 'string',
      name: 's',
      id: 14
    }]
  }, {
    name: 'GenericCommand',
    syntax: 'proto2',
    fields: [{
      rule: 'optional',
      type: 'CommandType',
      name: 'cmd',
      id: 1
    }, {
      rule: 'optional',
      type: 'OpType',
      name: 'op',
      id: 2
    }, {
      rule: 'optional',
      type: 'string',
      name: 'appId',
      id: 3
    }, {
      rule: 'optional',
      type: 'string',
      name: 'peerId',
      id: 4
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'i',
      id: 5
    }, {
      rule: 'optional',
      type: 'string',
      name: 'installationId',
      id: 6
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'priority',
      id: 7
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'service',
      id: 8
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'serverTs',
      id: 9
    }, {
      rule: 'optional',
      type: 'int64',
      name: 'clientTs',
      id: 10
    }, {
      rule: 'optional',
      type: 'int32',
      name: 'notificationType',
      id: 11
    }, {
      rule: 'optional',
      type: 'DataCommand',
      name: 'dataMessage',
      id: 101
    }, {
      rule: 'optional',
      type: 'SessionCommand',
      name: 'sessionMessage',
      id: 102
    }, {
      rule: 'optional',
      type: 'ErrorCommand',
      name: 'errorMessage',
      id: 103
    }, {
      rule: 'optional',
      type: 'DirectCommand',
      name: 'directMessage',
      id: 104
    }, {
      rule: 'optional',
      type: 'AckCommand',
      name: 'ackMessage',
      id: 105
    }, {
      rule: 'optional',
      type: 'UnreadCommand',
      name: 'unreadMessage',
      id: 106
    }, {
      rule: 'optional',
      type: 'ReadCommand',
      name: 'readMessage',
      id: 107
    }, {
      rule: 'optional',
      type: 'RcpCommand',
      name: 'rcpMessage',
      id: 108
    }, {
      rule: 'optional',
      type: 'LogsCommand',
      name: 'logsMessage',
      id: 109
    }, {
      rule: 'optional',
      type: 'ConvCommand',
      name: 'convMessage',
      id: 110
    }, {
      rule: 'optional',
      type: 'RoomCommand',
      name: 'roomMessage',
      id: 111
    }, {
      rule: 'optional',
      type: 'PresenceCommand',
      name: 'presenceMessage',
      id: 112
    }, {
      rule: 'optional',
      type: 'ReportCommand',
      name: 'reportMessage',
      id: 113
    }, {
      rule: 'optional',
      type: 'PatchCommand',
      name: 'patchMessage',
      id: 114
    }, {
      rule: 'optional',
      type: 'PubsubCommand',
      name: 'pubsubMessage',
      id: 115
    }, {
      rule: 'optional',
      type: 'BlacklistCommand',
      name: 'blacklistMessage',
      id: 116
    }]
  }],
  enums: [{
    name: 'CommandType',
    syntax: 'proto2',
    values: [{
      name: 'session',
      id: 0
    }, {
      name: 'conv',
      id: 1
    }, {
      name: 'direct',
      id: 2
    }, {
      name: 'ack',
      id: 3
    }, {
      name: 'rcp',
      id: 4
    }, {
      name: 'unread',
      id: 5
    }, {
      name: 'logs',
      id: 6
    }, {
      name: 'error',
      id: 7
    }, {
      name: 'login',
      id: 8
    }, {
      name: 'data',
      id: 9
    }, {
      name: 'room',
      id: 10
    }, {
      name: 'read',
      id: 11
    }, {
      name: 'presence',
      id: 12
    }, {
      name: 'report',
      id: 13
    }, {
      name: 'echo',
      id: 14
    }, {
      name: 'loggedin',
      id: 15
    }, {
      name: 'logout',
      id: 16
    }, {
      name: 'loggedout',
      id: 17
    }, {
      name: 'patch',
      id: 18
    }, {
      name: 'pubsub',
      id: 19
    }, {
      name: 'blacklist',
      id: 20
    }, {
      name: 'goaway',
      id: 21
    }]
  }, {
    name: 'OpType',
    syntax: 'proto2',
    values: [{
      name: 'open',
      id: 1
    }, {
      name: 'add',
      id: 2
    }, {
      name: 'remove',
      id: 3
    }, {
      name: 'close',
      id: 4
    }, {
      name: 'opened',
      id: 5
    }, {
      name: 'closed',
      id: 6
    }, {
      name: 'query',
      id: 7
    }, {
      name: 'query_result',
      id: 8
    }, {
      name: 'conflict',
      id: 9
    }, {
      name: 'added',
      id: 10
    }, {
      name: 'removed',
      id: 11
    }, {
      name: 'refresh',
      id: 12
    }, {
      name: 'refreshed',
      id: 13
    }, {
      name: 'start',
      id: 30
    }, {
      name: 'started',
      id: 31
    }, {
      name: 'joined',
      id: 32
    }, {
      name: 'members_joined',
      id: 33
    }, {
      name: 'left',
      id: 39
    }, {
      name: 'members_left',
      id: 40
    }, {
      name: 'results',
      id: 42
    }, {
      name: 'count',
      id: 43
    }, {
      name: 'result',
      id: 44
    }, {
      name: 'update',
      id: 45
    }, {
      name: 'updated',
      id: 46
    }, {
      name: 'mute',
      id: 47
    }, {
      name: 'unmute',
      id: 48
    }, {
      name: 'status',
      id: 49
    }, {
      name: 'members',
      id: 50
    }, {
      name: 'max_read',
      id: 51
    }, {
      name: 'is_member',
      id: 52
    }, {
      name: 'member_info_update',
      id: 53
    }, {
      name: 'member_info_updated',
      id: 54
    }, {
      name: 'member_info_changed',
      id: 55
    }, {
      name: 'join',
      id: 80
    }, {
      name: 'invite',
      id: 81
    }, {
      name: 'leave',
      id: 82
    }, {
      name: 'kick',
      id: 83
    }, {
      name: 'reject',
      id: 84
    }, {
      name: 'invited',
      id: 85
    }, {
      name: 'kicked',
      id: 86
    }, {
      name: 'upload',
      id: 100
    }, {
      name: 'uploaded',
      id: 101
    }, {
      name: 'subscribe',
      id: 120
    }, {
      name: 'subscribed',
      id: 121
    }, {
      name: 'unsubscribe',
      id: 122
    }, {
      name: 'unsubscribed',
      id: 123
    }, {
      name: 'is_subscribed',
      id: 124
    }, {
      name: 'modify',
      id: 150
    }, {
      name: 'modified',
      id: 151
    }, {
      name: 'block',
      id: 170
    }, {
      name: 'unblock',
      id: 171
    }, {
      name: 'blocked',
      id: 172
    }, {
      name: 'unblocked',
      id: 173
    }, {
      name: 'members_blocked',
      id: 174
    }, {
      name: 'members_unblocked',
      id: 175
    }, {
      name: 'check_block',
      id: 176
    }, {
      name: 'check_result',
      id: 177
    }, {
      name: 'add_shutup',
      id: 180
    }, {
      name: 'remove_shutup',
      id: 181
    }, {
      name: 'query_shutup',
      id: 182
    }, {
      name: 'shutup_added',
      id: 183
    }, {
      name: 'shutup_removed',
      id: 184
    }, {
      name: 'shutup_result',
      id: 185
    }, {
      name: 'shutuped',
      id: 186
    }, {
      name: 'unshutuped',
      id: 187
    }, {
      name: 'members_shutuped',
      id: 188
    }, {
      name: 'members_unshutuped',
      id: 189
    }, {
      name: 'check_shutup',
      id: 190
    }]
  }, {
    name: 'StatusType',
    syntax: 'proto2',
    values: [{
      name: 'on',
      id: 1
    }, {
      name: 'off',
      id: 2
    }]
  }],
  isNamespace: true
}).build();

const {
  JsonObjectMessage,
  UnreadTuple,
  LogItem,
  DataCommand,
  SessionCommand,
  ErrorCommand,
  DirectCommand,
  AckCommand,
  UnreadCommand,
  ConvCommand,
  RoomCommand,
  LogsCommand,
  RcpCommand,
  ReadTuple,
  MaxReadTuple,
  ReadCommand,
  PresenceCommand,
  ReportCommand,
  GenericCommand,
  BlacklistCommand,
  PatchCommand,
  PatchItem,
  ConvMemberInfo,
  CommandType,
  OpType,
  StatusType
} = messageCompiled.push_server.messages2;

var message = /*#__PURE__*/Object.freeze({
  __proto__: null,
  JsonObjectMessage: JsonObjectMessage,
  UnreadTuple: UnreadTuple,
  LogItem: LogItem,
  DataCommand: DataCommand,
  SessionCommand: SessionCommand,
  ErrorCommand: ErrorCommand,
  DirectCommand: DirectCommand,
  AckCommand: AckCommand,
  UnreadCommand: UnreadCommand,
  ConvCommand: ConvCommand,
  RoomCommand: RoomCommand,
  LogsCommand: LogsCommand,
  RcpCommand: RcpCommand,
  ReadTuple: ReadTuple,
  MaxReadTuple: MaxReadTuple,
  ReadCommand: ReadCommand,
  PresenceCommand: PresenceCommand,
  ReportCommand: ReportCommand,
  GenericCommand: GenericCommand,
  BlacklistCommand: BlacklistCommand,
  PatchCommand: PatchCommand,
  PatchItem: PatchItem,
  ConvMemberInfo: ConvMemberInfo,
  CommandType: CommandType,
  OpType: OpType,
  StatusType: StatusType
});

function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
  var desc = {};
  Object.keys(descriptor).forEach(function (key) {
    desc[key] = descriptor[key];
  });
  desc.enumerable = !!desc.enumerable;
  desc.configurable = !!desc.configurable;

  if ('value' in desc || desc.initializer) {
    desc.writable = true;
  }

  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
    return decorator(target, property, desc) || desc;
  }, desc);

  if (context && desc.initializer !== void 0) {
    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
    desc.initializer = undefined;
  }

  if (desc.initializer === void 0) {
    Object.defineProperty(target, property, desc);
    desc = null;
  }

  return desc;
}

const adapters = {};

const getAdapter = name => {
  const adapter = adapters[name];

  if (adapter === undefined) {
    throw new Error(`${name} adapter is not configured`);
  }

  return adapter;
};
/**
 * 指定 Adapters
 * @function
 * @memberof module:leancloud-realtime
 * @param {Adapters} newAdapters Adapters 的类型请参考 {@link https://url.leanapp.cn/adapter-type-definitions @leancloud/adapter-types} 中的定义
 */


const setAdapters = newAdapters => {
  Object.assign(adapters, newAdapters);
};

/* eslint-disable */
var global$1 = typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : {};

const EXPIRED = Symbol('expired');
const debug = d('LC:Expirable');
class Expirable {
  constructor(value, ttl) {
    this.originalValue = value;

    if (typeof ttl === 'number') {
      this.expiredAt = Date.now() + ttl;
    }
  }

  get value() {
    const expired = this.expiredAt && this.expiredAt <= Date.now();
    if (expired) debug(`expired: ${this.originalValue}`);
    return expired ? EXPIRED : this.originalValue;
  }

}
Expirable.EXPIRED = EXPIRED;

const debug$1 = d('LC:Cache');
class Cache {
  constructor(name = 'anonymous') {
    this.name = name;
    this._map = {};
  }

  get(key) {
    const cache = this._map[key];

    if (cache) {
      const {
        value
      } = cache;

      if (value !== Expirable.EXPIRED) {
        debug$1('[%s] hit: %s', this.name, key);
        return value;
      }

      delete this._map[key];
    }

    debug$1(`[${this.name}] missed: ${key}`);
    return null;
  }

  set(key, value, ttl) {
    debug$1('[%s] set: %s %d', this.name, key, ttl);
    this._map[key] = new Expirable(value, ttl);
  }

}

/**
 * 调试日志控制器
 * @const
 * @memberof module:leancloud-realtime
 * @example
 * debug.enable();  // 启用调试日志
 * debug.disable(); // 关闭调试日志
 */

const debug$2 = {
  enable: (namespaces = 'LC*') => d.enable(namespaces),
  disable: d.disable
};
const tryAll = promiseConstructors => {
  const promise = new Promise(promiseConstructors[0]);

  if (promiseConstructors.length === 1) {
    return promise;
  }

  return promise.catch(() => tryAll(promiseConstructors.slice(1)));
}; // eslint-disable-next-line no-sequences

const tap = interceptor => value => (interceptor(value), value);
const finalize = callback => [// eslint-disable-next-line no-sequences
value => (callback(), value), error => {
  callback();
  throw error;
}];
/**
 * 将对象转换为 Date，支持 string、number、ProtoBuf Long 以及 LeanCloud 的 Date 类型，
 * 其他情况下（包括对象为 falsy）返回原值。
 * @private
 */

const decodeDate = date => {
  if (!date) return date;

  if (typeof date === 'string' || typeof date === 'number') {
    return new Date(date);
  }

  if (date.__type === 'Date' && date.iso) {
    return new Date(date.iso);
  } // Long


  if (typeof date.toNumber === 'function') {
    return new Date(date.toNumber());
  }

  return date;
};
/**
 * 获取 Date 的毫秒数，如果不是一个 Date 返回 undefined。
 * @private
 */

const getTime = date => date && date.getTime ? date.getTime() : undefined;
/**
 * 解码对象中的 LeanCloud 数据结构。
 * 目前仅会处理 Date 类型。
 * @private
 */

const decode = value => {
  if (!value) return value;

  if (value.__type === 'Date' && value.iso) {
    return new Date(value.iso);
  }

  if (Array.isArray(value)) {
    return value.map(decode);
  }

  if (isPlainObject(value)) {
    return Object.keys(value).reduce((result, key) => ({ ...result,
      [key]: decode(value[key])
    }), {});
  }

  return value;
};
/**
 * 将对象中的特殊类型编码为 LeanCloud 数据结构。
 * 目前仅会处理 Date 类型。
 * @private
 */

const encode = value => {
  if (value instanceof Date) return {
    __type: 'Date',
    iso: value.toJSON()
  };

  if (Array.isArray(value)) {
    return value.map(encode);
  }

  if (isPlainObject(value)) {
    return Object.keys(value).reduce((result, key) => ({ ...result,
      [key]: encode(value[key])
    }), {});
  }

  return value;
};
const keyRemap = (keymap, obj) => Object.keys(obj).reduce((newObj, key) => {
  const newKey = keymap[key] || key;
  return Object.assign(newObj, {
    [newKey]: obj[key]
  });
}, {});
const isIE10 = global$1.navigator && global$1.navigator.userAgent && global$1.navigator.userAgent.indexOf('MSIE 10.') !== -1;
/* eslint-disable no-proto */

const getStaticProperty = (klass, property) => klass[property] || (klass.__proto__ ? getStaticProperty(klass.__proto__, property) : undefined);
/* eslint-enable no-proto */

const union = (a, b) => Array.from(new Set([...a, ...b]));
const difference = (a, b) => Array.from((bSet => new Set(a.filter(x => !bSet.has(x))))(new Set(b)));
const map = new WeakMap(); // protected property helper

const internal = object => {
  if (!map.has(object)) {
    map.set(object, {});
  }

  return map.get(object);
};
const compact = (obj, filter) => {
  if (!isPlainObject(obj)) return obj;
  const object = { ...obj
  };
  Object.keys(object).forEach(prop => {
    const value = object[prop];

    if (value === filter) {
      delete object[prop];
    } else {
      object[prop] = compact(value, filter);
    }
  });
  return object;
}; // debug utility

const removeNull = obj => compact(obj, null);

const trim = message => removeNull(JSON.parse(JSON.stringify(message)));
const ensureArray = target => {
  if (Array.isArray(target)) {
    return target;
  }

  if (target === undefined || target === null) {
    return [];
  }

  return [target];
};
const setValue = (target, key, value) => {
  // '.' is not allowed in Class keys, escaping is not in concern now.
  const segs = key.split('.');
  const lastSeg = segs.pop();
  let currentTarget = target;
  segs.forEach(seg => {
    if (currentTarget[seg] === undefined) currentTarget[seg] = {};
    currentTarget = currentTarget[seg];
  });
  currentTarget[lastSeg] = value;
  return target;
};
const isWeapp = // eslint-disable-next-line no-undef
typeof wx === 'object' && typeof wx.connectSocket === 'function'; // throttle decorator

const throttle = wait => (target, property, descriptor) => {
  const callback = descriptor.value; // very naive, internal use only

  if (callback.length) {
    throw new Error('throttled function should not accept any arguments');
  }

  return { ...descriptor,

    value() {
      let {
        throttleMeta
      } = internal(this);

      if (!throttleMeta) {
        throttleMeta = {};
        internal(this).throttleMeta = throttleMeta;
      }

      let {
        [property]: propertyMeta
      } = throttleMeta;

      if (!propertyMeta) {
        propertyMeta = {};
        throttleMeta[property] = propertyMeta;
      }

      const {
        previouseTimestamp = 0,
        timeout
      } = propertyMeta;
      const now = Date.now();
      const remainingTime = wait - (now - previouseTimestamp);

      if (remainingTime <= 0) {
        throttleMeta[property].previouseTimestamp = now;
        callback.apply(this);
      } else if (!timeout) {
        propertyMeta.timeout = setTimeout(() => {
          propertyMeta.previouseTimestamp = Date.now();
          delete propertyMeta.timeout;
          callback.apply(this);
        }, remainingTime);
      }
    }

  };
};
const isCNApp = appId => appId.slice(-9) !== '-MdYXbMMI';
const equalBuffer = (buffer1, buffer2) => {
  if (!buffer1 || !buffer2) return false;
  if (buffer1.byteLength !== buffer2.byteLength) return false;
  const a = new Uint8Array(buffer1);
  const b = new Uint8Array(buffer2);
  return !a.some((value, index) => value !== b[index]);
};

var _class;
const debug$3 = d('LC:WebSocketPlus');
const OPEN = 'open';
const DISCONNECT = 'disconnect';
const RECONNECT = 'reconnect';
const RETRY = 'retry';
const SCHEDULE = 'schedule';
const OFFLINE = 'offline';
const ONLINE = 'online';
const ERROR = 'error';
const MESSAGE = 'message';
const HEARTBEAT_TIME = 180000;
const TIMEOUT_TIME = 380000;

const DEFAULT_RETRY_STRATEGY = attempt => Math.min(1000 * 2 ** attempt, 300000);

const requireConnected = (target, name, descriptor) => ({ ...descriptor,
  value: function requireConnectedWrapper(...args) {
    this.checkConnectionAvailability(name);
    return descriptor.value.call(this, ...args);
  }
});

let WebSocketPlus = (_class = class WebSocketPlus extends EventEmitter {
  get urls() {
    return this._urls;
  }

  set urls(urls) {
    this._urls = ensureArray(urls);
  }

  constructor(getUrls, protocol) {
    super();
    this.init();
    this._protocol = protocol;
    Promise.resolve(typeof getUrls === 'function' ? getUrls() : getUrls).then(ensureArray).then(urls => {
      this._urls = urls;
      return this._open();
    }).then(() => {
      this.__postponeTimeoutTimer = this._postponeTimeoutTimer.bind(this);

      if (global$1.addEventListener) {
        this.__pause = () => {
          if (this.can('pause')) this.pause();
        };

        this.__resume = () => {
          if (this.can('resume')) this.resume();
        };

        global$1.addEventListener('offline', this.__pause);
        global$1.addEventListener('online', this.__resume);
      }

      this.open();
    }).catch(this.throw.bind(this));
  }

  _open() {
    return this._createWs(this._urls, this._protocol).then(ws => {
      const [first, ...reset] = this._urls;
      this._urls = [...reset, first];
      return ws;
    });
  }

  _createWs(urls, protocol) {
    return tryAll(urls.map(url => (resolve, reject) => {
      debug$3(`connect [${url}] ${protocol}`);
      const WebSocket = getAdapter('WebSocket');
      const ws = protocol ? new WebSocket(url, protocol) : new WebSocket(url);
      ws.binaryType = this.binaryType || 'arraybuffer';

      ws.onopen = () => resolve(ws);

      ws.onclose = error => {
        if (error instanceof Error) {
          return reject(error);
        } // in browser, error event is useless


        return reject(new Error(`Failed to connect [${url}]`));
      };

      ws.onerror = ws.onclose;
    })).then(ws => {
      this._ws = ws;
      this._ws.onclose = this._handleClose.bind(this);
      this._ws.onmessage = this._handleMessage.bind(this);
      return ws;
    });
  }

  _destroyWs() {
    const ws = this._ws;
    if (!ws) return;
    ws.onopen = null;
    ws.onclose = null;
    ws.onerror = null;
    ws.onmessage = null;
    this._ws = null;
    ws.close();
  } // eslint-disable-next-line class-methods-use-this


  onbeforeevent(event, from, to, ...payload) {
    debug$3(`${event}: ${from} -> ${to} %o`, payload);
  }

  onopen() {
    this.emit(OPEN);
  }

  onconnected() {
    this._startConnectionKeeper();
  }

  onleaveconnected(event, from, to) {
    this._stopConnectionKeeper();

    this._destroyWs();

    if (to === 'offline' || to === 'disconnected') {
      this.emit(DISCONNECT);
    }
  }

  onpause() {
    this.emit(OFFLINE);
  }

  onbeforeresume() {
    this.emit(ONLINE);
  }

  onreconnect() {
    this.emit(RECONNECT);
  }

  ondisconnected(event, from, to, attempt = 0) {
    const delay = from === OFFLINE ? 0 : DEFAULT_RETRY_STRATEGY.call(null, attempt);
    debug$3(`schedule attempt=${attempt} delay=${delay}`);
    this.emit(SCHEDULE, attempt, delay);

    if (this.__scheduledRetry) {
      clearTimeout(this.__scheduledRetry);
    }

    this.__scheduledRetry = setTimeout(() => {
      if (this.is('disconnected')) {
        this.retry(attempt);
      }
    }, delay);
  }

  onretry(event, from, to, attempt = 0) {
    this.emit(RETRY, attempt);

    this._open().then(() => this.can('reconnect') && this.reconnect(), () => this.can('fail') && this.fail(attempt + 1));
  }

  onerror(event, from, to, error) {
    this.emit(ERROR, error);
  }

  onclose() {
    if (global$1.removeEventListener) {
      if (this.__pause) global$1.removeEventListener('offline', this.__pause);
      if (this.__resume) global$1.removeEventListener('online', this.__resume);
    }
  }

  checkConnectionAvailability(name = 'API') {
    if (!this.is('connected')) {
      const currentState = this.current;
      console.warn(`${name} should not be called when the connection is ${currentState}`);

      if (this.is('disconnected') || this.is('reconnecting')) {
        console.warn('disconnect and reconnect event should be handled to avoid such calls.');
      }

      throw new Error('Connection unavailable');
    }
  } // jsdoc-ignore-start


  // jsdoc-ignore-end
  _ping() {
    debug$3('ping');

    try {
      this.ping();
    } catch (error) {
      console.warn(`websocket ping error: ${error.message}`);
    }
  }

  ping() {
    if (this._ws.ping) {
      this._ws.ping();
    } else {
      console.warn(`The WebSocket implement does not support sending ping frame.
        Override ping method to use application defined ping/pong mechanism.`);
    }
  }

  _postponeTimeoutTimer() {
    debug$3('_postponeTimeoutTimer');

    this._clearTimeoutTimers();

    this._timeoutTimer = setTimeout(() => {
      debug$3('timeout');
      this.disconnect();
    }, TIMEOUT_TIME);
  }

  _clearTimeoutTimers() {
    if (this._timeoutTimer) {
      clearTimeout(this._timeoutTimer);
    }
  }

  _startConnectionKeeper() {
    debug$3('start connection keeper');
    this._heartbeatTimer = setInterval(this._ping.bind(this), HEARTBEAT_TIME);
    const addListener = this._ws.addListener || this._ws.addEventListener;

    if (!addListener) {
      debug$3('connection keeper disabled due to the lack of #addEventListener.');
      return;
    }

    addListener.call(this._ws, 'message', this.__postponeTimeoutTimer);
    addListener.call(this._ws, 'pong', this.__postponeTimeoutTimer);

    this._postponeTimeoutTimer();
  }

  _stopConnectionKeeper() {
    debug$3('stop connection keeper'); // websockets/ws#489

    const removeListener = this._ws.removeListener || this._ws.removeEventListener;

    if (removeListener) {
      removeListener.call(this._ws, 'message', this.__postponeTimeoutTimer);
      removeListener.call(this._ws, 'pong', this.__postponeTimeoutTimer);

      this._clearTimeoutTimers();
    }

    if (this._heartbeatTimer) {
      clearInterval(this._heartbeatTimer);
    }
  }

  _handleClose(event) {
    debug$3(`ws closed [${event.code}] ${event.reason}`); // socket closed manually, ignore close event.

    if (this.isFinished()) return;
    this.handleClose(event);
  }

  handleClose() {
    // reconnect
    this.disconnect();
  } // jsdoc-ignore-start


  // jsdoc-ignore-end
  send(data) {
    debug$3('send', data);

    this._ws.send(data);
  }

  _handleMessage(event) {
    debug$3('message', event.data);
    this.handleMessage(event.data);
  }

  handleMessage(message) {
    this.emit(MESSAGE, message);
  }

}, (_applyDecoratedDescriptor(_class.prototype, "_ping", [requireConnected], Object.getOwnPropertyDescriptor(_class.prototype, "_ping"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "send", [requireConnected], Object.getOwnPropertyDescriptor(_class.prototype, "send"), _class.prototype)), _class);
StateMachine.create({
  target: WebSocketPlus.prototype,
  initial: {
    state: 'initialized',
    event: 'init',
    defer: true
  },
  terminal: 'closed',
  events: [{
    name: 'open',
    from: 'initialized',
    to: 'connected'
  }, {
    name: 'disconnect',
    from: 'connected',
    to: 'disconnected'
  }, {
    name: 'retry',
    from: 'disconnected',
    to: 'reconnecting'
  }, {
    name: 'fail',
    from: 'reconnecting',
    to: 'disconnected'
  }, {
    name: 'reconnect',
    from: 'reconnecting',
    to: 'connected'
  }, {
    name: 'pause',
    from: ['connected', 'disconnected', 'reconnecting'],
    to: 'offline'
  }, {}, {
    name: 'resume',
    from: 'offline',
    to: 'disconnected'
  }, {
    name: 'close',
    from: ['connected', 'disconnected', 'reconnecting', 'offline'],
    to: 'closed'
  }, {
    name: 'throw',
    from: '*',
    to: 'error'
  }]
});

const error = Object.freeze({
  1000: {
    name: 'CLOSE_NORMAL'
  },
  1006: {
    name: 'CLOSE_ABNORMAL'
  },
  4100: {
    name: 'APP_NOT_AVAILABLE',
    message: 'App not exists or realtime message service is disabled.'
  },
  4102: {
    name: 'SIGNATURE_FAILED',
    message: 'Login signature mismatch.'
  },
  4103: {
    name: 'INVALID_LOGIN',
    message: 'Malformed clientId.'
  },
  4105: {
    name: 'SESSION_REQUIRED',
    message: 'Message sent before session opened.'
  },
  4107: {
    name: 'READ_TIMEOUT'
  },
  4108: {
    name: 'LOGIN_TIMEOUT'
  },
  4109: {
    name: 'FRAME_TOO_LONG'
  },
  4110: {
    name: 'INVALID_ORIGIN',
    message: 'Access denied by domain whitelist.'
  },
  4111: {
    name: 'SESSION_CONFLICT'
  },
  4112: {
    name: 'SESSION_TOKEN_EXPIRED'
  },
  4113: {
    name: 'APP_QUOTA_EXCEEDED',
    message: 'The daily active users limit exceeded.'
  },
  4116: {
    name: 'MESSAGE_SENT_QUOTA_EXCEEDED',
    message: 'Command sent too fast.'
  },
  4200: {
    name: 'INTERNAL_ERROR',
    message: 'Internal error, please contact LeanCloud for support.'
  },
  4301: {
    name: 'CONVERSATION_API_FAILED',
    message: 'Upstream Conversatoin API failed, see error.detail for details.'
  },
  4302: {
    name: 'CONVERSATION_SIGNATURE_FAILED',
    message: 'Conversation action signature mismatch.'
  },
  4303: {
    name: 'CONVERSATION_NOT_FOUND'
  },
  4304: {
    name: 'CONVERSATION_FULL'
  },
  4305: {
    name: 'CONVERSATION_REJECTED_BY_APP',
    message: 'Conversation action rejected by hook.'
  },
  4306: {
    name: 'CONVERSATION_UPDATE_FAILED'
  },
  4307: {
    name: 'CONVERSATION_READ_ONLY'
  },
  4308: {
    name: 'CONVERSATION_NOT_ALLOWED'
  },
  4309: {
    name: 'CONVERSATION_UPDATE_REJECTED',
    message: 'Conversation update rejected because the client is not a member.'
  },
  4310: {
    name: 'CONVERSATION_QUERY_FAILED',
    message: 'Conversation query failed because it is too expansive.'
  },
  4311: {
    name: 'CONVERSATION_LOG_FAILED'
  },
  4312: {
    name: 'CONVERSATION_LOG_REJECTED',
    message: 'Message query rejected because the client is not a member of the conversation.'
  },
  4313: {
    name: 'SYSTEM_CONVERSATION_REQUIRED'
  },
  4314: {
    name: 'NORMAL_CONVERSATION_REQUIRED'
  },
  4315: {
    name: 'CONVERSATION_BLACKLISTED',
    message: 'Blacklisted in the conversation.'
  },
  4316: {
    name: 'TRANSIENT_CONVERSATION_REQUIRED'
  },
  4317: {
    name: 'CONVERSATION_MEMBERSHIP_REQUIRED'
  },
  4318: {
    name: 'CONVERSATION_API_QUOTA_EXCEEDED',
    message: 'LeanCloud API quota exceeded. You may upgrade your plan.'
  },
  4323: {
    name: 'TEMPORARY_CONVERSATION_EXPIRED',
    message: 'Temporary conversation expired or does not exist.'
  },
  4401: {
    name: 'INVALID_MESSAGING_TARGET',
    message: 'Conversation does not exist or client is not a member.'
  },
  4402: {
    name: 'MESSAGE_REJECTED_BY_APP',
    message: 'Message rejected by hook.'
  },
  4403: {
    name: 'MESSAGE_OWNERSHIP_REQUIRED'
  },
  4404: {
    name: 'MESSAGE_NOT_FOUND'
  },
  4405: {
    name: 'MESSAGE_UPDATE_REJECTED_BY_APP',
    message: 'Message update rejected by hook.'
  },
  4406: {
    name: 'MESSAGE_EDIT_DISABLED'
  },
  4407: {
    name: 'MESSAGE_RECALL_DISABLED'
  },
  5130: {
    name: 'OWNER_PROMOTION_NOT_ALLOWED',
    message: "Updating a member's role to owner is not allowed."
  }
});
const ErrorCode = Object.freeze(Object.keys(error).reduce((result, code) => Object.assign(result, {
  [error[code].name]: Number(code)
}), {}));
const createError = ({
  code,
  reason,
  appCode,
  detail,
  error: errorMessage
}) => {
  let message = reason || detail || errorMessage;
  let name = reason;

  if (!message && error[code]) {
    ({
      name
    } = error[code]);
    message = error[code].message || name;
  }

  if (!message) {
    message = `Unknow Error: ${code}`;
  }

  const err = new Error(message);
  return Object.assign(err, {
    code,
    appCode,
    detail,
    name
  });
};

const debug$4 = d('LC:Connection');
const COMMAND_TIMEOUT = 20000;
const EXPIRE = Symbol('expire');

const isIdempotentCommand = command => !(command.cmd === CommandType.direct || command.cmd === CommandType.session && command.op === OpType.open || command.cmd === CommandType.conv && (command.op === OpType.start || command.op === OpType.update || command.op === OpType.members));
class Connection extends WebSocketPlus {
  constructor(getUrl, {
    format,
    version
  }) {
    debug$4('initializing Connection');
    const protocolString = `lc.${format}.${version}`;
    super(getUrl, protocolString);
    this._protocolFormat = format;
    this._commands = {};
    this._serialId = 0;
  }

  async send(command, waitingForRespond = true) {
    let buffer;
    let serialId;

    if (waitingForRespond) {
      if (isIdempotentCommand(command)) {
        buffer = command.toArrayBuffer();
        const duplicatedCommand = values(this._commands).find(({
          buffer: targetBuffer,
          command: targetCommand
        }) => targetCommand.cmd === command.cmd && targetCommand.op === command.op && equalBuffer(targetBuffer, buffer));

        if (duplicatedCommand) {
          console.warn(`Duplicated command [cmd:${command.cmd} op:${command.op}] is throttled.`);
          return duplicatedCommand.promise;
        }
      }

      this._serialId += 1;
      serialId = this._serialId;
      command.i = serialId; // eslint-disable-line no-param-reassign
    }

    if (debug$4.enabled) debug$4('↑ %O sent', trim(command));
    let message;

    if (this._protocolFormat === 'proto2base64') {
      message = command.toBase64();
    } else if (command.toArrayBuffer) {
      message = command.toArrayBuffer();
    }

    if (!message) {
      throw new TypeError(`${command} is not a GenericCommand`);
    }

    super.send(message);
    if (!waitingForRespond) return undefined;
    const promise = new Promise((resolve, reject) => {
      this._commands[serialId] = {
        command,
        buffer,
        resolve,
        reject,
        timeout: setTimeout(() => {
          if (this._commands[serialId]) {
            if (debug$4.enabled) debug$4('✗ %O timeout', trim(command));
            reject(createError({
              error: `Command Timeout [cmd:${command.cmd} op:${command.op}]`,
              name: 'COMMAND_TIMEOUT'
            }));
            delete this._commands[serialId];
          }
        }, COMMAND_TIMEOUT)
      };
    });
    this._commands[serialId].promise = promise;
    return promise;
  }

  handleMessage(msg) {
    let message;

    try {
      message = GenericCommand.decode(msg);
      if (debug$4.enabled) debug$4('↓ %O received', trim(message));
    } catch (e) {
      console.warn('Decode message failed:', e.message, msg);
      return;
    }

    const serialId = message.i;

    if (serialId) {
      if (this._commands[serialId]) {
        clearTimeout(this._commands[serialId].timeout);

        if (message.cmd === CommandType.error) {
          this._commands[serialId].reject(createError(message.errorMessage));
        } else {
          this._commands[serialId].resolve(message);
        }

        delete this._commands[serialId];
      } else {
        console.warn(`Unexpected command received with serialId [${serialId}],
         which have timed out or never been requested.`);
      }
    } else {
      switch (message.cmd) {
        case CommandType.error:
          {
            this.emit(ERROR, createError(message.errorMessage));
            return;
          }

        case CommandType.goaway:
          {
            this.emit(EXPIRE);
            return;
          }

        default:
          {
            this.emit(MESSAGE, message);
          }
      }
    }
  }

  ping() {
    return this.send(new GenericCommand({
      cmd: CommandType.echo
    })).catch(error => debug$4('ping failed:', error));
  }

}

const debug$5 = d('LC:request');
var request = (({
  method = 'GET',
  url: _url,
  query,
  headers,
  data,
  timeout: time
}) => {
  let url = _url;

  if (query) {
    const queryString = Object.keys(query).map(key => {
      const value = query[key];
      if (value === undefined) return undefined;
      const v = isPlainObject(value) ? JSON.stringify(value) : value;
      return `${encodeURIComponent(key)}=${encodeURIComponent(v)}`;
    }).filter(qs => qs).join('&');
    url = `${url}?${queryString}`;
  }

  debug$5('Req: %O %O %O', method, url, {
    headers,
    data
  });
  const request = getAdapter('request');
  const promise = request(url, {
    method,
    headers,
    data
  }).then(response => {
    if (response.ok === false) {
      const error = createError(response.data);
      error.response = response;
      throw error;
    }

    debug$5('Res: %O %O %O', url, response.status, response.data);
    return response.data;
  }).catch(error => {
    if (error.response) {
      debug$5('Error: %O %O %O', url, error.response.status, error.response.data);
    }

    throw error;
  });
  return time ? promiseTimeout.timeout(promise, time) : promise;
});

/* eslint-disable max-len */

const checkType = middleware => param => {
  const {
    constructor
  } = param;
  return Promise.resolve(param).then(middleware).then(tap(result => {
    if (result === undefined || result === null) {
      // eslint-disable-next-line max-len
      return console.warn(`Middleware[${middleware._pluginName || 'anonymous plugin'}:${middleware.name || 'anonymous middleware'}] param/return types not match. It returns ${result} while a ${param.constructor.name} expected.`);
    }

    if (!(result instanceof constructor)) {
      // eslint-disable-next-line max-len
      return console.warn(`Middleware[${middleware._pluginName || 'anonymous plugin'}:${middleware.name || 'anonymous middleware'}] param/return types not match. It returns a ${result.constructor.name} while a ${param.constructor.name} expected.`);
    }

    return 0;
  }));
};

const applyDecorators = (decorators, target) => {
  if (decorators) {
    decorators.forEach(decorator => {
      try {
        decorator(target);
      } catch (error) {
        if (decorator._pluginName) {
          error.message += `[${decorator._pluginName}]`;
        }

        throw error;
      }
    });
  }
};
const applyMiddlewares = middlewares => target => ensureArray(middlewares).reduce((previousPromise, middleware) => previousPromise.then(checkType(middleware)).catch(error => {
  if (middleware._pluginName) {
    // eslint-disable-next-line no-param-reassign
    error.message += `[${middleware._pluginName}]`;
  }

  throw error;
}), Promise.resolve(target));
const applyDispatcher = (dispatchers, payload) => ensureArray(dispatchers).reduce((resultPromise, dispatcher) => resultPromise.then(shouldDispatch => shouldDispatch === false ? false : dispatcher(...payload)).catch(error => {
  if (dispatcher._pluginName) {
    // eslint-disable-next-line no-param-reassign
    error.message += `[${dispatcher._pluginName}]`;
  }

  throw error;
}), Promise.resolve(true));

var version = "5.0.0-rc.7";

// eslint-disable-next-line max-classes-per-file
const debug$6 = d('LC:Realtime');
const routerCache = new Cache('push-router');
const initializedApp = {};
class Realtime extends EventEmitter {
  /**
   * @extends EventEmitter
   * @param  {Object} options
   * @param  {String} options.appId
   * @param  {String} options.appKey （since 4.0.0）
   * @param  {String|Object} [options.server] 指定服务器域名，中国节点应用此参数必填（since 4.0.0）
   * @param  {Boolean} [options.noBinary=false] 设置 WebSocket 使用字符串格式收发消息（默认为二进制格式）。
   *                                            适用于 WebSocket 实现不支持二进制数据格式的情况
   * @param  {Boolean} [options.ssl=true] 使用 wss 进行连接
   * @param  {String|String[]} [options.RTMServers] 指定私有部署的 RTM 服务器地址（since 4.0.0）
   * @param  {Plugin[]} [options.plugins] 加载插件（since 3.1.0）
   */
  constructor({
    plugins,
    ...options
  }) {
    debug$6('initializing Realtime %s %O', version, options);
    super();
    const {
      appId
    } = options;

    if (typeof appId !== 'string') {
      throw new TypeError(`appId [${appId}] is not a string`);
    }

    if (initializedApp[appId]) {
      throw new Error(`App [${appId}] is already initialized.`);
    }

    initializedApp[appId] = true;

    if (typeof options.appKey !== 'string') {
      throw new TypeError(`appKey [${options.appKey}] is not a string`);
    }

    if (isCNApp(appId)) {
      if (!options.server) {
        throw new TypeError(`server option is required for apps from CN region`);
      }
    }

    this._options = {
      appId: undefined,
      appKey: undefined,
      noBinary: false,
      ssl: true,
      RTMServerName: typeof process !== 'undefined' ? process.env.RTM_SERVER_NAME : undefined,
      // undocumented on purpose, internal use only
      ...options
    };
    this._cache = new Cache('endpoints');

    const _this = internal(this);

    _this.clients = new Set();
    _this.pendingClients = new Set();
    const mergedPlugins = [...ensureArray(Realtime.__preRegisteredPlugins), ...ensureArray(plugins)];
    debug$6('Using plugins %o', mergedPlugins.map(plugin => plugin.name));
    this._plugins = mergedPlugins.reduce((result, plugin) => {
      Object.keys(plugin).forEach(hook => {
        if ({}.hasOwnProperty.call(plugin, hook) && hook !== 'name') {
          if (plugin.name) {
            ensureArray(plugin[hook]).forEach(value => {
              // eslint-disable-next-line no-param-reassign
              value._pluginName = plugin.name;
            });
          } // eslint-disable-next-line no-param-reassign


          result[hook] = ensureArray(result[hook]).concat(plugin[hook]);
        }
      });
      return result;
    }, {}); // onRealtimeCreate hook

    applyDecorators(this._plugins.onRealtimeCreate, this);
  }

  async _request({
    method,
    url: _url,
    version = '1.1',
    path,
    query,
    headers,
    data
  }) {
    let url = _url;

    if (!url) {
      const {
        appId,
        server
      } = this._options;
      const {
        api
      } = await this.constructor._getServerUrls({
        appId,
        server
      });
      url = `${api}/${version}${path}`;
    }

    return request({
      url,
      method,
      query,
      headers: {
        'X-LC-Id': this._options.appId,
        'X-LC-Key': this._options.appKey,
        ...headers
      },
      data
    });
  }

  _open() {
    if (this._openPromise) return this._openPromise;
    let format = 'protobuf2';

    if (this._options.noBinary) {
      // 不发送 binary data，fallback to base64 string
      format = 'proto2base64';
    }

    const version = 3;
    const protocol = {
      format,
      version
    };
    this._openPromise = new Promise((resolve, reject) => {
      debug$6('No connection established, create a new one.');
      const connection = new Connection(() => this._getRTMServers(this._options), protocol);
      connection.on(OPEN, () => resolve(connection)).on(ERROR, error => {
        delete this._openPromise;
        reject(error);
      }).on(EXPIRE, async () => {
        debug$6('Connection expired. Refresh endpoints.');

        this._cache.set('endpoints', null, 0);

        connection.urls = await this._getRTMServers(this._options);
        connection.disconnect();
      }).on(MESSAGE, this._dispatchCommand.bind(this));
      /**
       * 连接断开。
       * 连接断开可能是因为 SDK 进入了离线状态（see {@link Realtime#event:OFFLINE}），或长时间没有收到服务器心跳。
       * 连接断开后所有的网络操作都会失败，请在连接断开后禁用相关的 UI 元素。
       * @event Realtime#DISCONNECT
       */

      /**
       * 计划在一段时间后尝试重新连接
       * @event Realtime#SCHEDULE
       * @param {Number} attempt 尝试重连的次数
       * @param {Number} delay 延迟的毫秒数
       */

      /**
       * 正在尝试重新连接
       * @event Realtime#RETRY
       * @param {Number} attempt 尝试重连的次数
       */

      /**
       * 连接恢复正常。
       * 请重新启用在 {@link Realtime#event:DISCONNECT} 事件中禁用的相关 UI 元素
       * @event Realtime#RECONNECT
       */

      /**
       * 客户端连接断开
       * @event IMClient#DISCONNECT
       * @see Realtime#event:DISCONNECT
       * @since 3.2.0
       */

      /**
       * 计划在一段时间后尝试重新连接
       * @event IMClient#SCHEDULE
       * @param {Number} attempt 尝试重连的次数
       * @param {Number} delay 延迟的毫秒数
       * @since 3.2.0
       */

      /**
       * 正在尝试重新连接
       * @event IMClient#RETRY
       * @param {Number} attempt 尝试重连的次数
       * @since 3.2.0
       */

      /**
       * 客户端进入离线状态。
       * 这通常意味着网络已断开，或者 {@link Realtime#pause} 被调用
       * @event Realtime#OFFLINE
       * @since 3.4.0
       */

      /**
       * 客户端恢复在线状态
       * 这通常意味着网络已恢复，或者 {@link Realtime#resume} 被调用
       * @event Realtime#ONLINE
       * @since 3.4.0
       */

      /**
       * 进入离线状态。
       * 这通常意味着网络已断开，或者 {@link Realtime#pause} 被调用
       * @event IMClient#OFFLINE
       * @since 3.4.0
       */

      /**
       * 恢复在线状态
       * 这通常意味着网络已恢复，或者 {@link Realtime#resume} 被调用
       * @event IMClient#ONLINE
       * @since 3.4.0
       */
      // event proxy

      [DISCONNECT, RECONNECT, RETRY, SCHEDULE, OFFLINE, ONLINE].forEach(event => connection.on(event, (...payload) => {
        debug$6(`${event} event emitted. %o`, payload);
        this.emit(event, ...payload);

        if (event !== RECONNECT) {
          internal(this).clients.forEach(client => {
            client.emit(event, ...payload);
          });
        }
      })); // override handleClose

      connection.handleClose = function handleClose(event) {
        const isFatal = [ErrorCode.APP_NOT_AVAILABLE, ErrorCode.INVALID_LOGIN, ErrorCode.INVALID_ORIGIN].some(errorCode => errorCode === event.code);

        if (isFatal) {
          // in these cases, SDK should throw.
          this.throw(createError(event));
        } else {
          // reconnect
          this.disconnect();
        }
      };

      internal(this).connection = connection;
    });
    return this._openPromise;
  }

  async _getRTMServers(options) {
    if (options.RTMServers) return shuffle(ensureArray(options.RTMServers));
    let info;

    const cachedEndPoints = this._cache.get('endpoints');

    if (cachedEndPoints) {
      info = cachedEndPoints;
    } else {
      info = await this.constructor._fetchRTMServers(options);
      const {
        server,
        secondary,
        ttl
      } = info;

      if (typeof server !== 'string' && typeof secondary !== 'string' && typeof ttl !== 'number') {
        throw new Error(`malformed RTM route response: ${JSON.stringify(info)}`);
      }

      this._cache.set('endpoints', info, info.ttl * 1000);
    }

    debug$6('endpoint info: %O', info);
    return [info.server, info.secondary];
  }

  static async _getServerUrls({
    appId,
    server
  }) {
    debug$6('fetch server urls');

    if (server) {
      if (typeof server !== 'string') return server;
      return {
        RTMRouter: server,
        api: server
      };
    }

    const cachedRouter = routerCache.get(appId);
    if (cachedRouter) return cachedRouter;
    const defaultProtocol = 'https://';
    return request({
      url: 'https://app-router.com/2/route',
      query: {
        appId
      },
      timeout: 20000
    }).then(tap(debug$6)).then(({
      rtm_router_server: RTMRouterServer,
      api_server: APIServer,
      ttl = 3600
    }) => {
      if (!RTMRouterServer) {
        throw new Error('rtm router not exists');
      }

      const serverUrls = {
        RTMRouter: `${defaultProtocol}${RTMRouterServer}`,
        api: `${defaultProtocol}${APIServer}`
      };
      routerCache.set(appId, serverUrls, ttl * 1000);
      return serverUrls;
    }).catch(() => {
      const id = appId.slice(0, 8).toLowerCase();
      const domain = 'lncldglobal.com';
      return {
        RTMRouter: `${defaultProtocol}${id}.rtm.${domain}`,
        api: `${defaultProtocol}${id}.api.${domain}`
      };
    });
  }

  static _fetchRTMServers({
    appId,
    ssl,
    server,
    RTMServerName
  }) {
    debug$6('fetch endpoint info');
    return this._getServerUrls({
      appId,
      server
    }).then(tap(debug$6)).then(({
      RTMRouter
    }) => request({
      url: `${RTMRouter}/v1/route`,
      query: {
        appId,
        secure: ssl,
        features: isWeapp ? 'wechat' : undefined,
        server: RTMServerName,
        _t: Date.now()
      },
      timeout: 20000
    }).then(tap(debug$6)));
  }

  _close() {
    if (this._openPromise) {
      this._openPromise.then(connection => connection.close());
    }

    delete this._openPromise;
  }
  /**
   * 手动进行重连。
   * SDK 在网络出现异常时会自动按照一定的时间间隔尝试重连，调用该方法会立即尝试重连并重置重连尝试计数器。
   * 只能在 `SCHEDULE` 事件之后，`RETRY` 事件之前调用，如果当前网络正常或者正在进行重连，调用该方法会抛异常。
   */


  retry() {
    const {
      connection
    } = internal(this);

    if (!connection) {
      throw new Error('no connection established');
    }

    if (connection.cannot('retry')) {
      throw new Error(`retrying not allowed when not disconnected. the connection is now ${connection.current}`);
    }

    return connection.retry();
  }
  /**
   * 暂停，使 SDK 进入离线状态。
   * 你可以在网络断开、应用进入后台等时刻调用该方法让 SDK 进入离线状态，离线状态下不会尝试重连。
   * 在浏览器中 SDK 会自动监听网络变化，因此无需手动调用该方法。
   *
   * @since 3.4.0
   * @see Realtime#event:OFFLINE
   */


  pause() {
    // 这个方法常常在网络断开、进入后台时被调用，此时 connection 可能没有建立或者已经 close。
    // 因此不像 retry，这个方法应该尽可能 loose
    const {
      connection
    } = internal(this);
    if (!connection) return;
    if (connection.can('pause')) connection.pause();
  }
  /**
   * 恢复在线状态。
   * 你可以在网络恢复、应用回到前台等时刻调用该方法让 SDK 恢复在线状态，恢复在线状态后 SDK 会开始尝试重连。
   *
   * @since 3.4.0
   * @see Realtime#event:ONLINE
   */


  resume() {
    // 与 pause 一样，这个方法应该尽可能 loose
    const {
      connection
    } = internal(this);
    if (!connection) return;
    if (connection.can('resume')) connection.resume();
  }

  _registerPending(value) {
    internal(this).pendingClients.add(value);
  }

  _deregisterPending(client) {
    internal(this).pendingClients.delete(client);
  }

  _register(client) {
    internal(this).clients.add(client);
  }

  _deregister(client) {
    const _this = internal(this);

    _this.clients.delete(client);

    if (_this.clients.size + _this.pendingClients.size === 0) {
      this._close();
    }
  }

  _dispatchCommand(command) {
    return applyDispatcher(this._plugins.beforeCommandDispatch, [command, this]).then(shouldDispatch => {
      // no plugin handled this command
      if (shouldDispatch) return debug$6('[WARN] Unexpected message received: %O', trim(command));
      return false;
    });
  }

} // For test purpose only

const polyfilledPromise = Promise;

// IMClient
const UNREAD_MESSAGES_COUNT_UPDATE = 'unreadmessagescountupdate';
const CLOSE = 'close';
const CONFLICT = 'conflict';
const CONVERSATION_INFO_UPDATED = 'conversationinfoupdated';
const UNHANDLED_MESSAGE = 'unhandledmessage'; // shared

const INVITED = 'invited';
const KICKED = 'kicked';
const MEMBERS_JOINED = 'membersjoined';
const MEMBERS_LEFT = 'membersleft';
const MEMBER_INFO_UPDATED = 'memberinfoupdated';
const BLOCKED = 'blocked';
const UNBLOCKED = 'unblocked';
const MEMBERS_BLOCKED = 'membersblocked';
const MEMBERS_UNBLOCKED = 'membersunblocked';
const MUTED = 'muted';
const UNMUTED = 'unmuted';
const MEMBERS_MUTED = 'membersmuted';
const MEMBERS_UNMUTED = 'membersunmuted';
const MESSAGE$1 = 'message';
const MESSAGE_RECALL = 'messagerecall';
const MESSAGE_UPDATE = 'messageupdate'; // Conversation

const LAST_DELIVERED_AT_UPDATE = 'lastdeliveredatupdate';
const LAST_READ_AT_UPDATE = 'lastreadatupdate';
const INFO_UPDATED = 'infoupdated';

var IMEvent = /*#__PURE__*/Object.freeze({
  __proto__: null,
  UNREAD_MESSAGES_COUNT_UPDATE: UNREAD_MESSAGES_COUNT_UPDATE,
  CLOSE: CLOSE,
  CONFLICT: CONFLICT,
  CONVERSATION_INFO_UPDATED: CONVERSATION_INFO_UPDATED,
  UNHANDLED_MESSAGE: UNHANDLED_MESSAGE,
  INVITED: INVITED,
  KICKED: KICKED,
  MEMBERS_JOINED: MEMBERS_JOINED,
  MEMBERS_LEFT: MEMBERS_LEFT,
  MEMBER_INFO_UPDATED: MEMBER_INFO_UPDATED,
  BLOCKED: BLOCKED,
  UNBLOCKED: UNBLOCKED,
  MEMBERS_BLOCKED: MEMBERS_BLOCKED,
  MEMBERS_UNBLOCKED: MEMBERS_UNBLOCKED,
  MUTED: MUTED,
  UNMUTED: UNMUTED,
  MEMBERS_MUTED: MEMBERS_MUTED,
  MEMBERS_UNMUTED: MEMBERS_UNMUTED,
  MESSAGE: MESSAGE$1,
  MESSAGE_RECALL: MESSAGE_RECALL,
  MESSAGE_UPDATE: MESSAGE_UPDATE,
  LAST_DELIVERED_AT_UPDATE: LAST_DELIVERED_AT_UPDATE,
  LAST_READ_AT_UPDATE: LAST_READ_AT_UPDATE,
  INFO_UPDATED: INFO_UPDATED
});

/**
 * 消息状态枚举
 * @enum {Symbol}
 * @since 3.2.0
 * @memberof module:leancloud-realtime
 */

const MessageStatus = {
  /** 初始状态、未知状态 */
  NONE: Symbol('none'),

  /** 正在发送 */
  SENDING: Symbol('sending'),

  /** 已发送 */
  SENT: Symbol('sent'),

  /** 已送达 */
  DELIVERED: Symbol('delivered'),

  /** 发送失败 */
  FAILED: Symbol('failed')
};
Object.freeze(MessageStatus);
const rMessageStatus = {
  [MessageStatus.NONE]: true,
  [MessageStatus.SENDING]: true,
  [MessageStatus.SENT]: true,
  [MessageStatus.DELIVERED]: true,
  [MessageStatus.READ]: true,
  [MessageStatus.FAILED]: true
};
class Message {
  /**
   * @implements AVMessage
   * @param  {Object|String|ArrayBuffer} content 消息内容
   */
  constructor(content) {
    Object.assign(this, {
      content
    }, {
      /**
       * @type {String}
       * @memberof Message#
       */
      id: uuid(),

      /**
       * 消息所在的 conversation id
       * @memberof Message#
       * @type {String?}
       */
      cid: null,

      /**
       * 消息发送时间
       * @memberof Message#
       * @type {Date}
       */
      timestamp: new Date(),

      /**
       * 消息发送者
       * @memberof Message#
       * @type {String}
       */
      from: undefined,

      /**
       * 消息提及的用户
       * @since 4.0.0
       * @memberof Message#
       * @type {String[]}
       */
      mentionList: [],

      /**
       * 消息是否提及了所有人
       * @since 4.0.0
       * @memberof Message#
       * @type {Boolean}
       */
      mentionedAll: false,
      _mentioned: false
    });

    this._setStatus(MessageStatus.NONE);
  }
  /**
   * 将当前消息的内容序列化为 JSON 对象
   * @private
   * @return {Object}
   */


  getPayload() {
    return this.content;
  }

  _toJSON() {
    const {
      id,
      cid,
      from,
      timestamp,
      deliveredAt,
      updatedAt,
      mentionList,
      mentionedAll,
      mentioned
    } = this;
    return {
      id,
      cid,
      from,
      timestamp,
      deliveredAt,
      updatedAt,
      mentionList,
      mentionedAll,
      mentioned
    };
  }
  /**
   * 返回 JSON 格式的消息
   * @return {Object} 返回值是一个 plain Object
   */


  toJSON() {
    return { ...this._toJSON(),
      data: this.content
    };
  }
  /**
   * 返回 JSON 格式的消息，与 toJSON 不同的是，该对象包含了完整的信息，可以通过 {@link IMClient#parseMessage} 反序列化。
   * @return {Object} 返回值是一个 plain Object
   * @since 4.0.0
   */


  toFullJSON() {
    const {
      content,
      id,
      cid,
      from,
      timestamp,
      deliveredAt,
      _updatedAt,
      mentionList,
      mentionedAll
    } = this;
    return {
      data: content,
      id,
      cid,
      from,
      timestamp: getTime(timestamp),
      deliveredAt: getTime(deliveredAt),
      updatedAt: getTime(_updatedAt),
      mentionList,
      mentionedAll
    };
  }
  /**
   * 消息状态，值为 {@link module:leancloud-realtime.MessageStatus} 之一
   * @type {Symbol}
   * @readonly
   * @since 3.2.0
   */


  get status() {
    return this._status;
  }

  _setStatus(status) {
    if (!rMessageStatus[status]) {
      throw new Error('Invalid message status');
    }

    this._status = status;
  }

  get timestamp() {
    return this._timestamp;
  }

  set timestamp(value) {
    this._timestamp = decodeDate(value);
  }
  /**
   * 消息送达时间
   * @type {?Date}
   */


  get deliveredAt() {
    return this._deliveredAt;
  }

  set deliveredAt(value) {
    this._deliveredAt = decodeDate(value);
  }
  /**
   * 消息修改或撤回时间，可以通过比较其与消息的 timestamp 是否相等判断消息是否被修改过或撤回过。
   * @type {Date}
   * @since 3.5.0
   */


  get updatedAt() {
    return this._updatedAt || this.timestamp;
  }

  set updatedAt(value) {
    this._updatedAt = decodeDate(value);
  }
  /**
   * 当前用户是否在该消息中被提及
   * @type {Boolean}
   * @readonly
   * @since 4.0.0
   */


  get mentioned() {
    return this._mentioned;
  }

  _updateMentioned(client) {
    this._mentioned = this.from !== client && (this.mentionedAll || this.mentionList.indexOf(client) > -1);
  }
  /**
   * 获取提及用户列表
   * @since 4.0.0
   * @return {String[]} 提及用户的 id 列表
   */


  getMentionList() {
    return this.mentionList;
  }
  /**
   * 设置提及用户列表
   * @since 4.0.0
   * @param {String[]} clients 提及用户的 id 列表
   * @return {this} self
   */


  setMentionList(clients) {
    this.mentionList = ensureArray(clients);
    return this;
  }
  /**
   * 设置是否提及所有人
   * @since 4.0.0
   * @param {Boolean} [value=true]
   * @return {this} self
   */


  mentionAll(value = true) {
    this.mentionedAll = Boolean(value);
    return this;
  }
  /**
   * 判断给定的内容是否是有效的 Message，
   * 该方法始终返回 true
   * @private
   * @returns {Boolean}
   * @implements AVMessage.validate
   */


  static validate() {
    return true;
  }
  /**
   * 解析处理消息内容
   * <pre>
   * 如果子类提供了 message，返回该 message
   * 如果没有提供，将 json 作为 content 实例化一个 Message
   * @private
   * @param  {Object}  json    json 格式的消息内容
   * @param  {Message} message 子类提供的 message
   * @return {Message}
   * @implements AVMessage.parse
   */


  static parse(json, message) {
    return message || new this(json);
  }

}

/* eslint-disable no-param-reassign */

const messageType = type => {
  if (typeof type !== 'number') {
    throw new TypeError(`${type} is not a Number`);
  }

  return target => {
    target.TYPE = type;

    target.validate = json => json._lctype === type;

    target.prototype._getType = () => ({
      _lctype: type
    });
  };
}; // documented in ../plugin-im.js

const messageField = fields => {
  if (typeof fields !== 'string') {
    if (!Array.isArray(fields)) {
      throw new TypeError(`${fields} is not an Array`);
    } else if (fields.some(value => typeof value !== 'string')) {
      throw new TypeError('fields contains non-string typed member');
    }
  }

  return target => {
    // IE10 Hack:
    // static properties in IE10 will not be inherited from super
    // search for parse method and assign it manually
    let originalCustomFields = isIE10 ? getStaticProperty(target, '_customFields') : target._customFields;
    originalCustomFields = Array.isArray(originalCustomFields) ? originalCustomFields : [];
    target._customFields = originalCustomFields.concat(fields);
  };
}; // IE10 Hack:
// static properties in IE10 will not be inherited from super
// search for parse method and assign it manually

const IE10Compatible = target => {
  if (isIE10) {
    target.parse = getStaticProperty(target, 'parse');
  }
};

var _dec, _class$1;

let // jsdoc-ignore-end

/**
 * 所有内置的富媒体消息均继承自本类
 * @extends Message
 */
TypedMessage = (_dec = messageField(['_lctext', '_lcattrs']), _dec(_class$1 = class TypedMessage extends Message {
  /**
   * @type {Number}
   * @readonly
   */
  get type() {
    return this.constructor.TYPE;
  }
  /** @type {String} */


  set text(text) {
    return this.setText(text);
  }

  get text() {
    return this.getText();
  }
  /** @type {Object} */


  set attributes(attributes) {
    return this.setAttributes(attributes);
  }

  get attributes() {
    return this.getAttributes();
  }
  /**
   * 在客户端需要以文本形式展示该消息时显示的文案，
   * 如 <code>[红包] 新春快乐</code>。
   * 默认值为消息的 text。
   * @type {String}
   * @readonly
   */


  get summary() {
    return this.text;
  }
  /**
   * @param {String} text
   * @return {this} self
   */


  setText(text) {
    this._lctext = text;
    return this;
  }
  /**
   * @return {String}
   */


  getText() {
    return this._lctext;
  }
  /**
   * @param {Object} attributes
   * @return {this} self
   */


  setAttributes(attributes) {
    this._lcattrs = attributes;
    return this;
  }
  /**
   * @return {Object}
   */


  getAttributes() {
    return this._lcattrs;
  }

  _getCustomFields() {
    const fields = Array.isArray(this.constructor._customFields) ? this.constructor._customFields : [];
    return fields.reduce((result, field) => {
      if (typeof field !== 'string') return result;
      result[field] = this[field]; // eslint-disable-line no-param-reassign

      return result;
    }, {});
  }
  /* eslint-disable class-methods-use-this */


  _getType() {
    throw new Error('not implemented');
  }
  /* eslint-enable class-methods-use-this */


  getPayload() {
    return compact({
      _lctext: this.getText(),
      _lcattrs: this.getAttributes(),
      ...this._getCustomFields(),
      ...this._getType()
    });
  }

  toJSON() {
    const {
      type,
      text,
      attributes,
      summary
    } = this;
    return { ...super._toJSON(),
      type,
      text,
      attributes,
      summary
    };
  }

  toFullJSON() {
    return { ...super.toFullJSON(),
      data: this.getPayload()
    };
  }
  /**
   * 解析处理消息内容
   * <pre>
   * 为给定的 message 设置 text 与 attributes 属性，返回该 message
   * 如果子类没有提供 message，new this()
   * @protected
   * @param  {Object}  json    json 格式的消息内容
   * @param  {TypedMessage} message 子类提供的 message
   * @return {TypedMessage}
   * @implements AVMessage.parse
   */


  static parse(json, message = new this()) {
    message.content = json; // eslint-disable-line no-param-reassign

    const customFields = isIE10 ? getStaticProperty(message.constructor, '_customFields') : message.constructor._customFields;
    let fields = Array.isArray(customFields) ? customFields : [];
    fields = fields.reduce((result, field) => {
      if (typeof field !== 'string') return result;
      result[field] = json[field]; // eslint-disable-line no-param-reassign

      return result;
    }, {});
    Object.assign(message, fields);
    return super.parse(json, message);
  }

}) || _class$1);

var _dec$1, _class$2;

let // jsdoc-ignore-end

/**
 * 已撤回类型消息，当消息被撤回时，SDK 会使用该类型的消息替代原始消息
 * @extends TypedMessage
 */
RecalledMessage = (_dec$1 = messageType(-127), _dec$1(_class$2 = IE10Compatible(_class$2 = class RecalledMessage extends TypedMessage {
  /**
   * 在客户端需要以文本形式展示该消息时显示的文案，值为 <code>[该消息已撤回]</code>
   * @type {String}
   * @readonly
   */
  // eslint-disable-next-line class-methods-use-this
  get summary() {
    return '[该消息已撤回]';
  }

}) || _class$2) || _class$2);

/* eslint class-methods-use-this: ["error", { "exceptMethods": ["_addMembers", "_removeMembers"] }] */
const debug$7 = d('LC:Conversation');

const serializeMessage = message => {
  const content = message.getPayload();
  let msg;
  let binaryMsg;

  if (content instanceof ArrayBuffer) {
    binaryMsg = content;
  } else if (typeof content !== 'string') {
    msg = JSON.stringify(content);
  } else {
    msg = content;
  }

  return {
    msg,
    binaryMsg
  };
};

const {
  NEW,
  OLD
} = LogsCommand.QueryDirection;
/**
 * 历史消息查询方向枚举
 * @enum {Number}
 * @since 4.0.0
 * @memberof module:leancloud-realtime
 */

const MessageQueryDirection = {
  /** 从后向前 */
  NEW_TO_OLD: OLD,

  /** 从前向后 */
  OLD_TO_NEW: NEW
};
Object.freeze(MessageQueryDirection);
class ConversationBase extends EventEmitter {
  /**
   * @extends EventEmitter
   * @private
   * @abstract
   */
  constructor({
    id,
    lastMessageAt,
    lastMessage,
    lastDeliveredAt,
    lastReadAt,
    unreadMessagesCount = 0,
    members = [],
    mentioned = false,
    ...properties
  }, client) {
    super();
    Object.assign(this, {
      /**
       * 对话 id，对应 _Conversation 表中的 objectId
       * @memberof ConversationBase#
       * @type {String}
       */
      id,

      /**
       * 最后一条消息时间
       * @memberof ConversationBase#
       * @type {?Date}
       */
      lastMessageAt,

      /**
       * 最后一条消息
       * @memberof ConversationBase#
       * @type {?Message}
       */
      lastMessage,

      /**
       * 参与该对话的用户列表
       * @memberof ConversationBase#
       * @type {String[]}
       */
      members,
      // other properties provided by subclasses
      ...properties
    });
    this.members = Array.from(new Set(this.members));
    Object.assign(internal(this), {
      messagesWaitingForReceipt: {},
      lastDeliveredAt,
      lastReadAt,
      unreadMessagesCount,
      mentioned
    });
    this._client = client;

    if (debug$7.enabled) {
      values(IMEvent).forEach(event => this.on(event, (...payload) => this._debug(`${event} event emitted. %o`, payload)));
    } // onConversationCreate hook


    applyDecorators(this._client._plugins.onConversationCreate, this);
  }
  /**
   * 当前用户是否在该对话的未读消息中被提及
   * @type {Boolean}
   * @since 4.0.0
   */


  get unreadMessagesMentioned() {
    return internal(this).unreadMessagesMentioned;
  }

  _setUnreadMessagesMentioned(value) {
    internal(this).unreadMessagesMentioned = Boolean(value);
  }

  set unreadMessagesCount(value) {
    if (value !== this.unreadMessagesCount) {
      internal(this).unreadMessagesCount = value;

      this._client.emit(UNREAD_MESSAGES_COUNT_UPDATE, [this]);
    }
  }
  /**
   * 当前用户在该对话的未读消息数
   * @type {Number}
   */


  get unreadMessagesCount() {
    return internal(this).unreadMessagesCount;
  }

  set lastMessageAt(value) {
    const time = decodeDate(value);
    if (time <= this._lastMessageAt) return;
    this._lastMessageAt = time;
  }

  get lastMessageAt() {
    return this._lastMessageAt;
  }
  /**
   * 最后消息送达时间，常用来实现消息的「已送达」标记，可通过 {@link Conversation#fetchReceiptTimestamps} 获取或更新该属性
   * @type {?Date}
   * @since 3.4.0
   */


  get lastDeliveredAt() {
    if (this.members.length !== 2) return null;
    return internal(this).lastDeliveredAt;
  }

  _setLastDeliveredAt(value) {
    const date = decodeDate(value);

    if (!(date < internal(this).lastDeliveredAt)) {
      internal(this).lastDeliveredAt = date;
      /**
       * 最后消息送达时间更新
       * @event ConversationBase#LAST_DELIVERED_AT_UPDATE
       * @since 3.4.0
       */

      this.emit(LAST_DELIVERED_AT_UPDATE);
    }
  }
  /**
   * 最后消息被阅读时间，常用来实现发送消息的「已读」标记，可通过 {@link Conversation#fetchReceiptTimestamps} 获取或更新该属性
   * @type {?Date}
   * @since 3.4.0
   */


  get lastReadAt() {
    if (this.members.length !== 2) return null;
    return internal(this).lastReadAt;
  }

  _setLastReadAt(value) {
    const date = decodeDate(value);

    if (!(date < internal(this).lastReadAt)) {
      internal(this).lastReadAt = date;
      /**
       * 最后消息被阅读时间更新
       * @event ConversationBase#LAST_READ_AT_UPDATE
       * @since 3.4.0
       */

      this.emit(LAST_READ_AT_UPDATE);
    }
  }
  /**
   * 返回 JSON 格式的对话，与 toJSON 不同的是，该对象包含了完整的信息，可以通过 {@link IMClient#parseConversation} 反序列化。
   * @return {Object} 返回值是一个 plain Object
   * @since 4.0.0
   */


  toFullJSON() {
    const {
      id,
      members,
      lastMessageAt,
      lastDeliveredAt,
      lastReadAt,
      lastMessage,
      unreadMessagesCount
    } = this;
    return {
      id,
      members,
      lastMessageAt: getTime(lastMessageAt),
      lastDeliveredAt: getTime(lastDeliveredAt),
      lastReadAt: getTime(lastReadAt),
      lastMessage: lastMessage ? lastMessage.toFullJSON() : undefined,
      unreadMessagesCount
    };
  }
  /**
   * 返回 JSON 格式的对话
   * @return {Object} 返回值是一个 plain Object
   * @since 4.0.0
   */


  toJSON() {
    const {
      id,
      members,
      lastMessageAt,
      lastDeliveredAt,
      lastReadAt,
      lastMessage,
      unreadMessagesCount,
      unreadMessagesMentioned
    } = this;
    return {
      id,
      members,
      lastMessageAt,
      lastDeliveredAt,
      lastReadAt,
      lastMessage: lastMessage ? lastMessage.toJSON() : undefined,
      unreadMessagesCount,
      unreadMessagesMentioned
    };
  }

  _debug(...params) {
    debug$7(...params, `[${this.id}]`);
  }

  _send(command, ...args) {
    /* eslint-disable no-param-reassign */
    if (command.cmd === null) {
      command.cmd = 'conv';
    }

    if (command.cmd === 'conv' && command.convMessage === null) {
      command.convMessage = new ConvCommand();
    }

    if (command.convMessage && command.convMessage.cid === null) {
      command.convMessage.cid = this.id;
    }
    /* eslint-enable no-param-reassign */


    return this._client._send(command, ...args);
  }
  /**
   * 发送消息
   * @param  {Message} message 消息，Message 及其子类的实例
   * @param {Object} [options] since v3.3.0，发送选项
   * @param {Boolean} [options.transient] since v3.3.1，是否作为暂态消息发送
   * @param {Boolean} [options.receipt] 是否需要回执，仅在普通对话中有效
   * @param {Boolean} [options.will] since v3.4.0，是否指定该消息作为「掉线消息」发送，
   * 「掉线消息」会延迟到当前用户掉线后发送，常用来实现「下线通知」功能
   * @param {MessagePriority} [options.priority] 消息优先级，仅在暂态对话中有效，
   * see: {@link module:leancloud-realtime.MessagePriority MessagePriority}
   * @param {Object} [options.pushData] 消息对应的离线推送内容，如果消息接收方不在线，会推送指定的内容。其结构说明参见: {@link https://url.leanapp.cn/pushData 推送消息内容}
   * @return {Promise.<Message>} 发送的消息
   */


  async send(message, options) {
    this._debug(message, 'send');

    if (!(message instanceof Message)) {
      throw new TypeError(`${message} is not a Message`);
    }

    const {
      transient,
      receipt,
      priority,
      pushData,
      will
    } = { // support Message static property: sendOptions
      ...message.constructor.sendOptions,
      // support Message static property: getSendOptions
      ...(typeof message.constructor.getSendOptions === 'function' ? message.constructor.getSendOptions(message) : {}),
      ...options
    };

    if (receipt) {
      if (this.transient) {
        console.warn('receipt option is ignored as the conversation is transient.');
      } else if (transient) {
        console.warn('receipt option is ignored as the message is sent transiently.');
      } else if (this.members.length > 2) {
        console.warn('receipt option is recommended to be used in one-on-one conversation.'); // eslint-disable-line max-len
      }
    }

    if (priority && !this.transient) {
      console.warn('priority option is ignored as the conversation is not transient.');
    }

    Object.assign(message, {
      cid: this.id,
      from: this._client.id
    });

    message._setStatus(MessageStatus.SENDING);

    const {
      msg,
      binaryMsg
    } = serializeMessage(message);
    const command = new GenericCommand({
      cmd: 'direct',
      directMessage: new DirectCommand({
        msg,
        binaryMsg,
        cid: this.id,
        r: receipt,
        transient,
        dt: message.id,
        pushData: JSON.stringify(pushData),
        will,
        mentionPids: message.mentionList,
        mentionAll: message.mentionedAll
      }),
      priority
    });

    try {
      const resCommand = await this._send(command);
      const {
        ackMessage: {
          uid,
          t,
          code,
          reason,
          appCode
        }
      } = resCommand;

      if (code !== null) {
        throw createError({
          code,
          reason,
          appCode
        });
      }

      Object.assign(message, {
        id: uid,
        timestamp: t
      });

      if (!transient) {
        this.lastMessage = message;
        this.lastMessageAt = message.timestamp;
      }

      message._setStatus(MessageStatus.SENT);

      if (receipt) {
        internal(this).messagesWaitingForReceipt[message.id] = message;
      }

      return message;
    } catch (error) {
      message._setStatus(MessageStatus.FAILED);

      throw error;
    }
  }

  async _update(message, newMessage, recall) {
    this._debug('patch %O %O %O', message, newMessage, recall);

    if (message instanceof Message) {
      if (message.from !== this._client.id) {
        throw new Error('Updating message from others is not allowed');
      }

      if (message.status !== MessageStatus.SENT && message.status !== MessageStatus.DELIVERED) {
        throw new Error('Message is not sent');
      }
    } else if (!(message.id && message.timestamp)) {
      throw new TypeError(`${message} is not a Message`);
    }

    let msg;
    let binaryMsg;

    if (!recall) {
      const content = serializeMessage(newMessage);
      ({
        msg,
        binaryMsg
      } = content);
    }

    await this._send(new GenericCommand({
      cmd: CommandType.patch,
      op: OpType.modify,
      patchMessage: new PatchCommand({
        patches: [new PatchItem({
          cid: this.id,
          mid: message.id,
          timestamp: Number(message.timestamp),
          recall,
          data: msg,
          binaryMsg,
          mentionPids: newMessage.mentionList,
          mentionAll: newMessage.mentionedAll
        })],
        lastPatchTime: this._client._lastPatchTime
      })
    }));
    const {
      id,
      cid,
      timestamp,
      from,
      _status
    } = message;
    Object.assign(newMessage, {
      id,
      cid,
      timestamp,
      from,
      _status
    });

    if (this.lastMessage && this.lastMessage.id === newMessage.id) {
      this.lastMessage = newMessage;
    }

    return newMessage;
  }
  /**
   * 获取对话人数，或暂态对话的在线人数
   * @return {Promise.<Number>}
   */


  async count() {
    this._debug('count');

    const resCommand = await this._send(new GenericCommand({
      op: 'count'
    }));
    return resCommand.convMessage.count;
  }
  /**
   * 应用增加成员的操作，产生副作用
   * @param {string[]} members
   * @abstract
   * @private
   */


  _addMembers() {}
  /**
   * 应用减少成员的操作，产生副作用
   * @param {string[]} members
   * @abstract
   * @private
   */


  _removeMembers() {}
  /**
   * 修改已发送的消息
   * @param {AVMessage} message 要修改的消息，该消息必须是由当前用户发送的。也可以提供一个包含消息 {id, timestamp} 的对象
   * @param {AVMessage} newMessage 新的消息
   * @return {Promise.<AVMessage>} 更新后的消息
   */


  async update(message, newMessage) {
    if (!(newMessage instanceof Message)) {
      throw new TypeError(`${newMessage} is not a Message`);
    }

    return this._update(message, newMessage, false);
  }
  /**
   * 撤回已发送的消息
   * @param {AVMessage} message 要撤回的消息，该消息必须是由当前用户发送的。也可以提供一个包含消息 {id, timestamp} 的对象
   * @return {Promise.<RecalledMessage>} 一条已撤回的消息
   */


  async recall(message) {
    return this._update(message, new RecalledMessage(), true);
  }
  /**
   * 查询消息记录
   * 如果仅需实现消息向前记录翻页查询需求，建议使用 {@link Conversation#createMessagesIterator}。
   * 不论何种方向，获得的消息都是按照时间升序排列的。
   * startClosed 与 endClosed 用于指定查询区间的开闭。
   *
   * @param  {Object} [options]
   * @param  {Number} [options.limit] 限制查询结果的数量，目前服务端默认为 20
   * @param  {Number}   [options.type] 指定查询的富媒体消息类型，不指定则查询所有消息。
   * @param  {MessageQueryDirection} [options.direction] 查询的方向。
   * 在不指定的情况下如果 startTime 大于 endTime，则为从新到旧查询，可以实现加载聊天记录等场景。
   * 如果 startTime 小于 endTime，则为从旧到新查询，可以实现弹幕等场景。
   * @param  {Date}   [options.startTime] 从该时间开始查询，不传则从当前时间开始查询
   * @param  {String} [options.startMessageId] 从该消息之前开始查询，需要与 startTime 同时使用，为防止某时刻有重复消息
   * @param  {Boolean}[options.startClosed] 指定查询范围是否包括开始的时间点，默认不包括
   * @param  {Date}   [options.endTime] 查询到该时间为止，不传则查询最早消息为止
   * @param  {String} [options.endMessageId] 查询到该消息为止，需要与 endTime 同时使用，为防止某时刻有重复消息
   * @param  {Boolean}[options.endClosed] 指定查询范围是否包括结束的时间点，默认不包括
   *
   * @param  {Date}   [options.beforeTime] DEPRECATED: 使用 startTime 代替。限制查询结果为小于该时间之前的消息，不传则为当前时间
   * @param  {String} [options.beforeMessageId] DEPRECATED: 使用 startMessageId 代替。
   * 限制查询结果为该消息之前的消息，需要与 beforeTime 同时使用，为防止某时刻有重复消息
   * @param  {Date}   [options.afterTime] DEPRECATED: 使用 endTime 代替。限制查询结果为大于该时间之前的消息
   * @param  {String} [options.afterMessageId] DEPRECATED: 使用 endMessageId 代替。
   * 限制查询结果为该消息之后的消息，需要与 afterTime 同时使用，为防止某时刻有重复消息
   * @return {Promise.<Message[]>} 消息列表
   */


  async queryMessages(options = {}) {
    this._debug('query messages %O', options);

    const {
      beforeTime,
      beforeMessageId,
      afterTime,
      afterMessageId,
      limit,
      direction,
      type,
      startTime,
      startMessageId,
      startClosed,
      endTime,
      endMessageId,
      endClosed
    } = options;

    if (beforeMessageId || beforeTime || afterMessageId || afterTime) {
      console.warn('DEPRECATION: queryMessages options beforeTime, beforeMessageId, afterTime and afterMessageId are deprecated in favor of startTime, startMessageId, endTime and endMessageId.');
      return this.queryMessages({
        startTime: beforeTime,
        startMessageId: beforeMessageId,
        endTime: afterTime,
        endMessageId: afterMessageId,
        limit
      });
    }

    if (startMessageId && !startTime) {
      throw new Error('query option startMessageId must be used with option startTime');
    }

    if (endMessageId && !endTime) {
      throw new Error('query option endMessageId must be used with option endTime');
    }

    const conditions = {
      t: startTime,
      mid: startMessageId,
      tIncluded: startClosed,
      tt: endTime,
      tmid: endMessageId,
      ttIncluded: endClosed,
      l: limit,
      lctype: type
    };

    if (conditions.t instanceof Date) {
      conditions.t = conditions.t.getTime();
    }

    if (conditions.tt instanceof Date) {
      conditions.tt = conditions.tt.getTime();
    }

    if (direction !== undefined) {
      conditions.direction = direction;
    } else if (conditions.tt > conditions.t) {
      conditions.direction = MessageQueryDirection.OLD_TO_NEW;
    }

    const resCommand = await this._send(new GenericCommand({
      cmd: 'logs',
      logsMessage: new LogsCommand(Object.assign(conditions, {
        cid: this.id
      }))
    }));
    return Promise.all(resCommand.logsMessage.logs.map(async ({
      msgId,
      timestamp,
      patchTimestamp,
      from,
      ackAt,
      readAt,
      data,
      mentionAll,
      mentionPids,
      bin
    }) => {
      const messageData = {
        data,
        bin,
        id: msgId,
        cid: this.id,
        timestamp,
        from,
        deliveredAt: ackAt,
        updatedAt: patchTimestamp,
        mentionList: mentionPids,
        mentionedAll: mentionAll
      };
      const message = await this._client.parseMessage(messageData);
      let status = MessageStatus.SENT;

      if (this.members.length === 2) {
        if (ackAt) status = MessageStatus.DELIVERED;
        if (ackAt) this._setLastDeliveredAt(ackAt);
        if (readAt) this._setLastReadAt(readAt);
      }

      message._setStatus(status);

      return message;
    }));
  }
  /**
   * 获取消息翻页迭代器
   * @param  {Object} [options]
   * @param  {Date}   [options.beforeTime] 限制起始查询结果为小于该时间之前的消息，不传则为当前时间
   * @param  {String} [options.beforeMessageId] 限制起始查询结果为该消息之前的消息，需要与 beforeTime 同时使用，为防止某时刻有重复消息
   * @param  {Number} [options.limit] 限制每页查询结果的数量，目前服务端默认为 20
   * @return {AsyncIterater.<Promise.<IteratorResult<Message[]>>>} [AsyncIterator]{@link https://github.com/tc39/proposal-async-iteration}，调用其 next 方法返回获取下一页消息的 Promise
   * @example
   * var messageIterator = conversation.createMessagesIterator({ limit: 10 });
   * messageIterator.next().then(function(result) {
   *   // result: {
   *   //   value: [message1, ..., message10],
   *   //   done: false,
   *   // }
   * });
   * messageIterator.next().then(function(result) {
   *   // result: {
   *   //   value: [message11, ..., message20],
   *   //   done: false,
   *   // }
   * });
   * messageIterator.next().then(function(result) {
   *   // No more messages
   *   // result: { value: [], done: true }
   * });
   */


  createMessagesIterator({
    beforeTime,
    beforeMessageId,
    limit
  } = {}) {
    let promise;
    return {
      next: () => {
        if (promise === undefined) {
          // first call
          promise = this.queryMessages({
            limit,
            startTime: beforeTime,
            startMessageId: beforeMessageId
          });
        } else {
          promise = promise.then(prevMessages => {
            if (prevMessages.length === 0 || prevMessages.length < limit) {
              // no more messages
              return [];
            }

            return this.queryMessages({
              startTime: prevMessages[0].timestamp,
              startMessageId: prevMessages[0].id,
              limit
            });
          });
        }

        return promise.then(value => ({
          value: Array.from(value),
          done: value.length === 0 || value.length < limit
        }));
      }
    };
  }
  /**
   * 将该会话标记为已读
   * @return {Promise.<this>} self
   */


  async read() {
    this.unreadMessagesCount = 0;

    this._setUnreadMessagesMentioned(false); // 跳过暂态会话


    if (this.transient) return this;
    const client = this._client;

    if (!internal(client).readConversationsBuffer) {
      internal(client).readConversationsBuffer = new Set();
    }

    internal(client).readConversationsBuffer.add(this);

    client._doSendRead();

    return this;
  }

  _handleReceipt({
    messageId,
    timestamp,
    read
  }) {
    if (read) {
      this._setLastReadAt(timestamp);
    } else {
      this._setLastDeliveredAt(timestamp);
    }

    const {
      messagesWaitingForReceipt
    } = internal(this);
    const message = messagesWaitingForReceipt[messageId];
    if (!message) return;

    message._setStatus(MessageStatus.DELIVERED);

    message.deliveredAt = timestamp;
    delete messagesWaitingForReceipt[messageId];
  }
  /**
   * 更新对话的最新回执时间戳（lastDeliveredAt、lastReadAt）
   * @since 3.4.0
   * @return {Promise.<this>} this
   */


  async fetchReceiptTimestamps() {
    // 暂态/系统会话不支持回执
    if (this.transient || this.system) return this;
    const {
      convMessage: {
        maxReadTimestamp,
        maxAckTimestamp
      }
    } = await this._send(new GenericCommand({
      op: 'max_read'
    }));

    this._setLastDeliveredAt(maxAckTimestamp);

    this._setLastReadAt(maxReadTimestamp);

    return this;
  }

  _fetchAllReceiptTimestamps() {
    // 暂态/系统会话不支持回执
    if (this.transient || this.system) return this;
    const convMessage = new ConvCommand({
      queryAllMembers: true
    });
    return this._send(new GenericCommand({
      op: 'max_read',
      convMessage
    })).then(({
      convMessage: {
        maxReadTuples
      }
    }) => maxReadTuples.filter(maxReadTuple => maxReadTuple.maxAckTimestamp || maxReadTuple.maxReadTimestamp).map(({
      pid,
      maxAckTimestamp,
      maxReadTimestamp
    }) => ({
      pid,
      lastDeliveredAt: decodeDate(maxAckTimestamp),
      lastReadAt: decodeDate(maxReadTimestamp)
    })));
  }

}

const debug$8 = d('LC:SignatureFactoryRunner');

function _validateSignature(signatureResult = {}) {
  const {
    signature,
    timestamp,
    nonce
  } = signatureResult;

  if (typeof signature !== 'string' || typeof timestamp !== 'number' || typeof nonce !== 'string') {
    throw new Error('malformed signature');
  }

  return {
    signature,
    timestamp,
    nonce
  };
}

var runSignatureFactory = ((signatureFactory, params) => Promise.resolve().then(() => {
  debug$8('call signatureFactory with %O', params);
  return signatureFactory(...params);
}).then(tap(signatureResult => debug$8('sign result %O', signatureResult)), error => {
  // eslint-disable-next-line no-param-reassign
  error.message = `sign error: ${error.message}`;
  debug$8(error);
  throw error;
}).then(_validateSignature));

/**
 * 部分失败异常
 * @typedef OperationFailureError
 * @type {Error}
 * @property {string} message 异常信息
 * @property {string[]} clientIds 因为该原因失败的 client id 列表
 * @property {number} [code] 错误码
 * @property {string} [detail] 详细信息
 */

/**
 * 部分成功的结果
 * @typedef PartiallySuccess
 * @type {Object}
 * @property {string[]} successfulClientIds 成功的 client id 列表
 * @property {OperationFailureError[]} failures 失败的异常列表
 */

/**
 * 分页查询结果
 * @typedef PagedResults
 * @type {Object}
 * @property {T[]} results 查询结果
 * @property {string} [next] 存在表示还有更多结果，在下次查询中带上可实现翻页。
 */

const createPartiallySuccess = ({
  allowedPids,
  failedPids
}) => ({
  successfulClientIds: allowedPids,
  failures: failedPids.map(({
    pids,
    ...error
  }) => Object.assign(createError(error), {
    clientIds: pids
  }))
});
/**
 * @extends ConversationBase
 * @private
 * @abstract
 */


class PersistentConversation extends ConversationBase {
  constructor(data, {
    creator,
    createdAt,
    updatedAt,
    transient = false,
    system = false,
    muted = false,
    mutedMembers = [],
    ...attributes
  }, client) {
    super({ ...data,

      /**
       * 对话创建者
       * @memberof PersistentConversation#
       * @type {String}
       */
      creator,

      /**
       * 对话创建时间
       * @memberof PersistentConversation#
       * @type {Date}
       */
      createdAt,

      /**
       * 对话更新时间
       * @memberof PersistentConversation#
       * @type {Date}
       */
      updatedAt,

      /**
       * 对该对话设置了静音的用户列表
       * @memberof PersistentConversation#
       * @type {?String[]}
       */
      mutedMembers,

      /**
       * 暂态对话标记
       * @memberof PersistentConversation#
       * @type {Boolean}
       */
      transient,

      /**
       * 系统对话标记
       * @memberof PersistentConversation#
       * @type {Boolean}
       * @since 3.3.0
       */
      system,

      /**
       * 当前用户静音该对话标记
       * @memberof PersistentConversation#
       * @type {Boolean}
       */
      muted,
      _attributes: attributes
    }, client);

    this._reset();
  }

  set createdAt(value) {
    this._createdAt = decodeDate(value);
  }

  get createdAt() {
    return this._createdAt;
  }

  set updatedAt(value) {
    this._updatedAt = decodeDate(value);
  }

  get updatedAt() {
    return this._updatedAt;
  }
  /**
   * 对话名字，对应 _Conversation 表中的 name
   * @type {String}
   */


  get name() {
    return this.get('name');
  }

  set name(value) {
    this.set('name', value);
  }
  /**
   * 获取对话的自定义属性
   * @since 3.2.0
   * @param  {String} key key 属性的键名，'x' 对应 Conversation 表中的 x 列
   * @return {Any} 属性的值
   */


  get(key) {
    return get(internal(this).currentAttributes, key);
  }
  /**
   * 设置对话的自定义属性
   * @since 3.2.0
   * @param {String} key 属性的键名，'x' 对应 Conversation 表中的 x 列，支持使用 'x.y.z' 来修改对象的部分字段。
   * @param {Any} value 属性的值
   * @return {this} self
   * @example
   *
   * // 设置对话的 color 属性
   * conversation.set('color', {
   *   text: '#000',
   *   background: '#DDD',
   * });
   * // 设置对话的 color.text 属性
   * conversation.set('color.text', '#333');
   */


  set(key, value) {
    this._debug(`set [${key}]: ${value}`);

    const {
      pendingAttributes
    } = internal(this);
    const pendingKeys = Object.keys(pendingAttributes); // suppose pendingAttributes = { 'a.b': {} }
    // set 'a' or 'a.b': delete 'a.b'

    const re = new RegExp(`^${key}`);
    const childKeys = pendingKeys.filter(re.test.bind(re));
    childKeys.forEach(k => {
      delete pendingAttributes[k];
    });

    if (childKeys.length) {
      pendingAttributes[key] = value;
    } else {
      // set 'a.c': nothing to do
      // set 'a.b.c.d': assign c: { d: {} } to 'a.b'
      const parentKey = find(pendingKeys, k => key.indexOf(k) === 0); // 'a.b'

      if (parentKey) {
        setValue(pendingAttributes[parentKey], key.slice(parentKey.length + 1), value);
      } else {
        pendingAttributes[key] = value;
      }
    }

    this._buildCurrentAttributes();

    return this;
  }

  _buildCurrentAttributes() {
    const {
      pendingAttributes
    } = internal(this);
    internal(this).currentAttributes = Object.keys(pendingAttributes).reduce((target, k) => setValue(target, k, pendingAttributes[k]), cloneDeep(this._attributes));
  }

  _updateServerAttributes(attributes) {
    Object.keys(attributes).forEach(key => setValue(this._attributes, key, attributes[key]));

    this._buildCurrentAttributes();
  }

  _reset() {
    Object.assign(internal(this), {
      pendingAttributes: {},
      currentAttributes: this._attributes
    });
  }
  /**
   * 保存当前对话的属性至服务器
   * @return {Promise.<this>} self
   */


  async save() {
    this._debug('save');

    const attr = internal(this).pendingAttributes;

    if (isEmpty(attr)) {
      this._debug('nothing touched, resolve with self');

      return this;
    }

    this._debug('attr: %O', attr);

    const convMessage = new ConvCommand({
      attr: new JsonObjectMessage({
        data: JSON.stringify(encode(attr))
      })
    });
    const resCommand = await this._send(new GenericCommand({
      op: 'update',
      convMessage
    }));
    this.updatedAt = resCommand.convMessage.udate;
    this._attributes = internal(this).currentAttributes;
    internal(this).pendingAttributes = {};
    return this;
  }
  /**
   * 从服务器更新对话的属性
   * @return {Promise.<this>} self
   */


  async fetch() {
    const query = this._client.getQuery().equalTo('objectId', this.id);

    await query.find();
    return this;
  }
  /**
   * 静音，客户端拒绝收到服务器端的离线推送通知
   * @return {Promise.<this>} self
   */


  async mute() {
    this._debug('mute');

    await this._send(new GenericCommand({
      op: 'mute'
    }));

    if (!this.transient) {
      this.muted = true;
      this.mutedMembers = union(this.mutedMembers, [this._client.id]);
    }

    return this;
  }
  /**
   * 取消静音
   * @return {Promise.<this>} self
   */


  async unmute() {
    this._debug('unmute');

    await this._send(new GenericCommand({
      op: 'unmute'
    }));

    if (!this.transient) {
      this.muted = false;
      this.mutedMembers = difference(this.mutedMembers, [this._client.id]);
    }

    return this;
  }

  async _appendConversationSignature(command, action, clientIds) {
    if (this._client.options.conversationSignatureFactory) {
      const params = [this.id, this._client.id, clientIds.sort(), action];
      const signatureResult = await runSignatureFactory(this._client.options.conversationSignatureFactory, params);
      Object.assign(command.convMessage, keyRemap({
        signature: 's',
        timestamp: 't',
        nonce: 'n'
      }, signatureResult));
    }
  }

  async _appendBlacklistSignature(command, action, clientIds) {
    if (this._client.options.blacklistSignatureFactory) {
      const params = [this.id, this._client.id, clientIds.sort(), action];
      const signatureResult = await runSignatureFactory(this._client.options.blacklistSignatureFactory, params);
      Object.assign(command.blacklistMessage, keyRemap({
        signature: 's',
        timestamp: 't',
        nonce: 'n'
      }, signatureResult));
    }
  }
  /**
   * 增加成员
   * @param {String|String[]} clientIds 新增成员 client id
   * @return {Promise.<PartiallySuccess>} 部分成功结果，包含了成功的 id 列表、失败原因与对应的 id 列表
   */


  async add(clientIds) {
    this._debug('add', clientIds);

    if (typeof clientIds === 'string') {
      clientIds = [clientIds]; // eslint-disable-line no-param-reassign
    }

    const command = new GenericCommand({
      op: 'add',
      convMessage: new ConvCommand({
        m: clientIds
      })
    });
    await this._appendConversationSignature(command, 'invite', clientIds);
    const {
      convMessage,
      convMessage: {
        allowedPids
      }
    } = await this._send(command);

    this._addMembers(allowedPids);

    return createPartiallySuccess(convMessage);
  }
  /**
   * 剔除成员
   * @param {String|String[]} clientIds 成员 client id
   * @return {Promise.<PartiallySuccess>} 部分成功结果，包含了成功的 id 列表、失败原因与对应的 id 列表
   */


  async remove(clientIds) {
    this._debug('remove', clientIds);

    if (typeof clientIds === 'string') {
      clientIds = [clientIds]; // eslint-disable-line no-param-reassign
    }

    const command = new GenericCommand({
      op: 'remove',
      convMessage: new ConvCommand({
        m: clientIds
      })
    });
    await this._appendConversationSignature(command, 'kick', clientIds);
    const {
      convMessage,
      convMessage: {
        allowedPids
      }
    } = await this._send(command);

    this._removeMembers(allowedPids);

    return createPartiallySuccess(convMessage);
  }
  /**
   * （当前用户）加入该对话
   * @return {Promise.<this>} self
   */


  async join() {
    this._debug('join');

    return this.add(this._client.id).then(({
      failures
    }) => {
      if (failures[0]) throw failures[0];
      return this;
    });
  }
  /**
   * （当前用户）退出该对话
   * @return {Promise.<this>} self
   */


  async quit() {
    this._debug('quit');

    return this.remove(this._client.id).then(({
      failures
    }) => {
      if (failures[0]) throw failures[0];
      return this;
    });
  }
  /**
   * 在该对话中禁言成员
   * @param {String|String[]} clientIds 成员 client id
   * @return {Promise.<PartiallySuccess>} 部分成功结果，包含了成功的 id 列表、失败原因与对应的 id 列表
   */


  async muteMembers(clientIds) {
    this._debug('mute', clientIds);

    clientIds = ensureArray(clientIds); // eslint-disable-line no-param-reassign

    const command = new GenericCommand({
      op: OpType.add_shutup,
      convMessage: new ConvCommand({
        m: clientIds
      })
    });
    const {
      convMessage
    } = await this._send(command);
    return createPartiallySuccess(convMessage);
  }
  /**
   * 在该对话中解除成员禁言
   * @param {String|String[]} clientIds 成员 client id
   * @return {Promise.<PartiallySuccess>} 部分成功结果，包含了成功的 id 列表、失败原因与对应的 id 列表
   */


  async unmuteMembers(clientIds) {
    this._debug('unmute', clientIds);

    clientIds = ensureArray(clientIds); // eslint-disable-line no-param-reassign

    const command = new GenericCommand({
      op: OpType.remove_shutup,
      convMessage: new ConvCommand({
        m: clientIds
      })
    });
    const {
      convMessage
    } = await this._send(command);
    return createPartiallySuccess(convMessage);
  }
  /**
   * 查询该对话禁言成员列表
   * @param {Object} [options]
   * @param {Number} [options.limit] 返回的成员数量，服务器默认值 10
   * @param {String} [options.next] 从指定 next 开始查询，与 limit 一起使用可以完成翻页。
   * @return {PagedResults.<string>} 查询结果。其中的 cureser 存在表示还有更多结果。
   */


  async queryMutedMembers({
    limit,
    next
  } = {}) {
    this._debug('query muted: limit %O, next: %O', limit, next);

    const command = new GenericCommand({
      op: OpType.query_shutup,
      convMessage: new ConvCommand({
        limit,
        next
      })
    });
    const {
      convMessage: {
        m,
        next: newNext
      }
    } = await this._send(command);
    return {
      results: m,
      next: newNext
    };
  }
  /**
   * 将用户加入该对话黑名单
   * @param {String|String[]} clientIds 成员 client id
   * @return {Promise.<PartiallySuccess>} 部分成功结果，包含了成功的 id 列表、失败原因与对应的 id 列表
   */


  async blockMembers(clientIds) {
    this._debug('block', clientIds);

    clientIds = ensureArray(clientIds); // eslint-disable-line no-param-reassign

    const command = new GenericCommand({
      cmd: 'blacklist',
      op: OpType.block,
      blacklistMessage: new BlacklistCommand({
        srcCid: this.id,
        toPids: clientIds
      })
    });
    await this._appendBlacklistSignature(command, 'conversation-block-clients', clientIds);
    const {
      blacklistMessage
    } = await this._send(command);
    return createPartiallySuccess(blacklistMessage);
  }
  /**
   * 将用户移出该对话黑名单
   * @param {String|String[]} clientIds 成员 client id
   * @return {Promise.<PartiallySuccess>} 部分成功结果，包含了成功的 id 列表、失败原因与对应的 id 列表
   */


  async unblockMembers(clientIds) {
    this._debug('unblock', clientIds);

    clientIds = ensureArray(clientIds); // eslint-disable-line no-param-reassign

    const command = new GenericCommand({
      cmd: 'blacklist',
      op: OpType.unblock,
      blacklistMessage: new BlacklistCommand({
        srcCid: this.id,
        toPids: clientIds
      })
    });
    await this._appendBlacklistSignature(command, 'conversation-unblock-clients', clientIds);
    const {
      blacklistMessage
    } = await this._send(command);
    return createPartiallySuccess(blacklistMessage);
  }
  /**
   * 查询该对话黑名单
   * @param {Object} [options]
   * @param {Number} [options.limit] 返回的成员数量，服务器默认值 10
   * @param {String} [options.next] 从指定 next 开始查询，与 limit 一起使用可以完成翻页
   * @return {PagedResults.<string>} 查询结果。其中的 cureser 存在表示还有更多结果。
   */


  async queryBlockedMembers({
    limit,
    next
  } = {}) {
    this._debug('query blocked: limit %O, next: %O', limit, next);

    const command = new GenericCommand({
      cmd: 'blacklist',
      op: OpType.query,
      blacklistMessage: new BlacklistCommand({
        srcCid: this.id,
        limit,
        next
      })
    });
    const {
      blacklistMessage: {
        blockedPids,
        next: newNext
      }
    } = await this._send(command);
    return {
      results: blockedPids,
      next: newNext
    };
  }

  toFullJSON() {
    const {
      creator,
      system,
      transient,
      createdAt,
      updatedAt,
      _attributes
    } = this;
    return { ...super.toFullJSON(),
      creator,
      system,
      transient,
      createdAt: getTime(createdAt),
      updatedAt: getTime(updatedAt),
      ..._attributes
    };
  }

  toJSON() {
    const {
      creator,
      system,
      transient,
      muted,
      mutedMembers,
      createdAt,
      updatedAt,
      _attributes
    } = this;
    return { ...super.toJSON(),
      creator,
      system,
      transient,
      muted,
      mutedMembers,
      createdAt,
      updatedAt,
      ..._attributes
    };
  }

}

/**
 * 对话成员角色枚举
 * @enum {String}
 * @since 4.0.0
 * @memberof module:leancloud-realtime
 */

const ConversationMemberRole = {
  /** 所有者 */
  OWNER: 'Owner',

  /** 管理员 */
  MANAGER: 'Manager',

  /** 成员 */
  MEMBER: 'Member'
};
Object.freeze(ConversationMemberRole);
class ConversationMemberInfo {
  /**
   * 对话成员属性，保存了成员与某个对话相关的属性，对应 _ConversationMemberInfo 表
   * @since 4.0.0
   */
  constructor({
    conversation,
    memberId,
    role
  }) {
    if (!conversation) throw new Error('conversation requried');
    if (!memberId) throw new Error('memberId requried');
    Object.assign(internal(this), {
      conversation,
      memberId,
      role
    });
  }
  /**
   * 对话 Id
   * @type {String}
   * @readonly
   */


  get conversationId() {
    return internal(this).conversation.id;
  }
  /**
   * 成员 Id
   * @type {String}
   * @readonly
   */


  get memberId() {
    return internal(this).memberId;
  }
  /**
   * 角色
   * @type {module:leancloud-realtime.ConversationMemberRole | String}
   * @readonly
   */


  get role() {
    if (this.isOwner) return ConversationMemberRole.OWNER;
    return internal(this).role;
  }
  /**
   * 是否是管理员
   * @type {Boolean}
   * @readonly
   */


  get isOwner() {
    return this.memberId === internal(this).conversation.creator;
  }

  toJSON() {
    const {
      conversationId,
      memberId,
      role,
      isOwner
    } = this;
    return {
      conversationId,
      memberId,
      role,
      isOwner
    };
  }

}

/**
 * 普通对话
 *
 * 无法直接实例化，请使用 {@link IMClient#createConversation} 创建新的普通对话。
 * @extends PersistentConversation
 * @public
 */

class Conversation extends PersistentConversation {
  _addMembers(members) {
    super._addMembers(members);

    this.members = union(this.members, members);
    const {
      memberInfoMap
    } = internal(this);
    if (!memberInfoMap) return;
    members.forEach(memberId => {
      memberInfoMap[memberId] = memberInfoMap[memberId] || new ConversationMemberInfo({
        conversation: this,
        memberId,
        role: ConversationMemberRole.MEMBER
      });
    });
  }

  _removeMembers(members) {
    super._removeMembers(members);

    this.members = difference(this.members, members);
    const {
      memberInfoMap
    } = internal(this);
    if (!memberInfoMap) return;
    members.forEach(memberId => {
      delete memberInfoMap[memberId];
    });
  }

  async _fetchAllMemberInfo() {
    const response = await this._client._requestWithSessionToken({
      method: 'GET',
      path: '/classes/_ConversationMemberInfo',
      query: {
        where: {
          cid: this.id
        }
      }
    });
    const memberInfos = response.results.map(info => new ConversationMemberInfo({
      conversation: this,
      memberId: info.clientId,
      role: info.role
    }));
    const memberInfoMap = {};
    memberInfos.forEach(memberInfo => {
      memberInfoMap[memberInfo.memberId] = memberInfo;
    });
    this.members.forEach(memberId => {
      memberInfoMap[memberId] = memberInfoMap[memberId] || new ConversationMemberInfo({
        conversation: this,
        memberId,
        role: ConversationMemberRole.MEMBER
      });
    });
    internal(this).memberInfoMap = memberInfoMap;
    return memberInfoMap;
  }
  /**
   * 获取所有成员的对话属性
   * @since 4.0.0
   * @return {Promise.<ConversationMemberInfo[]>} 所有成员的对话属性列表
   */


  async getAllMemberInfo({
    noCache = false
  } = {}) {
    let {
      memberInfoMap
    } = internal(this);

    if (!memberInfoMap || noCache) {
      memberInfoMap = await this._fetchAllMemberInfo();
    }

    return this.members.map(memberId => memberInfoMap[memberId]);
  }
  /**
   * 获取指定成员的对话属性
   * @since 4.0.0
   * @param {String} memberId 成员 Id
   * @return {Promise.<ConversationMemberInfo>} 指定成员的对话属性
   */


  async getMemberInfo(memberId) {
    if (this.members.indexOf(memberId) === -1) throw new Error(`${memberId} is not the mumber of conversation[${this.id}]`);
    const {
      memberInfoMap
    } = internal(this);
    if (!(memberInfoMap && memberInfoMap[memberId])) await this.getAllMemberInfo();
    return internal(this).memberInfoMap[memberId];
  }
  /**
   * 更新指定用户的角色
   * @since 4.0.0
   * @param {String} memberId 成员 Id
   * @param {module:leancloud-realtime.ConversationMemberRole | String} role 角色
   * @return {Promise.<this>} self
   */


  async updateMemberRole(memberId, role) {
    this._debug('update member role');

    if (role === ConversationMemberRole.OWNER) throw createError({
      code: ErrorCode.OWNER_PROMOTION_NOT_ALLOWED
    });
    await this._send(new GenericCommand({
      op: OpType.member_info_update,
      convMessage: new ConvCommand({
        targetClientId: memberId,
        info: new ConvMemberInfo({
          pid: memberId,
          role
        })
      })
    }));
    const {
      memberInfos
    } = internal(this);

    if (memberInfos && memberInfos[memberId]) {
      internal(memberInfos[memberId]).role = role;
    }

    return this;
  }

}

/**
 * 聊天室。
 *
 * 无法直接实例化，请使用 {@link IMClient#createChatRoom} 创建新的聊天室。
 * @since 4.0.0
 * @extends PersistentConversation
 * @public
 */

class ChatRoom extends PersistentConversation {}

/**
 * 服务号。
 *
 * 服务号不支持在客户端创建。
 * @since 4.0.0
 * @extends PersistentConversation
 * @public
 */

class ServiceConversation extends PersistentConversation {
  /**
   * 订阅该服务号
   * @return {Promise.<this>} self
   */
  async subscribe() {
    return this.join();
  }
  /**
   * 退订该服务号
   * @return {Promise.<this>} self
   */


  async unsubscribe() {
    return this.quit();
  }

}

const transformNotFoundError = error => error.code === ErrorCode.CONVERSATION_NOT_FOUND ? createError({
  code: ErrorCode.TEMPORARY_CONVERSATION_EXPIRED
}) : error;
/**
 * 临时对话
 * @since 4.0.0
 * @extends ConversationBase
 * @public
 */


class TemporaryConversation extends ConversationBase {
  /**
   * 无法直接实例化，请使用 {@link IMClient#createTemporaryConversation} 创建新的临时对话。
   */
  constructor(data, {
    expiredAt
  }, client) {
    super({ ...data,
      expiredAt
    }, client);
  }
  /**
   * 对话失效时间
   * @type {Date}
   */


  set expiredAt(value) {
    this._expiredAt = decodeDate(value);
  }

  get expiredAt() {
    return this._expiredAt;
  }
  /**
   * 对话是否已失效
   * @type {Boolean}
   */


  get expired() {
    return this.expiredAt < new Date();
  }

  async _send(...args) {
    if (this.expired) throw createError({
      code: ErrorCode.TEMPORARY_CONVERSATION_EXPIRED
    });

    try {
      return await super._send(...args);
    } catch (error) {
      throw transformNotFoundError(error);
    }
  }

  async send(...args) {
    try {
      return await super.send(...args);
    } catch (error) {
      throw transformNotFoundError(error);
    }
  }

  toFullJSON() {
    const {
      expiredAt
    } = this;
    return { ...super.toFullJSON(),
      expiredAt: getTime(expiredAt)
    };
  }

  toJSON() {
    const {
      expiredAt,
      expired
    } = this;
    return { ...super.toJSON(),
      expiredAt,
      expired
    };
  }

}

const debug$9 = d('LC:ConversationQuery');
class ConversationQuery {
  static _encode(value) {
    if (value instanceof Date) {
      return {
        __type: 'Date',
        iso: value.toJSON()
      };
    }

    if (value instanceof RegExp) {
      return value.source;
    }

    return value;
  }

  static _quote(s) {
    return `\\Q${s.replace('\\E', '\\E\\\\E\\Q')}\\E`;
  }

  static _calculateFlag(options) {
    return ['withLastMessagesRefreshed', 'compact'].reduce( // eslint-disable-next-line no-bitwise
    (prev, key) => (prev << 1) + Boolean(options[key]), 0);
  }
  /**
   * 构造一个用 AND 连接所有查询的 ConversationQuery
   * @param {...ConversationQuery} queries
   * @return {ConversationQuery}
   */


  static and(...queries) {
    if (queries.length < 2) {
      throw new Error('The queries must contain at least two elements');
    }

    if (!queries.every(q => q instanceof ConversationQuery)) {
      throw new Error('The element of queries must be an instance of ConversationQuery');
    }

    const combined = new ConversationQuery(queries[0]._client);
    combined._where.$and = queries.map(q => q._where);
    return combined;
  }
  /**
   * 构造一个用 OR 连接所有查询的 ConversationQuery
   * @param  {...ConversationQuery} queries
   * @return {ConversationQuery}
   */


  static or(...queries) {
    const combined = ConversationQuery.and(...queries);
    combined._where.$or = combined._where.$and;
    delete combined._where.$and;
    return combined;
  }
  /**
   * Create a ConversationQuery
   * @param  {IMClient} client
   */


  constructor(client) {
    this._client = client;
    this._where = {};
    this._extraOptions = {};
  }

  _addCondition(key, condition, value) {
    // Check if we already have a condition
    if (!this._where[key]) {
      this._where[key] = {};
    }

    this._where[key][condition] = this.constructor._encode(value);
    return this;
  }

  toJSON() {
    const json = {
      where: this._where,
      flag: this.constructor._calculateFlag(this._extraOptions)
    };
    if (typeof this._skip !== 'undefined') json.skip = this._skip;
    if (typeof this._limit !== 'undefined') json.limit = this._limit;
    if (typeof this._order !== 'undefined') json.sort = this._order;
    debug$9(json);
    return json;
  }
  /**
   * 增加查询条件，指定聊天室的组员包含某些成员即可返回
   * @param {string[]} peerIds - 成员 ID 列表
   * @return {ConversationQuery} self
   */


  containsMembers(peerIds) {
    return this.containsAll('m', peerIds);
  }
  /**
   * 增加查询条件，指定聊天室的组员条件满足条件的才返回
   *
   * @param {string[]} - 成员 ID 列表
   * @param {Boolean} includeSelf - 是否包含自己
   * @return {ConversationQuery} self
   */


  withMembers(peerIds, includeSelf) {
    const peerIdsSet = new Set(peerIds);

    if (includeSelf) {
      peerIdsSet.add(this._client.id);
    }

    this.sizeEqualTo('m', peerIdsSet.size);
    return this.containsMembers(Array.from(peerIdsSet));
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段满足等于条件时即可返回
   *
   * @param {string} key
   * @param value
   * @return {ConversationQuery} self
   */


  equalTo(key, value) {
    this._where[key] = this.constructor._encode(value);
    return this;
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段满足小于条件时即可返回
   * @param {string} key
   * @param value
   * @return {ConversationQuery} self
   */


  lessThan(key, value) {
    return this._addCondition(key, '$lt', value);
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段满足小于等于条件时即可返回
    * @param {string} key
   * @param value
   * @return {ConversationQuery} self
   */


  lessThanOrEqualTo(key, value) {
    return this._addCondition(key, '$lte', value);
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段满足大于条件时即可返回
   *
   * @param {string} key
   * @param value
   * @return {ConversationQuery} self
   */


  greaterThan(key, value) {
    return this._addCondition(key, '$gt', value);
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段满足大于等于条件时即可返回
   *
   * @param {string} key
   * @param value
   * @return {ConversationQuery} self
   */


  greaterThanOrEqualTo(key, value) {
    return this._addCondition(key, '$gte', value);
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段满足不等于条件时即可返回
   *
   * @param {string} key
   * @param value
   * @return {ConversationQuery} self
   */


  notEqualTo(key, value) {
    return this._addCondition(key, '$ne', value);
  }
  /**
   * 增加查询条件，当 conversation 存在指定的字段时即可返回
   *
   * @since 3.5.0
   * @param {string} key
   * @return {ConversationQuery} self
   */


  exists(key) {
    return this._addCondition(key, '$exists', true);
  }
  /**
   * 增加查询条件，当 conversation 不存在指定的字段时即可返回
   *
   * @since 3.5.0
   * @param {string} key
   * @return {ConversationQuery} self
   */


  doesNotExist(key) {
    return this._addCondition(key, '$exists', false);
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段对应的值包含在指定值中时即可返回
   *
   * @param {string} key
   * @param values
   * @return {ConversationQuery} self
   */


  containedIn(key, values) {
    return this._addCondition(key, '$in', values);
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段对应的值不包含在指定值中时即可返回
   *
   * @param {string} key
   * @param values
   * @return {ConversationQuery} self
   */


  notContainsIn(key, values) {
    return this._addCondition(key, '$nin', values);
  }
  /**
   * 增加查询条件，当conversation的属性中对应的字段中的元素包含所有的值才可返回
   *
   * @param {string} key
   * @param values
   * @return {ConversationQuery} self
   */


  containsAll(key, values) {
    return this._addCondition(key, '$all', values);
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段对应的值包含此字符串即可返回
   *
   * @param {string} key
   * @param {string} subString
   * @return {ConversationQuery} self
   */


  contains(key, subString) {
    return this._addCondition(key, '$regex', ConversationQuery._quote(subString));
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段对应的值以此字符串起始即可返回
   *
   * @param {string} key
   * @param {string} prefix
   * @return {ConversationQuery} self
   */


  startsWith(key, prefix) {
    return this._addCondition(key, '$regex', `^${ConversationQuery._quote(prefix)}`);
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段对应的值以此字符串结束即可返回
   *
   * @param {string} key
   * @param {string} suffix
   * @return {ConversationQuery} self
   */


  endsWith(key, suffix) {
    return this._addCondition(key, '$regex', `${ConversationQuery._quote(suffix)}$`);
  }
  /**
   * 增加查询条件，当 conversation 的属性中对应的字段对应的值满足提供的正则表达式即可返回
   *
   * @param {string} key
   * @param {RegExp} regex
   * @return {ConversationQuery} self
   */


  matches(key, regex) {
    this._addCondition(key, '$regex', regex); // Javascript regex options support mig as inline options but store them
    // as properties of the object. We support mi & should migrate them to
    // modifiers


    let _modifiers = '';

    if (regex.ignoreCase) {
      _modifiers += 'i';
    }

    if (regex.multiline) {
      _modifiers += 'm';
    }

    if (_modifiers && _modifiers.length) {
      this._addCondition(key, '$options', _modifiers);
    }

    return this;
  }
  /**
   * 添加查询约束条件，查找 key 类型是数组，该数组的长度匹配提供的数值
   *
   * @param {string} key
   * @param {Number} length
   * @return {ConversationQuery} self
   */


  sizeEqualTo(key, length) {
    return this._addCondition(key, '$size', length);
  }
  /**
   * 设置返回集合的大小上限
   *
   * @param {Number} limit - 上限
   * @return {ConversationQuery} self
   */


  limit(limit) {
    this._limit = limit;
    return this;
  }
  /**
   * 设置返回集合的起始位置，一般用于分页
   *
   * @param {Number} skip - 起始位置跳过几个对象
   * @return {ConversationQuery} self
   */


  skip(skip) {
    this._skip = skip;
    return this;
  }
  /**
   * 设置返回集合按照指定key进行增序排列
   *
   * @param {string} key
   * @return {ConversationQuery} self
   */


  ascending(key) {
    this._order = key;
    return this;
  }
  /**
   * 设置返回集合按照指定key进行增序排列，如果已设置其他排序，原排序的优先级较高
   *
   * @param {string} key
   * @return {ConversationQuery} self
   */


  addAscending(key) {
    if (this._order) {
      this._order += `,${key}`;
    } else {
      this._order = key;
    }

    return this;
  }
  /**
   * 设置返回集合按照指定 key 进行降序排列
   *
   * @param {string} key
   * @return {ConversationQuery} self
   */


  descending(key) {
    this._order = `-${key}`;
    return this;
  }
  /**
   * 设置返回集合按照指定 key 进行降序排列，如果已设置其他排序，原排序的优先级较高
   *
   * @param {string} key
   * @return {ConversationQuery} self
   */


  addDescending(key) {
    if (this._order) {
      this._order += `,-${key}`;
    } else {
      this._order = `-${key}`;
    }

    return this;
  }
  /**
   * 设置返回的 conversations 刷新最后一条消息
   * @param  {Boolean} [enabled=true]
   * @return {ConversationQuery} self
   */


  withLastMessagesRefreshed(enabled = true) {
    this._extraOptions.withLastMessagesRefreshed = enabled;
    return this;
  }
  /**
   * 设置返回的 conversations 为精简模式，即不含成员列表
   * @param  {Boolean} [enabled=true]
   * @return {ConversationQuery} self
   */


  compact(enabled = true) {
    this._extraOptions.compact = enabled;
    return this;
  }
  /**
   * 执行查询
   * @return {Promise.<ConversationBase[]>}
   */


  async find() {
    return this._client._executeQuery(this);
  }
  /**
   * 返回符合条件的第一个结果
   * @return {Promise.<ConversationBase>}
   */


  async first() {
    return (await this.limit(1).find())[0];
  }

}

const debug$a = d('LC:SessionManager');
class SessionManager {
  constructor({
    refresh,
    onBeforeGetSessionToken
  } = {}) {
    this.refresh = refresh;
    this._onBeforeGetSessionToken = onBeforeGetSessionToken;
    this.setSessionToken(null, 0);
  }

  setSessionToken(token, ttl) {
    debug$a('set session token', token, ttl);
    const sessionToken = new Expirable(token, ttl * 1000);
    this._sessionToken = sessionToken;
    delete this._pendingSessionTokenPromise;
    return sessionToken;
  }

  async setSessionTokenAsync(promise) {
    const currentSessionToken = this._sessionToken;
    this._pendingSessionTokenPromise = promise.catch(error => {
      // revert, otherwise the following getSessionToken calls
      // will all be rejected
      this._sessionToken = currentSessionToken;
      throw error;
    });
    return this.setSessionToken(...(await this._pendingSessionTokenPromise));
  }

  async getSessionToken({
    autoRefresh = true
  } = {}) {
    debug$a('get session token');

    if (this._onBeforeGetSessionToken) {
      this._onBeforeGetSessionToken(this);
    }

    const {
      value,
      originalValue
    } = this._sessionToken || (await this._pendingSessionTokenPromise);

    if (value === Expirable.EXPIRED && autoRefresh && this.refresh) {
      debug$a('refresh expired session token');
      const {
        value: newValue
      } = await this.setSessionTokenAsync(this.refresh(this, originalValue));
      debug$a('session token', newValue);
      return newValue;
    }

    debug$a('session token', value);
    return value;
  }

  revoke() {
    if (this._sessionToken) this._sessionToken.expiredAt = -1;
  }

}

var _dec$2, _dec2, _class$3;
const debug$b = d('LC:IMClient');
const {
  INVITED: INVITED$1,
  KICKED: KICKED$1,
  MEMBERS_JOINED: MEMBERS_JOINED$1,
  MEMBERS_LEFT: MEMBERS_LEFT$1,
  MEMBER_INFO_UPDATED: MEMBER_INFO_UPDATED$1,
  BLOCKED: BLOCKED$1,
  UNBLOCKED: UNBLOCKED$1,
  MEMBERS_BLOCKED: MEMBERS_BLOCKED$1,
  MEMBERS_UNBLOCKED: MEMBERS_UNBLOCKED$1,
  MUTED: MUTED$1,
  UNMUTED: UNMUTED$1,
  MEMBERS_MUTED: MEMBERS_MUTED$1,
  MEMBERS_UNMUTED: MEMBERS_UNMUTED$1,
  MESSAGE: MESSAGE$2,
  UNREAD_MESSAGES_COUNT_UPDATE: UNREAD_MESSAGES_COUNT_UPDATE$1,
  CLOSE: CLOSE$1,
  CONFLICT: CONFLICT$1,
  UNHANDLED_MESSAGE: UNHANDLED_MESSAGE$1,
  CONVERSATION_INFO_UPDATED: CONVERSATION_INFO_UPDATED$1,
  MESSAGE_RECALL: MESSAGE_RECALL$1,
  MESSAGE_UPDATE: MESSAGE_UPDATE$1,
  INFO_UPDATED: INFO_UPDATED$1
} = IMEvent;

const isTemporaryConversatrionId = id => /^_tmp:/.test(id);
/**
 * 1 patch-msg
 * 1 temp-conv-msg
 * 0 auto-bind-deviceid-and-installation
 * 1 transient-msg-ack
 * 1 keep-notification
 * 1 partial-failed-msg
 * 0 group-chat-rcp
 * 1 omit-peer-id
 * @ignore
 */


const configBitmap = 0b10111011;
let IMClient = (_dec$2 = throttle(1000), _dec2 = throttle(1000), (_class$3 = class IMClient extends EventEmitter {
  /**
   * 无法直接实例化，请使用 {@link Realtime#createIMClient} 创建新的 IMClient。
   *
   * @extends EventEmitter
   */
  constructor(id, options = {}, props) {
    if (!(id === undefined || typeof id === 'string')) {
      throw new TypeError(`Client id [${id}] is not a String`);
    }

    super();
    Object.assign(this, {
      /**
       * @var id {String} 客户端 id
       * @memberof IMClient#
       */
      id,
      options
    }, props);

    if (!this._messageParser) {
      throw new Error('IMClient must be initialized with a MessageParser');
    }

    this._conversationCache = new Cache(`client:${this.id}`);
    this._ackMessageBuffer = {};
    internal(this).lastPatchTime = Date.now();
    internal(this).lastNotificationTime = undefined;
    internal(this)._eventemitter = new EventEmitter();

    if (debug$b.enabled) {
      values(IMEvent).forEach(event => this.on(event, (...payload) => this._debug(`${event} event emitted. %o`, payload)));
    } // onIMClientCreate hook


    applyDecorators(this._plugins.onIMClientCreate, this);
  }

  _debug(...params) {
    debug$b(...params, `[${this.id}]`);
  }
  /**
   * @override
   * @private
   */


  async _dispatchCommand(command) {
    this._debug(trim(command), 'received');

    if (command.serverTs && command.notificationType === 1) {
      internal(this).lastNotificationTime = getTime(decodeDate(command.serverTs));
    }

    switch (command.cmd) {
      case CommandType.conv:
        return this._dispatchConvMessage(command);

      case CommandType.direct:
        return this._dispatchDirectMessage(command);

      case CommandType.session:
        return this._dispatchSessionMessage(command);

      case CommandType.unread:
        return this._dispatchUnreadMessage(command);

      case CommandType.rcp:
        return this._dispatchRcpMessage(command);

      case CommandType.patch:
        return this._dispatchPatchMessage(command);

      default:
        return this.emit(UNHANDLED_MESSAGE$1, command);
    }
  }

  async _dispatchSessionMessage(message) {
    const {
      sessionMessage: {
        code,
        reason
      }
    } = message;

    switch (message.op) {
      case OpType.closed:
        {
          internal(this)._eventemitter.emit('close');

          if (code === ErrorCode.SESSION_CONFLICT) {
            /**
             * 用户在其他客户端登录，当前客户端被服务端强行下线。详见文档「单点登录」章节。
             * @event IMClient#CONFLICT
             * @param {Object} payload
             * @param {string} payload.reason 原因
             */
            return this.emit(CONFLICT$1, {
              reason
            });
          }
          /**
           * 当前客户端被服务端强行下线
           * @event IMClient#CLOSE
           * @param {Object} payload
           * @param {Number} payload.code 错误码
           * @param {String} payload.reason 原因
           */


          return this.emit(CLOSE$1, {
            code,
            reason
          });
        }

      default:
        this.emit(UNHANDLED_MESSAGE$1, message);
        throw new Error('Unrecognized session command');
    }
  }

  _dispatchUnreadMessage({
    unreadMessage: {
      convs,
      notifTime
    }
  }) {
    internal(this).lastUnreadNotifTime = notifTime; // ensure all converstions are cached

    return this.getConversations(convs.map(conv => conv.cid)).then(() => // update conversations data
    Promise.all(convs.map(({
      cid,
      unread,
      mid,
      timestamp: ts,
      from,
      data,
      binaryMsg,
      patchTimestamp,
      mentioned
    }) => {
      const conversation = this._conversationCache.get(cid); // deleted conversation


      if (!conversation) return null;
      let timestamp;

      if (ts) {
        timestamp = decodeDate(ts);
        conversation.lastMessageAt = timestamp; // eslint-disable-line no-param-reassign
      }

      return (mid ? this._messageParser.parse(binaryMsg || data).then(message => {
        const messageProps = {
          id: mid,
          cid,
          timestamp,
          updatedAt: patchTimestamp,
          from
        };
        Object.assign(message, messageProps);
        conversation.lastMessage = message; // eslint-disable-line no-param-reassign
      }) : Promise.resolve()).then(() => {
        conversation._setUnreadMessagesMentioned(mentioned);

        const countNotUpdated = unread === internal(conversation).unreadMessagesCount;
        if (countNotUpdated) return null; // to be filtered
        // manipulate internal property directly to skip unreadmessagescountupdate event

        internal(conversation).unreadMessagesCount = unread;
        return conversation;
      }); // filter conversations without unread count update
    })).then(conversations => conversations.filter(conversation => conversation))).then(conversations => {
      if (conversations.length) {
        /**
         * 未读消息数目更新
         * @event IMClient#UNREAD_MESSAGES_COUNT_UPDATE
         * @since 3.4.0
         * @param {Conversation[]} conversations 未读消息数目有更新的对话列表
         */
        this.emit(UNREAD_MESSAGES_COUNT_UPDATE$1, conversations);
      }
    });
  }

  async _dispatchRcpMessage(message) {
    const {
      rcpMessage,
      rcpMessage: {
        read
      }
    } = message;
    const conversationId = rcpMessage.cid;
    const messageId = rcpMessage.id;
    const timestamp = decodeDate(rcpMessage.t);

    const conversation = this._conversationCache.get(conversationId); // conversation not cached means the client does not send the message
    // during this session


    if (!conversation) return;

    conversation._handleReceipt({
      messageId,
      timestamp,
      read
    });
  }

  _dispatchPatchMessage({
    patchMessage: {
      patches
    }
  }) {
    // ensure all converstions are cached
    return this.getConversations(patches.map(patch => patch.cid)).then(() => Promise.all(patches.map(({
      cid,
      mid,
      timestamp,
      recall,
      data,
      patchTimestamp,
      from,
      binaryMsg,
      mentionAll,
      mentionPids,
      patchCode,
      patchReason
    }) => {
      const conversation = this._conversationCache.get(cid); // deleted conversation


      if (!conversation) return null;
      return this._messageParser.parse(binaryMsg || data).then(message => {
        const patchTime = getTime(decodeDate(patchTimestamp));
        const messageProps = {
          id: mid,
          cid,
          timestamp,
          updatedAt: patchTime,
          from,
          mentionList: mentionPids,
          mentionedAll: mentionAll
        };
        Object.assign(message, messageProps);

        message._setStatus(MessageStatus.SENT);

        message._updateMentioned(this.id);

        if (internal(this).lastPatchTime < patchTime) {
          internal(this).lastPatchTime = patchTime;
        } // update conversation lastMessage


        if (conversation.lastMessage && conversation.lastMessage.id === mid) {
          conversation.lastMessage = message; // eslint-disable-line no-param-reassign
        }

        let reason;

        if (patchCode) {
          reason = {
            code: patchCode.toNumber(),
            detail: patchReason
          };
        }

        if (recall) {
          /**
           * 消息被撤回
           * @event IMClient#MESSAGE_RECALL
           * @param {AVMessage} message 被撤回的消息
           * @param {ConversationBase} conversation 消息所在的会话
           * @param {PatchReason} [reason] 撤回的原因，不存在代表是发送者主动撤回
           */
          this.emit(MESSAGE_RECALL$1, message, conversation, reason);
          /**
           * 消息被撤回
           * @event ConversationBase#MESSAGE_RECALL
           * @param {AVMessage} message 被撤回的消息
           * @param {PatchReason} [reason] 撤回的原因，不存在代表是发送者主动撤回
           */

          conversation.emit(MESSAGE_RECALL$1, message, reason);
        } else {
          /**
           * 消息被修改
           * @event IMClient#MESSAGE_UPDATE
           * @param {AVMessage} message 被修改的消息
           * @param {ConversationBase} conversation 消息所在的会话
           * @param {PatchReason} [reason] 修改的原因，不存在代表是发送者主动修改
           */
          this.emit(MESSAGE_UPDATE$1, message, conversation, reason);
          /**
           * 消息被修改
           * @event ConversationBase#MESSAGE_UPDATE
           * @param {AVMessage} message 被修改的消息
           * @param {PatchReason} [reason] 修改的原因，不存在代表是发送者主动修改
           */

          conversation.emit(MESSAGE_UPDATE$1, message, reason);
        }
      });
    })));
  }

  async _dispatchConvMessage(message) {
    const {
      convMessage,
      convMessage: {
        initBy,
        m,
        info,
        attr
      }
    } = message;
    const conversation = await this.getConversation(convMessage.cid);

    switch (message.op) {
      case OpType.joined:
        {
          conversation._addMembers([this.id]);

          const payload = {
            invitedBy: initBy
          };
          /**
           * 当前用户被添加至某个对话
           * @event IMClient#INVITED
           * @param {Object} payload
           * @param {String} payload.invitedBy 邀请者 id
           * @param {ConversationBase} conversation
           */

          this.emit(INVITED$1, payload, conversation);
          /**
           * 当前用户被添加至当前对话
           * @event ConversationBase#INVITED
           * @param {Object} payload
           * @param {String} payload.invitedBy 该移除操作的发起者 id
           */

          conversation.emit(INVITED$1, payload);
          return;
        }

      case OpType.left:
        {
          conversation._removeMembers([this.id]);

          const payload = {
            kickedBy: initBy
          };
          /**
           * 当前用户被从某个对话中移除
           * @event IMClient#KICKED
           * @param {Object} payload
           * @param {String} payload.kickedBy 该移除操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(KICKED$1, payload, conversation);
          /**
           * 当前用户被从当前对话中移除
           * @event ConversationBase#KICKED
           * @param {Object} payload
           * @param {String} payload.kickedBy 该移除操作的发起者 id
           */

          conversation.emit(KICKED$1, payload);
          return;
        }

      case OpType.members_joined:
        {
          conversation._addMembers(m);

          const payload = {
            invitedBy: initBy,
            members: m
          };
          /**
           * 有用户被添加至某个对话
           * @event IMClient#MEMBERS_JOINED
           * @param {Object} payload
           * @param {String[]} payload.members 被添加的用户 id 列表
           * @param {String} payload.invitedBy 邀请者 id
           * @param {ConversationBase} conversation
           */

          this.emit(MEMBERS_JOINED$1, payload, conversation);
          /**
           * 有成员被添加至当前对话
           * @event ConversationBase#MEMBERS_JOINED
           * @param {Object} payload
           * @param {String[]} payload.members 被添加的成员 id 列表
           * @param {String} payload.invitedBy 邀请者 id
           */

          conversation.emit(MEMBERS_JOINED$1, payload);
          return;
        }

      case OpType.members_left:
        {
          conversation._removeMembers(m);

          const payload = {
            kickedBy: initBy,
            members: m
          };
          /**
           * 有成员被从某个对话中移除
           * @event IMClient#MEMBERS_LEFT
           * @param {Object} payload
           * @param {String[]} payload.members 被移除的成员 id 列表
           * @param {String} payload.kickedBy 该移除操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(MEMBERS_LEFT$1, payload, conversation);
          /**
           * 有成员被从当前对话中移除
           * @event ConversationBase#MEMBERS_LEFT
           * @param {Object} payload
           * @param {String[]} payload.members 被移除的成员 id 列表
           * @param {String} payload.kickedBy 该移除操作的发起者 id
           */

          conversation.emit(MEMBERS_LEFT$1, payload);
          return;
        }

      case OpType.members_blocked:
        {
          const payload = {
            blockedBy: initBy,
            members: m
          };
          /**
           * 有成员被加入某个对话的黑名单
           * @event IMClient#MEMBERS_BLOCKED
           * @param {Object} payload
           * @param {String[]} payload.members 成员 id 列表
           * @param {String} payload.blockedBy 该操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(MEMBERS_BLOCKED$1, payload, conversation);
          /**
           * 有成员被加入当前对话的黑名单
           * @event ConversationBase#MEMBERS_BLOCKED
           * @param {Object} payload
           * @param {String[]} payload.members 成员 id 列表
           * @param {String} payload.blockedBy 该操作的发起者 id
           */

          conversation.emit(MEMBERS_BLOCKED$1, payload);
          return;
        }

      case OpType.members_unblocked:
        {
          const payload = {
            unblockedBy: initBy,
            members: m
          };
          /**
           * 有成员被移出某个对话的黑名单
           * @event IMClient#MEMBERS_UNBLOCKED
           * @param {Object} payload
           * @param {String[]} payload.members 成员 id 列表
           * @param {String} payload.unblockedBy 该操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(MEMBERS_UNBLOCKED$1, payload, conversation);
          /**
           * 有成员被移出当前对话的黑名单
           * @event ConversationBase#MEMBERS_UNBLOCKED
           * @param {Object} payload
           * @param {String[]} payload.members 成员 id 列表
           * @param {String} payload.unblockedBy 该操作的发起者 id
           */

          conversation.emit(MEMBERS_UNBLOCKED$1, payload);
          return;
        }

      case OpType.blocked:
        {
          const payload = {
            blockedBy: initBy
          };
          /**
           * 当前用户被加入某个对话的黑名单
           * @event IMClient#BLOCKED
           * @param {Object} payload
           * @param {String} payload.blockedBy 该操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(BLOCKED$1, payload, conversation);
          /**
           * 当前用户被加入当前对话的黑名单
           * @event ConversationBase#BLOCKED
           * @param {Object} payload
           * @param {String} payload.blockedBy 该操作的发起者 id
           */

          conversation.emit(BLOCKED$1, payload);
          return;
        }

      case OpType.unblocked:
        {
          const payload = {
            unblockedBy: initBy
          };
          /**
           * 当前用户被移出某个对话的黑名单
           * @event IMClient#UNBLOCKED
           * @param {Object} payload
           * @param {String} payload.unblockedBy 该操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(UNBLOCKED$1, payload, conversation);
          /**
           * 当前用户被移出当前对话的黑名单
           * @event ConversationBase#UNBLOCKED
           * @param {Object} payload
           * @param {String} payload.unblockedBy 该操作的发起者 id
           */

          conversation.emit(UNBLOCKED$1, payload);
          return;
        }

      case OpType.members_shutuped:
        {
          const payload = {
            mutedBy: initBy,
            members: m
          };
          /**
           * 有成员在某个对话中被禁言
           * @event IMClient#MEMBERS_MUTED
           * @param {Object} payload
           * @param {String[]} payload.members 成员 id 列表
           * @param {String} payload.mutedBy 该操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(MEMBERS_MUTED$1, payload, conversation);
          /**
           * 有成员在当前对话中被禁言
           * @event ConversationBase#MEMBERS_MUTED
           * @param {Object} payload
           * @param {String[]} payload.members 成员 id 列表
           * @param {String} payload.mutedBy 该操作的发起者 id
           */

          conversation.emit(MEMBERS_MUTED$1, payload);
          return;
        }

      case OpType.members_unshutuped:
        {
          const payload = {
            unmutedBy: initBy,
            members: m
          };
          /**
           * 有成员在某个对话中被解除禁言
           * @event IMClient#MEMBERS_UNMUTED
           * @param {Object} payload
           * @param {String[]} payload.members 成员 id 列表
           * @param {String} payload.unmutedBy 该操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(MEMBERS_UNMUTED$1, payload, conversation);
          /**
           * 有成员在当前对话中被解除禁言
           * @event ConversationBase#MEMBERS_UNMUTED
           * @param {Object} payload
           * @param {String[]} payload.members 成员 id 列表
           * @param {String} payload.unmutedBy 该操作的发起者 id
           */

          conversation.emit(MEMBERS_UNMUTED$1, payload);
          return;
        }

      case OpType.shutuped:
        {
          const payload = {
            mutedBy: initBy
          };
          /**
           * 有成员在某个对话中被禁言
           * @event IMClient#MUTED
           * @param {Object} payload
           * @param {String} payload.mutedBy 该操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(MUTED$1, payload, conversation);
          /**
           * 有成员在当前对话中被禁言
           * @event ConversationBase#MUTED
           * @param {Object} payload
           * @param {String} payload.mutedBy 该操作的发起者 id
           */

          conversation.emit(MUTED$1, payload);
          return;
        }

      case OpType.unshutuped:
        {
          const payload = {
            unmutedBy: initBy
          };
          /**
           * 有成员在某个对话中被解除禁言
           * @event IMClient#UNMUTED
           * @param {Object} payload
           * @param {String} payload.unmutedBy 该操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(UNMUTED$1, payload, conversation);
          /**
           * 有成员在当前对话中被解除禁言
           * @event ConversationBase#UNMUTED
           * @param {Object} payload
           * @param {String} payload.unmutedBy 该操作的发起者 id
           */

          conversation.emit(UNMUTED$1, payload);
          return;
        }

      case OpType.member_info_changed:
        {
          const {
            pid,
            role
          } = info;
          const {
            memberInfoMap
          } = internal(conversation); // 如果不存在缓存，且不是 role 的更新，则不通知

          if (!memberInfoMap && !role) return;
          const memberInfo = await conversation.getMemberInfo(pid);
          internal(memberInfo).role = role;
          const payload = {
            member: pid,
            memberInfo,
            updatedBy: initBy
          };
          /**
           * 有成员的对话信息被更新
           * @event IMClient#MEMBER_INFO_UPDATED
           * @param {Object} payload
           * @param {String} payload.member 被更新对话信息的成员 id
           * @param {ConversationMumberInfo} payload.memberInfo 被更新的成员对话信息
           * @param {String} payload.updatedBy 该操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(MEMBER_INFO_UPDATED$1, payload, conversation);
          /**
           * 有成员的对话信息被更新
           * @event ConversationBase#MEMBER_INFO_UPDATED
           * @param {Object} payload
           * @param {String} payload.member 被更新对话信息的成员 id
           * @param {ConversationMumberInfo} payload.memberInfo 被更新的成员对话信息
           * @param {String} payload.updatedBy 该操作的发起者 id
           */

          conversation.emit(MEMBER_INFO_UPDATED$1, payload);
          return;
        }

      case OpType.updated:
        {
          const attributes = decode(JSON.parse(attr.data));

          conversation._updateServerAttributes(attributes);

          const payload = {
            attributes,
            updatedBy: initBy
          };
          /**
           * 该对话信息被更新
           * @event IMClient#CONVERSATION_INFO_UPDATED
           * @param {Object} payload
           * @param {Object} payload.attributes 被更新的属性
           * @param {String} payload.updatedBy 该操作的发起者 id
           * @param {ConversationBase} conversation
           */

          this.emit(CONVERSATION_INFO_UPDATED$1, payload, conversation);
          /**
           * 有对话信息被更新
           * @event ConversationBase#INFO_UPDATED
           * @param {Object} payload
           * @param {Object} payload.attributes 被更新的属性
           * @param {String} payload.updatedBy 该操作的发起者 id
           */

          conversation.emit(INFO_UPDATED$1, payload);
          return;
        }

      default:
        this.emit(UNHANDLED_MESSAGE$1, message);
        throw new Error('Unrecognized conversation command');
    }
  }

  _dispatchDirectMessage(originalMessage) {
    const {
      directMessage,
      directMessage: {
        id,
        cid,
        fromPeerId,
        timestamp,
        transient,
        patchTimestamp,
        mentionPids,
        mentionAll,
        binaryMsg,
        msg
      }
    } = originalMessage;
    const content = binaryMsg ? binaryMsg.toArrayBuffer() : msg;
    return Promise.all([this.getConversation(directMessage.cid), this._messageParser.parse(content)]).then(([conversation, message]) => {
      // deleted conversation
      if (!conversation) return undefined;
      const messageProps = {
        id,
        cid,
        timestamp,
        updatedAt: patchTimestamp,
        from: fromPeerId,
        mentionList: mentionPids,
        mentionedAll: mentionAll
      };
      Object.assign(message, messageProps);

      message._updateMentioned(this.id);

      message._setStatus(MessageStatus.SENT); // filter outgoing message sent from another device


      if (message.from !== this.id) {
        if (!(transient || conversation.transient)) {
          this._sendAck(message);
        }
      }

      return this._dispatchParsedMessage(message, conversation);
    });
  }

  _dispatchParsedMessage(message, conversation) {
    // beforeMessageDispatch hook
    return applyDispatcher(this._plugins.beforeMessageDispatch, [message, conversation]).then(shouldDispatch => {
      if (shouldDispatch === false) return;
      conversation.lastMessage = message; // eslint-disable-line no-param-reassign

      conversation.lastMessageAt = message.timestamp; // eslint-disable-line no-param-reassign
      // filter outgoing message sent from another device

      if (message.from !== this.id) {
        conversation.unreadMessagesCount += 1; // eslint-disable-line no-param-reassign

        if (message.mentioned) conversation._setUnreadMessagesMentioned(true);
      }
      /**
       * 当前用户收到消息
       * @event IMClient#MESSAGE
       * @param {Message} message
       * @param {ConversationBase} conversation 收到消息的对话
       */


      this.emit(MESSAGE$2, message, conversation);
      /**
       * 当前对话收到消息
       * @event ConversationBase#MESSAGE
       * @param {Message} message
       */

      conversation.emit(MESSAGE$2, message);
    });
  }

  _sendAck(message) {
    this._debug('send ack for %O', message);

    const {
      cid
    } = message;

    if (!cid) {
      throw new Error('missing cid');
    }

    if (!this._ackMessageBuffer[cid]) {
      this._ackMessageBuffer[cid] = [];
    }

    this._ackMessageBuffer[cid].push(message);

    return this._doSendAck();
  } // jsdoc-ignore-start


  // jsdoc-ignore-end
  _doSendAck() {
    // if not connected, just skip everything
    if (!this._connection.is('connected')) return;

    this._debug('do send ack %O', this._ackMessageBuffer);

    Promise.all(Object.keys(this._ackMessageBuffer).map(cid => {
      const convAckMessages = this._ackMessageBuffer[cid];
      const timestamps = convAckMessages.map(message => message.timestamp);
      const command = new GenericCommand({
        cmd: 'ack',
        ackMessage: new AckCommand({
          cid,
          fromts: Math.min.apply(null, timestamps),
          tots: Math.max.apply(null, timestamps)
        })
      });
      delete this._ackMessageBuffer[cid];
      return this._send(command, false).catch(error => {
        this._debug('send ack failed: %O', error);

        this._ackMessageBuffer[cid] = convAckMessages;
      });
    }));
  }

  _omitPeerId(value) {
    internal(this).peerIdOmittable = value;
  }

  _send(cmd, ...args) {
    const command = cmd;

    if (!internal(this).peerIdOmittable && this.id) {
      command.peerId = this.id;
    }

    return this._connection.send(command, ...args);
  }

  async _open(appId, tag, deviceId, isReconnect = false) {
    this._debug('open session');

    const {
      lastUnreadNotifTime,
      lastPatchTime,
      lastNotificationTime
    } = internal(this);
    const command = new GenericCommand({
      cmd: 'session',
      op: 'open',
      appId,
      peerId: this.id,
      sessionMessage: new SessionCommand({
        ua: `js/${version}`,
        r: isReconnect,
        lastUnreadNotifTime,
        lastPatchTime,
        configBitmap
      })
    });

    if (!isReconnect) {
      Object.assign(command.sessionMessage, trim({
        tag,
        deviceId
      }));

      if (this.options.signatureFactory) {
        const signatureResult = await runSignatureFactory(this.options.signatureFactory, [this._identity]);
        Object.assign(command.sessionMessage, keyRemap({
          signature: 's',
          timestamp: 't',
          nonce: 'n'
        }, signatureResult));
      }
    } else {
      const sessionToken = await this._sessionManager.getSessionToken({
        autoRefresh: false
      });

      if (sessionToken && sessionToken !== Expirable.EXPIRED) {
        Object.assign(command.sessionMessage, {
          st: sessionToken
        });
      }
    }

    let resCommand;

    try {
      resCommand = await this._send(command);
    } catch (error) {
      if (error.code === ErrorCode.SESSION_TOKEN_EXPIRED) {
        if (!this._sessionManager) {
          // let it fail if sessoinToken not cached but command rejected as token expired
          // to prevent session openning flood
          throw new Error('Unexpected session expiration');
        }

        debug$b('Session token expired, reopening');

        this._sessionManager.revoke();

        return this._open(appId, tag, deviceId, isReconnect);
      }

      throw error;
    }

    const {
      peerId,
      sessionMessage,
      sessionMessage: {
        st: token,
        stTtl: tokenTTL,
        code
      },
      serverTs
    } = resCommand;

    if (code) {
      throw createError(sessionMessage);
    }

    if (peerId) {
      this.id = peerId;
      if (!this._identity) this._identity = peerId;

      if (token) {
        this._sessionManager = this._sessionManager || this._createSessionManager();

        this._sessionManager.setSessionToken(token, tokenTTL);
      }

      const serverTime = getTime(decodeDate(serverTs));

      if (serverTs) {
        internal(this).lastPatchTime = serverTime;
      }

      if (lastNotificationTime) {
        // Do not await for it as this is failable
        this._syncNotifications(lastNotificationTime).catch(error => console.warn('Syncing notifications failed:', error));
      } else {
        // Set timestamp to now for next reconnection
        internal(this).lastNotificationTime = serverTime;
      }
    } else {
      console.warn('Unexpected session opened without peerId.');
    }

    return undefined;
  }

  async _syncNotifications(timestamp) {
    const {
      hasMore,
      notifications
    } = await this._fetchNotifications(timestamp);
    notifications.forEach(notification => {
      const {
        cmd,
        op,
        serverTs,
        notificationType,
        ...payload
      } = notification;

      this._dispatchCommand({
        cmd: CommandType[cmd],
        op: OpType[op],
        serverTs,
        notificationType,
        [`${cmd}Message`]: payload
      });
    });

    if (hasMore) {
      return this._syncNotifications(internal(this).lastNotificationTime);
    }

    return undefined;
  }

  async _fetchNotifications(timestamp) {
    return this._requestWithSessionToken({
      method: 'GET',
      path: '/rtm/notifications',
      query: {
        start_ts: timestamp,
        notification_type: 'permanent'
      }
    });
  }

  _createSessionManager() {
    debug$b('create SessionManager');
    return new SessionManager({
      onBeforeGetSessionToken: this._connection.checkConnectionAvailability.bind(this._connection),
      refresh: (manager, expiredSessionToken) => manager.setSessionTokenAsync(Promise.resolve(new GenericCommand({
        cmd: 'session',
        op: 'refresh',
        sessionMessage: new SessionCommand({
          ua: `js/${version}`,
          st: expiredSessionToken
        })
      })).then(async command => {
        if (this.options.signatureFactory) {
          const signatureResult = await runSignatureFactory(this.options.signatureFactory, [this._identity]);
          Object.assign(command.sessionMessage, keyRemap({
            signature: 's',
            timestamp: 't',
            nonce: 'n'
          }, signatureResult));
        }

        return command;
      }).then(this._send.bind(this)).then(({
        sessionMessage: {
          st: token,
          stTtl: ttl
        }
      }) => [token, ttl]))
    });
  }

  async _requestWithSessionToken({
    headers,
    query,
    ...params
  }) {
    const sessionToken = await this._sessionManager.getSessionToken();
    return this._request({
      headers: {
        'X-LC-IM-Session-Token': sessionToken,
        ...headers
      },
      query: {
        client_id: this.id,
        ...query
      },
      ...params
    });
  }
  /**
   * 关闭客户端
   * @return {Promise}
   */


  async close() {
    this._debug('close session');

    const _ee = internal(this)._eventemitter;

    _ee.emit('beforeclose');

    if (this._connection.is('connected')) {
      const command = new GenericCommand({
        cmd: 'session',
        op: 'close'
      });
      await this._send(command);
    }

    _ee.emit('close');

    this.emit(CLOSE$1, {
      code: 0
    });
  }
  /**
   * 获取 client 列表中在线的 client，每次查询最多 20 个 clientId，超出部分会被忽略
   * @param  {String[]} clientIds 要查询的 client ids
   * @return {Primse.<String[]>} 在线的 client ids
   */


  async ping(clientIds) {
    this._debug('ping');

    if (!(clientIds instanceof Array)) {
      throw new TypeError(`clientIds ${clientIds} is not an Array`);
    }

    if (!clientIds.length) {
      return Promise.resolve([]);
    }

    const command = new GenericCommand({
      cmd: 'session',
      op: 'query',
      sessionMessage: new SessionCommand({
        sessionPeerIds: clientIds
      })
    });
    const resCommand = await this._send(command);
    return resCommand.sessionMessage.onlineSessionPeerIds;
  }
  /**
   * 获取某个特定的对话
   * @param  {String} id 对话 id，对应 _Conversation 表中的 objectId
   * @param  {Boolean} [noCache=false] 强制不从缓存中获取
   * @return {Promise.<ConversationBase>} 如果 id 对应的对话不存在则返回 null
   */


  async getConversation(id, noCache = false) {
    if (typeof id !== 'string') {
      throw new TypeError(`${id} is not a String`);
    }

    if (!noCache) {
      const cachedConversation = this._conversationCache.get(id);

      if (cachedConversation) {
        return cachedConversation;
      }
    }

    if (isTemporaryConversatrionId(id)) {
      return (await this._getTemporaryConversations([id]))[0] || null;
    }

    return this.getQuery().equalTo('objectId', id).find().then(conversations => conversations[0] || null);
  }
  /**
   * 通过 id 批量获取某个特定的对话
   * @since 3.4.0
   * @param  {String[]} ids 对话 id 列表，对应 _Conversation 表中的 objectId
   * @param  {Boolean} [noCache=false] 强制不从缓存中获取
   * @return {Promise.<ConversationBase[]>} 如果 id 对应的对话不存在则返回 null
   */


  async getConversations(ids, noCache = false) {
    const remoteConversationIds = noCache ? ids : ids.filter(id => this._conversationCache.get(id) === null);

    if (remoteConversationIds.length) {
      const remoteTemporaryConversationIds = remove(remoteConversationIds, isTemporaryConversatrionId);
      const query = [];

      if (remoteConversationIds.length) {
        query.push(this.getQuery().containedIn('objectId', remoteConversationIds).limit(999).find());
      }

      if (remoteTemporaryConversationIds.length) {
        const remoteTemporaryConversationsPromise = remoteTemporaryConversationIds.map(this._getTemporaryConversations.bind(this));
        query.push(...remoteTemporaryConversationsPromise);
      }

      await Promise.all(query);
    }

    return ids.map(id => this._conversationCache.get(id));
  }

  async _getTemporaryConversations(ids) {
    const command = new GenericCommand({
      cmd: 'conv',
      op: 'query',
      convMessage: new ConvCommand({
        tempConvIds: ids
      })
    });
    const resCommand = await this._send(command);
    return this._handleQueryResults(resCommand);
  }
  /**
   * 构造一个 ConversationQuery 来查询对话
   * @return {ConversationQuery.<PersistentConversation>}
   */


  getQuery() {
    return new ConversationQuery(this);
  }
  /**
   * 构造一个 ConversationQuery 来查询聊天室
   * @return {ConversationQuery.<ChatRoom>}
   */


  getChatRoomQuery() {
    return this.getQuery().equalTo('tr', true);
  }
  /**
   * 构造一个 ConversationQuery 来查询服务号
   * @return {ConversationQuery.<ServiceConversation>}
   */


  getServiceConversationQuery() {
    return this.getQuery().equalTo('sys', true);
  }

  async _executeQuery(query) {
    const queryJSON = query.toJSON();
    queryJSON.where = new JsonObjectMessage({
      data: JSON.stringify(encode(queryJSON.where))
    });
    const command = new GenericCommand({
      cmd: 'conv',
      op: 'query',
      convMessage: new ConvCommand(queryJSON)
    });
    const resCommand = await this._send(command);
    return this._handleQueryResults(resCommand);
  }

  async _handleQueryResults(resCommand) {
    let conversations;

    try {
      conversations = decode(JSON.parse(resCommand.convMessage.results.data));
    } catch (error) {
      const commandString = JSON.stringify(trim(resCommand));
      throw new Error(`Parse query result failed: ${error.message}. Command: ${commandString}`);
    }

    conversations = await Promise.all(conversations.map(this._parseConversationFromRawData.bind(this)));
    return conversations.map(this._upsertConversationToCache.bind(this));
  }

  _upsertConversationToCache(fetchedConversation) {
    let conversation = this._conversationCache.get(fetchedConversation.id);

    if (!conversation) {
      conversation = fetchedConversation;

      this._debug('no match, set cache');

      this._conversationCache.set(fetchedConversation.id, fetchedConversation);
    } else {
      this._debug('update cached conversation');

      ['creator', 'createdAt', 'updatedAt', 'lastMessageAt', 'lastMessage', 'mutedMembers', 'members', '_attributes', 'transient', 'muted'].forEach(key => {
        const value = fetchedConversation[key];
        if (value !== undefined) conversation[key] = value;
      });
      if (conversation._reset) conversation._reset();
    }

    return conversation;
  }
  /**
   * 反序列化消息，与 {@link Message#toFullJSON} 相对。
   * @param {Object}
   * @return {AVMessage} 解析后的消息
   * @since 4.0.0
   */


  async parseMessage({
    data,
    bin = false,
    ...properties
  }) {
    const content = bin ? base64Arraybuffer.decode(data) : data;
    const message = await this._messageParser.parse(content);
    Object.assign(message, properties);

    message._updateMentioned(this.id);

    return message;
  }
  /**
   * 反序列化对话，与 {@link Conversation#toFullJSON} 相对。
   * @param {Object}
   * @return {ConversationBase} 解析后的对话
   * @since 4.0.0
   */


  async parseConversation({
    id,
    lastMessageAt,
    lastMessage,
    lastDeliveredAt,
    lastReadAt,
    unreadMessagesCount,
    members,
    mentioned,
    ...properties
  }) {
    const conversationData = {
      id,
      lastMessageAt,
      lastMessage,
      lastDeliveredAt,
      lastReadAt,
      unreadMessagesCount,
      members,
      mentioned
    };

    if (lastMessage) {
      conversationData.lastMessage = await this.parseMessage(lastMessage);

      conversationData.lastMessage._setStatus(MessageStatus.SENT);
    }

    const {
      transient,
      system,
      expiredAt
    } = properties;
    if (transient) return new ChatRoom(conversationData, properties, this);
    if (system) return new ServiceConversation(conversationData, properties, this);

    if (expiredAt || isTemporaryConversatrionId(id)) {
      return new TemporaryConversation(conversationData, {
        expiredAt
      }, this);
    }

    return new Conversation(conversationData, properties, this);
  }

  async _parseConversationFromRawData(rawData) {
    const data = keyRemap({
      objectId: 'id',
      lm: 'lastMessageAt',
      m: 'members',
      tr: 'transient',
      sys: 'system',
      c: 'creator',
      mu: 'mutedMembers'
    }, rawData);

    if (data.msg) {
      data.lastMessage = {
        data: data.msg,
        bin: data.bin,
        from: data.msg_from,
        id: data.msg_mid,
        timestamp: data.msg_timestamp,
        updatedAt: data.patch_timestamp
      };
      delete data.lastMessageFrom;
      delete data.lastMessageId;
      delete data.lastMessageTimestamp;
      delete data.lastMessagePatchTimestamp;
    }

    const {
      ttl
    } = data;
    if (ttl) data.expiredAt = Date.now() + ttl * 1000;
    return this.parseConversation(data);
  }
  /**
   * 创建一个对话
   * @param {Object} options 除了下列字段外的其他字段将被视为对话的自定义属性
   * @param {String[]} options.members 对话的初始成员列表，默认包含当前 client
   * @param {String} [options.name] 对话的名字
   * @param {Boolean} [options.unique=true] 唯一对话，当其为 true 时，如果当前已经有相同成员的对话存在则返回该对话，否则会创建新的对话
   * @return {Promise.<Conversation>}
   */


  async createConversation({
    members: m,
    name,
    transient,
    unique = true,
    _tempConv: tempConv,
    _tempConvTTL: tempConvTTL,
    ...properties
  } = {}) {
    if (!(transient || Array.isArray(m))) {
      throw new TypeError(`conversation members ${m} is not an array`);
    }

    let members = new Set(m);
    members.add(this.id);
    members = Array.from(members).sort();
    let attr = properties || {};

    if (name) {
      if (typeof name !== 'string') {
        throw new TypeError(`conversation name ${name} is not a string`);
      }

      attr.name = name;
    }

    attr = new JsonObjectMessage({
      data: JSON.stringify(encode(attr))
    });
    const startCommandJson = {
      m: members,
      attr,
      transient,
      unique,
      tempConv,
      tempConvTTL
    };
    const command = new GenericCommand({
      cmd: 'conv',
      op: 'start',
      convMessage: new ConvCommand(startCommandJson)
    });

    if (this.options.conversationSignatureFactory) {
      const params = [null, this._identity, members, 'create'];
      const signatureResult = await runSignatureFactory(this.options.conversationSignatureFactory, params);
      Object.assign(command.convMessage, keyRemap({
        signature: 's',
        timestamp: 't',
        nonce: 'n'
      }, signatureResult));
    }

    const {
      convMessage: {
        cid,
        cdate,
        tempConvTTL: ttl
      }
    } = await this._send(command);
    const data = {
      name,
      transient,
      unique,
      id: cid,
      createdAt: cdate,
      updatedAt: cdate,
      lastMessageAt: null,
      creator: this.id,
      members: transient ? [] : members,
      ...properties
    };
    if (ttl) data.expiredAt = Date.now() + ttl * 1000;
    const conversation = await this.parseConversation(data);
    return this._upsertConversationToCache(conversation);
  }
  /**
   * 创建一个聊天室
   * @since 4.0.0
   * @param {Object} options 除了下列字段外的其他字段将被视为对话的自定义属性
   * @param {String} [options.name] 对话的名字
   * @return {Promise.<ChatRoom>}
   */


  async createChatRoom(param) {
    return this.createConversation({ ...param,
      transient: true,
      members: null,
      unique: false,
      _tempConv: false
    });
  }
  /**
   * 创建一个临时对话
   * @since 4.0.0
   * @param {Object} options
   * @param {String[]} options.members 对话的初始成员列表，默认包含当前 client
   * @param {String} [options.ttl] 对话存在时间，单位为秒，最大值与默认值均为 86400（一天），过期后该对话不再可用。
   * @return {Promise.<TemporaryConversation>}
   */


  async createTemporaryConversation({
    ttl: _tempConvTTL,
    ...param
  }) {
    return this.createConversation({ ...param,
      _tempConv: true,
      _tempConvTTL
    });
  } // jsdoc-ignore-start


  // jsdoc-ignore-end
  _doSendRead() {
    // if not connected, just skip everything
    if (!this._connection.is('connected')) return;
    const buffer = internal(this).readConversationsBuffer;
    const conversations = Array.from(buffer);
    if (!conversations.length) return;
    const ids = conversations.map(conversation => {
      if (!(conversation instanceof ConversationBase)) {
        throw new TypeError(`${conversation} is not a Conversation`);
      }

      return conversation.id;
    });

    this._debug(`mark [${ids}] as read`);

    buffer.clear();

    this._sendReadCommand(conversations).catch(error => {
      this._debug('send read failed: %O', error);

      conversations.forEach(buffer.add.bind(buffer));
    });
  }

  _sendReadCommand(conversations) {
    return this._send(new GenericCommand({
      cmd: 'read',
      readMessage: new ReadCommand({
        convs: conversations.map(conversation => new ReadTuple({
          cid: conversation.id,
          mid: conversation.lastMessage && conversation.lastMessage.from !== this.id ? conversation.lastMessage.id : undefined,
          timestamp: (conversation.lastMessageAt || new Date()).getTime()
        }))
      })
    }), false);
  }

}, (_applyDecoratedDescriptor(_class$3.prototype, "_doSendAck", [_dec$2], Object.getOwnPropertyDescriptor(_class$3.prototype, "_doSendAck"), _class$3.prototype), _applyDecoratedDescriptor(_class$3.prototype, "_doSendRead", [_dec2], Object.getOwnPropertyDescriptor(_class$3.prototype, "_doSendRead"), _class$3.prototype)), _class$3));
/**
 * 修改、撤回消息的原因
 * @typedef PatchReason
 * @type {Object}
 * @property {number} code 负数为内置 code，正数为开发者在 hook 中自定义的 code。比如因为敏感词过滤被修改的 code 为 -4408。
 * @property {string} [detail] 具体的原因说明。
 */

const RECONNECT_ERROR = 'reconnecterror';

var CoreEvent = /*#__PURE__*/Object.freeze({
  __proto__: null,
  RECONNECT_ERROR: RECONNECT_ERROR,
  DISCONNECT: DISCONNECT,
  RECONNECT: RECONNECT,
  RETRY: RETRY,
  SCHEDULE: SCHEDULE,
  OFFLINE: OFFLINE,
  ONLINE: ONLINE
});

var _class$4;

let  // jsdoc-ignore-end
BinaryMessage = IE10Compatible(_class$4 = class BinaryMessage extends Message {
  /**
   * 二进制消息
   * @extends Message
   * @param {ArrayBuffer} buffer
   * @since 4.0.0
   */
  constructor(buffer) {
    if (!(buffer instanceof ArrayBuffer)) {
      throw new TypeError(`${buffer} is not an ArrayBuffer`);
    }

    super(buffer);
  }
  /**
   * @type ArrayBuffer
   */


  get buffer() {
    return this.content;
  }

  set buffer(buffer) {
    this.content = buffer;
  }

  static validate(target) {
    return target instanceof ArrayBuffer;
  }

  toJSON() {
    return { ...super._toJSON(),
      data: base64Arraybuffer.encode(this.content)
    };
  }

  toFullJSON() {
    return { ...super.toFullJSON(),
      bin: true,
      data: base64Arraybuffer.encode(this.content)
    };
  }

}) || _class$4;

var _dec$3, _class$5;

let  // jsdoc-ignore-end
TextMessage = (_dec$3 = messageType(-1), _dec$3(_class$5 = IE10Compatible(_class$5 = class TextMessage extends TypedMessage {
  /**
   * 文类类型消息
   * @extends TypedMessage
   * @param  {String} [text='']
   * @throws {TypeError} text 不是 String 类型
   */
  constructor(text = '') {
    if (typeof text !== 'string') {
      throw new TypeError(`${text} is not a string`);
    }

    super();
    this.setText(text);
  }

}) || _class$5) || _class$5);
/**
 * @name TYPE
 * @memberof TextMessage
 * @type Number
 * @static
 * @const
 */

var _class$6;
const debug$c = d('LC:MessageParser');

const tryParseJson = (target, key, descriptor) => {
  const fn = descriptor.value; // eslint-disable-next-line no-param-reassign

  descriptor.value = function wrapper(param) {
    let content;

    if (typeof param !== 'string') {
      content = param;
    } else {
      try {
        content = JSON.parse(param);
      } catch (error) {
        content = param;
      }
    }

    return fn.call(this, content);
  };
};

const applyPlugins = (target, key, descriptor) => {
  const fn = descriptor.value; // eslint-disable-next-line no-param-reassign

  descriptor.value = function wrapper(json) {
    return Promise.resolve(json).then(applyMiddlewares(this._plugins.beforeMessageParse)).then(decoratedJson => fn.call(this, decoratedJson)).then(applyMiddlewares(this._plugins.afterMessageParse));
  };
};

let MessageParser = (_class$6 = class MessageParser {
  /**
   * 消息解析器
   * @param {Object} plugins 插件，插件的 messageClasses 会自动被注册，在解析时 beforeMessageParse 与 afterMessageParse Middleware 会被应用。
   */
  constructor(plugins = {}) {
    this._plugins = plugins;
    this._messageClasses = [];
    this.register(plugins.messageClasses);
  }
  /**
   * 注册消息类
   *
   * @param  {Function | Function[]} messageClass 消息类，需要实现 {@link AVMessage} 接口，
   * 建议继承自 {@link TypedMessage}，也可以传入一个消息类数组。
   * @throws {TypeError} 如果 messageClass 没有实现 {@link AVMessage} 接口则抛出异常
   */


  register(messageClasses) {
    ensureArray(messageClasses).map(klass => this._register(klass));
  }

  _register(messageClass) {
    if (messageClass && messageClass.parse && messageClass.prototype && messageClass.prototype.getPayload) {
      this._messageClasses.unshift(messageClass);
    } else {
      throw new TypeError('Invalid messageClass');
    }
  } // jsdoc-ignore-start


  // jsdoc-ignore-end

  /**
   * 解析消息内容
   * @param {Object | string | any} target 消息内容，如果是字符串会尝试 parse 为 JSON。
   * @return {AVMessage} 解析后的消息
   * @throws {Error} 如果不匹配任何注册的消息则抛出异常
   */
  parse(content) {
    debug$c('parsing message: %O', content); // eslint-disable-next-line

    for (const Klass of this._messageClasses) {
      const contentCopy = isPlainObject(content) ? { ...content
      } : content;
      let valid;
      let result;

      try {
        valid = Klass.validate(contentCopy);
      } catch (error) {// eslint-disable-line no-empty
      }

      if (valid) {
        try {
          result = Klass.parse(contentCopy);
        } catch (error) {
          console.warn('parsing a valid message content error', {
            error,
            Klass,
            content: contentCopy
          });
        }

        if (result !== undefined) {
          debug$c('parse result: %O', result);
          return result;
        }
      }
    }

    throw new Error('No Message Class matched');
  }

}, (_applyDecoratedDescriptor(_class$6.prototype, "parse", [tryParseJson, applyPlugins], Object.getOwnPropertyDescriptor(_class$6.prototype, "parse"), _class$6.prototype)), _class$6);

/** @module leancloud-realtime */
const debug$d = d('LC:IMPlugin');
/**
 * 消息优先级枚举
 * @enum {Number}
 * @since 3.3.0
 */

const MessagePriority = {
  /** 高 */
  HIGH: 1,

  /** 普通 */
  NORMAL: 2,

  /** 低 */
  LOW: 3
};
Object.freeze(MessagePriority);
/**
 * 为 Conversation 定义一个新属性
 * @param {String} prop 属性名
 * @param {Object} [descriptor] 属性的描述符，参见 {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor#Description getOwnPropertyDescriptor#Description - MDN}，默认为该属性名对应的 Conversation 自定义属性的 getter/setter
 * @returns void
 * @example
 *
 * conversation.get('type');
 * conversation.set('type', 1);
 *
 * // equals to
 * defineConversationProperty('type');
 * conversation.type;
 * conversation.type = 1;
 */

const defineConversationProperty = (prop, descriptor = {
  get() {
    return this.get(prop);
  },

  set(value) {
    this.set(prop, value);
  }

}) => {
  Object.defineProperty(Conversation.prototype, prop, descriptor);
};

const onRealtimeCreate = realtime => {
  /* eslint-disable no-param-reassign */
  const deviceId = uuid();
  realtime._IMClients = {};
  realtime._IMClientsCreationCount = 0;
  const messageParser = new MessageParser(realtime._plugins);
  realtime._messageParser = messageParser;

  const signAVUser = async user => realtime._request({
    method: 'POST',
    path: '/rtm/sign',
    data: {
      session_token: user.getSessionToken()
    }
  });
  /**
   * 注册消息类
   *
   * 在接收消息、查询消息时，会按照消息类注册顺序的逆序依次尝试解析消息内容
   *
   * @memberof Realtime
   * @instance
   * @param  {Function | Function[]} messageClass 消息类，需要实现 {@link AVMessage} 接口，
   * 建议继承自 {@link TypedMessage}
   * @throws {TypeError} 如果 messageClass 没有实现 {@link AVMessage} 接口则抛出异常
   */


  const register = messageParser.register.bind(messageParser);
  /**
   * 创建一个即时通讯客户端，多次创建相同 id 的客户端会返回同一个实例
   * @memberof Realtime
   * @instance
   * @param  {String|AV.User} [identity] 客户端 identity，如果不指定该参数，服务端会随机生成一个字符串作为 identity，
   * 如果传入一个已登录的 AV.User，则会使用该用户的 id 作为客户端 identity 登录。
   * @param  {Object} [options]
   * @param  {Function} [options.signatureFactory] open session 时的签名方法 // TODO need details
   * @param  {Function} [options.conversationSignatureFactory] 对话创建、增减成员操作时的签名方法
   * @param  {Function} [options.blacklistSignatureFactory] 黑名单操作时的签名方法
   * @param  {String} [options.tag] 客户端类型标记，以支持单点登录功能
   * @param  {String} [options.isReconnect=false] 单点登录时标记该次登录是不是应用启动时自动重新登录
   * @return {Promise.<IMClient>}
   */

  const createIMClient = async (identity, {
    tag,
    isReconnect,
    ...clientOptions
  } = {}, lagecyTag) => {
    let id;
    const buildinOptions = {};

    if (identity) {
      if (typeof identity === 'string') {
        id = identity;
      } else if (identity.id && identity.getSessionToken) {
        ({
          id
        } = identity);
        const sessionToken = identity.getSessionToken();

        if (!sessionToken) {
          throw new Error('User must be authenticated');
        }

        buildinOptions.signatureFactory = signAVUser;
      } else {
        throw new TypeError('Identity must be a String or an AV.User');
      }

      if (realtime._IMClients[id] !== undefined) {
        return realtime._IMClients[id];
      }
    }

    if (lagecyTag) {
      console.warn('DEPRECATION createIMClient tag param: Use options.tag instead.');
    }

    const _tag = tag || lagecyTag;

    const promise = realtime._open().then(connection => {
      const client = new IMClient(id, { ...buildinOptions,
        ...clientOptions
      }, {
        _connection: connection,
        _request: realtime._request.bind(realtime),
        _messageParser: messageParser,
        _plugins: realtime._plugins,
        _identity: identity
      });
      connection.on(RECONNECT, () => client._open(realtime._options.appId, _tag, deviceId, true)
      /**
       * 客户端连接恢复正常，该事件通常在 {@link Realtime#event:RECONNECT} 之后发生
       * @event IMClient#RECONNECT
       * @see Realtime#event:RECONNECT
       * @since 3.2.0
       */

      /**
       * 客户端重新登录发生错误（网络连接已恢复，但重新登录错误）
       * @event IMClient#RECONNECT_ERROR
       * @since 3.2.0
       */
      .then(() => client.emit(RECONNECT), error => client.emit(RECONNECT_ERROR, error)));

      internal(client)._eventemitter.on('beforeclose', () => {
        delete realtime._IMClients[client.id];

        if (realtime._firstIMClient === client) {
          delete realtime._firstIMClient;
        }
      }, realtime);

      internal(client)._eventemitter.on('close', () => {
        realtime._deregister(client);
      }, realtime);

      return client._open(realtime._options.appId, _tag, deviceId, isReconnect).then(() => {
        realtime._IMClients[client.id] = client;
        realtime._IMClientsCreationCount += 1;

        if (realtime._IMClientsCreationCount === 1) {
          client._omitPeerId(true);

          realtime._firstIMClient = client;
        } else if (realtime._IMClientsCreationCount > 1 && realtime._firstIMClient) {
          realtime._firstIMClient._omitPeerId(false);
        }

        realtime._register(client);

        return client;
      }).catch(error => {
        delete realtime._IMClients[client.id];
        throw error;
      });
    }).then(...finalize(() => {
      realtime._deregisterPending(promise);
    })).catch(error => {
      delete realtime._IMClients[id];
      throw error;
    });

    if (identity) {
      realtime._IMClients[id] = promise;
    }

    realtime._registerPending(promise);

    return promise;
  };

  Object.assign(realtime, {
    register,
    createIMClient
  });
  /* eslint-enable no-param-reassign */
};

const beforeCommandDispatch = (command, realtime) => {
  const isIMCommand = command.service === null || command.service === 2;
  if (!isIMCommand) return true;
  const targetClient = command.peerId ? realtime._IMClients[command.peerId] : realtime._firstIMClient;

  if (targetClient) {
    Promise.resolve(targetClient).then(client => client._dispatchCommand(command)).catch(debug$d);
  } else {
    debug$d('[WARN] Unexpected message received without any live client match: %O', trim(command));
  }

  return false;
};

const IMPlugin = {
  name: 'leancloud-realtime-plugin-im',
  onRealtimeCreate,
  beforeCommandDispatch,
  messageClasses: [Message, BinaryMessage, RecalledMessage, TextMessage]
};

/** @module leancloud-realtime */
Realtime.defineConversationProperty = defineConversationProperty;
Realtime.__preRegisteredPlugins = [IMPlugin];
const Event = { ...CoreEvent,
  ...IMEvent
};

/** core + plugins + platform adapters */
setAdapters({
  WebSocket: platformAdaptersNode.WebSocket,
  request: platformAdaptersNode.request
});

exports.EventEmitter = EventEmitter;
exports.BinaryMessage = BinaryMessage;
exports.ChatRoom = ChatRoom;
exports.Conversation = Conversation;
exports.ConversationMemberRole = ConversationMemberRole;
exports.ConversationQuery = ConversationQuery;
exports.ErrorCode = ErrorCode;
exports.Event = Event;
exports.IE10Compatible = IE10Compatible;
exports.IMPlugin = IMPlugin;
exports.Message = Message;
exports.MessageParser = MessageParser;
exports.MessagePriority = MessagePriority;
exports.MessageQueryDirection = MessageQueryDirection;
exports.MessageStatus = MessageStatus;
exports.Promise = polyfilledPromise;
exports.Protocals = message;
exports.Protocols = message;
exports.Realtime = Realtime;
exports.RecalledMessage = RecalledMessage;
exports.ServiceConversation = ServiceConversation;
exports.TemporaryConversation = TemporaryConversation;
exports.TextMessage = TextMessage;
exports.TypedMessage = TypedMessage;
exports.debug = debug$2;
exports.defineConversationProperty = defineConversationProperty;
exports.getAdapter = getAdapter;
exports.messageField = messageField;
exports.messageType = messageType;
exports.setAdapters = setAdapters;
//# sourceMappingURL=im-node.js.map