8234 lines
613 KiB
JavaScript
8234 lines
613 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){
|
|
/**
|
|
* @file Helper methods for dealing with IndexedDB cache of messages, users, and topics.
|
|
* See <a href="https://github.com/tinode/webapp">https://github.com/tinode/webapp</a> for real-life usage.
|
|
*
|
|
* @copyright 2015-2021 Tinode
|
|
* @summary Javascript bindings for Tinode.
|
|
* @license Apache 2.0
|
|
* @version 0.17
|
|
*/
|
|
'use strict';
|
|
|
|
const DB_VERSION = 1;
|
|
const DB_NAME = 'tinode-web';
|
|
|
|
const DB = function(onError, logger) {
|
|
onError = onError || function() {}
|
|
logger = logger || function() {}
|
|
|
|
// Placeholder DB which does nothing.
|
|
let db = null;
|
|
|
|
// Serializable topic fields.
|
|
const topic_fields = ['created', 'updated', 'deleted', 'read', 'recv', 'seq', 'clear', 'defacs',
|
|
'creds', 'public', 'private', 'touched'
|
|
];
|
|
|
|
function serializeTopic(topic) {
|
|
const res = {
|
|
name: topic.name
|
|
};
|
|
topic_fields.forEach((f) => {
|
|
if (topic.hasOwnProperty(f)) {
|
|
res[f] = topic[f];
|
|
}
|
|
});
|
|
if (Array.isArray(topic._tags)) {
|
|
res.tags = topic._tags;
|
|
}
|
|
if (topic.acs) {
|
|
res.acs = topic.getAccessMode().jsonHelper();
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// Copy data from src to topic.
|
|
function deserializeTopic(topic, src) {
|
|
topic_fields.forEach((f) => {
|
|
if (src.hasOwnProperty(f)) {
|
|
topic[f] = src[f];
|
|
}
|
|
});
|
|
if (Array.isArray(src.tags)) {
|
|
topic._tags = src.tags;
|
|
}
|
|
if (src.acs) {
|
|
topic.setAccessMode(src.acs);
|
|
}
|
|
}
|
|
|
|
function serializeUser(user) {
|
|
return {};
|
|
}
|
|
|
|
function serializeMessage(topicName, msg) {
|
|
// Serializable fields.
|
|
const fields = ['topic', 'seq', 'ts', 'status', 'from', 'head', 'content'];
|
|
const res = {
|
|
topic: topicName
|
|
};
|
|
fields.forEach((f) => {
|
|
if (msg.hasOwnProperty(f)) {
|
|
res[f] = msg[f];
|
|
}
|
|
});
|
|
return res;
|
|
}
|
|
|
|
return {
|
|
/**
|
|
* Initialize persistent cache: open or create/upgrade if needed.
|
|
* @returns {Promise} promise to be resolved/rejected when the DB is initialized.
|
|
*/
|
|
initDatabase: function() {
|
|
return new Promise((resolve, reject) => {
|
|
// Open the database and initialize callbacks.
|
|
const req = indexedDB.open(DB_NAME, DB_VERSION);
|
|
req.onerror = (event) => {
|
|
logger("PCache", "failed to initialize", event);
|
|
reject(event.target.error);
|
|
if (onError) {
|
|
onError(event.target.error);
|
|
}
|
|
};
|
|
|
|
req.onsuccess = (event) => {
|
|
db = event.target.result;
|
|
resolve(db);
|
|
};
|
|
|
|
req.onupgradeneeded = function(event) {
|
|
db = event.target.result;
|
|
|
|
db.onerror = function(event) {
|
|
logger("PCache", "failed to create storage", event);
|
|
if (onError) {
|
|
onError(event.target.error);
|
|
}
|
|
};
|
|
|
|
// Individual object stores.
|
|
|
|
// Object store (table) for topics. The primary key is topic name.
|
|
db.createObjectStore('topic', {
|
|
keyPath: 'name'
|
|
});
|
|
|
|
// Users object store. UID is the primary key.
|
|
db.createObjectStore('user', {
|
|
keyPath: 'uid'
|
|
});
|
|
|
|
// Messages object store. The primary key is topic name + seq.
|
|
db.createObjectStore('message', {
|
|
keyPath: ['topic', 'seq']
|
|
});
|
|
};
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Delete persistent cache.
|
|
*/
|
|
deleteDatabase: function() {
|
|
return new Promise((resolve, reject) => {
|
|
const req = indexedDB.deleteDatabase(DB_NAME);
|
|
req.onerror = function(event) {
|
|
logger("PCache", "deleteDatabase", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
req.onsuccess = function(event) {
|
|
resolve(true);
|
|
};
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Check if persistent cache is ready for use.
|
|
* @returns {boolean} <code>true</code> if cache is ready, <code>false</code> otherwise.
|
|
*/
|
|
isReady: function() {
|
|
return !!db;
|
|
},
|
|
|
|
// Topics.
|
|
/**
|
|
* Serialize topic and write to database.
|
|
* @memberOf DB
|
|
* @param {Topic} topic - topic to be added to persistent storage.
|
|
* @returns {Promise} promise resolved/rejected on operation completion.
|
|
*/
|
|
addTopic: function(topic) {
|
|
if (!this.isReady()) {
|
|
return Promise.reject(new Error("not initialized"));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const trx = db.transaction(['topic'], 'readwrite');
|
|
trx.onsuccess = (event) => {
|
|
resolve(event.target.result);
|
|
};
|
|
trx.onerror = (event) => {
|
|
logger("PCache", "addTopic", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
trx.objectStore('topic').add(serializeTopic(topic));
|
|
trx.commit();
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Remove topic from the database.
|
|
* @memberOf DB
|
|
* @param {string} name - name of the topic to remove from database.
|
|
* @return {Promise} promise resolved/rejected on operation completion.
|
|
*/
|
|
remTopic: function(name) {
|
|
if (!this.isReady()) {
|
|
return Promise.reject(new Error("not initialized"));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const trx = db.transaction(['topic', 'message'], 'readwrite');
|
|
trx.onsuccess = (event) => {
|
|
resolve(event.target.result);
|
|
};
|
|
trx.onerror = (event) => {
|
|
logger("PCache", "remTopic", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
trx.objectStore('topic').delete(IDBKeyRange.only(name));
|
|
trx.objectStore('message').delete(IDBKeyRange.bound([name, 0], [name, Number.MAX_SAFE_INTEGER]));
|
|
trx.commit();
|
|
});
|
|
},
|
|
/**
|
|
* Update stored topic.
|
|
* @memberOf DB
|
|
* @param {Topic} topic - topic to update.
|
|
* @return {Promise} promise resolved/rejected on operation completion.
|
|
*/
|
|
updTopic: function(topic) {
|
|
if (!this.isReady()) {
|
|
return Promise.reject(new Error("not initialized"));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const trx = db.transaction(['topic'], 'readwrite');
|
|
trx.onsuccess = (event) => {
|
|
resolve(event.target.result);
|
|
};
|
|
trx.onerror = (event) => {
|
|
logger("PCache", "updTopic", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
trx.objectStore('topic').put(serializeTopic(topic));
|
|
trx.commit();
|
|
});
|
|
},
|
|
/**
|
|
* Execute a callback for each stored topic.
|
|
* @memberOf DB
|
|
* @param {function} callback - function to call for each topic.
|
|
* @param {Object} context - the value or <code>this</code> inside the callback.
|
|
* @return {Promise} promise resolved/rejected on operation completion.
|
|
*/
|
|
mapTopics: function(callback, context) {
|
|
if (!this.isReady()) {
|
|
return Promise.reject(new Error("not initialized"));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const trx = db.transaction(['topic']);
|
|
trx.onerror = (event) => {
|
|
logger("PCache", "mapTopics", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
trx.objectStore('topic').getAll().onsuccess = (event) => {
|
|
if (callback) {
|
|
event.target.result.forEach((topic) => {
|
|
callback.call(context, topic);
|
|
});
|
|
}
|
|
resolve(event.target.result);
|
|
};
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Copy data from serialized object to topic.
|
|
* @memberOf DB
|
|
* @param {Topic} topic - target to deserialize to.
|
|
* @param {Object} src - serialized data to copy from.
|
|
*/
|
|
deserializeTopic: function(topic, src) {
|
|
deserializeTopic(topic, src);
|
|
},
|
|
|
|
// Users.
|
|
addUser: function(user) {
|
|
if (!this.isReady()) {
|
|
return Promise.reject(new Error("not initialized"));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const trx = db.transaction(['user'], 'readwrite');
|
|
trx.onsuccess = (event) => {
|
|
resolve(event.target.result);
|
|
};
|
|
trx.onerror = (event) => {
|
|
logger("PCache", "addUser", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
trx.objectStore('user').add(serializeUser(user));
|
|
trx.commit();
|
|
});
|
|
},
|
|
|
|
remUser: function(uid) {
|
|
if (!this.isReady()) {
|
|
return Promise.reject(new Error("not initialized"));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const trx = db.transaction(['user'], 'readwrite');
|
|
trx.onsuccess = (event) => {
|
|
resolve(event.target.result);
|
|
};
|
|
trx.onerror = (event) => {
|
|
logger("PCache", "remUser", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
trx.objectStore('user').delete(IDBKeyRange.only(uid));
|
|
trx.commit();
|
|
});
|
|
},
|
|
|
|
// Messages.
|
|
/**
|
|
* Save message to persistent cache.
|
|
* @memberOf DB
|
|
* @param {string} topicName - name of the topic which owns the message.
|
|
* @param {Object} msg - message to save.
|
|
* @return {Promise} promise resolved/rejected on operation completion.
|
|
*/
|
|
addMessage: function(topicName, msg) {
|
|
if (!this.isReady()) {
|
|
return Promise.reject(new Error("not initialized"));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const trx = db.transaction(['message'], 'readwrite');
|
|
trx.onsuccess = (event) => {
|
|
resolve(event.target.result);
|
|
};
|
|
trx.onerror = (event) => {
|
|
logger("PCache", "addMesssage", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
trx.objectStore('message').add(serializeMessage(topicName, msg));
|
|
trx.commit();
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Update message stored in persistent cache.
|
|
* @memberOf DB
|
|
* @param {string} topicName - name of the topic which owns the message.
|
|
* @param {Object} msg - message to update.
|
|
* @return {Promise} promise resolved/rejected on operation completion.
|
|
*/
|
|
updMessage: function(topicName, msg) {
|
|
if (!this.isReady()) {
|
|
return Promise.reject(new Error("not initialized"));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const trx = db.transaction(['message'], 'readwrite');
|
|
trx.onsuccess = (event) => {
|
|
resolve(event.target.result);
|
|
};
|
|
trx.onerror = (event) => {
|
|
logger("PCache", "updMessage", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
trx.objectStore('message').put(serializeMessage(topicName, msg));
|
|
trx.commit();
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Remove one or more messages from persistent cache.
|
|
* @memberOf DB
|
|
* @param {string} topicName - name of the topic which owns the message.
|
|
* @param {number} from - id of the message to remove or lower boundary when removing range (inclusive).
|
|
* @param {number=} to - upper boundary (exclusive) when removing a range of messages.
|
|
* @return {Promise} promise resolved/rejected on operation completion.
|
|
*/
|
|
remMessages: function(topicName, from, to) {
|
|
if (!this.isReady()) {
|
|
return Promise.reject(new Error("not initialized"));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
if (!from && !to) {
|
|
from = 0;
|
|
to = Number.MAX_SAFE_INTEGER;
|
|
}
|
|
const range = to > 0 ? IDBKeyRange.bound([topicName, from], [topicName, to], false, true) :
|
|
IDBKeyRange.only([topicName, from]);
|
|
const trx = db.transaction(['message'], 'readwrite');
|
|
trx.onsuccess = (event) => {
|
|
resolve(event.target.result);
|
|
};
|
|
trx.onerror = (event) => {
|
|
logger("PCache", "remMessages", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
trx.objectStore('message').delete(range);
|
|
trx.commit();
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Retrieve messages from persistent store.
|
|
* @memberOf DB
|
|
* @param {string} topicName - name of the topic to retrieve messages from.
|
|
* @param {function} callback to call for each retrieved message.
|
|
* @param {Object} query - parameters of the message range to retrieve.
|
|
* @param {number=} query.from - the least message ID to retrieve (inclusive).
|
|
* @param {number=} query.to - the greatest message ID to retrieve (exclusive).
|
|
* @param {number=} query.limit - the maximum number of messages to retrieve.
|
|
* @return {Promise} promise resolved/rejected on operation completion.
|
|
*/
|
|
readMessages: function(topicName, query, callback, context) {
|
|
if (!this.isReady()) {
|
|
return Promise.reject(new Error("not initialized"));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
query = query || {};
|
|
const from = query.from > 0 ? query.from : 0;
|
|
const to = query.to > 0 ? query.to : Number.MAX_SAFE_INTEGER;
|
|
const limit = query.limit | 0;
|
|
|
|
const result = [];
|
|
const range = IDBKeyRange.bound([topicName, from], [topicName, to], false, true);
|
|
const trx = db.transaction(['message']);
|
|
trx.onerror = (event) => {
|
|
logger("PCache", "readMessages", event.target.error);
|
|
reject(event.target.error);
|
|
};
|
|
// Iterate in descending order.
|
|
trx.objectStore('message').openCursor(range, 'prev').onsuccess = (event) => {
|
|
const cursor = event.target.result;
|
|
if (cursor) {
|
|
if (callback) {
|
|
callback.call(context, cursor.value);
|
|
}
|
|
result.push(cursor.value);
|
|
if (limit <= 0 || result.length < limit) {
|
|
cursor.continue();
|
|
}
|
|
} else {
|
|
resolve(result);
|
|
}
|
|
};
|
|
});
|
|
}
|
|
};
|
|
}
|
|
|
|
if (typeof module != 'undefined') {
|
|
module.exports = DB;
|
|
}
|
|
|
|
},{}],2:[function(require,module,exports){
|
|
/**
|
|
* @copyright 2015-2021 Tinode
|
|
* @summary Minimally rich text representation and formatting for Tinode.
|
|
* @license Apache 2.0
|
|
* @version 0.16
|
|
*
|
|
* @file Basic parser and formatter for very simple text markup. Mostly targeted at
|
|
* mobile use cases similar to Telegram, WhatsApp, and FB Messenger.
|
|
*
|
|
* <p>Supports conversion of user keyboard input to formatted text:</p>
|
|
* <ul>
|
|
* <li>*abc* → <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
|
|
},
|
|
HL: {
|
|
name: 'span',
|
|
isVoid: false
|
|
}
|
|
};
|
|
|
|
// Convert base64-encoded string into Blob.
|
|
function base64toObjectUrl(b64, contentType, logger) {
|
|
if (!b64) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
const bin = atob(b64);
|
|
const length = bin.length;
|
|
const buf = new ArrayBuffer(length);
|
|
const arr = new Uint8Array(buf);
|
|
for (let i = 0; i < length; i++) {
|
|
arr[i] = bin.charCodeAt(i);
|
|
}
|
|
|
|
return URL.createObjectURL(new Blob([buf], {
|
|
type: contentType
|
|
}));
|
|
} catch (err) {
|
|
if (logger) {
|
|
logger("Drafty: failed to convert object.", err.message);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function base64toDataUrl(b64, contentType) {
|
|
if (!b64) {
|
|
return null;
|
|
}
|
|
contentType = contentType || 'image/jpeg';
|
|
return 'data:' + contentType + ';base64,' + b64;
|
|
}
|
|
|
|
// Helpers for converting Drafty to HTML.
|
|
const DECORATORS = {
|
|
// Visial styles
|
|
ST: {
|
|
open: function() {
|
|
return '<b>';
|
|
},
|
|
close: function() {
|
|
return '</b>';
|
|
}
|
|
},
|
|
EM: {
|
|
open: function() {
|
|
return '<i>';
|
|
},
|
|
close: function() {
|
|
return '</i>'
|
|
}
|
|
},
|
|
DL: {
|
|
open: function() {
|
|
return '<del>';
|
|
},
|
|
close: function() {
|
|
return '</del>'
|
|
}
|
|
},
|
|
CO: {
|
|
open: function() {
|
|
return '<tt>';
|
|
},
|
|
close: function() {
|
|
return '</tt>'
|
|
}
|
|
},
|
|
// Line break
|
|
BR: {
|
|
open: function() {
|
|
return '<br/>';
|
|
},
|
|
close: function() {
|
|
return ''
|
|
}
|
|
},
|
|
// Hidden element
|
|
HD: {
|
|
open: function() {
|
|
return '';
|
|
},
|
|
close: function() {
|
|
return '';
|
|
}
|
|
},
|
|
// Highlighted element.
|
|
HL: {
|
|
open: function() {
|
|
return '<span style="color:teal">';
|
|
},
|
|
close: function() {
|
|
return '</span>';
|
|
}
|
|
},
|
|
// Link (URL)
|
|
LN: {
|
|
open: function(data) {
|
|
return '<a href="' + data.url + '">';
|
|
},
|
|
close: function(data) {
|
|
return '</a>';
|
|
},
|
|
props: function(data) {
|
|
return data ? {
|
|
href: data.url,
|
|
target: "_blank"
|
|
} : null;
|
|
},
|
|
},
|
|
// Mention
|
|
MN: {
|
|
open: function(data) {
|
|
return '<a href="#' + data.val + '">';
|
|
},
|
|
close: function(data) {
|
|
return '</a>';
|
|
},
|
|
props: function(data) {
|
|
return data ? {
|
|
name: data.val
|
|
} : null;
|
|
},
|
|
},
|
|
// Hashtag
|
|
HT: {
|
|
open: function(data) {
|
|
return '<a href="#' + data.val + '">';
|
|
},
|
|
close: function(data) {
|
|
return '</a>';
|
|
},
|
|
props: function(data) {
|
|
return data ? {
|
|
name: data.val
|
|
} : null;
|
|
},
|
|
},
|
|
// Button
|
|
BN: {
|
|
open: function(data) {
|
|
return '<button>';
|
|
},
|
|
close: function(data) {
|
|
return '</button>';
|
|
},
|
|
props: function(data) {
|
|
return data ? {
|
|
'data-act': data.act,
|
|
'data-val': data.val,
|
|
'data-name': data.name,
|
|
'data-ref': data.ref
|
|
} : null;
|
|
},
|
|
},
|
|
// Image
|
|
IM: {
|
|
open: function(data) {
|
|
// Don't use data.ref for preview: it's a security risk.
|
|
const tmpPreviewUrl = base64toDataUrl(data._tempPreview, data.mime);
|
|
const previewUrl = base64toObjectUrl(data.val, data.mime, Drafty.logger);
|
|
const downloadUrl = data.ref || previewUrl;
|
|
return (data.name ? '<a href="' + downloadUrl + '" download="' + data.name + '">' : '') +
|
|
'<img src="' + (tmpPreviewUrl || previewUrl) + '"' +
|
|
(data.width ? ' width="' + data.width + '"' : '') +
|
|
(data.height ? ' height="' + data.height + '"' : '') + ' border="0" />';
|
|
},
|
|
close: function(data) {
|
|
return (data.name ? '</a>' : '');
|
|
},
|
|
props: function(data) {
|
|
if (!data) return null;
|
|
return {
|
|
// Temporary preview, or permanent preview, or external link.
|
|
src: base64toDataUrl(data._tempPreview, data.mime) ||
|
|
data.ref || base64toObjectUrl(data.val, data.mime, Drafty.logger),
|
|
title: data.name,
|
|
'data-width': data.width,
|
|
'data-height': data.height,
|
|
'data-name': data.name,
|
|
'data-size': data.val ? ((data.val.length * 0.75) | 0) : (data.size | 0),
|
|
'data-mime': data.mime
|
|
};
|
|
},
|
|
},
|
|
// Form - structured layout of elements.
|
|
FM: {
|
|
open: function(data) {
|
|
return '<div>';
|
|
},
|
|
close: function(data) {
|
|
return '</div>';
|
|
}
|
|
},
|
|
// Row: logic grouping of elements
|
|
RW: {
|
|
open: function(data) {
|
|
return '<div>';
|
|
},
|
|
close: function(data) {
|
|
return '</div>';
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The main object which performs all the formatting actions.
|
|
* @class Drafty
|
|
* @constructor
|
|
*/
|
|
const Drafty = function() {}
|
|
|
|
// Take a string and defined earlier style spans, re-compose them into a tree where each leaf is
|
|
// a same-style (including unstyled) string. I.e. 'hello *bold _italic_* and ~more~ world' ->
|
|
// ('hello ', (b: 'bold ', (i: 'italic')), ' and ', (s: 'more'), ' world');
|
|
//
|
|
// This is needed in order to clear markup, i.e. 'hello *world*' -> 'hello world' and convert
|
|
// ranges from markup-ed offsets to plain text offsets.
|
|
function chunkify(line, start, end, spans) {
|
|
const chunks = [];
|
|
|
|
if (spans.length == 0) {
|
|
return [];
|
|
}
|
|
|
|
for (let i in spans) {
|
|
// Get the next chunk from the queue
|
|
const span = spans[i];
|
|
|
|
// Grab the initial unstyled chunk
|
|
if (span.start > start) {
|
|
chunks.push({
|
|
text: line.slice(start, span.start)
|
|
});
|
|
}
|
|
|
|
// Grab the styled chunk. It may include subchunks.
|
|
const chunk = {
|
|
type: span.type
|
|
};
|
|
const chld = chunkify(line, span.start + 1, span.end, span.children);
|
|
if (chld.length > 0) {
|
|
chunk.children = chld;
|
|
} else {
|
|
chunk.text = span.text;
|
|
}
|
|
chunks.push(chunk);
|
|
start = span.end + 1; // '+1' is to skip the formatting character
|
|
}
|
|
|
|
// Grab the remaining unstyled chunk, after the last span
|
|
if (start < end) {
|
|
chunks.push({
|
|
text: line.slice(start, end)
|
|
});
|
|
}
|
|
|
|
return chunks;
|
|
}
|
|
|
|
// Inverse of chunkify. Returns a tree of formatted spans.
|
|
function forEach(line, start, end, spans, formatter, context) {
|
|
const result = [];
|
|
|
|
// Process ranges calling formatter for each range.
|
|
for (let i = 0; i < spans.length; i++) {
|
|
const span = spans[i];
|
|
if (span.at < 0) {
|
|
// Ask formatter if it wants to do anything with the non-visual span.
|
|
const s = formatter.call(context, span.tp, span.data, undefined, result.length);
|
|
if (s) {
|
|
result.push(s);
|
|
}
|
|
continue;
|
|
}
|
|
// Add un-styled range before the styled span starts.
|
|
if (start < span.at) {
|
|
result.push(formatter.call(context, null, undefined, line.slice(start, span.at), result.length));
|
|
start = span.at;
|
|
}
|
|
// Get all spans which are within current span.
|
|
const subspans = [];
|
|
for (let si = i + 1; si < spans.length && spans[si].at < span.at + span.len; si++) {
|
|
subspans.push(spans[si]);
|
|
i = si;
|
|
}
|
|
|
|
const tag = HTML_TAGS[span.tp] || {}
|
|
result.push(formatter.call(context, span.tp, span.data,
|
|
tag.isVoid ? null : forEach(line, start, span.at + span.len, subspans, formatter, context),
|
|
result.length));
|
|
|
|
start = span.at + span.len;
|
|
}
|
|
|
|
// Add the last unformatted range.
|
|
if (start < end) {
|
|
result.push(formatter.call(context, null, undefined, line.slice(start, end), result.length));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Detect starts and ends of formatting spans. Unformatted spans are
|
|
// ignored at this stage.
|
|
function spannify(original, re_start, re_end, type) {
|
|
const result = [];
|
|
let index = 0;
|
|
let line = original.slice(0); // make a copy;
|
|
|
|
while (line.length > 0) {
|
|
// match[0]; // match, like '*abc*'
|
|
// match[1]; // match captured in parenthesis, like 'abc'
|
|
// match['index']; // offset where the match started.
|
|
|
|
// Find the opening token.
|
|
const start = re_start.exec(line);
|
|
if (start == null) {
|
|
break;
|
|
}
|
|
|
|
// Because javascript RegExp does not support lookbehind, the actual offset may not point
|
|
// at the markup character. Find it in the matched string.
|
|
let start_offset = start['index'] + start[0].lastIndexOf(start[1]);
|
|
// Clip the processed part of the string.
|
|
line = line.slice(start_offset + 1);
|
|
// start_offset is an offset within the clipped string. Convert to original index.
|
|
start_offset += index;
|
|
// Index now point to the beginning of 'line' within the 'original' string.
|
|
index = start_offset + 1;
|
|
|
|
// Find the matching closing token.
|
|
const end = re_end ? re_end.exec(line) : null;
|
|
if (end == null) {
|
|
break;
|
|
}
|
|
let end_offset = end['index'] + end[0].indexOf(end[1]);
|
|
// Clip the processed part of the string.
|
|
line = line.slice(end_offset + 1);
|
|
// Update offsets
|
|
end_offset += index;
|
|
// Index now point to the beginning of 'line' within the 'original' string.
|
|
index = end_offset + 1;
|
|
|
|
result.push({
|
|
text: original.slice(start_offset + 1, end_offset),
|
|
children: [],
|
|
start: start_offset,
|
|
end: end_offset,
|
|
type: type
|
|
});
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Convert linear array or spans into a tree representation.
|
|
// Keep standalone and nested spans, throw away partially overlapping spans.
|
|
function toTree(spans) {
|
|
if (spans.length == 0) {
|
|
return [];
|
|
}
|
|
|
|
const tree = [spans[0]];
|
|
let last = spans[0];
|
|
for (let i = 1; i < spans.length; i++) {
|
|
// Keep spans which start after the end of the previous span or those which
|
|
// are complete within the previous span.
|
|
|
|
if (spans[i].start > last.end) {
|
|
// Span is completely outside of the previous span.
|
|
tree.push(spans[i]);
|
|
last = spans[i];
|
|
} else if (spans[i].end < last.end) {
|
|
// Span is fully inside of the previous span. Push to subnode.
|
|
last.children.push(spans[i]);
|
|
}
|
|
// Span could partially overlap, ignoring it as invalid.
|
|
}
|
|
|
|
// Recursively rearrange the subnodes.
|
|
for (let i in tree) {
|
|
tree[i].children = toTree(tree[i].children);
|
|
}
|
|
|
|
return tree;
|
|
}
|
|
|
|
// Get a list of entities from a text.
|
|
function extractEntities(line) {
|
|
let match;
|
|
let extracted = [];
|
|
ENTITY_TYPES.map(function(entity) {
|
|
while ((match = entity.re.exec(line)) !== null) {
|
|
extracted.push({
|
|
offset: match['index'],
|
|
len: match[0].length,
|
|
unique: match[0],
|
|
data: entity.pack(match[0]),
|
|
type: entity.name
|
|
});
|
|
}
|
|
});
|
|
|
|
if (extracted.length == 0) {
|
|
return extracted;
|
|
}
|
|
|
|
// Remove entities detected inside other entities, like #hashtag in a URL.
|
|
extracted.sort(function(a, b) {
|
|
return a.offset - b.offset;
|
|
});
|
|
|
|
let idx = -1;
|
|
extracted = extracted.filter(function(el) {
|
|
const result = (el.offset > idx);
|
|
idx = el.offset + el.len;
|
|
return result;
|
|
});
|
|
|
|
return extracted;
|
|
}
|
|
|
|
// Convert the chunks into format suitable for serialization.
|
|
function draftify(chunks, startAt) {
|
|
let plain = "";
|
|
let ranges = [];
|
|
for (let i in chunks) {
|
|
const chunk = chunks[i];
|
|
if (!chunk.text) {
|
|
const drafty = draftify(chunk.children, plain.length + startAt);
|
|
chunk.text = drafty.txt;
|
|
ranges = ranges.concat(drafty.fmt);
|
|
}
|
|
|
|
if (chunk.type) {
|
|
ranges.push({
|
|
at: plain.length + startAt,
|
|
len: chunk.text.length,
|
|
tp: chunk.type
|
|
});
|
|
}
|
|
|
|
plain += chunk.text;
|
|
}
|
|
return {
|
|
txt: plain,
|
|
fmt: ranges
|
|
};
|
|
}
|
|
|
|
// Splice two strings: insert second string into the first one at the given index
|
|
function splice(src, at, insert) {
|
|
return src.slice(0, at) + insert + src.slice(at);
|
|
}
|
|
|
|
/**
|
|
* Parse plain text into Drafty document.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {String} content - plain-text content to parse.
|
|
* @return {Drafty} parsed document or null if the source is not plain text.
|
|
*/
|
|
Drafty.parse = function(content) {
|
|
// Make sure we are parsing strings only.
|
|
if (typeof content != 'string') {
|
|
return null;
|
|
}
|
|
|
|
// Split text into lines. It makes further processing easier.
|
|
const lines = content.split(/\r?\n/);
|
|
|
|
// Holds entities referenced from text
|
|
const entityMap = [];
|
|
const entityIndex = {};
|
|
|
|
// Processing lines one by one, hold intermediate result in blx.
|
|
const blx = [];
|
|
lines.map(function(line) {
|
|
let spans = [];
|
|
let entities;
|
|
|
|
// Find formatted spans in the string.
|
|
// Try to match each style.
|
|
INLINE_STYLES.map(function(style) {
|
|
// Each style could be matched multiple times.
|
|
spans = spans.concat(spannify(line, style.start, style.end, style.name));
|
|
});
|
|
|
|
let block;
|
|
if (spans.length == 0) {
|
|
block = {
|
|
txt: line
|
|
};
|
|
} else {
|
|
// Sort spans by style occurence early -> late
|
|
spans.sort(function(a, b) {
|
|
return a.start - b.start;
|
|
});
|
|
|
|
// Convert an array of possibly overlapping spans into a tree
|
|
spans = toTree(spans);
|
|
|
|
// Build a tree representation of the entire string, not
|
|
// just the formatted parts.
|
|
const chunks = chunkify(line, 0, line.length, spans);
|
|
|
|
const drafty = draftify(chunks, 0);
|
|
|
|
block = {
|
|
txt: drafty.txt,
|
|
fmt: drafty.fmt
|
|
};
|
|
}
|
|
|
|
// Extract entities from the cleaned up string.
|
|
entities = extractEntities(block.txt);
|
|
if (entities.length > 0) {
|
|
const ranges = [];
|
|
for (let i in entities) {
|
|
// {offset: match['index'], unique: match[0], len: match[0].length, data: ent.packer(), type: ent.name}
|
|
const entity = entities[i];
|
|
let index = entityIndex[entity.unique];
|
|
if (!index) {
|
|
index = entityMap.length;
|
|
entityIndex[entity.unique] = index;
|
|
entityMap.push({
|
|
tp: entity.type,
|
|
data: entity.data
|
|
});
|
|
}
|
|
ranges.push({
|
|
at: entity.offset,
|
|
len: entity.len,
|
|
key: index
|
|
});
|
|
}
|
|
block.ent = ranges;
|
|
}
|
|
|
|
blx.push(block);
|
|
});
|
|
|
|
const result = {
|
|
txt: ""
|
|
};
|
|
|
|
// Merge lines and save line breaks as BR inline formatting.
|
|
if (blx.length > 0) {
|
|
result.txt = blx[0].txt;
|
|
result.fmt = (blx[0].fmt || []).concat(blx[0].ent || []);
|
|
|
|
for (let i = 1; i < blx.length; i++) {
|
|
const block = blx[i];
|
|
const offset = result.txt.length + 1;
|
|
|
|
result.fmt.push({
|
|
tp: 'BR',
|
|
len: 1,
|
|
at: offset - 1
|
|
});
|
|
|
|
result.txt += " " + block.txt;
|
|
if (block.fmt) {
|
|
result.fmt = result.fmt.concat(block.fmt.map(function(s) {
|
|
s.at += offset;
|
|
return s;
|
|
}));
|
|
}
|
|
if (block.ent) {
|
|
result.fmt = result.fmt.concat(block.ent.map(function(s) {
|
|
s.at += offset;
|
|
return s;
|
|
}));
|
|
}
|
|
}
|
|
|
|
if (result.fmt.length == 0) {
|
|
delete result.fmt;
|
|
}
|
|
|
|
if (entityMap.length > 0) {
|
|
result.ent = entityMap;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Initialize Drafty document to a plain text string.
|
|
*
|
|
* @param {String} plainText - string to use as Drafty content.
|
|
*
|
|
* @returns new Drafty document or null is plainText is not a string.
|
|
*/
|
|
Drafty.init = function(plainText) {
|
|
if (typeof plainText != 'string') {
|
|
return null;
|
|
}
|
|
return {
|
|
txt: plainText
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Append one Drafty document to another.
|
|
*
|
|
* @param {Drafty} first - Drafty document to append to.
|
|
* @param {Drafty} second - Drafty document being appended.
|
|
*
|
|
* @return {Drafty} first document with the second appended to it.
|
|
*/
|
|
Drafty.append = function(first, second) {
|
|
if (first == null) {
|
|
return second;
|
|
}
|
|
if (second == null) {
|
|
return first;
|
|
}
|
|
|
|
first.txt = first.txt || '';
|
|
second.txt = second.txt || '';
|
|
const len = first.txt.length;
|
|
|
|
first.txt += second.txt;
|
|
if (Array.isArray(second.fmt)) {
|
|
first.fmt = first.fmt || [];
|
|
if (Array.isArray(second.ent)) {
|
|
first.ent = first.ent || [];
|
|
}
|
|
second.fmt.forEach(src => {
|
|
const fmt = {
|
|
at: src.at + len,
|
|
len: src.len
|
|
};
|
|
if (src.tp) {
|
|
fmt.tp = src.tp;
|
|
} else {
|
|
fmt.key = first.ent.length;
|
|
first.ent.push(second.ent[src.key || 0]);
|
|
}
|
|
first.fmt.push(fmt);
|
|
});
|
|
}
|
|
|
|
return first;
|
|
}
|
|
|
|
/**
|
|
* @typedef Drafty.ImageDesc
|
|
* @memberof Drafty
|
|
* @type Object
|
|
* @param {string} mime - mime-type of the image, e.g. "image/png"
|
|
* @param {string} preview - base64-encoded image content (or preview, if large image is attached). Could be null/undefined.
|
|
* @param {integer} width - width of the image
|
|
* @param {integer} height - height of the image
|
|
* @param {string} filename - file name suggestion for downloading the image.
|
|
* @param {integer} size - size of the image in bytes. Treat is as an untrusted hint.
|
|
* @param {string} refurl - reference to the content. Could be null/undefined.
|
|
* @param {string} _tempPreview - base64-encoded image preview used during upload process; not serializable.
|
|
* @param {Promise} urlPromise - Promise which returns content URL when resolved.
|
|
*/
|
|
|
|
/**
|
|
* Insert inline image into Drafty document.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} content - document to add image to.
|
|
* @param {integer} at - index where the object is inserted. The length of the image is always 1.
|
|
* @param {ImageDesc} imageDesc - object with image paramenets and data.
|
|
*
|
|
* @return {Drafty} updated document.
|
|
*/
|
|
Drafty.insertImage = function(content, at, imageDesc) {
|
|
content = content || {
|
|
txt: " "
|
|
};
|
|
content.ent = content.ent || [];
|
|
content.fmt = content.fmt || [];
|
|
|
|
content.fmt.push({
|
|
at: at,
|
|
len: 1,
|
|
key: content.ent.length
|
|
});
|
|
|
|
const ex = {
|
|
tp: 'IM',
|
|
data: {
|
|
mime: imageDesc.mime,
|
|
val: imageDesc.preview,
|
|
width: imageDesc.width,
|
|
height: imageDesc.height,
|
|
name: imageDesc.filename,
|
|
size: imageDesc.size | 0,
|
|
ref: imageDesc.refurl
|
|
}
|
|
};
|
|
|
|
if (imageDesc.urlPromise) {
|
|
ex.data._tempPreview = imageDesc._tempPreview;
|
|
ex.data._processing = true;
|
|
imageDesc.urlPromise.then(
|
|
(url) => {
|
|
ex.data.ref = url;
|
|
ex.data._tempPreview = undefined;
|
|
ex.data._processing = undefined;
|
|
},
|
|
(err) => {
|
|
/* catch the error, otherwise it will appear in the console. */
|
|
ex.data._processing = undefined;
|
|
}
|
|
);
|
|
}
|
|
|
|
content.ent.push(ex);
|
|
|
|
return content;
|
|
}
|
|
|
|
/**
|
|
* Append inline image to Drafty document.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} content - document to add image to.
|
|
* @param {ImageDesc} imageDesc - object with image paramenets.
|
|
*
|
|
* @return {Drafty} updated document.
|
|
*/
|
|
Drafty.appendImage = function(content, imageDesc) {
|
|
content = content || {
|
|
txt: ""
|
|
};
|
|
content.txt += " ";
|
|
return Drafty.insertImage(content, content.txt.length - 1, imageDesc);
|
|
}
|
|
|
|
/**
|
|
* @typedef Drafty.AttachmentDesc
|
|
* @memberof Drafty
|
|
* @type Object
|
|
* @param {string} mime - mime-type of the image, e.g. "image/png"
|
|
* @param {string} data - base64-encoded in-band content of small attachments. Could be null/undefined.
|
|
* @param {string} filename - file name suggestion for downloading the attachment.
|
|
* @param {integer} size - size of the file in bytes. Treat is as an untrusted hint.
|
|
* @param {string} refurl - reference to the out-of-band content. Could be null/undefined.
|
|
* @param {Promise} urlPromise - Promise which returns content URL when resolved.
|
|
*/
|
|
|
|
/**
|
|
* Attach file to Drafty content. Either as a blob or as a reference.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} content - document to attach file to.
|
|
* @param {AttachmentDesc} object - containing attachment description and data.
|
|
*
|
|
* @return {Drafty} updated document.
|
|
*/
|
|
Drafty.attachFile = function(content, attachmentDesc) {
|
|
content = content || {
|
|
txt: ""
|
|
};
|
|
content.ent = content.ent || [];
|
|
content.fmt = content.fmt || [];
|
|
|
|
content.fmt.push({
|
|
at: -1,
|
|
len: 0,
|
|
key: content.ent.length
|
|
});
|
|
|
|
const ex = {
|
|
tp: 'EX',
|
|
data: {
|
|
mime: attachmentDesc.mime,
|
|
val: attachmentDesc.data,
|
|
name: attachmentDesc.filename,
|
|
ref: attachmentDesc.refurl,
|
|
size: attachmentDesc.size | 0
|
|
}
|
|
}
|
|
if (attachmentDesc.urlPromise) {
|
|
ex.data._processing = true;
|
|
attachmentDesc.urlPromise.then(
|
|
(url) => {
|
|
ex.data.ref = url;
|
|
ex.data._processing = undefined;
|
|
},
|
|
(err) => {
|
|
/* catch the error, otherwise it will appear in the console. */
|
|
ex.data._processing = undefined;
|
|
}
|
|
);
|
|
}
|
|
content.ent.push(ex);
|
|
|
|
return content;
|
|
}
|
|
|
|
/**
|
|
* Wraps content into an interactive form.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty|string} content - to wrap into a form.
|
|
* @param {number} at - index where the forms starts.
|
|
* @param {number} len - length of the form content.
|
|
*
|
|
* @return {Drafty} updated document.
|
|
*/
|
|
Drafty.wrapAsForm = function(content, at, len) {
|
|
if (typeof content == 'string') {
|
|
content = {
|
|
txt: content
|
|
};
|
|
}
|
|
content.fmt = content.fmt || [];
|
|
|
|
content.fmt.push({
|
|
at: at,
|
|
len: len,
|
|
tp: 'FM'
|
|
});
|
|
|
|
return content;
|
|
}
|
|
|
|
/**
|
|
* Insert clickable button into Drafty document.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty|string} content - Drafty document to insert button to or a string to be used as button text.
|
|
* @param {number} at - location where the button is inserted.
|
|
* @param {number} len - the length of the text to be used as button title.
|
|
* @param {string} name - the button. Client should return it to the server when the button is clicked.
|
|
* @param {string} actionType - the type of the button, one of 'url' or 'pub'.
|
|
* @param {string} actionValue - the value to return on click:
|
|
* @param {string} refUrl - the URL to go to when the 'url' button is clicked.
|
|
*
|
|
* @return {Drafty} updated document.
|
|
*/
|
|
Drafty.insertButton = function(content, at, len, name, actionType, actionValue, refUrl) {
|
|
if (typeof content == 'string') {
|
|
content = {
|
|
txt: content
|
|
};
|
|
}
|
|
|
|
if (!content || !content.txt || content.txt.length < at + len) {
|
|
return null;
|
|
}
|
|
|
|
if (len <= 0 || ['url', 'pub'].indexOf(actionType) == -1) {
|
|
return null;
|
|
}
|
|
// Ensure refUrl is a string.
|
|
if (actionType == 'url' && !refUrl) {
|
|
return null;
|
|
}
|
|
refUrl = '' + refUrl;
|
|
|
|
content.ent = content.ent || [];
|
|
content.fmt = content.fmt || [];
|
|
|
|
content.fmt.push({
|
|
at: at,
|
|
len: len,
|
|
key: content.ent.length
|
|
});
|
|
content.ent.push({
|
|
tp: 'BN',
|
|
data: {
|
|
act: actionType,
|
|
val: actionValue,
|
|
ref: refUrl,
|
|
name: name
|
|
}
|
|
});
|
|
|
|
return content;
|
|
}
|
|
|
|
/**
|
|
* Append clickable button to Drafty document.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty|string} content - Drafty document to insert button to or a string to be used as button text.
|
|
* @param {string} title - the text to be used as button title.
|
|
* @param {string} name - the button. Client should return it to the server when the button is clicked.
|
|
* @param {string} actionType - the type of the button, one of 'url' or 'pub'.
|
|
* @param {string} actionValue - the value to return on click:
|
|
* @param {string} refUrl - the URL to go to when the 'url' button is clicked.
|
|
*
|
|
* @return {Drafty} updated document.
|
|
*/
|
|
Drafty.appendButton = function(content, title, name, actionType, actionValue, refUrl) {
|
|
content = content || {
|
|
txt: ""
|
|
};
|
|
const at = content.txt.length;
|
|
content.txt += title;
|
|
return Drafty.insertButton(content, at, title.length, name, actionType, actionValue, refUrl);
|
|
}
|
|
|
|
/**
|
|
* Attach a generic JS object. The object is attached as a json string.
|
|
* Intended for representing a form response.
|
|
*
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} content - Drafty document to attach file to.
|
|
* @param {Object} data - data to convert to json string and attach.
|
|
* @returns {Drafty} the same document as <code>content</code>.
|
|
*/
|
|
Drafty.attachJSON = function(content, data) {
|
|
content = content || {
|
|
txt: ""
|
|
};
|
|
content.ent = content.ent || [];
|
|
content.fmt = content.fmt || [];
|
|
|
|
content.fmt.push({
|
|
at: -1,
|
|
len: 0,
|
|
key: content.ent.length
|
|
});
|
|
|
|
content.ent.push({
|
|
tp: 'EX',
|
|
data: {
|
|
mime: JSON_MIME_TYPE,
|
|
val: data
|
|
}
|
|
});
|
|
|
|
return content;
|
|
}
|
|
/**
|
|
* Append line break to a Drafty document.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} content - Drafty document to append linebreak to.
|
|
* @returns {Drafty} the same document as <code>content</code>.
|
|
*/
|
|
Drafty.appendLineBreak = function(content) {
|
|
content = content || {
|
|
txt: ""
|
|
};
|
|
content.fmt = content.fmt || [];
|
|
content.fmt.push({
|
|
at: content.txt.length,
|
|
len: 1,
|
|
tp: 'BR'
|
|
});
|
|
content.txt += " ";
|
|
|
|
return content;
|
|
}
|
|
/**
|
|
* Given Drafty document, convert it to HTML.
|
|
* No attempt is made to strip pre-existing html markup.
|
|
* This is potentially unsafe because <code>content.txt</code> may contain malicious
|
|
* markup.
|
|
* @memberof Tinode.Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafy} content - document to convert.
|
|
*
|
|
* @returns {string} HTML-representation of content.
|
|
*/
|
|
Drafty.UNSAFE_toHTML = function(content) {
|
|
let {
|
|
txt,
|
|
fmt,
|
|
ent
|
|
} = content;
|
|
|
|
const markup = [];
|
|
if (fmt) {
|
|
for (let i in fmt) {
|
|
const range = fmt[i];
|
|
const at = range.at | 0;
|
|
let tp = range.tp;
|
|
let data;
|
|
if (!tp) {
|
|
const entity = ent[range.key | 0];
|
|
if (entity) {
|
|
tp = entity.tp;
|
|
data = entity.data;
|
|
}
|
|
}
|
|
|
|
if (DECORATORS[tp]) {
|
|
// Because we later sort in descending order, closing markup must come first.
|
|
// Otherwise zero-length objects will not be represented correctly.
|
|
markup.push({
|
|
idx: at + range.len,
|
|
len: -range.len,
|
|
what: DECORATORS[tp].close(data)
|
|
});
|
|
markup.push({
|
|
idx: at,
|
|
len: range.len,
|
|
what: DECORATORS[tp].open(data)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
markup.sort(function(a, b) {
|
|
return b.idx == a.idx ? b.len - a.len : b.idx - a.idx; // in descending order
|
|
});
|
|
|
|
for (let i in markup) {
|
|
if (markup[i].what) {
|
|
txt = splice(txt, markup[i].idx, markup[i].what);
|
|
}
|
|
}
|
|
|
|
return txt;
|
|
}
|
|
|
|
/**
|
|
* Callback for applying custom formatting/transformation to a Drafty document.
|
|
* Called once for each syle span.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @callback Formatter
|
|
* @param {string} style - style code such as "ST" or "IM".
|
|
* @param {Object} data - entity's data
|
|
* @param {Object} values - possibly styled subspans contained in this style span.
|
|
* @param {number} index - of the current element among its siblings.
|
|
*/
|
|
|
|
/**
|
|
* Transform Drafty document using custom formatting.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} content - content to transform.
|
|
* @param {Formatter} formatter - callback which transforms individual elements
|
|
* @param {Object} context - context provided to formatter as <code>this</code>.
|
|
*
|
|
* @return {Object} transformed object
|
|
*/
|
|
Drafty.format = function(content, formatter, context) {
|
|
let {
|
|
txt,
|
|
fmt,
|
|
ent
|
|
} = content;
|
|
|
|
// Assign default values.
|
|
txt = txt || "";
|
|
if (!Array.isArray(ent)) {
|
|
ent = [];
|
|
}
|
|
|
|
if (!Array.isArray(fmt)) {
|
|
// Handle special case when all values in fmt are 0 and fmt is skipped.
|
|
if (ent.length == 1) {
|
|
fmt = [{
|
|
at: 0,
|
|
len: 0,
|
|
key: 0
|
|
}];
|
|
} else {
|
|
return [txt];
|
|
}
|
|
}
|
|
|
|
let spans = [].concat(fmt);
|
|
|
|
// Zero values may have been stripped. Restore them.
|
|
// Also ensure indexes and lengths are sane.
|
|
spans.map(function(s) {
|
|
s.at = s.at || 0;
|
|
s.len = s.len || 0;
|
|
if (s.len < 0) {
|
|
s.len = 0;
|
|
}
|
|
if (s.at < -1) {
|
|
s.at = -1;
|
|
}
|
|
});
|
|
|
|
// Sort spans first by start index (asc) then by length (desc).
|
|
spans.sort(function(a, b) {
|
|
if (a.at - b.at == 0) {
|
|
return b.len - a.len; // longer one comes first (<0)
|
|
}
|
|
return a.at - b.at;
|
|
});
|
|
|
|
// Denormalize entities into spans. Create a copy of the objects to leave
|
|
// original Drafty object unchanged.
|
|
spans = spans.map((s) => {
|
|
let data;
|
|
let tp = s.tp;
|
|
if (!tp) {
|
|
s.key = s.key || 0;
|
|
if (ent[s.key]) {
|
|
data = ent[s.key].data;
|
|
tp = ent[s.key].tp;
|
|
}
|
|
}
|
|
|
|
// Type still not defined? Hide invalid element.
|
|
tp = tp || 'HD';
|
|
|
|
return {
|
|
tp: tp,
|
|
data: data,
|
|
at: s.at,
|
|
len: s.len
|
|
};
|
|
});
|
|
|
|
return forEach(txt, 0, txt.length, spans, formatter, context);
|
|
}
|
|
|
|
/**
|
|
* Given Drafty document, convert it to plain text.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} content - document to convert to plain text.
|
|
* @returns {string} plain-text representation of the drafty document.
|
|
*/
|
|
Drafty.toPlainText = function(content) {
|
|
return typeof content == 'string' ? content : content.txt;
|
|
}
|
|
|
|
/**
|
|
* Check if the document has no markup and no entities.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} content - content to check for presence of markup.
|
|
* @returns <code>true</code> is content is plain text, <code>false</code> otherwise.
|
|
*/
|
|
Drafty.isPlainText = function(content) {
|
|
return typeof content == 'string' || !(content.fmt || content.ent);
|
|
}
|
|
|
|
/**
|
|
* Checks if the object represets is a valid Drafty document.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} content - content to check for validity.
|
|
* @returns <code>true</code> is content is valid, <code>false</code> otherwise.
|
|
*/
|
|
Drafty.isValid = function(content) {
|
|
if (!content) {
|
|
return false;
|
|
}
|
|
|
|
const {
|
|
txt,
|
|
fmt,
|
|
ent
|
|
} = content;
|
|
|
|
if (!txt && txt !== '' && !fmt && !ent) {
|
|
return false;
|
|
}
|
|
|
|
const txt_type = typeof txt;
|
|
if (txt_type != 'string' && txt_type != 'undefined' && txt !== null) {
|
|
return false;
|
|
}
|
|
|
|
if (typeof fmt != 'undefined' && !Array.isArray(fmt) && fmt !== null) {
|
|
return false;
|
|
}
|
|
|
|
if (typeof ent != 'undefined' && !Array.isArray(ent) && ent !== null) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check if the drafty document has attachments.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} content - document to check for attachments.
|
|
* @returns <code>true</code> if there are attachments.
|
|
*/
|
|
Drafty.hasAttachments = function(content) {
|
|
if (content.ent && content.ent.length > 0) {
|
|
for (let i in content.ent) {
|
|
if (content.ent[i] && content.ent[i].tp == 'EX') {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Callback for applying custom formatting/transformation to a Drafty document.
|
|
* 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 - document to process for attachments.
|
|
* @param {AttachmentCallback} callback - callback to call for each attachment.
|
|
* @param {Object} context - value of "this" for callback.
|
|
*/
|
|
Drafty.attachments = function(content, callback, context) {
|
|
if (content.ent && content.ent.length > 0) {
|
|
for (let i in content.ent) {
|
|
if (content.ent[i] && content.ent[i].tp == 'EX') {
|
|
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} entData - entity.data to get the URl from.
|
|
* @returns {string} URL to download entity data or <code>null</code>.
|
|
*/
|
|
Drafty.getDownloadUrl = function(entData) {
|
|
let url = null;
|
|
if (entData.mime != JSON_MIME_TYPE && entData.val) {
|
|
url = base64toObjectUrl(entData.val, entData.mime, Drafty.logger);
|
|
} else if (typeof entData.ref == 'string') {
|
|
url = entData.ref;
|
|
}
|
|
return url;
|
|
}
|
|
|
|
/**
|
|
* Check if the entity data is not ready for sending, such as being uploaded to the server.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Object} entity.data to get the URl from.
|
|
* @returns {boolean} true if upload is in progress, false otherwise.
|
|
*/
|
|
Drafty.isProcessing = function(entData) {
|
|
return !!entData._processing;
|
|
}
|
|
|
|
/**
|
|
* Given the entity, get URL which can be used for previewing
|
|
* the entity.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Object} entity.data to get the URl from.
|
|
*
|
|
* @returns {string} url for previewing or null if no such url is available.
|
|
*/
|
|
Drafty.getPreviewUrl = function(entData) {
|
|
return entData.val ? base64toObjectUrl(entData.val, entData.mime, Drafty.logger) : null;
|
|
}
|
|
|
|
/**
|
|
* Get approximate size of the entity.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Object} entData - entity.data to get the size for.
|
|
* @returns {number} size of entity data in bytes.
|
|
*/
|
|
Drafty.getEntitySize = function(entData) {
|
|
// Either size hint or length of value. The value is base64 encoded,
|
|
// the actual object size is smaller than the encoded length.
|
|
return entData.size ? entData.size : entData.val ? (entData.val.length * 0.75) | 0 : 0;
|
|
}
|
|
|
|
/**
|
|
* Get entity mime type.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Object} entData - entity.data to get the type for.
|
|
* @returns {string} mime type of entity.
|
|
*/
|
|
Drafty.getEntityMimeType = function(entData) {
|
|
return entData.mime || 'text/plain';
|
|
}
|
|
|
|
/**
|
|
* Get HTML tag for a given two-letter style name.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {string} style - two-letter style, like ST or LN.
|
|
*
|
|
* @returns {string} HTML tag name if style is found, '_UNKN' if not found, {code: undefined} if style is falsish.
|
|
*/
|
|
Drafty.tagName = function(style) {
|
|
return style ? (HTML_TAGS[style] ? HTML_TAGS[style].name : '_UNKN') : undefined;
|
|
}
|
|
|
|
/**
|
|
* For a given data bundle generate an object with HTML attributes,
|
|
* for instance, given {url: "http://www.example.com/"} return
|
|
* {href: "http://www.example.com/"}
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {string} style - two-letter style to generate attributes for.
|
|
* @param {Object} data - data bundle to convert to attributes
|
|
*
|
|
* @returns {Object} object with HTML attributes.
|
|
*/
|
|
Drafty.attrValue = function(style, data) {
|
|
if (data && DECORATORS[style]) {
|
|
return DECORATORS[style].props(data);
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* Drafty MIME type.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @returns {string} HTTP Content-Type "text/x-drafty".
|
|
*/
|
|
Drafty.getContentType = function() {
|
|
return 'text/x-drafty';
|
|
}
|
|
|
|
/**
|
|
* Shorten Drafty document and strip all entity data leaving just inline styles and entity references.
|
|
* @memberof Drafty
|
|
* @static
|
|
*
|
|
* @param {Drafty} original - Drafty object to shorten.
|
|
* @param {number} length - length in characters to shorten to.
|
|
* @returns new shortened Drafty object leaving the original intact.
|
|
*/
|
|
Drafty.preview = function(original, length) {
|
|
if (!original || length <= 0 || typeof original != 'object') {
|
|
return null;
|
|
}
|
|
|
|
const {
|
|
txt,
|
|
fmt,
|
|
ent
|
|
} = original;
|
|
|
|
const preview = {
|
|
txt: ''
|
|
};
|
|
let len = 0;
|
|
if (typeof txt == 'string') {
|
|
if (txt.length > length) {
|
|
preview.txt = txt.substr(0, length);
|
|
} else {
|
|
preview.txt = txt;
|
|
}
|
|
len = preview.txt.length;
|
|
}
|
|
|
|
if (Array.isArray(fmt) && fmt.length > 0) {
|
|
// Old key to new key entity mapping.
|
|
const ent_refs = [];
|
|
// Count styles which start within the new length of the text and save entity keys as a set.
|
|
let fmt_count = 0;
|
|
let ent_count = 0;
|
|
fmt.forEach((st) => {
|
|
if (st.at < len) {
|
|
fmt_count++;
|
|
if (!st.tp) {
|
|
const key = st.key | 0;
|
|
if (!ent_refs[key]) {
|
|
ent_refs[key] = ent_count;
|
|
ent_count++;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
if (fmt_count == 0) {
|
|
return preview;
|
|
}
|
|
|
|
// Allocate space for copying styles and entities.
|
|
preview.fmt = [];
|
|
if (Array.isArray(ent) && ent_refs.length > 0) {
|
|
preview.ent = [];
|
|
}
|
|
|
|
// Insertion point for styles.
|
|
let fmt_idx = 0;
|
|
fmt.forEach((st) => {
|
|
if (st.at < len) {
|
|
const style = {
|
|
at: st.at,
|
|
len: st.len
|
|
};
|
|
const key = st.key | 0;
|
|
if (st.tp) {
|
|
style.tp = '' + st.tp;
|
|
} else if (Array.isArray(ent) && ent.length > key && typeof ent_refs[key] == 'number') {
|
|
style.key = ent_refs[key];
|
|
preview.ent[style.key] = copyLight(ent[key]);
|
|
} else {
|
|
return;
|
|
}
|
|
preview.fmt[fmt_idx++] = style;
|
|
}
|
|
});
|
|
}
|
|
|
|
return preview;
|
|
}
|
|
|
|
// Create a copy of an entity without large data.
|
|
function copyLight(ent) {
|
|
let result = {
|
|
tp: ent.tp
|
|
};
|
|
if (ent.data && Object.entries(ent.data).length != 0) {
|
|
dc = {};
|
|
["mime", "name", "width", "height", "size"].forEach((key) => {
|
|
const val = ent.data[key];
|
|
if (val) {
|
|
dc[key] = val;
|
|
}
|
|
});
|
|
if (Object.entries(dc).length != 0) {
|
|
result.data = dc;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
if (typeof module != 'undefined') {
|
|
module.exports = Drafty;
|
|
}
|
|
|
|
},{}],3:[function(require,module,exports){
|
|
(function (global){(function (){
|
|
/**
|
|
* @file SDK to connect to Tinode chat server.
|
|
* See <a href="https://github.com/tinode/webapp">
|
|
* https://github.com/tinode/webapp</a> for real-life usage.
|
|
*
|
|
* @copyright 2015-2021 Tinode
|
|
* @summary Javascript bindings for Tinode.
|
|
* @license Apache 2.0
|
|
* @version 0.17
|
|
*
|
|
* @example
|
|
* <head>
|
|
* <script src=".../tinode.js"></script>
|
|
* </head>
|
|
*
|
|
* <body>
|
|
* ...
|
|
* <script>
|
|
* // Instantiate tinode.
|
|
* const tinode = new Tinode(APP_NAME, HOST, API_KEY, null, true);
|
|
* tinode.enableLogging(true);
|
|
* // Add logic to handle disconnects.
|
|
* tinode.onDisconnect = function(err) { ... };
|
|
* // Connect to the server.
|
|
* tinode.connect().then(() => {
|
|
* // Connected. Login now.
|
|
* return tinode.loginBasic(login, password);
|
|
* }).then((ctrl) => {
|
|
* // Logged in fine, attach callbacks, subscribe to 'me'.
|
|
* const me = tinode.getMeTopic();
|
|
* me.onMetaDesc = function(meta) { ... };
|
|
* // Subscribe, fetch topic description and the list of contacts.
|
|
* me.subscribe({get: {desc: {}, sub: {}});
|
|
* }).catch((err) => {
|
|
* // Login or subscription failed, do something.
|
|
* ...
|
|
* });
|
|
* ...
|
|
* </script>
|
|
* </body>
|
|
*/
|
|
'use strict';
|
|
|
|
// NOTE TO DEVELOPERS:
|
|
// Localizable strings should be double quoted "строка на другом языке",
|
|
// non-localizable strings should be single quoted 'non-localized'.
|
|
|
|
if (typeof require == 'function') {
|
|
if (typeof Drafty == 'undefined') {
|
|
var Drafty = require('./drafty.js');
|
|
}
|
|
if (typeof DB == 'undefined') {
|
|
var DB = require('./db.js');
|
|
}
|
|
var package_version = require('../version.json').version;
|
|
}
|
|
|
|
let WebSocketProvider;
|
|
if (typeof WebSocket != 'undefined') {
|
|
WebSocketProvider = WebSocket;
|
|
}
|
|
|
|
let XHRProvider;
|
|
if (typeof XMLHttpRequest != 'undefined') {
|
|
XHRProvider = XMLHttpRequest;
|
|
}
|
|
initForNonBrowserApp();
|
|
|
|
// Global constants
|
|
const PROTOCOL_VERSION = '0'; // Major component of the version, 0 in 0.16.9
|
|
const VERSION = package_version || '0.17';
|
|
const LIBRARY = 'tinodejs/' + VERSION;
|
|
|
|
const TOPIC_NEW = 'new';
|
|
const TOPIC_NEW_CHAN = 'nch';
|
|
const TOPIC_ME = 'me';
|
|
const TOPIC_FND = 'fnd';
|
|
const TOPIC_SYS = 'sys';
|
|
const TOPIC_CHAN = 'chn';
|
|
const USER_NEW = 'new';
|
|
|
|
// Starting value of a locally-generated seqId used for pending messages.
|
|
const LOCAL_SEQID = 0xFFFFFFF;
|
|
|
|
const MESSAGE_STATUS_NONE = 0; // Status not assigned.
|
|
const MESSAGE_STATUS_QUEUED = 1; // Local ID assigned, in progress to be sent.
|
|
const MESSAGE_STATUS_SENDING = 2; // Transmission started.
|
|
const MESSAGE_STATUS_FAILED = 3; // At least one attempt was made to send the message.
|
|
const MESSAGE_STATUS_SENT = 4; // Delivered to the server.
|
|
const MESSAGE_STATUS_RECEIVED = 5; // Received by the client.
|
|
const MESSAGE_STATUS_READ = 6; // Read by the user.
|
|
const MESSAGE_STATUS_TO_ME = 7; // Message from another user.
|
|
|
|
// 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";
|
|
|
|
// Default number of messages to pull into memory from persistent cache.
|
|
const DEFAULT_MESSAGES_PAGE = 24;
|
|
|
|
// Utility functions
|
|
|
|
// Add brower missing function for non browser app, eg nodeJs
|
|
function initForNonBrowserApp() {
|
|
// Tinode requirement in native mode because react native doesn't provide Base64 method
|
|
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
|
|
|
|
if (typeof btoa == 'undefined') {
|
|
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
|
|
global.btoa = function(input = '') {
|
|
let str = input;
|
|
let output = '';
|
|
|
|
for (let block = 0, charCode, i = 0, map = chars; str.charAt(i | 0) || (map = '=', i % 1); output += map.charAt(63 & block >> 8 - i % 1 * 8)) {
|
|
|
|
charCode = str.charCodeAt(i += 3 / 4);
|
|
|
|
if (charCode > 0xFF) {
|
|
throw new Error("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");
|
|
}
|
|
|
|
block = block << 8 | charCode;
|
|
}
|
|
|
|
return output;
|
|
};
|
|
}
|
|
|
|
if (typeof atob == 'undefined') {
|
|
global.atob = function(input = '') {
|
|
let str = input.replace(/=+$/, '');
|
|
let output = '';
|
|
|
|
if (str.length % 4 == 1) {
|
|
throw new Error("'atob' failed: The string to be decoded is not correctly encoded.");
|
|
}
|
|
for (let bc = 0, bs = 0, buffer, i = 0; buffer = str.charAt(i++);
|
|
|
|
~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,
|
|
bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0
|
|
) {
|
|
buffer = chars.indexOf(buffer);
|
|
}
|
|
|
|
return output;
|
|
};
|
|
}
|
|
|
|
if (typeof window == 'undefined') {
|
|
global.window = {
|
|
WebSocket: WebSocketProvider,
|
|
XMLHttpRequest: XHRProvider,
|
|
URL: {
|
|
createObjectURL: function() {
|
|
throw new Error("Unable to use URL.createObjectURL in a non-browser application");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// RFC3339 formater of Date
|
|
function rfc3339DateString(d) {
|
|
if (!d || d.getTime() == 0) {
|
|
return undefined;
|
|
}
|
|
|
|
function pad(val, sp) {
|
|
sp = sp || 2;
|
|
return '0'.repeat(sp - ('' + val).length) + val;
|
|
}
|
|
|
|
const millis = d.getUTCMilliseconds();
|
|
return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) +
|
|
'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) +
|
|
(millis ? '.' + pad(millis, 3) : '') + 'Z';
|
|
}
|
|
|
|
// btoa replacement. Stock btoa fails on on non-Latin1 strings.
|
|
function b64EncodeUnicode(str) {
|
|
// The encodeURIComponent percent-encodes UTF-8 string,
|
|
// then the percent encoding is converted into raw bytes which
|
|
// can be fed into btoa.
|
|
return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g,
|
|
function toSolidBytes(match, p1) {
|
|
return String.fromCharCode('0x' + p1);
|
|
}));
|
|
}
|
|
|
|
// Recursively merge src's own properties to dst.
|
|
// Ignore properties where ignore[property] is true.
|
|
// Array and Date objects are shallow-copied.
|
|
function mergeObj(dst, src, ignore) {
|
|
if (typeof src != 'object') {
|
|
if (src === Tinode.DEL_CHAR) {
|
|
return undefined;
|
|
}
|
|
if (src === undefined) {
|
|
return dst;
|
|
}
|
|
return src;
|
|
}
|
|
// JS is crazy: typeof null is 'object'.
|
|
if (src === null) {
|
|
return src;
|
|
}
|
|
|
|
// Handle Date
|
|
if (src instanceof Date) {
|
|
return (!dst || !(dst instanceof Date) || dst < src) ? src : dst;
|
|
}
|
|
|
|
// Access mode
|
|
if (src instanceof AccessMode) {
|
|
return new AccessMode(src);
|
|
}
|
|
|
|
// Handle Array
|
|
if (src instanceof Array) {
|
|
return src;
|
|
}
|
|
|
|
if (!dst || dst === Tinode.DEL_CHAR) {
|
|
dst = src.constructor();
|
|
}
|
|
|
|
for (let prop in src) {
|
|
if (src.hasOwnProperty(prop) &&
|
|
(!ignore || !ignore[prop]) &&
|
|
(prop != '_noForwarding')) {
|
|
|
|
dst[prop] = mergeObj(dst[prop], src[prop]);
|
|
}
|
|
}
|
|
return dst;
|
|
}
|
|
|
|
// Update object stored in a cache. Returns updated value.
|
|
function mergeToCache(cache, key, newval, ignore) {
|
|
cache[key] = mergeObj(cache[key], newval, ignore);
|
|
return cache[key];
|
|
}
|
|
|
|
function stringToDate(obj) {
|
|
if (typeof obj.created == 'string') {
|
|
obj.created = new Date(obj.created);
|
|
}
|
|
if (typeof obj.updated == 'string') {
|
|
obj.updated = new Date(obj.updated);
|
|
}
|
|
if (typeof obj.touched == 'string') {
|
|
obj.touched = new Date(obj.touched);
|
|
}
|
|
}
|
|
|
|
// JSON stringify helper - pre-processor for JSON.stringify
|
|
function jsonBuildHelper(key, val) {
|
|
if (val instanceof Date) {
|
|
// Convert javascript Date objects to rfc3339 strings
|
|
val = rfc3339DateString(val);
|
|
} else if (val instanceof AccessMode) {
|
|
val = val.jsonHelper();
|
|
} else if (val === undefined || val === null || val === false ||
|
|
(Array.isArray(val) && val.length == 0) ||
|
|
((typeof val == 'object') && (Object.keys(val).length == 0))) {
|
|
// strip out empty elements while serializing objects to JSON
|
|
return undefined;
|
|
}
|
|
|
|
return val;
|
|
};
|
|
|
|
// Strips all values from an object of they evaluate to false or if their name starts with '_'.
|
|
function simplify(obj) {
|
|
Object.keys(obj).forEach(function(key) {
|
|
if (key[0] == '_') {
|
|
// Strip fields like "obj._key".
|
|
delete obj[key];
|
|
} else if (!obj[key]) {
|
|
// Strip fields which evaluate to false.
|
|
delete obj[key];
|
|
} else if (Array.isArray(obj[key]) && obj[key].length == 0) {
|
|
// Strip empty arrays.
|
|
delete obj[key];
|
|
} else if (!obj[key]) {
|
|
// Strip fields which evaluate to false.
|
|
delete obj[key];
|
|
} else if (typeof obj[key] == 'object' && !(obj[key] instanceof Date)) {
|
|
simplify(obj[key]);
|
|
// Strip empty objects.
|
|
if (Object.getOwnPropertyNames(obj[key]).length == 0) {
|
|
delete obj[key];
|
|
}
|
|
}
|
|
});
|
|
return obj;
|
|
};
|
|
|
|
// Trim whitespace, strip empty and duplicate elements elements.
|
|
// If the result is an empty array, add a single element "\u2421" (Unicode Del character).
|
|
function normalizeArray(arr) {
|
|
let out = [];
|
|
if (Array.isArray(arr)) {
|
|
// Trim, throw away very short and empty tags.
|
|
for (let i = 0, l = arr.length; i < l; i++) {
|
|
let t = arr[i];
|
|
if (t) {
|
|
t = t.trim().toLowerCase();
|
|
if (t.length > 1) {
|
|
out.push(t);
|
|
}
|
|
}
|
|
}
|
|
out.sort().filter(function(item, pos, ary) {
|
|
return !pos || item != ary[pos - 1];
|
|
});
|
|
}
|
|
if (out.length == 0) {
|
|
// Add single tag with a Unicode Del character, otherwise an ampty array
|
|
// is ambiguos. The Del tag will be stripped by the server.
|
|
out.push(Tinode.DEL_CHAR);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Attempt to convert date strings to objects.
|
|
function jsonParseHelper(key, val) {
|
|
// Convert string timestamps with optional milliseconds to Date
|
|
// 2015-09-02T01:45:43[.123]Z
|
|
if (key === 'ts' && typeof val === 'string' &&
|
|
val.length >= 20 && val.length <= 24) {
|
|
let date = new Date(val);
|
|
if (date) {
|
|
return date;
|
|
}
|
|
} else if (key === 'acs' && typeof val === 'object') {
|
|
return new AccessMode(val);
|
|
}
|
|
return val;
|
|
};
|
|
|
|
// Trims very long strings (encoded images) to make logged packets more readable.
|
|
function jsonLoggerHelper(key, val) {
|
|
if (typeof val == 'string' && val.length > 128) {
|
|
return '<' + val.length + ', bytes: ' + val.substring(0, 12) + '...' + val.substring(val.length - 12) + '>';
|
|
}
|
|
return jsonBuildHelper(key, val);
|
|
};
|
|
|
|
// Parse browser user agent to extract browser name and version.
|
|
function getBrowserInfo(ua, product) {
|
|
ua = ua || '';
|
|
let reactnative = '';
|
|
// Check if this is a ReactNative app.
|
|
if (/reactnative/i.test(product)) {
|
|
reactnative = 'ReactNative; ';
|
|
}
|
|
// Then test for WebKit based browser.
|
|
ua = ua.replace(' (KHTML, like Gecko)', '');
|
|
let m = ua.match(/(AppleWebKit\/[.\d]+)/i);
|
|
let result;
|
|
if (m) {
|
|
// List of common strings, from more useful to less useful.
|
|
let priority = ['chrome', 'safari', 'mobile', 'version'];
|
|
let tmp = ua.substr(m.index + m[0].length).split(" ");
|
|
let tokens = [];
|
|
// Split Name/0.0.0 into Name and version 0.0.0
|
|
for (let i = 0; i < tmp.length; i++) {
|
|
let m2 = /([\w.]+)[\/]([\.\d]+)/.exec(tmp[i]);
|
|
if (m2) {
|
|
tokens.push([m2[1], m2[2], priority.findIndex(function(e) {
|
|
return (e == m2[1].toLowerCase());
|
|
})]);
|
|
}
|
|
}
|
|
// Sort by priority: more interesting is earlier than less interesting.
|
|
tokens.sort(function(a, b) {
|
|
let diff = a[2] - b[2];
|
|
return diff != 0 ? diff : b[0].length - a[0].length;
|
|
});
|
|
if (tokens.length > 0) {
|
|
// Return the least common browser string and version.
|
|
result = tokens[0][0] + '/' + tokens[0][1];
|
|
} else {
|
|
// Failed to ID the browser. Return the webkit version.
|
|
result = m[1];
|
|
}
|
|
// Test for MSIE.
|
|
} else if (/trident/i.test(ua)) {
|
|
m = /(?:\brv[ :]+([.\d]+))|(?:\bMSIE ([.\d]+))/g.exec(ua);
|
|
if (m) {
|
|
result = 'MSIE/' + (m[1] || m[2]);
|
|
} else {
|
|
result = 'MSIE/?';
|
|
}
|
|
// Test for Firefox.
|
|
} else if (/firefox/i.test(ua)) {
|
|
m = /Firefox\/([.\d]+)/g.exec(ua);
|
|
if (m) {
|
|
result = 'Firefox/' + m[1];
|
|
} else {
|
|
result = 'Firefox/?';
|
|
}
|
|
// Older Opera.
|
|
} else if (/presto/i.test(ua)) {
|
|
m = /Opera\/([.\d]+)/g.exec(ua);
|
|
if (m) {
|
|
result = 'Opera/' + m[1];
|
|
} else {
|
|
result = 'Opera/?';
|
|
}
|
|
} else {
|
|
// Failed to parse anything meaningfull. Try the last resort.
|
|
m = /([\w.]+)\/([.\d]+)/.exec(ua);
|
|
if (m) {
|
|
result = m[1] + '/' + m[2];
|
|
} else {
|
|
m = ua.split(' ');
|
|
result = m[0];
|
|
}
|
|
}
|
|
|
|
// Shorten the version to one dot 'a.bb.ccc.d -> a.bb' at most.
|
|
m = result.split('/');
|
|
if (m.length > 1) {
|
|
let v = m[1].split('.');
|
|
result = m[0] + '/' + v[0] + (v[1] ? '.' + v[1] : '');
|
|
}
|
|
return reactnative + result;
|
|
}
|
|
|
|
/**
|
|
* In-memory sorted cache of objects.
|
|
*
|
|
* @class CBuffer
|
|
* @memberof Tinode
|
|
* @protected
|
|
*
|
|
* @param {function} compare custom comparator of objects. Takes two parameters <code>a</code> and <code>b</code>;
|
|
* returns <code>-1</code> if <code>a < b</code>, <code>0</code> if <code>a == b</code>, <code>1</code> otherwise.
|
|
* @param {boolean} unique enforce element uniqueness: when <code>true</code> replace existing element with a new
|
|
* one on conflict; when <code>false</code> keep both elements.
|
|
*/
|
|
var CBuffer = function(compare, unique) {
|
|
let buffer = [];
|
|
|
|
compare = compare || function(a, b) {
|
|
return a === b ? 0 : a < b ? -1 : 1;
|
|
};
|
|
|
|
function findNearest(elem, arr, exact) {
|
|
let start = 0;
|
|
let end = arr.length - 1;
|
|
let pivot = 0;
|
|
let diff = 0;
|
|
let found = false;
|
|
|
|
while (start <= end) {
|
|
pivot = (start + end) / 2 | 0;
|
|
diff = compare(arr[pivot], elem);
|
|
if (diff < 0) {
|
|
start = pivot + 1;
|
|
} else if (diff > 0) {
|
|
end = pivot - 1;
|
|
} else {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (found) {
|
|
return {
|
|
idx: pivot,
|
|
exact: true
|
|
};
|
|
}
|
|
if (exact) {
|
|
return {
|
|
idx: -1
|
|
};
|
|
}
|
|
// Not exact - insertion point
|
|
return {
|
|
idx: diff < 0 ? pivot + 1 : pivot
|
|
};
|
|
}
|
|
|
|
// Insert element into a sorted array.
|
|
function insertSorted(elem, arr) {
|
|
const found = findNearest(elem, arr, false);
|
|
const count = (found.exact && unique) ? 1 : 0;
|
|
arr.splice(found.idx, count, elem);
|
|
return arr;
|
|
}
|
|
|
|
return {
|
|
/**
|
|
* Get an element at the given position.
|
|
* @memberof Tinode.CBuffer#
|
|
* @param {number} at - Position to fetch from.
|
|
* @returns {Object} Element at the given position or <code>undefined</code>.
|
|
*/
|
|
getAt: function(at) {
|
|
return buffer[at];
|
|
},
|
|
|
|
/**
|
|
* Convenience method for getting the last element of the buffer.
|
|
* @memberof Tinode.CBuffer#
|
|
* @returns {Object} The last element in the buffer or <code>undefined</code> if buffer is empty.
|
|
*/
|
|
getLast: function() {
|
|
return buffer.length > 0 ? buffer[buffer.length - 1] : undefined;
|
|
},
|
|
|
|
/**
|
|
* Add new element(s) to the buffer. Variadic: takes one or more arguments. If an array is passed as a single
|
|
* argument, its elements are inserted individually.
|
|
* @memberof Tinode.CBuffer#
|
|
*
|
|
* @param {...Object|Array} - One or more objects to insert.
|
|
*/
|
|
put: function() {
|
|
let insert;
|
|
// inspect arguments: if array, insert its elements, if one or more non-array arguments, insert them one by one
|
|
if (arguments.length == 1 && Array.isArray(arguments[0])) {
|
|
insert = arguments[0];
|
|
} else {
|
|
insert = arguments;
|
|
}
|
|
for (let idx in insert) {
|
|
insertSorted(insert[idx], buffer);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Remove element at the given position.
|
|
* @memberof Tinode.CBuffer#
|
|
* @param {number} at - Position to delete at.
|
|
* @returns {Object} Element at the given position or <code>undefined</code>.
|
|
*/
|
|
delAt: function(at) {
|
|
let r = buffer.splice(at, 1);
|
|
if (r && r.length > 0) {
|
|
return r[0];
|
|
}
|
|
return undefined;
|
|
},
|
|
|
|
/**
|
|
* Remove elements between two positions.
|
|
* @memberof Tinode.CBuffer#
|
|
* @param {number} since - Position to delete from (inclusive).
|
|
* @param {number} before - Position to delete to (exclusive).
|
|
*
|
|
* @returns {Array} array of removed elements (could be zero length).
|
|
*/
|
|
delRange: function(since, before) {
|
|
return buffer.splice(since, before - since);
|
|
},
|
|
|
|
/**
|
|
* Return the number of elements the buffer holds.
|
|
* @memberof Tinode.CBuffer#
|
|
* @return {number} Number of elements in the buffer.
|
|
*/
|
|
length: function() {
|
|
return buffer.length;
|
|
},
|
|
|
|
/**
|
|
* Reset the buffer discarding all elements
|
|
* @memberof Tinode.CBuffer#
|
|
*/
|
|
reset: function() {
|
|
buffer = [];
|
|
},
|
|
|
|
/**
|
|
* Callback for iterating contents of buffer. See {@link Tinode.CBuffer#forEach}.
|
|
* @callback ForEachCallbackType
|
|
* @memberof Tinode.CBuffer#
|
|
* @param {Object} elem - Element of the buffer.
|
|
* @param {number} index - Index of the current element.
|
|
*/
|
|
|
|
/**
|
|
* Apply given <code>callback</code> to all elements of the buffer.
|
|
* @memberof Tinode.CBuffer#
|
|
*
|
|
* @param {Tinode.ForEachCallbackType} callback - Function to call for each element.
|
|
* @param {number} startIdx - Optional index to start iterating from (inclusive).
|
|
* @param {number} beforeIdx - Optional index to stop iterating before (exclusive).
|
|
* @param {Object} context - calling context (i.e. value of <code>this</code> in callback)
|
|
*/
|
|
forEach: function(callback, startIdx, beforeIdx, context) {
|
|
startIdx = startIdx | 0;
|
|
beforeIdx = beforeIdx || buffer.length;
|
|
for (let i = startIdx; i < beforeIdx; i++) {
|
|
callback.call(context, buffer[i], i);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Find element in buffer using buffer's comparison function.
|
|
* @memberof Tinode.CBuffer#
|
|
*
|
|
* @param {Object} elem - element to find.
|
|
* @param {boolean=} nearest - when true and exact match is not found, return the nearest element (insertion point).
|
|
* @returns {number} index of the element in the buffer or -1.
|
|
*/
|
|
find: function(elem, nearest) {
|
|
const {
|
|
idx
|
|
} = findNearest(elem, buffer, !nearest);
|
|
return idx;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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 <code>"ws"<code>/<code>"wss"</code> for websocket or
|
|
* <code>lp</code> for long polling.
|
|
* @param {boolean} secure_ - Use secure WebSocket (wss) if <code>true</code>.
|
|
* @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
|
|
const timeout = _BOFF_BASE * (Math.pow(2, _boffIteration) * (1.0 + _BOFF_JITTER * Math.random()));
|
|
// Update iteration counter for future use
|
|
_boffIteration = (_boffIteration >= _BOFF_MAX_ITER ? _boffIteration : _boffIteration + 1);
|
|
if (this.onAutoreconnectIteration) {
|
|
this.onAutoreconnectIteration(timeout);
|
|
}
|
|
|
|
_boffTimer = setTimeout(() => {
|
|
log(`Reconnecting, iter=${_boffIteration}, timeout=${timeout}`);
|
|
// Maybe the socket was closed while we waited for the timer?
|
|
if (!_boffClosed) {
|
|
const prom = this.connect();
|
|
if (this.onAutoreconnectIteration) {
|
|
this.onAutoreconnectIteration(0, prom);
|
|
} else {
|
|
// Suppress error if it's not used.
|
|
prom.catch(() => {
|
|
/* do nothing */
|
|
});
|
|
}
|
|
} else if (this.onAutoreconnectIteration) {
|
|
this.onAutoreconnectIteration(-1);
|
|
}
|
|
}, timeout);
|
|
}
|
|
|
|
// Terminate auto-reconnect process.
|
|
function boffStop() {
|
|
clearTimeout(_boffTimer);
|
|
_boffTimer = null;
|
|
}
|
|
|
|
// Reset auto-reconnect iteration counter.
|
|
function boffReset() {
|
|
_boffIteration = 0;
|
|
}
|
|
|
|
// Initialization for Websocket
|
|
function init_ws(instance) {
|
|
let _socket = null;
|
|
|
|
/**
|
|
* Initiate a new connection
|
|
* @memberof Tinode.Connection#
|
|
* @param {string} host_ Host name to connect to; if <code>null</code> the old host name will be used.
|
|
* @param {boolean} force Force new connection even if one already exists.
|
|
* @return {Promise} Promise resolved/rejected when the connection call completes, resolution is called without
|
|
* parameters, rejection passes the {Error} as parameter.
|
|
*/
|
|
instance.connect = function(host_, force) {
|
|
_boffClosed = false;
|
|
|
|
if (_socket) {
|
|
if (!force && _socket.readyState == _socket.OPEN) {
|
|
return Promise.resolve();
|
|
}
|
|
_socket.close();
|
|
_socket = null;
|
|
}
|
|
|
|
if (host_) {
|
|
host = host_;
|
|
}
|
|
|
|
return new Promise(function(resolve, reject) {
|
|
const url = makeBaseUrl(host, secure ? 'wss' : 'ws', apiKey);
|
|
|
|
log("Connecting to: ", url);
|
|
|
|
// It throws when the server is not accessible but the exception cannot be caught:
|
|
// https://stackoverflow.com/questions/31002592/javascript-doesnt-catch-error-in-websocket-instantiation/31003057
|
|
const conn = new WebSocketProvider(url);
|
|
|
|
conn.onerror = function(err) {
|
|
reject(err);
|
|
}
|
|
|
|
conn.onopen = function(evt) {
|
|
if (autoreconnect) {
|
|
boffStop();
|
|
}
|
|
|
|
if (instance.onOpen) {
|
|
instance.onOpen();
|
|
}
|
|
|
|
resolve();
|
|
}
|
|
|
|
conn.onclose = function(evt) {
|
|
_socket = null;
|
|
|
|
if (instance.onDisconnect) {
|
|
const code = _boffClosed ? NETWORK_USER : NETWORK_ERROR;
|
|
instance.onDisconnect(new Error(_boffClosed ? NETWORK_USER_TEXT : NETWORK_ERROR_TEXT +
|
|
' (' + code + ')'), code);
|
|
}
|
|
|
|
if (!_boffClosed && autoreconnect) {
|
|
boffReconnect.call(instance);
|
|
}
|
|
}
|
|
|
|
conn.onmessage = function(evt) {
|
|
if (instance.onMessage) {
|
|
instance.onMessage(evt.data);
|
|
}
|
|
}
|
|
_socket = conn;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Try to restore a network connection, also reset backoff.
|
|
* @memberof Tinode.Connection#
|
|
*
|
|
* @param {boolean} force - reconnect even if there is a live connection already.
|
|
*/
|
|
instance.reconnect = function(force) {
|
|
boffStop();
|
|
instance.connect(null, force);
|
|
}
|
|
|
|
/**
|
|
* Terminate the network connection
|
|
* @memberof Tinode.Connection#
|
|
*/
|
|
instance.disconnect = function() {
|
|
_boffClosed = true;
|
|
boffStop();
|
|
|
|
if (!_socket) {
|
|
return;
|
|
}
|
|
_socket.close();
|
|
_socket = null;
|
|
}
|
|
|
|
/**
|
|
* Send a string to the server.
|
|
* @memberof Tinode.Connection#
|
|
*
|
|
* @param {string} msg - String to send.
|
|
* @throws Throws an exception if the underlying connection is not live.
|
|
*/
|
|
instance.sendText = function(msg) {
|
|
if (_socket && (_socket.readyState == _socket.OPEN)) {
|
|
_socket.send(msg);
|
|
} else {
|
|
throw new Error("Websocket is not connected");
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Check if socket is alive.
|
|
* @memberof Tinode.Connection#
|
|
* @returns {boolean} <code>true</code> if connection is live, <code>false</code> otherwise.
|
|
*/
|
|
instance.isConnected = function() {
|
|
return (_socket && (_socket.readyState == _socket.OPEN));
|
|
}
|
|
|
|
/**
|
|
* Get the name of the current network transport.
|
|
* @memberof Tinode.Connection#
|
|
* @returns {string} name of the transport such as <code>"ws"</code> or <code>"lp"</code>.
|
|
*/
|
|
instance.transport = function() {
|
|
return 'ws';
|
|
}
|
|
|
|
/**
|
|
* Send network probe to check if connection is indeed live.
|
|
* @memberof Tinode.Connection#
|
|
*/
|
|
instance.probe = function() {
|
|
instance.sendText('1');
|
|
}
|
|
}
|
|
|
|
// Initialization for long polling.
|
|
function init_lp(instance) {
|
|
const XDR_UNSENT = 0; // Client has been created. open() not called yet.
|
|
const XDR_OPENED = 1; // open() has been called.
|
|
const XDR_HEADERS_RECEIVED = 2; // send() has been called, and headers and status are available.
|
|
const XDR_LOADING = 3; // Downloading; responseText holds partial data.
|
|
const XDR_DONE = 4; // The operation is complete.
|
|
// Fully composed endpoint URL, with API key & SID
|
|
let _lpURL = null;
|
|
|
|
let _poller = null;
|
|
let _sender = null;
|
|
|
|
function lp_sender(url_) {
|
|
let sender = new XMLHttpRequest();
|
|
sender.onreadystatechange = function(evt) {
|
|
if (sender.readyState == XDR_DONE && sender.status >= 400) {
|
|
// Some sort of error response
|
|
throw new Error(`LP sender failed, ${sender.status}`);
|
|
}
|
|
}
|
|
|
|
sender.open('POST', url_, true);
|
|
return sender;
|
|
}
|
|
|
|
function lp_poller(url_, resolve, reject) {
|
|
let poller = new XMLHttpRequest();
|
|
let promiseCompleted = false;
|
|
|
|
poller.onreadystatechange = function(evt) {
|
|
|
|
if (poller.readyState == XDR_DONE) {
|
|
if (poller.status == 201) { // 201 == HTTP.Created, get SID
|
|
let pkt = JSON.parse(poller.responseText, jsonParseHelper);
|
|
_lpURL = url_ + '&sid=' + pkt.ctrl.params.sid
|
|
poller = lp_poller(_lpURL);
|
|
poller.send(null)
|
|
if (instance.onOpen) {
|
|
instance.onOpen();
|
|
}
|
|
|
|
if (resolve) {
|
|
promiseCompleted = true;
|
|
resolve();
|
|
}
|
|
|
|
if (autoreconnect) {
|
|
boffStop();
|
|
}
|
|
} else if (poller.status < 400) { // 400 = HTTP.BadRequest
|
|
if (instance.onMessage) {
|
|
instance.onMessage(poller.responseText)
|
|
}
|
|
poller = lp_poller(_lpURL);
|
|
poller.send(null);
|
|
} else {
|
|
// Don't throw an error here, gracefully handle server errors
|
|
if (reject && !promiseCompleted) {
|
|
promiseCompleted = true;
|
|
reject(poller.responseText);
|
|
}
|
|
if (instance.onMessage && poller.responseText) {
|
|
instance.onMessage(poller.responseText);
|
|
}
|
|
if (instance.onDisconnect) {
|
|
const code = poller.status || (_boffClosed ? NETWORK_USER : NETWORK_ERROR);
|
|
const text = poller.responseText || (_boffClosed ? NETWORK_USER_TEXT : NETWORK_ERROR_TEXT);
|
|
instance.onDisconnect(new Error(text + ' (' + code + ')'), code);
|
|
}
|
|
|
|
// Polling has stopped. Indicate it by setting poller to null.
|
|
poller = null;
|
|
if (!_boffClosed && autoreconnect) {
|
|
boffReconnect.call(instance);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
poller.open('GET', url_, true);
|
|
return poller;
|
|
}
|
|
|
|
instance.connect = function(host_, force) {
|
|
_boffClosed = false;
|
|
|
|
if (_poller) {
|
|
if (!force) {
|
|
return Promise.resolve();
|
|
}
|
|
_poller.onreadystatechange = undefined;
|
|
_poller.abort();
|
|
_poller = null;
|
|
}
|
|
|
|
if (host_) {
|
|
host = host_;
|
|
}
|
|
|
|
return new Promise(function(resolve, reject) {
|
|
const url = makeBaseUrl(host, secure ? 'https' : 'http', apiKey);
|
|
log("Connecting to: ", url);
|
|
_poller = lp_poller(url, resolve, reject);
|
|
_poller.send(null)
|
|
}).catch((err) => {
|
|
log("LP connection failed:", err);
|
|
});
|
|
};
|
|
|
|
instance.reconnect = function(force) {
|
|
boffStop();
|
|
instance.connect(null, force);
|
|
};
|
|
|
|
instance.disconnect = function() {
|
|
_boffClosed = true;
|
|
boffStop();
|
|
|
|
if (_sender) {
|
|
_sender.onreadystatechange = undefined;
|
|
_sender.abort();
|
|
_sender = null;
|
|
}
|
|
if (_poller) {
|
|
_poller.onreadystatechange = undefined;
|
|
_poller.abort();
|
|
_poller = null;
|
|
}
|
|
|
|
if (instance.onDisconnect) {
|
|
instance.onDisconnect(new Error(NETWORK_USER_TEXT + ' (' + NETWORK_USER + ')'), NETWORK_USER);
|
|
}
|
|
// Ensure it's reconstructed
|
|
_lpURL = null;
|
|
}
|
|
|
|
instance.sendText = function(msg) {
|
|
_sender = lp_sender(_lpURL);
|
|
if (_sender && (_sender.readyState == 1)) { // 1 == OPENED
|
|
_sender.send(msg);
|
|
} else {
|
|
throw new Error("Long poller failed to connect");
|
|
}
|
|
};
|
|
|
|
instance.isConnected = function() {
|
|
return (_poller && true);
|
|
}
|
|
|
|
instance.transport = function() {
|
|
return 'lp';
|
|
}
|
|
|
|
instance.probe = function() {
|
|
instance.sendText('1');
|
|
}
|
|
}
|
|
|
|
let initialized = false;
|
|
if (transport_ === 'lp') {
|
|
// explicit request to use long polling
|
|
init_lp(this);
|
|
initialized = true;
|
|
} else if (transport_ === 'ws') {
|
|
// explicit request to use web socket
|
|
// if websockets are not available, horrible things will happen
|
|
init_ws(this);
|
|
initialized = true;
|
|
|
|
// Default transport selection
|
|
} else if (typeof window == 'object') {
|
|
if (window['WebSocket']) {
|
|
// Using web sockets -- default.
|
|
init_ws(this);
|
|
initialized = true;
|
|
} else if (window['XMLHttpRequest']) {
|
|
// The browser has no websockets, using long polling.
|
|
init_lp(this);
|
|
initialized = true;
|
|
}
|
|
}
|
|
|
|
if (!initialized) {
|
|
// No transport is avaiilable.
|
|
log("No network transport is available. Running under Node? Call 'Tinode.setNetworkProviders()'.");
|
|
throw new Error("No network transport is available. Running under Node? Call 'Tinode.setNetworkProviders()'.");
|
|
}
|
|
|
|
/**
|
|
* Check if the given network transport is available.
|
|
* @memberof Tinode.Connection#
|
|
* @param {string} trans - either <code>"ws"</code> (websocket) or <code>"lp"</code> (long polling).
|
|
* @returns true if given transport is available, false otherwise.
|
|
*/
|
|
this.transportAvailable = function(transp) {
|
|
switch (transp) {
|
|
case 'ws':
|
|
return typeof window == 'object' && window['WebSocket'];
|
|
case 'lp':
|
|
return typeof window == 'object' && window['XMLHttpRequest'];
|
|
default:
|
|
log("Request for unknown transport", transp);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reset autoreconnect counter to zero.
|
|
* @memberof Tinode.Connection#
|
|
*/
|
|
this.backoffReset = function() {
|
|
boffReset();
|
|
}
|
|
|
|
// Callbacks:
|
|
/**
|
|
* A callback to pass incoming messages to. See {@link Tinode.Connection#onMessage}.
|
|
* @callback Tinode.Connection.OnMessage
|
|
* @memberof Tinode.Connection
|
|
* @param {string} message - Message to process.
|
|
*/
|
|
/**
|
|
* A callback to pass incoming messages to.
|
|
* @type {Tinode.Connection.OnMessage}
|
|
* @memberof Tinode.Connection#
|
|
*/
|
|
this.onMessage = undefined;
|
|
|
|
/**
|
|
* A callback for reporting a dropped connection.
|
|
* @type {function}
|
|
* @memberof Tinode.Connection#
|
|
*/
|
|
this.onDisconnect = undefined;
|
|
|
|
/**
|
|
* A callback called when the connection is ready to be used for sending. For websockets it's socket open,
|
|
* for long polling it's <code>readyState=1</code> (OPENED)
|
|
* @type {function}
|
|
* @memberof Tinode.Connection#
|
|
*/
|
|
this.onOpen = undefined;
|
|
|
|
/**
|
|
* A callback to notify of reconnection attempts. See {@link Tinode.Connection#onAutoreconnectIteration}.
|
|
* @memberof Tinode.Connection
|
|
* @callback AutoreconnectIterationType
|
|
* @param {string} timeout - time till the next reconnect attempt in milliseconds. <code>-1</code> means reconnect was skipped.
|
|
* @param {Promise} promise resolved or rejected when the reconnect attemp completes.
|
|
*
|
|
*/
|
|
/**
|
|
* A callback to inform when the next attampt to reconnect will happen and to receive connection promise.
|
|
* @memberof Tinode.Connection#
|
|
* @type {Tinode.Connection.AutoreconnectIterationType}
|
|
*/
|
|
this.onAutoreconnectIteration = undefined;
|
|
|
|
/**
|
|
* A callback to log events from Connection. See {@link Tinode.Connection#logger}.
|
|
* @memberof Tinode.Connection
|
|
* @callback LoggerCallbackType
|
|
* @param {string} event - Event to log.
|
|
*/
|
|
/**
|
|
* A callback to report logging events.
|
|
* @memberof Tinode.Connection#
|
|
* @type {Tinode.Connection.LoggerCallbackType}
|
|
*/
|
|
this.logger = undefined;
|
|
};
|
|
|
|
/**
|
|
* @class Tinode
|
|
*
|
|
* @param {Object} config - configuration parameters.
|
|
* @param {string} config.appName - Name of the calling application to be reported in the User Agent.
|
|
* @param {string} config.host - Host name and port number to connect to.
|
|
* @param {string} config.apiKey - API key generated by <code>keygen</code>.
|
|
* @param {string} config.transport - See {@link Tinode.Connection#transport}.
|
|
* @param {boolean} config.secure - Use Secure WebSocket if <code>true</code>.
|
|
* @param {string} config.platform - Optional platform identifier, one of <code>"ios"</code>, <code>"web"</code>, <code>"android"</code>.
|
|
* @param {boolen} config.persist - use indexDB persistent storage.
|
|
* @param {function} onComplete - callback to call when initialization is completed.
|
|
*/
|
|
var Tinode = function(config, onComplete) {
|
|
// Client-provided application name, format <Name>/<version number>
|
|
this._appName = config.appName || "Undefined";
|
|
|
|
// API Key.
|
|
this._apiKey = config.apiKey;
|
|
|
|
// Name and version of the browser.
|
|
this._browser = '';
|
|
this._platform = config.platform || 'web';
|
|
this._hwos = 'undefined';
|
|
this._humanLanguage = 'xx';
|
|
// Underlying OS.
|
|
if (typeof navigator != 'undefined') {
|
|
this._browser = getBrowserInfo(navigator.userAgent, navigator.product);
|
|
this._hwos = navigator.platform;
|
|
// This is the default language. It could be changed by client.
|
|
this._humanLanguage = navigator.language || 'en-US';
|
|
}
|
|
// Logging to console enabled
|
|
this._loggingEnabled = false;
|
|
// When logging, trip long strings (base64-encoded images) for readability
|
|
this._trimLongStrings = false;
|
|
// UID of the currently authenticated user.
|
|
this._myUID = null;
|
|
// Status of connection: authenticated or not.
|
|
this._authenticated = false;
|
|
// Login used in the last successful basic authentication
|
|
this._login = null;
|
|
// Token which can be used for login instead of login/password.
|
|
this._authToken = null;
|
|
// Counter of received packets
|
|
this._inPacketCount = 0;
|
|
// Counter for generating unique message IDs
|
|
this._messageId = Math.floor((Math.random() * 0xFFFF) + 0xFFFF);
|
|
// Information about the server, if connected
|
|
this._serverInfo = null;
|
|
// Push notification token. Called deviceToken for consistency with the Android SDK.
|
|
this._deviceToken = null;
|
|
|
|
// Cache of pending promises by message id.
|
|
this._pendingPromises = {};
|
|
|
|
// The Timeout object returned by the reject expired promises setInterval.
|
|
this._expirePromises = null;
|
|
|
|
/** A connection object, see {@link Tinode.Connection}. */
|
|
this._connection = new Connection(config.host, config.apiKey, config.transport, config.secure, true);
|
|
// Console logger. Babel somehow fails to parse '...rest' parameter.
|
|
this.logger = (str, ...args) => {
|
|
if (this._loggingEnabled) {
|
|
const d = new Date()
|
|
const dateString = ('0' + d.getUTCHours()).slice(-2) + ':' +
|
|
('0' + d.getUTCMinutes()).slice(-2) + ':' +
|
|
('0' + d.getUTCSeconds()).slice(-2) + '.' +
|
|
('00' + d.getUTCMilliseconds()).slice(-3);
|
|
|
|
console.log('[' + dateString + ']', str, args.join(' '));
|
|
}
|
|
}
|
|
this._connection.logger = this.logger;
|
|
Drafty.logger = this.logger;
|
|
|
|
// Timestamp of the most recent update to topics in cache.
|
|
this._lastTopicUpdate = null;
|
|
|
|
// Tinode's cache of objects
|
|
this._cache = {};
|
|
|
|
const cachePut = this.cachePut = (type, name, obj) => {
|
|
this._cache[type + ':' + name] = obj;
|
|
}
|
|
|
|
const cacheGet = this.cacheGet = (type, name) => {
|
|
return this._cache[type + ':' + name];
|
|
}
|
|
|
|
const cacheDel = this.cacheDel = (type, name) => {
|
|
delete this._cache[type + ':' + name];
|
|
}
|
|
// Enumerate all items in cache, call func for each item.
|
|
// Enumeration stops if func returns true.
|
|
const cacheMap = this.cacheMap = (type, func, context) => {
|
|
const key = type ? type + ':' : undefined;
|
|
for (let idx in this._cache) {
|
|
if (!key || idx.indexOf(key) == 0) {
|
|
if (func.call(context, this._cache[idx], idx)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make limited cache management available to topic.
|
|
// Caching user.public only. Everything else is per-topic.
|
|
this.attachCacheToTopic = (topic) => {
|
|
topic._tinode = this;
|
|
|
|
topic._cacheGetUser = (uid) => {
|
|
const pub = cacheGet('user', uid);
|
|
if (pub) {
|
|
return {
|
|
user: uid,
|
|
public: mergeObj({}, pub)
|
|
};
|
|
}
|
|
return undefined;
|
|
};
|
|
topic._cachePutUser = (uid, user) => {
|
|
return cachePut('user', uid, mergeObj({}, user.public));
|
|
};
|
|
topic._cacheDelUser = (uid) => {
|
|
return cacheDel('user', uid);
|
|
};
|
|
topic._cachePutSelf = () => {
|
|
if (topic.updated && topic.updated > this._lastTopicUpdate) {
|
|
this._lastTopicUpdate = topic.updated;
|
|
}
|
|
return cachePut('topic', topic.name, topic);
|
|
}
|
|
topic._cacheDelSelf = () => {
|
|
return cacheDel('topic', topic.name);
|
|
}
|
|
}
|
|
|
|
// Use indexDB for caching topics and messages.
|
|
this._persist = config.persist;
|
|
// Initialize object regardless. It simplifies the code.
|
|
this._db = DB((err) => {
|
|
this.logger("DB", err);
|
|
}, this.logger);
|
|
|
|
if (this._persist) {
|
|
// Create the persistent cache and read topics into memory.
|
|
this._db.initDatabase().then(() => {
|
|
// Load topics to memory.
|
|
return this._db.mapTopics((data) => {
|
|
let topic = this.cacheGet('topic', data.name);
|
|
if (topic) {
|
|
return;
|
|
}
|
|
if (data.name == TOPIC_ME) {
|
|
topic = new TopicMe();
|
|
} else if (data.name == TOPIC_FND) {
|
|
topic = new TopicFnd();
|
|
} else {
|
|
topic = new Topic(data.name);
|
|
}
|
|
|
|
this._db.deserializeTopic(topic, data);
|
|
this.attachCacheToTopic(topic);
|
|
topic._cachePutSelf();
|
|
topic._loadMessages();
|
|
}).then(() => {
|
|
if (onComplete) {
|
|
onComplete();
|
|
}
|
|
this.logger("Persistent cache initialized.");
|
|
});
|
|
});
|
|
}
|
|
|
|
// Resolve or reject a pending promise.
|
|
// Unresolved promises are stored in _pendingPromises.
|
|
const execPromise = (id, code, onOK, errorText) => {
|
|
const callbacks = this._pendingPromises[id];
|
|
if (callbacks) {
|
|
delete this._pendingPromises[id];
|
|
if (code >= 200 && code < 400) {
|
|
if (callbacks.resolve) {
|
|
callbacks.resolve(onOK);
|
|
}
|
|
} else if (callbacks.reject) {
|
|
callbacks.reject(new Error(`${errorText} (${code})`));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generator of default promises for sent packets.
|
|
const makePromise = (id) => {
|
|
let promise = null;
|
|
if (id) {
|
|
promise = new Promise((resolve, reject) => {
|
|
// Stored callbacks will be called when the response packet with this Id arrives
|
|
this._pendingPromises[id] = {
|
|
'resolve': resolve,
|
|
'reject': reject,
|
|
'ts': new Date()
|
|
};
|
|
})
|
|
}
|
|
return promise;
|
|
}
|
|
|
|
// Generates unique message IDs
|
|
const getNextUniqueId = this.getNextUniqueId = () => {
|
|
return (this._messageId != 0) ? '' + this._messageId++ : undefined;
|
|
}
|
|
|
|
// Get User Agent string
|
|
const getUserAgent = () => {
|
|
return this._appName + ' (' + (this._browser ? this._browser + '; ' : '') + this._hwos + '); ' + LIBRARY;
|
|
}
|
|
|
|
// Generator of packets stubs
|
|
this.initPacket = (type, topic) => {
|
|
switch (type) {
|
|
case 'hi':
|
|
return {
|
|
'hi': {
|
|
'id': getNextUniqueId(),
|
|
'ver': VERSION,
|
|
'ua': getUserAgent(),
|
|
'dev': this._deviceToken,
|
|
'lang': this._humanLanguage,
|
|
'platf': this._platform
|
|
}
|
|
};
|
|
|
|
case 'acc':
|
|
return {
|
|
'acc': {
|
|
'id': getNextUniqueId(),
|
|
'user': null,
|
|
'scheme': null,
|
|
'secret': null,
|
|
'login': false,
|
|
'tags': null,
|
|
'desc': {},
|
|
'cred': {}
|
|
}
|
|
};
|
|
|
|
case 'login':
|
|
return {
|
|
'login': {
|
|
'id': getNextUniqueId(),
|
|
'scheme': null,
|
|
'secret': null
|
|
}
|
|
};
|
|
|
|
case 'sub':
|
|
return {
|
|
'sub': {
|
|
'id': getNextUniqueId(),
|
|
'topic': topic,
|
|
'set': {},
|
|
'get': {}
|
|
}
|
|
};
|
|
|
|
case 'leave':
|
|
return {
|
|
'leave': {
|
|
'id': getNextUniqueId(),
|
|
'topic': topic,
|
|
'unsub': false
|
|
}
|
|
};
|
|
|
|
case 'pub':
|
|
return {
|
|
'pub': {
|
|
'id': getNextUniqueId(),
|
|
'topic': topic,
|
|
'noecho': false,
|
|
'head': null,
|
|
'content': {}
|
|
}
|
|
};
|
|
|
|
case 'get':
|
|
return {
|
|
'get': {
|
|
'id': getNextUniqueId(),
|
|
'topic': topic,
|
|
'what': null, // data, sub, desc, space separated list; unknown strings are ignored
|
|
'desc': {},
|
|
'sub': {},
|
|
'data': {}
|
|
}
|
|
};
|
|
|
|
case 'set':
|
|
return {
|
|
'set': {
|
|
'id': getNextUniqueId(),
|
|
'topic': topic,
|
|
'desc': {},
|
|
'sub': {},
|
|
'tags': []
|
|
}
|
|
};
|
|
|
|
case 'del':
|
|
return {
|
|
'del': {
|
|
'id': getNextUniqueId(),
|
|
'topic': topic,
|
|
'what': null,
|
|
'delseq': null,
|
|
'user': null,
|
|
'hard': false
|
|
}
|
|
};
|
|
|
|
case 'note':
|
|
return {
|
|
'note': {
|
|
// no id by design
|
|
'topic': topic,
|
|
'what': null, // one of "recv", "read", "kp"
|
|
'seq': undefined // the server-side message id aknowledged as received or read
|
|
}
|
|
};
|
|
|
|
default:
|
|
throw new Error(`Unknown packet type requested: ${type}`);
|
|
}
|
|
}
|
|
|
|
// Send a packet. If packet id is provided return a promise.
|
|
this.send = (pkt, id) => {
|
|
let promise;
|
|
if (id) {
|
|
promise = makePromise(id);
|
|
}
|
|
pkt = simplify(pkt);
|
|
let msg = JSON.stringify(pkt);
|
|
this.logger("out: " + (this._trimLongStrings ? JSON.stringify(pkt, jsonLoggerHelper) : msg));
|
|
try {
|
|
this._connection.sendText(msg);
|
|
} catch (err) {
|
|
// If sendText throws, wrap the error in a promise or rethrow.
|
|
if (id) {
|
|
execPromise(id, NETWORK_ERROR, null, err.message);
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
return promise;
|
|
}
|
|
|
|
// On successful login save server-provided data.
|
|
this.loginSuccessful = (ctrl) => {
|
|
if (!ctrl.params || !ctrl.params.user) {
|
|
return ctrl;
|
|
}
|
|
// This is a response to a successful login,
|
|
// extract UID and security token, save it in Tinode module
|
|
this._myUID = ctrl.params.user;
|
|
this._authenticated = (ctrl && ctrl.code >= 200 && ctrl.code < 300);
|
|
if (ctrl.params && ctrl.params.token && ctrl.params.expires) {
|
|
this._authToken = {
|
|
token: ctrl.params.token,
|
|
expires: new Date(ctrl.params.expires)
|
|
};
|
|
} else {
|
|
this._authToken = null;
|
|
}
|
|
|
|
if (this.onLogin) {
|
|
this.onLogin(ctrl.code, ctrl.text);
|
|
}
|
|
|
|
return ctrl;
|
|
}
|
|
|
|
// The main message dispatcher.
|
|
this._connection.onMessage = (data) => {
|
|
// Skip empty response. This happens when LP times out.
|
|
if (!data) return;
|
|
|
|
this._inPacketCount++;
|
|
|
|
// Send raw message to listener
|
|
if (this.onRawMessage) {
|
|
this.onRawMessage(data);
|
|
}
|
|
|
|
if (data === '0') {
|
|
// Server response to a network probe.
|
|
if (this.onNetworkProbe) {
|
|
this.onNetworkProbe();
|
|
}
|
|
// No processing is necessary.
|
|
return;
|
|
}
|
|
|
|
let pkt = JSON.parse(data, jsonParseHelper);
|
|
if (!pkt) {
|
|
this.logger("in: " + data);
|
|
this.logger("ERROR: failed to parse data");
|
|
} else {
|
|
this.logger("in: " + (this._trimLongStrings ? JSON.stringify(pkt, jsonLoggerHelper) : data));
|
|
|
|
// Send complete packet to listener
|
|
if (this.onMessage) {
|
|
this.onMessage(pkt);
|
|
}
|
|
|
|
if (pkt.ctrl) {
|
|
// Handling {ctrl} message
|
|
if (this.onCtrlMessage) {
|
|
this.onCtrlMessage(pkt.ctrl);
|
|
}
|
|
|
|
// Resolve or reject a pending promise, if any
|
|
if (pkt.ctrl.id) {
|
|
execPromise(pkt.ctrl.id, pkt.ctrl.code, pkt.ctrl, pkt.ctrl.text);
|
|
}
|
|
setTimeout(() => {
|
|
if (pkt.ctrl.code == 205 && pkt.ctrl.text == 'evicted') {
|
|
// User evicted from topic.
|
|
const topic = cacheGet('topic', pkt.ctrl.topic);
|
|
if (topic) {
|
|
topic._resetSub();
|
|
if (pkt.ctrl.params && pkt.ctrl.params.unsub) {
|
|
topic._gone();
|
|
}
|
|
}
|
|
} else if (pkt.ctrl.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 = () => {
|
|
if (!this._expirePromises) {
|
|
// Reject promises which have not been resolved for too long.
|
|
this._expirePromises = setInterval(() => {
|
|
const err = new Error("Timeout (504)");
|
|
const expires = new Date(new Date().getTime() - EXPIRE_PROMISES_TIMEOUT);
|
|
for (let id in this._pendingPromises) {
|
|
let callbacks = this._pendingPromises[id];
|
|
if (callbacks && callbacks.ts < expires) {
|
|
this.logger("Promise expired", id);
|
|
delete this._pendingPromises[id];
|
|
if (callbacks.reject) {
|
|
callbacks.reject(err);
|
|
}
|
|
}
|
|
}
|
|
}, EXPIRE_PROMISES_PERIOD);
|
|
}
|
|
this.hello();
|
|
}
|
|
|
|
// Wrapper for the reconnect iterator callback.
|
|
this._connection.onAutoreconnectIteration = (timeout, promise) => {
|
|
if (this.onAutoreconnectIteration) {
|
|
this.onAutoreconnectIteration(timeout, promise);
|
|
}
|
|
}
|
|
|
|
this._connection.onDisconnect = (err, code) => {
|
|
this._inPacketCount = 0;
|
|
this._serverInfo = null;
|
|
this._authenticated = false;
|
|
|
|
if (this._expirePromises) {
|
|
clearInterval(this._expirePromises);
|
|
this._expirePromises = null;
|
|
}
|
|
|
|
// Mark all topics as unsubscribed
|
|
cacheMap('topic', (topic, key) => {
|
|
topic._resetSub();
|
|
});
|
|
|
|
// Reject all pending promises
|
|
for (let key in this._pendingPromises) {
|
|
const callbacks = this._pendingPromises[key];
|
|
if (callbacks && callbacks.reject) {
|
|
callbacks.reject(err);
|
|
}
|
|
}
|
|
this._pendingPromises = {};
|
|
|
|
if (this.onDisconnect) {
|
|
this.onDisconnect(err);
|
|
}
|
|
}
|
|
};
|
|
|
|
// Static methods.
|
|
|
|
/**
|
|
* @typedef Credential
|
|
* @type {object}
|
|
* @property {string} meth - validation method.
|
|
* @property {string} val - value to validate (e.g. email or phone number).
|
|
* @property {string} resp - validation response.
|
|
* @property {Object} params - validation parameters.
|
|
*/
|
|
/**
|
|
* Helper method to package account credential.
|
|
*
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @param {string | Credential} meth - validation method or object with validation data.
|
|
* @param {string=} val - validation value (e.g. email or phone number).
|
|
* @param {Object=} params - validation parameters.
|
|
* @param {string=} resp - validation response.
|
|
*
|
|
* @returns {Array.<Credential>} array with a single credential or <code>null</code> if no valid credentials were given.
|
|
*/
|
|
Tinode.credential = function(meth, val, params, resp) {
|
|
if (typeof meth == 'object') {
|
|
({
|
|
val,
|
|
params,
|
|
resp,
|
|
meth
|
|
} = meth);
|
|
}
|
|
if (meth && (val || resp)) {
|
|
return [{
|
|
'meth': meth,
|
|
'val': val,
|
|
'resp': resp,
|
|
'params': params
|
|
}];
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Determine topic type from topic's name: grp, p2p, me, fnd, sys.
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @param {string} name - Name of the topic to test.
|
|
* @returns {string} One of <code>"me"</code>, <code>"fnd"</code>, <code>"sys"</code>, <code>"grp"</code>,
|
|
* <code>"p2p"</code> or <code>undefined</code>.
|
|
*/
|
|
Tinode.topicType = function(name) {
|
|
const types = {
|
|
'me': 'me',
|
|
'fnd': 'fnd',
|
|
'grp': 'grp',
|
|
'new': 'grp',
|
|
'nch': 'grp',
|
|
'chn': 'grp',
|
|
'usr': 'p2p',
|
|
'sys': 'sys'
|
|
};
|
|
return types[(typeof name == 'string') ? name.substring(0, 3) : 'xxx'];
|
|
};
|
|
|
|
/**
|
|
* Check if the given topic name is a name of a 'me' topic.
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @param {string} name - Name of the topic to test.
|
|
* @returns {boolean} <code>true</code> if the name is a name of a 'me' topic, <code>false</code> otherwise.
|
|
*/
|
|
Tinode.isMeTopicName = function(name) {
|
|
return Tinode.topicType(name) == 'me';
|
|
};
|
|
|
|
/**
|
|
* Check if the given topic name is a name of a group topic.
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @param {string} name - Name of the topic to test.
|
|
* @returns {boolean} <code>true</code> if the name is a name of a group topic, <code>false</code> otherwise.
|
|
*/
|
|
Tinode.isGroupTopicName = function(name) {
|
|
return Tinode.topicType(name) == 'grp';
|
|
};
|
|
|
|
/**
|
|
* Check if the given topic name is a name of a p2p topic.
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @param {string} name - Name of the topic to test.
|
|
* @returns {boolean} <code>true</code> if the name is a name of a p2p topic, <code>false</code> otherwise.
|
|
*/
|
|
Tinode.isP2PTopicName = function(name) {
|
|
return Tinode.topicType(name) == 'p2p';
|
|
};
|
|
|
|
/**
|
|
* Check if the given topic name is a name of a communication topic, i.e. P2P or group.
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @param {string} name - Name of the topic to test.
|
|
* @returns {boolean} <code>true</code> if the name is a name of a p2p or group topic, <code>false</code> otherwise.
|
|
*/
|
|
Tinode.isCommTopicName = function(name) {
|
|
return Tinode.isP2PTopicName(name) || Tinode.isGroupTopicName(name);
|
|
};
|
|
|
|
/**
|
|
* Check if the topic name is a name of a new topic.
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @param {string} name - topic name to check.
|
|
* @returns {boolean} <code>true</code> if the name is a name of a new topic, <code>false</code> otherwise.
|
|
*/
|
|
Tinode.isNewGroupTopicName = function(name) {
|
|
return (typeof name == 'string') &&
|
|
(name.substring(0, 3) == TOPIC_NEW || name.substring(0, 3) == TOPIC_NEW_CHAN);
|
|
};
|
|
|
|
/**
|
|
* Check if the topic name is a name of a channel.
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @param {string} name - topic name to check.
|
|
* @returns {boolean} <code>true</code> if the name is a name of a channel, <code>false</code> otherwise.
|
|
*/
|
|
Tinode.isChannelTopicName = function(name) {
|
|
return (typeof name == 'string') &&
|
|
(name.substring(0, 3) == TOPIC_CHAN || name.substring(0, 3) == TOPIC_NEW_CHAN);
|
|
};
|
|
|
|
/**
|
|
* Return information about the current version of this Tinode client library.
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @returns {string} semantic version of the library, e.g. <code>"0.15.5-rc1"</code>.
|
|
*/
|
|
Tinode.getVersion = function() {
|
|
return VERSION;
|
|
};
|
|
|
|
/**
|
|
* To use Tinode in a non browser context, supply WebSocket and XMLHttpRequest providers.
|
|
* @static
|
|
* @memberof Tinode
|
|
* @param wsProvider WebSocket provider, e.g. for nodeJS , <code>require('ws')</code>.
|
|
* @param xhrProvider XMLHttpRequest provider, e.g. for node <code>require('xhr')</code>.
|
|
*/
|
|
Tinode.setNetworkProviders = function(wsProvider, xhrProvider) {
|
|
WebSocketProvider = wsProvider;
|
|
XHRProvider = xhrProvider;
|
|
};
|
|
|
|
/**
|
|
* Return information about the current name and version of this Tinode library.
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @returns {string} the name of the library and it's version.
|
|
*/
|
|
Tinode.getLibrary = function() {
|
|
return LIBRARY;
|
|
};
|
|
|
|
// Exported constants
|
|
Tinode.MESSAGE_STATUS_NONE = MESSAGE_STATUS_NONE;
|
|
Tinode.MESSAGE_STATUS_QUEUED = MESSAGE_STATUS_QUEUED;
|
|
Tinode.MESSAGE_STATUS_SENDING = MESSAGE_STATUS_SENDING;
|
|
Tinode.MESSAGE_STATUS_FAILED = MESSAGE_STATUS_FAILED;
|
|
Tinode.MESSAGE_STATUS_SENT = MESSAGE_STATUS_SENT;
|
|
Tinode.MESSAGE_STATUS_RECEIVED = MESSAGE_STATUS_RECEIVED;
|
|
Tinode.MESSAGE_STATUS_READ = MESSAGE_STATUS_READ;
|
|
Tinode.MESSAGE_STATUS_TO_ME = MESSAGE_STATUS_TO_ME;
|
|
|
|
// Unicode [del] symbol.
|
|
Tinode.DEL_CHAR = '\u2421';
|
|
|
|
/**
|
|
* Check if the given string represents <code>NULL</code> value as defined by Tinode (<code>'\u2421'</code>).
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @param {string} str - string to check for <code>NULL</code> value.
|
|
*
|
|
* @returns {boolean} <code>true</code> if string represents <code>NULL</code> value, <code>false</code> otherwise.
|
|
*/
|
|
Tinode.isNullValue = function(str) {
|
|
return str === Tinode.DEL_CHAR;
|
|
};
|
|
|
|
/**
|
|
* Check if the given URL string is a relative URL.
|
|
* Check for cases like:
|
|
* <code>'http://example.com'</code>
|
|
* <code>' http://example.com'</code>
|
|
* <code>'//example.com/'</code>
|
|
* <code>'http:example.com'</code>
|
|
* <code>'http:/example.com'</code>
|
|
* @memberof Tinode
|
|
* @static
|
|
*
|
|
* @param {string} url - URL string to check.
|
|
*
|
|
* @returns {boolean} <code>true</code> if the URL is relative, <code>false</code> otherwise.
|
|
*/
|
|
Tinode.isRelativeURL = function(url) {
|
|
return !/^\s*([a-z][a-z0-9+.-]*:|\/\/)/im.test(url);
|
|
};
|
|
|
|
// Names of keys to server-provided configuration limits.
|
|
Tinode.MAX_MESSAGE_SIZE = 'maxMessageSize';
|
|
Tinode.MAX_SUBSCRIBER_COUNT = 'maxSubscriberCount';
|
|
Tinode.MAX_TAG_COUNT = 'maxTagCount';
|
|
Tinode.MAX_FILE_UPLOAD_SIZE = 'maxFileUploadSize';
|
|
|
|
// Public methods;
|
|
Tinode.prototype = {
|
|
/**
|
|
* Connect to the server.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} host_ - name of the host to connect to.
|
|
*
|
|
* @return {Promise} Promise resolved/rejected when the connection call completes:
|
|
* <code>resolve()</code> is called without parameters, <code>reject()</code> receives the
|
|
* <code>Error</code> as a single parameter.
|
|
*/
|
|
connect: function(host_) {
|
|
return this._connection.connect(host_);
|
|
},
|
|
|
|
/**
|
|
* Attempt to reconnect to the server immediately.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} force - reconnect even if there is a connection already.
|
|
*/
|
|
reconnect: function(force) {
|
|
this._connection.reconnect(force);
|
|
},
|
|
|
|
/**
|
|
* Disconnect from the server.
|
|
* @memberof Tinode#
|
|
*/
|
|
disconnect: function() {
|
|
this._connection.disconnect();
|
|
},
|
|
|
|
/**
|
|
* Clear persistent cache: remove indexDB cache of the most recently logged in user.
|
|
*/
|
|
clearStorage: function() {
|
|
if (this._db) {
|
|
this._db.deleteDatabase();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Send a network probe message to make sure the connection is alive.
|
|
* @memberof Tinode#
|
|
*/
|
|
networkProbe: function() {
|
|
this._connection.probe();
|
|
},
|
|
|
|
/**
|
|
* Check for live connection to server.
|
|
* @memberof Tinode#
|
|
*
|
|
* @returns {boolean} <code>true</code> if there is a live connection, <code>false</code> otherwise.
|
|
*/
|
|
isConnected: function() {
|
|
return this._connection.isConnected();
|
|
},
|
|
|
|
/**
|
|
* Check if connection is authenticated (last login was successful).
|
|
* @memberof Tinode#
|
|
* @returns {boolean} <code>true</code> if authenticated, <code>false</code> otherwise.
|
|
*/
|
|
isAuthenticated: function() {
|
|
return this._authenticated;
|
|
},
|
|
|
|
/**
|
|
* Add API key and auth token to the relative URL making it usable for getting data
|
|
* from the server in a simple <code>HTTP GET</code> request.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} URL - URL to wrap.
|
|
* @returns {string} URL with appended API key and token, if valid token is present.
|
|
*/
|
|
authorizeURL: function(url) {
|
|
if (!url) {
|
|
return url;
|
|
}
|
|
|
|
if (Tinode.isRelativeURL(url)) {
|
|
// Fake base to make the relative URL parseable.
|
|
const base = 'scheme://host/';
|
|
const parsed = new URL(url, base);
|
|
if (this._apiKey) {
|
|
parsed.searchParams.append('apikey', this._apiKey);
|
|
}
|
|
if (this._authToken.token) {
|
|
parsed.searchParams.append('auth', 'token');
|
|
parsed.searchParams.append('secret', this._authToken.token);
|
|
}
|
|
// Convert back to string and strip fake base URL except for the root slash.
|
|
url = parsed.toString().substring(base.length - 1);
|
|
}
|
|
return url;
|
|
},
|
|
|
|
/**
|
|
* @typedef AccountParams
|
|
* @memberof Tinode
|
|
* @type {Object}
|
|
* @property {Tinode.DefAcs=} defacs - Default access parameters for user's <code>me</code> topic.
|
|
* @property {Object=} public - Public application-defined data exposed on <code>me</code> topic.
|
|
* @property {Object=} private - Private application-defined data accessible on <code>me</code> topic.
|
|
* @property {Array} tags - array of string tags for user discovery.
|
|
* @property {string=} token - authentication token to use.
|
|
*/
|
|
/**
|
|
* @typedef DefAcs
|
|
* @memberof Tinode
|
|
* @type {Object}
|
|
* @property {string=} auth - Access mode for <code>me</code> for authenticated users.
|
|
* @property {string=} anon - Access mode for <code>me</code> for anonymous users.
|
|
*/
|
|
|
|
/**
|
|
* Create or update an account.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} uid - User id to update
|
|
* @param {string} scheme - Authentication scheme; <code>"basic"</code> and <code>"anonymous"</code> are the currently supported schemes.
|
|
* @param {string} secret - Authentication secret, assumed to be already base64 encoded.
|
|
* @param {boolean=} login - Use new account to authenticate current session
|
|
* @param {Tinode.AccountParams=} params - User data to pass to the server.
|
|
*/
|
|
account: function(uid, scheme, secret, login, params) {
|
|
const pkt = this.initPacket('acc');
|
|
pkt.acc.user = uid;
|
|
pkt.acc.scheme = scheme;
|
|
pkt.acc.secret = secret;
|
|
// Log in to the new account using selected scheme
|
|
pkt.acc.login = login;
|
|
|
|
if (params) {
|
|
pkt.acc.desc.defacs = params.defacs;
|
|
pkt.acc.desc.public = params.public;
|
|
pkt.acc.desc.private = params.private;
|
|
|
|
pkt.acc.tags = params.tags;
|
|
pkt.acc.cred = params.cred;
|
|
|
|
pkt.acc.token = params.token;
|
|
}
|
|
|
|
return this.send(pkt, pkt.acc.id);
|
|
},
|
|
|
|
/**
|
|
* Create a new user. Wrapper for {@link Tinode#account}.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} scheme - Authentication scheme; <code>"basic"</code> is the only currently supported scheme.
|
|
* @param {string} secret - Authentication.
|
|
* @param {boolean=} login - Use new account to authenticate current session
|
|
* @param {Tinode.AccountParams=} params - User data to pass to the server.
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected when server reply is received.
|
|
*/
|
|
createAccount: function(scheme, secret, login, params) {
|
|
let promise = this.account(USER_NEW, scheme, secret, login, params);
|
|
if (login) {
|
|
promise = promise.then((ctrl) => {
|
|
return this.loginSuccessful(ctrl);
|
|
});
|
|
}
|
|
return promise;
|
|
},
|
|
|
|
/**
|
|
* Create user with <code>'basic'</code> authentication scheme and immediately
|
|
* use it for authentication. Wrapper for {@link Tinode#account}.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} username - Login to use for the new account.
|
|
* @param {string} password - User's password.
|
|
* @param {Tinode.AccountParams=} params - User data to pass to the server.
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected when server reply is received.
|
|
*/
|
|
createAccountBasic: function(username, password, params) {
|
|
// Make sure we are not using 'null' or 'undefined';
|
|
username = username || '';
|
|
password = password || '';
|
|
return this.createAccount('basic',
|
|
b64EncodeUnicode(username + ':' + password), true, params);
|
|
},
|
|
|
|
/**
|
|
* Update user's credentials for <code>'basic'</code> authentication scheme. Wrapper for {@link Tinode#account}.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} uid - User ID to update.
|
|
* @param {string} username - Login to use for the new account.
|
|
* @param {string} password - User's password.
|
|
* @param {Tinode.AccountParams=} params - data to pass to the server.
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected when server reply is received.
|
|
*/
|
|
updateAccountBasic: function(uid, username, password, params) {
|
|
// Make sure we are not using 'null' or 'undefined';
|
|
username = username || '';
|
|
password = password || '';
|
|
return this.account(uid, 'basic',
|
|
b64EncodeUnicode(username + ':' + password), false, params);
|
|
},
|
|
|
|
/**
|
|
* Send handshake to the server.
|
|
* @memberof Tinode#
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected when server reply is received.
|
|
*/
|
|
hello: function() {
|
|
const pkt = this.initPacket('hi');
|
|
|
|
return this.send(pkt, pkt.hi.id)
|
|
.then((ctrl) => {
|
|
// Reset backoff counter on successful connection.
|
|
this._connection.backoffReset();
|
|
|
|
// Server response contains server protocol version, build, constraints,
|
|
// session ID for long polling. Save them.
|
|
if (ctrl.params) {
|
|
this._serverInfo = ctrl.params;
|
|
}
|
|
|
|
if (this.onConnect) {
|
|
this.onConnect();
|
|
}
|
|
|
|
return ctrl;
|
|
}).catch((err) => {
|
|
this._connection.reconnect(true);
|
|
|
|
if (this.onDisconnect) {
|
|
this.onDisconnect(err);
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Set or refresh the push notifications/device token. If the client is connected,
|
|
* the deviceToken can be sent to the server.
|
|
*
|
|
* @memberof Tinode#
|
|
* @param {string} dt - token obtained from the provider.
|
|
* @param {boolean} sendToServer - if true, send dt to server immediately.
|
|
*
|
|
* @returns 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; <code>"basic"</code> is the only currently supported scheme.
|
|
* @param {string} secret - Authentication secret, assumed to be already base64 encoded.
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected when server reply is received.
|
|
*/
|
|
login: function(scheme, secret, cred) {
|
|
const pkt = this.initPacket('login');
|
|
pkt.login.scheme = scheme;
|
|
pkt.login.secret = secret;
|
|
pkt.login.cred = cred;
|
|
|
|
return this.send(pkt, pkt.login.id)
|
|
.then((ctrl) => {
|
|
const x = this.loginSuccessful(ctrl);
|
|
return x;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Wrapper for {@link Tinode#login} with basic authentication
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} uname - User name.
|
|
* @param {string} password - Password.
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
loginBasic: function(uname, password, cred) {
|
|
return this.login('basic', b64EncodeUnicode(uname + ':' + password), cred)
|
|
.then((ctrl) => {
|
|
this._login = uname;
|
|
return ctrl;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Wrapper for {@link Tinode#login} with token authentication
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} token - Token received in response to earlier login.
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
loginToken: function(token, cred) {
|
|
return this.login('token', token, cred);
|
|
},
|
|
|
|
/**
|
|
* Send a request for resetting an authentication secret.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} scheme - authentication scheme to reset.
|
|
* @param {string} method - method to use for resetting the secret, such as "email" or "tel".
|
|
* @param {string} value - value of the credential to use, a specific email address or a phone number.
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving the server reply.
|
|
*/
|
|
requestResetAuthSecret: function(scheme, method, value) {
|
|
return this.login('reset', b64EncodeUnicode(scheme + ':' + method + ':' + value));
|
|
},
|
|
|
|
/**
|
|
* @typedef AuthToken
|
|
* @memberof Tinode
|
|
* @type {Object}
|
|
* @property {string} token - Token value.
|
|
* @property {Date} expires - Token expiration time.
|
|
*/
|
|
/**
|
|
* Get stored authentication token.
|
|
* @memberof Tinode#
|
|
*
|
|
* @returns {Tinode.AuthToken} authentication token.
|
|
*/
|
|
getAuthToken: function() {
|
|
if (this._authToken && (this._authToken.expires.getTime() > Date.now())) {
|
|
return this._authToken;
|
|
} else {
|
|
this._authToken = null;
|
|
}
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* Application may provide a saved authentication token.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {Tinode.AuthToken} token - authentication token.
|
|
*/
|
|
setAuthToken: function(token) {
|
|
this._authToken = token;
|
|
},
|
|
|
|
/**
|
|
* @typedef SetParams
|
|
* @type {Object}
|
|
* @memberof Tinode
|
|
* @property {Tinode.SetDesc=} desc - Topic initialization parameters when creating a new topic or a new subscription.
|
|
* @property {Tinode.SetSub=} sub - Subscription initialization parameters.
|
|
*/
|
|
/**
|
|
* @typedef SetDesc
|
|
* @type {Object}
|
|
* @memberof Tinode
|
|
* @property {Tinode.DefAcs=} defacs - Default access mode.
|
|
* @property {Object=} public - Free-form topic description, publically accessible.
|
|
* @property {Object=} private - Free-form topic descriptionaccessible only to the owner.
|
|
*/
|
|
/**
|
|
* @typedef SetSub
|
|
* @type {Object}
|
|
* @memberof Tinode
|
|
* @property {string=} user - UID of the user affected by the request. Default (empty) - current user.
|
|
* @property {string=} mode - User access mode, either requested or assigned dependent on context.
|
|
* @property {Object=} info - Free-form payload to pass to the invited user or topic manager.
|
|
*/
|
|
/**
|
|
* Parameters passed to {@link Tinode#subscribe}.
|
|
*
|
|
* @typedef SubscriptionParams
|
|
* @type {Object}
|
|
* @memberof Tinode
|
|
* @property {Tinode.SetParams=} set - Parameters used to initialize topic
|
|
* @property {Tinode.GetQuery=} get - Query for fetching data from topic.
|
|
*/
|
|
|
|
/**
|
|
* Send a topic subscription request.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topic - Name of the topic to subscribe to.
|
|
* @param {Tinode.GetQuery=} getParams - Optional subscription metadata query
|
|
* @param {Tinode.SetParams=} setParams - Optional initialization parameters
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
subscribe: function(topicName, getParams, setParams) {
|
|
const pkt = this.initPacket('sub', topicName)
|
|
if (!topicName) {
|
|
topicName = TOPIC_NEW;
|
|
}
|
|
|
|
pkt.sub.get = getParams;
|
|
|
|
if (setParams) {
|
|
if (setParams.sub) {
|
|
pkt.sub.set.sub = setParams.sub;
|
|
}
|
|
|
|
if (setParams.desc) {
|
|
if (Tinode.isNewGroupTopicName(topicName)) {
|
|
// Full set.desc params are used for new topics only
|
|
pkt.sub.set.desc = setParams.desc;
|
|
} else if (Tinode.isP2PTopicName(topicName) && setParams.desc.defacs) {
|
|
// Use optional default permissions only.
|
|
pkt.sub.set.desc = {
|
|
defacs: setParams.desc.defacs
|
|
};
|
|
}
|
|
}
|
|
|
|
if (setParams.tags) {
|
|
pkt.sub.set.tags = setParams.tags;
|
|
}
|
|
}
|
|
|
|
return this.send(pkt, pkt.sub.id);
|
|
},
|
|
|
|
/**
|
|
* Detach and optionally unsubscribe from the topic
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topic - Topic to detach from.
|
|
* @param {boolean} unsub - If <code>true</code>, detach and unsubscribe, otherwise just detach.
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
leave: function(topic, unsub) {
|
|
const pkt = this.initPacket('leave', topic);
|
|
pkt.leave.unsub = unsub;
|
|
|
|
return this.send(pkt, pkt.leave.id);
|
|
},
|
|
|
|
/**
|
|
* Create message draft without sending it to the server.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topic - Name of the topic to publish to.
|
|
* @param {Object} data - Payload to publish.
|
|
* @param {boolean=} noEcho - If <code>true</code>, tell the server not to echo the message to the original session.
|
|
*
|
|
* @returns {Object} new message which can be sent to the server or otherwise used.
|
|
*/
|
|
createMessage: function(topic, data, noEcho) {
|
|
const pkt = this.initPacket('pub', topic);
|
|
|
|
let dft = typeof data == 'string' ? Drafty.parse(data) : data;
|
|
if (dft && !Drafty.isPlainText(dft)) {
|
|
pkt.pub.head = {
|
|
mime: Drafty.getContentType()
|
|
};
|
|
data = dft;
|
|
}
|
|
pkt.pub.noecho = noEcho;
|
|
pkt.pub.content = data;
|
|
|
|
return pkt.pub;
|
|
},
|
|
|
|
/**
|
|
* Publish {data} message to topic.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topic - Name of the topic to publish to.
|
|
* @param {Object} data - Payload to publish.
|
|
* @param {boolean=} noEcho - If <code>true</code>, tell the server not to echo the message to the original session.
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
publish: function(topic, data, noEcho) {
|
|
return this.publishMessage(
|
|
this.createMessage(topic, data, noEcho)
|
|
);
|
|
},
|
|
|
|
/**
|
|
* Publish message to topic. The message should be created by {@link Tinode#createMessage}.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {Object} pub - Message to publish.
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
publishMessage: function(pub) {
|
|
// Make a shallow copy. Needed in order to clear locally-assigned temp values;
|
|
pub = Object.assign({}, pub);
|
|
pub.seq = undefined;
|
|
pub.from = undefined;
|
|
pub.ts = undefined;
|
|
return this.send({
|
|
pub: pub
|
|
}, pub.id);
|
|
},
|
|
|
|
/**
|
|
* @typedef GetQuery
|
|
* @type {Object}
|
|
* @memberof Tinode
|
|
* @property {Tinode.GetOptsType=} desc - If provided (even if empty), fetch topic description.
|
|
* @property {Tinode.GetOptsType=} sub - If provided (even if empty), fetch topic subscriptions.
|
|
* @property {Tinode.GetDataType=} data - If provided (even if empty), get messages.
|
|
*/
|
|
|
|
/**
|
|
* @typedef GetOptsType
|
|
* @type {Object}
|
|
* @memberof Tinode
|
|
* @property {Date=} ims - "If modified since", fetch data only it was was modified since stated date.
|
|
* @property {number=} limit - Maximum number of results to return. Ignored when querying topic description.
|
|
*/
|
|
|
|
/**
|
|
* @typedef GetDataType
|
|
* @type {Object}
|
|
* @memberof Tinode
|
|
* @property {number=} since - Load messages with seq id equal or greater than this value.
|
|
* @property {number=} before - Load messages with seq id lower than this number.
|
|
* @property {number=} limit - Maximum number of results to return.
|
|
*/
|
|
|
|
/**
|
|
* Request topic metadata
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topic - Name of the topic to query.
|
|
* @param {Tinode.GetQuery} params - Parameters of the query. Use {@link Tinode.MetaGetBuilder} to generate.
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
getMeta: function(topic, params) {
|
|
const pkt = this.initPacket('get', topic);
|
|
|
|
pkt.get = mergeObj(pkt.get, params);
|
|
|
|
return this.send(pkt, pkt.get.id);
|
|
},
|
|
|
|
/**
|
|
* Update topic's metadata: description, subscribtions.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topic - Topic to update.
|
|
* @param {Tinode.SetParams} params - topic metadata to update.
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
setMeta: function(topic, params) {
|
|
const pkt = this.initPacket('set', topic);
|
|
const what = [];
|
|
|
|
if (params) {
|
|
['desc', 'sub', 'tags', 'cred'].map(function(key) {
|
|
if (params.hasOwnProperty(key)) {
|
|
what.push(key);
|
|
pkt.set[key] = params[key];
|
|
}
|
|
});
|
|
}
|
|
|
|
if (what.length == 0) {
|
|
return Promise.reject(new Error("Invalid {set} parameters"));
|
|
}
|
|
|
|
return this.send(pkt, pkt.set.id);
|
|
},
|
|
|
|
/**
|
|
* Range of message IDs to delete.
|
|
*
|
|
* @typedef DelRange
|
|
* @type {Object}
|
|
* @memberof Tinode
|
|
* @property {number} low - low end of the range, inclusive (closed).
|
|
* @property {number=} hi - high end of the range, exclusive (open).
|
|
*/
|
|
/**
|
|
* Delete some or all messages in a topic.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topic - Topic name to delete messages from.
|
|
* @param {Tinode.DelRange[]} list - Ranges of message IDs to delete.
|
|
* @param {boolean=} hard - Hard or soft delete
|
|
*
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
delMessages: function(topic, ranges, hard) {
|
|
const pkt = this.initPacket('del', topic);
|
|
|
|
pkt.del.what = 'msg';
|
|
pkt.del.delseq = ranges;
|
|
pkt.del.hard = hard;
|
|
|
|
return this.send(pkt, pkt.del.id);
|
|
},
|
|
|
|
/**
|
|
* Delete the topic alltogether. Requires Owner permission.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topicName - Name of the topic to delete
|
|
* @param {boolean} hard - hard-delete topic.
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
delTopic: function(topicName, hard) {
|
|
const pkt = this.initPacket('del', topicName);
|
|
pkt.del.what = 'topic';
|
|
pkt.del.hard = hard;
|
|
|
|
return this.send(pkt, pkt.del.id).then((ctrl) => {
|
|
this._db.remTopic(topicName);
|
|
this.cacheDel('topic', topicName);
|
|
return this.ctrl;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Delete subscription. Requires Share permission.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topicName - Name of the topic to delete
|
|
* @param {string} user - User ID to remove.
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
delSubscription: function(topicName, user) {
|
|
const pkt = this.initPacket('del', topicName);
|
|
pkt.del.what = 'sub';
|
|
pkt.del.user = user;
|
|
|
|
return this.send(pkt, pkt.del.id);
|
|
},
|
|
|
|
/**
|
|
* Delete credential. Always sent on <code>'me'</code> topic.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} method - validation method such as <code>'email'</code> or <code>'tel'</code>.
|
|
* @param {string} value - validation value, i.e. <code>'alice@example.com'</code>.
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
delCredential: function(method, value) {
|
|
const pkt = this.initPacket('del', TOPIC_ME);
|
|
pkt.del.what = 'cred';
|
|
pkt.del.cred = {
|
|
meth: method,
|
|
val: value
|
|
};
|
|
|
|
return this.send(pkt, pkt.del.id);
|
|
},
|
|
|
|
/**
|
|
* Request to delete account of the current user.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {boolean} hard - hard-delete user.
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
delCurrentUser: function(hard) {
|
|
const pkt = this.initPacket('del', null);
|
|
pkt.del.what = 'user';
|
|
pkt.del.hard = hard;
|
|
|
|
return this.send(pkt, pkt.del.id).then((ctrl) => {
|
|
this._myUID = null;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Notify server that a message or messages were read or received. Does NOT return promise.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topicName - Name of the topic where the mesage is being aknowledged.
|
|
* @param {string} what - Action being aknowledged, either <code>"read"</code> or <code>"recv"</code>.
|
|
* @param {number} seq - Maximum id of the message being acknowledged.
|
|
*/
|
|
note: function(topicName, what, seq) {
|
|
if (seq <= 0 || seq >= LOCAL_SEQID) {
|
|
throw new Error(`Invalid message id ${seq}`);
|
|
}
|
|
|
|
const pkt = this.initPacket('note', topicName);
|
|
pkt.note.what = what;
|
|
pkt.note.seq = seq;
|
|
this.send(pkt);
|
|
},
|
|
|
|
/**
|
|
* Broadcast a key-press notification to topic subscribers. Used to show
|
|
* typing notifications "user X is typing...".
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topicName - Name of the topic to broadcast to.
|
|
*/
|
|
noteKeyPress: function(topicName) {
|
|
const pkt = this.initPacket('note', topicName);
|
|
pkt.note.what = 'kp';
|
|
this.send(pkt);
|
|
},
|
|
|
|
/**
|
|
* Get a named topic, either pull it from cache or create a new instance.
|
|
* There is a single instance of topic for each name.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topicName - Name of the topic to get.
|
|
* @returns {Tinode.Topic} Requested or newly created topic or <code>undefined</code> if topic name is invalid.
|
|
*/
|
|
getTopic: function(topicName) {
|
|
let topic = this.cacheGet('topic', topicName);
|
|
if (!topic && topicName) {
|
|
if (topicName == TOPIC_ME) {
|
|
topic = new TopicMe();
|
|
} else if (topicName == TOPIC_FND) {
|
|
topic = new TopicFnd();
|
|
} else {
|
|
topic = new Topic(topicName);
|
|
}
|
|
// Cache management.
|
|
this._db.addTopic(topic);
|
|
this.attachCacheToTopic(topic);
|
|
topic._cachePutSelf();
|
|
}
|
|
return topic;
|
|
},
|
|
|
|
/**
|
|
* Check if named topic is already present in cache.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} topicName - Name of the topic to check.
|
|
* @returns {boolean} true if topic is found in cache, false oterwise.
|
|
*/
|
|
isTopicCached: function(topicName) {
|
|
return !!this.cacheGet('topic', topicName);
|
|
},
|
|
|
|
/**
|
|
* Generate unique name like <code>'new123456'</code> suitable for creating a new group topic.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {boolean} isChan - if the topic is channel-enabled.
|
|
* @returns {string} name which can be used for creating a new group topic.
|
|
*/
|
|
newGroupTopicName: function(isChan) {
|
|
return (isChan ? TOPIC_NEW_CHAN : TOPIC_NEW) + this.getNextUniqueId();
|
|
},
|
|
|
|
/**
|
|
* Instantiate <code>'me'</code> topic or get it from cache.
|
|
* @memberof Tinode#
|
|
*
|
|
* @returns {Tinode.TopicMe} Instance of <code>'me'</code> topic.
|
|
*/
|
|
getMeTopic: function() {
|
|
return this.getTopic(TOPIC_ME);
|
|
},
|
|
|
|
/**
|
|
* Instantiate <code>'fnd'</code> (find) topic or get it from cache.
|
|
* @memberof Tinode#
|
|
*
|
|
* @returns {Tinode.Topic} Instance of <code>'fnd'</code> topic.
|
|
*/
|
|
getFndTopic: function() {
|
|
return this.getTopic(TOPIC_FND);
|
|
},
|
|
|
|
/**
|
|
* Create a new {@link LargeFileHelper} instance
|
|
* @memberof Tinode#
|
|
*
|
|
* @returns {Tinode.LargeFileHelper} instance of a {@link Tinode.LargeFileHelper}.
|
|
*/
|
|
getLargeFileHelper: function() {
|
|
return new LargeFileHelper(this);
|
|
},
|
|
|
|
/**
|
|
* Get the UID of the the current authenticated user.
|
|
* @memberof Tinode#
|
|
* @returns {string} UID of the current user or <code>undefined</code> if the session is not yet authenticated or if there is no session.
|
|
*/
|
|
getCurrentUserID: function() {
|
|
return this._myUID;
|
|
},
|
|
|
|
/**
|
|
* Check if the given user ID is equal to the current user's UID.
|
|
* @memberof Tinode#
|
|
* @param {string} uid - UID to check.
|
|
* @returns {boolean} true if the given UID belongs to the current logged in user.
|
|
*/
|
|
isMe: function(uid) {
|
|
return this._myUID === uid;
|
|
},
|
|
|
|
/**
|
|
* Get login used for last successful authentication.
|
|
* @memberof Tinode#
|
|
* @returns {string} login last used successfully or <code>undefined</code>.
|
|
*/
|
|
getCurrentLogin: function() {
|
|
return this._login;
|
|
},
|
|
|
|
/**
|
|
* Return information about the server: protocol version and build timestamp.
|
|
* @memberof Tinode#
|
|
* @returns {Object} build and version of the server or <code>null</code> if there is no connection or if the first server response has not been received yet.
|
|
*/
|
|
getServerInfo: function() {
|
|
return this._serverInfo;
|
|
},
|
|
|
|
/**
|
|
* Return server-provided configuration value (long integer).
|
|
* @memberof Tinode#
|
|
* @param {string} name of the value to return
|
|
* @param {Object} defaultValue to return in case server limit is not set or not found.
|
|
* @returns {number} named value.
|
|
*/
|
|
getServerLimit: function(name, defaultValue) {
|
|
return (this._serverInfo ? this._serverInfo[name] : null) || defaultValue;
|
|
},
|
|
|
|
/**
|
|
* Toggle console logging. Logging is off by default.
|
|
* @memberof Tinode#
|
|
* @param {boolean} enabled - Set to <code>true</code> to enable logging to console.
|
|
* @param {boolean} trimLongStrings - Set to <code>true</code> to trim long strings.
|
|
*/
|
|
enableLogging: function(enabled, trimLongStrings) {
|
|
this._loggingEnabled = enabled;
|
|
this._trimLongStrings = enabled && trimLongStrings;
|
|
},
|
|
|
|
/**
|
|
* Set UI language to report to the server. Must be called before <code>'hi'</code> is sent, otherwise it will not be used.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} hl - human (UI) language, like <code>"en_US"</code> or <code>"zh-Hans"</code>.
|
|
*/
|
|
setHumanLanguage: function(hl) {
|
|
if (hl) {
|
|
this._humanLanguage = hl;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Check if given topic is online.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} name of the topic to test.
|
|
* @returns {boolean} true if topic is online, false otherwise.
|
|
*/
|
|
isTopicOnline: function(name) {
|
|
const topic = this.cacheGet('topic', name);
|
|
return topic && topic.online;
|
|
},
|
|
|
|
/**
|
|
* Get access mode for the given contact.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {string} name of the topic to query.
|
|
* @returns {AccessMode} access mode if topic is found, null otherwise.
|
|
*/
|
|
getTopicAccessMode: function(name) {
|
|
const topic = this.cacheGet('topic', name);
|
|
return topic ? topic.acs : null;
|
|
},
|
|
|
|
/**
|
|
* Include message ID into all subsequest messages to server instructin it to send aknowledgemens.
|
|
* Required for promises to function. Default is <code>"on"</code>.
|
|
* @memberof Tinode#
|
|
*
|
|
* @param {boolean} status - Turn aknowledgemens on or off.
|
|
* @deprecated
|
|
*/
|
|
wantAkn: function(status) {
|
|
if (status) {
|
|
this._messageId = Math.floor((Math.random() * 0xFFFFFF) + 0xFFFFFF);
|
|
} else {
|
|
this._messageId = 0;
|
|
}
|
|
},
|
|
|
|
// Callbacks:
|
|
/**
|
|
* Callback to report when the websocket is opened. The callback has no parameters.
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onWebsocketOpen}
|
|
*/
|
|
onWebsocketOpen: undefined,
|
|
|
|
/**
|
|
* @typedef Tinode.ServerParams
|
|
* @memberof Tinode
|
|
* @type {Object}
|
|
* @property {string} ver - Server version
|
|
* @property {string} build - Server build
|
|
* @property {string=} sid - Session ID, long polling connections only.
|
|
*/
|
|
|
|
/**
|
|
* @callback Tinode.onConnect
|
|
* @param {number} code - Result code
|
|
* @param {string} text - Text epxplaining the completion, i.e "OK" or an error message.
|
|
* @param {Tinode.ServerParams} params - Parameters returned by the server.
|
|
*/
|
|
/**
|
|
* Callback to report when connection with Tinode server is established.
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onConnect}
|
|
*/
|
|
onConnect: undefined,
|
|
|
|
/**
|
|
* Callback to report when connection is lost. The callback has no parameters.
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onDisconnect}
|
|
*/
|
|
onDisconnect: undefined,
|
|
|
|
/**
|
|
* @callback Tinode.onLogin
|
|
* @param {number} code - NUmeric completion code, same as HTTP status codes.
|
|
* @param {string} text - Explanation of the completion code.
|
|
*/
|
|
/**
|
|
* Callback to report login completion.
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onLogin}
|
|
*/
|
|
onLogin: undefined,
|
|
|
|
/**
|
|
* Callback to receive <code>{ctrl}</code> (control) messages.
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onCtrlMessage}
|
|
*/
|
|
onCtrlMessage: undefined,
|
|
|
|
/**
|
|
* Callback to recieve <code>{data}</code> (content) messages.
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onDataMessage}
|
|
*/
|
|
onDataMessage: undefined,
|
|
|
|
/**
|
|
* Callback to receive <code>{pres}</code> (presence) messages.
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onPresMessage}
|
|
*/
|
|
onPresMessage: undefined,
|
|
|
|
/**
|
|
* Callback to receive all messages as objects.
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onMessage}
|
|
*/
|
|
onMessage: undefined,
|
|
|
|
/**
|
|
* Callback to receive all messages as unparsed text.
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onRawMessage}
|
|
*/
|
|
onRawMessage: undefined,
|
|
|
|
/**
|
|
* Callback to receive server responses to network probes. See {@link Tinode#networkProbe}
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onNetworkProbe}
|
|
*/
|
|
onNetworkProbe: undefined,
|
|
|
|
/**
|
|
* Callback to be notified when exponential backoff is iterating.
|
|
* @memberof Tinode#
|
|
* @type {Tinode.onAutoreconnectIteration}
|
|
*/
|
|
onAutoreconnectIteration: undefined,
|
|
};
|
|
|
|
/**
|
|
* 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;
|
|
this.what = {};
|
|
}
|
|
|
|
MetaGetBuilder.prototype = {
|
|
|
|
// Get timestamp of the most recent desc update.
|
|
_get_desc_ims: function() {
|
|
const tupd = this.topic._lastDescUpdate || 0;
|
|
return this.topic.updated > tupd ? this.topic.updated : tupd;
|
|
},
|
|
|
|
// Get timestamp of the most recent subs update.
|
|
_get_subs_ims: function() {
|
|
if (this.topic.isP2PType()) {
|
|
return this._get_desc_ims();
|
|
}
|
|
if (this.topic.isMeType()) {
|
|
const gupd = this.topic._tinode._lastTopicUpdate || 0;
|
|
if (gupd > this.topic._lastSubsUpdate) {
|
|
return gupd;
|
|
}
|
|
}
|
|
return this.topic._lastSubsUpdate;
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch messages within explicit limits.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @param {number=} since - messages newer than this (inclusive);
|
|
* @param {number=} before - older than this (exclusive)
|
|
* @param {number=} limit - number of messages to fetch
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withData: function(since, before, limit) {
|
|
this.what['data'] = {
|
|
since: since,
|
|
before: before,
|
|
limit: limit
|
|
};
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch messages newer than the latest saved message.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @param {number=} limit - number of messages to fetch
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withLaterData: function(limit) {
|
|
return this.withData(this.topic._maxSeq > 0 ? this.topic._maxSeq + 1 : undefined, undefined, limit);
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch messages older than the earliest saved message.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @param {number=} limit - maximum number of messages to fetch.
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withEarlierData: function(limit) {
|
|
return this.withData(undefined, this.topic._minSeq > 0 ? this.topic._minSeq : undefined, limit);
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch topic description if it's newer than the given timestamp.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @param {Date=} ims - fetch messages newer than this timestamp.
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withDesc: function(ims) {
|
|
this.what['desc'] = {
|
|
ims: ims
|
|
};
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch topic description if it's newer than the last update.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withLaterDesc: function() {
|
|
return this.withDesc(this._get_desc_ims());
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch subscriptions.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @param {Date=} ims - fetch subscriptions modified more recently than this timestamp
|
|
* @param {number=} limit - maximum number of subscriptions to fetch.
|
|
* @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withSub: function(ims, limit, userOrTopic) {
|
|
const opts = {
|
|
ims: ims,
|
|
limit: limit
|
|
};
|
|
if (this.topic.getType() == 'me') {
|
|
opts.topic = userOrTopic;
|
|
} else {
|
|
opts.user = userOrTopic;
|
|
}
|
|
this.what['sub'] = opts;
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch a single subscription.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @param {Date=} ims - fetch subscriptions modified more recently than this timestamp
|
|
* @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withOneSub: function(ims, userOrTopic) {
|
|
return this.withSub(ims, undefined, userOrTopic);
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch a single subscription if it's been updated since the last update.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withLaterOneSub: function(userOrTopic) {
|
|
return this.withOneSub(this.topic._lastSubsUpdate, userOrTopic);
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch subscriptions updated since the last update.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @param {number=} limit - maximum number of subscriptions to fetch.
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withLaterSub: function(limit) {
|
|
return this.withSub(this._get_subs_ims(), limit);
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch topic tags.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withTags: function() {
|
|
this.what['tags'] = true;
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch user's credentials. <code>'me'</code> topic only.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withCred: function() {
|
|
if (this.topic.getType() == 'me') {
|
|
this.what['cred'] = true;
|
|
} else {
|
|
this.topic._tinode.logger("ERROR: Invalid topic type for MetaGetBuilder:withCreds", this.topic.getType());
|
|
}
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch deleted messages within explicit limits. Any/all parameters can be null.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @param {number=} since - ids of messages deleted since this 'del' id (inclusive)
|
|
* @param {number=} limit - number of deleted message ids to fetch
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withDel: function(since, limit) {
|
|
if (since || limit) {
|
|
this.what['del'] = {
|
|
since: since,
|
|
limit: limit
|
|
};
|
|
}
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Add query parameters to fetch messages deleted after the saved <code>'del'</code> id.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @param {number=} limit - number of deleted message ids to fetch
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} <code>this</code> object.
|
|
*/
|
|
withLaterDel: function(limit) {
|
|
// Specify 'since' only if we have already received some messages. If
|
|
// we have no locally cached messages then we don't care if any messages were deleted.
|
|
return this.withDel(this.topic._maxSeq > 0 ? this.topic._maxDel + 1 : undefined, limit);
|
|
},
|
|
|
|
/**
|
|
* Construct parameters.
|
|
* @memberof Tinode.MetaGetBuilder#
|
|
*
|
|
* @returns {Tinode.GetQuery} Get query
|
|
*/
|
|
build: function() {
|
|
const what = [];
|
|
const instance = this;
|
|
let params = {};
|
|
['data', 'sub', 'desc', 'tags', 'cred', 'del'].map(function(key) {
|
|
if (instance.what.hasOwnProperty(key)) {
|
|
what.push(key);
|
|
if (Object.getOwnPropertyNames(instance.what[key]).length > 0) {
|
|
params[key] = instance.what[key];
|
|
}
|
|
}
|
|
});
|
|
if (what.length > 0) {
|
|
params.what = what.join(' ');
|
|
} else {
|
|
params = undefined;
|
|
}
|
|
return params;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 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 <code>'+'</code> or <code>'-'</code> then the bits to add or remove, e.g. <code>'+R-W'</code> or <code>'-PS'</code>.
|
|
* - a new value of access mode
|
|
*
|
|
* @memberof Tinode.AccessMode
|
|
* @static
|
|
*
|
|
* @param {number} val - access mode value to update.
|
|
* @param {string} upd - update to apply to val.
|
|
* @returns {number} - updated access mode.
|
|
*/
|
|
AccessMode.update = function(val, upd) {
|
|
if (!upd || typeof upd != 'string') {
|
|
return val;
|
|
}
|
|
|
|
let action = upd.charAt(0);
|
|
if (action == '+' || action == '-') {
|
|
let val0 = val;
|
|
// Split delta-string like '+ABC-DEF+Z' into an array of parts including + and -.
|
|
const parts = upd.split(/([-+])/);
|
|
// Starting iteration from 1 because String.split() creates an array with the first empty element.
|
|
// Iterating by 2 because we parse pairs +/- then data.
|
|
for (let i = 1; i < parts.length - 1; i += 2) {
|
|
action = parts[i];
|
|
const m0 = AccessMode.decode(parts[i + 1]);
|
|
if (m0 == AccessMode._INVALID) {
|
|
return val;
|
|
}
|
|
if (m0 == null) {
|
|
continue;
|
|
}
|
|
if (action === '+') {
|
|
val0 |= m0;
|
|
} else if (action === '-') {
|
|
val0 &= ~m0;
|
|
}
|
|
}
|
|
val = val0;
|
|
} else {
|
|
// The string is an explicit new value 'ABC' rather than delta.
|
|
const val0 = AccessMode.decode(upd);
|
|
if (val0 != AccessMode._INVALID) {
|
|
val = val0;
|
|
}
|
|
}
|
|
|
|
return val;
|
|
};
|
|
|
|
/**
|
|
* Bits present in a1 but missing in a2.
|
|
*
|
|
* @static
|
|
* @memberof Tinode
|
|
*
|
|
* @param {number | string} a1 - access mode to subtract from.
|
|
* @param {number | string} a2 - access mode to subtract.
|
|
* @returns {number} access mode with bits present in <code>a1</code> but missing in <code>a2</code>.
|
|
*/
|
|
AccessMode.diff = function(a1, a2) {
|
|
a1 = AccessMode.decode(a1);
|
|
a2 = AccessMode.decode(a2);
|
|
|
|
if (a1 == AccessMode._INVALID || a2 == AccessMode._INVALID) {
|
|
return AccessMode._INVALID;
|
|
}
|
|
return a1 & ~a2;
|
|
};
|
|
|
|
/**
|
|
* AccessMode is a class representing topic access mode.
|
|
*
|
|
* @memberof Tinode
|
|
* @class AccessMode
|
|
*/
|
|
AccessMode.prototype = {
|
|
/**
|
|
* Custom formatter
|
|
*/
|
|
toString: function() {
|
|
return '{"mode": "' + AccessMode.encode(this.mode) +
|
|
'", "given": "' + AccessMode.encode(this.given) +
|
|
'", "want": "' + AccessMode.encode(this.want) + '"}';
|
|
},
|
|
/**
|
|
* Converts numeric values to strings.
|
|
*/
|
|
jsonHelper: function() {
|
|
return {
|
|
mode: AccessMode.encode(this.mode),
|
|
given: AccessMode.encode(this.given),
|
|
want: AccessMode.encode(this.want)
|
|
};
|
|
},
|
|
/**
|
|
* Assign value to 'mode'.
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @param {string | Number} m - either a string representation of the access mode or a set of bits.
|
|
* @returns {AccessMode} - <code>this</code> AccessMode.
|
|
*/
|
|
setMode: function(m) {
|
|
this.mode = AccessMode.decode(m);
|
|
return this;
|
|
},
|
|
/**
|
|
* Update <code>mode</code> value.
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @param {string} u - string representation of the changes to apply to access mode.
|
|
* @returns {AccessMode} - <code>this</code> AccessMode.
|
|
*/
|
|
updateMode: function(u) {
|
|
this.mode = AccessMode.update(this.mode, u);
|
|
return this;
|
|
},
|
|
/**
|
|
* Get <code>mode</code> value as a string.
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @returns {string} - <code>mode</code> value.
|
|
*/
|
|
getMode: function() {
|
|
return AccessMode.encode(this.mode);
|
|
},
|
|
|
|
/**
|
|
* Assign <code>given</code> value.
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @param {string | Number} g - either a string representation of the access mode or a set of bits.
|
|
* @returns {AccessMode} - <code>this</code> AccessMode.
|
|
*/
|
|
setGiven: function(g) {
|
|
this.given = AccessMode.decode(g);
|
|
return this;
|
|
},
|
|
/**
|
|
* Update 'given' value.
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @param {string} u - string representation of the changes to apply to access mode.
|
|
* @returns {AccessMode} - <code>this</code> AccessMode.
|
|
*/
|
|
updateGiven: function(u) {
|
|
this.given = AccessMode.update(this.given, u);
|
|
return this;
|
|
},
|
|
/**
|
|
* Get 'given' value as a string.
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @returns {string} - <b>given</b> value.
|
|
*/
|
|
getGiven: function() {
|
|
return AccessMode.encode(this.given);
|
|
},
|
|
|
|
/**
|
|
* Assign 'want' value.
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @param {string | Number} w - either a string representation of the access mode or a set of bits.
|
|
* @returns {AccessMode} - <code>this</code> AccessMode.
|
|
*/
|
|
setWant: function(w) {
|
|
this.want = AccessMode.decode(w);
|
|
return this;
|
|
},
|
|
/**
|
|
* Update 'want' value.
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @param {string} u - string representation of the changes to apply to access mode.
|
|
* @returns {AccessMode} - <code>this</code> AccessMode.
|
|
*/
|
|
updateWant: function(u) {
|
|
this.want = AccessMode.update(this.want, u);
|
|
return this;
|
|
},
|
|
/**
|
|
* Get 'want' value as a string.
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @returns {string} - <b>want</b> value.
|
|
*/
|
|
getWant: function() {
|
|
return AccessMode.encode(this.want);
|
|
},
|
|
|
|
/**
|
|
* Get permissions present in 'want' but missing in 'given'.
|
|
* Inverse of {@link Tinode.AccessMode#getExcessive}
|
|
*
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @returns {string} permissions present in <b>want</b> but missing in <b>given</b>.
|
|
*/
|
|
getMissing: function() {
|
|
return AccessMode.encode(this.want & ~this.given);
|
|
},
|
|
|
|
/**
|
|
* Get permissions present in 'given' but missing in 'want'.
|
|
* Inverse of {@link Tinode.AccessMode#getMissing}
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @returns {string} permissions present in <b>given</b> but missing in <b>want</b>.
|
|
*/
|
|
getExcessive: function() {
|
|
return AccessMode.encode(this.given & ~this.want);
|
|
},
|
|
|
|
/**
|
|
* Update 'want', 'give', and 'mode' values.
|
|
* @memberof Tinode.AccessMode
|
|
*
|
|
* @param {AccessMode} val - new access mode value.
|
|
* @returns {AccessMode} - <code>this</code> AccessMode.
|
|
*/
|
|
updateAll: function(val) {
|
|
if (val) {
|
|
this.updateGiven(val.given);
|
|
this.updateWant(val.want);
|
|
this.mode = this.given & this.want;
|
|
}
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Check if Owner (O) flag is set.
|
|
* @memberof Tinode.AccessMode
|
|
* @param {string=} side - which permission to check: given, want, mode; default: mode.
|
|
* @returns {boolean} - <code>true</code> if flag is set.
|
|
*/
|
|
isOwner: function(side) {
|
|
return AccessMode._checkFlag(this, side, AccessMode._OWNER);
|
|
},
|
|
|
|
/**
|
|
* Check if Presence (P) flag is set.
|
|
* @memberof Tinode.AccessMode
|
|
* @param {string=} side - which permission to check: given, want, mode; default: mode.
|
|
* @returns {boolean} - <code>true</code> if flag is set.
|
|
*/
|
|
isPresencer: function(side) {
|
|
return AccessMode._checkFlag(this, side, AccessMode._PRES);
|
|
},
|
|
|
|
/**
|
|
* Check if Presence (P) flag is NOT set.
|
|
* @memberof Tinode.AccessMode
|
|
* @param {string=} side - which permission to check: given, want, mode; default: mode.
|
|
* @returns {boolean} - <code>true</code> if flag is set.
|
|
*/
|
|
isMuted: function(side) {
|
|
return !this.isPresencer(side);
|
|
},
|
|
|
|
/**
|
|
* Check if Join (J) flag is set.
|
|
* @memberof Tinode.AccessMode
|
|
* @param {string=} side - which permission to check: given, want, mode; default: mode.
|
|
* @returns {boolean} - <code>true</code> if flag is set.
|
|
*/
|
|
isJoiner: function(side) {
|
|
return AccessMode._checkFlag(this, side, AccessMode._JOIN);
|
|
},
|
|
|
|
/**
|
|
* Check if Reader (R) flag is set.
|
|
* @memberof Tinode.AccessMode
|
|
* @param {string=} side - which permission to check: given, want, mode; default: mode.
|
|
* @returns {boolean} - <code>true</code> if flag is set.
|
|
*/
|
|
isReader: function(side) {
|
|
return AccessMode._checkFlag(this, side, AccessMode._READ);
|
|
},
|
|
|
|
/**
|
|
* Check if Writer (W) flag is set.
|
|
* @memberof Tinode.AccessMode
|
|
* @param {string=} side - which permission to check: given, want, mode; default: mode.
|
|
* @returns {boolean} - <code>true</code> if flag is set.
|
|
*/
|
|
isWriter: function(side) {
|
|
return AccessMode._checkFlag(this, side, AccessMode._WRITE);
|
|
},
|
|
|
|
/**
|
|
* Check if Approver (A) flag is set.
|
|
* @memberof Tinode.AccessMode
|
|
* @param {string=} side - which permission to check: given, want, mode; default: mode.
|
|
* @returns {boolean} - <code>true</code> if flag is set.
|
|
*/
|
|
isApprover: function(side) {
|
|
return AccessMode._checkFlag(this, side, AccessMode._APPROVE);
|
|
},
|
|
|
|
/**
|
|
* Check if either one of Owner (O) or Approver (A) flags is set.
|
|
* @memberof Tinode.AccessMode
|
|
* @param {string=} side - which permission to check: given, want, mode; default: mode.
|
|
* @returns {boolean} - <code>true</code> if flag is set.
|
|
*/
|
|
isAdmin: function(side) {
|
|
return this.isOwner(side) || this.isApprover(side);
|
|
},
|
|
|
|
/**
|
|
* Check if either one of Owner (O), Approver (A), or Sharer (S) flags is set.
|
|
* @memberof Tinode.AccessMode
|
|
* @param {string=} side - which permission to check: given, want, mode; default: mode.
|
|
* @returns {boolean} - <code>true</code> if flag is set.
|
|
*/
|
|
isSharer: function(side) {
|
|
return this.isAdmin(side) || AccessMode._checkFlag(this, side, AccessMode._SHARE);
|
|
},
|
|
|
|
/**
|
|
* Check if Deleter (D) flag is set.
|
|
* @memberof Tinode.AccessMode
|
|
* @param {string=} side - which permission to check: given, want, mode; default: mode.
|
|
* @returns {boolean} - <code>true</code> if flag is set.
|
|
*/
|
|
isDeleter: function(side) {
|
|
return AccessMode._checkFlag(this, side, AccessMode._DELETE);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @callback Tinode.Topic.onData
|
|
* @param {Data} data - Data packet
|
|
*/
|
|
/**
|
|
* Topic is a class representing a logical communication channel.
|
|
* @class Topic
|
|
* @memberof Tinode
|
|
*
|
|
* @param {string} name - Name of the topic to create.
|
|
* @param {Object=} callbacks - Object with various event callbacks.
|
|
* @param {Tinode.Topic.onData} callbacks.onData - Callback which receives a <code>{data}</code> message.
|
|
* @param {callback} callbacks.onMeta - Callback which receives a <code>{meta}</code> message.
|
|
* @param {callback} callbacks.onPres - Callback which receives a <code>{pres}</code> message.
|
|
* @param {callback} callbacks.onInfo - Callback which receives an <code>{info}</code> message.
|
|
* @param {callback} callbacks.onMetaDesc - Callback which receives changes to topic desctioption {@link desc}.
|
|
* @param {callback} callbacks.onMetaSub - Called for a single subscription record change.
|
|
* @param {callback} callbacks.onSubsUpdated - Called after a batch of subscription changes have been recieved and cached.
|
|
* @param {callback} callbacks.onDeleteTopic - Called after the topic is deleted.
|
|
* @param {callback} callbacls.onAllMessagesReceived - Called when all requested <code>{data}</code> messages have been recived.
|
|
*/
|
|
var Topic = function(name, callbacks) {
|
|
// Parent Tinode object.
|
|
this._tinode = null;
|
|
|
|
// Server-provided data, locally immutable.
|
|
// topic name
|
|
this.name = name;
|
|
// timestamp when the topic was created
|
|
this.created = null;
|
|
// timestamp when the topic was last updated
|
|
this.updated = null;
|
|
// timestamp of the last messages
|
|
this.touched = null;
|
|
// access mode, see AccessMode
|
|
this.acs = new AccessMode(null);
|
|
// per-topic private data
|
|
this.private = null;
|
|
// per-topic public data
|
|
this.public = null;
|
|
|
|
// Locally cached data
|
|
// Subscribed users, for tracking read/recv/msg notifications.
|
|
this._users = {};
|
|
|
|
// Current value of locally issued seqId, used for pending messages.
|
|
this._queuedSeqId = LOCAL_SEQID;
|
|
|
|
// The maximum known {data.seq} value.
|
|
this._maxSeq = 0;
|
|
// The minimum known {data.seq} value.
|
|
this._minSeq = 0;
|
|
// Indicator that the last request for earlier messages returned 0.
|
|
this._noEarlierMsgs = false;
|
|
// The maximum known deletion ID.
|
|
this._maxDel = 0;
|
|
// User discovery tags
|
|
this._tags = [];
|
|
// Credentials such as email or phone number.
|
|
this._credentials = [];
|
|
// Message cache, sorted by message seq values, from old to new.
|
|
this._messages = CBuffer(function(a, b) {
|
|
return a.seq - b.seq;
|
|
}, true);
|
|
// Boolean, true if the topic is currently live
|
|
this._subscribed = false;
|
|
// Timestap when topic meta-desc update was recived.
|
|
this._lastDescUpdate = null;
|
|
// Timestap when topic meta-subs update was recived.
|
|
this._lastSubsUpdate = null;
|
|
// Topic created but not yet synced with the server. Used only during initialization.
|
|
this._new = true;
|
|
|
|
// Callbacks
|
|
if (callbacks) {
|
|
this.onData = callbacks.onData;
|
|
this.onMeta = callbacks.onMeta;
|
|
this.onPres = callbacks.onPres;
|
|
this.onInfo = callbacks.onInfo;
|
|
// A single desc update;
|
|
this.onMetaDesc = callbacks.onMetaDesc;
|
|
// A single subscription record;
|
|
this.onMetaSub = callbacks.onMetaSub;
|
|
// All subscription records received;
|
|
this.onSubsUpdated = callbacks.onSubsUpdated;
|
|
this.onTagsUpdated = callbacks.onTagsUpdated;
|
|
this.onCredsUpdated = callbacks.onCredsUpdated;
|
|
this.onDeleteTopic = callbacks.onDeleteTopic;
|
|
this.onAllMessagesReceived = callbacks.onAllMessagesReceived;
|
|
}
|
|
};
|
|
|
|
Topic.prototype = {
|
|
/**
|
|
* Check if the topic is subscribed.
|
|
* @memberof Tinode.Topic#
|
|
* @returns {boolean} True is topic is attached/subscribed, false otherwise.
|
|
*/
|
|
isSubscribed: function() {
|
|
return this._subscribed;
|
|
},
|
|
|
|
/**
|
|
* Request topic to subscribe. Wrapper for {@link Tinode#subscribe}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {Tinode.GetQuery=} getParams - get query parameters.
|
|
* @param {Tinode.SetParams=} setParams - set parameters.
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
|
|
*/
|
|
subscribe: function(getParams, setParams) {
|
|
// If the topic is already subscribed, return resolved promise
|
|
if (this._subscribed) {
|
|
return Promise.resolve(this);
|
|
}
|
|
|
|
// Send subscribe message, handle async response.
|
|
// If topic name is explicitly provided, use it. If no name, then it's a new group topic,
|
|
// use "new".
|
|
return this._tinode.subscribe(this.name || TOPIC_NEW, getParams, setParams).then((ctrl) => {
|
|
if (ctrl.code >= 300) {
|
|
// Do nothing if subscription status has not changed.
|
|
return ctrl;
|
|
}
|
|
|
|
this._subscribed = true;
|
|
this.acs = (ctrl.params && ctrl.params.acs) ? ctrl.params.acs : this.acs;
|
|
|
|
// Set topic name for new topics and add it to cache.
|
|
if (this._new) {
|
|
this._new = false;
|
|
|
|
// 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.onMetaSub) {
|
|
me.onMetaSub(this);
|
|
}
|
|
if (me.onSubsUpdated) {
|
|
me.onSubsUpdated([this.name], 1);
|
|
}
|
|
}
|
|
|
|
if (setParams && setParams.desc) {
|
|
setParams.desc._noForwarding = true;
|
|
this._processMetaDesc(setParams.desc);
|
|
}
|
|
}
|
|
|
|
return ctrl;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Create a draft of a message without sending it to the server.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {string | Object} data - Content to wrap in a draft.
|
|
* @param {boolean=} noEcho - If <code>true</code> server will not echo message back to originating
|
|
* session. Otherwise the server will send a copy of the message to sender.
|
|
*
|
|
* @returns {Object} message draft.
|
|
*/
|
|
createMessage: function(data, noEcho) {
|
|
return this._tinode.createMessage(this.name, data, noEcho);
|
|
},
|
|
|
|
/**
|
|
* Immediately publish data to topic. Wrapper for {@link Tinode#publish}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {string | Object} data - Data to publish, either plain string or a Drafty object.
|
|
* @param {boolean=} noEcho - If <code>true</code> server will not echo message back to originating
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
|
|
*/
|
|
publish: function(data, noEcho) {
|
|
return this.publishMessage(this.createMessage(data, noEcho));
|
|
},
|
|
|
|
/**
|
|
* Publish message created by {@link Tinode.Topic#createMessage}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {Object} pub - {data} object to publish. Must be created by {@link Tinode.Topic#createMessage}
|
|
*
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
|
|
*/
|
|
publishMessage: function(pub) {
|
|
if (!this._subscribed) {
|
|
return Promise.reject(new Error("Cannot publish on inactive topic"));
|
|
}
|
|
|
|
// Update header with attachment records.
|
|
if (Drafty.hasAttachments(pub.content) && !pub.head.attachments) {
|
|
let attachments = [];
|
|
Drafty.attachments(pub.content, (data) => {
|
|
attachments.push(data.ref);
|
|
});
|
|
pub.head.attachments = attachments;
|
|
}
|
|
|
|
// Send data.
|
|
pub._sending = true;
|
|
pub._failed = false;
|
|
return this._tinode.publishMessage(pub).then((ctrl) => {
|
|
pub._sending = false;
|
|
pub.ts = ctrl.ts;
|
|
this.swapMessageId(pub, ctrl.params.seq);
|
|
this._routeData(pub);
|
|
return ctrl;
|
|
}).catch((err) => {
|
|
this._tinode.logger("WARNING: Message rejected by the server", err);
|
|
pub._sending = false;
|
|
pub._failed = true;
|
|
if (this.onData) {
|
|
this.onData();
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Add message to local message cache, send to the server when the promise is resolved.
|
|
* If promise is null or undefined, the message will be sent immediately.
|
|
* The message is sent when the
|
|
* The message should be created by {@link Tinode.Topic#createMessage}.
|
|
* This is probably not the final API.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {Object} pub - Message to use as a draft.
|
|
* @param {Promise} prom - Message will be sent when this promise is resolved, discarded if rejected.
|
|
*
|
|
* @returns {Promise} derived promise.
|
|
*/
|
|
publishDraft: function(pub, prom) {
|
|
if (!prom && !this._subscribed) {
|
|
return Promise.reject(new Error("Cannot publish on inactive topic"));
|
|
}
|
|
|
|
const seq = pub.seq || this._getQueuedSeqId();
|
|
if (!pub._noForwarding) {
|
|
// The 'seq', 'ts', and 'from' are added to mimic {data}. They are removed later
|
|
// before the message is sent.
|
|
|
|
pub._noForwarding = true;
|
|
pub.seq = seq;
|
|
pub.ts = new Date();
|
|
pub.from = this._tinode.getCurrentUserID();
|
|
|
|
// Don't need an echo message because the message is added to local cache right away.
|
|
pub.noecho = true;
|
|
// Add to cache.
|
|
this._messages.put(pub);
|
|
this._tinode._db.addMessage(this.name, pub);
|
|
|
|
if (this.onData) {
|
|
this.onData(pub);
|
|
}
|
|
}
|
|
// If promise is provided, send the queued message when it's resolved.
|
|
// If no promise is provided, create a resolved one and send immediately.
|
|
prom = (prom || Promise.resolve()).then(
|
|
( /* argument ignored */ ) => {
|
|
if (pub._cancelled) {
|
|
return {
|
|
code: 300,
|
|
text: "cancelled"
|
|
};
|
|
}
|
|
return this.publishMessage(pub);
|
|
},
|
|
(err) => {
|
|
this._tinode.logger("WARNING: Message draft rejected", err);
|
|
pub._sending = false;
|
|
pub._failed = true;
|
|
this._messages.delAt(this._messages.find(pub));
|
|
this._tinode._db.remMessages(this.name, pub.seq);
|
|
if (this.onData) {
|
|
this.onData();
|
|
}
|
|
});
|
|
return prom;
|
|
},
|
|
|
|
/**
|
|
* Leave the topic, optionally unsibscribe. Leaving the topic means the topic will stop
|
|
* receiving updates from the server. Unsubscribing will terminate user's relationship with the topic.
|
|
* Wrapper for {@link Tinode#leave}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {boolean=} unsub - If true, unsubscribe, otherwise just leave.
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
|
|
*/
|
|
leave: function(unsub) {
|
|
// It's possible to unsubscribe (unsub==true) from inactive topic.
|
|
if (!this._subscribed && !unsub) {
|
|
return Promise.reject(new Error("Cannot leave inactive topic"));
|
|
}
|
|
|
|
// Send a 'leave' message, handle async response
|
|
return this._tinode.leave(this.name, unsub).then((ctrl) => {
|
|
this._resetSub();
|
|
if (unsub) {
|
|
this._tinode.cacheDel('topic', this.name);
|
|
this._gone();
|
|
}
|
|
return ctrl;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Request topic metadata from the server.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {Tinode.GetQuery} request parameters
|
|
*
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to request.
|
|
*/
|
|
getMeta: function(params) {
|
|
// Send {get} message, return promise.
|
|
return this._tinode.getMeta(this.name, params);
|
|
},
|
|
|
|
/**
|
|
* Request more messages from the server
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {number} limit number of messages to get.
|
|
* @param {boolean} forward if true, request newer messages.
|
|
*/
|
|
getMessagesPage: function(limit, forward) {
|
|
const query = this.startMetaQuery();
|
|
if (forward) {
|
|
query.withLaterData(limit);
|
|
} else {
|
|
query.withEarlierData(limit);
|
|
}
|
|
let promise = this.getMeta(query.build());
|
|
if (!forward) {
|
|
promise = promise.then((ctrl) => {
|
|
if (ctrl && ctrl.params && !ctrl.params.count) {
|
|
this._noEarlierMsgs = true;
|
|
}
|
|
});
|
|
}
|
|
return promise;
|
|
},
|
|
|
|
/**
|
|
* Update topic metadata.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {Tinode.SetParams} params parameters to update.
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to request.
|
|
*/
|
|
setMeta: function(params) {
|
|
if (params.tags) {
|
|
params.tags = normalizeArray(params.tags);
|
|
}
|
|
// Send Set message, handle async response.
|
|
return this._tinode.setMeta(this.name, params)
|
|
.then((ctrl) => {
|
|
if (ctrl && ctrl.code >= 300) {
|
|
// Not modified
|
|
return ctrl;
|
|
}
|
|
|
|
if (params.sub) {
|
|
params.sub.topic = this.name;
|
|
if (ctrl.params && ctrl.params.acs) {
|
|
params.sub.acs = ctrl.params.acs;
|
|
params.sub.updated = ctrl.ts;
|
|
}
|
|
if (!params.sub.user) {
|
|
// This is a subscription update of the current user.
|
|
// Assign user ID otherwise the update will be ignored by _processMetaSub.
|
|
params.sub.user = this._tinode.getCurrentUserID();
|
|
if (!params.desc) {
|
|
// Force update to topic's asc.
|
|
params.desc = {};
|
|
}
|
|
}
|
|
params.sub._noForwarding = true;
|
|
this._processMetaSub([params.sub]);
|
|
}
|
|
|
|
if (params.desc) {
|
|
if (ctrl.params && ctrl.params.acs) {
|
|
params.desc.acs = ctrl.params.acs;
|
|
params.desc.updated = ctrl.ts;
|
|
}
|
|
this._processMetaDesc(params.desc);
|
|
}
|
|
|
|
if (params.tags) {
|
|
this._processMetaTags(params.tags);
|
|
}
|
|
if (params.cred) {
|
|
this._processMetaCreds([params.cred], true);
|
|
}
|
|
|
|
return ctrl;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Update access mode of the current user or of another topic subsriber.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {string} uid - UID of the user to update or null to update current user.
|
|
* @param {string} update - the update value, full or delta.
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to request.
|
|
*/
|
|
updateMode: function(uid, update) {
|
|
const user = uid ? this.subscriber(uid) : null;
|
|
const am = user ?
|
|
user.acs.updateGiven(update).getGiven() :
|
|
this.getAccessMode().updateWant(update).getWant();
|
|
|
|
return this.setMeta({
|
|
sub: {
|
|
user: uid,
|
|
mode: am
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Create new topic subscription. Wrapper for {@link Tinode#setMeta}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {string} uid - ID of the user to invite
|
|
* @param {string=} mode - Access mode. <code>null</code> means to use default.
|
|
*
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to request.
|
|
*/
|
|
invite: function(uid, mode) {
|
|
return this.setMeta({
|
|
sub: {
|
|
user: uid,
|
|
mode: mode
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Archive or un-archive the topic. Wrapper for {@link Tinode#setMeta}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {boolean} arch - true to archive the topic, false otherwise.
|
|
*
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to request.
|
|
*/
|
|
archive: function(arch) {
|
|
if (this.private && this.private.arch == arch) {
|
|
return Promise.resolve(arch);
|
|
}
|
|
return this.setMeta({
|
|
desc: {
|
|
private: {
|
|
arch: arch ? true : Tinode.DEL_CHAR
|
|
}
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Delete messages. Hard-deleting messages requires Owner permission.
|
|
* Wrapper for {@link Tinode#delMessages}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {Tinode.DelRange[]} ranges - Ranges of message IDs to delete.
|
|
* @param {boolean=} hard - Hard or soft delete
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to request.
|
|
*/
|
|
delMessages: function(ranges, hard) {
|
|
if (!this._subscribed) {
|
|
return Promise.reject(new Error("Cannot delete messages in inactive topic"));
|
|
}
|
|
|
|
// Sort ranges in accending order by low, the descending by hi.
|
|
ranges.sort((r1, r2) => {
|
|
if (r1.low < r2.low) {
|
|
return true;
|
|
}
|
|
if (r1.low == r2.low) {
|
|
return !r2.hi || (r1.hi >= r2.hi);
|
|
}
|
|
return false;
|
|
});
|
|
|
|
// Remove pending messages from ranges possibly clipping some ranges.
|
|
let tosend = ranges.reduce((out, r) => {
|
|
if (r.low < LOCAL_SEQID) {
|
|
if (!r.hi || r.hi < LOCAL_SEQID) {
|
|
out.push(r);
|
|
} else {
|
|
// Clip hi to max allowed value.
|
|
out.push({
|
|
low: r.low,
|
|
hi: this._maxSeq + 1
|
|
});
|
|
}
|
|
}
|
|
return out;
|
|
}, []);
|
|
|
|
// Send {del} message, return promise
|
|
let result;
|
|
if (tosend.length > 0) {
|
|
result = this._tinode.delMessages(this.name, tosend, hard);
|
|
} else {
|
|
result = Promise.resolve({
|
|
params: {
|
|
del: 0
|
|
}
|
|
});
|
|
}
|
|
// Update local cache.
|
|
return result.then((ctrl) => {
|
|
if (ctrl.params.del > this._maxDel) {
|
|
this._maxDel = ctrl.params.del;
|
|
}
|
|
|
|
ranges.map((r) => {
|
|
if (r.hi) {
|
|
this.flushMessageRange(r.low, r.hi);
|
|
} else {
|
|
this.flushMessage(r.low);
|
|
}
|
|
});
|
|
|
|
this._updateDeletedRanges();
|
|
|
|
if (this.onData) {
|
|
// Calling with no parameters to indicate the messages were deleted.
|
|
this.onData();
|
|
}
|
|
return ctrl;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Delete all messages. Hard-deleting messages requires Owner permission.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {boolean} hardDel - true if messages should be hard-deleted.
|
|
*
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to request.
|
|
*/
|
|
delMessagesAll: function(hardDel) {
|
|
if (!this._maxSeq || this._maxSeq <= 0) {
|
|
// There are no messages to delete.
|
|
return Promise.resolve();
|
|
}
|
|
return this.delMessages([{
|
|
low: 1,
|
|
hi: this._maxSeq + 1,
|
|
_all: true
|
|
}], hardDel);
|
|
},
|
|
|
|
/**
|
|
* Delete multiple messages defined by their IDs. Hard-deleting messages requires Owner permission.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {Tinode.DelRange[]} list - list of seq IDs to delete
|
|
* @param {boolean=} hardDel - true if messages should be hard-deleted.
|
|
*
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to request.
|
|
*/
|
|
delMessagesList: function(list, hardDel) {
|
|
// Sort the list in ascending order
|
|
list.sort((a, b) => a - b);
|
|
// Convert the array of IDs to ranges.
|
|
let ranges = list.reduce((out, id) => {
|
|
if (out.length == 0) {
|
|
// First element.
|
|
out.push({
|
|
low: id
|
|
});
|
|
} else {
|
|
let prev = out[out.length - 1];
|
|
if ((!prev.hi && (id != prev.low + 1)) || (id > prev.hi)) {
|
|
// New range.
|
|
out.push({
|
|
low: id
|
|
});
|
|
} else {
|
|
// Expand existing range.
|
|
prev.hi = prev.hi ? Math.max(prev.hi, id + 1) : id + 1;
|
|
}
|
|
}
|
|
return out;
|
|
}, []);
|
|
// Send {del} message, return promise
|
|
return this.delMessages(ranges, hardDel)
|
|
},
|
|
|
|
/**
|
|
* Delete topic. Requires Owner permission. Wrapper for {@link Tinode#delTopic}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {boolean} hard - had-delete topic.
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to the request.
|
|
*/
|
|
delTopic: function(hard) {
|
|
return this._tinode.delTopic(this.name, hard).then((ctrl) => {
|
|
this._resetSub();
|
|
this._gone();
|
|
return ctrl;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Delete subscription. Requires Share permission. Wrapper for {@link Tinode#delSubscription}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {string} user - ID of the user to remove subscription for.
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to request.
|
|
*/
|
|
delSubscription: function(user) {
|
|
if (!this._subscribed) {
|
|
return Promise.reject(new Error("Cannot delete subscription in inactive topic"));
|
|
}
|
|
// Send {del} message, return promise
|
|
return this._tinode.delSubscription(this.name, user).then((ctrl) => {
|
|
// Remove the object from the subscription cache;
|
|
delete this._users[user];
|
|
// Notify listeners
|
|
if (this.onSubsUpdated) {
|
|
this.onSubsUpdated(Object.keys(this._users));
|
|
}
|
|
return ctrl;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Send a read/recv notification.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {string} what - what notification to send: <code>recv</code>, <code>read</code>.
|
|
* @param {number} seq - ID or the message read or received.
|
|
*/
|
|
note: function(what, seq) {
|
|
if (!this._subscribed) {
|
|
// Cannot sending {note} on an inactive topic".
|
|
return;
|
|
}
|
|
|
|
// Update local cache with the new count.
|
|
const user = this._users[this._tinode.getCurrentUserID()];
|
|
let update = false;
|
|
if (user) {
|
|
// Self-subscription is found.
|
|
if (!user[what] || user[what] < seq) {
|
|
user[what] = seq;
|
|
update = true;
|
|
}
|
|
} else {
|
|
// Self-subscription is not found.
|
|
update = (this[what] | 0) < seq;
|
|
}
|
|
|
|
if (update) {
|
|
// Send notification to the server.
|
|
this._tinode.note(this.name, what, seq);
|
|
// Update locally cached contact with the new count.
|
|
this._updateReadRecv(what, seq);
|
|
|
|
const me = this._tinode.getMeTopic();
|
|
if (this.acs != null && !this.acs.isMuted() && me.onContactUpdate) {
|
|
// Sent a notification to 'me' listeners.
|
|
me.onContactUpdate(what, this);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Send a 'recv' receipt. Wrapper for {@link Tinode#noteRecv}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {number} seq - ID of the message to aknowledge.
|
|
*/
|
|
noteRecv: function(seq) {
|
|
this.note('recv', seq);
|
|
},
|
|
|
|
/**
|
|
* Send a 'read' receipt. Wrapper for {@link Tinode#noteRead}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {number} seq - ID of the message to aknowledge or 0/undefined to acknowledge the latest messages.
|
|
*/
|
|
noteRead: function(seq) {
|
|
seq = seq || this._maxSeq;
|
|
if (seq > 0) {
|
|
this.note('read', seq);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Send a key-press notification. Wrapper for {@link Tinode#noteKeyPress}.
|
|
* @memberof Tinode.Topic#
|
|
*/
|
|
noteKeyPress: function() {
|
|
if (this._subscribed) {
|
|
this._tinode.noteKeyPress(this.name);
|
|
} else {
|
|
this._tinode.logger("INFO: Cannot send notification in inactive topic");
|
|
}
|
|
},
|
|
|
|
// Update cached read/recv/unread counts.
|
|
_updateReadRecv: function(what, seq, ts) {
|
|
let oldVal, doUpdate = false;
|
|
|
|
seq = seq | 0;
|
|
this.seq = this.seq | 0;
|
|
this.read = this.read | 0;
|
|
this.recv = this.recv | 0;
|
|
switch (what) {
|
|
case 'recv':
|
|
oldVal = this.recv;
|
|
this.recv = Math.max(this.recv, seq);
|
|
doUpdate = (oldVal != this.recv);
|
|
break;
|
|
case 'read':
|
|
oldVal = this.read;
|
|
this.read = Math.max(this.read, seq);
|
|
doUpdate = (oldVal != this.read);
|
|
break;
|
|
case 'msg':
|
|
oldVal = this.seq;
|
|
this.seq = Math.max(this.seq, seq);
|
|
if (!this.touched || this.touched < ts) {
|
|
this.touched = ts;
|
|
}
|
|
doUpdate = (oldVal != this.seq);
|
|
break;
|
|
}
|
|
|
|
// Sanity checks.
|
|
if (this.recv < this.read) {
|
|
this.recv = this.read;
|
|
doUpdate = true;
|
|
}
|
|
if (this.seq < this.recv) {
|
|
this.seq = this.recv;
|
|
if (!this.touched || this.touched < ts) {
|
|
this.touched = ts;
|
|
}
|
|
doUpdate = true;
|
|
}
|
|
this.unread = this.seq - this.read;
|
|
return doUpdate;
|
|
},
|
|
|
|
/**
|
|
* Get user description from global cache. The user does not need to be a
|
|
* subscriber of this topic.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {string} uid - ID of the user to fetch.
|
|
* @return {Object} user description or undefined.
|
|
*/
|
|
userDesc: function(uid) {
|
|
// TODO(gene): handle asynchronous requests
|
|
|
|
const user = this._cacheGetUser(uid);
|
|
if (user) {
|
|
return user; // Promise.resolve(user)
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get description of the p2p peer from subscription cache.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @return {Object} peer's description or undefined.
|
|
*/
|
|
p2pPeerDesc: function() {
|
|
if (!this.isP2PType()) {
|
|
return undefined;
|
|
}
|
|
return this._users[this.name];
|
|
},
|
|
|
|
/**
|
|
* Iterate over cached subscribers. If callback is undefined, use this.onMetaSub.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {function} callback - Callback which will receive subscribers one by one.
|
|
* @param {Object=} context - Value of `this` inside the `callback`.
|
|
*/
|
|
subscribers: function(callback, context) {
|
|
const cb = (callback || this.onMetaSub);
|
|
if (cb) {
|
|
for (let idx in this._users) {
|
|
cb.call(context, this._users[idx], idx, this._users);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get a copy of cached tags.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @return {Array.<string>} a copy of tags
|
|
*/
|
|
tags: function() {
|
|
// Return a copy.
|
|
return this._tags.slice(0);
|
|
},
|
|
|
|
/**
|
|
* Get cached subscription for the given user ID.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {string} uid - id of the user to query for
|
|
* @return user description or undefined.
|
|
*/
|
|
subscriber: function(uid) {
|
|
return this._users[uid];
|
|
},
|
|
|
|
/**
|
|
* Iterate over cached messages. If callback is undefined, use this.onData.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {function} callback - Callback which will receive messages one by one. See {@link Tinode.CBuffer#forEach}
|
|
* @param {number} sinceId - Optional seqId to start iterating from (inclusive).
|
|
* @param {number} beforeId - Optional seqId to stop iterating before (exclusive).
|
|
* @param {Object} context - Value of `this` inside the `callback`.
|
|
*/
|
|
messages: function(callback, sinceId, beforeId, context) {
|
|
const cb = (callback || this.onData);
|
|
if (cb) {
|
|
let startIdx = typeof sinceId == 'number' ? this._messages.find({
|
|
seq: sinceId
|
|
}, true) : undefined;
|
|
let beforeIdx = typeof beforeId == 'number' ? this._messages.find({
|
|
seq: beforeId
|
|
}, true) : undefined;
|
|
if (startIdx != -1 && beforeIdx != -1) {
|
|
this._messages.forEach(cb, startIdx, beforeIdx, context);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get the most recent message from cache.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {Object} the most recent cached message or <code>undefined</code>, if no messages are cached.
|
|
*/
|
|
latestMessage: function() {
|
|
return this._messages.getLast();
|
|
},
|
|
|
|
/**
|
|
* Iterate over cached unsent messages. Wraps {@link Tinode.Topic#messages}.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {function} callback - Callback which will receive messages one by one. See {@link Tinode.CBuffer#forEach}
|
|
* @param {Object} context - Value of <code>this</code> inside the <code>callback</code>.
|
|
*/
|
|
queuedMessages: function(callback, context) {
|
|
if (!callback) {
|
|
throw new Error("Callback must be provided");
|
|
}
|
|
this.messages(callback, LOCAL_SEQID, undefined, context);
|
|
},
|
|
|
|
/**
|
|
* Get the number of topic subscribers who marked this message as either recv or read
|
|
* Current user is excluded from the count.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {string} what - what action to consider: received <code>"recv"</code> or read <code>"read"</code>.
|
|
* @param {number} seq - ID or the message read or received.
|
|
*
|
|
* @returns {number} the number of subscribers who marked the message with the given ID as read or received.
|
|
*/
|
|
msgReceiptCount: function(what, seq) {
|
|
let count = 0;
|
|
if (seq > 0) {
|
|
const me = this._tinode.getCurrentUserID();
|
|
for (let idx in this._users) {
|
|
const user = this._users[idx];
|
|
if (user.user !== me && user[what] >= seq) {
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
},
|
|
|
|
/**
|
|
* Get the number of topic subscribers who marked this message (and all older messages) as read.
|
|
* The current user is excluded from the count.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {number} seq - message id to check.
|
|
* @returns {number} number of subscribers who claim to have received the message.
|
|
*/
|
|
msgReadCount: function(seq) {
|
|
return this.msgReceiptCount('read', seq);
|
|
},
|
|
|
|
/**
|
|
* Get the number of topic subscribers who marked this message (and all older messages) as received.
|
|
* The current user is excluded from the count.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {number} seq - Message id to check.
|
|
* @returns {number} Number of subscribers who claim to have received the message.
|
|
*/
|
|
msgRecvCount: function(seq) {
|
|
return this.msgReceiptCount('recv', seq);
|
|
},
|
|
|
|
/**
|
|
* Check if cached message IDs indicate that the server may have more messages.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {boolean} newer - if <code>true</code>, check for newer messages only.
|
|
*/
|
|
msgHasMoreMessages: function(newer) {
|
|
return newer ? this.seq > this._maxSeq :
|
|
// _minSeq could be more than 1, but earlier messages could have been deleted.
|
|
(this._minSeq > 1 && !this._noEarlierMsgs);
|
|
},
|
|
|
|
/**
|
|
* Check if the given seq Id is id of the most recent message.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {number} seqId id of the message to check
|
|
*/
|
|
isNewMessage: function(seqId) {
|
|
return this._maxSeq <= seqId;
|
|
},
|
|
|
|
/**
|
|
* Remove one message from local cache.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {number} seqId id of the message to remove from cache.
|
|
* @returns {Message} removed message or undefined if such message was not found.
|
|
*/
|
|
flushMessage: function(seqId) {
|
|
const idx = this._messages.find({
|
|
seq: seqId
|
|
});
|
|
if (idx >= 0) {
|
|
this._tinode._db.remMessages(this.name, seqId);
|
|
return this._messages.delAt(idx);
|
|
}
|
|
return undefined;
|
|
},
|
|
|
|
/**
|
|
* Update message's seqId.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {Object} pub message object.
|
|
* @param {number} newSeqId new seq id for pub.
|
|
*/
|
|
swapMessageId: function(pub, newSeqId) {
|
|
const idx = this._messages.find(pub);
|
|
const numMessages = this._messages.length();
|
|
if (0 <= idx && idx < numMessages) {
|
|
// Remove message with the old seq ID.
|
|
this._messages.delAt(idx);
|
|
this._tinode._db.remMessages(this.name, pub.seq);
|
|
// Add message with the new seq ID.
|
|
pub.seq = newSeqId;
|
|
this._messages.put(pub);
|
|
this._tinode._db.addMessage(this.name, pub);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Remove a range of messages from the local cache.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {number} fromId seq ID of the first message to remove (inclusive).
|
|
* @param {number} untilId seqID of the last message to remove (exclusive).
|
|
*
|
|
* @returns {Message[]} array of removed messages (could be empty).
|
|
*/
|
|
flushMessageRange: function(fromId, untilId) {
|
|
// Remove range from persistent cache.
|
|
this._tinode._db.remMessages(this.name, fromId, untilId);
|
|
// start, end: find insertion points (nearest == true).
|
|
const since = this._messages.find({
|
|
seq: fromId
|
|
}, true);
|
|
return since >= 0 ? this._messages.delRange(since, this._messages.find({
|
|
seq: untilId
|
|
}, true)) : [];
|
|
},
|
|
|
|
/**
|
|
* Attempt to stop message from being sent.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {number} seqId id of the message to stop sending and remove from cache.
|
|
*
|
|
* @returns {boolean} <code>true</code> if message was cancelled, <code>false</code> otherwise.
|
|
*/
|
|
cancelSend: function(seqId) {
|
|
const idx = this._messages.find({
|
|
seq: seqId
|
|
});
|
|
if (idx >= 0) {
|
|
const msg = this._messages.getAt(idx);
|
|
const status = this.msgStatus(msg);
|
|
if (status == MESSAGE_STATUS_QUEUED || status == MESSAGE_STATUS_FAILED) {
|
|
this._tinode._db.remMessages(this.name, seqId);
|
|
msg._cancelled = true;
|
|
this._messages.delAt(idx);
|
|
if (this.onData) {
|
|
// Calling with no parameters to indicate the message was deleted.
|
|
this.onData();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
|
|
/**
|
|
* Get type of the topic: me, p2p, grp, fnd...
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {string} One of 'me', 'p2p', 'grp', 'fnd', 'sys' or <code>undefined</code>.
|
|
*/
|
|
getType: function() {
|
|
return Tinode.topicType(this.name);
|
|
},
|
|
|
|
/**
|
|
* Get current user's access mode of the topic.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {Tinode.AccessMode} - user's access mode
|
|
*/
|
|
getAccessMode: function() {
|
|
return this.acs;
|
|
},
|
|
|
|
/**
|
|
* Set current user's access mode of the topic.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {AccessMode | Object} acs - access mode to set.
|
|
*/
|
|
setAccessMode: function(acs) {
|
|
return this.acs = new AccessMode(acs);
|
|
},
|
|
|
|
/**
|
|
* Get topic's default access mode.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {Tinode.DefAcs} - access mode, such as {auth: `RWP`, anon: `N`}.
|
|
*/
|
|
getDefaultAccess: function() {
|
|
return this.defacs;
|
|
},
|
|
|
|
/**
|
|
* Initialize new meta {@link Tinode.GetQuery} builder. The query is attched to the current topic.
|
|
* It will not work correctly if used with a different topic.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {Tinode.MetaGetBuilder} query attached to the current topic.
|
|
*/
|
|
startMetaQuery: function() {
|
|
return new MetaGetBuilder(this);
|
|
},
|
|
|
|
/**
|
|
* Check if topic is archived, i.e. private.arch == true.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {boolean} - <code>true</code> if topic is archived, <code>false</code> otherwise.
|
|
*/
|
|
isArchived: function() {
|
|
return this.private && this.private.arch ? true : false;
|
|
},
|
|
|
|
/**
|
|
* Check if topic is a 'me' topic.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {boolean} - <code>true</code> if topic is a 'me' topic, <code>false</code> otherwise.
|
|
*/
|
|
isMeType: function() {
|
|
return Tinode.isMeTopicName(this.name);
|
|
},
|
|
|
|
/**
|
|
* Check if topic is a channel.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {boolean} - <code>true</code> if topic is a channel, <code>false</code> otherwise.
|
|
*/
|
|
isChannelType: function() {
|
|
return Tinode.isChannelTopicName(this.name);
|
|
},
|
|
|
|
/**
|
|
* Check if topic is a group topic.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {boolean} - <code>true</code> if topic is a group, <code>false</code> otherwise.
|
|
*/
|
|
isGroupType: function() {
|
|
return Tinode.isGroupTopicName(this.name);
|
|
},
|
|
|
|
/**
|
|
* Check if topic is a p2p topic.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {boolean} - <code>true</code> if topic is a p2p topic, <code>false</code> otherwise.
|
|
*/
|
|
isP2PType: function() {
|
|
return Tinode.isP2PTopicName(this.name);
|
|
},
|
|
|
|
/**
|
|
* Check if topic is a communication topic, i.e. a group or p2p topic.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @returns {boolean} - <code>true</code> if topic is a p2p or group topic, <code>false</code> otherwise.
|
|
*/
|
|
isCommType: function() {
|
|
return Tinode.isCommTopicName(this.name);
|
|
},
|
|
|
|
/**
|
|
* Get status (queued, sent, received etc) of a given message in the context
|
|
* of this topic.
|
|
* @memberof Tinode.Topic#
|
|
*
|
|
* @param {Message} msg message to check for status.
|
|
* @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 || msg._cancelled) {
|
|
status = MESSAGE_STATUS_FAILED;
|
|
} else if (msg.seq >= LOCAL_SEQID) {
|
|
status = MESSAGE_STATUS_QUEUED;
|
|
} else if (this.msgReadCount(msg.seq) > 0) {
|
|
status = MESSAGE_STATUS_READ;
|
|
} else if (this.msgRecvCount(msg.seq) > 0) {
|
|
status = MESSAGE_STATUS_RECEIVED;
|
|
} else if (msg.seq > 0) {
|
|
status = MESSAGE_STATUS_SENT;
|
|
}
|
|
} else {
|
|
status = MESSAGE_STATUS_TO_ME;
|
|
}
|
|
return status;
|
|
},
|
|
|
|
// Process data message
|
|
_routeData: function(data) {
|
|
if (data.content) {
|
|
if (!this.touched || this.touched < data.ts) {
|
|
this.touched = data.ts;
|
|
}
|
|
}
|
|
|
|
if (data.seq > this._maxSeq) {
|
|
this._maxSeq = data.seq;
|
|
}
|
|
if (data.seq < this._minSeq || this._minSeq == 0) {
|
|
this._minSeq = data.seq;
|
|
}
|
|
|
|
if (!data._noForwarding) {
|
|
this._messages.put(data);
|
|
this._tinode._db.addMessage(this.name, data);
|
|
this._updateDeletedRanges();
|
|
}
|
|
|
|
if (this.onData) {
|
|
this.onData(data);
|
|
}
|
|
|
|
// Update locally cached contact with the new message count.
|
|
const what = ((!this.isChannelType() && !data.from) || this._tinode.isMe(data.from)) ? 'read' : 'msg';
|
|
const updated = this._updateReadRecv(what, data.seq, data.ts);
|
|
const me = this._tinode.getMeTopic();
|
|
if (updated && me.onContactUpdate) {
|
|
// Notify 'me' listeners of the change.
|
|
me.onContactUpdate(what, this);
|
|
}
|
|
},
|
|
|
|
// Process metadata message
|
|
_routeMeta: function(meta) {
|
|
if (meta.desc) {
|
|
this._lastDescUpdate = meta.ts;
|
|
this._processMetaDesc(meta.desc);
|
|
}
|
|
if (meta.sub && meta.sub.length > 0) {
|
|
this._lastSubsUpdate = meta.ts;
|
|
this._processMetaSub(meta.sub);
|
|
}
|
|
if (meta.del) {
|
|
this._processDelMessages(meta.del.clear, meta.del.delseq);
|
|
}
|
|
if (meta.tags) {
|
|
this._processMetaTags(meta.tags);
|
|
}
|
|
if (meta.cred) {
|
|
this._processMetaCreds(meta.cred);
|
|
}
|
|
if (this.onMeta) {
|
|
this.onMeta(meta);
|
|
}
|
|
},
|
|
|
|
// Process presence change message
|
|
_routePres: function(pres) {
|
|
let user;
|
|
switch (pres.what) {
|
|
case 'del':
|
|
// Delete cached messages.
|
|
this._processDelMessages(pres.clear, pres.delseq);
|
|
break;
|
|
case 'on':
|
|
case 'off':
|
|
// Update online status of a subscription.
|
|
user = this._users[pres.src];
|
|
if (user) {
|
|
user.online = pres.what == 'on';
|
|
} else {
|
|
this._tinode.logger("WARNING: Presence update for an unknown user", this.name, pres.src);
|
|
}
|
|
break;
|
|
case 'term':
|
|
// Attachment to topic is terminated probably due to cluster rehashing.
|
|
this._resetSub();
|
|
break;
|
|
case 'acs':
|
|
const uid = pres.src || this._tinode.getCurrentUserID();
|
|
user = this._users[uid];
|
|
if (!user) {
|
|
// Update for an unknown user: notification of a new subscription.
|
|
const acs = new AccessMode().updateAll(pres.dacs);
|
|
if (acs && acs.mode != AccessMode._NONE) {
|
|
user = this._cacheGetUser(uid);
|
|
if (!user) {
|
|
user = {
|
|
user: uid,
|
|
acs: acs
|
|
};
|
|
this.getMeta(this.startMetaQuery().withOneSub(undefined, uid).build());
|
|
} else {
|
|
user.acs = acs;
|
|
}
|
|
user.updated = new Date();
|
|
this._processMetaSub([user]);
|
|
}
|
|
} else {
|
|
// Known user
|
|
user.acs.updateAll(pres.dacs);
|
|
// Update user's access mode.
|
|
this._processMetaSub([{
|
|
user: uid,
|
|
updated: new Date(),
|
|
acs: user.acs
|
|
}]);
|
|
}
|
|
break;
|
|
default:
|
|
this._tinode.logger("INFO: Ignored presence update", pres.what);
|
|
}
|
|
|
|
if (this.onPres) {
|
|
this.onPres(pres);
|
|
}
|
|
},
|
|
|
|
// Process {info} message
|
|
_routeInfo: function(info) {
|
|
if (info.what !== 'kp') {
|
|
const user = this._users[info.from];
|
|
if (user) {
|
|
user[info.what] = info.seq;
|
|
if (user.recv < user.read) {
|
|
user.recv = user.read;
|
|
}
|
|
}
|
|
|
|
// If this is an update from the current user, update the cache with the new count and notify 'me' listener.
|
|
if (this._tinode.isMe(info.from)) {
|
|
const updated = this._updateReadRecv(info.what, info.seq);
|
|
if (updated) {
|
|
const me = this._tinode.getMeTopic();
|
|
if (me.onContactUpdate) {
|
|
me.onContactUpdate(info.what, this);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (this.onInfo) {
|
|
this.onInfo(info);
|
|
}
|
|
},
|
|
|
|
// Called by Tinode when meta.desc packet is received.
|
|
// Called by 'me' topic on contact update (desc._noForwarding is true).
|
|
_processMetaDesc: function(desc) {
|
|
// Synthetic desc may include defacs for p2p topics which is useless.
|
|
// Remove it.
|
|
if (this.isP2PType()) {
|
|
delete desc.defacs;
|
|
}
|
|
|
|
// Copy parameters from desc object to this topic.
|
|
mergeObj(this, desc);
|
|
// Make sure date fields are Date().
|
|
stringToDate(this);
|
|
|
|
// Notify 'me' listener, if available:
|
|
if (this.name !== TOPIC_ME && !desc._noForwarding) {
|
|
const me = this._tinode.getMeTopic();
|
|
if (me.onMetaSub) {
|
|
me.onMetaSub(this);
|
|
}
|
|
if (me.onSubsUpdated) {
|
|
me.onSubsUpdated([this.name], 1);
|
|
}
|
|
}
|
|
|
|
if (this.onMetaDesc) {
|
|
this.onMetaDesc(this);
|
|
}
|
|
},
|
|
|
|
// Called by Tinode when meta.sub is recived or in response to received
|
|
// {ctrl} after setMeta-sub.
|
|
_processMetaSub: function(subs) {
|
|
for (let idx in subs) {
|
|
const sub = subs[idx];
|
|
|
|
sub.updated = new Date(sub.updated);
|
|
sub.deleted = sub.deleted ? new Date(sub.deleted) : null;
|
|
|
|
let user = null;
|
|
if (!sub.deleted) {
|
|
// If this is a change to user's own permissions, update them in topic too.
|
|
// Desc will update 'me' topic.
|
|
if (this._tinode.isMe(sub.user) && sub.acs) {
|
|
this._processMetaDesc({
|
|
updated: sub.updated || new Date(),
|
|
touched: sub.updated,
|
|
acs: sub.acs
|
|
});
|
|
}
|
|
user = this._updateCachedUser(sub.user, sub);
|
|
} else {
|
|
// Subscription is deleted, remove it from topic (but leave in Users cache)
|
|
delete this._users[sub.user];
|
|
user = sub;
|
|
}
|
|
|
|
if (this.onMetaSub) {
|
|
this.onMetaSub(user);
|
|
}
|
|
}
|
|
|
|
if (this.onSubsUpdated) {
|
|
this.onSubsUpdated(Object.keys(this._users));
|
|
}
|
|
},
|
|
|
|
// Called by Tinode when meta.tags is recived.
|
|
_processMetaTags: function(tags) {
|
|
if (tags.length == 1 && tags[0] == Tinode.DEL_CHAR) {
|
|
tags = [];
|
|
}
|
|
this._tags = tags;
|
|
if (this.onTagsUpdated) {
|
|
this.onTagsUpdated(tags);
|
|
}
|
|
},
|
|
|
|
// Do nothing for topics other than 'me'
|
|
_processMetaCreds: function(creds) {},
|
|
|
|
// Delete cached messages and update cached transaction IDs
|
|
_processDelMessages: function(clear, delseq) {
|
|
this._maxDel = Math.max(clear, this._maxDel);
|
|
this.clear = Math.max(clear, this.clear);
|
|
const topic = this;
|
|
let count = 0;
|
|
if (Array.isArray(delseq)) {
|
|
delseq.map(function(range) {
|
|
if (!range.hi) {
|
|
count++;
|
|
topic.flushMessage(range.low);
|
|
} else {
|
|
for (let i = range.low; i < range.hi; i++) {
|
|
count++;
|
|
topic.flushMessage(i);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
if (count > 0) {
|
|
this._updateDeletedRanges();
|
|
|
|
if (this.onData) {
|
|
this.onData();
|
|
}
|
|
}
|
|
},
|
|
|
|
// Topic is informed that the entire response to {get what=data} has been received.
|
|
_allMessagesReceived: function(count) {
|
|
this._updateDeletedRanges();
|
|
|
|
if (this.onAllMessagesReceived) {
|
|
this.onAllMessagesReceived(count);
|
|
}
|
|
},
|
|
|
|
// Reset subscribed state
|
|
_resetSub: function() {
|
|
this._subscribed = false;
|
|
},
|
|
|
|
// This topic is either deleted or unsubscribed from.
|
|
_gone: function() {
|
|
this._messages.reset();
|
|
this._tinode._db.remMessages(this.name);
|
|
this._users = {};
|
|
this.acs = new AccessMode(null);
|
|
this.private = null;
|
|
this.public = null;
|
|
this._maxSeq = 0;
|
|
this._minSeq = 0;
|
|
this._subscribed = false;
|
|
|
|
const me = this._tinode.getMeTopic();
|
|
if (me) {
|
|
me._routePres({
|
|
_noForwarding: true,
|
|
what: 'gone',
|
|
topic: TOPIC_ME,
|
|
src: this.name
|
|
});
|
|
}
|
|
if (this.onDeleteTopic) {
|
|
this.onDeleteTopic();
|
|
}
|
|
},
|
|
|
|
// Update global user cache and local subscribers cache.
|
|
// Don't call this method for non-subscribers.
|
|
_updateCachedUser: function(uid, obj) {
|
|
// Fetch user object from the global cache.
|
|
// This is a clone of the stored object
|
|
let cached = this._cacheGetUser(uid);
|
|
cached = mergeObj(cached || {}, obj);
|
|
// Save to global cache
|
|
this._cachePutUser(uid, cached);
|
|
// Save to the list of topic subsribers.
|
|
return mergeToCache(this._users, uid, cached);
|
|
},
|
|
|
|
// Get local seqId for a queued message.
|
|
_getQueuedSeqId: function() {
|
|
return this._queuedSeqId++;
|
|
},
|
|
|
|
// Calculate ranges of missing messages.
|
|
_updateDeletedRanges: function() {
|
|
const ranges = [];
|
|
|
|
let prev = null;
|
|
// Check for gap in the beginning, before the first message.
|
|
const first = this._messages.getAt(0);
|
|
if (first && this._minSeq > 1 && !this._noEarlierMsgs) {
|
|
// Some messages are missing in the beginning.
|
|
if (first.hi) {
|
|
// The first message already represents a gap.
|
|
if (first.seq > 1) {
|
|
first.seq = 1;
|
|
}
|
|
if (first.hi < this._minSeq - 1) {
|
|
first.hi = this._minSeq - 1;
|
|
}
|
|
prev = first;
|
|
} else {
|
|
// Create new gap.
|
|
prev = {
|
|
seq: 1,
|
|
hi: this._minSeq - 1
|
|
};
|
|
ranges.push(prev);
|
|
}
|
|
} else {
|
|
// No gap in the beginning.
|
|
prev = {
|
|
seq: 0,
|
|
hi: 0
|
|
};
|
|
}
|
|
|
|
// Find gaps in the list of received messages. The list contains messages-proper as well
|
|
// as placeholers for deleted ranges.
|
|
// The messages are iterated by seq ID in ascending order.
|
|
this._messages.forEach((data) => {
|
|
// Do not create a gap between the last sent message and the first unsent.
|
|
if (data.seq >= LOCAL_SEQID) {
|
|
return;
|
|
}
|
|
|
|
// New message is reducing the existing gap
|
|
if (data.seq == (prev.hi || prev.seq) + 1) {
|
|
// No new gap. Replace previous with current.
|
|
prev = data;
|
|
return;
|
|
}
|
|
|
|
// Found a new gap.
|
|
if (prev.hi) {
|
|
// Previous is also a gap, alter it.
|
|
prev.hi = data.hi || data.seq;
|
|
return;
|
|
}
|
|
|
|
// Previous is not a gap. Create a new gap.
|
|
prev = {
|
|
seq: (prev.hi || prev.seq) + 1,
|
|
hi: data.hi || data.seq
|
|
};
|
|
ranges.push(prev);
|
|
});
|
|
|
|
// Check for missing messages at the end.
|
|
// All messages could be missing or it could be a new topic with no messages.
|
|
const last = this._messages.getLast();
|
|
const maxSeq = Math.max(this.seq, this._maxSeq) || 0;
|
|
if ((maxSeq > 0 && !last) || (last && ((last.hi || last.seq) < maxSeq))) {
|
|
if (last && last.hi) {
|
|
// Extend existing gap
|
|
last.hi = maxSeq;
|
|
} else {
|
|
// Create new gap.
|
|
ranges.push({
|
|
seq: last ? last.seq + 1 : 1,
|
|
hi: maxSeq
|
|
});
|
|
}
|
|
}
|
|
|
|
// Insert new gaps into cache.
|
|
ranges.map((gap) => {
|
|
this._messages.put(gap);
|
|
});
|
|
},
|
|
|
|
// Load most recent messages from persistent cache.
|
|
_loadMessages: function() {
|
|
return this._tinode._db.readMessages(this.name, {
|
|
limit: DEFAULT_MESSAGES_PAGE
|
|
})
|
|
.then((msgs) => {
|
|
msgs.forEach((data) => {
|
|
if (data.seq > this._maxSeq) {
|
|
this._maxSeq = data.seq;
|
|
}
|
|
if (data.seq < this._minSeq || this._minSeq == 0) {
|
|
this._minSeq = data.seq;
|
|
}
|
|
this._messages.put(data);
|
|
});
|
|
|
|
this._updateDeletedRanges();
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @class TopicMe - special case of {@link Tinode.Topic} for
|
|
* managing data of the current user, including contact list.
|
|
* @extends Tinode.Topic
|
|
* @memberof Tinode
|
|
*
|
|
* @param {TopicMe.Callbacks} callbacks - Callbacks to receive various events.
|
|
*/
|
|
var TopicMe = function(callbacks) {
|
|
Topic.call(this, TOPIC_ME, callbacks);
|
|
|
|
// me-specific callbacks
|
|
if (callbacks) {
|
|
this.onContactUpdate = callbacks.onContactUpdate;
|
|
}
|
|
};
|
|
|
|
// Inherit everyting from the generic Topic
|
|
TopicMe.prototype = Object.create(Topic.prototype, {
|
|
// Override the original Topic._processMetaDesc.
|
|
_processMetaDesc: {
|
|
value: function(desc) {
|
|
// Check if online contacts need to be turned off because P permission was removed.
|
|
const turnOff = (desc.acs && !desc.acs.isPresencer()) && (this.acs && this.acs.isPresencer());
|
|
|
|
// Copy parameters from desc object to this topic.
|
|
mergeObj(this, desc);
|
|
// String datetime headers to Date() objects.
|
|
stringToDate(this);
|
|
|
|
// 'P' permission was removed. All topics are offline now.
|
|
if (turnOff) {
|
|
this._tinode.cacheMap('topic', (cont) => {
|
|
if (cont.online) {
|
|
cont.online = false;
|
|
if (cont.seen) {
|
|
cont.seen.when = new Date();
|
|
} else {
|
|
cont.seen = {
|
|
when: new Date()
|
|
};
|
|
}
|
|
if (this.onContactUpdate) {
|
|
this.onContactUpdate('off', cont);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
if (this.onMetaDesc) {
|
|
this.onMetaDesc(this);
|
|
}
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
// Override the original Topic._processMetaSub
|
|
_processMetaSub: {
|
|
value: function(subs) {
|
|
let updateCount = 0;
|
|
subs.forEach((sub) => {
|
|
const topicName = sub.topic;
|
|
// Don't show 'me' and 'fnd' topics in the list of contacts.
|
|
if (topicName == TOPIC_FND || topicName == TOPIC_ME) {
|
|
return;
|
|
}
|
|
sub.updated = new Date(sub.updated);
|
|
sub.touched = sub.touched ? new Date(sub.touched) : undefined;
|
|
sub.deleted = sub.deleted ? new Date(sub.deleted) : null;
|
|
|
|
let cont = null;
|
|
if (sub.deleted) {
|
|
cont = sub;
|
|
this._tinode.cacheDel('topic', topicName);
|
|
this._tinode._db.remTopic(topicName);
|
|
} else {
|
|
// Ensure the values are defined and are integers.
|
|
if (typeof sub.seq != 'undefined') {
|
|
sub.seq = sub.seq | 0;
|
|
sub.recv = sub.recv | 0;
|
|
sub.read = sub.read | 0;
|
|
sub.unread = sub.seq - sub.read;
|
|
}
|
|
|
|
if (sub.seen && sub.seen.when) {
|
|
sub.seen.when = new Date(sub.seen.when);
|
|
}
|
|
|
|
cont = mergeObj(this._tinode.getTopic(topicName), sub);
|
|
this._tinode._db.updTopic(cont);
|
|
|
|
if (Tinode.isP2PTopicName(topicName)) {
|
|
this._cachePutUser(topicName, cont);
|
|
}
|
|
// Notify topic of the update if it's an external update.
|
|
if (!sub._noForwarding) {
|
|
const topic = this._tinode.getTopic(topicName);
|
|
if (topic) {
|
|
sub._noForwarding = true;
|
|
topic._processMetaDesc(sub);
|
|
}
|
|
}
|
|
}
|
|
|
|
updateCount++;
|
|
|
|
if (this.onMetaSub) {
|
|
this.onMetaSub(cont);
|
|
}
|
|
});
|
|
|
|
if (this.onSubsUpdated && updateCount > 0) {
|
|
const keys = [];
|
|
subs.forEach((s) => {
|
|
keys.push(s.topic);
|
|
});
|
|
this.onSubsUpdated(keys, updateCount);
|
|
}
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
// Called by Tinode when meta.sub is recived.
|
|
_processMetaCreds: {
|
|
value: function(creds, upd) {
|
|
if (creds.length == 1 && creds[0] == Tinode.DEL_CHAR) {
|
|
creds = [];
|
|
}
|
|
if (upd) {
|
|
creds.map((cr) => {
|
|
if (cr.val) {
|
|
// Adding a credential.
|
|
let idx = this._credentials.findIndex((el) => {
|
|
return el.meth == cr.meth && el.val == cr.val;
|
|
});
|
|
if (idx < 0) {
|
|
// Not found.
|
|
if (!cr.done) {
|
|
// Unconfirmed credential replaces previous unconfirmed credential of the same method.
|
|
idx = this._credentials.findIndex((el) => {
|
|
return el.meth == cr.meth && !el.done;
|
|
});
|
|
if (idx >= 0) {
|
|
// Remove previous unconfirmed credential.
|
|
this._credentials.splice(idx, 1);
|
|
}
|
|
}
|
|
this._credentials.push(cr);
|
|
} else {
|
|
// Found. Maybe change 'done' status.
|
|
this._credentials[idx].done = cr.done;
|
|
}
|
|
} else if (cr.resp) {
|
|
// Handle credential confirmation.
|
|
const idx = this._credentials.findIndex((el) => {
|
|
return el.meth == cr.meth && !el.done;
|
|
});
|
|
if (idx >= 0) {
|
|
this._credentials[idx].done = true;
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
this._credentials = creds;
|
|
}
|
|
if (this.onCredsUpdated) {
|
|
this.onCredsUpdated(this._credentials);
|
|
}
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
// Process presence change message
|
|
_routePres: {
|
|
value: function(pres) {
|
|
if (pres.what == 'term') {
|
|
// The 'me' topic itself is detached. Mark as unsubscribed.
|
|
this._resetSub();
|
|
return;
|
|
}
|
|
|
|
if (pres.what == 'upd' && pres.src == TOPIC_ME) {
|
|
// Update to me's description. Request updated value.
|
|
this.getMeta(this.startMetaQuery().withDesc().build());
|
|
return;
|
|
}
|
|
|
|
const cont = this._tinode.cacheGet('topic', pres.src);
|
|
if (cont) {
|
|
switch (pres.what) {
|
|
case 'on': // topic came online
|
|
cont.online = true;
|
|
break;
|
|
case 'off': // topic went offline
|
|
if (cont.online) {
|
|
cont.online = false;
|
|
if (cont.seen) {
|
|
cont.seen.when = new Date();
|
|
} else {
|
|
cont.seen = {
|
|
when: new Date()
|
|
};
|
|
}
|
|
}
|
|
break;
|
|
case 'msg': // new message received
|
|
cont.touched = new Date();
|
|
cont.seq = pres.seq | 0;
|
|
// Check if message is sent by the current user. If so it's been read already.
|
|
if (!pres.act || this._tinode.isMe(pres.act)) {
|
|
cont.read = cont.read ? Math.max(cont.read, cont.seq) : cont.seq;
|
|
cont.recv = cont.recv ? Math.max(cont.read, cont.recv) : cont.read;
|
|
}
|
|
cont.unread = cont.seq - (cont.read | 0);
|
|
break;
|
|
case 'upd': // desc updated
|
|
// Request updated subscription.
|
|
this.getMeta(this.startMetaQuery().withLaterOneSub(pres.src).build());
|
|
break;
|
|
case 'acs': // access mode changed
|
|
if (cont.acs) {
|
|
cont.acs.updateAll(pres.dacs);
|
|
} else {
|
|
cont.acs = new AccessMode().updateAll(pres.dacs);
|
|
}
|
|
cont.touched = new Date();
|
|
break;
|
|
case 'ua':
|
|
// user agent changed.
|
|
cont.seen = {
|
|
when: new Date(),
|
|
ua: pres.ua
|
|
};
|
|
break;
|
|
case 'recv':
|
|
// user's other session marked some messges as received.
|
|
pres.seq = pres.seq | 0;
|
|
cont.recv = cont.recv ? Math.max(cont.recv, pres.seq) : pres.seq;
|
|
break;
|
|
case 'read':
|
|
// user's other session marked some messages as read.
|
|
pres.seq = pres.seq | 0;
|
|
cont.read = cont.read ? Math.max(cont.read, pres.seq) : pres.seq;
|
|
cont.recv = cont.recv ? Math.max(cont.read, cont.recv) : cont.recv;
|
|
cont.unread = cont.seq - cont.read;
|
|
break;
|
|
case 'gone':
|
|
// topic deleted or unsubscribed from.
|
|
this._tinode.cacheDel('topic', pres.src);
|
|
break;
|
|
case 'del':
|
|
// Update topic.del value.
|
|
break;
|
|
default:
|
|
this._tinode.logger("INFO: Unsupported presence update in 'me'", pres.what);
|
|
}
|
|
|
|
if (this.onContactUpdate) {
|
|
this.onContactUpdate(pres.what, cont);
|
|
}
|
|
} else {
|
|
if (pres.what == 'acs') {
|
|
// New subscriptions and deleted/banned subscriptions have full
|
|
// access mode (no + or - in the dacs string). Changes to known subscriptions are sent as
|
|
// deltas, but they should not happen here.
|
|
const acs = new AccessMode(pres.dacs);
|
|
if (!acs || acs.mode == AccessMode._INVALID) {
|
|
this._tinode.logger("ERROR: Invalid access mode update", pres.src, pres.dacs);
|
|
return;
|
|
} else if (acs.mode == AccessMode._NONE) {
|
|
this._tinode.logger("WARNING: Removing non-existent subscription", pres.src, pres.dacs);
|
|
return;
|
|
} else {
|
|
// New subscription. Send request for the full description.
|
|
// Using .withOneSub (not .withLaterOneSub) to make sure IfModifiedSince is not set.
|
|
this.getMeta(this.startMetaQuery().withOneSub(undefined, pres.src).build());
|
|
// Create a dummy entry to catch online status update.
|
|
const dummy = this._tinode.getTopic(pres.src);
|
|
dummy.touched = new Date();
|
|
dummy.topic = pres.src;
|
|
dummy.online = false;
|
|
dummy.acs = acs;
|
|
this._tinode.attachCacheToTopic(dummy);
|
|
dummy._cachePutSelf();
|
|
this._db.addTopic(dummy);
|
|
}
|
|
} else if (pres.what == 'tags') {
|
|
this.getMeta(this.startMetaQuery().withTags().build());
|
|
}
|
|
}
|
|
|
|
if (this.onPres) {
|
|
this.onPres(pres);
|
|
}
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
/**
|
|
* Publishing to TopicMe is not supported. {@link Topic#publish} is overriden and thows an {Error} if called.
|
|
* @memberof Tinode.TopicMe#
|
|
* @throws {Error} Always throws an error.
|
|
*/
|
|
publish: {
|
|
value: function() {
|
|
return Promise.reject(new Error("Publishing to 'me' is not supported"));
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
/**
|
|
* Delete validation credential.
|
|
* @memberof Tinode.TopicMe#
|
|
*
|
|
* @param {string} topic - Name of the topic to delete
|
|
* @param {string} user - User ID to remove.
|
|
* @returns {Promise} Promise which will be resolved/rejected on receiving server reply.
|
|
*/
|
|
delCredential: {
|
|
value: function(method, value) {
|
|
if (!this._subscribed) {
|
|
return Promise.reject(new Error("Cannot delete credential in inactive 'me' topic"));
|
|
}
|
|
// Send {del} message, return promise
|
|
return this._tinode.delCredential(method, value).then((ctrl) => {
|
|
// Remove deleted credential from the cache.
|
|
const index = this._credentials.findIndex((el) => {
|
|
return el.meth == method && el.val == value;
|
|
});
|
|
if (index > -1) {
|
|
this._credentials.splice(index, 1);
|
|
}
|
|
// Notify listeners
|
|
if (this.onCredsUpdated) {
|
|
this.onCredsUpdated(this._credentials);
|
|
}
|
|
return ctrl;
|
|
});
|
|
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
/**
|
|
* @callback contactFilter
|
|
* @param {Object} contact to check for inclusion.
|
|
* @returns {boolean} <code>true</code> if contact should be processed, <code>false</code> to exclude it.
|
|
*/
|
|
/**
|
|
* Iterate over cached contacts.
|
|
*
|
|
* @function
|
|
* @memberof Tinode.TopicMe#
|
|
* @param {TopicMe.ContactCallback} callback - Callback to call for each contact.
|
|
* @param {contactFilter=} filter - Optionally filter contacts; include all if filter is false-ish, otherwise
|
|
* include those for which filter returns true-ish.
|
|
* @param {Object=} context - Context to use for calling the `callback`, i.e. the value of `this` inside the callback.
|
|
*/
|
|
contacts: {
|
|
value: function(callback, filter, context) {
|
|
this._tinode.cacheMap('topic', (c, idx) => {
|
|
if (c.isCommType() && (!filter || filter(c))) {
|
|
callback.call(context, c, idx);
|
|
}
|
|
});
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
/**
|
|
* Get a contact from cache.
|
|
* @memberof Tinode.TopicMe#
|
|
*
|
|
* @param {string} name - Name of the contact to get, either a UID (for p2p topics) or a topic name.
|
|
* @returns {Tinode.Contact} - Contact or `undefined`.
|
|
*/
|
|
getContact: {
|
|
value: function(name) {
|
|
return this._tinode.cacheGet('topic', name);
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
/**
|
|
* Get access mode of a given contact from cache.
|
|
* @memberof Tinode.TopicMe#
|
|
*
|
|
* @param {string} name - Name of the contact to get access mode for, either a UID (for p2p topics)
|
|
* or a topic name; if missing, access mode for the 'me' topic itself.
|
|
* @returns {string} - access mode, such as `RWP`.
|
|
*/
|
|
getAccessMode: {
|
|
value: function(name) {
|
|
if (name) {
|
|
const cont = this._tinode.cacheGet('topic', name);
|
|
return cont ? cont.acs : null;
|
|
}
|
|
return this.acs;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
/**
|
|
* Check if contact is archived, i.e. contact.private.arch == true.
|
|
* @memberof Tinode.TopicMe#
|
|
*
|
|
* @param {string} name - Name of the contact to check archived status, either a UID (for p2p topics) or a topic name.
|
|
* @returns {boolean} - true if contact is archived, false otherwise.
|
|
*/
|
|
isArchived: {
|
|
value: function(name) {
|
|
const cont = this._tinode.cacheGet('topic', name);
|
|
return cont ? ((cont.private && cont.private.arch) ? true : false) : null;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
/**
|
|
* @typedef Tinode.Credential
|
|
* @memberof Tinode
|
|
* @type Object
|
|
* @property {string} meth - validation method such as 'email' or 'tel'.
|
|
* @property {string} val - credential value, i.e. 'jdoe@example.com' or '+17025551234'
|
|
* @property {boolean} done - true if credential is validated.
|
|
*/
|
|
/**
|
|
* Get the user's credentials: email, phone, etc.
|
|
* @memberof Tinode.TopicMe#
|
|
*
|
|
* @returns {Tinode.Credential[]} - array of credentials.
|
|
*/
|
|
getCredentials: {
|
|
value: function() {
|
|
return this._credentials;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
TopicMe.prototype.constructor = TopicMe;
|
|
|
|
/**
|
|
* @class TopicFnd - special case of {@link Tinode.Topic} for searching for
|
|
* contacts and group topics.
|
|
* @extends Tinode.Topic
|
|
* @memberof Tinode
|
|
*
|
|
* @param {TopicFnd.Callbacks} callbacks - Callbacks to receive various events.
|
|
*/
|
|
var TopicFnd = function(callbacks) {
|
|
Topic.call(this, TOPIC_FND, callbacks);
|
|
// List of users and topics uid or topic_name -> Contact object)
|
|
this._contacts = {};
|
|
};
|
|
|
|
// Inherit everyting from the generic Topic
|
|
TopicFnd.prototype = Object.create(Topic.prototype, {
|
|
// Override the original Topic._processMetaSub
|
|
_processMetaSub: {
|
|
value: function(subs) {
|
|
let updateCount = Object.getOwnPropertyNames(this._contacts).length;
|
|
// Reset contact list.
|
|
this._contacts = {};
|
|
for (let idx in subs) {
|
|
let sub = subs[idx];
|
|
const indexBy = sub.topic ? sub.topic : sub.user;
|
|
|
|
sub.updated = new Date(sub.updated);
|
|
if (sub.seen && sub.seen.when) {
|
|
sub.seen.when = new Date(sub.seen.when);
|
|
}
|
|
|
|
sub = mergeToCache(this._contacts, indexBy, sub);
|
|
updateCount++;
|
|
|
|
if (this.onMetaSub) {
|
|
this.onMetaSub(sub);
|
|
}
|
|
}
|
|
|
|
if (updateCount > 0 && this.onSubsUpdated) {
|
|
this.onSubsUpdated(Object.keys(this._contacts));
|
|
}
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
/**
|
|
* Publishing to TopicFnd is not supported. {@link Topic#publish} is overriden and thows an {Error} if called.
|
|
* @memberof Tinode.TopicFnd#
|
|
* @throws {Error} Always throws an error.
|
|
*/
|
|
publish: {
|
|
value: function() {
|
|
return Promise.reject(new Error("Publishing to 'fnd' is not supported"));
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
/**
|
|
* setMeta to TopicFnd resets contact list in addition to sending the message.
|
|
* @memberof Tinode.TopicFnd#
|
|
* @param {Tinode.SetParams} params parameters to update.
|
|
* @returns {Promise} Promise to be resolved/rejected when the server responds to request.
|
|
*/
|
|
setMeta: {
|
|
value: function(params) {
|
|
const instance = this;
|
|
return Object.getPrototypeOf(TopicFnd.prototype).setMeta.call(this, params).then(function() {
|
|
if (Object.keys(instance._contacts).length > 0) {
|
|
instance._contacts = {};
|
|
if (instance.onSubsUpdated) {
|
|
instance.onSubsUpdated([]);
|
|
}
|
|
}
|
|
});
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
},
|
|
|
|
/**
|
|
* Iterate over found contacts. If callback is undefined, use {@link this.onMetaSub}.
|
|
* @function
|
|
* @memberof Tinode.TopicFnd#
|
|
* @param {TopicFnd.ContactCallback} callback - Callback to call for each contact.
|
|
* @param {Object} context - Context to use for calling the `callback`, i.e. the value of `this` inside the callback.
|
|
*/
|
|
contacts: {
|
|
value: function(callback, context) {
|
|
const cb = (callback || this.onMetaSub);
|
|
if (cb) {
|
|
for (let idx in this._contacts) {
|
|
cb.call(context, this._contacts[idx], idx, this._contacts);
|
|
}
|
|
}
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
TopicFnd.prototype.constructor = TopicFnd;
|
|
|
|
/**
|
|
* @class LargeFileHelper - collection of utilities for uploading and downloading files
|
|
* out of band. Don't instantiate this class directly. Use {Tinode.getLargeFileHelper} instead.
|
|
* @memberof Tinode
|
|
*
|
|
* @param {Tinode} tinode - the main Tinode object.
|
|
*/
|
|
var LargeFileHelper = function(tinode) {
|
|
this._tinode = tinode;
|
|
|
|
this._apiKey = tinode._apiKey;
|
|
this._authToken = tinode.getAuthToken();
|
|
this._msgId = tinode.getNextUniqueId();
|
|
this.xhr = new XMLHttpRequest();
|
|
|
|
// Promise
|
|
this.toResolve = null;
|
|
this.toReject = null;
|
|
|
|
// Callbacks
|
|
this.onProgress = null;
|
|
this.onSuccess = null;
|
|
this.onFailure = null;
|
|
}
|
|
|
|
LargeFileHelper.prototype = {
|
|
/**
|
|
* Start uploading the file to a non-default endpoint.
|
|
*
|
|
* @memberof Tinode.LargeFileHelper#
|
|
*
|
|
* @param {string} baseUrl alternative base URL of upload server.
|
|
* @param {File|Blob} data 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, data, 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 = (e) => {
|
|
if (e.lengthComputable && instance.onProgress) {
|
|
instance.onProgress(e.loaded / e.total);
|
|
}
|
|
}
|
|
|
|
this.xhr.onload = function() {
|
|
let pkt;
|
|
try {
|
|
pkt = JSON.parse(this.response, jsonParseHelper);
|
|
} catch (err) {
|
|
instance._tinode.logger("ERROR: Invalid server response in LargeFileHelper", this.response);
|
|
pkt = {
|
|
ctrl: {
|
|
code: this.status,
|
|
text: this.statusText
|
|
}
|
|
};
|
|
}
|
|
|
|
if (this.status >= 200 && this.status < 300) {
|
|
if (instance.toResolve) {
|
|
instance.toResolve(pkt.ctrl.params.url);
|
|
}
|
|
if (instance.onSuccess) {
|
|
instance.onSuccess(pkt.ctrl);
|
|
}
|
|
} else if (this.status >= 400) {
|
|
if (instance.toReject) {
|
|
instance.toReject(new Error(`${pkt.ctrl.text} (${pkt.ctrl.code})`));
|
|
}
|
|
if (instance.onFailure) {
|
|
instance.onFailure(pkt.ctrl)
|
|
}
|
|
} else {
|
|
instance._tinode.logger("ERROR: Unexpected server response status", this.status, this.response);
|
|
}
|
|
};
|
|
|
|
this.xhr.onerror = function(e) {
|
|
if (instance.toReject) {
|
|
instance.toReject(new Error("failed"));
|
|
}
|
|
if (instance.onFailure) {
|
|
instance.onFailure(null);
|
|
}
|
|
};
|
|
|
|
this.xhr.onabort = function(e) {
|
|
if (instance.toReject) {
|
|
instance.toReject(new Error("upload cancelled by user"));
|
|
}
|
|
if (instance.onFailure) {
|
|
instance.onFailure(null);
|
|
}
|
|
};
|
|
|
|
try {
|
|
const form = new FormData();
|
|
form.append('file', data);
|
|
form.set('id', this._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|Blob} data 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(data, onProgress, onSuccess, onFailure) {
|
|
return this.uploadWithBaseUrl(undefined, data, onProgress, onSuccess, onFailure);
|
|
},
|
|
|
|
/**
|
|
* Download the file from a given URL using GET request. This method works with the Tinode server only.
|
|
*
|
|
* @memberof Tinode.LargeFileHelper#
|
|
*
|
|
* @param {string} relativeUrl - URL to download the file from. Must be relative url, i.e. must not contain the host.
|
|
* @param {string=} filename - file name to use for the downloaded file.
|
|
*
|
|
* @returns {Promise} resolved/rejected when the download is completed/failed.
|
|
*/
|
|
download: function(relativeUrl, filename, mimetype, onProgress, onError) {
|
|
if (!Tinode.isRelativeURL(relativeUrl)) {
|
|
// As a security measure refuse to download from an absolute URL.
|
|
if (onError) {
|
|
onError(`The URL '${relativeUrl}' must be relative, not absolute`);
|
|
}
|
|
return;
|
|
}
|
|
if (!this._authToken) {
|
|
if (onError) {
|
|
onError("Must authenticate first");
|
|
}
|
|
return;
|
|
}
|
|
const instance = this;
|
|
// Get data as blob (stored by the browser as a temporary file).
|
|
this.xhr.open('GET', relativeUrl, true);
|
|
this.xhr.setRequestHeader('X-Tinode-APIKey', this._apiKey);
|
|
this.xhr.setRequestHeader('X-Tinode-Auth', 'Token ' + this._authToken.token);
|
|
this.xhr.responseType = 'blob';
|
|
|
|
this.onProgress = onProgress;
|
|
this.xhr.onprogress = function(e) {
|
|
if (instance.onProgress) {
|
|
// Passing e.loaded instead of e.loaded/e.total because e.total
|
|
// is always 0 with gzip compression enabled by the server.
|
|
instance.onProgress(e.loaded);
|
|
}
|
|
};
|
|
|
|
const result = new Promise((resolve, reject) => {
|
|
this.toResolve = resolve;
|
|
this.toReject = reject;
|
|
});
|
|
|
|
// The blob needs to be saved as file. There is no known way to
|
|
// save the blob as file other than to fake a click on an <a href... download=...>.
|
|
this.xhr.onload = function() {
|
|
if (this.status == 200) {
|
|
const link = document.createElement('a');
|
|
// URL.createObjectURL is not available in non-browser environment. This call will fail.
|
|
link.href = window.URL.createObjectURL(new Blob([this.response], {
|
|
type: mimetype
|
|
}));
|
|
link.style.display = 'none';
|
|
link.setAttribute('download', filename);
|
|
document.body.appendChild(link);
|
|
link.click();
|
|
document.body.removeChild(link);
|
|
window.URL.revokeObjectURL(link.href);
|
|
if (instance.toResolve) {
|
|
instance.toResolve();
|
|
}
|
|
} else if (this.status >= 400 && instance.toReject) {
|
|
// The this.responseText is undefined, must use this.response which is a blob.
|
|
// Need to convert this.response to JSON. The blob can only be accessed by the
|
|
// FileReader.
|
|
const reader = new FileReader();
|
|
reader.onload = function() {
|
|
try {
|
|
const pkt = JSON.parse(this.result, jsonParseHelper);
|
|
instance.toReject(new Error(`${pkt.ctrl.text} (${pkt.ctrl.code})`));
|
|
} catch (err) {
|
|
instance._tinode.logger("ERROR: Invalid server response in LargeFileHelper", this.result);
|
|
instance.toReject(err);
|
|
}
|
|
};
|
|
reader.readAsText(this.response);
|
|
}
|
|
};
|
|
|
|
this.xhr.onerror = function(e) {
|
|
if (instance.toReject) {
|
|
instance.toReject(new Error("failed"));
|
|
}
|
|
};
|
|
|
|
this.xhr.onabort = function() {
|
|
if (instance.toReject) {
|
|
instance.toReject(null);
|
|
}
|
|
};
|
|
|
|
try {
|
|
this.xhr.send();
|
|
} catch (err) {
|
|
if (this.toReject) {
|
|
this.toReject(err);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* Try to cancel an ongoing upload or download.
|
|
* @memberof Tinode.LargeFileHelper#
|
|
*/
|
|
cancel: function() {
|
|
if (this.xhr && this.xhr.readyState < 4) {
|
|
this.xhr.abort();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get unique id of this request.
|
|
* @memberof Tinode.LargeFileHelper#
|
|
*
|
|
* @returns {string} unique id
|
|
*/
|
|
getId: function() {
|
|
return this._msgId;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @class Message - definition a communication message.
|
|
* Work in progress.
|
|
* @memberof Tinode
|
|
*
|
|
* @param {string} topic_ - name of the topic the message belongs to.
|
|
* @param {string | Drafty} content_ - message contant.
|
|
*/
|
|
var Message = function(topic_, content_) {
|
|
this.status = Message.STATUS_NONE;
|
|
this.topic = topic_;
|
|
this.content = content_;
|
|
}
|
|
|
|
Message.STATUS_NONE = MESSAGE_STATUS_NONE;
|
|
Message.STATUS_QUEUED = MESSAGE_STATUS_QUEUED;
|
|
Message.STATUS_SENDING = MESSAGE_STATUS_SENDING;
|
|
Message.STATUS_FAILED = MESSAGE_STATUS_FAILED;
|
|
Message.STATUS_SENT = MESSAGE_STATUS_SENT;
|
|
Message.STATUS_RECEIVED = MESSAGE_STATUS_RECEIVED;
|
|
Message.STATUS_READ = MESSAGE_STATUS_READ;
|
|
Message.STATUS_TO_ME = MESSAGE_STATUS_TO_ME;
|
|
|
|
Message.prototype = {
|
|
/**
|
|
* Convert message object to {pub} packet.
|
|
*/
|
|
toJSON: function() {
|
|
|
|
},
|
|
/**
|
|
* Parse JSON into message.
|
|
*/
|
|
fromJSON: function(json) {
|
|
|
|
}
|
|
}
|
|
Message.prototype.constructor = Message;
|
|
|
|
if (typeof module != 'undefined') {
|
|
module.exports = Tinode;
|
|
module.exports.Drafty = Drafty;
|
|
module.exports.AccessMode = AccessMode;
|
|
}
|
|
|
|
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
|
|
},{"../version.json":4,"./db.js":1,"./drafty.js":2}],4:[function(require,module,exports){
|
|
module.exports={"version": "0.17.0"}
|
|
|
|
},{}]},{},[3])(3)
|
|
});
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","src/db.js","src/drafty.js","src/tinode.js","version.json"],"names":[],"mappings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lbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC1nDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7+LA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/**\n * @file Helper methods for dealing with IndexedDB cache of messages, users, and topics.\n * See <a href=\"https://github.com/tinode/webapp\">https://github.com/tinode/webapp</a> for real-life usage.\n *\n * @copyright 2015-2021 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.17\n */\n'use strict';\n\nconst DB_VERSION = 1;\nconst DB_NAME = 'tinode-web';\n\nconst DB = function(onError, logger) {\n  onError = onError || function() {}\n  logger = logger || function() {}\n\n  // Placeholder DB which does nothing.\n  let db = null;\n\n  // Serializable topic fields.\n  const topic_fields = ['created', 'updated', 'deleted', 'read', 'recv', 'seq', 'clear', 'defacs',\n    'creds', 'public', 'private', 'touched'\n  ];\n\n  function serializeTopic(topic) {\n    const res = {\n      name: topic.name\n    };\n    topic_fields.forEach((f) => {\n      if (topic.hasOwnProperty(f)) {\n        res[f] = topic[f];\n      }\n    });\n    if (Array.isArray(topic._tags)) {\n      res.tags = topic._tags;\n    }\n    if (topic.acs) {\n      res.acs = topic.getAccessMode().jsonHelper();\n    }\n    return res;\n  }\n\n  // Copy data from src to topic.\n  function deserializeTopic(topic, src) {\n    topic_fields.forEach((f) => {\n      if (src.hasOwnProperty(f)) {\n        topic[f] = src[f];\n      }\n    });\n    if (Array.isArray(src.tags)) {\n      topic._tags = src.tags;\n    }\n    if (src.acs) {\n      topic.setAccessMode(src.acs);\n    }\n  }\n\n  function serializeUser(user) {\n    return {};\n  }\n\n  function serializeMessage(topicName, msg) {\n    // Serializable fields.\n    const fields = ['topic', 'seq', 'ts', 'status', 'from', 'head', 'content'];\n    const res = {\n      topic: topicName\n    };\n    fields.forEach((f) => {\n      if (msg.hasOwnProperty(f)) {\n        res[f] = msg[f];\n      }\n    });\n    return res;\n  }\n\n  return {\n    /**\n     * Initialize persistent cache: open or create/upgrade if needed.\n     * @returns {Promise} promise to be resolved/rejected when the DB is initialized.\n     */\n    initDatabase: function() {\n      return new Promise((resolve, reject) => {\n        // Open the database and initialize callbacks.\n        const req = indexedDB.open(DB_NAME, DB_VERSION);\n        req.onerror = (event) => {\n          logger(\"PCache\", \"failed to initialize\", event);\n          reject(event.target.error);\n          if (onError) {\n            onError(event.target.error);\n          }\n        };\n\n        req.onsuccess = (event) => {\n          db = event.target.result;\n          resolve(db);\n        };\n\n        req.onupgradeneeded = function(event) {\n          db = event.target.result;\n\n          db.onerror = function(event) {\n            logger(\"PCache\", \"failed to create storage\", event);\n            if (onError) {\n              onError(event.target.error);\n            }\n          };\n\n          // Individual object stores.\n\n          // Object store (table) for topics. The primary key is topic name.\n          db.createObjectStore('topic', {\n            keyPath: 'name'\n          });\n\n          // Users object store. UID is the primary key.\n          db.createObjectStore('user', {\n            keyPath: 'uid'\n          });\n\n          // Messages object store. The primary key is topic name + seq.\n          db.createObjectStore('message', {\n            keyPath: ['topic', 'seq']\n          });\n        };\n      });\n    },\n\n    /**\n     * Delete persistent cache.\n     */\n    deleteDatabase: function() {\n      return new Promise((resolve, reject) => {\n        const req = indexedDB.deleteDatabase(DB_NAME);\n        req.onerror = function(event) {\n          logger(\"PCache\", \"deleteDatabase\", event.target.error);\n          reject(event.target.error);\n        };\n        req.onsuccess = function(event) {\n          resolve(true);\n        };\n      });\n    },\n\n    /**\n     * Check if persistent cache is ready for use.\n     * @returns {boolean} <code>true</code> if cache is ready, <code>false</code> otherwise.\n     */\n    isReady: function() {\n      return !!db;\n    },\n\n    // Topics.\n    /**\n     * Serialize topic and write to database.\n     * @memberOf DB\n     * @param {Topic} topic - topic to be added to persistent storage.\n     * @returns {Promise} promise resolved/rejected on operation completion.\n     */\n    addTopic: function(topic) {\n      if (!this.isReady()) {\n        return Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['topic'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"addTopic\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('topic').add(serializeTopic(topic));\n        trx.commit();\n      });\n    },\n\n    /**\n     * Remove topic from the database.\n     * @memberOf DB\n     * @param {string} name - name of the topic to remove from database.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    remTopic: function(name) {\n      if (!this.isReady()) {\n        return Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['topic', 'message'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"remTopic\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('topic').delete(IDBKeyRange.only(name));\n        trx.objectStore('message').delete(IDBKeyRange.bound([name, 0], [name, Number.MAX_SAFE_INTEGER]));\n        trx.commit();\n      });\n    },\n    /**\n     * Update stored topic.\n     * @memberOf DB\n     * @param {Topic} topic - topic to update.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    updTopic: function(topic) {\n      if (!this.isReady()) {\n        return Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['topic'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"updTopic\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('topic').put(serializeTopic(topic));\n        trx.commit();\n      });\n    },\n    /**\n     * Execute a callback for each stored topic.\n     * @memberOf DB\n     * @param {function} callback - function to call for each topic.\n     * @param {Object} context - the value or <code>this</code> inside the callback.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    mapTopics: function(callback, context) {\n      if (!this.isReady()) {\n        return Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['topic']);\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"mapTopics\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('topic').getAll().onsuccess = (event) => {\n          if (callback) {\n            event.target.result.forEach((topic) => {\n              callback.call(context, topic);\n            });\n          }\n          resolve(event.target.result);\n        };\n      });\n    },\n\n    /**\n     * Copy data from serialized object to topic.\n     * @memberOf DB\n     * @param {Topic} topic - target to deserialize to.\n     * @param {Object} src - serialized data to copy from.\n     */\n    deserializeTopic: function(topic, src) {\n      deserializeTopic(topic, src);\n    },\n\n    // Users.\n    addUser: function(user) {\n      if (!this.isReady()) {\n        return Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['user'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"addUser\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('user').add(serializeUser(user));\n        trx.commit();\n      });\n    },\n\n    remUser: function(uid) {\n      if (!this.isReady()) {\n        return Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['user'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"remUser\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('user').delete(IDBKeyRange.only(uid));\n        trx.commit();\n      });\n    },\n\n    // Messages.\n    /**\n     * Save message to persistent cache.\n     * @memberOf DB\n     * @param {string} topicName - name of the topic which owns the message.\n     * @param {Object} msg - message to save.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    addMessage: function(topicName, msg) {\n      if (!this.isReady()) {\n        return Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['message'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"addMesssage\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('message').add(serializeMessage(topicName, msg));\n        trx.commit();\n      });\n    },\n\n    /**\n     * Update message stored in persistent cache.\n     * @memberOf DB\n     * @param {string} topicName - name of the topic which owns the message.\n     * @param {Object} msg - message to update.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    updMessage: function(topicName, msg) {\n      if (!this.isReady()) {\n        return Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        const trx = db.transaction(['message'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"updMessage\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('message').put(serializeMessage(topicName, msg));\n        trx.commit();\n      });\n    },\n\n    /**\n     * Remove one or more messages from persistent cache.\n     * @memberOf DB\n     * @param {string} topicName - name of the topic which owns the message.\n     * @param {number} from - id of the message to remove or lower boundary when removing range (inclusive).\n     * @param {number=} to - upper boundary (exclusive) when removing a range of messages.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    remMessages: function(topicName, from, to) {\n      if (!this.isReady()) {\n        return Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        if (!from && !to) {\n          from = 0;\n          to = Number.MAX_SAFE_INTEGER;\n        }\n        const range = to > 0 ? IDBKeyRange.bound([topicName, from], [topicName, to], false, true) :\n          IDBKeyRange.only([topicName, from]);\n        const trx = db.transaction(['message'], 'readwrite');\n        trx.onsuccess = (event) => {\n          resolve(event.target.result);\n        };\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"remMessages\", event.target.error);\n          reject(event.target.error);\n        };\n        trx.objectStore('message').delete(range);\n        trx.commit();\n      });\n    },\n\n    /**\n     * Retrieve messages from persistent store.\n     * @memberOf DB\n     * @param {string} topicName - name of the topic to retrieve messages from.\n     * @param {function} callback to call for each retrieved message.\n     * @param {Object} query - parameters of the message range to retrieve.\n     * @param {number=} query.from - the least message ID to retrieve (inclusive).\n     * @param {number=} query.to - the greatest message ID to retrieve (exclusive).\n     * @param {number=} query.limit - the maximum number of messages to retrieve.\n     * @return {Promise} promise resolved/rejected on operation completion.\n     */\n    readMessages: function(topicName, query, callback, context) {\n      if (!this.isReady()) {\n        return Promise.reject(new Error(\"not initialized\"));\n      }\n      return new Promise((resolve, reject) => {\n        query = query || {};\n        const from = query.from > 0 ? query.from : 0;\n        const to = query.to > 0 ? query.to : Number.MAX_SAFE_INTEGER;\n        const limit = query.limit | 0;\n\n        const result = [];\n        const range = IDBKeyRange.bound([topicName, from], [topicName, to], false, true);\n        const trx = db.transaction(['message']);\n        trx.onerror = (event) => {\n          logger(\"PCache\", \"readMessages\", event.target.error);\n          reject(event.target.error);\n        };\n        // Iterate in descending order.\n        trx.objectStore('message').openCursor(range, 'prev').onsuccess = (event) => {\n          const cursor = event.target.result;\n          if (cursor) {\n            if (callback) {\n              callback.call(context, cursor.value);\n            }\n            result.push(cursor.value);\n            if (limit <= 0 || result.length < limit) {\n              cursor.continue();\n            }\n          } else {\n            resolve(result);\n          }\n        };\n      });\n    }\n  };\n}\n\nif (typeof module != 'undefined') {\n  module.exports = DB;\n}\n","/**\n * @copyright 2015-2021 Tinode\n * @summary Minimally rich text representation and formatting for Tinode.\n * @license Apache 2.0\n * @version 0.16\n *\n * @file Basic parser and formatter for very simple text markup. Mostly targeted at\n * mobile use cases similar to Telegram, WhatsApp, and FB Messenger.\n *\n * <p>Supports conversion of user keyboard input to formatted text:</p>\n * <ul>\n *   <li>*abc* &rarr; <b>abc</b></li>\n *   <li>_abc_ &rarr; <i>abc</i></li>\n *   <li>~abc~ &rarr; <del>abc</del></li>\n *   <li>`abc` &rarr; <tt>abc</tt></li>\n * </ul>\n * Also supports forms and buttons.\n *\n * Nested formatting is supported, e.g. *abc _def_* -> <b>abc <i>def</i></b>\n * URLs, @mentions, and #hashtags are extracted and converted into links.\n * Forms and buttons can be added procedurally.\n * JSON data representation is inspired by Draft.js raw formatting.\n *\n *\n * @example\n * Text:\n * <pre>\n *     this is *bold*, `code` and _italic_, ~strike~\n *     combined *bold and _italic_*\n *     an url: https://www.example.com/abc#fragment and another _www.tinode.co_\n *     this is a @mention and a #hashtag in a string\n *     second #hashtag\n * </pre>\n *\n *  Sample JSON representation of the text above:\n *  {\n *     \"txt\": \"this is bold, code and italic, strike combined bold and italic an url: https://www.example.com/abc#fragment \" +\n *             \"and another www.tinode.co this is a @mention and a #hashtag in a string second #hashtag\",\n *     \"fmt\": [\n *         { \"at\":8, \"len\":4,\"tp\":\"ST\" },{ \"at\":14, \"len\":4, \"tp\":\"CO\" },{ \"at\":23, \"len\":6, \"tp\":\"EM\"},\n *         { \"at\":31, \"len\":6, \"tp\":\"DL\" },{ \"tp\":\"BR\", \"len\":1, \"at\":37 },{ \"at\":56, \"len\":6, \"tp\":\"EM\" },\n *         { \"at\":47, \"len\":15, \"tp\":\"ST\" },{ \"tp\":\"BR\", \"len\":1, \"at\":62 },{ \"at\":120, \"len\":13, \"tp\":\"EM\" },\n *         { \"at\":71, \"len\":36, \"key\":0 },{ \"at\":120, \"len\":13, \"key\":1 },{ \"tp\":\"BR\", \"len\":1, \"at\":133 },\n *         { \"at\":144, \"len\":8, \"key\":2 },{ \"at\":159, \"len\":8, \"key\":3 },{ \"tp\":\"BR\", \"len\":1, \"at\":179 },\n *         { \"at\":187, \"len\":8, \"key\":3 },{ \"tp\":\"BR\", \"len\":1, \"at\":195 }\n *     ],\n *     \"ent\": [\n *         { \"tp\":\"LN\", \"data\":{ \"url\":\"https://www.example.com/abc#fragment\" } },\n *         { \"tp\":\"LN\", \"data\":{ \"url\":\"http://www.tinode.co\" } },\n *         { \"tp\":\"MN\", \"data\":{ \"val\":\"mention\" } },\n *         { \"tp\":\"HT\", \"data\":{ \"val\":\"hashtag\" } }\n *     ]\n *  }\n */\n\n'use strict';\n\nconst MAX_FORM_ELEMENTS = 8;\nconst JSON_MIME_TYPE = 'application/json';\n\n// Regular expressions for parsing inline formats. Javascript does not support lookbehind,\n// so it's a bit messy.\nconst INLINE_STYLES = [\n  // Strong = bold, *bold text*\n  {\n    name: 'ST',\n    start: /(?:^|[\\W_])(\\*)[^\\s*]/,\n    end: /[^\\s*](\\*)(?=$|[\\W_])/\n  },\n  // Emphesized = italic, _italic text_\n  {\n    name: 'EM',\n    start: /(?:^|\\W)(_)[^\\s_]/,\n    end: /[^\\s_](_)(?=$|\\W)/\n  },\n  // Deleted, ~strike this though~\n  {\n    name: 'DL',\n    start: /(?:^|[\\W_])(~)[^\\s~]/,\n    end: /[^\\s~](~)(?=$|[\\W_])/\n  },\n  // Code block `this is monospace`\n  {\n    name: 'CO',\n    start: /(?:^|\\W)(`)[^`]/,\n    end: /[^`](`)(?=$|\\W)/\n  }\n];\n\n// RegExps for entity extraction (RF = reference)\nconst ENTITY_TYPES = [\n  // URLs\n  {\n    name: 'LN',\n    dataName: 'url',\n    pack: function(val) {\n      // Check if the protocol is specified, if not use http\n      if (!/^[a-z]+:\\/\\//i.test(val)) {\n        val = 'http://' + val;\n      }\n      return {\n        url: val\n      };\n    },\n    re: /(?:(?:https?|ftp):\\/\\/|www\\.|ftp\\.)[-A-Z0-9+&@#\\/%=~_|$?!:,.]*[A-Z0-9+&@#\\/%=~_|$]/ig\n  },\n  // Mentions @user (must be 2 or more characters)\n  {\n    name: 'MN',\n    dataName: 'val',\n    pack: function(val) {\n      return {\n        val: val.slice(1)\n      };\n    },\n    re: /\\B@(\\w\\w+)/g\n  },\n  // Hashtags #hashtag, like metion 2 or more characters.\n  {\n    name: 'HT',\n    dataName: 'val',\n    pack: function(val) {\n      return {\n        val: val.slice(1)\n      };\n    },\n    re: /\\B#(\\w\\w+)/g\n  }\n];\n\n// HTML tag name suggestions\nconst HTML_TAGS = {\n  ST: {\n    name: 'b',\n    isVoid: false\n  },\n  EM: {\n    name: 'i',\n    isVoid: false\n  },\n  DL: {\n    name: 'del',\n    isVoid: false\n  },\n  CO: {\n    name: 'tt',\n    isVoid: false\n  },\n  BR: {\n    name: 'br',\n    isVoid: true\n  },\n  LN: {\n    name: 'a',\n    isVoid: false\n  },\n  MN: {\n    name: 'a',\n    isVoid: false\n  },\n  HT: {\n    name: 'a',\n    isVoid: false\n  },\n  IM: {\n    name: 'img',\n    isVoid: true\n  },\n  FM: {\n    name: 'div',\n    isVoid: false\n  },\n  RW: {\n    name: 'div',\n    isVoid: false,\n  },\n  BN: {\n    name: 'button',\n    isVoid: false\n  },\n  HD: {\n    name: '',\n    isVoid: false\n  },\n  HL: {\n    name: 'span',\n    isVoid: false\n  }\n};\n\n// Convert base64-encoded string into Blob.\nfunction base64toObjectUrl(b64, contentType, logger) {\n  if (!b64) {\n    return null;\n  }\n\n  try {\n    const bin = atob(b64);\n    const length = bin.length;\n    const buf = new ArrayBuffer(length);\n    const arr = new Uint8Array(buf);\n    for (let i = 0; i < length; i++) {\n      arr[i] = bin.charCodeAt(i);\n    }\n\n    return URL.createObjectURL(new Blob([buf], {\n      type: contentType\n    }));\n  } catch (err) {\n    if (logger) {\n      logger(\"Drafty: failed to convert object.\", err.message);\n    }\n  }\n\n  return null;\n}\n\nfunction base64toDataUrl(b64, contentType) {\n  if (!b64) {\n    return null;\n  }\n  contentType = contentType || 'image/jpeg';\n  return 'data:' + contentType + ';base64,' + b64;\n}\n\n// Helpers for converting Drafty to HTML.\nconst DECORATORS = {\n  // Visial styles\n  ST: {\n    open: function() {\n      return '<b>';\n    },\n    close: function() {\n      return '</b>';\n    }\n  },\n  EM: {\n    open: function() {\n      return '<i>';\n    },\n    close: function() {\n      return '</i>'\n    }\n  },\n  DL: {\n    open: function() {\n      return '<del>';\n    },\n    close: function() {\n      return '</del>'\n    }\n  },\n  CO: {\n    open: function() {\n      return '<tt>';\n    },\n    close: function() {\n      return '</tt>'\n    }\n  },\n  // Line break\n  BR: {\n    open: function() {\n      return '<br/>';\n    },\n    close: function() {\n      return ''\n    }\n  },\n  // Hidden element\n  HD: {\n    open: function() {\n      return '';\n    },\n    close: function() {\n      return '';\n    }\n  },\n  // Highlighted element.\n  HL: {\n    open: function() {\n      return '<span style=\"color:teal\">';\n    },\n    close: function() {\n      return '</span>';\n    }\n  },\n  // Link (URL)\n  LN: {\n    open: function(data) {\n      return '<a href=\"' + data.url + '\">';\n    },\n    close: function(data) {\n      return '</a>';\n    },\n    props: function(data) {\n      return data ? {\n        href: data.url,\n        target: \"_blank\"\n      } : null;\n    },\n  },\n  // Mention\n  MN: {\n    open: function(data) {\n      return '<a href=\"#' + data.val + '\">';\n    },\n    close: function(data) {\n      return '</a>';\n    },\n    props: function(data) {\n      return data ? {\n        name: data.val\n      } : null;\n    },\n  },\n  // Hashtag\n  HT: {\n    open: function(data) {\n      return '<a href=\"#' + data.val + '\">';\n    },\n    close: function(data) {\n      return '</a>';\n    },\n    props: function(data) {\n      return data ? {\n        name: data.val\n      } : null;\n    },\n  },\n  // Button\n  BN: {\n    open: function(data) {\n      return '<button>';\n    },\n    close: function(data) {\n      return '</button>';\n    },\n    props: function(data) {\n      return data ? {\n        'data-act': data.act,\n        'data-val': data.val,\n        'data-name': data.name,\n        'data-ref': data.ref\n      } : null;\n    },\n  },\n  // Image\n  IM: {\n    open: function(data) {\n      // Don't use data.ref for preview: it's a security risk.\n      const tmpPreviewUrl = base64toDataUrl(data._tempPreview, data.mime);\n      const previewUrl = base64toObjectUrl(data.val, data.mime, Drafty.logger);\n      const downloadUrl = data.ref || previewUrl;\n      return (data.name ? '<a href=\"' + downloadUrl + '\" download=\"' + data.name + '\">' : '') +\n        '<img src=\"' + (tmpPreviewUrl || previewUrl) + '\"' +\n        (data.width ? ' width=\"' + data.width + '\"' : '') +\n        (data.height ? ' height=\"' + data.height + '\"' : '') + ' border=\"0\" />';\n    },\n    close: function(data) {\n      return (data.name ? '</a>' : '');\n    },\n    props: function(data) {\n      if (!data) return null;\n      return {\n        // Temporary preview, or permanent preview, or external link.\n        src: base64toDataUrl(data._tempPreview, data.mime) ||\n          data.ref || base64toObjectUrl(data.val, data.mime, Drafty.logger),\n        title: data.name,\n        'data-width': data.width,\n        'data-height': data.height,\n        'data-name': data.name,\n        'data-size': data.val ? ((data.val.length * 0.75) | 0) : (data.size | 0),\n        'data-mime': data.mime\n      };\n    },\n  },\n  // Form - structured layout of elements.\n  FM: {\n    open: function(data) {\n      return '<div>';\n    },\n    close: function(data) {\n      return '</div>';\n    }\n  },\n  // Row: logic grouping of elements\n  RW: {\n    open: function(data) {\n      return '<div>';\n    },\n    close: function(data) {\n      return '</div>';\n    }\n  }\n};\n\n/**\n * The main object which performs all the formatting actions.\n * @class Drafty\n * @constructor\n */\nconst Drafty = function() {}\n\n// Take a string and defined earlier style spans, re-compose them into a tree where each leaf is\n// a same-style (including unstyled) string. I.e. 'hello *bold _italic_* and ~more~ world' ->\n// ('hello ', (b: 'bold ', (i: 'italic')), ' and ', (s: 'more'), ' world');\n//\n// This is needed in order to clear markup, i.e. 'hello *world*' -> 'hello world' and convert\n// ranges from markup-ed offsets to plain text offsets.\nfunction chunkify(line, start, end, spans) {\n  const chunks = [];\n\n  if (spans.length == 0) {\n    return [];\n  }\n\n  for (let i in spans) {\n    // Get the next chunk from the queue\n    const span = spans[i];\n\n    // Grab the initial unstyled chunk\n    if (span.start > start) {\n      chunks.push({\n        text: line.slice(start, span.start)\n      });\n    }\n\n    // Grab the styled chunk. It may include subchunks.\n    const chunk = {\n      type: span.type\n    };\n    const chld = chunkify(line, span.start + 1, span.end, span.children);\n    if (chld.length > 0) {\n      chunk.children = chld;\n    } else {\n      chunk.text = span.text;\n    }\n    chunks.push(chunk);\n    start = span.end + 1; // '+1' is to skip the formatting character\n  }\n\n  // Grab the remaining unstyled chunk, after the last span\n  if (start < end) {\n    chunks.push({\n      text: line.slice(start, end)\n    });\n  }\n\n  return chunks;\n}\n\n// Inverse of chunkify. Returns a tree of formatted spans.\nfunction forEach(line, start, end, spans, formatter, context) {\n  const result = [];\n\n  // Process ranges calling formatter for each range.\n  for (let i = 0; i < spans.length; i++) {\n    const span = spans[i];\n    if (span.at < 0) {\n      // Ask formatter if it wants to do anything with the non-visual span.\n      const s = formatter.call(context, span.tp, span.data, undefined, result.length);\n      if (s) {\n        result.push(s);\n      }\n      continue;\n    }\n    // Add un-styled range before the styled span starts.\n    if (start < span.at) {\n      result.push(formatter.call(context, null, undefined, line.slice(start, span.at), result.length));\n      start = span.at;\n    }\n    // Get all spans which are within current span.\n    const subspans = [];\n    for (let si = i + 1; si < spans.length && spans[si].at < span.at + span.len; si++) {\n      subspans.push(spans[si]);\n      i = si;\n    }\n\n    const tag = HTML_TAGS[span.tp] || {}\n    result.push(formatter.call(context, span.tp, span.data,\n      tag.isVoid ? null : forEach(line, start, span.at + span.len, subspans, formatter, context),\n      result.length));\n\n    start = span.at + span.len;\n  }\n\n  // Add the last unformatted range.\n  if (start < end) {\n    result.push(formatter.call(context, null, undefined, line.slice(start, end), result.length));\n  }\n\n  return result;\n}\n\n// Detect starts and ends of formatting spans. Unformatted spans are\n// ignored at this stage.\nfunction spannify(original, re_start, re_end, type) {\n  const result = [];\n  let index = 0;\n  let line = original.slice(0); // make a copy;\n\n  while (line.length > 0) {\n    // match[0]; // match, like '*abc*'\n    // match[1]; // match captured in parenthesis, like 'abc'\n    // match['index']; // offset where the match started.\n\n    // Find the opening token.\n    const start = re_start.exec(line);\n    if (start == null) {\n      break;\n    }\n\n    // Because javascript RegExp does not support lookbehind, the actual offset may not point\n    // at the markup character. Find it in the matched string.\n    let start_offset = start['index'] + start[0].lastIndexOf(start[1]);\n    // Clip the processed part of the string.\n    line = line.slice(start_offset + 1);\n    // start_offset is an offset within the clipped string. Convert to original index.\n    start_offset += index;\n    // Index now point to the beginning of 'line' within the 'original' string.\n    index = start_offset + 1;\n\n    // Find the matching closing token.\n    const end = re_end ? re_end.exec(line) : null;\n    if (end == null) {\n      break;\n    }\n    let end_offset = end['index'] + end[0].indexOf(end[1]);\n    // Clip the processed part of the string.\n    line = line.slice(end_offset + 1);\n    // Update offsets\n    end_offset += index;\n    // Index now point to the beginning of 'line' within the 'original' string.\n    index = end_offset + 1;\n\n    result.push({\n      text: original.slice(start_offset + 1, end_offset),\n      children: [],\n      start: start_offset,\n      end: end_offset,\n      type: type\n    });\n  }\n\n  return result;\n}\n\n// Convert linear array or spans into a tree representation.\n// Keep standalone and nested spans, throw away partially overlapping spans.\nfunction toTree(spans) {\n  if (spans.length == 0) {\n    return [];\n  }\n\n  const tree = [spans[0]];\n  let last = spans[0];\n  for (let i = 1; i < spans.length; i++) {\n    // Keep spans which start after the end of the previous span or those which\n    // are complete within the previous span.\n\n    if (spans[i].start > last.end) {\n      // Span is completely outside of the previous span.\n      tree.push(spans[i]);\n      last = spans[i];\n    } else if (spans[i].end < last.end) {\n      // Span is fully inside of the previous span. Push to subnode.\n      last.children.push(spans[i]);\n    }\n    // Span could partially overlap, ignoring it as invalid.\n  }\n\n  // Recursively rearrange the subnodes.\n  for (let i in tree) {\n    tree[i].children = toTree(tree[i].children);\n  }\n\n  return tree;\n}\n\n// Get a list of entities from a text.\nfunction extractEntities(line) {\n  let match;\n  let extracted = [];\n  ENTITY_TYPES.map(function(entity) {\n    while ((match = entity.re.exec(line)) !== null) {\n      extracted.push({\n        offset: match['index'],\n        len: match[0].length,\n        unique: match[0],\n        data: entity.pack(match[0]),\n        type: entity.name\n      });\n    }\n  });\n\n  if (extracted.length == 0) {\n    return extracted;\n  }\n\n  // Remove entities detected inside other entities, like #hashtag in a URL.\n  extracted.sort(function(a, b) {\n    return a.offset - b.offset;\n  });\n\n  let idx = -1;\n  extracted = extracted.filter(function(el) {\n    const result = (el.offset > idx);\n    idx = el.offset + el.len;\n    return result;\n  });\n\n  return extracted;\n}\n\n// Convert the chunks into format suitable for serialization.\nfunction draftify(chunks, startAt) {\n  let plain = \"\";\n  let ranges = [];\n  for (let i in chunks) {\n    const chunk = chunks[i];\n    if (!chunk.text) {\n      const drafty = draftify(chunk.children, plain.length + startAt);\n      chunk.text = drafty.txt;\n      ranges = ranges.concat(drafty.fmt);\n    }\n\n    if (chunk.type) {\n      ranges.push({\n        at: plain.length + startAt,\n        len: chunk.text.length,\n        tp: chunk.type\n      });\n    }\n\n    plain += chunk.text;\n  }\n  return {\n    txt: plain,\n    fmt: ranges\n  };\n}\n\n// Splice two strings: insert second string into the first one at the given index\nfunction splice(src, at, insert) {\n  return src.slice(0, at) + insert + src.slice(at);\n}\n\n/**\n * Parse plain text into Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {String} content - plain-text content to parse.\n * @return {Drafty} parsed document or null if the source is not plain text.\n */\nDrafty.parse = function(content) {\n  // Make sure we are parsing strings only.\n  if (typeof content != 'string') {\n    return null;\n  }\n\n  // Split text into lines. It makes further processing easier.\n  const lines = content.split(/\\r?\\n/);\n\n  // Holds entities referenced from text\n  const entityMap = [];\n  const entityIndex = {};\n\n  // Processing lines one by one, hold intermediate result in blx.\n  const blx = [];\n  lines.map(function(line) {\n    let spans = [];\n    let entities;\n\n    // Find formatted spans in the string.\n    // Try to match each style.\n    INLINE_STYLES.map(function(style) {\n      // Each style could be matched multiple times.\n      spans = spans.concat(spannify(line, style.start, style.end, style.name));\n    });\n\n    let block;\n    if (spans.length == 0) {\n      block = {\n        txt: line\n      };\n    } else {\n      // Sort spans by style occurence early -> late\n      spans.sort(function(a, b) {\n        return a.start - b.start;\n      });\n\n      // Convert an array of possibly overlapping spans into a tree\n      spans = toTree(spans);\n\n      // Build a tree representation of the entire string, not\n      // just the formatted parts.\n      const chunks = chunkify(line, 0, line.length, spans);\n\n      const drafty = draftify(chunks, 0);\n\n      block = {\n        txt: drafty.txt,\n        fmt: drafty.fmt\n      };\n    }\n\n    // Extract entities from the cleaned up string.\n    entities = extractEntities(block.txt);\n    if (entities.length > 0) {\n      const ranges = [];\n      for (let i in entities) {\n        // {offset: match['index'], unique: match[0], len: match[0].length, data: ent.packer(), type: ent.name}\n        const entity = entities[i];\n        let index = entityIndex[entity.unique];\n        if (!index) {\n          index = entityMap.length;\n          entityIndex[entity.unique] = index;\n          entityMap.push({\n            tp: entity.type,\n            data: entity.data\n          });\n        }\n        ranges.push({\n          at: entity.offset,\n          len: entity.len,\n          key: index\n        });\n      }\n      block.ent = ranges;\n    }\n\n    blx.push(block);\n  });\n\n  const result = {\n    txt: \"\"\n  };\n\n  // Merge lines and save line breaks as BR inline formatting.\n  if (blx.length > 0) {\n    result.txt = blx[0].txt;\n    result.fmt = (blx[0].fmt || []).concat(blx[0].ent || []);\n\n    for (let i = 1; i < blx.length; i++) {\n      const block = blx[i];\n      const offset = result.txt.length + 1;\n\n      result.fmt.push({\n        tp: 'BR',\n        len: 1,\n        at: offset - 1\n      });\n\n      result.txt += \" \" + block.txt;\n      if (block.fmt) {\n        result.fmt = result.fmt.concat(block.fmt.map(function(s) {\n          s.at += offset;\n          return s;\n        }));\n      }\n      if (block.ent) {\n        result.fmt = result.fmt.concat(block.ent.map(function(s) {\n          s.at += offset;\n          return s;\n        }));\n      }\n    }\n\n    if (result.fmt.length == 0) {\n      delete result.fmt;\n    }\n\n    if (entityMap.length > 0) {\n      result.ent = entityMap;\n    }\n  }\n  return result;\n}\n\n/**\n * Initialize Drafty document to a plain text string.\n *\n * @param {String} plainText - string to use as Drafty content.\n *\n * @returns new Drafty document or null is plainText is not a string.\n */\nDrafty.init = function(plainText) {\n  if (typeof plainText != 'string') {\n    return null;\n  }\n  return {\n    txt: plainText\n  };\n}\n\n/**\n * Append one Drafty document to another.\n *\n * @param {Drafty} first - Drafty document to append to.\n * @param {Drafty} second - Drafty document being appended.\n *\n * @return {Drafty} first document with the second appended to it.\n */\nDrafty.append = function(first, second) {\n  if (first == null) {\n    return second;\n  }\n  if (second == null) {\n    return first;\n  }\n\n  first.txt = first.txt || '';\n  second.txt = second.txt || '';\n  const len = first.txt.length;\n\n  first.txt += second.txt;\n  if (Array.isArray(second.fmt)) {\n    first.fmt = first.fmt || [];\n    if (Array.isArray(second.ent)) {\n      first.ent = first.ent || [];\n    }\n    second.fmt.forEach(src => {\n      const fmt = {\n        at: src.at + len,\n        len: src.len\n      };\n      if (src.tp) {\n        fmt.tp = src.tp;\n      } else {\n        fmt.key = first.ent.length;\n        first.ent.push(second.ent[src.key || 0]);\n      }\n      first.fmt.push(fmt);\n    });\n  }\n\n  return first;\n}\n\n/**\n * @typedef Drafty.ImageDesc\n * @memberof Drafty\n * @type Object\n * @param {string} mime - mime-type of the image, e.g. \"image/png\"\n * @param {string} preview - base64-encoded image content (or preview, if large image is attached). Could be null/undefined.\n * @param {integer} width - width of the image\n * @param {integer} height - height of the image\n * @param {string} filename - file name suggestion for downloading the image.\n * @param {integer} size - size of the image in bytes. Treat is as an untrusted hint.\n * @param {string} refurl - reference to the content. Could be null/undefined.\n * @param {string} _tempPreview - base64-encoded image preview used during upload process; not serializable.\n * @param {Promise} urlPromise - Promise which returns content URL when resolved.\n */\n\n/**\n * Insert inline image into Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to add image to.\n * @param {integer} at - index where the object is inserted. The length of the image is always 1.\n * @param {ImageDesc} imageDesc - object with image paramenets and data.\n *\n * @return {Drafty} updated document.\n */\nDrafty.insertImage = function(content, at, imageDesc) {\n  content = content || {\n    txt: \" \"\n  };\n  content.ent = content.ent || [];\n  content.fmt = content.fmt || [];\n\n  content.fmt.push({\n    at: at,\n    len: 1,\n    key: content.ent.length\n  });\n\n  const ex = {\n    tp: 'IM',\n    data: {\n      mime: imageDesc.mime,\n      val: imageDesc.preview,\n      width: imageDesc.width,\n      height: imageDesc.height,\n      name: imageDesc.filename,\n      size: imageDesc.size | 0,\n      ref: imageDesc.refurl\n    }\n  };\n\n  if (imageDesc.urlPromise) {\n    ex.data._tempPreview = imageDesc._tempPreview;\n    ex.data._processing = true;\n    imageDesc.urlPromise.then(\n      (url) => {\n        ex.data.ref = url;\n        ex.data._tempPreview = undefined;\n        ex.data._processing = undefined;\n      },\n      (err) => {\n        /* catch the error, otherwise it will appear in the console. */\n        ex.data._processing = undefined;\n      }\n    );\n  }\n\n  content.ent.push(ex);\n\n  return content;\n}\n\n/**\n * Append inline image to Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to add image to.\n * @param {ImageDesc} imageDesc - object with image paramenets.\n *\n * @return {Drafty} updated document.\n */\nDrafty.appendImage = function(content, imageDesc) {\n  content = content || {\n    txt: \"\"\n  };\n  content.txt += \" \";\n  return Drafty.insertImage(content, content.txt.length - 1, imageDesc);\n}\n\n/**\n * @typedef Drafty.AttachmentDesc\n * @memberof Drafty\n * @type Object\n * @param {string} mime - mime-type of the image, e.g. \"image/png\"\n * @param {string} data - base64-encoded in-band content of small attachments. Could be null/undefined.\n * @param {string} filename - file name suggestion for downloading the attachment.\n * @param {integer} size - size of the file in bytes. Treat is as an untrusted hint.\n * @param {string} refurl - reference to the out-of-band content. Could be null/undefined.\n * @param {Promise} urlPromise - Promise which returns content URL when resolved.\n */\n\n/**\n * Attach file to Drafty content. Either as a blob or as a reference.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to attach file to.\n * @param {AttachmentDesc} object - containing attachment description and data.\n *\n * @return {Drafty} updated document.\n */\nDrafty.attachFile = function(content, attachmentDesc) {\n  content = content || {\n    txt: \"\"\n  };\n  content.ent = content.ent || [];\n  content.fmt = content.fmt || [];\n\n  content.fmt.push({\n    at: -1,\n    len: 0,\n    key: content.ent.length\n  });\n\n  const ex = {\n    tp: 'EX',\n    data: {\n      mime: attachmentDesc.mime,\n      val: attachmentDesc.data,\n      name: attachmentDesc.filename,\n      ref: attachmentDesc.refurl,\n      size: attachmentDesc.size | 0\n    }\n  }\n  if (attachmentDesc.urlPromise) {\n    ex.data._processing = true;\n    attachmentDesc.urlPromise.then(\n      (url) => {\n        ex.data.ref = url;\n        ex.data._processing = undefined;\n      },\n      (err) => {\n        /* catch the error, otherwise it will appear in the console. */\n        ex.data._processing = undefined;\n      }\n    );\n  }\n  content.ent.push(ex);\n\n  return content;\n}\n\n/**\n * Wraps content into an interactive form.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty|string} content - to wrap into a form.\n * @param {number} at - index where the forms starts.\n * @param {number} len - length of the form content.\n *\n * @return {Drafty} updated document.\n */\nDrafty.wrapAsForm = function(content, at, len) {\n  if (typeof content == 'string') {\n    content = {\n      txt: content\n    };\n  }\n  content.fmt = content.fmt || [];\n\n  content.fmt.push({\n    at: at,\n    len: len,\n    tp: 'FM'\n  });\n\n  return content;\n}\n\n/**\n * Insert clickable button into Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty|string} content - Drafty document to insert button to or a string to be used as button text.\n * @param {number} at - location where the button is inserted.\n * @param {number} len - the length of the text to be used as button title.\n * @param {string} name - the button. Client should return it to the server when the button is clicked.\n * @param {string} actionType - the type of the button, one of 'url' or 'pub'.\n * @param {string} actionValue - the value to return on click:\n * @param {string} refUrl - the URL to go to when the 'url' button is clicked.\n *\n * @return {Drafty} updated document.\n */\nDrafty.insertButton = function(content, at, len, name, actionType, actionValue, refUrl) {\n  if (typeof content == 'string') {\n    content = {\n      txt: content\n    };\n  }\n\n  if (!content || !content.txt || content.txt.length < at + len) {\n    return null;\n  }\n\n  if (len <= 0 || ['url', 'pub'].indexOf(actionType) == -1) {\n    return null;\n  }\n  // Ensure refUrl is a string.\n  if (actionType == 'url' && !refUrl) {\n    return null;\n  }\n  refUrl = '' + refUrl;\n\n  content.ent = content.ent || [];\n  content.fmt = content.fmt || [];\n\n  content.fmt.push({\n    at: at,\n    len: len,\n    key: content.ent.length\n  });\n  content.ent.push({\n    tp: 'BN',\n    data: {\n      act: actionType,\n      val: actionValue,\n      ref: refUrl,\n      name: name\n    }\n  });\n\n  return content;\n}\n\n/**\n * Append clickable button to Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty|string} content - Drafty document to insert button to or a string to be used as button text.\n * @param {string} title - the text to be used as button title.\n * @param {string} name - the button. Client should return it to the server when the button is clicked.\n * @param {string} actionType - the type of the button, one of 'url' or 'pub'.\n * @param {string} actionValue - the value to return on click:\n * @param {string} refUrl - the URL to go to when the 'url' button is clicked.\n *\n * @return {Drafty} updated document.\n */\nDrafty.appendButton = function(content, title, name, actionType, actionValue, refUrl) {\n  content = content || {\n    txt: \"\"\n  };\n  const at = content.txt.length;\n  content.txt += title;\n  return Drafty.insertButton(content, at, title.length, name, actionType, actionValue, refUrl);\n}\n\n/**\n * Attach a generic JS object. The object is attached as a json string.\n * Intended for representing a form response.\n *\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - Drafty document to attach file to.\n * @param {Object} data - data to convert to json string and attach.\n * @returns {Drafty} the same document as <code>content</code>.\n */\nDrafty.attachJSON = function(content, data) {\n  content = content || {\n    txt: \"\"\n  };\n  content.ent = content.ent || [];\n  content.fmt = content.fmt || [];\n\n  content.fmt.push({\n    at: -1,\n    len: 0,\n    key: content.ent.length\n  });\n\n  content.ent.push({\n    tp: 'EX',\n    data: {\n      mime: JSON_MIME_TYPE,\n      val: data\n    }\n  });\n\n  return content;\n}\n/**\n * Append line break to a Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - Drafty document to append linebreak to.\n * @returns {Drafty} the same document as <code>content</code>.\n */\nDrafty.appendLineBreak = function(content) {\n  content = content || {\n    txt: \"\"\n  };\n  content.fmt = content.fmt || [];\n  content.fmt.push({\n    at: content.txt.length,\n    len: 1,\n    tp: 'BR'\n  });\n  content.txt += \" \";\n\n  return content;\n}\n/**\n * Given Drafty document, convert it to HTML.\n * No attempt is made to strip pre-existing html markup.\n * This is potentially unsafe because <code>content.txt</code> may contain malicious\n * markup.\n * @memberof Tinode.Drafty\n * @static\n *\n * @param {Drafy} content - document to convert.\n *\n * @returns {string} HTML-representation of content.\n */\nDrafty.UNSAFE_toHTML = function(content) {\n  let {\n    txt,\n    fmt,\n    ent\n  } = content;\n\n  const markup = [];\n  if (fmt) {\n    for (let i in fmt) {\n      const range = fmt[i];\n      const at = range.at | 0;\n      let tp = range.tp;\n      let data;\n      if (!tp) {\n        const entity = ent[range.key | 0];\n        if (entity) {\n          tp = entity.tp;\n          data = entity.data;\n        }\n      }\n\n      if (DECORATORS[tp]) {\n        // Because we later sort in descending order, closing markup must come first.\n        // Otherwise zero-length objects will not be represented correctly.\n        markup.push({\n          idx: at + range.len,\n          len: -range.len,\n          what: DECORATORS[tp].close(data)\n        });\n        markup.push({\n          idx: at,\n          len: range.len,\n          what: DECORATORS[tp].open(data)\n        });\n      }\n    }\n  }\n\n  markup.sort(function(a, b) {\n    return b.idx == a.idx ? b.len - a.len : b.idx - a.idx; // in descending order\n  });\n\n  for (let i in markup) {\n    if (markup[i].what) {\n      txt = splice(txt, markup[i].idx, markup[i].what);\n    }\n  }\n\n  return txt;\n}\n\n/**\n * Callback for applying custom formatting/transformation to a Drafty document.\n * Called once for each syle span.\n * @memberof Drafty\n * @static\n *\n * @callback Formatter\n * @param {string} style - style code such as \"ST\" or \"IM\".\n * @param {Object} data - entity's data\n * @param {Object} values - possibly styled subspans contained in this style span.\n * @param {number} index - of the current element among its siblings.\n */\n\n/**\n * Transform Drafty document using custom formatting.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - content to transform.\n * @param {Formatter} formatter - callback which transforms individual elements\n * @param {Object} context - context provided to formatter as <code>this</code>.\n *\n * @return {Object} transformed object\n */\nDrafty.format = function(content, formatter, context) {\n  let {\n    txt,\n    fmt,\n    ent\n  } = content;\n\n  // Assign default values.\n  txt = txt || \"\";\n  if (!Array.isArray(ent)) {\n    ent = [];\n  }\n\n  if (!Array.isArray(fmt)) {\n    // Handle special case when all values in fmt are 0 and fmt is skipped.\n    if (ent.length == 1) {\n      fmt = [{\n        at: 0,\n        len: 0,\n        key: 0\n      }];\n    } else {\n      return [txt];\n    }\n  }\n\n  let spans = [].concat(fmt);\n\n  // Zero values may have been stripped. Restore them.\n  // Also ensure indexes and lengths are sane.\n  spans.map(function(s) {\n    s.at = s.at || 0;\n    s.len = s.len || 0;\n    if (s.len < 0) {\n      s.len = 0;\n    }\n    if (s.at < -1) {\n      s.at = -1;\n    }\n  });\n\n  // Sort spans first by start index (asc) then by length (desc).\n  spans.sort(function(a, b) {\n    if (a.at - b.at == 0) {\n      return b.len - a.len; // longer one comes first (<0)\n    }\n    return a.at - b.at;\n  });\n\n  // Denormalize entities into spans. Create a copy of the objects to leave\n  // original Drafty object unchanged.\n  spans = spans.map((s) => {\n    let data;\n    let tp = s.tp;\n    if (!tp) {\n      s.key = s.key || 0;\n      if (ent[s.key]) {\n        data = ent[s.key].data;\n        tp = ent[s.key].tp;\n      }\n    }\n\n    // Type still not defined? Hide invalid element.\n    tp = tp || 'HD';\n\n    return {\n      tp: tp,\n      data: data,\n      at: s.at,\n      len: s.len\n    };\n  });\n\n  return forEach(txt, 0, txt.length, spans, formatter, context);\n}\n\n/**\n * Given Drafty document, convert it to plain text.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to convert to plain text.\n * @returns {string} plain-text representation of the drafty document.\n */\nDrafty.toPlainText = function(content) {\n  return typeof content == 'string' ? content : content.txt;\n}\n\n/**\n * Check if the document has no markup and no entities.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - content to check for presence of markup.\n * @returns <code>true</code> is content is plain text, <code>false</code> otherwise.\n */\nDrafty.isPlainText = function(content) {\n  return typeof content == 'string' || !(content.fmt || content.ent);\n}\n\n/**\n * Checks if the object represets is a valid Drafty document.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - content to check for validity.\n * @returns <code>true</code> is content is valid, <code>false</code> otherwise.\n */\nDrafty.isValid = function(content) {\n  if (!content) {\n    return false;\n  }\n\n  const {\n    txt,\n    fmt,\n    ent\n  } = content;\n\n  if (!txt && txt !== '' && !fmt && !ent) {\n    return false;\n  }\n\n  const txt_type = typeof txt;\n  if (txt_type != 'string' && txt_type != 'undefined' && txt !== null) {\n    return false;\n  }\n\n  if (typeof fmt != 'undefined' && !Array.isArray(fmt) && fmt !== null) {\n    return false;\n  }\n\n  if (typeof ent != 'undefined' && !Array.isArray(ent) && ent !== null) {\n    return false;\n  }\n  return true;\n}\n\n/**\n * Check if the drafty document has attachments.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} content - document to check for attachments.\n * @returns <code>true</code> if there are attachments.\n */\nDrafty.hasAttachments = function(content) {\n  if (content.ent && content.ent.length > 0) {\n    for (let i in content.ent) {\n      if (content.ent[i] && content.ent[i].tp == 'EX') {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * Callback for applying custom formatting/transformation to a Drafty document.\n * Called once for each 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 - document to process for attachments.\n * @param {AttachmentCallback} callback - callback to call for each attachment.\n * @param {Object} context - value of \"this\" for callback.\n */\nDrafty.attachments = function(content, callback, context) {\n  if (content.ent && content.ent.length > 0) {\n    for (let i in content.ent) {\n      if (content.ent[i] && content.ent[i].tp == 'EX') {\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} entData - entity.data to get the URl from.\n * @returns {string} URL to download entity data or <code>null</code>.\n */\nDrafty.getDownloadUrl = function(entData) {\n  let url = null;\n  if (entData.mime != JSON_MIME_TYPE && entData.val) {\n    url = base64toObjectUrl(entData.val, entData.mime, Drafty.logger);\n  } else if (typeof entData.ref == 'string') {\n    url = entData.ref;\n  }\n  return url;\n}\n\n/**\n * Check if the entity data is not ready for sending, such as being uploaded to the server.\n * @memberof Drafty\n * @static\n *\n * @param {Object} entity.data to get the URl from.\n * @returns {boolean} true if upload is in progress, false otherwise.\n */\nDrafty.isProcessing = function(entData) {\n  return !!entData._processing;\n}\n\n/**\n * Given the entity, get URL which can be used for previewing\n * the entity.\n * @memberof Drafty\n * @static\n *\n * @param {Object} entity.data to get the URl from.\n *\n * @returns {string} url for previewing or null if no such url is available.\n */\nDrafty.getPreviewUrl = function(entData) {\n  return entData.val ? base64toObjectUrl(entData.val, entData.mime, Drafty.logger) : null;\n}\n\n/**\n * Get approximate size of the entity.\n * @memberof Drafty\n * @static\n *\n * @param {Object} entData - entity.data to get the size for.\n * @returns {number} size of entity data in bytes.\n */\nDrafty.getEntitySize = function(entData) {\n  // Either size hint or length of value. The value is base64 encoded,\n  // the actual object size is smaller than the encoded length.\n  return entData.size ? entData.size : entData.val ? (entData.val.length * 0.75) | 0 : 0;\n}\n\n/**\n * Get entity mime type.\n * @memberof Drafty\n * @static\n *\n * @param {Object} entData - entity.data to get the type for.\n * @returns {string} mime type of entity.\n */\nDrafty.getEntityMimeType = function(entData) {\n  return entData.mime || 'text/plain';\n}\n\n/**\n * Get HTML tag for a given two-letter style name.\n * @memberof Drafty\n * @static\n *\n * @param {string} style - two-letter style, like ST or LN.\n *\n * @returns {string} HTML tag name if style is found, '_UNKN' if not found, {code: undefined} if style is falsish.\n */\nDrafty.tagName = function(style) {\n  return style ? (HTML_TAGS[style] ? HTML_TAGS[style].name : '_UNKN') : undefined;\n}\n\n/**\n * For a given data bundle generate an object with HTML attributes,\n * for instance, given {url: \"http://www.example.com/\"} return\n * {href: \"http://www.example.com/\"}\n * @memberof Drafty\n * @static\n *\n * @param {string} style - two-letter style to generate attributes for.\n * @param {Object} data - data bundle to convert to attributes\n *\n * @returns {Object} object with HTML attributes.\n */\nDrafty.attrValue = function(style, data) {\n  if (data && DECORATORS[style]) {\n    return DECORATORS[style].props(data);\n  }\n\n  return undefined;\n}\n\n/**\n * Drafty MIME type.\n * @memberof Drafty\n * @static\n *\n * @returns {string} HTTP Content-Type \"text/x-drafty\".\n */\nDrafty.getContentType = function() {\n  return 'text/x-drafty';\n}\n\n/**\n * Shorten Drafty document and strip all entity data leaving just inline styles and entity references.\n * @memberof Drafty\n * @static\n *\n * @param {Drafty} original - Drafty object to shorten.\n * @param {number} length - length in characters to shorten to.\n * @returns new shortened Drafty object leaving the original intact.\n */\nDrafty.preview = function(original, length) {\n  if (!original || length <= 0 || typeof original != 'object') {\n    return null;\n  }\n\n  const {\n    txt,\n    fmt,\n    ent\n  } = original;\n\n  const preview = {\n    txt: ''\n  };\n  let len = 0;\n  if (typeof txt == 'string') {\n    if (txt.length > length) {\n      preview.txt = txt.substr(0, length);\n    } else {\n      preview.txt = txt;\n    }\n    len = preview.txt.length;\n  }\n\n  if (Array.isArray(fmt) && fmt.length > 0) {\n    // Old key to new key entity mapping.\n    const ent_refs = [];\n    // Count styles which start within the new length of the text and save entity keys as a set.\n    let fmt_count = 0;\n    let ent_count = 0;\n    fmt.forEach((st) => {\n      if (st.at < len) {\n        fmt_count++;\n        if (!st.tp) {\n          const key = st.key | 0;\n          if (!ent_refs[key]) {\n            ent_refs[key] = ent_count;\n            ent_count++;\n          }\n        }\n      }\n    });\n\n    if (fmt_count == 0) {\n      return preview;\n    }\n\n    // Allocate space for copying styles and entities.\n    preview.fmt = [];\n    if (Array.isArray(ent) && ent_refs.length > 0) {\n      preview.ent = [];\n    }\n\n    // Insertion point for styles.\n    let fmt_idx = 0;\n    fmt.forEach((st) => {\n      if (st.at < len) {\n        const style = {\n          at: st.at,\n          len: st.len\n        };\n        const key = st.key | 0;\n        if (st.tp) {\n          style.tp = '' + st.tp;\n        } else if (Array.isArray(ent) && ent.length > key && typeof ent_refs[key] == 'number') {\n          style.key = ent_refs[key];\n          preview.ent[style.key] = copyLight(ent[key]);\n        } else {\n          return;\n        }\n        preview.fmt[fmt_idx++] = style;\n      }\n    });\n  }\n\n  return preview;\n}\n\n// Create a copy of an entity without large data.\nfunction copyLight(ent) {\n  let result = {\n    tp: ent.tp\n  };\n  if (ent.data && Object.entries(ent.data).length != 0) {\n    dc = {};\n    [\"mime\", \"name\", \"width\", \"height\", \"size\"].forEach((key) => {\n      const val = ent.data[key];\n      if (val) {\n        dc[key] = val;\n      }\n    });\n    if (Object.entries(dc).length != 0) {\n      result.data = dc;\n    }\n  }\n  return result;\n}\n\nif (typeof module != 'undefined') {\n  module.exports = Drafty;\n}\n","/**\n * @file SDK to connect to Tinode chat server.\n * See <a href=\"https://github.com/tinode/webapp\">\n * https://github.com/tinode/webapp</a> for real-life usage.\n *\n * @copyright 2015-2021 Tinode\n * @summary Javascript bindings for Tinode.\n * @license Apache 2.0\n * @version 0.17\n *\n * @example\n * <head>\n * <script src=\".../tinode.js\"></script>\n * </head>\n *\n * <body>\n *  ...\n * <script>\n *  // Instantiate tinode.\n *  const tinode = new Tinode(APP_NAME, HOST, API_KEY, null, true);\n *  tinode.enableLogging(true);\n *  // Add logic to handle disconnects.\n *  tinode.onDisconnect = function(err) { ... };\n *  // Connect to the server.\n *  tinode.connect().then(() => {\n *    // Connected. Login now.\n *    return tinode.loginBasic(login, password);\n *  }).then((ctrl) => {\n *    // Logged in fine, attach callbacks, subscribe to 'me'.\n *    const me = tinode.getMeTopic();\n *    me.onMetaDesc = function(meta) { ... };\n *    // Subscribe, fetch topic description and the list of contacts.\n *    me.subscribe({get: {desc: {}, sub: {}});\n *  }).catch((err) => {\n *    // Login or subscription failed, do something.\n *    ...\n *  });\n *  ...\n * </script>\n * </body>\n */\n'use strict';\n\n// NOTE TO DEVELOPERS:\n// Localizable strings should be double quoted \"строка на другом языке\",\n// non-localizable strings should be single quoted 'non-localized'.\n\nif (typeof require == 'function') {\n  if (typeof Drafty == 'undefined') {\n    var Drafty = require('./drafty.js');\n  }\n  if (typeof DB == 'undefined') {\n    var DB = require('./db.js');\n  }\n  var package_version = require('../version.json').version;\n}\n\nlet WebSocketProvider;\nif (typeof WebSocket != 'undefined') {\n  WebSocketProvider = WebSocket;\n}\n\nlet XHRProvider;\nif (typeof XMLHttpRequest != 'undefined') {\n  XHRProvider = XMLHttpRequest;\n}\ninitForNonBrowserApp();\n\n// Global constants\nconst PROTOCOL_VERSION = '0'; // Major component of the version, 0 in 0.16.9\nconst VERSION = package_version || '0.17';\nconst LIBRARY = 'tinodejs/' + VERSION;\n\nconst TOPIC_NEW = 'new';\nconst TOPIC_NEW_CHAN = 'nch';\nconst TOPIC_ME = 'me';\nconst TOPIC_FND = 'fnd';\nconst TOPIC_SYS = 'sys';\nconst TOPIC_CHAN = 'chn';\nconst USER_NEW = 'new';\n\n// Starting value of a locally-generated seqId used for pending messages.\nconst LOCAL_SEQID = 0xFFFFFFF;\n\nconst MESSAGE_STATUS_NONE = 0; // Status not assigned.\nconst MESSAGE_STATUS_QUEUED = 1; // Local ID assigned, in progress to be sent.\nconst MESSAGE_STATUS_SENDING = 2; // Transmission started.\nconst MESSAGE_STATUS_FAILED = 3; // At least one attempt was made to send the message.\nconst MESSAGE_STATUS_SENT = 4; // Delivered to the server.\nconst MESSAGE_STATUS_RECEIVED = 5; // Received by the client.\nconst MESSAGE_STATUS_READ = 6; // Read by the user.\nconst MESSAGE_STATUS_TO_ME = 7; // Message from another user.\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// Default number of messages to pull into memory from persistent cache.\nconst DEFAULT_MESSAGES_PAGE = 24;\n\n// Utility functions\n\n// Add brower missing function for non browser app, eg nodeJs\nfunction initForNonBrowserApp() {\n  // Tinode requirement in native mode because react native doesn't provide Base64 method\n  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\n  if (typeof btoa == 'undefined') {\n    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n    global.btoa = function(input = '') {\n      let str = input;\n      let output = '';\n\n      for (let block = 0, charCode, i = 0, map = chars; str.charAt(i | 0) || (map = '=', i % 1); output += map.charAt(63 & block >> 8 - i % 1 * 8)) {\n\n        charCode = str.charCodeAt(i += 3 / 4);\n\n        if (charCode > 0xFF) {\n          throw new Error(\"'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.\");\n        }\n\n        block = block << 8 | charCode;\n      }\n\n      return output;\n    };\n  }\n\n  if (typeof atob == 'undefined') {\n    global.atob = function(input = '') {\n      let str = input.replace(/=+$/, '');\n      let output = '';\n\n      if (str.length % 4 == 1) {\n        throw new Error(\"'atob' failed: The string to be decoded is not correctly encoded.\");\n      }\n      for (let bc = 0, bs = 0, buffer, i = 0; buffer = str.charAt(i++);\n\n        ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,\n          bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0\n      ) {\n        buffer = chars.indexOf(buffer);\n      }\n\n      return output;\n    };\n  }\n\n  if (typeof window == 'undefined') {\n    global.window = {\n      WebSocket: WebSocketProvider,\n      XMLHttpRequest: XHRProvider,\n      URL: {\n        createObjectURL: function() {\n          throw new Error(\"Unable to use URL.createObjectURL in a non-browser application\");\n        }\n      }\n    }\n  }\n}\n\n// RFC3339 formater of Date\nfunction rfc3339DateString(d) {\n  if (!d || d.getTime() == 0) {\n    return undefined;\n  }\n\n  function pad(val, sp) {\n    sp = sp || 2;\n    return '0'.repeat(sp - ('' + val).length) + val;\n  }\n\n  const millis = d.getUTCMilliseconds();\n  return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) +\n    'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) +\n    (millis ? '.' + pad(millis, 3) : '') + 'Z';\n}\n\n// btoa replacement. Stock btoa fails on on non-Latin1 strings.\nfunction b64EncodeUnicode(str) {\n  // The encodeURIComponent percent-encodes UTF-8 string,\n  // then the percent encoding is converted into raw bytes which\n  // can be fed into btoa.\n  return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g,\n    function toSolidBytes(match, p1) {\n      return String.fromCharCode('0x' + p1);\n    }));\n}\n\n// Recursively merge src's own properties to dst.\n// Ignore properties where ignore[property] is true.\n// Array and Date objects are shallow-copied.\nfunction mergeObj(dst, src, ignore) {\n  if (typeof src != 'object') {\n    if (src === Tinode.DEL_CHAR) {\n      return undefined;\n    }\n    if (src === undefined) {\n      return dst;\n    }\n    return src;\n  }\n  // JS is crazy: typeof null is 'object'.\n  if (src === null) {\n    return src;\n  }\n\n  // Handle Date\n  if (src instanceof Date) {\n    return (!dst || !(dst instanceof Date) || dst < src) ? src : dst;\n  }\n\n  // Access mode\n  if (src instanceof AccessMode) {\n    return new AccessMode(src);\n  }\n\n  // Handle Array\n  if (src instanceof Array) {\n    return src;\n  }\n\n  if (!dst || dst === Tinode.DEL_CHAR) {\n    dst = src.constructor();\n  }\n\n  for (let prop in src) {\n    if (src.hasOwnProperty(prop) &&\n      (!ignore || !ignore[prop]) &&\n      (prop != '_noForwarding')) {\n\n      dst[prop] = mergeObj(dst[prop], src[prop]);\n    }\n  }\n  return dst;\n}\n\n// Update object stored in a cache. Returns updated value.\nfunction mergeToCache(cache, key, newval, ignore) {\n  cache[key] = mergeObj(cache[key], newval, ignore);\n  return cache[key];\n}\n\nfunction stringToDate(obj) {\n  if (typeof obj.created == 'string') {\n    obj.created = new Date(obj.created);\n  }\n  if (typeof obj.updated == 'string') {\n    obj.updated = new Date(obj.updated);\n  }\n  if (typeof obj.touched == 'string') {\n    obj.touched = new Date(obj.touched);\n  }\n}\n\n// JSON stringify helper - pre-processor for JSON.stringify\nfunction jsonBuildHelper(key, val) {\n  if (val instanceof Date) {\n    // Convert javascript Date objects to rfc3339 strings\n    val = rfc3339DateString(val);\n  } else if (val instanceof AccessMode) {\n    val = val.jsonHelper();\n  } else if (val === undefined || val === null || val === false ||\n    (Array.isArray(val) && val.length == 0) ||\n    ((typeof val == 'object') && (Object.keys(val).length == 0))) {\n    // strip out empty elements while serializing objects to JSON\n    return undefined;\n  }\n\n  return val;\n};\n\n// Strips all values from an object of they evaluate to false or if their name starts with '_'.\nfunction simplify(obj) {\n  Object.keys(obj).forEach(function(key) {\n    if (key[0] == '_') {\n      // Strip fields like \"obj._key\".\n      delete obj[key];\n    } else if (!obj[key]) {\n      // Strip fields which evaluate to false.\n      delete obj[key];\n    } else if (Array.isArray(obj[key]) && obj[key].length == 0) {\n      // Strip empty arrays.\n      delete obj[key];\n    } else if (!obj[key]) {\n      // Strip fields which evaluate to false.\n      delete obj[key];\n    } else if (typeof obj[key] == 'object' && !(obj[key] instanceof Date)) {\n      simplify(obj[key]);\n      // Strip empty objects.\n      if (Object.getOwnPropertyNames(obj[key]).length == 0) {\n        delete obj[key];\n      }\n    }\n  });\n  return obj;\n};\n\n// Trim whitespace, strip empty and duplicate elements elements.\n// If the result is an empty array, add a single element \"\\u2421\" (Unicode Del character).\nfunction normalizeArray(arr) {\n  let out = [];\n  if (Array.isArray(arr)) {\n    // Trim, throw away very short and empty tags.\n    for (let i = 0, l = arr.length; i < l; i++) {\n      let t = arr[i];\n      if (t) {\n        t = t.trim().toLowerCase();\n        if (t.length > 1) {\n          out.push(t);\n        }\n      }\n    }\n    out.sort().filter(function(item, pos, ary) {\n      return !pos || item != ary[pos - 1];\n    });\n  }\n  if (out.length == 0) {\n    // Add single tag with a Unicode Del character, otherwise an ampty array\n    // is ambiguos. The Del tag will be stripped by the server.\n    out.push(Tinode.DEL_CHAR);\n  }\n  return out;\n}\n\n// Attempt to convert date strings to objects.\nfunction jsonParseHelper(key, val) {\n  // Convert string timestamps with optional milliseconds to Date\n  // 2015-09-02T01:45:43[.123]Z\n  if (key === 'ts' && typeof val === 'string' &&\n    val.length >= 20 && val.length <= 24) {\n    let date = new Date(val);\n    if (date) {\n      return date;\n    }\n  } else if (key === 'acs' && typeof val === 'object') {\n    return new AccessMode(val);\n  }\n  return val;\n};\n\n// Trims very long strings (encoded images) to make logged packets more readable.\nfunction jsonLoggerHelper(key, val) {\n  if (typeof val == 'string' && val.length > 128) {\n    return '<' + val.length + ', bytes: ' + val.substring(0, 12) + '...' + val.substring(val.length - 12) + '>';\n  }\n  return jsonBuildHelper(key, val);\n};\n\n// Parse browser user agent to extract browser name and version.\nfunction getBrowserInfo(ua, product) {\n  ua = ua || '';\n  let reactnative = '';\n  // Check if this is a ReactNative app.\n  if (/reactnative/i.test(product)) {\n    reactnative = 'ReactNative; ';\n  }\n  // Then test for WebKit based browser.\n  ua = ua.replace(' (KHTML, like Gecko)', '');\n  let m = ua.match(/(AppleWebKit\\/[.\\d]+)/i);\n  let result;\n  if (m) {\n    // List of common strings, from more useful to less useful.\n    let priority = ['chrome', 'safari', 'mobile', 'version'];\n    let tmp = ua.substr(m.index + m[0].length).split(\" \");\n    let tokens = [];\n    // Split Name/0.0.0 into Name and version 0.0.0\n    for (let i = 0; i < tmp.length; i++) {\n      let m2 = /([\\w.]+)[\\/]([\\.\\d]+)/.exec(tmp[i]);\n      if (m2) {\n        tokens.push([m2[1], m2[2], priority.findIndex(function(e) {\n          return (e == m2[1].toLowerCase());\n        })]);\n      }\n    }\n    // Sort by priority: more interesting is earlier than less interesting.\n    tokens.sort(function(a, b) {\n      let diff = a[2] - b[2];\n      return diff != 0 ? diff : b[0].length - a[0].length;\n    });\n    if (tokens.length > 0) {\n      // Return the least common browser string and version.\n      result = tokens[0][0] + '/' + tokens[0][1];\n    } else {\n      // Failed to ID the browser. Return the webkit version.\n      result = m[1];\n    }\n    // Test for MSIE.\n  } else if (/trident/i.test(ua)) {\n    m = /(?:\\brv[ :]+([.\\d]+))|(?:\\bMSIE ([.\\d]+))/g.exec(ua);\n    if (m) {\n      result = 'MSIE/' + (m[1] || m[2]);\n    } else {\n      result = 'MSIE/?';\n    }\n    // Test for Firefox.\n  } else if (/firefox/i.test(ua)) {\n    m = /Firefox\\/([.\\d]+)/g.exec(ua);\n    if (m) {\n      result = 'Firefox/' + m[1];\n    } else {\n      result = 'Firefox/?';\n    }\n    // Older Opera.\n  } else if (/presto/i.test(ua)) {\n    m = /Opera\\/([.\\d]+)/g.exec(ua);\n    if (m) {\n      result = 'Opera/' + m[1];\n    } else {\n      result = 'Opera/?';\n    }\n  } else {\n    // Failed to parse anything meaningfull. Try the last resort.\n    m = /([\\w.]+)\\/([.\\d]+)/.exec(ua);\n    if (m) {\n      result = m[1] + '/' + m[2];\n    } else {\n      m = ua.split(' ');\n      result = m[0];\n    }\n  }\n\n  // Shorten the version to one dot 'a.bb.ccc.d -> a.bb' at most.\n  m = result.split('/');\n  if (m.length > 1) {\n    let v = m[1].split('.');\n    result = m[0] + '/' + v[0] + (v[1] ? '.' + v[1] : '');\n  }\n  return reactnative + result;\n}\n\n/**\n * In-memory sorted cache of objects.\n *\n * @class CBuffer\n * @memberof Tinode\n * @protected\n *\n * @param {function} compare custom comparator of objects. Takes two parameters <code>a</code> and <code>b</code>;\n *    returns <code>-1</code> if <code>a < b</code>, <code>0</code> if <code>a == b</code>, <code>1</code> otherwise.\n * @param {boolean} unique enforce element uniqueness: when <code>true</code> replace existing element with a new\n *    one on conflict; when <code>false</code> keep both elements.\n */\nvar CBuffer = function(compare, unique) {\n  let buffer = [];\n\n  compare = compare || function(a, b) {\n    return a === b ? 0 : a < b ? -1 : 1;\n  };\n\n  function findNearest(elem, arr, exact) {\n    let start = 0;\n    let end = arr.length - 1;\n    let pivot = 0;\n    let diff = 0;\n    let found = false;\n\n    while (start <= end) {\n      pivot = (start + end) / 2 | 0;\n      diff = compare(arr[pivot], elem);\n      if (diff < 0) {\n        start = pivot + 1;\n      } else if (diff > 0) {\n        end = pivot - 1;\n      } else {\n        found = true;\n        break;\n      }\n    }\n    if (found) {\n      return {\n        idx: pivot,\n        exact: true\n      };\n    }\n    if (exact) {\n      return {\n        idx: -1\n      };\n    }\n    // Not exact - insertion point\n    return {\n      idx: diff < 0 ? pivot + 1 : pivot\n    };\n  }\n\n  // Insert element into a sorted array.\n  function insertSorted(elem, arr) {\n    const found = findNearest(elem, arr, false);\n    const count = (found.exact && unique) ? 1 : 0;\n    arr.splice(found.idx, count, elem);\n    return arr;\n  }\n\n  return {\n    /**\n     * Get an element at the given position.\n     * @memberof Tinode.CBuffer#\n     * @param {number} at - Position to fetch from.\n     * @returns {Object} Element at the given position or <code>undefined</code>.\n     */\n    getAt: function(at) {\n      return buffer[at];\n    },\n\n    /**\n     * Convenience method for getting the last element of the buffer.\n     * @memberof Tinode.CBuffer#\n     * @returns {Object} The last element in the buffer or <code>undefined</code> if buffer is empty.\n     */\n    getLast: function() {\n      return buffer.length > 0 ? buffer[buffer.length - 1] : undefined;\n    },\n\n    /**\n     * Add new element(s) to the buffer. Variadic: takes one or more arguments. If an array is passed as a single\n     * argument, its elements are inserted individually.\n     * @memberof Tinode.CBuffer#\n     *\n     * @param {...Object|Array} - One or more objects to insert.\n     */\n    put: function() {\n      let insert;\n      // inspect arguments: if array, insert its elements, if one or more non-array arguments, insert them one by one\n      if (arguments.length == 1 && Array.isArray(arguments[0])) {\n        insert = arguments[0];\n      } else {\n        insert = arguments;\n      }\n      for (let idx in insert) {\n        insertSorted(insert[idx], buffer);\n      }\n    },\n\n    /**\n     * Remove element at the given position.\n     * @memberof Tinode.CBuffer#\n     * @param {number} at - Position to delete at.\n     * @returns {Object} Element at the given position or <code>undefined</code>.\n     */\n    delAt: function(at) {\n      let r = buffer.splice(at, 1);\n      if (r && r.length > 0) {\n        return r[0];\n      }\n      return undefined;\n    },\n\n    /**\n     * Remove elements between two positions.\n     * @memberof Tinode.CBuffer#\n     * @param {number} since - Position to delete from (inclusive).\n     * @param {number} before - Position to delete to (exclusive).\n     *\n     * @returns {Array} array of removed elements (could be zero length).\n     */\n    delRange: function(since, before) {\n      return buffer.splice(since, before - since);\n    },\n\n    /**\n     * Return the number of elements the buffer holds.\n     * @memberof Tinode.CBuffer#\n     * @return {number} Number of elements in the buffer.\n     */\n    length: function() {\n      return buffer.length;\n    },\n\n    /**\n     * Reset the buffer discarding all elements\n     * @memberof Tinode.CBuffer#\n     */\n    reset: function() {\n      buffer = [];\n    },\n\n    /**\n     * Callback for iterating contents of buffer. See {@link Tinode.CBuffer#forEach}.\n     * @callback ForEachCallbackType\n     * @memberof Tinode.CBuffer#\n     * @param {Object} elem - Element of the buffer.\n     * @param {number} index - Index of the current element.\n     */\n\n    /**\n     * Apply given <code>callback</code> to all elements of the buffer.\n     * @memberof Tinode.CBuffer#\n     *\n     * @param {Tinode.ForEachCallbackType} callback - Function to call for each element.\n     * @param {number} startIdx - Optional index to start iterating from (inclusive).\n     * @param {number} beforeIdx - Optional index to stop iterating before (exclusive).\n     * @param {Object} context - calling context (i.e. value of <code>this</code> in callback)\n     */\n    forEach: function(callback, startIdx, beforeIdx, context) {\n      startIdx = startIdx | 0;\n      beforeIdx = beforeIdx || buffer.length;\n      for (let i = startIdx; i < beforeIdx; i++) {\n        callback.call(context, buffer[i], i);\n      }\n    },\n\n    /**\n     * Find element in buffer using buffer's comparison function.\n     * @memberof Tinode.CBuffer#\n     *\n     * @param {Object} elem - element to find.\n     * @param {boolean=} nearest - when true and exact match is not found, return the nearest element (insertion point).\n     * @returns {number} index of the element in the buffer or -1.\n     */\n    find: function(elem, nearest) {\n      const {\n        idx\n      } = findNearest(elem, buffer, !nearest);\n      return idx;\n    }\n  }\n}\n\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 <code>\"ws\"<code>/<code>\"wss\"</code> for websocket or\n *      <code>lp</code> for long polling.\n * @param {boolean} secure_ - Use secure WebSocket (wss) if <code>true</code>.\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    const timeout = _BOFF_BASE * (Math.pow(2, _boffIteration) * (1.0 + _BOFF_JITTER * Math.random()));\n    // Update iteration counter for future use\n    _boffIteration = (_boffIteration >= _BOFF_MAX_ITER ? _boffIteration : _boffIteration + 1);\n    if (this.onAutoreconnectIteration) {\n      this.onAutoreconnectIteration(timeout);\n    }\n\n    _boffTimer = setTimeout(() => {\n      log(`Reconnecting, iter=${_boffIteration}, timeout=${timeout}`);\n      // Maybe the socket was closed while we waited for the timer?\n      if (!_boffClosed) {\n        const prom = this.connect();\n        if (this.onAutoreconnectIteration) {\n          this.onAutoreconnectIteration(0, prom);\n        } else {\n          // Suppress error if it's not used.\n          prom.catch(() => {\n            /* do nothing */\n          });\n        }\n      } else if (this.onAutoreconnectIteration) {\n        this.onAutoreconnectIteration(-1);\n      }\n    }, timeout);\n  }\n\n  // Terminate auto-reconnect process.\n  function boffStop() {\n    clearTimeout(_boffTimer);\n    _boffTimer = null;\n  }\n\n  // Reset auto-reconnect iteration counter.\n  function boffReset() {\n    _boffIteration = 0;\n  }\n\n  // Initialization for Websocket\n  function init_ws(instance) {\n    let _socket = null;\n\n    /**\n     * Initiate a new connection\n     * @memberof Tinode.Connection#\n     * @param {string} host_ Host name to connect to; if <code>null</code> the old host name will be used.\n     * @param {boolean} force Force new connection even if one already exists.\n     * @return {Promise} Promise resolved/rejected when the connection call completes, resolution is called without\n     *  parameters, rejection passes the {Error} as parameter.\n     */\n    instance.connect = function(host_, force) {\n      _boffClosed = false;\n\n      if (_socket) {\n        if (!force && _socket.readyState == _socket.OPEN) {\n          return Promise.resolve();\n        }\n        _socket.close();\n        _socket = null;\n      }\n\n      if (host_) {\n        host = host_;\n      }\n\n      return new Promise(function(resolve, reject) {\n        const url = makeBaseUrl(host, secure ? 'wss' : 'ws', apiKey);\n\n        log(\"Connecting to: \", url);\n\n        // It throws when the server is not accessible but the exception cannot be caught:\n        // https://stackoverflow.com/questions/31002592/javascript-doesnt-catch-error-in-websocket-instantiation/31003057\n        const conn = new WebSocketProvider(url);\n\n        conn.onerror = function(err) {\n          reject(err);\n        }\n\n        conn.onopen = function(evt) {\n          if (autoreconnect) {\n            boffStop();\n          }\n\n          if (instance.onOpen) {\n            instance.onOpen();\n          }\n\n          resolve();\n        }\n\n        conn.onclose = function(evt) {\n          _socket = null;\n\n          if (instance.onDisconnect) {\n            const code = _boffClosed ? NETWORK_USER : NETWORK_ERROR;\n            instance.onDisconnect(new Error(_boffClosed ? NETWORK_USER_TEXT : NETWORK_ERROR_TEXT +\n              ' (' + code + ')'), code);\n          }\n\n          if (!_boffClosed && autoreconnect) {\n            boffReconnect.call(instance);\n          }\n        }\n\n        conn.onmessage = function(evt) {\n          if (instance.onMessage) {\n            instance.onMessage(evt.data);\n          }\n        }\n        _socket = conn;\n      });\n    }\n\n    /**\n     * Try to restore a network connection, also reset backoff.\n     * @memberof Tinode.Connection#\n     *\n     * @param {boolean} force - reconnect even if there is a live connection already.\n     */\n    instance.reconnect = function(force) {\n      boffStop();\n      instance.connect(null, force);\n    }\n\n    /**\n     * Terminate the network connection\n     * @memberof Tinode.Connection#\n     */\n    instance.disconnect = function() {\n      _boffClosed = true;\n      boffStop();\n\n      if (!_socket) {\n        return;\n      }\n      _socket.close();\n      _socket = null;\n    }\n\n    /**\n     * Send a string to the server.\n     * @memberof Tinode.Connection#\n     *\n     * @param {string} msg - String to send.\n     * @throws Throws an exception if the underlying connection is not live.\n     */\n    instance.sendText = function(msg) {\n      if (_socket && (_socket.readyState == _socket.OPEN)) {\n        _socket.send(msg);\n      } else {\n        throw new Error(\"Websocket is not connected\");\n      }\n    };\n\n    /**\n     * Check if socket is alive.\n     * @memberof Tinode.Connection#\n     * @returns {boolean} <code>true</code> if connection is live, <code>false</code> otherwise.\n     */\n    instance.isConnected = function() {\n      return (_socket && (_socket.readyState == _socket.OPEN));\n    }\n\n    /**\n     * Get the name of the current network transport.\n     * @memberof Tinode.Connection#\n     * @returns {string} name of the transport such as <code>\"ws\"</code> or <code>\"lp\"</code>.\n     */\n    instance.transport = function() {\n      return 'ws';\n    }\n\n    /**\n     * Send network probe to check if connection is indeed live.\n     * @memberof Tinode.Connection#\n     */\n    instance.probe = function() {\n      instance.sendText('1');\n    }\n  }\n\n  // Initialization for long polling.\n  function init_lp(instance) {\n    const XDR_UNSENT = 0; //\tClient has been created. open() not called yet.\n    const XDR_OPENED = 1; //\topen() has been called.\n    const XDR_HEADERS_RECEIVED = 2; // send() has been called, and headers and status are available.\n    const XDR_LOADING = 3; //\tDownloading; responseText holds partial data.\n    const XDR_DONE = 4; // The operation is complete.\n    // Fully composed endpoint URL, with API key & SID\n    let _lpURL = null;\n\n    let _poller = null;\n    let _sender = null;\n\n    function lp_sender(url_) {\n      let sender = new XMLHttpRequest();\n      sender.onreadystatechange = function(evt) {\n        if (sender.readyState == XDR_DONE && sender.status >= 400) {\n          // Some sort of error response\n          throw new Error(`LP sender failed, ${sender.status}`);\n        }\n      }\n\n      sender.open('POST', url_, true);\n      return sender;\n    }\n\n    function lp_poller(url_, resolve, reject) {\n      let poller = new XMLHttpRequest();\n      let promiseCompleted = false;\n\n      poller.onreadystatechange = function(evt) {\n\n        if (poller.readyState == XDR_DONE) {\n          if (poller.status == 201) { // 201 == HTTP.Created, get SID\n            let pkt = JSON.parse(poller.responseText, jsonParseHelper);\n            _lpURL = url_ + '&sid=' + pkt.ctrl.params.sid\n            poller = lp_poller(_lpURL);\n            poller.send(null)\n            if (instance.onOpen) {\n              instance.onOpen();\n            }\n\n            if (resolve) {\n              promiseCompleted = true;\n              resolve();\n            }\n\n            if (autoreconnect) {\n              boffStop();\n            }\n          } else if (poller.status < 400) { // 400 = HTTP.BadRequest\n            if (instance.onMessage) {\n              instance.onMessage(poller.responseText)\n            }\n            poller = lp_poller(_lpURL);\n            poller.send(null);\n          } else {\n            // Don't throw an error here, gracefully handle server errors\n            if (reject && !promiseCompleted) {\n              promiseCompleted = true;\n              reject(poller.responseText);\n            }\n            if (instance.onMessage && poller.responseText) {\n              instance.onMessage(poller.responseText);\n            }\n            if (instance.onDisconnect) {\n              const code = poller.status || (_boffClosed ? NETWORK_USER : NETWORK_ERROR);\n              const text = poller.responseText || (_boffClosed ? NETWORK_USER_TEXT : NETWORK_ERROR_TEXT);\n              instance.onDisconnect(new Error(text + ' (' + code + ')'), code);\n            }\n\n            // Polling has stopped. Indicate it by setting poller to null.\n            poller = null;\n            if (!_boffClosed && autoreconnect) {\n              boffReconnect.call(instance);\n            }\n          }\n        }\n      }\n      poller.open('GET', url_, true);\n      return poller;\n    }\n\n    instance.connect = function(host_, force) {\n      _boffClosed = false;\n\n      if (_poller) {\n        if (!force) {\n          return Promise.resolve();\n        }\n        _poller.onreadystatechange = undefined;\n        _poller.abort();\n        _poller = null;\n      }\n\n      if (host_) {\n        host = host_;\n      }\n\n      return new Promise(function(resolve, reject) {\n        const url = makeBaseUrl(host, secure ? 'https' : 'http', apiKey);\n        log(\"Connecting to: \", url);\n        _poller = lp_poller(url, resolve, reject);\n        _poller.send(null)\n      }).catch((err) => {\n        log(\"LP connection failed:\", err);\n      });\n    };\n\n    instance.reconnect = function(force) {\n      boffStop();\n      instance.connect(null, force);\n    };\n\n    instance.disconnect = function() {\n      _boffClosed = true;\n      boffStop();\n\n      if (_sender) {\n        _sender.onreadystatechange = undefined;\n        _sender.abort();\n        _sender = null;\n      }\n      if (_poller) {\n        _poller.onreadystatechange = undefined;\n        _poller.abort();\n        _poller = null;\n      }\n\n      if (instance.onDisconnect) {\n        instance.onDisconnect(new Error(NETWORK_USER_TEXT + ' (' + NETWORK_USER + ')'), NETWORK_USER);\n      }\n      // Ensure it's reconstructed\n      _lpURL = null;\n    }\n\n    instance.sendText = function(msg) {\n      _sender = lp_sender(_lpURL);\n      if (_sender && (_sender.readyState == 1)) { // 1 == OPENED\n        _sender.send(msg);\n      } else {\n        throw new Error(\"Long poller failed to connect\");\n      }\n    };\n\n    instance.isConnected = function() {\n      return (_poller && true);\n    }\n\n    instance.transport = function() {\n      return 'lp';\n    }\n\n    instance.probe = function() {\n      instance.sendText('1');\n    }\n  }\n\n  let initialized = false;\n  if (transport_ === 'lp') {\n    // explicit request to use long polling\n    init_lp(this);\n    initialized = true;\n  } else if (transport_ === 'ws') {\n    // explicit request to use web socket\n    // if websockets are not available, horrible things will happen\n    init_ws(this);\n    initialized = true;\n\n    // Default transport selection\n  } else if (typeof window == 'object') {\n    if (window['WebSocket']) {\n      // Using web sockets -- default.\n      init_ws(this);\n      initialized = true;\n    } else if (window['XMLHttpRequest']) {\n      // The browser has no websockets, using long polling.\n      init_lp(this);\n      initialized = true;\n    }\n  }\n\n  if (!initialized) {\n    // No transport is avaiilable.\n    log(\"No network transport is available. Running under Node? Call 'Tinode.setNetworkProviders()'.\");\n    throw new Error(\"No network transport is available. Running under Node? Call 'Tinode.setNetworkProviders()'.\");\n  }\n\n  /**\n   * Check if the given network transport is available.\n   * @memberof Tinode.Connection#\n   * @param {string} trans - either <code>\"ws\"</code> (websocket) or <code>\"lp\"</code> (long polling).\n   * @returns true if given transport is available, false otherwise.\n   */\n  this.transportAvailable = function(transp) {\n    switch (transp) {\n      case 'ws':\n        return typeof window == 'object' && window['WebSocket'];\n      case 'lp':\n        return typeof window == 'object' && window['XMLHttpRequest'];\n      default:\n        log(\"Request for unknown transport\", transp);\n        return false;\n    }\n  }\n\n  /**\n   * Reset autoreconnect counter to zero.\n   * @memberof Tinode.Connection#\n   */\n  this.backoffReset = function() {\n    boffReset();\n  }\n\n  // Callbacks:\n  /**\n   * A callback to pass incoming messages to. See {@link Tinode.Connection#onMessage}.\n   * @callback Tinode.Connection.OnMessage\n   * @memberof Tinode.Connection\n   * @param {string} message - Message to process.\n   */\n  /**\n   * A callback to pass incoming messages to.\n   * @type {Tinode.Connection.OnMessage}\n   * @memberof Tinode.Connection#\n   */\n  this.onMessage = undefined;\n\n  /**\n   * A callback for reporting a dropped connection.\n   * @type {function}\n   * @memberof Tinode.Connection#\n   */\n  this.onDisconnect = undefined;\n\n  /**\n   * A callback called when the connection is ready to be used for sending. For websockets it's socket open,\n   * for long polling it's <code>readyState=1</code> (OPENED)\n   * @type {function}\n   * @memberof Tinode.Connection#\n   */\n  this.onOpen = undefined;\n\n  /**\n   * A callback to notify of reconnection attempts. See {@link Tinode.Connection#onAutoreconnectIteration}.\n   * @memberof Tinode.Connection\n   * @callback AutoreconnectIterationType\n   * @param {string} timeout - time till the next reconnect attempt in milliseconds. <code>-1</code> means reconnect was skipped.\n   * @param {Promise} promise resolved or rejected when the reconnect attemp completes.\n   *\n   */\n  /**\n   * A callback to inform when the next attampt to reconnect will happen and to receive connection promise.\n   * @memberof Tinode.Connection#\n   * @type {Tinode.Connection.AutoreconnectIterationType}\n   */\n  this.onAutoreconnectIteration = undefined;\n\n  /**\n   * A callback to log events from Connection. See {@link Tinode.Connection#logger}.\n   * @memberof Tinode.Connection\n   * @callback LoggerCallbackType\n   * @param {string} event - Event to log.\n   */\n  /**\n   * A callback to report logging events.\n   * @memberof Tinode.Connection#\n   * @type {Tinode.Connection.LoggerCallbackType}\n   */\n  this.logger = undefined;\n};\n\n/**\n * @class Tinode\n *\n * @param {Object} config - configuration parameters.\n * @param {string} config.appName - Name of the calling application to be reported in the User Agent.\n * @param {string} config.host - Host name and port number to connect to.\n * @param {string} config.apiKey - API key generated by <code>keygen</code>.\n * @param {string} config.transport - See {@link Tinode.Connection#transport}.\n * @param {boolean} config.secure - Use Secure WebSocket if <code>true</code>.\n * @param {string} config.platform - Optional platform identifier, one of <code>\"ios\"</code>, <code>\"web\"</code>, <code>\"android\"</code>.\n * @param {boolen} config.persist - use indexDB persistent storage.\n * @param {function} onComplete - callback to call when initialization is completed.\n */\nvar Tinode = function(config, onComplete) {\n  // Client-provided application name, format <Name>/<version number>\n  this._appName = config.appName || \"Undefined\";\n\n  // API Key.\n  this._apiKey = config.apiKey;\n\n  // Name and version of the browser.\n  this._browser = '';\n  this._platform = config.platform || 'web';\n  this._hwos = 'undefined';\n  this._humanLanguage = 'xx';\n  // Underlying OS.\n  if (typeof navigator != 'undefined') {\n    this._browser = getBrowserInfo(navigator.userAgent, navigator.product);\n    this._hwos = navigator.platform;\n    // This is the default language. It could be changed by client.\n    this._humanLanguage = navigator.language || 'en-US';\n  }\n  // Logging to console enabled\n  this._loggingEnabled = false;\n  // When logging, trip long strings (base64-encoded images) for readability\n  this._trimLongStrings = false;\n  // UID of the currently authenticated user.\n  this._myUID = null;\n  // Status of connection: authenticated or not.\n  this._authenticated = false;\n  // Login used in the last successful basic authentication\n  this._login = null;\n  // Token which can be used for login instead of login/password.\n  this._authToken = null;\n  // Counter of received packets\n  this._inPacketCount = 0;\n  // Counter for generating unique message IDs\n  this._messageId = Math.floor((Math.random() * 0xFFFF) + 0xFFFF);\n  // Information about the server, if connected\n  this._serverInfo = null;\n  // Push notification token. Called deviceToken for consistency with the Android SDK.\n  this._deviceToken = null;\n\n  // Cache of pending promises by message id.\n  this._pendingPromises = {};\n\n  // The Timeout object returned by the reject expired promises setInterval.\n  this._expirePromises = null;\n\n  /** A connection object, see {@link Tinode.Connection}. */\n  this._connection = new Connection(config.host, config.apiKey, config.transport, config.secure, true);\n  // Console logger. Babel somehow fails to parse '...rest' parameter.\n  this.logger = (str, ...args) => {\n    if (this._loggingEnabled) {\n      const d = new Date()\n      const dateString = ('0' + d.getUTCHours()).slice(-2) + ':' +\n        ('0' + d.getUTCMinutes()).slice(-2) + ':' +\n        ('0' + d.getUTCSeconds()).slice(-2) + '.' +\n        ('00' + d.getUTCMilliseconds()).slice(-3);\n\n      console.log('[' + dateString + ']', str, args.join(' '));\n    }\n  }\n  this._connection.logger = this.logger;\n  Drafty.logger = this.logger;\n\n  // Timestamp of the most recent update to topics in cache.\n  this._lastTopicUpdate = null;\n\n  // Tinode's cache of objects\n  this._cache = {};\n\n  const cachePut = this.cachePut = (type, name, obj) => {\n    this._cache[type + ':' + name] = obj;\n  }\n\n  const cacheGet = this.cacheGet = (type, name) => {\n    return this._cache[type + ':' + name];\n  }\n\n  const cacheDel = this.cacheDel = (type, name) => {\n    delete this._cache[type + ':' + name];\n  }\n  // Enumerate all items in cache, call func for each item.\n  // Enumeration stops if func returns true.\n  const cacheMap = this.cacheMap = (type, func, context) => {\n    const key = type ? type + ':' : undefined;\n    for (let idx in this._cache) {\n      if (!key || idx.indexOf(key) == 0) {\n        if (func.call(context, this._cache[idx], idx)) {\n          break;\n        }\n      }\n    }\n  }\n\n  // Make limited cache management available to topic.\n  // Caching user.public only. Everything else is per-topic.\n  this.attachCacheToTopic = (topic) => {\n    topic._tinode = this;\n\n    topic._cacheGetUser = (uid) => {\n      const pub = cacheGet('user', uid);\n      if (pub) {\n        return {\n          user: uid,\n          public: mergeObj({}, pub)\n        };\n      }\n      return undefined;\n    };\n    topic._cachePutUser = (uid, user) => {\n      return cachePut('user', uid, mergeObj({}, user.public));\n    };\n    topic._cacheDelUser = (uid) => {\n      return cacheDel('user', uid);\n    };\n    topic._cachePutSelf = () => {\n      if (topic.updated && topic.updated > this._lastTopicUpdate) {\n        this._lastTopicUpdate = topic.updated;\n      }\n      return cachePut('topic', topic.name, topic);\n    }\n    topic._cacheDelSelf = () => {\n      return cacheDel('topic', topic.name);\n    }\n  }\n\n  // Use indexDB for caching topics and messages.\n  this._persist = config.persist;\n  // Initialize object regardless. It simplifies the code.\n  this._db = DB((err) => {\n    this.logger(\"DB\", err);\n  }, this.logger);\n\n  if (this._persist) {\n    // Create the persistent cache and read topics into memory.\n    this._db.initDatabase().then(() => {\n      // Load topics to memory.\n      return this._db.mapTopics((data) => {\n        let topic = this.cacheGet('topic', data.name);\n        if (topic) {\n          return;\n        }\n        if (data.name == TOPIC_ME) {\n          topic = new TopicMe();\n        } else if (data.name == TOPIC_FND) {\n          topic = new TopicFnd();\n        } else {\n          topic = new Topic(data.name);\n        }\n\n        this._db.deserializeTopic(topic, data);\n        this.attachCacheToTopic(topic);\n        topic._cachePutSelf();\n        topic._loadMessages();\n      }).then(() => {\n        if (onComplete) {\n          onComplete();\n        }\n        this.logger(\"Persistent cache initialized.\");\n      });\n    });\n  }\n\n  // Resolve or reject a pending promise.\n  // Unresolved promises are stored in _pendingPromises.\n  const execPromise = (id, code, onOK, errorText) => {\n    const callbacks = this._pendingPromises[id];\n    if (callbacks) {\n      delete this._pendingPromises[id];\n      if (code >= 200 && code < 400) {\n        if (callbacks.resolve) {\n          callbacks.resolve(onOK);\n        }\n      } else if (callbacks.reject) {\n        callbacks.reject(new Error(`${errorText} (${code})`));\n      }\n    }\n  }\n\n  // Generator of default promises for sent packets.\n  const makePromise = (id) => {\n    let promise = null;\n    if (id) {\n      promise = new Promise((resolve, reject) => {\n        // Stored callbacks will be called when the response packet with this Id arrives\n        this._pendingPromises[id] = {\n          'resolve': resolve,\n          'reject': reject,\n          'ts': new Date()\n        };\n      })\n    }\n    return promise;\n  }\n\n  // Generates unique message IDs\n  const getNextUniqueId = this.getNextUniqueId = () => {\n    return (this._messageId != 0) ? '' + this._messageId++ : undefined;\n  }\n\n  // Get User Agent string\n  const getUserAgent = () => {\n    return this._appName + ' (' + (this._browser ? this._browser + '; ' : '') + this._hwos + '); ' + LIBRARY;\n  }\n\n  // Generator of packets stubs\n  this.initPacket = (type, topic) => {\n    switch (type) {\n      case 'hi':\n        return {\n          'hi': {\n            'id': getNextUniqueId(),\n            'ver': VERSION,\n            'ua': getUserAgent(),\n            'dev': this._deviceToken,\n            'lang': this._humanLanguage,\n            'platf': this._platform\n          }\n        };\n\n      case 'acc':\n        return {\n          'acc': {\n            'id': getNextUniqueId(),\n            'user': null,\n            'scheme': null,\n            'secret': null,\n            'login': false,\n            'tags': null,\n            'desc': {},\n            'cred': {}\n          }\n        };\n\n      case 'login':\n        return {\n          'login': {\n            'id': getNextUniqueId(),\n            'scheme': null,\n            'secret': null\n          }\n        };\n\n      case 'sub':\n        return {\n          'sub': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'set': {},\n            'get': {}\n          }\n        };\n\n      case 'leave':\n        return {\n          'leave': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'unsub': false\n          }\n        };\n\n      case 'pub':\n        return {\n          'pub': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'noecho': false,\n            'head': null,\n            'content': {}\n          }\n        };\n\n      case 'get':\n        return {\n          'get': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'what': null, // data, sub, desc, space separated list; unknown strings are ignored\n            'desc': {},\n            'sub': {},\n            'data': {}\n          }\n        };\n\n      case 'set':\n        return {\n          'set': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'desc': {},\n            'sub': {},\n            'tags': []\n          }\n        };\n\n      case 'del':\n        return {\n          'del': {\n            'id': getNextUniqueId(),\n            'topic': topic,\n            'what': null,\n            'delseq': null,\n            'user': null,\n            'hard': false\n          }\n        };\n\n      case 'note':\n        return {\n          'note': {\n            // no id by design\n            'topic': topic,\n            'what': null, // one of \"recv\", \"read\", \"kp\"\n            'seq': undefined // the server-side message id aknowledged as received or read\n          }\n        };\n\n      default:\n        throw new Error(`Unknown packet type requested: ${type}`);\n    }\n  }\n\n  // Send a packet. If packet id is provided return a promise.\n  this.send = (pkt, id) => {\n    let promise;\n    if (id) {\n      promise = makePromise(id);\n    }\n    pkt = simplify(pkt);\n    let msg = JSON.stringify(pkt);\n    this.logger(\"out: \" + (this._trimLongStrings ? JSON.stringify(pkt, jsonLoggerHelper) : msg));\n    try {\n      this._connection.sendText(msg);\n    } catch (err) {\n      // If sendText throws, wrap the error in a promise or rethrow.\n      if (id) {\n        execPromise(id, NETWORK_ERROR, null, err.message);\n      } else {\n        throw err;\n      }\n    }\n    return promise;\n  }\n\n  // On successful login save server-provided data.\n  this.loginSuccessful = (ctrl) => {\n    if (!ctrl.params || !ctrl.params.user) {\n      return ctrl;\n    }\n    // This is a response to a successful login,\n    // extract UID and security token, save it in Tinode module\n    this._myUID = ctrl.params.user;\n    this._authenticated = (ctrl && ctrl.code >= 200 && ctrl.code < 300);\n    if (ctrl.params && ctrl.params.token && ctrl.params.expires) {\n      this._authToken = {\n        token: ctrl.params.token,\n        expires: new Date(ctrl.params.expires)\n      };\n    } else {\n      this._authToken = null;\n    }\n\n    if (this.onLogin) {\n      this.onLogin(ctrl.code, ctrl.text);\n    }\n\n    return ctrl;\n  }\n\n  // The main message dispatcher.\n  this._connection.onMessage = (data) => {\n    // Skip empty response. This happens when LP times out.\n    if (!data) return;\n\n    this._inPacketCount++;\n\n    // Send raw message to listener\n    if (this.onRawMessage) {\n      this.onRawMessage(data);\n    }\n\n    if (data === '0') {\n      // Server response to a network probe.\n      if (this.onNetworkProbe) {\n        this.onNetworkProbe();\n      }\n      // No processing is necessary.\n      return;\n    }\n\n    let pkt = JSON.parse(data, jsonParseHelper);\n    if (!pkt) {\n      this.logger(\"in: \" + data);\n      this.logger(\"ERROR: failed to parse data\");\n    } else {\n      this.logger(\"in: \" + (this._trimLongStrings ? JSON.stringify(pkt, jsonLoggerHelper) : data));\n\n      // Send complete packet to listener\n      if (this.onMessage) {\n        this.onMessage(pkt);\n      }\n\n      if (pkt.ctrl) {\n        // Handling {ctrl} message\n        if (this.onCtrlMessage) {\n          this.onCtrlMessage(pkt.ctrl);\n        }\n\n        // Resolve or reject a pending promise, if any\n        if (pkt.ctrl.id) {\n          execPromise(pkt.ctrl.id, pkt.ctrl.code, pkt.ctrl, pkt.ctrl.text);\n        }\n        setTimeout(() => {\n          if (pkt.ctrl.code == 205 && pkt.ctrl.text == 'evicted') {\n            // User evicted from topic.\n            const topic = cacheGet('topic', pkt.ctrl.topic);\n            if (topic) {\n              topic._resetSub();\n              if (pkt.ctrl.params && pkt.ctrl.params.unsub) {\n                topic._gone();\n              }\n            }\n          } else if (pkt.ctrl.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    if (!this._expirePromises) {\n      // Reject promises which have not been resolved for too long.\n      this._expirePromises = setInterval(() => {\n        const err = new Error(\"Timeout (504)\");\n        const expires = new Date(new Date().getTime() - EXPIRE_PROMISES_TIMEOUT);\n        for (let id in this._pendingPromises) {\n          let callbacks = this._pendingPromises[id];\n          if (callbacks && callbacks.ts < expires) {\n            this.logger(\"Promise expired\", id);\n            delete this._pendingPromises[id];\n            if (callbacks.reject) {\n              callbacks.reject(err);\n            }\n          }\n        }\n      }, EXPIRE_PROMISES_PERIOD);\n    }\n    this.hello();\n  }\n\n  // Wrapper for the reconnect iterator callback.\n  this._connection.onAutoreconnectIteration = (timeout, promise) => {\n    if (this.onAutoreconnectIteration) {\n      this.onAutoreconnectIteration(timeout, promise);\n    }\n  }\n\n  this._connection.onDisconnect = (err, code) => {\n    this._inPacketCount = 0;\n    this._serverInfo = null;\n    this._authenticated = false;\n\n    if (this._expirePromises) {\n      clearInterval(this._expirePromises);\n      this._expirePromises = null;\n    }\n\n    // Mark all topics as unsubscribed\n    cacheMap('topic', (topic, key) => {\n      topic._resetSub();\n    });\n\n    // Reject all pending promises\n    for (let key in this._pendingPromises) {\n      const callbacks = this._pendingPromises[key];\n      if (callbacks && callbacks.reject) {\n        callbacks.reject(err);\n      }\n    }\n    this._pendingPromises = {};\n\n    if (this.onDisconnect) {\n      this.onDisconnect(err);\n    }\n  }\n};\n\n// Static methods.\n\n/**\n * @typedef Credential\n * @type {object}\n * @property {string} meth - validation method.\n * @property {string} val - value to validate (e.g. email or phone number).\n * @property {string} resp - validation response.\n * @property {Object} params - validation parameters.\n */\n/**\n * Helper method to package account credential.\n *\n * @memberof Tinode\n * @static\n *\n * @param {string | Credential} meth - validation method or object with validation data.\n * @param {string=} val - validation value (e.g. email or phone number).\n * @param {Object=} params - validation parameters.\n * @param {string=} resp - validation response.\n *\n * @returns {Array.<Credential>} array with a single credential or <code>null</code> if no valid credentials were given.\n */\nTinode.credential = function(meth, val, params, resp) {\n  if (typeof meth == 'object') {\n    ({\n      val,\n      params,\n      resp,\n      meth\n    } = meth);\n  }\n  if (meth && (val || resp)) {\n    return [{\n      'meth': meth,\n      'val': val,\n      'resp': resp,\n      'params': params\n    }];\n  }\n  return null;\n};\n\n/**\n * Determine topic type from topic's name: grp, p2p, me, fnd, sys.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {string} One of <code>\"me\"</code>, <code>\"fnd\"</code>, <code>\"sys\"</code>, <code>\"grp\"</code>,\n *    <code>\"p2p\"</code> or <code>undefined</code>.\n */\nTinode.topicType = function(name) {\n  const types = {\n    'me': 'me',\n    'fnd': 'fnd',\n    'grp': 'grp',\n    'new': 'grp',\n    'nch': 'grp',\n    'chn': 'grp',\n    'usr': 'p2p',\n    'sys': 'sys'\n  };\n  return types[(typeof name == 'string') ? name.substring(0, 3) : 'xxx'];\n};\n\n/**\n * Check if the given topic name is a name of a 'me' topic.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {boolean} <code>true</code> if the name is a name of a 'me' topic, <code>false</code> otherwise.\n */\nTinode.isMeTopicName = function(name) {\n  return Tinode.topicType(name) == 'me';\n};\n\n/**\n * Check if the given topic name is a name of a group topic.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {boolean} <code>true</code> if the name is a name of a group topic, <code>false</code> otherwise.\n */\nTinode.isGroupTopicName = function(name) {\n  return Tinode.topicType(name) == 'grp';\n};\n\n/**\n * Check if the given topic name is a name of a p2p topic.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {boolean} <code>true</code> if the name is a name of a p2p topic, <code>false</code> otherwise.\n */\nTinode.isP2PTopicName = function(name) {\n  return Tinode.topicType(name) == 'p2p';\n};\n\n/**\n * Check if the given topic name is a name of a communication topic, i.e. P2P or group.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - Name of the topic to test.\n * @returns {boolean} <code>true</code> if the name is a name of a p2p or group topic, <code>false</code> otherwise.\n */\nTinode.isCommTopicName = function(name) {\n  return Tinode.isP2PTopicName(name) || Tinode.isGroupTopicName(name);\n};\n\n/**\n * Check if the topic name is a name of a new topic.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - topic name to check.\n * @returns {boolean} <code>true</code> if the name is a name of a new topic, <code>false</code> otherwise.\n */\nTinode.isNewGroupTopicName = function(name) {\n  return (typeof name == 'string') &&\n    (name.substring(0, 3) == TOPIC_NEW || name.substring(0, 3) == TOPIC_NEW_CHAN);\n};\n\n/**\n * Check if the topic name is a name of a channel.\n * @memberof Tinode\n * @static\n *\n * @param {string} name - topic name to check.\n * @returns {boolean} <code>true</code> if the name is a name of a channel, <code>false</code> otherwise.\n */\nTinode.isChannelTopicName = function(name) {\n  return (typeof name == 'string') &&\n    (name.substring(0, 3) == TOPIC_CHAN || name.substring(0, 3) == TOPIC_NEW_CHAN);\n};\n\n/**\n * Return information about the current version of this Tinode client library.\n * @memberof Tinode\n * @static\n *\n * @returns {string} semantic version of the library, e.g. <code>\"0.15.5-rc1\"</code>.\n */\nTinode.getVersion = function() {\n  return VERSION;\n};\n\n/**\n * To use Tinode in a non browser context, supply WebSocket and XMLHttpRequest providers.\n * @static\n * @memberof Tinode\n * @param wsProvider WebSocket provider, e.g. for nodeJS , <code>require('ws')</code>.\n * @param xhrProvider XMLHttpRequest provider, e.g. for node <code>require('xhr')</code>.\n */\nTinode.setNetworkProviders = function(wsProvider, xhrProvider) {\n  WebSocketProvider = wsProvider;\n  XHRProvider = xhrProvider;\n};\n\n/**\n * Return information about the current name and version of this Tinode library.\n * @memberof Tinode\n * @static\n *\n * @returns {string} the name of the library and it's version.\n */\nTinode.getLibrary = function() {\n  return LIBRARY;\n};\n\n// Exported constants\nTinode.MESSAGE_STATUS_NONE = MESSAGE_STATUS_NONE;\nTinode.MESSAGE_STATUS_QUEUED = MESSAGE_STATUS_QUEUED;\nTinode.MESSAGE_STATUS_SENDING = MESSAGE_STATUS_SENDING;\nTinode.MESSAGE_STATUS_FAILED = MESSAGE_STATUS_FAILED;\nTinode.MESSAGE_STATUS_SENT = MESSAGE_STATUS_SENT;\nTinode.MESSAGE_STATUS_RECEIVED = MESSAGE_STATUS_RECEIVED;\nTinode.MESSAGE_STATUS_READ = MESSAGE_STATUS_READ;\nTinode.MESSAGE_STATUS_TO_ME = MESSAGE_STATUS_TO_ME;\n\n// Unicode [del] symbol.\nTinode.DEL_CHAR = '\\u2421';\n\n/**\n * Check if the given string represents <code>NULL</code> value as defined by Tinode (<code>'\\u2421'</code>).\n * @memberof Tinode\n * @static\n *\n * @param {string} str - string to check for <code>NULL</code> value.\n *\n * @returns {boolean} <code>true</code> if string represents <code>NULL</code> value, <code>false</code> otherwise.\n */\nTinode.isNullValue = function(str) {\n  return str === Tinode.DEL_CHAR;\n};\n\n/**\n * Check if the given URL string is a relative URL.\n * Check for cases like:\n *  <code>'http://example.com'</code>\n *  <code>' http://example.com'</code>\n *  <code>'//example.com/'</code>\n *  <code>'http:example.com'</code>\n *  <code>'http:/example.com'</code>\n * @memberof Tinode\n * @static\n *\n * @param {string} url - URL string to check.\n *\n * @returns {boolean} <code>true</code> if the URL is relative, <code>false</code> otherwise.\n */\nTinode.isRelativeURL = function(url) {\n  return !/^\\s*([a-z][a-z0-9+.-]*:|\\/\\/)/im.test(url);\n};\n\n// Names of keys to server-provided configuration limits.\nTinode.MAX_MESSAGE_SIZE = 'maxMessageSize';\nTinode.MAX_SUBSCRIBER_COUNT = 'maxSubscriberCount';\nTinode.MAX_TAG_COUNT = 'maxTagCount';\nTinode.MAX_FILE_UPLOAD_SIZE = 'maxFileUploadSize';\n\n// Public methods;\nTinode.prototype = {\n  /**\n   * Connect to the server.\n   * @memberof Tinode#\n   *\n   * @param {string} host_ - name of the host to connect to.\n   *\n   * @return {Promise} Promise resolved/rejected when the connection call completes:\n   *    <code>resolve()</code> is called without parameters, <code>reject()</code> receives the\n   *    <code>Error</code> as a single parameter.\n   */\n  connect: function(host_) {\n    return this._connection.connect(host_);\n  },\n\n  /**\n   * Attempt to reconnect to the server immediately.\n   * @memberof Tinode#\n   *\n   * @param {string} force - reconnect even if there is a connection already.\n   */\n  reconnect: function(force) {\n    this._connection.reconnect(force);\n  },\n\n  /**\n   * Disconnect from the server.\n   * @memberof Tinode#\n   */\n  disconnect: function() {\n    this._connection.disconnect();\n  },\n\n  /**\n   * Clear persistent cache: remove indexDB cache of the most recently logged in user.\n   */\n  clearStorage: function() {\n    if (this._db) {\n      this._db.deleteDatabase();\n    }\n  },\n\n  /**\n   * Send a network probe message to make sure the connection is alive.\n   * @memberof Tinode#\n   */\n  networkProbe: function() {\n    this._connection.probe();\n  },\n\n  /**\n   * Check for live connection to server.\n   * @memberof Tinode#\n   *\n   * @returns {boolean} <code>true</code> if there is a live connection, <code>false</code> otherwise.\n   */\n  isConnected: function() {\n    return this._connection.isConnected();\n  },\n\n  /**\n   * Check if connection is authenticated (last login was successful).\n   * @memberof Tinode#\n   * @returns {boolean} <code>true</code> if authenticated, <code>false</code> otherwise.\n   */\n  isAuthenticated: function() {\n    return this._authenticated;\n  },\n\n  /**\n   * Add API key and auth token to the relative URL making it usable for getting data\n   * from the server in a simple <code>HTTP GET</code> request.\n   * @memberof Tinode#\n   *\n   * @param {string} URL - URL to wrap.\n   * @returns {string} URL with appended API key and token, if valid token is present.\n   */\n  authorizeURL: function(url) {\n    if (!url) {\n      return url;\n    }\n\n    if (Tinode.isRelativeURL(url)) {\n      // Fake base to make the relative URL parseable.\n      const base = 'scheme://host/';\n      const parsed = new URL(url, base);\n      if (this._apiKey) {\n        parsed.searchParams.append('apikey', this._apiKey);\n      }\n      if (this._authToken.token) {\n        parsed.searchParams.append('auth', 'token');\n        parsed.searchParams.append('secret', this._authToken.token);\n      }\n      // Convert back to string and strip fake base URL except for the root slash.\n      url = parsed.toString().substring(base.length - 1);\n    }\n    return url;\n  },\n\n  /**\n   * @typedef AccountParams\n   * @memberof Tinode\n   * @type {Object}\n   * @property {Tinode.DefAcs=} defacs - Default access parameters for user's <code>me</code> topic.\n   * @property {Object=} public - Public application-defined data exposed on <code>me</code> topic.\n   * @property {Object=} private - Private application-defined data accessible on <code>me</code> topic.\n   * @property {Array} tags - array of string tags for user discovery.\n   * @property {string=} token - authentication token to use.\n   */\n  /**\n   * @typedef DefAcs\n   * @memberof Tinode\n   * @type {Object}\n   * @property {string=} auth - Access mode for <code>me</code> for authenticated users.\n   * @property {string=} anon - Access mode for <code>me</code> for anonymous users.\n   */\n\n  /**\n   * Create or update an account.\n   * @memberof Tinode#\n   *\n   * @param {string} uid - User id to update\n   * @param {string} scheme - Authentication scheme; <code>\"basic\"</code> and <code>\"anonymous\"</code> are the currently supported schemes.\n   * @param {string} secret - Authentication secret, assumed to be already base64 encoded.\n   * @param {boolean=} login - Use new account to authenticate current session\n   * @param {Tinode.AccountParams=} params - User data to pass to the server.\n   */\n  account: function(uid, scheme, secret, login, params) {\n    const pkt = this.initPacket('acc');\n    pkt.acc.user = uid;\n    pkt.acc.scheme = scheme;\n    pkt.acc.secret = secret;\n    // Log in to the new account using selected scheme\n    pkt.acc.login = login;\n\n    if (params) {\n      pkt.acc.desc.defacs = params.defacs;\n      pkt.acc.desc.public = params.public;\n      pkt.acc.desc.private = params.private;\n\n      pkt.acc.tags = params.tags;\n      pkt.acc.cred = params.cred;\n\n      pkt.acc.token = params.token;\n    }\n\n    return this.send(pkt, pkt.acc.id);\n  },\n\n  /**\n   * Create a new user. Wrapper for {@link Tinode#account}.\n   * @memberof Tinode#\n   *\n   * @param {string} scheme - Authentication scheme; <code>\"basic\"</code> is the only currently supported scheme.\n   * @param {string} secret - Authentication.\n   * @param {boolean=} login - Use new account to authenticate current session\n   * @param {Tinode.AccountParams=} params - User data to pass to the server.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  createAccount: function(scheme, secret, login, params) {\n    let promise = this.account(USER_NEW, scheme, secret, login, params);\n    if (login) {\n      promise = promise.then((ctrl) => {\n        return this.loginSuccessful(ctrl);\n      });\n    }\n    return promise;\n  },\n\n  /**\n   * Create user with <code>'basic'</code> authentication scheme and immediately\n   * use it for authentication. Wrapper for {@link Tinode#account}.\n   * @memberof Tinode#\n   *\n   * @param {string} username - Login to use for the new account.\n   * @param {string} password - User's password.\n   * @param {Tinode.AccountParams=} params - User data to pass to the server.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  createAccountBasic: function(username, password, params) {\n    // Make sure we are not using 'null' or 'undefined';\n    username = username || '';\n    password = password || '';\n    return this.createAccount('basic',\n      b64EncodeUnicode(username + ':' + password), true, params);\n  },\n\n  /**\n   * Update user's credentials for <code>'basic'</code> authentication scheme. Wrapper for {@link Tinode#account}.\n   * @memberof Tinode#\n   *\n   * @param {string} uid - User ID to update.\n   * @param {string} username - Login to use for the new account.\n   * @param {string} password - User's password.\n   * @param {Tinode.AccountParams=} params - data to pass to the server.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  updateAccountBasic: function(uid, username, password, params) {\n    // Make sure we are not using 'null' or 'undefined';\n    username = username || '';\n    password = password || '';\n    return this.account(uid, 'basic',\n      b64EncodeUnicode(username + ':' + password), false, params);\n  },\n\n  /**\n   * Send handshake to the server.\n   * @memberof Tinode#\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  hello: function() {\n    const pkt = this.initPacket('hi');\n\n    return this.send(pkt, pkt.hi.id)\n      .then((ctrl) => {\n        // Reset backoff counter on successful connection.\n        this._connection.backoffReset();\n\n        // Server response contains server protocol version, build, constraints,\n        // session ID for long polling. Save them.\n        if (ctrl.params) {\n          this._serverInfo = ctrl.params;\n        }\n\n        if (this.onConnect) {\n          this.onConnect();\n        }\n\n        return ctrl;\n      }).catch((err) => {\n        this._connection.reconnect(true);\n\n        if (this.onDisconnect) {\n          this.onDisconnect(err);\n        }\n      });\n  },\n\n  /**\n   * Set or refresh the push notifications/device token. If the client is connected,\n   * the deviceToken can be sent to the server.\n   *\n   * @memberof Tinode#\n   * @param {string} dt - token obtained from the provider.\n   * @param {boolean} sendToServer - if true, send dt to server immediately.\n   *\n   * @returns 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; <code>\"basic\"</code> is the only currently supported scheme.\n   * @param {string} secret - Authentication secret, assumed to be already base64 encoded.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected when server reply is received.\n   */\n  login: function(scheme, secret, cred) {\n    const pkt = this.initPacket('login');\n    pkt.login.scheme = scheme;\n    pkt.login.secret = secret;\n    pkt.login.cred = cred;\n\n    return this.send(pkt, pkt.login.id)\n      .then((ctrl) => {\n        const x = this.loginSuccessful(ctrl);\n        return x;\n      });\n  },\n\n  /**\n   * Wrapper for {@link Tinode#login} with basic authentication\n   * @memberof Tinode#\n   *\n   * @param {string} uname - User name.\n   * @param {string} password  - Password.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  loginBasic: function(uname, password, cred) {\n    return this.login('basic', b64EncodeUnicode(uname + ':' + password), cred)\n      .then((ctrl) => {\n        this._login = uname;\n        return ctrl;\n      });\n  },\n\n  /**\n   * Wrapper for {@link Tinode#login} with token authentication\n   * @memberof Tinode#\n   *\n   * @param {string} token - Token received in response to earlier login.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  loginToken: function(token, cred) {\n    return this.login('token', token, cred);\n  },\n\n  /**\n   * Send a request for resetting an authentication secret.\n   * @memberof Tinode#\n   *\n   * @param {string} scheme - authentication scheme to reset.\n   * @param {string} method - method to use for resetting the secret, such as \"email\" or \"tel\".\n   * @param {string} value - value of the credential to use, a specific email address or a phone number.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving the server reply.\n   */\n  requestResetAuthSecret: function(scheme, method, value) {\n    return this.login('reset', b64EncodeUnicode(scheme + ':' + method + ':' + value));\n  },\n\n  /**\n   * @typedef AuthToken\n   * @memberof Tinode\n   * @type {Object}\n   * @property {string} token - Token value.\n   * @property {Date} expires - Token expiration time.\n   */\n  /**\n   * Get stored authentication token.\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.AuthToken} authentication token.\n   */\n  getAuthToken: function() {\n    if (this._authToken && (this._authToken.expires.getTime() > Date.now())) {\n      return this._authToken;\n    } else {\n      this._authToken = null;\n    }\n    return null;\n  },\n\n  /**\n   * Application may provide a saved authentication token.\n   * @memberof Tinode#\n   *\n   * @param {Tinode.AuthToken} token - authentication token.\n   */\n  setAuthToken: function(token) {\n    this._authToken = token;\n  },\n\n  /**\n   * @typedef SetParams\n   * @type {Object}\n   * @memberof Tinode\n   * @property {Tinode.SetDesc=} desc - Topic initialization parameters when creating a new topic or a new subscription.\n   * @property {Tinode.SetSub=} sub - Subscription initialization parameters.\n   */\n  /**\n   * @typedef SetDesc\n   * @type {Object}\n   * @memberof Tinode\n   * @property {Tinode.DefAcs=} defacs - Default access mode.\n   * @property {Object=} public - Free-form topic description, publically accessible.\n   * @property {Object=} private - Free-form topic descriptionaccessible only to the owner.\n   */\n  /**\n   * @typedef SetSub\n   * @type {Object}\n   * @memberof Tinode\n   * @property {string=} user - UID of the user affected by the request. Default (empty) - current user.\n   * @property {string=} mode - User access mode, either requested or assigned dependent on context.\n   * @property {Object=} info - Free-form payload to pass to the invited user or topic manager.\n   */\n  /**\n   * Parameters passed to {@link Tinode#subscribe}.\n   *\n   * @typedef SubscriptionParams\n   * @type {Object}\n   * @memberof Tinode\n   * @property {Tinode.SetParams=} set - Parameters used to initialize topic\n   * @property {Tinode.GetQuery=} get - Query for fetching data from topic.\n   */\n\n  /**\n   * Send a topic subscription request.\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Name of the topic to subscribe to.\n   * @param {Tinode.GetQuery=} getParams - Optional subscription metadata query\n   * @param {Tinode.SetParams=} setParams - Optional initialization parameters\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  subscribe: function(topicName, getParams, setParams) {\n    const pkt = this.initPacket('sub', topicName)\n    if (!topicName) {\n      topicName = TOPIC_NEW;\n    }\n\n    pkt.sub.get = getParams;\n\n    if (setParams) {\n      if (setParams.sub) {\n        pkt.sub.set.sub = setParams.sub;\n      }\n\n      if (setParams.desc) {\n        if (Tinode.isNewGroupTopicName(topicName)) {\n          // Full set.desc params are used for new topics only\n          pkt.sub.set.desc = setParams.desc;\n        } else if (Tinode.isP2PTopicName(topicName) && setParams.desc.defacs) {\n          // Use optional default permissions only.\n          pkt.sub.set.desc = {\n            defacs: setParams.desc.defacs\n          };\n        }\n      }\n\n      if (setParams.tags) {\n        pkt.sub.set.tags = setParams.tags;\n      }\n    }\n\n    return this.send(pkt, pkt.sub.id);\n  },\n\n  /**\n   * Detach and optionally unsubscribe from the topic\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Topic to detach from.\n   * @param {boolean} unsub - If <code>true</code>, detach and unsubscribe, otherwise just detach.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  leave: function(topic, unsub) {\n    const pkt = this.initPacket('leave', topic);\n    pkt.leave.unsub = unsub;\n\n    return this.send(pkt, pkt.leave.id);\n  },\n\n  /**\n   * Create message draft without sending it to the server.\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Name of the topic to publish to.\n   * @param {Object} data - Payload to publish.\n   * @param {boolean=} noEcho - If <code>true</code>, tell the server not to echo the message to the original session.\n   *\n   * @returns {Object} new message which can be sent to the server or otherwise used.\n   */\n  createMessage: function(topic, data, noEcho) {\n    const pkt = this.initPacket('pub', topic);\n\n    let dft = typeof data == 'string' ? Drafty.parse(data) : data;\n    if (dft && !Drafty.isPlainText(dft)) {\n      pkt.pub.head = {\n        mime: Drafty.getContentType()\n      };\n      data = dft;\n    }\n    pkt.pub.noecho = noEcho;\n    pkt.pub.content = data;\n\n    return pkt.pub;\n  },\n\n  /**\n   * Publish {data} message to topic.\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Name of the topic to publish to.\n   * @param {Object} data - Payload to publish.\n   * @param {boolean=} noEcho - If <code>true</code>, tell the server not to echo the message to the original session.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  publish: function(topic, data, noEcho) {\n    return this.publishMessage(\n      this.createMessage(topic, data, noEcho)\n    );\n  },\n\n  /**\n   * Publish message to topic. The message should be created by {@link Tinode#createMessage}.\n   * @memberof Tinode#\n   *\n   * @param {Object} pub - Message to publish.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  publishMessage: function(pub) {\n    // Make a shallow copy. Needed in order to clear locally-assigned temp values;\n    pub = Object.assign({}, pub);\n    pub.seq = undefined;\n    pub.from = undefined;\n    pub.ts = undefined;\n    return this.send({\n      pub: pub\n    }, pub.id);\n  },\n\n  /**\n   * @typedef GetQuery\n   * @type {Object}\n   * @memberof Tinode\n   * @property {Tinode.GetOptsType=} desc - If provided (even if empty), fetch topic description.\n   * @property {Tinode.GetOptsType=} sub - If provided (even if empty), fetch topic subscriptions.\n   * @property {Tinode.GetDataType=} data - If provided (even if empty), get messages.\n   */\n\n  /**\n   * @typedef GetOptsType\n   * @type {Object}\n   * @memberof Tinode\n   * @property {Date=} ims - \"If modified since\", fetch data only it was was modified since stated date.\n   * @property {number=} limit - Maximum number of results to return. Ignored when querying topic description.\n   */\n\n  /**\n   * @typedef GetDataType\n   * @type {Object}\n   * @memberof Tinode\n   * @property {number=} since - Load messages with seq id equal or greater than this value.\n   * @property {number=} before - Load messages with seq id lower than this number.\n   * @property {number=} limit - Maximum number of results to return.\n   */\n\n  /**\n   * Request topic metadata\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Name of the topic to query.\n   * @param {Tinode.GetQuery} params - Parameters of the query. Use {@link Tinode.MetaGetBuilder} to generate.\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  getMeta: function(topic, params) {\n    const pkt = this.initPacket('get', topic);\n\n    pkt.get = mergeObj(pkt.get, params);\n\n    return this.send(pkt, pkt.get.id);\n  },\n\n  /**\n   * Update topic's metadata: description, subscribtions.\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Topic to update.\n   * @param {Tinode.SetParams} params - topic metadata to update.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  setMeta: function(topic, params) {\n    const pkt = this.initPacket('set', topic);\n    const what = [];\n\n    if (params) {\n      ['desc', 'sub', 'tags', 'cred'].map(function(key) {\n        if (params.hasOwnProperty(key)) {\n          what.push(key);\n          pkt.set[key] = params[key];\n        }\n      });\n    }\n\n    if (what.length == 0) {\n      return Promise.reject(new Error(\"Invalid {set} parameters\"));\n    }\n\n    return this.send(pkt, pkt.set.id);\n  },\n\n  /**\n   * Range of message IDs to delete.\n   *\n   * @typedef DelRange\n   * @type {Object}\n   * @memberof Tinode\n   * @property {number} low - low end of the range, inclusive (closed).\n   * @property {number=} hi - high end of the range, exclusive (open).\n   */\n  /**\n   * Delete some or all messages in a topic.\n   * @memberof Tinode#\n   *\n   * @param {string} topic - Topic name to delete messages from.\n   * @param {Tinode.DelRange[]} list - Ranges of message IDs to delete.\n   * @param {boolean=} hard - Hard or soft delete\n   *\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delMessages: function(topic, ranges, hard) {\n    const pkt = this.initPacket('del', topic);\n\n    pkt.del.what = 'msg';\n    pkt.del.delseq = ranges;\n    pkt.del.hard = hard;\n\n    return this.send(pkt, pkt.del.id);\n  },\n\n  /**\n   * Delete the topic alltogether. Requires Owner permission.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic to delete\n   * @param {boolean} hard - hard-delete topic.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delTopic: function(topicName, hard) {\n    const pkt = this.initPacket('del', topicName);\n    pkt.del.what = 'topic';\n    pkt.del.hard = hard;\n\n    return this.send(pkt, pkt.del.id).then((ctrl) => {\n      this._db.remTopic(topicName);\n      this.cacheDel('topic', topicName);\n      return this.ctrl;\n    });\n  },\n\n  /**\n   * Delete subscription. Requires Share permission.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic to delete\n   * @param {string} user - User ID to remove.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delSubscription: function(topicName, user) {\n    const pkt = this.initPacket('del', topicName);\n    pkt.del.what = 'sub';\n    pkt.del.user = user;\n\n    return this.send(pkt, pkt.del.id);\n  },\n\n  /**\n   * Delete credential. Always sent on <code>'me'</code> topic.\n   * @memberof Tinode#\n   *\n   * @param {string} method - validation method such as <code>'email'</code> or <code>'tel'</code>.\n   * @param {string} value - validation value, i.e. <code>'alice@example.com'</code>.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delCredential: function(method, value) {\n    const pkt = this.initPacket('del', TOPIC_ME);\n    pkt.del.what = 'cred';\n    pkt.del.cred = {\n      meth: method,\n      val: value\n    };\n\n    return this.send(pkt, pkt.del.id);\n  },\n\n  /**\n   * Request to delete account of the current user.\n   * @memberof Tinode#\n   *\n   * @param {boolean} hard - hard-delete user.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delCurrentUser: function(hard) {\n    const pkt = this.initPacket('del', null);\n    pkt.del.what = 'user';\n    pkt.del.hard = hard;\n\n    return this.send(pkt, pkt.del.id).then((ctrl) => {\n      this._myUID = null;\n    });\n  },\n\n  /**\n   * Notify server that a message or messages were read or received. Does NOT return promise.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic where the mesage is being aknowledged.\n   * @param {string} what - Action being aknowledged, either <code>\"read\"</code> or <code>\"recv\"</code>.\n   * @param {number} seq - Maximum id of the message being acknowledged.\n   */\n  note: function(topicName, what, seq) {\n    if (seq <= 0 || seq >= LOCAL_SEQID) {\n      throw new Error(`Invalid message id ${seq}`);\n    }\n\n    const pkt = this.initPacket('note', topicName);\n    pkt.note.what = what;\n    pkt.note.seq = seq;\n    this.send(pkt);\n  },\n\n  /**\n   * Broadcast a key-press notification to topic subscribers. Used to show\n   * typing notifications \"user X is typing...\".\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic to broadcast to.\n   */\n  noteKeyPress: function(topicName) {\n    const pkt = this.initPacket('note', topicName);\n    pkt.note.what = 'kp';\n    this.send(pkt);\n  },\n\n  /**\n   * Get a named topic, either pull it from cache or create a new instance.\n   * There is a single instance of topic for each name.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic to get.\n   * @returns {Tinode.Topic} Requested or newly created topic or <code>undefined</code> if topic name is invalid.\n   */\n  getTopic: function(topicName) {\n    let topic = this.cacheGet('topic', topicName);\n    if (!topic && topicName) {\n      if (topicName == TOPIC_ME) {\n        topic = new TopicMe();\n      } else if (topicName == TOPIC_FND) {\n        topic = new TopicFnd();\n      } else {\n        topic = new Topic(topicName);\n      }\n      // Cache management.\n      this._db.addTopic(topic);\n      this.attachCacheToTopic(topic);\n      topic._cachePutSelf();\n    }\n    return topic;\n  },\n\n  /**\n   * Check if named topic is already present in cache.\n   * @memberof Tinode#\n   *\n   * @param {string} topicName - Name of the topic to check.\n   * @returns {boolean} true if topic is found in cache, false oterwise.\n   */\n  isTopicCached: function(topicName) {\n    return !!this.cacheGet('topic', topicName);\n  },\n\n  /**\n   * Generate unique name like <code>'new123456'</code> suitable for creating a new group topic.\n   * @memberof Tinode#\n   *\n   * @param {boolean} isChan - if the topic is channel-enabled.\n   * @returns {string} name which can be used for creating a new group topic.\n   */\n  newGroupTopicName: function(isChan) {\n    return (isChan ? TOPIC_NEW_CHAN : TOPIC_NEW) + this.getNextUniqueId();\n  },\n\n  /**\n   * Instantiate <code>'me'</code> topic or get it from cache.\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.TopicMe} Instance of <code>'me'</code> topic.\n   */\n  getMeTopic: function() {\n    return this.getTopic(TOPIC_ME);\n  },\n\n  /**\n   * Instantiate <code>'fnd'</code> (find) topic or get it from cache.\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.Topic} Instance of <code>'fnd'</code> topic.\n   */\n  getFndTopic: function() {\n    return this.getTopic(TOPIC_FND);\n  },\n\n  /**\n   * Create a new {@link LargeFileHelper} instance\n   * @memberof Tinode#\n   *\n   * @returns {Tinode.LargeFileHelper} instance of a {@link Tinode.LargeFileHelper}.\n   */\n  getLargeFileHelper: function() {\n    return new LargeFileHelper(this);\n  },\n\n  /**\n   * Get the UID of the the current authenticated user.\n   * @memberof Tinode#\n   * @returns {string} UID of the current user or <code>undefined</code> if the session is not yet authenticated or if there is no session.\n   */\n  getCurrentUserID: function() {\n    return this._myUID;\n  },\n\n  /**\n   * Check if the given user ID is equal to the current user's UID.\n   * @memberof Tinode#\n   * @param {string} uid - UID to check.\n   * @returns {boolean} true if the given UID belongs to the current logged in user.\n   */\n  isMe: function(uid) {\n    return this._myUID === uid;\n  },\n\n  /**\n   * Get login used for last successful authentication.\n   * @memberof Tinode#\n   * @returns {string} login last used successfully or <code>undefined</code>.\n   */\n  getCurrentLogin: function() {\n    return this._login;\n  },\n\n  /**\n   * Return information about the server: protocol version and build timestamp.\n   * @memberof Tinode#\n   * @returns {Object} build and version of the server or <code>null</code> if there is no connection or if the first server response has not been received yet.\n   */\n  getServerInfo: function() {\n    return this._serverInfo;\n  },\n\n  /**\n   * Return server-provided configuration value (long integer).\n   * @memberof Tinode#\n   * @param {string} name of the value to return\n   * @param {Object} defaultValue to return in case server limit is not set or not found.\n   * @returns {number} named value.\n   */\n  getServerLimit: function(name, defaultValue) {\n    return (this._serverInfo ? this._serverInfo[name] : null) || defaultValue;\n  },\n\n  /**\n   * Toggle console logging. Logging is off by default.\n   * @memberof Tinode#\n   * @param {boolean} enabled - Set to <code>true</code> to enable logging to console.\n   * @param {boolean} trimLongStrings - Set to <code>true</code> to trim long strings.\n   */\n  enableLogging: function(enabled, trimLongStrings) {\n    this._loggingEnabled = enabled;\n    this._trimLongStrings = enabled && trimLongStrings;\n  },\n\n  /**\n   * Set UI language to report to the server. Must be called before <code>'hi'</code> is sent, otherwise it will not be used.\n   * @memberof Tinode#\n   *\n   * @param {string} hl - human (UI) language, like <code>\"en_US\"</code> or <code>\"zh-Hans\"</code>.\n   */\n  setHumanLanguage: function(hl) {\n    if (hl) {\n      this._humanLanguage = hl;\n    }\n  },\n\n  /**\n   * Check if given topic is online.\n   * @memberof Tinode#\n   *\n   * @param {string} name of the topic to test.\n   * @returns {boolean} true if topic is online, false otherwise.\n   */\n  isTopicOnline: function(name) {\n    const topic = this.cacheGet('topic', name);\n    return topic && topic.online;\n  },\n\n  /**\n   * Get access mode for the given contact.\n   * @memberof Tinode#\n   *\n   * @param {string} name of the topic to query.\n   * @returns {AccessMode} access mode if topic is found, null otherwise.\n   */\n  getTopicAccessMode: function(name) {\n    const topic = this.cacheGet('topic', name);\n    return topic ? topic.acs : null;\n  },\n\n  /**\n   * Include message ID into all subsequest messages to server instructin it to send aknowledgemens.\n   * Required for promises to function. Default is <code>\"on\"</code>.\n   * @memberof Tinode#\n   *\n   * @param {boolean} status - Turn aknowledgemens on or off.\n   * @deprecated\n   */\n  wantAkn: function(status) {\n    if (status) {\n      this._messageId = Math.floor((Math.random() * 0xFFFFFF) + 0xFFFFFF);\n    } else {\n      this._messageId = 0;\n    }\n  },\n\n  // Callbacks:\n  /**\n   * Callback to report when the websocket is opened. The callback has no parameters.\n   * @memberof Tinode#\n   * @type {Tinode.onWebsocketOpen}\n   */\n  onWebsocketOpen: undefined,\n\n  /**\n   * @typedef Tinode.ServerParams\n   * @memberof Tinode\n   * @type {Object}\n   * @property {string} ver - Server version\n   * @property {string} build - Server build\n   * @property {string=} sid - Session ID, long polling connections only.\n   */\n\n  /**\n   * @callback Tinode.onConnect\n   * @param {number} code - Result code\n   * @param {string} text - Text epxplaining the completion, i.e \"OK\" or an error message.\n   * @param {Tinode.ServerParams} params - Parameters returned by the server.\n   */\n  /**\n   * Callback to report when connection with Tinode server is established.\n   * @memberof Tinode#\n   * @type {Tinode.onConnect}\n   */\n  onConnect: undefined,\n\n  /**\n   * Callback to report when connection is lost. The callback has no parameters.\n   * @memberof Tinode#\n   * @type {Tinode.onDisconnect}\n   */\n  onDisconnect: undefined,\n\n  /**\n   * @callback Tinode.onLogin\n   * @param {number} code - NUmeric completion code, same as HTTP status codes.\n   * @param {string} text - Explanation of the completion code.\n   */\n  /**\n   * Callback to report login completion.\n   * @memberof Tinode#\n   * @type {Tinode.onLogin}\n   */\n  onLogin: undefined,\n\n  /**\n   * Callback to receive <code>{ctrl}</code> (control) messages.\n   * @memberof Tinode#\n   * @type {Tinode.onCtrlMessage}\n   */\n  onCtrlMessage: undefined,\n\n  /**\n   * Callback to recieve <code>{data}</code> (content) messages.\n   * @memberof Tinode#\n   * @type {Tinode.onDataMessage}\n   */\n  onDataMessage: undefined,\n\n  /**\n   * Callback to receive <code>{pres}</code> (presence) messages.\n   * @memberof Tinode#\n   * @type {Tinode.onPresMessage}\n   */\n  onPresMessage: undefined,\n\n  /**\n   * Callback to receive all messages as objects.\n   * @memberof Tinode#\n   * @type {Tinode.onMessage}\n   */\n  onMessage: undefined,\n\n  /**\n   * Callback to receive all messages as unparsed text.\n   * @memberof Tinode#\n   * @type {Tinode.onRawMessage}\n   */\n  onRawMessage: undefined,\n\n  /**\n   * Callback to receive server responses to network probes. See {@link Tinode#networkProbe}\n   * @memberof Tinode#\n   * @type {Tinode.onNetworkProbe}\n   */\n  onNetworkProbe: undefined,\n\n  /**\n   * Callback to be notified when exponential backoff is iterating.\n   * @memberof Tinode#\n   * @type {Tinode.onAutoreconnectIteration}\n   */\n  onAutoreconnectIteration: undefined,\n};\n\n/**\n * 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  this.what = {};\n}\n\nMetaGetBuilder.prototype = {\n\n  // Get timestamp of the most recent desc update.\n  _get_desc_ims: function() {\n    const tupd = this.topic._lastDescUpdate || 0;\n    return this.topic.updated > tupd ? this.topic.updated : tupd;\n  },\n\n  // Get timestamp of the most recent subs update.\n  _get_subs_ims: function() {\n    if (this.topic.isP2PType()) {\n      return this._get_desc_ims();\n    }\n    if (this.topic.isMeType()) {\n      const gupd = this.topic._tinode._lastTopicUpdate || 0;\n      if (gupd > this.topic._lastSubsUpdate) {\n        return gupd;\n      }\n    }\n    return this.topic._lastSubsUpdate;\n  },\n\n  /**\n   * Add query parameters to fetch messages within explicit limits.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} since - messages newer than this (inclusive);\n   * @param {number=} before - older than this (exclusive)\n   * @param {number=} limit - number of messages to fetch\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withData: function(since, before, limit) {\n    this.what['data'] = {\n      since: since,\n      before: before,\n      limit: limit\n    };\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch messages newer than the latest saved message.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} limit - number of messages to fetch\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withLaterData: function(limit) {\n    return this.withData(this.topic._maxSeq > 0 ? this.topic._maxSeq + 1 : undefined, undefined, limit);\n  },\n\n  /**\n   * Add query parameters to fetch messages older than the earliest saved message.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} limit - maximum number of messages to fetch.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withEarlierData: function(limit) {\n    return this.withData(undefined, this.topic._minSeq > 0 ? this.topic._minSeq : undefined, limit);\n  },\n\n  /**\n   * Add query parameters to fetch topic description if it's newer than the given timestamp.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {Date=} ims - fetch messages newer than this timestamp.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withDesc: function(ims) {\n    this.what['desc'] = {\n      ims: ims\n    };\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch topic description if it's newer than the last update.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withLaterDesc: function() {\n    return this.withDesc(this._get_desc_ims());\n  },\n\n  /**\n   * Add query parameters to fetch subscriptions.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {Date=} ims - fetch subscriptions modified more recently than this timestamp\n   * @param {number=} limit - maximum number of subscriptions to fetch.\n   * @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withSub: function(ims, limit, userOrTopic) {\n    const opts = {\n      ims: ims,\n      limit: limit\n    };\n    if (this.topic.getType() == 'me') {\n      opts.topic = userOrTopic;\n    } else {\n      opts.user = userOrTopic;\n    }\n    this.what['sub'] = opts;\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch a single subscription.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {Date=} ims - fetch subscriptions modified more recently than this timestamp\n   * @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withOneSub: function(ims, userOrTopic) {\n    return this.withSub(ims, undefined, userOrTopic);\n  },\n\n  /**\n   * Add query parameters to fetch a single subscription if it's been updated since the last update.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {string=} userOrTopic - user ID or topic name to fetch for fetching one subscription.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withLaterOneSub: function(userOrTopic) {\n    return this.withOneSub(this.topic._lastSubsUpdate, userOrTopic);\n  },\n\n  /**\n   * Add query parameters to fetch subscriptions updated since the last update.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} limit - maximum number of subscriptions to fetch.\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withLaterSub: function(limit) {\n    return this.withSub(this._get_subs_ims(), limit);\n  },\n\n  /**\n   * Add query parameters to fetch topic tags.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withTags: function() {\n    this.what['tags'] = true;\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch user's credentials. <code>'me'</code> topic only.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withCred: function() {\n    if (this.topic.getType() == 'me') {\n      this.what['cred'] = true;\n    } else {\n      this.topic._tinode.logger(\"ERROR: Invalid topic type for MetaGetBuilder:withCreds\", this.topic.getType());\n    }\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch deleted messages within explicit limits. Any/all parameters can be null.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} since - ids of messages deleted since this 'del' id (inclusive)\n   * @param {number=} limit - number of deleted message ids to fetch\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withDel: function(since, limit) {\n    if (since || limit) {\n      this.what['del'] = {\n        since: since,\n        limit: limit\n      };\n    }\n    return this;\n  },\n\n  /**\n   * Add query parameters to fetch messages deleted after the saved <code>'del'</code> id.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @param {number=} limit - number of deleted message ids to fetch\n   *\n   * @returns {Tinode.MetaGetBuilder} <code>this</code> object.\n   */\n  withLaterDel: function(limit) {\n    // Specify 'since' only if we have already received some messages. If\n    // we have no locally cached messages then we don't care if any messages were deleted.\n    return this.withDel(this.topic._maxSeq > 0 ? this.topic._maxDel + 1 : undefined, limit);\n  },\n\n  /**\n   * Construct parameters.\n   * @memberof Tinode.MetaGetBuilder#\n   *\n   * @returns {Tinode.GetQuery} Get query\n   */\n  build: function() {\n    const what = [];\n    const instance = this;\n    let params = {};\n    ['data', 'sub', 'desc', 'tags', 'cred', 'del'].map(function(key) {\n      if (instance.what.hasOwnProperty(key)) {\n        what.push(key);\n        if (Object.getOwnPropertyNames(instance.what[key]).length > 0) {\n          params[key] = instance.what[key];\n        }\n      }\n    });\n    if (what.length > 0) {\n      params.what = what.join(' ');\n    } else {\n      params = undefined;\n    }\n    return params;\n  }\n};\n\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 <code>'+'</code> or <code>'-'</code> then the bits to add or remove, e.g. <code>'+R-W'</code> or <code>'-PS'</code>.\n *  - a new value of access mode\n *\n * @memberof Tinode.AccessMode\n * @static\n *\n * @param {number} val - access mode value to update.\n * @param {string} upd - update to apply to val.\n * @returns {number} - updated access mode.\n */\nAccessMode.update = function(val, upd) {\n  if (!upd || typeof upd != 'string') {\n    return val;\n  }\n\n  let action = upd.charAt(0);\n  if (action == '+' || action == '-') {\n    let val0 = val;\n    // Split delta-string like '+ABC-DEF+Z' into an array of parts including + and -.\n    const parts = upd.split(/([-+])/);\n    // Starting iteration from 1 because String.split() creates an array with the first empty element.\n    // Iterating by 2 because we parse pairs +/- then data.\n    for (let i = 1; i < parts.length - 1; i += 2) {\n      action = parts[i];\n      const m0 = AccessMode.decode(parts[i + 1]);\n      if (m0 == AccessMode._INVALID) {\n        return val;\n      }\n      if (m0 == null) {\n        continue;\n      }\n      if (action === '+') {\n        val0 |= m0;\n      } else if (action === '-') {\n        val0 &= ~m0;\n      }\n    }\n    val = val0;\n  } else {\n    // The string is an explicit new value 'ABC' rather than delta.\n    const val0 = AccessMode.decode(upd);\n    if (val0 != AccessMode._INVALID) {\n      val = val0;\n    }\n  }\n\n  return val;\n};\n\n/**\n * Bits present in a1 but missing in a2.\n *\n * @static\n * @memberof Tinode\n *\n * @param {number | string} a1 - access mode to subtract from.\n * @param {number | string} a2 - access mode to subtract.\n * @returns {number} access mode with bits present in <code>a1</code> but missing in <code>a2</code>.\n */\nAccessMode.diff = function(a1, a2) {\n  a1 = AccessMode.decode(a1);\n  a2 = AccessMode.decode(a2);\n\n  if (a1 == AccessMode._INVALID || a2 == AccessMode._INVALID) {\n    return AccessMode._INVALID;\n  }\n  return a1 & ~a2;\n};\n\n/**\n * AccessMode is a class representing topic access mode.\n *\n * @memberof Tinode\n * @class AccessMode\n */\nAccessMode.prototype = {\n  /**\n   * Custom formatter\n   */\n  toString: function() {\n    return '{\"mode\": \"' + AccessMode.encode(this.mode) +\n      '\", \"given\": \"' + AccessMode.encode(this.given) +\n      '\", \"want\": \"' + AccessMode.encode(this.want) + '\"}';\n  },\n  /**\n   * Converts numeric values to strings.\n   */\n  jsonHelper: function() {\n    return {\n      mode: AccessMode.encode(this.mode),\n      given: AccessMode.encode(this.given),\n      want: AccessMode.encode(this.want)\n    };\n  },\n  /**\n   * Assign value to 'mode'.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string | Number} m - either a string representation of the access mode or a set of bits.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  setMode: function(m) {\n    this.mode = AccessMode.decode(m);\n    return this;\n  },\n  /**\n   * Update <code>mode</code> value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string} u - string representation of the changes to apply to access mode.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  updateMode: function(u) {\n    this.mode = AccessMode.update(this.mode, u);\n    return this;\n  },\n  /**\n   * Get <code>mode</code> value as a string.\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} - <code>mode</code> value.\n   */\n  getMode: function() {\n    return AccessMode.encode(this.mode);\n  },\n\n  /**\n   * Assign <code>given</code>  value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string | Number} g - either a string representation of the access mode or a set of bits.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  setGiven: function(g) {\n    this.given = AccessMode.decode(g);\n    return this;\n  },\n  /**\n   * Update 'given' value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string} u - string representation of the changes to apply to access mode.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  updateGiven: function(u) {\n    this.given = AccessMode.update(this.given, u);\n    return this;\n  },\n  /**\n   * Get 'given' value as a string.\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} - <b>given</b> value.\n   */\n  getGiven: function() {\n    return AccessMode.encode(this.given);\n  },\n\n  /**\n   * Assign 'want' value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string | Number} w - either a string representation of the access mode or a set of bits.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  setWant: function(w) {\n    this.want = AccessMode.decode(w);\n    return this;\n  },\n  /**\n   * Update 'want' value.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {string} u - string representation of the changes to apply to access mode.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  updateWant: function(u) {\n    this.want = AccessMode.update(this.want, u);\n    return this;\n  },\n  /**\n   * Get 'want' value as a string.\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} - <b>want</b> value.\n   */\n  getWant: function() {\n    return AccessMode.encode(this.want);\n  },\n\n  /**\n   * Get permissions present in 'want' but missing in 'given'.\n   * Inverse of {@link Tinode.AccessMode#getExcessive}\n   *\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} permissions present in <b>want</b> but missing in <b>given</b>.\n   */\n  getMissing: function() {\n    return AccessMode.encode(this.want & ~this.given);\n  },\n\n  /**\n   * Get permissions present in 'given' but missing in 'want'.\n   * Inverse of {@link Tinode.AccessMode#getMissing}\n   * @memberof Tinode.AccessMode\n   *\n   * @returns {string} permissions present in <b>given</b> but missing in <b>want</b>.\n   */\n  getExcessive: function() {\n    return AccessMode.encode(this.given & ~this.want);\n  },\n\n  /**\n   * Update 'want', 'give', and 'mode' values.\n   * @memberof Tinode.AccessMode\n   *\n   * @param {AccessMode} val - new access mode value.\n   * @returns {AccessMode} - <code>this</code> AccessMode.\n   */\n  updateAll: function(val) {\n    if (val) {\n      this.updateGiven(val.given);\n      this.updateWant(val.want);\n      this.mode = this.given & this.want;\n    }\n    return this;\n  },\n\n  /**\n   * Check if Owner (O) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isOwner: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._OWNER);\n  },\n\n  /**\n   * Check if Presence (P) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isPresencer: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._PRES);\n  },\n\n  /**\n   * Check if Presence (P) flag is NOT set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isMuted: function(side) {\n    return !this.isPresencer(side);\n  },\n\n  /**\n   * Check if Join (J) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isJoiner: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._JOIN);\n  },\n\n  /**\n   * Check if Reader (R) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isReader: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._READ);\n  },\n\n  /**\n   * Check if Writer (W) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isWriter: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._WRITE);\n  },\n\n  /**\n   * Check if Approver (A) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isApprover: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._APPROVE);\n  },\n\n  /**\n   * Check if either one of Owner (O) or Approver (A) flags is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isAdmin: function(side) {\n    return this.isOwner(side) || this.isApprover(side);\n  },\n\n  /**\n   * Check if either one of Owner (O), Approver (A), or Sharer (S) flags is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isSharer: function(side) {\n    return this.isAdmin(side) || AccessMode._checkFlag(this, side, AccessMode._SHARE);\n  },\n\n  /**\n   * Check if Deleter (D) flag is set.\n   * @memberof Tinode.AccessMode\n   * @param {string=} side - which permission to check: given, want, mode; default: mode.\n   * @returns {boolean} - <code>true</code> if flag is set.\n   */\n  isDeleter: function(side) {\n    return AccessMode._checkFlag(this, side, AccessMode._DELETE);\n  }\n};\n\n/**\n * @callback Tinode.Topic.onData\n * @param {Data} data - Data packet\n */\n/**\n * Topic is a class representing a logical communication channel.\n * @class Topic\n * @memberof Tinode\n *\n * @param {string} name - Name of the topic to create.\n * @param {Object=} callbacks - Object with various event callbacks.\n * @param {Tinode.Topic.onData} callbacks.onData - Callback which receives a <code>{data}</code> message.\n * @param {callback} callbacks.onMeta - Callback which receives a <code>{meta}</code> message.\n * @param {callback} callbacks.onPres - Callback which receives a <code>{pres}</code> message.\n * @param {callback} callbacks.onInfo - Callback which receives an <code>{info}</code> message.\n * @param {callback} callbacks.onMetaDesc - Callback which receives changes to topic desctioption {@link desc}.\n * @param {callback} callbacks.onMetaSub - Called for a single subscription record change.\n * @param {callback} callbacks.onSubsUpdated - Called after a batch of subscription changes have been recieved and cached.\n * @param {callback} callbacks.onDeleteTopic - Called after the topic is deleted.\n * @param {callback} callbacls.onAllMessagesReceived - Called when all requested <code>{data}</code> messages have been recived.\n */\nvar Topic = function(name, callbacks) {\n  // Parent Tinode object.\n  this._tinode = null;\n\n  // Server-provided data, locally immutable.\n  // topic name\n  this.name = name;\n  // timestamp when the topic was created\n  this.created = null;\n  // timestamp when the topic was last updated\n  this.updated = null;\n  // timestamp of the last messages\n  this.touched = null;\n  // access mode, see AccessMode\n  this.acs = new AccessMode(null);\n  // per-topic private data\n  this.private = null;\n  // per-topic public data\n  this.public = null;\n\n  // Locally cached data\n  // Subscribed users, for tracking read/recv/msg notifications.\n  this._users = {};\n\n  // Current value of locally issued seqId, used for pending messages.\n  this._queuedSeqId = LOCAL_SEQID;\n\n  // The maximum known {data.seq} value.\n  this._maxSeq = 0;\n  // The minimum known {data.seq} value.\n  this._minSeq = 0;\n  // Indicator that the last request for earlier messages returned 0.\n  this._noEarlierMsgs = false;\n  // The maximum known deletion ID.\n  this._maxDel = 0;\n  // User discovery tags\n  this._tags = [];\n  // Credentials such as email or phone number.\n  this._credentials = [];\n  // Message cache, sorted by message seq values, from old to new.\n  this._messages = CBuffer(function(a, b) {\n    return a.seq - b.seq;\n  }, true);\n  // Boolean, true if the topic is currently live\n  this._subscribed = false;\n  // Timestap when topic meta-desc update was recived.\n  this._lastDescUpdate = null;\n  // Timestap when topic meta-subs update was recived.\n  this._lastSubsUpdate = null;\n  // Topic created but not yet synced with the server. Used only during initialization.\n  this._new = true;\n\n  // Callbacks\n  if (callbacks) {\n    this.onData = callbacks.onData;\n    this.onMeta = callbacks.onMeta;\n    this.onPres = callbacks.onPres;\n    this.onInfo = callbacks.onInfo;\n    // A single desc update;\n    this.onMetaDesc = callbacks.onMetaDesc;\n    // A single subscription record;\n    this.onMetaSub = callbacks.onMetaSub;\n    // All subscription records received;\n    this.onSubsUpdated = callbacks.onSubsUpdated;\n    this.onTagsUpdated = callbacks.onTagsUpdated;\n    this.onCredsUpdated = callbacks.onCredsUpdated;\n    this.onDeleteTopic = callbacks.onDeleteTopic;\n    this.onAllMessagesReceived = callbacks.onAllMessagesReceived;\n  }\n};\n\nTopic.prototype = {\n  /**\n   * Check if the topic is subscribed.\n   * @memberof Tinode.Topic#\n   * @returns {boolean} True is topic is attached/subscribed, false otherwise.\n   */\n  isSubscribed: function() {\n    return this._subscribed;\n  },\n\n  /**\n   * Request topic to subscribe. Wrapper for {@link Tinode#subscribe}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Tinode.GetQuery=} getParams - get query parameters.\n   * @param {Tinode.SetParams=} setParams - set parameters.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  subscribe: function(getParams, setParams) {\n    // If the topic is already subscribed, return resolved promise\n    if (this._subscribed) {\n      return Promise.resolve(this);\n    }\n\n    // Send subscribe message, handle async response.\n    // If topic name is explicitly provided, use it. If no name, then it's a new group topic,\n    // use \"new\".\n    return this._tinode.subscribe(this.name || TOPIC_NEW, getParams, setParams).then((ctrl) => {\n      if (ctrl.code >= 300) {\n        // Do nothing if subscription status has not changed.\n        return ctrl;\n      }\n\n      this._subscribed = true;\n      this.acs = (ctrl.params && ctrl.params.acs) ? ctrl.params.acs : this.acs;\n\n      // Set topic name for new topics and add it to cache.\n      if (this._new) {\n        this._new = false;\n\n        // 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.onMetaSub) {\n            me.onMetaSub(this);\n          }\n          if (me.onSubsUpdated) {\n            me.onSubsUpdated([this.name], 1);\n          }\n        }\n\n        if (setParams && setParams.desc) {\n          setParams.desc._noForwarding = true;\n          this._processMetaDesc(setParams.desc);\n        }\n      }\n\n      return ctrl;\n    });\n  },\n\n  /**\n   * Create a draft of a message without sending it to the server.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string | Object} data - Content to wrap in a draft.\n   * @param {boolean=} noEcho - If <code>true</code> server will not echo message back to originating\n   * session. Otherwise the server will send a copy of the message to sender.\n   *\n   * @returns {Object} message draft.\n   */\n  createMessage: function(data, noEcho) {\n    return this._tinode.createMessage(this.name, data, noEcho);\n  },\n\n  /**\n   * Immediately publish data to topic. Wrapper for {@link Tinode#publish}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string | Object} data - Data to publish, either plain string or a Drafty object.\n   * @param {boolean=} noEcho - If <code>true</code> server will not echo message back to originating\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  publish: function(data, noEcho) {\n    return this.publishMessage(this.createMessage(data, noEcho));\n  },\n\n  /**\n   * Publish message created by {@link Tinode.Topic#createMessage}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Object} pub - {data} object to publish. Must be created by {@link Tinode.Topic#createMessage}\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  publishMessage: function(pub) {\n    if (!this._subscribed) {\n      return Promise.reject(new Error(\"Cannot publish on inactive topic\"));\n    }\n\n    // Update header with attachment records.\n    if (Drafty.hasAttachments(pub.content) && !pub.head.attachments) {\n      let attachments = [];\n      Drafty.attachments(pub.content, (data) => {\n        attachments.push(data.ref);\n      });\n      pub.head.attachments = attachments;\n    }\n\n    // Send data.\n    pub._sending = true;\n    pub._failed = false;\n    return this._tinode.publishMessage(pub).then((ctrl) => {\n      pub._sending = false;\n      pub.ts = ctrl.ts;\n      this.swapMessageId(pub, ctrl.params.seq);\n      this._routeData(pub);\n      return ctrl;\n    }).catch((err) => {\n      this._tinode.logger(\"WARNING: Message rejected by the server\", err);\n      pub._sending = false;\n      pub._failed = true;\n      if (this.onData) {\n        this.onData();\n      }\n    });\n  },\n\n  /**\n   * Add message to local message cache, send to the server when the promise is resolved.\n   * If promise is null or undefined, the message will be sent immediately.\n   * The message is sent when the\n   * The message should be created by {@link Tinode.Topic#createMessage}.\n   * This is probably not the final API.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Object} pub - Message to use as a draft.\n   * @param {Promise} prom - Message will be sent when this promise is resolved, discarded if rejected.\n   *\n   * @returns {Promise} derived promise.\n   */\n  publishDraft: function(pub, prom) {\n    if (!prom && !this._subscribed) {\n      return Promise.reject(new Error(\"Cannot publish on inactive topic\"));\n    }\n\n    const seq = pub.seq || this._getQueuedSeqId();\n    if (!pub._noForwarding) {\n      // The 'seq', 'ts', and 'from' are added to mimic {data}. They are removed later\n      // before the message is sent.\n\n      pub._noForwarding = true;\n      pub.seq = seq;\n      pub.ts = new Date();\n      pub.from = this._tinode.getCurrentUserID();\n\n      // Don't need an echo message because the message is added to local cache right away.\n      pub.noecho = true;\n      // Add to cache.\n      this._messages.put(pub);\n      this._tinode._db.addMessage(this.name, pub);\n\n      if (this.onData) {\n        this.onData(pub);\n      }\n    }\n    // If promise is provided, send the queued message when it's resolved.\n    // If no promise is provided, create a resolved one and send immediately.\n    prom = (prom || Promise.resolve()).then(\n      ( /* argument ignored */ ) => {\n        if (pub._cancelled) {\n          return {\n            code: 300,\n            text: \"cancelled\"\n          };\n        }\n        return this.publishMessage(pub);\n      },\n      (err) => {\n        this._tinode.logger(\"WARNING: Message draft rejected\", err);\n        pub._sending = false;\n        pub._failed = true;\n        this._messages.delAt(this._messages.find(pub));\n        this._tinode._db.remMessages(this.name, pub.seq);\n        if (this.onData) {\n          this.onData();\n        }\n      });\n    return prom;\n  },\n\n  /**\n   * Leave the topic, optionally unsibscribe. Leaving the topic means the topic will stop\n   * receiving updates from the server. Unsubscribing will terminate user's relationship with the topic.\n   * Wrapper for {@link Tinode#leave}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolean=} unsub - If true, unsubscribe, otherwise just leave.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  leave: function(unsub) {\n    // It's possible to unsubscribe (unsub==true) from inactive topic.\n    if (!this._subscribed && !unsub) {\n      return Promise.reject(new Error(\"Cannot leave inactive topic\"));\n    }\n\n    // Send a 'leave' message, handle async response\n    return this._tinode.leave(this.name, unsub).then((ctrl) => {\n      this._resetSub();\n      if (unsub) {\n        this._tinode.cacheDel('topic', this.name);\n        this._gone();\n      }\n      return ctrl;\n    });\n  },\n\n  /**\n   * Request topic metadata from the server.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Tinode.GetQuery} request parameters\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  getMeta: function(params) {\n    // Send {get} message, return promise.\n    return this._tinode.getMeta(this.name, params);\n  },\n\n  /**\n   * Request more messages from the server\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} limit number of messages to get.\n   * @param {boolean} forward if true, request newer messages.\n   */\n  getMessagesPage: function(limit, forward) {\n    const query = this.startMetaQuery();\n    if (forward) {\n      query.withLaterData(limit);\n    } else {\n      query.withEarlierData(limit);\n    }\n    let promise = this.getMeta(query.build());\n    if (!forward) {\n      promise = promise.then((ctrl) => {\n        if (ctrl && ctrl.params && !ctrl.params.count) {\n          this._noEarlierMsgs = true;\n        }\n      });\n    }\n    return promise;\n  },\n\n  /**\n   * Update topic metadata.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Tinode.SetParams} params parameters to update.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  setMeta: function(params) {\n    if (params.tags) {\n      params.tags = normalizeArray(params.tags);\n    }\n    // Send Set message, handle async response.\n    return this._tinode.setMeta(this.name, params)\n      .then((ctrl) => {\n        if (ctrl && ctrl.code >= 300) {\n          // Not modified\n          return ctrl;\n        }\n\n        if (params.sub) {\n          params.sub.topic = this.name;\n          if (ctrl.params && ctrl.params.acs) {\n            params.sub.acs = ctrl.params.acs;\n            params.sub.updated = ctrl.ts;\n          }\n          if (!params.sub.user) {\n            // This is a subscription update of the current user.\n            // Assign user ID otherwise the update will be ignored by _processMetaSub.\n            params.sub.user = this._tinode.getCurrentUserID();\n            if (!params.desc) {\n              // Force update to topic's asc.\n              params.desc = {};\n            }\n          }\n          params.sub._noForwarding = true;\n          this._processMetaSub([params.sub]);\n        }\n\n        if (params.desc) {\n          if (ctrl.params && ctrl.params.acs) {\n            params.desc.acs = ctrl.params.acs;\n            params.desc.updated = ctrl.ts;\n          }\n          this._processMetaDesc(params.desc);\n        }\n\n        if (params.tags) {\n          this._processMetaTags(params.tags);\n        }\n        if (params.cred) {\n          this._processMetaCreds([params.cred], true);\n        }\n\n        return ctrl;\n      });\n  },\n\n  /**\n   * Update access mode of the current user or of another topic subsriber.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} uid - UID of the user to update or null to update current user.\n   * @param {string} update - the update value, full or delta.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  updateMode: function(uid, update) {\n    const user = uid ? this.subscriber(uid) : null;\n    const am = user ?\n      user.acs.updateGiven(update).getGiven() :\n      this.getAccessMode().updateWant(update).getWant();\n\n    return this.setMeta({\n      sub: {\n        user: uid,\n        mode: am\n      }\n    });\n  },\n\n  /**\n   * Create new topic subscription. Wrapper for {@link Tinode#setMeta}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} uid - ID of the user to invite\n   * @param {string=} mode - Access mode. <code>null</code> means to use default.\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  invite: function(uid, mode) {\n    return this.setMeta({\n      sub: {\n        user: uid,\n        mode: mode\n      }\n    });\n  },\n\n  /**\n   * Archive or un-archive the topic. Wrapper for {@link Tinode#setMeta}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolean} arch - true to archive the topic, false otherwise.\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  archive: function(arch) {\n    if (this.private && this.private.arch == arch) {\n      return Promise.resolve(arch);\n    }\n    return this.setMeta({\n      desc: {\n        private: {\n          arch: arch ? true : Tinode.DEL_CHAR\n        }\n      }\n    });\n  },\n\n  /**\n   * Delete messages. Hard-deleting messages requires Owner permission.\n   * Wrapper for {@link Tinode#delMessages}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Tinode.DelRange[]} ranges - Ranges of message IDs to delete.\n   * @param {boolean=} hard - Hard or soft delete\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  delMessages: function(ranges, hard) {\n    if (!this._subscribed) {\n      return Promise.reject(new Error(\"Cannot delete messages in inactive topic\"));\n    }\n\n    // Sort ranges in accending order by low, the descending by hi.\n    ranges.sort((r1, r2) => {\n      if (r1.low < r2.low) {\n        return true;\n      }\n      if (r1.low == r2.low) {\n        return !r2.hi || (r1.hi >= r2.hi);\n      }\n      return false;\n    });\n\n    // Remove pending messages from ranges possibly clipping some ranges.\n    let tosend = ranges.reduce((out, r) => {\n      if (r.low < LOCAL_SEQID) {\n        if (!r.hi || r.hi < LOCAL_SEQID) {\n          out.push(r);\n        } else {\n          // Clip hi to max allowed value.\n          out.push({\n            low: r.low,\n            hi: this._maxSeq + 1\n          });\n        }\n      }\n      return out;\n    }, []);\n\n    // Send {del} message, return promise\n    let result;\n    if (tosend.length > 0) {\n      result = this._tinode.delMessages(this.name, tosend, hard);\n    } else {\n      result = Promise.resolve({\n        params: {\n          del: 0\n        }\n      });\n    }\n    // Update local cache.\n    return result.then((ctrl) => {\n      if (ctrl.params.del > this._maxDel) {\n        this._maxDel = ctrl.params.del;\n      }\n\n      ranges.map((r) => {\n        if (r.hi) {\n          this.flushMessageRange(r.low, r.hi);\n        } else {\n          this.flushMessage(r.low);\n        }\n      });\n\n      this._updateDeletedRanges();\n\n      if (this.onData) {\n        // Calling with no parameters to indicate the messages were deleted.\n        this.onData();\n      }\n      return ctrl;\n    });\n  },\n\n  /**\n   * Delete all messages. Hard-deleting messages requires Owner permission.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolean} hardDel - true if messages should be hard-deleted.\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  delMessagesAll: function(hardDel) {\n    if (!this._maxSeq || this._maxSeq <= 0) {\n      // There are no messages to delete.\n      return Promise.resolve();\n    }\n    return this.delMessages([{\n      low: 1,\n      hi: this._maxSeq + 1,\n      _all: true\n    }], hardDel);\n  },\n\n  /**\n   * Delete multiple messages defined by their IDs. Hard-deleting messages requires Owner permission.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Tinode.DelRange[]} list - list of seq IDs to delete\n   * @param {boolean=} hardDel - true if messages should be hard-deleted.\n   *\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  delMessagesList: function(list, hardDel) {\n    // Sort the list in ascending order\n    list.sort((a, b) => a - b);\n    // Convert the array of IDs to ranges.\n    let ranges = list.reduce((out, id) => {\n      if (out.length == 0) {\n        // First element.\n        out.push({\n          low: id\n        });\n      } else {\n        let prev = out[out.length - 1];\n        if ((!prev.hi && (id != prev.low + 1)) || (id > prev.hi)) {\n          // New range.\n          out.push({\n            low: id\n          });\n        } else {\n          // Expand existing range.\n          prev.hi = prev.hi ? Math.max(prev.hi, id + 1) : id + 1;\n        }\n      }\n      return out;\n    }, []);\n    // Send {del} message, return promise\n    return this.delMessages(ranges, hardDel)\n  },\n\n  /**\n   * Delete topic. Requires Owner permission. Wrapper for {@link Tinode#delTopic}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolean} hard - had-delete topic.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to the request.\n   */\n  delTopic: function(hard) {\n    return this._tinode.delTopic(this.name, hard).then((ctrl) => {\n      this._resetSub();\n      this._gone();\n      return ctrl;\n    });\n  },\n\n  /**\n   * Delete subscription. Requires Share permission. Wrapper for {@link Tinode#delSubscription}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} user - ID of the user to remove subscription for.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  delSubscription: function(user) {\n    if (!this._subscribed) {\n      return Promise.reject(new Error(\"Cannot delete subscription in inactive topic\"));\n    }\n    // Send {del} message, return promise\n    return this._tinode.delSubscription(this.name, user).then((ctrl) => {\n      // Remove the object from the subscription cache;\n      delete this._users[user];\n      // Notify listeners\n      if (this.onSubsUpdated) {\n        this.onSubsUpdated(Object.keys(this._users));\n      }\n      return ctrl;\n    });\n  },\n\n  /**\n   * Send a read/recv notification.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} what - what notification to send: <code>recv</code>, <code>read</code>.\n   * @param {number} seq - ID or the message read or received.\n   */\n  note: function(what, seq) {\n    if (!this._subscribed) {\n      // Cannot sending {note} on an inactive topic\".\n      return;\n    }\n\n    // Update local cache with the new count.\n    const user = this._users[this._tinode.getCurrentUserID()];\n    let update = false;\n    if (user) {\n      // Self-subscription is found.\n      if (!user[what] || user[what] < seq) {\n        user[what] = seq;\n        update = true;\n      }\n    } else {\n      // Self-subscription is not found.\n      update = (this[what] | 0) < seq;\n    }\n\n    if (update) {\n      // Send notification to the server.\n      this._tinode.note(this.name, what, seq);\n      // Update locally cached contact with the new count.\n      this._updateReadRecv(what, seq);\n\n      const me = this._tinode.getMeTopic();\n      if (this.acs != null && !this.acs.isMuted() && me.onContactUpdate) {\n        // Sent a notification to 'me' listeners.\n        me.onContactUpdate(what, this);\n      }\n    }\n  },\n\n  /**\n   * Send a 'recv' receipt. Wrapper for {@link Tinode#noteRecv}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seq - ID of the message to aknowledge.\n   */\n  noteRecv: function(seq) {\n    this.note('recv', seq);\n  },\n\n  /**\n   * Send a 'read' receipt. Wrapper for {@link Tinode#noteRead}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seq - ID of the message to aknowledge or 0/undefined to acknowledge the latest messages.\n   */\n  noteRead: function(seq) {\n    seq = seq || this._maxSeq;\n    if (seq > 0) {\n      this.note('read', seq);\n    }\n  },\n\n  /**\n   * Send a key-press notification. Wrapper for {@link Tinode#noteKeyPress}.\n   * @memberof Tinode.Topic#\n   */\n  noteKeyPress: function() {\n    if (this._subscribed) {\n      this._tinode.noteKeyPress(this.name);\n    } else {\n      this._tinode.logger(\"INFO: Cannot send notification in inactive topic\");\n    }\n  },\n\n  // Update cached read/recv/unread counts.\n  _updateReadRecv: function(what, seq, ts) {\n    let oldVal, doUpdate = false;\n\n    seq = seq | 0;\n    this.seq = this.seq | 0;\n    this.read = this.read | 0;\n    this.recv = this.recv | 0;\n    switch (what) {\n      case 'recv':\n        oldVal = this.recv;\n        this.recv = Math.max(this.recv, seq);\n        doUpdate = (oldVal != this.recv);\n        break;\n      case 'read':\n        oldVal = this.read;\n        this.read = Math.max(this.read, seq);\n        doUpdate = (oldVal != this.read);\n        break;\n      case 'msg':\n        oldVal = this.seq;\n        this.seq = Math.max(this.seq, seq);\n        if (!this.touched || this.touched < ts) {\n          this.touched = ts;\n        }\n        doUpdate = (oldVal != this.seq);\n        break;\n    }\n\n    // Sanity checks.\n    if (this.recv < this.read) {\n      this.recv = this.read;\n      doUpdate = true;\n    }\n    if (this.seq < this.recv) {\n      this.seq = this.recv;\n      if (!this.touched || this.touched < ts) {\n        this.touched = ts;\n      }\n      doUpdate = true;\n    }\n    this.unread = this.seq - this.read;\n    return doUpdate;\n  },\n\n  /**\n   * Get user description from global cache. The user does not need to be a\n   * subscriber of this topic.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} uid - ID of the user to fetch.\n   * @return {Object} user description or undefined.\n   */\n  userDesc: function(uid) {\n    // TODO(gene): handle asynchronous requests\n\n    const user = this._cacheGetUser(uid);\n    if (user) {\n      return user; // Promise.resolve(user)\n    }\n  },\n\n  /**\n   * Get description of the p2p peer from subscription cache.\n   * @memberof Tinode.Topic#\n   *\n   * @return {Object} peer's description or undefined.\n   */\n  p2pPeerDesc: function() {\n    if (!this.isP2PType()) {\n      return undefined;\n    }\n    return this._users[this.name];\n  },\n\n  /**\n   * Iterate over cached subscribers. If callback is undefined, use this.onMetaSub.\n   * @memberof Tinode.Topic#\n   *\n   * @param {function} callback - Callback which will receive subscribers one by one.\n   * @param {Object=} context - Value of `this` inside the `callback`.\n   */\n  subscribers: function(callback, context) {\n    const cb = (callback || this.onMetaSub);\n    if (cb) {\n      for (let idx in this._users) {\n        cb.call(context, this._users[idx], idx, this._users);\n      }\n    }\n  },\n\n  /**\n   * Get a copy of cached tags.\n   * @memberof Tinode.Topic#\n   *\n   * @return {Array.<string>} a copy of tags\n   */\n  tags: function() {\n    // Return a copy.\n    return this._tags.slice(0);\n  },\n\n  /**\n   * Get cached subscription for the given user ID.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} uid - id of the user to query for\n   * @return user description or undefined.\n   */\n  subscriber: function(uid) {\n    return this._users[uid];\n  },\n\n  /**\n   * Iterate over cached messages. If callback is undefined, use this.onData.\n   * @memberof Tinode.Topic#\n   *\n   * @param {function} callback - Callback which will receive messages one by one. See {@link Tinode.CBuffer#forEach}\n   * @param {number} sinceId - Optional seqId to start iterating from (inclusive).\n   * @param {number} beforeId - Optional seqId to stop iterating before (exclusive).\n   * @param {Object} context - Value of `this` inside the `callback`.\n   */\n  messages: function(callback, sinceId, beforeId, context) {\n    const cb = (callback || this.onData);\n    if (cb) {\n      let startIdx = typeof sinceId == 'number' ? this._messages.find({\n        seq: sinceId\n      }, true) : undefined;\n      let beforeIdx = typeof beforeId == 'number' ? this._messages.find({\n        seq: beforeId\n      }, true) : undefined;\n      if (startIdx != -1 && beforeIdx != -1) {\n        this._messages.forEach(cb, startIdx, beforeIdx, context);\n      }\n    }\n  },\n\n  /**\n   * Get the most recent message from cache.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {Object} the most recent cached message or <code>undefined</code>, if no messages are cached.\n   */\n  latestMessage: function() {\n    return this._messages.getLast();\n  },\n\n  /**\n   * Iterate over cached unsent messages. Wraps {@link Tinode.Topic#messages}.\n   * @memberof Tinode.Topic#\n   *\n   * @param {function} callback - Callback which will receive messages one by one. See {@link Tinode.CBuffer#forEach}\n   * @param {Object} context - Value of <code>this</code> inside the <code>callback</code>.\n   */\n  queuedMessages: function(callback, context) {\n    if (!callback) {\n      throw new Error(\"Callback must be provided\");\n    }\n    this.messages(callback, LOCAL_SEQID, undefined, context);\n  },\n\n  /**\n   * Get the number of topic subscribers who marked this message as either recv or read\n   * Current user is excluded from the count.\n   * @memberof Tinode.Topic#\n   *\n   * @param {string} what - what action to consider: received <code>\"recv\"</code> or read <code>\"read\"</code>.\n   * @param {number} seq - ID or the message read or received.\n   *\n   * @returns {number} the number of subscribers who marked the message with the given ID as read or received.\n   */\n  msgReceiptCount: function(what, seq) {\n    let count = 0;\n    if (seq > 0) {\n      const me = this._tinode.getCurrentUserID();\n      for (let idx in this._users) {\n        const user = this._users[idx];\n        if (user.user !== me && user[what] >= seq) {\n          count++;\n        }\n      }\n    }\n    return count;\n  },\n\n  /**\n   * Get the number of topic subscribers who marked this message (and all older messages) as read.\n   * The current user is excluded from the count.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seq - message id to check.\n   * @returns {number} number of subscribers who claim to have received the message.\n   */\n  msgReadCount: function(seq) {\n    return this.msgReceiptCount('read', seq);\n  },\n\n  /**\n   * Get the number of topic subscribers who marked this message (and all older messages) as received.\n   * The current user is excluded from the count.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seq - Message id to check.\n   * @returns {number} Number of subscribers who claim to have received the message.\n   */\n  msgRecvCount: function(seq) {\n    return this.msgReceiptCount('recv', seq);\n  },\n\n  /**\n   * Check if cached message IDs indicate that the server may have more messages.\n   * @memberof Tinode.Topic#\n   *\n   * @param {boolean} newer - if <code>true</code>, check for newer messages only.\n   */\n  msgHasMoreMessages: function(newer) {\n    return newer ? this.seq > this._maxSeq :\n      // _minSeq could be more than 1, but earlier messages could have been deleted.\n      (this._minSeq > 1 && !this._noEarlierMsgs);\n  },\n\n  /**\n   * Check if the given seq Id is id of the most recent message.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seqId id of the message to check\n   */\n  isNewMessage: function(seqId) {\n    return this._maxSeq <= seqId;\n  },\n\n  /**\n   * Remove one message from local cache.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seqId id of the message to remove from cache.\n   * @returns {Message} removed message or undefined if such message was not found.\n   */\n  flushMessage: function(seqId) {\n    const idx = this._messages.find({\n      seq: seqId\n    });\n    if (idx >= 0) {\n      this._tinode._db.remMessages(this.name, seqId);\n      return this._messages.delAt(idx);\n    }\n    return undefined;\n  },\n\n  /**\n   * Update message's seqId.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Object} pub message object.\n   * @param {number} newSeqId new seq id for pub.\n   */\n  swapMessageId: function(pub, newSeqId) {\n    const idx = this._messages.find(pub);\n    const numMessages = this._messages.length();\n    if (0 <= idx && idx < numMessages) {\n      // Remove message with the old seq ID.\n      this._messages.delAt(idx);\n      this._tinode._db.remMessages(this.name, pub.seq);\n      // Add message with the new seq ID.\n      pub.seq = newSeqId;\n      this._messages.put(pub);\n      this._tinode._db.addMessage(this.name, pub);\n    }\n  },\n\n  /**\n   * Remove a range of messages from the local cache.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} fromId seq ID of the first message to remove (inclusive).\n   * @param {number} untilId seqID of the last message to remove (exclusive).\n   *\n   * @returns {Message[]} array of removed messages (could be empty).\n   */\n  flushMessageRange: function(fromId, untilId) {\n    // Remove range from persistent cache.\n    this._tinode._db.remMessages(this.name, fromId, untilId);\n    // start, end: find insertion points (nearest == true).\n    const since = this._messages.find({\n      seq: fromId\n    }, true);\n    return since >= 0 ? this._messages.delRange(since, this._messages.find({\n      seq: untilId\n    }, true)) : [];\n  },\n\n  /**\n   * Attempt to stop message from being sent.\n   * @memberof Tinode.Topic#\n   *\n   * @param {number} seqId id of the message to stop sending and remove from cache.\n   *\n   * @returns {boolean} <code>true</code> if message was cancelled, <code>false</code> otherwise.\n   */\n  cancelSend: function(seqId) {\n    const idx = this._messages.find({\n      seq: seqId\n    });\n    if (idx >= 0) {\n      const msg = this._messages.getAt(idx);\n      const status = this.msgStatus(msg);\n      if (status == MESSAGE_STATUS_QUEUED || status == MESSAGE_STATUS_FAILED) {\n        this._tinode._db.remMessages(this.name, seqId);\n        msg._cancelled = true;\n        this._messages.delAt(idx);\n        if (this.onData) {\n          // Calling with no parameters to indicate the message was deleted.\n          this.onData();\n        }\n        return true;\n      }\n    }\n    return false;\n  },\n\n  /**\n   * Get type of the topic: me, p2p, grp, fnd...\n   * @memberof Tinode.Topic#\n   *\n   * @returns {string} One of 'me', 'p2p', 'grp', 'fnd', 'sys' or <code>undefined</code>.\n   */\n  getType: function() {\n    return Tinode.topicType(this.name);\n  },\n\n  /**\n   * Get current user's access mode of the topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {Tinode.AccessMode} - user's access mode\n   */\n  getAccessMode: function() {\n    return this.acs;\n  },\n\n  /**\n   * Set current user's access mode of the topic.\n   * @memberof Tinode.Topic#\n   *\n   * @param {AccessMode | Object} acs - access mode to set.\n   */\n  setAccessMode: function(acs) {\n    return this.acs = new AccessMode(acs);\n  },\n\n  /**\n   * Get topic's default access mode.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {Tinode.DefAcs} - access mode, such as {auth: `RWP`, anon: `N`}.\n   */\n  getDefaultAccess: function() {\n    return this.defacs;\n  },\n\n  /**\n   * Initialize new meta {@link Tinode.GetQuery} builder. The query is attched to the current topic.\n   * It will not work correctly if used with a different topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {Tinode.MetaGetBuilder} query attached to the current topic.\n   */\n  startMetaQuery: function() {\n    return new MetaGetBuilder(this);\n  },\n\n  /**\n   * Check if topic is archived, i.e. private.arch == true.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is archived, <code>false</code> otherwise.\n   */\n  isArchived: function() {\n    return this.private && this.private.arch ? true : false;\n  },\n\n  /**\n   * Check if topic is a 'me' topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is a 'me' topic, <code>false</code> otherwise.\n   */\n  isMeType: function() {\n    return Tinode.isMeTopicName(this.name);\n  },\n\n  /**\n   * Check if topic is a channel.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is a channel, <code>false</code> otherwise.\n   */\n  isChannelType: function() {\n    return Tinode.isChannelTopicName(this.name);\n  },\n\n  /**\n   * Check if topic is a group topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is a group, <code>false</code> otherwise.\n   */\n  isGroupType: function() {\n    return Tinode.isGroupTopicName(this.name);\n  },\n\n  /**\n   * Check if topic is a p2p topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is a p2p topic, <code>false</code> otherwise.\n   */\n  isP2PType: function() {\n    return Tinode.isP2PTopicName(this.name);\n  },\n\n  /**\n   * Check if topic is a communication topic, i.e. a group or p2p topic.\n   * @memberof Tinode.Topic#\n   *\n   * @returns {boolean} - <code>true</code> if topic is a p2p or group topic, <code>false</code> otherwise.\n   */\n  isCommType: function() {\n    return Tinode.isCommTopicName(this.name);\n  },\n\n  /**\n   * Get status (queued, sent, received etc) of a given message in the context\n   * of this topic.\n   * @memberof Tinode.Topic#\n   *\n   * @param {Message} msg message to check for status.\n   * @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 || msg._cancelled) {\n        status = MESSAGE_STATUS_FAILED;\n      } else if (msg.seq >= LOCAL_SEQID) {\n        status = MESSAGE_STATUS_QUEUED;\n      } else if (this.msgReadCount(msg.seq) > 0) {\n        status = MESSAGE_STATUS_READ;\n      } else if (this.msgRecvCount(msg.seq) > 0) {\n        status = MESSAGE_STATUS_RECEIVED;\n      } else if (msg.seq > 0) {\n        status = MESSAGE_STATUS_SENT;\n      }\n    } else {\n      status = MESSAGE_STATUS_TO_ME;\n    }\n    return status;\n  },\n\n  // Process data message\n  _routeData: function(data) {\n    if (data.content) {\n      if (!this.touched || this.touched < data.ts) {\n        this.touched = data.ts;\n      }\n    }\n\n    if (data.seq > this._maxSeq) {\n      this._maxSeq = data.seq;\n    }\n    if (data.seq < this._minSeq || this._minSeq == 0) {\n      this._minSeq = data.seq;\n    }\n\n    if (!data._noForwarding) {\n      this._messages.put(data);\n      this._tinode._db.addMessage(this.name, data);\n      this._updateDeletedRanges();\n    }\n\n    if (this.onData) {\n      this.onData(data);\n    }\n\n    // Update locally cached contact with the new message count.\n    const what = ((!this.isChannelType() && !data.from) || this._tinode.isMe(data.from)) ? 'read' : 'msg';\n    const updated = this._updateReadRecv(what, data.seq, data.ts);\n    const me = this._tinode.getMeTopic();\n    if (updated && me.onContactUpdate) {\n      // Notify 'me' listeners of the change.\n      me.onContactUpdate(what, this);\n    }\n  },\n\n  // Process metadata message\n  _routeMeta: function(meta) {\n    if (meta.desc) {\n      this._lastDescUpdate = meta.ts;\n      this._processMetaDesc(meta.desc);\n    }\n    if (meta.sub && meta.sub.length > 0) {\n      this._lastSubsUpdate = meta.ts;\n      this._processMetaSub(meta.sub);\n    }\n    if (meta.del) {\n      this._processDelMessages(meta.del.clear, meta.del.delseq);\n    }\n    if (meta.tags) {\n      this._processMetaTags(meta.tags);\n    }\n    if (meta.cred) {\n      this._processMetaCreds(meta.cred);\n    }\n    if (this.onMeta) {\n      this.onMeta(meta);\n    }\n  },\n\n  // Process presence change message\n  _routePres: function(pres) {\n    let user;\n    switch (pres.what) {\n      case 'del':\n        // Delete cached messages.\n        this._processDelMessages(pres.clear, pres.delseq);\n        break;\n      case 'on':\n      case 'off':\n        // Update online status of a subscription.\n        user = this._users[pres.src];\n        if (user) {\n          user.online = pres.what == 'on';\n        } else {\n          this._tinode.logger(\"WARNING: Presence update for an unknown user\", this.name, pres.src);\n        }\n        break;\n      case 'term':\n        // Attachment to topic is terminated probably due to cluster rehashing.\n        this._resetSub();\n        break;\n      case 'acs':\n        const uid = pres.src || this._tinode.getCurrentUserID();\n        user = this._users[uid];\n        if (!user) {\n          // Update for an unknown user: notification of a new subscription.\n          const acs = new AccessMode().updateAll(pres.dacs);\n          if (acs && acs.mode != AccessMode._NONE) {\n            user = this._cacheGetUser(uid);\n            if (!user) {\n              user = {\n                user: uid,\n                acs: acs\n              };\n              this.getMeta(this.startMetaQuery().withOneSub(undefined, uid).build());\n            } else {\n              user.acs = acs;\n            }\n            user.updated = new Date();\n            this._processMetaSub([user]);\n          }\n        } else {\n          // Known user\n          user.acs.updateAll(pres.dacs);\n          // Update user's access mode.\n          this._processMetaSub([{\n            user: uid,\n            updated: new Date(),\n            acs: user.acs\n          }]);\n        }\n        break;\n      default:\n        this._tinode.logger(\"INFO: Ignored presence update\", pres.what);\n    }\n\n    if (this.onPres) {\n      this.onPres(pres);\n    }\n  },\n\n  // Process {info} message\n  _routeInfo: function(info) {\n    if (info.what !== 'kp') {\n      const user = this._users[info.from];\n      if (user) {\n        user[info.what] = info.seq;\n        if (user.recv < user.read) {\n          user.recv = user.read;\n        }\n      }\n\n      // If this is an update from the current user, update the cache with the new count and notify 'me' listener.\n      if (this._tinode.isMe(info.from)) {\n        const updated = this._updateReadRecv(info.what, info.seq);\n        if (updated) {\n          const me = this._tinode.getMeTopic();\n          if (me.onContactUpdate) {\n            me.onContactUpdate(info.what, this);\n          }\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.isP2PType()) {\n      delete desc.defacs;\n    }\n\n    // Copy parameters from desc object to this topic.\n    mergeObj(this, desc);\n    // Make sure date fields are Date().\n    stringToDate(this);\n\n    // Notify 'me' listener, if available:\n    if (this.name !== TOPIC_ME && !desc._noForwarding) {\n      const me = this._tinode.getMeTopic();\n      if (me.onMetaSub) {\n        me.onMetaSub(this);\n      }\n      if (me.onSubsUpdated) {\n        me.onSubsUpdated([this.name], 1);\n      }\n    }\n\n    if (this.onMetaDesc) {\n      this.onMetaDesc(this);\n    }\n  },\n\n  // Called by Tinode when meta.sub is recived or in response to received\n  // {ctrl} after setMeta-sub.\n  _processMetaSub: function(subs) {\n    for (let idx in subs) {\n      const sub = subs[idx];\n\n      sub.updated = new Date(sub.updated);\n      sub.deleted = sub.deleted ? new Date(sub.deleted) : null;\n\n      let user = null;\n      if (!sub.deleted) {\n        // If this is a change to user's own permissions, update them in topic too.\n        // Desc will update 'me' topic.\n        if (this._tinode.isMe(sub.user) && sub.acs) {\n          this._processMetaDesc({\n            updated: sub.updated || new Date(),\n            touched: sub.updated,\n            acs: sub.acs\n          });\n        }\n        user = this._updateCachedUser(sub.user, sub);\n      } else {\n        // Subscription is deleted, remove it from topic (but leave in Users cache)\n        delete this._users[sub.user];\n        user = sub;\n      }\n\n      if (this.onMetaSub) {\n        this.onMetaSub(user);\n      }\n    }\n\n    if (this.onSubsUpdated) {\n      this.onSubsUpdated(Object.keys(this._users));\n    }\n  },\n\n  // Called by Tinode when meta.tags is recived.\n  _processMetaTags: function(tags) {\n    if (tags.length == 1 && tags[0] == Tinode.DEL_CHAR) {\n      tags = [];\n    }\n    this._tags = tags;\n    if (this.onTagsUpdated) {\n      this.onTagsUpdated(tags);\n    }\n  },\n\n  // Do nothing for topics other than 'me'\n  _processMetaCreds: function(creds) {},\n\n  // Delete cached messages and update cached transaction IDs\n  _processDelMessages: function(clear, delseq) {\n    this._maxDel = Math.max(clear, this._maxDel);\n    this.clear = Math.max(clear, this.clear);\n    const topic = this;\n    let count = 0;\n    if (Array.isArray(delseq)) {\n      delseq.map(function(range) {\n        if (!range.hi) {\n          count++;\n          topic.flushMessage(range.low);\n        } else {\n          for (let i = range.low; i < range.hi; i++) {\n            count++;\n            topic.flushMessage(i);\n          }\n        }\n      });\n    }\n\n    if (count > 0) {\n      this._updateDeletedRanges();\n\n      if (this.onData) {\n        this.onData();\n      }\n    }\n  },\n\n  // Topic is informed that the entire response to {get what=data} has been received.\n  _allMessagesReceived: function(count) {\n    this._updateDeletedRanges();\n\n    if (this.onAllMessagesReceived) {\n      this.onAllMessagesReceived(count);\n    }\n  },\n\n  // Reset subscribed state\n  _resetSub: function() {\n    this._subscribed = false;\n  },\n\n  // This topic is either deleted or unsubscribed from.\n  _gone: function() {\n    this._messages.reset();\n    this._tinode._db.remMessages(this.name);\n    this._users = {};\n    this.acs = new AccessMode(null);\n    this.private = null;\n    this.public = null;\n    this._maxSeq = 0;\n    this._minSeq = 0;\n    this._subscribed = false;\n\n    const me = this._tinode.getMeTopic();\n    if (me) {\n      me._routePres({\n        _noForwarding: true,\n        what: 'gone',\n        topic: TOPIC_ME,\n        src: this.name\n      });\n    }\n    if (this.onDeleteTopic) {\n      this.onDeleteTopic();\n    }\n  },\n\n  // Update global user cache and local subscribers cache.\n  // Don't call this method for non-subscribers.\n  _updateCachedUser: function(uid, obj) {\n    // Fetch user object from the global cache.\n    // This is a clone of the stored object\n    let cached = this._cacheGetUser(uid);\n    cached = mergeObj(cached || {}, obj);\n    // Save to global cache\n    this._cachePutUser(uid, cached);\n    // Save to the list of topic subsribers.\n    return mergeToCache(this._users, uid, cached);\n  },\n\n  // Get local seqId for a queued message.\n  _getQueuedSeqId: function() {\n    return this._queuedSeqId++;\n  },\n\n  // Calculate ranges of missing messages.\n  _updateDeletedRanges: function() {\n    const ranges = [];\n\n    let prev = null;\n    // Check for gap in the beginning, before the first message.\n    const first = this._messages.getAt(0);\n    if (first && this._minSeq > 1 && !this._noEarlierMsgs) {\n      // Some messages are missing in the beginning.\n      if (first.hi) {\n        // The first message already represents a gap.\n        if (first.seq > 1) {\n          first.seq = 1;\n        }\n        if (first.hi < this._minSeq - 1) {\n          first.hi = this._minSeq - 1;\n        }\n        prev = first;\n      } else {\n        // Create new gap.\n        prev = {\n          seq: 1,\n          hi: this._minSeq - 1\n        };\n        ranges.push(prev);\n      }\n    } else {\n      // No gap in the beginning.\n      prev = {\n        seq: 0,\n        hi: 0\n      };\n    }\n\n    // Find gaps in the list of received messages. The list contains messages-proper as well\n    // as placeholers for deleted ranges.\n    // The messages are iterated by seq ID in ascending order.\n    this._messages.forEach((data) => {\n      // Do not create a gap between the last sent message and the first unsent.\n      if (data.seq >= LOCAL_SEQID) {\n        return;\n      }\n\n      // New message is reducing the existing gap\n      if (data.seq == (prev.hi || prev.seq) + 1) {\n        // No new gap. Replace previous with current.\n        prev = data;\n        return;\n      }\n\n      // Found a new gap.\n      if (prev.hi) {\n        // Previous is also a gap, alter it.\n        prev.hi = data.hi || data.seq;\n        return;\n      }\n\n      // Previous is not a gap. Create a new gap.\n      prev = {\n        seq: (prev.hi || prev.seq) + 1,\n        hi: data.hi || data.seq\n      };\n      ranges.push(prev);\n    });\n\n    // Check for missing messages at the end.\n    // All messages could be missing or it could be a new topic with no messages.\n    const last = this._messages.getLast();\n    const maxSeq = Math.max(this.seq, this._maxSeq) || 0;\n    if ((maxSeq > 0 && !last) || (last && ((last.hi || last.seq) < maxSeq))) {\n      if (last && last.hi) {\n        // Extend existing gap\n        last.hi = maxSeq;\n      } else {\n        // Create new gap.\n        ranges.push({\n          seq: last ? last.seq + 1 : 1,\n          hi: maxSeq\n        });\n      }\n    }\n\n    // Insert new gaps into cache.\n    ranges.map((gap) => {\n      this._messages.put(gap);\n    });\n  },\n\n  // Load most recent messages from persistent cache.\n  _loadMessages: function() {\n    return this._tinode._db.readMessages(this.name, {\n        limit: DEFAULT_MESSAGES_PAGE\n      })\n      .then((msgs) => {\n        msgs.forEach((data) => {\n          if (data.seq > this._maxSeq) {\n            this._maxSeq = data.seq;\n          }\n          if (data.seq < this._minSeq || this._minSeq == 0) {\n            this._minSeq = data.seq;\n          }\n          this._messages.put(data);\n        });\n\n        this._updateDeletedRanges();\n      });\n  }\n};\n\n/**\n * @class TopicMe - special case of {@link Tinode.Topic} for\n * managing data of the current user, including contact list.\n * @extends Tinode.Topic\n * @memberof Tinode\n *\n * @param {TopicMe.Callbacks} callbacks - Callbacks to receive various events.\n */\nvar TopicMe = function(callbacks) {\n  Topic.call(this, TOPIC_ME, callbacks);\n\n  // me-specific callbacks\n  if (callbacks) {\n    this.onContactUpdate = callbacks.onContactUpdate;\n  }\n};\n\n// Inherit everyting from the generic Topic\nTopicMe.prototype = Object.create(Topic.prototype, {\n  // Override the original Topic._processMetaDesc.\n  _processMetaDesc: {\n    value: function(desc) {\n      // Check if online contacts need to be turned off because P permission was removed.\n      const turnOff = (desc.acs && !desc.acs.isPresencer()) && (this.acs && this.acs.isPresencer());\n\n      // Copy parameters from desc object to this topic.\n      mergeObj(this, desc);\n      // String datetime headers to Date() objects.\n      stringToDate(this);\n\n      // 'P' permission was removed. All topics are offline now.\n      if (turnOff) {\n        this._tinode.cacheMap('topic', (cont) => {\n          if (cont.online) {\n            cont.online = false;\n            if (cont.seen) {\n              cont.seen.when = new Date();\n            } else {\n              cont.seen = {\n                when: new Date()\n              };\n            }\n            if (this.onContactUpdate) {\n              this.onContactUpdate('off', cont);\n            }\n          }\n        });\n      }\n\n      if (this.onMetaDesc) {\n        this.onMetaDesc(this);\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  // Override the original Topic._processMetaSub\n  _processMetaSub: {\n    value: function(subs) {\n      let updateCount = 0;\n      subs.forEach((sub) => {\n        const topicName = sub.topic;\n        // Don't show 'me' and 'fnd' topics in the list of contacts.\n        if (topicName == TOPIC_FND || topicName == TOPIC_ME) {\n          return;\n        }\n        sub.updated = new Date(sub.updated);\n        sub.touched = sub.touched ? new Date(sub.touched) : undefined;\n        sub.deleted = sub.deleted ? new Date(sub.deleted) : null;\n\n        let cont = null;\n        if (sub.deleted) {\n          cont = sub;\n          this._tinode.cacheDel('topic', topicName);\n          this._tinode._db.remTopic(topicName);\n        } else {\n          // Ensure the values are defined and are integers.\n          if (typeof sub.seq != 'undefined') {\n            sub.seq = sub.seq | 0;\n            sub.recv = sub.recv | 0;\n            sub.read = sub.read | 0;\n            sub.unread = sub.seq - sub.read;\n          }\n\n          if (sub.seen && sub.seen.when) {\n            sub.seen.when = new Date(sub.seen.when);\n          }\n\n          cont = mergeObj(this._tinode.getTopic(topicName), sub);\n          this._tinode._db.updTopic(cont);\n\n          if (Tinode.isP2PTopicName(topicName)) {\n            this._cachePutUser(topicName, cont);\n          }\n          // Notify topic of the update if it's an external update.\n          if (!sub._noForwarding) {\n            const topic = this._tinode.getTopic(topicName);\n            if (topic) {\n              sub._noForwarding = true;\n              topic._processMetaDesc(sub);\n            }\n          }\n        }\n\n        updateCount++;\n\n        if (this.onMetaSub) {\n          this.onMetaSub(cont);\n        }\n      });\n\n      if (this.onSubsUpdated && updateCount > 0) {\n        const keys = [];\n        subs.forEach((s) => {\n          keys.push(s.topic);\n        });\n        this.onSubsUpdated(keys, updateCount);\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  // Called by Tinode when meta.sub is recived.\n  _processMetaCreds: {\n    value: function(creds, upd) {\n      if (creds.length == 1 && creds[0] == Tinode.DEL_CHAR) {\n        creds = [];\n      }\n      if (upd) {\n        creds.map((cr) => {\n          if (cr.val) {\n            // Adding a credential.\n            let idx = this._credentials.findIndex((el) => {\n              return el.meth == cr.meth && el.val == cr.val;\n            });\n            if (idx < 0) {\n              // Not found.\n              if (!cr.done) {\n                // Unconfirmed credential replaces previous unconfirmed credential of the same method.\n                idx = this._credentials.findIndex((el) => {\n                  return el.meth == cr.meth && !el.done;\n                });\n                if (idx >= 0) {\n                  // Remove previous unconfirmed credential.\n                  this._credentials.splice(idx, 1);\n                }\n              }\n              this._credentials.push(cr);\n            } else {\n              // Found. Maybe change 'done' status.\n              this._credentials[idx].done = cr.done;\n            }\n          } else if (cr.resp) {\n            // Handle credential confirmation.\n            const idx = this._credentials.findIndex((el) => {\n              return el.meth == cr.meth && !el.done;\n            });\n            if (idx >= 0) {\n              this._credentials[idx].done = true;\n            }\n          }\n        });\n      } else {\n        this._credentials = creds;\n      }\n      if (this.onCredsUpdated) {\n        this.onCredsUpdated(this._credentials);\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  // Process presence change message\n  _routePres: {\n    value: function(pres) {\n      if (pres.what == 'term') {\n        // The 'me' topic itself is detached. Mark as unsubscribed.\n        this._resetSub();\n        return;\n      }\n\n      if (pres.what == 'upd' && pres.src == TOPIC_ME) {\n        // Update to me's description. Request updated value.\n        this.getMeta(this.startMetaQuery().withDesc().build());\n        return;\n      }\n\n      const cont = this._tinode.cacheGet('topic', pres.src);\n      if (cont) {\n        switch (pres.what) {\n          case 'on': // topic came online\n            cont.online = true;\n            break;\n          case 'off': // topic went offline\n            if (cont.online) {\n              cont.online = false;\n              if (cont.seen) {\n                cont.seen.when = new Date();\n              } else {\n                cont.seen = {\n                  when: new Date()\n                };\n              }\n            }\n            break;\n          case 'msg': // new message received\n            cont.touched = new Date();\n            cont.seq = pres.seq | 0;\n            // Check if message is sent by the current user. If so it's been read already.\n            if (!pres.act || this._tinode.isMe(pres.act)) {\n              cont.read = cont.read ? Math.max(cont.read, cont.seq) : cont.seq;\n              cont.recv = cont.recv ? Math.max(cont.read, cont.recv) : cont.read;\n            }\n            cont.unread = cont.seq - (cont.read | 0);\n            break;\n          case 'upd': // desc updated\n            // Request updated subscription.\n            this.getMeta(this.startMetaQuery().withLaterOneSub(pres.src).build());\n            break;\n          case 'acs': // access mode changed\n            if (cont.acs) {\n              cont.acs.updateAll(pres.dacs);\n            } else {\n              cont.acs = new AccessMode().updateAll(pres.dacs);\n            }\n            cont.touched = new Date();\n            break;\n          case 'ua':\n            // user agent changed.\n            cont.seen = {\n              when: new Date(),\n              ua: pres.ua\n            };\n            break;\n          case 'recv':\n            // user's other session marked some messges as received.\n            pres.seq = pres.seq | 0;\n            cont.recv = cont.recv ? Math.max(cont.recv, pres.seq) : pres.seq;\n            break;\n          case 'read':\n            // user's other session marked some messages as read.\n            pres.seq = pres.seq | 0;\n            cont.read = cont.read ? Math.max(cont.read, pres.seq) : pres.seq;\n            cont.recv = cont.recv ? Math.max(cont.read, cont.recv) : cont.recv;\n            cont.unread = cont.seq - cont.read;\n            break;\n          case 'gone':\n            // topic deleted or unsubscribed from.\n            this._tinode.cacheDel('topic', pres.src);\n            break;\n          case 'del':\n            // Update topic.del value.\n            break;\n          default:\n            this._tinode.logger(\"INFO: Unsupported presence update in 'me'\", pres.what);\n        }\n\n        if (this.onContactUpdate) {\n          this.onContactUpdate(pres.what, cont);\n        }\n      } else {\n        if (pres.what == 'acs') {\n          // New subscriptions and deleted/banned subscriptions have full\n          // access mode (no + or - in the dacs string). Changes to known subscriptions are sent as\n          // deltas, but they should not happen here.\n          const acs = new AccessMode(pres.dacs);\n          if (!acs || acs.mode == AccessMode._INVALID) {\n            this._tinode.logger(\"ERROR: Invalid access mode update\", pres.src, pres.dacs);\n            return;\n          } else if (acs.mode == AccessMode._NONE) {\n            this._tinode.logger(\"WARNING: Removing non-existent subscription\", pres.src, pres.dacs);\n            return;\n          } else {\n            // New subscription. Send request for the full description.\n            // Using .withOneSub (not .withLaterOneSub) to make sure IfModifiedSince is not set.\n            this.getMeta(this.startMetaQuery().withOneSub(undefined, pres.src).build());\n            // Create a dummy entry to catch online status update.\n            const dummy = this._tinode.getTopic(pres.src);\n            dummy.touched = new Date();\n            dummy.topic = pres.src;\n            dummy.online = false;\n            dummy.acs = acs;\n            this._tinode.attachCacheToTopic(dummy);\n            dummy._cachePutSelf();\n            this._db.addTopic(dummy);\n          }\n        } else if (pres.what == 'tags') {\n          this.getMeta(this.startMetaQuery().withTags().build());\n        }\n      }\n\n      if (this.onPres) {\n        this.onPres(pres);\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Publishing to TopicMe is not supported. {@link Topic#publish} is overriden and thows an {Error} if called.\n   * @memberof Tinode.TopicMe#\n   * @throws {Error} Always throws an error.\n   */\n  publish: {\n    value: function() {\n      return Promise.reject(new Error(\"Publishing to 'me' is not supported\"));\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Delete validation credential.\n   * @memberof Tinode.TopicMe#\n   *\n   * @param {string} topic - Name of the topic to delete\n   * @param {string} user - User ID to remove.\n   * @returns {Promise} Promise which will be resolved/rejected on receiving server reply.\n   */\n  delCredential: {\n    value: function(method, value) {\n      if (!this._subscribed) {\n        return Promise.reject(new Error(\"Cannot delete credential in inactive 'me' topic\"));\n      }\n      // Send {del} message, return promise\n      return this._tinode.delCredential(method, value).then((ctrl) => {\n        // Remove deleted credential from the cache.\n        const index = this._credentials.findIndex((el) => {\n          return el.meth == method && el.val == value;\n        });\n        if (index > -1) {\n          this._credentials.splice(index, 1);\n        }\n        // Notify listeners\n        if (this.onCredsUpdated) {\n          this.onCredsUpdated(this._credentials);\n        }\n        return ctrl;\n      });\n\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * @callback contactFilter\n   * @param {Object} contact to check for inclusion.\n   * @returns {boolean} <code>true</code> if contact should be processed, <code>false</code> to exclude it.\n   */\n  /**\n   * Iterate over cached contacts.\n   *\n   * @function\n   * @memberof Tinode.TopicMe#\n   * @param {TopicMe.ContactCallback} callback - Callback to call for each contact.\n   * @param {contactFilter=} filter - Optionally filter contacts; include all if filter is false-ish, otherwise\n   *      include those for which filter returns true-ish.\n   * @param {Object=} context - Context to use for calling the `callback`, i.e. the value of `this` inside the callback.\n   */\n  contacts: {\n    value: function(callback, filter, context) {\n      this._tinode.cacheMap('topic', (c, idx) => {\n        if (c.isCommType() && (!filter || filter(c))) {\n          callback.call(context, c, idx);\n        }\n      });\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Get a contact from cache.\n   * @memberof Tinode.TopicMe#\n   *\n   * @param {string} name - Name of the contact to get, either a UID (for p2p topics) or a topic name.\n   * @returns {Tinode.Contact} - Contact or `undefined`.\n   */\n  getContact: {\n    value: function(name) {\n      return this._tinode.cacheGet('topic', name);\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Get access mode of a given contact from cache.\n   * @memberof Tinode.TopicMe#\n   *\n   * @param {string} name - Name of the contact to get access mode for, either a UID (for p2p topics)\n   *        or a topic name; if missing, access mode for the 'me' topic itself.\n   * @returns {string} - access mode, such as `RWP`.\n   */\n  getAccessMode: {\n    value: function(name) {\n      if (name) {\n        const cont = this._tinode.cacheGet('topic', name);\n        return cont ? cont.acs : null;\n      }\n      return this.acs;\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Check if contact is archived, i.e. contact.private.arch == true.\n   * @memberof Tinode.TopicMe#\n   *\n   * @param {string} name - Name of the contact to check archived status, either a UID (for p2p topics) or a topic name.\n   * @returns {boolean} - true if contact is archived, false otherwise.\n   */\n  isArchived: {\n    value: function(name) {\n      const cont = this._tinode.cacheGet('topic', name);\n      return cont ? ((cont.private && cont.private.arch) ? true : false) : null;\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * @typedef Tinode.Credential\n   * @memberof Tinode\n   * @type Object\n   * @property {string} meth - validation method such as 'email' or 'tel'.\n   * @property {string} val - credential value, i.e. 'jdoe@example.com' or '+17025551234'\n   * @property {boolean} done - true if credential is validated.\n   */\n  /**\n   * Get the user's credentials: email, phone, etc.\n   * @memberof Tinode.TopicMe#\n   *\n   * @returns {Tinode.Credential[]} - array of credentials.\n   */\n  getCredentials: {\n    value: function() {\n      return this._credentials;\n    },\n    enumerable: true,\n    configurable: true\n  }\n});\nTopicMe.prototype.constructor = TopicMe;\n\n/**\n * @class TopicFnd - special case of {@link Tinode.Topic} for searching for\n * contacts and group topics.\n * @extends Tinode.Topic\n * @memberof Tinode\n *\n * @param {TopicFnd.Callbacks} callbacks - Callbacks to receive various events.\n */\nvar TopicFnd = function(callbacks) {\n  Topic.call(this, TOPIC_FND, callbacks);\n  // List of users and topics uid or topic_name -> Contact object)\n  this._contacts = {};\n};\n\n// Inherit everyting from the generic Topic\nTopicFnd.prototype = Object.create(Topic.prototype, {\n  // Override the original Topic._processMetaSub\n  _processMetaSub: {\n    value: function(subs) {\n      let updateCount = Object.getOwnPropertyNames(this._contacts).length;\n      // Reset contact list.\n      this._contacts = {};\n      for (let idx in subs) {\n        let sub = subs[idx];\n        const indexBy = sub.topic ? sub.topic : sub.user;\n\n        sub.updated = new Date(sub.updated);\n        if (sub.seen && sub.seen.when) {\n          sub.seen.when = new Date(sub.seen.when);\n        }\n\n        sub = mergeToCache(this._contacts, indexBy, sub);\n        updateCount++;\n\n        if (this.onMetaSub) {\n          this.onMetaSub(sub);\n        }\n      }\n\n      if (updateCount > 0 && this.onSubsUpdated) {\n        this.onSubsUpdated(Object.keys(this._contacts));\n      }\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Publishing to TopicFnd is not supported. {@link Topic#publish} is overriden and thows an {Error} if called.\n   * @memberof Tinode.TopicFnd#\n   * @throws {Error} Always throws an error.\n   */\n  publish: {\n    value: function() {\n      return Promise.reject(new Error(\"Publishing to 'fnd' is not supported\"));\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * setMeta to TopicFnd resets contact list in addition to sending the message.\n   * @memberof Tinode.TopicFnd#\n   * @param {Tinode.SetParams} params parameters to update.\n   * @returns {Promise} Promise to be resolved/rejected when the server responds to request.\n   */\n  setMeta: {\n    value: function(params) {\n      const instance = this;\n      return Object.getPrototypeOf(TopicFnd.prototype).setMeta.call(this, params).then(function() {\n        if (Object.keys(instance._contacts).length > 0) {\n          instance._contacts = {};\n          if (instance.onSubsUpdated) {\n            instance.onSubsUpdated([]);\n          }\n        }\n      });\n    },\n    enumerable: true,\n    configurable: true\n  },\n\n  /**\n   * Iterate over found contacts. If callback is undefined, use {@link this.onMetaSub}.\n   * @function\n   * @memberof Tinode.TopicFnd#\n   * @param {TopicFnd.ContactCallback} callback - Callback to call for each contact.\n   * @param {Object} context - Context to use for calling the `callback`, i.e. the value of `this` inside the callback.\n   */\n  contacts: {\n    value: function(callback, context) {\n      const cb = (callback || this.onMetaSub);\n      if (cb) {\n        for (let idx in this._contacts) {\n          cb.call(context, this._contacts[idx], idx, this._contacts);\n        }\n      }\n    },\n    enumerable: true,\n    configurable: true\n  }\n});\nTopicFnd.prototype.constructor = TopicFnd;\n\n/**\n * @class LargeFileHelper - collection of utilities for uploading and downloading files\n * out of band. Don't instantiate this class directly. Use {Tinode.getLargeFileHelper} instead.\n * @memberof Tinode\n *\n * @param {Tinode} tinode - the main Tinode object.\n */\nvar LargeFileHelper = function(tinode) {\n  this._tinode = tinode;\n\n  this._apiKey = tinode._apiKey;\n  this._authToken = tinode.getAuthToken();\n  this._msgId = tinode.getNextUniqueId();\n  this.xhr = new XMLHttpRequest();\n\n  // Promise\n  this.toResolve = null;\n  this.toReject = null;\n\n  // Callbacks\n  this.onProgress = null;\n  this.onSuccess = null;\n  this.onFailure = null;\n}\n\nLargeFileHelper.prototype = {\n  /**\n   * Start uploading the file to a non-default endpoint.\n   *\n   * @memberof Tinode.LargeFileHelper#\n   *\n   * @param {string} baseUrl alternative base URL of upload server.\n   * @param {File|Blob} data 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, data, 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 = (e) => {\n      if (e.lengthComputable && instance.onProgress) {\n        instance.onProgress(e.loaded / e.total);\n      }\n    }\n\n    this.xhr.onload = function() {\n      let pkt;\n      try {\n        pkt = JSON.parse(this.response, jsonParseHelper);\n      } catch (err) {\n        instance._tinode.logger(\"ERROR: Invalid server response in LargeFileHelper\", this.response);\n        pkt = {\n          ctrl: {\n            code: this.status,\n            text: this.statusText\n          }\n        };\n      }\n\n      if (this.status >= 200 && this.status < 300) {\n        if (instance.toResolve) {\n          instance.toResolve(pkt.ctrl.params.url);\n        }\n        if (instance.onSuccess) {\n          instance.onSuccess(pkt.ctrl);\n        }\n      } else if (this.status >= 400) {\n        if (instance.toReject) {\n          instance.toReject(new Error(`${pkt.ctrl.text} (${pkt.ctrl.code})`));\n        }\n        if (instance.onFailure) {\n          instance.onFailure(pkt.ctrl)\n        }\n      } else {\n        instance._tinode.logger(\"ERROR: Unexpected server response status\", this.status, this.response);\n      }\n    };\n\n    this.xhr.onerror = function(e) {\n      if (instance.toReject) {\n        instance.toReject(new Error(\"failed\"));\n      }\n      if (instance.onFailure) {\n        instance.onFailure(null);\n      }\n    };\n\n    this.xhr.onabort = function(e) {\n      if (instance.toReject) {\n        instance.toReject(new Error(\"upload cancelled by user\"));\n      }\n      if (instance.onFailure) {\n        instance.onFailure(null);\n      }\n    };\n\n    try {\n      const form = new FormData();\n      form.append('file', data);\n      form.set('id', this._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|Blob} data 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(data, onProgress, onSuccess, onFailure) {\n    return this.uploadWithBaseUrl(undefined, data, onProgress, onSuccess, onFailure);\n  },\n\n  /**\n   * Download the file from a given URL using GET request. This method works with the Tinode server only.\n   *\n   * @memberof Tinode.LargeFileHelper#\n   *\n   * @param {string} relativeUrl - URL to download the file from. Must be relative url, i.e. must not contain the host.\n   * @param {string=} filename - file name to use for the downloaded file.\n   *\n   * @returns {Promise} resolved/rejected when the download is completed/failed.\n   */\n  download: function(relativeUrl, filename, mimetype, onProgress, onError) {\n    if (!Tinode.isRelativeURL(relativeUrl)) {\n      // As a security measure refuse to download from an absolute URL.\n      if (onError) {\n        onError(`The URL '${relativeUrl}' must be relative, not absolute`);\n      }\n      return;\n    }\n    if (!this._authToken) {\n      if (onError) {\n        onError(\"Must authenticate first\");\n      }\n      return;\n    }\n    const instance = this;\n    // Get data as blob (stored by the browser as a temporary file).\n    this.xhr.open('GET', relativeUrl, true);\n    this.xhr.setRequestHeader('X-Tinode-APIKey', this._apiKey);\n    this.xhr.setRequestHeader('X-Tinode-Auth', 'Token ' + this._authToken.token);\n    this.xhr.responseType = 'blob';\n\n    this.onProgress = onProgress;\n    this.xhr.onprogress = function(e) {\n      if (instance.onProgress) {\n        // Passing e.loaded instead of e.loaded/e.total because e.total\n        // is always 0 with gzip compression enabled by the server.\n        instance.onProgress(e.loaded);\n      }\n    };\n\n    const result = new Promise((resolve, reject) => {\n      this.toResolve = resolve;\n      this.toReject = reject;\n    });\n\n    // The blob needs to be saved as file. There is no known way to\n    // save the blob as file other than to fake a click on an <a href... download=...>.\n    this.xhr.onload = function() {\n      if (this.status == 200) {\n        const link = document.createElement('a');\n        // URL.createObjectURL is not available in non-browser environment. This call will fail.\n        link.href = window.URL.createObjectURL(new Blob([this.response], {\n          type: mimetype\n        }));\n        link.style.display = 'none';\n        link.setAttribute('download', filename);\n        document.body.appendChild(link);\n        link.click();\n        document.body.removeChild(link);\n        window.URL.revokeObjectURL(link.href);\n        if (instance.toResolve) {\n          instance.toResolve();\n        }\n      } else if (this.status >= 400 && instance.toReject) {\n        // The this.responseText is undefined, must use this.response which is a blob.\n        // Need to convert this.response to JSON. The blob can only be accessed by the\n        // FileReader.\n        const reader = new FileReader();\n        reader.onload = function() {\n          try {\n            const pkt = JSON.parse(this.result, jsonParseHelper);\n            instance.toReject(new Error(`${pkt.ctrl.text} (${pkt.ctrl.code})`));\n          } catch (err) {\n            instance._tinode.logger(\"ERROR: Invalid server response in LargeFileHelper\", this.result);\n            instance.toReject(err);\n          }\n        };\n        reader.readAsText(this.response);\n      }\n    };\n\n    this.xhr.onerror = function(e) {\n      if (instance.toReject) {\n        instance.toReject(new Error(\"failed\"));\n      }\n    };\n\n    this.xhr.onabort = function() {\n      if (instance.toReject) {\n        instance.toReject(null);\n      }\n    };\n\n    try {\n      this.xhr.send();\n    } catch (err) {\n      if (this.toReject) {\n        this.toReject(err);\n      }\n    }\n\n    return result;\n  },\n\n  /**\n   * Try to cancel an ongoing upload or download.\n   * @memberof Tinode.LargeFileHelper#\n   */\n  cancel: function() {\n    if (this.xhr && this.xhr.readyState < 4) {\n      this.xhr.abort();\n    }\n  },\n\n  /**\n   * Get unique id of this request.\n   * @memberof Tinode.LargeFileHelper#\n   *\n   * @returns {string} unique id\n   */\n  getId: function() {\n    return this._msgId;\n  }\n};\n\n/**\n * @class Message - definition a communication message.\n * Work in progress.\n * @memberof Tinode\n *\n * @param {string} topic_ - name of the topic the message belongs to.\n * @param {string | Drafty} content_ - message contant.\n */\nvar Message = function(topic_, content_) {\n  this.status = Message.STATUS_NONE;\n  this.topic = topic_;\n  this.content = content_;\n}\n\nMessage.STATUS_NONE = MESSAGE_STATUS_NONE;\nMessage.STATUS_QUEUED = MESSAGE_STATUS_QUEUED;\nMessage.STATUS_SENDING = MESSAGE_STATUS_SENDING;\nMessage.STATUS_FAILED = MESSAGE_STATUS_FAILED;\nMessage.STATUS_SENT = MESSAGE_STATUS_SENT;\nMessage.STATUS_RECEIVED = MESSAGE_STATUS_RECEIVED;\nMessage.STATUS_READ = MESSAGE_STATUS_READ;\nMessage.STATUS_TO_ME = MESSAGE_STATUS_TO_ME;\n\nMessage.prototype = {\n  /**\n   * Convert message object to {pub} packet.\n   */\n  toJSON: function() {\n\n  },\n  /**\n   * Parse JSON into message.\n   */\n  fromJSON: function(json) {\n\n  }\n}\nMessage.prototype.constructor = Message;\n\nif (typeof module != 'undefined') {\n  module.exports = Tinode;\n  module.exports.Drafty = Drafty;\n  module.exports.AccessMode = AccessMode;\n}\n","module.exports={\"version\": \"0.17.0\"}\n"]}
|