6902 lines
507 KiB
JavaScript
6902 lines
507 KiB
JavaScript
(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-2018 Tinode
|
|
* @summary Minimally rich text representation and formatting for Tinode.
|
|
* @license Apache 2.0
|
|
* @version 0.15
|
|
*
|
|
* @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* → <b>abc</b></li>
|
|
* <li>_abc_ → <i>abc</i></li>
|
|
* <li>~abc~ → <del>abc</del></li>
|
|
* <li>`abc` → <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) {
|
|
var chunks = [];
|
|
|
|
if (spans.length == 0) {
|
|
return [];
|
|
}
|
|
|
|
for (var i in spans) {
|
|
// Get the next chunk from the queue
|
|
var 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.
|
|
var chunk = {
|
|
type: span.type
|
|
};
|
|
var 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) {
|
|
let result = [];
|
|
|
|
// Process ranges calling formatter for each range.
|
|
for (let i = 0; i < spans.length; i++) {
|
|
let 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) {
|
|
let 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.
|
|
let 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.
|
|
let 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 [];
|
|
}
|
|
|
|
var tree = [spans[0]];
|
|
var last = spans[0];
|
|
for (var 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 (var i in tree) {
|
|
tree[i].children = toTree(tree[i].children);
|
|
}
|
|
|
|
return tree;
|
|
}
|
|
|
|
// Get a list of entities from a text.
|
|
function extractEntities(line) {
|
|
var match;
|
|
var 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;
|
|
});
|
|
|
|
var idx = -1;
|
|
extracted = extracted.filter(function(el) {
|
|
var 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) {
|
|
var plain = "";
|
|
var ranges = [];
|
|
for (var i in chunks) {
|
|
var 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 structured representation.
|
|
* @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.
|
|
var lines = content.split(/\r?\n/);
|
|
|
|
// Holds entities referenced from text
|
|
var entityMap = [];
|
|
var entityIndex = {};
|
|
|
|
// Processing lines one by one, hold intermediate result in blx.
|
|
var blx = [];
|
|
lines.map(function(line) {
|
|
var spans = [];
|
|
var 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));
|
|
});
|
|
|
|
var 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.
|
|
var chunks = chunkify(line, 0, line.length, spans);
|
|
|
|
var 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) {
|
|
var ranges = [];
|
|
for (var i in entities) {
|
|
// {offset: match['index'], unique: match[0], len: match[0].length, data: ent.packer(), type: ent.name}
|
|
var entity = entities[i];
|
|
var 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);
|
|
});
|
|
|
|
var 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 (var i = 1; i < blx.length; i++) {
|
|
var block = blx[i];
|
|
var 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;
|
|
}
|
|
|
|
/**
|
|
* Insert inline image into Drafty content.
|
|
* @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
|
|
});
|
|
|
|
let 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: ""
|
|
};
|
|
let 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) {
|
|
var {
|
|
txt,
|
|
fmt,
|
|
ent
|
|
} = content;
|
|
|
|
var markup = [];
|
|
if (fmt) {
|
|
for (let i in fmt) {
|
|
let range = fmt[i];
|
|
let tp = range.tp,
|
|
data;
|
|
if (!tp) {
|
|
let 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 (var 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);
|
|
}
|
|
|
|
/**
|
|
* 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-2018 Tinode
|
|
* @summary Javascript bindings for Tinode.
|
|
* @license Apache 2.0
|
|
* @version 0.15
|
|
*
|
|
* @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;
|
|
}
|
|
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,
|
|
URL: {
|
|
createObjectURL: function() {
|
|
throw new Error("Unable to use window.URL 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];
|
|
}
|
|
|
|
// Basic cross-domain requester. Supports normal browsers and IE8+
|
|
function xdreq() {
|
|
let xdreq = null;
|
|
|
|
// Detect browser support for CORS
|
|
if ('withCredentials' in new XMLHttpRequest()) {
|
|
// Support for standard cross-domain requests
|
|
xdreq = new XMLHttpRequest();
|
|
} else if (typeof XDomainRequest != 'undefined') {
|
|
// IE-specific "CORS" with XDR
|
|
xdreq = new XDomainRequest();
|
|
} else {
|
|
// Browser without CORS support, don't know how to handle
|
|
throw new Error("Browser not supported");
|
|
}
|
|
|
|
return xdreq;
|
|
};
|
|
|
|
// 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.
|
|
*/
|
|
var CBuffer = function(compare) {
|
|
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 pivot;
|
|
}
|
|
if (exact) {
|
|
return -1;
|
|
}
|
|
// Not exact - insertion point
|
|
return diff < 0 ? pivot + 1 : pivot;
|
|
}
|
|
|
|
// Insert element into a sorted array.
|
|
function insertSorted(elem, arr) {
|
|
arr.splice(findNearest(elem, arr, false), 0, 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];
|
|
},
|
|
|
|
/** 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 maximum number of element the buffer can hold
|
|
* @memberof Tinode.CBuffer#
|
|
* @return {number} The size of the buffer.
|
|
*/
|
|
size: function() {
|
|
return buffer.length;
|
|
},
|
|
|
|
/**
|
|
* Discard all elements and reset the buffer to the new size (maximum number of elements).
|
|
* @memberof Tinode.CBuffer#
|
|
* @param {number} newSize - New size of the buffer.
|
|
*/
|
|
reset: function(newSize) {
|
|
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) {
|
|
return findNearest(elem, buffer, !nearest);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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#
|
|
* @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_) {
|
|
_boffClosed = false;
|
|
|
|
if (_socket && _socket.readyState == _socket.OPEN) {
|
|
if (!force) {
|
|
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);
|
|
|
|
const conn = new WebSocketProvider(url);
|
|
|
|
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.onerror = function(err) {
|
|
reject(err);
|
|
}
|
|
|
|
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 = xdreq();
|
|
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 = xdreq();
|
|
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_) {
|
|
_boffClosed = false;
|
|
|
|
if (_poller) {
|
|
return Promise.resolve();
|
|
}
|
|
|
|
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(function() {
|
|
// Catch an error and do nothing.
|
|
});
|
|
};
|
|
|
|
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');
|
|
}
|
|
}
|
|
|
|
if (transport_ === 'lp') {
|
|
// explicit request to use long polling
|
|
init_lp(this);
|
|
} else if (transport_ === 'ws') {
|
|
// explicit request to use web socket
|
|
// if websockets are not available, horrible things will happen
|
|
init_ws(this);
|
|
} else {
|
|
// Default transport selection
|
|
if (typeof window != 'object' || !window['WebSocket']) {
|
|
// The browser has no websockets
|
|
init_lp(this);
|
|
} else {
|
|
// Using web sockets -- default.
|
|
init_ws(this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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._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) + ':' +
|
|
('0' + 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 for non browser app, allow to specify WebSocket provider
|
|
* @param provider webSocket provider ex: for nodeJS require('ws')
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
*/
|
|
Tinode.setWebSocketProvider = function(provider) {
|
|
WebSocketProvider = provider;
|
|
};
|
|
|
|
/**
|
|
* 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';
|
|
|
|
// 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
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
delTopic: function(topic) {
|
|
const pkt = this.initPacket('del', topic);
|
|
pkt.del.what = 'topic';
|
|
|
|
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. Must be 'me' topic.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {String} topic - 'me'.
|
|
* @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(topic, method, value) {
|
|
if (topic != 'me') {
|
|
throw new Error("Invalid topic for deleting credentials '" + topic + "'");
|
|
}
|
|
const pkt = this.initPacket('del', topic);
|
|
pkt.del.what = 'cred';
|
|
pkt.del.cred = {
|
|
meth: method,
|
|
val: value
|
|
};
|
|
return this.send(pkt, pkt.del.id);
|
|
},
|
|
|
|
/**
|
|
* 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;
|
|
},
|
|
|
|
/**
|
|
* 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;
|
|
},
|
|
|
|
/**
|
|
* 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.logger("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;
|
|
};
|
|
|
|
/**
|
|
* AccessMode is a class representing topic access mode.
|
|
* @class Topic
|
|
* @memberof Tinode
|
|
*/
|
|
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;
|
|
});
|
|
// 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.seq = ctrl.params.seq;
|
|
pub.ts = ctrl.ts;
|
|
this._routeData(pub);
|
|
return ctrl;
|
|
}).catch((err) => {
|
|
this.logger("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.logger("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) {
|
|
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 ? user = this.subscriber(uid) : null;
|
|
let am;
|
|
if (user) {
|
|
am = user.acs.updateGiven(update).getGiven();
|
|
} else {
|
|
am = topic.getAccessMode().updateWant(update).getWant();
|
|
}
|
|
|
|
return topic.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);
|
|
}
|
|
});
|
|
|
|
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#
|
|
*
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
|
|
*/
|
|
delTopic: function() {
|
|
const topic = this;
|
|
return this._tinode.delTopic(this.name).then(function(ctrl) {
|
|
topic._resetSub();
|
|
topic._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("Not sending {note} on inactive topic");
|
|
}
|
|
|
|
user[what] = seq;
|
|
}
|
|
} else {
|
|
this._tinode.logger("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.
|
|
*/
|
|
noteRead: function(seq) {
|
|
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("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
|
|
}) : 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) {
|
|
let idx = this._messages.find({
|
|
seq: seqId
|
|
});
|
|
return idx >= 0 ? this._messages.delAt(idx) : undefined;
|
|
},
|
|
|
|
/**
|
|
* 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) {
|
|
// Maybe this is an empty message to indicate there are no actual messages.
|
|
if (data.content) {
|
|
if (!this.touched || this.touched < data.ts) {
|
|
this.touched = data.ts;
|
|
}
|
|
|
|
if (!data._noForwarding) {
|
|
this._messages.put(data);
|
|
}
|
|
}
|
|
|
|
if (data.seq > this._maxSeq) {
|
|
this._maxSeq = data.seq;
|
|
}
|
|
if (data.seq < this._minSeq || this._minSeq == 0) {
|
|
this._minSeq = data.seq;
|
|
}
|
|
|
|
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,
|
|
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("Presence update for an unknown user", this.name, pres.src);
|
|
}
|
|
break;
|
|
case 'acs':
|
|
user = this._users[pres.src];
|
|
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(pres.src);
|
|
if (!user) {
|
|
user = {
|
|
user: pres.src,
|
|
acs: acs
|
|
};
|
|
this.getMeta(this.startMetaQuery().withOneSub(undefined, pres.src).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: pres.src,
|
|
updated: new Date(),
|
|
acs: user.acs
|
|
}]);
|
|
}
|
|
break;
|
|
default:
|
|
this._tinode.logger("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);
|
|
|
|
if (typeof this.created == 'string') {
|
|
this.created = new Date(this.created);
|
|
}
|
|
if (typeof this.updated == 'string') {
|
|
this.updated = new Date(this.updated);
|
|
}
|
|
if (typeof this.touched == 'string') {
|
|
this.touched = new Date(this.touched);
|
|
}
|
|
|
|
// Update relevant contact in the me topic, if available:
|
|
if (this.name !== '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.onData) {
|
|
this.onData();
|
|
}
|
|
},
|
|
|
|
// Topic is informed that the entire response to {get what=data} has been received.
|
|
_allMessagesReceived: function(count) {
|
|
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: '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++;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @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._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 if (sub.acs && !sub.acs.isJoiner()) {
|
|
cont = sub;
|
|
cont.deleted = new Date();
|
|
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) {
|
|
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;
|
|
cont.unread = cont.seq - cont.read;
|
|
break;
|
|
case 'upd': // desc updated
|
|
// Request updated description
|
|
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
|
|
cont.recv = cont.recv ? Math.max(cont.recv, pres.seq) : (pres.seq | 0);
|
|
break;
|
|
case 'read': // user's other session marked some messages as read
|
|
cont.read = cont.read ? Math.max(cont.read, pres.seq) : (pres.seq | 0);
|
|
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.logger("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("Invalid access mode update", pres.src, pres.dacs);
|
|
return;
|
|
} else if (acs.mode == AccessMode._NONE) {
|
|
this._tinode.logger("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(this.name, 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. If callback is undefined, use {@link this.onMetaSub}.
|
|
* @function
|
|
* @memberof Tinode.TopicMe#
|
|
* @param {TopicMe.ContactCallback=} callback - Callback to call for each contact.
|
|
* @param {boolean=} includeBanned - Include banned contacts.
|
|
* @param {Object=} context - Context to use for calling the `callback`, i.e. the value of `this` inside the callback.
|
|
*/
|
|
contacts: {
|
|
value: function(callback, includeBanned, context) {
|
|
const cb = (callback || this.onMetaSub);
|
|
if (cb) {
|
|
for (let idx in this._contacts) {
|
|
if (!includeBanned &&
|
|
(!this._contacts[idx] ||
|
|
!this._contacts[idx].acs ||
|
|
!this._contacts[idx].acs.isJoiner())) {
|
|
|
|
continue;
|
|
}
|
|
cb.call(context, this._contacts[idx], 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.
|
|
* @returns {string} - access mode, such as `RWP`.
|
|
*/
|
|
getAccessMode: {
|
|
value: function(name) {
|
|
const cont = this._contacts[name];
|
|
return cont ? cont.acs : null;
|
|
},
|
|
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 = xdreq();
|
|
|
|
// 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("Invalid server response in LargeFileHelper", this.response);
|
|
}
|
|
|
|
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("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');
|
|
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("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;
|
|
}
|
|
|
|
}).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.2-rc2"}
|
|
|
|
},{}]},{},[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;;;AC/1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACx4KA;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-2018 Tinode\n * @summary Minimally rich text representation and formatting for Tinode.\n * @license Apache 2.0\n * @version 0.15\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  var chunks = [];\n\n  if (spans.length == 0) {\n    return [];\n  }\n\n  for (var i in spans) {\n    // Get the next chunk from the queue\n    var 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    var chunk = {\n      type: span.type\n    };\n    var 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  let result = [];\n\n  // Process ranges calling formatter for each range.\n  for (let i = 0; i < spans.length; i++) {\n    let 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  let 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    let 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    let 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  var tree = [spans[0]];\n  var last = spans[0];\n  for (var 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 (var 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  var match;\n  var 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  var idx = -1;\n  extracted = extracted.filter(function(el) {\n    var 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  var plain = \"\";\n  var ranges = [];\n  for (var i in chunks) {\n    var 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 structured representation.\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  var lines = content.split(/\\r?\\n/);\n\n  // Holds entities referenced from text\n  var entityMap = [];\n  var entityIndex = {};\n\n  // Processing lines one by one, hold intermediate result in blx.\n  var blx = [];\n  lines.map(function(line) {\n    var spans = [];\n    var 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    var 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      var chunks = chunkify(line, 0, line.length, spans);\n\n      var 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      var ranges = [];\n      for (var i in entities) {\n        // {offset: match['index'], unique: match[0], len: match[0].length, data: ent.packer(), type: ent.name}\n        var entity = entities[i];\n        var 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  var 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 (var i = 1; i < blx.length; i++) {\n      var block = blx[i];\n      var 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 * Insert inline image into Drafty content.\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  let 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  let 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  var {\n    txt,\n    fmt,\n    ent\n  } = content;\n\n  var markup = [];\n  if (fmt) {\n    for (let i in fmt) {\n      let range = fmt[i];\n      let tp = range.tp,\n        data;\n      if (!tp) {\n        let 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 (var 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 * 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-2018 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.15\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}\ninitForNonBrowserApp();\n\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      URL: {\n        createObjectURL: function() {\n          throw new Error(\"Unable to use window.URL 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\n// Basic cross-domain requester. Supports normal browsers and IE8+\nfunction xdreq() {\n  let xdreq = null;\n\n  // Detect browser support for CORS\n  if ('withCredentials' in new XMLHttpRequest()) {\n    // Support for standard cross-domain requests\n    xdreq = new XMLHttpRequest();\n  } else if (typeof XDomainRequest != 'undefined') {\n    // IE-specific \"CORS\" with XDR\n    xdreq = new XDomainRequest();\n  } else {\n    // Browser without CORS support, don't know how to handle\n    throw new Error(\"Browser not supported\");\n  }\n\n  return xdreq;\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 */\nvar CBuffer = function(compare) {\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 pivot;\n    }\n    if (exact) {\n      return -1;\n    }\n    // Not exact - insertion point\n    return diff < 0 ? pivot + 1 : pivot;\n  }\n\n  // Insert element into a sorted array.\n  function insertSorted(elem, arr) {\n    arr.splice(findNearest(elem, arr, false), 0, 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    /** 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 maximum number of element the buffer can hold\n     * @memberof Tinode.CBuffer#\n     * @return {number} The size of the buffer.\n     */\n    size: function() {\n      return buffer.length;\n    },\n\n    /**\n     * Discard all elements and reset the buffer to the new size (maximum number of elements).\n     * @memberof Tinode.CBuffer#\n     * @param {number} newSize - New size of the buffer.\n     */\n    reset: function(newSize) {\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      return findNearest(elem, buffer, !nearest);\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     * @return {Promise} Promise resolved/rejected when the connection call completes,\n     resolution is called without parameters, rejection passes the {Error} as parameter.\n     */\n    instance.connect = function(host_) {\n      _boffClosed = false;\n\n      if (_socket && _socket.readyState == _socket.OPEN) {\n        if (!force) {\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        const conn = new WebSocketProvider(url);\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.onerror = function(err) {\n          reject(err);\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 = xdreq();\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 = xdreq();\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_) {\n      _boffClosed = false;\n\n      if (_poller) {\n        return Promise.resolve();\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(function() {\n        // Catch an error and do nothing.\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  if (transport_ === 'lp') {\n    // explicit request to use long polling\n    init_lp(this);\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  } else {\n    // Default transport selection\n    if (typeof window != 'object' || !window['WebSocket']) {\n      // The browser has no websockets\n      init_lp(this);\n    } else {\n      // Using web sockets -- default.\n      init_ws(this);\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._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        ('0' + 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 for non browser app, allow to specify WebSocket provider\n * @param provider webSocket provider ex: for nodeJS require('ws')\n * @memberof Tinode\n * @static\n *\n */\nTinode.setWebSocketProvider = function(provider) {\n  WebSocketProvider = provider;\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,\n  Tinode.MESSAGE_STATUS_QUEUED = MESSAGE_STATUS_QUEUED,\n  Tinode.MESSAGE_STATUS_SENDING = MESSAGE_STATUS_SENDING,\n  Tinode.MESSAGE_STATUS_FAILED = MESSAGE_STATUS_FAILED,\n  Tinode.MESSAGE_STATUS_SENT = MESSAGE_STATUS_SENT,\n  Tinode.MESSAGE_STATUS_RECEIVED = MESSAGE_STATUS_RECEIVED,\n  Tinode.MESSAGE_STATUS_READ = MESSAGE_STATUS_READ,\n  Tinode.MESSAGE_STATUS_TO_ME = MESSAGE_STATUS_TO_ME,\n\n  // Unicode [del] symbol.\n  Tinode.DEL_CHAR = '\\u2421';\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   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delTopic: function(topic) {\n    const pkt = this.initPacket('del', topic);\n    pkt.del.what = 'topic';\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. Must be 'me' topic.\n   * @memberof Tinode#\n   *\n   * @param {String} topic - 'me'.\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(topic, method, value) {\n    if (topic != 'me') {\n      throw new Error(\"Invalid topic for deleting credentials '\" + topic + \"'\");\n    }\n    const pkt = this.initPacket('del', topic);\n    pkt.del.what = 'cred';\n    pkt.del.cred = {\n      meth: method,\n      val: value\n    };\n    return this.send(pkt, pkt.del.id);\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   * 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   * 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.logger(\"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 * AccessMode is a class representing topic access mode.\n * @class Topic\n * @memberof Tinode\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  });\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.seq = ctrl.params.seq;\n      pub.ts = ctrl.ts;\n      this._routeData(pub);\n      return ctrl;\n    }).catch((err) => {\n      this.logger(\"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.logger(\"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          if (ctrl.params && ctrl.params.acs) {\n            params.sub.acs = ctrl.params.acs;\n            params.sub.updated = ctrl.ts;\n          }\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 ? user = this.subscriber(uid) : null;\n    let am;\n    if (user) {\n      am = user.acs.updateGiven(update).getGiven();\n    } else {\n      am = topic.getAccessMode().updateWant(update).getWant();\n    }\n\n    return topic.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      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   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  delTopic: function() {\n    const topic = this;\n    return this._tinode.delTopic(this.name).then(function(ctrl) {\n      topic._resetSub();\n      topic._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(\"Not sending {note} on inactive topic\");\n        }\n\n        user[what] = seq;\n      }\n    } else {\n      this._tinode.logger(\"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.\n   */\n  noteRead: function(seq) {\n    this.note('read', seq);\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(\"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      }) : 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    let idx = this._messages.find({\n      seq: seqId\n    });\n    return idx >= 0 ? this._messages.delAt(idx) : undefined;\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    // Maybe this is an empty message to indicate there are no actual messages.\n    if (data.content) {\n      if (!this.touched || this.touched < data.ts) {\n        this.touched = data.ts;\n      }\n\n      if (!data._noForwarding) {\n        this._messages.put(data);\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 (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        this._tinode.isMe(data.from) ? 'read' : 'msg',\n        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(\"Presence update for an unknown user\", this.name, pres.src);\n        }\n        break;\n      case 'acs':\n        user = this._users[pres.src];\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(pres.src);\n            if (!user) {\n              user = {\n                user: pres.src,\n                acs: acs\n              };\n              this.getMeta(this.startMetaQuery().withOneSub(undefined, pres.src).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: pres.src,\n            updated: new Date(),\n            acs: user.acs\n          }]);\n        }\n        break;\n      default:\n        this._tinode.logger(\"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\n    if (typeof this.created == 'string') {\n      this.created = new Date(this.created);\n    }\n    if (typeof this.updated == 'string') {\n      this.updated = new Date(this.updated);\n    }\n    if (typeof this.touched == 'string') {\n      this.touched = new Date(this.touched);\n    }\n\n    // Update relevant contact in the me topic, if available:\n    if (this.name !== '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    if (count > 0 && this.onData) {\n      this.onData();\n    }\n  },\n\n  // Topic is informed that the entire response to {get what=data} has been received.\n  _allMessagesReceived: function(count) {\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: '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\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._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 if (sub.acs && !sub.acs.isJoiner()) {\n          cont = sub;\n          cont.deleted = new Date();\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      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            cont.unread = cont.seq - cont.read;\n            break;\n          case 'upd': // desc updated\n            // Request updated description\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            cont.recv = cont.recv ? Math.max(cont.recv, pres.seq) : (pres.seq | 0);\n            break;\n          case 'read': // user's other session marked some messages as read\n            cont.read = cont.read ? Math.max(cont.read, pres.seq) : (pres.seq | 0);\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.logger(\"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(\"Invalid access mode update\", pres.src, pres.dacs);\n            return;\n          } else if (acs.mode == AccessMode._NONE) {\n            this._tinode.logger(\"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(this.name, 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. If callback is undefined, use {@link this.onMetaSub}.\n   * @function\n   * @memberof Tinode.TopicMe#\n   * @param {TopicMe.ContactCallback=} callback - Callback to call for each contact.\n   * @param {boolean=} includeBanned - Include banned contacts.\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, includeBanned, context) {\n      const cb = (callback || this.onMetaSub);\n      if (cb) {\n        for (let idx in this._contacts) {\n          if (!includeBanned &&\n            (!this._contacts[idx] ||\n              !this._contacts[idx].acs ||\n              !this._contacts[idx].acs.isJoiner())) {\n\n            continue;\n          }\n          cb.call(context, this._contacts[idx], 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) or a topic name.\n   * @returns {string} - access mode, such as `RWP`.\n   */\n  getAccessMode: {\n    value: function(name) {\n      const cont = this._contacts[name];\n      return cont ? cont.acs : null;\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 = xdreq();\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(\"Invalid server response in LargeFileHelper\", this.response);\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(\"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        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(\"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}\n","module.exports={\"version\": \"0.16.2-rc2\"}\n"]}
|