webapp.vendor.js.riot+compiler.js Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of leshan-bsserver-demo Show documentation
Show all versions of leshan-bsserver-demo Show documentation
A LWM2M bootstrap demonstration server running an embedded Jetty server
/* Riot v3.13.2, @license MIT */
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global.riot = factory());
}(this, (function () { 'use strict';
/**
* Shorter and fast way to select a single node in the DOM
* @param { String } selector - unique dom selector
* @param { Object } ctx - DOM node where the target of our search will is located
* @returns { Object } dom node found
*/
function $(selector, ctx) {
return (ctx || document).querySelector(selector)
}
var
// be aware, internal usage
// ATTENTION: prefix the global dynamic variables with `__`
// tags instances cache
__TAGS_CACHE = [],
// tags implementation cache
__TAG_IMPL = {},
YIELD_TAG = 'yield',
/**
* Const
*/
GLOBAL_MIXIN = '__global_mixin',
// riot specific prefixes or attributes
ATTRS_PREFIX = 'riot-',
// Riot Directives
REF_DIRECTIVES = ['ref', 'data-ref'],
IS_DIRECTIVE = 'data-is',
CONDITIONAL_DIRECTIVE = 'if',
LOOP_DIRECTIVE = 'each',
LOOP_NO_REORDER_DIRECTIVE = 'no-reorder',
SHOW_DIRECTIVE = 'show',
HIDE_DIRECTIVE = 'hide',
KEY_DIRECTIVE = 'key',
RIOT_EVENTS_KEY = '__riot-events__',
// for typeof == '' comparisons
T_STRING = 'string',
T_OBJECT = 'object',
T_UNDEF = 'undefined',
T_FUNCTION = 'function',
XLINK_NS = 'http://www.w3.org/1999/xlink',
SVG_NS = 'http://www.w3.org/2000/svg',
XLINK_REGEX = /^xlink:(\w+)/,
WIN = typeof window === T_UNDEF ? /* istanbul ignore next */ undefined : window,
// special native tags that cannot be treated like the others
RE_SPECIAL_TAGS = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?|opt(?:ion|group))$/,
RE_SPECIAL_TAGS_NO_OPTION = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?)$/,
RE_EVENTS_PREFIX = /^on/,
RE_HTML_ATTRS = /([-\w]+) ?= ?(?:"([^"]*)|'([^']*)|({[^}]*}))/g,
// some DOM attributes must be normalized
CASE_SENSITIVE_ATTRIBUTES = {
'viewbox': 'viewBox',
'preserveaspectratio': 'preserveAspectRatio'
},
/**
* Matches boolean HTML attributes in the riot tag definition.
* With a long list like this, a regex is faster than `[].indexOf` in most browsers.
* @const {RegExp}
* @see [attributes.md](https://github.com/riot/compiler/blob/dev/doc/attributes.md)
*/
RE_BOOL_ATTRS = /^(?:disabled|checked|readonly|required|allowfullscreen|auto(?:focus|play)|compact|controls|default|formnovalidate|hidden|ismap|itemscope|loop|multiple|muted|no(?:resize|shade|validate|wrap)?|open|reversed|seamless|selected|sortable|truespeed|typemustmatch)$/,
// version# for IE 8-11, 0 for others
IE_VERSION = (WIN && WIN.document || /* istanbul ignore next */ {}).documentMode | 0;
/**
* Create a generic DOM node
* @param { String } name - name of the DOM node we want to create
* @returns { Object } DOM node just created
*/
function makeElement(name) {
return name === 'svg' ? document.createElementNS(SVG_NS, name) : document.createElement(name)
}
/**
* Set any DOM attribute
* @param { Object } dom - DOM node we want to update
* @param { String } name - name of the property we want to set
* @param { String } val - value of the property we want to set
*/
function setAttribute(dom, name, val) {
var xlink = XLINK_REGEX.exec(name);
if (xlink && xlink[1])
{ dom.setAttributeNS(XLINK_NS, xlink[1], val); }
else
{ dom.setAttribute(name, val); }
}
var styleNode;
// Create cache and shortcut to the correct property
var cssTextProp;
var byName = {};
var needsInject = false;
// skip the following code on the server
if (WIN) {
styleNode = ((function () {
// create a new style element with the correct type
var newNode = makeElement('style');
// replace any user node or insert the new one into the head
var userNode = $('style[type=riot]');
setAttribute(newNode, 'type', 'text/css');
/* istanbul ignore next */
if (userNode) {
if (userNode.id) { newNode.id = userNode.id; }
userNode.parentNode.replaceChild(newNode, userNode);
} else { document.head.appendChild(newNode); }
return newNode
}))();
cssTextProp = styleNode.styleSheet;
}
/**
* Object that will be used to inject and manage the css of every tag instance
*/
var styleManager = {
styleNode: styleNode,
/**
* Save a tag style to be later injected into DOM
* @param { String } css - css string
* @param { String } name - if it's passed we will map the css to a tagname
*/
add: function add(css, name) {
byName[name] = css;
needsInject = true;
},
/**
* Inject all previously saved tag styles into DOM
* innerHTML seems slow: http://jsperf.com/riot-insert-style
*/
inject: function inject() {
if (!WIN || !needsInject) { return }
needsInject = false;
var style = Object.keys(byName)
.map(function (k) { return byName[k]; })
.join('\n');
/* istanbul ignore next */
if (cssTextProp) { cssTextProp.cssText = style; }
else { styleNode.innerHTML = style; }
},
/**
* Remove a tag style of injected DOM later.
* @param {String} name a registered tagname
*/
remove: function remove(name) {
delete byName[name];
needsInject = true;
}
};
/**
* The riot template engine
* @version v3.0.8
*/
/* istanbul ignore next */
var skipRegex = (function () { //eslint-disable-line no-unused-vars
var beforeReChars = '[{(,;:?=|&!^~>%*/';
var beforeReWords = [
'case',
'default',
'do',
'else',
'in',
'instanceof',
'prefix',
'return',
'typeof',
'void',
'yield'
];
var wordsLastChar = beforeReWords.reduce(function (s, w) {
return s + w.slice(-1)
}, '');
var RE_REGEX = /^\/(?=[^*>/])[^[/\\]*(?:(?:\\.|\[(?:\\.|[^\]\\]*)*\])[^[\\/]*)*?\/[gimuy]*/;
var RE_VN_CHAR = /[$\w]/;
function prev (code, pos) {
while (--pos >= 0 && /\s/.test(code[pos])){ }
return pos
}
function _skipRegex (code, start) {
var re = /.*/g;
var pos = re.lastIndex = start++;
var match = re.exec(code)[0].match(RE_REGEX);
if (match) {
var next = pos + match[0].length;
pos = prev(code, pos);
var c = code[pos];
if (pos < 0 || ~beforeReChars.indexOf(c)) {
return next
}
if (c === '.') {
if (code[pos - 1] === '.') {
start = next;
}
} else if (c === '+' || c === '-') {
if (code[--pos] !== c ||
(pos = prev(code, pos)) < 0 ||
!RE_VN_CHAR.test(code[pos])) {
start = next;
}
} else if (~wordsLastChar.indexOf(c)) {
var end = pos + 1;
while (--pos >= 0 && RE_VN_CHAR.test(code[pos])){ }
if (~beforeReWords.indexOf(code.slice(pos + 1, end))) {
start = next;
}
}
}
return start
}
return _skipRegex
})();
/**
* riot.util.brackets
*
* - `brackets ` - Returns a string or regex based on its parameter
* - `brackets.set` - Change the current riot brackets
*
* @module
*/
/* global riot */
/* istanbul ignore next */
var brackets = (function (UNDEF) {
var
REGLOB = 'g',
R_MLCOMMS = /\/\*[^*]*\*+(?:[^*\/][^*]*\*+)*\//g,
R_STRINGS = /"[^"\\]*(?:\\[\S\s][^"\\]*)*"|'[^'\\]*(?:\\[\S\s][^'\\]*)*'|`[^`\\]*(?:\\[\S\s][^`\\]*)*`/g,
S_QBLOCKS = R_STRINGS.source + '|' +
/(?:\breturn\s+|(?:[$\w\)\]]|\+\+|--)\s*(\/)(?![*\/]))/.source + '|' +
/\/(?=[^*\/])[^[\/\\]*(?:(?:\[(?:\\.|[^\]\\]*)*\]|\\.)[^[\/\\]*)*?([^<]\/)[gim]*/.source,
UNSUPPORTED = RegExp('[\\' + 'x00-\\x1F<>a-zA-Z0-9\'",;\\\\]'),
NEED_ESCAPE = /(?=[[\]()*+?.^$|])/g,
S_QBLOCK2 = R_STRINGS.source + '|' + /(\/)(?![*\/])/.source,
FINDBRACES = {
'(': RegExp('([()])|' + S_QBLOCK2, REGLOB),
'[': RegExp('([[\\]])|' + S_QBLOCK2, REGLOB),
'{': RegExp('([{}])|' + S_QBLOCK2, REGLOB)
},
DEFAULT = '{ }';
var _pairs = [
'{', '}',
'{', '}',
/{[^}]*}/,
/\\([{}])/g,
/\\({)|{/g,
RegExp('\\\\(})|([[({])|(})|' + S_QBLOCK2, REGLOB),
DEFAULT,
/^\s*{\^?\s*([$\w]+)(?:\s*,\s*(\S+))?\s+in\s+(\S.*)\s*}/,
/(^|[^\\]){=[\S\s]*?}/
];
var
cachedBrackets = UNDEF,
_regex,
_cache = [],
_settings;
function _loopback (re) { return re }
function _rewrite (re, bp) {
if (!bp) { bp = _cache; }
return new RegExp(
re.source.replace(/{/g, bp[2]).replace(/}/g, bp[3]), re.global ? REGLOB : ''
)
}
function _create (pair) {
if (pair === DEFAULT) { return _pairs }
var arr = pair.split(' ');
if (arr.length !== 2 || UNSUPPORTED.test(pair)) {
throw new Error('Unsupported brackets "' + pair + '"')
}
arr = arr.concat(pair.replace(NEED_ESCAPE, '\\').split(' '));
arr[4] = _rewrite(arr[1].length > 1 ? /{[\S\s]*?}/ : _pairs[4], arr);
arr[5] = _rewrite(pair.length > 3 ? /\\({|})/g : _pairs[5], arr);
arr[6] = _rewrite(_pairs[6], arr);
arr[7] = RegExp('\\\\(' + arr[3] + ')|([[({])|(' + arr[3] + ')|' + S_QBLOCK2, REGLOB);
arr[8] = pair;
return arr
}
function _brackets (reOrIdx) {
return reOrIdx instanceof RegExp ? _regex(reOrIdx) : _cache[reOrIdx]
}
_brackets.split = function split (str, tmpl, _bp) {
// istanbul ignore next: _bp is for the compiler
if (!_bp) { _bp = _cache; }
var
parts = [],
match,
isexpr,
start,
pos,
re = _bp[6];
var qblocks = [];
var prevStr = '';
var mark, lastIndex;
isexpr = start = re.lastIndex = 0;
while ((match = re.exec(str))) {
lastIndex = re.lastIndex;
pos = match.index;
if (isexpr) {
if (match[2]) {
var ch = match[2];
var rech = FINDBRACES[ch];
var ix = 1;
rech.lastIndex = lastIndex;
while ((match = rech.exec(str))) {
if (match[1]) {
if (match[1] === ch) { ++ix; }
else if (!--ix) { break }
} else {
rech.lastIndex = pushQBlock(match.index, rech.lastIndex, match[2]);
}
}
re.lastIndex = ix ? str.length : rech.lastIndex;
continue
}
if (!match[3]) {
re.lastIndex = pushQBlock(pos, lastIndex, match[4]);
continue
}
}
if (!match[1]) {
unescapeStr(str.slice(start, pos));
start = re.lastIndex;
re = _bp[6 + (isexpr ^= 1)];
re.lastIndex = start;
}
}
if (str && start < str.length) {
unescapeStr(str.slice(start));
}
parts.qblocks = qblocks;
return parts
function unescapeStr (s) {
if (prevStr) {
s = prevStr + s;
prevStr = '';
}
if (tmpl || isexpr) {
parts.push(s && s.replace(_bp[5], '$1'));
} else {
parts.push(s);
}
}
function pushQBlock(_pos, _lastIndex, slash) { //eslint-disable-line
if (slash) {
_lastIndex = skipRegex(str, _pos);
}
if (tmpl && _lastIndex > _pos + 2) {
mark = '\u2057' + qblocks.length + '~';
qblocks.push(str.slice(_pos, _lastIndex));
prevStr += str.slice(start, _pos) + mark;
start = _lastIndex;
}
return _lastIndex
}
};
_brackets.hasExpr = function hasExpr (str) {
return _cache[4].test(str)
};
_brackets.loopKeys = function loopKeys (expr) {
var m = expr.match(_cache[9]);
return m
? { key: m[1], pos: m[2], val: _cache[0] + m[3].trim() + _cache[1] }
: { val: expr.trim() }
};
_brackets.array = function array (pair) {
return pair ? _create(pair) : _cache
};
function _reset (pair) {
if ((pair || (pair = DEFAULT)) !== _cache[8]) {
_cache = _create(pair);
_regex = pair === DEFAULT ? _loopback : _rewrite;
_cache[9] = _regex(_pairs[9]);
}
cachedBrackets = pair;
}
function _setSettings (o) {
var b;
o = o || {};
b = o.brackets;
Object.defineProperty(o, 'brackets', {
set: _reset,
get: function () { return cachedBrackets },
enumerable: true
});
_settings = o;
_reset(b);
}
Object.defineProperty(_brackets, 'settings', {
set: _setSettings,
get: function () { return _settings }
});
/* istanbul ignore next: in the browser riot is always in the scope */
_brackets.settings = typeof riot !== 'undefined' && riot.settings || {};
_brackets.set = _reset;
_brackets.skipRegex = skipRegex;
_brackets.R_STRINGS = R_STRINGS;
_brackets.R_MLCOMMS = R_MLCOMMS;
_brackets.S_QBLOCKS = S_QBLOCKS;
_brackets.S_QBLOCK2 = S_QBLOCK2;
return _brackets
})();
/**
* @module tmpl
*
* tmpl - Root function, returns the template value, render with data
* tmpl.hasExpr - Test the existence of a expression inside a string
* tmpl.loopKeys - Get the keys for an 'each' loop (used by `_each`)
*/
/* istanbul ignore next */
var tmpl = (function () {
var _cache = {};
function _tmpl (str, data) {
if (!str) { return str }
return (_cache[str] || (_cache[str] = _create(str))).call(
data, _logErr.bind({
data: data,
tmpl: str
})
)
}
_tmpl.hasExpr = brackets.hasExpr;
_tmpl.loopKeys = brackets.loopKeys;
// istanbul ignore next
_tmpl.clearCache = function () { _cache = {}; };
_tmpl.errorHandler = null;
function _logErr (err, ctx) {
err.riotData = {
tagName: ctx && ctx.__ && ctx.__.tagName,
_riot_id: ctx && ctx._riot_id //eslint-disable-line camelcase
};
if (_tmpl.errorHandler) { _tmpl.errorHandler(err); }
else if (
typeof console !== 'undefined' &&
typeof console.error === 'function'
) {
console.error(err.message);
console.log('<%s> %s', err.riotData.tagName || 'Unknown tag', this.tmpl); // eslint-disable-line
console.log(this.data); // eslint-disable-line
}
}
function _create (str) {
var expr = _getTmpl(str);
if (expr.slice(0, 11) !== 'try{return ') { expr = 'return ' + expr; }
return new Function('E', expr + ';') // eslint-disable-line no-new-func
}
var RE_DQUOTE = /\u2057/g;
var RE_QBMARK = /\u2057(\d+)~/g;
function _getTmpl (str) {
var parts = brackets.split(str.replace(RE_DQUOTE, '"'), 1);
var qstr = parts.qblocks;
var expr;
if (parts.length > 2 || parts[0]) {
var i, j, list = [];
for (i = j = 0; i < parts.length; ++i) {
expr = parts[i];
if (expr && (expr = i & 1
? _parseExpr(expr, 1, qstr)
: '"' + expr
.replace(/\\/g, '\\\\')
.replace(/\r\n?|\n/g, '\\n')
.replace(/"/g, '\\"') +
'"'
)) { list[j++] = expr; }
}
expr = j < 2 ? list[0]
: '[' + list.join(',') + '].join("")';
} else {
expr = _parseExpr(parts[1], 0, qstr);
}
if (qstr.length) {
expr = expr.replace(RE_QBMARK, function (_, pos) {
return qstr[pos]
.replace(/\r/g, '\\r')
.replace(/\n/g, '\\n')
});
}
return expr
}
var RE_CSNAME = /^(?:(-?[_A-Za-z\xA0-\xFF][-\w\xA0-\xFF]*)|\u2057(\d+)~):/;
var
RE_BREND = {
'(': /[()]/g,
'[': /[[\]]/g,
'{': /[{}]/g
};
function _parseExpr (expr, asText, qstr) {
expr = expr
.replace(/\s+/g, ' ').trim()
.replace(/\ ?([[\({},?\.:])\ ?/g, '$1');
if (expr) {
var
list = [],
cnt = 0,
match;
while (expr &&
(match = expr.match(RE_CSNAME)) &&
!match.index
) {
var
key,
jsb,
re = /,|([[{(])|$/g;
expr = RegExp.rightContext;
key = match[2] ? qstr[match[2]].slice(1, -1).trim().replace(/\s+/g, ' ') : match[1];
while (jsb = (match = re.exec(expr))[1]) { skipBraces(jsb, re); }
jsb = expr.slice(0, match.index);
expr = RegExp.rightContext;
list[cnt++] = _wrapExpr(jsb, 1, key);
}
expr = !cnt ? _wrapExpr(expr, asText)
: cnt > 1 ? '[' + list.join(',') + '].join(" ").trim()' : list[0];
}
return expr
function skipBraces (ch, re) {
var
mm,
lv = 1,
ir = RE_BREND[ch];
ir.lastIndex = re.lastIndex;
while (mm = ir.exec(expr)) {
if (mm[0] === ch) { ++lv; }
else if (!--lv) { break }
}
re.lastIndex = lv ? expr.length : ir.lastIndex;
}
}
// istanbul ignore next: not both
var // eslint-disable-next-line max-len
JS_CONTEXT = '"in this?this:' + (typeof window !== 'object' ? 'global' : 'window') + ').',
JS_VARNAME = /[,{][\$\w]+(?=:)|(^ *|[^$\w\.{])(?!(?:typeof|true|false|null|undefined|in|instanceof|is(?:Finite|NaN)|void|NaN|new|Date|RegExp|Math)(?![$\w]))([$_A-Za-z][$\w]*)/g,
JS_NOPROPS = /^(?=(\.[$\w]+))\1(?:[^.[(]|$)/;
function _wrapExpr (expr, asText, key) {
var tb;
expr = expr.replace(JS_VARNAME, function (match, p, mvar, pos, s) {
if (mvar) {
pos = tb ? 0 : pos + match.length;
if (mvar !== 'this' && mvar !== 'global' && mvar !== 'window') {
match = p + '("' + mvar + JS_CONTEXT + mvar;
if (pos) { tb = (s = s[pos]) === '.' || s === '(' || s === '['; }
} else if (pos) {
tb = !JS_NOPROPS.test(s.slice(pos));
}
}
return match
});
if (tb) {
expr = 'try{return ' + expr + '}catch(e){E(e,this)}';
}
if (key) {
expr = (tb
? 'function(){' + expr + '}.call(this)' : '(' + expr + ')'
) + '?"' + key + '":""';
} else if (asText) {
expr = 'function(v){' + (tb
? expr.replace('return ', 'v=') : 'v=(' + expr + ')'
) + ';return v||v===0?v:""}.call(this)';
}
return expr
}
_tmpl.version = brackets.version = 'v3.0.8';
return _tmpl
})();
/* istanbul ignore next */
var observable = function(el) {
/**
* Extend the original object or create a new empty one
* @type { Object }
*/
el = el || {};
/**
* Private variables
*/
var callbacks = {},
slice = Array.prototype.slice;
/**
* Public Api
*/
// extend the el object adding the observable methods
Object.defineProperties(el, {
/**
* Listen to the given `event` ands
* execute the `callback` each time an event is triggered.
* @param { String } event - event id
* @param { Function } fn - callback function
* @returns { Object } el
*/
on: {
value: function(event, fn) {
if (typeof fn == 'function')
{ (callbacks[event] = callbacks[event] || []).push(fn); }
return el
},
enumerable: false,
writable: false,
configurable: false
},
/**
* Removes the given `event` listeners
* @param { String } event - event id
* @param { Function } fn - callback function
* @returns { Object } el
*/
off: {
value: function(event, fn) {
if (event == '*' && !fn) { callbacks = {}; }
else {
if (fn) {
var arr = callbacks[event];
for (var i = 0, cb; cb = arr && arr[i]; ++i) {
if (cb == fn) { arr.splice(i--, 1); }
}
} else { delete callbacks[event]; }
}
return el
},
enumerable: false,
writable: false,
configurable: false
},
/**
* Listen to the given `event` and
* execute the `callback` at most once
* @param { String } event - event id
* @param { Function } fn - callback function
* @returns { Object } el
*/
one: {
value: function(event, fn) {
function on() {
el.off(event, on);
fn.apply(el, arguments);
}
return el.on(event, on)
},
enumerable: false,
writable: false,
configurable: false
},
/**
* Execute all callback functions that listen to
* the given `event`
* @param { String } event - event id
* @returns { Object } el
*/
trigger: {
value: function(event) {
var arguments$1 = arguments;
// getting the arguments
var arglen = arguments.length - 1,
args = new Array(arglen),
fns,
fn,
i;
for (i = 0; i < arglen; i++) {
args[i] = arguments$1[i + 1]; // skip first argument
}
fns = slice.call(callbacks[event] || [], 0);
for (i = 0; fn = fns[i]; ++i) {
fn.apply(el, args);
}
if (callbacks['*'] && event != '*')
{ el.trigger.apply(el, ['*', event].concat(args)); }
return el
},
enumerable: false,
writable: false,
configurable: false
}
});
return el
};
/**
* Short alias for Object.getOwnPropertyDescriptor
*/
function getPropDescriptor (o, k) {
return Object.getOwnPropertyDescriptor(o, k)
}
/**
* Check if passed argument is undefined
* @param { * } value -
* @returns { Boolean } -
*/
function isUndefined(value) {
return typeof value === T_UNDEF
}
/**
* Check whether object's property could be overridden
* @param { Object } obj - source object
* @param { String } key - object property
* @returns { Boolean } true if writable
*/
function isWritable(obj, key) {
var descriptor = getPropDescriptor(obj, key);
return isUndefined(obj[key]) || descriptor && descriptor.writable
}
/**
* Extend any object with other properties
* @param { Object } src - source object
* @returns { Object } the resulting extended object
*
* var obj = { foo: 'baz' }
* extend(obj, {bar: 'bar', foo: 'bar'})
* console.log(obj) => {bar: 'bar', foo: 'bar'}
*
*/
function extend(src) {
var obj;
var i = 1;
var args = arguments;
var l = args.length;
for (; i < l; i++) {
if (obj = args[i]) {
for (var key in obj) {
// check if this property of the source object could be overridden
if (isWritable(src, key))
{ src[key] = obj[key]; }
}
}
}
return src
}
/**
* Alias for Object.create
*/
function create(src) {
return Object.create(src)
}
var settings = extend(create(brackets.settings), {
skipAnonymousTags: true,
// the "value" attributes will be preserved
keepValueAttributes: false,
// handle the auto updates on any DOM event
autoUpdate: true
});
/**
* Shorter and fast way to select multiple nodes in the DOM
* @param { String } selector - DOM selector
* @param { Object } ctx - DOM node where the targets of our search will is located
* @returns { Object } dom nodes found
*/
function $$(selector, ctx) {
return [].slice.call((ctx || document).querySelectorAll(selector))
}
/**
* Create a document text node
* @returns { Object } create a text node to use as placeholder
*/
function createDOMPlaceholder() {
return document.createTextNode('')
}
/**
* Toggle the visibility of any DOM node
* @param { Object } dom - DOM node we want to hide
* @param { Boolean } show - do we want to show it?
*/
function toggleVisibility(dom, show) {
dom.style.display = show ? '' : 'none';
dom.hidden = show ? false : true;
}
/**
* Get the value of any DOM attribute on a node
* @param { Object } dom - DOM node we want to parse
* @param { String } name - name of the attribute we want to get
* @returns { String | undefined } name of the node attribute whether it exists
*/
function getAttribute(dom, name) {
return dom.getAttribute(name)
}
/**
* Remove any DOM attribute from a node
* @param { Object } dom - DOM node we want to update
* @param { String } name - name of the property we want to remove
*/
function removeAttribute(dom, name) {
dom.removeAttribute(name);
}
/**
* Set the inner html of any DOM node SVGs included
* @param { Object } container - DOM node where we'll inject new html
* @param { String } html - html to inject
* @param { Boolean } isSvg - svg tags should be treated a bit differently
*/
/* istanbul ignore next */
function setInnerHTML(container, html, isSvg) {
// innerHTML is not supported on svg tags so we neet to treat them differently
if (isSvg) {
var node = container.ownerDocument.importNode(
new DOMParser()
.parseFromString((""), 'application/xml')
.documentElement,
true
);
container.appendChild(node);
} else {
container.innerHTML = html;
}
}
/**
* Minimize risk: only zero or one _space_ between attr & value
* @param { String } html - html string we want to parse
* @param { Function } fn - callback function to apply on any attribute found
*/
function walkAttributes(html, fn) {
if (!html) { return }
var m;
while (m = RE_HTML_ATTRS.exec(html))
{ fn(m[1].toLowerCase(), m[2] || m[3] || m[4]); }
}
/**
* Create a document fragment
* @returns { Object } document fragment
*/
function createFragment() {
return document.createDocumentFragment()
}
/**
* Insert safely a tag to fix #1962 #1649
* @param { HTMLElement } root - children container
* @param { HTMLElement } curr - node to insert
* @param { HTMLElement } next - node that should preceed the current node inserted
*/
function safeInsert(root, curr, next) {
root.insertBefore(curr, next.parentNode && next);
}
/**
* Convert a style object to a string
* @param { Object } style - style object we need to parse
* @returns { String } resulting css string
* @example
* styleObjectToString({ color: 'red', height: '10px'}) // => 'color: red; height: 10px'
*/
function styleObjectToString(style) {
return Object.keys(style).reduce(function (acc, prop) {
return (acc + " " + prop + ": " + (style[prop]) + ";")
}, '')
}
/**
* Walk down recursively all the children tags starting dom node
* @param { Object } dom - starting node where we will start the recursion
* @param { Function } fn - callback to transform the child node just found
* @param { Object } context - fn can optionally return an object, which is passed to children
*/
function walkNodes(dom, fn, context) {
if (dom) {
var res = fn(dom, context);
var next;
// stop the recursion
if (res === false) { return }
dom = dom.firstChild;
while (dom) {
next = dom.nextSibling;
walkNodes(dom, fn, res);
dom = next;
}
}
}
var dom = /*#__PURE__*/Object.freeze({
$$: $$,
$: $,
createDOMPlaceholder: createDOMPlaceholder,
mkEl: makeElement,
setAttr: setAttribute,
toggleVisibility: toggleVisibility,
getAttr: getAttribute,
remAttr: removeAttribute,
setInnerHTML: setInnerHTML,
walkAttrs: walkAttributes,
createFrag: createFragment,
safeInsert: safeInsert,
styleObjectToString: styleObjectToString,
walkNodes: walkNodes
});
/**
* Check against the null and undefined values
* @param { * } value -
* @returns {Boolean} -
*/
function isNil(value) {
return isUndefined(value) || value === null
}
/**
* Check if passed argument is empty. Different from falsy, because we dont consider 0 or false to be blank
* @param { * } value -
* @returns { Boolean } -
*/
function isBlank(value) {
return isNil(value) || value === ''
}
/**
* Check if passed argument is a function
* @param { * } value -
* @returns { Boolean } -
*/
function isFunction(value) {
return typeof value === T_FUNCTION
}
/**
* Check if passed argument is an object, exclude null
* NOTE: use isObject(x) && !isArray(x) to excludes arrays.
* @param { * } value -
* @returns { Boolean } -
*/
function isObject(value) {
return value && typeof value === T_OBJECT // typeof null is 'object'
}
/**
* Check if a DOM node is an svg tag or part of an svg
* @param { HTMLElement } el - node we want to test
* @returns {Boolean} true if it's an svg node
*/
function isSvg(el) {
var owner = el.ownerSVGElement;
return !!owner || owner === null
}
/**
* Check if passed argument is a kind of array
* @param { * } value -
* @returns { Boolean } -
*/
function isArray(value) {
return Array.isArray(value) || value instanceof Array
}
/**
* Check if the passed argument is a boolean attribute
* @param { String } value -
* @returns { Boolean } -
*/
function isBoolAttr(value) {
return RE_BOOL_ATTRS.test(value)
}
/**
* Check if passed argument is a string
* @param { * } value -
* @returns { Boolean } -
*/
function isString(value) {
return typeof value === T_STRING
}
var check = /*#__PURE__*/Object.freeze({
isBlank: isBlank,
isFunction: isFunction,
isObject: isObject,
isSvg: isSvg,
isWritable: isWritable,
isArray: isArray,
isBoolAttr: isBoolAttr,
isNil: isNil,
isString: isString,
isUndefined: isUndefined
});
/**
* Check whether an array contains an item
* @param { Array } array - target array
* @param { * } item - item to test
* @returns { Boolean } -
*/
function contains(array, item) {
return array.indexOf(item) !== -1
}
/**
* Specialized function for looping an array-like collection with `each={}`
* @param { Array } list - collection of items
* @param {Function} fn - callback function
* @returns { Array } the array looped
*/
function each(list, fn) {
var len = list ? list.length : 0;
var i = 0;
for (; i < len; i++) { fn(list[i], i); }
return list
}
/**
* Faster String startsWith alternative
* @param { String } str - source string
* @param { String } value - test string
* @returns { Boolean } -
*/
function startsWith(str, value) {
return str.slice(0, value.length) === value
}
/**
* Function returning always a unique identifier
* @returns { Number } - number from 0...n
*/
var uid = (function uid() {
var i = -1;
return function () { return ++i; }
})();
/**
* Helper function to set an immutable property
* @param { Object } el - object where the new property will be set
* @param { String } key - object key where the new property will be stored
* @param { * } value - value of the new property
* @param { Object } options - set the propery overriding the default options
* @returns { Object } - the initial object
*/
function define(el, key, value, options) {
Object.defineProperty(el, key, extend({
value: value,
enumerable: false,
writable: false,
configurable: true
}, options));
return el
}
/**
* Convert a string containing dashes to camel case
* @param { String } str - input string
* @returns { String } my-string -> myString
*/
function toCamel(str) {
return str.replace(/-(\w)/g, function (_, c) { return c.toUpperCase(); })
}
/**
* Warn a message via console
* @param {String} message - warning message
*/
function warn(message) {
if (console && console.warn) { console.warn(message); }
}
var misc = /*#__PURE__*/Object.freeze({
contains: contains,
each: each,
getPropDescriptor: getPropDescriptor,
startsWith: startsWith,
uid: uid,
defineProperty: define,
objectCreate: create,
extend: extend,
toCamel: toCamel,
warn: warn
});
/**
* Set the property of an object for a given key. If something already
* exists there, then it becomes an array containing both the old and new value.
* @param { Object } obj - object on which to set the property
* @param { String } key - property name
* @param { Object } value - the value of the property to be set
* @param { Boolean } ensureArray - ensure that the property remains an array
* @param { Number } index - add the new item in a certain array position
*/
function arrayishAdd(obj, key, value, ensureArray, index) {
var dest = obj[key];
var isArr = isArray(dest);
var hasIndex = !isUndefined(index);
if (dest && dest === value) { return }
// if the key was never set, set it once
if (!dest && ensureArray) { obj[key] = [value]; }
else if (!dest) { obj[key] = value; }
// if it was an array and not yet set
else {
if (isArr) {
var oldIndex = dest.indexOf(value);
// this item never changed its position
if (oldIndex === index) { return }
// remove the item from its old position
if (oldIndex !== -1) { dest.splice(oldIndex, 1); }
// move or add the item
if (hasIndex) {
dest.splice(index, 0, value);
} else {
dest.push(value);
}
} else { obj[key] = [dest, value]; }
}
}
/**
* Detect the tag implementation by a DOM node
* @param { Object } dom - DOM node we need to parse to get its tag implementation
* @returns { Object } it returns an object containing the implementation of a custom tag (template and boot function)
*/
function get(dom) {
return dom.tagName && __TAG_IMPL[getAttribute(dom, IS_DIRECTIVE) ||
getAttribute(dom, IS_DIRECTIVE) || dom.tagName.toLowerCase()]
}
/**
* Get the tag name of any DOM node
* @param { Object } dom - DOM node we want to parse
* @param { Boolean } skipDataIs - hack to ignore the data-is attribute when attaching to parent
* @returns { String } name to identify this dom node in riot
*/
function getName(dom, skipDataIs) {
var child = get(dom);
var namedTag = !skipDataIs && getAttribute(dom, IS_DIRECTIVE);
return namedTag && !tmpl.hasExpr(namedTag) ?
namedTag : child ? child.name : dom.tagName.toLowerCase()
}
/**
* Return a temporary context containing also the parent properties
* @this Tag
* @param { Tag } - temporary tag context containing all the parent properties
*/
function inheritParentProps() {
if (this.parent) { return extend(create(this), this.parent) }
return this
}
/*
Includes hacks needed for the Internet Explorer version 9 and below
See: http://kangax.github.io/compat-table/es5/#ie8
http://codeplanet.io/dropping-ie8/
*/
var
reHasYield = /|>([\S\s]*?)<\/yield\s*>|>)/ig,
reYieldSrc = /]*)['"]\s*>([\S\s]*?)<\/yield\s*>/ig,
reYieldDest = /]*|"[^"]*")*)?>([\S\s]+?)<\/pre\s*>/gi;
var SPEC_TYPES = /^"(?:number|date(?:time)?|time|month|email|color)\b/i;
var IMPORT_STATEMENT = /^\s*import(?!\w|(\s)?\()(?:(?:\s|[^\s'"])*)['|"].*\n?/gm;
var TRIM_TRAIL = /[ \t]+$/gm;
var
RE_HASEXPR = safeRegex(/@#\d/, 'x01'),
RE_REPEXPR = safeRegex(/@#(\d+)/g, 'x01'),
CH_IDEXPR = '\x01#',
CH_DQCODE = '\u2057',
DQ = '"',
SQ = "'";
function cleanSource (src) {
var
mm,
re = HTML_COMMS;
if (src.indexOf('\r') !== 1) {
src = src.replace(/\r\n?/g, '\n');
}
re.lastIndex = 0;
while ((mm = re.exec(src))) {
if (mm[0][0] === '<') {
src = RegExp.leftContext + RegExp.rightContext;
re.lastIndex = mm[3] + 1;
}
}
return src
}
function parseAttribs (str, pcex) {
var
list = [],
match,
type, vexp;
HTML_ATTRS.lastIndex = 0;
str = str.replace(/\s+/g, ' ');
while ((match = HTML_ATTRS.exec(str))) {
var
k = match[1].toLowerCase(),
v = match[2];
if (!v) {
list.push(k);
} else {
if (v[0] !== DQ) {
v = DQ + (v[0] === SQ ? v.slice(1, -1) : v) + DQ;
}
if (k === 'type' && SPEC_TYPES.test(v)) {
type = v;
} else {
if (RE_HASEXPR.test(v)) {
if (k === 'value') { vexp = 1; }
if (RIOT_ATTRS.indexOf(k) !== -1) { k = 'riot-' + k; }
}
list.push(k + '=' + v);
}
}
}
if (type) {
if (vexp) { type = DQ + pcex._bp[0] + SQ + type.slice(1, -1) + SQ + pcex._bp[1] + DQ; }
list.push('type=' + type);
}
return list.join(' ')
}
function splitHtml (html, opts, pcex) {
var _bp = pcex._bp;
if (html && _bp[4].test(html)) {
var
jsfn = opts.expr && (opts.parser || opts.type) ? _compileJS : 0,
list = brackets.split(html, 0, _bp),
expr;
for (var i = 1; i < list.length; i += 2) {
expr = list[i];
if (expr[0] === '^') {
expr = expr.slice(1);
} else if (jsfn) {
expr = jsfn(expr, opts).trim();
if (expr.slice(-1) === ';') { expr = expr.slice(0, -1); }
}
list[i] = CH_IDEXPR + (pcex.push(expr) - 1) + _bp[1];
}
html = list.join('');
}
return html
}
function restoreExpr (html, pcex) {
if (pcex.length) {
html = html.replace(RE_REPEXPR, function (_, d) {
return pcex._bp[0] + pcex[d].trim().replace(/[\r\n]+/g, ' ').replace(/"/g, CH_DQCODE)
});
}
return html
}
function _compileHTML (html, opts, pcex) {
if (!/\S/.test(html)) { return '' }
html = splitHtml(html, opts, pcex)
.replace(HTML_TAGS, function (_, name, attr, ends) {
name = name.toLowerCase();
ends = ends && !VOID_TAGS.test(name) ? '>'
});
if (!opts.whitespace) {
var p = [];
if (/]/.test(html)) {
html = html.replace(PRE_TAGS, function (q) {
p.push(q);
return '\u0002'
});
}
html = html.trim().replace(/\s+/g, ' ');
if (p.length) { html = html.replace(/\u0002/g, function () { return p.shift() }); } // eslint-disable-line
}
if (opts.compact) { html = html.replace(HTML_PACK, '><$1'); }
return restoreExpr(html, pcex).replace(TRIM_TRAIL, '')
}
function compileHTML (html, opts, pcex) {
if (Array.isArray(opts)) {
pcex = opts;
opts = {};
} else {
if (!pcex) { pcex = []; }
if (!opts) { opts = {}; }
}
pcex._bp = brackets.array(opts.brackets);
return _compileHTML(cleanSource(html), opts, pcex)
}
var JS_ES6SIGN = /^[ \t]*(((?:async|\*)\s*)?([$_A-Za-z][$\w]*))\s*\([^()]*\)\s*{/m;
function riotjs (js) {
var
parts = [],
match,
toes5,
pos,
method,
prefix,
name,
RE = RegExp;
var src = jsSplitter(js);
js = src.shift().join('<%>');
while ((match = js.match(JS_ES6SIGN))) {
parts.push(RE.leftContext);
js = RE.rightContext;
pos = skipBody(js);
method = match[1];
prefix = match[2] || '';
name = match[3];
toes5 = !/^(?:if|while|for|switch|catch|function)$/.test(name);
if (toes5) {
name = match[0].replace(method, 'this.' + name + ' =' + prefix + ' function');
} else {
name = match[0];
}
parts.push(name, js.slice(0, pos));
js = js.slice(pos);
if (toes5 && !/^\s*.\s*bind\b/.test(js)) { parts.push('.bind(this)'); }
}
if (parts.length) {
js = parts.join('') + js;
}
if (src.length) {
js = js.replace(/<%>/g, function () {
return src.shift()
});
}
return js
function skipBody (s) {
var r = /[{}]/g;
var i = 1;
while (i && r.exec(s)) {
if (s[r.lastIndex - 1] === '{') { ++i; }
else { --i; }
}
return i ? s.length : r.lastIndex
}
}
function _compileJS (js, opts, type, parserOpts, url) {
if (!/\S/.test(js)) { return '' }
if (!type) { type = opts.type; }
var parser = opts.parser || type && parsers._req('js.' + type, true) || riotjs;
return parser(js, parserOpts, url).replace(/\r\n?/g, '\n').replace(TRIM_TRAIL, '')
}
function compileJS (js, opts, type, userOpts) {
if (typeof opts === 'string') {
userOpts = type;
type = opts;
opts = {};
}
if (type && typeof type === 'object') {
userOpts = type;
type = '';
}
if (!userOpts) { userOpts = {}; }
return _compileJS(js, opts || {}, type, userOpts.parserOptions, userOpts.url)
}
var CSS_SELECTOR = RegExp('([{}]|^)[; ]*((?:[^@ ;{}][^{}]*)?[^@ ;{}:] ?)(?={)|' + S_LINESTR, 'g');
function scopedCSS (tag, css) {
var scope = ':scope';
return css.replace(CSS_SELECTOR, function (m, p1, p2) {
if (!p2) { return m }
p2 = p2.replace(/[^,]+/g, function (sel) {
var s = sel.trim();
if (s.indexOf(tag) === 0) {
return sel
}
if (!s || s === 'from' || s === 'to' || s.slice(-1) === '%') {
return sel
}
if (s.indexOf(scope) < 0) {
s = tag + ' ' + s + ',[data-is="' + tag + '"] ' + s;
} else {
s = s.replace(scope, tag) + ',' +
s.replace(scope, '[data-is="' + tag + '"]');
}
return s
});
return p1 ? p1 + ' ' + p2 : p2
})
}
function _compileCSS (css, tag, type, opts) {
opts = opts || {};
if (type) {
if (type !== 'css') {
var parser = parsers._req('css.' + type, true);
css = parser(tag, css, opts.parserOpts || {}, opts.url);
}
}
css = css.replace(brackets.R_MLCOMMS, '').replace(/\s+/g, ' ').trim();
if (tag) { css = scopedCSS(tag, css); }
return css
}
function compileCSS (css, type, opts) {
if (type && typeof type === 'object') {
opts = type;
type = '';
} else if (!opts) { opts = {}; }
return _compileCSS(css, opts.tagName, type, opts)
}
var TYPE_ATTR = /\stype\s*=\s*(?:(['"])(.+?)\1|(\S+))/i;
var MISC_ATTR = '\\s*=\\s*(' + S_STRINGS + '|{[^}]+}|\\S+)';
var END_TAGS = /\/>\n|^<(?:\/?-?[A-Za-z][-\w\xA0-\xFF]*\s*|-?[A-Za-z][-\w\xA0-\xFF]*\s+[-\w:\xA0-\xFF][\S\s]*?)>\n/;
function _q (s, r) {
if (!s) { return "''" }
s = SQ + s.replace(/\\/g, '\\\\').replace(/'/g, "\\'") + SQ;
return r && s.indexOf('\n') !== -1 ? s.replace(/\n/g, '\\n') : s
}
function mktag (name, html, css, attr, js, imports, opts) {
var
c = opts.debug ? ',\n ' : ', ',
s = '});';
if (js && js.slice(-1) !== '\n') { s = '\n' + s; }
return imports + 'riot.tag2(\'' + name + SQ +
c + _q(html, 1) +
c + _q(css) +
c + _q(attr) + ', function(opts) {\n' + js + s
}
function splitBlocks (str) {
if (/<[-\w]/.test(str)) {
var
m,
k = str.lastIndexOf('<'),
n = str.length;
while (k !== -1) {
m = str.slice(k, n).match(END_TAGS);
if (m) {
k += m.index + m[0].length;
m = str.slice(0, k);
if (m.slice(-5) === '<-/>\n') { m = m.slice(0, -5); }
return [m, str.slice(k)]
}
n = k;
k = str.lastIndexOf('<', k - 1);
}
}
return ['', str]
}
function getType (attribs) {
if (attribs) {
var match = attribs.match(TYPE_ATTR);
match = match && (match[2] || match[3]);
if (match) {
return match.replace('text/', '')
}
}
return ''
}
function getAttrib (attribs, name) {
if (attribs) {
var match = attribs.match(RegExp('\\s' + name + MISC_ATTR, 'i'));
match = match && match[1];
if (match) {
return (/^['"]/).test(match) ? match.slice(1, -1) : match
}
}
return ''
}
function unescapeHTML (str) {
return str
.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, '\'')
}
function getParserOptions (attribs) {
var opts = unescapeHTML(getAttrib(attribs, 'options'));
return opts ? JSON.parse(opts) : null
}
function getCode (code, opts, attribs, base) {
var
type = getType(attribs),
src = getAttrib(attribs, 'src'),
jsParserOptions = extend$1({}, opts.parserOptions.js);
if (src) { return false }
return _compileJS(
code,
opts,
type,
extend$1(jsParserOptions, getParserOptions(attribs)),
base
)
}
function cssCode (code, opts, attribs, url, tag) {
var
parserStyleOptions = extend$1({}, opts.parserOptions.style),
extraOpts = {
parserOpts: extend$1(parserStyleOptions, getParserOptions(attribs)),
url: url
};
return _compileCSS(code, tag, getType(attribs) || opts.style, extraOpts)
}
function compileTemplate (html, url, lang, opts) {
var parser = parsers._req('html.' + lang, true);
return parser(html, opts, url)
}
var
CUST_TAG = RegExp(/^([ \t]*)<(-?[A-Za-z][-\w\xA0-\xFF]*)(?:\s+([^'"/>]+(?:(?:@|\/[^>])[^'"/>]*)*)|\s*)?(?:\/>|>[ \t]*\n?([\S\s]*)^\1<\/\2\s*>|>(.*)<\/\2\s*>)/
.source.replace('@', S_STRINGS), 'gim'),
SCRIPTS = /]*)?>\n?([\S\s]*?)<\/script\s*>/gi,
STYLES = /]*)?>\n?([\S\s]*?)<\/style\s*>/gi;
function compile (src, opts, url) {
var
parts = [],
included,
output = src,
defaultParserptions = {
template: {},
js: {},
style: {}
};
if (!opts) { opts = {}; }
opts.parserOptions = extend$1(defaultParserptions, opts.parserOptions || {});
included = opts.exclude
? function (s) { return opts.exclude.indexOf(s) < 0 } : function () { return 1 };
if (!url) { url = ''; }
var _bp = brackets.array(opts.brackets);
if (opts.template) {
output = compileTemplate(output, url, opts.template, opts.parserOptions.template);
}
output = cleanSource(output)
.replace(CUST_TAG, function (_, indent, tagName, attribs, body, body2) {
var
jscode = '',
styles = '',
html = '',
imports = '',
pcex = [];
pcex._bp = _bp;
tagName = tagName.toLowerCase();
attribs = attribs && included('attribs')
? restoreExpr(
parseAttribs(
splitHtml(attribs, opts, pcex),
pcex),
pcex) : '';
if ((body || (body = body2)) && /\S/.test(body)) {
if (body2) {
if (included('html')) { html = _compileHTML(body2, opts, pcex); }
} else {
body = body.replace(RegExp('^' + indent, 'gm'), '');
body = body.replace(SCRIPTS, function (_m, _attrs, _script) {
if (included('js')) {
var code = getCode(_script, opts, _attrs, url);
if (code) { jscode += (jscode ? '\n' : '') + code; }
}
return ''
});
body = body.replace(STYLES, function (_m, _attrs, _style) {
if (included('css')) {
styles += (styles ? ' ' : '') + cssCode(_style, opts, _attrs, url, tagName);
}
return ''
});
var blocks = splitBlocks(body.replace(TRIM_TRAIL, ''));
if (included('html')) {
html = _compileHTML(blocks[0], opts, pcex);
}
if (included('js')) {
body = _compileJS(blocks[1], opts, null, null, url);
if (body) { jscode += (jscode ? '\n' : '') + body; }
jscode = jscode.replace(IMPORT_STATEMENT, function (s) {
imports += s.trim() + '\n';
return ''
});
}
}
}
jscode = /\S/.test(jscode) ? jscode.replace(/\n{3,}/g, '\n\n') : '';
if (opts.entities) {
parts.push({
tagName: tagName,
html: html,
css: styles,
attribs: attribs,
js: jscode,
imports: imports
});
return ''
}
return mktag(tagName, html, styles, attribs, jscode, imports, opts)
});
if (opts.entities) { return parts }
return output
}
var version$2 = 'v3.5.2';
var compiler = {
compile: compile,
compileHTML: compileHTML,
compileCSS: compileCSS,
compileJS: compileJS,
parsers: parsers,
version: version$2
};
var
promise, // emits the 'ready' event and runs the first callback
ready; // all the scripts were compiled?
// gets the source of an external tag with an async call
function GET (url, fn, opts) {
var req = new XMLHttpRequest();
req.onreadystatechange = function () {
if (req.readyState === 4) {
if (req.status === 200 || !req.status && req.responseText.length) {
fn(req.responseText, opts, url);
} else {
compile$1.error(("\"" + url + "\" not found"));
}
}
};
req.onerror = function (e) { return compile$1.error(e); };
req.open('GET', url, true);
req.send('');
}
// evaluates a compiled tag within the global context
function globalEval (js, url) {
if (typeof js === T_STRING) {
var
node = makeElement('script'),
root = document.documentElement;
// make the source available in the "(no domain)" tab
// of Chrome DevTools, with a .js extension
if (url) { js += '\n//# sourceURL=' + url + '.js'; }
node.text = js;
root.appendChild(node);
root.removeChild(node);
}
}
// compiles all the internal and external tags on the page
function compileScripts (fn, xopt) {
var
scripts = $$('script[type="riot/tag"]'),
scriptsAmount = scripts.length;
function done() {
promise.trigger('ready');
ready = true;
if (fn) { fn(); }
}
function compileTag (src, opts, url) {
var code = compiler.compile(src, opts, url);
globalEval(code, url);
if (!--scriptsAmount) { done(); }
}
if (!scriptsAmount) { done(); }
else {
for (var i = 0; i < scripts.length; ++i) {
var
script = scripts[i],
opts = extend({template: getAttribute(script, 'template')}, xopt),
url = getAttribute(script, 'src') || getAttribute(script, 'data-src');
url ? GET(url, compileTag, opts) : compileTag(script.innerHTML, opts);
}
}
}
var parsers$1 = compiler.parsers;
/*
Compilation for the browser
*/
function compile$1 (arg, fn, opts) {
if (typeof arg === T_STRING) {
// 2nd parameter is optional, but can be null
if (isObject(fn)) {
opts = fn;
fn = false;
}
// `riot.compile(tag [, callback | true][, options])`
if (/^\s* © 2015 - 2025 Weber Informatics LLC | Privacy Policy