tweet_live: comparison web/res/js/mustache.js

Mercurial Mercurial > tweet_live / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

web/res/js/mustache.js

changeset 940	843f96e4eebd
parent 598	d366aa22bd79
child 1304	10974bff4dae

equal deleted inserted replaced

-:1648489454d7
+:843f96e4eebd
-/*
+/*!
-mustache.js — Logic-less templates in JavaScript
+* mustache.js - Logic-less {{mustache}} templates with JavaScript
+* http://github.com/janl/mustache.js
-See http://mustache.github.com/ for more info.
+*/
-*/
+/*global define: false*/
-var Mustache = function () {
-var _toString = Object.prototype.toString;
+(function (root, factory) {
+if (typeof exports === "object" && exports) {
-Array.isArray = Array.isArray || function (obj) {
+factory(exports); // CommonJS
-return _toString.call(obj) == "[object Array]";
-}
-var _trim = String.prototype.trim, trim;
-if (_trim) {
-trim = function (text) {
-return text == null ? "" : _trim.call(text);
-}
 } else {
-var trimLeft, trimRight;
+var mustache = {};
+factory(mustache);
-// IE doesn't match non-breaking spaces with \s.
+if (typeof define === "function" && define.amd) {
-if ((/\S/).test("\xA0")) {
+define(mustache); // AMD
-trimLeft = /^[\s\xA0]+/;
-trimRight = /[\s\xA0]+$/;
 } else {
-trimLeft = /^\s+/;
+root.Mustache = mustache; // <script>
-trimRight = /\s+$/;
+}
 }
+}(this, function (mustache) {
-trim = function (text) {
-return text == null ? "" :
+var whiteRe = /\s*/;
-text.toString().replace(trimLeft, "").replace(trimRight, "");
+var spaceRe = /\s+/;
-}
+var nonSpaceRe = /\S/;
-}
+var eqRe = /\s*=/;
+var curlyRe = /\s*\}/;
-var escapeMap = {
+var tagRe = /#|\^|\/|>|\{|&|=|!/;
+// Workaround for https://issues.apache.org/jira/browse/COUCHDB-577
+// See https://github.com/janl/mustache.js/issues/189
+var RegExp_test = RegExp.prototype.test;
+function testRegExp(re, string) {
+return RegExp_test.call(re, string);
+}
+function isWhitespace(string) {
+return !testRegExp(nonSpaceRe, string);
+}
+var Object_toString = Object.prototype.toString;
+var isArray = Array.isArray || function (obj) {
+return Object_toString.call(obj) === '[object Array]';
+};
+function escapeRegExp(string) {
+return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+}
+var entityMap = {
 "&": "&amp;",
 "<": "&lt;",
 ">": "&gt;",
 '"': '&quot;',
-"'": '&#39;'
+"'": '&#39;',
-};
+"/": '&#x2F;'
+};
-function escapeHTML(string) {
-return String(string).replace(/&(?!\w+;)|[<>"']/g, function (s) {
+function escapeHtml(string) {
-return escapeMap[s] || s;
+return String(string).replace(/[&<>"'\/]/g, function (s) {
+return entityMap[s];
 });
 }
-var regexCache = {};
+function Scanner(string) {
-var Renderer = function () {};
+this.string = string;
+this.tail = string;
-Renderer.prototype = {
+this.pos = 0;
-otag: "{{",
+}
-ctag: "}}",
-pragmas: {},
+/**
-buffer: [],
+* Returns `true` if the tail is empty (end of string).
-pragmas_implemented: {
+*/
-"IMPLICIT-ITERATOR": true
+Scanner.prototype.eos = function () {
-},
+return this.tail === "";
-context: {},
+};
-render: function (template, context, partials, in_recursion) {
+/**
-// reset buffer & set context
+* Tries to match the given regular expression at the current position.
-if (!in_recursion) {
+* Returns the matched text if it can match, the empty string otherwise.
-this.context = context;
+*/
-this.buffer = []; // TODO: make this non-lazy
+Scanner.prototype.scan = function (re) {
-}
+var match = this.tail.match(re);
-// fail fast
+if (match && match.index === 0) {
-if (!this.includes("", template)) {
+this.tail = this.tail.substring(match[0].length);
-if (in_recursion) {
+this.pos += match[0].length;
-return template;
+return match[0];
+}
+return "";
+};
+/**
+* Skips all text until the given regular expression can be matched. Returns
+* the skipped string, which is the entire tail if no match can be made.
+*/
+Scanner.prototype.scanUntil = function (re) {
+var match, pos = this.tail.search(re);
+switch (pos) {
+case -1:
+match = this.tail;
+this.pos += this.tail.length;
+this.tail = "";
+break;
+case 0:
+match = "";
+break;
+default:
+match = this.tail.substring(0, pos);
+this.tail = this.tail.substring(pos);
+this.pos += pos;
+}
+return match;
+};
+function Context(view, parent) {
+this.view = view || {};
+this.parent = parent;
+this._cache = {};
+}
+Context.make = function (view) {
+return (view instanceof Context) ? view : new Context(view);
+};
+Context.prototype.push = function (view) {
+return new Context(view, this);
+};
+Context.prototype.lookup = function (name) {
+var value = this._cache[name];
+if (!value) {
+if (name == '.') {
+value = this.view;
+} else {
+var context = this;
+while (context) {
+if (name.indexOf('.') > 0) {
+value = context.view;
+var names = name.split('.'), i = 0;
+while (value && i < names.length) {
+value = value[names[i++]];
+}
+} else {
+value = context.view[name];
+}
+if (value != null) break;
+context = context.parent;
+}
+}
+this._cache[name] = value;
+}
+if (typeof value === 'function') value = value.call(this.view);
+return value;
+};
+function Writer() {
+this.clearCache();
+}
+Writer.prototype.clearCache = function () {
+this._cache = {};
+this._partialCache = {};
+};
+Writer.prototype.compile = function (template, tags) {
+var fn = this._cache[template];
+if (!fn) {
+var tokens = mustache.parse(template, tags);
+fn = this._cache[template] = this.compileTokens(tokens, template);
+}
+return fn;
+};
+Writer.prototype.compilePartial = function (name, template, tags) {
+var fn = this.compile(template, tags);
+this._partialCache[name] = fn;
+return fn;
+};
+Writer.prototype.getPartial = function (name) {
+if (!(name in this._partialCache) && this._loadPartial) {
+this.compilePartial(name, this._loadPartial(name));
+}
+return this._partialCache[name];
+};
+Writer.prototype.compileTokens = function (tokens, template) {
+var self = this;
+return function (view, partials) {
+if (partials) {
+if (typeof partials === 'function') {
+self._loadPartial = partials;
 } else {
-this.send(template);
+for (var name in partials) {
-return;
+self.compilePartial(name, partials[name]);
 }
 }
+}
-// get the pragmas together
-template = this.render_pragmas(template);
+return renderTokens(tokens, self, Context.make(view), template);
+};
-// render the template
+};
-var html = this.render_section(template, context, partials);
+Writer.prototype.render = function (template, view, partials) {
-// render_section did not find any sections, we still need to render the tags
+return this.compile(template)(view, partials);
-if (html === false) {
+};
-html = this.render_tags(template, context, partials, in_recursion);
-}
+/**
+* Low-level function that renders the given `tokens` using the given `writer`
-if (in_recursion) {
+* and `context`. The `template` string is only needed for templates that use
-return html;
+* higher-order sections to extract the portion of the original template that
+* was contained in that section.
+*/
+function renderTokens(tokens, writer, context, template) {
+var buffer = '';
+var token, tokenValue, value;
+for (var i = 0, len = tokens.length; i < len; ++i) {
+token = tokens[i];
+tokenValue = token[1];
+switch (token[0]) {
+case '#':
+value = context.lookup(tokenValue);
+if (typeof value === 'object') {
+if (isArray(value)) {
+for (var j = 0, jlen = value.length; j < jlen; ++j) {
+buffer += renderTokens(token[4], writer, context.push(value[j]), template);
+}
+} else if (value) {
+buffer += renderTokens(token[4], writer, context.push(value), template);
+}
+} else if (typeof value === 'function') {
+var text = template == null ? null : template.slice(token[3], token[5]);
+value = value.call(context.view, text, function (template) {
+return writer.render(template, context);
+});
+if (value != null) buffer += value;
+} else if (value) {
+buffer += renderTokens(token[4], writer, context, template);
+}
+break;
+case '^':
+value = context.lookup(tokenValue);
+// Use JavaScript's definition of falsy. Include empty arrays.
+// See https://github.com/janl/mustache.js/issues/186
+if (!value || (isArray(value) && value.length === 0)) {
+buffer += renderTokens(token[4], writer, context, template);
+}
+break;
+case '>':
+value = writer.getPartial(tokenValue);
+if (typeof value === 'function') buffer += value(context);
+break;
+case '&':
+value = context.lookup(tokenValue);
+if (value != null) buffer += value;
+break;
+case 'name':
+value = context.lookup(tokenValue);
+if (value != null) buffer += mustache.escape(value);
+break;
+case 'text':
+buffer += tokenValue;
+break;
+}
+}
+return buffer;
+}
+/**
+* Forms the given array of `tokens` into a nested tree structure where
+* tokens that represent a section have two additional items: 1) an array of
+* all tokens that appear in that section and 2) the index in the original
+* template that represents the end of that section.
+*/
+function nestTokens(tokens) {
+var tree = [];
+var collector = tree;
+var sections = [];
+var token;
+for (var i = 0, len = tokens.length; i < len; ++i) {
+token = tokens[i];
+switch (token[0]) {
+case '#':
+case '^':
+sections.push(token);
+collector.push(token);
+collector = token[4] = [];
+break;
+case '/':
+var section = sections.pop();
+section[5] = token[2];
+collector = sections.length > 0 ? sections[sections.length - 1][4] : tree;
+break;
+default:
+collector.push(token);
+}
+}
+return tree;
+}
+/**
+* Combines the values of consecutive text tokens in the given `tokens` array
+* to a single token.
+*/
+function squashTokens(tokens) {
+var squashedTokens = [];
+var token, lastToken;
+for (var i = 0, len = tokens.length; i < len; ++i) {
+token = tokens[i];
+if (token) {
+if (token[0] === 'text' && lastToken && lastToken[0] === 'text') {
+lastToken[1] += token[1];
+lastToken[3] = token[3];
+} else {
+lastToken = token;
+squashedTokens.push(token);
+}
+}
+}
+return squashedTokens;
+}
+function escapeTags(tags) {
+return [
+new RegExp(escapeRegExp(tags[0]) + "\\s*"),
+new RegExp("\\s*" + escapeRegExp(tags[1]))
+];
+}
+/**
+* Breaks up the given `template` string into a tree of token objects. If
+* `tags` is given here it must be an array with two string values: the
+* opening and closing tags used in the template (e.g. ["<%", "%>"]). Of
+* course, the default is to use mustaches (i.e. Mustache.tags).
+*/
+function parseTemplate(template, tags) {
+template = template || '';
+tags = tags || mustache.tags;
+if (typeof tags === 'string') tags = tags.split(spaceRe);
+if (tags.length !== 2) throw new Error('Invalid tags: ' + tags.join(', '));
+var tagRes = escapeTags(tags);
+var scanner = new Scanner(template);
+var sections = [];     // Stack to hold section tokens
+var tokens = [];       // Buffer to hold the tokens
+var spaces = [];       // Indices of whitespace tokens on the current line
+var hasTag = false;    // Is there a {{tag}} on the current line?
+var nonSpace = false;  // Is there a non-space char on the current line?
+// Strips all whitespace tokens array for the current line
+// if there was a {{#tag}} on it and otherwise only space.
+function stripSpace() {
+if (hasTag && !nonSpace) {
+while (spaces.length) {
+delete tokens[spaces.pop()];
+}
 } else {
-this.sendLines(html);
+spaces = [];
 }
-},
+hasTag = false;
-/*
+nonSpace = false;
-Sends parsed lines
+}
-*/
-send: function (line) {
+var start, type, value, chr, token;
-if (line !== "") {
+while (!scanner.eos()) {
-this.buffer.push(line);
+start = scanner.pos;
-}
-},
+// Match any text between tags.
+value = scanner.scanUntil(tagRes[0]);
-sendLines: function (text) {
+if (value) {
-if (text) {
+for (var i = 0, len = value.length; i < len; ++i) {
-var lines = text.split("\n");
+chr = value.charAt(i);
-for (var i = 0; i < lines.length; i++) {
-this.send(lines[i]);
+if (isWhitespace(chr)) {
-}
+spaces.push(tokens.length);
-}
-},
-/*
-Looks for %PRAGMAS
-*/
-render_pragmas: function (template) {
-// no pragmas
-if (!this.includes("%", template)) {
-return template;
-}
-var that = this;
-var regex = this.getCachedRegex("render_pragmas", function (otag, ctag) {
-return new RegExp(otag + "%([\\w-]+) ?([\\w]+=[\\w]+)?" + ctag, "g");
-});
-return template.replace(regex, function (match, pragma, options) {
-if (!that.pragmas_implemented[pragma]) {
-throw({message:
-"This implementation of mustache doesn't understand the '" +
-pragma + "' pragma"});
-}
-that.pragmas[pragma] = {};
-if (options) {
-var opts = options.split("=");
-that.pragmas[pragma][opts[0]] = opts[1];
-}
-return "";
-// ignore unknown pragmas silently
-});
-},
-/*
-Tries to find a partial in the curent scope and render it
-*/
-render_partial: function (name, context, partials) {
-name = trim(name);
-if (!partials || partials[name] === undefined) {
-throw({message: "unknown_partial '" + name + "'"});
-}
-if (!context || typeof context[name] != "object") {
-return this.render(partials[name], context, partials, true);
-}
-return this.render(partials[name], context[name], partials, true);
-},
-/*
-Renders inverted (^) and normal (#) sections
-*/
-render_section: function (template, context, partials) {
-if (!this.includes("#", template) && !this.includes("^", template)) {
-// did not render anything, there were no sections
-return false;
-}
-var that = this;
-var regex = this.getCachedRegex("render_section", function (otag, ctag) {
-// This regex matches _the first_ section ({{#foo}}{{/foo}}), and captures the remainder
-return new RegExp(
-"^([\\s\\S]*?)" +         // all the crap at the beginning that is not {{*}} ($1)
-otag +                    // {{
-"(\\^|\\#)\\s*(.+)\\s*" + //  #foo (# == $2, foo == $3)
-ctag +                    // }}
-"\n*([\\s\\S]*?)" +       // between the tag ($2). leading newlines are dropped
-otag +                    // {{
-"\\/\\s*\\3\\s*" +        //  /foo (backreference to the opening tag).
-ctag +                    // }}
-"\\s*([\\s\\S]*)$",       // everything else in the string ($4). leading whitespace is dropped.
-"g");
-});
-// for each {{#foo}}{{/foo}} section do...
-return template.replace(regex, function (match, before, type, name, content, after) {
-// before contains only tags, no sections
-var renderedBefore = before ? that.render_tags(before, context, partials, true) : "",
-// after may contain both sections and tags, so use full rendering function
-renderedAfter = after ? that.render(after, context, partials, true) : "",
-// will be computed below
-renderedContent,
-value = that.find(name, context);
-if (type === "^") { // inverted section
-if (!value || Array.isArray(value) && value.length === 0) {
-// false or empty list, render it
-renderedContent = that.render(content, context, partials, true);
 } else {
-renderedContent = "";
+nonSpace = true;
 }
-} else if (type === "#") { // normal section
-if (Array.isArray(value)) { // Enumerable, Let's loop!
+tokens.push(['text', chr, start, start + 1]);
-renderedContent = that.map(value, function (row) {
+start += 1;
-return that.render(content, that.create_context(row), partials, true);
-}).join("");
+// Check for whitespace on the current line.
-} else if (that.is_object(value)) { // Object, Use it as subcontext!
+if (chr == '\n') stripSpace();
-renderedContent = that.render(content, that.create_context(value),
+}
-partials, true);
+}
-} else if (typeof value == "function") {
-// higher order section
+// Match the opening tag.
-renderedContent = value.call(context, content, function (text) {
+if (!scanner.scan(tagRes[0])) break;
-return that.render(text, context, partials, true);
+hasTag = true;
-});
-} else if (value) { // boolean section
+// Get the tag type.
-renderedContent = that.render(content, context, partials, true);
+type = scanner.scan(tagRe) || 'name';
-} else {
+scanner.scan(whiteRe);
-renderedContent = "";
-}
+// Get the tag value.
-}
+if (type === '=') {
+value = scanner.scanUntil(eqRe);
-return renderedBefore + renderedContent + renderedAfter;
+scanner.scan(eqRe);
-});
+scanner.scanUntil(tagRes[1]);
-},
+} else if (type === '{') {
+value = scanner.scanUntil(new RegExp('\\s*' + escapeRegExp('}' + tags[1])));
-/*
+scanner.scan(curlyRe);
-Replace {{foo}} and friends with values from our view
+scanner.scanUntil(tagRes[1]);
-*/
+type = '&';
-render_tags: function (template, context, partials, in_recursion) {
-// tit for tat
-var that = this;
-var new_regex = function () {
-return that.getCachedRegex("render_tags", function (otag, ctag) {
-return new RegExp(otag + "(=|!|>|&|\\{|%)?([^#\\^]+?)\\1?" + ctag + "+", "g");
-});
-};
-var regex = new_regex();
-var tag_replace_callback = function (match, operator, name) {
-switch(operator) {
-case "!": // ignore comments
-return "";
-case "=": // set new delimiters, rebuild the replace regexp
-that.set_delimiters(name);
-regex = new_regex();
-return "";
-case ">": // render partial
-return that.render_partial(name, context, partials);
-case "{": // the triple mustache is unescaped
-case "&": // & operator is an alternative unescape method
-return that.find(name, context);
-default: // escape the value
-return escapeHTML(that.find(name, context));
-}
-};
-var lines = template.split("\n");
-for(var i = 0; i < lines.length; i++) {
-lines[i] = lines[i].replace(regex, tag_replace_callback, this);
-if (!in_recursion) {
-this.send(lines[i]);
-}
-}
-if (in_recursion) {
-return lines.join("\n");
-}
-},
-set_delimiters: function (delimiters) {
-var dels = delimiters.split(" ");
-this.otag = this.escape_regex(dels[0]);
-this.ctag = this.escape_regex(dels[1]);
-},
-escape_regex: function (text) {
-// thank you Simon Willison
-if (!arguments.callee.sRE) {
-var specials = [
-'/', '.', '*', '+', '?', '|',
-'(', ')', '[', ']', '{', '}', '\\'
-];
-arguments.callee.sRE = new RegExp(
-'(\\' + specials.join('|\\') + ')', 'g'
-);
-}
-return text.replace(arguments.callee.sRE, '\\$1');
-},
-/*
-find `name` in current `context`. That is find me a value
-from the view object
-*/
-find: function (name, context) {
-name = trim(name);
-// Checks whether a value is thruthy or false or 0
-function is_kinda_truthy(bool) {
-return bool === false || bool === 0 || bool;
-}
-var value;
-// check for dot notation eg. foo.bar
-if (name.match(/([a-z_]+)\./ig)) {
-var childValue = this.walk_context(name, context);
-if (is_kinda_truthy(childValue)) {
-value = childValue;
-}
 } else {
-if (is_kinda_truthy(context[name])) {
+value = scanner.scanUntil(tagRes[1]);
-value = context[name];
+}
-} else if (is_kinda_truthy(this.context[name])) {
-value = this.context[name];
+// Match the closing tag.
-}
+if (!scanner.scan(tagRes[1])) throw new Error('Unclosed tag at ' + scanner.pos);
-}
+token = [type, value, start, scanner.pos];
-if (typeof value == "function") {
+tokens.push(token);
-return value.apply(context);
-}
+if (type === '#' || type === '^') {
-if (value !== undefined) {
+sections.push(token);
-return value;
+} else if (type === '/') {
-}
+// Check section nesting.
-// silently ignore unkown variables
+if (sections.length === 0) throw new Error('Unopened section "' + value + '" at ' + start);
-return "";
+var openSection = sections.pop();
-},
+if (openSection[1] !== value) throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
+} else if (type === 'name' || type === '{' || type === '&') {
-walk_context: function (name, context) {
+nonSpace = true;
-var path = name.split('.');
+} else if (type === '=') {
-// if the var doesn't exist in current context, check the top level context
+// Set the tags for the next time around.
-var value_context = (context[path[0]] != undefined) ? context : this.context;
+tags = value.split(spaceRe);
-var value = value_context[path.shift()];
+if (tags.length !== 2) throw new Error('Invalid tags at ' + start + ': ' + tags.join(', '));
-while (value != undefined && path.length > 0) {
+tagRes = escapeTags(tags);
-value_context = value;
+}
-value = value[path.shift()];
+}
-}
-// if the value is a function, call it, binding the correct context
+// Make sure there are no open sections when we're done.
-if (typeof value == "function") {
+var openSection = sections.pop();
-return value.apply(value_context);
+if (openSection) throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
-}
-return value;
+tokens = squashTokens(tokens);
-},
+return nestTokens(tokens);
-// Utility methods
+}
-/* includes tag */
+mustache.name = "mustache.js";
-includes: function (needle, haystack) {
+mustache.version = "0.7.2";
-return haystack.indexOf(this.otag + needle) != -1;
+mustache.tags = ["{{", "}}"];
-},
+mustache.Scanner = Scanner;
-// by @langalex, support for arrays of strings
+mustache.Context = Context;
-create_context: function (_context) {
+mustache.Writer = Writer;
-if (this.is_object(_context)) {
-return _context;
+mustache.parse = parseTemplate;
-} else {
-var iterator = ".";
+// Export the escaping function so that the user may override it.
-if (this.pragmas["IMPLICIT-ITERATOR"]) {
+// See https://github.com/janl/mustache.js/issues/244
-iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator;
+mustache.escape = escapeHtml;
-}
-var ctx = {};
+// All Mustache.* functions use this writer.
-ctx[iterator] = _context;
+var defaultWriter = new Writer();
-return ctx;
-}
+/**
-},
+* Clears all cached templates and partials in the default writer.
+*/
-is_object: function (a) {
+mustache.clearCache = function () {
-return a && typeof a == "object";
+return defaultWriter.clearCache();
-},
+};
-/*
+/**
-Why, why, why? Because IE. Cry, cry cry.
+* Compiles the given `template` to a reusable function using the default
-*/
+* writer.
-map: function (array, fn) {
+*/
-if (typeof array.map == "function") {
+mustache.compile = function (template, tags) {
-return array.map(fn);
+return defaultWriter.compile(template, tags);
-} else {
+};
-var r = [];
-var l = array.length;
+/**
-for(var i = 0; i < l; i++) {
+* Compiles the partial with the given `name` and `template` to a reusable
-r.push(fn(array[i]));
+* function using the default writer.
-}
+*/
-return r;
+mustache.compilePartial = function (name, template, tags) {
-}
+return defaultWriter.compilePartial(name, template, tags);
-},
+};
-getCachedRegex: function (name, generator) {
+/**
-var byOtag = regexCache[this.otag];
+* Compiles the given array of tokens (the output of a parse) to a reusable
-if (!byOtag) {
+* function using the default writer.
-byOtag = regexCache[this.otag] = {};
+*/
-}
+mustache.compileTokens = function (tokens, template) {
+return defaultWriter.compileTokens(tokens, template);
-var byCtag = byOtag[this.ctag];
+};
-if (!byCtag) {
-byCtag = byOtag[this.ctag] = {};
+/**
-}
+* Renders the `template` with the given `view` and `partials` using the
+* default writer.
-var regex = byCtag[name];
+*/
-if (!regex) {
+mustache.render = function (template, view, partials) {
-regex = byCtag[name] = generator(this.otag, this.ctag);
+return defaultWriter.render(template, view, partials);
-}
+};
-return regex;
+// This is here for backwards compatibility with 0.4.x.
-}
+mustache.to_html = function (template, view, partials, send) {
-};
+var result = mustache.render(template, view, partials);
-return({
+if (typeof send === "function") {
-name: "mustache.js",
+send(result);
-version: "0.5.0-dev",
+} else {
+return result;
-/*
+}
-Turns a template and view into HTML
+};
-*/
-to_html: function (template, view, partials, send_fun) {
+}));
-var renderer = new Renderer();
-if (send_fun) {
-renderer.send = send_fun;
-}
-renderer.render(template, view || {}, partials);
-if (!send_fun) {
-return renderer.buffer.join("\n");
-}
-}
-});
-}();

tweet_live