{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./model/user.js","webpack:///../node_modules/riot/riot.js","webpack:///./entry/cancel.js","webpack:///frontend/tags/user/cancel.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","User","data","this","_uid","uid","_email","email","_receipts","_isPaidFlg","_subscribed","_facebook_token","facebook_token","_created_date","created_date","_updated_date","updated_date","callback","requestServer","response","obs","requestNodeServer","then","console","warn","error","window","subscribed","paid","result","firebase","firestore","collection","doc","exists","$","selector","ctx","document","querySelector","styleNode","cssTextProp","__TAGS_CACHE","__TAG_IMPL","REF_DIRECTIVES","SVG_NS","XLINK_REGEX","WIN","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","RE_DQUOTE","qstr","j","list","_parseExpr","RE_QBMARK","_","_getTmpl","Function","_logErr","err","riotData","tagName","__","_riot_id","errorHandler","message","log","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","define","options","toCamel","toUpperCase","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","self","requestServerByPromise"],"mappings":"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","file":"cancel.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 = 1371);\n","export default class User{\n  // firebaseのUserデータを前提\n  constructor(data) {\n    this._uid            = data.uid;\n    this._email          = data.email;\n    this._receipts       = [];\n    this._isPaidFlg      = false;  // 課金済み\n    this._subscribed     = false; // 一度でも契約したことがある。\n    this._facebook_token = data.facebook_token;\n    this._created_date   = data.created_date;\n    this._updated_date   = data.updated_date;\n  }\n\n  get uid()   { return this._uid }\n  get email() { return this._email }\n  get isPaidFlg() { return this._isPaidFlg }\n  get isSubscribed() { return this._subscribed }\n  get createdDate() { return this._created_date }\n  get updatedDate() { return this._updated_date }\n\n  // web登録かどうかのチェック\n  checkWebRegistration(callback) {\n    requestServer(`/api/v1/user/web_registration?uid=${this._uid}`, 'GET', null, (response) => {\n      obs.response = response\n      callback(response)\n    })\n  }\n\n  // 登録経路のアイコンを返す\n  registrationIcon() {\n    if(this._facebook_token === null) {\n      return \"envelope\"\n    } else {\n      return \"facebook\"\n    }\n  }\n\n  // 課金状況のチェック\n  checkReceiptData(callback) {\n    // nodeサーバーに通信\n    requestNodeServer(\"/api/v1/user/check_payment\", 'POST', {uid: this._uid}).then((response) => {\n      console.warn(response)\n      if(response.error) {\n        window.error(\"通信に失敗しました。運営にお問い合わせください\")\n        return false\n      }\n      this._subscribed = response.subscribed\n      this._isPaidFlg  = response.paid\n      callback()\n    })\n  }\n\n  // Emailが更新された時にfirestoreのデータも更新する\n  updateEmail(callback) {\n    requestNodeServer(\"/api/v1/user/email\", 'POST', {uid: this._uid, email: this._email }).then((response) => {\n      console.warn(response)\n      callback(response.result)\n    })\n  }\n\n  getStripeData(callback) {\n    if(!obs.firebase) {\n      console.warn(\"Firebase SDKを読み込んでください\")\n      return false\n    }\n    var db = obs.firebase.firestore()\n    db.collection(\"purchase-stripe\").doc(this._uid).get().then((doc) => {\n      if (!doc.exists) {\n        return window.error(\"購入情報が確認できませんでした\", doc)\n      }\n      callback(doc.data())\n    })\n  }\n}\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/user/cancel\")\n\nriot.mount('cancel')\n","<cancel class=\"uk-text-center\">\n  <div class=\"step uk-margin-large-bottom\">\n    <span class=\"title\">BeatFitを解約する</span><br />\n    <span class=\"explain\">{ message }</span>\n  </div>\n\n  <div if={ !user && !notWebRegister }>\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  <div if={ user && !complete }>\n    <div class=\"uk-margin\">\n      <p class=\"notes\">\n        本当に解約しますか？\n      </p>\n    </div>\n\n    <div class=\"uk-margin uk-text-center\">\n      <button type=\"button\" onClick={ cancelExecute } class=\"credit-button\">解約する</button>\n    </div>\n  </div>\n\n  <div class=\"uk-text-danger\" if={ !complete }>\n    ウェブサイトよりクレジットカードでご契約いただいた場合のみこちらで解約可能です。<br />\n    iPhone、及びAndroidのアプリストアからご契約頂いた場合は、このページではご解約できません。<br/ >\n    お手数ですが、<a href=\"https://www.beatfit.jp/faq\">こちらから</a>解約方法をご確認ください。<br />\n  </div>\n\n  <div if={ complete }>\n    <span class=\"notes\">\n      解約手続きが完了しました。<br />\n      { expired_date }  までは引き続きご利用いただけます。\n    </span>\n  </div>\n\n\n  <script>\n    import User from '../../model/user';\n    var self = this\n\n    self.message  = \"解約を行います。まずは登録されているメールアドレスとパスワードをご入力ください\"\n    self.complete = false\n    self.expired  = new Date()\n\n    authentication(e) {\n      activeLoading()\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      requestServerByPromise('/api/v1/auth/user/signin', 'POST', { email: email, password: password }).then((response) => {\n        setToken(response.token)\n        let user = null\n        // uidを取得する\n        requestServerByPromise('/api/v2/user/uid', 'GET', { email: email, password: password }).then((uidResponse) => {\n          let user = new User(uidResponse)\n          requestServerByPromise('/api/v1/user/web_registration', 'GET', { uid: uidResponse.uid }).then((confirmResponse) => {\n            self.user = user\n            if (!confirmResponse.uid) {\n              self.message        = \"お客様はWeb登録者ではありません。\"\n              self.user           = null\n              self.notWebRegister = true\n            }\n            if(confirmResponse.status == \"cancel\") {\n              self.message        = \"お客様は既に解約済みです。\"\n              self.user           = null\n              self.notWebRegister = true\n            }\n            passiveLoading()\n            self.update()\n          }).catch((error) => {\n            UIkit.notification(error.message, { status: \"danger\" })\n            passiveLoading()\n            return false\n          })\n        })\n      })\n    }\n\n    cancelExecute(e) {\n      activeLoading()\n      requestServerByPromise('/api/v2/user/cancel', 'POST', {}).then((response) => {\n        if (!response.result) {\n          return UIkit.notification(response.message, { status: \"warning\" })\n        }\n        deleteCookie()\n        self.complete = true\n        self.expired = new Date(response.expiration_date)\n        self.expired_date = `${self.expired.getFullYear()}年 ${self.expired.getMonth() + 1}月 ${self.expired.getDate()}日`\n        passiveLoading()\n        self.update()\n      }).catch((error) => {\n        UIkit.notification(error.message, { status: \"danger\" })\n        passiveLoading()\n        return false\n      })\n    }\n  </script>\n</cancel>\n"],"sourceRoot":""}