(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){
/**
 * @copyright 2015-2019 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';

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
  }
};

// Convert base64-encoded string into Blob.
function base64toObjectUrl(b64, contentType) {
  let bin;
  try {
    bin = atob(b64);
    let length = bin.length;
    let buf = new ArrayBuffer(length);
    let 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) {
    console.log("Drafty: failed to convert object.", err.message);
  }

  return null;
}

// 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 '';
    }
  },
  // 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 previewUrl = base64toObjectUrl(data.val, data.mime);
      const downloadUrl = data.ref ? data.ref : previewUrl;
      return (data.name ? '<a href="' + downloadUrl + '" download="' + data.name + '">' : '') +
        '<img src="' + 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;
      let url = base64toObjectUrl(data.val, data.mime);
      return {
        src: url,
        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 : 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
 */
var 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) {
      // throw out non-visual spans.
      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 = "";
  const ranges = [];
  for (var i in chunks) {
    const chunk = chunks[i];
    if (!chunk.text) {
      var 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 object 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;
}

/**
 * Insert inline image into Drafty document.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content object to add image to.
 * @param {integer} at index where the object is inserted. The length of the image is always 1.
 * @param {string} mime mime-type of the image, e.g. "image/png"
 * @param {string} base64bits base64-encoded image content (or preview, if large image is attached)
 * @param {integer} width width of the image
 * @param {integer} height height of the image
 * @param {string} fname file name suggestion for downloading the image.
 * @param {integer} size size of the external file. Treat is as an untrusted hint.
 * @param {string} refurl reference to the content. Could be null or undefined.
 *
 * @return {Drafty} updated content.
 */
Drafty.insertImage = function(content, at, mime, base64bits, width, height, fname, size, refurl) {
  content = content || {
    txt: " "
  };
  content.ent = content.ent || [];
  content.fmt = content.fmt || [];

  content.fmt.push({
    at: at,
    len: 1,
    key: content.ent.length
  });
  content.ent.push({
    tp: 'IM',
    data: {
      mime: mime,
      val: base64bits,
      width: width,
      height: height,
      name: fname,
      ref: refurl,
      size: size | 0
    }
  });

  return content;
}

/**
 * Append image to Drafty content.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content object to add image to.
 * @param {string} mime mime-type of the image, e.g. "image/png"
 * @param {string} base64bits base64-encoded image content (or preview, if large image is attached)
 * @param {integer} width width of the image
 * @param {integer} height height of the image
 * @param {string} fname file name suggestion for downloading the image.
 * @param {integer} size size of the external file. Treat is as an untrusted hint.
 * @param {string} refurl reference to the content. Could be null or undefined.
 *
 * @return {Drafty} updated content.
 */
Drafty.appendImage = function(content, mime, base64bits, width, height, fname, size, refurl) {
  content = content || {
    txt: ""
  };
  content.txt += " ";
  return Drafty.insertImage(content, content.txt.length - 1, mime, base64bits, width, height, fname, size, refurl);
}

/**
 * Attach file to Drafty content. Either as a blob or as a reference.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content object to attach file to.
 * @param {string} mime mime-type of the file, e.g. "image/png"
 * @param {string} base64bits base64-encoded file content
 * @param {string} fname file name suggestion for downloading.
 * @param {integer} size size of the external file. Treat is as an untrusted hint.
 * @param {string | Promise} refurl optional reference to the content.
 *
 * @return {Drafty} updated content.
 */
Drafty.attachFile = function(content, mime, base64bits, fname, size, refurl) {
  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: mime,
      val: base64bits,
      name: fname,
      ref: refurl,
      size: size | 0
    }
  }
  if (refurl instanceof Promise) {
    ex.data.ref = refurl.then(
      (url) => {
        ex.data.ref = url;
      },
      (err) => {
        /* catch the error, otherwise it will appear in the console. */
      }
    );
  }
  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 content.
 */
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 is Drafty object to insert button to or a string to be used as button text.
 * @param {number} at is location where the button is inserted.
 * @param {number} len is the length of the text to be used as button title.
 * @param {string} name of the button. Client should return it to the server when the button is clicked.
 * @param {string} actionType is the type of the button, one of 'url' or 'pub'.
 * @param {string} actionValue is the value to return on click:
 * @param {string} refUrl is the URL to go to when the 'url' button is clicked.
 *
 * @return {Drafty} updated content.
 */
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 is Drafty object to insert button to or a string to be used as button text.
 * @param {string} title is the text to be used as button title.
 * @param {string} name of the button. Client should return it to the server when the button is clicked.
 * @param {string} actionType is the type of the button, one of 'url' or 'pub'.
 * @param {string} actionValue is the value to return on click:
 * @param {string} refUrl is the URL to go to when the 'url' button is clicked.
 *
 * @return {Drafty} updated content.
 */
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 object to attach file to.
 * @param {Object} data to convert to json string and attach.
 */
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;
}

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 the structured representation of rich text, convert it to HTML.
 * No attempt is made to strip pre-existing html markup.
 * This is potentially unsafe because `content.txt` may contain malicious
 * markup.
 * @memberof Tinode.Drafty
 * @static
 *
 * @param {drafy} content - structured representation of rich text.
 *
 * @return 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];
      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: range.at + range.len,
          len: -range.len,
          what: DECORATORS[tp].close(data)
        });
        markup.push({
          idx: range.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 object.
 * 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 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 'this'.
 *
 * @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 structured representation of rich text, convert it to plain text.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - content to convert to plain text.
 */
Drafty.toPlainText = function(content) {
  return typeof content == 'string' ? content : content.txt;
}

/**
 * Returns true if content has no markup and no entities.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - content to check for presence of markup.
 * @returns true is content is plain text, false 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 true is content is valid, false 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 content has attachments.
 * @memberof Drafty
 * @static
 *
 * @param {Drafty} content - content to check for attachments.
 * @returns true if there are attachments.
 */
Drafty.hasAttachments = function(content) {
  if (content.ent && content.ent.length > 0) {
    for (var i in content.ent) {
      if (content.ent[i] && content.ent[i].tp == 'EX') {
        return true;
      }
    }
  }
  return false;
}

/**
 * Callback for applying custom formatting/transformation to a Drafty object.
 * Called once for each syle span.
 * @memberof Drafty
 * @static
 *
 * @callback AttachmentCallback
 * @param {Object} data attachment data
 * @param {number} index attachment's index in `content.ent`.
 */

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

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

/**
 * Check if the entity data is 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.isUploading = function(entData) {
  return entData.ref instanceof Promise;
}

/**
 * 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) : null;
}

/**
 * Get approximate size of the entity.
 * @memberof Drafty
 * @static
 *
 * @param {Object} entity.data to get the size for.
 */
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} entity.data to get the type for.
 */
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} tag name
 */
Drafty.tagName = function(style) {
  return HTML_TAGS[style] ? HTML_TAGS[style].name : 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 - tw-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';
}

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

},{}],2:[function(require,module,exports){
(function (global){
/**
 * @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-2019 Tinode
 * @summary Javascript bindings for Tinode.
 * @license Apache 2.0
 * @version 0.16
 *
 * @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'.

if (typeof require == 'function') {
  if (typeof Drafty == 'undefined') {
    var Drafty = require('./drafty.js');
  }
  var 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';
const VERSION = package_version || '0.16';
const LIBRARY = 'tinodejs/' + VERSION;

const TOPIC_NEW = 'new';
const TOPIC_ME = 'me';
const TOPIC_FND = 'fnd';
const TOPIC_SYS = 'sys';
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.

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

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

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

// Utility functions

// Add brower missing function for non browser app, eg nodeJs
function initForNonBrowserApp() {
  // Tinode requirement in native mode because react native doesn't provide Base64 method
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';

  if (typeof btoa == 'undefined') {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
    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");
        }
      }
    }
  }
}

// RFC3339 formater of Date
function rfc3339DateString(d) {
  if (!d || d.getTime() == 0) {
    return undefined;
  }

  function pad(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) {
    return (!dst || !(dst instanceof Date) || 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 '_'.
function simplify(obj) {
  Object.keys(obj).forEach(function(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 (typeof obj[key] == 'object' && !(obj[key] instanceof Date)) {
      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;
}

// 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) {
    let date = new Date(val);
    if (date) {
      return date;
    }
  } else if (key === 'acs' && typeof val === 'object') {
    return new AccessMode(val);
  }
  return val;
};

// 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; ';
  }
  // Then test for WebKit based browser.
  ua = ua.replace(' (KHTML, like Gecko)', '');
  let m = ua.match(/(AppleWebKit\/[.\d]+)/i);
  let result;
  if (m) {
    // List of common strings, from more useful to less useful.
    let priority = ['chrome', 'safari', 'mobile', 'version'];
    let tmp = ua.substr(m.index + m[0].length).split(" ");
    let tokens = [];
    // Split Name/0.0.0 into Name and version 0.0.0
    for (let i = 0; i < tmp.length; i++) {
      let m2 = /([\w.]+)[\/]([\.\d]+)/.exec(tmp[i]);
      if (m2) {
        tokens.push([m2[1], m2[2], priority.findIndex(function(e) {
          return (e == m2[1].toLowerCase());
        })]);
      }
    }
    // Sort by priority: more interesting is earlier than less interesting.
    tokens.sort(function(a, b) {
      let diff = a[2] - b[2];
      return diff != 0 ? diff : b[0].length - a[0].length;
    });
    if (tokens.length > 0) {
      // Return the least common browser string and version.
      result = tokens[0][0] + '/' + tokens[0][1];
    } else {
      // Failed to ID the browser. Return the webkit version.
      result = m[1];
    }
    // Test for MSIE.
  } else if (/trident/i.test(ua)) {
    m = /(?:\brv[ :]+([.\d]+))|(?:\bMSIE ([.\d]+))/g.exec(ua);
    if (m) {
      result = 'MSIE/' + (m[1] || m[2]);
    } else {
      result = 'MSIE/?';
    }
    // Test for Firefox.
  } else if (/firefox/i.test(ua)) {
    m = /Firefox\/([.\d]+)/g.exec(ua);
    if (m) {
      result = 'Firefox/' + m[1];
    } else {
      result = 'Firefox/?';
    }
    // Older Opera.
  } else if (/presto/i.test(ua)) {
    m = /Opera\/([.\d]+)/g.exec(ua);
    if (m) {
      result = 'Opera/' + m[1];
    } else {
      result = 'Opera/?';
    }
  } else {
    // Failed to parse anything meaningfull. 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) {
    let v = m[1].split('.');
    result = m[0] + '/' + v[0] + (v[1] ? '.' + v[1] : '');
  }
  return reactnative + result;
}

/**
 * In-memory sorted cache of objects.
 *
 * @class CBuffer
 * @memberof Tinode
 * @protected
 *
 * @param {function} compare custom comparator of objects. Returns -1 if a < b, 0 if a == b, 1 otherwise.
 * @param {boolean} unique enforce element uniqueness: replace existing element with a new one on conflict.
 */
var 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 <tt>undefined</tt>
     */
    getAt: function(at) {
      return buffer[at];
    },

    /**
     * Convenience method for getting the last element of the buffer.
     * @memberof Tinode.CBuffer#
     * @returns {Object} The last element in the buffer or <tt>undefined</tt> if buffer is empty.
     */
    getLast: function() {
      return buffer.length > 0 ? buffer[buffer.length - 1] : 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 <tt>undefined</tt>
     */
    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 function `callback` to all elements of the buffer.
     * @memberof Tinode.CBuffer#
     *
     * @param {Tinode.ForEachCallbackType} callback - Function to call for each element.
     * @param {integer} startIdx- Optional index to start iterating from (inclusive).
     * @param {integer} beforeIdx - Optional index to stop iterating before (exclusive).
     * @param {Object} context - calling context (i.e. value of 'this' 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;
    }
  }
}

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

  if (protocol === 'http' || protocol === 'https' || protocol === 'ws' || protocol === 'wss') {
    url = protocol + '://';
    url += host;
    if (url.charAt(url.length - 1) !== '/') {
      url += '/';
    }
    url += 'v' + PROTOCOL_VERSION + '/channels';
    if (protocol === 'http' || protocol === 'https') {
      // Long polling endpoint end 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 {string} host_ - Host name and port number to connect to.
 * @param {string} apiKey_ - API key generated by keygen
 * @param {string} transport_ - Network transport to use, either `ws`/`wss` for websocket or `lp` for long polling.
 * @param {boolean} secure_ - Use secure WebSocket (wss) if true.
 * @param {boolean} autoreconnect_ - If connection is lost, try to reconnect automatically.
 */
var Connection = function(host_, apiKey_, transport_, secure_, autoreconnect_) {
  let host = host_;
  let secure = secure_;
  let apiKey = apiKey_;

  let 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.

  let log = (text, ...args) => {
    if (this.logger) {
      this.logger(text, ...args);
    }
  }

  // Backoff implementation - reconnect after a timeout.
  function boffReconnect() {
    // Clear timer
    clearTimeout(_boffTimer);
    // Calculate when to fire the reconnect attempt
    let 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) {
        let 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 null 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', 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;
      if (!_socket) {
        return;
      }

      boffStop();
      _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} true if connection is live, false 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 'ws' or 'lp'.
     */
    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_) {
      let sender = new XMLHttpRequest();
      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 XMLHttpRequest();
      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', apiKey);
        log("Connecting to: ", url);
        _poller = lp_poller(url, resolve, reject);
        _poller.send(null)
      }).catch((err) => {
        console.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 (transport_ === 'lp') {
    // explicit request to use long polling
    init_lp(this);
    initialized = true;
  } else if (transport_ === 'ws') {
    // explicit request to use web socket
    // if websockets are not available, horrible things will happen
    init_ws(this);
    initialized = true;

    // Default transport selection
  } else if (typeof window == 'object') {
    if (window['WebSocket']) {
      // Using web sockets -- default.
      init_ws(this);
      initialized = true;
    } else if (window['XMLHttpRequest']) {
      // The browser has no websockets, using long polling.
      init_lp(this);
      initialized = true;
    }
  }

  if (!initialized) {
    // No transport is avaiilable.
    console.log("No network transport is available. Running under Node? Call 'Tinode.setNetworkProviders()'.");
    throw new Error("No network transport is available. Running under Node? Call 'Tinode.setNetworkProviders()'.");
  }

  /**
   * Check if the given network transport is available.
   * @memberof Tinode.Connection#
   * @param {String} trans - either 'ws' (websocket) or 'lp' (long polling).
   * @returns true if given transport is available, false otherwise.
   */
  this.transportAvailable = function(transp) {
    switch (transp) {
      case 'ws':
        return typeof window == 'object' && window['WebSocket'];
      case 'lp':
        return typeof window == 'object' && window['XMLHttpRequest'];
      default:
        console.log("Request for unknown transport", transp);
        return false;
    }
  }

  /**
   * 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 readyState=1 (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. -1 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;
};

/**
 * @class Tinode
 *
 * @param {string} appname_ - Name of the caliing application to be reported in User Agent.
 * @param {string} host_ - Host name and port number to connect to.
 * @param {string} apiKey_ - API key generated by keygen
 * @param {string} transport_ - See {@link Tinode.Connection#transport}.
 * @param {boolean} secure_ - Use Secure WebSocket if true.
 * @param {string} platform_ - Optional platform identifier, one of "ios", "web", "android".
 */
var Tinode = function(appname_, host_, apiKey_, transport_, secure_, platform_) {
  // Client-provided application name, format <Name>/<version number>
  if (appname_) {
    this._appName = appname_;
  } else {
    this._appName = "Undefined";
  }

  // API Key.
  this._apiKey = apiKey_;

  // Name and version of the browser.
  this._browser = '';
  this._platform = platform_;
  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 = {};

  /** A connection object, see {@link Tinode.Connection}. */
  this._connection = new Connection(host_, apiKey_, transport_, secure_, true);
  // 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(' '));
    }
  }
  this._connection.logger = this.logger;

  // 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 = (func, context) => {
    for (let idx in this._cache) {
      if (func(this._cache[idx], idx, context)) {
        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);
    }
  }

  // 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;
  }

  // Reject promises which have not been resolved for too long.
  const 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);

  // 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, 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;
    }
    // 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);
    }
  }

  // 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();
            }
          } else if (pkt.ctrl.params && pkt.ctrl.params.what == 'data') {
            // 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 && pkt.ctrl.params.what == 'sub') {
            // The topic has no 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 = () => {
    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;

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

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

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

// Static methods.

/**
 * Helper method to package account credential.
 * @memberof Tinode
 * @static
 *
 * @param {String|Object} 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} array with a single credentail or null 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.
 * @memberof Tinode
 * @static
 *
 * @param {string} name - Name of the topic to test.
 * @returns {string} One of <tt>'me'</tt>, <tt>'grp'</tt>, <tt>'p2p'</tt> or <tt>undefined</tt>.
 */
Tinode.topicType = function(name) {
  const types = {
    'me': 'me',
    'fnd': 'fnd',
    'grp': 'grp',
    'new': 'grp',
    'usr': 'p2p',
    'sys': 'sys'
  };
  return types[(typeof name == 'string') ? name.substring(0, 3) : 'xxx'];
};

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

/**
 * Return information about the current version of this Tinode client library.
 * @memberof Tinode
 * @static
 *
 * @returns {string} semantic version of the library, e.g. '0.15.5-rc1'.
 */
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 require('ws').
 * @param xhrProvider XMLHttpRequest provider, e.g. for node require('xhr').
 */
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;

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

/**
 * Check if the given string reprsents NULL value.
 * @memberof Tinode
 * @static
 *
 * @param {String} str - string to check for null value.
 *
 * @returns {boolean} true if string is null, false otherwise.
 */
Tinode.isNullValue = function(str) {
  return str === Tinode.DEL_CHAR;
};

// 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:
   * <tt>resolve()</tt> is called without parameters, <tt>reject()</tt> receives the <tt>Error</tt> 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();
  },

  /**
   * 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} true if there is a live connection, false otherwise.
   */
  isConnected: function() {
    return this._connection.isConnected();
  },

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

  /**
   * @typedef AccountParams
   * @memberof Tinode
   * @type Object
   * @property {Tinode.DefAcs=} defacs - Default access parameters for user's <tt>me</tt> topic.
   * @property {Object=} public - Public application-defined data exposed on <tt>me</tt> topic.
   * @property {Object=} private - Private application-defined data accessible on <tt>me</tt> 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 <tt>me</tt> for authenticated users.
   * @property {string=} anon - Access mode for <tt>me</tt>  anonymous users.
   */

  /**
   * Create or update an account.
   * @memberof Tinode#
   *
   * @param {String} uid - User id to update
   * @param {String} scheme - Authentication scheme; <tt>"basic"</tt> and <tt>"anonymous"</tt> 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.
   */
  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; <tt>"basic"</tt> 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) => {
        this.loginSuccessful(ctrl);
        return ctrl;
      });
    }
    return promise;
  },

  /**
   * Create user with 'basic' 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 'basic' 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.
   * @param {boolean} sendToServer - if true, send dt to server immediately.
   *
   * @param true if attempt was made to send the token to the server.
   */
  setDeviceToken: function(dt, sendToServer) {
    let sent = false;
    if (dt && dt != this._deviceToken) {
      this._deviceToken = dt;
      if (sendToServer && this.isConnected() && this.isAuthenticated()) {
        this.send({
          'hi': {
            'dev': dt
          }
        });
        sent = true;
      }
    }
    return sent;
  },

  /**
   * Authenticate current session.
   * @memberof Tinode#
   *
   * @param {String} scheme - Authentication scheme; <tt>"basic"</tt> 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) => {
        this.loginSuccessful(ctrl);
        return 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
   * @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
   * @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
   * @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
   * @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.topicType(topicName) == 'p2p' && 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 <tt>true</tt>, 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 <tt>true</tt>, 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 <tt>true</tt>, 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);
  },

  /**
   * @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 {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} topic - 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(topic, hard) {
    const pkt = this.initPacket('del', topic);
    pkt.del.what = 'topic';
    pkt.del.hard = hard;

    return this.send(pkt, pkt.del.id).then((ctrl) => {
      this.cacheDel('topic', topic);
      return this.ctrl;
    });
  },

  /**
   * Delete subscription. Requires Share permission.
   * @memberof Tinode#
   *
   * @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.
   */
  delSubscription: function(topic, user) {
    const pkt = this.initPacket('del', topic);
    pkt.del.what = 'sub';
    pkt.del.user = user;

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

  /**
   * Delete credential. Always sent on 'me' topic.
   * @memberof Tinode#
   *
   * @param {String} method - validation method such as 'email' or 'tel'.
   * @param {String} value - validation value, i.e. 'alice@example.com'.
   * @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} topic - Name of the topic where the mesage is being aknowledged.
   * @param {String} what - Action being aknowledged, either "read" or "recv".
   * @param {Number} seq - Maximum id of the message being acknowledged.
   */
  note: function(topic, what, seq) {
    if (seq <= 0 || seq >= LOCAL_SEQID) {
      throw new Error("Invalid message id " + seq);
    }

    const pkt = this.initPacket('note', topic);
    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} topic - Name of the topic to broadcast to.
   */
  noteKeyPress: function(topic) {
    const pkt = this.initPacket('note', topic);
    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} topic - Name of the topic to get.
   * @returns {Tinode.Topic} Requested or newly created topic or <tt>undefined</tt> if topic name is invalid.
   */
  getTopic: function(name) {
    let topic = this.cacheGet('topic', name);
    if (!topic && name) {
      if (name == TOPIC_ME) {
        topic = new TopicMe();
      } else if (name == TOPIC_FND) {
        topic = new TopicFnd();
      } else {
        topic = new Topic(name);
      }
      // topic._new = false;
      this.cachePut('topic', name, topic);
      this.attachCacheToTopic(topic);
    }
    return topic;
  },

  /**
   * Instantiate a new unnamed topic. An actual name will be assigned by the server
   * on {@link Tinode.Topic.subscribe}.
   * @memberof Tinode#
   *
   * @param {Tinode.Callbacks} callbacks - Object with callbacks for various events.
   * @returns {Tinode.Topic} Newly created topic.
   */
  newTopic: function(callbacks) {
    const topic = new Topic(TOPIC_NEW, callbacks);
    this.attachCacheToTopic(topic);
    return topic;
  },

  /**
   * Generate unique name  like 'new123456' suitable for creating a new group topic.
   * @memberof Tinode#
   *
   * @returns {string} name which can be used for creating a new group topic.
   */
  newGroupTopicName: function() {
    return TOPIC_NEW + this.getNextUniqueId();
  },

  /**
   * Instantiate a new P2P topic with a given peer.
   * @memberof Tinode#
   *
   * @param {string} peer - UID of the peer to start topic with.
   * @param {Tinode.Callbacks} callbacks - Object with callbacks for various events.
   * @returns {Tinode.Topic} Newly created topic.
   */
  newTopicWith: function(peer, callbacks) {
    const topic = new Topic(peer, callbacks);
    this.attachCacheToTopic(topic);
    return topic;
  },

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

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

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

  /**
   * Get the UID of the the current authenticated user.
   * @memberof Tinode#
   * @returns {string} UID of the current user or <tt>undefined</tt> 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 <tt>undefined</tt>.
   */
  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 <tt>null</tt> 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 name of the value to return
   * @param defaultValue to return in case server limts are not set of value is not found.
   * @returns {integer} 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 <tt>true</tt> to enable logging to console.
   */
  enableLogging: function(enabled, trimLongStrings) {
    this._loggingEnabled = enabled;
    this._trimLongStrings = enabled && trimLongStrings;
  },

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

  /**
   * Check if given topic is online.
   * @memberof Tinode#
   *
   * @param {String} name - Name of the topic to test.
   * @returns {Boolean} true if topic is online, false otherwise.
   */
  isTopicOnline: function(name) {
    const me = this.getMeTopic();
    const cont = me && me.getContact(name);
    return cont && cont.online;
  },

  /**
   * Include message ID into all subsequest messages to server instructin it to send aknowledgemens.
   * Required for promises to function. Default is "on".
   * @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 {ctrl} (control) messages.
   * @memberof Tinode#
   * @type {Tinode.onCtrlMessage}
   */
  onCtrlMessage: undefined,

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

  /**
   * Callback to receive {pres} (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,
};

/**
 * Helper class for constructing {@link Tinode.GetQuery}.
 *
 * @class MetaGetBuilder
 * @memberof Tinode
 *
 * @param {Tinode.Topic} parent topic which instantiated this builder.
 */
var MetaGetBuilder = function(parent) {
  this.topic = parent;
  const me = parent._tinode.getMeTopic();
  this.contact = me && me.getContact(parent.name);
  this.what = {};
}

MetaGetBuilder.prototype = {

  // Get latest timestamp
  _get_ims: function() {
    const cupd = this.contact && this.contact.updated;
    const tupd = this.topic._lastDescUpdate || 0;
    return cupd > tupd ? cupd : tupd;
  },

  /**
   * 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} <tt>this</tt> 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} <tt>this</tt> 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} <tt>this</tt> 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} <tt>this</tt> 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} <tt>this</tt> object.
   */
  withLaterDesc: function() {
    return this.withDesc(this._get_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} <tt>this</tt> 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} <tt>this</tt> 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} <tt>this</tt> 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} <tt>this</tt> object.
   */
  withLaterSub: function(limit) {
    return this.withSub(
      this.topic.getType() == 'p2p' ? this._get_ims() : this.topic._lastSubsUpdate,
      limit);
  },

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

  /**
   * Add query parameters to fetch user's credentials. 'me' topic only.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @returns {Tinode.MetaGetBuilder} <tt>this</tt> 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} <tt>this</tt> 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 'del' id.
   * @memberof Tinode.MetaGetBuilder#
   *
   * @param {Number=} limit number of deleted message ids to fetch
   *
   * @returns {Tinode.MetaGetBuilder} <tt>this</tt> 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;
  }
};

/**
 * 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.
 */
var 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 '+' or '-' then the bits to add or remove, e.g. '+R-W' or '-PS'.
 *  - 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 a1 but missing in a2
 */
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) + '"}';
  },
  /**
   * Convert 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} - <b>this</b> AccessMode.
   */
  setMode: function(m) {
    this.mode = AccessMode.decode(m);
    return this;
  },
  /**
   * Update 'mode' value.
   * @memberof Tinode.AccessMode
   *
   * @param {string} u - string representation of the changes to apply to access mode.
   * @returns {AccessMode} - <b>this</b> AccessMode.
   */
  updateMode: function(u) {
    this.mode = AccessMode.update(this.mode, u);
    return this;
  },
  /**
   * Get 'mode' value as a string.
   * @memberof Tinode.AccessMode
   *
   * @returns {string} - <b>mode</b> value.
   */
  getMode: function() {
    return AccessMode.encode(this.mode);
  },

  /**
   * Assign 'given' value.
   * @memberof Tinode.AccessMode
   *
   * @param {string | number} g - either a string representation of the access mode or a set of bits.
   * @returns {AccessMode} - <b>this</b> 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} - <b>this</b> 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} - <b>this</b> 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} - <b>this</b> 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} - <b>this</b> 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} - true 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} - true 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} - true 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} - true 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} - true 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} - true 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} - true 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} - true 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} - true 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} - true if flag is set.
   */
  isDeleter: function(side) {
    return AccessMode._checkFlag(this, side, AccessMode._DELETE);
  }
};

/**
 * @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 {data} message.
 * @param {callback} callbacks.onMeta - Callback which receives a {meta} message.
 * @param {callback} callbacks.onPres - Callback which receives a {pres} message.
 * @param {callback} callbacks.onInfo - Callback which receives an {info} 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 {data} 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 = null;
  // 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 when topic meta-desc update was recived.
  this._lastDescUpdate = null;
  // Timestap when topic meta-subs update was recived.
  this._lastSubsUpdate = null;
  // 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 = callbacls.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 ff the topic is already subscribed to.
        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;

        // Name may change new123456 -> grpAbCdEf
        this.name = ctrl.topic;

        this.created = ctrl.ts;
        this.updated = ctrl.ts;
        // Don't assign touched, otherwise topic will be put on top of the list on subscribe.

        this._cachePutSelf();

        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) {
            me._processMetaSub([{
              _noForwarding: true,
              topic: this.name,
              created: ctrl.ts,
              updated: ctrl.ts,
              acs: this.acs
            }]);
          }
        }

        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 <tt>true</tt> 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 <tt>true</tt> 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 records.
    if (Drafty.hasAttachments(pub.content) && !pub.head.attachments) {
      let attachments = [];
      Drafty.attachments(pub.content, (data) => {
        attachments.push(data.ref);
      });
      pub.head.attachments = attachments;
    }

    // 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);

      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 by the server", err);
        pub._sending = false;
        pub._failed = true;
        this._messages.delAt(this._messages.find(pub));
        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._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 {integer} 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. <tt>null</tt> 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: <tt>recv</tt>, <tt>read</tt>.
   * @param {Number} seq - ID or the message read or received.
   */
  note: function(what, seq) {
    const user = this._users[this._tinode.getCurrentUserID()];
    if (user) {
      if (!user[what] || user[what] < seq) {
        if (this._subscribed) {
          this._tinode.note(this.name, what, seq);
        } else {
          this._tinode.logger("INFO: Not sending {note} on inactive topic");
        }

        user[what] = seq;
      }
    } else {
      this._tinode.logger("ERROR: note(): user not found " + this._tinode.getCurrentUserID());
    }

    // Update locally cached contact with the new count
    const me = this._tinode.getMeTopic();
    if (me) {
      me.setMsgReadRecv(this.name, what, seq);
    }
  },

  /**
   * 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");
    }
  },

  /**
   * 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.getType() != 'p2p') {
      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 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 {integer} sinceId - Optional seqId to start iterating from (inclusive).
   * @param {integer} 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);
      }
    }
  },

  /**
   * 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 `this` inside the `callback`.
   */
  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 notification to send: <tt>recv</tt>, <tt>read</tt>.
   * @param {Number} seq - ID or the message 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 check for newer messages
   */
  msgHasMoreMessages: function(newer) {
    return newer ? this.seq > this._maxSeq :
      // _minSeq cound 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 {integer} seqId id of the message to check
   */
  isNewMessage: function(seqId) {
    return this._maxSeq <= seqId;
  },

  /**
   * Remove one message from local cache.
   * @memberof Tinode.Topic#
   *
   * @param {integer} 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
    });
    return idx >= 0 ? this._messages.delAt(idx) : undefined;
  },

  /**
   * Update message's seqId.
   * @memberof Tinode.Topic#
   *
   * @param {Object} pub message object.
   * @param {integer} newSeqId new seq id for pub.
   */
  swapMessageId: function(pub, newSeqId) {
    const idx = this._messages.find({
      seq: pub.seq
    });
    const numMessages = this._messages.length();
    pub.seq = newSeqId;
    if (0 <= idx && idx < numMessages) {
      // this._messages are sorted by `seq`.
      // If changing pub.seq to newSeqId breaks the invariant, fix it.
      if ((idx > 0 && this._messages.getAt(idx - 1).seq >= newSeqId) ||
        (idx + 1 < numMessages && newSeqId < this._messages.getAt(idx + 1).seq <= newSeqId)) {
        this._messages.delAt(idx);
        this._messages.put(pub);
      }
    }
  },

  /**
   * Remove a range of messages from the local cache.
   * @memberof Tinode.Topic#
   *
   * @param {integer} fromId seq ID of the first message to remove (inclusive).
   * @param {integer} untilId seqID of the last message to remove (exclusive).
   *
   * @returns {Message[]} array of removed messages (could be empty).
   */
  flushMessageRange: function(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 {integer} seqId id of the message to stop sending and remove from cache.
   *
   * @returns {boolean} true if message was cancelled, false 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) {
        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' or <tt>undefined</tt>.
   */
  getType: function() {
    return Tinode.topicType(this.name);
  },

  /**
   * Get user's cumulative access mode of the topic.
   * @memberof Tinode.Topic#
   *
   * @returns {Tinode.AccessMode} - user's access mode
   */
  getAccessMode: function() {
    return this.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} - true if topic is archived, false otherwise.
   */
  isArchived: function() {
    return this.private && this.private.arch ? true : false;
  },

  /**
   * 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.
   * @returns message status constant.
   */
  msgStatus: function(msg) {
    let status = MESSAGE_STATUS_NONE;
    if (this._tinode.isMe(msg.from)) {
      if (msg._sending) {
        status = MESSAGE_STATUS_SENDING;
      } else if (msg._failed) {
        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 {
      status = MESSAGE_STATUS_TO_ME;
    }
    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._updateDeletedRanges();
    }

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

    // Update locally cached contact with the new message count.
    const me = this._tinode.getMeTopic();
    if (me) {
      // Messages from the current user are considered to be read already.
      me.setMsgReadRecv(this.name,
        (!data.from || this._tinode.isMe(data.from)) ? 'read' : 'msg', data.seq, data.ts);
    }
  },

  // Process metadata message
  _routeMeta: function(meta) {
    if (meta.desc) {
      this._lastDescUpdate = meta.ts;
      this._processMetaDesc(meta.desc);
    }
    if (meta.sub && meta.sub.length > 0) {
      this._lastSubsUpdate = meta.ts;
      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;
        }
      }

      // If this is an update from the current user, update the contact with the new count too.
      if (this._tinode.isMe(info.from)) {
        const me = this._tinode.getMeTopic();
        if (me) {
          me.setMsgReadRecv(info.topic, info.what, info.seq);
        }
      }
    }
    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) {
    // Synthetic desc may include defacs for p2p topics which is useless.
    // Remove it.
    if (this.getType() == 'p2p') {
      delete desc.defacs;
    }

    // Copy parameters from desc object to this topic.
    mergeObj(this, desc);
    // Make sure date fields are Date().
    stringToDate(this);

    // Update relevant contact in the me topic, if available:
    if (this.name !== TOPIC_ME && !desc._noForwarding) {
      const me = this._tinode.getMeTopic();
      if (me) {
        // Must use original 'desc' instead of 'this' so not to lose DEL_CHAR.
        me._processMetaSub([{
          _noForwarding: true,
          topic: this.name,
          updated: this.updated,
          touched: this.touched,
          acs: desc.acs,
          seq: desc.seq,
          read: desc.read,
          recv: desc.recv,
          public: desc.public,
          private: desc.private
        }]);
      }
    }

    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];

      sub.updated = new Date(sub.updated);
      sub.deleted = sub.deleted ? new Date(sub.deleted) : null;

      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 || new Date(),
            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._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) => {
      this._messages.put(gap);
    });
  }
};

/**
 * @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);
  // List of contacts (topic_name -> Contact object)
  this._contacts = {};

  // 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);
      // String datetime headers to Date() objects.
      stringToDate(this);

      // 'P' permission was removed. All topics are offline now.
      if (turnOff) {
        Object.values(this._contacts).map((cont) => {
          if (cont.online) {
            cont.online = false;
            if (cont.seen) {
              cont.seen.when = new Date();
            } else {
              cont.seen = {
                when: new Date()
              };
            }
            if (this.onContactUpdate) {
              this.onContactUpdate('off', cont);
            }
          }
        });
      }

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

  // Override the original Topic._processMetaSub
  _processMetaSub: {
    value: function(subs) {
      let updateCount = 0;
      for (let idx in subs) {
        const sub = subs[idx];
        const topicName = sub.topic;

        // Don't show 'me' and 'fnd' topics in the list of contacts.
        if (topicName == TOPIC_FND || topicName == TOPIC_ME) {
          continue;
        }
        sub.updated = new Date(sub.updated);
        sub.touched = sub.touched ? new Date(sub.touched) : undefined;
        sub.deleted = sub.deleted ? new Date(sub.deleted) : null;

        let cont = null;
        if (sub.deleted) {
          cont = sub;
          delete this._contacts[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 = mergeToCache(this._contacts, topicName, sub);

          if (Tinode.topicType(topicName) == 'p2p') {
            this._cachePutUser(topicName, cont);
          }
          // 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) {
        this.onSubsUpdated(Object.keys(this._contacts), updateCount);
      }
    },
    enumerable: true,
    configurable: true,
    writable: false
  },

  // 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,
    writable: false
  },

  // 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._contacts[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.touched = new Date();
            cont.seq = pres.seq | 0;
            // Check if message is sent by the current user. If so it's been read already.
            if (!pres.act || this._tinode.isMe(pres.act)) {
              cont.read = cont.read ? Math.max(cont.read, cont.seq) : cont.seq;
              cont.recv = cont.recv ? Math.max(cont.read, cont.recv) : cont.recv;
            }
            cont.unread = cont.seq - cont.read;
            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
            delete this._contacts[pres.src];
            break;
          case 'del':
            // Update topic.del value.
            break;
          default:
            this._tinode.logger("INFO: Unsupported presence update in 'me'", pres.what);
        }

        if (this.onContactUpdate) {
          this.onContactUpdate(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.
            this._contacts[pres.src] = {
              touched: new Date(),
              topic: pres.src,
              online: false,
              acs: acs
            };
          }
        } else if (pres.what == 'tags') {
          this.getMeta(this.startMetaQuery().withTags().build());
        }
      }

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

  /**
   * 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,
    writable: false
  },

  /**
   * 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,
    writable: false
  },

  /**
   * Iterate over cached contacts.
   *
   * @function
   * @memberof Tinode.TopicMe#
   * @param {TopicMe.ContactCallback} callback - Callback to call for each contact.
   * @param {function=} 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) {
      for (let idx in this._contacts) {
        const c = this._contacts[idx];
        if (!filter || filter(c)) {
          callback.call(context, c, idx, this._contacts);
        }
      }
    },
    enumerable: true,
    configurable: true,
    writable: true
  },

  /**
   * Update a cached contact with new read/received/message count.
   * @function
   * @memberof Tinode.TopicMe#
   *
   * @param {String} contactName - UID of contact to update.
   * @param {String} what - Whach count to update, one of <tt>"read", "recv", "msg"</tt>
   * @param {Number} seq - New value of the count.
   * @param {Date} ts - Timestamp of the update.
   */
  setMsgReadRecv: {
    value: function(contactName, what, seq, ts) {
      const cont = this._contacts[contactName];
      let oldVal, doUpdate = false;
      let mode = null;
      if (cont) {
        seq = seq | 0;
        cont.seq = cont.seq | 0;
        cont.read = cont.read | 0;
        cont.recv = cont.recv | 0;
        switch (what) {
          case 'recv':
            oldVal = cont.recv;
            cont.recv = Math.max(cont.recv, seq);
            doUpdate = (oldVal != cont.recv);
            break;
          case 'read':
            oldVal = cont.read;
            cont.read = Math.max(cont.read, seq);
            doUpdate = (oldVal != cont.read);
            break;
          case 'msg':
            oldVal = cont.seq;
            cont.seq = Math.max(cont.seq, seq);
            if (!cont.touched || cont.touched < ts) {
              cont.touched = ts;
            }
            doUpdate = (oldVal != cont.seq);
            break;
        }

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

        if (doUpdate && (!cont.acs || !cont.acs.isMuted()) && this.onContactUpdate) {
          this.onContactUpdate(what, cont);
        }
      }
    },
    enumerable: true,
    configurable: true,
    writable: 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._contacts[name];
    },
    enumerable: true,
    configurable: true,
    writable: 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._contacts[name];
        return cont ? cont.acs : null;
      }
      return this.acs;
    },
    enumerable: true,
    configurable: true,
    writable: 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._contacts[name];
      return cont ? ((cont.private && cont.private.arch) ? true : false) : null;
    },
    enumerable: true,
    configurable: true,
    writable: 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,
    writable: 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,
    writable: false
  },

  /**
   * 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,
    writable: false
  },

  /**
   * 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,
    writable: false
  },

  /**
   * 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,
    writable: true
  }
});
TopicFnd.prototype.constructor = TopicFnd;

/**
 * @class LargeFileHelper - collection of 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.
 */
var LargeFileHelper = function(tinode) {
  this._tinode = tinode;

  this._apiKey = tinode._apiKey;
  this._authToken = tinode.getAuthToken();
  this._msgId = tinode.getNextUniqueId();
  this.xhr = new XMLHttpRequest();

  // 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} file to upload
   * @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, file, onProgress, onSuccess, onFailure) {
    if (!this._authToken) {
      throw new Error("Must authenticate first");
    }
    const instance = this;

    let url = '/v' + PROTOCOL_VERSION + '/file/u/';
    if (baseUrl) {
      if (baseUrl.indexOf('http://') == 0 || baseUrl.indexOf('https://') == 0) {
        url = baseUrl + 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 = function(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', file);
      form.set('id', this._msgId);
      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} file to upload
   * @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(file, onProgress, onSuccess, onFailure) {
    return this.uploadWithBaseUrl(undefined, file, 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) {
    // Check if the URL is relative. Check for cases like:
    //  'http://example.com'
    //  ' http://example.com'
    //  '//example.com/'
    //  'http:example.com'
    //  'http:/example.com'
    if (/^\s*([a-z][a-z0-9+.-]*:|\/\/)/im.test(relativeUrl)) {
      // As a security measure refuse to download from an absolute URL.
      throw new Error("The URL '" + relativeUrl + "' must be relative, not absolute");
    }
    if (!this._authToken) {
      throw new Error("Must authenticate first");
    }
    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._msgId;
  }
};

/**
 * @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,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"../version.json":3,"./drafty.js":1}],3:[function(require,module,exports){
module.exports={"version": "0.16.5"}

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

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","src/drafty.js","src/tinode.js","version.json"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACj8CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACrsLA;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 * @copyright 2015-2019 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\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};\n\n// Convert base64-encoded string into Blob.\nfunction base64toObjectUrl(b64, contentType) {\n  let bin;\n  try {\n    bin = atob(b64);\n    let length = bin.length;\n    let buf = new ArrayBuffer(length);\n    let 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    console.log(\"Drafty: failed to convert object.\", err.message);\n  }\n\n  return null;\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  // 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 previewUrl = base64toObjectUrl(data.val, data.mime);\n      const downloadUrl = data.ref ? data.ref : previewUrl;\n      return (data.name ? '<a href=\"' + downloadUrl + '\" download=\"' + data.name + '\">' : '') +\n        '<img src=\"' + 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      let url = base64toObjectUrl(data.val, data.mime);\n      return {\n        src: url,\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 : 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 */\nvar 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      // throw out non-visual spans.\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  const ranges = [];\n  for (var i in chunks) {\n    const chunk = chunks[i];\n    if (!chunk.text) {\n      var 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 object 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 * Insert inline image into Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content object to add image to.\n * @param {integer} at index where the object is inserted. The length of the image is always 1.\n * @param {string} mime mime-type of the image, e.g. \"image/png\"\n * @param {string} base64bits base64-encoded image content (or preview, if large image is attached)\n * @param {integer} width width of the image\n * @param {integer} height height of the image\n * @param {string} fname file name suggestion for downloading the image.\n * @param {integer} size size of the external file. Treat is as an untrusted hint.\n * @param {string} refurl reference to the content. Could be null or undefined.\n *\n * @return {Drafty} updated content.\n */\nDrafty.insertImage = function(content, at, mime, base64bits, width, height, fname, size, refurl) {\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  content.ent.push({\n    tp: 'IM',\n    data: {\n      mime: mime,\n      val: base64bits,\n      width: width,\n      height: height,\n      name: fname,\n      ref: refurl,\n      size: size | 0\n    }\n  });\n\n  return content;\n}\n\n/**\n * Append image to Drafty content.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content object to add image to.\n * @param {string} mime mime-type of the image, e.g. \"image/png\"\n * @param {string} base64bits base64-encoded image content (or preview, if large image is attached)\n * @param {integer} width width of the image\n * @param {integer} height height of the image\n * @param {string} fname file name suggestion for downloading the image.\n * @param {integer} size size of the external file. Treat is as an untrusted hint.\n * @param {string} refurl reference to the content. Could be null or undefined.\n *\n * @return {Drafty} updated content.\n */\nDrafty.appendImage = function(content, mime, base64bits, width, height, fname, size, refurl) {\n  content = content || {\n    txt: \"\"\n  };\n  content.txt += \" \";\n  return Drafty.insertImage(content, content.txt.length - 1, mime, base64bits, width, height, fname, size, refurl);\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 object to attach file to.\n * @param {string} mime mime-type of the file, e.g. \"image/png\"\n * @param {string} base64bits base64-encoded file content\n * @param {string} fname file name suggestion for downloading.\n * @param {integer} size size of the external file. Treat is as an untrusted hint.\n * @param {string | Promise} refurl optional reference to the content.\n *\n * @return {Drafty} updated content.\n */\nDrafty.attachFile = function(content, mime, base64bits, fname, size, refurl) {\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: mime,\n      val: base64bits,\n      name: fname,\n      ref: refurl,\n      size: size | 0\n    }\n  }\n  if (refurl instanceof Promise) {\n    ex.data.ref = refurl.then(\n      (url) => {\n        ex.data.ref = url;\n      },\n      (err) => {\n        /* catch the error, otherwise it will appear in the console. */\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 content.\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 is Drafty object to insert button to or a string to be used as button text.\n * @param {number} at is location where the button is inserted.\n * @param {number} len is the length of the text to be used as button title.\n * @param {string} name of the button. Client should return it to the server when the button is clicked.\n * @param {string} actionType is the type of the button, one of 'url' or 'pub'.\n * @param {string} actionValue is the value to return on click:\n * @param {string} refUrl is the URL to go to when the 'url' button is clicked.\n *\n * @return {Drafty} updated content.\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 is Drafty object to insert button to or a string to be used as button text.\n * @param {string} title is the text to be used as button title.\n * @param {string} name of the button. Client should return it to the server when the button is clicked.\n * @param {string} actionType is the type of the button, one of 'url' or 'pub'.\n * @param {string} actionValue is the value to return on click:\n * @param {string} refUrl is the URL to go to when the 'url' button is clicked.\n *\n * @return {Drafty} updated content.\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 object to attach file to.\n * @param {Object} data to convert to json string and attach.\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\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 the structured representation of rich text, convert it to HTML.\n * No attempt is made to strip pre-existing html markup.\n * This is potentially unsafe because `content.txt` may contain malicious\n * markup.\n * @memberof Tinode.Drafty\n * @static\n *\n * @param {drafy} content - structured representation of rich text.\n *\n * @return 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      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: range.at + range.len,\n          len: -range.len,\n          what: DECORATORS[tp].close(data)\n        });\n        markup.push({\n          idx: range.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 object.\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 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 'this'.\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 structured representation of rich text, convert it to plain text.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - content to convert to plain text.\n */\nDrafty.toPlainText = function(content) {\n  return typeof content == 'string' ? content : content.txt;\n}\n\n/**\n * Returns true if content 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 true is content is plain text, false 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 true is content is valid, false 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 content has attachments.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - content to check for attachments.\n * @returns true if there are attachments.\n */\nDrafty.hasAttachments = function(content) {\n  if (content.ent && content.ent.length > 0) {\n    for (var i in content.ent) {\n      if (content.ent[i] && 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 object.\n * Called once for each syle span.\n * @memberof Drafty\n * @static\n *\n * @callback AttachmentCallback\n * @param {Object} data attachment data\n * @param {number} index attachment's index in `content.ent`.\n */\n\n/**\n * Enumerate attachments.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - drafty object to process for attachments.\n * @param {AttachmentCallback} callback - callback to call for each attachment.\n * @param {Object} content - value of \"this\" for callback.\n */\nDrafty.attachments = function(content, callback, context) {\n  if (content.ent && content.ent.length > 0) {\n    for (var i in content.ent) {\n      if (content.ent[i] && content.ent[i].tp == 'EX') {\n        callback.call(context, content.ent[i].data, i);\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} entity.data to get the URl from.\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);\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 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.isUploading = function(entData) {\n  return entData.ref instanceof Promise;\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) : null;\n}\n\n/**\n * Get approximate size of the entity.\n * @memberof Drafty\n * @static\n *\n * @param {Object} entity.data to get the size for.\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} entity.data to get the type for.\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} tag name\n */\nDrafty.tagName = function(style) {\n  return HTML_TAGS[style] ? HTML_TAGS[style].name : 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 - tw-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\nif (typeof module != 'undefined') {\n  module.exports = Drafty;\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-2019 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.16\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\nif (typeof require == 'function') {\n  if (typeof Drafty == 'undefined') {\n    var Drafty = require('./drafty.js');\n  }\n  var package_version = require('../version.json').version;\n}\n\nlet WebSocketProvider;\nif (typeof WebSocket != 'undefined') {\n  WebSocketProvider = WebSocket;\n}\n\nlet XHRProvider;\nif (typeof XMLHttpRequest != 'undefined') {\n  XHRProvider = XMLHttpRequest;\n}\ninitForNonBrowserApp();\n\n// Global constants\nconst PROTOCOL_VERSION = '0';\nconst VERSION = package_version || '0.16';\nconst LIBRARY = 'tinodejs/' + VERSION;\n\nconst TOPIC_NEW = 'new';\nconst TOPIC_ME = 'me';\nconst TOPIC_FND = 'fnd';\nconst TOPIC_SYS = 'sys';\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.\n\n// Error code to return in case of a network problem.\nconst NETWORK_ERROR = 503;\nconst NETWORK_ERROR_TEXT = \"Connection failed\";\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// Error code to return when user disconnected from server.\nconst NETWORK_USER = 418;\nconst NETWORK_USER_TEXT = \"Disconnected by client\";\n\n// Utility functions\n\n// Add brower missing function for non browser app, eg 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    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\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\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\n// RFC3339 formater of Date\nfunction rfc3339DateString(d) {\n  if (!d || d.getTime() == 0) {\n    return undefined;\n  }\n\n  function pad(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) {\n    return (!dst || !(dst instanceof Date) || 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 '_'.\nfunction simplify(obj) {\n  Object.keys(obj).forEach(function(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 (typeof obj[key] == 'object' && !(obj[key] instanceof Date)) {\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// 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' &&\n    val.length >= 20 && val.length <= 24) {\n    let date = new Date(val);\n    if (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// 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  // Then test for WebKit based browser.\n  ua = ua.replace(' (KHTML, like Gecko)', '');\n  let m = ua.match(/(AppleWebKit\\/[.\\d]+)/i);\n  let result;\n  if (m) {\n    // List of common strings, from more useful to less useful.\n    let priority = ['chrome', 'safari', 'mobile', 'version'];\n    let tmp = ua.substr(m.index + m[0].length).split(\" \");\n    let tokens = [];\n    // Split Name/0.0.0 into Name and version 0.0.0\n    for (let i = 0; i < tmp.length; i++) {\n      let m2 = /([\\w.]+)[\\/]([\\.\\d]+)/.exec(tmp[i]);\n      if (m2) {\n        tokens.push([m2[1], m2[2], priority.findIndex(function(e) {\n          return (e == m2[1].toLowerCase());\n        })]);\n      }\n    }\n    // Sort by priority: more interesting is earlier than less interesting.\n    tokens.sort(function(a, b) {\n      let diff = a[2] - b[2];\n      return diff != 0 ? diff : b[0].length - a[0].length;\n    });\n    if (tokens.length > 0) {\n      // Return the least common browser string and version.\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    // Test for MSIE.\n  } else if (/trident/i.test(ua)) {\n    m = /(?:\\brv[ :]+([.\\d]+))|(?:\\bMSIE ([.\\d]+))/g.exec(ua);\n    if (m) {\n      result = 'MSIE/' + (m[1] || m[2]);\n    } else {\n      result = 'MSIE/?';\n    }\n    // Test for Firefox.\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    // Older Opera.\n  } else if (/presto/i.test(ua)) {\n    m = /Opera\\/([.\\d]+)/g.exec(ua);\n    if (m) {\n      result = 'Opera/' + m[1];\n    } else {\n      result = 'Opera/?';\n    }\n  } else {\n    // Failed to parse anything meaningfull. 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    let v = m[1].split('.');\n    result = m[0] + '/' + v[0] + (v[1] ? '.' + v[1] : '');\n  }\n  return reactnative + result;\n}\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. Returns -1 if a < b, 0 if a == b, 1 otherwise.\n * @param {boolean} unique enforce element uniqueness: replace existing element with a new one on conflict.\n */\nvar 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 <tt>undefined</tt>\n     */\n    getAt: function(at) {\n      return buffer[at];\n    },\n\n    /**\n     * Convenience method for getting the last element of the buffer.\n     * @memberof Tinode.CBuffer#\n     * @returns {Object} The last element in the buffer or <tt>undefined</tt> if buffer is empty.\n     */\n    getLast: function() {\n      return buffer.length > 0 ? buffer[buffer.length - 1] : undefined;\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 <tt>undefined</tt>\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 function `callback` to all elements of the buffer.\n     * @memberof Tinode.CBuffer#\n     *\n     * @param {Tinode.ForEachCallbackType} callback - Function to call for each element.\n     * @param {integer} startIdx- Optional index to start iterating from (inclusive).\n     * @param {integer} beforeIdx - Optional index to stop iterating before (exclusive).\n     * @param {Object} context - calling context (i.e. value of 'this' 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\n// Helper function for creating an endpoint URL\nfunction makeBaseUrl(host, protocol, apiKey) {\n  let url = null;\n\n  if (protocol === 'http' || protocol === 'https' || protocol === 'ws' || protocol === 'wss') {\n    url = protocol + '://';\n    url += host;\n    if (url.charAt(url.length - 1) !== '/') {\n      url += '/';\n    }\n    url += 'v' + PROTOCOL_VERSION + '/channels';\n    if (protocol === 'http' || protocol === 'https') {\n      // Long polling endpoint end 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 {string} host_ - Host name and port number to connect to.\n * @param {string} apiKey_ - API key generated by keygen\n * @param {string} transport_ - Network transport to use, either `ws`/`wss` for websocket or `lp` for long polling.\n * @param {boolean} secure_ - Use secure WebSocket (wss) if true.\n * @param {boolean} autoreconnect_ - If connection is lost, try to reconnect automatically.\n */\nvar Connection = function(host_, apiKey_, transport_, secure_, autoreconnect_) {\n  let host = host_;\n  let secure = secure_;\n  let apiKey = apiKey_;\n\n  let 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  let log = (text, ...args) => {\n    if (this.logger) {\n      this.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    let 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        let 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 null 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 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', 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      if (!_socket) {\n        return;\n      }\n\n      boffStop();\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} true if connection is live, false 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 'ws' or 'lp'.\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; //\tClient has been created. open() not called yet.\n    const XDR_OPENED = 1; //\topen() has been called.\n    const XDR_HEADERS_RECEIVED = 2; // send() has been called, and headers and status are available.\n    const XDR_LOADING = 3; //\tDownloading; 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      let sender = new XMLHttpRequest();\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 XMLHttpRequest();\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', apiKey);\n        log(\"Connecting to: \", url);\n        _poller = lp_poller(url, resolve, reject);\n        _poller.send(null)\n      }).catch((err) => {\n        console.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 (transport_ === 'lp') {\n    // explicit request to use long polling\n    init_lp(this);\n    initialized = true;\n  } else if (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    // Default transport selection\n  } else if (typeof window == 'object') {\n    if (window['WebSocket']) {\n      // Using web sockets -- default.\n      init_ws(this);\n      initialized = true;\n    } else if (window['XMLHttpRequest']) {\n      // The browser has no websockets, using long polling.\n      init_lp(this);\n      initialized = true;\n    }\n  }\n\n  if (!initialized) {\n    // No transport is avaiilable.\n    console.log(\"No network transport is available. Running under Node? Call 'Tinode.setNetworkProviders()'.\");\n    throw new Error(\"No network transport is available. Running under Node? Call 'Tinode.setNetworkProviders()'.\");\n  }\n\n  /**\n   * Check if the given network transport is available.\n   * @memberof Tinode.Connection#\n   * @param {String} trans - either 'ws' (websocket) or 'lp' (long polling).\n   * @returns true if given transport is available, false otherwise.\n   */\n  this.transportAvailable = function(transp) {\n    switch (transp) {\n      case 'ws':\n        return typeof window == 'object' && window['WebSocket'];\n      case 'lp':\n        return typeof window == 'object' && window['XMLHttpRequest'];\n      default:\n        console.log(\"Request for unknown transport\", transp);\n        return false;\n    }\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 readyState=1 (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. -1 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 * @class Tinode\n *\n * @param {string} appname_ - Name of the caliing application to be reported in User Agent.\n * @param {string} host_ - Host name and port number to connect to.\n * @param {string} apiKey_ - API key generated by keygen\n * @param {string} transport_ - See {@link Tinode.Connection#transport}.\n * @param {boolean} secure_ - Use Secure WebSocket if true.\n * @param {string} platform_ - Optional platform identifier, one of \"ios\", \"web\", \"android\".\n */\nvar Tinode = function(appname_, host_, apiKey_, transport_, secure_, platform_) {\n  // Client-provided application name, format <Name>/<version number>\n  if (appname_) {\n    this._appName = appname_;\n  } else {\n    this._appName = \"Undefined\";\n  }\n\n  // API Key.\n  this._apiKey = apiKey_;\n\n  // Name and version of the browser.\n  this._browser = '';\n  this._platform = platform_;\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\n  /** A connection object, see {@link Tinode.Connection}. */\n  this._connection = new Connection(host_, apiKey_, transport_, secure_, true);\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  this._connection.logger = this.logger;\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 = (func, context) => {\n    for (let idx in this._cache) {\n      if (func(this._cache[idx], idx, context)) {\n        break;\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  // 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  // Reject promises which have not been resolved for too long.\n  const 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  // 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, 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;\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\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            }\n          } else if (pkt.ctrl.params && pkt.ctrl.params.what == 'data') {\n            // 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 && pkt.ctrl.params.what == 'sub') {\n            // The topic has no subscriptions.\n            const topic = cacheGet('topic', pkt.ctrl.topic);\n            if (topic) {\n              // Trigger topic.onSubsUpdated.\n              topic._processMetaSub([]);\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    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    // Mark all topics as unsubscribed\n    cacheMap((obj, key) => {\n      if (key.lastIndexOf('topic:', 0) === 0) {\n        obj._resetSub();\n      }\n    });\n\n    // Reject all pending promises\n    for (let key in this._pendingPromises) {\n      let 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 * Helper method to package account credential.\n * @memberof Tinode\n * @static\n *\n * @param {String|Object} 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} array with a single credentail or null 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.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {string} One of <tt>'me'</tt>, <tt>'grp'</tt>, <tt>'p2p'</tt> or <tt>undefined</tt>.\n */\nTinode.topicType = function(name) {\n  const types = {\n    'me': 'me',\n    'fnd': 'fnd',\n    'grp': 'grp',\n    'new': '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 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} true if the name is a name of a new topic.\n */\nTinode.isNewGroupTopicName = function(name) {\n  return (typeof name == 'string') && name.substring(0, 3) == TOPIC_NEW;\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. '0.15.5-rc1'.\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 require('ws').\n * @param xhrProvider XMLHttpRequest provider, e.g. for node require('xhr').\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;\n\n// Unicode [del] symbol.\nTinode.DEL_CHAR = '\\u2421';\n\n/**\n * Check if the given string reprsents NULL value.\n * @memberof Tinode\n * @static\n *\n * @param {String} str - string to check for null value.\n *\n * @returns {boolean} true if string is null, false otherwise.\n */\nTinode.isNullValue = function(str) {\n  return str === Tinode.DEL_CHAR;\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   * <tt>resolve()</tt> is called without parameters, <tt>reject()</tt> receives the <tt>Error</tt> 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   * 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} true if there is a live connection, false 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} true if authenticated, false otherwise.\n   */\n  isAuthenticated: function() {\n    return this._authenticated;\n  },\n\n  /**\n   * @typedef AccountParams\n   * @memberof Tinode\n   * @type Object\n   * @property {Tinode.DefAcs=} defacs - Default access parameters for user's <tt>me</tt> topic.\n   * @property {Object=} public - Public application-defined data exposed on <tt>me</tt> topic.\n   * @property {Object=} private - Private application-defined data accessible on <tt>me</tt> 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 <tt>me</tt> for authenticated users.\n   * @property {string=} anon - Access mode for <tt>me</tt>  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; <tt>\"basic\"</tt> and <tt>\"anonymous\"</tt> 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  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; <tt>\"basic\"</tt> 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        this.loginSuccessful(ctrl);\n        return ctrl;\n      });\n    }\n    return promise;\n  },\n\n  /**\n   * Create user with 'basic' 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 'basic' 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.\n   * @param {boolean} sendToServer - if true, send dt to server immediately.\n   *\n   * @param true if attempt was made to send the token to the server.\n   */\n  setDeviceToken: function(dt, sendToServer) {\n    let sent = false;\n    if (dt && dt != this._deviceToken) {\n      this._deviceToken = dt;\n      if (sendToServer && this.isConnected() && this.isAuthenticated()) {\n        this.send({\n          'hi': {\n            'dev': dt\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; <tt>\"basic\"</tt> 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        this.loginSuccessful(ctrl);\n        return 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   * @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   * @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   * @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   * @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.topicType(topicName) == 'p2p' && 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 <tt>true</tt>, 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 <tt>true</tt>, 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 <tt>true</tt>, 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   * @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 {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} topic - 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(topic, hard) {\n    const pkt = this.initPacket('del', topic);\n    pkt.del.what = 'topic';\n    pkt.del.hard = hard;\n\n    return this.send(pkt, pkt.del.id).then((ctrl) => {\n      this.cacheDel('topic', topic);\n      return this.ctrl;\n    });\n  },\n\n  /**\n   * Delete subscription. Requires Share permission.\n   * @memberof Tinode#\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  delSubscription: function(topic, user) {\n    const pkt = this.initPacket('del', topic);\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 'me' topic.\n   * @memberof Tinode#\n   *\n   * @param {String} method - validation method such as 'email' or 'tel'.\n   * @param {String} value - validation value, i.e. 'alice@example.com'.\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} topic - Name of the topic where the mesage is being aknowledged.\n   * @param {String} what - Action being aknowledged, either \"read\" or \"recv\".\n   * @param {Number} seq - Maximum id of the message being acknowledged.\n   */\n  note: function(topic, 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', topic);\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} topic - Name of the topic to broadcast to.\n   */\n  noteKeyPress: function(topic) {\n    const pkt = this.initPacket('note', topic);\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} topic - Name of the topic to get.\n   * @returns {Tinode.Topic} Requested or newly created topic or <tt>undefined</tt> if topic name is invalid.\n   */\n  getTopic: function(name) {\n    let topic = this.cacheGet('topic', name);\n    if (!topic && name) {\n      if (name == TOPIC_ME) {\n        topic = new TopicMe();\n      } else if (name == TOPIC_FND) {\n        topic = new TopicFnd();\n      } else {\n        topic = new Topic(name);\n      }\n      // topic._new = false;\n      this.cachePut('topic', name, topic);\n      this.attachCacheToTopic(topic);\n    }\n    return topic;\n  },\n\n  /**\n   * Instantiate a new unnamed topic. An actual name will be assigned by the server\n   * on {@link Tinode.Topic.subscribe}.\n   * @memberof Tinode#\n   *\n   * @param {Tinode.Callbacks} callbacks - Object with callbacks for various events.\n   * @returns {Tinode.Topic} Newly created topic.\n   */\n  newTopic: function(callbacks) {\n    const topic = new Topic(TOPIC_NEW, callbacks);\n    this.attachCacheToTopic(topic);\n    return topic;\n  },\n\n  /**\n   * Generate unique name  like 'new123456' suitable for creating a new group topic.\n   * @memberof Tinode#\n   *\n   * @returns {string} name which can be used for creating a new group topic.\n   */\n  newGroupTopicName: function() {\n    return TOPIC_NEW + this.getNextUniqueId();\n  },\n\n  /**\n   * Instantiate a new P2P topic with a given peer.\n   * @memberof Tinode#\n   *\n   * @param {string} peer - UID of the peer to start topic with.\n   * @param {Tinode.Callbacks} callbacks - Object with callbacks for various events.\n   * @returns {Tinode.Topic} Newly created topic.\n   */\n  newTopicWith: function(peer, callbacks) {\n    const topic = new Topic(peer, callbacks);\n    this.attachCacheToTopic(topic);\n    return topic;\n  },\n\n  /**\n   * Instantiate 'me' topic or get it from cache.\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.TopicMe} Instance of 'me' topic.\n   */\n  getMeTopic: function() {\n    return this.getTopic(TOPIC_ME);\n  },\n\n  /**\n   * Instantiate 'fnd' (find) topic or get it from cache.\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.Topic} Instance of 'fnd' topic.\n   */\n  getFndTopic: function() {\n    return this.getTopic(TOPIC_FND);\n  },\n\n  /**\n   * Create a new LargeFileHelper instance\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.LargeFileHelper} instance of a LargeFileHelper.\n   */\n  getLargeFileHelper: function() {\n    return new LargeFileHelper(this);\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 <tt>undefined</tt> 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 <tt>undefined</tt>.\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 <tt>null</tt> 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 name of the value to return\n   * @param defaultValue to return in case server limts are not set of value is not found.\n   * @returns {integer} 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 <tt>true</tt> to enable logging to console.\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 'hi' is sent, otherwise it will not be used.\n   * @memberof Tinode#\n   *\n   * @param {String} hl - human (UI) language, like \"en_US\" or \"zh-Hans\".\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 - Name of the topic to test.\n   * @returns {Boolean} true if topic is online, false otherwise.\n   */\n  isTopicOnline: function(name) {\n    const me = this.getMeTopic();\n    const cont = me && me.getContact(name);\n    return cont && cont.online;\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 \"on\".\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 {ctrl} (control) messages.\n   * @memberof Tinode#\n   * @type {Tinode.onCtrlMessage}\n   */\n  onCtrlMessage: undefined,\n\n  /**\n   * Callback to recieve {data} (content) messages.\n   * @memberof Tinode#\n   * @type {Tinode.onDataMessage}\n   */\n  onDataMessage: undefined,\n\n  /**\n   * Callback to receive {pres} (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 * 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 */\nvar MetaGetBuilder = function(parent) {\n  this.topic = parent;\n  const me = parent._tinode.getMeTopic();\n  this.contact = me && me.getContact(parent.name);\n  this.what = {};\n}\n\nMetaGetBuilder.prototype = {\n\n  // Get latest timestamp\n  _get_ims: function() {\n    const cupd = this.contact && this.contact.updated;\n    const tupd = this.topic._lastDescUpdate || 0;\n    return cupd > tupd ? cupd : tupd;\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} <tt>this</tt> 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} <tt>this</tt> 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} <tt>this</tt> 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} <tt>this</tt> 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} <tt>this</tt> object.\n   */\n  withLaterDesc: function() {\n    return this.withDesc(this._get_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} <tt>this</tt> 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} <tt>this</tt> 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} <tt>this</tt> 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} <tt>this</tt> object.\n   */\n  withLaterSub: function(limit) {\n    return this.withSub(\n      this.topic.getType() == 'p2p' ? this._get_ims() : this.topic._lastSubsUpdate,\n      limit);\n  },\n\n  /**\n   * Add query parameters to fetch topic tags.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @returns {Tinode.MetaGetBuilder} <tt>this</tt> 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. 'me' topic only.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @returns {Tinode.MetaGetBuilder} <tt>this</tt> 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} <tt>this</tt> 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 'del' id.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {Number=} limit number of deleted message ids to fetch\n   *\n   * @returns {Tinode.MetaGetBuilder} <tt>this</tt> 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\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 */\nvar 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 '+' or '-' then the bits to add or remove, e.g. '+R-W' or '-PS'.\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 a1 but missing in a2\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   * Convert 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} - <b>this</b> AccessMode.\n   */\n  setMode: function(m) {\n    this.mode = AccessMode.decode(m);\n    return this;\n  },\n  /**\n   * Update 'mode' value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string} u - string representation of the changes to apply to access mode.\n   * @returns {AccessMode} - <b>this</b> AccessMode.\n   */\n  updateMode: function(u) {\n    this.mode = AccessMode.update(this.mode, u);\n    return this;\n  },\n  /**\n   * Get 'mode' value as a string.\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} - <b>mode</b> value.\n   */\n  getMode: function() {\n    return AccessMode.encode(this.mode);\n  },\n\n  /**\n   * Assign 'given' 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} - <b>this</b> 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} - <b>this</b> 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} - <b>this</b> 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} - <b>this</b> 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} - <b>this</b> 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} - true 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} - true 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} - true 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} - true 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} - true 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} - true 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} - true 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} - true 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} - true 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} - true if flag is set.\n   */\n  isDeleter: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._DELETE);\n  }\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 {data} message.\n * @param {callback} callbacks.onMeta - Callback which receives a {meta} message.\n * @param {callback} callbacks.onPres - Callback which receives a {pres} message.\n * @param {callback} callbacks.onInfo - Callback which receives an {info} 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 {data} 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 = null;\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 when topic meta-desc update was recived.\n  this._lastDescUpdate = null;\n  // Timestap when topic meta-subs update was recived.\n  this._lastSubsUpdate = null;\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 = callbacls.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 ff the topic is already subscribed to.\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        // Name may change new123456 -> grpAbCdEf\n        this.name = ctrl.topic;\n\n        this.created = ctrl.ts;\n        this.updated = ctrl.ts;\n        // Don't assign touched, otherwise topic will be put on top of the list on subscribe.\n\n        this._cachePutSelf();\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) {\n            me._processMetaSub([{\n              _noForwarding: true,\n              topic: this.name,\n              created: ctrl.ts,\n              updated: ctrl.ts,\n              acs: this.acs\n            }]);\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 <tt>true</tt> 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 <tt>true</tt> 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 records.\n    if (Drafty.hasAttachments(pub.content) && !pub.head.attachments) {\n      let attachments = [];\n      Drafty.attachments(pub.content, (data) => {\n        attachments.push(data.ref);\n      });\n      pub.head.attachments = attachments;\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\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\n        return this.publishMessage(pub);\n      },\n      (err) => {\n        this._tinode.logger(\"WARNING: Message draft rejected by the server\", err);\n        pub._sending = false;\n        pub._failed = true;\n        this._messages.delAt(this._messages.find(pub));\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._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 {integer} 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. <tt>null</tt> 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: <tt>recv</tt>, <tt>read</tt>.\n   * @param {Number} seq - ID or the message read or received.\n   */\n  note: function(what, seq) {\n    const user = this._users[this._tinode.getCurrentUserID()];\n    if (user) {\n      if (!user[what] || user[what] < seq) {\n        if (this._subscribed) {\n          this._tinode.note(this.name, what, seq);\n        } else {\n          this._tinode.logger(\"INFO: Not sending {note} on inactive topic\");\n        }\n\n        user[what] = seq;\n      }\n    } else {\n      this._tinode.logger(\"ERROR: note(): user not found \" + this._tinode.getCurrentUserID());\n    }\n\n    // Update locally cached contact with the new count\n    const me = this._tinode.getMeTopic();\n    if (me) {\n      me.setMsgReadRecv(this.name, what, seq);\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  /**\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.getType() != 'p2p') {\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   * @return 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 {integer} sinceId - Optional seqId to start iterating from (inclusive).\n   * @param {integer} 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   * 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 `this` inside the `callback`.\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 notification to send: <tt>recv</tt>, <tt>read</tt>.\n   * @param {Number} seq - ID or the message 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 check for newer messages\n   */\n  msgHasMoreMessages: function(newer) {\n    return newer ? this.seq > this._maxSeq :\n      // _minSeq cound 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 {integer} 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 {integer} 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    return idx >= 0 ? this._messages.delAt(idx) : undefined;\n  },\n\n  /**\n   * Update message's seqId.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Object} pub message object.\n   * @param {integer} newSeqId new seq id for pub.\n   */\n  swapMessageId: function(pub, newSeqId) {\n    const idx = this._messages.find({\n      seq: pub.seq\n    });\n    const numMessages = this._messages.length();\n    pub.seq = newSeqId;\n    if (0 <= idx && idx < numMessages) {\n      // this._messages are sorted by `seq`.\n      // If changing pub.seq to newSeqId breaks the invariant, fix it.\n      if ((idx > 0 && this._messages.getAt(idx - 1).seq >= newSeqId) ||\n        (idx + 1 < numMessages && newSeqId < this._messages.getAt(idx + 1).seq <= newSeqId)) {\n        this._messages.delAt(idx);\n        this._messages.put(pub);\n      }\n    }\n  },\n\n  /**\n   * Remove a range of messages from the local cache.\n   * @memberof Tinode.Topic#\n   *\n   * @param {integer} fromId seq ID of the first message to remove (inclusive).\n   * @param {integer} 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    // 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 {integer} seqId id of the message to stop sending and remove from cache.\n   *\n   * @returns {boolean} true if message was cancelled, false 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        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' or <tt>undefined</tt>.\n   */\n  getType: function() {\n    return Tinode.topicType(this.name);\n  },\n\n  /**\n   * Get user's cumulative 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   * 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} - true if topic is archived, false otherwise.\n   */\n  isArchived: function() {\n    return this.private && this.private.arch ? true : false;\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   * @returns message status constant.\n   */\n  msgStatus: function(msg) {\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) {\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 {\n      status = MESSAGE_STATUS_TO_ME;\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._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 me = this._tinode.getMeTopic();\n    if (me) {\n      // Messages from the current user are considered to be read already.\n      me.setMsgReadRecv(this.name,\n        (!data.from || this._tinode.isMe(data.from)) ? 'read' : 'msg', data.seq, data.ts);\n    }\n  },\n\n  // Process metadata message\n  _routeMeta: function(meta) {\n    if (meta.desc) {\n      this._lastDescUpdate = meta.ts;\n      this._processMetaDesc(meta.desc);\n    }\n    if (meta.sub && meta.sub.length > 0) {\n      this._lastSubsUpdate = meta.ts;\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\n      // If this is an update from the current user, update the contact with the new count too.\n      if (this._tinode.isMe(info.from)) {\n        const me = this._tinode.getMeTopic();\n        if (me) {\n          me.setMsgReadRecv(info.topic, info.what, info.seq);\n        }\n      }\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    // Synthetic desc may include defacs for p2p topics which is useless.\n    // Remove it.\n    if (this.getType() == 'p2p') {\n      delete desc.defacs;\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\n    // Update relevant contact in the me topic, if available:\n    if (this.name !== TOPIC_ME && !desc._noForwarding) {\n      const me = this._tinode.getMeTopic();\n      if (me) {\n        // Must use original 'desc' instead of 'this' so not to lose DEL_CHAR.\n        me._processMetaSub([{\n          _noForwarding: true,\n          topic: this.name,\n          updated: this.updated,\n          touched: this.touched,\n          acs: desc.acs,\n          seq: desc.seq,\n          read: desc.read,\n          recv: desc.recv,\n          public: desc.public,\n          private: desc.private\n        }]);\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      sub.updated = new Date(sub.updated);\n      sub.deleted = sub.deleted ? new Date(sub.deleted) : null;\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 || new Date(),\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._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      this._messages.put(gap);\n    });\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  // List of contacts (topic_name -> Contact object)\n  this._contacts = {};\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      // String datetime headers to Date() objects.\n      stringToDate(this);\n\n      // 'P' permission was removed. All topics are offline now.\n      if (turnOff) {\n        Object.values(this._contacts).map((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            if (this.onContactUpdate) {\n              this.onContactUpdate('off', cont);\n            }\n          }\n        });\n      }\n\n      if (this.onMetaDesc) {\n        this.onMetaDesc(this);\n      }\n    },\n    enumerable: true,\n    configurable: true,\n    writable: false\n  },\n\n  // Override the original Topic._processMetaSub\n  _processMetaSub: {\n    value: function(subs) {\n      let updateCount = 0;\n      for (let idx in subs) {\n        const sub = subs[idx];\n        const topicName = sub.topic;\n\n        // Don't show 'me' and 'fnd' topics in the list of contacts.\n        if (topicName == TOPIC_FND || topicName == TOPIC_ME) {\n          continue;\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\n        let cont = null;\n        if (sub.deleted) {\n          cont = sub;\n          delete this._contacts[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          cont = mergeToCache(this._contacts, topicName, sub);\n\n          if (Tinode.topicType(topicName) == 'p2p') {\n            this._cachePutUser(topicName, cont);\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) {\n        this.onSubsUpdated(Object.keys(this._contacts), updateCount);\n      }\n    },\n    enumerable: true,\n    configurable: true,\n    writable: false\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    writable: false\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._contacts[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.touched = new Date();\n            cont.seq = pres.seq | 0;\n            // Check if message is sent by the current user. If so it's been read already.\n            if (!pres.act || this._tinode.isMe(pres.act)) {\n              cont.read = cont.read ? Math.max(cont.read, cont.seq) : cont.seq;\n              cont.recv = cont.recv ? Math.max(cont.read, cont.recv) : cont.recv;\n            }\n            cont.unread = cont.seq - cont.read;\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': // user agent changed\n            cont.seen = {\n              when: new Date(),\n              ua: pres.ua\n            };\n            break;\n          case 'recv': // 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': // 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': // topic deleted or unsubscribed from\n            delete this._contacts[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        if (this.onContactUpdate) {\n          this.onContactUpdate(pres.what, cont);\n        }\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            this._contacts[pres.src] = {\n              touched: new Date(),\n              topic: pres.src,\n              online: false,\n              acs: acs\n            };\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    writable: false\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    writable: false\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    writable: false\n  },\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 {function=} filter - Optionally filter contacts; include all if filter is false-ish, otherwise include those for\n   *                            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      for (let idx in this._contacts) {\n        const c = this._contacts[idx];\n        if (!filter || filter(c)) {\n          callback.call(context, c, idx, this._contacts);\n        }\n      }\n    },\n    enumerable: true,\n    configurable: true,\n    writable: true\n  },\n\n  /**\n   * Update a cached contact with new read/received/message count.\n   * @function\n   * @memberof Tinode.TopicMe#\n   *\n   * @param {String} contactName - UID of contact to update.\n   * @param {String} what - Whach count to update, one of <tt>\"read\", \"recv\", \"msg\"</tt>\n   * @param {Number} seq - New value of the count.\n   * @param {Date} ts - Timestamp of the update.\n   */\n  setMsgReadRecv: {\n    value: function(contactName, what, seq, ts) {\n      const cont = this._contacts[contactName];\n      let oldVal, doUpdate = false;\n      let mode = null;\n      if (cont) {\n        seq = seq | 0;\n        cont.seq = cont.seq | 0;\n        cont.read = cont.read | 0;\n        cont.recv = cont.recv | 0;\n        switch (what) {\n          case 'recv':\n            oldVal = cont.recv;\n            cont.recv = Math.max(cont.recv, seq);\n            doUpdate = (oldVal != cont.recv);\n            break;\n          case 'read':\n            oldVal = cont.read;\n            cont.read = Math.max(cont.read, seq);\n            doUpdate = (oldVal != cont.read);\n            break;\n          case 'msg':\n            oldVal = cont.seq;\n            cont.seq = Math.max(cont.seq, seq);\n            if (!cont.touched || cont.touched < ts) {\n              cont.touched = ts;\n            }\n            doUpdate = (oldVal != cont.seq);\n            break;\n        }\n\n        // Sanity checks.\n        if (cont.recv < cont.read) {\n          cont.recv = cont.read;\n          doUpdate = true;\n        }\n        if (cont.seq < cont.recv) {\n          cont.seq = cont.recv;\n          if (!cont.touched || cont.touched < ts) {\n            cont.touched = ts;\n          }\n          doUpdate = true;\n        }\n        cont.unread = cont.seq - cont.read;\n\n        if (doUpdate && (!cont.acs || !cont.acs.isMuted()) && this.onContactUpdate) {\n          this.onContactUpdate(what, cont);\n        }\n      }\n    },\n    enumerable: true,\n    configurable: true,\n    writable: 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._contacts[name];\n    },\n    enumerable: true,\n    configurable: true,\n    writable: 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._contacts[name];\n        return cont ? cont.acs : null;\n      }\n      return this.acs;\n    },\n    enumerable: true,\n    configurable: true,\n    writable: 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._contacts[name];\n      return cont ? ((cont.private && cont.private.arch) ? true : false) : null;\n    },\n    enumerable: true,\n    configurable: true,\n    writable: 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    writable: 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    writable: false\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    writable: false\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    writable: false\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    writable: true\n  }\n});\nTopicFnd.prototype.constructor = TopicFnd;\n\n/**\n * @class LargeFileHelper - collection of utilities for uploading and downloading files\n * out of band. Don't instantiate this class directly. Use {Tinode.getLargeFileHelper} instead.\n * @memberof Tinode\n *\n * @param {Tinode} tinode - the main Tinode object.\n */\nvar LargeFileHelper = function(tinode) {\n  this._tinode = tinode;\n\n  this._apiKey = tinode._apiKey;\n  this._authToken = tinode.getAuthToken();\n  this._msgId = tinode.getNextUniqueId();\n  this.xhr = new XMLHttpRequest();\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} file to upload\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, file, onProgress, onSuccess, onFailure) {\n    if (!this._authToken) {\n      throw new Error(\"Must authenticate first\");\n    }\n    const instance = this;\n\n    let url = '/v' + PROTOCOL_VERSION + '/file/u/';\n    if (baseUrl) {\n      if (baseUrl.indexOf('http://') == 0 || baseUrl.indexOf('https://') == 0) {\n        url = baseUrl + 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 = function(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', file);\n      form.set('id', this._msgId);\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} file to upload\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(file, onProgress, onSuccess, onFailure) {\n    return this.uploadWithBaseUrl(undefined, file, 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) {\n    // Check if the URL is relative. Check for cases like:\n    //  'http://example.com'\n    //  ' http://example.com'\n    //  '//example.com/'\n    //  'http:example.com'\n    //  'http:/example.com'\n    if (/^\\s*([a-z][a-z0-9+.-]*:|\\/\\/)/im.test(relativeUrl)) {\n      // As a security measure refuse to download from an absolute URL.\n      throw new Error(\"The URL '\" + relativeUrl + \"' must be relative, not absolute\");\n    }\n    if (!this._authToken) {\n      throw new Error(\"Must authenticate first\");\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._msgId;\n  }\n};\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","module.exports={\"version\": \"0.16.5\"}\n"]}