{"version":3,"file":"rules.js","mappings":"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","sources":["webpack://croco-keyphrase/./node_modules/debounce-promise/dist/index.js","webpack://croco-keyphrase/./node_modules/debounce/index.js","webpack://croco-keyphrase/./node_modules/riot/riot.js","webpack://croco-keyphrase/webpack/bootstrap","webpack://croco-keyphrase/webpack/runtime/compat get default export","webpack://croco-keyphrase/webpack/runtime/define property getters","webpack://croco-keyphrase/webpack/runtime/hasOwnProperty shorthand","webpack://croco-keyphrase/./node_modules/croco-framework/opt/app/front-end/lib/router.js","webpack://croco-keyphrase/./node_modules/croco-framework/opt/app/front-end/lib/util.js","webpack://croco-keyphrase/./node_modules/croco-framework/opt/app/front-end/tags/utils/binding.riot","webpack://croco-keyphrase/./node_modules/croco-framework/opt/app/front-end/tags/utils/codemirror.riot","webpack://croco-keyphrase/./node_modules/croco-framework/opt/app/front-end/tags/utils/number-format.riot","webpack://croco-keyphrase/./node_modules/croco-framework/opt/app/front-end/tags/utils/pagination.riot","webpack://croco-keyphrase/./node_modules/croco-framework/opt/app/front-end/tags/utils/radar-chart.riot","webpack://croco-keyphrase/./node_modules/croco-framework/opt/app/front-end/lib/radar-chart.js","webpack://croco-keyphrase/./node_modules/croco-framework/opt/app/front-end/tags/utils/raw.riot","webpack://croco-keyphrase/./opt/app/front-end/config/services.js","webpack://croco-keyphrase/./node_modules/croco-framework/opt/app/front-end/lib/dependeny-injection.js","webpack://croco-keyphrase/./opt/app/front-end/rules.js"],"sourcesContent":["'use strict';\n\n/* global setTimeout, clearTimeout */\n\nmodule.exports = function debounce(fn) {\n  var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n  var lastCallAt = void 0;\n  var deferred = void 0;\n  var timer = void 0;\n  var pendingArgs = [];\n  return function debounced() {\n    var currentWait = getWait(wait);\n    var currentTime = new Date().getTime();\n\n    var isCold = !lastCallAt || currentTime - lastCallAt > currentWait;\n\n    lastCallAt = currentTime;\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    if (isCold && options.leading) {\n      return options.accumulate ? Promise.resolve(fn.call(this, [args])).then(function (result) {\n        return result[0];\n      }) : Promise.resolve(fn.call.apply(fn, [this].concat(args)));\n    }\n\n    if (deferred) {\n      clearTimeout(timer);\n    } else {\n      deferred = defer();\n    }\n\n    pendingArgs.push(args);\n    timer = setTimeout(flush.bind(this), currentWait);\n\n    if (options.accumulate) {\n      var argsIndex = pendingArgs.length - 1;\n      return deferred.promise.then(function (results) {\n        return results[argsIndex];\n      });\n    }\n\n    return deferred.promise;\n  };\n\n  function flush() {\n    var thisDeferred = deferred;\n    clearTimeout(timer);\n\n    Promise.resolve(options.accumulate ? fn.call(this, pendingArgs) : fn.apply(this, pendingArgs[pendingArgs.length - 1])).then(thisDeferred.resolve, thisDeferred.reject);\n\n    pendingArgs = [];\n    deferred = null;\n  }\n};\n\nfunction getWait(wait) {\n  return typeof wait === 'function' ? wait() : wait;\n}\n\nfunction defer() {\n  var deferred = {};\n  deferred.promise = new Promise(function (resolve, reject) {\n    deferred.resolve = resolve;\n    deferred.reject = reject;\n  });\n  return deferred;\n}\n//# sourceMappingURL=index.js.map","/**\n * Returns a function, that, as long as it continues to be invoked, will not\n * be triggered. The function will be called after it stops being called for\n * N milliseconds. If `immediate` is passed, trigger the function on the\n * leading edge, instead of the trailing. The function also has a property 'clear' \n * that is a function which will clear the timer to prevent previously scheduled executions. \n *\n * @source underscore.js\n * @see http://unscriptable.com/2009/03/20/debouncing-javascript-methods/\n * @param {Function} function to wrap\n * @param {Number} timeout in ms (`100`)\n * @param {Boolean} whether to execute at the beginning (`false`)\n * @api public\n */\nfunction debounce(func, wait, immediate){\n  var timeout, args, context, timestamp, result;\n  if (null == wait) wait = 100;\n\n  function later() {\n    var last = Date.now() - timestamp;\n\n    if (last < wait && last >= 0) {\n      timeout = setTimeout(later, wait - last);\n    } else {\n      timeout = null;\n      if (!immediate) {\n        result = func.apply(context, args);\n        context = args = null;\n      }\n    }\n  };\n\n  var debounced = function(){\n    context = this;\n    args = arguments;\n    timestamp = Date.now();\n    var callNow = immediate && !timeout;\n    if (!timeout) timeout = setTimeout(later, wait);\n    if (callNow) {\n      result = func.apply(context, args);\n      context = args = null;\n    }\n\n    return result;\n  };\n\n  debounced.clear = function() {\n    if (timeout) {\n      clearTimeout(timeout);\n      timeout = null;\n    }\n  };\n  \n  debounced.flush = function() {\n    if (timeout) {\n      result = func.apply(context, args);\n      context = args = null;\n      \n      clearTimeout(timeout);\n      timeout = null;\n    }\n  };\n\n  return debounced;\n};\n\n// Adds compatibility for ES modules\ndebounce.debounce = debounce;\n\nmodule.exports = debounce;\n","/* Riot v4.8.0, @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  (global = global || self, factory(global.riot = {}));\n}(this, (function (exports) { 'use strict';\n\n  const COMPONENTS_IMPLEMENTATION_MAP = new Map(),\n        DOM_COMPONENT_INSTANCE_PROPERTY = Symbol('riot-component'),\n        PLUGINS_SET = new Set(),\n        IS_DIRECTIVE = 'is',\n        VALUE_ATTRIBUTE = 'value',\n        MOUNT_METHOD_KEY = 'mount',\n        UPDATE_METHOD_KEY = 'update',\n        UNMOUNT_METHOD_KEY = 'unmount',\n        IS_PURE_SYMBOL = Symbol.for('pure'),\n        PARENT_KEY_SYMBOL = Symbol('parent'),\n        ATTRIBUTES_KEY_SYMBOL = Symbol('attributes'),\n        TEMPLATE_KEY_SYMBOL = Symbol('template');\n\n  var globals = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    COMPONENTS_IMPLEMENTATION_MAP: COMPONENTS_IMPLEMENTATION_MAP,\n    DOM_COMPONENT_INSTANCE_PROPERTY: DOM_COMPONENT_INSTANCE_PROPERTY,\n    PLUGINS_SET: PLUGINS_SET,\n    IS_DIRECTIVE: IS_DIRECTIVE,\n    VALUE_ATTRIBUTE: VALUE_ATTRIBUTE,\n    MOUNT_METHOD_KEY: MOUNT_METHOD_KEY,\n    UPDATE_METHOD_KEY: UPDATE_METHOD_KEY,\n    UNMOUNT_METHOD_KEY: UNMOUNT_METHOD_KEY,\n    IS_PURE_SYMBOL: IS_PURE_SYMBOL,\n    PARENT_KEY_SYMBOL: PARENT_KEY_SYMBOL,\n    ATTRIBUTES_KEY_SYMBOL: ATTRIBUTES_KEY_SYMBOL,\n    TEMPLATE_KEY_SYMBOL: TEMPLATE_KEY_SYMBOL\n  });\n\n  /**\n   * Quick type checking\n   * @param   {*} element - anything\n   * @param   {string} type - type definition\n   * @returns {boolean} true if the type corresponds\n   */\n  function checkType(element, type) {\n    return typeof element === type;\n  }\n  /**\n   * Check that will be passed if its argument is a function\n   * @param   {*} value - value to check\n   * @returns {boolean} - true if the value is a function\n   */\n\n  function isFunction(value) {\n    return checkType(value, 'function');\n  }\n\n  function noop() {\n    return this;\n  }\n  /**\n   * Autobind the methods of a source object to itself\n   * @param   {Object} source - probably a riot tag instance\n   * @param   {Array<string>} methods - list of the methods to autobind\n   * @returns {Object} the original object received\n   */\n\n  function autobindMethods(source, methods) {\n    methods.forEach(method => {\n      source[method] = source[method].bind(source);\n    });\n    return source;\n  }\n  /**\n   * Call the first argument received only if it's a function otherwise return it as it is\n   * @param   {*} source - anything\n   * @returns {*} anything\n   */\n\n  function callOrAssign(source) {\n    return isFunction(source) ? source.prototype && source.prototype.constructor ? new source() : source() : source;\n  }\n\n  /**\n   * Convert a string from camel case to dash-case\n   * @param   {string} string - probably a component tag name\n   * @returns {string} component name normalized\n   */\n\n  /**\n   * Convert a string containing dashes to camel case\n   * @param   {string} string - input string\n   * @returns {string} my-string -> myString\n   */\n  function dashToCamelCase(string) {\n    return string.replace(/-(\\w)/g, (_, c) => c.toUpperCase());\n  }\n  /**\n   * Move all the child nodes from a source tag to another\n   * @param   {HTMLElement} source - source node\n   * @param   {HTMLElement} target - target node\n   * @returns {undefined} it's a void method ¯\\_(ツ)_/¯\n   */\n  // Ignore this helper because it's needed only for svg tags\n\n\n  function moveChildren(source, target) {\n    if (source.firstChild) {\n      target.appendChild(source.firstChild);\n      moveChildren(source, target);\n    }\n  }\n  /**\n   * Remove the child nodes from any DOM node\n   * @param   {HTMLElement} node - target node\n   * @returns {undefined}\n   */\n\n\n  function cleanNode(node) {\n    clearChildren(node.childNodes);\n  }\n  /**\n   * Clear multiple children in a node\n   * @param   {HTMLElement[]} children - direct children nodes\n   * @returns {undefined}\n   */\n\n\n  function clearChildren(children) {\n    Array.from(children).forEach(n => n.parentNode && n.parentNode.removeChild(n));\n  }\n\n  const EACH = 0;\n  const IF = 1;\n  const SIMPLE = 2;\n  const TAG = 3;\n  const SLOT = 4;\n  var bindingTypes = {\n    EACH,\n    IF,\n    SIMPLE,\n    TAG,\n    SLOT\n  };\n  const ATTRIBUTE = 0;\n  const EVENT = 1;\n  const TEXT = 2;\n  const VALUE = 3;\n  var expressionTypes = {\n    ATTRIBUTE,\n    EVENT,\n    TEXT,\n    VALUE\n  };\n  /**\n   * Create the template meta object in case of <template> fragments\n   * @param   {TemplateChunk} componentTemplate - template chunk object\n   * @returns {Object} the meta property that will be passed to the mount function of the TemplateChunk\n   */\n\n  function createTemplateMeta(componentTemplate) {\n    const fragment = componentTemplate.dom.cloneNode(true);\n    return {\n      avoidDOMInjection: true,\n      fragment,\n      children: Array.from(fragment.childNodes)\n    };\n  }\n\n  const {\n    indexOf: iOF\n  } = [];\n\n  const append = (get, parent, children, start, end, before) => {\n    const isSelect = 'selectedIndex' in parent;\n    let noSelection = isSelect;\n\n    while (start < end) {\n      const child = get(children[start], 1);\n      parent.insertBefore(child, before);\n\n      if (isSelect && noSelection && child.selected) {\n        noSelection = !noSelection;\n        let {\n          selectedIndex\n        } = parent;\n        parent.selectedIndex = selectedIndex < 0 ? start : iOF.call(parent.querySelectorAll('option'), child);\n      }\n\n      start++;\n    }\n  };\n\n  const eqeq = (a, b) => a == b;\n\n  const identity = O => O;\n\n  const indexOf = (moreNodes, moreStart, moreEnd, lessNodes, lessStart, lessEnd, compare) => {\n    const length = lessEnd - lessStart;\n    /* istanbul ignore if */\n\n    if (length < 1) return -1;\n\n    while (moreEnd - moreStart >= length) {\n      let m = moreStart;\n      let l = lessStart;\n\n      while (m < moreEnd && l < lessEnd && compare(moreNodes[m], lessNodes[l])) {\n        m++;\n        l++;\n      }\n\n      if (l === lessEnd) return moreStart;\n      moreStart = m + 1;\n    }\n\n    return -1;\n  };\n\n  const isReversed = (futureNodes, futureEnd, currentNodes, currentStart, currentEnd, compare) => {\n    while (currentStart < currentEnd && compare(currentNodes[currentStart], futureNodes[futureEnd - 1])) {\n      currentStart++;\n      futureEnd--;\n    }\n\n    return futureEnd === 0;\n  };\n\n  const next = (get, list, i, length, before) => i < length ? get(list[i], 0) : 0 < i ? get(list[i - 1], -0).nextSibling : before;\n\n  const remove = (get, children, start, end) => {\n    while (start < end) drop(get(children[start++], -1));\n  }; // - - - - - - - - - - - - - - - - - - -\n  // diff related constants and utilities\n  // - - - - - - - - - - - - - - - - - - -\n\n\n  const DELETION = -1;\n  const INSERTION = 1;\n  const SKIP = 0;\n  const SKIP_OND = 50;\n\n  const HS = (futureNodes, futureStart, futureEnd, futureChanges, currentNodes, currentStart, currentEnd, currentChanges) => {\n    let k = 0;\n    /* istanbul ignore next */\n\n    let minLen = futureChanges < currentChanges ? futureChanges : currentChanges;\n    const link = Array(minLen++);\n    const tresh = Array(minLen);\n    tresh[0] = -1;\n\n    for (let i = 1; i < minLen; i++) tresh[i] = currentEnd;\n\n    const nodes = currentNodes.slice(currentStart, currentEnd);\n\n    for (let i = futureStart; i < futureEnd; i++) {\n      const index = nodes.indexOf(futureNodes[i]);\n\n      if (-1 < index) {\n        const idxInOld = index + currentStart;\n        k = findK(tresh, minLen, idxInOld);\n        /* istanbul ignore else */\n\n        if (-1 < k) {\n          tresh[k] = idxInOld;\n          link[k] = {\n            newi: i,\n            oldi: idxInOld,\n            prev: link[k - 1]\n          };\n        }\n      }\n    }\n\n    k = --minLen;\n    --currentEnd;\n\n    while (tresh[k] > currentEnd) --k;\n\n    minLen = currentChanges + futureChanges - k;\n    const diff = Array(minLen);\n    let ptr = link[k];\n    --futureEnd;\n\n    while (ptr) {\n      const {\n        newi,\n        oldi\n      } = ptr;\n\n      while (futureEnd > newi) {\n        diff[--minLen] = INSERTION;\n        --futureEnd;\n      }\n\n      while (currentEnd > oldi) {\n        diff[--minLen] = DELETION;\n        --currentEnd;\n      }\n\n      diff[--minLen] = SKIP;\n      --futureEnd;\n      --currentEnd;\n      ptr = ptr.prev;\n    }\n\n    while (futureEnd >= futureStart) {\n      diff[--minLen] = INSERTION;\n      --futureEnd;\n    }\n\n    while (currentEnd >= currentStart) {\n      diff[--minLen] = DELETION;\n      --currentEnd;\n    }\n\n    return diff;\n  }; // this is pretty much the same petit-dom code without the delete map part\n  // https://github.com/yelouafi/petit-dom/blob/bd6f5c919b5ae5297be01612c524c40be45f14a7/src/vdom.js#L556-L561\n\n\n  const OND = (futureNodes, futureStart, rows, currentNodes, currentStart, cols, compare) => {\n    const length = rows + cols;\n    const v = [];\n    let d, k, r, c, pv, cv, pd;\n\n    outer: for (d = 0; d <= length; d++) {\n      /* istanbul ignore if */\n      if (d > SKIP_OND) return null;\n      pd = d - 1;\n      /* istanbul ignore next */\n\n      pv = d ? v[d - 1] : [0, 0];\n      cv = v[d] = [];\n\n      for (k = -d; k <= d; k += 2) {\n        if (k === -d || k !== d && pv[pd + k - 1] < pv[pd + k + 1]) {\n          c = pv[pd + k + 1];\n        } else {\n          c = pv[pd + k - 1] + 1;\n        }\n\n        r = c - k;\n\n        while (c < cols && r < rows && compare(currentNodes[currentStart + c], futureNodes[futureStart + r])) {\n          c++;\n          r++;\n        }\n\n        if (c === cols && r === rows) {\n          break outer;\n        }\n\n        cv[d + k] = c;\n      }\n    }\n\n    const diff = Array(d / 2 + length / 2);\n    let diffIdx = diff.length - 1;\n\n    for (d = v.length - 1; d >= 0; d--) {\n      while (c > 0 && r > 0 && compare(currentNodes[currentStart + c - 1], futureNodes[futureStart + r - 1])) {\n        // diagonal edge = equality\n        diff[diffIdx--] = SKIP;\n        c--;\n        r--;\n      }\n\n      if (!d) break;\n      pd = d - 1;\n      /* istanbul ignore next */\n\n      pv = d ? v[d - 1] : [0, 0];\n      k = c - r;\n\n      if (k === -d || k !== d && pv[pd + k - 1] < pv[pd + k + 1]) {\n        // vertical edge = insertion\n        r--;\n        diff[diffIdx--] = INSERTION;\n      } else {\n        // horizontal edge = deletion\n        c--;\n        diff[diffIdx--] = DELETION;\n      }\n    }\n\n    return diff;\n  };\n\n  const applyDiff = (diff, get, parentNode, futureNodes, futureStart, currentNodes, currentStart, currentLength, before) => {\n    const live = [];\n    const length = diff.length;\n    let currentIndex = currentStart;\n    let i = 0;\n\n    while (i < length) {\n      switch (diff[i++]) {\n        case SKIP:\n          futureStart++;\n          currentIndex++;\n          break;\n\n        case INSERTION:\n          // TODO: bulk appends for sequential nodes\n          live.push(futureNodes[futureStart]);\n          append(get, parentNode, futureNodes, futureStart++, futureStart, currentIndex < currentLength ? get(currentNodes[currentIndex], 0) : before);\n          break;\n\n        case DELETION:\n          currentIndex++;\n          break;\n      }\n    }\n\n    i = 0;\n\n    while (i < length) {\n      switch (diff[i++]) {\n        case SKIP:\n          currentStart++;\n          break;\n\n        case DELETION:\n          // TODO: bulk removes for sequential nodes\n          if (-1 < live.indexOf(currentNodes[currentStart])) currentStart++;else remove(get, currentNodes, currentStart++, currentStart);\n          break;\n      }\n    }\n  };\n\n  const findK = (ktr, length, j) => {\n    let lo = 1;\n    let hi = length;\n\n    while (lo < hi) {\n      const mid = (lo + hi) / 2 >>> 0;\n      if (j < ktr[mid]) hi = mid;else lo = mid + 1;\n    }\n\n    return lo;\n  };\n\n  const smartDiff = (get, parentNode, futureNodes, futureStart, futureEnd, futureChanges, currentNodes, currentStart, currentEnd, currentChanges, currentLength, compare, before) => {\n    applyDiff(OND(futureNodes, futureStart, futureChanges, currentNodes, currentStart, currentChanges, compare) || HS(futureNodes, futureStart, futureEnd, futureChanges, currentNodes, currentStart, currentEnd, currentChanges), get, parentNode, futureNodes, futureStart, currentNodes, currentStart, currentLength, before);\n  };\n\n  const drop = node => (node.remove || dropChild).call(node);\n\n  function dropChild() {\n    const {\n      parentNode\n    } = this;\n    /* istanbul ignore else */\n\n    if (parentNode) parentNode.removeChild(this);\n  }\n  /*! (c) 2018 Andrea Giammarchi (ISC) */\n\n\n  const domdiff = (parentNode, // where changes happen\n  currentNodes, // Array of current items/nodes\n  futureNodes, // Array of future items/nodes\n  options // optional object with one of the following properties\n  //  before: domNode\n  //  compare(generic, generic) => true if same generic\n  //  node(generic) => Node\n  ) => {\n    if (!options) options = {};\n    const compare = options.compare || eqeq;\n    const get = options.node || identity;\n    const before = options.before == null ? null : get(options.before, 0);\n    const currentLength = currentNodes.length;\n    let currentEnd = currentLength;\n    let currentStart = 0;\n    let futureEnd = futureNodes.length;\n    let futureStart = 0; // common prefix\n\n    while (currentStart < currentEnd && futureStart < futureEnd && compare(currentNodes[currentStart], futureNodes[futureStart])) {\n      currentStart++;\n      futureStart++;\n    } // common suffix\n\n\n    while (currentStart < currentEnd && futureStart < futureEnd && compare(currentNodes[currentEnd - 1], futureNodes[futureEnd - 1])) {\n      currentEnd--;\n      futureEnd--;\n    }\n\n    const currentSame = currentStart === currentEnd;\n    const futureSame = futureStart === futureEnd; // same list\n\n    if (currentSame && futureSame) return futureNodes; // only stuff to add\n\n    if (currentSame && futureStart < futureEnd) {\n      append(get, parentNode, futureNodes, futureStart, futureEnd, next(get, currentNodes, currentStart, currentLength, before));\n      return futureNodes;\n    } // only stuff to remove\n\n\n    if (futureSame && currentStart < currentEnd) {\n      remove(get, currentNodes, currentStart, currentEnd);\n      return futureNodes;\n    }\n\n    const currentChanges = currentEnd - currentStart;\n    const futureChanges = futureEnd - futureStart;\n    let i = -1; // 2 simple indels: the shortest sequence is a subsequence of the longest\n\n    if (currentChanges < futureChanges) {\n      i = indexOf(futureNodes, futureStart, futureEnd, currentNodes, currentStart, currentEnd, compare); // inner diff\n\n      if (-1 < i) {\n        append(get, parentNode, futureNodes, futureStart, i, get(currentNodes[currentStart], 0));\n        append(get, parentNode, futureNodes, i + currentChanges, futureEnd, next(get, currentNodes, currentEnd, currentLength, before));\n        return futureNodes;\n      }\n    }\n    /* istanbul ignore else */\n    else if (futureChanges < currentChanges) {\n        i = indexOf(currentNodes, currentStart, currentEnd, futureNodes, futureStart, futureEnd, compare); // outer diff\n\n        if (-1 < i) {\n          remove(get, currentNodes, currentStart, i);\n          remove(get, currentNodes, i + futureChanges, currentEnd);\n          return futureNodes;\n        }\n      } // common case with one replacement for many nodes\n    // or many nodes replaced for a single one\n\n    /* istanbul ignore else */\n\n\n    if (currentChanges < 2 || futureChanges < 2) {\n      append(get, parentNode, futureNodes, futureStart, futureEnd, get(currentNodes[currentStart], 0));\n      remove(get, currentNodes, currentStart, currentEnd);\n      return futureNodes;\n    } // the half match diff part has been skipped in petit-dom\n    // https://github.com/yelouafi/petit-dom/blob/bd6f5c919b5ae5297be01612c524c40be45f14a7/src/vdom.js#L391-L397\n    // accordingly, I think it's safe to skip in here too\n    // if one day it'll come out like the speediest thing ever to do\n    // then I might add it in here too\n    // Extra: before going too fancy, what about reversed lists ?\n    //        This should bail out pretty quickly if that's not the case.\n\n\n    if (currentChanges === futureChanges && isReversed(futureNodes, futureEnd, currentNodes, currentStart, currentEnd, compare)) {\n      append(get, parentNode, futureNodes, futureStart, futureEnd, next(get, currentNodes, currentEnd, currentLength, before));\n      return futureNodes;\n    } // last resort through a smart diff\n\n\n    smartDiff(get, parentNode, futureNodes, futureStart, futureEnd, futureChanges, currentNodes, currentStart, currentEnd, currentChanges, currentLength, compare, before);\n    return futureNodes;\n  };\n  /**\n   * Quick type checking\n   * @param   {*} element - anything\n   * @param   {string} type - type definition\n   * @returns {boolean} true if the type corresponds\n   */\n\n\n  function checkType$1(element, type) {\n    return typeof element === type;\n  }\n  /**\n   * Check if an element is part of an svg\n   * @param   {HTMLElement}  el - element to check\n   * @returns {boolean} true if we are in an svg context\n   */\n\n\n  function isSvg(el) {\n    const owner = el.ownerSVGElement;\n    return !!owner || owner === null;\n  }\n  /**\n   * Check if an element is a template tag\n   * @param   {HTMLElement}  el - element to check\n   * @returns {boolean} true if it's a <template>\n   */\n\n\n  function isTemplate(el) {\n    return !isNil(el.content);\n  }\n  /**\n   * Check if a value is a Boolean\n   * @param   {*}  value - anything\n   * @returns {boolean} true only for the value is a boolean\n   */\n\n\n  function isBoolean(value) {\n    return checkType$1(value, 'boolean');\n  }\n  /**\n   * Check if a value is an Object\n   * @param   {*}  value - anything\n   * @returns {boolean} true only for the value is an object\n   */\n\n\n  function isObject(value) {\n    return !isNil(value) && checkType$1(value, 'object');\n  }\n  /**\n   * Check if a value is null or undefined\n   * @param   {*}  value - anything\n   * @returns {boolean} true only for the 'undefined' and 'null' types\n   */\n\n\n  function isNil(value) {\n    return value === null || value === undefined;\n  }\n\n  const UNMOUNT_SCOPE = Symbol('unmount');\n  const EachBinding = Object.seal({\n    // dynamic binding properties\n    // childrenMap: null,\n    // node: null,\n    // root: null,\n    // condition: null,\n    // evaluate: null,\n    // template: null,\n    // isTemplateTag: false,\n    nodes: [],\n\n    // getKey: null,\n    // indexName: null,\n    // itemName: null,\n    // afterPlaceholder: null,\n    // placeholder: null,\n    // API methods\n    mount(scope, parentScope) {\n      return this.update(scope, parentScope);\n    },\n\n    update(scope, parentScope) {\n      const {\n        placeholder,\n        nodes,\n        childrenMap\n      } = this;\n      const collection = scope === UNMOUNT_SCOPE ? null : this.evaluate(scope);\n      const items = collection ? Array.from(collection) : [];\n      const parent = placeholder.parentNode; // prepare the diffing\n\n      const {\n        newChildrenMap,\n        batches,\n        futureNodes\n      } = createPatch(items, scope, parentScope, this); // patch the DOM only if there are new nodes\n\n      domdiff(parent, nodes, futureNodes, {\n        before: placeholder,\n        node: patch(Array.from(childrenMap.values()), parentScope)\n      }); // trigger the mounts and the updates\n\n      batches.forEach(fn => fn()); // update the children map\n\n      this.childrenMap = newChildrenMap;\n      this.nodes = futureNodes;\n      return this;\n    },\n\n    unmount(scope, parentScope) {\n      this.update(UNMOUNT_SCOPE, parentScope);\n      return this;\n    }\n\n  });\n  /**\n   * Patch the DOM while diffing\n   * @param   {TemplateChunk[]} redundant - redundant tepmplate chunks\n   * @param   {*} parentScope - scope of the parent template\n   * @returns {Function} patch function used by domdiff\n   */\n\n  function patch(redundant, parentScope) {\n    return (item, info) => {\n      if (info < 0) {\n        const element = redundant.pop();\n\n        if (element) {\n          const {\n            template,\n            context\n          } = element; // notice that we pass null as last argument because\n          // the root node and its children will be removed by domdiff\n\n          template.unmount(context, parentScope, null);\n        }\n      }\n\n      return item;\n    };\n  }\n  /**\n   * Check whether a template must be filtered from a loop\n   * @param   {Function} condition - filter function\n   * @param   {Object} context - argument passed to the filter function\n   * @returns {boolean} true if this item should be skipped\n   */\n\n\n  function mustFilterItem(condition, context) {\n    return condition ? Boolean(condition(context)) === false : false;\n  }\n  /**\n   * Extend the scope of the looped template\n   * @param   {Object} scope - current template scope\n   * @param   {string} options.itemName - key to identify the looped item in the new context\n   * @param   {string} options.indexName - key to identify the index of the looped item\n   * @param   {number} options.index - current index\n   * @param   {*} options.item - collection item looped\n   * @returns {Object} enhanced scope object\n   */\n\n\n  function extendScope(scope, _ref) {\n    let {\n      itemName,\n      indexName,\n      index,\n      item\n    } = _ref;\n    scope[itemName] = item;\n    if (indexName) scope[indexName] = index;\n    return scope;\n  }\n  /**\n   * Loop the current template items\n   * @param   {Array} items - expression collection value\n   * @param   {*} scope - template scope\n   * @param   {*} parentScope - scope of the parent template\n   * @param   {EeachBinding} binding - each binding object instance\n   * @returns {Object} data\n   * @returns {Map} data.newChildrenMap - a Map containing the new children template structure\n   * @returns {Array} data.batches - array containing the template lifecycle functions to trigger\n   * @returns {Array} data.futureNodes - array containing the nodes we need to diff\n   */\n\n\n  function createPatch(items, scope, parentScope, binding) {\n    const {\n      condition,\n      template,\n      childrenMap,\n      itemName,\n      getKey,\n      indexName,\n      root,\n      isTemplateTag\n    } = binding;\n    const newChildrenMap = new Map();\n    const batches = [];\n    const futureNodes = [];\n    items.forEach((item, index) => {\n      const context = extendScope(Object.create(scope), {\n        itemName,\n        indexName,\n        index,\n        item\n      });\n      const key = getKey ? getKey(context) : index;\n      const oldItem = childrenMap.get(key);\n\n      if (mustFilterItem(condition, context)) {\n        return;\n      }\n\n      const componentTemplate = oldItem ? oldItem.template : template.clone();\n      const el = oldItem ? componentTemplate.el : root.cloneNode();\n      const mustMount = !oldItem;\n      const meta = isTemplateTag && mustMount ? createTemplateMeta(componentTemplate) : {};\n\n      if (mustMount) {\n        batches.push(() => componentTemplate.mount(el, context, parentScope, meta));\n      } else {\n        batches.push(() => componentTemplate.update(context, parentScope));\n      } // create the collection of nodes to update or to add\n      // in case of template tags we need to add all its children nodes\n\n\n      if (isTemplateTag) {\n        const children = meta.children || componentTemplate.children;\n        futureNodes.push(...children); // add fake children into the childrenMap in order to preserve\n        // the index in case of unmount calls\n\n        children.forEach(child => newChildrenMap.set(child, null));\n      } else {\n        futureNodes.push(el);\n      } // delete the old item from the children map\n\n\n      childrenMap.delete(key); // update the children map\n\n      newChildrenMap.set(key, {\n        template: componentTemplate,\n        context,\n        index\n      });\n    });\n    return {\n      newChildrenMap,\n      batches,\n      futureNodes\n    };\n  }\n\n  function create(node, _ref2) {\n    let {\n      evaluate,\n      condition,\n      itemName,\n      indexName,\n      getKey,\n      template\n    } = _ref2;\n    const placeholder = document.createTextNode('');\n    const parent = node.parentNode;\n    const root = node.cloneNode();\n    parent.insertBefore(placeholder, node);\n    parent.removeChild(node);\n    return Object.assign({}, EachBinding, {\n      childrenMap: new Map(),\n      node,\n      root,\n      condition,\n      evaluate,\n      isTemplateTag: isTemplate(root),\n      template: template.createDOM(node),\n      getKey,\n      indexName,\n      itemName,\n      placeholder\n    });\n  }\n  /**\n   * Binding responsible for the `if` directive\n   */\n\n\n  const IfBinding = Object.seal({\n    // dynamic binding properties\n    // node: null,\n    // evaluate: null,\n    // parent: null,\n    // isTemplateTag: false,\n    // placeholder: null,\n    // template: null,\n    // API methods\n    mount(scope, parentScope) {\n      this.parent.insertBefore(this.placeholder, this.node);\n      this.parent.removeChild(this.node);\n      return this.update(scope, parentScope);\n    },\n\n    update(scope, parentScope) {\n      const value = !!this.evaluate(scope);\n      const mustMount = !this.value && value;\n      const mustUnmount = this.value && !value;\n\n      const mount = () => {\n        const pristine = this.node.cloneNode();\n        this.parent.insertBefore(pristine, this.placeholder);\n        this.template = this.template.clone();\n        this.template.mount(pristine, scope, parentScope);\n      };\n\n      switch (true) {\n        case mustMount:\n          mount();\n          break;\n\n        case mustUnmount:\n          this.unmount(scope);\n          break;\n\n        default:\n          if (value) this.template.update(scope, parentScope);\n      }\n\n      this.value = value;\n      return this;\n    },\n\n    unmount(scope, parentScope) {\n      this.template.unmount(scope, parentScope, true);\n      return this;\n    }\n\n  });\n\n  function create$1(node, _ref3) {\n    let {\n      evaluate,\n      template\n    } = _ref3;\n    return Object.assign({}, IfBinding, {\n      node,\n      evaluate,\n      parent: node.parentNode,\n      placeholder: document.createTextNode(''),\n      template: template.createDOM(node)\n    });\n  }\n\n  const REMOVE_ATTRIBUTE = 'removeAttribute';\n  const SET_ATTIBUTE = 'setAttribute';\n  /**\n   * Add all the attributes provided\n   * @param   {HTMLElement} node - target node\n   * @param   {Object} attributes - object containing the attributes names and values\n   * @returns {undefined} sorry it's a void function :(\n   */\n\n  function setAllAttributes(node, attributes) {\n    Object.entries(attributes).forEach((_ref4) => {\n      let [name, value] = _ref4;\n      return attributeExpression(node, {\n        name\n      }, value);\n    });\n  }\n  /**\n   * Remove all the attributes provided\n   * @param   {HTMLElement} node - target node\n   * @param   {Object} attributes - object containing all the attribute names\n   * @returns {undefined} sorry it's a void function :(\n   */\n\n\n  function removeAllAttributes(node, attributes) {\n    Object.keys(attributes).forEach(attribute => node.removeAttribute(attribute));\n  }\n  /**\n   * This methods handles the DOM attributes updates\n   * @param   {HTMLElement} node - target node\n   * @param   {Object} expression - expression object\n   * @param   {string} expression.name - attribute name\n   * @param   {*} value - new expression value\n   * @param   {*} oldValue - the old expression cached value\n   * @returns {undefined}\n   */\n\n\n  function attributeExpression(node, _ref5, value, oldValue) {\n    let {\n      name\n    } = _ref5;\n\n    // is it a spread operator? {...attributes}\n    if (!name) {\n      // is the value still truthy?\n      if (value) {\n        setAllAttributes(node, value);\n      } else if (oldValue) {\n        // otherwise remove all the old attributes\n        removeAllAttributes(node, oldValue);\n      }\n\n      return;\n    } // handle boolean attributes\n\n\n    if (isBoolean(value) || isObject(value)) {\n      node[name] = value;\n    }\n\n    node[getMethod(value)](name, normalizeValue(name, value));\n  }\n  /**\n   * Get the attribute modifier method\n   * @param   {*} value - if truthy we return `setAttribute` othewise `removeAttribute`\n   * @returns {string} the node attribute modifier method name\n   */\n\n\n  function getMethod(value) {\n    return isNil(value) || value === false || value === '' || isObject(value) ? REMOVE_ATTRIBUTE : SET_ATTIBUTE;\n  }\n  /**\n   * Get the value as string\n   * @param   {string} name - attribute name\n   * @param   {*} value - user input value\n   * @returns {string} input value as string\n   */\n\n\n  function normalizeValue(name, value) {\n    // be sure that expressions like selected={ true } will be always rendered as selected='selected'\n    if (value === true) return name;\n    return value;\n  }\n\n  const RE_EVENTS_PREFIX = /^on/;\n  /**\n   * Set a new event listener\n   * @param   {HTMLElement} node - target node\n   * @param   {Object} expression - expression object\n   * @param   {string} expression.name - event name\n   * @param   {*} value - new expression value\n   * @param   {*} oldValue - old expression value\n   * @returns {value} the callback just received\n   */\n\n  function eventExpression(node, _ref6, value, oldValue) {\n    let {\n      name\n    } = _ref6;\n    const normalizedEventName = name.replace(RE_EVENTS_PREFIX, '');\n\n    if (oldValue) {\n      node.removeEventListener(normalizedEventName, oldValue);\n    }\n\n    if (value) {\n      node.addEventListener(normalizedEventName, value, false);\n    }\n  }\n  /**\n   * Normalize the user value in order to render a empty string in case of falsy values\n   * @param   {*} value - user input value\n   * @returns {string} hopefully a string\n   */\n\n\n  function normalizeStringValue(value) {\n    return isNil(value) ? '' : value;\n  }\n  /**\n   * Get the the target text node to update or create one from of a comment node\n   * @param   {HTMLElement} node - any html element containing childNodes\n   * @param   {number} childNodeIndex - index of the text node in the childNodes list\n   * @returns {HTMLTextNode} the text node to update\n   */\n\n\n  const getTextNode = (node, childNodeIndex) => {\n    const target = node.childNodes[childNodeIndex];\n\n    if (target.nodeType === Node.COMMENT_NODE) {\n      const textNode = document.createTextNode('');\n      node.replaceChild(textNode, target);\n      return textNode;\n    }\n\n    return target;\n  };\n  /**\n   * This methods handles a simple text expression update\n   * @param   {HTMLElement} node - target node\n   * @param   {Object} data - expression object\n   * @param   {*} value - new expression value\n   * @returns {undefined}\n   */\n\n\n  function textExpression(node, data, value) {\n    node.data = normalizeStringValue(value);\n  }\n  /**\n   * This methods handles the input fileds value updates\n   * @param   {HTMLElement} node - target node\n   * @param   {Object} expression - expression object\n   * @param   {*} value - new expression value\n   * @returns {undefined}\n   */\n\n\n  function valueExpression(node, expression, value) {\n    node.value = normalizeStringValue(value);\n  }\n\n  var expressions = {\n    [ATTRIBUTE]: attributeExpression,\n    [EVENT]: eventExpression,\n    [TEXT]: textExpression,\n    [VALUE]: valueExpression\n  };\n  const Expression = Object.seal({\n    // Static props\n    // node: null,\n    // value: null,\n    // API methods\n\n    /**\n     * Mount the expression evaluating its initial value\n     * @param   {*} scope - argument passed to the expression to evaluate its current values\n     * @returns {Expression} self\n     */\n    mount(scope) {\n      // hopefully a pure function\n      this.value = this.evaluate(scope); // IO() DOM updates\n\n      apply(this, this.value);\n      return this;\n    },\n\n    /**\n     * Update the expression if its value changed\n     * @param   {*} scope - argument passed to the expression to evaluate its current values\n     * @returns {Expression} self\n     */\n    update(scope) {\n      // pure function\n      const value = this.evaluate(scope);\n\n      if (this.value !== value) {\n        // IO() DOM updates\n        apply(this, value);\n        this.value = value;\n      }\n\n      return this;\n    },\n\n    /**\n     * Expression teardown method\n     * @returns {Expression} self\n     */\n    unmount() {\n      // unmount only the event handling expressions\n      if (this.type === EVENT) apply(this, null);\n      return this;\n    }\n\n  });\n  /**\n   * IO() function to handle the DOM updates\n   * @param {Expression} expression - expression object\n   * @param {*} value - current expression value\n   * @returns {undefined}\n   */\n\n  function apply(expression, value) {\n    return expressions[expression.type](expression.node, expression, value, expression.value);\n  }\n\n  function create$2(node, data) {\n    return Object.assign({}, Expression, {}, data, {\n      node: data.type === TEXT ? getTextNode(node, data.childNodeIndex) : node\n    });\n  }\n  /**\n   * Create a flat object having as keys a list of methods that if dispatched will propagate\n   * on the whole collection\n   * @param   {Array} collection - collection to iterate\n   * @param   {Array<string>} methods - methods to execute on each item of the collection\n   * @param   {*} context - context returned by the new methods created\n   * @returns {Object} a new object to simplify the the nested methods dispatching\n   */\n\n\n  function flattenCollectionMethods(collection, methods, context) {\n    return methods.reduce((acc, method) => {\n      return Object.assign({}, acc, {\n        [method]: scope => {\n          return collection.map(item => item[method](scope)) && context;\n        }\n      });\n    }, {});\n  }\n\n  function create$3(node, _ref7) {\n    let {\n      expressions\n    } = _ref7;\n    return Object.assign({}, flattenCollectionMethods(expressions.map(expression => create$2(node, expression)), ['mount', 'update', 'unmount']));\n  }\n  /**\n   * Evaluate a list of attribute expressions\n   * @param   {Array} attributes - attribute expressions generated by the riot compiler\n   * @returns {Object} key value pairs with the result of the computation\n   */\n\n\n  function evaluateAttributeExpressions(attributes) {\n    return attributes.reduce((acc, attribute) => {\n      const {\n        value,\n        type\n      } = attribute;\n\n      switch (true) {\n        // spread attribute\n        case !attribute.name && type === ATTRIBUTE:\n          return Object.assign({}, acc, {}, value);\n        // value attribute\n\n        case type === VALUE:\n          acc.value = attribute.value;\n          break;\n        // normal attributes\n\n        default:\n          acc[dashToCamelCase(attribute.name)] = attribute.value;\n      }\n\n      return acc;\n    }, {});\n  }\n\n  function extendParentScope(attributes, scope, parentScope) {\n    if (!attributes || !attributes.length) return parentScope;\n    const expressions = attributes.map(attr => Object.assign({}, attr, {\n      value: attr.evaluate(scope)\n    }));\n    return Object.assign(Object.create(parentScope || null), evaluateAttributeExpressions(expressions));\n  }\n\n  const SlotBinding = Object.seal({\n    // dynamic binding properties\n    // node: null,\n    // name: null,\n    attributes: [],\n\n    // template: null,\n    getTemplateScope(scope, parentScope) {\n      return extendParentScope(this.attributes, scope, parentScope);\n    },\n\n    // API methods\n    mount(scope, parentScope) {\n      const templateData = scope.slots ? scope.slots.find((_ref8) => {\n        let {\n          id\n        } = _ref8;\n        return id === this.name;\n      }) : false;\n      const {\n        parentNode\n      } = this.node;\n      this.template = templateData && create$6(templateData.html, templateData.bindings).createDOM(parentNode);\n\n      if (this.template) {\n        this.template.mount(this.node, this.getTemplateScope(scope, parentScope));\n        this.template.children = moveSlotInnerContent(this.node);\n      }\n\n      parentNode.removeChild(this.node);\n      return this;\n    },\n\n    update(scope, parentScope) {\n      if (this.template) {\n        this.template.update(this.getTemplateScope(scope, parentScope));\n      }\n\n      return this;\n    },\n\n    unmount(scope, parentScope, mustRemoveRoot) {\n      if (this.template) {\n        this.template.unmount(this.getTemplateScope(scope, parentScope), null, mustRemoveRoot);\n      }\n\n      return this;\n    }\n\n  });\n  /**\n   * Move the inner content of the slots outside of them\n   * @param   {HTMLNode} slot - slot node\n   * @param   {HTMLElement} children - array to fill with the child nodes detected\n   * @returns {HTMLElement[]} list of the node moved\n   */\n\n  function moveSlotInnerContent(slot, children) {\n    if (children === void 0) {\n      children = [];\n    }\n\n    const child = slot.firstChild;\n\n    if (child) {\n      slot.parentNode.insertBefore(child, slot);\n      return [child, ...moveSlotInnerContent(slot)];\n    }\n\n    return children;\n  }\n  /**\n   * Create a single slot binding\n   * @param   {HTMLElement} node - slot node\n   * @param   {string} options.name - slot id\n   * @returns {Object} Slot binding object\n   */\n\n\n  function createSlot(node, _ref9) {\n    let {\n      name,\n      attributes\n    } = _ref9;\n    return Object.assign({}, SlotBinding, {\n      attributes,\n      node,\n      name\n    });\n  }\n  /**\n   * Create a new tag object if it was registered before, otherwise fallback to the simple\n   * template chunk\n   * @param   {Function} component - component factory function\n   * @param   {Array<Object>} slots - array containing the slots markup\n   * @param   {Array} attributes - dynamic attributes that will be received by the tag element\n   * @returns {TagImplementation|TemplateChunk} a tag implementation or a template chunk as fallback\n   */\n\n\n  function getTag(component, slots, attributes) {\n    if (slots === void 0) {\n      slots = [];\n    }\n\n    if (attributes === void 0) {\n      attributes = [];\n    }\n\n    // if this tag was registered before we will return its implementation\n    if (component) {\n      return component({\n        slots,\n        attributes\n      });\n    } // otherwise we return a template chunk\n\n\n    return create$6(slotsToMarkup(slots), [...slotBindings(slots), {\n      // the attributes should be registered as binding\n      // if we fallback to a normal template chunk\n      expressions: attributes.map(attr => {\n        return Object.assign({\n          type: ATTRIBUTE\n        }, attr);\n      })\n    }]);\n  }\n  /**\n   * Merge all the slots bindings into a single array\n   * @param   {Array<Object>} slots - slots collection\n   * @returns {Array<Bindings>} flatten bindings array\n   */\n\n\n  function slotBindings(slots) {\n    return slots.reduce((acc, _ref10) => {\n      let {\n        bindings\n      } = _ref10;\n      return acc.concat(bindings);\n    }, []);\n  }\n  /**\n   * Merge all the slots together in a single markup string\n   * @param   {Array<Object>} slots - slots collection\n   * @returns {string} markup of all the slots in a single string\n   */\n\n\n  function slotsToMarkup(slots) {\n    return slots.reduce((acc, slot) => {\n      return acc + slot.html;\n    }, '');\n  }\n\n  const TagBinding = Object.seal({\n    // dynamic binding properties\n    // node: null,\n    // evaluate: null,\n    // name: null,\n    // slots: null,\n    // tag: null,\n    // attributes: null,\n    // getComponent: null,\n    mount(scope) {\n      return this.update(scope);\n    },\n\n    update(scope, parentScope) {\n      const name = this.evaluate(scope); // simple update\n\n      if (name === this.name) {\n        this.tag.update(scope);\n      } else {\n        // unmount the old tag if it exists\n        this.unmount(scope, parentScope, true); // mount the new tag\n\n        this.name = name;\n        this.tag = getTag(this.getComponent(name), this.slots, this.attributes);\n        this.tag.mount(this.node, scope);\n      }\n\n      return this;\n    },\n\n    unmount(scope, parentScope, keepRootTag) {\n      if (this.tag) {\n        // keep the root tag\n        this.tag.unmount(keepRootTag);\n      }\n\n      return this;\n    }\n\n  });\n\n  function create$4(node, _ref11) {\n    let {\n      evaluate,\n      getComponent,\n      slots,\n      attributes\n    } = _ref11;\n    return Object.assign({}, TagBinding, {\n      node,\n      evaluate,\n      slots,\n      attributes,\n      getComponent\n    });\n  }\n\n  var bindings = {\n    [IF]: create$1,\n    [SIMPLE]: create$3,\n    [EACH]: create,\n    [TAG]: create$4,\n    [SLOT]: createSlot\n  };\n  /**\n   * Text expressions in a template tag will get childNodeIndex value normalized\n   * depending on the position of the <template> tag offset\n   * @param   {Expression[]} expressions - riot expressions array\n   * @param   {number} textExpressionsOffset - offset of the <template> tag\n   * @returns {Expression[]} expressions containing the text expressions normalized\n   */\n\n  function fixTextExpressionsOffset(expressions, textExpressionsOffset) {\n    return expressions.map(e => e.type === TEXT ? Object.assign({}, e, {\n      childNodeIndex: e.childNodeIndex + textExpressionsOffset\n    }) : e);\n  }\n  /**\n   * Bind a new expression object to a DOM node\n   * @param   {HTMLElement} root - DOM node where to bind the expression\n   * @param   {Object} binding - binding data\n   * @param   {number|null} templateTagOffset - if it's defined we need to fix the text expressions childNodeIndex offset\n   * @returns {Binding} Binding object\n   */\n\n\n  function create$5(root, binding, templateTagOffset) {\n    const {\n      selector,\n      type,\n      redundantAttribute,\n      expressions\n    } = binding; // find the node to apply the bindings\n\n    const node = selector ? root.querySelector(selector) : root; // remove eventually additional attributes created only to select this node\n\n    if (redundantAttribute) node.removeAttribute(redundantAttribute);\n    const bindingExpressions = expressions || []; // init the binding\n\n    return (bindings[type] || bindings[SIMPLE])(node, Object.assign({}, binding, {\n      expressions: templateTagOffset && !selector ? fixTextExpressionsOffset(bindingExpressions, templateTagOffset) : bindingExpressions\n    }));\n  } // in this case a simple innerHTML is enough\n\n\n  function createHTMLTree(html, root) {\n    const template = isTemplate(root) ? root : document.createElement('template');\n    template.innerHTML = html;\n    return template.content;\n  } // for svg nodes we need a bit more work\n\n\n  function createSVGTree(html, container) {\n    // create the SVGNode\n    const svgNode = container.ownerDocument.importNode(new window.DOMParser().parseFromString(`<svg xmlns=\"http://www.w3.org/2000/svg\">${html}</svg>`, 'application/xml').documentElement, true);\n    return svgNode;\n  }\n  /**\n   * Create the DOM that will be injected\n   * @param {Object} root - DOM node to find out the context where the fragment will be created\n   * @param   {string} html - DOM to create as string\n   * @returns {HTMLDocumentFragment|HTMLElement} a new html fragment\n   */\n\n\n  function createDOMTree(root, html) {\n    if (isSvg(root)) return createSVGTree(html, root);\n    return createHTMLTree(html, root);\n  }\n  /**\n   * Inject the DOM tree into a target node\n   * @param   {HTMLElement} el - target element\n   * @param   {HTMLFragment|SVGElement} dom - dom tree to inject\n   * @returns {undefined}\n   */\n\n\n  function injectDOM(el, dom) {\n    switch (true) {\n      case isSvg(el):\n        moveChildren(dom, el);\n        break;\n\n      case isTemplate(el):\n        el.parentNode.replaceChild(dom, el);\n        break;\n\n      default:\n        el.appendChild(dom);\n    }\n  }\n  /**\n   * Create the Template DOM skeleton\n   * @param   {HTMLElement} el - root node where the DOM will be injected\n   * @param   {string} html - markup that will be injected into the root node\n   * @returns {HTMLFragment} fragment that will be injected into the root node\n   */\n\n\n  function createTemplateDOM(el, html) {\n    return html && (typeof html === 'string' ? createDOMTree(el, html) : html);\n  }\n  /**\n   * Template Chunk model\n   * @type {Object}\n   */\n\n\n  const TemplateChunk = Object.freeze({\n    // Static props\n    // bindings: null,\n    // bindingsData: null,\n    // html: null,\n    // isTemplateTag: false,\n    // fragment: null,\n    // children: null,\n    // dom: null,\n    // el: null,\n\n    /**\n     * Create the template DOM structure that will be cloned on each mount\n     * @param   {HTMLElement} el - the root node\n     * @returns {TemplateChunk} self\n     */\n    createDOM(el) {\n      // make sure that the DOM gets created before cloning the template\n      this.dom = this.dom || createTemplateDOM(el, this.html);\n      return this;\n    },\n\n    // API methods\n\n    /**\n     * Attach the template to a DOM node\n     * @param   {HTMLElement} el - target DOM node\n     * @param   {*} scope - template data\n     * @param   {*} parentScope - scope of the parent template tag\n     * @param   {Object} meta - meta properties needed to handle the <template> tags in loops\n     * @returns {TemplateChunk} self\n     */\n    mount(el, scope, parentScope, meta) {\n      if (meta === void 0) {\n        meta = {};\n      }\n\n      if (!el) throw new Error('Please provide DOM node to mount properly your template');\n      if (this.el) this.unmount(scope); // <template> tags require a bit more work\n      // the template fragment might be already created via meta outside of this call\n\n      const {\n        fragment,\n        children,\n        avoidDOMInjection\n      } = meta; // <template> bindings of course can not have a root element\n      // so we check the parent node to set the query selector bindings\n\n      const {\n        parentNode\n      } = children ? children[0] : el;\n      const isTemplateTag = isTemplate(el);\n      const templateTagOffset = isTemplateTag ? Math.max(Array.from(parentNode.children).indexOf(el), 0) : null;\n      this.isTemplateTag = isTemplateTag; // create the DOM if it wasn't created before\n\n      this.createDOM(el);\n\n      if (this.dom) {\n        // create the new template dom fragment if it want already passed in via meta\n        this.fragment = fragment || this.dom.cloneNode(true);\n      } // store root node\n      // notice that for template tags the root note will be the parent tag\n\n\n      this.el = this.isTemplateTag ? parentNode : el; // create the children array only for the <template> fragments\n\n      this.children = this.isTemplateTag ? children || Array.from(this.fragment.childNodes) : null; // inject the DOM into the el only if a fragment is available\n\n      if (!avoidDOMInjection && this.fragment) injectDOM(el, this.fragment); // create the bindings\n\n      this.bindings = this.bindingsData.map(binding => create$5(this.el, binding, templateTagOffset));\n      this.bindings.forEach(b => b.mount(scope, parentScope));\n      return this;\n    },\n\n    /**\n     * Update the template with fresh data\n     * @param   {*} scope - template data\n     * @param   {*} parentScope - scope of the parent template tag\n     * @returns {TemplateChunk} self\n     */\n    update(scope, parentScope) {\n      this.bindings.forEach(b => b.update(scope, parentScope));\n      return this;\n    },\n\n    /**\n     * Remove the template from the node where it was initially mounted\n     * @param   {*} scope - template data\n     * @param   {*} parentScope - scope of the parent template tag\n     * @param   {boolean|null} mustRemoveRoot - if true remove the root element,\n     * if false or undefined clean the root tag content, if null don't touch the DOM\n     * @returns {TemplateChunk} self\n     */\n    unmount(scope, parentScope, mustRemoveRoot) {\n      if (this.el) {\n        this.bindings.forEach(b => b.unmount(scope, parentScope, mustRemoveRoot));\n\n        switch (true) {\n          // <template> tags should be treated a bit differently\n          // we need to clear their children only if it's explicitly required by the caller\n          // via mustRemoveRoot !== null\n          case this.children && mustRemoveRoot !== null:\n            clearChildren(this.children);\n            break;\n          // remove the root node only if the mustRemoveRoot === true\n\n          case mustRemoveRoot === true && this.el.parentNode !== null:\n            this.el.parentNode.removeChild(this.el);\n            break;\n          // otherwise we clean the node children\n\n          case mustRemoveRoot !== null:\n            cleanNode(this.el);\n            break;\n        }\n\n        this.el = null;\n      }\n\n      return this;\n    },\n\n    /**\n     * Clone the template chunk\n     * @returns {TemplateChunk} a clone of this object resetting the this.el property\n     */\n    clone() {\n      return Object.assign({}, this, {\n        el: null\n      });\n    }\n\n  });\n  /**\n   * Create a template chunk wiring also the bindings\n   * @param   {string|HTMLElement} html - template string\n   * @param   {Array} bindings - bindings collection\n   * @returns {TemplateChunk} a new TemplateChunk copy\n   */\n\n  function create$6(html, bindings) {\n    if (bindings === void 0) {\n      bindings = [];\n    }\n\n    return Object.assign({}, TemplateChunk, {\n      html,\n      bindingsData: bindings\n    });\n  }\n\n  /**\n   * Helper function to set an immutable property\n   * @param   {Object} source - 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 original object modified\n   */\n  function defineProperty(source, key, value, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    /* eslint-disable fp/no-mutating-methods */\n    Object.defineProperty(source, key, Object.assign({\n      value,\n      enumerable: false,\n      writable: false,\n      configurable: true\n    }, options));\n    /* eslint-enable fp/no-mutating-methods */\n\n    return source;\n  }\n  /**\n   * Define multiple properties on a target object\n   * @param   {Object} source - object where the new properties will be set\n   * @param   {Object} properties - object containing as key pair the key + value properties\n   * @param   {Object} options - set the propery overriding the default options\n   * @returns {Object} the original object modified\n   */\n\n  function defineProperties(source, properties, options) {\n    Object.entries(properties).forEach((_ref) => {\n      let [key, value] = _ref;\n      defineProperty(source, key, value, options);\n    });\n    return source;\n  }\n  /**\n   * Define default properties if they don't exist on the source object\n   * @param   {Object} source - object that will receive the default properties\n   * @param   {Object} defaults - object containing additional optional keys\n   * @returns {Object} the original object received enhanced\n   */\n\n  function defineDefaults(source, defaults) {\n    Object.entries(defaults).forEach((_ref2) => {\n      let [key, value] = _ref2;\n      if (!source[key]) source[key] = value;\n    });\n    return source;\n  }\n\n  const ATTRIBUTE$1 = 0;\n  const VALUE$1 = 3;\n\n  /**\n   * Convert a string from camel case to dash-case\n   * @param   {string} string - probably a component tag name\n   * @returns {string} component name normalized\n   */\n  function camelToDashCase(string) {\n    return string.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();\n  }\n  /**\n   * Convert a string containing dashes to camel case\n   * @param   {string} string - input string\n   * @returns {string} my-string -> myString\n   */\n\n  function dashToCamelCase$1(string) {\n    return string.replace(/-(\\w)/g, (_, c) => c.toUpperCase());\n  }\n\n  /**\n   * Throw an error with a descriptive message\n   * @param   { string } message - error message\n   * @returns { undefined } hoppla.. at this point the program should stop working\n   */\n\n  function panic(message) {\n    throw new Error(message);\n  }\n  /**\n   * Evaluate a list of attribute expressions\n   * @param   {Array} attributes - attribute expressions generated by the riot compiler\n   * @returns {Object} key value pairs with the result of the computation\n   */\n\n  function evaluateAttributeExpressions$1(attributes) {\n    return attributes.reduce((acc, attribute) => {\n      const {\n        value,\n        type\n      } = attribute;\n\n      switch (true) {\n        // spread attribute\n        case !attribute.name && type === ATTRIBUTE$1:\n          return Object.assign({}, acc, {}, value);\n        // value attribute\n\n        case type === VALUE$1:\n          acc.value = attribute.value;\n          break;\n        // normal attributes\n\n        default:\n          acc[dashToCamelCase$1(attribute.name)] = attribute.value;\n      }\n\n      return acc;\n    }, {});\n  }\n\n  /**\n   * Converts any DOM node/s to a loopable array\n   * @param   { HTMLElement|NodeList } els - single html element or a node list\n   * @returns { Array } always a loopable object\n   */\n  function domToArray(els) {\n    // can this object be already looped?\n    if (!Array.isArray(els)) {\n      // is it a node list?\n      if (/^\\[object (HTMLCollection|NodeList|Object)\\]$/.test(Object.prototype.toString.call(els)) && typeof els.length === 'number') return Array.from(els);else // if it's a single node\n        // it will be returned as \"array\" with one single entry\n        return [els];\n    } // this object could be looped out of the box\n\n\n    return els;\n  }\n\n  /**\n   * Simple helper to find DOM nodes returning them as array like loopable object\n   * @param   { string|DOMNodeList } selector - either the query or the DOM nodes to arraify\n   * @param   { HTMLElement }        ctx      - context defining where the query will search for the DOM nodes\n   * @returns { Array } DOM nodes found as array\n   */\n\n  function $(selector, ctx) {\n    return domToArray(typeof selector === 'string' ? (ctx || document).querySelectorAll(selector) : selector);\n  }\n\n  /**\n   * Get all the element attributes as object\n   * @param   {HTMLElement} element - DOM node we want to parse\n   * @returns {Object} all the attributes found as a key value pairs\n   */\n\n  function DOMattributesToObject(element) {\n    return Array.from(element.attributes).reduce((acc, attribute) => {\n      acc[dashToCamelCase$1(attribute.name)] = attribute.value;\n      return acc;\n    }, {});\n  }\n\n  /**\n   * Normalize the return values, in case of a single value we avoid to return an array\n   * @param   { Array } values - list of values we want to return\n   * @returns { Array|string|boolean } either the whole list of values or the single one found\n   * @private\n   */\n\n  const normalize = values => values.length === 1 ? values[0] : values;\n  /**\n   * Parse all the nodes received to get/remove/check their attributes\n   * @param   { HTMLElement|NodeList|Array } els    - DOM node/s to parse\n   * @param   { string|Array }               name   - name or list of attributes\n   * @param   { string }                     method - method that will be used to parse the attributes\n   * @returns { Array|string } result of the parsing in a list or a single value\n   * @private\n   */\n\n\n  function parseNodes(els, name, method) {\n    const names = typeof name === 'string' ? [name] : name;\n    return normalize(domToArray(els).map(el => {\n      return normalize(names.map(n => el[method](n)));\n    }));\n  }\n  /**\n   * Set any attribute on a single or a list of DOM nodes\n   * @param   { HTMLElement|NodeList|Array } els   - DOM node/s to parse\n   * @param   { string|Object }              name  - either the name of the attribute to set\n   *                                                 or a list of properties as object key - value\n   * @param   { string }                     value - the new value of the attribute (optional)\n   * @returns { HTMLElement|NodeList|Array } the original array of elements passed to this function\n   *\n   * @example\n   *\n   * import { set } from 'bianco.attr'\n   *\n   * const img = document.createElement('img')\n   *\n   * set(img, 'width', 100)\n   *\n   * // or also\n   * set(img, {\n   *   width: 300,\n   *   height: 300\n   * })\n   *\n   */\n\n\n  function set(els, name, value) {\n    const attrs = typeof name === 'object' ? name : {\n      [name]: value\n    };\n    const props = Object.keys(attrs);\n    domToArray(els).forEach(el => {\n      props.forEach(prop => el.setAttribute(prop, attrs[prop]));\n    });\n    return els;\n  }\n  /**\n   * Get any attribute from a single or a list of DOM nodes\n   * @param   { HTMLElement|NodeList|Array } els   - DOM node/s to parse\n   * @param   { string|Array }               name  - name or list of attributes to get\n   * @returns { Array|string } list of the attributes found\n   *\n   * @example\n   *\n   * import { get } from 'bianco.attr'\n   *\n   * const img = document.createElement('img')\n   *\n   * get(img, 'width') // => '200'\n   *\n   * // or also\n   * get(img, ['width', 'height']) // => ['200', '300']\n   *\n   * // or also\n   * get([img1, img2], ['width', 'height']) // => [['200', '300'], ['500', '200']]\n   */\n\n  function get(els, name) {\n    return parseNodes(els, name, 'getAttribute');\n  }\n\n  const CSS_BY_NAME = new Map();\n  const STYLE_NODE_SELECTOR = 'style[riot]'; // memoized curried function\n\n  const getStyleNode = (style => {\n    return () => {\n      // lazy evaluation:\n      // if this function was already called before\n      // we return its cached result\n      if (style) return style; // create a new style element or use an existing one\n      // and cache it internally\n\n      style = $(STYLE_NODE_SELECTOR)[0] || document.createElement('style');\n      set(style, 'type', 'text/css');\n      /* istanbul ignore next */\n\n      if (!style.parentNode) document.head.appendChild(style);\n      return style;\n    };\n  })();\n  /**\n   * Object that will be used to inject and manage the css of every tag instance\n   */\n\n\n  var cssManager = {\n    CSS_BY_NAME,\n\n    /**\n     * Save a tag style to be later injected into DOM\n     * @param { string } name - if it's passed we will map the css to a tagname\n     * @param { string } css - css string\n     * @returns {Object} self\n     */\n    add(name, css) {\n      if (!CSS_BY_NAME.has(name)) {\n        CSS_BY_NAME.set(name, css);\n        this.inject();\n      }\n\n      return this;\n    },\n\n    /**\n     * Inject all previously saved tag styles into DOM\n     * innerHTML seems slow: http://jsperf.com/riot-insert-style\n     * @returns {Object} self\n     */\n    inject() {\n      getStyleNode().innerHTML = [...CSS_BY_NAME.values()].join('\\n');\n      return this;\n    },\n\n    /**\n     * Remove a tag style from the DOM\n     * @param {string} name a registered tagname\n     * @returns {Object} self\n     */\n    remove(name) {\n      if (CSS_BY_NAME.has(name)) {\n        CSS_BY_NAME.delete(name);\n        this.inject();\n      }\n\n      return this;\n    }\n\n  };\n\n  /**\n   * Function to curry any javascript method\n   * @param   {Function}  fn - the target function we want to curry\n   * @param   {...[args]} acc - initial arguments\n   * @returns {Function|*} it will return a function until the target function\n   *                       will receive all of its arguments\n   */\n  function curry(fn) {\n    for (var _len = arguments.length, acc = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      acc[_key - 1] = arguments[_key];\n    }\n\n    return function () {\n      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        args[_key2] = arguments[_key2];\n      }\n\n      args = [...acc, ...args];\n      return args.length < fn.length ? curry(fn, ...args) : fn(...args);\n    };\n  }\n\n  /**\n   * Get the tag name of any DOM node\n   * @param   {HTMLElement} element - DOM node we want to inspect\n   * @returns {string} name to identify this dom node in riot\n   */\n\n  function getName(element) {\n    return get(element, IS_DIRECTIVE) || element.tagName.toLowerCase();\n  }\n\n  const COMPONENT_CORE_HELPERS = Object.freeze({\n    // component helpers\n    $(selector) {\n      return $(selector, this.root)[0];\n    },\n\n    $$(selector) {\n      return $(selector, this.root);\n    }\n\n  });\n  const PURE_COMPONENT_API = Object.freeze({\n    [MOUNT_METHOD_KEY]: noop,\n    [UPDATE_METHOD_KEY]: noop,\n    [UNMOUNT_METHOD_KEY]: noop\n  });\n  const COMPONENT_LIFECYCLE_METHODS = Object.freeze({\n    shouldUpdate: noop,\n    onBeforeMount: noop,\n    onMounted: noop,\n    onBeforeUpdate: noop,\n    onUpdated: noop,\n    onBeforeUnmount: noop,\n    onUnmounted: noop\n  });\n  const MOCKED_TEMPLATE_INTERFACE = Object.assign({}, PURE_COMPONENT_API, {\n    clone: noop,\n    createDOM: noop\n  });\n  /**\n   * Wrap the Riot.js core API methods using a mapping function\n   * @param   {Function} mapFunction - lifting function\n   * @returns {Object} an object having the { mount, update, unmount } functions\n   */\n\n  function createCoreAPIMethods(mapFunction) {\n    return [MOUNT_METHOD_KEY, UPDATE_METHOD_KEY, UNMOUNT_METHOD_KEY].reduce((acc, method) => {\n      acc[method] = mapFunction(method);\n      return acc;\n    }, {});\n  }\n  /**\n   * Factory function to create the component templates only once\n   * @param   {Function} template - component template creation function\n   * @param   {Object} components - object containing the nested components\n   * @returns {TemplateChunk} template chunk object\n   */\n\n\n  function componentTemplateFactory(template, components) {\n    return template(create$6, expressionTypes, bindingTypes, name => {\n      return components[name] || COMPONENTS_IMPLEMENTATION_MAP.get(name);\n    });\n  }\n  /**\n   * Create a pure component\n   * @param   {Function} pureFactoryFunction - pure component factory function\n   * @param   {Array} options.slots - component slots\n   * @param   {Array} options.attributes - component attributes\n   * @param   {Array} options.template - template factory function\n   * @param   {Array} options.template - template factory function\n   * @param   {any} options.props - initial component properties\n   * @returns {Object} pure component object\n   */\n\n\n  function createPureComponent(pureFactoryFunction, _ref) {\n    let {\n      slots,\n      attributes,\n      props,\n      css,\n      template\n    } = _ref;\n    if (template) panic('Pure components can not have html');\n    if (css) panic('Pure components do not have css');\n    const component = defineDefaults(pureFactoryFunction({\n      slots,\n      attributes,\n      props\n    }), PURE_COMPONENT_API);\n    return createCoreAPIMethods(method => function () {\n      component[method](...arguments);\n      return component;\n    });\n  }\n  /**\n   * Create the component interface needed for the @riotjs/dom-bindings tag bindings\n   * @param   {string} options.css - component css\n   * @param   {Function} options.template - functon that will return the dom-bindings template function\n   * @param   {Object} options.exports - component interface\n   * @param   {string} options.name - component name\n   * @returns {Object} component like interface\n   */\n\n\n  function createComponent(_ref2) {\n    let {\n      css,\n      template,\n      exports,\n      name\n    } = _ref2;\n    const templateFn = template ? componentTemplateFactory(template, exports ? createSubcomponents(exports.components) : {}) : MOCKED_TEMPLATE_INTERFACE;\n    return (_ref3) => {\n      let {\n        slots,\n        attributes,\n        props\n      } = _ref3;\n      // pure components rendering will be managed by the end user\n      if (exports && exports[IS_PURE_SYMBOL]) return createPureComponent(exports, {\n        slots,\n        attributes,\n        props,\n        css,\n        template\n      });\n      const componentAPI = callOrAssign(exports) || {};\n      const component = defineComponent({\n        css,\n        template: templateFn,\n        componentAPI,\n        name\n      })({\n        slots,\n        attributes,\n        props\n      }); // notice that for the components create via tag binding\n      // we need to invert the mount (state/parentScope) arguments\n      // the template bindings will only forward the parentScope updates\n      // and never deal with the component state\n\n      return {\n        mount(element, parentScope, state) {\n          return component.mount(element, state, parentScope);\n        },\n\n        update(parentScope, state) {\n          return component.update(state, parentScope);\n        },\n\n        unmount(preserveRoot) {\n          return component.unmount(preserveRoot);\n        }\n\n      };\n    };\n  }\n  /**\n   * Component definition function\n   * @param   {Object} implementation - the componen implementation will be generated via compiler\n   * @param   {Object} component - the component initial properties\n   * @returns {Object} a new component implementation object\n   */\n\n  function defineComponent(_ref4) {\n    let {\n      css,\n      template,\n      componentAPI,\n      name\n    } = _ref4;\n    // add the component css into the DOM\n    if (css && name) cssManager.add(name, css);\n    return curry(enhanceComponentAPI)(defineProperties( // set the component defaults without overriding the original component API\n    defineDefaults(componentAPI, Object.assign({}, COMPONENT_LIFECYCLE_METHODS, {\n      state: {}\n    })), Object.assign({\n      // defined during the component creation\n      slots: null,\n      root: null\n    }, COMPONENT_CORE_HELPERS, {\n      name,\n      css,\n      template\n    })));\n  }\n  /**\n   * Evaluate the component properties either from its real attributes or from its attribute expressions\n   * @param   {HTMLElement} element - component root\n   * @param   {Array}  attributeExpressions - attribute values generated via createAttributeBindings\n   * @returns {Object} attributes key value pairs\n   */\n\n  function evaluateProps(element, attributeExpressions) {\n    if (attributeExpressions === void 0) {\n      attributeExpressions = [];\n    }\n\n    return Object.assign({}, DOMattributesToObject(element), {}, evaluateAttributeExpressions$1(attributeExpressions));\n  }\n  /**\n   * Create the bindings to update the component attributes\n   * @param   {HTMLElement} node - node where we will bind the expressions\n   * @param   {Array} attributes - list of attribute bindings\n   * @returns {TemplateChunk} - template bindings object\n   */\n\n\n  function createAttributeBindings(node, attributes) {\n    if (attributes === void 0) {\n      attributes = [];\n    }\n\n    const expressions = attributes.map(a => create$2(node, a));\n    const binding = {};\n    return Object.assign(binding, Object.assign({\n      expressions\n    }, createCoreAPIMethods(method => scope => {\n      expressions.forEach(e => e[method](scope));\n      return binding;\n    })));\n  }\n  /**\n   * Create the subcomponents that can be included inside a tag in runtime\n   * @param   {Object} components - components imported in runtime\n   * @returns {Object} all the components transformed into Riot.Component factory functions\n   */\n\n\n  function createSubcomponents(components) {\n    if (components === void 0) {\n      components = {};\n    }\n\n    return Object.entries(callOrAssign(components)).reduce((acc, _ref5) => {\n      let [key, value] = _ref5;\n      acc[camelToDashCase(key)] = createComponent(value);\n      return acc;\n    }, {});\n  }\n  /**\n   * Run the component instance through all the plugins set by the user\n   * @param   {Object} component - component instance\n   * @returns {Object} the component enhanced by the plugins\n   */\n\n\n  function runPlugins(component) {\n    return [...PLUGINS_SET].reduce((c, fn) => fn(c) || c, component);\n  }\n  /**\n   * Compute the component current state merging it with its previous state\n   * @param   {Object} oldState - previous state object\n   * @param   {Object} newState - new state givent to the `update` call\n   * @returns {Object} new object state\n   */\n\n\n  function computeState(oldState, newState) {\n    return Object.assign({}, oldState, {}, callOrAssign(newState));\n  }\n  /**\n   * Add eventually the \"is\" attribute to link this DOM node to its css\n   * @param {HTMLElement} element - target root node\n   * @param {string} name - name of the component mounted\n   * @returns {undefined} it's a void function\n   */\n\n\n  function addCssHook(element, name) {\n    if (getName(element) !== name) {\n      set(element, 'is', name);\n    }\n  }\n  /**\n   * Component creation factory function that will enhance the user provided API\n   * @param   {Object} component - a component implementation previously defined\n   * @param   {Array} options.slots - component slots generated via riot compiler\n   * @param   {Array} options.attributes - attribute expressions generated via riot compiler\n   * @returns {Riot.Component} a riot component instance\n   */\n\n\n  function enhanceComponentAPI(component, _ref6) {\n    let {\n      slots,\n      attributes,\n      props\n    } = _ref6;\n    const initialProps = callOrAssign(props);\n    return autobindMethods(runPlugins(defineProperties(Object.create(component), {\n      mount(element, state, parentScope) {\n        if (state === void 0) {\n          state = {};\n        }\n\n        this[ATTRIBUTES_KEY_SYMBOL] = createAttributeBindings(element, attributes).mount(parentScope);\n        this.props = Object.freeze(Object.assign({}, initialProps, {}, evaluateProps(element, this[ATTRIBUTES_KEY_SYMBOL].expressions)));\n        this.state = computeState(this.state, state);\n        this[TEMPLATE_KEY_SYMBOL] = this.template.createDOM(element).clone(); // link this object to the DOM node\n\n        element[DOM_COMPONENT_INSTANCE_PROPERTY] = this; // add eventually the 'is' attribute\n\n        component.name && addCssHook(element, component.name); // define the root element\n\n        defineProperty(this, 'root', element); // define the slots array\n\n        defineProperty(this, 'slots', slots); // before mount lifecycle event\n\n        this.onBeforeMount(this.props, this.state); // mount the template\n\n        this[TEMPLATE_KEY_SYMBOL].mount(element, this, parentScope);\n        this[PARENT_KEY_SYMBOL] = parentScope;\n        this.onMounted(this.props, this.state);\n        return this;\n      },\n\n      update(state, parentScope) {\n        if (state === void 0) {\n          state = {};\n        }\n\n        if (parentScope) {\n          this[ATTRIBUTES_KEY_SYMBOL].update(parentScope);\n        }\n\n        const newProps = evaluateProps(this.root, this[ATTRIBUTES_KEY_SYMBOL].expressions);\n        if (this.shouldUpdate(newProps, this.props) === false) return;\n        this.props = Object.freeze(Object.assign({}, initialProps, {}, newProps));\n        this.state = computeState(this.state, state);\n        this.onBeforeUpdate(this.props, this.state);\n        this[TEMPLATE_KEY_SYMBOL].update(this, this[PARENT_KEY_SYMBOL]);\n        this.onUpdated(this.props, this.state);\n        return this;\n      },\n\n      unmount(preserveRoot) {\n        this.onBeforeUnmount(this.props, this.state);\n        this[ATTRIBUTES_KEY_SYMBOL].unmount(); // if the preserveRoot is null the template html will be left untouched\n        // in that case the DOM cleanup will happen differently from a parent node\n\n        this[TEMPLATE_KEY_SYMBOL].unmount(this, this[PARENT_KEY_SYMBOL], preserveRoot === null ? null : !preserveRoot);\n        this.onUnmounted(this.props, this.state);\n        return this;\n      }\n\n    })), Object.keys(component).filter(prop => isFunction(component[prop])));\n  }\n  /**\n   * Component initialization function starting from a DOM node\n   * @param   {HTMLElement} element - element to upgrade\n   * @param   {Object} initialProps - initial component properties\n   * @param   {string} componentName - component id\n   * @returns {Object} a new component instance bound to a DOM node\n   */\n\n  function mountComponent(element, initialProps, componentName) {\n    const name = componentName || getName(element);\n    if (!COMPONENTS_IMPLEMENTATION_MAP.has(name)) panic(`The component named \"${name}\" was never registered`);\n    const component = COMPONENTS_IMPLEMENTATION_MAP.get(name)({\n      props: initialProps\n    });\n    return component.mount(element);\n  }\n\n  /**\n   * Similar to compose but performs from left-to-right function composition.<br/>\n   * {@link https://30secondsofcode.org/function#composeright see also}\n   * @param   {...[function]} fns) - list of unary function\n   * @returns {*} result of the computation\n   */\n  /**\n   * Performs right-to-left function composition.<br/>\n   * Use Array.prototype.reduce() to perform right-to-left function composition.<br/>\n   * The last (rightmost) function can accept one or more arguments; the remaining functions must be unary.<br/>\n   * {@link https://30secondsofcode.org/function#compose original source code}\n   * @param   {...[function]} fns) - list of unary function\n   * @returns {*} result of the computation\n   */\n\n  function compose() {\n    for (var _len2 = arguments.length, fns = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      fns[_key2] = arguments[_key2];\n    }\n\n    return fns.reduce((f, g) => function () {\n      return f(g(...arguments));\n    });\n  }\n\n  const {\n    DOM_COMPONENT_INSTANCE_PROPERTY: DOM_COMPONENT_INSTANCE_PROPERTY$1,\n    COMPONENTS_IMPLEMENTATION_MAP: COMPONENTS_IMPLEMENTATION_MAP$1,\n    PLUGINS_SET: PLUGINS_SET$1\n  } = globals;\n  /**\n   * Riot public api\n   */\n\n  /**\n   * Register a custom tag by name\n   * @param   {string} name - component name\n   * @param   {Object} implementation - tag implementation\n   * @returns {Map} map containing all the components implementations\n   */\n\n  function register(name, _ref) {\n    let {\n      css,\n      template,\n      exports\n    } = _ref;\n    if (COMPONENTS_IMPLEMENTATION_MAP$1.has(name)) panic(`The component \"${name}\" was already registered`);\n    COMPONENTS_IMPLEMENTATION_MAP$1.set(name, createComponent({\n      name,\n      css,\n      template,\n      exports\n    }));\n    return COMPONENTS_IMPLEMENTATION_MAP$1;\n  }\n  /**\n   * Unregister a riot web component\n   * @param   {string} name - component name\n   * @returns {Map} map containing all the components implementations\n   */\n\n  function unregister(name) {\n    if (!COMPONENTS_IMPLEMENTATION_MAP$1.has(name)) panic(`The component \"${name}\" was never registered`);\n    COMPONENTS_IMPLEMENTATION_MAP$1.delete(name);\n    cssManager.remove(name);\n    return COMPONENTS_IMPLEMENTATION_MAP$1;\n  }\n  /**\n   * Mounting function that will work only for the components that were globally registered\n   * @param   {string|HTMLElement} selector - query for the selection or a DOM element\n   * @param   {Object} initialProps - the initial component properties\n   * @param   {string} name - optional component name\n   * @returns {Array} list of nodes upgraded\n   */\n\n  function mount(selector, initialProps, name) {\n    return $(selector).map(element => mountComponent(element, initialProps, name));\n  }\n  /**\n   * Sweet unmounting helper function for the DOM node mounted manually by the user\n   * @param   {string|HTMLElement} selector - query for the selection or a DOM element\n   * @param   {boolean|null} keepRootElement - if true keep the root element\n   * @returns {Array} list of nodes unmounted\n   */\n\n  function unmount(selector, keepRootElement) {\n    return $(selector).map(element => {\n      if (element[DOM_COMPONENT_INSTANCE_PROPERTY$1]) {\n        element[DOM_COMPONENT_INSTANCE_PROPERTY$1].unmount(keepRootElement);\n      }\n\n      return element;\n    });\n  }\n  /**\n   * Define a riot plugin\n   * @param   {Function} plugin - function that will receive all the components created\n   * @returns {Set} the set containing all the plugins installed\n   */\n\n  function install(plugin) {\n    if (!isFunction(plugin)) panic('Plugins must be of type function');\n    if (PLUGINS_SET$1.has(plugin)) panic('This plugin was already install');\n    PLUGINS_SET$1.add(plugin);\n    return PLUGINS_SET$1;\n  }\n  /**\n   * Uninstall a riot plugin\n   * @param   {Function} plugin - plugin previously installed\n   * @returns {Set} the set containing all the plugins installed\n   */\n\n  function uninstall(plugin) {\n    if (!PLUGINS_SET$1.has(plugin)) panic('This plugin was never installed');\n    PLUGINS_SET$1.delete(plugin);\n    return PLUGINS_SET$1;\n  }\n  /**\n   * Helpter method to create component without relying on the registered ones\n   * @param   {Object} implementation - component implementation\n   * @returns {Function} function that will allow you to mount a riot component on a DOM node\n   */\n\n  function component(implementation) {\n    return function (el, props, _temp) {\n      let {\n        slots,\n        attributes\n      } = _temp === void 0 ? {} : _temp;\n      return compose(c => c.mount(el), c => c({\n        props,\n        slots,\n        attributes\n      }), createComponent)(implementation);\n    };\n  }\n  /**\n   * Lift a riot component Interface into a pure riot object\n   * @param   {Function} func - RiotPureComponent factory function\n   * @returns {Function} the lifted original function received as argument\n   */\n\n  function pure(func) {\n    if (!isFunction(func)) panic('riot.pure accepts only arguments of type \"function\"');\n    func[IS_PURE_SYMBOL] = true;\n    return func;\n  }\n  /** @type {string} current riot version */\n\n  const version = 'v4.8.0'; // expose some internal stuff that might be used from external tools\n\n  const __ = {\n    cssManager,\n    createComponent,\n    defineComponent,\n    globals\n  };\n\n  exports.__ = __;\n  exports.component = component;\n  exports.install = install;\n  exports.mount = mount;\n  exports.pure = pure;\n  exports.register = register;\n  exports.uninstall = uninstall;\n  exports.unmount = unmount;\n  exports.unregister = unregister;\n  exports.version = version;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","import debounce from 'debounce-promise';\n\n/**\n * Router\n *\n * @package     riot.router\n * @author      Yujiro Takahashi <yujiro@cro-co.co.jp>\n */\nclass Router {\n    /**\n     * コンストラクタ\n     *\n     * @access public\n     */\n    constructor() {\n        this.RE_ORIGIN = /^.+?\\/\\/+[^/]+/;\n        this.POPSTATE = 'popstate';\n        this.HASHCHANGE = 'hashchange';\n        this.MAX_EMIT_STACK_LEVEL = 3;\n\n        this.win = typeof window != 'undefined' && window;\n        this.doc = typeof document != 'undefined' && document;\n        this.hist = this.win && history;\n        this.loc = this.win && (this.hist.location || this.win.location); // see html5-history-api\n        this.emitDebounce = debounce(this.emit.bind(this), 1);\n        this.clickEvent = this.doc && this.doc.ontouchstart ? 'touchstart' : 'click';\n\n        this._routeFound = false;\n        this._current = null;\n        this._emitStack = [];\n        this._emitStackLevel = 0;\n\n        this._base = '#';\n        this._args = [];\n        this._routing = new Map();\n        this._parser = this.DEFAULT_PARSER;\n        this._secondParser = this.DEFAULT_SECOND_PARSER;\n\n        this._stateActions = new Map();\n    }\n\n    /**\n     * Default parser. You can replace it via router.parser method.\n     * @param {string} path - current path (normalized)\n     * @returns {array} array\n     */\n    DEFAULT_PARSER(path) {\n        return path.split(/[/?#]/);\n    }\n\n    /**\n     * Default parser (second). You can replace it via router.parser method.\n     * @param {string} path - current path (normalized)\n     * @param {string} filter - filter string (normalized)\n     * @returns {array} array\n     */\n    DEFAULT_SECOND_PARSER(path, filter) {\n        let f = filter\n            .replace(/\\?/g, '\\\\?')\n            .replace(/\\*/g, '([^/?#]+?)')\n            .replace(/\\.\\./, '.*');\n        let re = new RegExp((\"^\" + f + \"$\"));\n        let args = path.match(re);\n    \n        if (args) {\n            return args.slice(1);\n        }\n    }\n\n    /**\n     * Set the window listeners to trigger the routes\n     * @param {boolean} autoExec - see route.start\n     */\n    start(autoExec) {\n        this.win.addEventListener(this.POPSTATE, this.emitDebounce);\n        this.win.addEventListener(this.HASHCHANGE, this.emitDebounce);\n        this.doc.addEventListener(this.clickEvent, this.click.bind(this));\n\n        if (autoExec) {\n            this.emit(true); \n        }\n    }\n\n    stop() {\n        if (this.win) {\n            this.win.removeEventListener(this.POPSTATE, this.emitDebounce);\n            this.win.removeEventListener(this.HASHCHANGE, this.emitDebounce);\n            this.doc.removeEventListener(this.clickEvent, this.click.bind(this));\n        }\n\n        this.stopper();\n    }\n\n    /**\n     * Compare paths\n     * @param {string} path\n     * @returns {boolean}\n     */\n    compare(path) {\n        let current = this.getPathFromBase();\n        return (current === path);\n    }\n\n    on(key, action) {\n        /* Overwrite duplicate key */\n        this._stateActions.set(key, action);\n//        this._emitAction();\n    }\n\n    getArgs() {\n        let path = this.getPathFromBase();\n\n        for (let filter of this._routing.keys()) {\n            let args = this._secondParser(\n                this.normalize(path), \n                this.normalize(filter)                \n            );\n            if (typeof args !== 'undefined') {\n                return args;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * Get the part after domain name\n     * @param {string} href - fullpath\n     * @returns {string} path from root\n     */\n    getPathFromRoot(href) {\n        return (href || this.loc.href).replace(this.RE_ORIGIN, '');\n    }\n    \n    /**\n     * Get the part after base\n     * @param {string} href - fullpath\n     * @returns {string} path from base\n     */\n    getPathFromBase(href) {\n        let base = this._base;\n        return base[0] === '#'\n            ? (href || this.loc.href || '').split(base)[1] || ''\n            : (this.loc ? this.getPathFromRoot(href) : href || '').replace(base, '');\n    }\n\n    normalize(path) {\n        return path.replace(/^\\/|\\/$/, '')\n    }\n\n    emit(force) {\n        // the stack is needed for redirections\n        let isRoot = this._emitStackLevel === 0;\n        if (this.MAX_EMIT_STACK_LEVEL <= this._emitStackLevel) {\n            return ;\n        }\n      \n        this._emitStackLevel++;\n        this._emitStack.push(() => {\n            let path = this.getPathFromBase();\n            if (force || path !== this._current) {\n                this.emitter(path);\n                this._current = path;\n            }\n        });\n      \n        if (isRoot) {\n            let first;\n            while (first = this._emitStack.shift()) { \n                first();\n            } // stack increses within this call\n            this._emitStackLevel = 0;\n        }\n    }\n      \n    click(e) {\n        if (\n            e.which !== 1 // not left click\n            || e.metaKey || e.ctrlKey || e.shiftKey // or meta keys\n            || e.defaultPrevented // or default prevented\n        ) { return }\n      \n        let el = e.target;\n        while (el && el.nodeName !== 'A') {\n            el = el.parentNode;\n        }\n\n        if (\n            !el || el.nodeName !== 'A' // not A tag\n            || el.hasAttribute('download') // has download attr\n            || !el.hasAttribute('href') // has no href attr\n            || el.target && el.target !== '_self' // another window or frame\n            || el.href.indexOf(this.loc.href.match(this.RE_ORIGIN)[0]) === -1 // cross origin\n        ) { return }\n      \n        let base = this._base;\n      \n        if (el.href !== this.loc.href\n            && (\n                el.href.split('#')[0] === this.loc.href.split('#')[0] // internal jump\n                || base[0] !== '#' && this.getPathFromRoot(el.href).indexOf(base) !== 0 // outside of base\n                || base[0] === '#' && el.href.split(base)[0] !== this.loc.href.split(base)[0] // outside of #base\n                || !this.go(this.getPathFromBase(el.href), el.title || this.doc.title) // route not found\n        )) { return }\n\n        e.preventDefault();\n    }\n\n    /**\n     * Go to the path\n     * @param {string} path - destination path\n     * @param {string} title - page title\n     * @param {boolean} shouldReplace - use replaceState or pushState\n     * @returns {boolean} - route not found flag\n     */\n    go(path, title, shouldReplace) {\n        // Server-side usage: directly execute handlers for the path\n        if (!this.hist) {\n            return this.emitter(this.getPathFromBase(path));\n        }\n    \n        path = this._base + this.normalize(path);\n        title = title || this.doc.title;\n        // browsers ignores the second parameter `title`\n        shouldReplace\n            ? this.hist.replaceState(null, title, path)\n            : this.hist.pushState(null, title, path);\n        // so we need to set it manually\n        this.doc.title = title;\n        this._routeFound = false;\n        this.emit();\n        return this._routeFound;\n    }\n\n    /**\n     * Helper function to get url query as an object\n     * @returns {object} parsed query\n     */\n    query() {\n        let q = {};\n        let href = this.loc.href || this._current;\n        href.replace(/[?&](.+?)=([^&]*)/g, (_, k, v) => { q[k] = v; });\n        return q\n    }\n\n\n    isString(str) {\n        return typeof str == 'string'\n    }\n      \n    /**\n     * Go to path or set action\n     * a single string:                go there\n     * two strings:                    go there with setting a title\n     * two strings and boolean:        replace history with setting a title\n     * a single function:              set an action on the default route\n     * a string/RegExp and a function: set an action on the route\n     * @param {(string|function)} first - path / action / filter\n     * @param {(string|RegExp|function)} second - title / action\n     * @param {boolean} third - replace flag\n     */\n    mount(first, second, third) {\n        if (this.isString(first) && (!second || this.isString(second))) {\n            this.go(first, second, third || false); \n        } else if (second) {\n            this.register(first, second); \n        } else {\n            this.register('@', first);\n        }\n    }\n    \n    /**\n     * Emitter\n     * @param {string} path - path\n     */\n    emitter(path) {\n        this._routing.forEach((collback, filter)=> {\n            this._args = this._secondParser(\n                this.normalize(path), \n                this.normalize(filter)                \n            );\n            if (typeof this._args != 'undefined') {\n                collback.apply(null, this._args);\n                this._routeFound = true;\n                this._emitAction();\n\n                return this._routeFound; // exit from loop\n            }\n        });\n\n        if (!this._routeFound && this._routing.has('@')) {\n            let callback = this._routing.get('@');\n            callback.call();\n        }\n    }\n  \n    /**\n     * Register route\n     * @param {string} filter - filter for matching to url\n     * @param {function} action - action to register\n     */\n    register(filter, action) {\n        if (filter !== '@') {\n            filter = '/' + this.normalize(filter);\n        }\n\n        this._routing.set(filter, action);\n    }\n\n\n    /**\n     * Set the base of url\n     * @param {(str|RegExp)} arg - a new base or '#' or '#!'\n     */\n    base(arg) {\n        this._base = arg || '#';\n        this._current = this.getPathFromBase(); // recalculate current path\n    }\n    \n    /** Exec routing right now **/\n    exec() {\n        this.emit(true);\n    }\n    \n    /**\n     * Replace the default router to yours\n     * @param {function} fn - your parser function\n     * @param {function} fn2 - your secondParser function\n     */\n    parser(fn, fn2) {\n        if (!fn && !fn2) {\n            // reset parser for testing...\n            this._parser = this.DEFAULT_PARSER;\n            this._secondParser = this.DEFAULT_SECOND_PARSER;\n        }\n        if (fn) { \n            this._parser = fn;\n        }\n        if (fn2) {\n            this._secondParser = fn2;\n        }\n    }\n\n    /**\n     * Stop routing\n     */\n    stopper() {\n        if (this.started) {\n            this.routing.clear();\n            this.started = false;\n        }\n    }\n\n    _emitAction() {\n        if (this._routeFound && (typeof this._args[0] != 'undefined')) {\n            if (this._stateActions.has(this._args[0])) {\n                let action = this._stateActions.get(this._args[0]);\n                action.apply(null, this._args);\n//                Promise.resolve(action.apply(null, this._args));\n            }\n        } // if (this._routeFound && (typeof this._args[0] != 'undefined'))\n    }\n} // class Router\n\nexport default Router;\n","\r\nconst croco = {\r\n    utils: {\r\n        strLen: (val) => {\r\n            let str = new String(val);\r\n            let arr = str.match(/[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[^\\uD800-\\uDFFF]/g) || [];\r\n            return arr.length;    \r\n        },\r\n        numberformat: (val) => {\r\n            return new Intl.NumberFormat(\r\n                'en-IN', { \r\n                    maximumSignificantDigits: 3 \r\n                }\r\n            ).format(val);\r\n        },\r\n        addIFrame: (src) => {\r\n            let root = document.createElement('iframe'); \r\n\r\n            root.setAttribute('src', src);\r\n            document.body.appendChild(root);\r\n\r\n            setTimeout(()=> {\r\n                document.body.removeChild(root);\r\n            }, 1000);\r\n        },\r\n        byteformat: (size) => {\r\n            let sizes =[' B', ' KB', ' MB', ' GB', ' TB', ' PB', ' EB'];\r\n            let ext = sizes[0];\r\n            if (typeof size === 'number') {\r\n                for (var idx =1; idx < sizes.length; idx += 1) {\r\n                    if (size >= 1024) {\r\n                        size = size / 1024;\r\n                        ext = sizes[idx];\r\n                    }\r\n                }\r\n            } // if (typeof size === 'number')\r\n            return Math.round(size, 2) + ext;\r\n        }\r\n    }\r\n};\r\n\r\nexport default croco;\r\n","<binding>\n    <slot/>\n    <script>\n        import debounce from 'debounce';\n\n        export default {\n            setInput(validate) {\n                let input = null;\n                if (this.isValidator) {\n                    this.validation.validate = (typeof this.props.validate !== 'undefined') \n                                                    ? this.props.validate : validate;\n                    input = debounce((e)=> {\n                        this.props.data.set(\n                            this.props.name, \n                            e.target.value,\n                            this.validation\n                        );\n                    }, 100);\n                } else {\n                    input = debounce((e)=> {\n                        this.props.data[this.props.name] = e.target.value;\n                    }, 100);\n                }\n                this.root.value = this.props.data[this.props.name];\n                this.root.onkeyup = input;\n                this.root.onchange = input;\n            },\n            setCheck() {\n                let input = null;\n                if (this.isValidator) {\n                    input = debounce((e)=> {\n                        let value = e.target.checked ? e.target.value : '';\n                        this.props.data.set(\n                            this.props.name, \n                            value, \n                            this.validation\n                        );\n                    }, 50);\n                } else {\n                    input = debounce((e)=> {\n                        let value = e.target.checked ? e.target.value : '';\n                        this.props.data[this.props.name] = value;\n                    }, 50);\n                }\n                this.root.value = this.root.hasAttribute('val') ? this.root.getAttribute('val') : null;\n                if (this.props.data[this.props.name] == this.root.value) {\n                    this.root.checked = true;\n                }\n                this.root.onclick = input;\n            },\n            setTextArea() {\n                let input = null;\n                if (this.isValidator) {\n                    input = debounce((e)=> {\n                        this.props.data.set(\n                            this.props.name, \n                            e.target.value, \n                            this.validation\n                        );\n                    }, 400);\n                } else {\n                    input = debounce((e)=> {\n                        this.props.data[this.props.name] = e.target.value;\n                    }, 400);\n                }\n                this.root.value = this.props.data[this.props.name];\n                this.root.onkeyup = input;\n                this.root.onchange = input;\n            },\n            setSelect() {\n                let selector = null;\n                if (this.isValidator) {\n                    selector = debounce((e)=> {\n                        this.props.data.set(\n                            this.props.name,\n                            this.root.options[this.root.selectedIndex].value,\n                            this.validation\n                        );\n                    }, 50);\n                } else {\n                    selector = debounce((e)=> {\n                        this.props.data[this.props.name] = this.root.options[this.root.selectedIndex].value;\n                    }, 50);\n                }\n                for (let idx=0; idx < this.root.options.length; idx++) {\n                    if (this.root.options[idx].value == this.props.data[this.props.name]) {\n                        this.root.options[idx].selected = true;\n                    } else {\n                        this.root.options[idx].selected = false;\n                    }\n                }\n                this.root.onchange = selector;\n            },\n            onValid() {\n                if (this.root.parentElement.classList.contains('field')) {\n                    this.field = this.root.parentElement;\n                } else {\n                    if (this.root.parentElement.parentElement.classList.contains('field')) {\n                        this.field = this.root.parentElement.parentElement;\n                    } else {\n                        return ;\n                    }\n                }\n\n                this.props.data.on('valid:'+ this.props.name, (valid) => {\n                    if (valid) {\n                        this.field.classList.remove('error');\n                    } else {\n                        if (!this.field.classList.contains('error')) {\n                            this.field.classList.add('error');\n                        }\n                    }\n                });\n            },\n            setBinding() {\n                this.isValidator = false;\n                this.validation = {\n                    validate:  'string',\n                    required:  false\n                };\n\n                if (typeof this.props.data !== 'undefined') {\n                    if (typeof this.props.data.validate !== 'undefined') {\n                        this.isValidator = true;\n                        this.validation = {\n                            validate:  (typeof this.props.validate !== 'undefined') ? this.props.validate : 'string',\n                            required:  (typeof this.props.required !== 'undefined')\n                        };\n                        this.onValid();\n                        this.props.data.isRequired(this.props.name, this.validation.required);\n                    }\n                }\n\n                if (this.root.tagName === 'INPUT') {\n                    switch(this.root.type) {\n                        case 'text':\n                        case 'search':\n                        case 'telephone':\n                            this.setInput('string');\n                            break;\n                        case 'checkbox':\n                        case 'radio':\n                            this.setCheck();\n                            break;\n                        case 'number':\n                        case 'range':\n                            this.setInput('number');\n                            break;\n                        case 'url':\n                            this.setInput('url');\n                            break;\n                        case 'date':\n                        case 'datetime':\n                        case 'datetime-local':\n                        case 'month':\n                        case 'week':\n                        case 'time':\n                        case 'color':\n                            this.setInput('string');\n                            break;\n                    }\n                } else if (this.root.tagName === 'TEXTAREA') {\n                    this.setTextArea();\n                } else if (this.root.tagName === 'SELECT') {\n                    this.setSelect();\n                }\n            },\n            onMounted(props, state) {\n                this.setBinding();\n            },\n            onUpdated(props, state) {\n                this.setBinding();\n            }\n        }\n    </script>\n</binding>\n","<codemirror-tag>\n    <slot/>\n    <script>\n        export default {\n            cm: null,\n            emitcm: null,\n            onMounted(props, state) {\n                let width    = (typeof props.width !== 'undefined') ?  props.width : 'auto'\n                let height   = (typeof props.height !== 'undefined') ?  props.height : 'auto'\n                let readonly = (typeof props.readonly !== 'undefined') ?  true : false\n                this.emitcm  = (typeof props.onupdate !== 'undefined') ?  props.onupdate : null\n                console.log(readonly)\n\n                let body = this.root.innerHTML\n                this.root.innerHTML = ''\n                this.cm = CodeMirror(\n                    this.root,\n                    {\n                        mode: 'simplemode',\n                        readOnly: readonly,\n                        autofocus: true,\n                        label: 'label',\n                        styleActiveLine: true,\n                        lineNumbers: true,\n                        lineWrapping: true,\n                        scrollbarStyle: 'simple',\n                        gutters: ['CodeMirror-linenumbers', 'leafpoints'],\n                        tabSize: 4,\n                        value: body\n                    }\n                )\n                this.cm.setSize(width, height);\n            },\n            onUpdated(props, state) {\n                if (null !== this.emitcm) {\n                    this.emitcm(this.cm)\n                }\n            }\n        }\n    </script>\n    <style>\n        .CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}\n        .CodeMirror-selected  { background-color: blue !important; }\n        .CodeMirror-selectedtext { color: white; }\n        .styled-background { background-color: #ff7; }\n    </style>\n</codemirror-tag>\n","<number-format-tag>\r\n    <script>\r\n        export default {\r\n            setInnerHTML(number) {\r\n                this.root.innerHTML = new Intl.NumberFormat(\r\n                    'en-IN', { \r\n                        maximumSignificantDigits: 3 \r\n                    }\r\n                ).format(number);\r\n            },\r\n            onMounted(props, state) {\r\n                this.setInnerHTML(props.number)\r\n            },\r\n            onUpdated(props, state) {\r\n                this.setInnerHTML(props.number)\r\n            }\r\n        }\r\n    </script>\r\n</number-format-tag>\r\n","<pagination-tag>\n    <div class=\"ui pagination menu\">\n        <a class=\"icon item\" onclick=\"{(e)=> select(this, e, 1)}\"><i class=\"angle double left icon\"></i></a>\n        <a class=\"icon item\" onclick=\"{(e)=> select(this, e, prev)}\"><i class=\"angle left icon\"></i></a>\n        <a each=\"{ item in pager }\" class=\"item{ item.curr ? ' active' : '' }\" onclick=\"{(e)=> select(this, e, item.page)}\">{ item.page }</a>\n        <a class=\"icon item\" onclick=\"{(e)=> select(this, e, next)}\"><i class=\"angle right icon\"></i></a>\n        <a class=\"icon item\" onclick=\"{(e)=> select(this, e, last)}\"><i class=\"angle double right icon\"></i></a>\n    </div>\n    <p class=\"pager_txt\">全{total}件 {page} ／ {last}ページ</p>\n    <script>\n        export default {\n            onBeforeMount(props, state) {\n                this.page = 1;\n                this.total = 1;\n                this.last = 1;\n                this.prev = 1;\n                this.next = 1;\n                this.pager = [];\n                this.setPager(props.pager);\n            },\n            onBeforeUpdate(props, state) {\n                this.setPager(props.pager);\n            },\n            setPager(pager) {\n                this.page = (typeof pager.page !== 'undefined') ? pager.page: 1;\n                this.total = (typeof pager.total !== 'undefined') ? pager.total: 1;\n                this.last = (typeof pager.last !== 'undefined') ? pager.last: 1;\n                this.prev = (typeof pager.prev !== 'undefined') ? pager.prev: 1;\n                this.next = (typeof pager.next !== 'undefined') ? pager.next: 1;\n\n                let start = this.page  - 5\n                  , end = this.page  + 5\n                  , page = 0\n                  , list = [];\n\n                if (0 >= start) {\n                    end = end + start * -1;\n                    start = 1;\n                }\n                if (this.last <= end) {\n                    end = this.last;\n                }\n\n                for (page=start; page < this.page; page++) {\n                    list.push({ page:page, curr:false });\n                }\n                list.push({ page:this.page, curr:true });\n\n                for (page++; page <= end; page++) {\n                    list.push({ page:page, curr:false });\n                }\n                this.pager = list;\n            },\n            select(parent, e, page) {\n                if (typeof parent.props === 'undefined') {\n                    return ;\n                } else if (typeof parent.props.onpager === 'undefined') {\n                    return ;\n                }\n                parent.props.onpager(e, page);\n            }\n        }\n    </script>\n</pagination-tag>\n","<radar-chart-tag>\n    <slot/>\n    <script>\n        import radarChart from '@croco/radar-chart';\n\n        export default {\n            onMounted(props, state) {\n                let width  = (typeof props.width !== 'undefined') ?  props.width : 250\n                let height = (typeof props.height !== 'undefined') ?  props.height : 250\n                let data   = (typeof props.data !== 'undefined') ?  props.data : null\n\n                radarChart.draw(this.root, data, {\n                    w: width,\n                    h: height,\n                    maxValue: 71.98197841644287,\n                    levels: 6,\n                    ExtraWidthX: width + 50\n                })\n\n            }\n        }\n    </script>\n</radar-chart-tag>\n","//Practically all this code comes from https://github.com/alangrafu/radar-chart-d3\n//I only made some additions and aesthetic adjustments to make the chart look better \n//(of course, that is only my point of view)\n//Such as a better placement of the titles at each line end, \n//adding numbers that reflect what each circular level stands for\n//Not placing the last level and slight differences in color\n//\n//For a bit of extra information check the blog about it:\n//http://nbremer.blogspot.nl/2013/09/making-d3-radar-chart-look-bit-better.html\n\nexport default {\n    draw: function(id, d, options) {\n        let cfg = {\n            radius: 5,\n            w: 600,\n            h: 600,\n            factor: 1,\n            factorLegend: .85,\n            levels: 3,\n            maxValue: 0,\n            radians: 2 * Math.PI,\n            opacityArea: 0.5,\n            ToRight: 5,\n            TranslateX: 80,\n            TranslateY: 30,\n            ExtraWidthX: 100,\n            ExtraWidthY: 100,\n            color: d3.schemeCategory10\n        };\n      \n        if ('undefined' !== typeof options) {\n            for (let i in options) {\n                if ('undefined' !== typeof options[i]){\n                    cfg[i] = options[i];\n                }\n            }\n        }\n        cfg.maxValue = Math.max(cfg.maxValue, d3.max(d, function(i){return d3.max(i.map(function(o){return o.value;}))}));\n        let allAxis = (d[0].map(function(i, j){return i.axis}));\n        let total = allAxis.length;\n        let radius = cfg.factor*Math.min(cfg.w/2, cfg.h/2);\n        let Format = d3.format('%');\n        d3.select(id).select(\"svg\").remove();\n      \n        let g = d3.select(id)\n              .append(\"svg\")\n              .attr(\"width\", cfg.w+cfg.ExtraWidthX)\n              .attr(\"height\", cfg.h+cfg.ExtraWidthY)\n              .append(\"g\")\n              .attr(\"transform\", \"translate(\" + cfg.TranslateX + \",\" + cfg.TranslateY + \")\");\n              ;\n  \n        let tooltip;\n      \n        //Circular segments\n        for (let j=0; j<cfg.levels-1; j++) {\n            let levelFactor = cfg.factor*radius*((j+1)/cfg.levels);\n            g.selectAll(\".levels\")\n                .data(allAxis)\n                .enter()\n                .append(\"svg:line\")\n                .attr(\"x1\", function(d, i){return levelFactor*(1-cfg.factor*Math.sin(i*cfg.radians/total));})\n                .attr(\"y1\", function(d, i){return levelFactor*(1-cfg.factor*Math.cos(i*cfg.radians/total));})\n                .attr(\"x2\", function(d, i){return levelFactor*(1-cfg.factor*Math.sin((i+1)*cfg.radians/total));})\n                .attr(\"y2\", function(d, i){return levelFactor*(1-cfg.factor*Math.cos((i+1)*cfg.radians/total));})\n                .attr(\"class\", \"line\")\n                .style(\"stroke\", \"grey\")\n                .style(\"stroke-opacity\", \"0.75\")\n                .style(\"stroke-width\", \"0.3px\")\n                .attr(\"transform\", \"translate(\" + (cfg.w/2-levelFactor) + \", \" + (cfg.h/2-levelFactor) + \")\");\n        }\n  \n        //Text indicating at what % each level is\n        for (let j=0; j<cfg.levels; j++) {\n            let levelFactor = cfg.factor*radius*((j+1)/cfg.levels);\n            g.selectAll(\".levels\")\n            .data([1]) //dummy data\n            .enter()\n            .append(\"svg:text\")\n            .attr(\"x\", function(d){return levelFactor*(1-cfg.factor*Math.sin(0));})\n            .attr(\"y\", function(d){return levelFactor*(1-cfg.factor*Math.cos(0));})\n            .attr(\"class\", \"legend\")\n            .style(\"font-family\", \"sans-serif\")\n            .style(\"font-size\", \"10px\")\n            .attr(\"transform\", \"translate(\" + (cfg.w/2-levelFactor + cfg.ToRight) + \", \" + (cfg.h/2-levelFactor) + \")\")\n            .attr(\"fill\", \"#737373\")\n//            .text(Format((j+1)*cfg.maxValue/cfg.levels));\n        }\n      \n        let series = 0;\n  \n        let axis = g.selectAll(\".axis\")\n              .data(allAxis)\n              .enter()\n              .append(\"g\")\n              .attr(\"class\", \"axis\");\n  \n        axis.append(\"line\")\n            .attr(\"x1\", cfg.w/2)\n            .attr(\"y1\", cfg.h/2)\n            .attr(\"x2\", function(d, i){return cfg.w/2*(1-cfg.factor*Math.sin(i*cfg.radians/total));})\n            .attr(\"y2\", function(d, i){return cfg.h/2*(1-cfg.factor*Math.cos(i*cfg.radians/total));})\n            .attr(\"class\", \"line\")\n            .style(\"stroke\", \"grey\")\n            .style(\"stroke-width\", \"1px\");\n    \n        axis.append(\"text\")\n            .attr(\"class\", \"legend\")\n            .text(function(d){return d})\n            .style(\"font-family\", \"sans-serif\")\n            .style(\"font-size\", \"11px\")\n            .attr(\"text-anchor\", \"middle\")\n            .attr(\"dy\", \"1.5em\")\n            .attr(\"transform\", function(d, i){return \"translate(0, -10)\"})\n            .attr(\"x\", function(d, i){return cfg.w/2*(1-cfg.factorLegend*Math.sin(i*cfg.radians/total))-60*Math.sin(i*cfg.radians/total);})\n            .attr(\"y\", function(d, i){return cfg.h/2*(1-Math.cos(i*cfg.radians/total))-20*Math.cos(i*cfg.radians/total);});\n  \n        let dataValues = [];\n\n        d.forEach(function(y, x) {\n            dataValues = [];\n            g.selectAll(\".nodes\")\n            .data(y, function(j, i){\n                dataValues.push([\n                cfg.w/2*(1-(parseFloat(Math.max(j.value, 0))/cfg.maxValue)*cfg.factor*Math.sin(i*cfg.radians/total)), \n                cfg.h/2*(1-(parseFloat(Math.max(j.value, 0))/cfg.maxValue)*cfg.factor*Math.cos(i*cfg.radians/total))\n                ]);\n            });\n        dataValues.push(dataValues[0]);\n        g.selectAll(\".area\")\n                       .data([dataValues])\n                       .enter()\n                       .append(\"polygon\")\n                       .attr(\"class\", \"radar-chart-serie\"+series)\n                       .style(\"stroke-width\", \"2px\")\n                       .style(\"stroke\", cfg.color[series])\n                       .attr(\"points\",function(d) {\n                           let str=\"\";\n                           for(let pti=0;pti<d.length;pti++){\n                               str=str+d[pti][0]+\",\"+d[pti][1]+\" \";\n                           }\n                           return str;\n                        })\n                       .style(\"fill\", function(j, i){return cfg.color[series]})\n                       .style(\"fill-opacity\", cfg.opacityArea)\n                       .on('mouseover', function (d){\n                                          z = \"polygon.\"+d3.select(this).attr(\"class\");\n                                          g.selectAll(\"polygon\")\n                                           .transition(200)\n                                           .style(\"fill-opacity\", 0.1); \n                                          g.selectAll(z)\n                                           .transition(200)\n                                           .style(\"fill-opacity\", .7);\n                                        })\n                       .on('mouseout', function(){\n                                          g.selectAll(\"polygon\")\n                                           .transition(200)\n                                           .style(\"fill-opacity\", cfg.opacityArea);\n                       });\n            series++;\n        });\n        series=0;\n  \n  \n        d.forEach(function(y, x) {\n            g.selectAll(\".nodes\")\n                .data(y).enter()\n                .append(\"svg:circle\")\n                .attr(\"class\", \"radar-chart-serie\"+series)\n                .attr('r', cfg.radius)\n                .attr(\"alt\", function(j){return Math.max(j.value, 0)})\n                .attr(\"cx\", function(j, i) {\n                    dataValues.push([\n                        cfg.w/2*(1-(parseFloat(Math.max(j.value, 0))/cfg.maxValue)*cfg.factor*Math.sin(i*cfg.radians/total)), \n                        cfg.h/2*(1-(parseFloat(Math.max(j.value, 0))/cfg.maxValue)*cfg.factor*Math.cos(i*cfg.radians/total))\n                    ]);\n                    return cfg.w/2*(1-(Math.max(j.value, 0)/cfg.maxValue)*cfg.factor*Math.sin(i*cfg.radians/total));\n                })\n                .attr(\"cy\", function(j, i){\n                    return cfg.h/2*(1-(Math.max(j.value, 0)/cfg.maxValue)*cfg.factor*Math.cos(i*cfg.radians/total));\n                })\n                .attr(\"data-id\", function(j){return j.axis})\n                .style(\"fill\", cfg.color[series]).style(\"fill-opacity\", .9)\n                .on('mouseover', function (d){\n                      newX =  parseFloat(d3.select(this).attr('cx')) - 10;\n                      newY =  parseFloat(d3.select(this).attr('cy')) - 5;\n                      \n                      tooltip\n                          .attr('x', newX)\n                          .attr('y', newY)\n                          .text(Format(d.value))\n                          .transition(200)\n                          .style('opacity', 1);\n                          \n                      z = \"polygon.\"+d3.select(this).attr(\"class\");\n                      g.selectAll(\"polygon\")\n                          .transition(200)\n                          .style(\"fill-opacity\", 0.1); \n                      g.selectAll(z)\n                          .transition(200)\n                          .style(\"fill-opacity\", .7);\n                    })\n          .on('mouseout', function(){\n                      tooltip\n                          .transition(200)\n                          .style('opacity', 0);\n                      g.selectAll(\"polygon\")\n                          .transition(200)\n                          .style(\"fill-opacity\", cfg.opacityArea);\n                    })\n          .append(\"svg:title\")\n          .text(function(j){return Math.max(j.value, 0)});\n  \n        series++;\n      });\n      //Tooltip\n      tooltip = g.append('text')\n                 .style('opacity', 0)\n                 .style('font-family', 'sans-serif')\n                 .style('font-size', '13px');\n    }\n};\n  ","<raw-tag>\n    <script>\n        export default {\n            setInnerHTML(html) {\n                this.root.innerHTML = html;\n            },\n            onMounted(props, state) {\n                this.setInnerHTML(props.html);\n            },\n            onUpdated(props, state) {\n                this.setInnerHTML(props.html);\n            }\n        }\n    </script>\n</raw-tag>\n","/* コアライブラリ */\nimport 'riot';\nimport Router       from '@croco/router';\nimport Util         from '@croco/util';\nimport DI           from '@croco/dependeny-injection';\n\n/* ユーティリティタグ */\nimport binding      from '@croco-tags/utils/binding.riot';\nimport codemirror   from '@croco-tags/utils/codemirror.riot';\nimport numberFormat from '@croco-tags/utils/number-format.riot';\nimport pagination   from '@croco-tags/utils/pagination.riot';\nimport radarChart   from '@croco-tags/utils/radar-chart.riot';\nimport raw          from '@croco-tags/utils/raw.riot';\n\nconst config =  {\n};\n\n/* DIコンテナ */\nconst DependenyInjection = new DI();\n\n/* オブジェクト登録 */\nDependenyInjection.set('riot', riot);\nDependenyInjection.set('config', config);\nDependenyInjection.set('util', Util.utils);\nDependenyInjection.set('route', new Router());\n\n/* タグの登録 */\nDependenyInjection.riot.register('binding', binding);\nDependenyInjection.riot.register('codemirror-tag', codemirror);\nDependenyInjection.riot.register('number-format-tag', numberFormat);\nDependenyInjection.riot.register('pagination-tag', pagination);\nDependenyInjection.riot.register('radar-chart-tag', radarChart);\nDependenyInjection.riot.register('raw-tag', raw);\n\nexport default DependenyInjection;\n","/**\n * DependenyInjection\n *\n * @package     croco-fw\n * @author      Yujiro Takahashi <yujiro@cro-co.co.jp>\n */\nclass DependenyInjection {\n    /**\n     * コンストラクタ\n     *\n     * @access public\n     * @param  array opts\n     * @return void\n     */\n    constructor() {\n        this.objects = new Map();\n    }\n\n    /**\n     * プロパティ設定\n     *\n     * @access private\n     * @return void\n     */\n    set(prop, service) {\n        Object.defineProperty(this, prop, {\n            get: ()=> {\n                return service;\n            },\n            enumerable: true,\n            configurable: false\n        });\n    }\n\n    /**\n     * サービスの即時登録\n     *\n     * @access private\n     * @return void\n     */\n    registr(prop, service) {\n        Object.defineProperty(this, prop, {\n            get: ()=> {\n                if (!this.objects.has(prop)) {\n                    let obj = service();\n                    this.objects.set(prop, obj);\n                }\n                return this.objects.get(prop);\n            },\n            enumerable: true,\n            configurable: false\n        });\n    }\n} // class DependenyInjection\n\nexport default DependenyInjection;\n","import di        from 'dependeny-injection';\nimport container from './tags/rules.riot';\n\nconst mtContainer = di.riot.component(container);\nmtContainer(\n    document.getElementById('root')\n);\n"],"names":["getWait","wait","defer","deferred","promise","Promise","resolve","reject","module","exports","fn","arguments","length","undefined","options","lastCallAt","timer","pendingArgs","currentWait","currentTime","Date","getTime","isCold","_len","args","Array","_key","leading","accumulate","call","this","then","result","apply","concat","clearTimeout","push","setTimeout","flush","bind","argsIndex","results","thisDeferred","debounce","func","immediate","timeout","context","timestamp","later","last","now","debounced","callNow","clear","COMPONENTS_IMPLEMENTATION_MAP","Map","DOM_COMPONENT_INSTANCE_PROPERTY","Symbol","PLUGINS_SET","Set","MOUNT_METHOD_KEY","UPDATE_METHOD_KEY","UNMOUNT_METHOD_KEY","IS_PURE_SYMBOL","for","PARENT_KEY_SYMBOL","ATTRIBUTES_KEY_SYMBOL","TEMPLATE_KEY_SYMBOL","globals","Object","freeze","__proto__","IS_DIRECTIVE","VALUE_ATTRIBUTE","isFunction","value","noop","callOrAssign","source","prototype","constructor","moveChildren","target","firstChild","appendChild","clearChildren","children","from","forEach","n","parentNode","removeChild","bindingTypes","EACH","IF","SIMPLE","TAG","SLOT","expressionTypes","ATTRIBUTE","EVENT","TEXT","VALUE","indexOf","iOF","append","get","parent","start","end","before","isSelect","noSelection","child","insertBefore","selected","selectedIndex","querySelectorAll","eqeq","a","b","identity","O","moreNodes","moreStart","moreEnd","lessNodes","lessStart","lessEnd","compare","m","l","next","list","i","nextSibling","remove","drop","findK","ktr","j","lo","hi","mid","smartDiff","futureNodes","futureStart","futureEnd","futureChanges","currentNodes","currentStart","currentEnd","currentChanges","currentLength","diff","live","currentIndex","applyDiff","rows","cols","v","d","k","r","c","pv","cv","pd","outer","diffIdx","OND","minLen","link","tresh","nodes","slice","index","idxInOld","newi","oldi","prev","ptr","HS","node","dropChild","checkType$1","element","type","isSvg","el","owner","ownerSVGElement","isTemplate","isNil","content","isObject","UNMOUNT_SCOPE","EachBinding","seal","mount","scope","parentScope","update","placeholder","childrenMap","collection","evaluate","items","newChildrenMap","batches","binding","condition","template","itemName","getKey","indexName","root","isTemplateTag","item","_ref","extendScope","create","key","oldItem","Boolean","mustFilterItem","componentTemplate","clone","cloneNode","mustMount","meta","fragment","dom","avoidDOMInjection","childNodes","createTemplateMeta","set","delete","createPatch","currentSame","futureSame","isReversed","domdiff","patch","values","unmount","redundant","info","pop","IfBinding","mustUnmount","pristine","REMOVE_ATTRIBUTE","SET_ATTIBUTE","attributeExpression","_ref5","oldValue","name","isBoolean","getMethod","normalizeValue","attributes","entries","_ref4","setAllAttributes","keys","attribute","removeAttribute","removeAllAttributes","RE_EVENTS_PREFIX","normalizeStringValue","getTextNode","childNodeIndex","nodeType","Node","COMMENT_NODE","textNode","document","createTextNode","replaceChild","expressions","_ref6","normalizedEventName","replace","removeEventListener","addEventListener","data","expression","Expression","create$2","assign","extendParentScope","map","attr","reduce","acc","string","_","toUpperCase","evaluateAttributeExpressions","SlotBinding","getTemplateScope","templateData","slots","find","_ref8","id","create$6","html","bindings","createDOM","moveSlotInnerContent","mustRemoveRoot","slot","slotBindings","_ref10","TagBinding","tag","component","slotsToMarkup","getTag","getComponent","keepRootTag","_ref3","_ref7","method","_ref2","_ref11","_ref9","fixTextExpressionsOffset","textExpressionsOffset","e","createDOMTree","container","ownerDocument","importNode","window","DOMParser","parseFromString","documentElement","createSVGTree","createElement","innerHTML","createHTMLTree","injectDOM","TemplateChunk","createTemplateDOM","Error","templateTagOffset","Math","max","bindingsData","selector","redundantAttribute","querySelector","bindingExpressions","create$5","defineProperty","enumerable","writable","configurable","defineProperties","properties","defineDefaults","defaults","dashToCamelCase$1","panic","message","domToArray","els","isArray","test","toString","$","ctx","normalize","attrs","props","prop","setAttribute","names","parseNodes","CSS_BY_NAME","style","cssManager","add","css","has","inject","head","join","curry","_len2","_key2","getName","tagName","toLowerCase","COMPONENT_CORE_HELPERS","$$","PURE_COMPONENT_API","COMPONENT_LIFECYCLE_METHODS","shouldUpdate","onBeforeMount","onMounted","onBeforeUpdate","onUpdated","onBeforeUnmount","onUnmounted","MOCKED_TEMPLATE_INTERFACE","createCoreAPIMethods","mapFunction","createComponent","templateFn","components","componentTemplateFactory","pureFactoryFunction","createPureComponent","componentAPI","defineComponent","state","preserveRoot","enhanceComponentAPI","evaluateProps","attributeExpressions","DOMattributesToObject","computeState","oldState","newState","initialProps","runPlugins","createAttributeBindings","addCssHook","newProps","filter","DOM_COMPONENT_INSTANCE_PROPERTY$1","COMPONENTS_IMPLEMENTATION_MAP$1","PLUGINS_SET$1","__","implementation","_temp","fns","f","g","compose","install","plugin","componentName","mountComponent","pure","register","uninstall","keepRootElement","unregister","version","factory","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","definition","o","obj","hasOwnProperty","utils","strLen","val","String","match","numberformat","Intl","NumberFormat","maximumSignificantDigits","format","addIFrame","src","body","byteformat","size","sizes","ext","idx","round","setInput","validate","input","isValidator","validation","onkeyup","onchange","setCheck","checked","hasAttribute","getAttribute","onclick","setTextArea","setSelect","onValid","parentElement","classList","contains","field","on","valid","setBinding","required","isRequired","cm","emitcm","width","height","readonly","onupdate","console","log","CodeMirror","mode","readOnly","autofocus","label","styleActiveLine","lineNumbers","lineWrapping","scrollbarStyle","gutters","tabSize","setSize","setInnerHTML","number","page","total","pager","setPager","curr","select","onpager","cfg","radius","w","h","factor","factorLegend","levels","maxValue","radians","PI","opacityArea","ToRight","TranslateX","TranslateY","ExtraWidthX","ExtraWidthY","color","d3","schemeCategory10","allAxis","axis","min","Format","tooltip","levelFactor","selectAll","enter","sin","cos","series","text","dataValues","y","x","parseFloat","str","pti","z","transition","newX","newY","DependenyInjection","objects","service","registr","riot","Util","RE_ORIGIN","POPSTATE","HASHCHANGE","MAX_EMIT_STACK_LEVEL","win","doc","hist","history","loc","location","emitDebounce","emit","clickEvent","ontouchstart","_routeFound","_current","_emitStack","_emitStackLevel","_base","_args","_routing","_parser","DEFAULT_PARSER","_secondParser","DEFAULT_SECOND_PARSER","_stateActions","path","split","re","RegExp","autoExec","click","stop","stopper","getPathFromBase","action","getArgs","getPathFromRoot","href","base","force","isRoot","emitter","first","shift","which","metaKey","ctrlKey","shiftKey","defaultPrevented","nodeName","go","title","preventDefault","shouldReplace","replaceState","pushState","query","q","isString","second","third","collback","_emitAction","arg","exec","parser","fn2","started","routing","codemirror","numberFormat","pagination","radarChart","raw","di","mtContainer","getElementById"],"sourceRoot":""}