{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///../node_modules/riot/riot.js","webpack:///./entry/credit.js","webpack:///frontend/tags/credit/index.tag"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","$","selector","ctx","document","querySelector","styleNode","cssTextProp","__TAGS_CACHE","__TAG_IMPL","REF_DIRECTIVES","SVG_NS","XLINK_REGEX","WIN","window","undefined","RE_EVENTS_PREFIX","RE_HTML_ATTRS","CASE_SENSITIVE_ATTRIBUTES","RE_BOOL_ATTRS","IE_VERSION","documentMode","makeElement","createElementNS","createElement","setAttribute","dom","val","xlink","exec","setAttributeNS","newNode","userNode","byName","needsInject","id","parentNode","replaceChild","head","appendChild","styleSheet","styleManager","add","css","inject","style","keys","map","k","join","cssText","innerHTML","remove","skipRegex","beforeReWords","wordsLastChar","reduce","w","slice","RE_REGEX","RE_VN_CHAR","prev","code","pos","test","start","re","lastIndex","match","next","length","indexOf","end","brackets","UNDEF","_regex","_settings","R_STRINGS","S_QBLOCKS","source","UNSUPPORTED","RegExp","NEED_ESCAPE","S_QBLOCK2","FINDBRACES","_pairs","cachedBrackets","_cache","_loopback","_rewrite","bp","replace","global","_create","pair","arr","split","Error","concat","_brackets","reOrIdx","_reset","str","tmpl","_bp","isexpr","mark","parts","qblocks","prevStr","index","ch","rech","ix","pushQBlock","unescapeStr","push","_pos","_lastIndex","slash","hasExpr","loopKeys","expr","trim","array","set","b","settings","riot","R_MLCOMMS","_tmpl","data","RE_DQUOTE","qstr","j","list","_parseExpr","RE_QBMARK","_","_getTmpl","Function","_logErr","err","riotData","tagName","__","_riot_id","errorHandler","console","error","message","log","this","clearCache","RE_CSNAME","RE_BREND","asText","cnt","jsb","rightContext","skipBraces","_wrapExpr","mm","lv","ir","JS_CONTEXT","JS_VARNAME","JS_NOPROPS","tb","mvar","version","observable","el","callbacks","Array","defineProperties","on","event","fn","writable","configurable","off","cb","splice","one","apply","arguments","trigger","fns","arguments$1","arglen","args","getPropDescriptor","getOwnPropertyDescriptor","isUndefined","isWritable","obj","descriptor","extend","src","skipAnonymousTags","keepValueAttributes","autoUpdate","$$","querySelectorAll","createDOMPlaceholder","createTextNode","toggleVisibility","show","display","hidden","getAttribute","removeAttribute","setInnerHTML","container","html","isSvg","node","ownerDocument","importNode","DOMParser","parseFromString","documentElement","walkAttributes","toLowerCase","createFragment","createDocumentFragment","safeInsert","root","curr","insertBefore","styleObjectToString","acc","prop","walkNodes","context","res","firstChild","nextSibling","freeze","mkEl","setAttr","getAttr","remAttr","walkAttrs","createFrag","isNil","isBlank","isFunction","isObject","owner","ownerSVGElement","isArray","isBoolAttr","isString","check","contains","item","each","len","startsWith","uid","define","options","toCamel","toUpperCase","warn","misc","objectCreate","arrayishAdd","ensureArray","dest","isArr","hasIndex","oldIndex","getName","skipDataIs","child","namedTag","inheritParentProps","parent","reHasYield","reYieldAll","reYieldSrc","reYieldDest","rootEls","tr","th","td","col","tblTags","mkdom","ref","text","def","replaceYield","select","selectedIndex","tname","childElementCount","specialTags","EVENT_ATTR_RE","getImmediateCustomParent","tag","ptag","isAnonymous","handleEvent","handler","e","currentTarget","target","srcElement","which","charCode","keyCode","preventUpdate","isMounted","update","setEventHandler","eventName","listeners","removeEventListener","addEventListener","initChild","opts","createTag","tags","arrayishRemove","makeVirtual","sib","tail","frag","virts","makeReplaceVirtual","updateExpression","attrName","normalizeAttrName","attr","isToggle","isVirtual","isStyleAttr","isClassAttr","isValueAttr","wasCreated","mount","hasValue","isObj","JSON","stringify","wasParsedOnce","bool","isRtag","_tag","unmount","impl","attrs","a","onUnmount","delName","dataIs","updateDataIs","nodeValue","attribute","expressions","updateOpts","isLoop","instAttrs","query","filter","Tag","onCreate","class","constructor","mount$1","tag2","elem","allTags","nodeList","_el","pushTagsTo","riotTag","mixins","globals","mixins_id","mixin","mix","g","store","update$1","unregister","core","componentMixin","tag$$1","instance","props","propsBlacklist","proto","getPrototypeOf","getOwnPropertyNames","hasGetterSetter","init","moveChild","newPos","moveVirtual","mkitem","moveNestedTags","this$1","move","nextTag","insert","append","_each","mustReorder","keyAttr","hasKeyAttrExpr","placeholder","ifExpr","oldItems","removeChild","items","tmpItems","hasKeys","filteredItemsCount","_item","itemId","originalItem","keyedItem","getItemId","doReorder","oldPos","isNew","mustAppend","mustCreate","cloneNode","unmountRedundant","RefExpr","attrValue","rawValue","hasExp","old","customParent","tagOrDom","__ref","refs","createRefDirective","unmountAll","IfExpr","stub","pristine","current","parseExpressions","createIfDirective","mustIncludeRoot","tagImpl","type","nodeType","attributes","parentElement","outerHTML","hasIsDirective","parseAttributes","setMountState","skipAnonymous","conf","isInline","implAttrs","nextOpts","canTrigger","shouldUpdate","componentUpdate","isPrototypeOf","v","globalMixin","componentMount","mustKeepRoot","tagIndex","forEach","tagUnmount","implClass","_innerHTML","settings$1","util","vdom","getTagName","mountTo","selectTags","getTag","initChildTag","moveChildTag","getImmediateCustomParentTag","Tag$1","tag$1","tag2$1","mount$2","mixin$1","update$2","unregister$1","observable$1","riot$1","default","factory","require"],"mappings":"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","file":"credit.bundle.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 1377);\n","/* Riot v3.13.2, @license MIT */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n  (factory((global.riot = {})));\n}(this, (function (exports) { 'use strict';\n\n  /**\n   * Shorter and fast way to select a single node in the DOM\n   * @param   { String } selector - unique dom selector\n   * @param   { Object } ctx - DOM node where the target of our search will is located\n   * @returns { Object } dom node found\n   */\n  function $(selector, ctx) {\n    return (ctx || document).querySelector(selector)\n  }\n\n  var\n    // be aware, internal usage\n    // ATTENTION: prefix the global dynamic variables with `__`\n    // tags instances cache\n    __TAGS_CACHE = [],\n    // tags implementation cache\n    __TAG_IMPL = {},\n    YIELD_TAG = 'yield',\n\n    /**\n     * Const\n     */\n    GLOBAL_MIXIN = '__global_mixin',\n\n    // riot specific prefixes or attributes\n    ATTRS_PREFIX = 'riot-',\n\n    // Riot Directives\n    REF_DIRECTIVES = ['ref', 'data-ref'],\n    IS_DIRECTIVE = 'data-is',\n    CONDITIONAL_DIRECTIVE = 'if',\n    LOOP_DIRECTIVE = 'each',\n    LOOP_NO_REORDER_DIRECTIVE = 'no-reorder',\n    SHOW_DIRECTIVE = 'show',\n    HIDE_DIRECTIVE = 'hide',\n    KEY_DIRECTIVE = 'key',\n    RIOT_EVENTS_KEY = '__riot-events__',\n\n    // for typeof == '' comparisons\n    T_STRING = 'string',\n    T_OBJECT = 'object',\n    T_UNDEF  = 'undefined',\n    T_FUNCTION = 'function',\n\n    XLINK_NS = 'http://www.w3.org/1999/xlink',\n    SVG_NS = 'http://www.w3.org/2000/svg',\n    XLINK_REGEX = /^xlink:(\\w+)/,\n\n    WIN = typeof window === T_UNDEF ? /* istanbul ignore next */ undefined : window,\n\n    // special native tags that cannot be treated like the others\n    RE_SPECIAL_TAGS = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?|opt(?:ion|group))$/,\n    RE_SPECIAL_TAGS_NO_OPTION = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?)$/,\n    RE_EVENTS_PREFIX = /^on/,\n    RE_HTML_ATTRS = /([-\\w]+) ?= ?(?:\"([^\"]*)|'([^']*)|({[^}]*}))/g,\n    // some DOM attributes must be normalized\n    CASE_SENSITIVE_ATTRIBUTES = {\n      'viewbox': 'viewBox',\n      'preserveaspectratio': 'preserveAspectRatio'\n    },\n    /**\n     * Matches boolean HTML attributes in the riot tag definition.\n     * With a long list like this, a regex is faster than `[].indexOf` in most browsers.\n     * @const {RegExp}\n     * @see [attributes.md](https://github.com/riot/compiler/blob/dev/doc/attributes.md)\n     */\n    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)$/,\n    // version# for IE 8-11, 0 for others\n    IE_VERSION = (WIN && WIN.document || /* istanbul ignore next */ {}).documentMode | 0;\n\n  /**\n   * Create a generic DOM node\n   * @param   { String } name - name of the DOM node we want to create\n   * @returns { Object } DOM node just created\n   */\n  function makeElement(name) {\n    return name === 'svg' ? document.createElementNS(SVG_NS, name) : document.createElement(name)\n  }\n\n  /**\n   * Set any DOM attribute\n   * @param { Object } dom - DOM node we want to update\n   * @param { String } name - name of the property we want to set\n   * @param { String } val - value of the property we want to set\n   */\n  function setAttribute(dom, name, val) {\n    var xlink = XLINK_REGEX.exec(name);\n    if (xlink && xlink[1])\n      { dom.setAttributeNS(XLINK_NS, xlink[1], val); }\n    else\n      { dom.setAttribute(name, val); }\n  }\n\n  var styleNode;\n  // Create cache and shortcut to the correct property\n  var cssTextProp;\n  var byName = {};\n  var needsInject = false;\n\n  // skip the following code on the server\n  if (WIN) {\n    styleNode = ((function () {\n      // create a new style element with the correct type\n      var newNode = makeElement('style');\n      // replace any user node or insert the new one into the head\n      var userNode = $('style[type=riot]');\n\n      setAttribute(newNode, 'type', 'text/css');\n      /* istanbul ignore next */\n      if (userNode) {\n        if (userNode.id) { newNode.id = userNode.id; }\n        userNode.parentNode.replaceChild(newNode, userNode);\n      } else { document.head.appendChild(newNode); }\n\n      return newNode\n    }))();\n    cssTextProp = styleNode.styleSheet;\n  }\n\n  /**\n   * Object that will be used to inject and manage the css of every tag instance\n   */\n  var styleManager = {\n    styleNode: styleNode,\n    /**\n     * Save a tag style to be later injected into DOM\n     * @param { String } css - css string\n     * @param { String } name - if it's passed we will map the css to a tagname\n     */\n    add: function add(css, name) {\n      byName[name] = css;\n      needsInject = true;\n    },\n    /**\n     * Inject all previously saved tag styles into DOM\n     * innerHTML seems slow: http://jsperf.com/riot-insert-style\n     */\n    inject: function inject() {\n      if (!WIN || !needsInject) { return }\n      needsInject = false;\n      var style = Object.keys(byName)\n        .map(function (k) { return byName[k]; })\n        .join('\\n');\n      /* istanbul ignore next */\n      if (cssTextProp) { cssTextProp.cssText = style; }\n      else { styleNode.innerHTML = style; }\n    },\n\n    /**\n     * Remove a tag style of injected DOM later.\n     * @param {String} name a registered tagname\n     */\n    remove: function remove(name) {\n      delete byName[name];\n      needsInject = true;\n    }\n  };\n\n  /**\n   * The riot template engine\n   * @version v3.0.8\n   */\n\n  /* istanbul ignore next */\n  var skipRegex = (function () { //eslint-disable-line no-unused-vars\n\n    var beforeReChars = '[{(,;:?=|&!^~>%*/';\n\n    var beforeReWords = [\n      'case',\n      'default',\n      'do',\n      'else',\n      'in',\n      'instanceof',\n      'prefix',\n      'return',\n      'typeof',\n      'void',\n      'yield'\n    ];\n\n    var wordsLastChar = beforeReWords.reduce(function (s, w) {\n      return s + w.slice(-1)\n    }, '');\n\n    var RE_REGEX = /^\\/(?=[^*>/])[^[/\\\\]*(?:(?:\\\\.|\\[(?:\\\\.|[^\\]\\\\]*)*\\])[^[\\\\/]*)*?\\/[gimuy]*/;\n    var RE_VN_CHAR = /[$\\w]/;\n\n    function prev (code, pos) {\n      while (--pos >= 0 && /\\s/.test(code[pos])){ }\n      return pos\n    }\n\n    function _skipRegex (code, start) {\n\n      var re = /.*/g;\n      var pos = re.lastIndex = start++;\n      var match = re.exec(code)[0].match(RE_REGEX);\n\n      if (match) {\n        var next = pos + match[0].length;\n\n        pos = prev(code, pos);\n        var c = code[pos];\n\n        if (pos < 0 || ~beforeReChars.indexOf(c)) {\n          return next\n        }\n\n        if (c === '.') {\n\n          if (code[pos - 1] === '.') {\n            start = next;\n          }\n\n        } else if (c === '+' || c === '-') {\n\n          if (code[--pos] !== c ||\n              (pos = prev(code, pos)) < 0 ||\n              !RE_VN_CHAR.test(code[pos])) {\n            start = next;\n          }\n\n        } else if (~wordsLastChar.indexOf(c)) {\n\n          var end = pos + 1;\n\n          while (--pos >= 0 && RE_VN_CHAR.test(code[pos])){ }\n          if (~beforeReWords.indexOf(code.slice(pos + 1, end))) {\n            start = next;\n          }\n        }\n      }\n\n      return start\n    }\n\n    return _skipRegex\n\n  })();\n\n  /**\n   * riot.util.brackets\n   *\n   * - `brackets    ` - Returns a string or regex based on its parameter\n   * - `brackets.set` - Change the current riot brackets\n   *\n   * @module\n   */\n\n  /* global riot */\n\n  /* istanbul ignore next */\n  var brackets = (function (UNDEF) {\n\n    var\n      REGLOB = 'g',\n\n      R_MLCOMMS = /\\/\\*[^*]*\\*+(?:[^*\\/][^*]*\\*+)*\\//g,\n\n      R_STRINGS = /\"[^\"\\\\]*(?:\\\\[\\S\\s][^\"\\\\]*)*\"|'[^'\\\\]*(?:\\\\[\\S\\s][^'\\\\]*)*'|`[^`\\\\]*(?:\\\\[\\S\\s][^`\\\\]*)*`/g,\n\n      S_QBLOCKS = R_STRINGS.source + '|' +\n        /(?:\\breturn\\s+|(?:[$\\w\\)\\]]|\\+\\+|--)\\s*(\\/)(?![*\\/]))/.source + '|' +\n        /\\/(?=[^*\\/])[^[\\/\\\\]*(?:(?:\\[(?:\\\\.|[^\\]\\\\]*)*\\]|\\\\.)[^[\\/\\\\]*)*?([^<]\\/)[gim]*/.source,\n\n      UNSUPPORTED = RegExp('[\\\\' + 'x00-\\\\x1F<>a-zA-Z0-9\\'\",;\\\\\\\\]'),\n\n      NEED_ESCAPE = /(?=[[\\]()*+?.^$|])/g,\n\n      S_QBLOCK2 = R_STRINGS.source + '|' + /(\\/)(?![*\\/])/.source,\n\n      FINDBRACES = {\n        '(': RegExp('([()])|'   + S_QBLOCK2, REGLOB),\n        '[': RegExp('([[\\\\]])|' + S_QBLOCK2, REGLOB),\n        '{': RegExp('([{}])|'   + S_QBLOCK2, REGLOB)\n      },\n\n      DEFAULT = '{ }';\n\n    var _pairs = [\n      '{', '}',\n      '{', '}',\n      /{[^}]*}/,\n      /\\\\([{}])/g,\n      /\\\\({)|{/g,\n      RegExp('\\\\\\\\(})|([[({])|(})|' + S_QBLOCK2, REGLOB),\n      DEFAULT,\n      /^\\s*{\\^?\\s*([$\\w]+)(?:\\s*,\\s*(\\S+))?\\s+in\\s+(\\S.*)\\s*}/,\n      /(^|[^\\\\]){=[\\S\\s]*?}/\n    ];\n\n    var\n      cachedBrackets = UNDEF,\n      _regex,\n      _cache = [],\n      _settings;\n\n    function _loopback (re) { return re }\n\n    function _rewrite (re, bp) {\n      if (!bp) { bp = _cache; }\n      return new RegExp(\n        re.source.replace(/{/g, bp[2]).replace(/}/g, bp[3]), re.global ? REGLOB : ''\n      )\n    }\n\n    function _create (pair) {\n      if (pair === DEFAULT) { return _pairs }\n\n      var arr = pair.split(' ');\n\n      if (arr.length !== 2 || UNSUPPORTED.test(pair)) {\n        throw new Error('Unsupported brackets \"' + pair + '\"')\n      }\n      arr = arr.concat(pair.replace(NEED_ESCAPE, '\\\\').split(' '));\n\n      arr[4] = _rewrite(arr[1].length > 1 ? /{[\\S\\s]*?}/ : _pairs[4], arr);\n      arr[5] = _rewrite(pair.length > 3 ? /\\\\({|})/g : _pairs[5], arr);\n      arr[6] = _rewrite(_pairs[6], arr);\n      arr[7] = RegExp('\\\\\\\\(' + arr[3] + ')|([[({])|(' + arr[3] + ')|' + S_QBLOCK2, REGLOB);\n      arr[8] = pair;\n      return arr\n    }\n\n    function _brackets (reOrIdx) {\n      return reOrIdx instanceof RegExp ? _regex(reOrIdx) : _cache[reOrIdx]\n    }\n\n    _brackets.split = function split (str, tmpl, _bp) {\n      // istanbul ignore next: _bp is for the compiler\n      if (!_bp) { _bp = _cache; }\n\n      var\n        parts = [],\n        match,\n        isexpr,\n        start,\n        pos,\n        re = _bp[6];\n\n      var qblocks = [];\n      var prevStr = '';\n      var mark, lastIndex;\n\n      isexpr = start = re.lastIndex = 0;\n\n      while ((match = re.exec(str))) {\n\n        lastIndex = re.lastIndex;\n        pos = match.index;\n\n        if (isexpr) {\n\n          if (match[2]) {\n\n            var ch = match[2];\n            var rech = FINDBRACES[ch];\n            var ix = 1;\n\n            rech.lastIndex = lastIndex;\n            while ((match = rech.exec(str))) {\n              if (match[1]) {\n                if (match[1] === ch) { ++ix; }\n                else if (!--ix) { break }\n              } else {\n                rech.lastIndex = pushQBlock(match.index, rech.lastIndex, match[2]);\n              }\n            }\n            re.lastIndex = ix ? str.length : rech.lastIndex;\n            continue\n          }\n\n          if (!match[3]) {\n            re.lastIndex = pushQBlock(pos, lastIndex, match[4]);\n            continue\n          }\n        }\n\n        if (!match[1]) {\n          unescapeStr(str.slice(start, pos));\n          start = re.lastIndex;\n          re = _bp[6 + (isexpr ^= 1)];\n          re.lastIndex = start;\n        }\n      }\n\n      if (str && start < str.length) {\n        unescapeStr(str.slice(start));\n      }\n\n      parts.qblocks = qblocks;\n\n      return parts\n\n      function unescapeStr (s) {\n        if (prevStr) {\n          s = prevStr + s;\n          prevStr = '';\n        }\n        if (tmpl || isexpr) {\n          parts.push(s && s.replace(_bp[5], '$1'));\n        } else {\n          parts.push(s);\n        }\n      }\n\n      function pushQBlock(_pos, _lastIndex, slash) { //eslint-disable-line\n        if (slash) {\n          _lastIndex = skipRegex(str, _pos);\n        }\n\n        if (tmpl && _lastIndex > _pos + 2) {\n          mark = '\\u2057' + qblocks.length + '~';\n          qblocks.push(str.slice(_pos, _lastIndex));\n          prevStr += str.slice(start, _pos) + mark;\n          start = _lastIndex;\n        }\n        return _lastIndex\n      }\n    };\n\n    _brackets.hasExpr = function hasExpr (str) {\n      return _cache[4].test(str)\n    };\n\n    _brackets.loopKeys = function loopKeys (expr) {\n      var m = expr.match(_cache[9]);\n\n      return m\n        ? { key: m[1], pos: m[2], val: _cache[0] + m[3].trim() + _cache[1] }\n        : { val: expr.trim() }\n    };\n\n    _brackets.array = function array (pair) {\n      return pair ? _create(pair) : _cache\n    };\n\n    function _reset (pair) {\n      if ((pair || (pair = DEFAULT)) !== _cache[8]) {\n        _cache = _create(pair);\n        _regex = pair === DEFAULT ? _loopback : _rewrite;\n        _cache[9] = _regex(_pairs[9]);\n      }\n      cachedBrackets = pair;\n    }\n\n    function _setSettings (o) {\n      var b;\n\n      o = o || {};\n      b = o.brackets;\n      Object.defineProperty(o, 'brackets', {\n        set: _reset,\n        get: function () { return cachedBrackets },\n        enumerable: true\n      });\n      _settings = o;\n      _reset(b);\n    }\n\n    Object.defineProperty(_brackets, 'settings', {\n      set: _setSettings,\n      get: function () { return _settings }\n    });\n\n    /* istanbul ignore next: in the browser riot is always in the scope */\n    _brackets.settings = typeof riot !== 'undefined' && riot.settings || {};\n    _brackets.set = _reset;\n    _brackets.skipRegex = skipRegex;\n\n    _brackets.R_STRINGS = R_STRINGS;\n    _brackets.R_MLCOMMS = R_MLCOMMS;\n    _brackets.S_QBLOCKS = S_QBLOCKS;\n    _brackets.S_QBLOCK2 = S_QBLOCK2;\n\n    return _brackets\n\n  })();\n\n  /**\n   * @module tmpl\n   *\n   * tmpl          - Root function, returns the template value, render with data\n   * tmpl.hasExpr  - Test the existence of a expression inside a string\n   * tmpl.loopKeys - Get the keys for an 'each' loop (used by `_each`)\n   */\n\n  /* istanbul ignore next */\n  var tmpl = (function () {\n\n    var _cache = {};\n\n    function _tmpl (str, data) {\n      if (!str) { return str }\n\n      return (_cache[str] || (_cache[str] = _create(str))).call(\n        data, _logErr.bind({\n          data: data,\n          tmpl: str\n        })\n      )\n    }\n\n    _tmpl.hasExpr = brackets.hasExpr;\n\n    _tmpl.loopKeys = brackets.loopKeys;\n\n    // istanbul ignore next\n    _tmpl.clearCache = function () { _cache = {}; };\n\n    _tmpl.errorHandler = null;\n\n    function _logErr (err, ctx) {\n\n      err.riotData = {\n        tagName: ctx && ctx.__ && ctx.__.tagName,\n        _riot_id: ctx && ctx._riot_id  //eslint-disable-line camelcase\n      };\n\n      if (_tmpl.errorHandler) { _tmpl.errorHandler(err); }\n      else if (\n        typeof console !== 'undefined' &&\n        typeof console.error === 'function'\n      ) {\n        console.error(err.message);\n        console.log('<%s> %s', err.riotData.tagName || 'Unknown tag', this.tmpl); // eslint-disable-line\n        console.log(this.data); // eslint-disable-line\n      }\n    }\n\n    function _create (str) {\n      var expr = _getTmpl(str);\n\n      if (expr.slice(0, 11) !== 'try{return ') { expr = 'return ' + expr; }\n\n      return new Function('E', expr + ';')    // eslint-disable-line no-new-func\n    }\n\n    var RE_DQUOTE = /\\u2057/g;\n    var RE_QBMARK = /\\u2057(\\d+)~/g;\n\n    function _getTmpl (str) {\n      var parts = brackets.split(str.replace(RE_DQUOTE, '\"'), 1);\n      var qstr = parts.qblocks;\n      var expr;\n\n      if (parts.length > 2 || parts[0]) {\n        var i, j, list = [];\n\n        for (i = j = 0; i < parts.length; ++i) {\n\n          expr = parts[i];\n\n          if (expr && (expr = i & 1\n\n              ? _parseExpr(expr, 1, qstr)\n\n              : '\"' + expr\n                  .replace(/\\\\/g, '\\\\\\\\')\n                  .replace(/\\r\\n?|\\n/g, '\\\\n')\n                  .replace(/\"/g, '\\\\\"') +\n                '\"'\n\n            )) { list[j++] = expr; }\n\n        }\n\n        expr = j < 2 ? list[0]\n             : '[' + list.join(',') + '].join(\"\")';\n\n      } else {\n\n        expr = _parseExpr(parts[1], 0, qstr);\n      }\n\n      if (qstr.length) {\n        expr = expr.replace(RE_QBMARK, function (_, pos) {\n          return qstr[pos]\n            .replace(/\\r/g, '\\\\r')\n            .replace(/\\n/g, '\\\\n')\n        });\n      }\n      return expr\n    }\n\n    var RE_CSNAME = /^(?:(-?[_A-Za-z\\xA0-\\xFF][-\\w\\xA0-\\xFF]*)|\\u2057(\\d+)~):/;\n    var\n      RE_BREND = {\n        '(': /[()]/g,\n        '[': /[[\\]]/g,\n        '{': /[{}]/g\n      };\n\n    function _parseExpr (expr, asText, qstr) {\n\n      expr = expr\n        .replace(/\\s+/g, ' ').trim()\n        .replace(/\\ ?([[\\({},?\\.:])\\ ?/g, '$1');\n\n      if (expr) {\n        var\n          list = [],\n          cnt = 0,\n          match;\n\n        while (expr &&\n              (match = expr.match(RE_CSNAME)) &&\n              !match.index\n          ) {\n          var\n            key,\n            jsb,\n            re = /,|([[{(])|$/g;\n\n          expr = RegExp.rightContext;\n          key  = match[2] ? qstr[match[2]].slice(1, -1).trim().replace(/\\s+/g, ' ') : match[1];\n\n          while (jsb = (match = re.exec(expr))[1]) { skipBraces(jsb, re); }\n\n          jsb  = expr.slice(0, match.index);\n          expr = RegExp.rightContext;\n\n          list[cnt++] = _wrapExpr(jsb, 1, key);\n        }\n\n        expr = !cnt ? _wrapExpr(expr, asText)\n             : cnt > 1 ? '[' + list.join(',') + '].join(\" \").trim()' : list[0];\n      }\n      return expr\n\n      function skipBraces (ch, re) {\n        var\n          mm,\n          lv = 1,\n          ir = RE_BREND[ch];\n\n        ir.lastIndex = re.lastIndex;\n        while (mm = ir.exec(expr)) {\n          if (mm[0] === ch) { ++lv; }\n          else if (!--lv) { break }\n        }\n        re.lastIndex = lv ? expr.length : ir.lastIndex;\n      }\n    }\n\n    // istanbul ignore next: not both\n    var // eslint-disable-next-line max-len\n      JS_CONTEXT = '\"in this?this:' + (typeof window !== 'object' ? 'global' : 'window') + ').',\n      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,\n      JS_NOPROPS = /^(?=(\\.[$\\w]+))\\1(?:[^.[(]|$)/;\n\n    function _wrapExpr (expr, asText, key) {\n      var tb;\n\n      expr = expr.replace(JS_VARNAME, function (match, p, mvar, pos, s) {\n        if (mvar) {\n          pos = tb ? 0 : pos + match.length;\n\n          if (mvar !== 'this' && mvar !== 'global' && mvar !== 'window') {\n            match = p + '(\"' + mvar + JS_CONTEXT + mvar;\n            if (pos) { tb = (s = s[pos]) === '.' || s === '(' || s === '['; }\n          } else if (pos) {\n            tb = !JS_NOPROPS.test(s.slice(pos));\n          }\n        }\n        return match\n      });\n\n      if (tb) {\n        expr = 'try{return ' + expr + '}catch(e){E(e,this)}';\n      }\n\n      if (key) {\n\n        expr = (tb\n            ? 'function(){' + expr + '}.call(this)' : '(' + expr + ')'\n          ) + '?\"' + key + '\":\"\"';\n\n      } else if (asText) {\n\n        expr = 'function(v){' + (tb\n            ? expr.replace('return ', 'v=') : 'v=(' + expr + ')'\n          ) + ';return v||v===0?v:\"\"}.call(this)';\n      }\n\n      return expr\n    }\n\n    _tmpl.version = brackets.version = 'v3.0.8';\n\n    return _tmpl\n\n  })();\n\n  /* istanbul ignore next */\n  var observable = function(el) {\n\n    /**\n     * Extend the original object or create a new empty one\n     * @type { Object }\n     */\n\n    el = el || {};\n\n    /**\n     * Private variables\n     */\n    var callbacks = {},\n      slice = Array.prototype.slice;\n\n    /**\n     * Public Api\n     */\n\n    // extend the el object adding the observable methods\n    Object.defineProperties(el, {\n      /**\n       * Listen to the given `event` ands\n       * execute the `callback` each time an event is triggered.\n       * @param  { String } event - event id\n       * @param  { Function } fn - callback function\n       * @returns { Object } el\n       */\n      on: {\n        value: function(event, fn) {\n          if (typeof fn == 'function')\n            { (callbacks[event] = callbacks[event] || []).push(fn); }\n          return el\n        },\n        enumerable: false,\n        writable: false,\n        configurable: false\n      },\n\n      /**\n       * Removes the given `event` listeners\n       * @param   { String } event - event id\n       * @param   { Function } fn - callback function\n       * @returns { Object } el\n       */\n      off: {\n        value: function(event, fn) {\n          if (event == '*' && !fn) { callbacks = {}; }\n          else {\n            if (fn) {\n              var arr = callbacks[event];\n              for (var i = 0, cb; cb = arr && arr[i]; ++i) {\n                if (cb == fn) { arr.splice(i--, 1); }\n              }\n            } else { delete callbacks[event]; }\n          }\n          return el\n        },\n        enumerable: false,\n        writable: false,\n        configurable: false\n      },\n\n      /**\n       * Listen to the given `event` and\n       * execute the `callback` at most once\n       * @param   { String } event - event id\n       * @param   { Function } fn - callback function\n       * @returns { Object } el\n       */\n      one: {\n        value: function(event, fn) {\n          function on() {\n            el.off(event, on);\n            fn.apply(el, arguments);\n          }\n          return el.on(event, on)\n        },\n        enumerable: false,\n        writable: false,\n        configurable: false\n      },\n\n      /**\n       * Execute all callback functions that listen to\n       * the given `event`\n       * @param   { String } event - event id\n       * @returns { Object } el\n       */\n      trigger: {\n        value: function(event) {\n          var arguments$1 = arguments;\n\n\n          // getting the arguments\n          var arglen = arguments.length - 1,\n            args = new Array(arglen),\n            fns,\n            fn,\n            i;\n\n          for (i = 0; i < arglen; i++) {\n            args[i] = arguments$1[i + 1]; // skip first argument\n          }\n\n          fns = slice.call(callbacks[event] || [], 0);\n\n          for (i = 0; fn = fns[i]; ++i) {\n            fn.apply(el, args);\n          }\n\n          if (callbacks['*'] && event != '*')\n            { el.trigger.apply(el, ['*', event].concat(args)); }\n\n          return el\n        },\n        enumerable: false,\n        writable: false,\n        configurable: false\n      }\n    });\n\n    return el\n\n  };\n\n  /**\n   * Short alias for Object.getOwnPropertyDescriptor\n   */\n  function getPropDescriptor (o, k) {\n    return Object.getOwnPropertyDescriptor(o, k)\n  }\n\n  /**\n   * Check if passed argument is undefined\n   * @param   { * } value -\n   * @returns { Boolean } -\n   */\n  function isUndefined(value) {\n    return typeof value === T_UNDEF\n  }\n\n  /**\n   * Check whether object's property could be overridden\n   * @param   { Object }  obj - source object\n   * @param   { String }  key - object property\n   * @returns { Boolean } true if writable\n   */\n  function isWritable(obj, key) {\n    var descriptor = getPropDescriptor(obj, key);\n    return isUndefined(obj[key]) || descriptor && descriptor.writable\n  }\n\n  /**\n   * Extend any object with other properties\n   * @param   { Object } src - source object\n   * @returns { Object } the resulting extended object\n   *\n   * var obj = { foo: 'baz' }\n   * extend(obj, {bar: 'bar', foo: 'bar'})\n   * console.log(obj) => {bar: 'bar', foo: 'bar'}\n   *\n   */\n  function extend(src) {\n    var obj;\n    var i = 1;\n    var args = arguments;\n    var l = args.length;\n\n    for (; i < l; i++) {\n      if (obj = args[i]) {\n        for (var key in obj) {\n          // check if this property of the source object could be overridden\n          if (isWritable(src, key))\n            { src[key] = obj[key]; }\n        }\n      }\n    }\n    return src\n  }\n\n  /**\n   * Alias for Object.create\n   */\n  function create(src) {\n    return Object.create(src)\n  }\n\n  var settings = extend(create(brackets.settings), {\n    skipAnonymousTags: true,\n    // the \"value\" attributes will be preserved\n    keepValueAttributes: false,\n    // handle the auto updates on any DOM event\n    autoUpdate: true\n  });\n\n  /**\n   * Shorter and fast way to select multiple nodes in the DOM\n   * @param   { String } selector - DOM selector\n   * @param   { Object } ctx - DOM node where the targets of our search will is located\n   * @returns { Object } dom nodes found\n   */\n  function $$(selector, ctx) {\n    return [].slice.call((ctx || document).querySelectorAll(selector))\n  }\n\n  /**\n   * Create a document text node\n   * @returns { Object } create a text node to use as placeholder\n   */\n  function createDOMPlaceholder() {\n    return document.createTextNode('')\n  }\n\n  /**\n   * Toggle the visibility of any DOM node\n   * @param   { Object }  dom - DOM node we want to hide\n   * @param   { Boolean } show - do we want to show it?\n   */\n\n  function toggleVisibility(dom, show) {\n    dom.style.display = show ? '' : 'none';\n    dom.hidden = show ? false : true;\n  }\n\n  /**\n   * Get the value of any DOM attribute on a node\n   * @param   { Object } dom - DOM node we want to parse\n   * @param   { String } name - name of the attribute we want to get\n   * @returns { String | undefined } name of the node attribute whether it exists\n   */\n  function getAttribute(dom, name) {\n    return dom.getAttribute(name)\n  }\n\n  /**\n   * Remove any DOM attribute from a node\n   * @param   { Object } dom - DOM node we want to update\n   * @param   { String } name - name of the property we want to remove\n   */\n  function removeAttribute(dom, name) {\n    dom.removeAttribute(name);\n  }\n\n  /**\n   * Set the inner html of any DOM node SVGs included\n   * @param { Object } container - DOM node where we'll inject new html\n   * @param { String } html - html to inject\n   * @param { Boolean } isSvg - svg tags should be treated a bit differently\n   */\n  /* istanbul ignore next */\n  function setInnerHTML(container, html, isSvg) {\n    // innerHTML is not supported on svg tags so we neet to treat them differently\n    if (isSvg) {\n      var node = container.ownerDocument.importNode(\n        new DOMParser()\n          .parseFromString((\"<svg xmlns=\\\"\" + SVG_NS + \"\\\">\" + html + \"</svg>\"), 'application/xml')\n          .documentElement,\n        true\n      );\n\n      container.appendChild(node);\n    } else {\n      container.innerHTML = html;\n    }\n  }\n\n  /**\n   * Minimize risk: only zero or one _space_ between attr & value\n   * @param   { String }   html - html string we want to parse\n   * @param   { Function } fn - callback function to apply on any attribute found\n   */\n  function walkAttributes(html, fn) {\n    if (!html) { return }\n    var m;\n    while (m = RE_HTML_ATTRS.exec(html))\n      { fn(m[1].toLowerCase(), m[2] || m[3] || m[4]); }\n  }\n\n  /**\n   * Create a document fragment\n   * @returns { Object } document fragment\n   */\n  function createFragment() {\n    return document.createDocumentFragment()\n  }\n\n  /**\n   * Insert safely a tag to fix #1962 #1649\n   * @param   { HTMLElement } root - children container\n   * @param   { HTMLElement } curr - node to insert\n   * @param   { HTMLElement } next - node that should preceed the current node inserted\n   */\n  function safeInsert(root, curr, next) {\n    root.insertBefore(curr, next.parentNode && next);\n  }\n\n  /**\n   * Convert a style object to a string\n   * @param   { Object } style - style object we need to parse\n   * @returns { String } resulting css string\n   * @example\n   * styleObjectToString({ color: 'red', height: '10px'}) // => 'color: red; height: 10px'\n   */\n  function styleObjectToString(style) {\n    return Object.keys(style).reduce(function (acc, prop) {\n      return (acc + \" \" + prop + \": \" + (style[prop]) + \";\")\n    }, '')\n  }\n\n  /**\n   * Walk down recursively all the children tags starting dom node\n   * @param   { Object }   dom - starting node where we will start the recursion\n   * @param   { Function } fn - callback to transform the child node just found\n   * @param   { Object }   context - fn can optionally return an object, which is passed to children\n   */\n  function walkNodes(dom, fn, context) {\n    if (dom) {\n      var res = fn(dom, context);\n      var next;\n      // stop the recursion\n      if (res === false) { return }\n\n      dom = dom.firstChild;\n\n      while (dom) {\n        next = dom.nextSibling;\n        walkNodes(dom, fn, res);\n        dom = next;\n      }\n    }\n  }\n\n\n\n  var dom = /*#__PURE__*/Object.freeze({\n    $$: $$,\n    $: $,\n    createDOMPlaceholder: createDOMPlaceholder,\n    mkEl: makeElement,\n    setAttr: setAttribute,\n    toggleVisibility: toggleVisibility,\n    getAttr: getAttribute,\n    remAttr: removeAttribute,\n    setInnerHTML: setInnerHTML,\n    walkAttrs: walkAttributes,\n    createFrag: createFragment,\n    safeInsert: safeInsert,\n    styleObjectToString: styleObjectToString,\n    walkNodes: walkNodes\n  });\n\n  /**\n   * Check against the null and undefined values\n   * @param   { * }  value -\n   * @returns {Boolean} -\n   */\n  function isNil(value) {\n    return isUndefined(value) || value === null\n  }\n\n  /**\n   * Check if passed argument is empty. Different from falsy, because we dont consider 0 or false to be blank\n   * @param { * } value -\n   * @returns { Boolean } -\n   */\n  function isBlank(value) {\n    return isNil(value) || value === ''\n  }\n\n  /**\n   * Check if passed argument is a function\n   * @param   { * } value -\n   * @returns { Boolean } -\n   */\n  function isFunction(value) {\n    return typeof value === T_FUNCTION\n  }\n\n  /**\n   * Check if passed argument is an object, exclude null\n   * NOTE: use isObject(x) && !isArray(x) to excludes arrays.\n   * @param   { * } value -\n   * @returns { Boolean } -\n   */\n  function isObject(value) {\n    return value && typeof value === T_OBJECT // typeof null is 'object'\n  }\n\n  /**\n   * Check if a DOM node is an svg tag or part of an svg\n   * @param   { HTMLElement }  el - node we want to test\n   * @returns {Boolean} true if it's an svg node\n   */\n  function isSvg(el) {\n    var owner = el.ownerSVGElement;\n    return !!owner || owner === null\n  }\n\n  /**\n   * Check if passed argument is a kind of array\n   * @param   { * } value -\n   * @returns { Boolean } -\n   */\n  function isArray(value) {\n    return Array.isArray(value) || value instanceof Array\n  }\n\n  /**\n   * Check if the passed argument is a boolean attribute\n   * @param   { String } value -\n   * @returns { Boolean } -\n   */\n  function isBoolAttr(value) {\n    return RE_BOOL_ATTRS.test(value)\n  }\n\n  /**\n   * Check if passed argument is a string\n   * @param   { * } value -\n   * @returns { Boolean } -\n   */\n  function isString(value) {\n    return typeof value === T_STRING\n  }\n\n\n\n  var check = /*#__PURE__*/Object.freeze({\n    isBlank: isBlank,\n    isFunction: isFunction,\n    isObject: isObject,\n    isSvg: isSvg,\n    isWritable: isWritable,\n    isArray: isArray,\n    isBoolAttr: isBoolAttr,\n    isNil: isNil,\n    isString: isString,\n    isUndefined: isUndefined\n  });\n\n  /**\n   * Check whether an array contains an item\n   * @param   { Array } array - target array\n   * @param   { * } item - item to test\n   * @returns { Boolean } -\n   */\n  function contains(array, item) {\n    return array.indexOf(item) !== -1\n  }\n\n  /**\n   * Specialized function for looping an array-like collection with `each={}`\n   * @param   { Array } list - collection of items\n   * @param   {Function} fn - callback function\n   * @returns { Array } the array looped\n   */\n  function each(list, fn) {\n    var len = list ? list.length : 0;\n    var i = 0;\n    for (; i < len; i++) { fn(list[i], i); }\n    return list\n  }\n\n  /**\n   * Faster String startsWith alternative\n   * @param   { String } str - source string\n   * @param   { String } value - test string\n   * @returns { Boolean } -\n   */\n  function startsWith(str, value) {\n    return str.slice(0, value.length) === value\n  }\n\n  /**\n   * Function returning always a unique identifier\n   * @returns { Number } - number from 0...n\n   */\n  var uid = (function uid() {\n    var i = -1;\n    return function () { return ++i; }\n  })();\n\n  /**\n   * Helper function to set an immutable property\n   * @param   { Object } el - object where the new property will be set\n   * @param   { String } key - object key where the new property will be stored\n   * @param   { * } value - value of the new property\n   * @param   { Object } options - set the propery overriding the default options\n   * @returns { Object } - the initial object\n   */\n  function define(el, key, value, options) {\n    Object.defineProperty(el, key, extend({\n      value: value,\n      enumerable: false,\n      writable: false,\n      configurable: true\n    }, options));\n    return el\n  }\n\n  /**\n   * Convert a string containing dashes to camel case\n   * @param   { String } str - input string\n   * @returns { String } my-string -> myString\n   */\n  function toCamel(str) {\n    return str.replace(/-(\\w)/g, function (_, c) { return c.toUpperCase(); })\n  }\n\n  /**\n   * Warn a message via console\n   * @param   {String} message - warning message\n   */\n  function warn(message) {\n    if (console && console.warn) { console.warn(message); }\n  }\n\n\n\n  var misc = /*#__PURE__*/Object.freeze({\n    contains: contains,\n    each: each,\n    getPropDescriptor: getPropDescriptor,\n    startsWith: startsWith,\n    uid: uid,\n    defineProperty: define,\n    objectCreate: create,\n    extend: extend,\n    toCamel: toCamel,\n    warn: warn\n  });\n\n  /**\n   * Set the property of an object for a given key. If something already\n   * exists there, then it becomes an array containing both the old and new value.\n   * @param { Object } obj - object on which to set the property\n   * @param { String } key - property name\n   * @param { Object } value - the value of the property to be set\n   * @param { Boolean } ensureArray - ensure that the property remains an array\n   * @param { Number } index - add the new item in a certain array position\n   */\n  function arrayishAdd(obj, key, value, ensureArray, index) {\n    var dest = obj[key];\n    var isArr = isArray(dest);\n    var hasIndex = !isUndefined(index);\n\n    if (dest && dest === value) { return }\n\n    // if the key was never set, set it once\n    if (!dest && ensureArray) { obj[key] = [value]; }\n    else if (!dest) { obj[key] = value; }\n    // if it was an array and not yet set\n    else {\n      if (isArr) {\n        var oldIndex = dest.indexOf(value);\n        // this item never changed its position\n        if (oldIndex === index) { return }\n        // remove the item from its old position\n        if (oldIndex !== -1) { dest.splice(oldIndex, 1); }\n        // move or add the item\n        if (hasIndex) {\n          dest.splice(index, 0, value);\n        } else {\n          dest.push(value);\n        }\n      } else { obj[key] = [dest, value]; }\n    }\n  }\n\n  /**\n   * Detect the tag implementation by a DOM node\n   * @param   { Object } dom - DOM node we need to parse to get its tag implementation\n   * @returns { Object } it returns an object containing the implementation of a custom tag (template and boot function)\n   */\n  function get(dom) {\n    return dom.tagName && __TAG_IMPL[getAttribute(dom, IS_DIRECTIVE) ||\n      getAttribute(dom, IS_DIRECTIVE) || dom.tagName.toLowerCase()]\n  }\n\n  /**\n   * Get the tag name of any DOM node\n   * @param   { Object } dom - DOM node we want to parse\n   * @param   { Boolean } skipDataIs - hack to ignore the data-is attribute when attaching to parent\n   * @returns { String } name to identify this dom node in riot\n   */\n  function getName(dom, skipDataIs) {\n    var child = get(dom);\n    var namedTag = !skipDataIs && getAttribute(dom, IS_DIRECTIVE);\n    return namedTag && !tmpl.hasExpr(namedTag) ?\n      namedTag : child ? child.name : dom.tagName.toLowerCase()\n  }\n\n  /**\n   * Return a temporary context containing also the parent properties\n   * @this Tag\n   * @param { Tag } - temporary tag context containing all the parent properties\n   */\n  function inheritParentProps() {\n    if (this.parent) { return extend(create(this), this.parent) }\n    return this\n  }\n\n  /*\n    Includes hacks needed for the Internet Explorer version 9 and below\n    See: http://kangax.github.io/compat-table/es5/#ie8\n         http://codeplanet.io/dropping-ie8/\n  */\n\n  var\n    reHasYield  = /<yield\\b/i,\n    reYieldAll  = /<yield\\s*(?:\\/>|>([\\S\\s]*?)<\\/yield\\s*>|>)/ig,\n    reYieldSrc  = /<yield\\s+to=['\"]([^'\">]*)['\"]\\s*>([\\S\\s]*?)<\\/yield\\s*>/ig,\n    reYieldDest = /<yield\\s+from=['\"]?([-\\w]+)['\"]?\\s*(?:\\/>|>([\\S\\s]*?)<\\/yield\\s*>)/ig,\n    rootEls = { tr: 'tbody', th: 'tr', td: 'tr', col: 'colgroup' },\n    tblTags = IE_VERSION && IE_VERSION < 10 ? RE_SPECIAL_TAGS : RE_SPECIAL_TAGS_NO_OPTION,\n    GENERIC = 'div',\n    SVG = 'svg';\n\n\n  /*\n    Creates the root element for table or select child elements:\n    tr/th/td/thead/tfoot/tbody/caption/col/colgroup/option/optgroup\n  */\n  function specialTags(el, tmpl, tagName) {\n\n    var\n      select = tagName[0] === 'o',\n      parent = select ? 'select>' : 'table>';\n\n    // trim() is important here, this ensures we don't have artifacts,\n    // so we can check if we have only one element inside the parent\n    el.innerHTML = '<' + parent + tmpl.trim() + '</' + parent;\n    parent = el.firstChild;\n\n    // returns the immediate parent if tr/th/td/col is the only element, if not\n    // returns the whole tree, as this can include additional elements\n    /* istanbul ignore next */\n    if (select) {\n      parent.selectedIndex = -1;  // for IE9, compatible w/current riot behavior\n    } else {\n      // avoids insertion of cointainer inside container (ex: tbody inside tbody)\n      var tname = rootEls[tagName];\n      if (tname && parent.childElementCount === 1) { parent = $(tname, parent); }\n    }\n    return parent\n  }\n\n  /*\n    Replace the yield tag from any tag template with the innerHTML of the\n    original tag in the page\n  */\n  function replaceYield(tmpl, html) {\n    // do nothing if no yield\n    if (!reHasYield.test(tmpl)) { return tmpl }\n\n    // be careful with #1343 - string on the source having `$1`\n    var src = {};\n\n    html = html && html.replace(reYieldSrc, function (_, ref, text) {\n      src[ref] = src[ref] || text;   // preserve first definition\n      return ''\n    }).trim();\n\n    return tmpl\n      .replace(reYieldDest, function (_, ref, def) {  // yield with from - to attrs\n        return src[ref] || def || ''\n      })\n      .replace(reYieldAll, function (_, def) {        // yield without any \"from\"\n        return html || def || ''\n      })\n  }\n\n  /**\n   * Creates a DOM element to wrap the given content. Normally an `DIV`, but can be\n   * also a `TABLE`, `SELECT`, `TBODY`, `TR`, or `COLGROUP` element.\n   *\n   * @param   { String } tmpl  - The template coming from the custom tag definition\n   * @param   { String } html - HTML content that comes from the DOM element where you\n   *           will mount the tag, mostly the original tag in the page\n   * @param   { Boolean } isSvg - true if the root node is an svg\n   * @returns { HTMLElement } DOM element with _tmpl_ merged through `YIELD` with the _html_.\n   */\n  function mkdom(tmpl, html, isSvg) {\n    var match   = tmpl && tmpl.match(/^\\s*<([-\\w]+)/);\n    var  tagName = match && match[1].toLowerCase();\n    var el = makeElement(isSvg ? SVG : GENERIC);\n\n    // replace all the yield tags with the tag inner html\n    tmpl = replaceYield(tmpl, html);\n\n    /* istanbul ignore next */\n    if (tblTags.test(tagName))\n      { el = specialTags(el, tmpl, tagName); }\n    else\n      { setInnerHTML(el, tmpl, isSvg); }\n\n    return el\n  }\n\n  var EVENT_ATTR_RE = /^on/;\n\n  /**\n   * True if the event attribute starts with 'on'\n   * @param   { String } attribute - event attribute\n   * @returns { Boolean }\n   */\n  function isEventAttribute(attribute) {\n    return EVENT_ATTR_RE.test(attribute)\n  }\n\n  /**\n   * Loop backward all the parents tree to detect the first custom parent tag\n   * @param   { Object } tag - a Tag instance\n   * @returns { Object } the instance of the first custom parent tag found\n   */\n  function getImmediateCustomParent(tag) {\n    var ptag = tag;\n    while (ptag.__.isAnonymous) {\n      if (!ptag.parent) { break }\n      ptag = ptag.parent;\n    }\n    return ptag\n  }\n\n  /**\n   * Trigger DOM events\n   * @param   { HTMLElement } dom - dom element target of the event\n   * @param   { Function } handler - user function\n   * @param   { Object } e - event object\n   */\n  function handleEvent(dom, handler, e) {\n    var ptag = this.__.parent;\n    var item = this.__.item;\n\n    if (!item)\n      { while (ptag && !item) {\n        item = ptag.__.item;\n        ptag = ptag.__.parent;\n      } }\n\n    // override the event properties\n    /* istanbul ignore next */\n    if (isWritable(e, 'currentTarget')) { e.currentTarget = dom; }\n    /* istanbul ignore next */\n    if (isWritable(e, 'target')) { e.target = e.srcElement; }\n    /* istanbul ignore next */\n    if (isWritable(e, 'which')) { e.which = e.charCode || e.keyCode; }\n\n    e.item = item;\n\n    handler.call(this, e);\n\n    // avoid auto updates\n    if (!settings.autoUpdate) { return }\n\n    if (!e.preventUpdate) {\n      var p = getImmediateCustomParent(this);\n      // fixes #2083\n      if (p.isMounted) { p.update(); }\n    }\n  }\n\n  /**\n   * Attach an event to a DOM node\n   * @param { String } name - event name\n   * @param { Function } handler - event callback\n   * @param { Object } dom - dom node\n   * @param { Tag } tag - tag instance\n   */\n  function setEventHandler(name, handler, dom, tag) {\n    var eventName;\n    var cb = handleEvent.bind(tag, dom, handler);\n\n    // avoid to bind twice the same event\n    // possible fix for #2332\n    dom[name] = null;\n\n    // normalize event name\n    eventName = name.replace(RE_EVENTS_PREFIX, '');\n\n    // cache the listener into the listeners array\n    if (!contains(tag.__.listeners, dom)) { tag.__.listeners.push(dom); }\n    if (!dom[RIOT_EVENTS_KEY]) { dom[RIOT_EVENTS_KEY] = {}; }\n    if (dom[RIOT_EVENTS_KEY][name]) { dom.removeEventListener(eventName, dom[RIOT_EVENTS_KEY][name]); }\n\n    dom[RIOT_EVENTS_KEY][name] = cb;\n    dom.addEventListener(eventName, cb, false);\n  }\n\n  /**\n   * Create a new child tag including it correctly into its parent\n   * @param   { Object } child - child tag implementation\n   * @param   { Object } opts - tag options containing the DOM node where the tag will be mounted\n   * @param   { String } innerHTML - inner html of the child node\n   * @param   { Object } parent - instance of the parent tag including the child custom tag\n   * @returns { Object } instance of the new child tag just created\n   */\n  function initChild(child, opts, innerHTML, parent) {\n    var tag = createTag(child, opts, innerHTML);\n    var tagName = opts.tagName || getName(opts.root, true);\n    var ptag = getImmediateCustomParent(parent);\n    // fix for the parent attribute in the looped elements\n    define(tag, 'parent', ptag);\n    // store the real parent tag\n    // in some cases this could be different from the custom parent tag\n    // for example in nested loops\n    tag.__.parent = parent;\n\n    // add this tag to the custom parent tag\n    arrayishAdd(ptag.tags, tagName, tag);\n\n    // and also to the real parent tag\n    if (ptag !== parent)\n      { arrayishAdd(parent.tags, tagName, tag); }\n\n    return tag\n  }\n\n  /**\n   * Removes an item from an object at a given key. If the key points to an array,\n   * then the item is just removed from the array.\n   * @param { Object } obj - object on which to remove the property\n   * @param { String } key - property name\n   * @param { Object } value - the value of the property to be removed\n   * @param { Boolean } ensureArray - ensure that the property remains an array\n  */\n  function arrayishRemove(obj, key, value, ensureArray) {\n    if (isArray(obj[key])) {\n      var index = obj[key].indexOf(value);\n      if (index !== -1) { obj[key].splice(index, 1); }\n      if (!obj[key].length) { delete obj[key]; }\n      else if (obj[key].length === 1 && !ensureArray) { obj[key] = obj[key][0]; }\n    } else if (obj[key] === value)\n      { delete obj[key]; } // otherwise just delete the key\n  }\n\n  /**\n   * Adds the elements for a virtual tag\n   * @this Tag\n   * @param { Node } src - the node that will do the inserting or appending\n   * @param { Tag } target - only if inserting, insert before this tag's first child\n   */\n  function makeVirtual(src, target) {\n    var this$1 = this;\n\n    var head = createDOMPlaceholder();\n    var tail = createDOMPlaceholder();\n    var frag = createFragment();\n    var sib;\n    var el;\n\n    this.root.insertBefore(head, this.root.firstChild);\n    this.root.appendChild(tail);\n\n    this.__.head = el = head;\n    this.__.tail = tail;\n\n    while (el) {\n      sib = el.nextSibling;\n      frag.appendChild(el);\n      this$1.__.virts.push(el); // hold for unmounting\n      el = sib;\n    }\n\n    if (target)\n      { src.insertBefore(frag, target.__.head); }\n    else\n      { src.appendChild(frag); }\n  }\n\n  /**\n   * makes a tag virtual and replaces a reference in the dom\n   * @this Tag\n   * @param { tag } the tag to make virtual\n   * @param { ref } the dom reference location\n   */\n  function makeReplaceVirtual(tag, ref) {\n    if (!ref.parentNode) { return }\n    var frag = createFragment();\n    makeVirtual.call(tag, frag);\n    ref.parentNode.replaceChild(frag, ref);\n  }\n\n  /**\n   * Update dynamically created data-is tags with changing expressions\n   * @param { Object } expr - expression tag and expression info\n   * @param { Tag }    parent - parent for tag creation\n   * @param { String } tagName - tag implementation we want to use\n   */\n  function updateDataIs(expr, parent, tagName) {\n    var tag = expr.tag || expr.dom._tag;\n    var ref;\n\n    var ref$1 = tag ? tag.__ : {};\n    var head = ref$1.head;\n    var isVirtual = expr.dom.tagName === 'VIRTUAL';\n\n    if (tag && expr.tagName === tagName) {\n      tag.update();\n      return\n    }\n\n    // sync _parent to accommodate changing tagnames\n    if (tag) {\n      // need placeholder before unmount\n      if(isVirtual) {\n        ref = createDOMPlaceholder();\n        head.parentNode.insertBefore(ref, head);\n      }\n\n      tag.unmount(true);\n    }\n\n    // unable to get the tag name\n    if (!isString(tagName)) { return }\n\n    expr.impl = __TAG_IMPL[tagName];\n\n    // unknown implementation\n    if (!expr.impl) { return }\n\n    expr.tag = tag = initChild(\n      expr.impl, {\n        root: expr.dom,\n        parent: parent,\n        tagName: tagName\n      },\n      expr.dom.innerHTML,\n      parent\n    );\n\n    each(expr.attrs, function (a) { return setAttribute(tag.root, a.name, a.value); });\n    expr.tagName = tagName;\n    tag.mount();\n\n    // root exist first time, after use placeholder\n    if (isVirtual) { makeReplaceVirtual(tag, ref || tag.root); }\n\n    // parent is the placeholder tag, not the dynamic tag so clean up\n    parent.__.onUnmount = function () {\n      var delName = tag.opts.dataIs;\n      arrayishRemove(tag.parent.tags, delName, tag);\n      arrayishRemove(tag.__.parent.tags, delName, tag);\n      tag.unmount();\n    };\n  }\n\n  /**\n   * Nomalize any attribute removing the \"riot-\" prefix\n   * @param   { String } attrName - original attribute name\n   * @returns { String } valid html attribute name\n   */\n  function normalizeAttrName(attrName) {\n    if (!attrName) { return null }\n    attrName = attrName.replace(ATTRS_PREFIX, '');\n    if (CASE_SENSITIVE_ATTRIBUTES[attrName]) { attrName = CASE_SENSITIVE_ATTRIBUTES[attrName]; }\n    return attrName\n  }\n\n  /**\n   * Update on single tag expression\n   * @this Tag\n   * @param { Object } expr - expression logic\n   * @returns { undefined }\n   */\n  function updateExpression(expr) {\n    if (this.root && getAttribute(this.root,'virtualized')) { return }\n\n    var dom = expr.dom;\n    // remove the riot- prefix\n    var attrName = normalizeAttrName(expr.attr);\n    var isToggle = contains([SHOW_DIRECTIVE, HIDE_DIRECTIVE], attrName);\n    var isVirtual = expr.root && expr.root.tagName === 'VIRTUAL';\n    var ref = this.__;\n    var isAnonymous = ref.isAnonymous;\n    var parent = dom && (expr.parent || dom.parentNode);\n    var keepValueAttributes = settings.keepValueAttributes;\n    // detect the style attributes\n    var isStyleAttr = attrName === 'style';\n    var isClassAttr = attrName === 'class';\n    var isValueAttr = attrName === 'value';\n\n    var value;\n\n    // if it's a tag we could totally skip the rest\n    if (expr._riot_id) {\n      if (expr.__.wasCreated) {\n        expr.update();\n      // if it hasn't been mounted yet, do that now.\n      } else {\n        expr.mount();\n        if (isVirtual) {\n          makeReplaceVirtual(expr, expr.root);\n        }\n      }\n      return\n    }\n\n    // if this expression has the update method it means it can handle the DOM changes by itself\n    if (expr.update) { return expr.update() }\n\n    var context = isToggle && !isAnonymous ? inheritParentProps.call(this) : this;\n\n    // ...it seems to be a simple expression so we try to calculate its value\n    value = tmpl(expr.expr, context);\n\n    var hasValue = !isBlank(value);\n    var isObj = isObject(value);\n\n    // convert the style/class objects to strings\n    if (isObj) {\n      if (isClassAttr) {\n        value = tmpl(JSON.stringify(value), this);\n      } else if (isStyleAttr) {\n        value = styleObjectToString(value);\n      }\n    }\n\n    // remove original attribute\n    if (expr.attr &&\n        (\n          // the original attribute can be removed only if we are parsing the original expression\n          !expr.wasParsedOnce ||\n          // or its value is false\n          value === false ||\n          // or if its value is currently falsy...\n          // We will keep the \"value\" attributes if the \"keepValueAttributes\"\n          // is enabled though\n          (!hasValue && (!isValueAttr || isValueAttr && !keepValueAttributes))\n        )\n    ) {\n      // remove either riot-* attributes or just the attribute name\n      removeAttribute(dom, getAttribute(dom, expr.attr) ? expr.attr : attrName);\n    }\n\n    // for the boolean attributes we don't need the value\n    // we can convert it to checked=true to checked=checked\n    if (expr.bool) { value = value ? attrName : false; }\n    if (expr.isRtag) { return updateDataIs(expr, this, value) }\n    if (expr.wasParsedOnce && expr.value === value) { return }\n\n    // update the expression value\n    expr.value = value;\n    expr.wasParsedOnce = true;\n\n    // if the value is an object (and it's not a style or class attribute) we can not do much more with it\n    if (isObj && !isClassAttr && !isStyleAttr && !isToggle) { return }\n    // avoid to render undefined/null values\n    if (!hasValue) { value = ''; }\n\n    // textarea and text nodes have no attribute name\n    if (!attrName) {\n      // about #815 w/o replace: the browser converts the value to a string,\n      // the comparison by \"==\" does too, but not in the server\n      value += '';\n      // test for parent avoids error with invalid assignment to nodeValue\n      if (parent) {\n        // cache the parent node because somehow it will become null on IE\n        // on the next iteration\n        expr.parent = parent;\n        if (parent.tagName === 'TEXTAREA') {\n          parent.value = value;                    // #1113\n          if (!IE_VERSION) { dom.nodeValue = value; }  // #1625 IE throws here, nodeValue\n        }                                         // will be available on 'updated'\n        else { dom.nodeValue = value; }\n      }\n      return\n    }\n\n    switch (true) {\n    // handle events binding\n    case isFunction(value):\n      if (isEventAttribute(attrName)) {\n        setEventHandler(attrName, value, dom, this);\n      }\n      break\n    // show / hide\n    case isToggle:\n      toggleVisibility(dom, attrName === HIDE_DIRECTIVE ? !value : value);\n      break\n    // handle attributes\n    default:\n      if (expr.bool) {\n        dom[attrName] = value;\n      }\n\n      if (isValueAttr && dom.value !== value) {\n        dom.value = value;\n      } else if (hasValue && value !== false) {\n        setAttribute(dom, attrName, value);\n      }\n\n      // make sure that in case of style changes\n      // the element stays hidden\n      if (isStyleAttr && dom.hidden) { toggleVisibility(dom, false); }\n    }\n  }\n\n  /**\n   * Update all the expressions in a Tag instance\n   * @this Tag\n   * @param { Array } expressions - expression that must be re evaluated\n   */\n  function update(expressions) {\n    each(expressions, updateExpression.bind(this));\n  }\n\n  /**\n   * We need to update opts for this tag. That requires updating the expressions\n   * in any attributes on the tag, and then copying the result onto opts.\n   * @this Tag\n   * @param   {Boolean} isLoop - is it a loop tag?\n   * @param   { Tag }  parent - parent tag node\n   * @param   { Boolean }  isAnonymous - is it a tag without any impl? (a tag not registered)\n   * @param   { Object }  opts - tag options\n   * @param   { Array }  instAttrs - tag attributes array\n   */\n  function updateOpts(isLoop, parent, isAnonymous, opts, instAttrs) {\n    // isAnonymous `each` tags treat `dom` and `root` differently. In this case\n    // (and only this case) we don't need to do updateOpts, because the regular parse\n    // will update those attrs. Plus, isAnonymous tags don't need opts anyway\n    if (isLoop && isAnonymous) { return }\n    var ctx = isLoop ? inheritParentProps.call(this) : parent || this;\n\n    each(instAttrs, function (attr) {\n      if (attr.expr) { updateExpression.call(ctx, attr.expr); }\n      // normalize the attribute names\n      opts[toCamel(attr.name).replace(ATTRS_PREFIX, '')] = attr.expr ? attr.expr.value : attr.value;\n    });\n  }\n\n  /**\n   * Update the tag expressions and options\n   * @param { Tag } tag - tag object\n   * @param { * } data - data we want to use to extend the tag properties\n   * @param { Array } expressions - component expressions array\n   * @returns { Tag } the current tag instance\n   */\n  function componentUpdate(tag, data, expressions) {\n    var __ = tag.__;\n    var nextOpts = {};\n    var canTrigger = tag.isMounted && !__.skipAnonymous;\n\n    // inherit properties from the parent tag\n    if (__.isAnonymous && __.parent) { extend(tag, __.parent); }\n    extend(tag, data);\n\n    updateOpts.apply(tag, [__.isLoop, __.parent, __.isAnonymous, nextOpts, __.instAttrs]);\n\n    if (\n      canTrigger &&\n      tag.isMounted &&\n      isFunction(tag.shouldUpdate) && !tag.shouldUpdate(data, nextOpts)\n    ) {\n      return tag\n    }\n\n    extend(tag.opts, nextOpts);\n\n    if (canTrigger) { tag.trigger('update', data); }\n    update.call(tag, expressions);\n    if (canTrigger) { tag.trigger('updated'); }\n\n    return tag\n  }\n\n  /**\n   * Get selectors for tags\n   * @param   { Array } tags - tag names to select\n   * @returns { String } selector\n   */\n  function query(tags) {\n    // select all tags\n    if (!tags) {\n      var keys = Object.keys(__TAG_IMPL);\n      return keys + query(keys)\n    }\n\n    return tags\n      .filter(function (t) { return !/[^-\\w]/.test(t); })\n      .reduce(function (list, t) {\n        var name = t.trim().toLowerCase();\n        return list + \",[\" + IS_DIRECTIVE + \"=\\\"\" + name + \"\\\"]\"\n      }, '')\n  }\n\n  /**\n   * Another way to create a riot tag a bit more es6 friendly\n   * @param { HTMLElement } el - tag DOM selector or DOM node/s\n   * @param { Object } opts - tag logic\n   * @returns { Tag } new riot tag instance\n   */\n  function Tag(el, opts) {\n    // get the tag properties from the class constructor\n    var ref = this;\n    var name = ref.name;\n    var tmpl = ref.tmpl;\n    var css = ref.css;\n    var attrs = ref.attrs;\n    var onCreate = ref.onCreate;\n    // register a new tag and cache the class prototype\n    if (!__TAG_IMPL[name]) {\n      tag(name, tmpl, css, attrs, onCreate);\n      // cache the class constructor\n      __TAG_IMPL[name].class = this.constructor;\n    }\n\n    // mount the tag using the class instance\n    mount$1(el, name, opts, this);\n    // inject the component css\n    if (css) { styleManager.inject(); }\n\n    return this\n  }\n\n  /**\n   * Create a new riot tag implementation\n   * @param   { String }   name - name/id of the new riot tag\n   * @param   { String }   tmpl - tag template\n   * @param   { String }   css - custom tag css\n   * @param   { String }   attrs - root tag attributes\n   * @param   { Function } fn - user function\n   * @returns { String } name/id of the tag just created\n   */\n  function tag(name, tmpl, css, attrs, fn) {\n    if (isFunction(attrs)) {\n      fn = attrs;\n\n      if (/^[\\w-]+\\s?=/.test(css)) {\n        attrs = css;\n        css = '';\n      } else\n        { attrs = ''; }\n    }\n\n    if (css) {\n      if (isFunction(css))\n        { fn = css; }\n      else\n        { styleManager.add(css, name); }\n    }\n\n    name = name.toLowerCase();\n    __TAG_IMPL[name] = { name: name, tmpl: tmpl, attrs: attrs, fn: fn };\n\n    return name\n  }\n\n  /**\n   * Create a new riot tag implementation (for use by the compiler)\n   * @param   { String }   name - name/id of the new riot tag\n   * @param   { String }   tmpl - tag template\n   * @param   { String }   css - custom tag css\n   * @param   { String }   attrs - root tag attributes\n   * @param   { Function } fn - user function\n   * @returns { String } name/id of the tag just created\n   */\n  function tag2(name, tmpl, css, attrs, fn) {\n    if (css) { styleManager.add(css, name); }\n\n    __TAG_IMPL[name] = { name: name, tmpl: tmpl, attrs: attrs, fn: fn };\n\n    return name\n  }\n\n  /**\n   * Mount a tag using a specific tag implementation\n   * @param   { * } selector - tag DOM selector or DOM node/s\n   * @param   { String } tagName - tag implementation name\n   * @param   { Object } opts - tag logic\n   * @returns { Array } new tags instances\n   */\n  function mount(selector, tagName, opts) {\n    var tags = [];\n    var elem, allTags;\n\n    function pushTagsTo(root) {\n      if (root.tagName) {\n        var riotTag = getAttribute(root, IS_DIRECTIVE), tag;\n\n        // have tagName? force riot-tag to be the same\n        if (tagName && riotTag !== tagName) {\n          riotTag = tagName;\n          setAttribute(root, IS_DIRECTIVE, tagName);\n        }\n\n        tag = mount$1(\n          root,\n          riotTag || root.tagName.toLowerCase(),\n          isFunction(opts) ? opts() : opts\n        );\n\n        if (tag)\n          { tags.push(tag); }\n      } else if (root.length)\n        { each(root, pushTagsTo); } // assume nodeList\n    }\n\n    // inject styles into DOM\n    styleManager.inject();\n\n    if (isObject(tagName) || isFunction(tagName)) {\n      opts = tagName;\n      tagName = 0;\n    }\n\n    // crawl the DOM to find the tag\n    if (isString(selector)) {\n      selector = selector === '*' ?\n        // select all registered tags\n        // & tags found with the riot-tag attribute set\n        allTags = query() :\n        // or just the ones named like the selector\n        selector + query(selector.split(/, */));\n\n      // make sure to pass always a selector\n      // to the querySelectorAll function\n      elem = selector ? $$(selector) : [];\n    }\n    else\n      // probably you have passed already a tag or a NodeList\n      { elem = selector; }\n\n    // select all the registered and mount them inside their root elements\n    if (tagName === '*') {\n      // get all custom tags\n      tagName = allTags || query();\n      // if the root els it's just a single tag\n      if (elem.tagName)\n        { elem = $$(tagName, elem); }\n      else {\n        // select all the children for all the different root elements\n        var nodeList = [];\n\n        each(elem, function (_el) { return nodeList.push($$(tagName, _el)); });\n\n        elem = nodeList;\n      }\n      // get rid of the tagName\n      tagName = 0;\n    }\n\n    pushTagsTo(elem);\n\n    return tags\n  }\n\n  // Create a mixin that could be globally shared across all the tags\n  var mixins = {};\n  var globals = mixins[GLOBAL_MIXIN] = {};\n  var mixins_id = 0;\n\n  /**\n   * Create/Return a mixin by its name\n   * @param   { String }  name - mixin name (global mixin if object)\n   * @param   { Object }  mix - mixin logic\n   * @param   { Boolean } g - is global?\n   * @returns { Object }  the mixin logic\n   */\n  function mixin(name, mix, g) {\n    // Unnamed global\n    if (isObject(name)) {\n      mixin((\"__\" + (mixins_id++) + \"__\"), name, true);\n      return\n    }\n\n    var store = g ? globals : mixins;\n\n    // Getter\n    if (!mix) {\n      if (isUndefined(store[name]))\n        { throw new Error((\"Unregistered mixin: \" + name)) }\n\n      return store[name]\n    }\n\n    // Setter\n    store[name] = isFunction(mix) ?\n      extend(mix.prototype, store[name] || {}) && mix :\n      extend(store[name] || {}, mix);\n  }\n\n  /**\n   * Update all the tags instances created\n   * @returns { Array } all the tags instances\n   */\n  function update$1() {\n    return each(__TAGS_CACHE, function (tag) { return tag.update(); })\n  }\n\n  function unregister(name) {\n    styleManager.remove(name);\n    return delete __TAG_IMPL[name]\n  }\n\n  var version = 'v3.13.2';\n\n  var core = /*#__PURE__*/Object.freeze({\n    Tag: Tag,\n    tag: tag,\n    tag2: tag2,\n    mount: mount,\n    mixin: mixin,\n    update: update$1,\n    unregister: unregister,\n    version: version\n  });\n\n  /**\n   * Add a mixin to this tag\n   * @returns { Tag } the current tag instance\n   */\n  function componentMixin(tag$$1) {\n    var mixins = [], len = arguments.length - 1;\n    while ( len-- > 0 ) mixins[ len ] = arguments[ len + 1 ];\n\n    each(mixins, function (mix) {\n      var instance;\n      var obj;\n      var props = [];\n\n      // properties blacklisted and will not be bound to the tag instance\n      var propsBlacklist = ['init', '__proto__'];\n\n      mix = isString(mix) ? mixin(mix) : mix;\n\n      // check if the mixin is a function\n      if (isFunction(mix)) {\n        // create the new mixin instance\n        instance = new mix();\n      } else { instance = mix; }\n\n      var proto = Object.getPrototypeOf(instance);\n\n      // build multilevel prototype inheritance chain property list\n      do { props = props.concat(Object.getOwnPropertyNames(obj || instance)); }\n      while (obj = Object.getPrototypeOf(obj || instance))\n\n      // loop the keys in the function prototype or the all object keys\n      each(props, function (key) {\n        // bind methods to tag\n        // allow mixins to override other properties/parent mixins\n        if (!contains(propsBlacklist, key)) {\n          // check for getters/setters\n          var descriptor = getPropDescriptor(instance, key) || getPropDescriptor(proto, key);\n          var hasGetterSetter = descriptor && (descriptor.get || descriptor.set);\n\n          // apply method only if it does not already exist on the instance\n          if (!tag$$1.hasOwnProperty(key) && hasGetterSetter) {\n            Object.defineProperty(tag$$1, key, descriptor);\n          } else {\n            tag$$1[key] = isFunction(instance[key]) ?\n              instance[key].bind(tag$$1) :\n              instance[key];\n          }\n        }\n      });\n\n      // init method will be called automatically\n      if (instance.init)\n        { instance.init.bind(tag$$1)(tag$$1.opts); }\n    });\n\n    return tag$$1\n  }\n\n  /**\n   * Move the position of a custom tag in its parent tag\n   * @this Tag\n   * @param   { String } tagName - key where the tag was stored\n   * @param   { Number } newPos - index where the new tag will be stored\n   */\n  function moveChild(tagName, newPos) {\n    var parent = this.parent;\n    var tags;\n    // no parent no move\n    if (!parent) { return }\n\n    tags = parent.tags[tagName];\n\n    if (isArray(tags))\n      { tags.splice(newPos, 0, tags.splice(tags.indexOf(this), 1)[0]); }\n    else { arrayishAdd(parent.tags, tagName, this); }\n  }\n\n  /**\n   * Move virtual tag and all child nodes\n   * @this Tag\n   * @param { Node } src  - the node that will do the inserting\n   * @param { Tag } target - insert before this tag's first child\n   */\n  function moveVirtual(src, target) {\n    var this$1 = this;\n\n    var el = this.__.head;\n    var sib;\n    var frag = createFragment();\n\n    while (el) {\n      sib = el.nextSibling;\n      frag.appendChild(el);\n      el = sib;\n      if (el === this$1.__.tail) {\n        frag.appendChild(el);\n        src.insertBefore(frag, target.__.head);\n        break\n      }\n    }\n  }\n\n  /**\n   * Convert the item looped into an object used to extend the child tag properties\n   * @param   { Object } expr - object containing the keys used to extend the children tags\n   * @param   { * } key - value to assign to the new object returned\n   * @param   { * } val - value containing the position of the item in the array\n   * @returns { Object } - new object containing the values of the original item\n   *\n   * The variables 'key' and 'val' are arbitrary.\n   * They depend on the collection type looped (Array, Object)\n   * and on the expression used on the each tag\n   *\n   */\n  function mkitem(expr, key, val) {\n    var item = {};\n    item[expr.key] = key;\n    if (expr.pos) { item[expr.pos] = val; }\n    return item\n  }\n\n  /**\n   * Unmount the redundant tags\n   * @param   { Array } items - array containing the current items to loop\n   * @param   { Array } tags - array containing all the children tags\n   */\n  function unmountRedundant(items, tags, filteredItemsCount) {\n    var i = tags.length;\n    var j = items.length - filteredItemsCount;\n\n    while (i > j) {\n      i--;\n      remove.apply(tags[i], [tags, i]);\n    }\n  }\n\n\n  /**\n   * Remove a child tag\n   * @this Tag\n   * @param   { Array } tags - tags collection\n   * @param   { Number } i - index of the tag to remove\n   */\n  function remove(tags, i) {\n    tags.splice(i, 1);\n    this.unmount();\n    arrayishRemove(this.parent, this, this.__.tagName, true);\n  }\n\n  /**\n   * Move the nested custom tags in non custom loop tags\n   * @this Tag\n   * @param   { Number } i - current position of the loop tag\n   */\n  function moveNestedTags(i) {\n    var this$1 = this;\n\n    each(Object.keys(this.tags), function (tagName) {\n      moveChild.apply(this$1.tags[tagName], [tagName, i]);\n    });\n  }\n\n  /**\n   * Move a child tag\n   * @this Tag\n   * @param   { HTMLElement } root - dom node containing all the loop children\n   * @param   { Tag } nextTag - instance of the next tag preceding the one we want to move\n   * @param   { Boolean } isVirtual - is it a virtual tag?\n   */\n  function move(root, nextTag, isVirtual) {\n    if (isVirtual)\n      { moveVirtual.apply(this, [root, nextTag]); }\n    else\n      { safeInsert(root, this.root, nextTag.root); }\n  }\n\n  /**\n   * Insert and mount a child tag\n   * @this Tag\n   * @param   { HTMLElement } root - dom node containing all the loop children\n   * @param   { Tag } nextTag - instance of the next tag preceding the one we want to insert\n   * @param   { Boolean } isVirtual - is it a virtual tag?\n   */\n  function insert(root, nextTag, isVirtual) {\n    if (isVirtual)\n      { makeVirtual.apply(this, [root, nextTag]); }\n    else\n      { safeInsert(root, this.root, nextTag.root); }\n  }\n\n  /**\n   * Append a new tag into the DOM\n   * @this Tag\n   * @param   { HTMLElement } root - dom node containing all the loop children\n   * @param   { Boolean } isVirtual - is it a virtual tag?\n   */\n  function append(root, isVirtual) {\n    if (isVirtual)\n      { makeVirtual.call(this, root); }\n    else\n      { root.appendChild(this.root); }\n  }\n\n  /**\n   * Return the value we want to use to lookup the postion of our items in the collection\n   * @param   { String }  keyAttr         - lookup string or expression\n   * @param   { * }       originalItem    - original item from the collection\n   * @param   { Object }  keyedItem       - object created by riot via { item, i in collection }\n   * @param   { Boolean } hasKeyAttrExpr  - flag to check whether the key is an expression\n   * @returns { * } value that we will use to figure out the item position via collection.indexOf\n   */\n  function getItemId(keyAttr, originalItem, keyedItem, hasKeyAttrExpr) {\n    if (keyAttr) {\n      return hasKeyAttrExpr ?  tmpl(keyAttr, keyedItem) :  originalItem[keyAttr]\n    }\n\n    return originalItem\n  }\n\n  /**\n   * Manage tags having the 'each'\n   * @param   { HTMLElement } dom - DOM node we need to loop\n   * @param   { Tag } parent - parent tag instance where the dom node is contained\n   * @param   { String } expr - string contained in the 'each' attribute\n   * @returns { Object } expression object for this each loop\n   */\n  function _each(dom, parent, expr) {\n    var mustReorder = typeof getAttribute(dom, LOOP_NO_REORDER_DIRECTIVE) !== T_STRING || removeAttribute(dom, LOOP_NO_REORDER_DIRECTIVE);\n    var keyAttr = getAttribute(dom, KEY_DIRECTIVE);\n    var hasKeyAttrExpr = keyAttr ? tmpl.hasExpr(keyAttr) : false;\n    var tagName = getName(dom);\n    var impl = __TAG_IMPL[tagName];\n    var parentNode = dom.parentNode;\n    var placeholder = createDOMPlaceholder();\n    var child = get(dom);\n    var ifExpr = getAttribute(dom, CONDITIONAL_DIRECTIVE);\n    var tags = [];\n    var isLoop = true;\n    var innerHTML = dom.innerHTML;\n    var isAnonymous = !__TAG_IMPL[tagName];\n    var isVirtual = dom.tagName === 'VIRTUAL';\n    var oldItems = [];\n\n    // remove the each property from the original tag\n    removeAttribute(dom, LOOP_DIRECTIVE);\n    removeAttribute(dom, KEY_DIRECTIVE);\n\n    // parse the each expression\n    expr = tmpl.loopKeys(expr);\n    expr.isLoop = true;\n\n    if (ifExpr) { removeAttribute(dom, CONDITIONAL_DIRECTIVE); }\n\n    // insert a marked where the loop tags will be injected\n    parentNode.insertBefore(placeholder, dom);\n    parentNode.removeChild(dom);\n\n    expr.update = function updateEach() {\n      // get the new items collection\n      expr.value = tmpl(expr.val, parent);\n\n      var items = expr.value;\n      var frag = createFragment();\n      var isObject = !isArray(items) && !isString(items);\n      var root = placeholder.parentNode;\n      var tmpItems = [];\n      var hasKeys = isObject && !!items;\n\n      // if this DOM was removed the update here is useless\n      // this condition fixes also a weird async issue on IE in our unit test\n      if (!root) { return }\n\n      // object loop. any changes cause full redraw\n      if (isObject) {\n        items = items ? Object.keys(items).map(function (key) { return mkitem(expr, items[key], key); }) : [];\n      }\n\n      // store the amount of filtered items\n      var filteredItemsCount = 0;\n\n      // loop all the new items\n      each(items, function (_item, index) {\n        var i = index - filteredItemsCount;\n        var item = !hasKeys && expr.key ? mkitem(expr, _item, index) : _item;\n\n        // skip this item because it must be filtered\n        if (ifExpr && !tmpl(ifExpr, extend(create(parent), item))) {\n          filteredItemsCount ++;\n          return\n        }\n\n        var itemId = getItemId(keyAttr, _item, item, hasKeyAttrExpr);\n        // reorder only if the items are not objects\n        // or a key attribute has been provided\n        var doReorder = !isObject && mustReorder && typeof _item === T_OBJECT || keyAttr;\n        var oldPos = oldItems.indexOf(itemId);\n        var isNew = oldPos === -1;\n        var pos = !isNew && doReorder ? oldPos : i;\n        // does a tag exist in this position?\n        var tag = tags[pos];\n        var mustAppend = i >= oldItems.length;\n        var mustCreate = doReorder && isNew || !doReorder && !tag || !tags[i];\n\n        // new tag\n        if (mustCreate) {\n          tag = createTag(impl, {\n            parent: parent,\n            isLoop: isLoop,\n            isAnonymous: isAnonymous,\n            tagName: tagName,\n            root: dom.cloneNode(isAnonymous),\n            item: item,\n            index: i,\n          }, innerHTML);\n\n          // mount the tag\n          tag.mount();\n\n          if (mustAppend)\n            { append.apply(tag, [frag || root, isVirtual]); }\n          else\n            { insert.apply(tag, [root, tags[i], isVirtual]); }\n\n          if (!mustAppend) { oldItems.splice(i, 0, item); }\n          tags.splice(i, 0, tag);\n          if (child) { arrayishAdd(parent.tags, tagName, tag, true); }\n        } else if (pos !== i && doReorder) {\n          // move\n          if (keyAttr || contains(items, oldItems[pos])) {\n            move.apply(tag, [root, tags[i], isVirtual]);\n            // move the old tag instance\n            tags.splice(i, 0, tags.splice(pos, 1)[0]);\n            // move the old item\n            oldItems.splice(i, 0, oldItems.splice(pos, 1)[0]);\n          }\n\n          // update the position attribute if it exists\n          if (expr.pos) { tag[expr.pos] = i; }\n\n          // if the loop tags are not custom\n          // we need to move all their custom tags into the right position\n          if (!child && tag.tags) { moveNestedTags.call(tag, i); }\n        }\n\n        // cache the original item to use it in the events bound to this node\n        // and its children\n        extend(tag.__, {\n          item: item,\n          index: i,\n          parent: parent\n        });\n\n        tmpItems[i] = itemId;\n\n        if (!mustCreate) { tag.update(item); }\n      });\n\n      // remove the redundant tags\n      unmountRedundant(items, tags, filteredItemsCount);\n\n      // clone the items array\n      oldItems = tmpItems.slice();\n\n      root.insertBefore(frag, placeholder);\n    };\n\n    expr.unmount = function () {\n      each(tags, function (t) { t.unmount(); });\n    };\n\n    return expr\n  }\n\n  var RefExpr = {\n    init: function init(dom, parent, attrName, attrValue) {\n      this.dom = dom;\n      this.attr = attrName;\n      this.rawValue = attrValue;\n      this.parent = parent;\n      this.hasExp = tmpl.hasExpr(attrValue);\n      return this\n    },\n    update: function update() {\n      var old = this.value;\n      var customParent = this.parent && getImmediateCustomParent(this.parent);\n      // if the referenced element is a custom tag, then we set the tag itself, rather than DOM\n      var tagOrDom = this.dom.__ref || this.tag || this.dom;\n\n      this.value = this.hasExp ? tmpl(this.rawValue, this.parent) : this.rawValue;\n\n      // the name changed, so we need to remove it from the old key (if present)\n      if (!isBlank(old) && customParent) { arrayishRemove(customParent.refs, old, tagOrDom); }\n      if (!isBlank(this.value) && isString(this.value)) {\n        // add it to the refs of parent tag (this behavior was changed >=3.0)\n        if (customParent) { arrayishAdd(\n          customParent.refs,\n          this.value,\n          tagOrDom,\n          // use an array if it's a looped node and the ref is not an expression\n          null,\n          this.parent.__.index\n        ); }\n\n        if (this.value !== old) {\n          setAttribute(this.dom, this.attr, this.value);\n        }\n      } else {\n        removeAttribute(this.dom, this.attr);\n      }\n\n      // cache the ref bound to this dom node\n      // to reuse it in future (see also #2329)\n      if (!this.dom.__ref) { this.dom.__ref = tagOrDom; }\n    },\n    unmount: function unmount() {\n      var tagOrDom = this.tag || this.dom;\n      var customParent = this.parent && getImmediateCustomParent(this.parent);\n      if (!isBlank(this.value) && customParent)\n        { arrayishRemove(customParent.refs, this.value, tagOrDom); }\n    }\n  };\n\n  /**\n   * Create a new ref directive\n   * @param   { HTMLElement } dom - dom node having the ref attribute\n   * @param   { Tag } context - tag instance where the DOM node is located\n   * @param   { String } attrName - either 'ref' or 'data-ref'\n   * @param   { String } attrValue - value of the ref attribute\n   * @returns { RefExpr } a new RefExpr object\n   */\n  function createRefDirective(dom, tag, attrName, attrValue) {\n    return create(RefExpr).init(dom, tag, attrName, attrValue)\n  }\n\n  /**\n   * Trigger the unmount method on all the expressions\n   * @param   { Array } expressions - DOM expressions\n   */\n  function unmountAll(expressions) {\n    each(expressions, function (expr) {\n      if (expr.unmount) { expr.unmount(true); }\n      else if (expr.tagName) { expr.tag.unmount(true); }\n      else if (expr.unmount) { expr.unmount(); }\n    });\n  }\n\n  var IfExpr = {\n    init: function init(dom, tag, expr) {\n      removeAttribute(dom, CONDITIONAL_DIRECTIVE);\n      extend(this, { tag: tag, expr: expr, stub: createDOMPlaceholder(), pristine: dom });\n      var p = dom.parentNode;\n      p.insertBefore(this.stub, dom);\n      p.removeChild(dom);\n\n      return this\n    },\n    update: function update$$1() {\n      this.value = tmpl(this.expr, this.tag);\n\n      if (!this.stub.parentNode) { return }\n\n      if (this.value && !this.current) { // insert\n        this.current = this.pristine.cloneNode(true);\n        this.stub.parentNode.insertBefore(this.current, this.stub);\n        this.expressions = parseExpressions.apply(this.tag, [this.current, true]);\n      } else if (!this.value && this.current) { // remove\n        this.unmount();\n        this.current = null;\n        this.expressions = [];\n      }\n\n      if (this.value) { update.call(this.tag, this.expressions); }\n    },\n    unmount: function unmount() {\n      if (this.current) {\n        if (this.current._tag) {\n          this.current._tag.unmount();\n        } else if (this.current.parentNode) {\n          this.current.parentNode.removeChild(this.current);\n        }\n      }\n\n      unmountAll(this.expressions || []);\n    }\n  };\n\n  /**\n   * Create a new if directive\n   * @param   { HTMLElement } dom - if root dom node\n   * @param   { Tag } context - tag instance where the DOM node is located\n   * @param   { String } attr - if expression\n   * @returns { IFExpr } a new IfExpr object\n   */\n  function createIfDirective(dom, tag, attr) {\n    return create(IfExpr).init(dom, tag, attr)\n  }\n\n  /**\n   * Walk the tag DOM to detect the expressions to evaluate\n   * @this Tag\n   * @param   { HTMLElement } root - root tag where we will start digging the expressions\n   * @param   { Boolean } mustIncludeRoot - flag to decide whether the root must be parsed as well\n   * @returns { Array } all the expressions found\n   */\n  function parseExpressions(root, mustIncludeRoot) {\n    var this$1 = this;\n\n    var expressions = [];\n\n    walkNodes(root, function (dom) {\n      var type = dom.nodeType;\n      var attr;\n      var tagImpl;\n\n      if (!mustIncludeRoot && dom === root) { return }\n\n      // text node\n      if (type === 3 && dom.parentNode.tagName !== 'STYLE' && tmpl.hasExpr(dom.nodeValue))\n        { expressions.push({dom: dom, expr: dom.nodeValue}); }\n\n      if (type !== 1) { return }\n\n      var isVirtual = dom.tagName === 'VIRTUAL';\n\n      // loop. each does it's own thing (for now)\n      if (attr = getAttribute(dom, LOOP_DIRECTIVE)) {\n        if(isVirtual) { setAttribute(dom, 'loopVirtual', true); } // ignore here, handled in _each\n        expressions.push(_each(dom, this$1, attr));\n        return false\n      }\n\n      // if-attrs become the new parent. Any following expressions (either on the current\n      // element, or below it) become children of this expression.\n      if (attr = getAttribute(dom, CONDITIONAL_DIRECTIVE)) {\n        expressions.push(createIfDirective(dom, this$1, attr));\n        return false\n      }\n\n      if (attr = getAttribute(dom, IS_DIRECTIVE)) {\n        if (tmpl.hasExpr(attr)) {\n          expressions.push({\n            isRtag: true,\n            expr: attr,\n            dom: dom,\n            attrs: [].slice.call(dom.attributes)\n          });\n\n          return false\n        }\n      }\n\n      // if this is a tag, stop traversing here.\n      // we ignore the root, since parseExpressions is called while we're mounting that root\n      tagImpl = get(dom);\n\n      if(isVirtual) {\n        if(getAttribute(dom, 'virtualized')) {dom.parentElement.removeChild(dom); } // tag created, remove from dom\n        if(!tagImpl && !getAttribute(dom, 'virtualized') && !getAttribute(dom, 'loopVirtual'))  // ok to create virtual tag\n          { tagImpl = { tmpl: dom.outerHTML }; }\n      }\n\n      if (tagImpl && (dom !== root || mustIncludeRoot)) {\n        var hasIsDirective = getAttribute(dom, IS_DIRECTIVE);\n        if(isVirtual && !hasIsDirective) { // handled in update\n          // can not remove attribute like directives\n          // so flag for removal after creation to prevent maximum stack error\n          setAttribute(dom, 'virtualized', true);\n          var tag = createTag(\n            {tmpl: dom.outerHTML},\n            {root: dom, parent: this$1},\n            dom.innerHTML\n          );\n\n          expressions.push(tag); // no return, anonymous tag, keep parsing\n        } else {\n          if (hasIsDirective && isVirtual)\n            { warn((\"Virtual tags shouldn't be used together with the \\\"\" + IS_DIRECTIVE + \"\\\" attribute - https://github.com/riot/riot/issues/2511\")); }\n\n          expressions.push(\n            initChild(\n              tagImpl,\n              {\n                root: dom,\n                parent: this$1\n              },\n              dom.innerHTML,\n              this$1\n            )\n          );\n          return false\n        }\n      }\n\n      // attribute expressions\n      parseAttributes.apply(this$1, [dom, dom.attributes, function (attr, expr) {\n        if (!expr) { return }\n        expressions.push(expr);\n      }]);\n    });\n\n    return expressions\n  }\n\n  /**\n   * Calls `fn` for every attribute on an element. If that attr has an expression,\n   * it is also passed to fn.\n   * @this Tag\n   * @param   { HTMLElement } dom - dom node to parse\n   * @param   { Array } attrs - array of attributes\n   * @param   { Function } fn - callback to exec on any iteration\n   */\n  function parseAttributes(dom, attrs, fn) {\n    var this$1 = this;\n\n    each(attrs, function (attr) {\n      if (!attr) { return false }\n\n      var name = attr.name;\n      var bool = isBoolAttr(name);\n      var expr;\n\n      if (contains(REF_DIRECTIVES, name) && dom.tagName.toLowerCase() !== YIELD_TAG) {\n        expr =  createRefDirective(dom, this$1, name, attr.value);\n      } else if (tmpl.hasExpr(attr.value)) {\n        expr = {dom: dom, expr: attr.value, attr: name, bool: bool};\n      }\n\n      fn(attr, expr);\n    });\n  }\n\n  /**\n   * Manage the mount state of a tag triggering also the observable events\n   * @this Tag\n   * @param { Boolean } value - ..of the isMounted flag\n   */\n  function setMountState(value) {\n    var ref = this.__;\n    var isAnonymous = ref.isAnonymous;\n    var skipAnonymous = ref.skipAnonymous;\n\n    define(this, 'isMounted', value);\n\n    if (!isAnonymous || !skipAnonymous) {\n      if (value) { this.trigger('mount'); }\n      else {\n        this.trigger('unmount');\n        this.off('*');\n        this.__.wasCreated = false;\n      }\n    }\n  }\n\n  /**\n   * Mount the current tag instance\n   * @returns { Tag } the current tag instance\n   */\n  function componentMount(tag$$1, dom, expressions, opts) {\n    var __ = tag$$1.__;\n    var root = __.root;\n    root._tag = tag$$1; // keep a reference to the tag just created\n\n    // Read all the attrs on this instance. This give us the info we need for updateOpts\n    parseAttributes.apply(__.parent, [root, root.attributes, function (attr, expr) {\n      if (!__.isAnonymous && RefExpr.isPrototypeOf(expr)) { expr.tag = tag$$1; }\n      attr.expr = expr;\n      __.instAttrs.push(attr);\n    }]);\n\n    // update the root adding custom attributes coming from the compiler\n    walkAttributes(__.impl.attrs, function (k, v) { __.implAttrs.push({name: k, value: v}); });\n    parseAttributes.apply(tag$$1, [root, __.implAttrs, function (attr, expr) {\n      if (expr) { expressions.push(expr); }\n      else { setAttribute(root, attr.name, attr.value); }\n    }]);\n\n    // initialiation\n    updateOpts.apply(tag$$1, [__.isLoop, __.parent, __.isAnonymous, opts, __.instAttrs]);\n\n    // add global mixins\n    var globalMixin = mixin(GLOBAL_MIXIN);\n\n    if (globalMixin && !__.skipAnonymous) {\n      for (var i in globalMixin) {\n        if (globalMixin.hasOwnProperty(i)) {\n          tag$$1.mixin(globalMixin[i]);\n        }\n      }\n    }\n\n    if (__.impl.fn) { __.impl.fn.call(tag$$1, opts); }\n\n    if (!__.skipAnonymous) { tag$$1.trigger('before-mount'); }\n\n    // parse layout after init. fn may calculate args for nested custom tags\n    each(parseExpressions.apply(tag$$1, [dom, __.isAnonymous]), function (e) { return expressions.push(e); });\n\n    tag$$1.update(__.item);\n\n    if (!__.isAnonymous && !__.isInline) {\n      while (dom.firstChild) { root.appendChild(dom.firstChild); }\n    }\n\n    define(tag$$1, 'root', root);\n\n    // if we need to wait that the parent \"mount\" or \"updated\" event gets triggered\n    if (!__.skipAnonymous && tag$$1.parent) {\n      var p = getImmediateCustomParent(tag$$1.parent);\n      p.one(!p.isMounted ? 'mount' : 'updated', function () {\n        setMountState.call(tag$$1, true);\n      });\n    } else {\n      // otherwise it's not a child tag we can trigger its mount event\n      setMountState.call(tag$$1, true);\n    }\n\n    tag$$1.__.wasCreated = true;\n\n    return tag$$1\n  }\n\n  /**\n   * Unmount the tag instance\n   * @param { Boolean } mustKeepRoot - if it's true the root node will not be removed\n   * @returns { Tag } the current tag instance\n   */\n  function tagUnmount(tag, mustKeepRoot, expressions) {\n    var __ = tag.__;\n    var root = __.root;\n    var tagIndex = __TAGS_CACHE.indexOf(tag);\n    var p = root.parentNode;\n\n    if (!__.skipAnonymous) { tag.trigger('before-unmount'); }\n\n    // clear all attributes coming from the mounted tag\n    walkAttributes(__.impl.attrs, function (name) {\n      if (startsWith(name, ATTRS_PREFIX))\n        { name = name.slice(ATTRS_PREFIX.length); }\n\n      removeAttribute(root, name);\n    });\n\n    // remove all the event listeners\n    tag.__.listeners.forEach(function (dom) {\n      Object.keys(dom[RIOT_EVENTS_KEY]).forEach(function (eventName) {\n        dom.removeEventListener(eventName, dom[RIOT_EVENTS_KEY][eventName]);\n      });\n    });\n\n    // remove tag instance from the global tags cache collection\n    if (tagIndex !== -1) { __TAGS_CACHE.splice(tagIndex, 1); }\n\n    // clean up the parent tags object\n    if (__.parent && !__.isAnonymous) {\n      var ptag = getImmediateCustomParent(__.parent);\n\n      if (__.isVirtual) {\n        Object\n          .keys(tag.tags)\n          .forEach(function (tagName) { return arrayishRemove(ptag.tags, tagName, tag.tags[tagName]); });\n      } else {\n        arrayishRemove(ptag.tags, __.tagName, tag);\n      }\n    }\n\n    // unmount all the virtual directives\n    if (tag.__.virts) {\n      each(tag.__.virts, function (v) {\n        if (v.parentNode) { v.parentNode.removeChild(v); }\n      });\n    }\n\n    // allow expressions to unmount themselves\n    unmountAll(expressions);\n    each(__.instAttrs, function (a) { return a.expr && a.expr.unmount && a.expr.unmount(); });\n\n    // clear the tag html if it's necessary\n    if (mustKeepRoot) { setInnerHTML(root, ''); }\n    // otherwise detach the root tag from the DOM\n    else if (p) { p.removeChild(root); }\n\n    // custom internal unmount function to avoid relying on the observable\n    if (__.onUnmount) { __.onUnmount(); }\n\n    // weird fix for a weird edge case #2409 and #2436\n    // some users might use your software not as you've expected\n    // so I need to add these dirty hacks to mitigate unexpected issues\n    if (!tag.isMounted) { setMountState.call(tag, true); }\n\n    setMountState.call(tag, false);\n\n    delete root._tag;\n\n    return tag\n  }\n\n  /**\n   * Tag creation factory function\n   * @constructor\n   * @param { Object } impl - it contains the tag template, and logic\n   * @param { Object } conf - tag options\n   * @param { String } innerHTML - html that eventually we need to inject in the tag\n   */\n  function createTag(impl, conf, innerHTML) {\n    if ( impl === void 0 ) impl = {};\n    if ( conf === void 0 ) conf = {};\n\n    var tag = conf.context || {};\n    var opts = conf.opts || {};\n    var parent = conf.parent;\n    var isLoop = conf.isLoop;\n    var isAnonymous = !!conf.isAnonymous;\n    var skipAnonymous = settings.skipAnonymousTags && isAnonymous;\n    var item = conf.item;\n    // available only for the looped nodes\n    var index = conf.index;\n    // All attributes on the Tag when it's first parsed\n    var instAttrs = [];\n    // expressions on this type of Tag\n    var implAttrs = [];\n    var tmpl = impl.tmpl;\n    var expressions = [];\n    var root = conf.root;\n    var tagName = conf.tagName || getName(root);\n    var isVirtual = tagName === 'virtual';\n    var isInline = !isVirtual && !tmpl;\n    var dom;\n\n    if (isInline || isLoop && isAnonymous) {\n      dom = root;\n    } else {\n      if (!isVirtual) { root.innerHTML = ''; }\n      dom = mkdom(tmpl, innerHTML, isSvg(root));\n    }\n\n    // make this tag observable\n    if (!skipAnonymous) { observable(tag); }\n\n    // only call unmount if we have a valid __TAG_IMPL (has name property)\n    if (impl.name && root._tag) { root._tag.unmount(true); }\n\n    define(tag, '__', {\n      impl: impl,\n      root: root,\n      skipAnonymous: skipAnonymous,\n      implAttrs: implAttrs,\n      isAnonymous: isAnonymous,\n      instAttrs: instAttrs,\n      innerHTML: innerHTML,\n      tagName: tagName,\n      index: index,\n      isLoop: isLoop,\n      isInline: isInline,\n      item: item,\n      parent: parent,\n      // tags having event listeners\n      // it would be better to use weak maps here but we can not introduce breaking changes now\n      listeners: [],\n      // these vars will be needed only for the virtual tags\n      virts: [],\n      wasCreated: false,\n      tail: null,\n      head: null\n    });\n\n    // tag protected properties\n    return [\n      ['isMounted', false],\n      // create a unique id to this tag\n      // it could be handy to use it also to improve the virtual dom rendering speed\n      ['_riot_id', uid()],\n      ['root', root],\n      ['opts', opts, { writable: true, enumerable: true }],\n      ['parent', parent || null],\n      // protect the \"tags\" and \"refs\" property from being overridden\n      ['tags', {}],\n      ['refs', {}],\n      ['update', function (data) { return componentUpdate(tag, data, expressions); }],\n      ['mixin', function () {\n        var mixins = [], len = arguments.length;\n        while ( len-- ) mixins[ len ] = arguments[ len ];\n\n        return componentMixin.apply(void 0, [ tag ].concat( mixins ));\n    }],\n      ['mount', function () { return componentMount(tag, dom, expressions, opts); }],\n      ['unmount', function (mustKeepRoot) { return tagUnmount(tag, mustKeepRoot, expressions); }]\n    ].reduce(function (acc, ref) {\n      var key = ref[0];\n      var value = ref[1];\n      var opts = ref[2];\n\n      define(tag, key, value, opts);\n      return acc\n    }, extend(tag, item))\n  }\n\n  /**\n   * Mount a tag creating new Tag instance\n   * @param   { Object } root - dom node where the tag will be mounted\n   * @param   { String } tagName - name of the riot tag we want to mount\n   * @param   { Object } opts - options to pass to the Tag instance\n   * @param   { Object } ctx - optional context that will be used to extend an existing class ( used in riot.Tag )\n   * @returns { Tag } a new Tag instance\n   */\n  function mount$1(root, tagName, opts, ctx) {\n    var impl = __TAG_IMPL[tagName];\n    var implClass = __TAG_IMPL[tagName].class;\n    var context = ctx || (implClass ? create(implClass.prototype) : {});\n    // cache the inner HTML to fix #855\n    var innerHTML = root._innerHTML = root._innerHTML || root.innerHTML;\n    var conf = extend({ root: root, opts: opts, context: context }, { parent: opts ? opts.parent : null });\n    var tag;\n\n    if (impl && root) { tag = createTag(impl, conf, innerHTML); }\n\n    if (tag && tag.mount) {\n      tag.mount(true);\n      // add this tag to the virtualDom variable\n      if (!contains(__TAGS_CACHE, tag)) { __TAGS_CACHE.push(tag); }\n    }\n\n    return tag\n  }\n\n\n\n  var tags = /*#__PURE__*/Object.freeze({\n    arrayishAdd: arrayishAdd,\n    getTagName: getName,\n    inheritParentProps: inheritParentProps,\n    mountTo: mount$1,\n    selectTags: query,\n    arrayishRemove: arrayishRemove,\n    getTag: get,\n    initChildTag: initChild,\n    moveChildTag: moveChild,\n    makeReplaceVirtual: makeReplaceVirtual,\n    getImmediateCustomParentTag: getImmediateCustomParent,\n    makeVirtual: makeVirtual,\n    moveVirtual: moveVirtual,\n    unmountAll: unmountAll,\n    createIfDirective: createIfDirective,\n    createRefDirective: createRefDirective\n  });\n\n  /**\n   * Riot public api\n   */\n  var settings$1 = settings;\n  var util = {\n    tmpl: tmpl,\n    brackets: brackets,\n    styleManager: styleManager,\n    vdom: __TAGS_CACHE,\n    styleNode: styleManager.styleNode,\n    // export the riot internal utils as well\n    dom: dom,\n    check: check,\n    misc: misc,\n    tags: tags\n  };\n\n  // export the core props/methods\n  var Tag$1 = Tag;\n  var tag$1 = tag;\n  var tag2$1 = tag2;\n  var mount$2 = mount;\n  var mixin$1 = mixin;\n  var update$2 = update$1;\n  var unregister$1 = unregister;\n  var version$1 = version;\n  var observable$1 = observable;\n\n  var riot$1 = extend({}, core, {\n    observable: observable,\n    settings: settings$1,\n    util: util,\n  });\n\n  exports.settings = settings$1;\n  exports.util = util;\n  exports.Tag = Tag$1;\n  exports.tag = tag$1;\n  exports.tag2 = tag2$1;\n  exports.mount = mount$2;\n  exports.mixin = mixin$1;\n  exports.update = update$2;\n  exports.unregister = unregister$1;\n  exports.version = version$1;\n  exports.observable = observable$1;\n  exports.default = riot$1;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n","require(\"../tags/credit/index\")\n\nriot.mount('credit-index')\n","<credit-index class=\"uk-text-center\">\n  <div class=\"step uk-margin-large-bottom\">\n    <span class=\"title\">クレジットカードを更新する</span><br />\n    <span class=\"explain\">登録されているクレジットカードを更新します。まずはログインを行なってください</span>\n  </div>\n\n  <div if={ !user }>\n    <div class=\"uk-margin\">\n      <div class=\"uk-inline uk-width-1-1\">\n        <input class=\"input-form\" id=\"mail_address\" type=\"text\" placeholder=\"メールアドレス\"></input>\n      </div>\n    </div>\n    <div class=\"uk-margin\">\n      <div class=\"uk-inline uk-width-1-1\">\n        <input class=\"input-form\" id=\"password\" type=\"password\" placeholder=\"パスワード\"></input>\n      </div>\n    </div>\n\n    <div class=\"uk-margin uk-text-center\">\n      <button type=\"button\" onClick={ authentication } class=\"credit-button\">ログイン</button>\n    </div>\n  </div>\n\n  <script>\n    var self = this\n    self.message  = \"メールアドレスを変更します。まずは現在設定されているメールアドレスとパスワードを入力してください\"\n    self.complete = false\n\n    authentication(e) {\n      let email = $('#mail_address').val()\n      let password = $('#password').val()\n\n      if(!email) {\n        return UIkit.notification(\"メールアドレスを入力してください\")\n      }\n      if(!password) {\n        return UIkit.notification(\"パスワードを入力してください\")\n      }\n\n      requestServerByPromise('/api/v1/auth/user/signin', 'POST', { email: email, password: password }).then((response) => {\n        setToken(response.token)\n        // uidを取得する\n        requestServerByPromise('/api/v2/user/uid', 'GET', { email: email, password: password }).then((uidResponse) => {\n          // 念の為cookie削除しておく\n          deleteCookie()\n          // 更新にリダイレクトする\n          redirectInputCredit(uidResponse.uid, email)\n        }).catch((error) => {\n          window.error('ログインエラー', { code: error.code, message: error.message })\n          return false\n        })\n      }).catch((error) => {\n        window.error('ログインエラー', { code: error.code, message: response.message })\n        return false\n      })\n    }\n\n    function redirectInputCredit(uid, email) {\n      var form = document.createElement('form');\n      form.action = \"/credit/input\";\n      form.method = 'post';\n\n      var uid_ele = document.createElement('input');\n      uid_ele.setAttribute('type', 'hidden');\n      uid_ele.setAttribute('name', 'uid');\n      uid_ele.setAttribute('value', uid);\n      form.appendChild(uid_ele)\n\n      var email_ele = document.createElement('input');\n      email_ele.setAttribute('type', 'hidden');\n      email_ele.setAttribute('name', 'email');\n      email_ele.setAttribute('value', email);\n      form.appendChild(email_ele)\n\n      document.body.appendChild(form);\n      form.submit()\n    }\n  </script>\n</credit-index>\n"],"sourceRoot":""}