(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Tinode = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
/**
 * @file Access control model.
 *
 * @copyright 2015-2021 Tinode
 * @summary Javascript bindings for Tinode.
 * @license Apache 2.0
 * @version 0.17
 */
'use strict';

// NOTE TO DEVELOPERS:
// Localizable strings should be double quoted "строка на другом языке",
// non-localizable strings should be single quoted 'non-localized'.

/**
 * Helper class for handling access mode.
 *
 * @class AccessMode
 * @memberof Tinode
 *
 * @param {AccessMode|Object=} acs - AccessMode to copy or access mode object received from the server.
 */
const AccessMode = function(acs) {
  if (acs) {
    this.given = typeof acs.given == 'number' ? acs.given : AccessMode.decode(acs.given);
    this.want = typeof acs.want == 'number' ? acs.want : AccessMode.decode(acs.want);
    this.mode = acs.mode ? (typeof acs.mode == 'number' ? acs.mode : AccessMode.decode(acs.mode)) :
      (this.given & this.want);
  }
};

AccessMode._NONE = 0x00;
AccessMode._JOIN = 0x01;
AccessMode._READ = 0x02;
AccessMode._WRITE = 0x04;
AccessMode._PRES = 0x08;
AccessMode._APPROVE = 0x10;
AccessMode._SHARE = 0x20;
AccessMode._DELETE = 0x40;
AccessMode._OWNER = 0x80;

AccessMode._BITMASK = AccessMode._JOIN | AccessMode._READ | AccessMode._WRITE | AccessMode._PRES |
  AccessMode._APPROVE | AccessMode._SHARE | AccessMode._DELETE | AccessMode._OWNER;
AccessMode._INVALID = 0x100000;

AccessMode._checkFlag = function(val, side, flag) {
  side = side || 'mode';
  if (['given', 'want', 'mode'].includes(side)) {
    return ((val[side] & flag) != 0);
  }
  throw new Error(`Invalid AccessMode component '${side}'`);
}

/**
 * Parse string into an access mode value.
 * @memberof Tinode.AccessMode
 * @static
 *
 * @param {string | Number} mode - either a String representation of the access mode to parse or a set of bits to assign.
 * @returns {number} - Access mode as a numeric value.
 */
AccessMode.decode = function(str) {
  if (!str) {
    return null;
  } else if (typeof str == 'number') {
    return str & AccessMode._BITMASK;
  } else if (str === 'N' || str === 'n') {
    return AccessMode._NONE;
  }

  const bitmask = {
    'J': AccessMode._JOIN,
    'R': AccessMode._READ,
    'W': AccessMode._WRITE,
    'P': AccessMode._PRES,
    'A': AccessMode._APPROVE,
    'S': AccessMode._SHARE,
    'D': AccessMode._DELETE,
    'O': AccessMode._OWNER
  };

  let m0 = AccessMode._NONE;

  for (let i = 0; i < str.length; i++) {
    const bit = bitmask[str.charAt(i).toUpperCase()];
    if (!bit) {
      // Unrecognized bit, skip.
      continue;
    }
    m0 |= bit;
  }
  return m0;
};

/**
 * Convert numeric representation of the access mode into a string.
 *
 * @memberof Tinode.AccessMode
 * @static
 *
 * @param {number} val - access mode value to convert to a string.
 * @returns {string} - Access mode as a string.
 */
AccessMode.encode = function(val) {
  if (val === null || val === AccessMode._INVALID) {
    return null;
  } else if (val === AccessMode._NONE) {
    return 'N';
  }

  const bitmask = ['J', 'R', 'W', 'P', 'A', 'S', 'D', 'O'];
  let res = '';
  for (let i = 0; i < bitmask.length; i++) {
    if ((val & (1 << i)) != 0) {
      res = res + bitmask[i];
    }
  }
  return res;
};

/**
 * Update numeric representation of access mode with the new value. The value
 * is one of the following:
 *  - a string starting with <code>'+'</code> or <code>'-'</code> then the bits to add or remove, e.g. <code>'+R-W'</code> or <code>'-PS'</code>.
 *  - a new value of access mode
 *
 * @memberof Tinode.AccessMode
 * @static
 *
 * @param {number} val - access mode value to update.
 * @param {string} upd - update to apply to val.
 * @returns {number} - updated access mode.
 */
AccessMode.update = function(val, upd) {
  if (!upd || typeof upd != 'string') {
    return val;
  }

  let action = upd.charAt(0);
  if (action == '+' || action == '-') {
    let val0 = val;
    // Split delta-string like '+ABC-DEF+Z' into an array of parts including + and -.
    const parts = upd.split(/([-+])/);
    // Starting iteration from 1 because String.split() creates an array with the first empty element.
    // Iterating by 2 because we parse pairs +/- then data.
    for (let i = 1; i < parts.length - 1; i += 2) {
      action = parts[i];
      const m0 = AccessMode.decode(parts[i + 1]);
      if (m0 == AccessMode._INVALID) {
        return val;
      }
      if (m0 == null) {
        continue;
      }
      if (action === '+') {
        val0 |= m0;
      } else if (action === '-') {
        val0 &= ~m0;
      }
    }
    val = val0;
  } else {
    // The string is an explicit new value 'ABC' rather than delta.
    const val0 = AccessMode.decode(upd);
    if (val0 != AccessMode._INVALID) {
      val = val0;
    }
  }

  return val;
};

/**
 * Bits present in a1 but missing in a2.
 *
 * @static
 * @memberof Tinode
 *
 * @param {number | string} a1 - access mode to subtract from.
 * @param {number | string} a2 - access mode to subtract.
 * @returns {number} access mode with bits present in <code>a1</code> but missing in <code>a2</code>.
 */
AccessMode.diff = function(a1, a2) {
  a1 = AccessMode.decode(a1);
  a2 = AccessMode.decode(a2);

  if (a1 == AccessMode._INVALID || a2 == AccessMode._INVALID) {
    return AccessMode._INVALID;
  }
  return a1 & ~a2;
};

/**
 * AccessMode is a class representing topic access mode.
 *
 * @memberof Tinode
 * @class AccessMode
 */
AccessMode.prototype = {
  /**
   * Custom formatter
   */
  toString: function() {
    return '{"mode": "' + AccessMode.encode(this.mode) +
      '", "given": "' + AccessMode.encode(this.given) +
      '", "want": "' + AccessMode.encode(this.want) + '"}';
  },
  /**
   * Converts numeric values to strings.
   */
  jsonHelper: function() {
    return {
      mode: AccessMode.encode(this.mode),
      given: AccessMode.encode(this.given),
      want: AccessMode.encode(this.want)
    };
  },
  /**
   * Assign value to 'mode'.
   * @memberof Tinode.AccessMode
   *
   * @param {string | Number} m - either a string representation of the access mode or a set of bits.
   * @returns {AccessMode} - <code>this</code> AccessMode.
   */
  setMode: function(m) {
    this.mode = AccessMode.decode(m);
    return this;
  },
  /**
   * Update <code>mode</code> value.
   * @memberof Tinode.AccessMode
   *
   * @param {string} u - string representation of the changes to apply to access mode.
   * @returns {AccessMode} - <code>this</code> AccessMode.
   */
  updateMode: function(u) {
    this.mode = AccessMode.update(this.mode, u);
    return this;
  },
  /**
   * Get <code>mode</code> value as a string.
   * @memberof Tinode.AccessMode
   *
   * @returns {string} - <code>mode</code> value.
   */
  getMode: function() {
    return AccessMode.encode(this.mode);
  },

  /**
   * Assign <code>given</code>  value.
   * @memberof Tinode.AccessMode
   *
   * @param {string | Number} g - either a string representation of the access mode or a set of bits.
   * @returns {AccessMode} - <code>this</code> AccessMode.
   */
  setGiven: function(g) {
    this.given = AccessMode.decode(g);
    return this;
  },
  /**
   * Update 'given' value.
   * @memberof Tinode.AccessMode
   *
   * @param {string} u - string representation of the changes to apply to access mode.
   * @returns {AccessMode} - <code>this</code> AccessMode.
   */
  updateGiven: function(u) {
    this.given = AccessMode.update(this.given, u);
    return this;
  },
  /**
   * Get 'given' value as a string.
   * @memberof Tinode.AccessMode
   *
   * @returns {string} - <b>given</b> value.
   */
  getGiven: function() {
    return AccessMode.encode(this.given);
  },

  /**
   * Assign 'want' value.
   * @memberof Tinode.AccessMode
   *
   * @param {string | Number} w - either a string representation of the access mode or a set of bits.
   * @returns {AccessMode} - <code>this</code> AccessMode.
   */
  setWant: function(w) {
    this.want = AccessMode.decode(w);
    return this;
  },
  /**
   * Update 'want' value.
   * @memberof Tinode.AccessMode
   *
   * @param {string} u - string representation of the changes to apply to access mode.
   * @returns {AccessMode} - <code>this</code> AccessMode.
   */
  updateWant: function(u) {
    this.want = AccessMode.update(this.want, u);
    return this;
  },
  /**
   * Get 'want' value as a string.
   * @memberof Tinode.AccessMode
   *
   * @returns {string} - <b>want</b> value.
   */
  getWant: function() {
    return AccessMode.encode(this.want);
  },

  /**
   * Get permissions present in 'want' but missing in 'given'.
   * Inverse of {@link Tinode.AccessMode#getExcessive}
   *
   * @memberof Tinode.AccessMode
   *
   * @returns {string} permissions present in <b>want</b> but missing in <b>given</b>.
   */
  getMissing: function() {
    return AccessMode.encode(this.want & ~this.given);
  },

  /**
   * Get permissions present in 'given' but missing in 'want'.
   * Inverse of {@link Tinode.AccessMode#getMissing}
   * @memberof Tinode.AccessMode
   *
   * @returns {string} permissions present in <b>given</b> but missing in <b>want</b>.
   */
  getExcessive: function() {
    return AccessMode.encode(this.given & ~this.want);
  },

  /**
   * Update 'want', 'give', and 'mode' values.
   * @memberof Tinode.AccessMode
   *
   * @param {AccessMode} val - new access mode value.
   * @returns {AccessMode} - <code>this</code> AccessMode.
   */
  updateAll: function(val) {
    if (val) {
      this.updateGiven(val.given);
      this.updateWant(val.want);
      this.mode = this.given & this.want;
    }
    return this;
  },

  /**
   * Check if Owner (O) flag is set.
   * @memberof Tinode.AccessMode
   * @param {string=} side - which permission to check: given, want, mode; default: mode.
   * @returns {boolean} - <code>true</code> if flag is set.
   */
  isOwner: function(side) {
    return AccessMode._checkFlag(this, side, AccessMode._OWNER);
  },

  /**
   * Check if Presence (P) flag is set.
   * @memberof Tinode.AccessMode
   * @param {string=} side - which permission to check: given, want, mode; default: mode.
   * @returns {boolean} - <code>true</code> if flag is set.
   */
  isPresencer: function(side) {
    return AccessMode._checkFlag(this, side, AccessMode._PRES);
  },

  /**
   * Check if Presence (P) flag is NOT set.
   * @memberof Tinode.AccessMode
   * @param {string=} side - which permission to check: given, want, mode; default: mode.
   * @returns {boolean} - <code>true</code> if flag is set.
   */
  isMuted: function(side) {
    return !this.isPresencer(side);
  },

  /**
   * Check if Join (J) flag is set.
   * @memberof Tinode.AccessMode
   * @param {string=} side - which permission to check: given, want, mode; default: mode.
   * @returns {boolean} - <code>true</code> if flag is set.
   */
  isJoiner: function(side) {
    return AccessMode._checkFlag(this, side, AccessMode._JOIN);
  },

  /**
   * Check if Reader (R) flag is set.
   * @memberof Tinode.AccessMode
   * @param {string=} side - which permission to check: given, want, mode; default: mode.
   * @returns {boolean} - <code>true</code> if flag is set.
   */
  isReader: function(side) {
    return AccessMode._checkFlag(this, side, AccessMode._READ);
  },

  /**
   * Check if Writer (W) flag is set.
   * @memberof Tinode.AccessMode
   * @param {string=} side - which permission to check: given, want, mode; default: mode.
   * @returns {boolean} - <code>true</code> if flag is set.
   */
  isWriter: function(side) {
    return AccessMode._checkFlag(this, side, AccessMode._WRITE);
  },

  /**
   * Check if Approver (A) flag is set.
   * @memberof Tinode.AccessMode
   * @param {string=} side - which permission to check: given, want, mode; default: mode.
   * @returns {boolean} - <code>true</code> if flag is set.
   */
  isApprover: function(side) {
    return AccessMode._checkFlag(this, side, AccessMode._APPROVE);
  },

  /**
   * Check if either one of Owner (O) or Approver (A) flags is set.
   * @memberof Tinode.AccessMode
   * @param {string=} side - which permission to check: given, want, mode; default: mode.
   * @returns {boolean} - <code>true</code> if flag is set.
   */
  isAdmin: function(side) {
    return this.isOwner(side) || this.isApprover(side);
  },

  /**
   * Check if either one of Owner (O), Approver (A), or Sharer (S) flags is set.
   * @memberof Tinode.AccessMode
   * @param {string=} side - which permission to check: given, want, mode; default: mode.
   * @returns {boolean} - <code>true</code> if flag is set.
   */
  isSharer: function(side) {
    return this.isAdmin(side) || AccessMode._checkFlag(this, side, AccessMode._SHARE);
  },

  /**
   * Check if Deleter (D) flag is set.
   * @memberof Tinode.AccessMode
   * @param {string=} side - which permission to check: given, want, mode; default: mode.
   * @returns {boolean} - <code>true</code> if flag is set.
   */
  isDeleter: function(side) {
    return AccessMode._checkFlag(this, side, AccessMode._DELETE);
  }
};

if (typeof module != 'undefined') {
  module.exports = AccessMode;
}

},{}],2:[function(require,module,exports){
/**
 * @file In-memory sorted cache of objects.
 *
 * @copyright 2015-2021 Tinode
 * @summary Javascript bindings for Tinode.
 * @license Apache 2.0
 * @version 0.17
 */
'use strict';

/**
 * In-memory sorted cache of objects.
 *
 * @class CBuffer
 * @memberof Tinode
 * @protected
 *
 * @param {function} compare custom comparator of objects. Takes two parameters <code>a</code> and <code>b</code>;
 *    returns <code>-1</code> if <code>a < b</code>, <code>0</code> if <code>a == b</code>, <code>1</code> otherwise.
 * @param {boolean} unique enforce element uniqueness: when <code>true</code> replace existing element with a new
 *    one on conflict; when <code>false</code> keep both elements.
 */
const CBuffer = function(compare, unique) {
  let buffer = [];

  compare = compare || function(a, b) {
    return a === b ? 0 : a < b ? -1 : 1;
  };

  function findNearest(elem, arr, exact) {
    let start = 0;
    let end = arr.length - 1;
    let pivot = 0;
    let diff = 0;
    let found = false;

    while (start <= end) {
      pivot = (start + end) / 2 | 0;
      diff = compare(arr[pivot], elem);
      if (diff < 0) {
        start = pivot + 1;
      } else if (diff > 0) {
        end = pivot - 1;
      } else {
        found = true;
        break;
      }
    }
    if (found) {
      return {
        idx: pivot,
        exact: true
      };
    }
    if (exact) {
      return {
        idx: -1
      };
    }
    // Not exact - insertion point
    return {
      idx: diff < 0 ? pivot + 1 : pivot
    };
  }

  // Insert element into a sorted array.
  function insertSorted(elem, arr) {
    const found = findNearest(elem, arr, false);
    const count = (found.exact && unique) ? 1 : 0;
    arr.splice(found.idx, count, elem);
    return arr;
  }

  return {
    /**
     * Get an element at the given position.
     * @memberof Tinode.CBuffer#
     * @param {number} at - Position to fetch from.
     * @returns {Object} Element at the given position or <code>undefined</code>.
     */
    getAt: function(at) {
      return buffer[at];
    },

    /**
     * Convenience method for getting the element from the end of the buffer.
     * @memberof Tinode.CBuffer#
     * @param {number} at - position to fetch from, counting from the end;
     *    <code>undefined</code> or <code>null</code>  mean "last".
     * @returns {Object} The last element in the buffer or <code>undefined</code> if buffer is empty.
     */
    getLast: function(at) {
      at |= 0;
      return buffer.length > at ? buffer[buffer.length - 1 - at] : undefined;
    },

    /**
     * Add new element(s) to the buffer. Variadic: takes one or more arguments. If an array is passed as a single
     * argument, its elements are inserted individually.
     * @memberof Tinode.CBuffer#
     *
     * @param {...Object|Array} - One or more objects to insert.
     */
    put: function() {
      let insert;
      // inspect arguments: if array, insert its elements, if one or more non-array arguments, insert them one by one
      if (arguments.length == 1 && Array.isArray(arguments[0])) {
        insert = arguments[0];
      } else {
        insert = arguments;
      }
      for (let idx in insert) {
        insertSorted(insert[idx], buffer);
      }
    },

    /**
     * Remove element at the given position.
     * @memberof Tinode.CBuffer#
     * @param {number} at - Position to delete at.
     * @returns {Object} Element at the given position or <code>undefined</code>.
     */
    delAt: function(at) {
      let r = buffer.splice(at, 1);
      if (r && r.length > 0) {
        return r[0];
      }
      return undefined;
    },

    /**
     * Remove elements between two positions.
     * @memberof Tinode.CBuffer#
     * @param {number} since - Position to delete from (inclusive).
     * @param {number} before - Position to delete to (exclusive).
     *
     * @returns {Array} array of removed elements (could be zero length).
     */
    delRange: function(since, before) {
      return buffer.splice(since, before - since);
    },

    /**
     * Return the number of elements the buffer holds.
     * @memberof Tinode.CBuffer#
     * @return {number} Number of elements in the buffer.
     */
    length: function() {
      return buffer.length;
    },

    /**
     * Reset the buffer discarding all elements
     * @memberof Tinode.CBuffer#
     */
    reset: function() {
      buffer = [];
    },

    /**
     * Callback for iterating contents of buffer. See {@link Tinode.CBuffer#forEach}.
     * @callback ForEachCallbackType
     * @memberof Tinode.CBuffer#
     * @param {Object} elem - Element of the buffer.
     * @param {number} index - Index of the current element.
     */

    /**
     * Apply given <code>callback</code> to all elements of the buffer.
     * @memberof Tinode.CBuffer#
     *
     * @param {Tinode.ForEachCallbackType} callback - Function to call for each element.
     * @param {number} startIdx - Optional index to start iterating from (inclusive).
     * @param {number} beforeIdx - Optional index to stop iterating before (exclusive).
     * @param {Object} context - calling context (i.e. value of <code>this</code> in callback)
     */
    forEach: function(callback, startIdx, beforeIdx, context) {
      startIdx = startIdx | 0;
      beforeIdx = beforeIdx || buffer.length;
      for (let i = startIdx; i < beforeIdx; i++) {
        callback.call(context, buffer[i], i);
      }
    },

    /**
     * Find element in buffer using buffer's comparison function.
     * @memberof Tinode.CBuffer#
     *
     * @param {Object} elem - element to find.
     * @param {boolean=} nearest - when true and exact match is not found, return the nearest element (insertion point).
     * @returns {number} index of the element in the buffer or -1.
     */
    find: function(elem, nearest) {
      const {
        idx
      } = findNearest(elem, buffer, !nearest);
      return idx;
    }
  }
}

if (typeof module != 'undefined') {
  module.exports = CBuffer;
}

},{}],3:[function(require,module,exports){
/**
 * @file Abstraction layer for websocket and long polling connections.
 * See <a href="https://github.com/tinode/webapp">https://github.com/tinode/webapp</a> for real-life usage.
 *
 * @copyright 2015-2021 Tinode
 * @summary Javascript bindings for Tinode.
 * @license Apache 2.0
 * @version 0.17
 */
'use strict';

const {
  jsonParseHelper
} = require('./utils.js');

let WebSocketProvider;
let XHRProvider;

// Error code to return in case of a network problem.
const NETWORK_ERROR = 503;
const NETWORK_ERROR_TEXT = "Connection failed";

// Error code to return when user disconnected from server.
const NETWORK_USER = 418;
const NETWORK_USER_TEXT = "Disconnected by client";

// Helper function for creating an endpoint URL.
function makeBaseUrl(host, protocol, version, apiKey) {
  let url = null;

  if (['http', 'https', 'ws', 'wss'].includes(protocol)) {
    url = `${protocol}://${host}`;
    if (url.charAt(url.length - 1) !== '/') {
      url += '/';
    }
    url += 'v' + version + '/channels';
    if (['http', 'https'].includes(protocol)) {
      // Long polling endpoint ends with "lp", i.e.
      // '/v0/channels/lp' vs just '/v0/channels' for ws
      url += '/lp';
    }
    url += '?apikey=' + apiKey;
  }

  return url;
}

/**
 * An abstraction for a websocket or a long polling connection.
 *
 * @class Connection
 * @memberof Tinode

 * @param {Object} config - configuration parameters.
 * @param {string} config.host - Host name and optional port number to connect to.
 * @param {string} config.apiKey - API key generated by <code>keygen</code>.
 * @param {string} config.transport - Network transport to use, either <code>"ws"<code>/<code>"wss"</code> for websocket or
 *      <code>lp</code> for long polling.
 * @param {boolean} config.secure - Use Secure WebSocket if <code>true</code>.
 * @param {string} version_ - Major value of the protocol version, e.g. '0' in '0.17.1'.
 * @param {boolean} autoreconnect_ - If connection is lost, try to reconnect automatically.
 */
// config.host, PROTOCOL_VERSION, config.apiKey, config.transport, config.secure, true
const Connection = function(config, version_, autoreconnect_) {
  const host = config.host;
  const secure = config.secure;
  const apiKey = config.apiKey;

  const version = version_;
  const autoreconnect = autoreconnect_;

  // Settings for exponential backoff
  const _BOFF_BASE = 2000; // 2000 milliseconds, minimum delay between reconnects
  const _BOFF_MAX_ITER = 10; // Maximum delay between reconnects 2^10 * 2000 ~ 34 minutes
  const _BOFF_JITTER = 0.3; // Add random delay

  let _boffTimer = null;
  let _boffIteration = 0;
  let _boffClosed = false; // Indicator if the socket was manually closed - don't autoreconnect if true.

  const log = (text, ...args) => {
    if (Connection.logger) {
      Connection.logger(text, ...args);
    }
  }

  // Backoff implementation - reconnect after a timeout.
  function boffReconnect() {
    // Clear timer
    clearTimeout(_boffTimer);
    // Calculate when to fire the reconnect attempt
    const timeout = _BOFF_BASE * (Math.pow(2, _boffIteration) * (1.0 + _BOFF_JITTER * Math.random()));
    // Update iteration counter for future use
    _boffIteration = (_boffIteration >= _BOFF_MAX_ITER ? _boffIteration : _boffIteration + 1);
    if (this.onAutoreconnectIteration) {
      this.onAutoreconnectIteration(timeout);
    }

    _boffTimer = setTimeout(() => {
      log(`Reconnecting, iter=${_boffIteration}, timeout=${timeout}`);
      // Maybe the socket was closed while we waited for the timer?
      if (!_boffClosed) {
        const prom = this.connect();
        if (this.onAutoreconnectIteration) {
          this.onAutoreconnectIteration(0, prom);
        } else {
          // Suppress error if it's not used.
          prom.catch(() => {
            /* do nothing */
          });
        }
      } else if (this.onAutoreconnectIteration) {
        this.onAutoreconnectIteration(-1);
      }
    }, timeout);
  }

  // Terminate auto-reconnect process.
  function boffStop() {
    clearTimeout(_boffTimer);
    _boffTimer = null;
  }

  // Reset auto-reconnect iteration counter.
  function boffReset() {
    _boffIteration = 0;
  }

  // Initialization for Websocket
  function init_ws(instance) {
    let _socket = null;

    /**
     * Initiate a new connection
     * @memberof Tinode.Connection#
     * @param {string} host_ Host name to connect to; if <code>null</code> the old host name will be used.
     * @param {boolean} force Force new connection even if one already exists.
     * @return {Promise} Promise resolved/rejected when the connection call completes, resolution is called without
     *  parameters, rejection passes the {Error} as parameter.
     */
    instance.connect = function(host_, force) {
      _boffClosed = false;

      if (_socket) {
        if (!force && _socket.readyState == _socket.OPEN) {
          return Promise.resolve();
        }
        _socket.close();
        _socket = null;
      }

      if (host_) {
        host = host_;
      }

      return new Promise(function(resolve, reject) {
        const url = makeBaseUrl(host, secure ? 'wss' : 'ws', version, apiKey);

        log("Connecting to: ", url);

        // It throws when the server is not accessible but the exception cannot be caught:
        // https://stackoverflow.com/questions/31002592/javascript-doesnt-catch-error-in-websocket-instantiation/31003057
        const conn = new WebSocketProvider(url);

        conn.onerror = function(err) {
          reject(err);
        }

        conn.onopen = function(evt) {
          if (autoreconnect) {
            boffStop();
          }

          if (instance.onOpen) {
            instance.onOpen();
          }

          resolve();
        }

        conn.onclose = function(evt) {
          _socket = null;

          if (instance.onDisconnect) {
            const code = _boffClosed ? NETWORK_USER : NETWORK_ERROR;
            instance.onDisconnect(new Error(_boffClosed ? NETWORK_USER_TEXT : NETWORK_ERROR_TEXT +
              ' (' + code + ')'), code);
          }

          if (!_boffClosed && autoreconnect) {
            boffReconnect.call(instance);
          }
        }

        conn.onmessage = function(evt) {
          if (instance.onMessage) {
            instance.onMessage(evt.data);
          }
        }
        _socket = conn;
      });
    }

    /**
     * Try to restore a network connection, also reset backoff.
     * @memberof Tinode.Connection#
     *
     * @param {boolean} force - reconnect even if there is a live connection already.
     */
    instance.reconnect = function(force) {
      boffStop();
      instance.connect(null, force);
    }

    /**
     * Terminate the network connection
     * @memberof Tinode.Connection#
     */
    instance.disconnect = function() {
      _boffClosed = true;
      boffStop();

      if (!_socket) {
        return;
      }
      _socket.close();
      _socket = null;
    }

    /**
     * Send a string to the server.
     * @memberof Tinode.Connection#
     *
     * @param {string} msg - String to send.
     * @throws Throws an exception if the underlying connection is not live.
     */
    instance.sendText = function(msg) {
      if (_socket && (_socket.readyState == _socket.OPEN)) {
        _socket.send(msg);
      } else {
        throw new Error("Websocket is not connected");
      }
    };

    /**
     * Check if socket is alive.
     * @memberof Tinode.Connection#
     * @returns {boolean} <code>true</code> if connection is live, <code>false</code> otherwise.
     */
    instance.isConnected = function() {
      return (_socket && (_socket.readyState == _socket.OPEN));
    }

    /**
     * Get the name of the current network transport.
     * @memberof Tinode.Connection#
     * @returns {string} name of the transport such as <code>"ws"</code> or <code>"lp"</code>.
     */
    instance.transport = function() {
      return 'ws';
    }

    /**
     * Send network probe to check if connection is indeed live.
     * @memberof Tinode.Connection#
     */
    instance.probe = function() {
      instance.sendText('1');
    }
  }

  // Initialization for long polling.
  function init_lp(instance) {
    const XDR_UNSENT = 0; // Client has been created. open() not called yet.
    const XDR_OPENED = 1; // open() has been called.
    const XDR_HEADERS_RECEIVED = 2; // send() has been called, and headers and status are available.
    const XDR_LOADING = 3; // Downloading; responseText holds partial data.
    const XDR_DONE = 4; // The operation is complete.
    // Fully composed endpoint URL, with API key & SID
    let _lpURL = null;

    let _poller = null;
    let _sender = null;

    function lp_sender(url_) {
      const sender = new XHRProvider();
      sender.onreadystatechange = function(evt) {
        if (sender.readyState == XDR_DONE && sender.status >= 400) {
          // Some sort of error response
          throw new Error(`LP sender failed, ${sender.status}`);
        }
      }

      sender.open('POST', url_, true);
      return sender;
    }

    function lp_poller(url_, resolve, reject) {
      let poller = new XHRProvider();
      let promiseCompleted = false;

      poller.onreadystatechange = function(evt) {

        if (poller.readyState == XDR_DONE) {
          if (poller.status == 201) { // 201 == HTTP.Created, get SID
            let pkt = JSON.parse(poller.responseText, jsonParseHelper);
            _lpURL = url_ + '&sid=' + pkt.ctrl.params.sid
            poller = lp_poller(_lpURL);
            poller.send(null)
            if (instance.onOpen) {
              instance.onOpen();
            }

            if (resolve) {
              promiseCompleted = true;
              resolve();
            }

            if (autoreconnect) {
              boffStop();
            }
          } else if (poller.status < 400) { // 400 = HTTP.BadRequest
            if (instance.onMessage) {
              instance.onMessage(poller.responseText)
            }
            poller = lp_poller(_lpURL);
            poller.send(null);
          } else {
            // Don't throw an error here, gracefully handle server errors
            if (reject && !promiseCompleted) {
              promiseCompleted = true;
              reject(poller.responseText);
            }
            if (instance.onMessage && poller.responseText) {
              instance.onMessage(poller.responseText);
            }
            if (instance.onDisconnect) {
              const code = poller.status || (_boffClosed ? NETWORK_USER : NETWORK_ERROR);
              const text = poller.responseText || (_boffClosed ? NETWORK_USER_TEXT : NETWORK_ERROR_TEXT);
              instance.onDisconnect(new Error(text + ' (' + code + ')'), code);
            }

            // Polling has stopped. Indicate it by setting poller to null.
            poller = null;
            if (!_boffClosed && autoreconnect) {
              boffReconnect.call(instance);
            }
          }
        }
      }
      poller.open('GET', url_, true);
      return poller;
    }

    instance.connect = function(host_, force) {
      _boffClosed = false;

      if (_poller) {
        if (!force) {
          return Promise.resolve();
        }
        _poller.onreadystatechange = undefined;
        _poller.abort();
        _poller = null;
      }

      if (host_) {
        host = host_;
      }

      return new Promise(function(resolve, reject) {
        const url = makeBaseUrl(host, secure ? 'https' : 'http', version, apiKey);
        log("Connecting to:", url);
        _poller = lp_poller(url, resolve, reject);
        _poller.send(null)
      }).catch((err) => {
        log("LP connection failed:", err);
      });
    };

    instance.reconnect = function(force) {
      boffStop();
      instance.connect(null, force);
    };

    instance.disconnect = function() {
      _boffClosed = true;
      boffStop();

      if (_sender) {
        _sender.onreadystatechange = undefined;
        _sender.abort();
        _sender = null;
      }
      if (_poller) {
        _poller.onreadystatechange = undefined;
        _poller.abort();
        _poller = null;
      }

      if (instance.onDisconnect) {
        instance.onDisconnect(new Error(NETWORK_USER_TEXT + ' (' + NETWORK_USER + ')'), NETWORK_USER);
      }
      // Ensure it's reconstructed
      _lpURL = null;
    }

    instance.sendText = function(msg) {
      _sender = lp_sender(_lpURL);
      if (_sender && (_sender.readyState == 1)) { // 1 == OPENED
        _sender.send(msg);
      } else {
        throw new Error("Long poller failed to connect");
      }
    };

    instance.isConnected = function() {
      return (_poller && true);
    }

    instance.transport = function() {
      return 'lp';
    }

    instance.probe = function() {
      instance.sendText('1');
    }
  }

  let initialized = false;
  if (config.transport === 'lp') {
    // explicit request to use long polling
    init_lp(this);
    initialized = true;
  } else if (config.transport === 'ws') {
    // explicit request to use web socket
    // if websockets are not available, horrible things will happen
    init_ws(this);
    initialized = true;
  }

  if (!initialized) {
    // Invalid or undefined network transport.
    log("Unknown or invalid network transport. Running under Node? Call 'Tinode.setNetworkProviders()'.");
    throw new Error("Unknown or invalid network transport. Running under Node? Call 'Tinode.setNetworkProviders()'.");
  }

  /**
   * Reset autoreconnect counter to zero.
   * @memberof Tinode.Connection#
   */
  this.backoffReset = function() {
    boffReset();
  }

  // Callbacks:
  /**
   * A callback to pass incoming messages to. See {@link Tinode.Connection#onMessage}.
   * @callback Tinode.Connection.OnMessage
   * @memberof Tinode.Connection
   * @param {string} message - Message to process.
   */
  /**
   * A callback to pass incoming messages to.
   * @type {Tinode.Connection.OnMessage}
   * @memberof Tinode.Connection#
   */
  this.onMessage = undefined;

  /**
   * A callback for reporting a dropped connection.
   * @type {function}
   * @memberof Tinode.Connection#
   */
  this.onDisconnect = undefined;

  /**
   * A callback called when the connection is ready to be used for sending. For websockets it's socket open,
   * for long polling it's <code>readyState=1</code> (OPENED)
   * @type {function}
   * @memberof Tinode.Connection#
   */
  this.onOpen = undefined;

  /**
   * A callback to notify of reconnection attempts. See {@link Tinode.Connection#onAutoreconnectIteration}.
   * @memberof Tinode.Connection
   * @callback AutoreconnectIterationType
   * @param {string} timeout - time till the next reconnect attempt in milliseconds. <code>-1</code> means reconnect was skipped.
   * @param {Promise} promise resolved or rejected when the reconnect attemp completes.
   *
   */
  /**
   * A callback to inform when the next attampt to reconnect will happen and to receive connection promise.
   * @memberof Tinode.Connection#
   * @type {Tinode.Connection.AutoreconnectIterationType}
   */
  this.onAutoreconnectIteration = undefined;

  /**
   * A callback to log events from Connection. See {@link Tinode.Connection#logger}.
   * @memberof Tinode.Connection
   * @callback LoggerCallbackType
   * @param {string} event - Event to log.
   */
  /**
   * A callback to report logging events.
   * @memberof Tinode.Connection#
   * @type {Tinode.Connection.LoggerCallbackType}
   */
  this.logger = undefined;
};

/**
 * To use Connection in a non browser context, supply WebSocket and XMLHttpRequest providers.
 * @static
 * @memberof Connection
 * @param wsProvider WebSocket provider, e.g. for nodeJS , <code>require('ws')</code>.
 * @param xhrProvider XMLHttpRequest provider, e.g. for node <code>require('xhr')</code>.
 */
Connection.setNetworkProviders = function(wsProvider, xhrProvider) {
  WebSocketProvider = wsProvider;
  XHRProvider = xhrProvider;
};

Connection.NETWORK_ERROR = NETWORK_ERROR;
Connection.NETWORK_ERROR_TEXT = NETWORK_ERROR_TEXT;
Connection.NETWORK_USER = NETWORK_USER;
Connection.NETWORK_USER_TEXT = NETWORK_USER_TEXT;

if (typeof module != 'undefined') {
  module.exports = Connection;
}

},{"./utils.js":9}],4:[function(require,module,exports){
/**
 * @file Helper methods for dealing with IndexedDB cache of messages, users, and topics.
 * See <a href="https://github.com/tinode/webapp">https://github.com/tinode/webapp</a> for real-life usage.
 *
 * @copyright 2015-2021 Tinode
 * @summary Javascript bindings for Tinode.
 * @license Apache 2.0
 * @version 0.17
 */
'use strict';

// NOTE TO DEVELOPERS:
// Localizable strings should be double quoted "строка на другом языке",
// non-localizable strings should be single quoted 'non-localized'.

const DB_VERSION = 1;
const DB_NAME = 'tinode-web';

const DB = function(onError, logger) {
  onError = onError || function() {}
  logger = logger || function() {}

  // Instance of IndexDB.
  let db = null;
  // Indicator that the cache is disabled.
  let disabled = false;

  // Serializable topic fields.
  const topic_fields = ['created', 'updated', 'deleted', 'read', 'recv', 'seq', 'clear', 'defacs',
    'creds', 'public', 'trusted', 'private', 'touched'
  ];

  // Copy values from 'src' to 'dst'. Allocate dst if it's null or undefined.
  function serializeTopic(dst, src) {
    const res = dst || {
      name: src.name
    };
    topic_fields.forEach((f) => {
      if (src.hasOwnProperty(f)) {
        res[f] = src[f];
      }
    });
    if (Array.isArray(src._tags)) {
      res.tags = src._tags;
    }
    if (src.acs) {
      res.acs = src.getAccessMode().jsonHelper();
    }
    return res;
  }

  // Copy data from src to Topic object.
  function deserializeTopic(topic, src) {
    topic_fields.forEach((f) => {
      if (src.hasOwnProperty(f)) {
        topic[f] = src[f];
      }
    });
    if (Array.isArray(src.tags)) {
      topic._tags = src.tags;
    }
    if (src.acs) {
      topic.setAccessMode(src.acs);
    }
    topic.seq |= 0;
    topic.read |= 0;
    topic.unread = Math.max(0, topic.seq - topic.read);
  }

  function serializeSubscription(dst, topicName, uid, sub) {
    const fields = ['updated', 'mode', 'read', 'recv', 'clear', 'lastSeen', 'userAgent'];
    const res = dst || {
      topic: topicName,
      uid: uid
    };

    fields.forEach((f) => {
      if (sub.hasOwnProperty(f)) {
        res[f] = sub[f];
      }
    });

    return res;
  }

  function serializeMessage(dst, msg) {
    // Serializable fields.
    const fields = ['topic', 'seq', 'ts', '_status', 'from', 'head', 'content'];
    const res = dst || {};
    fields.forEach((f) => {
      if (msg.hasOwnProperty(f)) {
        res[f] = msg[f];
      }
    });
    return res;
  }

  function mapObjects(source, callback, context) {
    if (!db) {
      return disabled ?
        Promise.resolve([]) :
        Promise.reject(new Error("not initialized"));
    }

    return new Promise((resolve, reject) => {
      const trx = db.transaction([source]);
      trx.onerror = (event) => {
        logger("PCache", "mapObjects", source, event.target.error);
        reject(event.target.error);
      };
      trx.objectStore(source).getAll().onsuccess = (event) => {
        if (callback) {
          event.target.result.forEach((topic) => {
            callback.call(context, topic);
          });
        }
        resolve(event.target.result);
      };
    });
  }

  return {
    /**
     * Initialize persistent cache: open or create/upgrade if needed.
     * @returns {Promise} promise to be resolved/rejected when the DB is initialized.
     */
    initDatabase: function() {
      return new Promise((resolve, reject) => {
        // Open the database and initialize callbacks.
        const req = indexedDB.open(DB_NAME, DB_VERSION);
        req.onsuccess = (event) => {
          db = event.target.result;
          disabled = false;
          resolve(db);
        };
        req.onerror = (event) => {
          logger("PCache", "failed to initialize", event);
          reject(event.target.error);
          onError(event.target.error);
        };
        req.onupgradeneeded = function(event) {
          db = event.target.result;

          db.onerror = function(event) {
            logger("PCache", "failed to create storage", event);
            onError(event.target.error);
          };

          // Individual object stores.

          // Object store (table) for topics. The primary key is topic name.
          db.createObjectStore('topic', {
            keyPath: 'name'
          });

          // Users object store. UID is the primary key.
          db.createObjectStore('user', {
            keyPath: 'uid'
          });

          // Subscriptions object store topic <-> user. Topic name + UID is the primary key.
          db.createObjectStore('subscription', {
            keyPath: ['topic', 'uid']
          });

          // Messages object store. The primary key is topic name + seq.
          db.createObjectStore('message', {
            keyPath: ['topic', 'seq']
          });
        };
      });
    },

    /**
     * Delete persistent cache.
     */
    deleteDatabase: function() {
      return new Promise((resolve, reject) => {
        const req = indexedDB.deleteDatabase(DB_NAME);
        req.onblocked = function(event) {
          if (db) {
            db.close();
          }
        };
        req.onsuccess = (event) => {
          db = null;
          disabled = true;
          resolve(true);
        };
        req.onerror = (event) => {
          logger("PCache", "deleteDatabase", event.target.error);
          reject(event.target.error);
        };
      });
    },

    /**
     * Check if persistent cache is ready for use.
     * @memberOf DB
     * @returns {boolean} <code>true</code> if cache is ready, <code>false</code> otherwise.
     */
    isReady: function() {
      return !!db;
    },

    // Topics.
    /**
     * Save to cache or update topic in persistent cache.
     * @memberOf DB
     * @param {Topic} topic - topic to be added or updated.
     * @returns {Promise} promise resolved/rejected on operation completion.
     */
    updTopic: function(topic) {
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve() :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        const trx = db.transaction(['topic'], 'readwrite');
        trx.oncomplete = (event) => {
          resolve(event.target.result);
        };
        trx.onerror = (event) => {
          logger("PCache", "updTopic", event.target.error);
          reject(event.target.error);
        };
        const req = trx.objectStore('topic').get(topic.name);
        req.onsuccess = (event) => {
          trx.objectStore('topic').put(serializeTopic(req.result, topic));
          trx.commit();
        };
      });
    },

    /**
     * Remove topic from persistent cache.
     * @memberOf DB
     * @param {string} name - name of the topic to remove from database.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    remTopic: function(name) {
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve() :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        const trx = db.transaction(['topic', 'subscription', 'message'], 'readwrite');
        trx.oncomplete = (event) => {
          resolve(event.target.result);
        };
        trx.onerror = (event) => {
          logger("PCache", "remTopic", event.target.error);
          reject(event.target.error);
        };
        trx.objectStore('topic').delete(IDBKeyRange.only(name));
        trx.objectStore('subscription').delete(IDBKeyRange.bound([name, '-'], [name, '~']));
        trx.objectStore('message').delete(IDBKeyRange.bound([name, 0], [name, Number.MAX_SAFE_INTEGER]));
        trx.commit();
      });
    },

    /**
     * Execute a callback for each stored topic.
     * @memberOf DB
     * @param {function} callback - function to call for each topic.
     * @param {Object} context - the value or <code>this</code> inside the callback.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    mapTopics: function(callback, context) {
      return mapObjects('topic', callback, context);
    },

    /**
     * Copy data from serialized object to topic.
     * @memberOf DB
     * @param {Topic} topic - target to deserialize to.
     * @param {Object} src - serialized data to copy from.
     */
    deserializeTopic: function(topic, src) {
      deserializeTopic(topic, src);
    },

    // Users.
    /**
     * Add or update user object in the persistent cache.
     * @memberOf DB
     * @param {string} uid - ID of the user to save or update.
     * @param {Object} pub - user's <code>public</code> information.
     * @returns {Promise} promise resolved/rejected on operation completion.
     */
    updUser: function(uid, pub) {
      if (arguments.length < 2 || pub === undefined) {
        // No point inupdating user with invalid data.
        return;
      }
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve() :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        const trx = db.transaction(['user'], 'readwrite');
        trx.oncomplete = (event) => {
          resolve(event.target.result);
        };
        trx.onerror = (event) => {
          logger("PCache", "updUser", event.target.error);
          reject(event.target.error);
        };
        trx.objectStore('user').put({
          uid: uid,
          public: pub
        });
        trx.commit();
      });
    },

    /**
     * Remove user from persistent cache.
     * @memberOf DB
     * @param {string} uid - ID of the user to remove from the cache.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    remUser: function(uid) {
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve() :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        const trx = db.transaction(['user'], 'readwrite');
        trx.oncomplete = (event) => {
          resolve(event.target.result);
        };
        trx.onerror = (event) => {
          logger("PCache", "remUser", event.target.error);
          reject(event.target.error);
        };
        trx.objectStore('user').delete(IDBKeyRange.only(uid));
        trx.commit();
      });
    },

    /**
     * Execute a callback for each stored user.
     * @memberOf DB
     * @param {function} callback - function to call for each topic.
     * @param {Object} context - the value or <code>this</code> inside the callback.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    mapUsers: function(callback, context) {
      return mapObjects('user', callback, context);
    },

    /**
     * Read a single user from persistent cache.
     * @memberOf DB
     * @param {string} uid - ID of the user to fetch from cache.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    getUser: function(uid) {
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve() :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        const trx = db.transaction(['user']);
        trx.oncomplete = (event) => {
          const user = event.target.result;
          resolve({
            user: user.uid,
            public: user.public
          });
        };
        trx.onerror = (event) => {
          logger("PCache", "getUser", event.target.error);
          reject(event.target.error);
        };
        trx.objectStore('user').get(uid);
      });
    },

    // Subscriptions.

    /**
     * Add or update subscription in persistent cache.
     * @memberOf DB
     * @param {string} topicName - name of the topic which owns the message.
     * @param {string} uid - ID of the subscribed user.
     * @param {Object} sub - subscription to save.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    updSubscription: function(topicName, uid, sub) {
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve() :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        const trx = db.transaction(['subscription'], 'readwrite');
        trx.oncomplete = (event) => {
          resolve(event.target.result);
        };
        trx.onerror = (event) => {
          logger("PCache", "updSubscription", event.target.error);
          reject(event.target.error);
        };
        trx.objectStore('subscription').get([topicName, uid]).onsuccess = (event) => {
          trx.objectStore('subscription').put(serializeSubscription(event.target.result, topicName, uid, sub));
          trx.commit();
        };
      });
    },

    /**
     * Execute a callback for each cached subscription in a given topic.
     * @memberOf DB
     * @param {string} topicName - name of the topic which owns the subscriptions.
     * @param {function} callback - function to call for each subscription.
     * @param {Object} context - the value or <code>this</code> inside the callback.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    mapSubscriptions: function(topicName, callback, context) {
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve([]) :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        const trx = db.transaction(['subscription']);
        trx.onerror = (event) => {
          logger("PCache", "mapSubscriptions", event.target.error);
          reject(event.target.error);
        };
        trx.objectStore('subscription').getAll(IDBKeyRange.bound([topicName, '-'], [topicName, '~'])).onsuccess = (event) => {
          if (callback) {
            event.target.result.forEach((topic) => {
              callback.call(context, topic);
            });
          }
          resolve(event.target.result);
        };
      });
    },

    // Messages.

    /**
     * Save message to persistent cache.
     * @memberOf DB
     * @param {string} topicName - name of the topic which owns the message.
     * @param {Object} msg - message to save.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    addMessage: function(msg) {
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve() :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        const trx = db.transaction(['message'], 'readwrite');
        trx.onsuccess = (event) => {
          resolve(event.target.result);
        };
        trx.onerror = (event) => {
          logger("PCache", "addMesssage", event.target.error);
          reject(event.target.error);
        };
        trx.objectStore('message').add(serializeMessage(null, msg));
        trx.commit();
      });
    },

    /**
     * Update delivery status of a message stored in persistent cache.
     * @memberOf DB
     * @param {string} topicName - name of the topic which owns the message.
     * @param {number} seq - ID of the message to update
     * @param {number} status - new delivery status of the message.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    updMessageStatus: function(topicName, seq, status) {
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve() :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        const trx = db.transaction(['message'], 'readwrite');
        trx.onsuccess = (event) => {
          resolve(event.target.result);
        };
        trx.onerror = (event) => {
          logger("PCache", "updMessageStatus", event.target.error);
          reject(event.target.error);
        };
        const req = trx.objectStore('message').get(IDBKeyRange.only([topicName, seq]));
        req.onsuccess = (event) => {
          const src = req.result || event.target.result;
          if (!src || src._status == status) {
            trx.commit();
            return;
          }
          trx.objectStore('message').put(serializeMessage(src, {
            topic: topicName,
            seq: seq,
            _status: status
          }));
          trx.commit();
        };
      });
    },

    /**
     * Remove one or more messages from persistent cache.
     * @memberOf DB
     * @param {string} topicName - name of the topic which owns the message.
     * @param {number} from - id of the message to remove or lower boundary when removing range (inclusive).
     * @param {number=} to - upper boundary (exclusive) when removing a range of messages.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    remMessages: function(topicName, from, to) {
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve() :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        if (!from && !to) {
          from = 0;
          to = Number.MAX_SAFE_INTEGER;
        }
        const range = to > 0 ? IDBKeyRange.bound([topicName, from], [topicName, to], false, true) :
          IDBKeyRange.only([topicName, from]);
        const trx = db.transaction(['message'], 'readwrite');
        trx.onsuccess = (event) => {
          resolve(event.target.result);
        };
        trx.onerror = (event) => {
          logger("PCache", "remMessages", event.target.error);
          reject(event.target.error);
        };
        trx.objectStore('message').delete(range);
        trx.commit();
      });
    },

    /**
     * Retrieve messages from persistent store.
     * @memberOf DB
     * @param {string} topicName - name of the topic to retrieve messages from.
     * @param {function} callback to call for each retrieved message.
     * @param {Object} query - parameters of the message range to retrieve.
     * @param {number=} query.from - the least message ID to retrieve (inclusive).
     * @param {number=} query.to - the greatest message ID to retrieve (exclusive).
     * @param {number=} query.limit - the maximum number of messages to retrieve.
     * @return {Promise} promise resolved/rejected on operation completion.
     */
    readMessages: function(topicName, query, callback, context) {
      if (!this.isReady()) {
        return disabled ?
          Promise.resolve([]) :
          Promise.reject(new Error("not initialized"));
      }
      return new Promise((resolve, reject) => {
        query = query || {};
        const from = query.from > 0 ? query.from : 0;
        const to = query.to > 0 ? query.to : Number.MAX_SAFE_INTEGER;
        const limit = query.limit | 0;

        const result = [];
        const range = IDBKeyRange.bound([topicName, from], [topicName, to], false, true);
        const trx = db.transaction(['message']);
        trx.onerror = (event) => {
          logger("PCache", "readMessages", event.target.error);
          reject(event.target.error);
        };
        // Iterate in descending order.
        trx.objectStore('message').openCursor(range, 'prev').onsuccess = (event) => {
          const cursor = event.target.result;
          if (cursor) {
            if (callback) {
              callback.call(context, cursor.value);
            }
            result.push(cursor.value);
            if (limit <= 0 || result.length < limit) {
              cursor.continue();
            } else {
              resolve(result);
            }
          } else {
            resolve(result);
          }
        };
      });
    }
  };
}

if (typeof module != 'undefined') {
  module.exports = DB;
}

},{}],5:[function(require,module,exports){
/**
 * @copyright 2015-2021 Tinode
 * @summary Minimally rich text representation and formatting for Tinode.
 * @license Apache 2.0
 * @version 0.16
 *
 * @file Basic parser and formatter for very simple text markup. Mostly targeted at
 * mobile use cases similar to Telegram, WhatsApp, and FB Messenger.
 *
 * <p>Supports conversion of user keyboard input to formatted text:</p>
 * <ul>
 *   <li>*abc* &rarr; <b>abc</b></li>
 *   <li>_abc_ &rarr; <i>abc</i></li>
 *   <li>~abc~ &rarr; <del>abc</del></li>
 *   <li>`abc` &rarr; <tt>abc</tt></li>
 * </ul>
 * Also supports forms and buttons.
 *
 * Nested formatting is supported, e.g. *abc _def_* -> <b>abc <i>def</i></b>
 * URLs, @mentions, and #hashtags are extracted and converted into links.
 * Forms and buttons can be added procedurally.
 * JSON data representation is inspired by Draft.js raw formatting.
 *
 *
 * @example
 * Text:
 * <pre>
 *     this is *bold*, `code` and _italic_, ~strike~
 *     combined *bold and _italic_*
 *     an url: https://www.example.com/abc#fragment and another _www.tinode.co_
 *     this is a @mention and a #hashtag in a string
 *     second #hashtag
 * </pre>
 *
 *  Sample JSON representation of the text above:
 *  {
 *     "txt": "this is bold, code and italic, strike combined bold and italic an url: https://www.example.com/abc#fragment " +
 *             "and another www.tinode.co this is a @mention and a #hashtag in a string second #hashtag",
 *     "fmt": [
 *         { "at":8, "len":4,"tp":"ST" },{ "at":14, "len":4, "tp":"CO" },{ "at":23, "len":6, "tp":"EM"},
 *         { "at":31, "len":6, "tp":"DL" },{ "tp":"BR", "len":1, "at":37 },{ "at":56, "len":6, "tp":"EM" },
 *         { "at":47, "len":15, "tp":"ST" },{ "tp":"BR", "len":1, "at":62 },{ "at":120, "len":13, "tp":"EM" },
 *         { "at":71, "len":36, "key":0 },{ "at":120, "len":13, "key":1 },{ "tp":"BR", "len":1, "at":133 },
 *         { "at":144, "len":8, "key":2 },{ "at":159, "len":8, "key":3 },{ "tp":"BR", "len":1, "at":179 },
 *         { "at":187, "len":8, "key":3 },{ "tp":"BR", "len":1, "at":195 }
 *     ],
 *     "ent": [
 *         { "tp":"LN", "data":{ "url":"https://www.example.com/abc#fragment" } },
 *         { "tp":"LN", "data":{ "url":"http://www.tinode.co" } },
 *         { "tp":"MN", "data":{ "val":"mention" } },
 *         { "tp":"HT", "data":{ "val":"hashtag" } }
 *     ]
 *  }
 */

'use strict';

// NOTE TO DEVELOPERS:
// Localizable strings should be double quoted "строка на другом языке",
// non-localizable strings should be single quoted 'non-localized'.

const MAX_FORM_ELEMENTS = 8;
const JSON_MIME_TYPE = 'application/json';

// Regular expressions for parsing inline formats. Javascript does not support lookbehind,
// so it's a bit messy.
const INLINE_STYLES = [
  // Strong = bold, *bold text*
  {
    name: 'ST',
    start: /(?:^|[\W_])(\*)[^\s*]/,
    end: /[^\s*](\*)(?=$|[\W_])/
  },
  // Emphesized = italic, _italic text_
  {
    name: 'EM',
    start: /(?:^|\W)(_)[^\s_]/,
    end: /[^\s_](_)(?=$|\W)/
  },
  // Deleted, ~strike this though~
  {
    name: 'DL',
    start: /(?:^|[\W_])(~)[^\s~]/,
    end: /[^\s~](~)(?=$|[\W_])/
  },
  // Code block `this is monospace`
  {
    name: 'CO',
    start: /(?:^|\W)(`)[^`]/,
    end: /[^`](`)(?=$|\W)/
  }
];

// RegExps for entity extraction (RF = reference)
const ENTITY_TYPES = [
  // URLs
  {
    name: 'LN',
    dataName: 'url',
    pack: function(val) {
      // Check if the protocol is specified, if not use http
      if (!/^[a-z]+:\/\//i.test(val)) {
        val = 'http://' + val;
      }
      return {
        url: val
      };
    },
    re: /(?:(?:https?|ftp):\/\/|www\.|ftp\.)[-A-Z0-9+&@#\/%=~_|$?!:,.]*[A-Z0-9+&@#\/%=~_|$]/ig
  },
  // Mentions @user (must be 2 or more characters)
  {
    name: 'MN',
    dataName: 'val',
    pack: function(val) {
      return {
        val: val.slice(1)
      };
    },
    re: /\B@(\w\w+)/g
  },
  // Hashtags #hashtag, like metion 2 or more characters.
  {
    name: 'HT',
    dataName: 'val',
    pack: function(val) {
      return {
        val: val.slice(1)
      };
    },
    re: /\B#(\w\w+)/g
  }
];

// HTML tag name suggestions
const HTML_TAGS = {
  ST: {
    name: 'b',
    isVoid: false
  },
  EM: {
    name: 'i',
    isVoid: false
  },
  DL: {
    name: 'del',
    isVoid: false
  },
  CO: {
    name: 'tt',
    isVoid: false
  },
  BR: {
    name: 'br',
    isVoid: true
  },
  LN: {
    name: 'a',
    isVoid: false
  },
  MN: {
    name: 'a',
    isVoid: false
  },
  HT: {
    name: 'a',
    isVoid: false
  },
  IM: {
    name: 'img',
    isVoid: true
  },
  FM: {
    name: 'div',
    isVoid: false
  },
  RW: {
    name: 'div',
    isVoid: false,
  },
  BN: {
    name: 'button',
    isVoid: false
  },
  HD: {
    name: '',
    isVoid: false
  },
  HL: {
    name: 'span',
    isVoid: false
  }
};

// Convert base64-encoded string into Blob.
function base64toObjectUrl(b64, contentType, logger) {
  if (!b64) {
    return null;
  }

  try {
    const bin = atob(b64);
    const length = bin.length;
    const buf = new ArrayBuffer(length);
    const arr = new Uint8Array(buf);
    for (let i = 0; i < length; i++) {
      arr[i] = bin.charCodeAt(i);
    }

    return URL.createObjectURL(new Blob([buf], {
      type: contentType
    }));
  } catch (err) {
    if (logger) {
      logger("Drafty: failed to convert object.", err.message);
    }
  }

  return null;
}

function base64toDataUrl(b64, contentType) {
  if (!b64) {
    return null;
  }
  contentType = contentType || 'image/jpeg';
  return 'data:' + contentType + ';base64,' + b64;
}

// Helpers for converting Drafty to HTML.
const DECORATORS = {
  // Visial styles
  ST: {
    open: function() {
      return '<b>';
    },
    close: function() {
      return '</b>';
    }
  },
  EM: {
    open: function() {
      return '<i>';
    },
    close: function() {
      return '</i>'
    }
  },
  DL: {
    open: function() {
      return '<del>';
    },
    close: function() {
      return '</del>'
    }
  },
  CO: {
    open: function() {
      return '<tt>';
    },
    close: function() {
      return '</tt>'
    }
  },
  // Line break
  BR: {
    open: function() {
      return '<br/>';
    },
    close: function() {
      return ''
    }
  },
  // Hidden element
  HD: {
    open: function() {
      return '';
    },
    close: function() {
      return '';
    }
  },
  // Highlighted element.
  HL: {
    open: function() {
      return '<span style="color:teal">';
    },
    close: function() {
      return '</span>';
    }
  },
  // Link (URL)
  LN: {
    open: function(data) {
      return '<a href="' + data.url + '">';
    },
    close: function(data) {
      return '</a>';
    },
    props: function(data) {
      return data ? {
        href: data.url,
        target: "_blank"
      } : null;
    },
  },
  // Mention
  MN: {
    open: function(data) {
      return '<a href="#' + data.val + '">';
    },
    close: function(data) {
      return '</a>';
    },
    props: function(data) {
      return data ? {
        name: data.val
      } : null;
    },
  },
  // Hashtag
  HT: {
    open: function(data) {
      return '<a href="#' + data.val + '">';
    },
    close: function(data) {
      return '</a>';
    },
    props: function(data) {
      return data ? {
        name: data.val
      } : null;
    },
  },
  // Button
  BN: {
    open: function(data) {
      return '<button>';
    },
    close: function(data) {
      return '</button>';
    },
    props: function(data) {
      return data ? {
        'data-act': data.act,
        'data-val': data.val,
        'data-name': data.name,
        'data-ref': data.ref
      } : null;
    },
  },
  // Image
  IM: {
    open: function(data) {
      // Don't use data.ref for preview: it's a security risk.
      const tmpPreviewUrl = base64toDataUrl(data._tempPreview, data.mime);
      const previewUrl = base64toObjectUrl(data.val, data.mime, Drafty.logger);
      const downloadUrl = data.ref || previewUrl;
      return (data.name ? '<a href="' + downloadUrl + '" download="' + data.name + '">' : '') +
        '<img src="' + (tmpPreviewUrl || previewUrl) + '"' +
        (data.width ? ' width="' + data.width + '"' : '') +
        (data.height ? ' height="' + data.height + '"' : '') + ' border="0" />';
    },
    close: function(data) {
      return (data.name ? '</a>' : '');
    },
    props: function(data) {
      if (!data) return null;
      return {
        // Temporary preview, or permanent preview, or external link.
        src: base64toDataUrl(data._tempPreview, data.mime) ||
          data.ref || base64toObjectUrl(data.val, data.mime, Drafty.logger),
        title: data.name,
        'data-width': data.width,
        'data-height': data.height,
        'data-name': data.name,
        'data-size': data.val ? ((data.val.length * 0.75) | 0) : (data.size | 0),
        'data-mime': data.mime
      };
    },
  },
  // Form - structured layout of elements.
  FM: {
    open: function(data) {
      return '<div>';
    },
    close: function(data) {
      return '</div>';
    }
  },
  // Row: logic grouping of elements
  RW: {
    open: function(data) {
      return '<div>';
    },
    close: function(data) {
      return '</div>';
    }
  }
};

/**
 * The main object which performs all the formatting actions.
 * @class Drafty
 * @constructor
 */
const Drafty = function() {}

// Take a string and defined earlier style spans, re-compose them into a tree where each leaf is
// a same-style (including unstyled) string. I.e. 'hello *bold _italic_* and ~more~ world' ->
// ('hello ', (b: 'bold ', (i: 'italic')), ' and ', (s: 'more'), ' world');
//
// This is needed in order to clear markup, i.e. 'hello *world*' -> 'hello world' and convert
// ranges from markup-ed offsets to plain text offsets.
function chunkify(line, start, end, spans) {
  const chunks = [];

  if (spans.length == 0) {
    return [];
  }

  for (let i in spans) {
    // Get the next chunk from the queue
    const span = spans[i];

    // Grab the initial unstyled chunk
    if (span.start > start) {
      chunks.push({
        text: line.slice(start, span.start)
      });
    }

    // Grab the styled chunk. It may include subchunks.
    const chunk = {
      type: span.type
    };
    const chld = chunkify(line, span.start + 1, span.end, span.children);
    if (chld.length > 0) {
      chunk.children = chld;
    } else {
      chunk.text = span.text;
    }
    chunks.push(chunk);
    start = span.end + 1; // '+1' is to skip the formatting character
  }

  // Grab the remaining unstyled chunk, after the last span
  if (start < end) {
    chunks.push({
      text: line.slice(start, end)
    });
  }

  return chunks;
}

// Inverse of chunkify. Returns a tree of formatted spans.
function forEach(line, start, end, spans, formatter, context) {
  const result = [];

  // Process ranges calling formatter for each range.
  for (let i = 0; i < spans.length; i++) {
    const span = spans[i];
    if (span.at < 0) {
      // Ask formatter if it wants to do anything with the non-visual span.
      const s = formatter.call(context, span.tp, span.data, undefined, result.length);
      if (s) {
        result.push(s);
      }
      continue;
    }
    // Add un-styled range before the styled span starts.
    if (start < span.at) {
      result.push(formatter.call(context, null, undefined, line.slice(start, span.at), result.length));
      start = span.at;
    }
    // Get all spans which are within current span.
    const subspans = [];
    for (let si = i + 1; si < spans.length && spans[si].at < span.at + span.len; si++) {
      subspans.push(spans[si]);
      i = si;
    }

    const tag = HTML_TAGS[span.tp] || {}
    result.push(formatter.call(context, span.tp, span.data,
      tag.isVoid ? null : forEach(line, start, span.at + span.len, subspans, formatter, context),
      result.length));

    start = span.at + span.len;
  }

  // Add the last unformatted range.
  if (start < end) {
    result.push(formatter.call(context, null, undefined, line.slice(start, end), result.length));
  }

  return result;
}

// Detect starts and ends of formatting spans. Unformatted spans are
// ignored at this stage.
function spannify(original, re_start, re_end, type) {
  const result = [];
  let index = 0;
  let line = original.slice(0); // make a copy;

  while (line.length > 0) {
    // match[0]; // match, like '*abc*'
    // match[1]; // match captured in parenthesis, like 'abc'
    // match['index']; // offset where the match started.

    // Find the opening token.
    const start = re_start.exec(line);
    if (start == null) {
      break;
    }

    // Because javascript RegExp does not support lookbehind, the actual offset may not point
    // at the markup character. Find it in the matched string.
    let start_offset = start['index'] + start[0].lastIndexOf(start[1]);
    // Clip the processed part of the string.
    line = line.slice(start_offset + 1);
    // start_offset is an offset within the clipped string. Convert to original index.
    start_offset += index;
    // Index now point to the beginning of 'line' within the 'original' string.
    index = start_offset + 1;

    // Find the matching closing token.
    const end = re_end ? re_end.exec(line) : null;
    if (end == null) {
      break;
    }
    let end_offset = end['index'] + end[0].indexOf(end[1]);
    // Clip the processed part of the string.
    line = line.slice(end_offset + 1);
    // Update offsets
    end_offset += index;
    // Index now point to the beginning of 'line' within the 'original' string.
    index = end_offset + 1;

    result.push({
      text: original.slice(start_offset + 1, end_offset),
      children: [],
      start: start_offset,
      end: end_offset,
      type: type
    });
  }

  return result;
}

// Convert linear array or spans into a tree representation.
// Keep standalone and nested spans, throw away partially overlapping spans.
function toTree(spans) {
  if (spans.length == 0) {
    return [];
  }

  const tree = [spans[0]];
  let last = spans[0];
  for (let i = 1; i < spans.length; i++) {
    // Keep spans which start after the end of the previous span or those which
    // are complete within the previous span.

    if (spans[i].start > last.end) {
      // Span is completely outside of the previous span.
      tree.push(spans[i]);
      last = spans[i];
    } else if (spans[i].end < last.end) {
      // Span is fully inside of the previous span. Push to subnode.
      last.children.push(spans[i]);
    }
    // Span could partially overlap, ignoring it as invalid.
  }

  // Recursively rearrange the subnodes.
  for (let i in tree) {
    tree[i].children = toTree(tree[i].children);
  }

  return tree;
}

// Get a list of entities from a text.
function extractEntities(line) {
  let match;
  let extracted = [];
  ENTITY_TYPES.map(function(entity) {
    while ((match = entity.re.exec(line)) !== null) {
      extracted.push({
        offset: match['index'],
        len: match[0].length,
        unique: match[0],
        data: entity.pack(match[0]),
        type: entity.name
      });
    }
  });

  if (extracted.length == 0) {
    return extracted;
  }

  // Remove entities detected inside other entities, like #hashtag in a URL.
  extracted.sort(function(a, b) {
    return a.offset - b.offset;
  });

  let idx = -1;
  extracted = extracted.filter(function(el) {
    const result = (el.offset > idx);
    idx = el.offset + el.len;
    return result;
  });

  return extracted;
}

// Convert the chunks into format suitable for serialization.
function draftify(chunks, startAt) {
  let plain = "";
  let ranges = [];
  for (let i in chunks) {
    const chunk = chunks[i];
    if (!chunk.text) {
      const drafty = draftify(chunk.children, plain.length + startAt);
      chunk.text = drafty.txt;
      ranges = ranges.concat(drafty.fmt);
    }

    if (chunk.type) {
      ranges.push({
        at: plain.length + startAt,
        len: chunk.text.length,
        tp: chunk.type
      });
    }

    plain += chunk.text;
  }
  return {
    txt: plain,
    fmt: ranges
  };
}

// Splice two strings: insert second string into the first one at the given index
function splice(src, at, insert) {
  return src.slice(0, at) + insert + src.slice(at);
}

/**
 * Parse plain text into Drafty document.
 * @memberof Drafty
 * @static
 *
 * @param {String} content - plain-text content to parse.
 * @return {Drafty} parsed document or null if the source is not plain text.
 */
Drafty.parse = function(content) {
  // Make sure we are parsing strings only.
  if (typeof content != 'string') {
    return null;
  }

  // Split text into lines. It makes further processing easier.
  const lines = content.split(/\r?\n/);

  // Holds entities referenced from text
  const entityMap = [];
  const entityIndex = {};

  // Processing lines one by one, hold intermediate result in blx.
  const blx = [];
  lines.map(function(line) {
    let spans = [];
    let entities;

    // Find formatted spans in the string.
    // Try to match each style.
    INLINE_STYLES.map(function(style) {
      // Each style could be matched multiple times.
      spans = spans.concat(spannify(line, style.start, style.end, style.name));
    });

    let block;
    if (spans.length == 0) {
      block = {
        txt: line
      };
    } else {
      // Sort spans by style occurence early -> late
      spans.sort(function(a, b) {
        return a.start - b.start;
      });

      // Convert an array of possibly overlapping spans into a tree
      spans = toTree(spans);

      // Build a tree representation of the entire string, not
      // just the formatted parts.
      const chunks = chunkify(line, 0, line.length, spans);

      const drafty = draftify(chunks, 0);

      block = {
        txt: drafty.txt,
        fmt: drafty.fmt
      };
    }

    // Extract entities from the cleaned up string.
    entities = extractEntities(block.txt);
    if (entities.length > 0) {
      const ranges = [];
      for (let i in entities) {
        // {offset: match['index'], unique: match[0], len: match[0].length, data: ent.packer(), type: ent.name}
        const entity = entities[i];
        let index = entityIndex[entity.unique];
        if (!index) {
          index = entityMap.length;
          entityIndex[entity.unique] = index;
          entityMap.push({
            tp: entity.type,
            data: entity.data
          });
        }
        ranges.push({
          at: entity.offset,
          len: entity.len,
          key: index
        });
      }
      block.ent = ranges;
    }

    blx.push(block);
  });

  const result = {
    txt: ""
  };

  // Merge lines and save line breaks as BR inline formatting.
  if (blx.length > 0) {
    result.txt = blx[0].txt;
    result.fmt = (blx[0].fmt || []).concat(blx[0].ent || []);

    for (let i = 1; i < blx.length; i++) {
      const block = blx[i];
      const offset = result.txt.length + 1;

      result.fmt.push({
        tp: 'BR',
        len: 1,
        at: offset - 1
      });

      result.txt += " " + block.txt;
      if (block.fmt) {
        result.fmt = result.fmt.concat(block.fmt.map(function(s) {
          s.at += offset;
          return s;
        }));
      }
      if (block.ent) {
        result.fmt = result.fmt.concat(block.ent.map(function(s) {
          s.at += offset;
          return s;
        }));
      }
    }

    if (result.fmt.length == 0) {
      delete result.fmt;
    }

    if (entityMap.length > 0) {
      result.ent = entityMap;
    }
  }
  return result;
}

/**
 * Initialize Drafty document to a plain text string.
 *
 * @param {String} plainText - string to use as Drafty content.
 *
 * @returns new Drafty document or null is plainText is not a string.
 */
Drafty.init = function(plainText) {
  if (typeof plainText != 'string') {
    return null;
  }
  return {
    txt: plainText
  };
}

/**
 * Append one Drafty document to another.
 *
 * @param {Drafty} first - Drafty document to append to.
 * @param {Drafty} second - Drafty document being appended.
 *
 * @return {Drafty} first document with the second appended to it.
 */
Drafty.append = function(first, second) {
  if (first == null) {
    return second;
  }
  if (second == null) {
    return first;
  }

  first.txt = first.txt || '';
  second.txt = second.txt || '';
  const len = first.txt.length;

  first.txt += second.txt;
  if (Array.isArray(second.fmt)) {
    first.fmt = first.fmt || [];
    if (Array.isArray(second.ent)) {
      first.ent = first.ent || [];
    }
    second.fmt.forEach(src => {
      const fmt = {
        at: src.at + len,
        len: src.len
      };
      if (src.tp) {
        fmt.tp = src.tp;
      } else {
        fmt.key = first.ent.length;
        first.ent.push(second.ent[src.key || 0]);
      }
      first.fmt.push(fmt);
    });
  }

  return first;
}

/**
 * @typedef Drafty.ImageDesc
 * @memberof Drafty
 * @type Object
 * @param {string} mime - mime-type of the image, e.g. "image/png"
 * @param {string} preview - base64-encoded image content (or preview, if large image is attached). Could be null/undefined.
 * @param {integer} width - width of the image
 * @param {integer} height - height of the image
 * @param {string} filename - file name suggestion for downloading the image.
 * @param {integer} size - size of the image in bytes. Treat is as an untrusted hint.
 * @param {string} refurl - reference to the content. Could be null/undefined.
 * @param {string} _tempPreview - base64-encoded image preview used during upload process; not serializable.
 * @param {Promise} urlPromise - Promise which returns content URL when resolved.
 */

/**
 * Insert inline image into Drafty document.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - document to add image to.
 * @param {integer} at - index where the object is inserted. The length of the image is always 1.
 * @param {ImageDesc} imageDesc - object with image paramenets and data.
 *
 * @return {Drafty} updated document.
 */
Drafty.insertImage = function(content, at, imageDesc) {
  content = content || {
    txt: " "
  };
  content.ent = content.ent || [];
  content.fmt = content.fmt || [];

  content.fmt.push({
    at: at,
    len: 1,
    key: content.ent.length
  });

  const ex = {
    tp: 'IM',
    data: {
      mime: imageDesc.mime,
      val: imageDesc.preview,
      width: imageDesc.width,
      height: imageDesc.height,
      name: imageDesc.filename,
      size: imageDesc.size | 0,
      ref: imageDesc.refurl
    }
  };

  if (imageDesc.urlPromise) {
    ex.data._tempPreview = imageDesc._tempPreview;
    ex.data._processing = true;
    imageDesc.urlPromise.then(
      (url) => {
        ex.data.ref = url;
        ex.data._tempPreview = undefined;
        ex.data._processing = undefined;
      },
      (err) => {
        /* catch the error, otherwise it will appear in the console. */
        ex.data._processing = undefined;
      }
    );
  }

  content.ent.push(ex);

  return content;
}

/**
 * Append inline image to Drafty document.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - document to add image to.
 * @param {ImageDesc} imageDesc - object with image paramenets.
 *
 * @return {Drafty} updated document.
 */
Drafty.appendImage = function(content, imageDesc) {
  content = content || {
    txt: ""
  };
  content.txt += " ";
  return Drafty.insertImage(content, content.txt.length - 1, imageDesc);
}

/**
 * @typedef Drafty.AttachmentDesc
 * @memberof Drafty
 * @type Object
 * @param {string} mime - mime-type of the image, e.g. "image/png"
 * @param {string} data - base64-encoded in-band content of small attachments. Could be null/undefined.
 * @param {string} filename - file name suggestion for downloading the attachment.
 * @param {integer} size - size of the file in bytes. Treat is as an untrusted hint.
 * @param {string} refurl - reference to the out-of-band content. Could be null/undefined.
 * @param {Promise} urlPromise - Promise which returns content URL when resolved.
 */

/**
 * Attach file to Drafty content. Either as a blob or as a reference.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - document to attach file to.
 * @param {AttachmentDesc} object - containing attachment description and data.
 *
 * @return {Drafty} updated document.
 */
Drafty.attachFile = function(content, attachmentDesc) {
  content = content || {
    txt: ""
  };
  content.ent = content.ent || [];
  content.fmt = content.fmt || [];

  content.fmt.push({
    at: -1,
    len: 0,
    key: content.ent.length
  });

  const ex = {
    tp: 'EX',
    data: {
      mime: attachmentDesc.mime,
      val: attachmentDesc.data,
      name: attachmentDesc.filename,
      ref: attachmentDesc.refurl,
      size: attachmentDesc.size | 0
    }
  }
  if (attachmentDesc.urlPromise) {
    ex.data._processing = true;
    attachmentDesc.urlPromise.then(
      (url) => {
        ex.data.ref = url;
        ex.data._processing = undefined;
      },
      (err) => {
        /* catch the error, otherwise it will appear in the console. */
        ex.data._processing = undefined;
      }
    );
  }
  content.ent.push(ex);

  return content;
}

/**
 * Wraps content into an interactive form.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty|string} content - to wrap into a form.
 * @param {number} at - index where the forms starts.
 * @param {number} len - length of the form content.
 *
 * @return {Drafty} updated document.
 */
Drafty.wrapAsForm = function(content, at, len) {
  if (typeof content == 'string') {
    content = {
      txt: content
    };
  }
  content.fmt = content.fmt || [];

  content.fmt.push({
    at: at,
    len: len,
    tp: 'FM'
  });

  return content;
}

/**
 * Insert clickable button into Drafty document.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty|string} content - Drafty document to insert button to or a string to be used as button text.
 * @param {number} at - location where the button is inserted.
 * @param {number} len - the length of the text to be used as button title.
 * @param {string} name - the button. Client should return it to the server when the button is clicked.
 * @param {string} actionType - the type of the button, one of 'url' or 'pub'.
 * @param {string} actionValue - the value to return on click:
 * @param {string} refUrl - the URL to go to when the 'url' button is clicked.
 *
 * @return {Drafty} updated document.
 */
Drafty.insertButton = function(content, at, len, name, actionType, actionValue, refUrl) {
  if (typeof content == 'string') {
    content = {
      txt: content
    };
  }

  if (!content || !content.txt || content.txt.length < at + len) {
    return null;
  }

  if (len <= 0 || ['url', 'pub'].indexOf(actionType) == -1) {
    return null;
  }
  // Ensure refUrl is a string.
  if (actionType == 'url' && !refUrl) {
    return null;
  }
  refUrl = '' + refUrl;

  content.ent = content.ent || [];
  content.fmt = content.fmt || [];

  content.fmt.push({
    at: at,
    len: len,
    key: content.ent.length
  });
  content.ent.push({
    tp: 'BN',
    data: {
      act: actionType,
      val: actionValue,
      ref: refUrl,
      name: name
    }
  });

  return content;
}

/**
 * Append clickable button to Drafty document.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty|string} content - Drafty document to insert button to or a string to be used as button text.
 * @param {string} title - the text to be used as button title.
 * @param {string} name - the button. Client should return it to the server when the button is clicked.
 * @param {string} actionType - the type of the button, one of 'url' or 'pub'.
 * @param {string} actionValue - the value to return on click:
 * @param {string} refUrl - the URL to go to when the 'url' button is clicked.
 *
 * @return {Drafty} updated document.
 */
Drafty.appendButton = function(content, title, name, actionType, actionValue, refUrl) {
  content = content || {
    txt: ""
  };
  const at = content.txt.length;
  content.txt += title;
  return Drafty.insertButton(content, at, title.length, name, actionType, actionValue, refUrl);
}

/**
 * Attach a generic JS object. The object is attached as a json string.
 * Intended for representing a form response.
 *
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - Drafty document to attach file to.
 * @param {Object} data - data to convert to json string and attach.
 * @returns {Drafty} the same document as <code>content</code>.
 */
Drafty.attachJSON = function(content, data) {
  content = content || {
    txt: ""
  };
  content.ent = content.ent || [];
  content.fmt = content.fmt || [];

  content.fmt.push({
    at: -1,
    len: 0,
    key: content.ent.length
  });

  content.ent.push({
    tp: 'EX',
    data: {
      mime: JSON_MIME_TYPE,
      val: data
    }
  });

  return content;
}
/**
 * Append line break to a Drafty document.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - Drafty document to append linebreak to.
 * @returns {Drafty} the same document as <code>content</code>.
 */
Drafty.appendLineBreak = function(content) {
  content = content || {
    txt: ""
  };
  content.fmt = content.fmt || [];
  content.fmt.push({
    at: content.txt.length,
    len: 1,
    tp: 'BR'
  });
  content.txt += " ";

  return content;
}
/**
 * Given Drafty document, convert it to HTML.
 * No attempt is made to strip pre-existing html markup.
 * This is potentially unsafe because <code>content.txt</code> may contain malicious
 * markup.
 * @memberof Tinode.Drafty
 * @static
 *
 * @param {Drafy} content - document to convert.
 *
 * @returns {string} HTML-representation of content.
 */
Drafty.UNSAFE_toHTML = function(content) {
  let {
    txt,
    fmt,
    ent
  } = content;

  const markup = [];
  if (fmt) {
    for (let i in fmt) {
      const range = fmt[i];
      const at = range.at | 0;
      let tp = range.tp;
      let data;
      if (!tp) {
        const entity = ent[range.key | 0];
        if (entity) {
          tp = entity.tp;
          data = entity.data;
        }
      }

      if (DECORATORS[tp]) {
        // Because we later sort in descending order, closing markup must come first.
        // Otherwise zero-length objects will not be represented correctly.
        markup.push({
          idx: at + range.len,
          len: -range.len,
          what: DECORATORS[tp].close(data)
        });
        markup.push({
          idx: at,
          len: range.len,
          what: DECORATORS[tp].open(data)
        });
      }
    }
  }

  markup.sort(function(a, b) {
    return b.idx == a.idx ? b.len - a.len : b.idx - a.idx; // in descending order
  });

  for (let i in markup) {
    if (markup[i].what) {
      txt = splice(txt, markup[i].idx, markup[i].what);
    }
  }

  return txt;
}

/**
 * Callback for applying custom formatting/transformation to a Drafty document.
 * Called once for each syle span.
 * @memberof Drafty
 * @static
 *
 * @callback Formatter
 * @param {string} style - style code such as "ST" or "IM".
 * @param {Object} data - entity's data
 * @param {Object} values - possibly styled subspans contained in this style span.
 * @param {number} index - of the current element among its siblings.
 */

/**
 * Transform Drafty document using custom formatting.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - content to transform.
 * @param {Formatter} formatter - callback which transforms individual elements
 * @param {Object} context - context provided to formatter as <code>this</code>.
 *
 * @return {Object} transformed object
 */
Drafty.format = function(content, formatter, context) {
  let {
    txt,
    fmt,
    ent
  } = content;

  // Assign default values.
  txt = txt || "";
  if (!Array.isArray(ent)) {
    ent = [];
  }

  if (!Array.isArray(fmt)) {
    // Handle special case when all values in fmt are 0 and fmt is skipped.
    if (ent.length == 1) {
      fmt = [{
        at: 0,
        len: 0,
        key: 0
      }];
    } else {
      return [txt];
    }
  }

  let spans = [].concat(fmt);

  // Zero values may have been stripped. Restore them.
  // Also ensure indexes and lengths are sane.
  spans.map(function(s) {
    s.at = s.at || 0;
    s.len = s.len || 0;
    if (s.len < 0) {
      s.len = 0;
    }
    if (s.at < -1) {
      s.at = -1;
    }
  });

  // Sort spans first by start index (asc) then by length (desc).
  spans.sort(function(a, b) {
    if (a.at - b.at == 0) {
      return b.len - a.len; // longer one comes first (<0)
    }
    return a.at - b.at;
  });

  // Denormalize entities into spans. Create a copy of the objects to leave
  // original Drafty object unchanged.
  spans = spans.map((s) => {
    let data;
    let tp = s.tp;
    if (!tp) {
      s.key = s.key || 0;
      if (ent[s.key]) {
        data = ent[s.key].data;
        tp = ent[s.key].tp;
      }
    }

    // Type still not defined? Hide invalid element.
    tp = tp || 'HD';

    return {
      tp: tp,
      data: data,
      at: s.at,
      len: s.len
    };
  });

  return forEach(txt, 0, txt.length, spans, formatter, context);
}

/**
 * Given Drafty document, convert it to plain text.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - document to convert to plain text.
 * @returns {string} plain-text representation of the drafty document.
 */
Drafty.toPlainText = function(content) {
  return typeof content == 'string' ? content : content.txt;
}

/**
 * Check if the document has no markup and no entities.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - content to check for presence of markup.
 * @returns <code>true</code> is content is plain text, <code>false</code> otherwise.
 */
Drafty.isPlainText = function(content) {
  return typeof content == 'string' || !(content.fmt || content.ent);
}

/**
 * Checks if the object represets is a valid Drafty document.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - content to check for validity.
 * @returns <code>true</code> is content is valid, <code>false</code> otherwise.
 */
Drafty.isValid = function(content) {
  if (!content) {
    return false;
  }

  const {
    txt,
    fmt,
    ent
  } = content;

  if (!txt && txt !== '' && !fmt && !ent) {
    return false;
  }

  const txt_type = typeof txt;
  if (txt_type != 'string' && txt_type != 'undefined' && txt !== null) {
    return false;
  }

  if (typeof fmt != 'undefined' && !Array.isArray(fmt) && fmt !== null) {
    return false;
  }

  if (typeof ent != 'undefined' && !Array.isArray(ent) && ent !== null) {
    return false;
  }
  return true;
}

/**
 * Check if the drafty document has attachments.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - document to check for attachments.
 * @returns <code>true</code> if there are attachments.
 */
Drafty.hasAttachments = function(content) {
  if (content.ent && content.ent.length > 0) {
    for (let i in content.ent) {
      if (content.ent[i] && content.ent[i].data && content.ent[i].tp == 'EX') {
        return true;
      }
    }
  }
  return false;
}

/**
 * Callback for applying custom formatting/transformation to a Drafty document.
 * Called once for each entity.
 * @memberof Drafty
 * @static
 *
 * @callback EntityCallback
 * @param {Object} data entity data.
 * @param {string} entity type.
 * @param {number} index entity's index in `content.ent`.
 */

/**
 * Enumerate attachments.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - document to process for attachments.
 * @param {EntityCallback} callback - callback to call for each attachment.
 * @param {Object} context - value of "this" for callback.
 */
Drafty.attachments = function(content, callback, context) {
  if (content.ent && content.ent.length > 0) {
    for (let i in content.ent) {
      if (content.ent[i] && content.ent[i].tp == 'EX' && content.ent[i].data) {
        callback.call(context, content.ent[i].data, i, 'EX');
      }
    }
  }
}

/**
 * Check if the drafty document has entities.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - document to check for entities.
 * @returns <code>true</code> if there are entities.
 */
Drafty.hasEntities = function(content) {
  return content.ent && content.ent.length > 0;
}

/**
 * Enumerate entities.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - document with entities to enumerate.
 * @param {EntityCallback} callback - callback to call for each entity.
 * @param {Object} context - value of "this" for callback.
 */
Drafty.entities = function(content, callback, context) {
  if (content.ent && content.ent.length > 0) {
    for (let i in content.ent) {
      if (content.ent[i]) {
        callback.call(context, content.ent[i].data, i, content.ent[i].tp);
      }
    }
  }
}

/**
 * Given the entity, get URL which can be used for downloading
 * entity data.
 * @memberof Drafty
 * @static
 *
 * @param {Object} entData - entity.data to get the URl from.
 * @returns {string} URL to download entity data or <code>null</code>.
 */
Drafty.getDownloadUrl = function(entData) {
  let url = null;
  if (entData.mime != JSON_MIME_TYPE && entData.val) {
    url = base64toObjectUrl(entData.val, entData.mime, Drafty.logger);
  } else if (typeof entData.ref == 'string') {
    url = entData.ref;
  }
  return url;
}

/**
 * Check if the entity data is not ready for sending, such as being uploaded to the server.
 * @memberof Drafty
 * @static
 *
 * @param {Object} entity.data to get the URl from.
 * @returns {boolean} true if upload is in progress, false otherwise.
 */
Drafty.isProcessing = function(entData) {
  return !!entData._processing;
}

/**
 * Given the entity, get URL which can be used for previewing
 * the entity.
 * @memberof Drafty
 * @static
 *
 * @param {Object} entity.data to get the URl from.
 *
 * @returns {string} url for previewing or null if no such url is available.
 */
Drafty.getPreviewUrl = function(entData) {
  return entData.val ? base64toObjectUrl(entData.val, entData.mime, Drafty.logger) : null;
}

/**
 * Get approximate size of the entity.
 * @memberof Drafty
 * @static
 *
 * @param {Object} entData - entity.data to get the size for.
 * @returns {number} size of entity data in bytes.
 */
Drafty.getEntitySize = function(entData) {
  // Either size hint or length of value. The value is base64 encoded,
  // the actual object size is smaller than the encoded length.
  return entData.size ? entData.size : entData.val ? (entData.val.length * 0.75) | 0 : 0;
}

/**
 * Get entity mime type.
 * @memberof Drafty
 * @static
 *
 * @param {Object} entData - entity.data to get the type for.
 * @returns {string} mime type of entity.
 */
Drafty.getEntityMimeType = function(entData) {
  return entData.mime || 'text/plain';
}

/**
 * Get HTML tag for a given two-letter style name.
 * @memberof Drafty
 * @static
 *
 * @param {string} style - two-letter style, like ST or LN.
 *
 * @returns {string} HTML tag name if style is found, '_UNKN' if not found, {code: undefined} if style is falsish.
 */
Drafty.tagName = function(style) {
  return style ? (HTML_TAGS[style] ? HTML_TAGS[style].name : '_UNKN') : undefined;
}

/**
 * For a given data bundle generate an object with HTML attributes,
 * for instance, given {url: "http://www.example.com/"} return
 * {href: "http://www.example.com/"}
 * @memberof Drafty
 * @static
 *
 * @param {string} style - two-letter style to generate attributes for.
 * @param {Object} data - data bundle to convert to attributes
 *
 * @returns {Object} object with HTML attributes.
 */
Drafty.attrValue = function(style, data) {
  if (data && DECORATORS[style]) {
    return DECORATORS[style].props(data);
  }

  return undefined;
}

/**
 * Drafty MIME type.
 * @memberof Drafty
 * @static
 *
 * @returns {string} HTTP Content-Type "text/x-drafty".
 */
Drafty.getContentType = function() {
  return 'text/x-drafty';
}

/**
 * Shorten Drafty document and strip all entity data leaving just inline styles and entity references.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} original - Drafty object to shorten.
 * @param {number} length - length in characters to shorten to.
 * @returns new shortened Drafty object leaving the original intact.
 */
Drafty.preview = function(original, length) {
  if (!original || length <= 0 || typeof original != 'object') {
    return null;
  }

  const {
    txt,
    fmt,
    ent
  } = original;

  const preview = {
    txt: ''
  };

  if (typeof txt == 'string') {
    preview.txt = txt.substr(0, length);
  }
  let len = preview.txt.length;

  if (Array.isArray(fmt) && fmt.length > 0) {
    // Old key to new key entity mapping.
    const ent_refs = [];
    // Count styles which start within the new length of the text and save entity keys as a set.
    let fmt_count = 0;
    let ent_count = 0;
    fmt.forEach((st) => {
      st.at |= 0;
      if (st.at < len) {
        fmt_count++;
        if (!st.tp) {
          st.key |= 0;
          if (!ent_refs[st.key]) {
            ent_refs[st.key] = ent_count;
            ent_count++;
          }
        }
      }
    });

    if (fmt_count == 0) {
      return preview;
    }

    // Allocate space for copying styles and entities.
    preview.fmt = [];
    if (Array.isArray(ent) && ent_refs.length > 0) {
      preview.ent = [];
    }

    // Insertion point for styles.
    let fmt_idx = 0;
    fmt.forEach((st) => {
      if (st.at < len) {
        const style = {
          at: st.at,
          len: st.len | 0
        };
        if (st.tp) {
          style.tp = '' + st.tp;
        } else if (Array.isArray(ent) && ent.length > st.key && typeof ent_refs[st.key] == 'number') {
          style.key = ent_refs[st.key];
          preview.ent[style.key] = copyLight(ent[st.key]);
        } else {
          return;
        }
        preview.fmt[fmt_idx++] = style;
      }
    });
  }

  return preview;
}

// Create a copy of an entity without large data.
function copyLight(ent) {
  let result = {
    tp: ent.tp
  };
  if (ent.data && Object.entries(ent.data).length != 0) {
    const dc = {};
    ["mime", "name", "width", "height", "size"].forEach((key) => {
      const val = ent.data[key];
      if (val) {
        dc[key] = val;
      }
    });
    if (Object.entries(dc).length != 0) {
      result.data = dc;
    }
  }
  return result;
}

if (typeof module != 'undefined') {
  module.exports = Drafty;
}

},{}],6:[function(require,module,exports){
/**
 * @file Utilities for uploading and downloading files.
 *
 * @copyright 2015-2021 Tinode
 * @summary Javascript bindings for Tinode.
 * @license Apache 2.0
 * @version 0.17
 */
'use strict';

const { jsonParseHelper } = require('./utils.js');

let XHRProvider;

/**
 * @class LargeFileHelper - utilities for uploading and downloading files out of band.
 * Don't instantiate this class directly. Use {Tinode.getLargeFileHelper} instead.
 * @memberof Tinode
 *
 * @param {Tinode} tinode - the main Tinode object.
 * @param {string} version - protocol version, i.e. '0'.
 */
const LargeFileHelper = function(tinode, version) {
  this._tinode = tinode;
  this._version = version;

  this._apiKey = tinode._apiKey;
  this._authToken = tinode.getAuthToken();
  this._reqId = tinode.getNextUniqueId();
  this.xhr = new XHRProvider();

  // Promise
  this.toResolve = null;
  this.toReject = null;

  // Callbacks
  this.onProgress = null;
  this.onSuccess = null;
  this.onFailure = null;
}

LargeFileHelper.prototype = {
  /**
   * Start uploading the file to a non-default endpoint.
   *
   * @memberof Tinode.LargeFileHelper#
   *
   * @param {string} baseUrl alternative base URL of upload server.
   * @param {File|Blob} data to upload.
   * @param {string} avatarFor topic name if the upload represents an avatar.
   * @param {Callback} onProgress callback. Takes one {float} parameter 0..1
   * @param {Callback} onSuccess callback. Called when the file is successfully uploaded.
   * @param {Callback} onFailure callback. Called in case of a failure.
   *
   * @returns {Promise} resolved/rejected when the upload is completed/failed.
   */
  uploadWithBaseUrl: function(baseUrl, data, avatarFor, onProgress, onSuccess, onFailure) {
    if (!this._authToken) {
      throw new Error("Must authenticate first");
    }
    const instance = this;

    let url = `/v${this._version}/file/u/`;
    if (baseUrl) {
      let base = baseUrl;
      if (base.endsWith('/')) {
        // Removing trailing slash.
        base = base.slice(0, -1);
      }
      if (base.startsWith('http://') || base.startsWith('https://')) {
        url = base + url;
      } else {
        throw new Error(`Invalid base URL '${baseUrl}'`);
      }
    }
    this.xhr.open('POST', url, true);
    this.xhr.setRequestHeader('X-Tinode-APIKey', this._apiKey);
    this.xhr.setRequestHeader('X-Tinode-Auth', `Token ${this._authToken.token}`);
    const result = new Promise((resolve, reject) => {
      this.toResolve = resolve;
      this.toReject = reject;
    });

    this.onProgress = onProgress;
    this.onSuccess = onSuccess;
    this.onFailure = onFailure;

    this.xhr.upload.onprogress = (e) => {
      if (e.lengthComputable && instance.onProgress) {
        instance.onProgress(e.loaded / e.total);
      }
    }

    this.xhr.onload = function() {
      let pkt;
      try {
        pkt = JSON.parse(this.response, jsonParseHelper);
      } catch (err) {
        instance._tinode.logger("ERROR: Invalid server response in LargeFileHelper", this.response);
        pkt = {
          ctrl: {
            code: this.status,
            text: this.statusText
          }
        };
      }

      if (this.status >= 200 && this.status < 300) {
        if (instance.toResolve) {
          instance.toResolve(pkt.ctrl.params.url);
        }
        if (instance.onSuccess) {
          instance.onSuccess(pkt.ctrl);
        }
      } else if (this.status >= 400) {
        if (instance.toReject) {
          instance.toReject(new Error(`${pkt.ctrl.text} (${pkt.ctrl.code})`));
        }
        if (instance.onFailure) {
          instance.onFailure(pkt.ctrl)
        }
      } else {
        instance._tinode.logger("ERROR: Unexpected server response status", this.status, this.response);
      }
    };

    this.xhr.onerror = function(e) {
      if (instance.toReject) {
        instance.toReject(new Error("failed"));
      }
      if (instance.onFailure) {
        instance.onFailure(null);
      }
    };

    this.xhr.onabort = function(e) {
      if (instance.toReject) {
        instance.toReject(new Error("upload cancelled by user"));
      }
      if (instance.onFailure) {
        instance.onFailure(null);
      }
    };

    try {
      const form = new FormData();
      form.append('file', data);
      form.set('id', this._reqId);
      if (avatarFor) {
        form.set('topic', avatarFor);
      }
      this.xhr.send(form);
    } catch (err) {
      if (this.toReject) {
        this.toReject(err);
      }
      if (this.onFailure) {
        this.onFailure(null);
      }
    }

    return result;
  },

  /**
   * Start uploading the file to default endpoint.
   *
   * @memberof Tinode.LargeFileHelper#
   *
   * @param {File|Blob} data to upload
   * @param {string} avatarFor topic name if the upload represents an avatar.
   * @param {Callback} onProgress callback. Takes one {float} parameter 0..1
   * @param {Callback} onSuccess callback. Called when the file is successfully uploaded.
   * @param {Callback} onFailure callback. Called in case of a failure.
   *
   * @returns {Promise} resolved/rejected when the upload is completed/failed.
   */
  upload: function(data, avatarFor, onProgress, onSuccess, onFailure) {
    const baseUrl = (this._tinode._secure ? 'https://' : 'http://') + this._tinode._host;
    return this.uploadWithBaseUrl(baseUrl, data, avatarFor, onProgress, onSuccess, onFailure);
  },

  /**
   * Download the file from a given URL using GET request. This method works with the Tinode server only.
   *
   * @memberof Tinode.LargeFileHelper#
   *
   * @param {string} relativeUrl - URL to download the file from. Must be relative url, i.e. must not contain the host.
   * @param {string=} filename - file name to use for the downloaded file.
   *
   * @returns {Promise} resolved/rejected when the download is completed/failed.
   */
  download: function(relativeUrl, filename, mimetype, onProgress, onError) {
    if (!Tinode.isRelativeURL(relativeUrl)) {
      // As a security measure refuse to download from an absolute URL.
      if (onError) {
        onError(`The URL '${relativeUrl}' must be relative, not absolute`);
      }
      return;
    }
    if (!this._authToken) {
      if (onError) {
        onError("Must authenticate first");
      }
      return;
    }
    const instance = this;
    // Get data as blob (stored by the browser as a temporary file).
    this.xhr.open('GET', relativeUrl, true);
    this.xhr.setRequestHeader('X-Tinode-APIKey', this._apiKey);
    this.xhr.setRequestHeader('X-Tinode-Auth', 'Token ' + this._authToken.token);
    this.xhr.responseType = 'blob';

    this.onProgress = onProgress;
    this.xhr.onprogress = function(e) {
      if (instance.onProgress) {
        // Passing e.loaded instead of e.loaded/e.total because e.total
        // is always 0 with gzip compression enabled by the server.
        instance.onProgress(e.loaded);
      }
    };

    const result = new Promise((resolve, reject) => {
      this.toResolve = resolve;
      this.toReject = reject;
    });

    // The blob needs to be saved as file. There is no known way to
    // save the blob as file other than to fake a click on an <a href... download=...>.
    this.xhr.onload = function() {
      if (this.status == 200) {
        const link = document.createElement('a');
        // URL.createObjectURL is not available in non-browser environment. This call will fail.
        link.href = window.URL.createObjectURL(new Blob([this.response], {
          type: mimetype
        }));
        link.style.display = 'none';
        link.setAttribute('download', filename);
        document.body.appendChild(link);
        link.click();
        document.body.removeChild(link);
        window.URL.revokeObjectURL(link.href);
        if (instance.toResolve) {
          instance.toResolve();
        }
      } else if (this.status >= 400 && instance.toReject) {
        // The this.responseText is undefined, must use this.response which is a blob.
        // Need to convert this.response to JSON. The blob can only be accessed by the
        // FileReader.
        const reader = new FileReader();
        reader.onload = function() {
          try {
            const pkt = JSON.parse(this.result, jsonParseHelper);
            instance.toReject(new Error(`${pkt.ctrl.text} (${pkt.ctrl.code})`));
          } catch (err) {
            instance._tinode.logger("ERROR: Invalid server response in LargeFileHelper", this.result);
            instance.toReject(err);
          }
        };
        reader.readAsText(this.response);
      }
    };

    this.xhr.onerror = function(e) {
      if (instance.toReject) {
        instance.toReject(new Error("failed"));
      }
    };

    this.xhr.onabort = function() {
      if (instance.toReject) {
        instance.toReject(null);
      }
    };

    try {
      this.xhr.send();
    } catch (err) {
      if (this.toReject) {
        this.toReject(err);
      }
    }

    return result;
  },

  /**
   * Try to cancel an ongoing upload or download.
   * @memberof Tinode.LargeFileHelper#
   */
  cancel: function() {
    if (this.xhr && this.xhr.readyState < 4) {
      this.xhr.abort();
    }
  },

  /**
   * Get unique id of this request.
   * @memberof Tinode.LargeFileHelper#
   *
   * @returns {string} unique id
   */
  getId: function() {
    return this._reqId;
  }
};

/**
 * To use LargeFileHelper in a non browser context, supply XMLHttpRequest provider.
 * @static
 * @memberof LargeFileHelper
 * @param xhrProvider XMLHttpRequest provider, e.g. for node <code>require('xhr')</code>.
 */
LargeFileHelper.setNetworkProvider = function(xhrProvider) {
  XHRProvider = xhrProvider;
};

if (typeof module != 'undefined') {
  module.exports = LargeFileHelper;
}

},{"./utils.js":9}],7:[function(require,module,exports){
/**
 * @file Helper class for constructing {@link Tinode.GetQuery}.
 *
 * @copyright 2015-2021 Tinode
 * @summary Javascript bindings for Tinode.
 * @license Apache 2.0
 * @version 0.17
 */
'use strict';

/**
 * Helper class for constructing {@link Tinode.GetQuery}.
 *
 * @class MetaGetBuilder
 * @memberof Tinode
 *
 * @param {Tinode.Topic} parent topic which instantiated this builder.
 */
const MetaGetBuilder = function(parent) {
  this.topic = parent;
  this.what = {};
}

MetaGetBuilder.prototype = {

  // Get timestamp of the most recent desc update.
  _get_desc_ims: function() {
    return this.topic.updated;
  },

  // Get timestamp of the most recent subs update.
  _get_subs_ims: function() {
    if (this.topic.isP2PType()) {
      return this._get_desc_ims();
    }
    return this.topic._lastSubsUpdate;
  },

  /**
   * Add query parameters to fetch messages within explicit limits.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {number=} since - messages newer than this (inclusive);
   * @param {number=} before - older than this (exclusive)
   * @param {number=} limit - number of messages to fetch
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withData: function(since, before, limit) {
    this.what['data'] = {
      since: since,
      before: before,
      limit: limit
    };
    return this;
  },

  /**
   * Add query parameters to fetch messages newer than the latest saved message.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {number=} limit - number of messages to fetch
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withLaterData: function(limit) {
    return this.withData(this.topic._maxSeq > 0 ? this.topic._maxSeq + 1 : undefined, undefined, limit);
  },

  /**
   * Add query parameters to fetch messages older than the earliest saved message.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {number=} limit - maximum number of messages to fetch.
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withEarlierData: function(limit) {
    return this.withData(undefined, this.topic._minSeq > 0 ? this.topic._minSeq : undefined, limit);
  },

  /**
   * Add query parameters to fetch topic description if it's newer than the given timestamp.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {Date=} ims - fetch messages newer than this timestamp.
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withDesc: function(ims) {
    this.what['desc'] = {
      ims: ims
    };
    return this;
  },

  /**
   * Add query parameters to fetch topic description if it's newer than the last update.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withLaterDesc: function() {
    return this.withDesc(this._get_desc_ims());
  },

  /**
   * Add query parameters to fetch subscriptions.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {Date=} ims - fetch subscriptions modified more recently than this timestamp
   * @param {number=} limit - maximum number of subscriptions to fetch.
   * @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withSub: function(ims, limit, userOrTopic) {
    const opts = {
      ims: ims,
      limit: limit
    };
    if (this.topic.getType() == 'me') {
      opts.topic = userOrTopic;
    } else {
      opts.user = userOrTopic;
    }
    this.what['sub'] = opts;
    return this;
  },

  /**
   * Add query parameters to fetch a single subscription.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {Date=} ims - fetch subscriptions modified more recently than this timestamp
   * @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withOneSub: function(ims, userOrTopic) {
    return this.withSub(ims, undefined, userOrTopic);
  },

  /**
   * Add query parameters to fetch a single subscription if it's been updated since the last update.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withLaterOneSub: function(userOrTopic) {
    return this.withOneSub(this.topic._lastSubsUpdate, userOrTopic);
  },

  /**
   * Add query parameters to fetch subscriptions updated since the last update.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {number=} limit - maximum number of subscriptions to fetch.
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withLaterSub: function(limit) {
    return this.withSub(this._get_subs_ims(), limit);
  },

  /**
   * Add query parameters to fetch topic tags.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withTags: function() {
    this.what['tags'] = true;
    return this;
  },

  /**
   * Add query parameters to fetch user's credentials. <code>'me'</code> topic only.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withCred: function() {
    if (this.topic.getType() == 'me') {
      this.what['cred'] = true;
    } else {
      this.topic._tinode.logger("ERROR: Invalid topic type for MetaGetBuilder:withCreds", this.topic.getType());
    }
    return this;
  },

  /**
   * Add query parameters to fetch deleted messages within explicit limits. Any/all parameters can be null.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {number=} since - ids of messages deleted since this 'del' id (inclusive)
   * @param {number=} limit - number of deleted message ids to fetch
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withDel: function(since, limit) {
    if (since || limit) {
      this.what['del'] = {
        since: since,
        limit: limit
      };
    }
    return this;
  },

  /**
   * Add query parameters to fetch messages deleted after the saved <code>'del'</code> id.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {number=} limit - number of deleted message ids to fetch
   *
   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.
   */
  withLaterDel: function(limit) {
    // Specify 'since' only if we have already received some messages. If
    // we have no locally cached messages then we don't care if any messages were deleted.
    return this.withDel(this.topic._maxSeq > 0 ? this.topic._maxDel + 1 : undefined, limit);
  },

  /**
   * Construct parameters.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @returns {Tinode.GetQuery} Get query
   */
  build: function() {
    const what = [];
    const instance = this;
    let params = {};
    ['data', 'sub', 'desc', 'tags', 'cred', 'del'].map(function(key) {
      if (instance.what.hasOwnProperty(key)) {
        what.push(key);
        if (Object.getOwnPropertyNames(instance.what[key]).length > 0) {
          params[key] = instance.what[key];
        }
      }
    });
    if (what.length > 0) {
      params.what = what.join(' ');
    } else {
      params = undefined;
    }
    return params;
  }
};

if (typeof module != 'undefined') {
  module.exports = MetaGetBuilder;
}

},{}],8:[function(require,module,exports){
(function (global){(function (){
/**
 * @file SDK to connect to Tinode chat server.
 * See <a href="https://github.com/tinode/webapp">
 * https://github.com/tinode/webapp</a> for real-life usage.
 *
 * @copyright 2015-2021 Tinode
 * @summary Javascript bindings for Tinode.
 * @license Apache 2.0
 * @version 0.17
 *
 * @example
 * <head>
 * <script src=".../tinode.js"></script>
 * </head>
 *
 * <body>
 *  ...
 * <script>
 *  // Instantiate tinode.
 *  const tinode = new Tinode(APP_NAME, HOST, API_KEY, null, true);
 *  tinode.enableLogging(true);
 *  // Add logic to handle disconnects.
 *  tinode.onDisconnect = function(err) { ... };
 *  // Connect to the server.
 *  tinode.connect().then(() => {
 *    // Connected. Login now.
 *    return tinode.loginBasic(login, password);
 *  }).then((ctrl) => {
 *    // Logged in fine, attach callbacks, subscribe to 'me'.
 *    const me = tinode.getMeTopic();
 *    me.onMetaDesc = function(meta) { ... };
 *    // Subscribe, fetch topic description and the list of contacts.
 *    me.subscribe({get: {desc: {}, sub: {}});
 *  }).catch((err) => {
 *    // Login or subscription failed, do something.
 *    ...
 *  });
 *  ...
 * </script>
 * </body>
 */
'use strict';

// NOTE TO DEVELOPERS:
// Localizable strings should be double quoted "строка на другом языке",
// non-localizable strings should be single quoted 'non-localized'.

// Module imports Node.js style.
if (typeof require != 'function') {
  throw new Error("Unable to load modules: require() is not available.");
}

const AccessMode = require('./access-mode.js');
const CBuffer = require('./cbuffer.js');
const Connection = require('./connection.js');
const DBCache = require('./db.js');
const Drafty = require('./drafty.js');
const LargeFileHelper = require('./large-file.js');
const MetaGetBuilder = require('./meta-builder.js');
const {
  jsonParseHelper
} = require('./utils.js');

const package_version = require('../version.json').version;

let WebSocketProvider;
if (typeof WebSocket != 'undefined') {
  WebSocketProvider = WebSocket;
}

let XHRProvider;
if (typeof XMLHttpRequest != 'undefined') {
  XHRProvider = XMLHttpRequest;
}

initForNonBrowserApp();

// Global constants
const PROTOCOL_VERSION = '0'; // Major component of the version, e.g. '0' in '0.17.1'.
const VERSION = package_version || '0.17';
const LIBRARY = 'tinodejs/' + VERSION;

const TOPIC_NEW = 'new';
const TOPIC_NEW_CHAN = 'nch';
const TOPIC_ME = 'me';
const TOPIC_FND = 'fnd';
const TOPIC_SYS = 'sys';
const TOPIC_CHAN = 'chn';
const USER_NEW = 'new';

// Starting value of a locally-generated seqId used for pending messages.
const LOCAL_SEQID = 0xFFFFFFF;

const MESSAGE_STATUS_NONE = 0; // Status not assigned.
const MESSAGE_STATUS_QUEUED = 1; // Local ID assigned, in progress to be sent.
const MESSAGE_STATUS_SENDING = 2; // Transmission started.
const MESSAGE_STATUS_FAILED = 3; // At least one attempt was made to send the message.
const MESSAGE_STATUS_SENT = 4; // Delivered to the server.
const MESSAGE_STATUS_RECEIVED = 5; // Received by the client.
const MESSAGE_STATUS_READ = 6; // Read by the user.
const MESSAGE_STATUS_TO_ME = 7; // Message from another user.
const MESSAGE_STATUS_DEL_RANGE = 8; // Message is a deleted range.

// Reject unresolved futures after this many milliseconds.
const EXPIRE_PROMISES_TIMEOUT = 5000;
// Periodicity of garbage collection of unresolved futures.
const EXPIRE_PROMISES_PERIOD = 1000;

// Default number of messages to pull into memory from persistent cache.
const DEFAULT_MESSAGES_PAGE = 24;

// Utility functions

// Polyfill for non-browser context, e.g. NodeJs.
function initForNonBrowserApp() {
  // Tinode requirement in native mode because react native doesn't provide Base64 method
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';

  if (typeof btoa == 'undefined') {
    global.btoa = function(input = '') {
      let str = input;
      let output = '';

      for (let block = 0, charCode, i = 0, map = chars; str.charAt(i | 0) || (map = '=', i % 1); output += map.charAt(63 & block >> 8 - i % 1 * 8)) {

        charCode = str.charCodeAt(i += 3 / 4);

        if (charCode > 0xFF) {
          throw new Error("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");
        }
        block = block << 8 | charCode;
      }

      return output;
    };
  }

  if (typeof atob == 'undefined') {
    global.atob = function(input = '') {
      let str = input.replace(/=+$/, '');
      let output = '';

      if (str.length % 4 == 1) {
        throw new Error("'atob' failed: The string to be decoded is not correctly encoded.");
      }
      for (let bc = 0, bs = 0, buffer, i = 0; buffer = str.charAt(i++);

        ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,
          bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0
      ) {
        buffer = chars.indexOf(buffer);
      }

      return output;
    };
  }

  if (typeof window == 'undefined') {
    global.window = {
      WebSocket: WebSocketProvider,
      XMLHttpRequest: XHRProvider,
      URL: {
        createObjectURL: function() {
          throw new Error("Unable to use URL.createObjectURL in a non-browser application");
        }
      }
    }
  }

  Connection.setNetworkProviders(WebSocketProvider, XHRProvider);
  LargeFileHelper.setNetworkProvider(XHRProvider);
}

// Detect find most useful network transport.
function detectTransport() {
  if (typeof window == 'object') {
    if (window['WebSocket']) {
      return 'ws';
    } else if (window['XMLHttpRequest']) {
      // The browser or node has no websockets, using long polling.
      return 'lp';
    }
  }
  return null;
}

// Checks if 'd' is a valid non-zero date;
function isValidDate(d) {
  return (d instanceof Date) && !isNaN(d) && (d.getTime() != 0);
}

// RFC3339 formater of Date
function rfc3339DateString(d) {
  if (!isValidDate(d)) {
    return undefined;
  }

  const pad = function(val, sp) {
    sp = sp || 2;
    return '0'.repeat(sp - ('' + val).length) + val;
  };

  const millis = d.getUTCMilliseconds();
  return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) +
    'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) +
    (millis ? '.' + pad(millis, 3) : '') + 'Z';
}

// btoa replacement. Stock btoa fails on on non-Latin1 strings.
function b64EncodeUnicode(str) {
  // The encodeURIComponent percent-encodes UTF-8 string,
  // then the percent encoding is converted into raw bytes which
  // can be fed into btoa.
  return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g,
    function toSolidBytes(match, p1) {
      return String.fromCharCode('0x' + p1);
    }));
}

// Recursively merge src's own properties to dst.
// Ignore properties where ignore[property] is true.
// Array and Date objects are shallow-copied.
function mergeObj(dst, src, ignore) {
  if (typeof src != 'object') {
    if (src === Tinode.DEL_CHAR) {
      return undefined;
    }
    if (src === undefined) {
      return dst;
    }
    return src;
  }
  // JS is crazy: typeof null is 'object'.
  if (src === null) {
    return src;
  }

  // Handle Date
  if (src instanceof Date && !isNaN(src)) {
    return (!dst || !(dst instanceof Date) || isNaN(dst) || dst < src) ? src : dst;
  }

  // Access mode
  if (src instanceof AccessMode) {
    return new AccessMode(src);
  }

  // Handle Array
  if (src instanceof Array) {
    return src;
  }

  if (!dst || dst === Tinode.DEL_CHAR) {
    dst = src.constructor();
  }

  for (let prop in src) {
    if (src.hasOwnProperty(prop) &&
      (!ignore || !ignore[prop]) &&
      (prop != '_noForwarding')) {

      dst[prop] = mergeObj(dst[prop], src[prop]);
    }
  }
  return dst;
}

// Update object stored in a cache. Returns updated value.
function mergeToCache(cache, key, newval, ignore) {
  cache[key] = mergeObj(cache[key], newval, ignore);
  return cache[key];
}

function stringToDate(obj) {
  if (typeof obj.created == 'string') {
    obj.created = new Date(obj.created);
  }
  if (typeof obj.updated == 'string') {
    obj.updated = new Date(obj.updated);
  }
  if (typeof obj.touched == 'string') {
    obj.touched = new Date(obj.touched);
  }
}

// JSON stringify helper - pre-processor for JSON.stringify
function jsonBuildHelper(key, val) {
  if (val instanceof Date) {
    // Convert javascript Date objects to rfc3339 strings
    val = rfc3339DateString(val);
  } else if (val instanceof AccessMode) {
    val = val.jsonHelper();
  } else if (val === undefined || val === null || val === false ||
    (Array.isArray(val) && val.length == 0) ||
    ((typeof val == 'object') && (Object.keys(val).length == 0))) {
    // strip out empty elements while serializing objects to JSON
    return undefined;
  }

  return val;
};

// Strips all values from an object of they evaluate to false or if their name starts with '_'.
// Used on all outgoing object before serialization to string.
function simplify(obj) {
  Object.keys(obj).forEach((key) => {
    if (key[0] == '_') {
      // Strip fields like "obj._key".
      delete obj[key];
    } else if (!obj[key]) {
      // Strip fields which evaluate to false.
      delete obj[key];
    } else if (Array.isArray(obj[key]) && obj[key].length == 0) {
      // Strip empty arrays.
      delete obj[key];
    } else if (!obj[key]) {
      // Strip fields which evaluate to false.
      delete obj[key];
    } else if (obj[key] instanceof Date) {
      // Strip invalid or zero date.
      if (!isValidDate(obj[key])) {
        delete obj[key];
      }
    } else if (typeof obj[key] == 'object') {
      simplify(obj[key]);
      // Strip empty objects.
      if (Object.getOwnPropertyNames(obj[key]).length == 0) {
        delete obj[key];
      }
    }
  });
  return obj;
};

// Trim whitespace, strip empty and duplicate elements elements.
// If the result is an empty array, add a single element "\u2421" (Unicode Del character).
function normalizeArray(arr) {
  let out = [];
  if (Array.isArray(arr)) {
    // Trim, throw away very short and empty tags.
    for (let i = 0, l = arr.length; i < l; i++) {
      let t = arr[i];
      if (t) {
        t = t.trim().toLowerCase();
        if (t.length > 1) {
          out.push(t);
        }
      }
    }
    out.sort().filter(function(item, pos, ary) {
      return !pos || item != ary[pos - 1];
    });
  }
  if (out.length == 0) {
    // Add single tag with a Unicode Del character, otherwise an ampty array
    // is ambiguos. The Del tag will be stripped by the server.
    out.push(Tinode.DEL_CHAR);
  }
  return out;
}

// Trims very long strings (encoded images) to make logged packets more readable.
function jsonLoggerHelper(key, val) {
  if (typeof val == 'string' && val.length > 128) {
    return '<' + val.length + ', bytes: ' + val.substring(0, 12) + '...' + val.substring(val.length - 12) + '>';
  }
  return jsonBuildHelper(key, val);
};

// Parse browser user agent to extract browser name and version.
function getBrowserInfo(ua, product) {
  ua = ua || '';
  let reactnative = '';
  // Check if this is a ReactNative app.
  if (/reactnative/i.test(product)) {
    reactnative = 'ReactNative; ';
  }
  let result;
  // Remove useless string.
  ua = ua.replace(' (KHTML, like Gecko)', '');
  // Test for WebKit-based browser.
  let m = ua.match(/(AppleWebKit\/[.\d]+)/i);
  if (m) {
    // List of common strings, from more useful to less useful.
    // All unknown strings get the highest (-1) priority.
    const priority = ['edg', 'chrome', 'safari', 'mobile', 'version'];
    let tmp = ua.substr(m.index + m[0].length).split(' ');
    let tokens = [];
    let version; // 1.0 in Version/1.0 or undefined;
    // Split string like 'Name/0.0.0' into ['Name', '0.0.0', 3] where the last element is the priority.
    for (let i = 0; i < tmp.length; i++) {
      let m2 = /([\w.]+)[\/]([\.\d]+)/.exec(tmp[i]);
      if (m2) {
        // Unknown values are highest priority (-1).
        tokens.push([m2[1], m2[2], priority.findIndex((e) => {
          return m2[1].toLowerCase().startsWith(e);
        })]);
        if (m2[1] == 'Version') {
          version = m2[2];
        }
      }
    }
    // Sort by priority: more interesting is earlier than less interesting.
    tokens.sort((a, b) => {
      return a[2] - b[2];
    });
    if (tokens.length > 0) {
      // Return the least common browser string and version.
      if (tokens[0][0].toLowerCase().startsWith('edg')) {
        tokens[0][0] = 'Edge';
      } else if (tokens[0][0] == 'OPR') {
        tokens[0][0] = 'Opera';
      } else if (tokens[0][0] == 'Safari' && version) {
        tokens[0][1] = version;
      }
      result = tokens[0][0] + '/' + tokens[0][1];
    } else {
      // Failed to ID the browser. Return the webkit version.
      result = m[1];
    }
  } else if (/firefox/i.test(ua)) {
    m = /Firefox\/([.\d]+)/g.exec(ua);
    if (m) {
      result = 'Firefox/' + m[1];
    } else {
      result = 'Firefox/?';
    }
  } else {
    // Neither AppleWebKit nor Firefox. Try the last resort.
    m = /([\w.]+)\/([.\d]+)/.exec(ua);
    if (m) {
      result = m[1] + '/' + m[2];
    } else {
      m = ua.split(' ');
      result = m[0];
    }
  }

  // Shorten the version to one dot 'a.bb.ccc.d -> a.bb' at most.
  m = result.split('/');
  if (m.length > 1) {
    const v = m[1].split('.');
    const minor = v[1] ? '.' + v[1].substr(0, 2) : '';
    result = `${m[0]}/${v[0]}${minor}`;
  }
  return reactnative + result;
}

/**
 * @class Tinode
 *
 * @param {Object} config - configuration parameters.
 * @param {string} config.appName - Name of the calling application to be reported in the User Agent.
 * @param {string} config.host - Host name and optional port number to connect to.
 * @param {string} config.apiKey - API key generated by <code>keygen</code>.
 * @param {string} config.transport - See {@link Tinode.Connection#transport}.
 * @param {boolean} config.secure - Use Secure WebSocket if <code>true</code>.
 * @param {string} config.platform - Optional platform identifier, one of <code>"ios"</code>, <code>"web"</code>, <code>"android"</code>.
 * @param {boolen} config.persist - Use IndexedDB persistent storage.
 * @param {function} onComplete - callback to call when initialization is completed.
 */
var Tinode = function(config, onComplete) {
  this._host = config.host;
  this._secure = config.secure;

  // Client-provided application name, format <Name>/<version number>
  this._appName = config.appName || "Undefined";

  // API Key.
  this._apiKey = config.apiKey;

  // Name and version of the browser.
  this._browser = '';
  this._platform = config.platform || 'web';
  // Hardware
  this._hwos = 'undefined';
  this._humanLanguage = 'xx';
  // Underlying OS.
  if (typeof navigator != 'undefined') {
    this._browser = getBrowserInfo(navigator.userAgent, navigator.product);
    this._hwos = navigator.platform;
    // This is the default language. It could be changed by client.
    this._humanLanguage = navigator.language || 'en-US';
  }
  // Logging to console enabled
  this._loggingEnabled = false;
  // When logging, trip long strings (base64-encoded images) for readability
  this._trimLongStrings = false;
  // UID of the currently authenticated user.
  this._myUID = null;
  // Status of connection: authenticated or not.
  this._authenticated = false;
  // Login used in the last successful basic authentication
  this._login = null;
  // Token which can be used for login instead of login/password.
  this._authToken = null;
  // Counter of received packets
  this._inPacketCount = 0;
  // Counter for generating unique message IDs
  this._messageId = Math.floor((Math.random() * 0xFFFF) + 0xFFFF);
  // Information about the server, if connected
  this._serverInfo = null;
  // Push notification token. Called deviceToken for consistency with the Android SDK.
  this._deviceToken = null;

  // Cache of pending promises by message id.
  this._pendingPromises = {};
  // The Timeout object returned by the reject expired promises setInterval.
  this._expirePromises = null;

  // Console logger. Babel somehow fails to parse '...rest' parameter.
  this.logger = (str, ...args) => {
    if (this._loggingEnabled) {
      const d = new Date()
      const dateString = ('0' + d.getUTCHours()).slice(-2) + ':' +
        ('0' + d.getUTCMinutes()).slice(-2) + ':' +
        ('0' + d.getUTCSeconds()).slice(-2) + '.' +
        ('00' + d.getUTCMilliseconds()).slice(-3);

      console.log('[' + dateString + ']', str, args.join(' '));
    }
  }

  Connection.logger = this.logger;
  Drafty.logger = this.logger;

  // WebSocket or long polling network connection.
  if (config.transport != 'lp' && config.transport != 'ws') {
    config.transport = detectTransport();
  }
  this._connection = new Connection(config, PROTOCOL_VERSION, /* autoreconnect */ true);

  // Tinode's cache of objects
  this._cache = {};

  const cachePut = this.cachePut = (type, name, obj) => {
    this._cache[type + ':' + name] = obj;
  }

  const cacheGet = this.cacheGet = (type, name) => {
    return this._cache[type + ':' + name];
  }

  const cacheDel = this.cacheDel = (type, name) => {
    delete this._cache[type + ':' + name];
  }
  // Enumerate all items in cache, call func for each item.
  // Enumeration stops if func returns true.
  const cacheMap = this.cacheMap = (type, func, context) => {
    const key = type ? type + ':' : undefined;
    for (let idx in this._cache) {
      if (!key || idx.indexOf(key) == 0) {
        if (func.call(context, this._cache[idx], idx)) {
          break;
        }
      }
    }
  }

  // Make limited cache management available to topic.
  // Caching user.public only. Everything else is per-topic.
  this.attachCacheToTopic = (topic) => {
    topic._tinode = this;

    topic._cacheGetUser = (uid) => {
      const pub = cacheGet('user', uid);
      if (pub) {
        return {
          user: uid,
          public: mergeObj({}, pub)
        };
      }
      return undefined;
    };
    topic._cachePutUser = (uid, user) => {
      return cachePut('user', uid, mergeObj({}, user.public));
    };
    topic._cacheDelUser = (uid) => {
      return cacheDel('user', uid);
    };
    topic._cachePutSelf = () => {
      return cachePut('topic', topic.name, topic);
    }
    topic._cacheDelSelf = () => {
      return cacheDel('topic', topic.name);
    }
  }

  // Use indexDB for caching topics and messages.
  this._persist = config.persist;
  // Initialize object regardless. It simplifies the code.
  this._db = DBCache((err) => {
    this.logger("DB", err);
  }, this.logger);

  if (this._persist) {
    // Create the persistent cache.
    // Store promises to be resolved when messages load into memory.
    const msgs = [];
    this._db.initDatabase().then(() => {
      // First load topics into memory.
      return this._db.mapTopics((data) => {
        let topic = this.cacheGet('topic', data.name);
        if (topic) {
          return;
        }
        if (data.name == TOPIC_ME) {
          topic = new TopicMe();
        } else if (data.name == TOPIC_FND) {
          topic = new TopicFnd();
        } else {
          topic = new Topic(data.name);
        }

        this._db.deserializeTopic(topic, data);
        this.attachCacheToTopic(topic);
        topic._cachePutSelf();
        // Request to load messages and save the promise.
        msgs.push(topic._loadMessages(this._db));
      });
    }).then(() => {
      // Then load users.
      return this._db.mapUsers((data) => {
        return cachePut('user', data.uid, mergeObj({}, data.public));
      });
    }).then(() => {
      // Now wait for all messages to finish loading.
      return Promise.all(msgs);
    }).then(() => {
      if (onComplete) {
        onComplete();
      }
      this.logger("Persistent cache initialized.");
    });
  } else {
    this._db.deleteDatabase().then(() => {
      if (onComplete) {
        onComplete();
      }
    });
  }

  // Resolve or reject a pending promise.
  // Unresolved promises are stored in _pendingPromises.
  const execPromise = (id, code, onOK, errorText) => {
    const callbacks = this._pendingPromises[id];
    if (callbacks) {
      delete this._pendingPromises[id];
      if (code >= 200 && code < 400) {
        if (callbacks.resolve) {
          callbacks.resolve(onOK);
        }
      } else if (callbacks.reject) {
        callbacks.reject(new Error(`${errorText} (${code})`));
      }
    }
  }

  // Generator of default promises for sent packets.
  const makePromise = (id) => {
    let promise = null;
    if (id) {
      promise = new Promise((resolve, reject) => {
        // Stored callbacks will be called when the response packet with this Id arrives
        this._pendingPromises[id] = {
          'resolve': resolve,
          'reject': reject,
          'ts': new Date()
        };
      })
    }
    return promise;
  }

  // Generates unique message IDs
  const getNextUniqueId = this.getNextUniqueId = () => {
    return (this._messageId != 0) ? '' + this._messageId++ : undefined;
  }

  // Get User Agent string
  const getUserAgent = () => {
    return this._appName + ' (' + (this._browser ? this._browser + '; ' : '') + this._hwos + '); ' + LIBRARY;
  }

  // Generator of packets stubs
  this.initPacket = (type, topic) => {
    switch (type) {
      case 'hi':
        return {
          'hi': {
            'id': getNextUniqueId(),
            'ver': VERSION,
            'ua': getUserAgent(),
            'dev': this._deviceToken,
            'lang': this._humanLanguage,
            'platf': this._platform
          }
        };

      case 'acc':
        return {
          'acc': {
            'id': getNextUniqueId(),
            'user': null,
            'scheme': null,
            'secret': null,
            'login': false,
            'tags': null,
            'desc': {},
            'cred': {}
          }
        };

      case 'login':
        return {
          'login': {
            'id': getNextUniqueId(),
            'scheme': null,
            'secret': null
          }
        };

      case 'sub':
        return {
          'sub': {
            'id': getNextUniqueId(),
            'topic': topic,
            'set': {},
            'get': {}
          }
        };

      case 'leave':
        return {
          'leave': {
            'id': getNextUniqueId(),
            'topic': topic,
            'unsub': false
          }
        };

      case 'pub':
        return {
          'pub': {
            'id': getNextUniqueId(),
            'topic': topic,
            'noecho': false,
            'head': null,
            'content': {}
          }
        };

      case 'get':
        return {
          'get': {
            'id': getNextUniqueId(),
            'topic': topic,
            'what': null, // data, sub, desc, space separated list; unknown strings are ignored
            'desc': {},
            'sub': {},
            'data': {}
          }
        };

      case 'set':
        return {
          'set': {
            'id': getNextUniqueId(),
            'topic': topic,
            'desc': {},
            'sub': {},
            'tags': []
          }
        };

      case 'del':
        return {
          'del': {
            'id': getNextUniqueId(),
            'topic': topic,
            'what': null,
            'delseq': null,
            'user': null,
            'hard': false
          }
        };

      case 'note':
        return {
          'note': {
            // no id by design
            'topic': topic,
            'what': null, // one of "recv", "read", "kp"
            'seq': undefined // the server-side message id aknowledged as received or read
          }
        };

      default:
        throw new Error(`Unknown packet type requested: ${type}`);
    }
  }

  // Send a packet. If packet id is provided return a promise.
  this.send = (pkt, id) => {
    let promise;
    if (id) {
      promise = makePromise(id);
    }
    pkt = simplify(pkt);
    let msg = JSON.stringify(pkt);
    this.logger("out: " + (this._trimLongStrings ? JSON.stringify(pkt, jsonLoggerHelper) : msg));
    try {
      this._connection.sendText(msg);
    } catch (err) {
      // If sendText throws, wrap the error in a promise or rethrow.
      if (id) {
        execPromise(id, Connection.NETWORK_ERROR, null, err.message);
      } else {
        throw err;
      }
    }
    return promise;
  }

  // On successful login save server-provided data.
  this.loginSuccessful = (ctrl) => {
    if (!ctrl.params || !ctrl.params.user) {
      return ctrl;
    }
    // This is a response to a successful login,
    // extract UID and security token, save it in Tinode module
    this._myUID = ctrl.params.user;
    this._authenticated = (ctrl && ctrl.code >= 200 && ctrl.code < 300);
    if (ctrl.params && ctrl.params.token && ctrl.params.expires) {
      this._authToken = {
        token: ctrl.params.token,
        expires: new Date(ctrl.params.expires)
      };
    } else {
      this._authToken = null;
    }

    if (this.onLogin) {
      this.onLogin(ctrl.code, ctrl.text);
    }

    return ctrl;
  }

  // The main message dispatcher.
  this._connection.onMessage = (data) => {
    // Skip empty response. This happens when LP times out.
    if (!data) return;

    this._inPacketCount++;

    // Send raw message to listener
    if (this.onRawMessage) {
      this.onRawMessage(data);
    }

    if (data === '0') {
      // Server response to a network probe.
      if (this.onNetworkProbe) {
        this.onNetworkProbe();
      }
      // No processing is necessary.
      return;
    }

    let pkt = JSON.parse(data, jsonParseHelper);
    if (!pkt) {
      this.logger("in: " + data);
      this.logger("ERROR: failed to parse data");
    } else {
      this.logger("in: " + (this._trimLongStrings ? JSON.stringify(pkt, jsonLoggerHelper) : data));

      // Send complete packet to listener
      if (this.onMessage) {
        this.onMessage(pkt);
      }

      if (pkt.ctrl) {
        // Handling {ctrl} message
        if (this.onCtrlMessage) {
          this.onCtrlMessage(pkt.ctrl);
        }

        // Resolve or reject a pending promise, if any
        if (pkt.ctrl.id) {
          execPromise(pkt.ctrl.id, pkt.ctrl.code, pkt.ctrl, pkt.ctrl.text);
        }
        setTimeout(() => {
          if (pkt.ctrl.code == 205 && pkt.ctrl.text == 'evicted') {
            // User evicted from topic.
            const topic = cacheGet('topic', pkt.ctrl.topic);
            if (topic) {
              topic._resetSub();
              if (pkt.ctrl.params && pkt.ctrl.params.unsub) {
                topic._gone();
              }
            }
          } else if (pkt.ctrl.code < 300 && pkt.ctrl.params) {
            if (pkt.ctrl.params.what == 'data') {
              // code=208, all messages received: "params":{"count":11,"what":"data"},
              const topic = cacheGet('topic', pkt.ctrl.topic);
              if (topic) {
                topic._allMessagesReceived(pkt.ctrl.params.count);
              }
            } else if (pkt.ctrl.params.what == 'sub') {
              // code=204, the topic has no (refreshed) subscriptions.
              const topic = cacheGet('topic', pkt.ctrl.topic);
              if (topic) {
                // Trigger topic.onSubsUpdated.
                topic._processMetaSub([]);
              }
            }
          }
        }, 0);
      } else {
        setTimeout(() => {
          if (pkt.meta) {
            // Handling a {meta} message.

            // Preferred API: Route meta to topic, if one is registered
            const topic = cacheGet('topic', pkt.meta.topic);
            if (topic) {
              topic._routeMeta(pkt.meta);
            }

            if (pkt.meta.id) {
              execPromise(pkt.meta.id, 200, pkt.meta, 'META');
            }

            // Secondary API: callback
            if (this.onMetaMessage) {
              this.onMetaMessage(pkt.meta);
            }
          } else if (pkt.data) {
            // Handling {data} message

            // Preferred API: Route data to topic, if one is registered
            const topic = cacheGet('topic', pkt.data.topic);
            if (topic) {
              topic._routeData(pkt.data);
            }

            // Secondary API: Call callback
            if (this.onDataMessage) {
              this.onDataMessage(pkt.data);
            }
          } else if (pkt.pres) {
            // Handling {pres} message

            // Preferred API: Route presence to topic, if one is registered
            const topic = cacheGet('topic', pkt.pres.topic);
            if (topic) {
              topic._routePres(pkt.pres);
            }

            // Secondary API - callback
            if (this.onPresMessage) {
              this.onPresMessage(pkt.pres);
            }
          } else if (pkt.info) {
            // {info} message - read/received notifications and key presses

            // Preferred API: Route {info}} to topic, if one is registered
            const topic = cacheGet('topic', pkt.info.topic);
            if (topic) {
              topic._routeInfo(pkt.info);
            }

            // Secondary API - callback
            if (this.onInfoMessage) {
              this.onInfoMessage(pkt.info);
            }
          } else {
            this.logger("ERROR: Unknown packet received.");
          }
        }, 0);
      }
    }
  }

  // Ready to start sending.
  this._connection.onOpen = () => {
    if (!this._expirePromises) {
      // Reject promises which have not been resolved for too long.
      this._expirePromises = setInterval(() => {
        const err = new Error("Timeout (504)");
        const expires = new Date(new Date().getTime() - EXPIRE_PROMISES_TIMEOUT);
        for (let id in this._pendingPromises) {
          let callbacks = this._pendingPromises[id];
          if (callbacks && callbacks.ts < expires) {
            this.logger("Promise expired", id);
            delete this._pendingPromises[id];
            if (callbacks.reject) {
              callbacks.reject(err);
            }
          }
        }
      }, EXPIRE_PROMISES_PERIOD);
    }
    this.hello();
  }

  // Wrapper for the reconnect iterator callback.
  this._connection.onAutoreconnectIteration = (timeout, promise) => {
    if (this.onAutoreconnectIteration) {
      this.onAutoreconnectIteration(timeout, promise);
    }
  }

  this._connection.onDisconnect = (err, code) => {
    this._inPacketCount = 0;
    this._serverInfo = null;
    this._authenticated = false;

    if (this._expirePromises) {
      clearInterval(this._expirePromises);
      this._expirePromises = null;
    }

    // Mark all topics as unsubscribed
    cacheMap('topic', (topic, key) => {
      topic._resetSub();
    });

    // Reject all pending promises
    for (let key in this._pendingPromises) {
      const callbacks = this._pendingPromises[key];
      if (callbacks && callbacks.reject) {
        callbacks.reject(err);
      }
    }
    this._pendingPromises = {};

    if (this.onDisconnect) {
      this.onDisconnect(err);
    }
  }
};

// Static methods.

/**
 * @typedef Credential
 * @type {object}
 * @property {string} meth - validation method.
 * @property {string} val - value to validate (e.g. email or phone number).
 * @property {string} resp - validation response.
 * @property {Object} params - validation parameters.
 */
/**
 * Helper method to package account credential.
 *
 * @memberof Tinode
 * @static
 *
 * @param {string | Credential} meth - validation method or object with validation data.
 * @param {string=} val - validation value (e.g. email or phone number).
 * @param {Object=} params - validation parameters.
 * @param {string=} resp - validation response.
 *
 * @returns {Array.<Credential>} array with a single credential or <code>null</code> if no valid credentials were given.
 */
Tinode.credential = function(meth, val, params, resp) {
  if (typeof meth == 'object') {
    ({
      val,
      params,
      resp,
      meth
    } = meth);
  }
  if (meth && (val || resp)) {
    return [{
      'meth': meth,
      'val': val,
      'resp': resp,
      'params': params
    }];
  }
  return null;
};

/**
 * Determine topic type from topic's name: grp, p2p, me, fnd, sys.
 * @memberof Tinode
 * @static
 *
 * @param {string} name - Name of the topic to test.
 * @returns {string} One of <code>"me"</code>, <code>"fnd"</code>, <code>"sys"</code>, <code>"grp"</code>,
 *    <code>"p2p"</code> or <code>undefined</code>.
 */
Tinode.topicType = function(name) {
  const types = {
    'me': 'me',
    'fnd': 'fnd',
    'grp': 'grp',
    'new': 'grp',
    'nch': 'grp',
    'chn': 'grp',
    'usr': 'p2p',
    'sys': 'sys'
  };
  return types[(typeof name == 'string') ? name.substring(0, 3) : 'xxx'];
};

/**
 * Check if the given topic name is a name of a 'me' topic.
 * @memberof Tinode
 * @static
 *
 * @param {string} name - Name of the topic to test.
 * @returns {boolean} <code>true</code> if the name is a name of a 'me' topic, <code>false</code> otherwise.
 */
Tinode.isMeTopicName = function(name) {
  return Tinode.topicType(name) == 'me';
};

/**
 * Check if the given topic name is a name of a group topic.
 * @memberof Tinode
 * @static
 *
 * @param {string} name - Name of the topic to test.
 * @returns {boolean} <code>true</code> if the name is a name of a group topic, <code>false</code> otherwise.
 */
Tinode.isGroupTopicName = function(name) {
  return Tinode.topicType(name) == 'grp';
};

/**
 * Check if the given topic name is a name of a p2p topic.
 * @memberof Tinode
 * @static
 *
 * @param {string} name - Name of the topic to test.
 * @returns {boolean} <code>true</code> if the name is a name of a p2p topic, <code>false</code> otherwise.
 */
Tinode.isP2PTopicName = function(name) {
  return Tinode.topicType(name) == 'p2p';
};

/**
 * Check if the given topic name is a name of a communication topic, i.e. P2P or group.
 * @memberof Tinode
 * @static
 *
 * @param {string} name - Name of the topic to test.
 * @returns {boolean} <code>true</code> if the name is a name of a p2p or group topic, <code>false</code> otherwise.
 */
Tinode.isCommTopicName = function(name) {
  return Tinode.isP2PTopicName(name) || Tinode.isGroupTopicName(name);
};

/**
 * Check if the topic name is a name of a new topic.
 * @memberof Tinode
 * @static
 *
 * @param {string} name - topic name to check.
 * @returns {boolean} <code>true</code> if the name is a name of a new topic, <code>false</code> otherwise.
 */
Tinode.isNewGroupTopicName = function(name) {
  return (typeof name == 'string') &&
    (name.substring(0, 3) == TOPIC_NEW || name.substring(0, 3) == TOPIC_NEW_CHAN);
};

/**
 * Check if the topic name is a name of a channel.
 * @memberof Tinode
 * @static
 *
 * @param {string} name - topic name to check.
 * @returns {boolean} <code>true</code> if the name is a name of a channel, <code>false</code> otherwise.
 */
Tinode.isChannelTopicName = function(name) {
  return (typeof name == 'string') &&
    (name.substring(0, 3) == TOPIC_CHAN || name.substring(0, 3) == TOPIC_NEW_CHAN);
};

/**
 * Return information about the current version of this Tinode client library.
 * @memberof Tinode
 * @static
 *
 * @returns {string} semantic version of the library, e.g. <code>"0.15.5-rc1"</code>.
 */
Tinode.getVersion = function() {
  return VERSION;
};

/**
 * To use Tinode in a non browser context, supply WebSocket and XMLHttpRequest providers.
 * @static
 * @memberof Tinode
 * @param wsProvider WebSocket provider, e.g. for nodeJS , <code>require('ws')</code>.
 * @param xhrProvider XMLHttpRequest provider, e.g. for node <code>require('xhr')</code>.
 */
Tinode.setNetworkProviders = function(wsProvider, xhrProvider) {
  WebSocketProvider = wsProvider;
  XHRProvider = xhrProvider;
};

/**
 * Return information about the current name and version of this Tinode library.
 * @memberof Tinode
 * @static
 *
 * @returns {string} the name of the library and it's version.
 */
Tinode.getLibrary = function() {
  return LIBRARY;
};

// Exported constants
Tinode.MESSAGE_STATUS_NONE = MESSAGE_STATUS_NONE;
Tinode.MESSAGE_STATUS_QUEUED = MESSAGE_STATUS_QUEUED;
Tinode.MESSAGE_STATUS_SENDING = MESSAGE_STATUS_SENDING;
Tinode.MESSAGE_STATUS_FAILED = MESSAGE_STATUS_FAILED;
Tinode.MESSAGE_STATUS_SENT = MESSAGE_STATUS_SENT;
Tinode.MESSAGE_STATUS_RECEIVED = MESSAGE_STATUS_RECEIVED;
Tinode.MESSAGE_STATUS_READ = MESSAGE_STATUS_READ;
Tinode.MESSAGE_STATUS_TO_ME = MESSAGE_STATUS_TO_ME;
Tinode.MESSAGE_STATUS_DEL_RANGE = MESSAGE_STATUS_DEL_RANGE;

// Unicode [del] symbol.
Tinode.DEL_CHAR = '\u2421';

/**
 * Check if the given string represents <code>NULL</code> value as defined by Tinode (<code>'\u2421'</code>).
 * @memberof Tinode
 * @static
 *
 * @param {string} str - string to check for <code>NULL</code> value.
 *
 * @returns {boolean} <code>true</code> if string represents <code>NULL</code> value, <code>false</code> otherwise.
 */
Tinode.isNullValue = function(str) {
  return str === Tinode.DEL_CHAR;
};

/**
 * Check if the given URL string is a relative URL.
 * Check for cases like:
 *  <code>'http://example.com'</code>
 *  <code>' http://example.com'</code>
 *  <code>'//example.com/'</code>
 *  <code>'http:example.com'</code>
 *  <code>'http:/example.com'</code>
 * @memberof Tinode
 * @static
 *
 * @param {string} url - URL string to check.
 *
 * @returns {boolean} <code>true</code> if the URL is relative, <code>false</code> otherwise.
 */
Tinode.isRelativeURL = function(url) {
  return !/^\s*([a-z][a-z0-9+.-]*:|\/\/)/im.test(url);
};

// Names of keys to server-provided configuration limits.
Tinode.MAX_MESSAGE_SIZE = 'maxMessageSize';
Tinode.MAX_SUBSCRIBER_COUNT = 'maxSubscriberCount';
Tinode.MAX_TAG_COUNT = 'maxTagCount';
Tinode.MAX_FILE_UPLOAD_SIZE = 'maxFileUploadSize';

// Public methods;
Tinode.prototype = {
  /**
   * Connect to the server.
   * @memberof Tinode#
   *
   * @param {string} host_ - name of the host to connect to.
   *
   * @return {Promise} Promise resolved/rejected when the connection call completes:
   *    <code>resolve()</code> is called without parameters, <code>reject()</code> receives the
   *    <code>Error</code> as a single parameter.
   */
  connect: function(host_) {
    return this._connection.connect(host_);
  },

  /**
   * Attempt to reconnect to the server immediately.
   * @memberof Tinode#
   *
   * @param {string} force - reconnect even if there is a connection already.
   */
  reconnect: function(force) {
    this._connection.reconnect(force);
  },

  /**
   * Disconnect from the server.
   * @memberof Tinode#
   */
  disconnect: function() {
    this._connection.disconnect();
  },

  /**
   * Clear persistent cache: remove IndexedDB.
   * @memberof Tinode#
   * @return {Promise} Promise resolved/rejected when the operation is completed.
   */
  clearStorage: function() {
    if (this._db.isReady()) {
      return this._db.deleteDatabase();
    }
    return Promise.resolve();
  },

  /**
   * Initialize persistent cache: create IndexedDB cache.
   * @memberof Tinode#
   * @return {Promise} Promise resolved/rejected when the operation is completed.
   */
  initStorage: function() {
    if (!this._db.isReady()) {
      return this._db.initDatabase();
    }
    return Promise.resolve();
  },

  /**
   * Send a network probe message to make sure the connection is alive.
   * @memberof Tinode#
   */
  networkProbe: function() {
    this._connection.probe();
  },

  /**
   * Check for live connection to server.
   * @memberof Tinode#
   *
   * @returns {boolean} <code>true</code> if there is a live connection, <code>false</code> otherwise.
   */
  isConnected: function() {
    return this._connection.isConnected();
  },

  /**
   * Check if connection is authenticated (last login was successful).
   * @memberof Tinode#
   * @returns {boolean} <code>true</code> if authenticated, <code>false</code> otherwise.
   */
  isAuthenticated: function() {
    return this._authenticated;
  },

  /**
   * Add API key and auth token to the relative URL making it usable for getting data
   * from the server in a simple <code>HTTP GET</code> request.
   * @memberof Tinode#
   *
   * @param {string} URL - URL to wrap.
   * @returns {string} URL with appended API key and token, if valid token is present.
   */
  authorizeURL: function(url) {
    if (!url) {
      return url;
    }

    if (Tinode.isRelativeURL(url)) {
      // Fake base to make the relative URL parseable.
      const base = 'scheme://host/';
      const parsed = new URL(url, base);
      if (this._apiKey) {
        parsed.searchParams.append('apikey', this._apiKey);
      }
      if (this._authToken.token) {
        parsed.searchParams.append('auth', 'token');
        parsed.searchParams.append('secret', this._authToken.token);
      }
      // Convert back to string and strip fake base URL except for the root slash.
      url = parsed.toString().substring(base.length - 1);
    }
    return url;
  },

  /**
   * @typedef AccountParams
   * @memberof Tinode
   * @type {Object}
   * @property {Tinode.DefAcs=} defacs - Default access parameters for user's <code>me</code> topic.
   * @property {Object=} public - Public application-defined data exposed on <code>me</code> topic.
   * @property {Object=} private - Private application-defined data accessible on <code>me</code> topic.
   * @property {Array} tags - array of string tags for user discovery.
   * @property {string=} token - authentication token to use.
   */
  /**
   * @typedef DefAcs
   * @memberof Tinode
   * @type {Object}
   * @property {string=} auth - Access mode for <code>me</code> for authenticated users.
   * @property {string=} anon - Access mode for <code>me</code> for anonymous users.
   */

  /**
   * Create or update an account.
   * @memberof Tinode#
   *
   * @param {string} uid - User id to update
   * @param {string} scheme - Authentication scheme; <code>"basic"</code> and <code>"anonymous"</code> are the currently supported schemes.
   * @param {string} secret - Authentication secret, assumed to be already base64 encoded.
   * @param {boolean=} login - Use new account to authenticate current session
   * @param {Tinode.AccountParams=} params - User data to pass to the server.
   *
   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.
   */
  account: function(uid, scheme, secret, login, params) {
    const pkt = this.initPacket('acc');
    pkt.acc.user = uid;
    pkt.acc.scheme = scheme;
    pkt.acc.secret = secret;
    // Log in to the new account using selected scheme
    pkt.acc.login = login;

    if (params) {
      pkt.acc.desc.defacs = params.defacs;
      pkt.acc.desc.public = params.public;
      pkt.acc.desc.private = params.private;

      pkt.acc.tags = params.tags;
      pkt.acc.cred = params.cred;

      pkt.acc.token = params.token;
    }

    return this.send(pkt, pkt.acc.id);
  },

  /**
   * Create a new user. Wrapper for {@link Tinode#account}.
   * @memberof Tinode#
   *
   * @param {string} scheme - Authentication scheme; <code>"basic"</code> is the only currently supported scheme.
   * @param {string} secret - Authentication.
   * @param {boolean=} login - Use new account to authenticate current session
   * @param {Tinode.AccountParams=} params - User data to pass to the server.
   *
   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.
   */
  createAccount: function(scheme, secret, login, params) {
    let promise = this.account(USER_NEW, scheme, secret, login, params);
    if (login) {
      promise = promise.then((ctrl) => {
        return this.loginSuccessful(ctrl);
      });
    }
    return promise;
  },

  /**
   * Create user with <code>'basic'</code> authentication scheme and immediately
   * use it for authentication. Wrapper for {@link Tinode#account}.
   * @memberof Tinode#
   *
   * @param {string} username - Login to use for the new account.
   * @param {string} password - User's password.
   * @param {Tinode.AccountParams=} params - User data to pass to the server.
   *
   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.
   */
  createAccountBasic: function(username, password, params) {
    // Make sure we are not using 'null' or 'undefined';
    username = username || '';
    password = password || '';
    return this.createAccount('basic',
      b64EncodeUnicode(username + ':' + password), true, params);
  },

  /**
   * Update user's credentials for <code>'basic'</code> authentication scheme. Wrapper for {@link Tinode#account}.
   * @memberof Tinode#
   *
   * @param {string} uid - User ID to update.
   * @param {string} username - Login to use for the new account.
   * @param {string} password - User's password.
   * @param {Tinode.AccountParams=} params - data to pass to the server.
   *
   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.
   */
  updateAccountBasic: function(uid, username, password, params) {
    // Make sure we are not using 'null' or 'undefined';
    username = username || '';
    password = password || '';
    return this.account(uid, 'basic',
      b64EncodeUnicode(username + ':' + password), false, params);
  },

  /**
   * Send handshake to the server.
   * @memberof Tinode#
   *
   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.
   */
  hello: function() {
    const pkt = this.initPacket('hi');

    return this.send(pkt, pkt.hi.id)
      .then((ctrl) => {
        // Reset backoff counter on successful connection.
        this._connection.backoffReset();

        // Server response contains server protocol version, build, constraints,
        // session ID for long polling. Save them.
        if (ctrl.params) {
          this._serverInfo = ctrl.params;
        }

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

        return ctrl;
      }).catch((err) => {
        this._connection.reconnect(true);

        if (this.onDisconnect) {
          this.onDisconnect(err);
        }
      });
  },

  /**
   * Set or refresh the push notifications/device token. If the client is connected,
   * the deviceToken can be sent to the server.
   *
   * @memberof Tinode#
   * @param {string} dt - token obtained from the provider or <code>false</code>,
   *    <code>null</code> or <code>undefined</code> to clear the token.
   *
   * @returns <code>true</code> if attempt was made to send the update to the server.
   */
  setDeviceToken: function(dt) {
    let sent = false;
    // Convert any falsish value to null.
    dt = dt || null;
    if (dt != this._deviceToken) {
      this._deviceToken = dt;
      if (this.isConnected() && this.isAuthenticated()) {
        this.send({
          'hi': {
            'dev': dt || Tinode.DEL_CHAR
          }
        });
        sent = true;
      }
    }
    return sent;
  },

  /**
   * Authenticate current session.
   * @memberof Tinode#
   *
   * @param {string} scheme - Authentication scheme; <code>"basic"</code> is the only currently supported scheme.
   * @param {string} secret - Authentication secret, assumed to be already base64 encoded.
   *
   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.
   */
  login: function(scheme, secret, cred) {
    const pkt = this.initPacket('login');
    pkt.login.scheme = scheme;
    pkt.login.secret = secret;
    pkt.login.cred = cred;

    return this.send(pkt, pkt.login.id)
      .then((ctrl) => {
        return this.loginSuccessful(ctrl);
      });
  },

  /**
   * Wrapper for {@link Tinode#login} with basic authentication
   * @memberof Tinode#
   *
   * @param {string} uname - User name.
   * @param {string} password  - Password.
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  loginBasic: function(uname, password, cred) {
    return this.login('basic', b64EncodeUnicode(uname + ':' + password), cred)
      .then((ctrl) => {
        this._login = uname;
        return ctrl;
      });
  },

  /**
   * Wrapper for {@link Tinode#login} with token authentication
   * @memberof Tinode#
   *
   * @param {string} token - Token received in response to earlier login.
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  loginToken: function(token, cred) {
    return this.login('token', token, cred);
  },

  /**
   * Send a request for resetting an authentication secret.
   * @memberof Tinode#
   *
   * @param {string} scheme - authentication scheme to reset.
   * @param {string} method - method to use for resetting the secret, such as "email" or "tel".
   * @param {string} value - value of the credential to use, a specific email address or a phone number.
   *
   * @returns {Promise} Promise which will be resolved/rejected on receiving the server reply.
   */
  requestResetAuthSecret: function(scheme, method, value) {
    return this.login('reset', b64EncodeUnicode(scheme + ':' + method + ':' + value));
  },

  /**
   * @typedef AuthToken
   * @memberof Tinode
   * @type {Object}
   * @property {string} token - Token value.
   * @property {Date} expires - Token expiration time.
   */
  /**
   * Get stored authentication token.
   * @memberof Tinode#
   *
   * @returns {Tinode.AuthToken} authentication token.
   */
  getAuthToken: function() {
    if (this._authToken && (this._authToken.expires.getTime() > Date.now())) {
      return this._authToken;
    } else {
      this._authToken = null;
    }
    return null;
  },

  /**
   * Application may provide a saved authentication token.
   * @memberof Tinode#
   *
   * @param {Tinode.AuthToken} token - authentication token.
   */
  setAuthToken: function(token) {
    this._authToken = token;
  },

  /**
   * @typedef SetParams
   * @type {Object}
   * @memberof Tinode
   * @property {Tinode.SetDesc=} desc - Topic initialization parameters when creating a new topic or a new subscription.
   * @property {Tinode.SetSub=} sub - Subscription initialization parameters.
   */
  /**
   * @typedef SetDesc
   * @type {Object}
   * @memberof Tinode
   * @property {Tinode.DefAcs=} defacs - Default access mode.
   * @property {Object=} public - Free-form topic description, publically accessible.
   * @property {Object=} private - Free-form topic descriptionaccessible only to the owner.
   */
  /**
   * @typedef SetSub
   * @type {Object}
   * @memberof Tinode
   * @property {string=} user - UID of the user affected by the request. Default (empty) - current user.
   * @property {string=} mode - User access mode, either requested or assigned dependent on context.
   * @property {Object=} info - Free-form payload to pass to the invited user or topic manager.
   */
  /**
   * Parameters passed to {@link Tinode#subscribe}.
   *
   * @typedef SubscriptionParams
   * @type {Object}
   * @memberof Tinode
   * @property {Tinode.SetParams=} set - Parameters used to initialize topic
   * @property {Tinode.GetQuery=} get - Query for fetching data from topic.
   */

  /**
   * Send a topic subscription request.
   * @memberof Tinode#
   *
   * @param {string} topic - Name of the topic to subscribe to.
   * @param {Tinode.GetQuery=} getParams - Optional subscription metadata query
   * @param {Tinode.SetParams=} setParams - Optional initialization parameters
   *
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  subscribe: function(topicName, getParams, setParams) {
    const pkt = this.initPacket('sub', topicName)
    if (!topicName) {
      topicName = TOPIC_NEW;
    }

    pkt.sub.get = getParams;

    if (setParams) {
      if (setParams.sub) {
        pkt.sub.set.sub = setParams.sub;
      }

      if (setParams.desc) {
        if (Tinode.isNewGroupTopicName(topicName)) {
          // Full set.desc params are used for new topics only
          pkt.sub.set.desc = setParams.desc;
        } else if (Tinode.isP2PTopicName(topicName) && setParams.desc.defacs) {
          // Use optional default permissions only.
          pkt.sub.set.desc = {
            defacs: setParams.desc.defacs
          };
        }
      }

      if (setParams.tags) {
        pkt.sub.set.tags = setParams.tags;
      }
    }

    return this.send(pkt, pkt.sub.id);
  },

  /**
   * Detach and optionally unsubscribe from the topic
   * @memberof Tinode#
   *
   * @param {string} topic - Topic to detach from.
   * @param {boolean} unsub - If <code>true</code>, detach and unsubscribe, otherwise just detach.
   *
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  leave: function(topic, unsub) {
    const pkt = this.initPacket('leave', topic);
    pkt.leave.unsub = unsub;

    return this.send(pkt, pkt.leave.id);
  },

  /**
   * Create message draft without sending it to the server.
   * @memberof Tinode#
   *
   * @param {string} topic - Name of the topic to publish to.
   * @param {Object} data - Payload to publish.
   * @param {boolean=} noEcho - If <code>true</code>, tell the server not to echo the message to the original session.
   *
   * @returns {Object} new message which can be sent to the server or otherwise used.
   */
  createMessage: function(topic, data, noEcho) {
    const pkt = this.initPacket('pub', topic);

    let dft = typeof data == 'string' ? Drafty.parse(data) : data;
    if (dft && !Drafty.isPlainText(dft)) {
      pkt.pub.head = {
        mime: Drafty.getContentType()
      };
      data = dft;
    }
    pkt.pub.noecho = noEcho;
    pkt.pub.content = data;

    return pkt.pub;
  },

  /**
   * Publish {data} message to topic.
   * @memberof Tinode#
   *
   * @param {string} topic - Name of the topic to publish to.
   * @param {Object} data - Payload to publish.
   * @param {boolean=} noEcho - If <code>true</code>, tell the server not to echo the message to the original session.
   *
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  publish: function(topic, data, noEcho) {
    return this.publishMessage(
      this.createMessage(topic, data, noEcho)
    );
  },

  /**
   * Publish message to topic. The message should be created by {@link Tinode#createMessage}.
   * @memberof Tinode#
   *
   * @param {Object} pub - Message to publish.
   *
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  publishMessage: function(pub) {
    // Make a shallow copy. Needed in order to clear locally-assigned temp values;
    pub = Object.assign({}, pub);
    pub.seq = undefined;
    pub.from = undefined;
    pub.ts = undefined;
    return this.send({
      pub: pub
    }, pub.id);
  },

  /**
   * Out of band notification: notify topic that an external (push) notification was recived by the client.
   * @memberof Tinode#
   *
   * @param {string} topicName - name of the updated topic.
   * @param {number} seq - seq ID of the new message.
   * @param {string=} act - UID of the sender; default is current.
   */
  oobNotification: function(topicName, seq, act) {
    const topic = this.cacheGet('topic', topicName);
    if (topic) {
      topic._updateReceived(seq, act);
      this.getMeTopic()._refreshContact('msg', topic);
    }
  },

  /**
   * @typedef GetQuery
   * @type {Object}
   * @memberof Tinode
   * @property {Tinode.GetOptsType=} desc - If provided (even if empty), fetch topic description.
   * @property {Tinode.GetOptsType=} sub - If provided (even if empty), fetch topic subscriptions.
   * @property {Tinode.GetDataType=} data - If provided (even if empty), get messages.
   */

  /**
   * @typedef GetOptsType
   * @type {Object}
   * @memberof Tinode
   * @property {Date=} ims - "If modified since", fetch data only it was was modified since stated date.
   * @property {number=} limit - Maximum number of results to return. Ignored when querying topic description.
   */

  /**
   * @typedef GetDataType
   * @type {Object}
   * @memberof Tinode
   * @property {number=} since - Load messages with seq id equal or greater than this value.
   * @property {number=} before - Load messages with seq id lower than this number.
   * @property {number=} limit - Maximum number of results to return.
   */

  /**
   * Request topic metadata
   * @memberof Tinode#
   *
   * @param {string} topic - Name of the topic to query.
   * @param {Tinode.GetQuery} params - Parameters of the query. Use {@link Tinode.MetaGetBuilder} to generate.
   *
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  getMeta: function(topic, params) {
    const pkt = this.initPacket('get', topic);

    pkt.get = mergeObj(pkt.get, params);

    return this.send(pkt, pkt.get.id);
  },

  /**
   * Update topic's metadata: description, subscribtions.
   * @memberof Tinode#
   *
   * @param {string} topic - Topic to update.
   * @param {Tinode.SetParams} params - topic metadata to update.
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  setMeta: function(topic, params) {
    const pkt = this.initPacket('set', topic);
    const what = [];

    if (params) {
      ['desc', 'sub', 'tags', 'cred'].map(function(key) {
        if (params.hasOwnProperty(key)) {
          what.push(key);
          pkt.set[key] = params[key];
        }
      });
    }

    if (what.length == 0) {
      return Promise.reject(new Error("Invalid {set} parameters"));
    }

    return this.send(pkt, pkt.set.id);
  },

  /**
   * Range of message IDs to delete.
   *
   * @typedef DelRange
   * @type {Object}
   * @memberof Tinode
   * @property {number} low - low end of the range, inclusive (closed).
   * @property {number=} hi - high end of the range, exclusive (open).
   */
  /**
   * Delete some or all messages in a topic.
   * @memberof Tinode#
   *
   * @param {string} topic - Topic name to delete messages from.
   * @param {Tinode.DelRange[]} list - Ranges of message IDs to delete.
   * @param {boolean=} hard - Hard or soft delete
   *
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  delMessages: function(topic, ranges, hard) {
    const pkt = this.initPacket('del', topic);

    pkt.del.what = 'msg';
    pkt.del.delseq = ranges;
    pkt.del.hard = hard;

    return this.send(pkt, pkt.del.id);
  },

  /**
   * Delete the topic alltogether. Requires Owner permission.
   * @memberof Tinode#
   *
   * @param {string} topicName - Name of the topic to delete
   * @param {boolean} hard - hard-delete topic.
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  delTopic: function(topicName, hard) {
    const pkt = this.initPacket('del', topicName);
    pkt.del.what = 'topic';
    pkt.del.hard = hard;

    return this.send(pkt, pkt.del.id);
  },

  /**
   * Delete subscription. Requires Share permission.
   * @memberof Tinode#
   *
   * @param {string} topicName - Name of the topic to delete
   * @param {string} user - User ID to remove.
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  delSubscription: function(topicName, user) {
    const pkt = this.initPacket('del', topicName);
    pkt.del.what = 'sub';
    pkt.del.user = user;

    return this.send(pkt, pkt.del.id);
  },

  /**
   * Delete credential. Always sent on <code>'me'</code> topic.
   * @memberof Tinode#
   *
   * @param {string} method - validation method such as <code>'email'</code> or <code>'tel'</code>.
   * @param {string} value - validation value, i.e. <code>'alice@example.com'</code>.
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  delCredential: function(method, value) {
    const pkt = this.initPacket('del', TOPIC_ME);
    pkt.del.what = 'cred';
    pkt.del.cred = {
      meth: method,
      val: value
    };

    return this.send(pkt, pkt.del.id);
  },

  /**
   * Request to delete account of the current user.
   * @memberof Tinode#
   *
   * @param {boolean} hard - hard-delete user.
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  delCurrentUser: function(hard) {
    const pkt = this.initPacket('del', null);
    pkt.del.what = 'user';
    pkt.del.hard = hard;

    return this.send(pkt, pkt.del.id).then((ctrl) => {
      this._myUID = null;
    });
  },

  /**
   * Notify server that a message or messages were read or received. Does NOT return promise.
   * @memberof Tinode#
   *
   * @param {string} topicName - Name of the topic where the mesage is being aknowledged.
   * @param {string} what - Action being aknowledged, either <code>"read"</code> or <code>"recv"</code>.
   * @param {number} seq - Maximum id of the message being acknowledged.
   */
  note: function(topicName, what, seq) {
    if (seq <= 0 || seq >= LOCAL_SEQID) {
      throw new Error(`Invalid message id ${seq}`);
    }

    const pkt = this.initPacket('note', topicName);
    pkt.note.what = what;
    pkt.note.seq = seq;
    this.send(pkt);
  },

  /**
   * Broadcast a key-press notification to topic subscribers. Used to show
   * typing notifications "user X is typing...".
   * @memberof Tinode#
   *
   * @param {string} topicName - Name of the topic to broadcast to.
   */
  noteKeyPress: function(topicName) {
    const pkt = this.initPacket('note', topicName);
    pkt.note.what = 'kp';
    this.send(pkt);
  },

  /**
   * Get a named topic, either pull it from cache or create a new instance.
   * There is a single instance of topic for each name.
   * @memberof Tinode#
   *
   * @param {string} topicName - Name of the topic to get.
   * @returns {Tinode.Topic} Requested or newly created topic or <code>undefined</code> if topic name is invalid.
   */
  getTopic: function(topicName) {
    let topic = this.cacheGet('topic', topicName);
    if (!topic && topicName) {
      if (topicName == TOPIC_ME) {
        topic = new TopicMe();
      } else if (topicName == TOPIC_FND) {
        topic = new TopicFnd();
      } else {
        topic = new Topic(topicName);
      }
      // Cache management.
      this.attachCacheToTopic(topic);
      topic._cachePutSelf();
      // Don't save to DB here: a record will be added when the topic is subscribed.
    }
    return topic;
  },

  /**
   * Check if named topic is already present in cache.
   * @memberof Tinode#
   *
   * @param {string} topicName - Name of the topic to check.
   * @returns {boolean} true if topic is found in cache, false oterwise.
   */
  isTopicCached: function(topicName) {
    return !!this.cacheGet('topic', topicName);
  },

  /**
   * Generate unique name like <code>'new123456'</code> suitable for creating a new group topic.
   * @memberof Tinode#
   *
   * @param {boolean} isChan - if the topic is channel-enabled.
   * @returns {string} name which can be used for creating a new group topic.
   */
  newGroupTopicName: function(isChan) {
    return (isChan ? TOPIC_NEW_CHAN : TOPIC_NEW) + this.getNextUniqueId();
  },

  /**
   * Instantiate <code>'me'</code> topic or get it from cache.
   * @memberof Tinode#
   *
   * @returns {Tinode.TopicMe} Instance of <code>'me'</code> topic.
   */
  getMeTopic: function() {
    return this.getTopic(TOPIC_ME);
  },

  /**
   * Instantiate <code>'fnd'</code> (find) topic or get it from cache.
   * @memberof Tinode#
   *
   * @returns {Tinode.Topic} Instance of <code>'fnd'</code> topic.
   */
  getFndTopic: function() {
    return this.getTopic(TOPIC_FND);
  },

  /**
   * Create a new {@link LargeFileHelper} instance
   * @memberof Tinode#
   *
   * @returns {Tinode.LargeFileHelper} instance of a {@link Tinode.LargeFileHelper}.
   */
  getLargeFileHelper: function() {
    return new LargeFileHelper(this, PROTOCOL_VERSION);
  },

  /**
   * Get the UID of the the current authenticated user.
   * @memberof Tinode#
   * @returns {string} UID of the current user or <code>undefined</code> if the session is not yet authenticated or if there is no session.
   */
  getCurrentUserID: function() {
    return this._myUID;
  },

  /**
   * Check if the given user ID is equal to the current user's UID.
   * @memberof Tinode#
   * @param {string} uid - UID to check.
   * @returns {boolean} true if the given UID belongs to the current logged in user.
   */
  isMe: function(uid) {
    return this._myUID === uid;
  },

  /**
   * Get login used for last successful authentication.
   * @memberof Tinode#
   * @returns {string} login last used successfully or <code>undefined</code>.
   */
  getCurrentLogin: function() {
    return this._login;
  },

  /**
   * Return information about the server: protocol version and build timestamp.
   * @memberof Tinode#
   * @returns {Object} build and version of the server or <code>null</code> if there is no connection or if the first server response has not been received yet.
   */
  getServerInfo: function() {
    return this._serverInfo;
  },

  /**
   * Return server-provided configuration value (long integer).
   * @memberof Tinode#
   * @param {string} name of the value to return
   * @param {Object} defaultValue to return in case server limit is not set or not found.
   * @returns {number} named value.
   */
  getServerLimit: function(name, defaultValue) {
    return (this._serverInfo ? this._serverInfo[name] : null) || defaultValue;
  },

  /**
   * Toggle console logging. Logging is off by default.
   * @memberof Tinode#
   * @param {boolean} enabled - Set to <code>true</code> to enable logging to console.
   * @param {boolean} trimLongStrings - Set to <code>true</code> to trim long strings.
   */
  enableLogging: function(enabled, trimLongStrings) {
    this._loggingEnabled = enabled;
    this._trimLongStrings = enabled && trimLongStrings;
  },

  /**
   * Set UI language to report to the server. Must be called before <code>'hi'</code> is sent, otherwise it will not be used.
   * @memberof Tinode#
   *
   * @param {string} hl - human (UI) language, like <code>"en_US"</code> or <code>"zh-Hans"</code>.
   */
  setHumanLanguage: function(hl) {
    if (hl) {
      this._humanLanguage = hl;
    }
  },

  /**
   * Check if given topic is online.
   * @memberof Tinode#
   *
   * @param {string} name of the topic to test.
   * @returns {boolean} true if topic is online, false otherwise.
   */
  isTopicOnline: function(name) {
    const topic = this.cacheGet('topic', name);
    return topic && topic.online;
  },

  /**
   * Get access mode for the given contact.
   * @memberof Tinode#
   *
   * @param {string} name of the topic to query.
   * @returns {AccessMode} access mode if topic is found, null otherwise.
   */
  getTopicAccessMode: function(name) {
    const topic = this.cacheGet('topic', name);
    return topic ? topic.acs : null;
  },

  /**
   * Include message ID into all subsequest messages to server instructin it to send aknowledgemens.
   * Required for promises to function. Default is <code>"on"</code>.
   * @memberof Tinode#
   *
   * @param {boolean} status - Turn aknowledgemens on or off.
   * @deprecated
   */
  wantAkn: function(status) {
    if (status) {
      this._messageId = Math.floor((Math.random() * 0xFFFFFF) + 0xFFFFFF);
    } else {
      this._messageId = 0;
    }
  },

  // Callbacks:
  /**
   * Callback to report when the websocket is opened. The callback has no parameters.
   * @memberof Tinode#
   * @type {Tinode.onWebsocketOpen}
   */
  onWebsocketOpen: undefined,

  /**
   * @typedef Tinode.ServerParams
   * @memberof Tinode
   * @type {Object}
   * @property {string} ver - Server version
   * @property {string} build - Server build
   * @property {string=} sid - Session ID, long polling connections only.
   */

  /**
   * @callback Tinode.onConnect
   * @param {number} code - Result code
   * @param {string} text - Text epxplaining the completion, i.e "OK" or an error message.
   * @param {Tinode.ServerParams} params - Parameters returned by the server.
   */
  /**
   * Callback to report when connection with Tinode server is established.
   * @memberof Tinode#
   * @type {Tinode.onConnect}
   */
  onConnect: undefined,

  /**
   * Callback to report when connection is lost. The callback has no parameters.
   * @memberof Tinode#
   * @type {Tinode.onDisconnect}
   */
  onDisconnect: undefined,

  /**
   * @callback Tinode.onLogin
   * @param {number} code - NUmeric completion code, same as HTTP status codes.
   * @param {string} text - Explanation of the completion code.
   */
  /**
   * Callback to report login completion.
   * @memberof Tinode#
   * @type {Tinode.onLogin}
   */
  onLogin: undefined,

  /**
   * Callback to receive <code>{ctrl}</code> (control) messages.
   * @memberof Tinode#
   * @type {Tinode.onCtrlMessage}
   */
  onCtrlMessage: undefined,

  /**
   * Callback to recieve <code>{data}</code> (content) messages.
   * @memberof Tinode#
   * @type {Tinode.onDataMessage}
   */
  onDataMessage: undefined,

  /**
   * Callback to receive <code>{pres}</code> (presence) messages.
   * @memberof Tinode#
   * @type {Tinode.onPresMessage}
   */
  onPresMessage: undefined,

  /**
   * Callback to receive all messages as objects.
   * @memberof Tinode#
   * @type {Tinode.onMessage}
   */
  onMessage: undefined,

  /**
   * Callback to receive all messages as unparsed text.
   * @memberof Tinode#
   * @type {Tinode.onRawMessage}
   */
  onRawMessage: undefined,

  /**
   * Callback to receive server responses to network probes. See {@link Tinode#networkProbe}
   * @memberof Tinode#
   * @type {Tinode.onNetworkProbe}
   */
  onNetworkProbe: undefined,

  /**
   * Callback to be notified when exponential backoff is iterating.
   * @memberof Tinode#
   * @type {Tinode.onAutoreconnectIteration}
   */
  onAutoreconnectIteration: undefined,
};

/**
 * @callback Tinode.Topic.onData
 * @param {Data} data - Data packet
 */
/**
 * Topic is a class representing a logical communication channel.
 * @class Topic
 * @memberof Tinode
 *
 * @param {string} name - Name of the topic to create.
 * @param {Object=} callbacks - Object with various event callbacks.
 * @param {Tinode.Topic.onData} callbacks.onData - Callback which receives a <code>{data}</code> message.
 * @param {callback} callbacks.onMeta - Callback which receives a <code>{meta}</code> message.
 * @param {callback} callbacks.onPres - Callback which receives a <code>{pres}</code> message.
 * @param {callback} callbacks.onInfo - Callback which receives an <code>{info}</code> message.
 * @param {callback} callbacks.onMetaDesc - Callback which receives changes to topic desctioption {@link desc}.
 * @param {callback} callbacks.onMetaSub - Called for a single subscription record change.
 * @param {callback} callbacks.onSubsUpdated - Called after a batch of subscription changes have been recieved and cached.
 * @param {callback} callbacks.onDeleteTopic - Called after the topic is deleted.
 * @param {callback} callbacls.onAllMessagesReceived - Called when all requested <code>{data}</code> messages have been recived.
 */
var Topic = function(name, callbacks) {
  // Parent Tinode object.
  this._tinode = null;

  // Server-provided data, locally immutable.
  // topic name
  this.name = name;
  // Timestamp when the topic was created.
  this.created = null;
  // Timestamp when the topic was last updated.
  this.updated = null;
  // Timestamp of the last messages
  this.touched = new Date(0);
  // Access mode, see AccessMode
  this.acs = new AccessMode(null);
  // per-topic private data
  this.private = null;
  // per-topic public data
  this.public = null;

  // Locally cached data
  // Subscribed users, for tracking read/recv/msg notifications.
  this._users = {};

  // Current value of locally issued seqId, used for pending messages.
  this._queuedSeqId = LOCAL_SEQID;

  // The maximum known {data.seq} value.
  this._maxSeq = 0;
  // The minimum known {data.seq} value.
  this._minSeq = 0;
  // Indicator that the last request for earlier messages returned 0.
  this._noEarlierMsgs = false;
  // The maximum known deletion ID.
  this._maxDel = 0;
  // User discovery tags
  this._tags = [];
  // Credentials such as email or phone number.
  this._credentials = [];
  // Message cache, sorted by message seq values, from old to new.
  this._messages = CBuffer(function(a, b) {
    return a.seq - b.seq;
  }, true);
  // Boolean, true if the topic is currently live
  this._subscribed = false;
  // Timestap of the most recently updated subscription.
  this._lastSubsUpdate = new Date(0);
  // Topic created but not yet synced with the server. Used only during initialization.
  this._new = true;

  // Callbacks
  if (callbacks) {
    this.onData = callbacks.onData;
    this.onMeta = callbacks.onMeta;
    this.onPres = callbacks.onPres;
    this.onInfo = callbacks.onInfo;
    // A single desc update;
    this.onMetaDesc = callbacks.onMetaDesc;
    // A single subscription record;
    this.onMetaSub = callbacks.onMetaSub;
    // All subscription records received;
    this.onSubsUpdated = callbacks.onSubsUpdated;
    this.onTagsUpdated = callbacks.onTagsUpdated;
    this.onCredsUpdated = callbacks.onCredsUpdated;
    this.onDeleteTopic = callbacks.onDeleteTopic;
    this.onAllMessagesReceived = callbacks.onAllMessagesReceived;
  }
};

Topic.prototype = {
  /**
   * Check if the topic is subscribed.
   * @memberof Tinode.Topic#
   * @returns {boolean} True is topic is attached/subscribed, false otherwise.
   */
  isSubscribed: function() {
    return this._subscribed;
  },

  /**
   * Request topic to subscribe. Wrapper for {@link Tinode#subscribe}.
   * @memberof Tinode.Topic#
   *
   * @param {Tinode.GetQuery=} getParams - get query parameters.
   * @param {Tinode.SetParams=} setParams - set parameters.
   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
   */
  subscribe: function(getParams, setParams) {
    // If the topic is already subscribed, return resolved promise
    if (this._subscribed) {
      return Promise.resolve(this);
    }

    // Send subscribe message, handle async response.
    // If topic name is explicitly provided, use it. If no name, then it's a new group topic,
    // use "new".
    return this._tinode.subscribe(this.name || TOPIC_NEW, getParams, setParams).then((ctrl) => {
      if (ctrl.code >= 300) {
        // Do nothing if subscription status has not changed.
        return ctrl;
      }

      this._subscribed = true;
      this.acs = (ctrl.params && ctrl.params.acs) ? ctrl.params.acs : this.acs;

      // Set topic name for new topics and add it to cache.
      if (this._new) {
        this._new = false;

        if (this.name != ctrl.topic) {
          // Name may change new123456 -> grpAbCdEf. Remove from cache under the old name.
          this._cacheDelSelf();
          this.name = ctrl.topic;
        }
        this._cachePutSelf();

        this.created = ctrl.ts;
        this.updated = ctrl.ts;
        this.touched = ctrl.ts;

        if (this.name != TOPIC_ME && this.name != TOPIC_FND) {
          // Add the new topic to the list of contacts maintained by the 'me' topic.
          const me = this._tinode.getMeTopic();
          if (me.onMetaSub) {
            me.onMetaSub(this);
          }
          if (me.onSubsUpdated) {
            me.onSubsUpdated([this.name], 1);
          }
        }

        if (setParams && setParams.desc) {
          setParams.desc._noForwarding = true;
          this._processMetaDesc(setParams.desc);
        }
      }

      return ctrl;
    });
  },

  /**
   * Create a draft of a message without sending it to the server.
   * @memberof Tinode.Topic#
   *
   * @param {string | Object} data - Content to wrap in a draft.
   * @param {boolean=} noEcho - If <code>true</code> server will not echo message back to originating
   * session. Otherwise the server will send a copy of the message to sender.
   *
   * @returns {Object} message draft.
   */
  createMessage: function(data, noEcho) {
    return this._tinode.createMessage(this.name, data, noEcho);
  },

  /**
   * Immediately publish data to topic. Wrapper for {@link Tinode#publish}.
   * @memberof Tinode.Topic#
   *
   * @param {string | Object} data - Data to publish, either plain string or a Drafty object.
   * @param {boolean=} noEcho - If <code>true</code> server will not echo message back to originating
   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
   */
  publish: function(data, noEcho) {
    return this.publishMessage(this.createMessage(data, noEcho));
  },

  /**
   * Publish message created by {@link Tinode.Topic#createMessage}.
   * @memberof Tinode.Topic#
   *
   * @param {Object} pub - {data} object to publish. Must be created by {@link Tinode.Topic#createMessage}
   *
   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
   */
  publishMessage: function(pub) {
    if (!this._subscribed) {
      return Promise.reject(new Error("Cannot publish on inactive topic"));
    }

    // Update header with attachment and out of band image records.
    if (Drafty.hasEntities(pub.content) && !pub.head.attachments) {
      const entities = [];
      Drafty.entities(pub.content, (data) => {
        if (data && data.ref) {
          entities.push(data.ref);
        }
      });
      if (entities.length > 0) {
        pub.head.attachments = entities;
      }
    }

    // Send data.
    pub._sending = true;
    pub._failed = false;
    return this._tinode.publishMessage(pub).then((ctrl) => {
      pub._sending = false;
      pub.ts = ctrl.ts;
      this.swapMessageId(pub, ctrl.params.seq);
      this._routeData(pub);
      return ctrl;
    }).catch((err) => {
      this._tinode.logger("WARNING: Message rejected by the server", err);
      pub._sending = false;
      pub._failed = true;
      if (this.onData) {
        this.onData();
      }
    });
  },

  /**
   * Add message to local message cache, send to the server when the promise is resolved.
   * If promise is null or undefined, the message will be sent immediately.
   * The message is sent when the
   * The message should be created by {@link Tinode.Topic#createMessage}.
   * This is probably not the final API.
   * @memberof Tinode.Topic#
   *
   * @param {Object} pub - Message to use as a draft.
   * @param {Promise} prom - Message will be sent when this promise is resolved, discarded if rejected.
   *
   * @returns {Promise} derived promise.
   */
  publishDraft: function(pub, prom) {
    if (!prom && !this._subscribed) {
      return Promise.reject(new Error("Cannot publish on inactive topic"));
    }

    const seq = pub.seq || this._getQueuedSeqId();
    if (!pub._noForwarding) {
      // The 'seq', 'ts', and 'from' are added to mimic {data}. They are removed later
      // before the message is sent.

      pub._noForwarding = true;
      pub.seq = seq;
      pub.ts = new Date();
      pub.from = this._tinode.getCurrentUserID();

      // Don't need an echo message because the message is added to local cache right away.
      pub.noecho = true;
      // Add to cache.
      this._messages.put(pub);
      this._tinode._db.addMessage(pub);

      if (this.onData) {
        this.onData(pub);
      }
    }
    // If promise is provided, send the queued message when it's resolved.
    // If no promise is provided, create a resolved one and send immediately.
    prom = (prom || Promise.resolve()).then(
      ( /* argument ignored */ ) => {
        if (pub._cancelled) {
          return {
            code: 300,
            text: "cancelled"
          };
        }
        return this.publishMessage(pub);
      },
      (err) => {
        this._tinode.logger("WARNING: Message draft rejected", err);
        pub._sending = false;
        pub._failed = true;
        this._messages.delAt(this._messages.find(pub));
        this._tinode._db.remMessages(this.name, pub.seq);
        if (this.onData) {
          this.onData();
        }
      });
    return prom;
  },

  /**
   * Leave the topic, optionally unsibscribe. Leaving the topic means the topic will stop
   * receiving updates from the server. Unsubscribing will terminate user's relationship with the topic.
   * Wrapper for {@link Tinode#leave}.
   * @memberof Tinode.Topic#
   *
   * @param {boolean=} unsub - If true, unsubscribe, otherwise just leave.
   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
   */
  leave: function(unsub) {
    // It's possible to unsubscribe (unsub==true) from inactive topic.
    if (!this._subscribed && !unsub) {
      return Promise.reject(new Error("Cannot leave inactive topic"));
    }

    // Send a 'leave' message, handle async response
    return this._tinode.leave(this.name, unsub).then((ctrl) => {
      this._resetSub();
      if (unsub) {
        this._tinode._db.remTopic(this.name);
        this._tinode.cacheDel('topic', this.name);
        this._gone();
      }
      return ctrl;
    });
  },

  /**
   * Request topic metadata from the server.
   * @memberof Tinode.Topic#
   *
   * @param {Tinode.GetQuery} request parameters
   *
   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.
   */
  getMeta: function(params) {
    // Send {get} message, return promise.
    return this._tinode.getMeta(this.name, params);
  },

  /**
   * Request more messages from the server
   * @memberof Tinode.Topic#
   *
   * @param {number} limit number of messages to get.
   * @param {boolean} forward if true, request newer messages.
   */
  getMessagesPage: function(limit, forward) {
    const query = this.startMetaQuery();
    if (forward) {
      query.withLaterData(limit);
    } else {
      query.withEarlierData(limit);
    }
    let promise = this.getMeta(query.build());
    if (!forward) {
      promise = promise.then((ctrl) => {
        if (ctrl && ctrl.params && !ctrl.params.count) {
          this._noEarlierMsgs = true;
        }
      });
    }
    return promise;
  },

  /**
   * Update topic metadata.
   * @memberof Tinode.Topic#
   *
   * @param {Tinode.SetParams} params parameters to update.
   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.
   */
  setMeta: function(params) {
    if (params.tags) {
      params.tags = normalizeArray(params.tags);
    }
    // Send Set message, handle async response.
    return this._tinode.setMeta(this.name, params)
      .then((ctrl) => {
        if (ctrl && ctrl.code >= 300) {
          // Not modified
          return ctrl;
        }

        if (params.sub) {
          params.sub.topic = this.name;
          if (ctrl.params && ctrl.params.acs) {
            params.sub.acs = ctrl.params.acs;
            params.sub.updated = ctrl.ts;
          }
          if (!params.sub.user) {
            // This is a subscription update of the current user.
            // Assign user ID otherwise the update will be ignored by _processMetaSub.
            params.sub.user = this._tinode.getCurrentUserID();
            if (!params.desc) {
              // Force update to topic's asc.
              params.desc = {};
            }
          }
          params.sub._noForwarding = true;
          this._processMetaSub([params.sub]);
        }

        if (params.desc) {
          if (ctrl.params && ctrl.params.acs) {
            params.desc.acs = ctrl.params.acs;
            params.desc.updated = ctrl.ts;
          }
          this._processMetaDesc(params.desc);
        }

        if (params.tags) {
          this._processMetaTags(params.tags);
        }
        if (params.cred) {
          this._processMetaCreds([params.cred], true);
        }

        return ctrl;
      });
  },

  /**
   * Update access mode of the current user or of another topic subsriber.
   * @memberof Tinode.Topic#
   *
   * @param {string} uid - UID of the user to update or null to update current user.
   * @param {string} update - the update value, full or delta.
   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.
   */
  updateMode: function(uid, update) {
    const user = uid ? this.subscriber(uid) : null;
    const am = user ?
      user.acs.updateGiven(update).getGiven() :
      this.getAccessMode().updateWant(update).getWant();

    return this.setMeta({
      sub: {
        user: uid,
        mode: am
      }
    });
  },

  /**
   * Create new topic subscription. Wrapper for {@link Tinode#setMeta}.
   * @memberof Tinode.Topic#
   *
   * @param {string} uid - ID of the user to invite
   * @param {string=} mode - Access mode. <code>null</code> means to use default.
   *
   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.
   */
  invite: function(uid, mode) {
    return this.setMeta({
      sub: {
        user: uid,
        mode: mode
      }
    });
  },

  /**
   * Archive or un-archive the topic. Wrapper for {@link Tinode#setMeta}.
   * @memberof Tinode.Topic#
   *
   * @param {boolean} arch - true to archive the topic, false otherwise.
   *
   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.
   */
  archive: function(arch) {
    if (this.private && this.private.arch == arch) {
      return Promise.resolve(arch);
    }
    return this.setMeta({
      desc: {
        private: {
          arch: arch ? true : Tinode.DEL_CHAR
        }
      }
    });
  },

  /**
   * Delete messages. Hard-deleting messages requires Owner permission.
   * Wrapper for {@link Tinode#delMessages}.
   * @memberof Tinode.Topic#
   *
   * @param {Tinode.DelRange[]} ranges - Ranges of message IDs to delete.
   * @param {boolean=} hard - Hard or soft delete
   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.
   */
  delMessages: function(ranges, hard) {
    if (!this._subscribed) {
      return Promise.reject(new Error("Cannot delete messages in inactive topic"));
    }

    // Sort ranges in accending order by low, the descending by hi.
    ranges.sort((r1, r2) => {
      if (r1.low < r2.low) {
        return true;
      }
      if (r1.low == r2.low) {
        return !r2.hi || (r1.hi >= r2.hi);
      }
      return false;
    });

    // Remove pending messages from ranges possibly clipping some ranges.
    let tosend = ranges.reduce((out, r) => {
      if (r.low < LOCAL_SEQID) {
        if (!r.hi || r.hi < LOCAL_SEQID) {
          out.push(r);
        } else {
          // Clip hi to max allowed value.
          out.push({
            low: r.low,
            hi: this._maxSeq + 1
          });
        }
      }
      return out;
    }, []);

    // Send {del} message, return promise
    let result;
    if (tosend.length > 0) {
      result = this._tinode.delMessages(this.name, tosend, hard);
    } else {
      result = Promise.resolve({
        params: {
          del: 0
        }
      });
    }
    // Update local cache.
    return result.then((ctrl) => {
      if (ctrl.params.del > this._maxDel) {
        this._maxDel = ctrl.params.del;
      }

      ranges.map((r) => {
        if (r.hi) {
          this.flushMessageRange(r.low, r.hi);
        } else {
          this.flushMessage(r.low);
        }
      });

      this._updateDeletedRanges();

      if (this.onData) {
        // Calling with no parameters to indicate the messages were deleted.
        this.onData();
      }
      return ctrl;
    });
  },

  /**
   * Delete all messages. Hard-deleting messages requires Owner permission.
   * @memberof Tinode.Topic#
   *
   * @param {boolean} hardDel - true if messages should be hard-deleted.
   *
   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.
   */
  delMessagesAll: function(hardDel) {
    if (!this._maxSeq || this._maxSeq <= 0) {
      // There are no messages to delete.
      return Promise.resolve();
    }
    return this.delMessages([{
      low: 1,
      hi: this._maxSeq + 1,
      _all: true
    }], hardDel);
  },

  /**
   * Delete multiple messages defined by their IDs. Hard-deleting messages requires Owner permission.
   * @memberof Tinode.Topic#
   *
   * @param {Tinode.DelRange[]} list - list of seq IDs to delete
   * @param {boolean=} hardDel - true if messages should be hard-deleted.
   *
   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.
   */
  delMessagesList: function(list, hardDel) {
    // Sort the list in ascending order
    list.sort((a, b) => a - b);
    // Convert the array of IDs to ranges.
    let ranges = list.reduce((out, id) => {
      if (out.length == 0) {
        // First element.
        out.push({
          low: id
        });
      } else {
        let prev = out[out.length - 1];
        if ((!prev.hi && (id != prev.low + 1)) || (id > prev.hi)) {
          // New range.
          out.push({
            low: id
          });
        } else {
          // Expand existing range.
          prev.hi = prev.hi ? Math.max(prev.hi, id + 1) : id + 1;
        }
      }
      return out;
    }, []);
    // Send {del} message, return promise
    return this.delMessages(ranges, hardDel)
  },

  /**
   * Delete topic. Requires Owner permission. Wrapper for {@link Tinode#delTopic}.
   * @memberof Tinode.Topic#
   *
   * @param {boolean} hard - had-delete topic.
   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
   */
  delTopic: function(hard) {
    return this._tinode.delTopic(this.name, hard).then((ctrl) => {
      this._resetSub();
      this._gone();
      return ctrl;
    });
  },

  /**
   * Delete subscription. Requires Share permission. Wrapper for {@link Tinode#delSubscription}.
   * @memberof Tinode.Topic#
   *
   * @param {string} user - ID of the user to remove subscription for.
   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.
   */
  delSubscription: function(user) {
    if (!this._subscribed) {
      return Promise.reject(new Error("Cannot delete subscription in inactive topic"));
    }
    // Send {del} message, return promise
    return this._tinode.delSubscription(this.name, user).then((ctrl) => {
      // Remove the object from the subscription cache;
      delete this._users[user];
      // Notify listeners
      if (this.onSubsUpdated) {
        this.onSubsUpdated(Object.keys(this._users));
      }
      return ctrl;
    });
  },

  /**
   * Send a read/recv notification.
   * @memberof Tinode.Topic#
   *
   * @param {string} what - what notification to send: <code>recv</code>, <code>read</code>.
   * @param {number} seq - ID or the message read or received.
   */
  note: function(what, seq) {
    if (!this._subscribed) {
      // Cannot sending {note} on an inactive topic".
      return;
    }

    // Update local cache with the new count.
    const user = this._users[this._tinode.getCurrentUserID()];
    let update = false;
    if (user) {
      // Self-subscription is found.
      if (!user[what] || user[what] < seq) {
        user[what] = seq;
        update = true;
      }
    } else {
      // Self-subscription is not found.
      update = (this[what] | 0) < seq;
    }

    if (update) {
      // Send notification to the server.
      this._tinode.note(this.name, what, seq);
      // Update locally cached contact with the new count.
      this._updateReadRecv(what, seq);

      if (this.acs != null && !this.acs.isMuted()) {
        const me = this._tinode.getMeTopic();
        // Sent a notification to 'me' listeners.
        me._refreshContact(what, this);
      }
    }
  },

  /**
   * Send a 'recv' receipt. Wrapper for {@link Tinode#noteRecv}.
   * @memberof Tinode.Topic#
   *
   * @param {number} seq - ID of the message to aknowledge.
   */
  noteRecv: function(seq) {
    this.note('recv', seq);
  },

  /**
   * Send a 'read' receipt. Wrapper for {@link Tinode#noteRead}.
   * @memberof Tinode.Topic#
   *
   * @param {number} seq - ID of the message to aknowledge or 0/undefined to acknowledge the latest messages.
   */
  noteRead: function(seq) {
    seq = seq || this._maxSeq;
    if (seq > 0) {
      this.note('read', seq);
    }
  },

  /**
   * Send a key-press notification. Wrapper for {@link Tinode#noteKeyPress}.
   * @memberof Tinode.Topic#
   */
  noteKeyPress: function() {
    if (this._subscribed) {
      this._tinode.noteKeyPress(this.name);
    } else {
      this._tinode.logger("INFO: Cannot send notification in inactive topic");
    }
  },

  // Update cached read/recv/unread counts.
  _updateReadRecv: function(what, seq, ts) {
    let oldVal, doUpdate = false;

    seq = seq | 0;
    this.seq = this.seq | 0;
    this.read = this.read | 0;
    this.recv = this.recv | 0;
    switch (what) {
      case 'recv':
        oldVal = this.recv;
        this.recv = Math.max(this.recv, seq);
        doUpdate = (oldVal != this.recv);
        break;
      case 'read':
        oldVal = this.read;
        this.read = Math.max(this.read, seq);
        doUpdate = (oldVal != this.read);
        break;
      case 'msg':
        oldVal = this.seq;
        this.seq = Math.max(this.seq, seq);
        if (!this.touched || this.touched < ts) {
          this.touched = ts;
        }
        doUpdate = (oldVal != this.seq);
        break;
    }

    // Sanity checks.
    if (this.recv < this.read) {
      this.recv = this.read;
      doUpdate = true;
    }
    if (this.seq < this.recv) {
      this.seq = this.recv;
      if (!this.touched || this.touched < ts) {
        this.touched = ts;
      }
      doUpdate = true;
    }
    this.unread = this.seq - this.read;
    return doUpdate;
  },

  /**
   * Get user description from global cache. The user does not need to be a
   * subscriber of this topic.
   * @memberof Tinode.Topic#
   *
   * @param {string} uid - ID of the user to fetch.
   * @return {Object} user description or undefined.
   */
  userDesc: function(uid) {
    // TODO(gene): handle asynchronous requests

    const user = this._cacheGetUser(uid);
    if (user) {
      return user; // Promise.resolve(user)
    }
  },

  /**
   * Get description of the p2p peer from subscription cache.
   * @memberof Tinode.Topic#
   *
   * @return {Object} peer's description or undefined.
   */
  p2pPeerDesc: function() {
    if (!this.isP2PType()) {
      return undefined;
    }
    return this._users[this.name];
  },

  /**
   * Iterate over cached subscribers. If callback is undefined, use this.onMetaSub.
   * @memberof Tinode.Topic#
   *
   * @param {function} callback - Callback which will receive subscribers one by one.
   * @param {Object=} context - Value of `this` inside the `callback`.
   */
  subscribers: function(callback, context) {
    const cb = (callback || this.onMetaSub);
    if (cb) {
      for (let idx in this._users) {
        cb.call(context, this._users[idx], idx, this._users);
      }
    }
  },

  /**
   * Get a copy of cached tags.
   * @memberof Tinode.Topic#
   *
   * @return {Array.<string>} a copy of tags
   */
  tags: function() {
    // Return a copy.
    return this._tags.slice(0);
  },

  /**
   * Get cached subscription for the given user ID.
   * @memberof Tinode.Topic#
   *
   * @param {string} uid - id of the user to query for
   * @return user description or undefined.
   */
  subscriber: function(uid) {
    return this._users[uid];
  },

  /**
   * Iterate over cached messages. If callback is undefined, use this.onData.
   * @memberof Tinode.Topic#
   *
   * @param {function} callback - Callback which will receive messages one by one. See {@link Tinode.CBuffer#forEach}
   * @param {number} sinceId - Optional seqId to start iterating from (inclusive).
   * @param {number} beforeId - Optional seqId to stop iterating before (exclusive).
   * @param {Object} context - Value of `this` inside the `callback`.
   */
  messages: function(callback, sinceId, beforeId, context) {
    const cb = (callback || this.onData);
    if (cb) {
      let startIdx = typeof sinceId == 'number' ? this._messages.find({
        seq: sinceId
      }, true) : undefined;
      let beforeIdx = typeof beforeId == 'number' ? this._messages.find({
        seq: beforeId
      }, true) : undefined;
      if (startIdx != -1 && beforeIdx != -1) {
        this._messages.forEach(cb, startIdx, beforeIdx, context);
      }
    }
  },

  /**
   * Get the most recent message from cache.
   * @memberof Tinode.Topic#
   *
   * @param {boolen} skipDeleted - if the last message is a deleted range, get the one before it.
   * @returns {Object} the most recent cached message or <code>undefined</code>, if no messages are cached.
   */
  latestMessage: function(skipDeleted) {
    const msg = this._messages.getLast();
    if (!skipDeleted || !msg || msg._status != MESSAGE_STATUS_DEL_RANGE) {
      return msg;
    }
    return this._messages.getLast(1);
  },

  /**
   * Iterate over cached unsent messages. Wraps {@link Tinode.Topic#messages}.
   * @memberof Tinode.Topic#
   *
   * @param {function} callback - Callback which will receive messages one by one. See {@link Tinode.CBuffer#forEach}
   * @param {Object} context - Value of <code>this</code> inside the <code>callback</code>.
   */
  queuedMessages: function(callback, context) {
    if (!callback) {
      throw new Error("Callback must be provided");
    }
    this.messages(callback, LOCAL_SEQID, undefined, context);
  },

  /**
   * Get the number of topic subscribers who marked this message as either recv or read
   * Current user is excluded from the count.
   * @memberof Tinode.Topic#
   *
   * @param {string} what - what action to consider: received <code>"recv"</code> or read <code>"read"</code>.
   * @param {number} seq - ID or the message read or received.
   *
   * @returns {number} the number of subscribers who marked the message with the given ID as read or received.
   */
  msgReceiptCount: function(what, seq) {
    let count = 0;
    if (seq > 0) {
      const me = this._tinode.getCurrentUserID();
      for (let idx in this._users) {
        const user = this._users[idx];
        if (user.user !== me && user[what] >= seq) {
          count++;
        }
      }
    }
    return count;
  },

  /**
   * Get the number of topic subscribers who marked this message (and all older messages) as read.
   * The current user is excluded from the count.
   * @memberof Tinode.Topic#
   *
   * @param {number} seq - message id to check.
   * @returns {number} number of subscribers who claim to have received the message.
   */
  msgReadCount: function(seq) {
    return this.msgReceiptCount('read', seq);
  },

  /**
   * Get the number of topic subscribers who marked this message (and all older messages) as received.
   * The current user is excluded from the count.
   * @memberof Tinode.Topic#
   *
   * @param {number} seq - Message id to check.
   * @returns {number} Number of subscribers who claim to have received the message.
   */
  msgRecvCount: function(seq) {
    return this.msgReceiptCount('recv', seq);
  },

  /**
   * Check if cached message IDs indicate that the server may have more messages.
   * @memberof Tinode.Topic#
   *
   * @param {boolean} newer - if <code>true</code>, check for newer messages only.
   */
  msgHasMoreMessages: function(newer) {
    return newer ? this.seq > this._maxSeq :
      // _minSeq could be more than 1, but earlier messages could have been deleted.
      (this._minSeq > 1 && !this._noEarlierMsgs);
  },

  /**
   * Check if the given seq Id is id of the most recent message.
   * @memberof Tinode.Topic#
   *
   * @param {number} seqId id of the message to check
   */
  isNewMessage: function(seqId) {
    return this._maxSeq <= seqId;
  },

  /**
   * Remove one message from local cache.
   * @memberof Tinode.Topic#
   *
   * @param {number} seqId id of the message to remove from cache.
   * @returns {Message} removed message or undefined if such message was not found.
   */
  flushMessage: function(seqId) {
    const idx = this._messages.find({
      seq: seqId
    });
    if (idx >= 0) {
      this._tinode._db.remMessages(this.name, seqId);
      return this._messages.delAt(idx);
    }
    return undefined;
  },

  /**
   * Update message's seqId.
   * @memberof Tinode.Topic#
   *
   * @param {Object} pub message object.
   * @param {number} newSeqId new seq id for pub.
   */
  swapMessageId: function(pub, newSeqId) {
    const idx = this._messages.find(pub);
    const numMessages = this._messages.length();
    if (0 <= idx && idx < numMessages) {
      // Remove message with the old seq ID.
      this._messages.delAt(idx);
      this._tinode._db.remMessages(this.name, pub.seq);
      // Add message with the new seq ID.
      pub.seq = newSeqId;
      this._messages.put(pub);
      this._tinode._db.addMessage(pub);
    }
  },

  /**
   * Remove a range of messages from the local cache.
   * @memberof Tinode.Topic#
   *
   * @param {number} fromId seq ID of the first message to remove (inclusive).
   * @param {number} untilId seqID of the last message to remove (exclusive).
   *
   * @returns {Message[]} array of removed messages (could be empty).
   */
  flushMessageRange: function(fromId, untilId) {
    // Remove range from persistent cache.
    this._tinode._db.remMessages(this.name, fromId, untilId);
    // start, end: find insertion points (nearest == true).
    const since = this._messages.find({
      seq: fromId
    }, true);
    return since >= 0 ? this._messages.delRange(since, this._messages.find({
      seq: untilId
    }, true)) : [];
  },

  /**
   * Attempt to stop message from being sent.
   * @memberof Tinode.Topic#
   *
   * @param {number} seqId id of the message to stop sending and remove from cache.
   *
   * @returns {boolean} <code>true</code> if message was cancelled, <code>false</code> otherwise.
   */
  cancelSend: function(seqId) {
    const idx = this._messages.find({
      seq: seqId
    });
    if (idx >= 0) {
      const msg = this._messages.getAt(idx);
      const status = this.msgStatus(msg);
      if (status == MESSAGE_STATUS_QUEUED || status == MESSAGE_STATUS_FAILED) {
        this._tinode._db.remMessages(this.name, seqId);
        msg._cancelled = true;
        this._messages.delAt(idx);
        if (this.onData) {
          // Calling with no parameters to indicate the message was deleted.
          this.onData();
        }
        return true;
      }
    }
    return false;
  },

  /**
   * Get type of the topic: me, p2p, grp, fnd...
   * @memberof Tinode.Topic#
   *
   * @returns {string} One of 'me', 'p2p', 'grp', 'fnd', 'sys' or <code>undefined</code>.
   */
  getType: function() {
    return Tinode.topicType(this.name);
  },

  /**
   * Get current user's access mode of the topic.
   * @memberof Tinode.Topic#
   *
   * @returns {Tinode.AccessMode} - user's access mode
   */
  getAccessMode: function() {
    return this.acs;
  },

  /**
   * Set current user's access mode of the topic.
   * @memberof Tinode.Topic#
   *
   * @param {AccessMode | Object} acs - access mode to set.
   */
  setAccessMode: function(acs) {
    return this.acs = new AccessMode(acs);
  },

  /**
   * Get topic's default access mode.
   * @memberof Tinode.Topic#
   *
   * @returns {Tinode.DefAcs} - access mode, such as {auth: `RWP`, anon: `N`}.
   */
  getDefaultAccess: function() {
    return this.defacs;
  },

  /**
   * Initialize new meta {@link Tinode.GetQuery} builder. The query is attched to the current topic.
   * It will not work correctly if used with a different topic.
   * @memberof Tinode.Topic#
   *
   * @returns {Tinode.MetaGetBuilder} query attached to the current topic.
   */
  startMetaQuery: function() {
    return new MetaGetBuilder(this);
  },

  /**
   * Check if topic is archived, i.e. private.arch == true.
   * @memberof Tinode.Topic#
   *
   * @returns {boolean} - <code>true</code> if topic is archived, <code>false</code> otherwise.
   */
  isArchived: function() {
    return !!(this.private && this.private.arch);
  },

  /**
   * Check if topic is verified.
   * @memberof Tinode.Topic#
   *
   * @returns {boolean} - <code>true</code> if topic is verified, <code>false</code> otherwise.
   */
  isVerified: function() {
    return !!(this.trusted && this.trusted.verified);
  },

  /**
   * Check if topic is managed by staff.
   * @memberof Tinode.Topic#
   *
   * @returns {boolean} - <code>true</code> if topic is managed by staff, <code>false</code> otherwise.
   */
  isStaff: function() {
    return !!(this.trusted && this.trusted.staff);
  },

  /**
   * Check if topic is marked as suspicious.
   * @memberof Tinode.Topic#
   *
   * @returns {boolean} - <code>true</code> if topic is suspicious, <code>false</code> otherwise.
   */
  isDangerous: function() {
    return !!(this.trusted && this.trusted.danger);
  },

  /**
   * Check if topic is a 'me' topic.
   * @memberof Tinode.Topic#
   *
   * @returns {boolean} - <code>true</code> if topic is a 'me' topic, <code>false</code> otherwise.
   */
  isMeType: function() {
    return Tinode.isMeTopicName(this.name);
  },

  /**
   * Check if topic is a channel.
   * @memberof Tinode.Topic#
   *
   * @returns {boolean} - <code>true</code> if topic is a channel, <code>false</code> otherwise.
   */
  isChannelType: function() {
    return Tinode.isChannelTopicName(this.name);
  },

  /**
   * Check if topic is a group topic.
   * @memberof Tinode.Topic#
   *
   * @returns {boolean} - <code>true</code> if topic is a group, <code>false</code> otherwise.
   */
  isGroupType: function() {
    return Tinode.isGroupTopicName(this.name);
  },

  /**
   * Check if topic is a p2p topic.
   * @memberof Tinode.Topic#
   *
   * @returns {boolean} - <code>true</code> if topic is a p2p topic, <code>false</code> otherwise.
   */
  isP2PType: function() {
    return Tinode.isP2PTopicName(this.name);
  },

  /**
   * Check if topic is a communication topic, i.e. a group or p2p topic.
   * @memberof Tinode.Topic#
   *
   * @returns {boolean} - <code>true</code> if topic is a p2p or group topic, <code>false</code> otherwise.
   */
  isCommType: function() {
    return Tinode.isCommTopicName(this.name);
  },

  /**
   * Get status (queued, sent, received etc) of a given message in the context
   * of this topic.
   * @memberof Tinode.Topic#
   *
   * @param {Message} msg - message to check for status.
   * @param {boolean} upd - update chached message status.
   *
   * @returns message status constant.
   */
  msgStatus: function(msg, upd) {
    let status = MESSAGE_STATUS_NONE;
    if (this._tinode.isMe(msg.from)) {
      if (msg._sending) {
        status = MESSAGE_STATUS_SENDING;
      } else if (msg._failed || msg._cancelled) {
        status = MESSAGE_STATUS_FAILED;
      } else if (msg.seq >= LOCAL_SEQID) {
        status = MESSAGE_STATUS_QUEUED;
      } else if (this.msgReadCount(msg.seq) > 0) {
        status = MESSAGE_STATUS_READ;
      } else if (this.msgRecvCount(msg.seq) > 0) {
        status = MESSAGE_STATUS_RECEIVED;
      } else if (msg.seq > 0) {
        status = MESSAGE_STATUS_SENT;
      }
    } else if (msg._status == MESSAGE_STATUS_DEL_RANGE) {
      status == MESSAGE_STATUS_DEL_RANGE;
    } else {
      status = MESSAGE_STATUS_TO_ME;
    }

    if (upd && msg._status != status) {
      msg._status = status;
      this._tinode._db.updMessageStatus(this.name, msg.seq, status);
    }

    return status;
  },

  // Process data message
  _routeData: function(data) {
    if (data.content) {
      if (!this.touched || this.touched < data.ts) {
        this.touched = data.ts;
      }
    }

    if (data.seq > this._maxSeq) {
      this._maxSeq = data.seq;
    }
    if (data.seq < this._minSeq || this._minSeq == 0) {
      this._minSeq = data.seq;
    }

    if (!data._noForwarding) {
      this._messages.put(data);
      this._tinode._db.addMessage(data);
      this._updateDeletedRanges();
    }

    if (this.onData) {
      this.onData(data);
    }

    // Update locally cached contact with the new message count.
    const what = ((!this.isChannelType() && !data.from) || this._tinode.isMe(data.from)) ? 'read' : 'msg';
    this._updateReadRecv(what, data.seq, data.ts);
    // Notify 'me' listeners of the change.
    this._tinode.getMeTopic()._refreshContact(what, this);
  },

  // Process metadata message
  _routeMeta: function(meta) {
    if (meta.desc) {
      this._processMetaDesc(meta.desc);
    }
    if (meta.sub && meta.sub.length > 0) {
      this._processMetaSub(meta.sub);
    }
    if (meta.del) {
      this._processDelMessages(meta.del.clear, meta.del.delseq);
    }
    if (meta.tags) {
      this._processMetaTags(meta.tags);
    }
    if (meta.cred) {
      this._processMetaCreds(meta.cred);
    }
    if (this.onMeta) {
      this.onMeta(meta);
    }
  },

  // Process presence change message
  _routePres: function(pres) {
    let user;
    switch (pres.what) {
      case 'del':
        // Delete cached messages.
        this._processDelMessages(pres.clear, pres.delseq);
        break;
      case 'on':
      case 'off':
        // Update online status of a subscription.
        user = this._users[pres.src];
        if (user) {
          user.online = pres.what == 'on';
        } else {
          this._tinode.logger("WARNING: Presence update for an unknown user", this.name, pres.src);
        }
        break;
      case 'term':
        // Attachment to topic is terminated probably due to cluster rehashing.
        this._resetSub();
        break;
      case 'acs':
        const uid = pres.src || this._tinode.getCurrentUserID();
        user = this._users[uid];
        if (!user) {
          // Update for an unknown user: notification of a new subscription.
          const acs = new AccessMode().updateAll(pres.dacs);
          if (acs && acs.mode != AccessMode._NONE) {
            user = this._cacheGetUser(uid);
            if (!user) {
              user = {
                user: uid,
                acs: acs
              };
              this.getMeta(this.startMetaQuery().withOneSub(undefined, uid).build());
            } else {
              user.acs = acs;
            }
            user.updated = new Date();
            this._processMetaSub([user]);
          }
        } else {
          // Known user
          user.acs.updateAll(pres.dacs);
          // Update user's access mode.
          this._processMetaSub([{
            user: uid,
            updated: new Date(),
            acs: user.acs
          }]);
        }
        break;
      default:
        this._tinode.logger("INFO: Ignored presence update", pres.what);
    }

    if (this.onPres) {
      this.onPres(pres);
    }
  },

  // Process {info} message
  _routeInfo: function(info) {
    if (info.what !== 'kp') {
      const user = this._users[info.from];
      if (user) {
        user[info.what] = info.seq;
        if (user.recv < user.read) {
          user.recv = user.read;
        }
      }
      const msg = this.latestMessage();
      if (msg) {
        this.msgStatus(msg, true);
      }

      // If this is an update from the current user, update the cache with the new count.
      if (this._tinode.isMe(info.from)) {
        this._updateReadRecv(info.what, info.seq);
      }

      // Notify 'me' listener of the status change.
      this._tinode.getMeTopic()._refreshContact(info.what, this);
    }
    if (this.onInfo) {
      this.onInfo(info);
    }
  },

  // Called by Tinode when meta.desc packet is received.
  // Called by 'me' topic on contact update (desc._noForwarding is true).
  _processMetaDesc: function(desc) {
    if (this.isP2PType()) {
      // Synthetic desc may include defacs for p2p topics which is useless.
      // Remove it.
      delete desc.defacs;

      // Update to p2p desc is the same as user update. Update cached user.
      this._tinode._db.updUser(this.name, desc.public);
    }

    // Copy parameters from desc object to this topic.
    mergeObj(this, desc);
    // Make sure date fields are Date().
    stringToDate(this);
    // Update persistent cache.
    this._tinode._db.updTopic(this);

    // Notify 'me' listener, if available:
    if (this.name !== TOPIC_ME && !desc._noForwarding) {
      const me = this._tinode.getMeTopic();
      if (me.onMetaSub) {
        me.onMetaSub(this);
      }
      if (me.onSubsUpdated) {
        me.onSubsUpdated([this.name], 1);
      }
    }

    if (this.onMetaDesc) {
      this.onMetaDesc(this);
    }
  },

  // Called by Tinode when meta.sub is recived or in response to received
  // {ctrl} after setMeta-sub.
  _processMetaSub: function(subs) {
    for (let idx in subs) {
      const sub = subs[idx];

      // Fill defaults.
      sub.updated = new Date(sub.updated);
      sub.deleted = sub.deleted ? new Date(sub.deleted) : null;
      sub.online = !!sub.online;
      // Update timestamp of the most recent subscription update.
      this._lastSubsUpdate = new Date(Math.max(this._lastSubsUpdate, sub.updated));

      let user = null;
      if (!sub.deleted) {
        // If this is a change to user's own permissions, update them in topic too.
        // Desc will update 'me' topic.
        if (this._tinode.isMe(sub.user) && sub.acs) {
          this._processMetaDesc({
            updated: sub.updated,
            touched: sub.updated,
            acs: sub.acs
          });
        }
        user = this._updateCachedUser(sub.user, sub);
      } else {
        // Subscription is deleted, remove it from topic (but leave in Users cache)
        delete this._users[sub.user];
        user = sub;
      }

      if (this.onMetaSub) {
        this.onMetaSub(user);
      }
    }

    if (this.onSubsUpdated) {
      this.onSubsUpdated(Object.keys(this._users));
    }
  },

  // Called by Tinode when meta.tags is recived.
  _processMetaTags: function(tags) {
    if (tags.length == 1 && tags[0] == Tinode.DEL_CHAR) {
      tags = [];
    }
    this._tags = tags;
    if (this.onTagsUpdated) {
      this.onTagsUpdated(tags);
    }
  },

  // Do nothing for topics other than 'me'
  _processMetaCreds: function(creds) {},

  // Delete cached messages and update cached transaction IDs
  _processDelMessages: function(clear, delseq) {
    this._maxDel = Math.max(clear, this._maxDel);
    this.clear = Math.max(clear, this.clear);
    const topic = this;
    let count = 0;
    if (Array.isArray(delseq)) {
      delseq.map(function(range) {
        if (!range.hi) {
          count++;
          topic.flushMessage(range.low);
        } else {
          for (let i = range.low; i < range.hi; i++) {
            count++;
            topic.flushMessage(i);
          }
        }
      });
    }

    if (count > 0) {
      this._updateDeletedRanges();

      if (this.onData) {
        this.onData();
      }
    }
  },

  // Topic is informed that the entire response to {get what=data} has been received.
  _allMessagesReceived: function(count) {
    this._updateDeletedRanges();

    if (this.onAllMessagesReceived) {
      this.onAllMessagesReceived(count);
    }
  },

  // Reset subscribed state
  _resetSub: function() {
    this._subscribed = false;
  },

  // This topic is either deleted or unsubscribed from.
  _gone: function() {
    this._messages.reset();
    this._tinode._db.remMessages(this.name);
    this._users = {};
    this.acs = new AccessMode(null);
    this.private = null;
    this.public = null;
    this._maxSeq = 0;
    this._minSeq = 0;
    this._subscribed = false;

    const me = this._tinode.getMeTopic();
    if (me) {
      me._routePres({
        _noForwarding: true,
        what: 'gone',
        topic: TOPIC_ME,
        src: this.name
      });
    }
    if (this.onDeleteTopic) {
      this.onDeleteTopic();
    }
  },

  // Update global user cache and local subscribers cache.
  // Don't call this method for non-subscribers.
  _updateCachedUser: function(uid, obj) {
    // Fetch user object from the global cache.
    // This is a clone of the stored object
    let cached = this._cacheGetUser(uid);
    cached = mergeObj(cached || {}, obj);
    // Save to global cache
    this._cachePutUser(uid, cached);
    // Save to the list of topic subsribers.
    return mergeToCache(this._users, uid, cached);
  },

  // Get local seqId for a queued message.
  _getQueuedSeqId: function() {
    return this._queuedSeqId++;
  },

  // Calculate ranges of missing messages.
  _updateDeletedRanges: function() {
    const ranges = [];

    let prev = null;
    // Check for gap in the beginning, before the first message.
    const first = this._messages.getAt(0);
    if (first && this._minSeq > 1 && !this._noEarlierMsgs) {
      // Some messages are missing in the beginning.
      if (first.hi) {
        // The first message already represents a gap.
        if (first.seq > 1) {
          first.seq = 1;
        }
        if (first.hi < this._minSeq - 1) {
          first.hi = this._minSeq - 1;
        }
        prev = first;
      } else {
        // Create new gap.
        prev = {
          seq: 1,
          hi: this._minSeq - 1
        };
        ranges.push(prev);
      }
    } else {
      // No gap in the beginning.
      prev = {
        seq: 0,
        hi: 0
      };
    }

    // Find gaps in the list of received messages. The list contains messages-proper as well
    // as placeholers for deleted ranges.
    // The messages are iterated by seq ID in ascending order.
    this._messages.forEach((data) => {
      // Do not create a gap between the last sent message and the first unsent.
      if (data.seq >= LOCAL_SEQID) {
        return;
      }

      // New message is reducing the existing gap
      if (data.seq == (prev.hi || prev.seq) + 1) {
        // No new gap. Replace previous with current.
        prev = data;
        return;
      }

      // Found a new gap.
      if (prev.hi) {
        // Previous is also a gap, alter it.
        prev.hi = data.hi || data.seq;
        return;
      }

      // Previous is not a gap. Create a new gap.
      prev = {
        seq: (prev.hi || prev.seq) + 1,
        hi: data.hi || data.seq
      };
      ranges.push(prev);
    });

    // Check for missing messages at the end.
    // All messages could be missing or it could be a new topic with no messages.
    const last = this._messages.getLast();
    const maxSeq = Math.max(this.seq, this._maxSeq) || 0;
    if ((maxSeq > 0 && !last) || (last && ((last.hi || last.seq) < maxSeq))) {
      if (last && last.hi) {
        // Extend existing gap
        last.hi = maxSeq;
      } else {
        // Create new gap.
        ranges.push({
          seq: last ? last.seq + 1 : 1,
          hi: maxSeq
        });
      }
    }

    // Insert new gaps into cache.
    ranges.map((gap) => {
      gap._status = MESSAGE_STATUS_DEL_RANGE;
      this._messages.put(gap);
    });
  },

  // Load most recent messages from persistent cache.
  _loadMessages: function(db) {
    return db.readMessages(this.name, {
        limit: DEFAULT_MESSAGES_PAGE
      })
      .then((msgs) => {
        msgs.forEach((data) => {
          if (data.seq > this._maxSeq) {
            this._maxSeq = data.seq;
          }
          if (data.seq < this._minSeq || this._minSeq == 0) {
            this._minSeq = data.seq;
          }
          this._messages.put(data);
        });

        this._updateDeletedRanges();
        return this.name;
      });
  },

  // Push or {pres}: message received.
  _updateReceived: function(seq, act) {
    this.touched = new Date();
    this.seq = seq | 0;
    // Check if message is sent by the current user. If so it's been read already.
    if (!act || this._tinode.isMe(act)) {
      this.read = this.read ? Math.max(this.read, this.seq) : this.seq;
      this.recv = this.recv ? Math.max(this.read, this.recv) : this.read;
    }
    this.unread = this.seq - (this.read | 0);
    this._tinode._db.updTopic(this);
  }
};

/**
 * @class TopicMe - special case of {@link Tinode.Topic} for
 * managing data of the current user, including contact list.
 * @extends Tinode.Topic
 * @memberof Tinode
 *
 * @param {TopicMe.Callbacks} callbacks - Callbacks to receive various events.
 */
var TopicMe = function(callbacks) {
  Topic.call(this, TOPIC_ME, callbacks);

  // me-specific callbacks
  if (callbacks) {
    this.onContactUpdate = callbacks.onContactUpdate;
  }
};

// Inherit everyting from the generic Topic
TopicMe.prototype = Object.create(Topic.prototype, {
  // Override the original Topic._processMetaDesc.
  _processMetaDesc: {
    value: function(desc) {
      // Check if online contacts need to be turned off because P permission was removed.
      const turnOff = (desc.acs && !desc.acs.isPresencer()) && (this.acs && this.acs.isPresencer());

      // Copy parameters from desc object to this topic.
      mergeObj(this, desc);
      this._tinode._db.updTopic(this);

      // String datetime headers to Date() objects.
      stringToDate(this);

      // 'P' permission was removed. All topics are offline now.
      if (turnOff) {
        this._tinode.cacheMap('topic', (cont) => {
          if (cont.online) {
            cont.online = false;
            if (cont.seen) {
              cont.seen.when = new Date();
            } else {
              cont.seen = {
                when: new Date()
              };
            }
            this._refreshContact('off', cont);
          }
        });
      }

      if (this.onMetaDesc) {
        this.onMetaDesc(this);
      }
    },
    enumerable: true,
    configurable: true
  },

  // Override the original Topic._processMetaSub
  _processMetaSub: {
    value: function(subs) {
      let updateCount = 0;
      subs.forEach((sub) => {
        const topicName = sub.topic;
        // Don't show 'me' and 'fnd' topics in the list of contacts.
        if (topicName == TOPIC_FND || topicName == TOPIC_ME) {
          return;
        }
        sub.updated = new Date(sub.updated);
        sub.touched = sub.touched ? new Date(sub.touched) : undefined;
        sub.deleted = sub.deleted ? new Date(sub.deleted) : null;
        sub.online = !!sub.online;

        let cont = null;
        if (sub.deleted) {
          cont = sub;
          this._tinode.cacheDel('topic', topicName);
          this._tinode._db.remTopic(topicName);
        } else {
          // Ensure the values are defined and are integers.
          if (typeof sub.seq != 'undefined') {
            sub.seq = sub.seq | 0;
            sub.recv = sub.recv | 0;
            sub.read = sub.read | 0;
            sub.unread = sub.seq - sub.read;
          }

          if (sub.seen && sub.seen.when) {
            sub.seen.when = new Date(sub.seen.when);
          }

          cont = mergeObj(this._tinode.getTopic(topicName), sub);
          this._tinode._db.updTopic(cont);

          if (Tinode.isP2PTopicName(topicName)) {
            this._cachePutUser(topicName, cont);
            this._tinode._db.updUser(topicName, cont.public);
          }
          // Notify topic of the update if it's an external update.
          if (!sub._noForwarding) {
            const topic = this._tinode.getTopic(topicName);
            if (topic) {
              sub._noForwarding = true;
              topic._processMetaDesc(sub);
            }
          }
        }

        updateCount++;

        if (this.onMetaSub) {
          this.onMetaSub(cont);
        }
      });

      if (this.onSubsUpdated && updateCount > 0) {
        const keys = [];
        subs.forEach((s) => {
          keys.push(s.topic);
        });
        this.onSubsUpdated(keys, updateCount);
      }
    },
    enumerable: true,
    configurable: true
  },

  // Called by Tinode when meta.sub is recived.
  _processMetaCreds: {
    value: function(creds, upd) {
      if (creds.length == 1 && creds[0] == Tinode.DEL_CHAR) {
        creds = [];
      }
      if (upd) {
        creds.map((cr) => {
          if (cr.val) {
            // Adding a credential.
            let idx = this._credentials.findIndex((el) => {
              return el.meth == cr.meth && el.val == cr.val;
            });
            if (idx < 0) {
              // Not found.
              if (!cr.done) {
                // Unconfirmed credential replaces previous unconfirmed credential of the same method.
                idx = this._credentials.findIndex((el) => {
                  return el.meth == cr.meth && !el.done;
                });
                if (idx >= 0) {
                  // Remove previous unconfirmed credential.
                  this._credentials.splice(idx, 1);
                }
              }
              this._credentials.push(cr);
            } else {
              // Found. Maybe change 'done' status.
              this._credentials[idx].done = cr.done;
            }
          } else if (cr.resp) {
            // Handle credential confirmation.
            const idx = this._credentials.findIndex((el) => {
              return el.meth == cr.meth && !el.done;
            });
            if (idx >= 0) {
              this._credentials[idx].done = true;
            }
          }
        });
      } else {
        this._credentials = creds;
      }
      if (this.onCredsUpdated) {
        this.onCredsUpdated(this._credentials);
      }
    },
    enumerable: true,
    configurable: true
  },

  // Process presence change message
  _routePres: {
    value: function(pres) {
      if (pres.what == 'term') {
        // The 'me' topic itself is detached. Mark as unsubscribed.
        this._resetSub();
        return;
      }

      if (pres.what == 'upd' && pres.src == TOPIC_ME) {
        // Update to me's description. Request updated value.
        this.getMeta(this.startMetaQuery().withDesc().build());
        return;
      }

      const cont = this._tinode.cacheGet('topic', pres.src);
      if (cont) {
        switch (pres.what) {
          case 'on': // topic came online
            cont.online = true;
            break;
          case 'off': // topic went offline
            if (cont.online) {
              cont.online = false;
              if (cont.seen) {
                cont.seen.when = new Date();
              } else {
                cont.seen = {
                  when: new Date()
                };
              }
            }
            break;
          case 'msg': // new message received
            cont._updateReceived(pres.seq, pres.act);
            break;
          case 'upd': // desc updated
            // Request updated subscription.
            this.getMeta(this.startMetaQuery().withLaterOneSub(pres.src).build());
            break;
          case 'acs': // access mode changed
            if (cont.acs) {
              cont.acs.updateAll(pres.dacs);
            } else {
              cont.acs = new AccessMode().updateAll(pres.dacs);
            }
            cont.touched = new Date();
            break;
          case 'ua':
            // user agent changed.
            cont.seen = {
              when: new Date(),
              ua: pres.ua
            };
            break;
          case 'recv':
            // user's other session marked some messges as received.
            pres.seq = pres.seq | 0;
            cont.recv = cont.recv ? Math.max(cont.recv, pres.seq) : pres.seq;
            break;
          case 'read':
            // user's other session marked some messages as read.
            pres.seq = pres.seq | 0;
            cont.read = cont.read ? Math.max(cont.read, pres.seq) : pres.seq;
            cont.recv = cont.recv ? Math.max(cont.read, cont.recv) : cont.recv;
            cont.unread = cont.seq - cont.read;
            break;
          case 'gone':
            // topic deleted or unsubscribed from.
            this._tinode.cacheDel('topic', pres.src);
            this._tinode._db.remTopic(pres.src);
            break;
          case 'del':
            // Update topic.del value.
            break;
          default:
            this._tinode.logger("INFO: Unsupported presence update in 'me'", pres.what);
        }

        this._refreshContact(pres.what, cont);
      } else {
        if (pres.what == 'acs') {
          // New subscriptions and deleted/banned subscriptions have full
          // access mode (no + or - in the dacs string). Changes to known subscriptions are sent as
          // deltas, but they should not happen here.
          const acs = new AccessMode(pres.dacs);
          if (!acs || acs.mode == AccessMode._INVALID) {
            this._tinode.logger("ERROR: Invalid access mode update", pres.src, pres.dacs);
            return;
          } else if (acs.mode == AccessMode._NONE) {
            this._tinode.logger("WARNING: Removing non-existent subscription", pres.src, pres.dacs);
            return;
          } else {
            // New subscription. Send request for the full description.
            // Using .withOneSub (not .withLaterOneSub) to make sure IfModifiedSince is not set.
            this.getMeta(this.startMetaQuery().withOneSub(undefined, pres.src).build());
            // Create a dummy entry to catch online status update.
            const dummy = this._tinode.getTopic(pres.src);
            dummy.touched = new Date();
            dummy.topic = pres.src;
            dummy.online = false;
            dummy.acs = acs;
            this._tinode.attachCacheToTopic(dummy);
            dummy._cachePutSelf();
            this._db.updTopic(dummy);
          }
        } else if (pres.what == 'tags') {
          this.getMeta(this.startMetaQuery().withTags().build());
        }
      }

      if (this.onPres) {
        this.onPres(pres);
      }
    },
    enumerable: true,
    configurable: true
  },

  // Contact is updated, execute callbacks.
  _refreshContact: {
    value: function(what, cont) {
      if (this.onContactUpdate) {
        this.onContactUpdate(what, cont);
      }
    },
    enumerable: true,
    configurable: true
  },

  /**
   * Publishing to TopicMe is not supported. {@link Topic#publish} is overriden and thows an {Error} if called.
   * @memberof Tinode.TopicMe#
   * @throws {Error} Always throws an error.
   */
  publish: {
    value: function() {
      return Promise.reject(new Error("Publishing to 'me' is not supported"));
    },
    enumerable: true,
    configurable: true
  },

  /**
   * Delete validation credential.
   * @memberof Tinode.TopicMe#
   *
   * @param {string} topic - Name of the topic to delete
   * @param {string} user - User ID to remove.
   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
   */
  delCredential: {
    value: function(method, value) {
      if (!this._subscribed) {
        return Promise.reject(new Error("Cannot delete credential in inactive 'me' topic"));
      }
      // Send {del} message, return promise
      return this._tinode.delCredential(method, value).then((ctrl) => {
        // Remove deleted credential from the cache.
        const index = this._credentials.findIndex((el) => {
          return el.meth == method && el.val == value;
        });
        if (index > -1) {
          this._credentials.splice(index, 1);
        }
        // Notify listeners
        if (this.onCredsUpdated) {
          this.onCredsUpdated(this._credentials);
        }
        return ctrl;
      });

    },
    enumerable: true,
    configurable: true
  },

  /**
   * @callback contactFilter
   * @param {Object} contact to check for inclusion.
   * @returns {boolean} <code>true</code> if contact should be processed, <code>false</code> to exclude it.
   */
  /**
   * Iterate over cached contacts.
   *
   * @function
   * @memberof Tinode.TopicMe#
   * @param {TopicMe.ContactCallback} callback - Callback to call for each contact.
   * @param {contactFilter=} filter - Optionally filter contacts; include all if filter is false-ish, otherwise
   *      include those for which filter returns true-ish.
   * @param {Object=} context - Context to use for calling the `callback`, i.e. the value of `this` inside the callback.
   */
  contacts: {
    value: function(callback, filter, context) {
      this._tinode.cacheMap('topic', (c, idx) => {
        if (c.isCommType() && (!filter || filter(c))) {
          callback.call(context, c, idx);
        }
      });
    },
    enumerable: true,
    configurable: true
  },

  /**
   * Get a contact from cache.
   * @memberof Tinode.TopicMe#
   *
   * @param {string} name - Name of the contact to get, either a UID (for p2p topics) or a topic name.
   * @returns {Tinode.Contact} - Contact or `undefined`.
   */
  getContact: {
    value: function(name) {
      return this._tinode.cacheGet('topic', name);
    },
    enumerable: true,
    configurable: true
  },

  /**
   * Get access mode of a given contact from cache.
   * @memberof Tinode.TopicMe#
   *
   * @param {string} name - Name of the contact to get access mode for, either a UID (for p2p topics)
   *        or a topic name; if missing, access mode for the 'me' topic itself.
   * @returns {string} - access mode, such as `RWP`.
   */
  getAccessMode: {
    value: function(name) {
      if (name) {
        const cont = this._tinode.cacheGet('topic', name);
        return cont ? cont.acs : null;
      }
      return this.acs;
    },
    enumerable: true,
    configurable: true
  },

  /**
   * Check if contact is archived, i.e. contact.private.arch == true.
   * @memberof Tinode.TopicMe#
   *
   * @param {string} name - Name of the contact to check archived status, either a UID (for p2p topics) or a topic name.
   * @returns {boolean} - true if contact is archived, false otherwise.
   */
  isArchived: {
    value: function(name) {
      const cont = this._tinode.cacheGet('topic', name);
      return cont ? ((cont.private && cont.private.arch) ? true : false) : null;
    },
    enumerable: true,
    configurable: true
  },

  /**
   * @typedef Tinode.Credential
   * @memberof Tinode
   * @type Object
   * @property {string} meth - validation method such as 'email' or 'tel'.
   * @property {string} val - credential value, i.e. 'jdoe@example.com' or '+17025551234'
   * @property {boolean} done - true if credential is validated.
   */
  /**
   * Get the user's credentials: email, phone, etc.
   * @memberof Tinode.TopicMe#
   *
   * @returns {Tinode.Credential[]} - array of credentials.
   */
  getCredentials: {
    value: function() {
      return this._credentials;
    },
    enumerable: true,
    configurable: true
  }
});
TopicMe.prototype.constructor = TopicMe;

/**
 * @class TopicFnd - special case of {@link Tinode.Topic} for searching for
 * contacts and group topics.
 * @extends Tinode.Topic
 * @memberof Tinode
 *
 * @param {TopicFnd.Callbacks} callbacks - Callbacks to receive various events.
 */
var TopicFnd = function(callbacks) {
  Topic.call(this, TOPIC_FND, callbacks);
  // List of users and topics uid or topic_name -> Contact object)
  this._contacts = {};
};

// Inherit everyting from the generic Topic
TopicFnd.prototype = Object.create(Topic.prototype, {
  // Override the original Topic._processMetaSub
  _processMetaSub: {
    value: function(subs) {
      let updateCount = Object.getOwnPropertyNames(this._contacts).length;
      // Reset contact list.
      this._contacts = {};
      for (let idx in subs) {
        let sub = subs[idx];
        const indexBy = sub.topic ? sub.topic : sub.user;

        sub.updated = new Date(sub.updated);
        if (sub.seen && sub.seen.when) {
          sub.seen.when = new Date(sub.seen.when);
        }

        sub = mergeToCache(this._contacts, indexBy, sub);
        updateCount++;

        if (this.onMetaSub) {
          this.onMetaSub(sub);
        }
      }

      if (updateCount > 0 && this.onSubsUpdated) {
        this.onSubsUpdated(Object.keys(this._contacts));
      }
    },
    enumerable: true,
    configurable: true
  },

  /**
   * Publishing to TopicFnd is not supported. {@link Topic#publish} is overriden and thows an {Error} if called.
   * @memberof Tinode.TopicFnd#
   * @throws {Error} Always throws an error.
   */
  publish: {
    value: function() {
      return Promise.reject(new Error("Publishing to 'fnd' is not supported"));
    },
    enumerable: true,
    configurable: true
  },

  /**
   * setMeta to TopicFnd resets contact list in addition to sending the message.
   * @memberof Tinode.TopicFnd#
   * @param {Tinode.SetParams} params parameters to update.
   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.
   */
  setMeta: {
    value: function(params) {
      const instance = this;
      return Object.getPrototypeOf(TopicFnd.prototype).setMeta.call(this, params).then(function() {
        if (Object.keys(instance._contacts).length > 0) {
          instance._contacts = {};
          if (instance.onSubsUpdated) {
            instance.onSubsUpdated([]);
          }
        }
      });
    },
    enumerable: true,
    configurable: true
  },

  /**
   * Iterate over found contacts. If callback is undefined, use {@link this.onMetaSub}.
   * @function
   * @memberof Tinode.TopicFnd#
   * @param {TopicFnd.ContactCallback} callback - Callback to call for each contact.
   * @param {Object} context - Context to use for calling the `callback`, i.e. the value of `this` inside the callback.
   */
  contacts: {
    value: function(callback, context) {
      const cb = (callback || this.onMetaSub);
      if (cb) {
        for (let idx in this._contacts) {
          cb.call(context, this._contacts[idx], idx, this._contacts);
        }
      }
    },
    enumerable: true,
    configurable: true
  }
});
TopicFnd.prototype.constructor = TopicFnd;

/**
 * @class Message - definition a communication message.
 * Work in progress.
 * @memberof Tinode
 *
 * @param {string} topic_ - name of the topic the message belongs to.
 * @param {string | Drafty} content_ - message contant.
 */
var Message = function(topic_, content_) {
  this.status = Message.STATUS_NONE;
  this.topic = topic_;
  this.content = content_;
}

Message.STATUS_NONE = MESSAGE_STATUS_NONE;
Message.STATUS_QUEUED = MESSAGE_STATUS_QUEUED;
Message.STATUS_SENDING = MESSAGE_STATUS_SENDING;
Message.STATUS_FAILED = MESSAGE_STATUS_FAILED;
Message.STATUS_SENT = MESSAGE_STATUS_SENT;
Message.STATUS_RECEIVED = MESSAGE_STATUS_RECEIVED;
Message.STATUS_READ = MESSAGE_STATUS_READ;
Message.STATUS_TO_ME = MESSAGE_STATUS_TO_ME;

Message.prototype = {
  /**
   * Convert message object to {pub} packet.
   */
  toJSON: function() {

  },
  /**
   * Parse JSON into message.
   */
  fromJSON: function(json) {

  }
}
Message.prototype.constructor = Message;

if (typeof module != 'undefined') {
  module.exports = Tinode;
  module.exports.Drafty = Drafty;
  module.exports.AccessMode = AccessMode;
}

}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"../version.json":10,"./access-mode.js":1,"./cbuffer.js":2,"./connection.js":3,"./db.js":4,"./drafty.js":5,"./large-file.js":6,"./meta-builder.js":7,"./utils.js":9}],9:[function(require,module,exports){
/**
 * @file Utilities used in multiple places.
 *
 * @copyright 2015-2021 Tinode
 * @summary Javascript bindings for Tinode.
 * @license Apache 2.0
 * @version 0.17
 */
'use strict';

const AccessMode = require('./access-mode.js');

// Attempt to convert date strings to objects.
function jsonParseHelper(key, val) {
  // Convert string timestamps with optional milliseconds to Date
  // 2015-09-02T01:45:43[.123]Z
  if (key === 'ts' && typeof val === 'string' && val.length >= 20 && val.length <= 24) {
    const date = new Date(val);
    if (!isNaN(date)) {
      return date;
    }
  } else if (key === 'acs' && typeof val === 'object') {
    return new AccessMode(val);
  }
  return val;
}


if (typeof module != 'undefined') {
  module.exports.jsonParseHelper = jsonParseHelper;
}

},{"./access-mode.js":1}],10:[function(require,module,exports){
module.exports={"version": "0.18.0-alpha1"}

},{}]},{},[8])(8)
});

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","src/access-mode.js","src/cbuffer.js","src/connection.js","src/db.js","src/drafty.js","src/large-file.js","src/meta-builder.js","src/tinode.js","src/utils.js","version.json"],"names":[],"mappings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xcA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrhBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9lBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1pDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC/PA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC9+IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/**\n * @file Access control model.\n *\n * @copyright 2015-2021 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.17\n */\n'use strict';\n\n// NOTE TO DEVELOPERS:\n// Localizable strings should be double quoted \"строка на другом языке\",\n// non-localizable strings should be single quoted 'non-localized'.\n\n/**\n * Helper class for handling access mode.\n *\n * @class AccessMode\n * @memberof Tinode\n *\n * @param {AccessMode|Object=} acs - AccessMode to copy or access mode object received from the server.\n */\nconst AccessMode = function(acs) {\n  if (acs) {\n    this.given = typeof acs.given == 'number' ? acs.given : AccessMode.decode(acs.given);\n    this.want = typeof acs.want == 'number' ? acs.want : AccessMode.decode(acs.want);\n    this.mode = acs.mode ? (typeof acs.mode == 'number' ? acs.mode : AccessMode.decode(acs.mode)) :\n      (this.given & this.want);\n  }\n};\n\nAccessMode._NONE = 0x00;\nAccessMode._JOIN = 0x01;\nAccessMode._READ = 0x02;\nAccessMode._WRITE = 0x04;\nAccessMode._PRES = 0x08;\nAccessMode._APPROVE = 0x10;\nAccessMode._SHARE = 0x20;\nAccessMode._DELETE = 0x40;\nAccessMode._OWNER = 0x80;\n\nAccessMode._BITMASK = AccessMode._JOIN | AccessMode._READ | AccessMode._WRITE | AccessMode._PRES |\n  AccessMode._APPROVE | AccessMode._SHARE | AccessMode._DELETE | AccessMode._OWNER;\nAccessMode._INVALID = 0x100000;\n\nAccessMode._checkFlag = function(val, side, flag) {\n  side = side || 'mode';\n  if (['given', 'want', 'mode'].includes(side)) {\n    return ((val[side] & flag) != 0);\n  }\n  throw new Error(`Invalid AccessMode component '${side}'`);\n}\n\n/**\n * Parse string into an access mode value.\n * @memberof Tinode.AccessMode\n * @static\n *\n * @param {string | Number} mode - either a String representation of the access mode to parse or a set of bits to assign.\n * @returns {number} - Access mode as a numeric value.\n */\nAccessMode.decode = function(str) {\n  if (!str) {\n    return null;\n  } else if (typeof str == 'number') {\n    return str & AccessMode._BITMASK;\n  } else if (str === 'N' || str === 'n') {\n    return AccessMode._NONE;\n  }\n\n  const bitmask = {\n    'J': AccessMode._JOIN,\n    'R': AccessMode._READ,\n    'W': AccessMode._WRITE,\n    'P': AccessMode._PRES,\n    'A': AccessMode._APPROVE,\n    'S': AccessMode._SHARE,\n    'D': AccessMode._DELETE,\n    'O': AccessMode._OWNER\n  };\n\n  let m0 = AccessMode._NONE;\n\n  for (let i = 0; i < str.length; i++) {\n    const bit = bitmask[str.charAt(i).toUpperCase()];\n    if (!bit) {\n      // Unrecognized bit, skip.\n      continue;\n    }\n    m0 |= bit;\n  }\n  return m0;\n};\n\n/**\n * Convert numeric representation of the access mode into a string.\n *\n * @memberof Tinode.AccessMode\n * @static\n *\n * @param {number} val - access mode value to convert to a string.\n * @returns {string} - Access mode as a string.\n */\nAccessMode.encode = function(val) {\n  if (val === null || val === AccessMode._INVALID) {\n    return null;\n  } else if (val === AccessMode._NONE) {\n    return 'N';\n  }\n\n  const bitmask = ['J', 'R', 'W', 'P', 'A', 'S', 'D', 'O'];\n  let res = '';\n  for (let i = 0; i < bitmask.length; i++) {\n    if ((val & (1 << i)) != 0) {\n      res = res + bitmask[i];\n    }\n  }\n  return res;\n};\n\n/**\n * Update numeric representation of access mode with the new value. The value\n * is one of the following:\n *  - a string starting with <code>'+'</code> or <code>'-'</code> then the bits to add or remove, e.g. <code>'+R-W'</code> or <code>'-PS'</code>.\n *  - a new value of access mode\n *\n * @memberof Tinode.AccessMode\n * @static\n *\n * @param {number} val - access mode value to update.\n * @param {string} upd - update to apply to val.\n * @returns {number} - updated access mode.\n */\nAccessMode.update = function(val, upd) {\n  if (!upd || typeof upd != 'string') {\n    return val;\n  }\n\n  let action = upd.charAt(0);\n  if (action == '+' || action == '-') {\n    let val0 = val;\n    // Split delta-string like '+ABC-DEF+Z' into an array of parts including + and -.\n    const parts = upd.split(/([-+])/);\n    // Starting iteration from 1 because String.split() creates an array with the first empty element.\n    // Iterating by 2 because we parse pairs +/- then data.\n    for (let i = 1; i < parts.length - 1; i += 2) {\n      action = parts[i];\n      const m0 = AccessMode.decode(parts[i + 1]);\n      if (m0 == AccessMode._INVALID) {\n        return val;\n      }\n      if (m0 == null) {\n        continue;\n      }\n      if (action === '+') {\n        val0 |= m0;\n      } else if (action === '-') {\n        val0 &= ~m0;\n      }\n    }\n    val = val0;\n  } else {\n    // The string is an explicit new value 'ABC' rather than delta.\n    const val0 = AccessMode.decode(upd);\n    if (val0 != AccessMode._INVALID) {\n      val = val0;\n    }\n  }\n\n  return val;\n};\n\n/**\n * Bits present in a1 but missing in a2.\n *\n * @static\n * @memberof Tinode\n *\n * @param {number | string} a1 - access mode to subtract from.\n * @param {number | string} a2 - access mode to subtract.\n * @returns {number} access mode with bits present in <code>a1</code> but missing in <code>a2</code>.\n */\nAccessMode.diff = function(a1, a2) {\n  a1 = AccessMode.decode(a1);\n  a2 = AccessMode.decode(a2);\n\n  if (a1 == AccessMode._INVALID || a2 == AccessMode._INVALID) {\n    return AccessMode._INVALID;\n  }\n  return a1 & ~a2;\n};\n\n/**\n * AccessMode is a class representing topic access mode.\n *\n * @memberof Tinode\n * @class AccessMode\n */\nAccessMode.prototype = {\n  /**\n   * Custom formatter\n   */\n  toString: function() {\n    return '{\"mode\": \"' + AccessMode.encode(this.mode) +\n      '\", \"given\": \"' + AccessMode.encode(this.given) +\n      '\", \"want\": \"' + AccessMode.encode(this.want) + '\"}';\n  },\n  /**\n   * Converts numeric values to strings.\n   */\n  jsonHelper: function() {\n    return {\n      mode: AccessMode.encode(this.mode),\n      given: AccessMode.encode(this.given),\n      want: AccessMode.encode(this.want)\n    };\n  },\n  /**\n   * Assign value to 'mode'.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string | Number} m - either a string representation of the access mode or a set of bits.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  setMode: function(m) {\n    this.mode = AccessMode.decode(m);\n    return this;\n  },\n  /**\n   * Update <code>mode</code> value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string} u - string representation of the changes to apply to access mode.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  updateMode: function(u) {\n    this.mode = AccessMode.update(this.mode, u);\n    return this;\n  },\n  /**\n   * Get <code>mode</code> value as a string.\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} - <code>mode</code> value.\n   */\n  getMode: function() {\n    return AccessMode.encode(this.mode);\n  },\n\n  /**\n   * Assign <code>given</code>  value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string | Number} g - either a string representation of the access mode or a set of bits.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  setGiven: function(g) {\n    this.given = AccessMode.decode(g);\n    return this;\n  },\n  /**\n   * Update 'given' value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string} u - string representation of the changes to apply to access mode.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  updateGiven: function(u) {\n    this.given = AccessMode.update(this.given, u);\n    return this;\n  },\n  /**\n   * Get 'given' value as a string.\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} - <b>given</b> value.\n   */\n  getGiven: function() {\n    return AccessMode.encode(this.given);\n  },\n\n  /**\n   * Assign 'want' value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string | Number} w - either a string representation of the access mode or a set of bits.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  setWant: function(w) {\n    this.want = AccessMode.decode(w);\n    return this;\n  },\n  /**\n   * Update 'want' value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string} u - string representation of the changes to apply to access mode.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  updateWant: function(u) {\n    this.want = AccessMode.update(this.want, u);\n    return this;\n  },\n  /**\n   * Get 'want' value as a string.\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} - <b>want</b> value.\n   */\n  getWant: function() {\n    return AccessMode.encode(this.want);\n  },\n\n  /**\n   * Get permissions present in 'want' but missing in 'given'.\n   * Inverse of {@link Tinode.AccessMode#getExcessive}\n   *\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} permissions present in <b>want</b> but missing in <b>given</b>.\n   */\n  getMissing: function() {\n    return AccessMode.encode(this.want & ~this.given);\n  },\n\n  /**\n   * Get permissions present in 'given' but missing in 'want'.\n   * Inverse of {@link Tinode.AccessMode#getMissing}\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} permissions present in <b>given</b> but missing in <b>want</b>.\n   */\n  getExcessive: function() {\n    return AccessMode.encode(this.given & ~this.want);\n  },\n\n  /**\n   * Update 'want', 'give', and 'mode' values.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {AccessMode} val - new access mode value.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  updateAll: function(val) {\n    if (val) {\n      this.updateGiven(val.given);\n      this.updateWant(val.want);\n      this.mode = this.given & this.want;\n    }\n    return this;\n  },\n\n  /**\n   * Check if Owner (O) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isOwner: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._OWNER);\n  },\n\n  /**\n   * Check if Presence (P) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isPresencer: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._PRES);\n  },\n\n  /**\n   * Check if Presence (P) flag is NOT set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isMuted: function(side) {\n    return !this.isPresencer(side);\n  },\n\n  /**\n   * Check if Join (J) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isJoiner: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._JOIN);\n  },\n\n  /**\n   * Check if Reader (R) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isReader: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._READ);\n  },\n\n  /**\n   * Check if Writer (W) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isWriter: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._WRITE);\n  },\n\n  /**\n   * Check if Approver (A) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isApprover: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._APPROVE);\n  },\n\n  /**\n   * Check if either one of Owner (O) or Approver (A) flags is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isAdmin: function(side) {\n    return this.isOwner(side) || this.isApprover(side);\n  },\n\n  /**\n   * Check if either one of Owner (O), Approver (A), or Sharer (S) flags is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isSharer: function(side) {\n    return this.isAdmin(side) || AccessMode._checkFlag(this, side, AccessMode._SHARE);\n  },\n\n  /**\n   * Check if Deleter (D) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isDeleter: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._DELETE);\n  }\n};\n\nif (typeof module != 'undefined') {\n  module.exports = AccessMode;\n}\n","/**\n * @file In-memory sorted cache of objects.\n *\n * @copyright 2015-2021 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.17\n */\n'use strict';\n\n/**\n * In-memory sorted cache of objects.\n *\n * @class CBuffer\n * @memberof Tinode\n * @protected\n *\n * @param {function} compare custom comparator of objects. Takes two parameters <code>a</code> and <code>b</code>;\n *    returns <code>-1</code> if <code>a < b</code>, <code>0</code> if <code>a == b</code>, <code>1</code> otherwise.\n * @param {boolean} unique enforce element uniqueness: when <code>true</code> replace existing element with a new\n *    one on conflict; when <code>false</code> keep both elements.\n */\nconst CBuffer = function(compare, unique) {\n  let buffer = [];\n\n  compare = compare || function(a, b) {\n    return a === b ? 0 : a < b ? -1 : 1;\n  };\n\n  function findNearest(elem, arr, exact) {\n    let start = 0;\n    let end = arr.length - 1;\n    let pivot = 0;\n    let diff = 0;\n    let found = false;\n\n    while (start <= end) {\n      pivot = (start + end) / 2 | 0;\n      diff = compare(arr[pivot], elem);\n      if (diff < 0) {\n        start = pivot + 1;\n      } else if (diff > 0) {\n        end = pivot - 1;\n      } else {\n        found = true;\n        break;\n      }\n    }\n    if (found) {\n      return {\n        idx: pivot,\n        exact: true\n      };\n    }\n    if (exact) {\n      return {\n        idx: -1\n      };\n    }\n    // Not exact - insertion point\n    return {\n      idx: diff < 0 ? pivot + 1 : pivot\n    };\n  }\n\n  // Insert element into a sorted array.\n  function insertSorted(elem, arr) {\n    const found = findNearest(elem, arr, false);\n    const count = (found.exact && unique) ? 1 : 0;\n    arr.splice(found.idx, count, elem);\n    return arr;\n  }\n\n  return {\n    /**\n     * Get an element at the given position.\n     * @memberof Tinode.CBuffer#\n     * @param {number} at - Position to fetch from.\n     * @returns {Object} Element at the given position or <code>undefined</code>.\n     */\n    getAt: function(at) {\n      return buffer[at];\n    },\n\n    /**\n     * Convenience method for getting the element from the end of the buffer.\n     * @memberof Tinode.CBuffer#\n     * @param {number} at - position to fetch from, counting from the end;\n     *    <code>undefined</code> or <code>null</code>  mean \"last\".\n     * @returns {Object} The last element in the buffer or <code>undefined</code> if buffer is empty.\n     */\n    getLast: function(at) {\n      at |= 0;\n      return buffer.length > at ? buffer[buffer.length - 1 - at] : undefined;\n    },\n\n    /**\n     * Add new element(s) to the buffer. Variadic: takes one or more arguments. If an array is passed as a single\n     * argument, its elements are inserted individually.\n     * @memberof Tinode.CBuffer#\n     *\n     * @param {...Object|Array} - One or more objects to insert.\n     */\n    put: function() {\n      let insert;\n      // inspect arguments: if array, insert its elements, if one or more non-array arguments, insert them one by one\n      if (arguments.length == 1 && Array.isArray(arguments[0])) {\n        insert = arguments[0];\n      } else {\n        insert = arguments;\n      }\n      for (let idx in insert) {\n        insertSorted(insert[idx], buffer);\n      }\n    },\n\n    /**\n     * Remove element at the given position.\n     * @memberof Tinode.CBuffer#\n     * @param {number} at - Position to delete at.\n     * @returns {Object} Element at the given position or <code>undefined</code>.\n     */\n    delAt: function(at) {\n      let r = buffer.splice(at, 1);\n      if (r && r.length > 0) {\n        return r[0];\n      }\n      return undefined;\n    },\n\n    /**\n     * Remove elements between two positions.\n     * @memberof Tinode.CBuffer#\n     * @param {number} since - Position to delete from (inclusive).\n     * @param {number} before - Position to delete to (exclusive).\n     *\n     * @returns {Array} array of removed elements (could be zero length).\n     */\n    delRange: function(since, before) {\n      return buffer.splice(since, before - since);\n    },\n\n    /**\n     * Return the number of elements the buffer holds.\n     * @memberof Tinode.CBuffer#\n     * @return {number} Number of elements in the buffer.\n     */\n    length: function() {\n      return buffer.length;\n    },\n\n    /**\n     * Reset the buffer discarding all elements\n     * @memberof Tinode.CBuffer#\n     */\n    reset: function() {\n      buffer = [];\n    },\n\n    /**\n     * Callback for iterating contents of buffer. See {@link Tinode.CBuffer#forEach}.\n     * @callback ForEachCallbackType\n     * @memberof Tinode.CBuffer#\n     * @param {Object} elem - Element of the buffer.\n     * @param {number} index - Index of the current element.\n     */\n\n    /**\n     * Apply given <code>callback</code> to all elements of the buffer.\n     * @memberof Tinode.CBuffer#\n     *\n     * @param {Tinode.ForEachCallbackType} callback - Function to call for each element.\n     * @param {number} startIdx - Optional index to start iterating from (inclusive).\n     * @param {number} beforeIdx - Optional index to stop iterating before (exclusive).\n     * @param {Object} context - calling context (i.e. value of <code>this</code> in callback)\n     */\n    forEach: function(callback, startIdx, beforeIdx, context) {\n      startIdx = startIdx | 0;\n      beforeIdx = beforeIdx || buffer.length;\n      for (let i = startIdx; i < beforeIdx; i++) {\n        callback.call(context, buffer[i], i);\n      }\n    },\n\n    /**\n     * Find element in buffer using buffer's comparison function.\n     * @memberof Tinode.CBuffer#\n     *\n     * @param {Object} elem - element to find.\n     * @param {boolean=} nearest - when true and exact match is not found, return the nearest element (insertion point).\n     * @returns {number} index of the element in the buffer or -1.\n     */\n    find: function(elem, nearest) {\n      const {\n        idx\n      } = findNearest(elem, buffer, !nearest);\n      return idx;\n    }\n  }\n}\n\nif (typeof module != 'undefined') {\n  module.exports = CBuffer;\n}\n","/**\n * @file Abstraction layer for websocket and long polling connections.\n * See <a href=\"https://github.com/tinode/webapp\">https://github.com/tinode/webapp</a> for real-life usage.\n *\n * @copyright 2015-2021 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.17\n */\n'use strict';\n\nconst {\n  jsonParseHelper\n} = require('./utils.js');\n\nlet WebSocketProvider;\nlet XHRProvider;\n\n// Error code to return in case of a network problem.\nconst NETWORK_ERROR = 503;\nconst NETWORK_ERROR_TEXT = \"Connection failed\";\n\n// Error code to return when user disconnected from server.\nconst NETWORK_USER = 418;\nconst NETWORK_USER_TEXT = \"Disconnected by client\";\n\n// Helper function for creating an endpoint URL.\nfunction makeBaseUrl(host, protocol, version, apiKey) {\n  let url = null;\n\n  if (['http', 'https', 'ws', 'wss'].includes(protocol)) {\n    url = `${protocol}://${host}`;\n    if (url.charAt(url.length - 1) !== '/') {\n      url += '/';\n    }\n    url += 'v' + version + '/channels';\n    if (['http', 'https'].includes(protocol)) {\n      // Long polling endpoint ends with \"lp\", i.e.\n      // '/v0/channels/lp' vs just '/v0/channels' for ws\n      url += '/lp';\n    }\n    url += '?apikey=' + apiKey;\n  }\n\n  return url;\n}\n\n/**\n * An abstraction for a websocket or a long polling connection.\n *\n * @class Connection\n * @memberof Tinode\n\n * @param {Object} config - configuration parameters.\n * @param {string} config.host - Host name and optional port number to connect to.\n * @param {string} config.apiKey - API key generated by <code>keygen</code>.\n * @param {string} config.transport - Network transport to use, either <code>\"ws\"<code>/<code>\"wss\"</code> for websocket or\n *      <code>lp</code> for long polling.\n * @param {boolean} config.secure - Use Secure WebSocket if <code>true</code>.\n * @param {string} version_ - Major value of the protocol version, e.g. '0' in '0.17.1'.\n * @param {boolean} autoreconnect_ - If connection is lost, try to reconnect automatically.\n */\n// config.host, PROTOCOL_VERSION, config.apiKey, config.transport, config.secure, true\nconst Connection = function(config, version_, autoreconnect_) {\n  const host = config.host;\n  const secure = config.secure;\n  const apiKey = config.apiKey;\n\n  const version = version_;\n  const autoreconnect = autoreconnect_;\n\n  // Settings for exponential backoff\n  const _BOFF_BASE = 2000; // 2000 milliseconds, minimum delay between reconnects\n  const _BOFF_MAX_ITER = 10; // Maximum delay between reconnects 2^10 * 2000 ~ 34 minutes\n  const _BOFF_JITTER = 0.3; // Add random delay\n\n  let _boffTimer = null;\n  let _boffIteration = 0;\n  let _boffClosed = false; // Indicator if the socket was manually closed - don't autoreconnect if true.\n\n  const log = (text, ...args) => {\n    if (Connection.logger) {\n      Connection.logger(text, ...args);\n    }\n  }\n\n  // Backoff implementation - reconnect after a timeout.\n  function boffReconnect() {\n    // Clear timer\n    clearTimeout(_boffTimer);\n    // Calculate when to fire the reconnect attempt\n    const timeout = _BOFF_BASE * (Math.pow(2, _boffIteration) * (1.0 + _BOFF_JITTER * Math.random()));\n    // Update iteration counter for future use\n    _boffIteration = (_boffIteration >= _BOFF_MAX_ITER ? _boffIteration : _boffIteration + 1);\n    if (this.onAutoreconnectIteration) {\n      this.onAutoreconnectIteration(timeout);\n    }\n\n    _boffTimer = setTimeout(() => {\n      log(`Reconnecting, iter=${_boffIteration}, timeout=${timeout}`);\n      // Maybe the socket was closed while we waited for the timer?\n      if (!_boffClosed) {\n        const prom = this.connect();\n        if (this.onAutoreconnectIteration) {\n          this.onAutoreconnectIteration(0, prom);\n        } else {\n          // Suppress error if it's not used.\n          prom.catch(() => {\n            /* do nothing */\n          });\n        }\n      } else if (this.onAutoreconnectIteration) {\n        this.onAutoreconnectIteration(-1);\n      }\n    }, timeout);\n  }\n\n  // Terminate auto-reconnect process.\n  function boffStop() {\n    clearTimeout(_boffTimer);\n    _boffTimer = null;\n  }\n\n  // Reset auto-reconnect iteration counter.\n  function boffReset() {\n    _boffIteration = 0;\n  }\n\n  // Initialization for Websocket\n  function init_ws(instance) {\n    let _socket = null;\n\n    /**\n     * Initiate a new connection\n     * @memberof Tinode.Connection#\n     * @param {string} host_ Host name to connect to; if <code>null</code> the old host name will be used.\n     * @param {boolean} force Force new connection even if one already exists.\n     * @return {Promise} Promise resolved/rejected when the connection call completes, resolution is called without\n     *  parameters, rejection passes the {Error} as parameter.\n     */\n    instance.connect = function(host_, force) {\n      _boffClosed = false;\n\n      if (_socket) {\n        if (!force && _socket.readyState == _socket.OPEN) {\n          return Promise.resolve();\n        }\n        _socket.close();\n        _socket = null;\n      }\n\n      if (host_) {\n        host = host_;\n      }\n\n      return new Promise(function(resolve, reject) {\n        const url = makeBaseUrl(host, secure ? 'wss' : 'ws', version, apiKey);\n\n        log(\"Connecting to: \", url);\n\n        // It throws when the server is not accessible but the exception cannot be caught:\n        // https://stackoverflow.com/questions/31002592/javascript-doesnt-catch-error-in-websocket-instantiation/31003057\n        const conn = new WebSocketProvider(url);\n\n        conn.onerror = function(err) {\n          reject(err);\n        }\n\n        conn.onopen = function(evt) {\n          if (autoreconnect) {\n            boffStop();\n          }\n\n          if (instance.onOpen) {\n            instance.onOpen();\n          }\n\n          resolve();\n        }\n\n        conn.onclose = function(evt) {\n          _socket = null;\n\n          if (instance.onDisconnect) {\n            const code = _boffClosed ? NETWORK_USER : NETWORK_ERROR;\n            instance.onDisconnect(new Error(_boffClosed ? NETWORK_USER_TEXT : NETWORK_ERROR_TEXT +\n              ' (' + code + ')'), code);\n          }\n\n          if (!_boffClosed && autoreconnect) {\n            boffReconnect.call(instance);\n          }\n        }\n\n        conn.onmessage = function(evt) {\n          if (instance.onMessage) {\n            instance.onMessage(evt.data);\n          }\n        }\n        _socket = conn;\n      });\n    }\n\n    /**\n     * Try to restore a network connection, also reset backoff.\n     * @memberof Tinode.Connection#\n     *\n     * @param {boolean} force - reconnect even if there is a live connection already.\n     */\n    instance.reconnect = function(force) {\n      boffStop();\n      instance.connect(null, force);\n    }\n\n    /**\n     * Terminate the network connection\n     * @memberof Tinode.Connection#\n     */\n    instance.disconnect = function() {\n      _boffClosed = true;\n      boffStop();\n\n      if (!_socket) {\n        return;\n      }\n      _socket.close();\n      _socket = null;\n    }\n\n    /**\n     * Send a string to the server.\n     * @memberof Tinode.Connection#\n     *\n     * @param {string} msg - String to send.\n     * @throws Throws an exception if the underlying connection is not live.\n     */\n    instance.sendText = function(msg) {\n      if (_socket && (_socket.readyState == _socket.OPEN)) {\n        _socket.send(msg);\n      } else {\n        throw new Error(\"Websocket is not connected\");\n      }\n    };\n\n    /**\n     * Check if socket is alive.\n     * @memberof Tinode.Connection#\n     * @returns {boolean} <code>true</code> if connection is live, <code>false</code> otherwise.\n     */\n    instance.isConnected = function() {\n      return (_socket && (_socket.readyState == _socket.OPEN));\n    }\n\n    /**\n     * Get the name of the current network transport.\n     * @memberof Tinode.Connection#\n     * @returns {string} name of the transport such as <code>\"ws\"</code> or <code>\"lp\"</code>.\n     */\n    instance.transport = function() {\n      return 'ws';\n    }\n\n    /**\n     * Send network probe to check if connection is indeed live.\n     * @memberof Tinode.Connection#\n     */\n    instance.probe = function() {\n      instance.sendText('1');\n    }\n  }\n\n  // Initialization for long polling.\n  function init_lp(instance) {\n    const XDR_UNSENT = 0; // Client has been created. open() not called yet.\n    const XDR_OPENED = 1; // open() has been called.\n    const XDR_HEADERS_RECEIVED = 2; // send() has been called, and headers and status are available.\n    const XDR_LOADING = 3; // Downloading; responseText holds partial data.\n    const XDR_DONE = 4; // The operation is complete.\n    // Fully composed endpoint URL, with API key & SID\n    let _lpURL = null;\n\n    let _poller = null;\n    let _sender = null;\n\n    function lp_sender(url_) {\n      const sender = new XHRProvider();\n      sender.onreadystatechange = function(evt) {\n        if (sender.readyState == XDR_DONE && sender.status >= 400) {\n          // Some sort of error response\n          throw new Error(`LP sender failed, ${sender.status}`);\n        }\n      }\n\n      sender.open('POST', url_, true);\n      return sender;\n    }\n\n    function lp_poller(url_, resolve, reject) {\n      let poller = new XHRProvider();\n      let promiseCompleted = false;\n\n      poller.onreadystatechange = function(evt) {\n\n        if (poller.readyState == XDR_DONE) {\n          if (poller.status == 201) { // 201 == HTTP.Created, get SID\n            let pkt = JSON.parse(poller.responseText, jsonParseHelper);\n            _lpURL = url_ + '&sid=' + pkt.ctrl.params.sid\n            poller = lp_poller(_lpURL);\n            poller.send(null)\n            if (instance.onOpen) {\n              instance.onOpen();\n            }\n\n            if (resolve) {\n              promiseCompleted = true;\n              resolve();\n            }\n\n            if (autoreconnect) {\n              boffStop();\n            }\n          } else if (poller.status < 400) { // 400 = HTTP.BadRequest\n            if (instance.onMessage) {\n              instance.onMessage(poller.responseText)\n            }\n            poller = lp_poller(_lpURL);\n            poller.send(null);\n          } else {\n            // Don't throw an error here, gracefully handle server errors\n            if (reject && !promiseCompleted) {\n              promiseCompleted = true;\n              reject(poller.responseText);\n            }\n            if (instance.onMessage && poller.responseText) {\n              instance.onMessage(poller.responseText);\n            }\n            if (instance.onDisconnect) {\n              const code = poller.status || (_boffClosed ? NETWORK_USER : NETWORK_ERROR);\n              const text = poller.responseText || (_boffClosed ? NETWORK_USER_TEXT : NETWORK_ERROR_TEXT);\n              instance.onDisconnect(new Error(text + ' (' + code + ')'), code);\n            }\n\n            // Polling has stopped. Indicate it by setting poller to null.\n            poller = null;\n            if (!_boffClosed && autoreconnect) {\n              boffReconnect.call(instance);\n            }\n          }\n        }\n      }\n      poller.open('GET', url_, true);\n      return poller;\n    }\n\n    instance.connect = function(host_, force) {\n      _boffClosed = false;\n\n      if (_poller) {\n        if (!force) {\n          return Promise.resolve();\n        }\n        _poller.onreadystatechange = undefined;\n        _poller.abort();\n        _poller = null;\n      }\n\n      if (host_) {\n        host = host_;\n      }\n\n      return new Promise(function(resolve, reject) {\n        const url = makeBaseUrl(host, secure ? 'https' : 'http', version, apiKey);\n        log(\"Connecting to:\", url);\n        _poller = lp_poller(url, resolve, reject);\n        _poller.send(null)\n      }).catch((err) => {\n        log(\"LP connection failed:\", err);\n      });\n    };\n\n    instance.reconnect = function(force) {\n      boffStop();\n      instance.connect(null, force);\n    };\n\n    instance.disconnect = function() {\n      _boffClosed = true;\n      boffStop();\n\n      if (_sender) {\n        _sender.onreadystatechange = undefined;\n        _sender.abort();\n        _sender = null;\n      }\n      if (_poller) {\n        _poller.onreadystatechange = undefined;\n        _poller.abort();\n        _poller = null;\n      }\n\n      if (instance.onDisconnect) {\n        instance.onDisconnect(new Error(NETWORK_USER_TEXT + ' (' + NETWORK_USER + ')'), NETWORK_USER);\n      }\n      // Ensure it's reconstructed\n      _lpURL = null;\n    }\n\n    instance.sendText = function(msg) {\n      _sender = lp_sender(_lpURL);\n      if (_sender && (_sender.readyState == 1)) { // 1 == OPENED\n        _sender.send(msg);\n      } else {\n        throw new Error(\"Long poller failed to connect\");\n      }\n    };\n\n    instance.isConnected = function() {\n      return (_poller && true);\n    }\n\n    instance.transport = function() {\n      return 'lp';\n    }\n\n    instance.probe = function() {\n      instance.sendText('1');\n    }\n  }\n\n  let initialized = false;\n  if (config.transport === 'lp') {\n    // explicit request to use long polling\n    init_lp(this);\n    initialized = true;\n  } else if (config.transport === 'ws') {\n    // explicit request to use web socket\n    // if websockets are not available, horrible things will happen\n    init_ws(this);\n    initialized = true;\n  }\n\n  if (!initialized) {\n    // Invalid or undefined network transport.\n    log(\"Unknown or invalid network transport. Running under Node? Call 'Tinode.setNetworkProviders()'.\");\n    throw new Error(\"Unknown or invalid network transport. Running under Node? Call 'Tinode.setNetworkProviders()'.\");\n  }\n\n  /**\n   * Reset autoreconnect counter to zero.\n   * @memberof Tinode.Connection#\n   */\n  this.backoffReset = function() {\n    boffReset();\n  }\n\n  // Callbacks:\n  /**\n   * A callback to pass incoming messages to. See {@link Tinode.Connection#onMessage}.\n   * @callback Tinode.Connection.OnMessage\n   * @memberof Tinode.Connection\n   * @param {string} message - Message to process.\n   */\n  /**\n   * A callback to pass incoming messages to.\n   * @type {Tinode.Connection.OnMessage}\n   * @memberof Tinode.Connection#\n   */\n  this.onMessage = undefined;\n\n  /**\n   * A callback for reporting a dropped connection.\n   * @type {function}\n   * @memberof Tinode.Connection#\n   */\n  this.onDisconnect = undefined;\n\n  /**\n   * A callback called when the connection is ready to be used for sending. For websockets it's socket open,\n   * for long polling it's <code>readyState=1</code> (OPENED)\n   * @type {function}\n   * @memberof Tinode.Connection#\n   */\n  this.onOpen = undefined;\n\n  /**\n   * A callback to notify of reconnection attempts. See {@link Tinode.Connection#onAutoreconnectIteration}.\n   * @memberof Tinode.Connection\n   * @callback AutoreconnectIterationType\n   * @param {string} timeout - time till the next reconnect attempt in milliseconds. <code>-1</code> means reconnect was skipped.\n   * @param {Promise} promise resolved or rejected when the reconnect attemp completes.\n   *\n   */\n  /**\n   * A callback to inform when the next attampt to reconnect will happen and to receive connection promise.\n   * @memberof Tinode.Connection#\n   * @type {Tinode.Connection.AutoreconnectIterationType}\n   */\n  this.onAutoreconnectIteration = undefined;\n\n  /**\n   * A callback to log events from Connection. See {@link Tinode.Connection#logger}.\n   * @memberof Tinode.Connection\n   * @callback LoggerCallbackType\n   * @param {string} event - Event to log.\n   */\n  /**\n   * A callback to report logging events.\n   * @memberof Tinode.Connection#\n   * @type {Tinode.Connection.LoggerCallbackType}\n   */\n  this.logger = undefined;\n};\n\n/**\n * To use Connection in a non browser context, supply WebSocket and XMLHttpRequest providers.\n * @static\n * @memberof Connection\n * @param wsProvider WebSocket provider, e.g. for nodeJS , <code>require('ws')</code>.\n * @param xhrProvider XMLHttpRequest provider, e.g. for node <code>require('xhr')</code>.\n */\nConnection.setNetworkProviders = function(wsProvider, xhrProvider) {\n  WebSocketProvider = wsProvider;\n  XHRProvider = xhrProvider;\n};\n\nConnection.NETWORK_ERROR = NETWORK_ERROR;\nConnection.NETWORK_ERROR_TEXT = NETWORK_ERROR_TEXT;\nConnection.NETWORK_USER = NETWORK_USER;\nConnection.NETWORK_USER_TEXT = NETWORK_USER_TEXT;\n\nif (typeof module != 'undefined') {\n  module.exports = Connection;\n}\n","/**\n * @file Helper methods for dealing with IndexedDB cache of messages, users, and topics.\n * See <a href=\"https://github.com/tinode/webapp\">https://github.com/tinode/webapp</a> for real-life usage.\n *\n * @copyright 2015-2021 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.17\n */\n'use strict';\n\n// NOTE TO DEVELOPERS:\n// Localizable strings should be double quoted \"строка на другом языке\",\n// non-localizable strings should be single quoted 'non-localized'.\n\nconst DB_VERSION = 1;\nconst DB_NAME = 'tinode-web';\n\nconst DB = function(onError, logger) {\n  onError = onError || function() {}\n  logger = logger || function() {}\n\n  // Instance of IndexDB.\n  let db = null;\n  // Indicator that the cache is disabled.\n  let disabled = false;\n\n  // Serializable topic fields.\n  const topic_fields = ['created', 'updated', 'deleted', 'read', 'recv', 'seq', 'clear', 'defacs',\n    'creds', 'public', 'trusted', 'private', 'touched'\n  ];\n\n  // Copy values from 'src' to 'dst'. Allocate dst if it's null or undefined.\n  function serializeTopic(dst, src) {\n    const res = dst || {\n      name: src.name\n    };\n    topic_fields.forEach((f) => {\n      if (src.hasOwnProperty(f)) {\n        res[f] = src[f];\n      }\n    });\n    if (Array.isArray(src._tags)) {\n      res.tags = src._tags;\n    }\n    if (src.acs) {\n      res.acs = src.getAccessMode().jsonHelper();\n    }\n    return res;\n  }\n\n  // Copy data from src to Topic object.\n  function deserializeTopic(topic, src) {\n    topic_fields.forEach((f) => {\n      if (src.hasOwnProperty(f)) {\n        topic[f] = src[f];\n      }\n    });\n    if (Array.isArray(src.tags)) {\n      topic._tags = src.tags;\n    }\n    if (src.acs) {\n      topic.setAccessMode(src.acs);\n    }\n    topic.seq |= 0;\n    topic.read |= 0;\n    topic.unread = Math.max(0, topic.seq - topic.read);\n  }\n\n  function serializeSubscription(dst, topicName, uid, sub) {\n    const fields = ['updated', 'mode', 'read', 'recv', 'clear', 'lastSeen', 'userAgent'];\n    const res = dst || {\n      topic: topicName,\n      uid: uid\n    };\n\n    fields.forEach((f) => {\n      if (sub.hasOwnProperty(f)) {\n        res[f] = sub[f];\n      }\n    });\n\n    return res;\n  }\n\n  function serializeMessage(dst, msg) {\n    // Serializable fields.\n    const fields = ['topic', 'seq', 'ts', '_status', 'from', 'head', 'content'];\n    const res = dst || {};\n    fields.forEach((f) => {\n      if (msg.hasOwnProperty(f)) {\n        res[f] = msg[f];\n      }\n    });\n    return res;\n  }\n\n  function mapObjects(source, callback, context) {\n    if (!db) {\n      return disabled ?\n        Promise.resolve([]) :\n        Promise.reject(new Error(\"not initialized\"));\n    }\n\n    return new Promise((resolve, reject) => {\n      const trx = db.transaction([source]);\n      trx.onerror = (event) => {\n        logger(\"PCache\", \"mapObjects\", source, event.target.error);\n        reject(event.target.error);\n      };\n      trx.objectStore(source).getAll().onsuccess = (event) => {\n        if (callback) {\n          event.target.result.forEach((topic) => {\n            callback.call(context, topic);\n          });\n        }\n        resolve(event.target.result);\n      };\n    });\n  }\n\n  return {\n    /**\n     * Initialize persistent cache: open or create/upgrade if needed.\n     * @returns {Promise} promise to be resolved/rejected when the DB is initialized.\n     */\n    initDatabase: function() {\n      return new Promise((resolve, reject) => {\n        // Open the database and initialize callbacks.\n        const req = indexedDB.open(DB_NAME, DB_VERSION);\n        req.onsuccess = (event) => {\n          db = event.target.result;\n          disabled = false;\n          resolve(db);\n        };\n        req.onerror = (event) => {\n          logger(\"PCache\", \"failed to initialize\", event);\n          reject(event.target.error);\n          onError(event.target.error);\n        };\n        req.onupgradeneeded = function(event) {\n          db = event.target.result;\n\n          db.onerror = function(event) {\n            logger(\"PCache\", \"failed to create storage\", event);\n            onError(event.target.error);\n          };\n\n          // Individual object stores.\n\n          // Object store (table) for topics. The primary key is topic name.\n          db.createObjectStore('topic', {\n            keyPath: 'name'\n          });\n\n          // Users object store. UID is the primary key.\n          db.createObjectStore('user', {\n            keyPath: 'uid'\n          });\n\n          // Subscriptions object store topic <-> user. Topic name + UID is the primary key.\n          db.createObjectStore('subscription', {\n            keyPath: ['topic', 'uid']\n          });\n\n          // Messages object store. The primary key is topic name + seq.\n          db.createObjectStore('message', {\n            keyPath: ['topic', 'seq']\n          });\n        };\n      });\n    },\n\n    /**\n     * Delete persistent cache.\n     */\n    deleteDatabase: function() {\n      return new Promise((resolve, reject) => {\n        const req = indexedDB.deleteDatabase(DB_NAME);\n        req.onblocked = function(event) {\n          if (db) {\n            db.close();\n          }\n        };\n        req.onsuccess = (event) => {\n          db = null;\n          disabled = true;\n          resolve(true);\n        };\n        req.onerror = (event) => {\n          logger(\"PCache\", \"deleteDatabase\", event.target.error);\n          reject(event.target.error);\n        };\n      });\n    },\n\n    /**\n     * Check if persistent cache is ready for use.\n     * @memberOf DB\n     * @returns {boolean} <code>true</code> if cache is ready, <code>false</code> otherwise.\n     */\n    isReady: function() {\n      return !!db;\n    },\n\n    // Topics.\n    /**\n     * Save to cache or update topic in persistent cache.\n     * @memberOf DB\n     * @param {Topic} topic - topic to be added or updated.\n     * @returns {Promise} promise resolved/rejected on operation completion.\n     */\n    updTopic: function(topic) {\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve() :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['topic'], 'readwrite');\n        trx.oncomplete = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"updTopic\", event.target.error);\n          reject(event.target.error);\n        };\n        const req = trx.objectStore('topic').get(topic.name);\n        req.onsuccess = (event) => {\n          trx.objectStore('topic').put(serializeTopic(req.result, topic));\n          trx.commit();\n        };\n      });\n    },\n\n    /**\n     * Remove topic from persistent cache.\n     * @memberOf DB\n     * @param {string} name - name of the topic to remove from database.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    remTopic: function(name) {\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve() :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['topic', 'subscription', 'message'], 'readwrite');\n        trx.oncomplete = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"remTopic\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('topic').delete(IDBKeyRange.only(name));\n        trx.objectStore('subscription').delete(IDBKeyRange.bound([name, '-'], [name, '~']));\n        trx.objectStore('message').delete(IDBKeyRange.bound([name, 0], [name, Number.MAX_SAFE_INTEGER]));\n        trx.commit();\n      });\n    },\n\n    /**\n     * Execute a callback for each stored topic.\n     * @memberOf DB\n     * @param {function} callback - function to call for each topic.\n     * @param {Object} context - the value or <code>this</code> inside the callback.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    mapTopics: function(callback, context) {\n      return mapObjects('topic', callback, context);\n    },\n\n    /**\n     * Copy data from serialized object to topic.\n     * @memberOf DB\n     * @param {Topic} topic - target to deserialize to.\n     * @param {Object} src - serialized data to copy from.\n     */\n    deserializeTopic: function(topic, src) {\n      deserializeTopic(topic, src);\n    },\n\n    // Users.\n    /**\n     * Add or update user object in the persistent cache.\n     * @memberOf DB\n     * @param {string} uid - ID of the user to save or update.\n     * @param {Object} pub - user's <code>public</code> information.\n     * @returns {Promise} promise resolved/rejected on operation completion.\n     */\n    updUser: function(uid, pub) {\n      if (arguments.length < 2 || pub === undefined) {\n        // No point inupdating user with invalid data.\n        return;\n      }\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve() :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['user'], 'readwrite');\n        trx.oncomplete = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"updUser\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('user').put({\n          uid: uid,\n          public: pub\n        });\n        trx.commit();\n      });\n    },\n\n    /**\n     * Remove user from persistent cache.\n     * @memberOf DB\n     * @param {string} uid - ID of the user to remove from the cache.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    remUser: function(uid) {\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve() :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['user'], 'readwrite');\n        trx.oncomplete = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"remUser\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('user').delete(IDBKeyRange.only(uid));\n        trx.commit();\n      });\n    },\n\n    /**\n     * Execute a callback for each stored user.\n     * @memberOf DB\n     * @param {function} callback - function to call for each topic.\n     * @param {Object} context - the value or <code>this</code> inside the callback.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    mapUsers: function(callback, context) {\n      return mapObjects('user', callback, context);\n    },\n\n    /**\n     * Read a single user from persistent cache.\n     * @memberOf DB\n     * @param {string} uid - ID of the user to fetch from cache.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    getUser: function(uid) {\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve() :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['user']);\n        trx.oncomplete = (event) => {\n          const user = event.target.result;\n          resolve({\n            user: user.uid,\n            public: user.public\n          });\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"getUser\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('user').get(uid);\n      });\n    },\n\n    // Subscriptions.\n\n    /**\n     * Add or update subscription in persistent cache.\n     * @memberOf DB\n     * @param {string} topicName - name of the topic which owns the message.\n     * @param {string} uid - ID of the subscribed user.\n     * @param {Object} sub - subscription to save.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    updSubscription: function(topicName, uid, sub) {\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve() :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['subscription'], 'readwrite');\n        trx.oncomplete = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"updSubscription\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('subscription').get([topicName, uid]).onsuccess = (event) => {\n          trx.objectStore('subscription').put(serializeSubscription(event.target.result, topicName, uid, sub));\n          trx.commit();\n        };\n      });\n    },\n\n    /**\n     * Execute a callback for each cached subscription in a given topic.\n     * @memberOf DB\n     * @param {string} topicName - name of the topic which owns the subscriptions.\n     * @param {function} callback - function to call for each subscription.\n     * @param {Object} context - the value or <code>this</code> inside the callback.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    mapSubscriptions: function(topicName, callback, context) {\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve([]) :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['subscription']);\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"mapSubscriptions\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('subscription').getAll(IDBKeyRange.bound([topicName, '-'], [topicName, '~'])).onsuccess = (event) => {\n          if (callback) {\n            event.target.result.forEach((topic) => {\n              callback.call(context, topic);\n            });\n          }\n          resolve(event.target.result);\n        };\n      });\n    },\n\n    // Messages.\n\n    /**\n     * Save message to persistent cache.\n     * @memberOf DB\n     * @param {string} topicName - name of the topic which owns the message.\n     * @param {Object} msg - message to save.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    addMessage: function(msg) {\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve() :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['message'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"addMesssage\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('message').add(serializeMessage(null, msg));\n        trx.commit();\n      });\n    },\n\n    /**\n     * Update delivery status of a message stored in persistent cache.\n     * @memberOf DB\n     * @param {string} topicName - name of the topic which owns the message.\n     * @param {number} seq - ID of the message to update\n     * @param {number} status - new delivery status of the message.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    updMessageStatus: function(topicName, seq, status) {\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve() :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['message'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"updMessageStatus\", event.target.error);\n          reject(event.target.error);\n        };\n        const req = trx.objectStore('message').get(IDBKeyRange.only([topicName, seq]));\n        req.onsuccess = (event) => {\n          const src = req.result || event.target.result;\n          if (!src || src._status == status) {\n            trx.commit();\n            return;\n          }\n          trx.objectStore('message').put(serializeMessage(src, {\n            topic: topicName,\n            seq: seq,\n            _status: status\n          }));\n          trx.commit();\n        };\n      });\n    },\n\n    /**\n     * Remove one or more messages from persistent cache.\n     * @memberOf DB\n     * @param {string} topicName - name of the topic which owns the message.\n     * @param {number} from - id of the message to remove or lower boundary when removing range (inclusive).\n     * @param {number=} to - upper boundary (exclusive) when removing a range of messages.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    remMessages: function(topicName, from, to) {\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve() :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        if (!from && !to) {\n          from = 0;\n          to = Number.MAX_SAFE_INTEGER;\n        }\n        const range = to > 0 ? IDBKeyRange.bound([topicName, from], [topicName, to], false, true) :\n          IDBKeyRange.only([topicName, from]);\n        const trx = db.transaction(['message'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"remMessages\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('message').delete(range);\n        trx.commit();\n      });\n    },\n\n    /**\n     * Retrieve messages from persistent store.\n     * @memberOf DB\n     * @param {string} topicName - name of the topic to retrieve messages from.\n     * @param {function} callback to call for each retrieved message.\n     * @param {Object} query - parameters of the message range to retrieve.\n     * @param {number=} query.from - the least message ID to retrieve (inclusive).\n     * @param {number=} query.to - the greatest message ID to retrieve (exclusive).\n     * @param {number=} query.limit - the maximum number of messages to retrieve.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    readMessages: function(topicName, query, callback, context) {\n      if (!this.isReady()) {\n        return disabled ?\n          Promise.resolve([]) :\n          Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        query = query || {};\n        const from = query.from > 0 ? query.from : 0;\n        const to = query.to > 0 ? query.to : Number.MAX_SAFE_INTEGER;\n        const limit = query.limit | 0;\n\n        const result = [];\n        const range = IDBKeyRange.bound([topicName, from], [topicName, to], false, true);\n        const trx = db.transaction(['message']);\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"readMessages\", event.target.error);\n          reject(event.target.error);\n        };\n        // Iterate in descending order.\n        trx.objectStore('message').openCursor(range, 'prev').onsuccess = (event) => {\n          const cursor = event.target.result;\n          if (cursor) {\n            if (callback) {\n              callback.call(context, cursor.value);\n            }\n            result.push(cursor.value);\n            if (limit <= 0 || result.length < limit) {\n              cursor.continue();\n            } else {\n              resolve(result);\n            }\n          } else {\n            resolve(result);\n          }\n        };\n      });\n    }\n  };\n}\n\nif (typeof module != 'undefined') {\n  module.exports = DB;\n}\n","/**\n * @copyright 2015-2021 Tinode\n * @summary Minimally rich text representation and formatting for Tinode.\n * @license Apache 2.0\n * @version 0.16\n *\n * @file Basic parser and formatter for very simple text markup. Mostly targeted at\n * mobile use cases similar to Telegram, WhatsApp, and FB Messenger.\n *\n * <p>Supports conversion of user keyboard input to formatted text:</p>\n * <ul>\n *   <li>*abc* &rarr; <b>abc</b></li>\n *   <li>_abc_ &rarr; <i>abc</i></li>\n *   <li>~abc~ &rarr; <del>abc</del></li>\n *   <li>`abc` &rarr; <tt>abc</tt></li>\n * </ul>\n * Also supports forms and buttons.\n *\n * Nested formatting is supported, e.g. *abc _def_* -> <b>abc <i>def</i></b>\n * URLs, @mentions, and #hashtags are extracted and converted into links.\n * Forms and buttons can be added procedurally.\n * JSON data representation is inspired by Draft.js raw formatting.\n *\n *\n * @example\n * Text:\n * <pre>\n *     this is *bold*, `code` and _italic_, ~strike~\n *     combined *bold and _italic_*\n *     an url: https://www.example.com/abc#fragment and another _www.tinode.co_\n *     this is a @mention and a #hashtag in a string\n *     second #hashtag\n * </pre>\n *\n *  Sample JSON representation of the text above:\n *  {\n *     \"txt\": \"this is bold, code and italic, strike combined bold and italic an url: https://www.example.com/abc#fragment \" +\n *             \"and another www.tinode.co this is a @mention and a #hashtag in a string second #hashtag\",\n *     \"fmt\": [\n *         { \"at\":8, \"len\":4,\"tp\":\"ST\" },{ \"at\":14, \"len\":4, \"tp\":\"CO\" },{ \"at\":23, \"len\":6, \"tp\":\"EM\"},\n *         { \"at\":31, \"len\":6, \"tp\":\"DL\" },{ \"tp\":\"BR\", \"len\":1, \"at\":37 },{ \"at\":56, \"len\":6, \"tp\":\"EM\" },\n *         { \"at\":47, \"len\":15, \"tp\":\"ST\" },{ \"tp\":\"BR\", \"len\":1, \"at\":62 },{ \"at\":120, \"len\":13, \"tp\":\"EM\" },\n *         { \"at\":71, \"len\":36, \"key\":0 },{ \"at\":120, \"len\":13, \"key\":1 },{ \"tp\":\"BR\", \"len\":1, \"at\":133 },\n *         { \"at\":144, \"len\":8, \"key\":2 },{ \"at\":159, \"len\":8, \"key\":3 },{ \"tp\":\"BR\", \"len\":1, \"at\":179 },\n *         { \"at\":187, \"len\":8, \"key\":3 },{ \"tp\":\"BR\", \"len\":1, \"at\":195 }\n *     ],\n *     \"ent\": [\n *         { \"tp\":\"LN\", \"data\":{ \"url\":\"https://www.example.com/abc#fragment\" } },\n *         { \"tp\":\"LN\", \"data\":{ \"url\":\"http://www.tinode.co\" } },\n *         { \"tp\":\"MN\", \"data\":{ \"val\":\"mention\" } },\n *         { \"tp\":\"HT\", \"data\":{ \"val\":\"hashtag\" } }\n *     ]\n *  }\n */\n\n'use strict';\n\n// NOTE TO DEVELOPERS:\n// Localizable strings should be double quoted \"строка на другом языке\",\n// non-localizable strings should be single quoted 'non-localized'.\n\nconst MAX_FORM_ELEMENTS = 8;\nconst JSON_MIME_TYPE = 'application/json';\n\n// Regular expressions for parsing inline formats. Javascript does not support lookbehind,\n// so it's a bit messy.\nconst INLINE_STYLES = [\n  // Strong = bold, *bold text*\n  {\n    name: 'ST',\n    start: /(?:^|[\\W_])(\\*)[^\\s*]/,\n    end: /[^\\s*](\\*)(?=$|[\\W_])/\n  },\n  // Emphesized = italic, _italic text_\n  {\n    name: 'EM',\n    start: /(?:^|\\W)(_)[^\\s_]/,\n    end: /[^\\s_](_)(?=$|\\W)/\n  },\n  // Deleted, ~strike this though~\n  {\n    name: 'DL',\n    start: /(?:^|[\\W_])(~)[^\\s~]/,\n    end: /[^\\s~](~)(?=$|[\\W_])/\n  },\n  // Code block `this is monospace`\n  {\n    name: 'CO',\n    start: /(?:^|\\W)(`)[^`]/,\n    end: /[^`](`)(?=$|\\W)/\n  }\n];\n\n// RegExps for entity extraction (RF = reference)\nconst ENTITY_TYPES = [\n  // URLs\n  {\n    name: 'LN',\n    dataName: 'url',\n    pack: function(val) {\n      // Check if the protocol is specified, if not use http\n      if (!/^[a-z]+:\\/\\//i.test(val)) {\n        val = 'http://' + val;\n      }\n      return {\n        url: val\n      };\n    },\n    re: /(?:(?:https?|ftp):\\/\\/|www\\.|ftp\\.)[-A-Z0-9+&@#\\/%=~_|$?!:,.]*[A-Z0-9+&@#\\/%=~_|$]/ig\n  },\n  // Mentions @user (must be 2 or more characters)\n  {\n    name: 'MN',\n    dataName: 'val',\n    pack: function(val) {\n      return {\n        val: val.slice(1)\n      };\n    },\n    re: /\\B@(\\w\\w+)/g\n  },\n  // Hashtags #hashtag, like metion 2 or more characters.\n  {\n    name: 'HT',\n    dataName: 'val',\n    pack: function(val) {\n      return {\n        val: val.slice(1)\n      };\n    },\n    re: /\\B#(\\w\\w+)/g\n  }\n];\n\n// HTML tag name suggestions\nconst HTML_TAGS = {\n  ST: {\n    name: 'b',\n    isVoid: false\n  },\n  EM: {\n    name: 'i',\n    isVoid: false\n  },\n  DL: {\n    name: 'del',\n    isVoid: false\n  },\n  CO: {\n    name: 'tt',\n    isVoid: false\n  },\n  BR: {\n    name: 'br',\n    isVoid: true\n  },\n  LN: {\n    name: 'a',\n    isVoid: false\n  },\n  MN: {\n    name: 'a',\n    isVoid: false\n  },\n  HT: {\n    name: 'a',\n    isVoid: false\n  },\n  IM: {\n    name: 'img',\n    isVoid: true\n  },\n  FM: {\n    name: 'div',\n    isVoid: false\n  },\n  RW: {\n    name: 'div',\n    isVoid: false,\n  },\n  BN: {\n    name: 'button',\n    isVoid: false\n  },\n  HD: {\n    name: '',\n    isVoid: false\n  },\n  HL: {\n    name: 'span',\n    isVoid: false\n  }\n};\n\n// Convert base64-encoded string into Blob.\nfunction base64toObjectUrl(b64, contentType, logger) {\n  if (!b64) {\n    return null;\n  }\n\n  try {\n    const bin = atob(b64);\n    const length = bin.length;\n    const buf = new ArrayBuffer(length);\n    const arr = new Uint8Array(buf);\n    for (let i = 0; i < length; i++) {\n      arr[i] = bin.charCodeAt(i);\n    }\n\n    return URL.createObjectURL(new Blob([buf], {\n      type: contentType\n    }));\n  } catch (err) {\n    if (logger) {\n      logger(\"Drafty: failed to convert object.\", err.message);\n    }\n  }\n\n  return null;\n}\n\nfunction base64toDataUrl(b64, contentType) {\n  if (!b64) {\n    return null;\n  }\n  contentType = contentType || 'image/jpeg';\n  return 'data:' + contentType + ';base64,' + b64;\n}\n\n// Helpers for converting Drafty to HTML.\nconst DECORATORS = {\n  // Visial styles\n  ST: {\n    open: function() {\n      return '<b>';\n    },\n    close: function() {\n      return '</b>';\n    }\n  },\n  EM: {\n    open: function() {\n      return '<i>';\n    },\n    close: function() {\n      return '</i>'\n    }\n  },\n  DL: {\n    open: function() {\n      return '<del>';\n    },\n    close: function() {\n      return '</del>'\n    }\n  },\n  CO: {\n    open: function() {\n      return '<tt>';\n    },\n    close: function() {\n      return '</tt>'\n    }\n  },\n  // Line break\n  BR: {\n    open: function() {\n      return '<br/>';\n    },\n    close: function() {\n      return ''\n    }\n  },\n  // Hidden element\n  HD: {\n    open: function() {\n      return '';\n    },\n    close: function() {\n      return '';\n    }\n  },\n  // Highlighted element.\n  HL: {\n    open: function() {\n      return '<span style=\"color:teal\">';\n    },\n    close: function() {\n      return '</span>';\n    }\n  },\n  // Link (URL)\n  LN: {\n    open: function(data) {\n      return '<a href=\"' + data.url + '\">';\n    },\n    close: function(data) {\n      return '</a>';\n    },\n    props: function(data) {\n      return data ? {\n        href: data.url,\n        target: \"_blank\"\n      } : null;\n    },\n  },\n  // Mention\n  MN: {\n    open: function(data) {\n      return '<a href=\"#' + data.val + '\">';\n    },\n    close: function(data) {\n      return '</a>';\n    },\n    props: function(data) {\n      return data ? {\n        name: data.val\n      } : null;\n    },\n  },\n  // Hashtag\n  HT: {\n    open: function(data) {\n      return '<a href=\"#' + data.val + '\">';\n    },\n    close: function(data) {\n      return '</a>';\n    },\n    props: function(data) {\n      return data ? {\n        name: data.val\n      } : null;\n    },\n  },\n  // Button\n  BN: {\n    open: function(data) {\n      return '<button>';\n    },\n    close: function(data) {\n      return '</button>';\n    },\n    props: function(data) {\n      return data ? {\n        'data-act': data.act,\n        'data-val': data.val,\n        'data-name': data.name,\n        'data-ref': data.ref\n      } : null;\n    },\n  },\n  // Image\n  IM: {\n    open: function(data) {\n      // Don't use data.ref for preview: it's a security risk.\n      const tmpPreviewUrl = base64toDataUrl(data._tempPreview, data.mime);\n      const previewUrl = base64toObjectUrl(data.val, data.mime, Drafty.logger);\n      const downloadUrl = data.ref || previewUrl;\n      return (data.name ? '<a href=\"' + downloadUrl + '\" download=\"' + data.name + '\">' : '') +\n        '<img src=\"' + (tmpPreviewUrl || previewUrl) + '\"' +\n        (data.width ? ' width=\"' + data.width + '\"' : '') +\n        (data.height ? ' height=\"' + data.height + '\"' : '') + ' border=\"0\" />';\n    },\n    close: function(data) {\n      return (data.name ? '</a>' : '');\n    },\n    props: function(data) {\n      if (!data) return null;\n      return {\n        // Temporary preview, or permanent preview, or external link.\n        src: base64toDataUrl(data._tempPreview, data.mime) ||\n          data.ref || base64toObjectUrl(data.val, data.mime, Drafty.logger),\n        title: data.name,\n        'data-width': data.width,\n        'data-height': data.height,\n        'data-name': data.name,\n        'data-size': data.val ? ((data.val.length * 0.75) | 0) : (data.size | 0),\n        'data-mime': data.mime\n      };\n    },\n  },\n  // Form - structured layout of elements.\n  FM: {\n    open: function(data) {\n      return '<div>';\n    },\n    close: function(data) {\n      return '</div>';\n    }\n  },\n  // Row: logic grouping of elements\n  RW: {\n    open: function(data) {\n      return '<div>';\n    },\n    close: function(data) {\n      return '</div>';\n    }\n  }\n};\n\n/**\n * The main object which performs all the formatting actions.\n * @class Drafty\n * @constructor\n */\nconst Drafty = function() {}\n\n// Take a string and defined earlier style spans, re-compose them into a tree where each leaf is\n// a same-style (including unstyled) string. I.e. 'hello *bold _italic_* and ~more~ world' ->\n// ('hello ', (b: 'bold ', (i: 'italic')), ' and ', (s: 'more'), ' world');\n//\n// This is needed in order to clear markup, i.e. 'hello *world*' -> 'hello world' and convert\n// ranges from markup-ed offsets to plain text offsets.\nfunction chunkify(line, start, end, spans) {\n  const chunks = [];\n\n  if (spans.length == 0) {\n    return [];\n  }\n\n  for (let i in spans) {\n    // Get the next chunk from the queue\n    const span = spans[i];\n\n    // Grab the initial unstyled chunk\n    if (span.start > start) {\n      chunks.push({\n        text: line.slice(start, span.start)\n      });\n    }\n\n    // Grab the styled chunk. It may include subchunks.\n    const chunk = {\n      type: span.type\n    };\n    const chld = chunkify(line, span.start + 1, span.end, span.children);\n    if (chld.length > 0) {\n      chunk.children = chld;\n    } else {\n      chunk.text = span.text;\n    }\n    chunks.push(chunk);\n    start = span.end + 1; // '+1' is to skip the formatting character\n  }\n\n  // Grab the remaining unstyled chunk, after the last span\n  if (start < end) {\n    chunks.push({\n      text: line.slice(start, end)\n    });\n  }\n\n  return chunks;\n}\n\n// Inverse of chunkify. Returns a tree of formatted spans.\nfunction forEach(line, start, end, spans, formatter, context) {\n  const result = [];\n\n  // Process ranges calling formatter for each range.\n  for (let i = 0; i < spans.length; i++) {\n    const span = spans[i];\n    if (span.at < 0) {\n      // Ask formatter if it wants to do anything with the non-visual span.\n      const s = formatter.call(context, span.tp, span.data, undefined, result.length);\n      if (s) {\n        result.push(s);\n      }\n      continue;\n    }\n    // Add un-styled range before the styled span starts.\n    if (start < span.at) {\n      result.push(formatter.call(context, null, undefined, line.slice(start, span.at), result.length));\n      start = span.at;\n    }\n    // Get all spans which are within current span.\n    const subspans = [];\n    for (let si = i + 1; si < spans.length && spans[si].at < span.at + span.len; si++) {\n      subspans.push(spans[si]);\n      i = si;\n    }\n\n    const tag = HTML_TAGS[span.tp] || {}\n    result.push(formatter.call(context, span.tp, span.data,\n      tag.isVoid ? null : forEach(line, start, span.at + span.len, subspans, formatter, context),\n      result.length));\n\n    start = span.at + span.len;\n  }\n\n  // Add the last unformatted range.\n  if (start < end) {\n    result.push(formatter.call(context, null, undefined, line.slice(start, end), result.length));\n  }\n\n  return result;\n}\n\n// Detect starts and ends of formatting spans. Unformatted spans are\n// ignored at this stage.\nfunction spannify(original, re_start, re_end, type) {\n  const result = [];\n  let index = 0;\n  let line = original.slice(0); // make a copy;\n\n  while (line.length > 0) {\n    // match[0]; // match, like '*abc*'\n    // match[1]; // match captured in parenthesis, like 'abc'\n    // match['index']; // offset where the match started.\n\n    // Find the opening token.\n    const start = re_start.exec(line);\n    if (start == null) {\n      break;\n    }\n\n    // Because javascript RegExp does not support lookbehind, the actual offset may not point\n    // at the markup character. Find it in the matched string.\n    let start_offset = start['index'] + start[0].lastIndexOf(start[1]);\n    // Clip the processed part of the string.\n    line = line.slice(start_offset + 1);\n    // start_offset is an offset within the clipped string. Convert to original index.\n    start_offset += index;\n    // Index now point to the beginning of 'line' within the 'original' string.\n    index = start_offset + 1;\n\n    // Find the matching closing token.\n    const end = re_end ? re_end.exec(line) : null;\n    if (end == null) {\n      break;\n    }\n    let end_offset = end['index'] + end[0].indexOf(end[1]);\n    // Clip the processed part of the string.\n    line = line.slice(end_offset + 1);\n    // Update offsets\n    end_offset += index;\n    // Index now point to the beginning of 'line' within the 'original' string.\n    index = end_offset + 1;\n\n    result.push({\n      text: original.slice(start_offset + 1, end_offset),\n      children: [],\n      start: start_offset,\n      end: end_offset,\n      type: type\n    });\n  }\n\n  return result;\n}\n\n// Convert linear array or spans into a tree representation.\n// Keep standalone and nested spans, throw away partially overlapping spans.\nfunction toTree(spans) {\n  if (spans.length == 0) {\n    return [];\n  }\n\n  const tree = [spans[0]];\n  let last = spans[0];\n  for (let i = 1; i < spans.length; i++) {\n    // Keep spans which start after the end of the previous span or those which\n    // are complete within the previous span.\n\n    if (spans[i].start > last.end) {\n      // Span is completely outside of the previous span.\n      tree.push(spans[i]);\n      last = spans[i];\n    } else if (spans[i].end < last.end) {\n      // Span is fully inside of the previous span. Push to subnode.\n      last.children.push(spans[i]);\n    }\n    // Span could partially overlap, ignoring it as invalid.\n  }\n\n  // Recursively rearrange the subnodes.\n  for (let i in tree) {\n    tree[i].children = toTree(tree[i].children);\n  }\n\n  return tree;\n}\n\n// Get a list of entities from a text.\nfunction extractEntities(line) {\n  let match;\n  let extracted = [];\n  ENTITY_TYPES.map(function(entity) {\n    while ((match = entity.re.exec(line)) !== null) {\n      extracted.push({\n        offset: match['index'],\n        len: match[0].length,\n        unique: match[0],\n        data: entity.pack(match[0]),\n        type: entity.name\n      });\n    }\n  });\n\n  if (extracted.length == 0) {\n    return extracted;\n  }\n\n  // Remove entities detected inside other entities, like #hashtag in a URL.\n  extracted.sort(function(a, b) {\n    return a.offset - b.offset;\n  });\n\n  let idx = -1;\n  extracted = extracted.filter(function(el) {\n    const result = (el.offset > idx);\n    idx = el.offset + el.len;\n    return result;\n  });\n\n  return extracted;\n}\n\n// Convert the chunks into format suitable for serialization.\nfunction draftify(chunks, startAt) {\n  let plain = \"\";\n  let ranges = [];\n  for (let i in chunks) {\n    const chunk = chunks[i];\n    if (!chunk.text) {\n      const drafty = draftify(chunk.children, plain.length + startAt);\n      chunk.text = drafty.txt;\n      ranges = ranges.concat(drafty.fmt);\n    }\n\n    if (chunk.type) {\n      ranges.push({\n        at: plain.length + startAt,\n        len: chunk.text.length,\n        tp: chunk.type\n      });\n    }\n\n    plain += chunk.text;\n  }\n  return {\n    txt: plain,\n    fmt: ranges\n  };\n}\n\n// Splice two strings: insert second string into the first one at the given index\nfunction splice(src, at, insert) {\n  return src.slice(0, at) + insert + src.slice(at);\n}\n\n/**\n * Parse plain text into Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {String} content - plain-text content to parse.\n * @return {Drafty} parsed document or null if the source is not plain text.\n */\nDrafty.parse = function(content) {\n  // Make sure we are parsing strings only.\n  if (typeof content != 'string') {\n    return null;\n  }\n\n  // Split text into lines. It makes further processing easier.\n  const lines = content.split(/\\r?\\n/);\n\n  // Holds entities referenced from text\n  const entityMap = [];\n  const entityIndex = {};\n\n  // Processing lines one by one, hold intermediate result in blx.\n  const blx = [];\n  lines.map(function(line) {\n    let spans = [];\n    let entities;\n\n    // Find formatted spans in the string.\n    // Try to match each style.\n    INLINE_STYLES.map(function(style) {\n      // Each style could be matched multiple times.\n      spans = spans.concat(spannify(line, style.start, style.end, style.name));\n    });\n\n    let block;\n    if (spans.length == 0) {\n      block = {\n        txt: line\n      };\n    } else {\n      // Sort spans by style occurence early -> late\n      spans.sort(function(a, b) {\n        return a.start - b.start;\n      });\n\n      // Convert an array of possibly overlapping spans into a tree\n      spans = toTree(spans);\n\n      // Build a tree representation of the entire string, not\n      // just the formatted parts.\n      const chunks = chunkify(line, 0, line.length, spans);\n\n      const drafty = draftify(chunks, 0);\n\n      block = {\n        txt: drafty.txt,\n        fmt: drafty.fmt\n      };\n    }\n\n    // Extract entities from the cleaned up string.\n    entities = extractEntities(block.txt);\n    if (entities.length > 0) {\n      const ranges = [];\n      for (let i in entities) {\n        // {offset: match['index'], unique: match[0], len: match[0].length, data: ent.packer(), type: ent.name}\n        const entity = entities[i];\n        let index = entityIndex[entity.unique];\n        if (!index) {\n          index = entityMap.length;\n          entityIndex[entity.unique] = index;\n          entityMap.push({\n            tp: entity.type,\n            data: entity.data\n          });\n        }\n        ranges.push({\n          at: entity.offset,\n          len: entity.len,\n          key: index\n        });\n      }\n      block.ent = ranges;\n    }\n\n    blx.push(block);\n  });\n\n  const result = {\n    txt: \"\"\n  };\n\n  // Merge lines and save line breaks as BR inline formatting.\n  if (blx.length > 0) {\n    result.txt = blx[0].txt;\n    result.fmt = (blx[0].fmt || []).concat(blx[0].ent || []);\n\n    for (let i = 1; i < blx.length; i++) {\n      const block = blx[i];\n      const offset = result.txt.length + 1;\n\n      result.fmt.push({\n        tp: 'BR',\n        len: 1,\n        at: offset - 1\n      });\n\n      result.txt += \" \" + block.txt;\n      if (block.fmt) {\n        result.fmt = result.fmt.concat(block.fmt.map(function(s) {\n          s.at += offset;\n          return s;\n        }));\n      }\n      if (block.ent) {\n        result.fmt = result.fmt.concat(block.ent.map(function(s) {\n          s.at += offset;\n          return s;\n        }));\n      }\n    }\n\n    if (result.fmt.length == 0) {\n      delete result.fmt;\n    }\n\n    if (entityMap.length > 0) {\n      result.ent = entityMap;\n    }\n  }\n  return result;\n}\n\n/**\n * Initialize Drafty document to a plain text string.\n *\n * @param {String} plainText - string to use as Drafty content.\n *\n * @returns new Drafty document or null is plainText is not a string.\n */\nDrafty.init = function(plainText) {\n  if (typeof plainText != 'string') {\n    return null;\n  }\n  return {\n    txt: plainText\n  };\n}\n\n/**\n * Append one Drafty document to another.\n *\n * @param {Drafty} first - Drafty document to append to.\n * @param {Drafty} second - Drafty document being appended.\n *\n * @return {Drafty} first document with the second appended to it.\n */\nDrafty.append = function(first, second) {\n  if (first == null) {\n    return second;\n  }\n  if (second == null) {\n    return first;\n  }\n\n  first.txt = first.txt || '';\n  second.txt = second.txt || '';\n  const len = first.txt.length;\n\n  first.txt += second.txt;\n  if (Array.isArray(second.fmt)) {\n    first.fmt = first.fmt || [];\n    if (Array.isArray(second.ent)) {\n      first.ent = first.ent || [];\n    }\n    second.fmt.forEach(src => {\n      const fmt = {\n        at: src.at + len,\n        len: src.len\n      };\n      if (src.tp) {\n        fmt.tp = src.tp;\n      } else {\n        fmt.key = first.ent.length;\n        first.ent.push(second.ent[src.key || 0]);\n      }\n      first.fmt.push(fmt);\n    });\n  }\n\n  return first;\n}\n\n/**\n * @typedef Drafty.ImageDesc\n * @memberof Drafty\n * @type Object\n * @param {string} mime - mime-type of the image, e.g. \"image/png\"\n * @param {string} preview - base64-encoded image content (or preview, if large image is attached). Could be null/undefined.\n * @param {integer} width - width of the image\n * @param {integer} height - height of the image\n * @param {string} filename - file name suggestion for downloading the image.\n * @param {integer} size - size of the image in bytes. Treat is as an untrusted hint.\n * @param {string} refurl - reference to the content. Could be null/undefined.\n * @param {string} _tempPreview - base64-encoded image preview used during upload process; not serializable.\n * @param {Promise} urlPromise - Promise which returns content URL when resolved.\n */\n\n/**\n * Insert inline image into Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to add image to.\n * @param {integer} at - index where the object is inserted. The length of the image is always 1.\n * @param {ImageDesc} imageDesc - object with image paramenets and data.\n *\n * @return {Drafty} updated document.\n */\nDrafty.insertImage = function(content, at, imageDesc) {\n  content = content || {\n    txt: \" \"\n  };\n  content.ent = content.ent || [];\n  content.fmt = content.fmt || [];\n\n  content.fmt.push({\n    at: at,\n    len: 1,\n    key: content.ent.length\n  });\n\n  const ex = {\n    tp: 'IM',\n    data: {\n      mime: imageDesc.mime,\n      val: imageDesc.preview,\n      width: imageDesc.width,\n      height: imageDesc.height,\n      name: imageDesc.filename,\n      size: imageDesc.size | 0,\n      ref: imageDesc.refurl\n    }\n  };\n\n  if (imageDesc.urlPromise) {\n    ex.data._tempPreview = imageDesc._tempPreview;\n    ex.data._processing = true;\n    imageDesc.urlPromise.then(\n      (url) => {\n        ex.data.ref = url;\n        ex.data._tempPreview = undefined;\n        ex.data._processing = undefined;\n      },\n      (err) => {\n        /* catch the error, otherwise it will appear in the console. */\n        ex.data._processing = undefined;\n      }\n    );\n  }\n\n  content.ent.push(ex);\n\n  return content;\n}\n\n/**\n * Append inline image to Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to add image to.\n * @param {ImageDesc} imageDesc - object with image paramenets.\n *\n * @return {Drafty} updated document.\n */\nDrafty.appendImage = function(content, imageDesc) {\n  content = content || {\n    txt: \"\"\n  };\n  content.txt += \" \";\n  return Drafty.insertImage(content, content.txt.length - 1, imageDesc);\n}\n\n/**\n * @typedef Drafty.AttachmentDesc\n * @memberof Drafty\n * @type Object\n * @param {string} mime - mime-type of the image, e.g. \"image/png\"\n * @param {string} data - base64-encoded in-band content of small attachments. Could be null/undefined.\n * @param {string} filename - file name suggestion for downloading the attachment.\n * @param {integer} size - size of the file in bytes. Treat is as an untrusted hint.\n * @param {string} refurl - reference to the out-of-band content. Could be null/undefined.\n * @param {Promise} urlPromise - Promise which returns content URL when resolved.\n */\n\n/**\n * Attach file to Drafty content. Either as a blob or as a reference.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to attach file to.\n * @param {AttachmentDesc} object - containing attachment description and data.\n *\n * @return {Drafty} updated document.\n */\nDrafty.attachFile = function(content, attachmentDesc) {\n  content = content || {\n    txt: \"\"\n  };\n  content.ent = content.ent || [];\n  content.fmt = content.fmt || [];\n\n  content.fmt.push({\n    at: -1,\n    len: 0,\n    key: content.ent.length\n  });\n\n  const ex = {\n    tp: 'EX',\n    data: {\n      mime: attachmentDesc.mime,\n      val: attachmentDesc.data,\n      name: attachmentDesc.filename,\n      ref: attachmentDesc.refurl,\n      size: attachmentDesc.size | 0\n    }\n  }\n  if (attachmentDesc.urlPromise) {\n    ex.data._processing = true;\n    attachmentDesc.urlPromise.then(\n      (url) => {\n        ex.data.ref = url;\n        ex.data._processing = undefined;\n      },\n      (err) => {\n        /* catch the error, otherwise it will appear in the console. */\n        ex.data._processing = undefined;\n      }\n    );\n  }\n  content.ent.push(ex);\n\n  return content;\n}\n\n/**\n * Wraps content into an interactive form.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty|string} content - to wrap into a form.\n * @param {number} at - index where the forms starts.\n * @param {number} len - length of the form content.\n *\n * @return {Drafty} updated document.\n */\nDrafty.wrapAsForm = function(content, at, len) {\n  if (typeof content == 'string') {\n    content = {\n      txt: content\n    };\n  }\n  content.fmt = content.fmt || [];\n\n  content.fmt.push({\n    at: at,\n    len: len,\n    tp: 'FM'\n  });\n\n  return content;\n}\n\n/**\n * Insert clickable button into Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty|string} content - Drafty document to insert button to or a string to be used as button text.\n * @param {number} at - location where the button is inserted.\n * @param {number} len - the length of the text to be used as button title.\n * @param {string} name - the button. Client should return it to the server when the button is clicked.\n * @param {string} actionType - the type of the button, one of 'url' or 'pub'.\n * @param {string} actionValue - the value to return on click:\n * @param {string} refUrl - the URL to go to when the 'url' button is clicked.\n *\n * @return {Drafty} updated document.\n */\nDrafty.insertButton = function(content, at, len, name, actionType, actionValue, refUrl) {\n  if (typeof content == 'string') {\n    content = {\n      txt: content\n    };\n  }\n\n  if (!content || !content.txt || content.txt.length < at + len) {\n    return null;\n  }\n\n  if (len <= 0 || ['url', 'pub'].indexOf(actionType) == -1) {\n    return null;\n  }\n  // Ensure refUrl is a string.\n  if (actionType == 'url' && !refUrl) {\n    return null;\n  }\n  refUrl = '' + refUrl;\n\n  content.ent = content.ent || [];\n  content.fmt = content.fmt || [];\n\n  content.fmt.push({\n    at: at,\n    len: len,\n    key: content.ent.length\n  });\n  content.ent.push({\n    tp: 'BN',\n    data: {\n      act: actionType,\n      val: actionValue,\n      ref: refUrl,\n      name: name\n    }\n  });\n\n  return content;\n}\n\n/**\n * Append clickable button to Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty|string} content - Drafty document to insert button to or a string to be used as button text.\n * @param {string} title - the text to be used as button title.\n * @param {string} name - the button. Client should return it to the server when the button is clicked.\n * @param {string} actionType - the type of the button, one of 'url' or 'pub'.\n * @param {string} actionValue - the value to return on click:\n * @param {string} refUrl - the URL to go to when the 'url' button is clicked.\n *\n * @return {Drafty} updated document.\n */\nDrafty.appendButton = function(content, title, name, actionType, actionValue, refUrl) {\n  content = content || {\n    txt: \"\"\n  };\n  const at = content.txt.length;\n  content.txt += title;\n  return Drafty.insertButton(content, at, title.length, name, actionType, actionValue, refUrl);\n}\n\n/**\n * Attach a generic JS object. The object is attached as a json string.\n * Intended for representing a form response.\n *\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - Drafty document to attach file to.\n * @param {Object} data - data to convert to json string and attach.\n * @returns {Drafty} the same document as <code>content</code>.\n */\nDrafty.attachJSON = function(content, data) {\n  content = content || {\n    txt: \"\"\n  };\n  content.ent = content.ent || [];\n  content.fmt = content.fmt || [];\n\n  content.fmt.push({\n    at: -1,\n    len: 0,\n    key: content.ent.length\n  });\n\n  content.ent.push({\n    tp: 'EX',\n    data: {\n      mime: JSON_MIME_TYPE,\n      val: data\n    }\n  });\n\n  return content;\n}\n/**\n * Append line break to a Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - Drafty document to append linebreak to.\n * @returns {Drafty} the same document as <code>content</code>.\n */\nDrafty.appendLineBreak = function(content) {\n  content = content || {\n    txt: \"\"\n  };\n  content.fmt = content.fmt || [];\n  content.fmt.push({\n    at: content.txt.length,\n    len: 1,\n    tp: 'BR'\n  });\n  content.txt += \" \";\n\n  return content;\n}\n/**\n * Given Drafty document, convert it to HTML.\n * No attempt is made to strip pre-existing html markup.\n * This is potentially unsafe because <code>content.txt</code> may contain malicious\n * markup.\n * @memberof Tinode.Drafty\n * @static\n *\n * @param {Drafy} content - document to convert.\n *\n * @returns {string} HTML-representation of content.\n */\nDrafty.UNSAFE_toHTML = function(content) {\n  let {\n    txt,\n    fmt,\n    ent\n  } = content;\n\n  const markup = [];\n  if (fmt) {\n    for (let i in fmt) {\n      const range = fmt[i];\n      const at = range.at | 0;\n      let tp = range.tp;\n      let data;\n      if (!tp) {\n        const entity = ent[range.key | 0];\n        if (entity) {\n          tp = entity.tp;\n          data = entity.data;\n        }\n      }\n\n      if (DECORATORS[tp]) {\n        // Because we later sort in descending order, closing markup must come first.\n        // Otherwise zero-length objects will not be represented correctly.\n        markup.push({\n          idx: at + range.len,\n          len: -range.len,\n          what: DECORATORS[tp].close(data)\n        });\n        markup.push({\n          idx: at,\n          len: range.len,\n          what: DECORATORS[tp].open(data)\n        });\n      }\n    }\n  }\n\n  markup.sort(function(a, b) {\n    return b.idx == a.idx ? b.len - a.len : b.idx - a.idx; // in descending order\n  });\n\n  for (let i in markup) {\n    if (markup[i].what) {\n      txt = splice(txt, markup[i].idx, markup[i].what);\n    }\n  }\n\n  return txt;\n}\n\n/**\n * Callback for applying custom formatting/transformation to a Drafty document.\n * Called once for each syle span.\n * @memberof Drafty\n * @static\n *\n * @callback Formatter\n * @param {string} style - style code such as \"ST\" or \"IM\".\n * @param {Object} data - entity's data\n * @param {Object} values - possibly styled subspans contained in this style span.\n * @param {number} index - of the current element among its siblings.\n */\n\n/**\n * Transform Drafty document using custom formatting.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - content to transform.\n * @param {Formatter} formatter - callback which transforms individual elements\n * @param {Object} context - context provided to formatter as <code>this</code>.\n *\n * @return {Object} transformed object\n */\nDrafty.format = function(content, formatter, context) {\n  let {\n    txt,\n    fmt,\n    ent\n  } = content;\n\n  // Assign default values.\n  txt = txt || \"\";\n  if (!Array.isArray(ent)) {\n    ent = [];\n  }\n\n  if (!Array.isArray(fmt)) {\n    // Handle special case when all values in fmt are 0 and fmt is skipped.\n    if (ent.length == 1) {\n      fmt = [{\n        at: 0,\n        len: 0,\n        key: 0\n      }];\n    } else {\n      return [txt];\n    }\n  }\n\n  let spans = [].concat(fmt);\n\n  // Zero values may have been stripped. Restore them.\n  // Also ensure indexes and lengths are sane.\n  spans.map(function(s) {\n    s.at = s.at || 0;\n    s.len = s.len || 0;\n    if (s.len < 0) {\n      s.len = 0;\n    }\n    if (s.at < -1) {\n      s.at = -1;\n    }\n  });\n\n  // Sort spans first by start index (asc) then by length (desc).\n  spans.sort(function(a, b) {\n    if (a.at - b.at == 0) {\n      return b.len - a.len; // longer one comes first (<0)\n    }\n    return a.at - b.at;\n  });\n\n  // Denormalize entities into spans. Create a copy of the objects to leave\n  // original Drafty object unchanged.\n  spans = spans.map((s) => {\n    let data;\n    let tp = s.tp;\n    if (!tp) {\n      s.key = s.key || 0;\n      if (ent[s.key]) {\n        data = ent[s.key].data;\n        tp = ent[s.key].tp;\n      }\n    }\n\n    // Type still not defined? Hide invalid element.\n    tp = tp || 'HD';\n\n    return {\n      tp: tp,\n      data: data,\n      at: s.at,\n      len: s.len\n    };\n  });\n\n  return forEach(txt, 0, txt.length, spans, formatter, context);\n}\n\n/**\n * Given Drafty document, convert it to plain text.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to convert to plain text.\n * @returns {string} plain-text representation of the drafty document.\n */\nDrafty.toPlainText = function(content) {\n  return typeof content == 'string' ? content : content.txt;\n}\n\n/**\n * Check if the document has no markup and no entities.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - content to check for presence of markup.\n * @returns <code>true</code> is content is plain text, <code>false</code> otherwise.\n */\nDrafty.isPlainText = function(content) {\n  return typeof content == 'string' || !(content.fmt || content.ent);\n}\n\n/**\n * Checks if the object represets is a valid Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - content to check for validity.\n * @returns <code>true</code> is content is valid, <code>false</code> otherwise.\n */\nDrafty.isValid = function(content) {\n  if (!content) {\n    return false;\n  }\n\n  const {\n    txt,\n    fmt,\n    ent\n  } = content;\n\n  if (!txt && txt !== '' && !fmt && !ent) {\n    return false;\n  }\n\n  const txt_type = typeof txt;\n  if (txt_type != 'string' && txt_type != 'undefined' && txt !== null) {\n    return false;\n  }\n\n  if (typeof fmt != 'undefined' && !Array.isArray(fmt) && fmt !== null) {\n    return false;\n  }\n\n  if (typeof ent != 'undefined' && !Array.isArray(ent) && ent !== null) {\n    return false;\n  }\n  return true;\n}\n\n/**\n * Check if the drafty document has attachments.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to check for attachments.\n * @returns <code>true</code> if there are attachments.\n */\nDrafty.hasAttachments = function(content) {\n  if (content.ent && content.ent.length > 0) {\n    for (let i in content.ent) {\n      if (content.ent[i] && content.ent[i].data && content.ent[i].tp == 'EX') {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * Callback for applying custom formatting/transformation to a Drafty document.\n * Called once for each entity.\n * @memberof Drafty\n * @static\n *\n * @callback EntityCallback\n * @param {Object} data entity data.\n * @param {string} entity type.\n * @param {number} index entity's index in `content.ent`.\n */\n\n/**\n * Enumerate attachments.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to process for attachments.\n * @param {EntityCallback} callback - callback to call for each attachment.\n * @param {Object} context - value of \"this\" for callback.\n */\nDrafty.attachments = function(content, callback, context) {\n  if (content.ent && content.ent.length > 0) {\n    for (let i in content.ent) {\n      if (content.ent[i] && content.ent[i].tp == 'EX' && content.ent[i].data) {\n        callback.call(context, content.ent[i].data, i, 'EX');\n      }\n    }\n  }\n}\n\n/**\n * Check if the drafty document has entities.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to check for entities.\n * @returns <code>true</code> if there are entities.\n */\nDrafty.hasEntities = function(content) {\n  return content.ent && content.ent.length > 0;\n}\n\n/**\n * Enumerate entities.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document with entities to enumerate.\n * @param {EntityCallback} callback - callback to call for each entity.\n * @param {Object} context - value of \"this\" for callback.\n */\nDrafty.entities = function(content, callback, context) {\n  if (content.ent && content.ent.length > 0) {\n    for (let i in content.ent) {\n      if (content.ent[i]) {\n        callback.call(context, content.ent[i].data, i, content.ent[i].tp);\n      }\n    }\n  }\n}\n\n/**\n * Given the entity, get URL which can be used for downloading\n * entity data.\n * @memberof Drafty\n * @static\n *\n * @param {Object} entData - entity.data to get the URl from.\n * @returns {string} URL to download entity data or <code>null</code>.\n */\nDrafty.getDownloadUrl = function(entData) {\n  let url = null;\n  if (entData.mime != JSON_MIME_TYPE && entData.val) {\n    url = base64toObjectUrl(entData.val, entData.mime, Drafty.logger);\n  } else if (typeof entData.ref == 'string') {\n    url = entData.ref;\n  }\n  return url;\n}\n\n/**\n * Check if the entity data is not ready for sending, such as being uploaded to the server.\n * @memberof Drafty\n * @static\n *\n * @param {Object} entity.data to get the URl from.\n * @returns {boolean} true if upload is in progress, false otherwise.\n */\nDrafty.isProcessing = function(entData) {\n  return !!entData._processing;\n}\n\n/**\n * Given the entity, get URL which can be used for previewing\n * the entity.\n * @memberof Drafty\n * @static\n *\n * @param {Object} entity.data to get the URl from.\n *\n * @returns {string} url for previewing or null if no such url is available.\n */\nDrafty.getPreviewUrl = function(entData) {\n  return entData.val ? base64toObjectUrl(entData.val, entData.mime, Drafty.logger) : null;\n}\n\n/**\n * Get approximate size of the entity.\n * @memberof Drafty\n * @static\n *\n * @param {Object} entData - entity.data to get the size for.\n * @returns {number} size of entity data in bytes.\n */\nDrafty.getEntitySize = function(entData) {\n  // Either size hint or length of value. The value is base64 encoded,\n  // the actual object size is smaller than the encoded length.\n  return entData.size ? entData.size : entData.val ? (entData.val.length * 0.75) | 0 : 0;\n}\n\n/**\n * Get entity mime type.\n * @memberof Drafty\n * @static\n *\n * @param {Object} entData - entity.data to get the type for.\n * @returns {string} mime type of entity.\n */\nDrafty.getEntityMimeType = function(entData) {\n  return entData.mime || 'text/plain';\n}\n\n/**\n * Get HTML tag for a given two-letter style name.\n * @memberof Drafty\n * @static\n *\n * @param {string} style - two-letter style, like ST or LN.\n *\n * @returns {string} HTML tag name if style is found, '_UNKN' if not found, {code: undefined} if style is falsish.\n */\nDrafty.tagName = function(style) {\n  return style ? (HTML_TAGS[style] ? HTML_TAGS[style].name : '_UNKN') : undefined;\n}\n\n/**\n * For a given data bundle generate an object with HTML attributes,\n * for instance, given {url: \"http://www.example.com/\"} return\n * {href: \"http://www.example.com/\"}\n * @memberof Drafty\n * @static\n *\n * @param {string} style - two-letter style to generate attributes for.\n * @param {Object} data - data bundle to convert to attributes\n *\n * @returns {Object} object with HTML attributes.\n */\nDrafty.attrValue = function(style, data) {\n  if (data && DECORATORS[style]) {\n    return DECORATORS[style].props(data);\n  }\n\n  return undefined;\n}\n\n/**\n * Drafty MIME type.\n * @memberof Drafty\n * @static\n *\n * @returns {string} HTTP Content-Type \"text/x-drafty\".\n */\nDrafty.getContentType = function() {\n  return 'text/x-drafty';\n}\n\n/**\n * Shorten Drafty document and strip all entity data leaving just inline styles and entity references.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} original - Drafty object to shorten.\n * @param {number} length - length in characters to shorten to.\n * @returns new shortened Drafty object leaving the original intact.\n */\nDrafty.preview = function(original, length) {\n  if (!original || length <= 0 || typeof original != 'object') {\n    return null;\n  }\n\n  const {\n    txt,\n    fmt,\n    ent\n  } = original;\n\n  const preview = {\n    txt: ''\n  };\n\n  if (typeof txt == 'string') {\n    preview.txt = txt.substr(0, length);\n  }\n  let len = preview.txt.length;\n\n  if (Array.isArray(fmt) && fmt.length > 0) {\n    // Old key to new key entity mapping.\n    const ent_refs = [];\n    // Count styles which start within the new length of the text and save entity keys as a set.\n    let fmt_count = 0;\n    let ent_count = 0;\n    fmt.forEach((st) => {\n      st.at |= 0;\n      if (st.at < len) {\n        fmt_count++;\n        if (!st.tp) {\n          st.key |= 0;\n          if (!ent_refs[st.key]) {\n            ent_refs[st.key] = ent_count;\n            ent_count++;\n          }\n        }\n      }\n    });\n\n    if (fmt_count == 0) {\n      return preview;\n    }\n\n    // Allocate space for copying styles and entities.\n    preview.fmt = [];\n    if (Array.isArray(ent) && ent_refs.length > 0) {\n      preview.ent = [];\n    }\n\n    // Insertion point for styles.\n    let fmt_idx = 0;\n    fmt.forEach((st) => {\n      if (st.at < len) {\n        const style = {\n          at: st.at,\n          len: st.len | 0\n        };\n        if (st.tp) {\n          style.tp = '' + st.tp;\n        } else if (Array.isArray(ent) && ent.length > st.key && typeof ent_refs[st.key] == 'number') {\n          style.key = ent_refs[st.key];\n          preview.ent[style.key] = copyLight(ent[st.key]);\n        } else {\n          return;\n        }\n        preview.fmt[fmt_idx++] = style;\n      }\n    });\n  }\n\n  return preview;\n}\n\n// Create a copy of an entity without large data.\nfunction copyLight(ent) {\n  let result = {\n    tp: ent.tp\n  };\n  if (ent.data && Object.entries(ent.data).length != 0) {\n    const dc = {};\n    [\"mime\", \"name\", \"width\", \"height\", \"size\"].forEach((key) => {\n      const val = ent.data[key];\n      if (val) {\n        dc[key] = val;\n      }\n    });\n    if (Object.entries(dc).length != 0) {\n      result.data = dc;\n    }\n  }\n  return result;\n}\n\nif (typeof module != 'undefined') {\n  module.exports = Drafty;\n}\n","/**\n * @file Utilities for uploading and downloading files.\n *\n * @copyright 2015-2021 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.17\n */\n'use strict';\n\nconst { jsonParseHelper } = require('./utils.js');\n\nlet XHRProvider;\n\n/**\n * @class LargeFileHelper - utilities for uploading and downloading files out of band.\n * Don't instantiate this class directly. Use {Tinode.getLargeFileHelper} instead.\n * @memberof Tinode\n *\n * @param {Tinode} tinode - the main Tinode object.\n * @param {string} version - protocol version, i.e. '0'.\n */\nconst LargeFileHelper = function(tinode, version) {\n  this._tinode = tinode;\n  this._version = version;\n\n  this._apiKey = tinode._apiKey;\n  this._authToken = tinode.getAuthToken();\n  this._reqId = tinode.getNextUniqueId();\n  this.xhr = new XHRProvider();\n\n  // Promise\n  this.toResolve = null;\n  this.toReject = null;\n\n  // Callbacks\n  this.onProgress = null;\n  this.onSuccess = null;\n  this.onFailure = null;\n}\n\nLargeFileHelper.prototype = {\n  /**\n   * Start uploading the file to a non-default endpoint.\n   *\n   * @memberof Tinode.LargeFileHelper#\n   *\n   * @param {string} baseUrl alternative base URL of upload server.\n   * @param {File|Blob} data to upload.\n   * @param {string} avatarFor topic name if the upload represents an avatar.\n   * @param {Callback} onProgress callback. Takes one {float} parameter 0..1\n   * @param {Callback} onSuccess callback. Called when the file is successfully uploaded.\n   * @param {Callback} onFailure callback. Called in case of a failure.\n   *\n   * @returns {Promise} resolved/rejected when the upload is completed/failed.\n   */\n  uploadWithBaseUrl: function(baseUrl, data, avatarFor, onProgress, onSuccess, onFailure) {\n    if (!this._authToken) {\n      throw new Error(\"Must authenticate first\");\n    }\n    const instance = this;\n\n    let url = `/v${this._version}/file/u/`;\n    if (baseUrl) {\n      let base = baseUrl;\n      if (base.endsWith('/')) {\n        // Removing trailing slash.\n        base = base.slice(0, -1);\n      }\n      if (base.startsWith('http://') || base.startsWith('https://')) {\n        url = base + url;\n      } else {\n        throw new Error(`Invalid base URL '${baseUrl}'`);\n      }\n    }\n    this.xhr.open('POST', url, true);\n    this.xhr.setRequestHeader('X-Tinode-APIKey', this._apiKey);\n    this.xhr.setRequestHeader('X-Tinode-Auth', `Token ${this._authToken.token}`);\n    const result = new Promise((resolve, reject) => {\n      this.toResolve = resolve;\n      this.toReject = reject;\n    });\n\n    this.onProgress = onProgress;\n    this.onSuccess = onSuccess;\n    this.onFailure = onFailure;\n\n    this.xhr.upload.onprogress = (e) => {\n      if (e.lengthComputable && instance.onProgress) {\n        instance.onProgress(e.loaded / e.total);\n      }\n    }\n\n    this.xhr.onload = function() {\n      let pkt;\n      try {\n        pkt = JSON.parse(this.response, jsonParseHelper);\n      } catch (err) {\n        instance._tinode.logger(\"ERROR: Invalid server response in LargeFileHelper\", this.response);\n        pkt = {\n          ctrl: {\n            code: this.status,\n            text: this.statusText\n          }\n        };\n      }\n\n      if (this.status >= 200 && this.status < 300) {\n        if (instance.toResolve) {\n          instance.toResolve(pkt.ctrl.params.url);\n        }\n        if (instance.onSuccess) {\n          instance.onSuccess(pkt.ctrl);\n        }\n      } else if (this.status >= 400) {\n        if (instance.toReject) {\n          instance.toReject(new Error(`${pkt.ctrl.text} (${pkt.ctrl.code})`));\n        }\n        if (instance.onFailure) {\n          instance.onFailure(pkt.ctrl)\n        }\n      } else {\n        instance._tinode.logger(\"ERROR: Unexpected server response status\", this.status, this.response);\n      }\n    };\n\n    this.xhr.onerror = function(e) {\n      if (instance.toReject) {\n        instance.toReject(new Error(\"failed\"));\n      }\n      if (instance.onFailure) {\n        instance.onFailure(null);\n      }\n    };\n\n    this.xhr.onabort = function(e) {\n      if (instance.toReject) {\n        instance.toReject(new Error(\"upload cancelled by user\"));\n      }\n      if (instance.onFailure) {\n        instance.onFailure(null);\n      }\n    };\n\n    try {\n      const form = new FormData();\n      form.append('file', data);\n      form.set('id', this._reqId);\n      if (avatarFor) {\n        form.set('topic', avatarFor);\n      }\n      this.xhr.send(form);\n    } catch (err) {\n      if (this.toReject) {\n        this.toReject(err);\n      }\n      if (this.onFailure) {\n        this.onFailure(null);\n      }\n    }\n\n    return result;\n  },\n\n  /**\n   * Start uploading the file to default endpoint.\n   *\n   * @memberof Tinode.LargeFileHelper#\n   *\n   * @param {File|Blob} data to upload\n   * @param {string} avatarFor topic name if the upload represents an avatar.\n   * @param {Callback} onProgress callback. Takes one {float} parameter 0..1\n   * @param {Callback} onSuccess callback. Called when the file is successfully uploaded.\n   * @param {Callback} onFailure callback. Called in case of a failure.\n   *\n   * @returns {Promise} resolved/rejected when the upload is completed/failed.\n   */\n  upload: function(data, avatarFor, onProgress, onSuccess, onFailure) {\n    const baseUrl = (this._tinode._secure ? 'https://' : 'http://') + this._tinode._host;\n    return this.uploadWithBaseUrl(baseUrl, data, avatarFor, onProgress, onSuccess, onFailure);\n  },\n\n  /**\n   * Download the file from a given URL using GET request. This method works with the Tinode server only.\n   *\n   * @memberof Tinode.LargeFileHelper#\n   *\n   * @param {string} relativeUrl - URL to download the file from. Must be relative url, i.e. must not contain the host.\n   * @param {string=} filename - file name to use for the downloaded file.\n   *\n   * @returns {Promise} resolved/rejected when the download is completed/failed.\n   */\n  download: function(relativeUrl, filename, mimetype, onProgress, onError) {\n    if (!Tinode.isRelativeURL(relativeUrl)) {\n      // As a security measure refuse to download from an absolute URL.\n      if (onError) {\n        onError(`The URL '${relativeUrl}' must be relative, not absolute`);\n      }\n      return;\n    }\n    if (!this._authToken) {\n      if (onError) {\n        onError(\"Must authenticate first\");\n      }\n      return;\n    }\n    const instance = this;\n    // Get data as blob (stored by the browser as a temporary file).\n    this.xhr.open('GET', relativeUrl, true);\n    this.xhr.setRequestHeader('X-Tinode-APIKey', this._apiKey);\n    this.xhr.setRequestHeader('X-Tinode-Auth', 'Token ' + this._authToken.token);\n    this.xhr.responseType = 'blob';\n\n    this.onProgress = onProgress;\n    this.xhr.onprogress = function(e) {\n      if (instance.onProgress) {\n        // Passing e.loaded instead of e.loaded/e.total because e.total\n        // is always 0 with gzip compression enabled by the server.\n        instance.onProgress(e.loaded);\n      }\n    };\n\n    const result = new Promise((resolve, reject) => {\n      this.toResolve = resolve;\n      this.toReject = reject;\n    });\n\n    // The blob needs to be saved as file. There is no known way to\n    // save the blob as file other than to fake a click on an <a href... download=...>.\n    this.xhr.onload = function() {\n      if (this.status == 200) {\n        const link = document.createElement('a');\n        // URL.createObjectURL is not available in non-browser environment. This call will fail.\n        link.href = window.URL.createObjectURL(new Blob([this.response], {\n          type: mimetype\n        }));\n        link.style.display = 'none';\n        link.setAttribute('download', filename);\n        document.body.appendChild(link);\n        link.click();\n        document.body.removeChild(link);\n        window.URL.revokeObjectURL(link.href);\n        if (instance.toResolve) {\n          instance.toResolve();\n        }\n      } else if (this.status >= 400 && instance.toReject) {\n        // The this.responseText is undefined, must use this.response which is a blob.\n        // Need to convert this.response to JSON. The blob can only be accessed by the\n        // FileReader.\n        const reader = new FileReader();\n        reader.onload = function() {\n          try {\n            const pkt = JSON.parse(this.result, jsonParseHelper);\n            instance.toReject(new Error(`${pkt.ctrl.text} (${pkt.ctrl.code})`));\n          } catch (err) {\n            instance._tinode.logger(\"ERROR: Invalid server response in LargeFileHelper\", this.result);\n            instance.toReject(err);\n          }\n        };\n        reader.readAsText(this.response);\n      }\n    };\n\n    this.xhr.onerror = function(e) {\n      if (instance.toReject) {\n        instance.toReject(new Error(\"failed\"));\n      }\n    };\n\n    this.xhr.onabort = function() {\n      if (instance.toReject) {\n        instance.toReject(null);\n      }\n    };\n\n    try {\n      this.xhr.send();\n    } catch (err) {\n      if (this.toReject) {\n        this.toReject(err);\n      }\n    }\n\n    return result;\n  },\n\n  /**\n   * Try to cancel an ongoing upload or download.\n   * @memberof Tinode.LargeFileHelper#\n   */\n  cancel: function() {\n    if (this.xhr && this.xhr.readyState < 4) {\n      this.xhr.abort();\n    }\n  },\n\n  /**\n   * Get unique id of this request.\n   * @memberof Tinode.LargeFileHelper#\n   *\n   * @returns {string} unique id\n   */\n  getId: function() {\n    return this._reqId;\n  }\n};\n\n/**\n * To use LargeFileHelper in a non browser context, supply XMLHttpRequest provider.\n * @static\n * @memberof LargeFileHelper\n * @param xhrProvider XMLHttpRequest provider, e.g. for node <code>require('xhr')</code>.\n */\nLargeFileHelper.setNetworkProvider = function(xhrProvider) {\n  XHRProvider = xhrProvider;\n};\n\nif (typeof module != 'undefined') {\n  module.exports = LargeFileHelper;\n}\n","/**\n * @file Helper class for constructing {@link Tinode.GetQuery}.\n *\n * @copyright 2015-2021 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.17\n */\n'use strict';\n\n/**\n * Helper class for constructing {@link Tinode.GetQuery}.\n *\n * @class MetaGetBuilder\n * @memberof Tinode\n *\n * @param {Tinode.Topic} parent topic which instantiated this builder.\n */\nconst MetaGetBuilder = function(parent) {\n  this.topic = parent;\n  this.what = {};\n}\n\nMetaGetBuilder.prototype = {\n\n  // Get timestamp of the most recent desc update.\n  _get_desc_ims: function() {\n    return this.topic.updated;\n  },\n\n  // Get timestamp of the most recent subs update.\n  _get_subs_ims: function() {\n    if (this.topic.isP2PType()) {\n      return this._get_desc_ims();\n    }\n    return this.topic._lastSubsUpdate;\n  },\n\n  /**\n   * Add query parameters to fetch messages within explicit limits.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} since - messages newer than this (inclusive);\n   * @param {number=} before - older than this (exclusive)\n   * @param {number=} limit - number of messages to fetch\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withData: function(since, before, limit) {\n    this.what['data'] = {\n      since: since,\n      before: before,\n      limit: limit\n    };\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch messages newer than the latest saved message.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} limit - number of messages to fetch\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withLaterData: function(limit) {\n    return this.withData(this.topic._maxSeq > 0 ? this.topic._maxSeq + 1 : undefined, undefined, limit);\n  },\n\n  /**\n   * Add query parameters to fetch messages older than the earliest saved message.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} limit - maximum number of messages to fetch.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withEarlierData: function(limit) {\n    return this.withData(undefined, this.topic._minSeq > 0 ? this.topic._minSeq : undefined, limit);\n  },\n\n  /**\n   * Add query parameters to fetch topic description if it's newer than the given timestamp.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {Date=} ims - fetch messages newer than this timestamp.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withDesc: function(ims) {\n    this.what['desc'] = {\n      ims: ims\n    };\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch topic description if it's newer than the last update.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withLaterDesc: function() {\n    return this.withDesc(this._get_desc_ims());\n  },\n\n  /**\n   * Add query parameters to fetch subscriptions.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {Date=} ims - fetch subscriptions modified more recently than this timestamp\n   * @param {number=} limit - maximum number of subscriptions to fetch.\n   * @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withSub: function(ims, limit, userOrTopic) {\n    const opts = {\n      ims: ims,\n      limit: limit\n    };\n    if (this.topic.getType() == 'me') {\n      opts.topic = userOrTopic;\n    } else {\n      opts.user = userOrTopic;\n    }\n    this.what['sub'] = opts;\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch a single subscription.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {Date=} ims - fetch subscriptions modified more recently than this timestamp\n   * @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withOneSub: function(ims, userOrTopic) {\n    return this.withSub(ims, undefined, userOrTopic);\n  },\n\n  /**\n   * Add query parameters to fetch a single subscription if it's been updated since the last update.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withLaterOneSub: function(userOrTopic) {\n    return this.withOneSub(this.topic._lastSubsUpdate, userOrTopic);\n  },\n\n  /**\n   * Add query parameters to fetch subscriptions updated since the last update.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} limit - maximum number of subscriptions to fetch.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withLaterSub: function(limit) {\n    return this.withSub(this._get_subs_ims(), limit);\n  },\n\n  /**\n   * Add query parameters to fetch topic tags.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withTags: function() {\n    this.what['tags'] = true;\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch user's credentials. <code>'me'</code> topic only.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withCred: function() {\n    if (this.topic.getType() == 'me') {\n      this.what['cred'] = true;\n    } else {\n      this.topic._tinode.logger(\"ERROR: Invalid topic type for MetaGetBuilder:withCreds\", this.topic.getType());\n    }\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch deleted messages within explicit limits. Any/all parameters can be null.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} since - ids of messages deleted since this 'del' id (inclusive)\n   * @param {number=} limit - number of deleted message ids to fetch\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withDel: function(since, limit) {\n    if (since || limit) {\n      this.what['del'] = {\n        since: since,\n        limit: limit\n      };\n    }\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch messages deleted after the saved <code>'del'</code> id.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} limit - number of deleted message ids to fetch\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withLaterDel: function(limit) {\n    // Specify 'since' only if we have already received some messages. If\n    // we have no locally cached messages then we don't care if any messages were deleted.\n    return this.withDel(this.topic._maxSeq > 0 ? this.topic._maxDel + 1 : undefined, limit);\n  },\n\n  /**\n   * Construct parameters.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @returns {Tinode.GetQuery} Get query\n   */\n  build: function() {\n    const what = [];\n    const instance = this;\n    let params = {};\n    ['data', 'sub', 'desc', 'tags', 'cred', 'del'].map(function(key) {\n      if (instance.what.hasOwnProperty(key)) {\n        what.push(key);\n        if (Object.getOwnPropertyNames(instance.what[key]).length > 0) {\n          params[key] = instance.what[key];\n        }\n      }\n    });\n    if (what.length > 0) {\n      params.what = what.join(' ');\n    } else {\n      params = undefined;\n    }\n    return params;\n  }\n};\n\nif (typeof module != 'undefined') {\n  module.exports = MetaGetBuilder;\n}\n","/**\n * @file SDK to connect to Tinode chat server.\n * See <a href=\"https://github.com/tinode/webapp\">\n * https://github.com/tinode/webapp</a> for real-life usage.\n *\n * @copyright 2015-2021 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.17\n *\n * @example\n * <head>\n * <script src=\".../tinode.js\"></script>\n * </head>\n *\n * <body>\n *  ...\n * <script>\n *  // Instantiate tinode.\n *  const tinode = new Tinode(APP_NAME, HOST, API_KEY, null, true);\n *  tinode.enableLogging(true);\n *  // Add logic to handle disconnects.\n *  tinode.onDisconnect = function(err) { ... };\n *  // Connect to the server.\n *  tinode.connect().then(() => {\n *    // Connected. Login now.\n *    return tinode.loginBasic(login, password);\n *  }).then((ctrl) => {\n *    // Logged in fine, attach callbacks, subscribe to 'me'.\n *    const me = tinode.getMeTopic();\n *    me.onMetaDesc = function(meta) { ... };\n *    // Subscribe, fetch topic description and the list of contacts.\n *    me.subscribe({get: {desc: {}, sub: {}});\n *  }).catch((err) => {\n *    // Login or subscription failed, do something.\n *    ...\n *  });\n *  ...\n * </script>\n * </body>\n */\n'use strict';\n\n// NOTE TO DEVELOPERS:\n// Localizable strings should be double quoted \"строка на другом языке\",\n// non-localizable strings should be single quoted 'non-localized'.\n\n// Module imports Node.js style.\nif (typeof require != 'function') {\n  throw new Error(\"Unable to load modules: require() is not available.\");\n}\n\nconst AccessMode = require('./access-mode.js');\nconst CBuffer = require('./cbuffer.js');\nconst Connection = require('./connection.js');\nconst DBCache = require('./db.js');\nconst Drafty = require('./drafty.js');\nconst LargeFileHelper = require('./large-file.js');\nconst MetaGetBuilder = require('./meta-builder.js');\nconst {\n  jsonParseHelper\n} = require('./utils.js');\n\nconst package_version = require('../version.json').version;\n\nlet WebSocketProvider;\nif (typeof WebSocket != 'undefined') {\n  WebSocketProvider = WebSocket;\n}\n\nlet XHRProvider;\nif (typeof XMLHttpRequest != 'undefined') {\n  XHRProvider = XMLHttpRequest;\n}\n\ninitForNonBrowserApp();\n\n// Global constants\nconst PROTOCOL_VERSION = '0'; // Major component of the version, e.g. '0' in '0.17.1'.\nconst VERSION = package_version || '0.17';\nconst LIBRARY = 'tinodejs/' + VERSION;\n\nconst TOPIC_NEW = 'new';\nconst TOPIC_NEW_CHAN = 'nch';\nconst TOPIC_ME = 'me';\nconst TOPIC_FND = 'fnd';\nconst TOPIC_SYS = 'sys';\nconst TOPIC_CHAN = 'chn';\nconst USER_NEW = 'new';\n\n// Starting value of a locally-generated seqId used for pending messages.\nconst LOCAL_SEQID = 0xFFFFFFF;\n\nconst MESSAGE_STATUS_NONE = 0; // Status not assigned.\nconst MESSAGE_STATUS_QUEUED = 1; // Local ID assigned, in progress to be sent.\nconst MESSAGE_STATUS_SENDING = 2; // Transmission started.\nconst MESSAGE_STATUS_FAILED = 3; // At least one attempt was made to send the message.\nconst MESSAGE_STATUS_SENT = 4; // Delivered to the server.\nconst MESSAGE_STATUS_RECEIVED = 5; // Received by the client.\nconst MESSAGE_STATUS_READ = 6; // Read by the user.\nconst MESSAGE_STATUS_TO_ME = 7; // Message from another user.\nconst MESSAGE_STATUS_DEL_RANGE = 8; // Message is a deleted range.\n\n// Reject unresolved futures after this many milliseconds.\nconst EXPIRE_PROMISES_TIMEOUT = 5000;\n// Periodicity of garbage collection of unresolved futures.\nconst EXPIRE_PROMISES_PERIOD = 1000;\n\n// Default number of messages to pull into memory from persistent cache.\nconst DEFAULT_MESSAGES_PAGE = 24;\n\n// Utility functions\n\n// Polyfill for non-browser context, e.g. NodeJs.\nfunction initForNonBrowserApp() {\n  // Tinode requirement in native mode because react native doesn't provide Base64 method\n  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\n  if (typeof btoa == 'undefined') {\n    global.btoa = function(input = '') {\n      let str = input;\n      let output = '';\n\n      for (let block = 0, charCode, i = 0, map = chars; str.charAt(i | 0) || (map = '=', i % 1); output += map.charAt(63 & block >> 8 - i % 1 * 8)) {\n\n        charCode = str.charCodeAt(i += 3 / 4);\n\n        if (charCode > 0xFF) {\n          throw new Error(\"'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.\");\n        }\n        block = block << 8 | charCode;\n      }\n\n      return output;\n    };\n  }\n\n  if (typeof atob == 'undefined') {\n    global.atob = function(input = '') {\n      let str = input.replace(/=+$/, '');\n      let output = '';\n\n      if (str.length % 4 == 1) {\n        throw new Error(\"'atob' failed: The string to be decoded is not correctly encoded.\");\n      }\n      for (let bc = 0, bs = 0, buffer, i = 0; buffer = str.charAt(i++);\n\n        ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,\n          bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0\n      ) {\n        buffer = chars.indexOf(buffer);\n      }\n\n      return output;\n    };\n  }\n\n  if (typeof window == 'undefined') {\n    global.window = {\n      WebSocket: WebSocketProvider,\n      XMLHttpRequest: XHRProvider,\n      URL: {\n        createObjectURL: function() {\n          throw new Error(\"Unable to use URL.createObjectURL in a non-browser application\");\n        }\n      }\n    }\n  }\n\n  Connection.setNetworkProviders(WebSocketProvider, XHRProvider);\n  LargeFileHelper.setNetworkProvider(XHRProvider);\n}\n\n// Detect find most useful network transport.\nfunction detectTransport() {\n  if (typeof window == 'object') {\n    if (window['WebSocket']) {\n      return 'ws';\n    } else if (window['XMLHttpRequest']) {\n      // The browser or node has no websockets, using long polling.\n      return 'lp';\n    }\n  }\n  return null;\n}\n\n// Checks if 'd' is a valid non-zero date;\nfunction isValidDate(d) {\n  return (d instanceof Date) && !isNaN(d) && (d.getTime() != 0);\n}\n\n// RFC3339 formater of Date\nfunction rfc3339DateString(d) {\n  if (!isValidDate(d)) {\n    return undefined;\n  }\n\n  const pad = function(val, sp) {\n    sp = sp || 2;\n    return '0'.repeat(sp - ('' + val).length) + val;\n  };\n\n  const millis = d.getUTCMilliseconds();\n  return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) +\n    'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) +\n    (millis ? '.' + pad(millis, 3) : '') + 'Z';\n}\n\n// btoa replacement. Stock btoa fails on on non-Latin1 strings.\nfunction b64EncodeUnicode(str) {\n  // The encodeURIComponent percent-encodes UTF-8 string,\n  // then the percent encoding is converted into raw bytes which\n  // can be fed into btoa.\n  return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g,\n    function toSolidBytes(match, p1) {\n      return String.fromCharCode('0x' + p1);\n    }));\n}\n\n// Recursively merge src's own properties to dst.\n// Ignore properties where ignore[property] is true.\n// Array and Date objects are shallow-copied.\nfunction mergeObj(dst, src, ignore) {\n  if (typeof src != 'object') {\n    if (src === Tinode.DEL_CHAR) {\n      return undefined;\n    }\n    if (src === undefined) {\n      return dst;\n    }\n    return src;\n  }\n  // JS is crazy: typeof null is 'object'.\n  if (src === null) {\n    return src;\n  }\n\n  // Handle Date\n  if (src instanceof Date && !isNaN(src)) {\n    return (!dst || !(dst instanceof Date) || isNaN(dst) || dst < src) ? src : dst;\n  }\n\n  // Access mode\n  if (src instanceof AccessMode) {\n    return new AccessMode(src);\n  }\n\n  // Handle Array\n  if (src instanceof Array) {\n    return src;\n  }\n\n  if (!dst || dst === Tinode.DEL_CHAR) {\n    dst = src.constructor();\n  }\n\n  for (let prop in src) {\n    if (src.hasOwnProperty(prop) &&\n      (!ignore || !ignore[prop]) &&\n      (prop != '_noForwarding')) {\n\n      dst[prop] = mergeObj(dst[prop], src[prop]);\n    }\n  }\n  return dst;\n}\n\n// Update object stored in a cache. Returns updated value.\nfunction mergeToCache(cache, key, newval, ignore) {\n  cache[key] = mergeObj(cache[key], newval, ignore);\n  return cache[key];\n}\n\nfunction stringToDate(obj) {\n  if (typeof obj.created == 'string') {\n    obj.created = new Date(obj.created);\n  }\n  if (typeof obj.updated == 'string') {\n    obj.updated = new Date(obj.updated);\n  }\n  if (typeof obj.touched == 'string') {\n    obj.touched = new Date(obj.touched);\n  }\n}\n\n// JSON stringify helper - pre-processor for JSON.stringify\nfunction jsonBuildHelper(key, val) {\n  if (val instanceof Date) {\n    // Convert javascript Date objects to rfc3339 strings\n    val = rfc3339DateString(val);\n  } else if (val instanceof AccessMode) {\n    val = val.jsonHelper();\n  } else if (val === undefined || val === null || val === false ||\n    (Array.isArray(val) && val.length == 0) ||\n    ((typeof val == 'object') && (Object.keys(val).length == 0))) {\n    // strip out empty elements while serializing objects to JSON\n    return undefined;\n  }\n\n  return val;\n};\n\n// Strips all values from an object of they evaluate to false or if their name starts with '_'.\n// Used on all outgoing object before serialization to string.\nfunction simplify(obj) {\n  Object.keys(obj).forEach((key) => {\n    if (key[0] == '_') {\n      // Strip fields like \"obj._key\".\n      delete obj[key];\n    } else if (!obj[key]) {\n      // Strip fields which evaluate to false.\n      delete obj[key];\n    } else if (Array.isArray(obj[key]) && obj[key].length == 0) {\n      // Strip empty arrays.\n      delete obj[key];\n    } else if (!obj[key]) {\n      // Strip fields which evaluate to false.\n      delete obj[key];\n    } else if (obj[key] instanceof Date) {\n      // Strip invalid or zero date.\n      if (!isValidDate(obj[key])) {\n        delete obj[key];\n      }\n    } else if (typeof obj[key] == 'object') {\n      simplify(obj[key]);\n      // Strip empty objects.\n      if (Object.getOwnPropertyNames(obj[key]).length == 0) {\n        delete obj[key];\n      }\n    }\n  });\n  return obj;\n};\n\n// Trim whitespace, strip empty and duplicate elements elements.\n// If the result is an empty array, add a single element \"\\u2421\" (Unicode Del character).\nfunction normalizeArray(arr) {\n  let out = [];\n  if (Array.isArray(arr)) {\n    // Trim, throw away very short and empty tags.\n    for (let i = 0, l = arr.length; i < l; i++) {\n      let t = arr[i];\n      if (t) {\n        t = t.trim().toLowerCase();\n        if (t.length > 1) {\n          out.push(t);\n        }\n      }\n    }\n    out.sort().filter(function(item, pos, ary) {\n      return !pos || item != ary[pos - 1];\n    });\n  }\n  if (out.length == 0) {\n    // Add single tag with a Unicode Del character, otherwise an ampty array\n    // is ambiguos. The Del tag will be stripped by the server.\n    out.push(Tinode.DEL_CHAR);\n  }\n  return out;\n}\n\n// Trims very long strings (encoded images) to make logged packets more readable.\nfunction jsonLoggerHelper(key, val) {\n  if (typeof val == 'string' && val.length > 128) {\n    return '<' + val.length + ', bytes: ' + val.substring(0, 12) + '...' + val.substring(val.length - 12) + '>';\n  }\n  return jsonBuildHelper(key, val);\n};\n\n// Parse browser user agent to extract browser name and version.\nfunction getBrowserInfo(ua, product) {\n  ua = ua || '';\n  let reactnative = '';\n  // Check if this is a ReactNative app.\n  if (/reactnative/i.test(product)) {\n    reactnative = 'ReactNative; ';\n  }\n  let result;\n  // Remove useless string.\n  ua = ua.replace(' (KHTML, like Gecko)', '');\n  // Test for WebKit-based browser.\n  let m = ua.match(/(AppleWebKit\\/[.\\d]+)/i);\n  if (m) {\n    // List of common strings, from more useful to less useful.\n    // All unknown strings get the highest (-1) priority.\n    const priority = ['edg', 'chrome', 'safari', 'mobile', 'version'];\n    let tmp = ua.substr(m.index + m[0].length).split(' ');\n    let tokens = [];\n    let version; // 1.0 in Version/1.0 or undefined;\n    // Split string like 'Name/0.0.0' into ['Name', '0.0.0', 3] where the last element is the priority.\n    for (let i = 0; i < tmp.length; i++) {\n      let m2 = /([\\w.]+)[\\/]([\\.\\d]+)/.exec(tmp[i]);\n      if (m2) {\n        // Unknown values are highest priority (-1).\n        tokens.push([m2[1], m2[2], priority.findIndex((e) => {\n          return m2[1].toLowerCase().startsWith(e);\n        })]);\n        if (m2[1] == 'Version') {\n          version = m2[2];\n        }\n      }\n    }\n    // Sort by priority: more interesting is earlier than less interesting.\n    tokens.sort((a, b) => {\n      return a[2] - b[2];\n    });\n    if (tokens.length > 0) {\n      // Return the least common browser string and version.\n      if (tokens[0][0].toLowerCase().startsWith('edg')) {\n        tokens[0][0] = 'Edge';\n      } else if (tokens[0][0] == 'OPR') {\n        tokens[0][0] = 'Opera';\n      } else if (tokens[0][0] == 'Safari' && version) {\n        tokens[0][1] = version;\n      }\n      result = tokens[0][0] + '/' + tokens[0][1];\n    } else {\n      // Failed to ID the browser. Return the webkit version.\n      result = m[1];\n    }\n  } else if (/firefox/i.test(ua)) {\n    m = /Firefox\\/([.\\d]+)/g.exec(ua);\n    if (m) {\n      result = 'Firefox/' + m[1];\n    } else {\n      result = 'Firefox/?';\n    }\n  } else {\n    // Neither AppleWebKit nor Firefox. Try the last resort.\n    m = /([\\w.]+)\\/([.\\d]+)/.exec(ua);\n    if (m) {\n      result = m[1] + '/' + m[2];\n    } else {\n      m = ua.split(' ');\n      result = m[0];\n    }\n  }\n\n  // Shorten the version to one dot 'a.bb.ccc.d -> a.bb' at most.\n  m = result.split('/');\n  if (m.length > 1) {\n    const v = m[1].split('.');\n    const minor = v[1] ? '.' + v[1].substr(0, 2) : '';\n    result = `${m[0]}/${v[0]}${minor}`;\n  }\n  return reactnative + result;\n}\n\n/**\n * @class Tinode\n *\n * @param {Object} config - configuration parameters.\n * @param {string} config.appName - Name of the calling application to be reported in the User Agent.\n * @param {string} config.host - Host name and optional port number to connect to.\n * @param {string} config.apiKey - API key generated by <code>keygen</code>.\n * @param {string} config.transport - See {@link Tinode.Connection#transport}.\n * @param {boolean} config.secure - Use Secure WebSocket if <code>true</code>.\n * @param {string} config.platform - Optional platform identifier, one of <code>\"ios\"</code>, <code>\"web\"</code>, <code>\"android\"</code>.\n * @param {boolen} config.persist - Use IndexedDB persistent storage.\n * @param {function} onComplete - callback to call when initialization is completed.\n */\nvar Tinode = function(config, onComplete) {\n  this._host = config.host;\n  this._secure = config.secure;\n\n  // Client-provided application name, format <Name>/<version number>\n  this._appName = config.appName || \"Undefined\";\n\n  // API Key.\n  this._apiKey = config.apiKey;\n\n  // Name and version of the browser.\n  this._browser = '';\n  this._platform = config.platform || 'web';\n  // Hardware\n  this._hwos = 'undefined';\n  this._humanLanguage = 'xx';\n  // Underlying OS.\n  if (typeof navigator != 'undefined') {\n    this._browser = getBrowserInfo(navigator.userAgent, navigator.product);\n    this._hwos = navigator.platform;\n    // This is the default language. It could be changed by client.\n    this._humanLanguage = navigator.language || 'en-US';\n  }\n  // Logging to console enabled\n  this._loggingEnabled = false;\n  // When logging, trip long strings (base64-encoded images) for readability\n  this._trimLongStrings = false;\n  // UID of the currently authenticated user.\n  this._myUID = null;\n  // Status of connection: authenticated or not.\n  this._authenticated = false;\n  // Login used in the last successful basic authentication\n  this._login = null;\n  // Token which can be used for login instead of login/password.\n  this._authToken = null;\n  // Counter of received packets\n  this._inPacketCount = 0;\n  // Counter for generating unique message IDs\n  this._messageId = Math.floor((Math.random() * 0xFFFF) + 0xFFFF);\n  // Information about the server, if connected\n  this._serverInfo = null;\n  // Push notification token. Called deviceToken for consistency with the Android SDK.\n  this._deviceToken = null;\n\n  // Cache of pending promises by message id.\n  this._pendingPromises = {};\n  // The Timeout object returned by the reject expired promises setInterval.\n  this._expirePromises = null;\n\n  // Console logger. Babel somehow fails to parse '...rest' parameter.\n  this.logger = (str, ...args) => {\n    if (this._loggingEnabled) {\n      const d = new Date()\n      const dateString = ('0' + d.getUTCHours()).slice(-2) + ':' +\n        ('0' + d.getUTCMinutes()).slice(-2) + ':' +\n        ('0' + d.getUTCSeconds()).slice(-2) + '.' +\n        ('00' + d.getUTCMilliseconds()).slice(-3);\n\n      console.log('[' + dateString + ']', str, args.join(' '));\n    }\n  }\n\n  Connection.logger = this.logger;\n  Drafty.logger = this.logger;\n\n  // WebSocket or long polling network connection.\n  if (config.transport != 'lp' && config.transport != 'ws') {\n    config.transport = detectTransport();\n  }\n  this._connection = new Connection(config, PROTOCOL_VERSION, /* autoreconnect */ true);\n\n  // Tinode's cache of objects\n  this._cache = {};\n\n  const cachePut = this.cachePut = (type, name, obj) => {\n    this._cache[type + ':' + name] = obj;\n  }\n\n  const cacheGet = this.cacheGet = (type, name) => {\n    return this._cache[type + ':' + name];\n  }\n\n  const cacheDel = this.cacheDel = (type, name) => {\n    delete this._cache[type + ':' + name];\n  }\n  // Enumerate all items in cache, call func for each item.\n  // Enumeration stops if func returns true.\n  const cacheMap = this.cacheMap = (type, func, context) => {\n    const key = type ? type + ':' : undefined;\n    for (let idx in this._cache) {\n      if (!key || idx.indexOf(key) == 0) {\n        if (func.call(context, this._cache[idx], idx)) {\n          break;\n        }\n      }\n    }\n  }\n\n  // Make limited cache management available to topic.\n  // Caching user.public only. Everything else is per-topic.\n  this.attachCacheToTopic = (topic) => {\n    topic._tinode = this;\n\n    topic._cacheGetUser = (uid) => {\n      const pub = cacheGet('user', uid);\n      if (pub) {\n        return {\n          user: uid,\n          public: mergeObj({}, pub)\n        };\n      }\n      return undefined;\n    };\n    topic._cachePutUser = (uid, user) => {\n      return cachePut('user', uid, mergeObj({}, user.public));\n    };\n    topic._cacheDelUser = (uid) => {\n      return cacheDel('user', uid);\n    };\n    topic._cachePutSelf = () => {\n      return cachePut('topic', topic.name, topic);\n    }\n    topic._cacheDelSelf = () => {\n      return cacheDel('topic', topic.name);\n    }\n  }\n\n  // Use indexDB for caching topics and messages.\n  this._persist = config.persist;\n  // Initialize object regardless. It simplifies the code.\n  this._db = DBCache((err) => {\n    this.logger(\"DB\", err);\n  }, this.logger);\n\n  if (this._persist) {\n    // Create the persistent cache.\n    // Store promises to be resolved when messages load into memory.\n    const msgs = [];\n    this._db.initDatabase().then(() => {\n      // First load topics into memory.\n      return this._db.mapTopics((data) => {\n        let topic = this.cacheGet('topic', data.name);\n        if (topic) {\n          return;\n        }\n        if (data.name == TOPIC_ME) {\n          topic = new TopicMe();\n        } else if (data.name == TOPIC_FND) {\n          topic = new TopicFnd();\n        } else {\n          topic = new Topic(data.name);\n        }\n\n        this._db.deserializeTopic(topic, data);\n        this.attachCacheToTopic(topic);\n        topic._cachePutSelf();\n        // Request to load messages and save the promise.\n        msgs.push(topic._loadMessages(this._db));\n      });\n    }).then(() => {\n      // Then load users.\n      return this._db.mapUsers((data) => {\n        return cachePut('user', data.uid, mergeObj({}, data.public));\n      });\n    }).then(() => {\n      // Now wait for all messages to finish loading.\n      return Promise.all(msgs);\n    }).then(() => {\n      if (onComplete) {\n        onComplete();\n      }\n      this.logger(\"Persistent cache initialized.\");\n    });\n  } else {\n    this._db.deleteDatabase().then(() => {\n      if (onComplete) {\n        onComplete();\n      }\n    });\n  }\n\n  // Resolve or reject a pending promise.\n  // Unresolved promises are stored in _pendingPromises.\n  const execPromise = (id, code, onOK, errorText) => {\n    const callbacks = this._pendingPromises[id];\n    if (callbacks) {\n      delete this._pendingPromises[id];\n      if (code >= 200 && code < 400) {\n        if (callbacks.resolve) {\n          callbacks.resolve(onOK);\n        }\n      } else if (callbacks.reject) {\n        callbacks.reject(new Error(`${errorText} (${code})`));\n      }\n    }\n  }\n\n  // Generator of default promises for sent packets.\n  const makePromise = (id) => {\n    let promise = null;\n    if (id) {\n      promise = new Promise((resolve, reject) => {\n        // Stored callbacks will be called when the response packet with this Id arrives\n        this._pendingPromises[id] = {\n          'resolve': resolve,\n          'reject': reject,\n          'ts': new Date()\n        };\n      })\n    }\n    return promise;\n  }\n\n  // Generates unique message IDs\n  const getNextUniqueId = this.getNextUniqueId = () => {\n    return (this._messageId != 0) ? '' + this._messageId++ : undefined;\n  }\n\n  // Get User Agent string\n  const getUserAgent = () => {\n    return this._appName + ' (' + (this._browser ? this._browser + '; ' : '') + this._hwos + '); ' + LIBRARY;\n  }\n\n  // Generator of packets stubs\n  this.initPacket = (type, topic) => {\n    switch (type) {\n      case 'hi':\n        return {\n          'hi': {\n            'id': getNextUniqueId(),\n            'ver': VERSION,\n            'ua': getUserAgent(),\n            'dev': this._deviceToken,\n            'lang': this._humanLanguage,\n            'platf': this._platform\n          }\n        };\n\n      case 'acc':\n        return {\n          'acc': {\n            'id': getNextUniqueId(),\n            'user': null,\n            'scheme': null,\n            'secret': null,\n            'login': false,\n            'tags': null,\n            'desc': {},\n            'cred': {}\n          }\n        };\n\n      case 'login':\n        return {\n          'login': {\n            'id': getNextUniqueId(),\n            'scheme': null,\n            'secret': null\n          }\n        };\n\n      case 'sub':\n        return {\n          'sub': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'set': {},\n            'get': {}\n          }\n        };\n\n      case 'leave':\n        return {\n          'leave': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'unsub': false\n          }\n        };\n\n      case 'pub':\n        return {\n          'pub': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'noecho': false,\n            'head': null,\n            'content': {}\n          }\n        };\n\n      case 'get':\n        return {\n          'get': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'what': null, // data, sub, desc, space separated list; unknown strings are ignored\n            'desc': {},\n            'sub': {},\n            'data': {}\n          }\n        };\n\n      case 'set':\n        return {\n          'set': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'desc': {},\n            'sub': {},\n            'tags': []\n          }\n        };\n\n      case 'del':\n        return {\n          'del': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'what': null,\n            'delseq': null,\n            'user': null,\n            'hard': false\n          }\n        };\n\n      case 'note':\n        return {\n          'note': {\n            // no id by design\n            'topic': topic,\n            'what': null, // one of \"recv\", \"read\", \"kp\"\n            'seq': undefined // the server-side message id aknowledged as received or read\n          }\n        };\n\n      default:\n        throw new Error(`Unknown packet type requested: ${type}`);\n    }\n  }\n\n  // Send a packet. If packet id is provided return a promise.\n  this.send = (pkt, id) => {\n    let promise;\n    if (id) {\n      promise = makePromise(id);\n    }\n    pkt = simplify(pkt);\n    let msg = JSON.stringify(pkt);\n    this.logger(\"out: \" + (this._trimLongStrings ? JSON.stringify(pkt, jsonLoggerHelper) : msg));\n    try {\n      this._connection.sendText(msg);\n    } catch (err) {\n      // If sendText throws, wrap the error in a promise or rethrow.\n      if (id) {\n        execPromise(id, Connection.NETWORK_ERROR, null, err.message);\n      } else {\n        throw err;\n      }\n    }\n    return promise;\n  }\n\n  // On successful login save server-provided data.\n  this.loginSuccessful = (ctrl) => {\n    if (!ctrl.params || !ctrl.params.user) {\n      return ctrl;\n    }\n    // This is a response to a successful login,\n    // extract UID and security token, save it in Tinode module\n    this._myUID = ctrl.params.user;\n    this._authenticated = (ctrl && ctrl.code >= 200 && ctrl.code < 300);\n    if (ctrl.params && ctrl.params.token && ctrl.params.expires) {\n      this._authToken = {\n        token: ctrl.params.token,\n        expires: new Date(ctrl.params.expires)\n      };\n    } else {\n      this._authToken = null;\n    }\n\n    if (this.onLogin) {\n      this.onLogin(ctrl.code, ctrl.text);\n    }\n\n    return ctrl;\n  }\n\n  // The main message dispatcher.\n  this._connection.onMessage = (data) => {\n    // Skip empty response. This happens when LP times out.\n    if (!data) return;\n\n    this._inPacketCount++;\n\n    // Send raw message to listener\n    if (this.onRawMessage) {\n      this.onRawMessage(data);\n    }\n\n    if (data === '0') {\n      // Server response to a network probe.\n      if (this.onNetworkProbe) {\n        this.onNetworkProbe();\n      }\n      // No processing is necessary.\n      return;\n    }\n\n    let pkt = JSON.parse(data, jsonParseHelper);\n    if (!pkt) {\n      this.logger(\"in: \" + data);\n      this.logger(\"ERROR: failed to parse data\");\n    } else {\n      this.logger(\"in: \" + (this._trimLongStrings ? JSON.stringify(pkt, jsonLoggerHelper) : data));\n\n      // Send complete packet to listener\n      if (this.onMessage) {\n        this.onMessage(pkt);\n      }\n\n      if (pkt.ctrl) {\n        // Handling {ctrl} message\n        if (this.onCtrlMessage) {\n          this.onCtrlMessage(pkt.ctrl);\n        }\n\n        // Resolve or reject a pending promise, if any\n        if (pkt.ctrl.id) {\n          execPromise(pkt.ctrl.id, pkt.ctrl.code, pkt.ctrl, pkt.ctrl.text);\n        }\n        setTimeout(() => {\n          if (pkt.ctrl.code == 205 && pkt.ctrl.text == 'evicted') {\n            // User evicted from topic.\n            const topic = cacheGet('topic', pkt.ctrl.topic);\n            if (topic) {\n              topic._resetSub();\n              if (pkt.ctrl.params && pkt.ctrl.params.unsub) {\n                topic._gone();\n              }\n            }\n          } else if (pkt.ctrl.code < 300 && pkt.ctrl.params) {\n            if (pkt.ctrl.params.what == 'data') {\n              // code=208, all messages received: \"params\":{\"count\":11,\"what\":\"data\"},\n              const topic = cacheGet('topic', pkt.ctrl.topic);\n              if (topic) {\n                topic._allMessagesReceived(pkt.ctrl.params.count);\n              }\n            } else if (pkt.ctrl.params.what == 'sub') {\n              // code=204, the topic has no (refreshed) subscriptions.\n              const topic = cacheGet('topic', pkt.ctrl.topic);\n              if (topic) {\n                // Trigger topic.onSubsUpdated.\n                topic._processMetaSub([]);\n              }\n            }\n          }\n        }, 0);\n      } else {\n        setTimeout(() => {\n          if (pkt.meta) {\n            // Handling a {meta} message.\n\n            // Preferred API: Route meta to topic, if one is registered\n            const topic = cacheGet('topic', pkt.meta.topic);\n            if (topic) {\n              topic._routeMeta(pkt.meta);\n            }\n\n            if (pkt.meta.id) {\n              execPromise(pkt.meta.id, 200, pkt.meta, 'META');\n            }\n\n            // Secondary API: callback\n            if (this.onMetaMessage) {\n              this.onMetaMessage(pkt.meta);\n            }\n          } else if (pkt.data) {\n            // Handling {data} message\n\n            // Preferred API: Route data to topic, if one is registered\n            const topic = cacheGet('topic', pkt.data.topic);\n            if (topic) {\n              topic._routeData(pkt.data);\n            }\n\n            // Secondary API: Call callback\n            if (this.onDataMessage) {\n              this.onDataMessage(pkt.data);\n            }\n          } else if (pkt.pres) {\n            // Handling {pres} message\n\n            // Preferred API: Route presence to topic, if one is registered\n            const topic = cacheGet('topic', pkt.pres.topic);\n            if (topic) {\n              topic._routePres(pkt.pres);\n            }\n\n            // Secondary API - callback\n            if (this.onPresMessage) {\n              this.onPresMessage(pkt.pres);\n            }\n          } else if (pkt.info) {\n            // {info} message - read/received notifications and key presses\n\n            // Preferred API: Route {info}} to topic, if one is registered\n            const topic = cacheGet('topic', pkt.info.topic);\n            if (topic) {\n              topic._routeInfo(pkt.info);\n            }\n\n            // Secondary API - callback\n            if (this.onInfoMessage) {\n              this.onInfoMessage(pkt.info);\n            }\n          } else {\n            this.logger(\"ERROR: Unknown packet received.\");\n          }\n        }, 0);\n      }\n    }\n  }\n\n  // Ready to start sending.\n  this._connection.onOpen = () => {\n    if (!this._expirePromises) {\n      // Reject promises which have not been resolved for too long.\n      this._expirePromises = setInterval(() => {\n        const err = new Error(\"Timeout (504)\");\n        const expires = new Date(new Date().getTime() - EXPIRE_PROMISES_TIMEOUT);\n        for (let id in this._pendingPromises) {\n          let callbacks = this._pendingPromises[id];\n          if (callbacks && callbacks.ts < expires) {\n            this.logger(\"Promise expired\", id);\n            delete this._pendingPromises[id];\n            if (callbacks.reject) {\n              callbacks.reject(err);\n            }\n          }\n        }\n      }, EXPIRE_PROMISES_PERIOD);\n    }\n    this.hello();\n  }\n\n  // Wrapper for the reconnect iterator callback.\n  this._connection.onAutoreconnectIteration = (timeout, promise) => {\n    if (this.onAutoreconnectIteration) {\n      this.onAutoreconnectIteration(timeout, promise);\n    }\n  }\n\n  this._connection.onDisconnect = (err, code) => {\n    this._inPacketCount = 0;\n    this._serverInfo = null;\n    this._authenticated = false;\n\n    if (this._expirePromises) {\n      clearInterval(this._expirePromises);\n      this._expirePromises = null;\n    }\n\n    // Mark all topics as unsubscribed\n    cacheMap('topic', (topic, key) => {\n      topic._resetSub();\n    });\n\n    // Reject all pending promises\n    for (let key in this._pendingPromises) {\n      const callbacks = this._pendingPromises[key];\n      if (callbacks && callbacks.reject) {\n        callbacks.reject(err);\n      }\n    }\n    this._pendingPromises = {};\n\n    if (this.onDisconnect) {\n      this.onDisconnect(err);\n    }\n  }\n};\n\n// Static methods.\n\n/**\n * @typedef Credential\n * @type {object}\n * @property {string} meth - validation method.\n * @property {string} val - value to validate (e.g. email or phone number).\n * @property {string} resp - validation response.\n * @property {Object} params - validation parameters.\n */\n/**\n * Helper method to package account credential.\n *\n * @memberof Tinode\n * @static\n *\n * @param {string | Credential} meth - validation method or object with validation data.\n * @param {string=} val - validation value (e.g. email or phone number).\n * @param {Object=} params - validation parameters.\n * @param {string=} resp - validation response.\n *\n * @returns {Array.<Credential>} array with a single credential or <code>null</code> if no valid credentials were given.\n */\nTinode.credential = function(meth, val, params, resp) {\n  if (typeof meth == 'object') {\n    ({\n      val,\n      params,\n      resp,\n      meth\n    } = meth);\n  }\n  if (meth && (val || resp)) {\n    return [{\n      'meth': meth,\n      'val': val,\n      'resp': resp,\n      'params': params\n    }];\n  }\n  return null;\n};\n\n/**\n * Determine topic type from topic's name: grp, p2p, me, fnd, sys.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {string} One of <code>\"me\"</code>, <code>\"fnd\"</code>, <code>\"sys\"</code>, <code>\"grp\"</code>,\n *    <code>\"p2p\"</code> or <code>undefined</code>.\n */\nTinode.topicType = function(name) {\n  const types = {\n    'me': 'me',\n    'fnd': 'fnd',\n    'grp': 'grp',\n    'new': 'grp',\n    'nch': 'grp',\n    'chn': 'grp',\n    'usr': 'p2p',\n    'sys': 'sys'\n  };\n  return types[(typeof name == 'string') ? name.substring(0, 3) : 'xxx'];\n};\n\n/**\n * Check if the given topic name is a name of a 'me' topic.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {boolean} <code>true</code> if the name is a name of a 'me' topic, <code>false</code> otherwise.\n */\nTinode.isMeTopicName = function(name) {\n  return Tinode.topicType(name) == 'me';\n};\n\n/**\n * Check if the given topic name is a name of a group topic.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {boolean} <code>true</code> if the name is a name of a group topic, <code>false</code> otherwise.\n */\nTinode.isGroupTopicName = function(name) {\n  return Tinode.topicType(name) == 'grp';\n};\n\n/**\n * Check if the given topic name is a name of a p2p topic.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {boolean} <code>true</code> if the name is a name of a p2p topic, <code>false</code> otherwise.\n */\nTinode.isP2PTopicName = function(name) {\n  return Tinode.topicType(name) == 'p2p';\n};\n\n/**\n * Check if the given topic name is a name of a communication topic, i.e. P2P or group.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {boolean} <code>true</code> if the name is a name of a p2p or group topic, <code>false</code> otherwise.\n */\nTinode.isCommTopicName = function(name) {\n  return Tinode.isP2PTopicName(name) || Tinode.isGroupTopicName(name);\n};\n\n/**\n * Check if the topic name is a name of a new topic.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - topic name to check.\n * @returns {boolean} <code>true</code> if the name is a name of a new topic, <code>false</code> otherwise.\n */\nTinode.isNewGroupTopicName = function(name) {\n  return (typeof name == 'string') &&\n    (name.substring(0, 3) == TOPIC_NEW || name.substring(0, 3) == TOPIC_NEW_CHAN);\n};\n\n/**\n * Check if the topic name is a name of a channel.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - topic name to check.\n * @returns {boolean} <code>true</code> if the name is a name of a channel, <code>false</code> otherwise.\n */\nTinode.isChannelTopicName = function(name) {\n  return (typeof name == 'string') &&\n    (name.substring(0, 3) == TOPIC_CHAN || name.substring(0, 3) == TOPIC_NEW_CHAN);\n};\n\n/**\n * Return information about the current version of this Tinode client library.\n * @memberof Tinode\n * @static\n *\n * @returns {string} semantic version of the library, e.g. <code>\"0.15.5-rc1\"</code>.\n */\nTinode.getVersion = function() {\n  return VERSION;\n};\n\n/**\n * To use Tinode in a non browser context, supply WebSocket and XMLHttpRequest providers.\n * @static\n * @memberof Tinode\n * @param wsProvider WebSocket provider, e.g. for nodeJS , <code>require('ws')</code>.\n * @param xhrProvider XMLHttpRequest provider, e.g. for node <code>require('xhr')</code>.\n */\nTinode.setNetworkProviders = function(wsProvider, xhrProvider) {\n  WebSocketProvider = wsProvider;\n  XHRProvider = xhrProvider;\n};\n\n/**\n * Return information about the current name and version of this Tinode library.\n * @memberof Tinode\n * @static\n *\n * @returns {string} the name of the library and it's version.\n */\nTinode.getLibrary = function() {\n  return LIBRARY;\n};\n\n// Exported constants\nTinode.MESSAGE_STATUS_NONE = MESSAGE_STATUS_NONE;\nTinode.MESSAGE_STATUS_QUEUED = MESSAGE_STATUS_QUEUED;\nTinode.MESSAGE_STATUS_SENDING = MESSAGE_STATUS_SENDING;\nTinode.MESSAGE_STATUS_FAILED = MESSAGE_STATUS_FAILED;\nTinode.MESSAGE_STATUS_SENT = MESSAGE_STATUS_SENT;\nTinode.MESSAGE_STATUS_RECEIVED = MESSAGE_STATUS_RECEIVED;\nTinode.MESSAGE_STATUS_READ = MESSAGE_STATUS_READ;\nTinode.MESSAGE_STATUS_TO_ME = MESSAGE_STATUS_TO_ME;\nTinode.MESSAGE_STATUS_DEL_RANGE = MESSAGE_STATUS_DEL_RANGE;\n\n// Unicode [del] symbol.\nTinode.DEL_CHAR = '\\u2421';\n\n/**\n * Check if the given string represents <code>NULL</code> value as defined by Tinode (<code>'\\u2421'</code>).\n * @memberof Tinode\n * @static\n *\n * @param {string} str - string to check for <code>NULL</code> value.\n *\n * @returns {boolean} <code>true</code> if string represents <code>NULL</code> value, <code>false</code> otherwise.\n */\nTinode.isNullValue = function(str) {\n  return str === Tinode.DEL_CHAR;\n};\n\n/**\n * Check if the given URL string is a relative URL.\n * Check for cases like:\n *  <code>'http://example.com'</code>\n *  <code>' http://example.com'</code>\n *  <code>'//example.com/'</code>\n *  <code>'http:example.com'</code>\n *  <code>'http:/example.com'</code>\n * @memberof Tinode\n * @static\n *\n * @param {string} url - URL string to check.\n *\n * @returns {boolean} <code>true</code> if the URL is relative, <code>false</code> otherwise.\n */\nTinode.isRelativeURL = function(url) {\n  return !/^\\s*([a-z][a-z0-9+.-]*:|\\/\\/)/im.test(url);\n};\n\n// Names of keys to server-provided configuration limits.\nTinode.MAX_MESSAGE_SIZE = 'maxMessageSize';\nTinode.MAX_SUBSCRIBER_COUNT = 'maxSubscriberCount';\nTinode.MAX_TAG_COUNT = 'maxTagCount';\nTinode.MAX_FILE_UPLOAD_SIZE = 'maxFileUploadSize';\n\n// Public methods;\nTinode.prototype = {\n  /**\n   * Connect to the server.\n   * @memberof Tinode#\n   *\n   * @param {string} host_ - name of the host to connect to.\n   *\n   * @return {Promise} Promise resolved/rejected when the connection call completes:\n   *    <code>resolve()</code> is called without parameters, <code>reject()</code> receives the\n   *    <code>Error</code> as a single parameter.\n   */\n  connect: function(host_) {\n    return this._connection.connect(host_);\n  },\n\n  /**\n   * Attempt to reconnect to the server immediately.\n   * @memberof Tinode#\n   *\n   * @param {string} force - reconnect even if there is a connection already.\n   */\n  reconnect: function(force) {\n    this._connection.reconnect(force);\n  },\n\n  /**\n   * Disconnect from the server.\n   * @memberof Tinode#\n   */\n  disconnect: function() {\n    this._connection.disconnect();\n  },\n\n  /**\n   * Clear persistent cache: remove IndexedDB.\n   * @memberof Tinode#\n   * @return {Promise} Promise resolved/rejected when the operation is completed.\n   */\n  clearStorage: function() {\n    if (this._db.isReady()) {\n      return this._db.deleteDatabase();\n    }\n    return Promise.resolve();\n  },\n\n  /**\n   * Initialize persistent cache: create IndexedDB cache.\n   * @memberof Tinode#\n   * @return {Promise} Promise resolved/rejected when the operation is completed.\n   */\n  initStorage: function() {\n    if (!this._db.isReady()) {\n      return this._db.initDatabase();\n    }\n    return Promise.resolve();\n  },\n\n  /**\n   * Send a network probe message to make sure the connection is alive.\n   * @memberof Tinode#\n   */\n  networkProbe: function() {\n    this._connection.probe();\n  },\n\n  /**\n   * Check for live connection to server.\n   * @memberof Tinode#\n   *\n   * @returns {boolean} <code>true</code> if there is a live connection, <code>false</code> otherwise.\n   */\n  isConnected: function() {\n    return this._connection.isConnected();\n  },\n\n  /**\n   * Check if connection is authenticated (last login was successful).\n   * @memberof Tinode#\n   * @returns {boolean} <code>true</code> if authenticated, <code>false</code> otherwise.\n   */\n  isAuthenticated: function() {\n    return this._authenticated;\n  },\n\n  /**\n   * Add API key and auth token to the relative URL making it usable for getting data\n   * from the server in a simple <code>HTTP GET</code> request.\n   * @memberof Tinode#\n   *\n   * @param {string} URL - URL to wrap.\n   * @returns {string} URL with appended API key and token, if valid token is present.\n   */\n  authorizeURL: function(url) {\n    if (!url) {\n      return url;\n    }\n\n    if (Tinode.isRelativeURL(url)) {\n      // Fake base to make the relative URL parseable.\n      const base = 'scheme://host/';\n      const parsed = new URL(url, base);\n      if (this._apiKey) {\n        parsed.searchParams.append('apikey', this._apiKey);\n      }\n      if (this._authToken.token) {\n        parsed.searchParams.append('auth', 'token');\n        parsed.searchParams.append('secret', this._authToken.token);\n      }\n      // Convert back to string and strip fake base URL except for the root slash.\n      url = parsed.toString().substring(base.length - 1);\n    }\n    return url;\n  },\n\n  /**\n   * @typedef AccountParams\n   * @memberof Tinode\n   * @type {Object}\n   * @property {Tinode.DefAcs=} defacs - Default access parameters for user's <code>me</code> topic.\n   * @property {Object=} public - Public application-defined data exposed on <code>me</code> topic.\n   * @property {Object=} private - Private application-defined data accessible on <code>me</code> topic.\n   * @property {Array} tags - array of string tags for user discovery.\n   * @property {string=} token - authentication token to use.\n   */\n  /**\n   * @typedef DefAcs\n   * @memberof Tinode\n   * @type {Object}\n   * @property {string=} auth - Access mode for <code>me</code> for authenticated users.\n   * @property {string=} anon - Access mode for <code>me</code> for anonymous users.\n   */\n\n  /**\n   * Create or update an account.\n   * @memberof Tinode#\n   *\n   * @param {string} uid - User id to update\n   * @param {string} scheme - Authentication scheme; <code>\"basic\"</code> and <code>\"anonymous\"</code> are the currently supported schemes.\n   * @param {string} secret - Authentication secret, assumed to be already base64 encoded.\n   * @param {boolean=} login - Use new account to authenticate current session\n   * @param {Tinode.AccountParams=} params - User data to pass to the server.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  account: function(uid, scheme, secret, login, params) {\n    const pkt = this.initPacket('acc');\n    pkt.acc.user = uid;\n    pkt.acc.scheme = scheme;\n    pkt.acc.secret = secret;\n    // Log in to the new account using selected scheme\n    pkt.acc.login = login;\n\n    if (params) {\n      pkt.acc.desc.defacs = params.defacs;\n      pkt.acc.desc.public = params.public;\n      pkt.acc.desc.private = params.private;\n\n      pkt.acc.tags = params.tags;\n      pkt.acc.cred = params.cred;\n\n      pkt.acc.token = params.token;\n    }\n\n    return this.send(pkt, pkt.acc.id);\n  },\n\n  /**\n   * Create a new user. Wrapper for {@link Tinode#account}.\n   * @memberof Tinode#\n   *\n   * @param {string} scheme - Authentication scheme; <code>\"basic\"</code> is the only currently supported scheme.\n   * @param {string} secret - Authentication.\n   * @param {boolean=} login - Use new account to authenticate current session\n   * @param {Tinode.AccountParams=} params - User data to pass to the server.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  createAccount: function(scheme, secret, login, params) {\n    let promise = this.account(USER_NEW, scheme, secret, login, params);\n    if (login) {\n      promise = promise.then((ctrl) => {\n        return this.loginSuccessful(ctrl);\n      });\n    }\n    return promise;\n  },\n\n  /**\n   * Create user with <code>'basic'</code> authentication scheme and immediately\n   * use it for authentication. Wrapper for {@link Tinode#account}.\n   * @memberof Tinode#\n   *\n   * @param {string} username - Login to use for the new account.\n   * @param {string} password - User's password.\n   * @param {Tinode.AccountParams=} params - User data to pass to the server.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  createAccountBasic: function(username, password, params) {\n    // Make sure we are not using 'null' or 'undefined';\n    username = username || '';\n    password = password || '';\n    return this.createAccount('basic',\n      b64EncodeUnicode(username + ':' + password), true, params);\n  },\n\n  /**\n   * Update user's credentials for <code>'basic'</code> authentication scheme. Wrapper for {@link Tinode#account}.\n   * @memberof Tinode#\n   *\n   * @param {string} uid - User ID to update.\n   * @param {string} username - Login to use for the new account.\n   * @param {string} password - User's password.\n   * @param {Tinode.AccountParams=} params - data to pass to the server.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  updateAccountBasic: function(uid, username, password, params) {\n    // Make sure we are not using 'null' or 'undefined';\n    username = username || '';\n    password = password || '';\n    return this.account(uid, 'basic',\n      b64EncodeUnicode(username + ':' + password), false, params);\n  },\n\n  /**\n   * Send handshake to the server.\n   * @memberof Tinode#\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  hello: function() {\n    const pkt = this.initPacket('hi');\n\n    return this.send(pkt, pkt.hi.id)\n      .then((ctrl) => {\n        // Reset backoff counter on successful connection.\n        this._connection.backoffReset();\n\n        // Server response contains server protocol version, build, constraints,\n        // session ID for long polling. Save them.\n        if (ctrl.params) {\n          this._serverInfo = ctrl.params;\n        }\n\n        if (this.onConnect) {\n          this.onConnect();\n        }\n\n        return ctrl;\n      }).catch((err) => {\n        this._connection.reconnect(true);\n\n        if (this.onDisconnect) {\n          this.onDisconnect(err);\n        }\n      });\n  },\n\n  /**\n   * Set or refresh the push notifications/device token. If the client is connected,\n   * the deviceToken can be sent to the server.\n   *\n   * @memberof Tinode#\n   * @param {string} dt - token obtained from the provider or <code>false</code>,\n   *    <code>null</code> or <code>undefined</code> to clear the token.\n   *\n   * @returns <code>true</code> if attempt was made to send the update to the server.\n   */\n  setDeviceToken: function(dt) {\n    let sent = false;\n    // Convert any falsish value to null.\n    dt = dt || null;\n    if (dt != this._deviceToken) {\n      this._deviceToken = dt;\n      if (this.isConnected() && this.isAuthenticated()) {\n        this.send({\n          'hi': {\n            'dev': dt || Tinode.DEL_CHAR\n          }\n        });\n        sent = true;\n      }\n    }\n    return sent;\n  },\n\n  /**\n   * Authenticate current session.\n   * @memberof Tinode#\n   *\n   * @param {string} scheme - Authentication scheme; <code>\"basic\"</code> is the only currently supported scheme.\n   * @param {string} secret - Authentication secret, assumed to be already base64 encoded.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  login: function(scheme, secret, cred) {\n    const pkt = this.initPacket('login');\n    pkt.login.scheme = scheme;\n    pkt.login.secret = secret;\n    pkt.login.cred = cred;\n\n    return this.send(pkt, pkt.login.id)\n      .then((ctrl) => {\n        return this.loginSuccessful(ctrl);\n      });\n  },\n\n  /**\n   * Wrapper for {@link Tinode#login} with basic authentication\n   * @memberof Tinode#\n   *\n   * @param {string} uname - User name.\n   * @param {string} password  - Password.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  loginBasic: function(uname, password, cred) {\n    return this.login('basic', b64EncodeUnicode(uname + ':' + password), cred)\n      .then((ctrl) => {\n        this._login = uname;\n        return ctrl;\n      });\n  },\n\n  /**\n   * Wrapper for {@link Tinode#login} with token authentication\n   * @memberof Tinode#\n   *\n   * @param {string} token - Token received in response to earlier login.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  loginToken: function(token, cred) {\n    return this.login('token', token, cred);\n  },\n\n  /**\n   * Send a request for resetting an authentication secret.\n   * @memberof Tinode#\n   *\n   * @param {string} scheme - authentication scheme to reset.\n   * @param {string} method - method to use for resetting the secret, such as \"email\" or \"tel\".\n   * @param {string} value - value of the credential to use, a specific email address or a phone number.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving the server reply.\n   */\n  requestResetAuthSecret: function(scheme, method, value) {\n    return this.login('reset', b64EncodeUnicode(scheme + ':' + method + ':' + value));\n  },\n\n  /**\n   * @typedef AuthToken\n   * @memberof Tinode\n   * @type {Object}\n   * @property {string} token - Token value.\n   * @property {Date} expires - Token expiration time.\n   */\n  /**\n   * Get stored authentication token.\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.AuthToken} authentication token.\n   */\n  getAuthToken: function() {\n    if (this._authToken && (this._authToken.expires.getTime() > Date.now())) {\n      return this._authToken;\n    } else {\n      this._authToken = null;\n    }\n    return null;\n  },\n\n  /**\n   * Application may provide a saved authentication token.\n   * @memberof Tinode#\n   *\n   * @param {Tinode.AuthToken} token - authentication token.\n   */\n  setAuthToken: function(token) {\n    this._authToken = token;\n  },\n\n  /**\n   * @typedef SetParams\n   * @type {Object}\n   * @memberof Tinode\n   * @property {Tinode.SetDesc=} desc - Topic initialization parameters when creating a new topic or a new subscription.\n   * @property {Tinode.SetSub=} sub - Subscription initialization parameters.\n   */\n  /**\n   * @typedef SetDesc\n   * @type {Object}\n   * @memberof Tinode\n   * @property {Tinode.DefAcs=} defacs - Default access mode.\n   * @property {Object=} public - Free-form topic description, publically accessible.\n   * @property {Object=} private - Free-form topic descriptionaccessible only to the owner.\n   */\n  /**\n   * @typedef SetSub\n   * @type {Object}\n   * @memberof Tinode\n   * @property {string=} user - UID of the user affected by the request. Default (empty) - current user.\n   * @property {string=} mode - User access mode, either requested or assigned dependent on context.\n   * @property {Object=} info - Free-form payload to pass to the invited user or topic manager.\n   */\n  /**\n   * Parameters passed to {@link Tinode#subscribe}.\n   *\n   * @typedef SubscriptionParams\n   * @type {Object}\n   * @memberof Tinode\n   * @property {Tinode.SetParams=} set - Parameters used to initialize topic\n   * @property {Tinode.GetQuery=} get - Query for fetching data from topic.\n   */\n\n  /**\n   * Send a topic subscription request.\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Name of the topic to subscribe to.\n   * @param {Tinode.GetQuery=} getParams - Optional subscription metadata query\n   * @param {Tinode.SetParams=} setParams - Optional initialization parameters\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  subscribe: function(topicName, getParams, setParams) {\n    const pkt = this.initPacket('sub', topicName)\n    if (!topicName) {\n      topicName = TOPIC_NEW;\n    }\n\n    pkt.sub.get = getParams;\n\n    if (setParams) {\n      if (setParams.sub) {\n        pkt.sub.set.sub = setParams.sub;\n      }\n\n      if (setParams.desc) {\n        if (Tinode.isNewGroupTopicName(topicName)) {\n          // Full set.desc params are used for new topics only\n          pkt.sub.set.desc = setParams.desc;\n        } else if (Tinode.isP2PTopicName(topicName) && setParams.desc.defacs) {\n          // Use optional default permissions only.\n          pkt.sub.set.desc = {\n            defacs: setParams.desc.defacs\n          };\n        }\n      }\n\n      if (setParams.tags) {\n        pkt.sub.set.tags = setParams.tags;\n      }\n    }\n\n    return this.send(pkt, pkt.sub.id);\n  },\n\n  /**\n   * Detach and optionally unsubscribe from the topic\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Topic to detach from.\n   * @param {boolean} unsub - If <code>true</code>, detach and unsubscribe, otherwise just detach.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  leave: function(topic, unsub) {\n    const pkt = this.initPacket('leave', topic);\n    pkt.leave.unsub = unsub;\n\n    return this.send(pkt, pkt.leave.id);\n  },\n\n  /**\n   * Create message draft without sending it to the server.\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Name of the topic to publish to.\n   * @param {Object} data - Payload to publish.\n   * @param {boolean=} noEcho - If <code>true</code>, tell the server not to echo the message to the original session.\n   *\n   * @returns {Object} new message which can be sent to the server or otherwise used.\n   */\n  createMessage: function(topic, data, noEcho) {\n    const pkt = this.initPacket('pub', topic);\n\n    let dft = typeof data == 'string' ? Drafty.parse(data) : data;\n    if (dft && !Drafty.isPlainText(dft)) {\n      pkt.pub.head = {\n        mime: Drafty.getContentType()\n      };\n      data = dft;\n    }\n    pkt.pub.noecho = noEcho;\n    pkt.pub.content = data;\n\n    return pkt.pub;\n  },\n\n  /**\n   * Publish {data} message to topic.\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Name of the topic to publish to.\n   * @param {Object} data - Payload to publish.\n   * @param {boolean=} noEcho - If <code>true</code>, tell the server not to echo the message to the original session.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  publish: function(topic, data, noEcho) {\n    return this.publishMessage(\n      this.createMessage(topic, data, noEcho)\n    );\n  },\n\n  /**\n   * Publish message to topic. The message should be created by {@link Tinode#createMessage}.\n   * @memberof Tinode#\n   *\n   * @param {Object} pub - Message to publish.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  publishMessage: function(pub) {\n    // Make a shallow copy. Needed in order to clear locally-assigned temp values;\n    pub = Object.assign({}, pub);\n    pub.seq = undefined;\n    pub.from = undefined;\n    pub.ts = undefined;\n    return this.send({\n      pub: pub\n    }, pub.id);\n  },\n\n  /**\n   * Out of band notification: notify topic that an external (push) notification was recived by the client.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - name of the updated topic.\n   * @param {number} seq - seq ID of the new message.\n   * @param {string=} act - UID of the sender; default is current.\n   */\n  oobNotification: function(topicName, seq, act) {\n    const topic = this.cacheGet('topic', topicName);\n    if (topic) {\n      topic._updateReceived(seq, act);\n      this.getMeTopic()._refreshContact('msg', topic);\n    }\n  },\n\n  /**\n   * @typedef GetQuery\n   * @type {Object}\n   * @memberof Tinode\n   * @property {Tinode.GetOptsType=} desc - If provided (even if empty), fetch topic description.\n   * @property {Tinode.GetOptsType=} sub - If provided (even if empty), fetch topic subscriptions.\n   * @property {Tinode.GetDataType=} data - If provided (even if empty), get messages.\n   */\n\n  /**\n   * @typedef GetOptsType\n   * @type {Object}\n   * @memberof Tinode\n   * @property {Date=} ims - \"If modified since\", fetch data only it was was modified since stated date.\n   * @property {number=} limit - Maximum number of results to return. Ignored when querying topic description.\n   */\n\n  /**\n   * @typedef GetDataType\n   * @type {Object}\n   * @memberof Tinode\n   * @property {number=} since - Load messages with seq id equal or greater than this value.\n   * @property {number=} before - Load messages with seq id lower than this number.\n   * @property {number=} limit - Maximum number of results to return.\n   */\n\n  /**\n   * Request topic metadata\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Name of the topic to query.\n   * @param {Tinode.GetQuery} params - Parameters of the query. Use {@link Tinode.MetaGetBuilder} to generate.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  getMeta: function(topic, params) {\n    const pkt = this.initPacket('get', topic);\n\n    pkt.get = mergeObj(pkt.get, params);\n\n    return this.send(pkt, pkt.get.id);\n  },\n\n  /**\n   * Update topic's metadata: description, subscribtions.\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Topic to update.\n   * @param {Tinode.SetParams} params - topic metadata to update.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  setMeta: function(topic, params) {\n    const pkt = this.initPacket('set', topic);\n    const what = [];\n\n    if (params) {\n      ['desc', 'sub', 'tags', 'cred'].map(function(key) {\n        if (params.hasOwnProperty(key)) {\n          what.push(key);\n          pkt.set[key] = params[key];\n        }\n      });\n    }\n\n    if (what.length == 0) {\n      return Promise.reject(new Error(\"Invalid {set} parameters\"));\n    }\n\n    return this.send(pkt, pkt.set.id);\n  },\n\n  /**\n   * Range of message IDs to delete.\n   *\n   * @typedef DelRange\n   * @type {Object}\n   * @memberof Tinode\n   * @property {number} low - low end of the range, inclusive (closed).\n   * @property {number=} hi - high end of the range, exclusive (open).\n   */\n  /**\n   * Delete some or all messages in a topic.\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Topic name to delete messages from.\n   * @param {Tinode.DelRange[]} list - Ranges of message IDs to delete.\n   * @param {boolean=} hard - Hard or soft delete\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delMessages: function(topic, ranges, hard) {\n    const pkt = this.initPacket('del', topic);\n\n    pkt.del.what = 'msg';\n    pkt.del.delseq = ranges;\n    pkt.del.hard = hard;\n\n    return this.send(pkt, pkt.del.id);\n  },\n\n  /**\n   * Delete the topic alltogether. Requires Owner permission.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic to delete\n   * @param {boolean} hard - hard-delete topic.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delTopic: function(topicName, hard) {\n    const pkt = this.initPacket('del', topicName);\n    pkt.del.what = 'topic';\n    pkt.del.hard = hard;\n\n    return this.send(pkt, pkt.del.id);\n  },\n\n  /**\n   * Delete subscription. Requires Share permission.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic to delete\n   * @param {string} user - User ID to remove.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delSubscription: function(topicName, user) {\n    const pkt = this.initPacket('del', topicName);\n    pkt.del.what = 'sub';\n    pkt.del.user = user;\n\n    return this.send(pkt, pkt.del.id);\n  },\n\n  /**\n   * Delete credential. Always sent on <code>'me'</code> topic.\n   * @memberof Tinode#\n   *\n   * @param {string} method - validation method such as <code>'email'</code> or <code>'tel'</code>.\n   * @param {string} value - validation value, i.e. <code>'alice@example.com'</code>.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delCredential: function(method, value) {\n    const pkt = this.initPacket('del', TOPIC_ME);\n    pkt.del.what = 'cred';\n    pkt.del.cred = {\n      meth: method,\n      val: value\n    };\n\n    return this.send(pkt, pkt.del.id);\n  },\n\n  /**\n   * Request to delete account of the current user.\n   * @memberof Tinode#\n   *\n   * @param {boolean} hard - hard-delete user.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delCurrentUser: function(hard) {\n    const pkt = this.initPacket('del', null);\n    pkt.del.what = 'user';\n    pkt.del.hard = hard;\n\n    return this.send(pkt, pkt.del.id).then((ctrl) => {\n      this._myUID = null;\n    });\n  },\n\n  /**\n   * Notify server that a message or messages were read or received. Does NOT return promise.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic where the mesage is being aknowledged.\n   * @param {string} what - Action being aknowledged, either <code>\"read\"</code> or <code>\"recv\"</code>.\n   * @param {number} seq - Maximum id of the message being acknowledged.\n   */\n  note: function(topicName, what, seq) {\n    if (seq <= 0 || seq >= LOCAL_SEQID) {\n      throw new Error(`Invalid message id ${seq}`);\n    }\n\n    const pkt = this.initPacket('note', topicName);\n    pkt.note.what = what;\n    pkt.note.seq = seq;\n    this.send(pkt);\n  },\n\n  /**\n   * Broadcast a key-press notification to topic subscribers. Used to show\n   * typing notifications \"user X is typing...\".\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic to broadcast to.\n   */\n  noteKeyPress: function(topicName) {\n    const pkt = this.initPacket('note', topicName);\n    pkt.note.what = 'kp';\n    this.send(pkt);\n  },\n\n  /**\n   * Get a named topic, either pull it from cache or create a new instance.\n   * There is a single instance of topic for each name.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic to get.\n   * @returns {Tinode.Topic} Requested or newly created topic or <code>undefined</code> if topic name is invalid.\n   */\n  getTopic: function(topicName) {\n    let topic = this.cacheGet('topic', topicName);\n    if (!topic && topicName) {\n      if (topicName == TOPIC_ME) {\n        topic = new TopicMe();\n      } else if (topicName == TOPIC_FND) {\n        topic = new TopicFnd();\n      } else {\n        topic = new Topic(topicName);\n      }\n      // Cache management.\n      this.attachCacheToTopic(topic);\n      topic._cachePutSelf();\n      // Don't save to DB here: a record will be added when the topic is subscribed.\n    }\n    return topic;\n  },\n\n  /**\n   * Check if named topic is already present in cache.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic to check.\n   * @returns {boolean} true if topic is found in cache, false oterwise.\n   */\n  isTopicCached: function(topicName) {\n    return !!this.cacheGet('topic', topicName);\n  },\n\n  /**\n   * Generate unique name like <code>'new123456'</code> suitable for creating a new group topic.\n   * @memberof Tinode#\n   *\n   * @param {boolean} isChan - if the topic is channel-enabled.\n   * @returns {string} name which can be used for creating a new group topic.\n   */\n  newGroupTopicName: function(isChan) {\n    return (isChan ? TOPIC_NEW_CHAN : TOPIC_NEW) + this.getNextUniqueId();\n  },\n\n  /**\n   * Instantiate <code>'me'</code> topic or get it from cache.\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.TopicMe} Instance of <code>'me'</code> topic.\n   */\n  getMeTopic: function() {\n    return this.getTopic(TOPIC_ME);\n  },\n\n  /**\n   * Instantiate <code>'fnd'</code> (find) topic or get it from cache.\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.Topic} Instance of <code>'fnd'</code> topic.\n   */\n  getFndTopic: function() {\n    return this.getTopic(TOPIC_FND);\n  },\n\n  /**\n   * Create a new {@link LargeFileHelper} instance\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.LargeFileHelper} instance of a {@link Tinode.LargeFileHelper}.\n   */\n  getLargeFileHelper: function() {\n    return new LargeFileHelper(this, PROTOCOL_VERSION);\n  },\n\n  /**\n   * Get the UID of the the current authenticated user.\n   * @memberof Tinode#\n   * @returns {string} UID of the current user or <code>undefined</code> if the session is not yet authenticated or if there is no session.\n   */\n  getCurrentUserID: function() {\n    return this._myUID;\n  },\n\n  /**\n   * Check if the given user ID is equal to the current user's UID.\n   * @memberof Tinode#\n   * @param {string} uid - UID to check.\n   * @returns {boolean} true if the given UID belongs to the current logged in user.\n   */\n  isMe: function(uid) {\n    return this._myUID === uid;\n  },\n\n  /**\n   * Get login used for last successful authentication.\n   * @memberof Tinode#\n   * @returns {string} login last used successfully or <code>undefined</code>.\n   */\n  getCurrentLogin: function() {\n    return this._login;\n  },\n\n  /**\n   * Return information about the server: protocol version and build timestamp.\n   * @memberof Tinode#\n   * @returns {Object} build and version of the server or <code>null</code> if there is no connection or if the first server response has not been received yet.\n   */\n  getServerInfo: function() {\n    return this._serverInfo;\n  },\n\n  /**\n   * Return server-provided configuration value (long integer).\n   * @memberof Tinode#\n   * @param {string} name of the value to return\n   * @param {Object} defaultValue to return in case server limit is not set or not found.\n   * @returns {number} named value.\n   */\n  getServerLimit: function(name, defaultValue) {\n    return (this._serverInfo ? this._serverInfo[name] : null) || defaultValue;\n  },\n\n  /**\n   * Toggle console logging. Logging is off by default.\n   * @memberof Tinode#\n   * @param {boolean} enabled - Set to <code>true</code> to enable logging to console.\n   * @param {boolean} trimLongStrings - Set to <code>true</code> to trim long strings.\n   */\n  enableLogging: function(enabled, trimLongStrings) {\n    this._loggingEnabled = enabled;\n    this._trimLongStrings = enabled && trimLongStrings;\n  },\n\n  /**\n   * Set UI language to report to the server. Must be called before <code>'hi'</code> is sent, otherwise it will not be used.\n   * @memberof Tinode#\n   *\n   * @param {string} hl - human (UI) language, like <code>\"en_US\"</code> or <code>\"zh-Hans\"</code>.\n   */\n  setHumanLanguage: function(hl) {\n    if (hl) {\n      this._humanLanguage = hl;\n    }\n  },\n\n  /**\n   * Check if given topic is online.\n   * @memberof Tinode#\n   *\n   * @param {string} name of the topic to test.\n   * @returns {boolean} true if topic is online, false otherwise.\n   */\n  isTopicOnline: function(name) {\n    const topic = this.cacheGet('topic', name);\n    return topic && topic.online;\n  },\n\n  /**\n   * Get access mode for the given contact.\n   * @memberof Tinode#\n   *\n   * @param {string} name of the topic to query.\n   * @returns {AccessMode} access mode if topic is found, null otherwise.\n   */\n  getTopicAccessMode: function(name) {\n    const topic = this.cacheGet('topic', name);\n    return topic ? topic.acs : null;\n  },\n\n  /**\n   * Include message ID into all subsequest messages to server instructin it to send aknowledgemens.\n   * Required for promises to function. Default is <code>\"on\"</code>.\n   * @memberof Tinode#\n   *\n   * @param {boolean} status - Turn aknowledgemens on or off.\n   * @deprecated\n   */\n  wantAkn: function(status) {\n    if (status) {\n      this._messageId = Math.floor((Math.random() * 0xFFFFFF) + 0xFFFFFF);\n    } else {\n      this._messageId = 0;\n    }\n  },\n\n  // Callbacks:\n  /**\n   * Callback to report when the websocket is opened. The callback has no parameters.\n   * @memberof Tinode#\n   * @type {Tinode.onWebsocketOpen}\n   */\n  onWebsocketOpen: undefined,\n\n  /**\n   * @typedef Tinode.ServerParams\n   * @memberof Tinode\n   * @type {Object}\n   * @property {string} ver - Server version\n   * @property {string} build - Server build\n   * @property {string=} sid - Session ID, long polling connections only.\n   */\n\n  /**\n   * @callback Tinode.onConnect\n   * @param {number} code - Result code\n   * @param {string} text - Text epxplaining the completion, i.e \"OK\" or an error message.\n   * @param {Tinode.ServerParams} params - Parameters returned by the server.\n   */\n  /**\n   * Callback to report when connection with Tinode server is established.\n   * @memberof Tinode#\n   * @type {Tinode.onConnect}\n   */\n  onConnect: undefined,\n\n  /**\n   * Callback to report when connection is lost. The callback has no parameters.\n   * @memberof Tinode#\n   * @type {Tinode.onDisconnect}\n   */\n  onDisconnect: undefined,\n\n  /**\n   * @callback Tinode.onLogin\n   * @param {number} code - NUmeric completion code, same as HTTP status codes.\n   * @param {string} text - Explanation of the completion code.\n   */\n  /**\n   * Callback to report login completion.\n   * @memberof Tinode#\n   * @type {Tinode.onLogin}\n   */\n  onLogin: undefined,\n\n  /**\n   * Callback to receive <code>{ctrl}</code> (control) messages.\n   * @memberof Tinode#\n   * @type {Tinode.onCtrlMessage}\n   */\n  onCtrlMessage: undefined,\n\n  /**\n   * Callback to recieve <code>{data}</code> (content) messages.\n   * @memberof Tinode#\n   * @type {Tinode.onDataMessage}\n   */\n  onDataMessage: undefined,\n\n  /**\n   * Callback to receive <code>{pres}</code> (presence) messages.\n   * @memberof Tinode#\n   * @type {Tinode.onPresMessage}\n   */\n  onPresMessage: undefined,\n\n  /**\n   * Callback to receive all messages as objects.\n   * @memberof Tinode#\n   * @type {Tinode.onMessage}\n   */\n  onMessage: undefined,\n\n  /**\n   * Callback to receive all messages as unparsed text.\n   * @memberof Tinode#\n   * @type {Tinode.onRawMessage}\n   */\n  onRawMessage: undefined,\n\n  /**\n   * Callback to receive server responses to network probes. See {@link Tinode#networkProbe}\n   * @memberof Tinode#\n   * @type {Tinode.onNetworkProbe}\n   */\n  onNetworkProbe: undefined,\n\n  /**\n   * Callback to be notified when exponential backoff is iterating.\n   * @memberof Tinode#\n   * @type {Tinode.onAutoreconnectIteration}\n   */\n  onAutoreconnectIteration: undefined,\n};\n\n/**\n * @callback Tinode.Topic.onData\n * @param {Data} data - Data packet\n */\n/**\n * Topic is a class representing a logical communication channel.\n * @class Topic\n * @memberof Tinode\n *\n * @param {string} name - Name of the topic to create.\n * @param {Object=} callbacks - Object with various event callbacks.\n * @param {Tinode.Topic.onData} callbacks.onData - Callback which receives a <code>{data}</code> message.\n * @param {callback} callbacks.onMeta - Callback which receives a <code>{meta}</code> message.\n * @param {callback} callbacks.onPres - Callback which receives a <code>{pres}</code> message.\n * @param {callback} callbacks.onInfo - Callback which receives an <code>{info}</code> message.\n * @param {callback} callbacks.onMetaDesc - Callback which receives changes to topic desctioption {@link desc}.\n * @param {callback} callbacks.onMetaSub - Called for a single subscription record change.\n * @param {callback} callbacks.onSubsUpdated - Called after a batch of subscription changes have been recieved and cached.\n * @param {callback} callbacks.onDeleteTopic - Called after the topic is deleted.\n * @param {callback} callbacls.onAllMessagesReceived - Called when all requested <code>{data}</code> messages have been recived.\n */\nvar Topic = function(name, callbacks) {\n  // Parent Tinode object.\n  this._tinode = null;\n\n  // Server-provided data, locally immutable.\n  // topic name\n  this.name = name;\n  // Timestamp when the topic was created.\n  this.created = null;\n  // Timestamp when the topic was last updated.\n  this.updated = null;\n  // Timestamp of the last messages\n  this.touched = new Date(0);\n  // Access mode, see AccessMode\n  this.acs = new AccessMode(null);\n  // per-topic private data\n  this.private = null;\n  // per-topic public data\n  this.public = null;\n\n  // Locally cached data\n  // Subscribed users, for tracking read/recv/msg notifications.\n  this._users = {};\n\n  // Current value of locally issued seqId, used for pending messages.\n  this._queuedSeqId = LOCAL_SEQID;\n\n  // The maximum known {data.seq} value.\n  this._maxSeq = 0;\n  // The minimum known {data.seq} value.\n  this._minSeq = 0;\n  // Indicator that the last request for earlier messages returned 0.\n  this._noEarlierMsgs = false;\n  // The maximum known deletion ID.\n  this._maxDel = 0;\n  // User discovery tags\n  this._tags = [];\n  // Credentials such as email or phone number.\n  this._credentials = [];\n  // Message cache, sorted by message seq values, from old to new.\n  this._messages = CBuffer(function(a, b) {\n    return a.seq - b.seq;\n  }, true);\n  // Boolean, true if the topic is currently live\n  this._subscribed = false;\n  // Timestap of the most recently updated subscription.\n  this._lastSubsUpdate = new Date(0);\n  // Topic created but not yet synced with the server. Used only during initialization.\n  this._new = true;\n\n  // Callbacks\n  if (callbacks) {\n    this.onData = callbacks.onData;\n    this.onMeta = callbacks.onMeta;\n    this.onPres = callbacks.onPres;\n    this.onInfo = callbacks.onInfo;\n    // A single desc update;\n    this.onMetaDesc = callbacks.onMetaDesc;\n    // A single subscription record;\n    this.onMetaSub = callbacks.onMetaSub;\n    // All subscription records received;\n    this.onSubsUpdated = callbacks.onSubsUpdated;\n    this.onTagsUpdated = callbacks.onTagsUpdated;\n    this.onCredsUpdated = callbacks.onCredsUpdated;\n    this.onDeleteTopic = callbacks.onDeleteTopic;\n    this.onAllMessagesReceived = callbacks.onAllMessagesReceived;\n  }\n};\n\nTopic.prototype = {\n  /**\n   * Check if the topic is subscribed.\n   * @memberof Tinode.Topic#\n   * @returns {boolean} True is topic is attached/subscribed, false otherwise.\n   */\n  isSubscribed: function() {\n    return this._subscribed;\n  },\n\n  /**\n   * Request topic to subscribe. Wrapper for {@link Tinode#subscribe}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Tinode.GetQuery=} getParams - get query parameters.\n   * @param {Tinode.SetParams=} setParams - set parameters.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  subscribe: function(getParams, setParams) {\n    // If the topic is already subscribed, return resolved promise\n    if (this._subscribed) {\n      return Promise.resolve(this);\n    }\n\n    // Send subscribe message, handle async response.\n    // If topic name is explicitly provided, use it. If no name, then it's a new group topic,\n    // use \"new\".\n    return this._tinode.subscribe(this.name || TOPIC_NEW, getParams, setParams).then((ctrl) => {\n      if (ctrl.code >= 300) {\n        // Do nothing if subscription status has not changed.\n        return ctrl;\n      }\n\n      this._subscribed = true;\n      this.acs = (ctrl.params && ctrl.params.acs) ? ctrl.params.acs : this.acs;\n\n      // Set topic name for new topics and add it to cache.\n      if (this._new) {\n        this._new = false;\n\n        if (this.name != ctrl.topic) {\n          // Name may change new123456 -> grpAbCdEf. Remove from cache under the old name.\n          this._cacheDelSelf();\n          this.name = ctrl.topic;\n        }\n        this._cachePutSelf();\n\n        this.created = ctrl.ts;\n        this.updated = ctrl.ts;\n        this.touched = ctrl.ts;\n\n        if (this.name != TOPIC_ME && this.name != TOPIC_FND) {\n          // Add the new topic to the list of contacts maintained by the 'me' topic.\n          const me = this._tinode.getMeTopic();\n          if (me.onMetaSub) {\n            me.onMetaSub(this);\n          }\n          if (me.onSubsUpdated) {\n            me.onSubsUpdated([this.name], 1);\n          }\n        }\n\n        if (setParams && setParams.desc) {\n          setParams.desc._noForwarding = true;\n          this._processMetaDesc(setParams.desc);\n        }\n      }\n\n      return ctrl;\n    });\n  },\n\n  /**\n   * Create a draft of a message without sending it to the server.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string | Object} data - Content to wrap in a draft.\n   * @param {boolean=} noEcho - If <code>true</code> server will not echo message back to originating\n   * session. Otherwise the server will send a copy of the message to sender.\n   *\n   * @returns {Object} message draft.\n   */\n  createMessage: function(data, noEcho) {\n    return this._tinode.createMessage(this.name, data, noEcho);\n  },\n\n  /**\n   * Immediately publish data to topic. Wrapper for {@link Tinode#publish}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string | Object} data - Data to publish, either plain string or a Drafty object.\n   * @param {boolean=} noEcho - If <code>true</code> server will not echo message back to originating\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  publish: function(data, noEcho) {\n    return this.publishMessage(this.createMessage(data, noEcho));\n  },\n\n  /**\n   * Publish message created by {@link Tinode.Topic#createMessage}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Object} pub - {data} object to publish. Must be created by {@link Tinode.Topic#createMessage}\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  publishMessage: function(pub) {\n    if (!this._subscribed) {\n      return Promise.reject(new Error(\"Cannot publish on inactive topic\"));\n    }\n\n    // Update header with attachment and out of band image records.\n    if (Drafty.hasEntities(pub.content) && !pub.head.attachments) {\n      const entities = [];\n      Drafty.entities(pub.content, (data) => {\n        if (data && data.ref) {\n          entities.push(data.ref);\n        }\n      });\n      if (entities.length > 0) {\n        pub.head.attachments = entities;\n      }\n    }\n\n    // Send data.\n    pub._sending = true;\n    pub._failed = false;\n    return this._tinode.publishMessage(pub).then((ctrl) => {\n      pub._sending = false;\n      pub.ts = ctrl.ts;\n      this.swapMessageId(pub, ctrl.params.seq);\n      this._routeData(pub);\n      return ctrl;\n    }).catch((err) => {\n      this._tinode.logger(\"WARNING: Message rejected by the server\", err);\n      pub._sending = false;\n      pub._failed = true;\n      if (this.onData) {\n        this.onData();\n      }\n    });\n  },\n\n  /**\n   * Add message to local message cache, send to the server when the promise is resolved.\n   * If promise is null or undefined, the message will be sent immediately.\n   * The message is sent when the\n   * The message should be created by {@link Tinode.Topic#createMessage}.\n   * This is probably not the final API.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Object} pub - Message to use as a draft.\n   * @param {Promise} prom - Message will be sent when this promise is resolved, discarded if rejected.\n   *\n   * @returns {Promise} derived promise.\n   */\n  publishDraft: function(pub, prom) {\n    if (!prom && !this._subscribed) {\n      return Promise.reject(new Error(\"Cannot publish on inactive topic\"));\n    }\n\n    const seq = pub.seq || this._getQueuedSeqId();\n    if (!pub._noForwarding) {\n      // The 'seq', 'ts', and 'from' are added to mimic {data}. They are removed later\n      // before the message is sent.\n\n      pub._noForwarding = true;\n      pub.seq = seq;\n      pub.ts = new Date();\n      pub.from = this._tinode.getCurrentUserID();\n\n      // Don't need an echo message because the message is added to local cache right away.\n      pub.noecho = true;\n      // Add to cache.\n      this._messages.put(pub);\n      this._tinode._db.addMessage(pub);\n\n      if (this.onData) {\n        this.onData(pub);\n      }\n    }\n    // If promise is provided, send the queued message when it's resolved.\n    // If no promise is provided, create a resolved one and send immediately.\n    prom = (prom || Promise.resolve()).then(\n      ( /* argument ignored */ ) => {\n        if (pub._cancelled) {\n          return {\n            code: 300,\n            text: \"cancelled\"\n          };\n        }\n        return this.publishMessage(pub);\n      },\n      (err) => {\n        this._tinode.logger(\"WARNING: Message draft rejected\", err);\n        pub._sending = false;\n        pub._failed = true;\n        this._messages.delAt(this._messages.find(pub));\n        this._tinode._db.remMessages(this.name, pub.seq);\n        if (this.onData) {\n          this.onData();\n        }\n      });\n    return prom;\n  },\n\n  /**\n   * Leave the topic, optionally unsibscribe. Leaving the topic means the topic will stop\n   * receiving updates from the server. Unsubscribing will terminate user's relationship with the topic.\n   * Wrapper for {@link Tinode#leave}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolean=} unsub - If true, unsubscribe, otherwise just leave.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  leave: function(unsub) {\n    // It's possible to unsubscribe (unsub==true) from inactive topic.\n    if (!this._subscribed && !unsub) {\n      return Promise.reject(new Error(\"Cannot leave inactive topic\"));\n    }\n\n    // Send a 'leave' message, handle async response\n    return this._tinode.leave(this.name, unsub).then((ctrl) => {\n      this._resetSub();\n      if (unsub) {\n        this._tinode._db.remTopic(this.name);\n        this._tinode.cacheDel('topic', this.name);\n        this._gone();\n      }\n      return ctrl;\n    });\n  },\n\n  /**\n   * Request topic metadata from the server.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Tinode.GetQuery} request parameters\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  getMeta: function(params) {\n    // Send {get} message, return promise.\n    return this._tinode.getMeta(this.name, params);\n  },\n\n  /**\n   * Request more messages from the server\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} limit number of messages to get.\n   * @param {boolean} forward if true, request newer messages.\n   */\n  getMessagesPage: function(limit, forward) {\n    const query = this.startMetaQuery();\n    if (forward) {\n      query.withLaterData(limit);\n    } else {\n      query.withEarlierData(limit);\n    }\n    let promise = this.getMeta(query.build());\n    if (!forward) {\n      promise = promise.then((ctrl) => {\n        if (ctrl && ctrl.params && !ctrl.params.count) {\n          this._noEarlierMsgs = true;\n        }\n      });\n    }\n    return promise;\n  },\n\n  /**\n   * Update topic metadata.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Tinode.SetParams} params parameters to update.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  setMeta: function(params) {\n    if (params.tags) {\n      params.tags = normalizeArray(params.tags);\n    }\n    // Send Set message, handle async response.\n    return this._tinode.setMeta(this.name, params)\n      .then((ctrl) => {\n        if (ctrl && ctrl.code >= 300) {\n          // Not modified\n          return ctrl;\n        }\n\n        if (params.sub) {\n          params.sub.topic = this.name;\n          if (ctrl.params && ctrl.params.acs) {\n            params.sub.acs = ctrl.params.acs;\n            params.sub.updated = ctrl.ts;\n          }\n          if (!params.sub.user) {\n            // This is a subscription update of the current user.\n            // Assign user ID otherwise the update will be ignored by _processMetaSub.\n            params.sub.user = this._tinode.getCurrentUserID();\n            if (!params.desc) {\n              // Force update to topic's asc.\n              params.desc = {};\n            }\n          }\n          params.sub._noForwarding = true;\n          this._processMetaSub([params.sub]);\n        }\n\n        if (params.desc) {\n          if (ctrl.params && ctrl.params.acs) {\n            params.desc.acs = ctrl.params.acs;\n            params.desc.updated = ctrl.ts;\n          }\n          this._processMetaDesc(params.desc);\n        }\n\n        if (params.tags) {\n          this._processMetaTags(params.tags);\n        }\n        if (params.cred) {\n          this._processMetaCreds([params.cred], true);\n        }\n\n        return ctrl;\n      });\n  },\n\n  /**\n   * Update access mode of the current user or of another topic subsriber.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} uid - UID of the user to update or null to update current user.\n   * @param {string} update - the update value, full or delta.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  updateMode: function(uid, update) {\n    const user = uid ? this.subscriber(uid) : null;\n    const am = user ?\n      user.acs.updateGiven(update).getGiven() :\n      this.getAccessMode().updateWant(update).getWant();\n\n    return this.setMeta({\n      sub: {\n        user: uid,\n        mode: am\n      }\n    });\n  },\n\n  /**\n   * Create new topic subscription. Wrapper for {@link Tinode#setMeta}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} uid - ID of the user to invite\n   * @param {string=} mode - Access mode. <code>null</code> means to use default.\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  invite: function(uid, mode) {\n    return this.setMeta({\n      sub: {\n        user: uid,\n        mode: mode\n      }\n    });\n  },\n\n  /**\n   * Archive or un-archive the topic. Wrapper for {@link Tinode#setMeta}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolean} arch - true to archive the topic, false otherwise.\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  archive: function(arch) {\n    if (this.private && this.private.arch == arch) {\n      return Promise.resolve(arch);\n    }\n    return this.setMeta({\n      desc: {\n        private: {\n          arch: arch ? true : Tinode.DEL_CHAR\n        }\n      }\n    });\n  },\n\n  /**\n   * Delete messages. Hard-deleting messages requires Owner permission.\n   * Wrapper for {@link Tinode#delMessages}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Tinode.DelRange[]} ranges - Ranges of message IDs to delete.\n   * @param {boolean=} hard - Hard or soft delete\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  delMessages: function(ranges, hard) {\n    if (!this._subscribed) {\n      return Promise.reject(new Error(\"Cannot delete messages in inactive topic\"));\n    }\n\n    // Sort ranges in accending order by low, the descending by hi.\n    ranges.sort((r1, r2) => {\n      if (r1.low < r2.low) {\n        return true;\n      }\n      if (r1.low == r2.low) {\n        return !r2.hi || (r1.hi >= r2.hi);\n      }\n      return false;\n    });\n\n    // Remove pending messages from ranges possibly clipping some ranges.\n    let tosend = ranges.reduce((out, r) => {\n      if (r.low < LOCAL_SEQID) {\n        if (!r.hi || r.hi < LOCAL_SEQID) {\n          out.push(r);\n        } else {\n          // Clip hi to max allowed value.\n          out.push({\n            low: r.low,\n            hi: this._maxSeq + 1\n          });\n        }\n      }\n      return out;\n    }, []);\n\n    // Send {del} message, return promise\n    let result;\n    if (tosend.length > 0) {\n      result = this._tinode.delMessages(this.name, tosend, hard);\n    } else {\n      result = Promise.resolve({\n        params: {\n          del: 0\n        }\n      });\n    }\n    // Update local cache.\n    return result.then((ctrl) => {\n      if (ctrl.params.del > this._maxDel) {\n        this._maxDel = ctrl.params.del;\n      }\n\n      ranges.map((r) => {\n        if (r.hi) {\n          this.flushMessageRange(r.low, r.hi);\n        } else {\n          this.flushMessage(r.low);\n        }\n      });\n\n      this._updateDeletedRanges();\n\n      if (this.onData) {\n        // Calling with no parameters to indicate the messages were deleted.\n        this.onData();\n      }\n      return ctrl;\n    });\n  },\n\n  /**\n   * Delete all messages. Hard-deleting messages requires Owner permission.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolean} hardDel - true if messages should be hard-deleted.\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  delMessagesAll: function(hardDel) {\n    if (!this._maxSeq || this._maxSeq <= 0) {\n      // There are no messages to delete.\n      return Promise.resolve();\n    }\n    return this.delMessages([{\n      low: 1,\n      hi: this._maxSeq + 1,\n      _all: true\n    }], hardDel);\n  },\n\n  /**\n   * Delete multiple messages defined by their IDs. Hard-deleting messages requires Owner permission.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Tinode.DelRange[]} list - list of seq IDs to delete\n   * @param {boolean=} hardDel - true if messages should be hard-deleted.\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  delMessagesList: function(list, hardDel) {\n    // Sort the list in ascending order\n    list.sort((a, b) => a - b);\n    // Convert the array of IDs to ranges.\n    let ranges = list.reduce((out, id) => {\n      if (out.length == 0) {\n        // First element.\n        out.push({\n          low: id\n        });\n      } else {\n        let prev = out[out.length - 1];\n        if ((!prev.hi && (id != prev.low + 1)) || (id > prev.hi)) {\n          // New range.\n          out.push({\n            low: id\n          });\n        } else {\n          // Expand existing range.\n          prev.hi = prev.hi ? Math.max(prev.hi, id + 1) : id + 1;\n        }\n      }\n      return out;\n    }, []);\n    // Send {del} message, return promise\n    return this.delMessages(ranges, hardDel)\n  },\n\n  /**\n   * Delete topic. Requires Owner permission. Wrapper for {@link Tinode#delTopic}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolean} hard - had-delete topic.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  delTopic: function(hard) {\n    return this._tinode.delTopic(this.name, hard).then((ctrl) => {\n      this._resetSub();\n      this._gone();\n      return ctrl;\n    });\n  },\n\n  /**\n   * Delete subscription. Requires Share permission. Wrapper for {@link Tinode#delSubscription}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} user - ID of the user to remove subscription for.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  delSubscription: function(user) {\n    if (!this._subscribed) {\n      return Promise.reject(new Error(\"Cannot delete subscription in inactive topic\"));\n    }\n    // Send {del} message, return promise\n    return this._tinode.delSubscription(this.name, user).then((ctrl) => {\n      // Remove the object from the subscription cache;\n      delete this._users[user];\n      // Notify listeners\n      if (this.onSubsUpdated) {\n        this.onSubsUpdated(Object.keys(this._users));\n      }\n      return ctrl;\n    });\n  },\n\n  /**\n   * Send a read/recv notification.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} what - what notification to send: <code>recv</code>, <code>read</code>.\n   * @param {number} seq - ID or the message read or received.\n   */\n  note: function(what, seq) {\n    if (!this._subscribed) {\n      // Cannot sending {note} on an inactive topic\".\n      return;\n    }\n\n    // Update local cache with the new count.\n    const user = this._users[this._tinode.getCurrentUserID()];\n    let update = false;\n    if (user) {\n      // Self-subscription is found.\n      if (!user[what] || user[what] < seq) {\n        user[what] = seq;\n        update = true;\n      }\n    } else {\n      // Self-subscription is not found.\n      update = (this[what] | 0) < seq;\n    }\n\n    if (update) {\n      // Send notification to the server.\n      this._tinode.note(this.name, what, seq);\n      // Update locally cached contact with the new count.\n      this._updateReadRecv(what, seq);\n\n      if (this.acs != null && !this.acs.isMuted()) {\n        const me = this._tinode.getMeTopic();\n        // Sent a notification to 'me' listeners.\n        me._refreshContact(what, this);\n      }\n    }\n  },\n\n  /**\n   * Send a 'recv' receipt. Wrapper for {@link Tinode#noteRecv}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seq - ID of the message to aknowledge.\n   */\n  noteRecv: function(seq) {\n    this.note('recv', seq);\n  },\n\n  /**\n   * Send a 'read' receipt. Wrapper for {@link Tinode#noteRead}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seq - ID of the message to aknowledge or 0/undefined to acknowledge the latest messages.\n   */\n  noteRead: function(seq) {\n    seq = seq || this._maxSeq;\n    if (seq > 0) {\n      this.note('read', seq);\n    }\n  },\n\n  /**\n   * Send a key-press notification. Wrapper for {@link Tinode#noteKeyPress}.\n   * @memberof Tinode.Topic#\n   */\n  noteKeyPress: function() {\n    if (this._subscribed) {\n      this._tinode.noteKeyPress(this.name);\n    } else {\n      this._tinode.logger(\"INFO: Cannot send notification in inactive topic\");\n    }\n  },\n\n  // Update cached read/recv/unread counts.\n  _updateReadRecv: function(what, seq, ts) {\n    let oldVal, doUpdate = false;\n\n    seq = seq | 0;\n    this.seq = this.seq | 0;\n    this.read = this.read | 0;\n    this.recv = this.recv | 0;\n    switch (what) {\n      case 'recv':\n        oldVal = this.recv;\n        this.recv = Math.max(this.recv, seq);\n        doUpdate = (oldVal != this.recv);\n        break;\n      case 'read':\n        oldVal = this.read;\n        this.read = Math.max(this.read, seq);\n        doUpdate = (oldVal != this.read);\n        break;\n      case 'msg':\n        oldVal = this.seq;\n        this.seq = Math.max(this.seq, seq);\n        if (!this.touched || this.touched < ts) {\n          this.touched = ts;\n        }\n        doUpdate = (oldVal != this.seq);\n        break;\n    }\n\n    // Sanity checks.\n    if (this.recv < this.read) {\n      this.recv = this.read;\n      doUpdate = true;\n    }\n    if (this.seq < this.recv) {\n      this.seq = this.recv;\n      if (!this.touched || this.touched < ts) {\n        this.touched = ts;\n      }\n      doUpdate = true;\n    }\n    this.unread = this.seq - this.read;\n    return doUpdate;\n  },\n\n  /**\n   * Get user description from global cache. The user does not need to be a\n   * subscriber of this topic.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} uid - ID of the user to fetch.\n   * @return {Object} user description or undefined.\n   */\n  userDesc: function(uid) {\n    // TODO(gene): handle asynchronous requests\n\n    const user = this._cacheGetUser(uid);\n    if (user) {\n      return user; // Promise.resolve(user)\n    }\n  },\n\n  /**\n   * Get description of the p2p peer from subscription cache.\n   * @memberof Tinode.Topic#\n   *\n   * @return {Object} peer's description or undefined.\n   */\n  p2pPeerDesc: function() {\n    if (!this.isP2PType()) {\n      return undefined;\n    }\n    return this._users[this.name];\n  },\n\n  /**\n   * Iterate over cached subscribers. If callback is undefined, use this.onMetaSub.\n   * @memberof Tinode.Topic#\n   *\n   * @param {function} callback - Callback which will receive subscribers one by one.\n   * @param {Object=} context - Value of `this` inside the `callback`.\n   */\n  subscribers: function(callback, context) {\n    const cb = (callback || this.onMetaSub);\n    if (cb) {\n      for (let idx in this._users) {\n        cb.call(context, this._users[idx], idx, this._users);\n      }\n    }\n  },\n\n  /**\n   * Get a copy of cached tags.\n   * @memberof Tinode.Topic#\n   *\n   * @return {Array.<string>} a copy of tags\n   */\n  tags: function() {\n    // Return a copy.\n    return this._tags.slice(0);\n  },\n\n  /**\n   * Get cached subscription for the given user ID.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} uid - id of the user to query for\n   * @return user description or undefined.\n   */\n  subscriber: function(uid) {\n    return this._users[uid];\n  },\n\n  /**\n   * Iterate over cached messages. If callback is undefined, use this.onData.\n   * @memberof Tinode.Topic#\n   *\n   * @param {function} callback - Callback which will receive messages one by one. See {@link Tinode.CBuffer#forEach}\n   * @param {number} sinceId - Optional seqId to start iterating from (inclusive).\n   * @param {number} beforeId - Optional seqId to stop iterating before (exclusive).\n   * @param {Object} context - Value of `this` inside the `callback`.\n   */\n  messages: function(callback, sinceId, beforeId, context) {\n    const cb = (callback || this.onData);\n    if (cb) {\n      let startIdx = typeof sinceId == 'number' ? this._messages.find({\n        seq: sinceId\n      }, true) : undefined;\n      let beforeIdx = typeof beforeId == 'number' ? this._messages.find({\n        seq: beforeId\n      }, true) : undefined;\n      if (startIdx != -1 && beforeIdx != -1) {\n        this._messages.forEach(cb, startIdx, beforeIdx, context);\n      }\n    }\n  },\n\n  /**\n   * Get the most recent message from cache.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolen} skipDeleted - if the last message is a deleted range, get the one before it.\n   * @returns {Object} the most recent cached message or <code>undefined</code>, if no messages are cached.\n   */\n  latestMessage: function(skipDeleted) {\n    const msg = this._messages.getLast();\n    if (!skipDeleted || !msg || msg._status != MESSAGE_STATUS_DEL_RANGE) {\n      return msg;\n    }\n    return this._messages.getLast(1);\n  },\n\n  /**\n   * Iterate over cached unsent messages. Wraps {@link Tinode.Topic#messages}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {function} callback - Callback which will receive messages one by one. See {@link Tinode.CBuffer#forEach}\n   * @param {Object} context - Value of <code>this</code> inside the <code>callback</code>.\n   */\n  queuedMessages: function(callback, context) {\n    if (!callback) {\n      throw new Error(\"Callback must be provided\");\n    }\n    this.messages(callback, LOCAL_SEQID, undefined, context);\n  },\n\n  /**\n   * Get the number of topic subscribers who marked this message as either recv or read\n   * Current user is excluded from the count.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} what - what action to consider: received <code>\"recv\"</code> or read <code>\"read\"</code>.\n   * @param {number} seq - ID or the message read or received.\n   *\n   * @returns {number} the number of subscribers who marked the message with the given ID as read or received.\n   */\n  msgReceiptCount: function(what, seq) {\n    let count = 0;\n    if (seq > 0) {\n      const me = this._tinode.getCurrentUserID();\n      for (let idx in this._users) {\n        const user = this._users[idx];\n        if (user.user !== me && user[what] >= seq) {\n          count++;\n        }\n      }\n    }\n    return count;\n  },\n\n  /**\n   * Get the number of topic subscribers who marked this message (and all older messages) as read.\n   * The current user is excluded from the count.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seq - message id to check.\n   * @returns {number} number of subscribers who claim to have received the message.\n   */\n  msgReadCount: function(seq) {\n    return this.msgReceiptCount('read', seq);\n  },\n\n  /**\n   * Get the number of topic subscribers who marked this message (and all older messages) as received.\n   * The current user is excluded from the count.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seq - Message id to check.\n   * @returns {number} Number of subscribers who claim to have received the message.\n   */\n  msgRecvCount: function(seq) {\n    return this.msgReceiptCount('recv', seq);\n  },\n\n  /**\n   * Check if cached message IDs indicate that the server may have more messages.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolean} newer - if <code>true</code>, check for newer messages only.\n   */\n  msgHasMoreMessages: function(newer) {\n    return newer ? this.seq > this._maxSeq :\n      // _minSeq could be more than 1, but earlier messages could have been deleted.\n      (this._minSeq > 1 && !this._noEarlierMsgs);\n  },\n\n  /**\n   * Check if the given seq Id is id of the most recent message.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seqId id of the message to check\n   */\n  isNewMessage: function(seqId) {\n    return this._maxSeq <= seqId;\n  },\n\n  /**\n   * Remove one message from local cache.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seqId id of the message to remove from cache.\n   * @returns {Message} removed message or undefined if such message was not found.\n   */\n  flushMessage: function(seqId) {\n    const idx = this._messages.find({\n      seq: seqId\n    });\n    if (idx >= 0) {\n      this._tinode._db.remMessages(this.name, seqId);\n      return this._messages.delAt(idx);\n    }\n    return undefined;\n  },\n\n  /**\n   * Update message's seqId.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Object} pub message object.\n   * @param {number} newSeqId new seq id for pub.\n   */\n  swapMessageId: function(pub, newSeqId) {\n    const idx = this._messages.find(pub);\n    const numMessages = this._messages.length();\n    if (0 <= idx && idx < numMessages) {\n      // Remove message with the old seq ID.\n      this._messages.delAt(idx);\n      this._tinode._db.remMessages(this.name, pub.seq);\n      // Add message with the new seq ID.\n      pub.seq = newSeqId;\n      this._messages.put(pub);\n      this._tinode._db.addMessage(pub);\n    }\n  },\n\n  /**\n   * Remove a range of messages from the local cache.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} fromId seq ID of the first message to remove (inclusive).\n   * @param {number} untilId seqID of the last message to remove (exclusive).\n   *\n   * @returns {Message[]} array of removed messages (could be empty).\n   */\n  flushMessageRange: function(fromId, untilId) {\n    // Remove range from persistent cache.\n    this._tinode._db.remMessages(this.name, fromId, untilId);\n    // start, end: find insertion points (nearest == true).\n    const since = this._messages.find({\n      seq: fromId\n    }, true);\n    return since >= 0 ? this._messages.delRange(since, this._messages.find({\n      seq: untilId\n    }, true)) : [];\n  },\n\n  /**\n   * Attempt to stop message from being sent.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seqId id of the message to stop sending and remove from cache.\n   *\n   * @returns {boolean} <code>true</code> if message was cancelled, <code>false</code> otherwise.\n   */\n  cancelSend: function(seqId) {\n    const idx = this._messages.find({\n      seq: seqId\n    });\n    if (idx >= 0) {\n      const msg = this._messages.getAt(idx);\n      const status = this.msgStatus(msg);\n      if (status == MESSAGE_STATUS_QUEUED || status == MESSAGE_STATUS_FAILED) {\n        this._tinode._db.remMessages(this.name, seqId);\n        msg._cancelled = true;\n        this._messages.delAt(idx);\n        if (this.onData) {\n          // Calling with no parameters to indicate the message was deleted.\n          this.onData();\n        }\n        return true;\n      }\n    }\n    return false;\n  },\n\n  /**\n   * Get type of the topic: me, p2p, grp, fnd...\n   * @memberof Tinode.Topic#\n   *\n   * @returns {string} One of 'me', 'p2p', 'grp', 'fnd', 'sys' or <code>undefined</code>.\n   */\n  getType: function() {\n    return Tinode.topicType(this.name);\n  },\n\n  /**\n   * Get current user's access mode of the topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {Tinode.AccessMode} - user's access mode\n   */\n  getAccessMode: function() {\n    return this.acs;\n  },\n\n  /**\n   * Set current user's access mode of the topic.\n   * @memberof Tinode.Topic#\n   *\n   * @param {AccessMode | Object} acs - access mode to set.\n   */\n  setAccessMode: function(acs) {\n    return this.acs = new AccessMode(acs);\n  },\n\n  /**\n   * Get topic's default access mode.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {Tinode.DefAcs} - access mode, such as {auth: `RWP`, anon: `N`}.\n   */\n  getDefaultAccess: function() {\n    return this.defacs;\n  },\n\n  /**\n   * Initialize new meta {@link Tinode.GetQuery} builder. The query is attched to the current topic.\n   * It will not work correctly if used with a different topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {Tinode.MetaGetBuilder} query attached to the current topic.\n   */\n  startMetaQuery: function() {\n    return new MetaGetBuilder(this);\n  },\n\n  /**\n   * Check if topic is archived, i.e. private.arch == true.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is archived, <code>false</code> otherwise.\n   */\n  isArchived: function() {\n    return !!(this.private && this.private.arch);\n  },\n\n  /**\n   * Check if topic is verified.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is verified, <code>false</code> otherwise.\n   */\n  isVerified: function() {\n    return !!(this.trusted && this.trusted.verified);\n  },\n\n  /**\n   * Check if topic is managed by staff.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is managed by staff, <code>false</code> otherwise.\n   */\n  isStaff: function() {\n    return !!(this.trusted && this.trusted.staff);\n  },\n\n  /**\n   * Check if topic is marked as suspicious.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is suspicious, <code>false</code> otherwise.\n   */\n  isDangerous: function() {\n    return !!(this.trusted && this.trusted.danger);\n  },\n\n  /**\n   * Check if topic is a 'me' topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is a 'me' topic, <code>false</code> otherwise.\n   */\n  isMeType: function() {\n    return Tinode.isMeTopicName(this.name);\n  },\n\n  /**\n   * Check if topic is a channel.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is a channel, <code>false</code> otherwise.\n   */\n  isChannelType: function() {\n    return Tinode.isChannelTopicName(this.name);\n  },\n\n  /**\n   * Check if topic is a group topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is a group, <code>false</code> otherwise.\n   */\n  isGroupType: function() {\n    return Tinode.isGroupTopicName(this.name);\n  },\n\n  /**\n   * Check if topic is a p2p topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is a p2p topic, <code>false</code> otherwise.\n   */\n  isP2PType: function() {\n    return Tinode.isP2PTopicName(this.name);\n  },\n\n  /**\n   * Check if topic is a communication topic, i.e. a group or p2p topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is a p2p or group topic, <code>false</code> otherwise.\n   */\n  isCommType: function() {\n    return Tinode.isCommTopicName(this.name);\n  },\n\n  /**\n   * Get status (queued, sent, received etc) of a given message in the context\n   * of this topic.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Message} msg - message to check for status.\n   * @param {boolean} upd - update chached message status.\n   *\n   * @returns message status constant.\n   */\n  msgStatus: function(msg, upd) {\n    let status = MESSAGE_STATUS_NONE;\n    if (this._tinode.isMe(msg.from)) {\n      if (msg._sending) {\n        status = MESSAGE_STATUS_SENDING;\n      } else if (msg._failed || msg._cancelled) {\n        status = MESSAGE_STATUS_FAILED;\n      } else if (msg.seq >= LOCAL_SEQID) {\n        status = MESSAGE_STATUS_QUEUED;\n      } else if (this.msgReadCount(msg.seq) > 0) {\n        status = MESSAGE_STATUS_READ;\n      } else if (this.msgRecvCount(msg.seq) > 0) {\n        status = MESSAGE_STATUS_RECEIVED;\n      } else if (msg.seq > 0) {\n        status = MESSAGE_STATUS_SENT;\n      }\n    } else if (msg._status == MESSAGE_STATUS_DEL_RANGE) {\n      status == MESSAGE_STATUS_DEL_RANGE;\n    } else {\n      status = MESSAGE_STATUS_TO_ME;\n    }\n\n    if (upd && msg._status != status) {\n      msg._status = status;\n      this._tinode._db.updMessageStatus(this.name, msg.seq, status);\n    }\n\n    return status;\n  },\n\n  // Process data message\n  _routeData: function(data) {\n    if (data.content) {\n      if (!this.touched || this.touched < data.ts) {\n        this.touched = data.ts;\n      }\n    }\n\n    if (data.seq > this._maxSeq) {\n      this._maxSeq = data.seq;\n    }\n    if (data.seq < this._minSeq || this._minSeq == 0) {\n      this._minSeq = data.seq;\n    }\n\n    if (!data._noForwarding) {\n      this._messages.put(data);\n      this._tinode._db.addMessage(data);\n      this._updateDeletedRanges();\n    }\n\n    if (this.onData) {\n      this.onData(data);\n    }\n\n    // Update locally cached contact with the new message count.\n    const what = ((!this.isChannelType() && !data.from) || this._tinode.isMe(data.from)) ? 'read' : 'msg';\n    this._updateReadRecv(what, data.seq, data.ts);\n    // Notify 'me' listeners of the change.\n    this._tinode.getMeTopic()._refreshContact(what, this);\n  },\n\n  // Process metadata message\n  _routeMeta: function(meta) {\n    if (meta.desc) {\n      this._processMetaDesc(meta.desc);\n    }\n    if (meta.sub && meta.sub.length > 0) {\n      this._processMetaSub(meta.sub);\n    }\n    if (meta.del) {\n      this._processDelMessages(meta.del.clear, meta.del.delseq);\n    }\n    if (meta.tags) {\n      this._processMetaTags(meta.tags);\n    }\n    if (meta.cred) {\n      this._processMetaCreds(meta.cred);\n    }\n    if (this.onMeta) {\n      this.onMeta(meta);\n    }\n  },\n\n  // Process presence change message\n  _routePres: function(pres) {\n    let user;\n    switch (pres.what) {\n      case 'del':\n        // Delete cached messages.\n        this._processDelMessages(pres.clear, pres.delseq);\n        break;\n      case 'on':\n      case 'off':\n        // Update online status of a subscription.\n        user = this._users[pres.src];\n        if (user) {\n          user.online = pres.what == 'on';\n        } else {\n          this._tinode.logger(\"WARNING: Presence update for an unknown user\", this.name, pres.src);\n        }\n        break;\n      case 'term':\n        // Attachment to topic is terminated probably due to cluster rehashing.\n        this._resetSub();\n        break;\n      case 'acs':\n        const uid = pres.src || this._tinode.getCurrentUserID();\n        user = this._users[uid];\n        if (!user) {\n          // Update for an unknown user: notification of a new subscription.\n          const acs = new AccessMode().updateAll(pres.dacs);\n          if (acs && acs.mode != AccessMode._NONE) {\n            user = this._cacheGetUser(uid);\n            if (!user) {\n              user = {\n                user: uid,\n                acs: acs\n              };\n              this.getMeta(this.startMetaQuery().withOneSub(undefined, uid).build());\n            } else {\n              user.acs = acs;\n            }\n            user.updated = new Date();\n            this._processMetaSub([user]);\n          }\n        } else {\n          // Known user\n          user.acs.updateAll(pres.dacs);\n          // Update user's access mode.\n          this._processMetaSub([{\n            user: uid,\n            updated: new Date(),\n            acs: user.acs\n          }]);\n        }\n        break;\n      default:\n        this._tinode.logger(\"INFO: Ignored presence update\", pres.what);\n    }\n\n    if (this.onPres) {\n      this.onPres(pres);\n    }\n  },\n\n  // Process {info} message\n  _routeInfo: function(info) {\n    if (info.what !== 'kp') {\n      const user = this._users[info.from];\n      if (user) {\n        user[info.what] = info.seq;\n        if (user.recv < user.read) {\n          user.recv = user.read;\n        }\n      }\n      const msg = this.latestMessage();\n      if (msg) {\n        this.msgStatus(msg, true);\n      }\n\n      // If this is an update from the current user, update the cache with the new count.\n      if (this._tinode.isMe(info.from)) {\n        this._updateReadRecv(info.what, info.seq);\n      }\n\n      // Notify 'me' listener of the status change.\n      this._tinode.getMeTopic()._refreshContact(info.what, this);\n    }\n    if (this.onInfo) {\n      this.onInfo(info);\n    }\n  },\n\n  // Called by Tinode when meta.desc packet is received.\n  // Called by 'me' topic on contact update (desc._noForwarding is true).\n  _processMetaDesc: function(desc) {\n    if (this.isP2PType()) {\n      // Synthetic desc may include defacs for p2p topics which is useless.\n      // Remove it.\n      delete desc.defacs;\n\n      // Update to p2p desc is the same as user update. Update cached user.\n      this._tinode._db.updUser(this.name, desc.public);\n    }\n\n    // Copy parameters from desc object to this topic.\n    mergeObj(this, desc);\n    // Make sure date fields are Date().\n    stringToDate(this);\n    // Update persistent cache.\n    this._tinode._db.updTopic(this);\n\n    // Notify 'me' listener, if available:\n    if (this.name !== TOPIC_ME && !desc._noForwarding) {\n      const me = this._tinode.getMeTopic();\n      if (me.onMetaSub) {\n        me.onMetaSub(this);\n      }\n      if (me.onSubsUpdated) {\n        me.onSubsUpdated([this.name], 1);\n      }\n    }\n\n    if (this.onMetaDesc) {\n      this.onMetaDesc(this);\n    }\n  },\n\n  // Called by Tinode when meta.sub is recived or in response to received\n  // {ctrl} after setMeta-sub.\n  _processMetaSub: function(subs) {\n    for (let idx in subs) {\n      const sub = subs[idx];\n\n      // Fill defaults.\n      sub.updated = new Date(sub.updated);\n      sub.deleted = sub.deleted ? new Date(sub.deleted) : null;\n      sub.online = !!sub.online;\n      // Update timestamp of the most recent subscription update.\n      this._lastSubsUpdate = new Date(Math.max(this._lastSubsUpdate, sub.updated));\n\n      let user = null;\n      if (!sub.deleted) {\n        // If this is a change to user's own permissions, update them in topic too.\n        // Desc will update 'me' topic.\n        if (this._tinode.isMe(sub.user) && sub.acs) {\n          this._processMetaDesc({\n            updated: sub.updated,\n            touched: sub.updated,\n            acs: sub.acs\n          });\n        }\n        user = this._updateCachedUser(sub.user, sub);\n      } else {\n        // Subscription is deleted, remove it from topic (but leave in Users cache)\n        delete this._users[sub.user];\n        user = sub;\n      }\n\n      if (this.onMetaSub) {\n        this.onMetaSub(user);\n      }\n    }\n\n    if (this.onSubsUpdated) {\n      this.onSubsUpdated(Object.keys(this._users));\n    }\n  },\n\n  // Called by Tinode when meta.tags is recived.\n  _processMetaTags: function(tags) {\n    if (tags.length == 1 && tags[0] == Tinode.DEL_CHAR) {\n      tags = [];\n    }\n    this._tags = tags;\n    if (this.onTagsUpdated) {\n      this.onTagsUpdated(tags);\n    }\n  },\n\n  // Do nothing for topics other than 'me'\n  _processMetaCreds: function(creds) {},\n\n  // Delete cached messages and update cached transaction IDs\n  _processDelMessages: function(clear, delseq) {\n    this._maxDel = Math.max(clear, this._maxDel);\n    this.clear = Math.max(clear, this.clear);\n    const topic = this;\n    let count = 0;\n    if (Array.isArray(delseq)) {\n      delseq.map(function(range) {\n        if (!range.hi) {\n          count++;\n          topic.flushMessage(range.low);\n        } else {\n          for (let i = range.low; i < range.hi; i++) {\n            count++;\n            topic.flushMessage(i);\n          }\n        }\n      });\n    }\n\n    if (count > 0) {\n      this._updateDeletedRanges();\n\n      if (this.onData) {\n        this.onData();\n      }\n    }\n  },\n\n  // Topic is informed that the entire response to {get what=data} has been received.\n  _allMessagesReceived: function(count) {\n    this._updateDeletedRanges();\n\n    if (this.onAllMessagesReceived) {\n      this.onAllMessagesReceived(count);\n    }\n  },\n\n  // Reset subscribed state\n  _resetSub: function() {\n    this._subscribed = false;\n  },\n\n  // This topic is either deleted or unsubscribed from.\n  _gone: function() {\n    this._messages.reset();\n    this._tinode._db.remMessages(this.name);\n    this._users = {};\n    this.acs = new AccessMode(null);\n    this.private = null;\n    this.public = null;\n    this._maxSeq = 0;\n    this._minSeq = 0;\n    this._subscribed = false;\n\n    const me = this._tinode.getMeTopic();\n    if (me) {\n      me._routePres({\n        _noForwarding: true,\n        what: 'gone',\n        topic: TOPIC_ME,\n        src: this.name\n      });\n    }\n    if (this.onDeleteTopic) {\n      this.onDeleteTopic();\n    }\n  },\n\n  // Update global user cache and local subscribers cache.\n  // Don't call this method for non-subscribers.\n  _updateCachedUser: function(uid, obj) {\n    // Fetch user object from the global cache.\n    // This is a clone of the stored object\n    let cached = this._cacheGetUser(uid);\n    cached = mergeObj(cached || {}, obj);\n    // Save to global cache\n    this._cachePutUser(uid, cached);\n    // Save to the list of topic subsribers.\n    return mergeToCache(this._users, uid, cached);\n  },\n\n  // Get local seqId for a queued message.\n  _getQueuedSeqId: function() {\n    return this._queuedSeqId++;\n  },\n\n  // Calculate ranges of missing messages.\n  _updateDeletedRanges: function() {\n    const ranges = [];\n\n    let prev = null;\n    // Check for gap in the beginning, before the first message.\n    const first = this._messages.getAt(0);\n    if (first && this._minSeq > 1 && !this._noEarlierMsgs) {\n      // Some messages are missing in the beginning.\n      if (first.hi) {\n        // The first message already represents a gap.\n        if (first.seq > 1) {\n          first.seq = 1;\n        }\n        if (first.hi < this._minSeq - 1) {\n          first.hi = this._minSeq - 1;\n        }\n        prev = first;\n      } else {\n        // Create new gap.\n        prev = {\n          seq: 1,\n          hi: this._minSeq - 1\n        };\n        ranges.push(prev);\n      }\n    } else {\n      // No gap in the beginning.\n      prev = {\n        seq: 0,\n        hi: 0\n      };\n    }\n\n    // Find gaps in the list of received messages. The list contains messages-proper as well\n    // as placeholers for deleted ranges.\n    // The messages are iterated by seq ID in ascending order.\n    this._messages.forEach((data) => {\n      // Do not create a gap between the last sent message and the first unsent.\n      if (data.seq >= LOCAL_SEQID) {\n        return;\n      }\n\n      // New message is reducing the existing gap\n      if (data.seq == (prev.hi || prev.seq) + 1) {\n        // No new gap. Replace previous with current.\n        prev = data;\n        return;\n      }\n\n      // Found a new gap.\n      if (prev.hi) {\n        // Previous is also a gap, alter it.\n        prev.hi = data.hi || data.seq;\n        return;\n      }\n\n      // Previous is not a gap. Create a new gap.\n      prev = {\n        seq: (prev.hi || prev.seq) + 1,\n        hi: data.hi || data.seq\n      };\n      ranges.push(prev);\n    });\n\n    // Check for missing messages at the end.\n    // All messages could be missing or it could be a new topic with no messages.\n    const last = this._messages.getLast();\n    const maxSeq = Math.max(this.seq, this._maxSeq) || 0;\n    if ((maxSeq > 0 && !last) || (last && ((last.hi || last.seq) < maxSeq))) {\n      if (last && last.hi) {\n        // Extend existing gap\n        last.hi = maxSeq;\n      } else {\n        // Create new gap.\n        ranges.push({\n          seq: last ? last.seq + 1 : 1,\n          hi: maxSeq\n        });\n      }\n    }\n\n    // Insert new gaps into cache.\n    ranges.map((gap) => {\n      gap._status = MESSAGE_STATUS_DEL_RANGE;\n      this._messages.put(gap);\n    });\n  },\n\n  // Load most recent messages from persistent cache.\n  _loadMessages: function(db) {\n    return db.readMessages(this.name, {\n        limit: DEFAULT_MESSAGES_PAGE\n      })\n      .then((msgs) => {\n        msgs.forEach((data) => {\n          if (data.seq > this._maxSeq) {\n            this._maxSeq = data.seq;\n          }\n          if (data.seq < this._minSeq || this._minSeq == 0) {\n            this._minSeq = data.seq;\n          }\n          this._messages.put(data);\n        });\n\n        this._updateDeletedRanges();\n        return this.name;\n      });\n  },\n\n  // Push or {pres}: message received.\n  _updateReceived: function(seq, act) {\n    this.touched = new Date();\n    this.seq = seq | 0;\n    // Check if message is sent by the current user. If so it's been read already.\n    if (!act || this._tinode.isMe(act)) {\n      this.read = this.read ? Math.max(this.read, this.seq) : this.seq;\n      this.recv = this.recv ? Math.max(this.read, this.recv) : this.read;\n    }\n    this.unread = this.seq - (this.read | 0);\n    this._tinode._db.updTopic(this);\n  }\n};\n\n/**\n * @class TopicMe - special case of {@link Tinode.Topic} for\n * managing data of the current user, including contact list.\n * @extends Tinode.Topic\n * @memberof Tinode\n *\n * @param {TopicMe.Callbacks} callbacks - Callbacks to receive various events.\n */\nvar TopicMe = function(callbacks) {\n  Topic.call(this, TOPIC_ME, callbacks);\n\n  // me-specific callbacks\n  if (callbacks) {\n    this.onContactUpdate = callbacks.onContactUpdate;\n  }\n};\n\n// Inherit everyting from the generic Topic\nTopicMe.prototype = Object.create(Topic.prototype, {\n  // Override the original Topic._processMetaDesc.\n  _processMetaDesc: {\n    value: function(desc) {\n      // Check if online contacts need to be turned off because P permission was removed.\n      const turnOff = (desc.acs && !desc.acs.isPresencer()) && (this.acs && this.acs.isPresencer());\n\n      // Copy parameters from desc object to this topic.\n      mergeObj(this, desc);\n      this._tinode._db.updTopic(this);\n\n      // String datetime headers to Date() objects.\n      stringToDate(this);\n\n      // 'P' permission was removed. All topics are offline now.\n      if (turnOff) {\n        this._tinode.cacheMap('topic', (cont) => {\n          if (cont.online) {\n            cont.online = false;\n            if (cont.seen) {\n              cont.seen.when = new Date();\n            } else {\n              cont.seen = {\n                when: new Date()\n              };\n            }\n            this._refreshContact('off', cont);\n          }\n        });\n      }\n\n      if (this.onMetaDesc) {\n        this.onMetaDesc(this);\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  // Override the original Topic._processMetaSub\n  _processMetaSub: {\n    value: function(subs) {\n      let updateCount = 0;\n      subs.forEach((sub) => {\n        const topicName = sub.topic;\n        // Don't show 'me' and 'fnd' topics in the list of contacts.\n        if (topicName == TOPIC_FND || topicName == TOPIC_ME) {\n          return;\n        }\n        sub.updated = new Date(sub.updated);\n        sub.touched = sub.touched ? new Date(sub.touched) : undefined;\n        sub.deleted = sub.deleted ? new Date(sub.deleted) : null;\n        sub.online = !!sub.online;\n\n        let cont = null;\n        if (sub.deleted) {\n          cont = sub;\n          this._tinode.cacheDel('topic', topicName);\n          this._tinode._db.remTopic(topicName);\n        } else {\n          // Ensure the values are defined and are integers.\n          if (typeof sub.seq != 'undefined') {\n            sub.seq = sub.seq | 0;\n            sub.recv = sub.recv | 0;\n            sub.read = sub.read | 0;\n            sub.unread = sub.seq - sub.read;\n          }\n\n          if (sub.seen && sub.seen.when) {\n            sub.seen.when = new Date(sub.seen.when);\n          }\n\n          cont = mergeObj(this._tinode.getTopic(topicName), sub);\n          this._tinode._db.updTopic(cont);\n\n          if (Tinode.isP2PTopicName(topicName)) {\n            this._cachePutUser(topicName, cont);\n            this._tinode._db.updUser(topicName, cont.public);\n          }\n          // Notify topic of the update if it's an external update.\n          if (!sub._noForwarding) {\n            const topic = this._tinode.getTopic(topicName);\n            if (topic) {\n              sub._noForwarding = true;\n              topic._processMetaDesc(sub);\n            }\n          }\n        }\n\n        updateCount++;\n\n        if (this.onMetaSub) {\n          this.onMetaSub(cont);\n        }\n      });\n\n      if (this.onSubsUpdated && updateCount > 0) {\n        const keys = [];\n        subs.forEach((s) => {\n          keys.push(s.topic);\n        });\n        this.onSubsUpdated(keys, updateCount);\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  // Called by Tinode when meta.sub is recived.\n  _processMetaCreds: {\n    value: function(creds, upd) {\n      if (creds.length == 1 && creds[0] == Tinode.DEL_CHAR) {\n        creds = [];\n      }\n      if (upd) {\n        creds.map((cr) => {\n          if (cr.val) {\n            // Adding a credential.\n            let idx = this._credentials.findIndex((el) => {\n              return el.meth == cr.meth && el.val == cr.val;\n            });\n            if (idx < 0) {\n              // Not found.\n              if (!cr.done) {\n                // Unconfirmed credential replaces previous unconfirmed credential of the same method.\n                idx = this._credentials.findIndex((el) => {\n                  return el.meth == cr.meth && !el.done;\n                });\n                if (idx >= 0) {\n                  // Remove previous unconfirmed credential.\n                  this._credentials.splice(idx, 1);\n                }\n              }\n              this._credentials.push(cr);\n            } else {\n              // Found. Maybe change 'done' status.\n              this._credentials[idx].done = cr.done;\n            }\n          } else if (cr.resp) {\n            // Handle credential confirmation.\n            const idx = this._credentials.findIndex((el) => {\n              return el.meth == cr.meth && !el.done;\n            });\n            if (idx >= 0) {\n              this._credentials[idx].done = true;\n            }\n          }\n        });\n      } else {\n        this._credentials = creds;\n      }\n      if (this.onCredsUpdated) {\n        this.onCredsUpdated(this._credentials);\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  // Process presence change message\n  _routePres: {\n    value: function(pres) {\n      if (pres.what == 'term') {\n        // The 'me' topic itself is detached. Mark as unsubscribed.\n        this._resetSub();\n        return;\n      }\n\n      if (pres.what == 'upd' && pres.src == TOPIC_ME) {\n        // Update to me's description. Request updated value.\n        this.getMeta(this.startMetaQuery().withDesc().build());\n        return;\n      }\n\n      const cont = this._tinode.cacheGet('topic', pres.src);\n      if (cont) {\n        switch (pres.what) {\n          case 'on': // topic came online\n            cont.online = true;\n            break;\n          case 'off': // topic went offline\n            if (cont.online) {\n              cont.online = false;\n              if (cont.seen) {\n                cont.seen.when = new Date();\n              } else {\n                cont.seen = {\n                  when: new Date()\n                };\n              }\n            }\n            break;\n          case 'msg': // new message received\n            cont._updateReceived(pres.seq, pres.act);\n            break;\n          case 'upd': // desc updated\n            // Request updated subscription.\n            this.getMeta(this.startMetaQuery().withLaterOneSub(pres.src).build());\n            break;\n          case 'acs': // access mode changed\n            if (cont.acs) {\n              cont.acs.updateAll(pres.dacs);\n            } else {\n              cont.acs = new AccessMode().updateAll(pres.dacs);\n            }\n            cont.touched = new Date();\n            break;\n          case 'ua':\n            // user agent changed.\n            cont.seen = {\n              when: new Date(),\n              ua: pres.ua\n            };\n            break;\n          case 'recv':\n            // user's other session marked some messges as received.\n            pres.seq = pres.seq | 0;\n            cont.recv = cont.recv ? Math.max(cont.recv, pres.seq) : pres.seq;\n            break;\n          case 'read':\n            // user's other session marked some messages as read.\n            pres.seq = pres.seq | 0;\n            cont.read = cont.read ? Math.max(cont.read, pres.seq) : pres.seq;\n            cont.recv = cont.recv ? Math.max(cont.read, cont.recv) : cont.recv;\n            cont.unread = cont.seq - cont.read;\n            break;\n          case 'gone':\n            // topic deleted or unsubscribed from.\n            this._tinode.cacheDel('topic', pres.src);\n            this._tinode._db.remTopic(pres.src);\n            break;\n          case 'del':\n            // Update topic.del value.\n            break;\n          default:\n            this._tinode.logger(\"INFO: Unsupported presence update in 'me'\", pres.what);\n        }\n\n        this._refreshContact(pres.what, cont);\n      } else {\n        if (pres.what == 'acs') {\n          // New subscriptions and deleted/banned subscriptions have full\n          // access mode (no + or - in the dacs string). Changes to known subscriptions are sent as\n          // deltas, but they should not happen here.\n          const acs = new AccessMode(pres.dacs);\n          if (!acs || acs.mode == AccessMode._INVALID) {\n            this._tinode.logger(\"ERROR: Invalid access mode update\", pres.src, pres.dacs);\n            return;\n          } else if (acs.mode == AccessMode._NONE) {\n            this._tinode.logger(\"WARNING: Removing non-existent subscription\", pres.src, pres.dacs);\n            return;\n          } else {\n            // New subscription. Send request for the full description.\n            // Using .withOneSub (not .withLaterOneSub) to make sure IfModifiedSince is not set.\n            this.getMeta(this.startMetaQuery().withOneSub(undefined, pres.src).build());\n            // Create a dummy entry to catch online status update.\n            const dummy = this._tinode.getTopic(pres.src);\n            dummy.touched = new Date();\n            dummy.topic = pres.src;\n            dummy.online = false;\n            dummy.acs = acs;\n            this._tinode.attachCacheToTopic(dummy);\n            dummy._cachePutSelf();\n            this._db.updTopic(dummy);\n          }\n        } else if (pres.what == 'tags') {\n          this.getMeta(this.startMetaQuery().withTags().build());\n        }\n      }\n\n      if (this.onPres) {\n        this.onPres(pres);\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  // Contact is updated, execute callbacks.\n  _refreshContact: {\n    value: function(what, cont) {\n      if (this.onContactUpdate) {\n        this.onContactUpdate(what, cont);\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Publishing to TopicMe is not supported. {@link Topic#publish} is overriden and thows an {Error} if called.\n   * @memberof Tinode.TopicMe#\n   * @throws {Error} Always throws an error.\n   */\n  publish: {\n    value: function() {\n      return Promise.reject(new Error(\"Publishing to 'me' is not supported\"));\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Delete validation credential.\n   * @memberof Tinode.TopicMe#\n   *\n   * @param {string} topic - Name of the topic to delete\n   * @param {string} user - User ID to remove.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delCredential: {\n    value: function(method, value) {\n      if (!this._subscribed) {\n        return Promise.reject(new Error(\"Cannot delete credential in inactive 'me' topic\"));\n      }\n      // Send {del} message, return promise\n      return this._tinode.delCredential(method, value).then((ctrl) => {\n        // Remove deleted credential from the cache.\n        const index = this._credentials.findIndex((el) => {\n          return el.meth == method && el.val == value;\n        });\n        if (index > -1) {\n          this._credentials.splice(index, 1);\n        }\n        // Notify listeners\n        if (this.onCredsUpdated) {\n          this.onCredsUpdated(this._credentials);\n        }\n        return ctrl;\n      });\n\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * @callback contactFilter\n   * @param {Object} contact to check for inclusion.\n   * @returns {boolean} <code>true</code> if contact should be processed, <code>false</code> to exclude it.\n   */\n  /**\n   * Iterate over cached contacts.\n   *\n   * @function\n   * @memberof Tinode.TopicMe#\n   * @param {TopicMe.ContactCallback} callback - Callback to call for each contact.\n   * @param {contactFilter=} filter - Optionally filter contacts; include all if filter is false-ish, otherwise\n   *      include those for which filter returns true-ish.\n   * @param {Object=} context - Context to use for calling the `callback`, i.e. the value of `this` inside the callback.\n   */\n  contacts: {\n    value: function(callback, filter, context) {\n      this._tinode.cacheMap('topic', (c, idx) => {\n        if (c.isCommType() && (!filter || filter(c))) {\n          callback.call(context, c, idx);\n        }\n      });\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Get a contact from cache.\n   * @memberof Tinode.TopicMe#\n   *\n   * @param {string} name - Name of the contact to get, either a UID (for p2p topics) or a topic name.\n   * @returns {Tinode.Contact} - Contact or `undefined`.\n   */\n  getContact: {\n    value: function(name) {\n      return this._tinode.cacheGet('topic', name);\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Get access mode of a given contact from cache.\n   * @memberof Tinode.TopicMe#\n   *\n   * @param {string} name - Name of the contact to get access mode for, either a UID (for p2p topics)\n   *        or a topic name; if missing, access mode for the 'me' topic itself.\n   * @returns {string} - access mode, such as `RWP`.\n   */\n  getAccessMode: {\n    value: function(name) {\n      if (name) {\n        const cont = this._tinode.cacheGet('topic', name);\n        return cont ? cont.acs : null;\n      }\n      return this.acs;\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Check if contact is archived, i.e. contact.private.arch == true.\n   * @memberof Tinode.TopicMe#\n   *\n   * @param {string} name - Name of the contact to check archived status, either a UID (for p2p topics) or a topic name.\n   * @returns {boolean} - true if contact is archived, false otherwise.\n   */\n  isArchived: {\n    value: function(name) {\n      const cont = this._tinode.cacheGet('topic', name);\n      return cont ? ((cont.private && cont.private.arch) ? true : false) : null;\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * @typedef Tinode.Credential\n   * @memberof Tinode\n   * @type Object\n   * @property {string} meth - validation method such as 'email' or 'tel'.\n   * @property {string} val - credential value, i.e. 'jdoe@example.com' or '+17025551234'\n   * @property {boolean} done - true if credential is validated.\n   */\n  /**\n   * Get the user's credentials: email, phone, etc.\n   * @memberof Tinode.TopicMe#\n   *\n   * @returns {Tinode.Credential[]} - array of credentials.\n   */\n  getCredentials: {\n    value: function() {\n      return this._credentials;\n    },\n    enumerable: true,\n    configurable: true\n  }\n});\nTopicMe.prototype.constructor = TopicMe;\n\n/**\n * @class TopicFnd - special case of {@link Tinode.Topic} for searching for\n * contacts and group topics.\n * @extends Tinode.Topic\n * @memberof Tinode\n *\n * @param {TopicFnd.Callbacks} callbacks - Callbacks to receive various events.\n */\nvar TopicFnd = function(callbacks) {\n  Topic.call(this, TOPIC_FND, callbacks);\n  // List of users and topics uid or topic_name -> Contact object)\n  this._contacts = {};\n};\n\n// Inherit everyting from the generic Topic\nTopicFnd.prototype = Object.create(Topic.prototype, {\n  // Override the original Topic._processMetaSub\n  _processMetaSub: {\n    value: function(subs) {\n      let updateCount = Object.getOwnPropertyNames(this._contacts).length;\n      // Reset contact list.\n      this._contacts = {};\n      for (let idx in subs) {\n        let sub = subs[idx];\n        const indexBy = sub.topic ? sub.topic : sub.user;\n\n        sub.updated = new Date(sub.updated);\n        if (sub.seen && sub.seen.when) {\n          sub.seen.when = new Date(sub.seen.when);\n        }\n\n        sub = mergeToCache(this._contacts, indexBy, sub);\n        updateCount++;\n\n        if (this.onMetaSub) {\n          this.onMetaSub(sub);\n        }\n      }\n\n      if (updateCount > 0 && this.onSubsUpdated) {\n        this.onSubsUpdated(Object.keys(this._contacts));\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Publishing to TopicFnd is not supported. {@link Topic#publish} is overriden and thows an {Error} if called.\n   * @memberof Tinode.TopicFnd#\n   * @throws {Error} Always throws an error.\n   */\n  publish: {\n    value: function() {\n      return Promise.reject(new Error(\"Publishing to 'fnd' is not supported\"));\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * setMeta to TopicFnd resets contact list in addition to sending the message.\n   * @memberof Tinode.TopicFnd#\n   * @param {Tinode.SetParams} params parameters to update.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  setMeta: {\n    value: function(params) {\n      const instance = this;\n      return Object.getPrototypeOf(TopicFnd.prototype).setMeta.call(this, params).then(function() {\n        if (Object.keys(instance._contacts).length > 0) {\n          instance._contacts = {};\n          if (instance.onSubsUpdated) {\n            instance.onSubsUpdated([]);\n          }\n        }\n      });\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Iterate over found contacts. If callback is undefined, use {@link this.onMetaSub}.\n   * @function\n   * @memberof Tinode.TopicFnd#\n   * @param {TopicFnd.ContactCallback} callback - Callback to call for each contact.\n   * @param {Object} context - Context to use for calling the `callback`, i.e. the value of `this` inside the callback.\n   */\n  contacts: {\n    value: function(callback, context) {\n      const cb = (callback || this.onMetaSub);\n      if (cb) {\n        for (let idx in this._contacts) {\n          cb.call(context, this._contacts[idx], idx, this._contacts);\n        }\n      }\n    },\n    enumerable: true,\n    configurable: true\n  }\n});\nTopicFnd.prototype.constructor = TopicFnd;\n\n/**\n * @class Message - definition a communication message.\n * Work in progress.\n * @memberof Tinode\n *\n * @param {string} topic_ - name of the topic the message belongs to.\n * @param {string | Drafty} content_ - message contant.\n */\nvar Message = function(topic_, content_) {\n  this.status = Message.STATUS_NONE;\n  this.topic = topic_;\n  this.content = content_;\n}\n\nMessage.STATUS_NONE = MESSAGE_STATUS_NONE;\nMessage.STATUS_QUEUED = MESSAGE_STATUS_QUEUED;\nMessage.STATUS_SENDING = MESSAGE_STATUS_SENDING;\nMessage.STATUS_FAILED = MESSAGE_STATUS_FAILED;\nMessage.STATUS_SENT = MESSAGE_STATUS_SENT;\nMessage.STATUS_RECEIVED = MESSAGE_STATUS_RECEIVED;\nMessage.STATUS_READ = MESSAGE_STATUS_READ;\nMessage.STATUS_TO_ME = MESSAGE_STATUS_TO_ME;\n\nMessage.prototype = {\n  /**\n   * Convert message object to {pub} packet.\n   */\n  toJSON: function() {\n\n  },\n  /**\n   * Parse JSON into message.\n   */\n  fromJSON: function(json) {\n\n  }\n}\nMessage.prototype.constructor = Message;\n\nif (typeof module != 'undefined') {\n  module.exports = Tinode;\n  module.exports.Drafty = Drafty;\n  module.exports.AccessMode = AccessMode;\n}\n","/**\n * @file Utilities used in multiple places.\n *\n * @copyright 2015-2021 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.17\n */\n'use strict';\n\nconst AccessMode = require('./access-mode.js');\n\n// Attempt to convert date strings to objects.\nfunction jsonParseHelper(key, val) {\n  // Convert string timestamps with optional milliseconds to Date\n  // 2015-09-02T01:45:43[.123]Z\n  if (key === 'ts' && typeof val === 'string' && val.length >= 20 && val.length <= 24) {\n    const date = new Date(val);\n    if (!isNaN(date)) {\n      return date;\n    }\n  } else if (key === 'acs' && typeof val === 'object') {\n    return new AccessMode(val);\n  }\n  return val;\n}\n\n\nif (typeof module != 'undefined') {\n  module.exports.jsonParseHelper = jsonParseHelper;\n}\n","module.exports={\"version\": \"0.18.0-alpha1\"}\n"]}