{"version":3,"sources":["webpack:///./node_modules/core-js-pure/modules/es.object.create.js","webpack:///./node_modules/core-js-pure/stable/instance/trim.js","webpack:///./node_modules/core-js-pure/stable/object/create.js","webpack:///./node_modules/core-js-pure/es/instance/trim.js","webpack:///./node_modules/core-js-pure/es/function/virtual/bind.js","webpack:///./node_modules/core-js-pure/es/object/create.js","webpack:///./node_modules/core-js-pure/modules/es.string.trim.js","webpack:///./node_modules/@babel/runtime-corejs3/core-js-stable/instance/trim.js","webpack:///./node_modules/underscore/modules/restArguments.js","webpack:///./node_modules/underscore/modules/isObject.js","webpack:///./node_modules/underscore/modules/isNull.js","webpack:///./node_modules/underscore/modules/isUndefined.js","webpack:///./node_modules/underscore/modules/isBoolean.js","webpack:///./node_modules/underscore/modules/isElement.js","webpack:///./node_modules/underscore/modules/_tagTester.js","webpack:///./node_modules/underscore/modules/isString.js","webpack:///./node_modules/underscore/modules/isNumber.js","webpack:///./node_modules/underscore/modules/isDate.js","webpack:///./node_modules/underscore/modules/isRegExp.js","webpack:///./node_modules/underscore/modules/isError.js","webpack:///./node_modules/underscore/modules/isSymbol.js","webpack:///./node_modules/underscore/modules/isArrayBuffer.js","webpack:///./node_modules/underscore/modules/isFunction.js","webpack:///./node_modules/underscore/modules/_hasObjectTag.js","webpack:///./node_modules/underscore/modules/_stringTagBug.js","webpack:///./node_modules/underscore/modules/isDataView.js","webpack:///./node_modules/underscore/modules/isArray.js","webpack:///./node_modules/underscore/modules/_has.js","webpack:///./node_modules/underscore/modules/isArguments.js","webpack:///./node_modules/underscore/modules/isFinite.js","webpack:///./node_modules/underscore/modules/isNaN.js","webpack:///./node_modules/underscore/modules/constant.js","webpack:///./node_modules/underscore/modules/_createSizePropertyCheck.js","webpack:///./node_modules/underscore/modules/_shallowProperty.js","webpack:///./node_modules/underscore/modules/_getByteLength.js","webpack:///./node_modules/underscore/modules/_isBufferLike.js","webpack:///./node_modules/underscore/modules/isTypedArray.js","webpack:///./node_modules/underscore/modules/_getLength.js","webpack:///./node_modules/underscore/modules/_collectNonEnumProps.js","webpack:///./node_modules/underscore/modules/keys.js","webpack:///./node_modules/underscore/modules/isEmpty.js","webpack:///./node_modules/underscore/modules/isMatch.js","webpack:///./node_modules/underscore/modules/underscore.js","webpack:///./node_modules/underscore/modules/_toBufferView.js","webpack:///./node_modules/underscore/modules/isEqual.js","webpack:///./node_modules/underscore/modules/allKeys.js","webpack:///./node_modules/underscore/modules/_methodFingerprint.js","webpack:///./node_modules/underscore/modules/isMap.js","webpack:///./node_modules/underscore/modules/isWeakMap.js","webpack:///./node_modules/underscore/modules/isSet.js","webpack:///./node_modules/underscore/modules/isWeakSet.js","webpack:///./node_modules/underscore/modules/values.js","webpack:///./node_modules/underscore/modules/pairs.js","webpack:///./node_modules/underscore/modules/invert.js","webpack:///./node_modules/underscore/modules/functions.js","webpack:///./node_modules/underscore/modules/_createAssigner.js","webpack:///./node_modules/underscore/modules/extend.js","webpack:///./node_modules/underscore/modules/extendOwn.js","webpack:///./node_modules/underscore/modules/defaults.js","webpack:///./node_modules/underscore/modules/_baseCreate.js","webpack:///./node_modules/underscore/modules/create.js","webpack:///./node_modules/underscore/modules/clone.js","webpack:///./node_modules/underscore/modules/tap.js","webpack:///./node_modules/underscore/modules/toPath.js","webpack:///./node_modules/underscore/modules/_toPath.js","webpack:///./node_modules/underscore/modules/_deepGet.js","webpack:///./node_modules/underscore/modules/get.js","webpack:///./node_modules/underscore/modules/has.js","webpack:///./node_modules/underscore/modules/identity.js","webpack:///./node_modules/underscore/modules/matcher.js","webpack:///./node_modules/underscore/modules/property.js","webpack:///./node_modules/underscore/modules/_optimizeCb.js","webpack:///./node_modules/underscore/modules/_baseIteratee.js","webpack:///./node_modules/underscore/modules/iteratee.js","webpack:///./node_modules/underscore/modules/_cb.js","webpack:///./node_modules/underscore/modules/mapObject.js","webpack:///./node_modules/underscore/modules/noop.js","webpack:///./node_modules/underscore/modules/propertyOf.js","webpack:///./node_modules/underscore/modules/times.js","webpack:///./node_modules/underscore/modules/random.js","webpack:///./node_modules/underscore/modules/now.js","webpack:///./node_modules/underscore/modules/_createEscaper.js","webpack:///./node_modules/underscore/modules/_escapeMap.js","webpack:///./node_modules/underscore/modules/escape.js","webpack:///./node_modules/underscore/modules/unescape.js","webpack:///./node_modules/underscore/modules/_unescapeMap.js","webpack:///./node_modules/underscore/modules/templateSettings.js","webpack:///./node_modules/underscore/modules/template.js","webpack:///./node_modules/underscore/modules/result.js","webpack:///./node_modules/underscore/modules/uniqueId.js","webpack:///./node_modules/underscore/modules/chain.js","webpack:///./node_modules/underscore/modules/_executeBound.js","webpack:///./node_modules/underscore/modules/partial.js","webpack:///./node_modules/underscore/modules/bind.js","webpack:///./node_modules/underscore/modules/_isArrayLike.js","webpack:///./node_modules/underscore/modules/_flatten.js","webpack:///./node_modules/underscore/modules/bindAll.js","webpack:///./node_modules/underscore/modules/memoize.js","webpack:///./node_modules/underscore/modules/delay.js","webpack:///./node_modules/underscore/modules/defer.js","webpack:///./node_modules/underscore/modules/throttle.js","webpack:///./node_modules/underscore/modules/debounce.js","webpack:///./node_modules/underscore/modules/wrap.js","webpack:///./node_modules/underscore/modules/negate.js","webpack:///./node_modules/underscore/modules/compose.js","webpack:///./node_modules/underscore/modules/after.js","webpack:///./node_modules/underscore/modules/before.js","webpack:///./node_modules/underscore/modules/once.js","webpack:///./node_modules/underscore/modules/findKey.js","webpack:///./node_modules/underscore/modules/_createPredicateIndexFinder.js","webpack:///./node_modules/underscore/modules/findIndex.js","webpack:///./node_modules/underscore/modules/findLastIndex.js","webpack:///./node_modules/underscore/modules/sortedIndex.js","webpack:///./node_modules/underscore/modules/_createIndexFinder.js","webpack:///./node_modules/underscore/modules/indexOf.js","webpack:///./node_modules/underscore/modules/lastIndexOf.js","webpack:///./node_modules/underscore/modules/find.js","webpack:///./node_modules/underscore/modules/findWhere.js","webpack:///./node_modules/underscore/modules/each.js","webpack:///./node_modules/underscore/modules/map.js","webpack:///./node_modules/underscore/modules/_createReduce.js","webpack:///./node_modules/underscore/modules/reduce.js","webpack:///./node_modules/underscore/modules/reduceRight.js","webpack:///./node_modules/underscore/modules/filter.js","webpack:///./node_modules/underscore/modules/reject.js","webpack:///./node_modules/underscore/modules/every.js","webpack:///./node_modules/underscore/modules/some.js","webpack:///./node_modules/underscore/modules/contains.js","webpack:///./node_modules/underscore/modules/invoke.js","webpack:///./node_modules/underscore/modules/pluck.js","webpack:///./node_modules/underscore/modules/where.js","webpack:///./node_modules/underscore/modules/max.js","webpack:///./node_modules/underscore/modules/min.js","webpack:///./node_modules/underscore/modules/sample.js","webpack:///./node_modules/underscore/modules/shuffle.js","webpack:///./node_modules/underscore/modules/sortBy.js","webpack:///./node_modules/underscore/modules/_group.js","webpack:///./node_modules/underscore/modules/groupBy.js","webpack:///./node_modules/underscore/modules/indexBy.js","webpack:///./node_modules/underscore/modules/countBy.js","webpack:///./node_modules/underscore/modules/partition.js","webpack:///./node_modules/underscore/modules/toArray.js","webpack:///./node_modules/underscore/modules/size.js","webpack:///./node_modules/underscore/modules/_keyInObj.js","webpack:///./node_modules/underscore/modules/pick.js","webpack:///./node_modules/underscore/modules/omit.js","webpack:///./node_modules/underscore/modules/initial.js","webpack:///./node_modules/underscore/modules/first.js","webpack:///./node_modules/underscore/modules/rest.js","webpack:///./node_modules/underscore/modules/last.js","webpack:///./node_modules/underscore/modules/compact.js","webpack:///./node_modules/underscore/modules/flatten.js","webpack:///./node_modules/underscore/modules/difference.js","webpack:///./node_modules/underscore/modules/without.js","webpack:///./node_modules/underscore/modules/uniq.js","webpack:///./node_modules/underscore/modules/union.js","webpack:///./node_modules/underscore/modules/intersection.js","webpack:///./node_modules/underscore/modules/unzip.js","webpack:///./node_modules/underscore/modules/zip.js","webpack:///./node_modules/underscore/modules/object.js","webpack:///./node_modules/underscore/modules/range.js","webpack:///./node_modules/underscore/modules/chunk.js","webpack:///./node_modules/underscore/modules/_chainResult.js","webpack:///./node_modules/underscore/modules/mixin.js","webpack:///./node_modules/underscore/modules/underscore-array-methods.js","webpack:///./node_modules/underscore/modules/index-default.js","webpack:///(webpack)/buildin/amd-options.js","webpack:///./node_modules/core-js-pure/internals/function-bind.js","webpack:///./node_modules/core-js/modules/es.symbol.description.js","webpack:///./node_modules/underscore/modules/_setup.js","webpack:///./node_modules/core-js-pure/stable/instance/bind.js","webpack:///./node_modules/@babel/runtime-corejs3/core-js-stable/instance/bind.js","webpack:///./node_modules/core-js-pure/internals/string-trim-forced.js","webpack:///./node_modules/riot/riot.js","webpack:///./node_modules/core-js-pure/modules/es.function.bind.js","webpack:///./node_modules/core-js-pure/es/instance/bind.js","webpack:///./node_modules/core-js-pure/es/string/virtual/trim.js","webpack:///./node_modules/@babel/runtime-corejs3/core-js-stable/object/create.js"],"names":["$","target","stat","sham","create","parent","module","exports","trim","StringPrototype","String","prototype","it","own","entryVirtual","bind","Object","P","D","$trim","proto","forced","forcedStringTrimMethod","this","restArguments","func","startIndex","length","Math","max","arguments","rest","Array","index","call","args","apply","isObject","obj","type","isNull","isUndefined","isBoolean","isElement","nodeType","tagTester","name","tag","isFunction","nodelist","document","childNodes","Int8Array","hasStringTagBug","DataView","ArrayBuffer","isIE11","Map","isDataView","getInt8","isArrayBuffer","buffer","has","key","isArguments","isSymbol","isNaN","parseFloat","isNumber","constant","value","createSizePropertyCheck","getSizeProperty","collection","sizeProperty","shallowProperty","typedArrayPattern","test","collectNonEnumProps","keys","hash","l","i","contains","push","emulatedSet","nonEnumIdx","constructor","prop","isEmpty","isArray","isString","isMatch","object","attrs","_keys","_","_wrapped","toBufferView","bufferSource","Uint8Array","byteOffset","VERSION","valueOf","toJSON","toString","tagDataView","eq","a","b","aStack","bStack","deepEq","className","areArrays","aCtor","bCtor","pop","isEqual","allKeys","ie11fingerprint","methods","weakMapMethods","forEachName","commonInit","mapTail","mapMethods","concat","setMethods","values","pairs","invert","result","functions","names","sort","createAssigner","keysFunc","defaults","source","baseCreate","Ctor","props","extendOwn","clone","slice","extend","tap","interceptor","toPath","path","deepGet","get","defaultValue","identity","property","optimizeCb","context","argCount","accumulator","baseIteratee","Infinity","cb","iteratee","mapObject","results","currentKey","noop","propertyOf","times","n","accum","random","min","floor","Date","getTime","createEscaper","map","escaper","match","join","testRegexp","RegExp","replaceRegexp","string","replace","templateSettings","evaluate","interpolate","escape","noMatch","escapes","escapeRegExp","escapeChar","bareIdentifier","text","settings","oldSettings","matcher","offset","render","argument","variable","Error","Function","e","template","data","fallback","idCounter","uniqueId","prefix","id","chain","instance","_chain","executeBound","sourceFunc","boundFunc","callingContext","self","partial","boundArgs","placeholder","bound","position","TypeError","callArgs","flatten","input","depth","strict","output","idx","j","len","hasher","memoize","cache","address","wait","setTimeout","delay","throttle","options","timeout","previous","later","leading","now","throttled","_now","remaining","clearTimeout","trailing","cancel","debounce","immediate","passed","debounced","_args","wrap","wrapper","negate","predicate","compose","start","after","before","memo","findKey","createPredicateIndexFinder","dir","array","low","high","mid","createIndexFinder","predicateFind","sortedIndex","item","findIndex","findLastIndex","find","findWhere","each","createReduce","reducer","initial","filter","list","reject","every","some","fromIndex","guard","indexOf","contextPath","method","pluck","where","computed","lastComputed","v","sample","last","rand","temp","shuffle","sortBy","criteria","left","right","group","behavior","partition","pass","reStrSymbol","toArray","size","keyInObj","pick","first","compact","Boolean","otherArrays","difference","uniq","isSorted","seen","arrays","intersection","argsLength","unzip","range","stop","step","ceil","chunk","count","chainResult","mixin","__webpack_amd_options__","aFunction","factories","construct","C","that","fn","partArgs","boundFunction","DESCRIPTORS","global","defineProperty","f","copyConstructorProperties","NativeSymbol","Symbol","undefined","description","EmptyStringDescriptionStore","SymbolWrapper","symbolPrototype","symbolToString","native","regexp","configurable","symbol","desc","root","ArrayProto","ObjProto","SymbolProto","hasOwnProperty","supportsArrayBuffer","supportsDataView","nativeIsArray","nativeKeys","nativeCreate","nativeIsView","isView","_isNaN","_isFinite","isFinite","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","MAX_ARRAY_INDEX","pow","fails","whitespaces","METHOD_NAME","window","riot","version","__uid","__virtualDom","__tagImpl","GLOBAL_MIXIN","RIOT_PREFIX","RIOT_TAG","RIOT_TAG_IS","T_STRING","T_OBJECT","T_UNDEF","T_FUNCTION","XLINK_REGEX","SPECIAL_TAGS_REGEX","RESERVED_WORDS_BLACKLIST","SVG_TAGS_LIST","IE_VERSION","documentMode","FIREFOX","InstallTrigger","observable","el","callbacks","onEachEvent","es","split","defineProperties","on","events","pos","typed","enumerable","writable","off","arr","splice","one","trigger","fns","arglen","busy","debouncedEmit","base","current","parser","secondParser","RE_ORIGIN","POPSTATE","HASHCHANGE","win","doc","hist","history","loc","location","prot","Router","clickEvent","ontouchstart","started","central","routeFound","emitStack","emitStackLevel","DEFAULT_PARSER","DEFAULT_SECOND_PARSER","re","autoExec","t","emit","click","s","normalize","str","getPathFromRoot","href","getPathFromBase","force","isRoot","shift","which","metaKey","ctrlKey","shiftKey","defaultPrevented","nodeName","parentNode","go","title","preventDefault","shouldReplace","replaceState","pushState","m","second","third","r","action","mainRouter","route","newSubRouter","router","arg","exec","fn2","query","q","k","readyState","brackets","UNDEF","_regex","_settings","REGLOB","R_STRINGS","S_QBLOCKS","UNSUPPORTED","NEED_ESCAPE","FINDBRACES","DEFAULT","_pairs","cachedBrackets","_cache","_loopback","_rewrite","bp","_create","pair","_brackets","reOrIdx","_reset","tmpl","_bp","isexpr","parts","lastIndex","skipBraces","unescapeStr","ch","ix","recch","hasExpr","loopKeys","expr","val","set","o","R_MLCOMMS","_tmpl","qstr","RE_DQUOTE","_parseExpr","RE_QBMARK","_getTmpl","_logErr","err","ctx","errorHandler","riotData","tagName","_riot_id","haveRaw","hasRaw","clearCache","CH_IDEXPR","fromCharCode","RE_CSNAME","RE_QBLOCK","RE_BREND","asText","div","cnt","jsb","rightContext","_wrapExpr","mm","lv","ir","JS_CONTEXT","JS_VARNAME","JS_NOPROPS","tb","p","mvar","mkdom","reHasYield","reYieldAll","reYieldSrc","reYieldDest","rootEls","tr","th","td","col","tblTags","_mkdom","templ","html","checkSvg","toLowerCase","mkEl","src","ref","def","replaceYield","select","innerHTML","firstChild","selectedIndex","tname","childElementCount","specialTags","container","DOMParser","parseFromString","appendChild","ownerDocument","importNode","documentElement","setInnerHTML","stub","mkitem","moveNestedTags","child","tags","forEach","moveChildTag","addVirtual","sib","_root","_virts","nextSibling","insertBefore","moveVirtual","insertTag","isVirtual","prevTag","newTag","virtualFn","dom","isInStub","styleManager","_riot","add","inject","styleNode","newNode","setAttr","userNode","replaceChild","getElementsByTagName","cssTextProp","styleSheet","stylesToInject","css","cssText","parseNamedElements","childTags","forceParsingNamed","walk","isLoop","getAttr","getTag","opts","Tag","getTagName","ptag","getImmediateCustomParentTag","_parent","addChildTag","initChildTag","isArr","getNamedKey","setNamed","parseExpressions","expressions","addExpr","extra","attr","nodeValue","remAttr","hasKeys","mustReorder","impl","getOuterHTML","useRoot","createTextNode","isOption","oldItems","removeChild","items","frag","createDocumentFragment","itemsLength","_mustReorder","oldPos","hasImpl","cloneNode","mount","update","_item","unmount","unmountRedundant","multiple","__riot1374","_each","attributes","bool","conf","inherit","cleanUpData","propsInSyncWithParent","updateOpts","toCamel","inheritFrom","mustSync","onChildUpdate","toggle","isMount","evt","_tag","isMounted","isInherited","isWritable","normalizeData","attrName","handler","event","currentTarget","srcElement","charCode","keyCode","returnValue","preventUpdate","setEventHandler","remove","insertTo","inStub","style","display","rAF","mix","getPrototypeOf","getOwnPropertyNames","descriptor","getOwnPropertyDescriptor","hasGetterSetter","init","globalMixin","walkAttributes","keepRootTag","tagIndex","node","els","outerHTML","removeAttribute","c","toUpperCase","getAttribute","xlink","setAttributeNS","setAttribute","cachedTag","newPos","namedTag","isSvg","createElementNS","createElement","$$","selector","querySelectorAll","querySelector","mixins","globals","_id","w","raf","requestAnimationFrame","mozRequestAnimationFrame","webkitRequestAnimationFrame","navigator","userAgent","lastTime","nowtime","util","g","store","tag2","allTags","addRiotTags","selectAllTags","nodeList","_el","pushTags","riotTag","_innerHTML","mountTo","vdom","FunctionPrototype"],"mappings":"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","file":"script/chunks/chunk.2.c349ec72e7.js","sourcesContent":["var $ = require('../internals/export');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar create = require('../internals/object-create');\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, {\n  create: create\n});\n","var parent = require('../../es/instance/trim');\n\nmodule.exports = parent;\n","var parent = require('../../es/object/create');\n\nmodule.exports = parent;\n","var trim = require('../string/virtual/trim');\n\nvar StringPrototype = String.prototype;\n\nmodule.exports = function (it) {\n  var own = it.trim;\n  return typeof it === 'string' || it === StringPrototype\n    || (it instanceof String && own === StringPrototype.trim) ? trim : own;\n};\n","require('../../../modules/es.function.bind');\nvar entryVirtual = require('../../../internals/entry-virtual');\n\nmodule.exports = entryVirtual('Function').bind;\n","require('../../modules/es.object.create');\nvar path = require('../../internals/path');\n\nvar Object = path.Object;\n\nmodule.exports = function create(P, D) {\n  return Object.create(P, D);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $trim = require('../internals/string-trim').trim;\nvar forcedStringTrimMethod = require('../internals/string-trim-forced');\n\n// `String.prototype.trim` method\n// https://tc39.es/ecma262/#sec-string.prototype.trim\n$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {\n  trim: function trim() {\n    return $trim(this);\n  }\n});\n","module.exports = require(\"core-js-pure/stable/instance/trim\");","// Some functions take a variable number of arguments, or a few expected\n// arguments at the beginning and then a variable number of values to operate\n// on. This helper accumulates all remaining arguments past the function’s\n// argument length (or an explicit `startIndex`), into an array that becomes\n// the last argument. Similar to ES6’s \"rest parameter\".\nexport default function restArguments(func, startIndex) {\n  startIndex = startIndex == null ? func.length - 1 : +startIndex;\n  return function() {\n    var length = Math.max(arguments.length - startIndex, 0),\n        rest = Array(length),\n        index = 0;\n    for (; index < length; index++) {\n      rest[index] = arguments[index + startIndex];\n    }\n    switch (startIndex) {\n      case 0: return func.call(this, rest);\n      case 1: return func.call(this, arguments[0], rest);\n      case 2: return func.call(this, arguments[0], arguments[1], rest);\n    }\n    var args = Array(startIndex + 1);\n    for (index = 0; index < startIndex; index++) {\n      args[index] = arguments[index];\n    }\n    args[startIndex] = rest;\n    return func.apply(this, args);\n  };\n}\n","// Is a given variable an object?\nexport default function isObject(obj) {\n  var type = typeof obj;\n  return type === 'function' || type === 'object' && !!obj;\n}\n","// Is a given value equal to null?\nexport default function isNull(obj) {\n  return obj === null;\n}\n","// Is a given variable undefined?\nexport default function isUndefined(obj) {\n  return obj === void 0;\n}\n","import { toString } from './_setup.js';\n\n// Is a given value a boolean?\nexport default function isBoolean(obj) {\n  return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n}\n","// Is a given value a DOM element?\nexport default function isElement(obj) {\n  return !!(obj && obj.nodeType === 1);\n}\n","import { toString } from './_setup.js';\n\n// Internal function for creating a `toString`-based type tester.\nexport default function tagTester(name) {\n  var tag = '[object ' + name + ']';\n  return function(obj) {\n    return toString.call(obj) === tag;\n  };\n}\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('String');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Number');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Date');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('RegExp');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Error');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Symbol');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('ArrayBuffer');\n","import tagTester from './_tagTester.js';\nimport { root } from './_setup.js';\n\nvar isFunction = tagTester('Function');\n\n// Optimize `isFunction` if appropriate. Work around some `typeof` bugs in old\n// v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).\nvar nodelist = root.document && root.document.childNodes;\nif (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {\n  isFunction = function(obj) {\n    return typeof obj == 'function' || false;\n  };\n}\n\nexport default isFunction;\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Object');\n","import { supportsDataView } from './_setup.js';\nimport hasObjectTag from './_hasObjectTag.js';\n\n// In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`.\n// In IE 11, the most common among them, this problem also applies to\n// `Map`, `WeakMap` and `Set`.\nexport var hasStringTagBug = (\n      supportsDataView && hasObjectTag(new DataView(new ArrayBuffer(8)))\n    ),\n    isIE11 = (typeof Map !== 'undefined' && hasObjectTag(new Map));\n","import tagTester from './_tagTester.js';\nimport isFunction from './isFunction.js';\nimport isArrayBuffer from './isArrayBuffer.js';\nimport { hasStringTagBug } from './_stringTagBug.js';\n\nvar isDataView = tagTester('DataView');\n\n// In IE 10 - Edge 13, we need a different heuristic\n// to determine whether an object is a `DataView`.\nfunction ie10IsDataView(obj) {\n  return obj != null && isFunction(obj.getInt8) && isArrayBuffer(obj.buffer);\n}\n\nexport default (hasStringTagBug ? ie10IsDataView : isDataView);\n","import { nativeIsArray } from './_setup.js';\nimport tagTester from './_tagTester.js';\n\n// Is a given value an array?\n// Delegates to ECMA5's native `Array.isArray`.\nexport default nativeIsArray || tagTester('Array');\n","import { hasOwnProperty } from './_setup.js';\n\n// Internal function to check whether `key` is an own property name of `obj`.\nexport default function has(obj, key) {\n  return obj != null && hasOwnProperty.call(obj, key);\n}\n","import tagTester from './_tagTester.js';\nimport has from './_has.js';\n\nvar isArguments = tagTester('Arguments');\n\n// Define a fallback version of the method in browsers (ahem, IE < 9), where\n// there isn't any inspectable \"Arguments\" type.\n(function() {\n  if (!isArguments(arguments)) {\n    isArguments = function(obj) {\n      return has(obj, 'callee');\n    };\n  }\n}());\n\nexport default isArguments;\n","import { _isFinite } from './_setup.js';\nimport isSymbol from './isSymbol.js';\n\n// Is a given object a finite number?\nexport default function isFinite(obj) {\n  return !isSymbol(obj) && _isFinite(obj) && !isNaN(parseFloat(obj));\n}\n","import { _isNaN } from './_setup.js';\nimport isNumber from './isNumber.js';\n\n// Is the given value `NaN`?\nexport default function isNaN(obj) {\n  return isNumber(obj) && _isNaN(obj);\n}\n","// Predicate-generating function. Often useful outside of Underscore.\nexport default function constant(value) {\n  return function() {\n    return value;\n  };\n}\n","import { MAX_ARRAY_INDEX } from './_setup.js';\n\n// Common internal logic for `isArrayLike` and `isBufferLike`.\nexport default function createSizePropertyCheck(getSizeProperty) {\n  return function(collection) {\n    var sizeProperty = getSizeProperty(collection);\n    return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;\n  }\n}\n","// Internal helper to generate a function to obtain property `key` from `obj`.\nexport default function shallowProperty(key) {\n  return function(obj) {\n    return obj == null ? void 0 : obj[key];\n  };\n}\n","import shallowProperty from './_shallowProperty.js';\n\n// Internal helper to obtain the `byteLength` property of an object.\nexport default shallowProperty('byteLength');\n","import createSizePropertyCheck from './_createSizePropertyCheck.js';\nimport getByteLength from './_getByteLength.js';\n\n// Internal helper to determine whether we should spend extensive checks against\n// `ArrayBuffer` et al.\nexport default createSizePropertyCheck(getByteLength);\n","import { supportsArrayBuffer, nativeIsView, toString } from './_setup.js';\nimport isDataView from './isDataView.js';\nimport constant from './constant.js';\nimport isBufferLike from './_isBufferLike.js';\n\n// Is a given value a typed array?\nvar typedArrayPattern = /\\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\\]/;\nfunction isTypedArray(obj) {\n  // `ArrayBuffer.isView` is the most future-proof, so use it when available.\n  // Otherwise, fall back on the above regular expression.\n  return nativeIsView ? (nativeIsView(obj) && !isDataView(obj)) :\n                isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));\n}\n\nexport default supportsArrayBuffer ? isTypedArray : constant(false);\n","import shallowProperty from './_shallowProperty.js';\n\n// Internal helper to obtain the `length` property of an object.\nexport default shallowProperty('length');\n","import { nonEnumerableProps, ObjProto } from './_setup.js';\nimport isFunction from './isFunction.js';\nimport has from './_has.js';\n\n// Internal helper to create a simple lookup structure.\n// `collectNonEnumProps` used to depend on `_.contains`, but this led to\n// circular imports. `emulatedSet` is a one-off solution that only works for\n// arrays of strings.\nfunction emulatedSet(keys) {\n  var hash = {};\n  for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;\n  return {\n    contains: function(key) { return hash[key]; },\n    push: function(key) {\n      hash[key] = true;\n      return keys.push(key);\n    }\n  };\n}\n\n// Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't\n// be iterated by `for key in ...` and thus missed. Extends `keys` in place if\n// needed.\nexport default function collectNonEnumProps(obj, keys) {\n  keys = emulatedSet(keys);\n  var nonEnumIdx = nonEnumerableProps.length;\n  var constructor = obj.constructor;\n  var proto = isFunction(constructor) && constructor.prototype || ObjProto;\n\n  // Constructor is a special case.\n  var prop = 'constructor';\n  if (has(obj, prop) && !keys.contains(prop)) keys.push(prop);\n\n  while (nonEnumIdx--) {\n    prop = nonEnumerableProps[nonEnumIdx];\n    if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {\n      keys.push(prop);\n    }\n  }\n}\n","import isObject from './isObject.js';\nimport { nativeKeys, hasEnumBug } from './_setup.js';\nimport has from './_has.js';\nimport collectNonEnumProps from './_collectNonEnumProps.js';\n\n// Retrieve the names of an object's own properties.\n// Delegates to **ECMAScript 5**'s native `Object.keys`.\nexport default function keys(obj) {\n  if (!isObject(obj)) return [];\n  if (nativeKeys) return nativeKeys(obj);\n  var keys = [];\n  for (var key in obj) if (has(obj, key)) keys.push(key);\n  // Ahem, IE < 9.\n  if (hasEnumBug) collectNonEnumProps(obj, keys);\n  return keys;\n}\n","import getLength from './_getLength.js';\nimport isArray from './isArray.js';\nimport isString from './isString.js';\nimport isArguments from './isArguments.js';\nimport keys from './keys.js';\n\n// Is a given array, string, or object empty?\n// An \"empty\" object has no enumerable own-properties.\nexport default function isEmpty(obj) {\n  if (obj == null) return true;\n  // Skip the more expensive `toString`-based type checks if `obj` has no\n  // `.length`.\n  var length = getLength(obj);\n  if (typeof length == 'number' && (\n    isArray(obj) || isString(obj) || isArguments(obj)\n  )) return length === 0;\n  return getLength(keys(obj)) === 0;\n}\n","import keys from './keys.js';\n\n// Returns whether an object has a given set of `key:value` pairs.\nexport default function isMatch(object, attrs) {\n  var _keys = keys(attrs), length = _keys.length;\n  if (object == null) return !length;\n  var obj = Object(object);\n  for (var i = 0; i < length; i++) {\n    var key = _keys[i];\n    if (attrs[key] !== obj[key] || !(key in obj)) return false;\n  }\n  return true;\n}\n","import { VERSION } from './_setup.js';\n\n// If Underscore is called as a function, it returns a wrapped object that can\n// be used OO-style. This wrapper holds altered versions of all functions added\n// through `_.mixin`. Wrapped objects may be chained.\nexport default function _(obj) {\n  if (obj instanceof _) return obj;\n  if (!(this instanceof _)) return new _(obj);\n  this._wrapped = obj;\n}\n\n_.VERSION = VERSION;\n\n// Extracts the result from a wrapped and chained object.\n_.prototype.value = function() {\n  return this._wrapped;\n};\n\n// Provide unwrapping proxies for some methods used in engine operations\n// such as arithmetic and JSON stringification.\n_.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n_.prototype.toString = function() {\n  return String(this._wrapped);\n};\n","import getByteLength from './_getByteLength.js';\n\n// Internal function to wrap or shallow-copy an ArrayBuffer,\n// typed array or DataView to a new view, reusing the buffer.\nexport default function toBufferView(bufferSource) {\n  return new Uint8Array(\n    bufferSource.buffer || bufferSource,\n    bufferSource.byteOffset || 0,\n    getByteLength(bufferSource)\n  );\n}\n","import _ from './underscore.js';\nimport { toString, SymbolProto } from './_setup.js';\nimport getByteLength from './_getByteLength.js';\nimport isTypedArray from './isTypedArray.js';\nimport isFunction from './isFunction.js';\nimport { hasStringTagBug }  from './_stringTagBug.js';\nimport isDataView from './isDataView.js';\nimport keys from './keys.js';\nimport has from './_has.js';\nimport toBufferView from './_toBufferView.js';\n\n// We use this string twice, so give it a name for minification.\nvar tagDataView = '[object DataView]';\n\n// Internal recursive comparison function for `_.isEqual`.\nfunction eq(a, b, aStack, bStack) {\n  // Identical objects are equal. `0 === -0`, but they aren't identical.\n  // See the [Harmony `egal` proposal](https://wiki.ecmascript.org/doku.php?id=harmony:egal).\n  if (a === b) return a !== 0 || 1 / a === 1 / b;\n  // `null` or `undefined` only equal to itself (strict comparison).\n  if (a == null || b == null) return false;\n  // `NaN`s are equivalent, but non-reflexive.\n  if (a !== a) return b !== b;\n  // Exhaust primitive checks\n  var type = typeof a;\n  if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;\n  return deepEq(a, b, aStack, bStack);\n}\n\n// Internal recursive comparison function for `_.isEqual`.\nfunction deepEq(a, b, aStack, bStack) {\n  // Unwrap any wrapped objects.\n  if (a instanceof _) a = a._wrapped;\n  if (b instanceof _) b = b._wrapped;\n  // Compare `[[Class]]` names.\n  var className = toString.call(a);\n  if (className !== toString.call(b)) return false;\n  // Work around a bug in IE 10 - Edge 13.\n  if (hasStringTagBug && className == '[object Object]' && isDataView(a)) {\n    if (!isDataView(b)) return false;\n    className = tagDataView;\n  }\n  switch (className) {\n    // These types are compared by value.\n    case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n    case '[object String]':\n      // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n      // equivalent to `new String(\"5\")`.\n      return '' + a === '' + b;\n    case '[object Number]':\n      // `NaN`s are equivalent, but non-reflexive.\n      // Object(NaN) is equivalent to NaN.\n      if (+a !== +a) return +b !== +b;\n      // An `egal` comparison is performed for other numeric values.\n      return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n    case '[object Date]':\n    case '[object Boolean]':\n      // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n      // millisecond representations. Note that invalid dates with millisecond representations\n      // of `NaN` are not equivalent.\n      return +a === +b;\n    case '[object Symbol]':\n      return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);\n    case '[object ArrayBuffer]':\n    case tagDataView:\n      // Coerce to typed array so we can fall through.\n      return deepEq(toBufferView(a), toBufferView(b), aStack, bStack);\n  }\n\n  var areArrays = className === '[object Array]';\n  if (!areArrays && isTypedArray(a)) {\n      var byteLength = getByteLength(a);\n      if (byteLength !== getByteLength(b)) return false;\n      if (a.buffer === b.buffer && a.byteOffset === b.byteOffset) return true;\n      areArrays = true;\n  }\n  if (!areArrays) {\n    if (typeof a != 'object' || typeof b != 'object') return false;\n\n    // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n    // from different frames are.\n    var aCtor = a.constructor, bCtor = b.constructor;\n    if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor &&\n                             isFunction(bCtor) && bCtor instanceof bCtor)\n                        && ('constructor' in a && 'constructor' in b)) {\n      return false;\n    }\n  }\n  // Assume equality for cyclic structures. The algorithm for detecting cyclic\n  // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n  // Initializing stack of traversed objects.\n  // It's done here since we only need them for objects and arrays comparison.\n  aStack = aStack || [];\n  bStack = bStack || [];\n  var length = aStack.length;\n  while (length--) {\n    // Linear search. Performance is inversely proportional to the number of\n    // unique nested structures.\n    if (aStack[length] === a) return bStack[length] === b;\n  }\n\n  // Add the first object to the stack of traversed objects.\n  aStack.push(a);\n  bStack.push(b);\n\n  // Recursively compare objects and arrays.\n  if (areArrays) {\n    // Compare array lengths to determine if a deep comparison is necessary.\n    length = a.length;\n    if (length !== b.length) return false;\n    // Deep compare the contents, ignoring non-numeric properties.\n    while (length--) {\n      if (!eq(a[length], b[length], aStack, bStack)) return false;\n    }\n  } else {\n    // Deep compare objects.\n    var _keys = keys(a), key;\n    length = _keys.length;\n    // Ensure that both objects contain the same number of properties before comparing deep equality.\n    if (keys(b).length !== length) return false;\n    while (length--) {\n      // Deep compare each member\n      key = _keys[length];\n      if (!(has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n    }\n  }\n  // Remove the first object from the stack of traversed objects.\n  aStack.pop();\n  bStack.pop();\n  return true;\n}\n\n// Perform a deep comparison to check if two objects are equal.\nexport default function isEqual(a, b) {\n  return eq(a, b);\n}\n","import isObject from './isObject.js';\nimport { hasEnumBug } from './_setup.js';\nimport collectNonEnumProps from './_collectNonEnumProps.js';\n\n// Retrieve all the enumerable property names of an object.\nexport default function allKeys(obj) {\n  if (!isObject(obj)) return [];\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  // Ahem, IE < 9.\n  if (hasEnumBug) collectNonEnumProps(obj, keys);\n  return keys;\n}\n","import getLength from './_getLength.js';\nimport isFunction from './isFunction.js';\nimport allKeys from './allKeys.js';\n\n// Since the regular `Object.prototype.toString` type tests don't work for\n// some types in IE 11, we use a fingerprinting heuristic instead, based\n// on the methods. It's not great, but it's the best we got.\n// The fingerprint method lists are defined below.\nexport function ie11fingerprint(methods) {\n  var length = getLength(methods);\n  return function(obj) {\n    if (obj == null) return false;\n    // `Map`, `WeakMap` and `Set` have no enumerable keys.\n    var keys = allKeys(obj);\n    if (getLength(keys)) return false;\n    for (var i = 0; i < length; i++) {\n      if (!isFunction(obj[methods[i]])) return false;\n    }\n    // If we are testing against `WeakMap`, we need to ensure that\n    // `obj` doesn't have a `forEach` method in order to distinguish\n    // it from a regular `Map`.\n    return methods !== weakMapMethods || !isFunction(obj[forEachName]);\n  };\n}\n\n// In the interest of compact minification, we write\n// each string in the fingerprints only once.\nvar forEachName = 'forEach',\n    hasName = 'has',\n    commonInit = ['clear', 'delete'],\n    mapTail = ['get', hasName, 'set'];\n\n// `Map`, `WeakMap` and `Set` each have slightly different\n// combinations of the above sublists.\nexport var mapMethods = commonInit.concat(forEachName, mapTail),\n    weakMapMethods = commonInit.concat(mapTail),\n    setMethods = ['add'].concat(commonInit, forEachName, hasName);\n","import tagTester from './_tagTester.js';\nimport { isIE11 } from './_stringTagBug.js';\nimport { ie11fingerprint, mapMethods }  from './_methodFingerprint.js';\n\nexport default isIE11 ? ie11fingerprint(mapMethods) : tagTester('Map');\n","import tagTester from './_tagTester.js';\nimport { isIE11 } from './_stringTagBug.js';\nimport { ie11fingerprint, weakMapMethods }  from './_methodFingerprint.js';\n\nexport default isIE11 ? ie11fingerprint(weakMapMethods) : tagTester('WeakMap');\n","import tagTester from './_tagTester.js';\nimport { isIE11 } from './_stringTagBug.js';\nimport { ie11fingerprint, setMethods }  from './_methodFingerprint.js';\n\nexport default isIE11 ? ie11fingerprint(setMethods) : tagTester('Set');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('WeakSet');\n","import keys from './keys.js';\n\n// Retrieve the values of an object's properties.\nexport default function values(obj) {\n  var _keys = keys(obj);\n  var length = _keys.length;\n  var values = Array(length);\n  for (var i = 0; i < length; i++) {\n    values[i] = obj[_keys[i]];\n  }\n  return values;\n}\n","import keys from './keys.js';\n\n// Convert an object into a list of `[key, value]` pairs.\n// The opposite of `_.object` with one argument.\nexport default function pairs(obj) {\n  var _keys = keys(obj);\n  var length = _keys.length;\n  var pairs = Array(length);\n  for (var i = 0; i < length; i++) {\n    pairs[i] = [_keys[i], obj[_keys[i]]];\n  }\n  return pairs;\n}\n","import keys from './keys.js';\n\n// Invert the keys and values of an object. The values must be serializable.\nexport default function invert(obj) {\n  var result = {};\n  var _keys = keys(obj);\n  for (var i = 0, length = _keys.length; i < length; i++) {\n    result[obj[_keys[i]]] = _keys[i];\n  }\n  return result;\n}\n","import isFunction from './isFunction.js';\n\n// Return a sorted list of the function names available on the object.\nexport default function functions(obj) {\n  var names = [];\n  for (var key in obj) {\n    if (isFunction(obj[key])) names.push(key);\n  }\n  return names.sort();\n}\n","// An internal function for creating assigner functions.\nexport default function createAssigner(keysFunc, defaults) {\n  return function(obj) {\n    var length = arguments.length;\n    if (defaults) obj = Object(obj);\n    if (length < 2 || obj == null) return obj;\n    for (var index = 1; index < length; index++) {\n      var source = arguments[index],\n          keys = keysFunc(source),\n          l = keys.length;\n      for (var i = 0; i < l; i++) {\n        var key = keys[i];\n        if (!defaults || obj[key] === void 0) obj[key] = source[key];\n      }\n    }\n    return obj;\n  };\n}\n","import createAssigner from './_createAssigner.js';\nimport allKeys from './allKeys.js';\n\n// Extend a given object with all the properties in passed-in object(s).\nexport default createAssigner(allKeys);\n","import createAssigner from './_createAssigner.js';\nimport keys from './keys.js';\n\n// Assigns a given object with all the own properties in the passed-in\n// object(s).\n// (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\nexport default createAssigner(keys);\n","import createAssigner from './_createAssigner.js';\nimport allKeys from './allKeys.js';\n\n// Fill in a given object with default properties.\nexport default createAssigner(allKeys, true);\n","import isObject from './isObject.js';\nimport { nativeCreate } from './_setup.js';\n\n// Create a naked function reference for surrogate-prototype-swapping.\nfunction ctor() {\n  return function(){};\n}\n\n// An internal function for creating a new object that inherits from another.\nexport default function baseCreate(prototype) {\n  if (!isObject(prototype)) return {};\n  if (nativeCreate) return nativeCreate(prototype);\n  var Ctor = ctor();\n  Ctor.prototype = prototype;\n  var result = new Ctor;\n  Ctor.prototype = null;\n  return result;\n}\n","import baseCreate from './_baseCreate.js';\nimport extendOwn from './extendOwn.js';\n\n// Creates an object that inherits from the given prototype object.\n// If additional properties are provided then they will be added to the\n// created object.\nexport default function create(prototype, props) {\n  var result = baseCreate(prototype);\n  if (props) extendOwn(result, props);\n  return result;\n}\n","import isObject from './isObject.js';\nimport isArray from './isArray.js';\nimport extend from './extend.js';\n\n// Create a (shallow-cloned) duplicate of an object.\nexport default function clone(obj) {\n  if (!isObject(obj)) return obj;\n  return isArray(obj) ? obj.slice() : extend({}, obj);\n}\n","// Invokes `interceptor` with the `obj` and then returns `obj`.\n// The primary purpose of this method is to \"tap into\" a method chain, in\n// order to perform operations on intermediate results within the chain.\nexport default function tap(obj, interceptor) {\n  interceptor(obj);\n  return obj;\n}\n","import _ from './underscore.js';\nimport isArray from './isArray.js';\n\n// Normalize a (deep) property `path` to array.\n// Like `_.iteratee`, this function can be customized.\nexport default function toPath(path) {\n  return isArray(path) ? path : [path];\n}\n_.toPath = toPath;\n","import _ from './underscore.js';\nimport './toPath.js';\n\n// Internal wrapper for `_.toPath` to enable minification.\n// Similar to `cb` for `_.iteratee`.\nexport default function toPath(path) {\n  return _.toPath(path);\n}\n","// Internal function to obtain a nested property in `obj` along `path`.\nexport default function deepGet(obj, path) {\n  var length = path.length;\n  for (var i = 0; i < length; i++) {\n    if (obj == null) return void 0;\n    obj = obj[path[i]];\n  }\n  return length ? obj : void 0;\n}\n","import toPath from './_toPath.js';\nimport deepGet from './_deepGet.js';\nimport isUndefined from './isUndefined.js';\n\n// Get the value of the (deep) property on `path` from `object`.\n// If any property in `path` does not exist or if the value is\n// `undefined`, return `defaultValue` instead.\n// The `path` is normalized through `_.toPath`.\nexport default function get(object, path, defaultValue) {\n  var value = deepGet(object, toPath(path));\n  return isUndefined(value) ? defaultValue : value;\n}\n","import _has from './_has.js';\nimport toPath from './_toPath.js';\n\n// Shortcut function for checking if an object has a given property directly on\n// itself (in other words, not on a prototype). Unlike the internal `has`\n// function, this public version can also traverse nested properties.\nexport default function has(obj, path) {\n  path = toPath(path);\n  var length = path.length;\n  for (var i = 0; i < length; i++) {\n    var key = path[i];\n    if (!_has(obj, key)) return false;\n    obj = obj[key];\n  }\n  return !!length;\n}\n","// Keep the identity function around for default iteratees.\nexport default function identity(value) {\n  return value;\n}\n","import extendOwn from './extendOwn.js';\nimport isMatch from './isMatch.js';\n\n// Returns a predicate for checking whether an object has a given set of\n// `key:value` pairs.\nexport default function matcher(attrs) {\n  attrs = extendOwn({}, attrs);\n  return function(obj) {\n    return isMatch(obj, attrs);\n  };\n}\n","import deepGet from './_deepGet.js';\nimport toPath from './_toPath.js';\n\n// Creates a function that, when passed an object, will traverse that object’s\n// properties down the given `path`, specified as an array of keys or indices.\nexport default function property(path) {\n  path = toPath(path);\n  return function(obj) {\n    return deepGet(obj, path);\n  };\n}\n","// Internal function that returns an efficient (for current engines) version\n// of the passed-in callback, to be repeatedly applied in other Underscore\n// functions.\nexport default function optimizeCb(func, context, argCount) {\n  if (context === void 0) return func;\n  switch (argCount == null ? 3 : argCount) {\n    case 1: return function(value) {\n      return func.call(context, value);\n    };\n    // The 2-argument case is omitted because we’re not using it.\n    case 3: return function(value, index, collection) {\n      return func.call(context, value, index, collection);\n    };\n    case 4: return function(accumulator, value, index, collection) {\n      return func.call(context, accumulator, value, index, collection);\n    };\n  }\n  return function() {\n    return func.apply(context, arguments);\n  };\n}\n","import identity from './identity.js';\nimport isFunction from './isFunction.js';\nimport isObject from './isObject.js';\nimport isArray from './isArray.js';\nimport matcher from './matcher.js';\nimport property from './property.js';\nimport optimizeCb from './_optimizeCb.js';\n\n// An internal function to generate callbacks that can be applied to each\n// element in a collection, returning the desired result — either `_.identity`,\n// an arbitrary callback, a property matcher, or a property accessor.\nexport default function baseIteratee(value, context, argCount) {\n  if (value == null) return identity;\n  if (isFunction(value)) return optimizeCb(value, context, argCount);\n  if (isObject(value) && !isArray(value)) return matcher(value);\n  return property(value);\n}\n","import _ from './underscore.js';\nimport baseIteratee from './_baseIteratee.js';\n\n// External wrapper for our callback generator. Users may customize\n// `_.iteratee` if they want additional predicate/iteratee shorthand styles.\n// This abstraction hides the internal-only `argCount` argument.\nexport default function iteratee(value, context) {\n  return baseIteratee(value, context, Infinity);\n}\n_.iteratee = iteratee;\n","import _ from './underscore.js';\nimport baseIteratee from './_baseIteratee.js';\nimport iteratee from './iteratee.js';\n\n// The function we call internally to generate a callback. It invokes\n// `_.iteratee` if overridden, otherwise `baseIteratee`.\nexport default function cb(value, context, argCount) {\n  if (_.iteratee !== iteratee) return _.iteratee(value, context);\n  return baseIteratee(value, context, argCount);\n}\n","import cb from './_cb.js';\nimport keys from './keys.js';\n\n// Returns the results of applying the `iteratee` to each element of `obj`.\n// In contrast to `_.map` it returns an object.\nexport default function mapObject(obj, iteratee, context) {\n  iteratee = cb(iteratee, context);\n  var _keys = keys(obj),\n      length = _keys.length,\n      results = {};\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys[index];\n    results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n  }\n  return results;\n}\n","// Predicate-generating function. Often useful outside of Underscore.\nexport default function noop(){}\n","import noop from './noop.js';\nimport get from './get.js';\n\n// Generates a function for a given object that returns a given property.\nexport default function propertyOf(obj) {\n  if (obj == null) return noop;\n  return function(path) {\n    return get(obj, path);\n  };\n}\n","import optimizeCb from './_optimizeCb.js';\n\n// Run a function **n** times.\nexport default function times(n, iteratee, context) {\n  var accum = Array(Math.max(0, n));\n  iteratee = optimizeCb(iteratee, context, 1);\n  for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n  return accum;\n}\n","// Return a random integer between `min` and `max` (inclusive).\nexport default function random(min, max) {\n  if (max == null) {\n    max = min;\n    min = 0;\n  }\n  return min + Math.floor(Math.random() * (max - min + 1));\n}\n","// A (possibly faster) way to get the current timestamp as an integer.\nexport default Date.now || function() {\n  return new Date().getTime();\n};\n","import keys from './keys.js';\n\n// Internal helper to generate functions for escaping and unescaping strings\n// to/from HTML interpolation.\nexport default function createEscaper(map) {\n  var escaper = function(match) {\n    return map[match];\n  };\n  // Regexes for identifying a key that needs to be escaped.\n  var source = '(?:' + keys(map).join('|') + ')';\n  var testRegexp = RegExp(source);\n  var replaceRegexp = RegExp(source, 'g');\n  return function(string) {\n    string = string == null ? '' : '' + string;\n    return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n  };\n}\n","// Internal list of HTML entities for escaping.\nexport default {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#x27;',\n  '`': '&#x60;'\n};\n","import createEscaper from './_createEscaper.js';\nimport escapeMap from './_escapeMap.js';\n\n// Function for escaping strings to HTML interpolation.\nexport default createEscaper(escapeMap);\n","import createEscaper from './_createEscaper.js';\nimport unescapeMap from './_unescapeMap.js';\n\n// Function for unescaping strings from HTML interpolation.\nexport default createEscaper(unescapeMap);\n","import invert from './invert.js';\nimport escapeMap from './_escapeMap.js';\n\n// Internal list of HTML entities for unescaping.\nexport default invert(escapeMap);\n","import _ from './underscore.js';\n\n// By default, Underscore uses ERB-style template delimiters. Change the\n// following template settings to use alternative delimiters.\nexport default _.templateSettings = {\n  evaluate: /<%([\\s\\S]+?)%>/g,\n  interpolate: /<%=([\\s\\S]+?)%>/g,\n  escape: /<%-([\\s\\S]+?)%>/g\n};\n","import defaults from './defaults.js';\nimport _ from './underscore.js';\nimport './templateSettings.js';\n\n// When customizing `_.templateSettings`, if you don't want to define an\n// interpolation, evaluation or escaping regex, we need one that is\n// guaranteed not to match.\nvar noMatch = /(.)^/;\n\n// Certain characters need to be escaped so that they can be put into a\n// string literal.\nvar escapes = {\n  \"'\": \"'\",\n  '\\\\': '\\\\',\n  '\\r': 'r',\n  '\\n': 'n',\n  '\\u2028': 'u2028',\n  '\\u2029': 'u2029'\n};\n\nvar escapeRegExp = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\nfunction escapeChar(match) {\n  return '\\\\' + escapes[match];\n}\n\n// In order to prevent third-party code injection through\n// `_.templateSettings.variable`, we test it against the following regular\n// expression. It is intentionally a bit more liberal than just matching valid\n// identifiers, but still prevents possible loopholes through defaults or\n// destructuring assignment.\nvar bareIdentifier = /^\\s*(\\w|\\$)+\\s*$/;\n\n// JavaScript micro-templating, similar to John Resig's implementation.\n// Underscore templating handles arbitrary delimiters, preserves whitespace,\n// and correctly escapes quotes within interpolated code.\n// NB: `oldSettings` only exists for backwards compatibility.\nexport default function template(text, settings, oldSettings) {\n  if (!settings && oldSettings) settings = oldSettings;\n  settings = defaults({}, settings, _.templateSettings);\n\n  // Combine delimiters into one regular expression via alternation.\n  var matcher = RegExp([\n    (settings.escape || noMatch).source,\n    (settings.interpolate || noMatch).source,\n    (settings.evaluate || noMatch).source\n  ].join('|') + '|$', 'g');\n\n  // Compile the template source, escaping string literals appropriately.\n  var index = 0;\n  var source = \"__p+='\";\n  text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n    source += text.slice(index, offset).replace(escapeRegExp, escapeChar);\n    index = offset + match.length;\n\n    if (escape) {\n      source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n    } else if (interpolate) {\n      source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n    } else if (evaluate) {\n      source += \"';\\n\" + evaluate + \"\\n__p+='\";\n    }\n\n    // Adobe VMs need the match returned to produce the correct offset.\n    return match;\n  });\n  source += \"';\\n\";\n\n  var argument = settings.variable;\n  if (argument) {\n    // Insure against third-party code injection. (CVE-2021-23358)\n    if (!bareIdentifier.test(argument)) throw new Error(\n      'variable is not a bare identifier: ' + argument\n    );\n  } else {\n    // If a variable is not specified, place data values in local scope.\n    source = 'with(obj||{}){\\n' + source + '}\\n';\n    argument = 'obj';\n  }\n\n  source = \"var __t,__p='',__j=Array.prototype.join,\" +\n    \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n    source + 'return __p;\\n';\n\n  var render;\n  try {\n    render = new Function(argument, '_', source);\n  } catch (e) {\n    e.source = source;\n    throw e;\n  }\n\n  var template = function(data) {\n    return render.call(this, data, _);\n  };\n\n  // Provide the compiled source as a convenience for precompilation.\n  template.source = 'function(' + argument + '){\\n' + source + '}';\n\n  return template;\n}\n","import isFunction from './isFunction.js';\nimport toPath from './_toPath.js';\n\n// Traverses the children of `obj` along `path`. If a child is a function, it\n// is invoked with its parent as context. Returns the value of the final\n// child, or `fallback` if any child is undefined.\nexport default function result(obj, path, fallback) {\n  path = toPath(path);\n  var length = path.length;\n  if (!length) {\n    return isFunction(fallback) ? fallback.call(obj) : fallback;\n  }\n  for (var i = 0; i < length; i++) {\n    var prop = obj == null ? void 0 : obj[path[i]];\n    if (prop === void 0) {\n      prop = fallback;\n      i = length; // Ensure we don't continue iterating.\n    }\n    obj = isFunction(prop) ? prop.call(obj) : prop;\n  }\n  return obj;\n}\n","// Generate a unique integer id (unique within the entire client session).\n// Useful for temporary DOM ids.\nvar idCounter = 0;\nexport default function uniqueId(prefix) {\n  var id = ++idCounter + '';\n  return prefix ? prefix + id : id;\n}\n","import _ from './underscore.js';\n\n// Start chaining a wrapped Underscore object.\nexport default function chain(obj) {\n  var instance = _(obj);\n  instance._chain = true;\n  return instance;\n}\n","import baseCreate from './_baseCreate.js';\nimport isObject from './isObject.js';\n\n// Internal function to execute `sourceFunc` bound to `context` with optional\n// `args`. Determines whether to execute a function as a constructor or as a\n// normal function.\nexport default function executeBound(sourceFunc, boundFunc, context, callingContext, args) {\n  if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n  var self = baseCreate(sourceFunc.prototype);\n  var result = sourceFunc.apply(self, args);\n  if (isObject(result)) return result;\n  return self;\n}\n","import restArguments from './restArguments.js';\nimport executeBound from './_executeBound.js';\nimport _ from './underscore.js';\n\n// Partially apply a function by creating a version that has had some of its\n// arguments pre-filled, without changing its dynamic `this` context. `_` acts\n// as a placeholder by default, allowing any combination of arguments to be\n// pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.\nvar partial = restArguments(function(func, boundArgs) {\n  var placeholder = partial.placeholder;\n  var bound = function() {\n    var position = 0, length = boundArgs.length;\n    var args = Array(length);\n    for (var i = 0; i < length; i++) {\n      args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];\n    }\n    while (position < arguments.length) args.push(arguments[position++]);\n    return executeBound(func, bound, this, this, args);\n  };\n  return bound;\n});\n\npartial.placeholder = _;\nexport default partial;\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport executeBound from './_executeBound.js';\n\n// Create a function bound to a given object (assigning `this`, and arguments,\n// optionally).\nexport default restArguments(function(func, context, args) {\n  if (!isFunction(func)) throw new TypeError('Bind must be called on a function');\n  var bound = restArguments(function(callArgs) {\n    return executeBound(func, bound, context, this, args.concat(callArgs));\n  });\n  return bound;\n});\n","import createSizePropertyCheck from './_createSizePropertyCheck.js';\nimport getLength from './_getLength.js';\n\n// Internal helper for collection methods to determine whether a collection\n// should be iterated as an array or as an object.\n// Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n// Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\nexport default createSizePropertyCheck(getLength);\n","import getLength from './_getLength.js';\nimport isArrayLike from './_isArrayLike.js';\nimport isArray from './isArray.js';\nimport isArguments from './isArguments.js';\n\n// Internal implementation of a recursive `flatten` function.\nexport default function flatten(input, depth, strict, output) {\n  output = output || [];\n  if (!depth && depth !== 0) {\n    depth = Infinity;\n  } else if (depth <= 0) {\n    return output.concat(input);\n  }\n  var idx = output.length;\n  for (var i = 0, length = getLength(input); i < length; i++) {\n    var value = input[i];\n    if (isArrayLike(value) && (isArray(value) || isArguments(value))) {\n      // Flatten current level of array or arguments object.\n      if (depth > 1) {\n        flatten(value, depth - 1, strict, output);\n        idx = output.length;\n      } else {\n        var j = 0, len = value.length;\n        while (j < len) output[idx++] = value[j++];\n      }\n    } else if (!strict) {\n      output[idx++] = value;\n    }\n  }\n  return output;\n}\n","import restArguments from './restArguments.js';\nimport flatten from './_flatten.js';\nimport bind from './bind.js';\n\n// Bind a number of an object's methods to that object. Remaining arguments\n// are the method names to be bound. Useful for ensuring that all callbacks\n// defined on an object belong to it.\nexport default restArguments(function(obj, keys) {\n  keys = flatten(keys, false, false);\n  var index = keys.length;\n  if (index < 1) throw new Error('bindAll must be passed function names');\n  while (index--) {\n    var key = keys[index];\n    obj[key] = bind(obj[key], obj);\n  }\n  return obj;\n});\n","import has from './_has.js';\n\n// Memoize an expensive function by storing its results.\nexport default function memoize(func, hasher) {\n  var memoize = function(key) {\n    var cache = memoize.cache;\n    var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n    if (!has(cache, address)) cache[address] = func.apply(this, arguments);\n    return cache[address];\n  };\n  memoize.cache = {};\n  return memoize;\n}\n","import restArguments from './restArguments.js';\n\n// Delays a function for the given number of milliseconds, and then calls\n// it with the arguments supplied.\nexport default restArguments(function(func, wait, args) {\n  return setTimeout(function() {\n    return func.apply(null, args);\n  }, wait);\n});\n","import partial from './partial.js';\nimport delay from './delay.js';\nimport _ from './underscore.js';\n\n// Defers a function, scheduling it to run after the current call stack has\n// cleared.\nexport default partial(delay, _, 1);\n","import now from './now.js';\n\n// Returns a function, that, when invoked, will only be triggered at most once\n// during a given window of time. Normally, the throttled function will run\n// as much as it can, without ever going more than once per `wait` duration;\n// but if you'd like to disable the execution on the leading edge, pass\n// `{leading: false}`. To disable execution on the trailing edge, ditto.\nexport default function throttle(func, wait, options) {\n  var timeout, context, args, result;\n  var previous = 0;\n  if (!options) options = {};\n\n  var later = function() {\n    previous = options.leading === false ? 0 : now();\n    timeout = null;\n    result = func.apply(context, args);\n    if (!timeout) context = args = null;\n  };\n\n  var throttled = function() {\n    var _now = now();\n    if (!previous && options.leading === false) previous = _now;\n    var remaining = wait - (_now - previous);\n    context = this;\n    args = arguments;\n    if (remaining <= 0 || remaining > wait) {\n      if (timeout) {\n        clearTimeout(timeout);\n        timeout = null;\n      }\n      previous = _now;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    } else if (!timeout && options.trailing !== false) {\n      timeout = setTimeout(later, remaining);\n    }\n    return result;\n  };\n\n  throttled.cancel = function() {\n    clearTimeout(timeout);\n    previous = 0;\n    timeout = context = args = null;\n  };\n\n  return throttled;\n}\n","import restArguments from './restArguments.js';\nimport now from './now.js';\n\n// When a sequence of calls of the returned function ends, the argument\n// function is triggered. The end of a sequence is defined by the `wait`\n// parameter. If `immediate` is passed, the argument function will be\n// triggered at the beginning of the sequence instead of at the end.\nexport default function debounce(func, wait, immediate) {\n  var timeout, previous, args, result, context;\n\n  var later = function() {\n    var passed = now() - previous;\n    if (wait > passed) {\n      timeout = setTimeout(later, wait - passed);\n    } else {\n      timeout = null;\n      if (!immediate) result = func.apply(context, args);\n      // This check is needed because `func` can recursively invoke `debounced`.\n      if (!timeout) args = context = null;\n    }\n  };\n\n  var debounced = restArguments(function(_args) {\n    context = this;\n    args = _args;\n    previous = now();\n    if (!timeout) {\n      timeout = setTimeout(later, wait);\n      if (immediate) result = func.apply(context, args);\n    }\n    return result;\n  });\n\n  debounced.cancel = function() {\n    clearTimeout(timeout);\n    timeout = args = context = null;\n  };\n\n  return debounced;\n}\n","import partial from './partial.js';\n\n// Returns the first function passed as an argument to the second,\n// allowing you to adjust arguments, run code before and after, and\n// conditionally execute the original function.\nexport default function wrap(func, wrapper) {\n  return partial(wrapper, func);\n}\n","// Returns a negated version of the passed-in predicate.\nexport default function negate(predicate) {\n  return function() {\n    return !predicate.apply(this, arguments);\n  };\n}\n","// Returns a function that is the composition of a list of functions, each\n// consuming the return value of the function that follows.\nexport default function compose() {\n  var args = arguments;\n  var start = args.length - 1;\n  return function() {\n    var i = start;\n    var result = args[start].apply(this, arguments);\n    while (i--) result = args[i].call(this, result);\n    return result;\n  };\n}\n","// Returns a function that will only be executed on and after the Nth call.\nexport default function after(times, func) {\n  return function() {\n    if (--times < 1) {\n      return func.apply(this, arguments);\n    }\n  };\n}\n","// Returns a function that will only be executed up to (but not including) the\n// Nth call.\nexport default function before(times, func) {\n  var memo;\n  return function() {\n    if (--times > 0) {\n      memo = func.apply(this, arguments);\n    }\n    if (times <= 1) func = null;\n    return memo;\n  };\n}\n","import partial from './partial.js';\nimport before from './before.js';\n\n// Returns a function that will be executed at most one time, no matter how\n// often you call it. Useful for lazy initialization.\nexport default partial(before, 2);\n","import cb from './_cb.js';\nimport keys from './keys.js';\n\n// Returns the first key on an object that passes a truth test.\nexport default function findKey(obj, predicate, context) {\n  predicate = cb(predicate, context);\n  var _keys = keys(obj), key;\n  for (var i = 0, length = _keys.length; i < length; i++) {\n    key = _keys[i];\n    if (predicate(obj[key], key, obj)) return key;\n  }\n}\n","import cb from './_cb.js';\nimport getLength from './_getLength.js';\n\n// Internal function to generate `_.findIndex` and `_.findLastIndex`.\nexport default function createPredicateIndexFinder(dir) {\n  return function(array, predicate, context) {\n    predicate = cb(predicate, context);\n    var length = getLength(array);\n    var index = dir > 0 ? 0 : length - 1;\n    for (; index >= 0 && index < length; index += dir) {\n      if (predicate(array[index], index, array)) return index;\n    }\n    return -1;\n  };\n}\n","import createPredicateIndexFinder from './_createPredicateIndexFinder.js';\n\n// Returns the first index on an array-like that passes a truth test.\nexport default createPredicateIndexFinder(1);\n","import createPredicateIndexFinder from './_createPredicateIndexFinder.js';\n\n// Returns the last index on an array-like that passes a truth test.\nexport default createPredicateIndexFinder(-1);\n","import cb from './_cb.js';\nimport getLength from './_getLength.js';\n\n// Use a comparator function to figure out the smallest index at which\n// an object should be inserted so as to maintain order. Uses binary search.\nexport default function sortedIndex(array, obj, iteratee, context) {\n  iteratee = cb(iteratee, context, 1);\n  var value = iteratee(obj);\n  var low = 0, high = getLength(array);\n  while (low < high) {\n    var mid = Math.floor((low + high) / 2);\n    if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n  }\n  return low;\n}\n","import getLength from './_getLength.js';\nimport { slice } from './_setup.js';\nimport isNaN from './isNaN.js';\n\n// Internal function to generate the `_.indexOf` and `_.lastIndexOf` functions.\nexport default function createIndexFinder(dir, predicateFind, sortedIndex) {\n  return function(array, item, idx) {\n    var i = 0, length = getLength(array);\n    if (typeof idx == 'number') {\n      if (dir > 0) {\n        i = idx >= 0 ? idx : Math.max(idx + length, i);\n      } else {\n        length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n      }\n    } else if (sortedIndex && idx && length) {\n      idx = sortedIndex(array, item);\n      return array[idx] === item ? idx : -1;\n    }\n    if (item !== item) {\n      idx = predicateFind(slice.call(array, i, length), isNaN);\n      return idx >= 0 ? idx + i : -1;\n    }\n    for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n      if (array[idx] === item) return idx;\n    }\n    return -1;\n  };\n}\n","import sortedIndex from './sortedIndex.js';\nimport findIndex from './findIndex.js';\nimport createIndexFinder from './_createIndexFinder.js';\n\n// Return the position of the first occurrence of an item in an array,\n// or -1 if the item is not included in the array.\n// If the array is large and already in sort order, pass `true`\n// for **isSorted** to use binary search.\nexport default createIndexFinder(1, findIndex, sortedIndex);\n","import findLastIndex from './findLastIndex.js';\nimport createIndexFinder from './_createIndexFinder.js';\n\n// Return the position of the last occurrence of an item in an array,\n// or -1 if the item is not included in the array.\nexport default createIndexFinder(-1, findLastIndex);\n","import isArrayLike from './_isArrayLike.js';\nimport findIndex from './findIndex.js';\nimport findKey from './findKey.js';\n\n// Return the first value which passes a truth test.\nexport default function find(obj, predicate, context) {\n  var keyFinder = isArrayLike(obj) ? findIndex : findKey;\n  var key = keyFinder(obj, predicate, context);\n  if (key !== void 0 && key !== -1) return obj[key];\n}\n","import find from './find.js';\nimport matcher from './matcher.js';\n\n// Convenience version of a common use case of `_.find`: getting the first\n// object containing specific `key:value` pairs.\nexport default function findWhere(obj, attrs) {\n  return find(obj, matcher(attrs));\n}\n","import optimizeCb from './_optimizeCb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// The cornerstone for collection functions, an `each`\n// implementation, aka `forEach`.\n// Handles raw objects in addition to array-likes. Treats all\n// sparse array-likes as if they were dense.\nexport default function each(obj, iteratee, context) {\n  iteratee = optimizeCb(iteratee, context);\n  var i, length;\n  if (isArrayLike(obj)) {\n    for (i = 0, length = obj.length; i < length; i++) {\n      iteratee(obj[i], i, obj);\n    }\n  } else {\n    var _keys = keys(obj);\n    for (i = 0, length = _keys.length; i < length; i++) {\n      iteratee(obj[_keys[i]], _keys[i], obj);\n    }\n  }\n  return obj;\n}\n","import cb from './_cb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Return the results of applying the iteratee to each element.\nexport default function map(obj, iteratee, context) {\n  iteratee = cb(iteratee, context);\n  var _keys = !isArrayLike(obj) && keys(obj),\n      length = (_keys || obj).length,\n      results = Array(length);\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys ? _keys[index] : index;\n    results[index] = iteratee(obj[currentKey], currentKey, obj);\n  }\n  return results;\n}\n","import isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\nimport optimizeCb from './_optimizeCb.js';\n\n// Internal helper to create a reducing function, iterating left or right.\nexport default function createReduce(dir) {\n  // Wrap code that reassigns argument variables in a separate function than\n  // the one that accesses `arguments.length` to avoid a perf hit. (#1991)\n  var reducer = function(obj, iteratee, memo, initial) {\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length,\n        index = dir > 0 ? 0 : length - 1;\n    if (!initial) {\n      memo = obj[_keys ? _keys[index] : index];\n      index += dir;\n    }\n    for (; index >= 0 && index < length; index += dir) {\n      var currentKey = _keys ? _keys[index] : index;\n      memo = iteratee(memo, obj[currentKey], currentKey, obj);\n    }\n    return memo;\n  };\n\n  return function(obj, iteratee, memo, context) {\n    var initial = arguments.length >= 3;\n    return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);\n  };\n}\n","import createReduce from './_createReduce.js';\n\n// **Reduce** builds up a single result from a list of values, aka `inject`,\n// or `foldl`.\nexport default createReduce(1);\n","import createReduce from './_createReduce.js';\n\n// The right-associative version of reduce, also known as `foldr`.\nexport default createReduce(-1);\n","import cb from './_cb.js';\nimport each from './each.js';\n\n// Return all the elements that pass a truth test.\nexport default function filter(obj, predicate, context) {\n  var results = [];\n  predicate = cb(predicate, context);\n  each(obj, function(value, index, list) {\n    if (predicate(value, index, list)) results.push(value);\n  });\n  return results;\n}\n","import filter from './filter.js';\nimport negate from './negate.js';\nimport cb from './_cb.js';\n\n// Return all the elements for which a truth test fails.\nexport default function reject(obj, predicate, context) {\n  return filter(obj, negate(cb(predicate)), context);\n}\n","import cb from './_cb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Determine whether all of the elements pass a truth test.\nexport default function every(obj, predicate, context) {\n  predicate = cb(predicate, context);\n  var _keys = !isArrayLike(obj) && keys(obj),\n      length = (_keys || obj).length;\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys ? _keys[index] : index;\n    if (!predicate(obj[currentKey], currentKey, obj)) return false;\n  }\n  return true;\n}\n","import cb from './_cb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Determine if at least one element in the object passes a truth test.\nexport default function some(obj, predicate, context) {\n  predicate = cb(predicate, context);\n  var _keys = !isArrayLike(obj) && keys(obj),\n      length = (_keys || obj).length;\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys ? _keys[index] : index;\n    if (predicate(obj[currentKey], currentKey, obj)) return true;\n  }\n  return false;\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport indexOf from './indexOf.js';\n\n// Determine if the array or object contains a given item (using `===`).\nexport default function contains(obj, item, fromIndex, guard) {\n  if (!isArrayLike(obj)) obj = values(obj);\n  if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n  return indexOf(obj, item, fromIndex) >= 0;\n}\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport map from './map.js';\nimport deepGet from './_deepGet.js';\nimport toPath from './_toPath.js';\n\n// Invoke a method (with arguments) on every item in a collection.\nexport default restArguments(function(obj, path, args) {\n  var contextPath, func;\n  if (isFunction(path)) {\n    func = path;\n  } else {\n    path = toPath(path);\n    contextPath = path.slice(0, -1);\n    path = path[path.length - 1];\n  }\n  return map(obj, function(context) {\n    var method = func;\n    if (!method) {\n      if (contextPath && contextPath.length) {\n        context = deepGet(context, contextPath);\n      }\n      if (context == null) return void 0;\n      method = context[path];\n    }\n    return method == null ? method : method.apply(context, args);\n  });\n});\n","import map from './map.js';\nimport property from './property.js';\n\n// Convenience version of a common use case of `_.map`: fetching a property.\nexport default function pluck(obj, key) {\n  return map(obj, property(key));\n}\n","import filter from './filter.js';\nimport matcher from './matcher.js';\n\n// Convenience version of a common use case of `_.filter`: selecting only\n// objects containing specific `key:value` pairs.\nexport default function where(obj, attrs) {\n  return filter(obj, matcher(attrs));\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport cb from './_cb.js';\nimport each from './each.js';\n\n// Return the maximum element (or element-based computation).\nexport default function max(obj, iteratee, context) {\n  var result = -Infinity, lastComputed = -Infinity,\n      value, computed;\n  if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {\n    obj = isArrayLike(obj) ? obj : values(obj);\n    for (var i = 0, length = obj.length; i < length; i++) {\n      value = obj[i];\n      if (value != null && value > result) {\n        result = value;\n      }\n    }\n  } else {\n    iteratee = cb(iteratee, context);\n    each(obj, function(v, index, list) {\n      computed = iteratee(v, index, list);\n      if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n        result = v;\n        lastComputed = computed;\n      }\n    });\n  }\n  return result;\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport cb from './_cb.js';\nimport each from './each.js';\n\n// Return the minimum element (or element-based computation).\nexport default function min(obj, iteratee, context) {\n  var result = Infinity, lastComputed = Infinity,\n      value, computed;\n  if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {\n    obj = isArrayLike(obj) ? obj : values(obj);\n    for (var i = 0, length = obj.length; i < length; i++) {\n      value = obj[i];\n      if (value != null && value < result) {\n        result = value;\n      }\n    }\n  } else {\n    iteratee = cb(iteratee, context);\n    each(obj, function(v, index, list) {\n      computed = iteratee(v, index, list);\n      if (computed < lastComputed || computed === Infinity && result === Infinity) {\n        result = v;\n        lastComputed = computed;\n      }\n    });\n  }\n  return result;\n}\n","import isArrayLike from './_isArrayLike.js';\nimport clone from './clone.js';\nimport values from './values.js';\nimport getLength from './_getLength.js';\nimport random from './random.js';\n\n// Sample **n** random values from a collection using the modern version of the\n// [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n// If **n** is not specified, returns a single random element.\n// The internal `guard` argument allows it to work with `_.map`.\nexport default function sample(obj, n, guard) {\n  if (n == null || guard) {\n    if (!isArrayLike(obj)) obj = values(obj);\n    return obj[random(obj.length - 1)];\n  }\n  var sample = isArrayLike(obj) ? clone(obj) : values(obj);\n  var length = getLength(sample);\n  n = Math.max(Math.min(n, length), 0);\n  var last = length - 1;\n  for (var index = 0; index < n; index++) {\n    var rand = random(index, last);\n    var temp = sample[index];\n    sample[index] = sample[rand];\n    sample[rand] = temp;\n  }\n  return sample.slice(0, n);\n}\n","import sample from './sample.js';\n\n// Shuffle a collection.\nexport default function shuffle(obj) {\n  return sample(obj, Infinity);\n}\n","import cb from './_cb.js';\nimport pluck from './pluck.js';\nimport map from './map.js';\n\n// Sort the object's values by a criterion produced by an iteratee.\nexport default function sortBy(obj, iteratee, context) {\n  var index = 0;\n  iteratee = cb(iteratee, context);\n  return pluck(map(obj, function(value, key, list) {\n    return {\n      value: value,\n      index: index++,\n      criteria: iteratee(value, key, list)\n    };\n  }).sort(function(left, right) {\n    var a = left.criteria;\n    var b = right.criteria;\n    if (a !== b) {\n      if (a > b || a === void 0) return 1;\n      if (a < b || b === void 0) return -1;\n    }\n    return left.index - right.index;\n  }), 'value');\n}\n","import cb from './_cb.js';\nimport each from './each.js';\n\n// An internal function used for aggregate \"group by\" operations.\nexport default function group(behavior, partition) {\n  return function(obj, iteratee, context) {\n    var result = partition ? [[], []] : {};\n    iteratee = cb(iteratee, context);\n    each(obj, function(value, index) {\n      var key = iteratee(value, index, obj);\n      behavior(result, value, key);\n    });\n    return result;\n  };\n}\n","import group from './_group.js';\nimport has from './_has.js';\n\n// Groups the object's values by a criterion. Pass either a string attribute\n// to group by, or a function that returns the criterion.\nexport default group(function(result, value, key) {\n  if (has(result, key)) result[key].push(value); else result[key] = [value];\n});\n","import group from './_group.js';\n\n// Indexes the object's values by a criterion, similar to `_.groupBy`, but for\n// when you know that your index values will be unique.\nexport default group(function(result, value, key) {\n  result[key] = value;\n});\n","import group from './_group.js';\nimport has from './_has.js';\n\n// Counts instances of an object that group by a certain criterion. Pass\n// either a string attribute to count by, or a function that returns the\n// criterion.\nexport default group(function(result, value, key) {\n  if (has(result, key)) result[key]++; else result[key] = 1;\n});\n","import group from './_group.js';\n\n// Split a collection into two arrays: one whose elements all pass the given\n// truth test, and one whose elements all do not pass the truth test.\nexport default group(function(result, value, pass) {\n  result[pass ? 0 : 1].push(value);\n}, true);\n","import isArray from './isArray.js';\nimport { slice } from './_setup.js';\nimport isString from './isString.js';\nimport isArrayLike from './_isArrayLike.js';\nimport map from './map.js';\nimport identity from './identity.js';\nimport values from './values.js';\n\n// Safely create a real, live array from anything iterable.\nvar reStrSymbol = /[^\\ud800-\\udfff]|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff]/g;\nexport default function toArray(obj) {\n  if (!obj) return [];\n  if (isArray(obj)) return slice.call(obj);\n  if (isString(obj)) {\n    // Keep surrogate pair characters together.\n    return obj.match(reStrSymbol);\n  }\n  if (isArrayLike(obj)) return map(obj, identity);\n  return values(obj);\n}\n","import isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Return the number of elements in a collection.\nexport default function size(obj) {\n  if (obj == null) return 0;\n  return isArrayLike(obj) ? obj.length : keys(obj).length;\n}\n","// Internal `_.pick` helper function to determine whether `key` is an enumerable\n// property name of `obj`.\nexport default function keyInObj(value, key, obj) {\n  return key in obj;\n}\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport optimizeCb from './_optimizeCb.js';\nimport allKeys from './allKeys.js';\nimport keyInObj from './_keyInObj.js';\nimport flatten from './_flatten.js';\n\n// Return a copy of the object only containing the allowed properties.\nexport default restArguments(function(obj, keys) {\n  var result = {}, iteratee = keys[0];\n  if (obj == null) return result;\n  if (isFunction(iteratee)) {\n    if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);\n    keys = allKeys(obj);\n  } else {\n    iteratee = keyInObj;\n    keys = flatten(keys, false, false);\n    obj = Object(obj);\n  }\n  for (var i = 0, length = keys.length; i < length; i++) {\n    var key = keys[i];\n    var value = obj[key];\n    if (iteratee(value, key, obj)) result[key] = value;\n  }\n  return result;\n});\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport negate from './negate.js';\nimport map from './map.js';\nimport flatten from './_flatten.js';\nimport contains from './contains.js';\nimport pick from './pick.js';\n\n// Return a copy of the object without the disallowed properties.\nexport default restArguments(function(obj, keys) {\n  var iteratee = keys[0], context;\n  if (isFunction(iteratee)) {\n    iteratee = negate(iteratee);\n    if (keys.length > 1) context = keys[1];\n  } else {\n    keys = map(flatten(keys, false, false), String);\n    iteratee = function(value, key) {\n      return !contains(keys, key);\n    };\n  }\n  return pick(obj, iteratee, context);\n});\n","import { slice } from './_setup.js';\n\n// Returns everything but the last entry of the array. Especially useful on\n// the arguments object. Passing **n** will return all the values in\n// the array, excluding the last N.\nexport default function initial(array, n, guard) {\n  return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n}\n","import initial from './initial.js';\n\n// Get the first element of an array. Passing **n** will return the first N\n// values in the array. The **guard** check allows it to work with `_.map`.\nexport default function first(array, n, guard) {\n  if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n  if (n == null || guard) return array[0];\n  return initial(array, array.length - n);\n}\n","import { slice } from './_setup.js';\n\n// Returns everything but the first entry of the `array`. Especially useful on\n// the `arguments` object. Passing an **n** will return the rest N values in the\n// `array`.\nexport default function rest(array, n, guard) {\n  return slice.call(array, n == null || guard ? 1 : n);\n}\n","import rest from './rest.js';\n\n// Get the last element of an array. Passing **n** will return the last N\n// values in the array.\nexport default function last(array, n, guard) {\n  if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n  if (n == null || guard) return array[array.length - 1];\n  return rest(array, Math.max(0, array.length - n));\n}\n","import filter from './filter.js';\n\n// Trim out all falsy values from an array.\nexport default function compact(array) {\n  return filter(array, Boolean);\n}\n","import _flatten from './_flatten.js';\n\n// Flatten out an array, either recursively (by default), or up to `depth`.\n// Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively.\nexport default function flatten(array, depth) {\n  return _flatten(array, depth, false);\n}\n","import restArguments from './restArguments.js';\nimport flatten from './_flatten.js';\nimport filter from './filter.js';\nimport contains from './contains.js';\n\n// Take the difference between one array and a number of other arrays.\n// Only the elements present in just the first array will remain.\nexport default restArguments(function(array, rest) {\n  rest = flatten(rest, true, true);\n  return filter(array, function(value){\n    return !contains(rest, value);\n  });\n});\n","import restArguments from './restArguments.js';\nimport difference from './difference.js';\n\n// Return a version of the array that does not contain the specified value(s).\nexport default restArguments(function(array, otherArrays) {\n  return difference(array, otherArrays);\n});\n","import isBoolean from './isBoolean.js';\nimport cb from './_cb.js';\nimport getLength from './_getLength.js';\nimport contains from './contains.js';\n\n// Produce a duplicate-free version of the array. If the array has already\n// been sorted, you have the option of using a faster algorithm.\n// The faster algorithm will not work with an iteratee if the iteratee\n// is not a one-to-one function, so providing an iteratee will disable\n// the faster algorithm.\nexport default function uniq(array, isSorted, iteratee, context) {\n  if (!isBoolean(isSorted)) {\n    context = iteratee;\n    iteratee = isSorted;\n    isSorted = false;\n  }\n  if (iteratee != null) iteratee = cb(iteratee, context);\n  var result = [];\n  var seen = [];\n  for (var i = 0, length = getLength(array); i < length; i++) {\n    var value = array[i],\n        computed = iteratee ? iteratee(value, i, array) : value;\n    if (isSorted && !iteratee) {\n      if (!i || seen !== computed) result.push(value);\n      seen = computed;\n    } else if (iteratee) {\n      if (!contains(seen, computed)) {\n        seen.push(computed);\n        result.push(value);\n      }\n    } else if (!contains(result, value)) {\n      result.push(value);\n    }\n  }\n  return result;\n}\n","import restArguments from './restArguments.js';\nimport uniq from './uniq.js';\nimport flatten from './_flatten.js';\n\n// Produce an array that contains the union: each distinct element from all of\n// the passed-in arrays.\nexport default restArguments(function(arrays) {\n  return uniq(flatten(arrays, true, true));\n});\n","import getLength from './_getLength.js';\nimport contains from './contains.js';\n\n// Produce an array that contains every item shared between all the\n// passed-in arrays.\nexport default function intersection(array) {\n  var result = [];\n  var argsLength = arguments.length;\n  for (var i = 0, length = getLength(array); i < length; i++) {\n    var item = array[i];\n    if (contains(result, item)) continue;\n    var j;\n    for (j = 1; j < argsLength; j++) {\n      if (!contains(arguments[j], item)) break;\n    }\n    if (j === argsLength) result.push(item);\n  }\n  return result;\n}\n","import max from './max.js';\nimport getLength from './_getLength.js';\nimport pluck from './pluck.js';\n\n// Complement of zip. Unzip accepts an array of arrays and groups\n// each array's elements on shared indices.\nexport default function unzip(array) {\n  var length = array && max(array, getLength).length || 0;\n  var result = Array(length);\n\n  for (var index = 0; index < length; index++) {\n    result[index] = pluck(array, index);\n  }\n  return result;\n}\n","import restArguments from './restArguments.js';\nimport unzip from './unzip.js';\n\n// Zip together multiple lists into a single array -- elements that share\n// an index go together.\nexport default restArguments(unzip);\n","import getLength  from './_getLength.js';\n\n// Converts lists into objects. Pass either a single array of `[key, value]`\n// pairs, or two parallel arrays of the same length -- one of keys, and one of\n// the corresponding values. Passing by pairs is the reverse of `_.pairs`.\nexport default function object(list, values) {\n  var result = {};\n  for (var i = 0, length = getLength(list); i < length; i++) {\n    if (values) {\n      result[list[i]] = values[i];\n    } else {\n      result[list[i][0]] = list[i][1];\n    }\n  }\n  return result;\n}\n","// Generate an integer Array containing an arithmetic progression. A port of\n// the native Python `range()` function. See\n// [the Python documentation](https://docs.python.org/library/functions.html#range).\nexport default function range(start, stop, step) {\n  if (stop == null) {\n    stop = start || 0;\n    start = 0;\n  }\n  if (!step) {\n    step = stop < start ? -1 : 1;\n  }\n\n  var length = Math.max(Math.ceil((stop - start) / step), 0);\n  var range = Array(length);\n\n  for (var idx = 0; idx < length; idx++, start += step) {\n    range[idx] = start;\n  }\n\n  return range;\n}\n","import { slice } from './_setup.js';\n\n// Chunk a single array into multiple arrays, each containing `count` or fewer\n// items.\nexport default function chunk(array, count) {\n  if (count == null || count < 1) return [];\n  var result = [];\n  var i = 0, length = array.length;\n  while (i < length) {\n    result.push(slice.call(array, i, i += count));\n  }\n  return result;\n}\n","import _ from './underscore.js';\n\n// Helper function to continue chaining intermediate results.\nexport default function chainResult(instance, obj) {\n  return instance._chain ? _(obj).chain() : obj;\n}\n","import _ from './underscore.js';\nimport each from './each.js';\nimport functions from './functions.js';\nimport { push } from './_setup.js';\nimport chainResult from './_chainResult.js';\n\n// Add your own custom functions to the Underscore object.\nexport default function mixin(obj) {\n  each(functions(obj), function(name) {\n    var func = _[name] = obj[name];\n    _.prototype[name] = function() {\n      var args = [this._wrapped];\n      push.apply(args, arguments);\n      return chainResult(this, func.apply(_, args));\n    };\n  });\n  return _;\n}\n","import _ from './underscore.js';\nimport each from './each.js';\nimport { ArrayProto } from './_setup.js';\nimport chainResult from './_chainResult.js';\n\n// Add all mutator `Array` functions to the wrapper.\neach(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n  var method = ArrayProto[name];\n  _.prototype[name] = function() {\n    var obj = this._wrapped;\n    if (obj != null) {\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) {\n        delete obj[0];\n      }\n    }\n    return chainResult(this, obj);\n  };\n});\n\n// Add all accessor `Array` functions to the wrapper.\neach(['concat', 'join', 'slice'], function(name) {\n  var method = ArrayProto[name];\n  _.prototype[name] = function() {\n    var obj = this._wrapped;\n    if (obj != null) obj = method.apply(obj, arguments);\n    return chainResult(this, obj);\n  };\n});\n\nexport default _;\n","// Default Export\n// ==============\n// In this module, we mix our bundled exports into the `_` object and export\n// the result. This is analogous to setting `module.exports = _` in CommonJS.\n// Hence, this module is also the entry point of our UMD bundle and the package\n// entry point for CommonJS and AMD users. In other words, this is (the source\n// of) the module you are interfacing with when you do any of the following:\n//\n// ```js\n// // CommonJS\n// var _ = require('underscore');\n//\n// // AMD\n// define(['underscore'], function(_) {...});\n//\n// // UMD in the browser\n// // _ is available as a global variable\n// ```\nimport * as allExports from './index.js';\nimport { mixin } from './index.js';\n\n// Add all of the Underscore functions to the wrapper object.\nvar _ = mixin(allExports);\n// Legacy Node.js API.\n_._ = _;\n// Export the Underscore API.\nexport default _;\n","/* globals __webpack_amd_options__ */\nmodule.exports = __webpack_amd_options__;\n","'use strict';\nvar aFunction = require('../internals/a-function');\nvar isObject = require('../internals/is-object');\n\nvar slice = [].slice;\nvar factories = {};\n\nvar construct = function (C, argsLength, args) {\n  if (!(argsLength in factories)) {\n    for (var list = [], i = 0; i < argsLength; i++) list[i] = 'a[' + i + ']';\n    // eslint-disable-next-line no-new-func -- we have no proper alternatives, IE8- only\n    factories[argsLength] = Function('C,a', 'return new C(' + list.join(',') + ')');\n  } return factories[argsLength](C, args);\n};\n\n// `Function.prototype.bind` method implementation\n// https://tc39.es/ecma262/#sec-function.prototype.bind\nmodule.exports = Function.bind || function bind(that /* , ...args */) {\n  var fn = aFunction(this);\n  var partArgs = slice.call(arguments, 1);\n  var boundFunction = function bound(/* args... */) {\n    var args = partArgs.concat(slice.call(arguments));\n    return this instanceof boundFunction ? construct(fn, args.length, args) : fn.apply(that, args);\n  };\n  if (isObject(fn.prototype)) boundFunction.prototype = fn.prototype;\n  return boundFunction;\n};\n","// `Symbol.prototype.description` getter\n// https://tc39.github.io/ecma262/#sec-symbol.prototype.description\n'use strict';\nvar $ = require('../internals/export');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar has = require('../internals/has');\nvar isObject = require('../internals/is-object');\nvar defineProperty = require('../internals/object-define-property').f;\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\n\nvar NativeSymbol = global.Symbol;\n\nif (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) ||\n  // Safari 12 bug\n  NativeSymbol().description !== undefined\n)) {\n  var EmptyStringDescriptionStore = {};\n  // wrap Symbol constructor for correct work with undefined description\n  var SymbolWrapper = function Symbol() {\n    var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]);\n    var result = this instanceof SymbolWrapper\n      ? new NativeSymbol(description)\n      // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'\n      : description === undefined ? NativeSymbol() : NativeSymbol(description);\n    if (description === '') EmptyStringDescriptionStore[result] = true;\n    return result;\n  };\n  copyConstructorProperties(SymbolWrapper, NativeSymbol);\n  var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype;\n  symbolPrototype.constructor = SymbolWrapper;\n\n  var symbolToString = symbolPrototype.toString;\n  var native = String(NativeSymbol('test')) == 'Symbol(test)';\n  var regexp = /^Symbol\\((.*)\\)[^)]+$/;\n  defineProperty(symbolPrototype, 'description', {\n    configurable: true,\n    get: function description() {\n      var symbol = isObject(this) ? this.valueOf() : this;\n      var string = symbolToString.call(symbol);\n      if (has(EmptyStringDescriptionStore, symbol)) return '';\n      var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1');\n      return desc === '' ? undefined : desc;\n    }\n  });\n\n  $({ global: true, forced: true }, {\n    Symbol: SymbolWrapper\n  });\n}\n","// Current version.\nexport var VERSION = '1.13.1';\n\n// Establish the root object, `window` (`self`) in the browser, `global`\n// on the server, or `this` in some virtual machines. We use `self`\n// instead of `window` for `WebWorker` support.\nexport var root = typeof self == 'object' && self.self === self && self ||\n          typeof global == 'object' && global.global === global && global ||\n          Function('return this')() ||\n          {};\n\n// Save bytes in the minified (but not gzipped) version:\nexport var ArrayProto = Array.prototype, ObjProto = Object.prototype;\nexport var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;\n\n// Create quick reference variables for speed access to core prototypes.\nexport var push = ArrayProto.push,\n    slice = ArrayProto.slice,\n    toString = ObjProto.toString,\n    hasOwnProperty = ObjProto.hasOwnProperty;\n\n// Modern feature detection.\nexport var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',\n    supportsDataView = typeof DataView !== 'undefined';\n\n// All **ECMAScript 5+** native function implementations that we hope to use\n// are declared here.\nexport var nativeIsArray = Array.isArray,\n    nativeKeys = Object.keys,\n    nativeCreate = Object.create,\n    nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;\n\n// Create references to these builtin functions because we override them.\nexport var _isNaN = isNaN,\n    _isFinite = isFinite;\n\n// Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\nexport var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\nexport var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n  'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n// The largest integer that can be represented exactly.\nexport var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n","var parent = require('../../es/instance/bind');\n\nmodule.exports = parent;\n","module.exports = require(\"core-js-pure/stable/instance/bind\");","var fails = require('../internals/fails');\nvar whitespaces = require('../internals/whitespaces');\n\nvar non = '\\u200B\\u0085\\u180E';\n\n// check that a method works with the correct list\n// of whitespaces and has a correct name\nmodule.exports = function (METHOD_NAME) {\n  return fails(function () {\n    return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME;\n  });\n};\n","/* Riot v2.6.8, @license MIT */\n\n;(function(window, undefined) {\n  'use strict';\nvar riot = { version: 'v2.6.8', settings: {} },\n  // be aware, internal usage\n  // ATTENTION: prefix the global dynamic variables with `__`\n\n  // counter to give a unique id to all the Tag instances\n  __uid = 0,\n  // tags instances cache\n  __virtualDom = [],\n  // tags implementation cache\n  __tagImpl = {},\n\n  /**\n   * Const\n   */\n  GLOBAL_MIXIN = '__global_mixin',\n\n  // riot specific prefixes\n  RIOT_PREFIX = 'riot-',\n  RIOT_TAG = RIOT_PREFIX + 'tag',\n  RIOT_TAG_IS = 'data-is',\n\n  // for typeof == '' comparisons\n  T_STRING = 'string',\n  T_OBJECT = 'object',\n  T_UNDEF  = 'undefined',\n  T_FUNCTION = 'function',\n  XLINK_NS = 'http://www.w3.org/1999/xlink',\n  XLINK_REGEX = /^xlink:(\\w+)/,\n  // special native tags that cannot be treated like the others\n  SPECIAL_TAGS_REGEX = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?|opt(?:ion|group))$/,\n  RESERVED_WORDS_BLACKLIST = /^(?:_(?:item|id|parent)|update|root|(?:un)?mount|mixin|is(?:Mounted|Loop)|tags|parent|opts|trigger|o(?:n|ff|ne))$/,\n  // SVG tags list https://www.w3.org/TR/SVG/attindex.html#PresentationAttributes\n  SVG_TAGS_LIST = ['altGlyph', 'animate', 'animateColor', 'circle', 'clipPath', 'defs', 'ellipse', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feFlood', 'feGaussianBlur', 'feImage', 'feMerge', 'feMorphology', 'feOffset', 'feSpecularLighting', 'feTile', 'feTurbulence', 'filter', 'font', 'foreignObject', 'g', 'glyph', 'glyphRef', 'image', 'line', 'linearGradient', 'marker', 'mask', 'missing-glyph', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'switch', 'symbol', 'text', 'textPath', 'tref', 'tspan', 'use'],\n\n  // version# for IE 8-11, 0 for others\n  IE_VERSION = (window && window.document || {}).documentMode | 0,\n\n  // detect firefox to fix #1374\n  FIREFOX = window && !!window.InstallTrigger\n/* istanbul ignore next */\nriot.observable = function(el) {\n\n  /**\n   * Extend the original object or create a new empty one\n   * @type { Object }\n   */\n\n  el = el || {}\n\n  /**\n   * Private variables\n   */\n  var callbacks = {},\n    slice = Array.prototype.slice\n\n  /**\n   * Private Methods\n   */\n\n  /**\n   * Helper function needed to get and loop all the events in a string\n   * @param   { String }   e - event string\n   * @param   {Function}   fn - callback\n   */\n  function onEachEvent(e, fn) {\n    var es = e.split(' '), l = es.length, i = 0\n    for (; i < l; i++) {\n      var name = es[i]\n      if (name) fn(name, i)\n    }\n  }\n\n  /**\n   * Public Api\n   */\n\n  // extend the el object adding the observable methods\n  Object.defineProperties(el, {\n    /**\n     * Listen to the given space separated list of `events` and\n     * execute the `callback` each time an event is triggered.\n     * @param  { String } events - events ids\n     * @param  { Function } fn - callback function\n     * @returns { Object } el\n     */\n    on: {\n      value: function(events, fn) {\n        if (typeof fn != 'function')  return el\n\n        onEachEvent(events, function(name, pos) {\n          (callbacks[name] = callbacks[name] || []).push(fn)\n          fn.typed = pos > 0\n        })\n\n        return el\n      },\n      enumerable: false,\n      writable: false,\n      configurable: false\n    },\n\n    /**\n     * Removes the given space separated list of `events` listeners\n     * @param   { String } events - events ids\n     * @param   { Function } fn - callback function\n     * @returns { Object } el\n     */\n    off: {\n      value: function(events, fn) {\n        if (events == '*' && !fn) callbacks = {}\n        else {\n          onEachEvent(events, function(name, pos) {\n            if (fn) {\n              var arr = callbacks[name]\n              for (var i = 0, cb; cb = arr && arr[i]; ++i) {\n                if (cb == fn) arr.splice(i--, 1)\n              }\n            } else delete callbacks[name]\n          })\n        }\n        return el\n      },\n      enumerable: false,\n      writable: false,\n      configurable: false\n    },\n\n    /**\n     * Listen to the given space separated list of `events` and\n     * execute the `callback` at most once\n     * @param   { String } events - events ids\n     * @param   { Function } fn - callback function\n     * @returns { Object } el\n     */\n    one: {\n      value: function(events, fn) {\n        function on() {\n          el.off(events, on)\n          fn.apply(el, arguments)\n        }\n        return el.on(events, on)\n      },\n      enumerable: false,\n      writable: false,\n      configurable: false\n    },\n\n    /**\n     * Execute all callback functions that listen to\n     * the given space separated list of `events`\n     * @param   { String } events - events ids\n     * @returns { Object } el\n     */\n    trigger: {\n      value: function(events) {\n\n        // getting the arguments\n        var arglen = arguments.length - 1,\n          args = new Array(arglen),\n          fns\n\n        for (var i = 0; i < arglen; i++) {\n          args[i] = arguments[i + 1] // skip first argument\n        }\n\n        onEachEvent(events, function(name, pos) {\n\n          fns = slice.call(callbacks[name] || [], 0)\n\n          for (var i = 0, fn; fn = fns[i]; ++i) {\n            if (fn.busy) continue\n            fn.busy = 1\n            fn.apply(el, fn.typed ? [name].concat(args) : args)\n            if (fns[i] !== fn) { i-- }\n            fn.busy = 0\n          }\n\n          if (callbacks['*'] && name != '*')\n            el.trigger.apply(el, ['*', name].concat(args))\n\n        })\n\n        return el\n      },\n      enumerable: false,\n      writable: false,\n      configurable: false\n    }\n  })\n\n  return el\n\n}\n/* istanbul ignore next */\n;(function(riot) {\n\n/**\n * Simple client-side router\n * @module riot-route\n */\n\n\nvar RE_ORIGIN = /^.+?\\/\\/+[^\\/]+/,\n  EVENT_LISTENER = 'EventListener',\n  REMOVE_EVENT_LISTENER = 'remove' + EVENT_LISTENER,\n  ADD_EVENT_LISTENER = 'add' + EVENT_LISTENER,\n  HAS_ATTRIBUTE = 'hasAttribute',\n  REPLACE = 'replace',\n  POPSTATE = 'popstate',\n  HASHCHANGE = 'hashchange',\n  TRIGGER = 'trigger',\n  MAX_EMIT_STACK_LEVEL = 3,\n  win = typeof window != 'undefined' && window,\n  doc = typeof document != 'undefined' && document,\n  hist = win && history,\n  loc = win && (hist.location || win.location), // see html5-history-api\n  prot = Router.prototype, // to minify more\n  clickEvent = doc && doc.ontouchstart ? 'touchstart' : 'click',\n  started = false,\n  central = riot.observable(),\n  routeFound = false,\n  debouncedEmit,\n  base, current, parser, secondParser, emitStack = [], emitStackLevel = 0\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 */\nfunction 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 */\nfunction DEFAULT_SECOND_PARSER(path, filter) {\n  var re = new RegExp('^' + filter[REPLACE](/\\*/g, '([^/?#]+?)')[REPLACE](/\\.\\./, '.*') + '$'),\n    args = path.match(re)\n\n  if (args) return args.slice(1)\n}\n\n/**\n * Simple/cheap debounce implementation\n * @param   {function} fn - callback\n * @param   {number} delay - delay in seconds\n * @returns {function} debounced function\n */\nfunction debounce(fn, delay) {\n  var t\n  return function () {\n    clearTimeout(t)\n    t = setTimeout(fn, delay)\n  }\n}\n\n/**\n * Set the window listeners to trigger the routes\n * @param {boolean} autoExec - see route.start\n */\nfunction start(autoExec) {\n  debouncedEmit = debounce(emit, 1)\n  win[ADD_EVENT_LISTENER](POPSTATE, debouncedEmit)\n  win[ADD_EVENT_LISTENER](HASHCHANGE, debouncedEmit)\n  doc[ADD_EVENT_LISTENER](clickEvent, click)\n  if (autoExec) emit(true)\n}\n\n/**\n * Router class\n */\nfunction Router() {\n  this.$ = []\n  riot.observable(this) // make it observable\n  central.on('stop', this.s.bind(this))\n  central.on('emit', this.e.bind(this))\n}\n\nfunction normalize(path) {\n  return path[REPLACE](/^\\/|\\/$/, '')\n}\n\nfunction isString(str) {\n  return typeof str == 'string'\n}\n\n/**\n * Get the part after domain name\n * @param {string} href - fullpath\n * @returns {string} path from root\n */\nfunction getPathFromRoot(href) {\n  return (href || loc.href)[REPLACE](RE_ORIGIN, '')\n}\n\n/**\n * Get the part after base\n * @param {string} href - fullpath\n * @returns {string} path from base\n */\nfunction getPathFromBase(href) {\n  return base[0] == '#'\n    ? (href || loc.href || '').split(base)[1] || ''\n    : (loc ? getPathFromRoot(href) : href || '')[REPLACE](base, '')\n}\n\nfunction emit(force) {\n  // the stack is needed for redirections\n  var isRoot = emitStackLevel == 0, first\n  if (MAX_EMIT_STACK_LEVEL <= emitStackLevel) return\n\n  emitStackLevel++\n  emitStack.push(function() {\n    var path = getPathFromBase()\n    if (force || path != current) {\n      central[TRIGGER]('emit', path)\n      current = path\n    }\n  })\n  if (isRoot) {\n    while (first = emitStack.shift()) first() // stack increses within this call\n    emitStackLevel = 0\n  }\n}\n\nfunction 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  var el = e.target\n  while (el && el.nodeName != 'A') el = el.parentNode\n\n  if (\n    !el || el.nodeName != 'A' // not A tag\n    || el[HAS_ATTRIBUTE]('download') // has download attr\n    || !el[HAS_ATTRIBUTE]('href') // has no href attr\n    || el.target && el.target != '_self' // another window or frame\n    || el.href.indexOf(loc.href.match(RE_ORIGIN)[0]) == -1 // cross origin\n  ) return\n\n  if (el.href != loc.href\n    && (\n      el.href.split('#')[0] == loc.href.split('#')[0] // internal jump\n      || base[0] != '#' && getPathFromRoot(el.href).indexOf(base) !== 0 // outside of base\n      || base[0] == '#' && el.href.split(base)[0] != loc.href.split(base)[0] // outside of #base\n      || !go(getPathFromBase(el.href), el.title || 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 */\nfunction go(path, title, shouldReplace) {\n  // Server-side usage: directly execute handlers for the path\n  if (!hist) return central[TRIGGER]('emit', getPathFromBase(path))\n\n  path = base + normalize(path)\n  title = title || doc.title\n  // browsers ignores the second parameter `title`\n  shouldReplace\n    ? hist.replaceState(null, title, path)\n    : hist.pushState(null, title, path)\n  // so we need to set it manually\n  doc.title = title\n  routeFound = false\n  emit()\n  return routeFound\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 */\nprot.m = function(first, second, third) {\n  if (isString(first) && (!second || isString(second))) go(first, second, third || false)\n  else if (second) this.r(first, second)\n  else this.r('@', first)\n}\n\n/**\n * Stop routing\n */\nprot.s = function() {\n  this.off('*')\n  this.$ = []\n}\n\n/**\n * Emit\n * @param {string} path - path\n */\nprot.e = function(path) {\n  this.$.concat('@').some(function(filter) {\n    var args = (filter == '@' ? parser : secondParser)(normalize(path), normalize(filter))\n    if (typeof args != 'undefined') {\n      this[TRIGGER].apply(null, [filter].concat(args))\n      return routeFound = true // exit from loop\n    }\n  }, this)\n}\n\n/**\n * Register route\n * @param {string} filter - filter for matching to url\n * @param {function} action - action to register\n */\nprot.r = function(filter, action) {\n  if (filter != '@') {\n    filter = '/' + normalize(filter)\n    this.$.push(filter)\n  }\n  this.on(filter, action)\n}\n\nvar mainRouter = new Router()\nvar route = mainRouter.m.bind(mainRouter)\n\n/**\n * Create a sub router\n * @returns {function} the method of a new Router object\n */\nroute.create = function() {\n  var newSubRouter = new Router()\n  // assign sub-router's main method\n  var router = newSubRouter.m.bind(newSubRouter)\n  // stop only this sub-router\n  router.stop = newSubRouter.s.bind(newSubRouter)\n  return router\n}\n\n/**\n * Set the base of url\n * @param {(str|RegExp)} arg - a new base or '#' or '#!'\n */\nroute.base = function(arg) {\n  base = arg || '#'\n  current = getPathFromBase() // recalculate current path\n}\n\n/** Exec routing right now **/\nroute.exec = function() {\n  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 */\nroute.parser = function(fn, fn2) {\n  if (!fn && !fn2) {\n    // reset parser for testing...\n    parser = DEFAULT_PARSER\n    secondParser = DEFAULT_SECOND_PARSER\n  }\n  if (fn) parser = fn\n  if (fn2) secondParser = fn2\n}\n\n/**\n * Helper function to get url query as an object\n * @returns {object} parsed query\n */\nroute.query = function() {\n  var q = {}\n  var href = loc.href || current\n  href[REPLACE](/[?&](.+?)=([^&]*)/g, function(_, k, v) { q[k] = v })\n  return q\n}\n\n/** Stop routing **/\nroute.stop = function () {\n  if (started) {\n    if (win) {\n      win[REMOVE_EVENT_LISTENER](POPSTATE, debouncedEmit)\n      win[REMOVE_EVENT_LISTENER](HASHCHANGE, debouncedEmit)\n      doc[REMOVE_EVENT_LISTENER](clickEvent, click)\n    }\n    central[TRIGGER]('stop')\n    started = false\n  }\n}\n\n/**\n * Start routing\n * @param {boolean} autoExec - automatically exec after starting if true\n */\nroute.start = function (autoExec) {\n  if (!started) {\n    if (win) {\n      if (document.readyState == 'complete') start(autoExec)\n      // the timeout is needed to solve\n      // a weird safari bug https://github.com/riot/route/issues/33\n      else win[ADD_EVENT_LISTENER]('load', function() {\n        setTimeout(function() { start(autoExec) }, 1)\n      })\n    }\n    started = true\n  }\n}\n\n/** Prepare the router **/\nroute.base()\nroute.parser()\n\nriot.route = route\n})(riot)\n/* istanbul ignore next */\n\n/**\n * The riot template engine\n * @version v2.4.2\n */\n/**\n * riot.util.brackets\n *\n * - `brackets    ` - Returns a string or regex based on its parameter\n * - `brackets.set` - Change the current riot brackets\n *\n * @module\n */\n\nvar brackets = (function (UNDEF) {\n\n  var\n    REGLOB = 'g',\n\n    R_MLCOMMS = /\\/\\*[^*]*\\*+(?:[^*\\/][^*]*\\*+)*\\//g,\n\n    R_STRINGS = /\"[^\"\\\\]*(?:\\\\[\\S\\s][^\"\\\\]*)*\"|'[^'\\\\]*(?:\\\\[\\S\\s][^'\\\\]*)*'/g,\n\n    S_QBLOCKS = R_STRINGS.source + '|' +\n      /(?:\\breturn\\s+|(?:[$\\w\\)\\]]|\\+\\+|--)\\s*(\\/)(?![*\\/]))/.source + '|' +\n      /\\/(?=[^*\\/])[^[\\/\\\\]*(?:(?:\\[(?:\\\\.|[^\\]\\\\]*)*\\]|\\\\.)[^[\\/\\\\]*)*?(\\/)[gim]*/.source,\n\n    UNSUPPORTED = RegExp('[\\\\' + 'x00-\\\\x1F<>a-zA-Z0-9\\'\",;\\\\\\\\]'),\n\n    NEED_ESCAPE = /(?=[[\\]()*+?.^$|])/g,\n\n    FINDBRACES = {\n      '(': RegExp('([()])|'   + S_QBLOCKS, REGLOB),\n      '[': RegExp('([[\\\\]])|' + S_QBLOCKS, REGLOB),\n      '{': RegExp('([{}])|'   + S_QBLOCKS, REGLOB)\n    },\n\n    DEFAULT = '{ }'\n\n  var _pairs = [\n    '{', '}',\n    '{', '}',\n    /{[^}]*}/,\n    /\\\\([{}])/g,\n    /\\\\({)|{/g,\n    RegExp('\\\\\\\\(})|([[({])|(})|' + S_QBLOCKS, REGLOB),\n    DEFAULT,\n    /^\\s*{\\^?\\s*([$\\w]+)(?:\\s*,\\s*(\\S+))?\\s+in\\s+(\\S.*)\\s*}/,\n    /(^|[^\\\\]){=[\\S\\s]*?}/\n  ]\n\n  var\n    cachedBrackets = UNDEF,\n    _regex,\n    _cache = [],\n    _settings\n\n  function _loopback (re) { return re }\n\n  function _rewrite (re, bp) {\n    if (!bp) bp = _cache\n    return new RegExp(\n      re.source.replace(/{/g, bp[2]).replace(/}/g, bp[3]), re.global ? REGLOB : ''\n    )\n  }\n\n  function _create (pair) {\n    if (pair === DEFAULT) return _pairs\n\n    var arr = pair.split(' ')\n\n    if (arr.length !== 2 || UNSUPPORTED.test(pair)) {\n      throw new Error('Unsupported brackets \"' + pair + '\"')\n    }\n    arr = arr.concat(pair.replace(NEED_ESCAPE, '\\\\').split(' '))\n\n    arr[4] = _rewrite(arr[1].length > 1 ? /{[\\S\\s]*?}/ : _pairs[4], arr)\n    arr[5] = _rewrite(pair.length > 3 ? /\\\\({|})/g : _pairs[5], arr)\n    arr[6] = _rewrite(_pairs[6], arr)\n    arr[7] = RegExp('\\\\\\\\(' + arr[3] + ')|([[({])|(' + arr[3] + ')|' + S_QBLOCKS, REGLOB)\n    arr[8] = pair\n    return arr\n  }\n\n  function _brackets (reOrIdx) {\n    return reOrIdx instanceof RegExp ? _regex(reOrIdx) : _cache[reOrIdx]\n  }\n\n  _brackets.split = function split (str, tmpl, _bp) {\n    // istanbul ignore next: _bp is for the compiler\n    if (!_bp) _bp = _cache\n\n    var\n      parts = [],\n      match,\n      isexpr,\n      start,\n      pos,\n      re = _bp[6]\n\n    isexpr = start = re.lastIndex = 0\n\n    while ((match = re.exec(str))) {\n\n      pos = match.index\n\n      if (isexpr) {\n\n        if (match[2]) {\n          re.lastIndex = skipBraces(str, match[2], re.lastIndex)\n          continue\n        }\n        if (!match[3]) {\n          continue\n        }\n      }\n\n      if (!match[1]) {\n        unescapeStr(str.slice(start, pos))\n        start = re.lastIndex\n        re = _bp[6 + (isexpr ^= 1)]\n        re.lastIndex = start\n      }\n    }\n\n    if (str && start < str.length) {\n      unescapeStr(str.slice(start))\n    }\n\n    return parts\n\n    function unescapeStr (s) {\n      if (tmpl || isexpr) {\n        parts.push(s && s.replace(_bp[5], '$1'))\n      } else {\n        parts.push(s)\n      }\n    }\n\n    function skipBraces (s, ch, ix) {\n      var\n        match,\n        recch = FINDBRACES[ch]\n\n      recch.lastIndex = ix\n      ix = 1\n      while ((match = recch.exec(s))) {\n        if (match[1] &&\n          !(match[1] === ch ? ++ix : --ix)) break\n      }\n      return ix ? s.length : recch.lastIndex\n    }\n  }\n\n  _brackets.hasExpr = function hasExpr (str) {\n    return _cache[4].test(str)\n  }\n\n  _brackets.loopKeys = function loopKeys (expr) {\n    var m = expr.match(_cache[9])\n\n    return m\n      ? { key: m[1], pos: m[2], val: _cache[0] + m[3].trim() + _cache[1] }\n      : { val: expr.trim() }\n  }\n\n  _brackets.array = function array (pair) {\n    return pair ? _create(pair) : _cache\n  }\n\n  function _reset (pair) {\n    if ((pair || (pair = DEFAULT)) !== _cache[8]) {\n      _cache = _create(pair)\n      _regex = pair === DEFAULT ? _loopback : _rewrite\n      _cache[9] = _regex(_pairs[9])\n    }\n    cachedBrackets = pair\n  }\n\n  function _setSettings (o) {\n    var b\n\n    o = o || {}\n    b = o.brackets\n    Object.defineProperty(o, 'brackets', {\n      set: _reset,\n      get: function () { return cachedBrackets },\n      enumerable: true\n    })\n    _settings = o\n    _reset(b)\n  }\n\n  Object.defineProperty(_brackets, 'settings', {\n    set: _setSettings,\n    get: function () { return _settings }\n  })\n\n  /* istanbul ignore next: in the browser riot is always in the scope */\n  _brackets.settings = typeof riot !== 'undefined' && riot.settings || {}\n  _brackets.set = _reset\n\n  _brackets.R_STRINGS = R_STRINGS\n  _brackets.R_MLCOMMS = R_MLCOMMS\n  _brackets.S_QBLOCKS = S_QBLOCKS\n\n  return _brackets\n\n})()\n\n/**\n * @module tmpl\n *\n * tmpl          - Root function, returns the template value, render with data\n * tmpl.hasExpr  - Test the existence of a expression inside a string\n * tmpl.loopKeys - Get the keys for an 'each' loop (used by `_each`)\n */\n\nvar tmpl = (function () {\n\n  var _cache = {}\n\n  function _tmpl (str, data) {\n    if (!str) return str\n\n    return (_cache[str] || (_cache[str] = _create(str))).call(data, _logErr)\n  }\n\n  _tmpl.haveRaw = brackets.hasRaw\n\n  _tmpl.hasExpr = brackets.hasExpr\n\n  _tmpl.loopKeys = brackets.loopKeys\n\n  // istanbul ignore next\n  _tmpl.clearCache = function () { _cache = {} }\n\n  _tmpl.errorHandler = null\n\n  function _logErr (err, ctx) {\n\n    if (_tmpl.errorHandler) {\n\n      err.riotData = {\n        tagName: ctx && ctx.root && ctx.root.tagName,\n        _riot_id: ctx && ctx._riot_id  //eslint-disable-line camelcase\n      }\n      _tmpl.errorHandler(err)\n    }\n  }\n\n  function _create (str) {\n    var expr = _getTmpl(str)\n\n    if (expr.slice(0, 11) !== 'try{return ') expr = 'return ' + expr\n\n    return new Function('E', expr + ';')    // eslint-disable-line no-new-func\n  }\n\n  var\n    CH_IDEXPR = String.fromCharCode(0x2057),\n    RE_CSNAME = /^(?:(-?[_A-Za-z\\xA0-\\xFF][-\\w\\xA0-\\xFF]*)|\\u2057(\\d+)~):/,\n    RE_QBLOCK = RegExp(brackets.S_QBLOCKS, 'g'),\n    RE_DQUOTE = /\\u2057/g,\n    RE_QBMARK = /\\u2057(\\d+)~/g\n\n  function _getTmpl (str) {\n    var\n      qstr = [],\n      expr,\n      parts = brackets.split(str.replace(RE_DQUOTE, '\"'), 1)\n\n    if (parts.length > 2 || parts[0]) {\n      var i, j, list = []\n\n      for (i = j = 0; i < parts.length; ++i) {\n\n        expr = parts[i]\n\n        if (expr && (expr = i & 1\n\n            ? _parseExpr(expr, 1, qstr)\n\n            : '\"' + expr\n                .replace(/\\\\/g, '\\\\\\\\')\n                .replace(/\\r\\n?|\\n/g, '\\\\n')\n                .replace(/\"/g, '\\\\\"') +\n              '\"'\n\n          )) list[j++] = expr\n\n      }\n\n      expr = j < 2 ? list[0]\n           : '[' + list.join(',') + '].join(\"\")'\n\n    } else {\n\n      expr = _parseExpr(parts[1], 0, qstr)\n    }\n\n    if (qstr[0]) {\n      expr = expr.replace(RE_QBMARK, function (_, pos) {\n        return qstr[pos]\n          .replace(/\\r/g, '\\\\r')\n          .replace(/\\n/g, '\\\\n')\n      })\n    }\n    return expr\n  }\n\n  var\n    RE_BREND = {\n      '(': /[()]/g,\n      '[': /[[\\]]/g,\n      '{': /[{}]/g\n    }\n\n  function _parseExpr (expr, asText, qstr) {\n\n    expr = expr\n          .replace(RE_QBLOCK, function (s, div) {\n            return s.length > 2 && !div ? CH_IDEXPR + (qstr.push(s) - 1) + '~' : s\n          })\n          .replace(/\\s+/g, ' ').trim()\n          .replace(/\\ ?([[\\({},?\\.:])\\ ?/g, '$1')\n\n    if (expr) {\n      var\n        list = [],\n        cnt = 0,\n        match\n\n      while (expr &&\n            (match = expr.match(RE_CSNAME)) &&\n            !match.index\n        ) {\n        var\n          key,\n          jsb,\n          re = /,|([[{(])|$/g\n\n        expr = RegExp.rightContext\n        key  = match[2] ? qstr[match[2]].slice(1, -1).trim().replace(/\\s+/g, ' ') : match[1]\n\n        while (jsb = (match = re.exec(expr))[1]) skipBraces(jsb, re)\n\n        jsb  = expr.slice(0, match.index)\n        expr = RegExp.rightContext\n\n        list[cnt++] = _wrapExpr(jsb, 1, key)\n      }\n\n      expr = !cnt ? _wrapExpr(expr, asText)\n           : cnt > 1 ? '[' + list.join(',') + '].join(\" \").trim()' : list[0]\n    }\n    return expr\n\n    function skipBraces (ch, re) {\n      var\n        mm,\n        lv = 1,\n        ir = RE_BREND[ch]\n\n      ir.lastIndex = re.lastIndex\n      while (mm = ir.exec(expr)) {\n        if (mm[0] === ch) ++lv\n        else if (!--lv) break\n      }\n      re.lastIndex = lv ? expr.length : ir.lastIndex\n    }\n  }\n\n  // istanbul ignore next: not both\n  var // eslint-disable-next-line max-len\n    JS_CONTEXT = '\"in this?this:' + (typeof window !== 'object' ? 'global' : 'window') + ').',\n    JS_VARNAME = /[,{][\\$\\w]+(?=:)|(^ *|[^$\\w\\.{])(?!(?:typeof|true|false|null|undefined|in|instanceof|is(?:Finite|NaN)|void|NaN|new|Date|RegExp|Math)(?![$\\w]))([$_A-Za-z][$\\w]*)/g,\n    JS_NOPROPS = /^(?=(\\.[$\\w]+))\\1(?:[^.[(]|$)/\n\n  function _wrapExpr (expr, asText, key) {\n    var tb\n\n    expr = expr.replace(JS_VARNAME, function (match, p, mvar, pos, s) {\n      if (mvar) {\n        pos = tb ? 0 : pos + match.length\n\n        if (mvar !== 'this' && mvar !== 'global' && mvar !== 'window') {\n          match = p + '(\"' + mvar + JS_CONTEXT + mvar\n          if (pos) tb = (s = s[pos]) === '.' || s === '(' || s === '['\n        } else if (pos) {\n          tb = !JS_NOPROPS.test(s.slice(pos))\n        }\n      }\n      return match\n    })\n\n    if (tb) {\n      expr = 'try{return ' + expr + '}catch(e){E(e,this)}'\n    }\n\n    if (key) {\n\n      expr = (tb\n          ? 'function(){' + expr + '}.call(this)' : '(' + expr + ')'\n        ) + '?\"' + key + '\":\"\"'\n\n    } else if (asText) {\n\n      expr = 'function(v){' + (tb\n          ? expr.replace('return ', 'v=') : 'v=(' + expr + ')'\n        ) + ';return v||v===0?v:\"\"}.call(this)'\n    }\n\n    return expr\n  }\n\n  _tmpl.version = brackets.version = 'v2.4.2'\n\n  return _tmpl\n\n})()\n\n/*\n  lib/browser/tag/mkdom.js\n\n  Includes hacks needed for the Internet Explorer version 9 and below\n  See: http://kangax.github.io/compat-table/es5/#ie8\n       http://codeplanet.io/dropping-ie8/\n*/\nvar mkdom = (function _mkdom() {\n  var\n    reHasYield  = /<yield\\b/i,\n    reYieldAll  = /<yield\\s*(?:\\/>|>([\\S\\s]*?)<\\/yield\\s*>|>)/ig,\n    reYieldSrc  = /<yield\\s+to=['\"]([^'\">]*)['\"]\\s*>([\\S\\s]*?)<\\/yield\\s*>/ig,\n    reYieldDest = /<yield\\s+from=['\"]?([-\\w]+)['\"]?\\s*(?:\\/>|>([\\S\\s]*?)<\\/yield\\s*>)/ig\n  var\n    rootEls = { tr: 'tbody', th: 'tr', td: 'tr', col: 'colgroup' },\n    tblTags = IE_VERSION && IE_VERSION < 10\n      ? SPECIAL_TAGS_REGEX : /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?)$/\n\n  /**\n   * Creates a DOM element to wrap the given content. Normally an `DIV`, but can be\n   * also a `TABLE`, `SELECT`, `TBODY`, `TR`, or `COLGROUP` element.\n   *\n   * @param   { String } templ  - The template coming from the custom tag definition\n   * @param   { String } [html] - HTML content that comes from the DOM element where you\n   *           will mount the tag, mostly the original tag in the page\n   * @param   { Boolean } checkSvg - flag needed to know if we need to force the svg rendering in case of loop nodes\n   * @returns {HTMLElement} DOM element with _templ_ merged through `YIELD` with the _html_.\n   */\n  function _mkdom(templ, html, checkSvg) {\n    var\n      match   = templ && templ.match(/^\\s*<([-\\w]+)/),\n      tagName = match && match[1].toLowerCase(),\n      el = mkEl('div', checkSvg && isSVGTag(tagName))\n\n    // replace all the yield tags with the tag inner html\n    templ = replaceYield(templ, html)\n\n    /* istanbul ignore next */\n    if (tblTags.test(tagName))\n      el = specialTags(el, templ, tagName)\n    else\n      setInnerHTML(el, templ)\n\n    el.stub = true\n\n    return el\n  }\n\n  /*\n    Creates the root element for table or select child elements:\n    tr/th/td/thead/tfoot/tbody/caption/col/colgroup/option/optgroup\n  */\n  function specialTags(el, templ, tagName) {\n    var\n      select = tagName[0] === 'o',\n      parent = select ? 'select>' : 'table>'\n\n    // trim() is important here, this ensures we don't have artifacts,\n    // so we can check if we have only one element inside the parent\n    el.innerHTML = '<' + parent + templ.trim() + '</' + parent\n    parent = el.firstChild\n\n    // returns the immediate parent if tr/th/td/col is the only element, if not\n    // returns the whole tree, as this can include additional elements\n    if (select) {\n      parent.selectedIndex = -1  // for IE9, compatible w/current riot behavior\n    } else {\n      // avoids insertion of cointainer inside container (ex: tbody inside tbody)\n      var tname = rootEls[tagName]\n      if (tname && parent.childElementCount === 1) parent = $(tname, parent)\n    }\n    return parent\n  }\n\n  /*\n    Replace the yield tag from any tag template with the innerHTML of the\n    original tag in the page\n  */\n  function replaceYield(templ, html) {\n    // do nothing if no yield\n    if (!reHasYield.test(templ)) return templ\n\n    // be careful with #1343 - string on the source having `$1`\n    var src = {}\n\n    html = html && html.replace(reYieldSrc, function (_, ref, text) {\n      src[ref] = src[ref] || text   // preserve first definition\n      return ''\n    }).trim()\n\n    return templ\n      .replace(reYieldDest, function (_, ref, def) {  // yield with from - to attrs\n        return src[ref] || def || ''\n      })\n      .replace(reYieldAll, function (_, def) {        // yield without any \"from\"\n        return html || def || ''\n      })\n  }\n\n  return _mkdom\n\n})()\n\n/**\n * Convert the item looped into an object used to extend the child tag properties\n * @param   { Object } expr - object containing the keys used to extend the children tags\n * @param   { * } key - value to assign to the new object returned\n * @param   { * } val - value containing the position of the item in the array\n * @returns { Object } - new object containing the values of the original item\n *\n * The variables 'key' and 'val' are arbitrary.\n * They depend on the collection type looped (Array, Object)\n * and on the expression used on the each tag\n *\n */\nfunction mkitem(expr, key, val) {\n  var item = {}\n  item[expr.key] = key\n  if (expr.pos) item[expr.pos] = val\n  return item\n}\n\n/**\n * Unmount the redundant tags\n * @param   { Array } items - array containing the current items to loop\n * @param   { Array } tags - array containing all the children tags\n */\nfunction unmountRedundant(items, tags) {\n\n  var i = tags.length,\n    j = items.length,\n    t\n\n  while (i > j) {\n    t = tags[--i]\n    tags.splice(i, 1)\n    t.unmount()\n  }\n}\n\n/**\n * Move the nested custom tags in non custom loop tags\n * @param   { Object } child - non custom loop tag\n * @param   { Number } i - current position of the loop tag\n */\nfunction moveNestedTags(child, i) {\n  Object.keys(child.tags).forEach(function(tagName) {\n    var tag = child.tags[tagName]\n    if (isArray(tag))\n      each(tag, function (t) {\n        moveChildTag(t, tagName, i)\n      })\n    else\n      moveChildTag(tag, tagName, i)\n  })\n}\n\n/**\n * Adds the elements for a virtual tag\n * @param { Tag } tag - the tag whose root's children will be inserted or appended\n * @param { Node } src - the node that will do the inserting or appending\n * @param { Tag } target - only if inserting, insert before this tag's first child\n */\nfunction addVirtual(tag, src, target) {\n  var el = tag._root, sib\n  tag._virts = []\n  while (el) {\n    sib = el.nextSibling\n    if (target)\n      src.insertBefore(el, target._root)\n    else\n      src.appendChild(el)\n\n    tag._virts.push(el) // hold for unmounting\n    el = sib\n  }\n}\n\n/**\n * Move virtual tag and all child nodes\n * @param { Tag } tag - first child reference used to start move\n * @param { Node } src  - the node that will do the inserting\n * @param { Tag } target - insert before this tag's first child\n * @param { Number } len - how many child nodes to move\n */\nfunction moveVirtual(tag, src, target, len) {\n  var el = tag._root, sib, i = 0\n  for (; i < len; i++) {\n    sib = el.nextSibling\n    src.insertBefore(el, target._root)\n    el = sib\n  }\n}\n\n/**\n * Insert a new tag avoiding the insert for the conditional tags\n * @param   {Boolean} isVirtual [description]\n * @param   { Tag }  prevTag - tag instance used as reference to prepend our new tag\n * @param   { Tag }  newTag - new tag to be inserted\n * @param   { HTMLElement }  root - loop parent node\n * @param   { Array }  tags - array containing the current tags list\n * @param   { Function }  virtualFn - callback needed to move or insert virtual DOM\n * @param   { Object } dom - DOM node we need to loop\n */\nfunction insertTag(isVirtual, prevTag, newTag, root, tags, virtualFn, dom) {\n  if (isInStub(prevTag.root)) return\n  if (isVirtual) virtualFn(prevTag, root, newTag, dom.childNodes.length)\n  else root.insertBefore(prevTag.root, newTag.root) // #1374 some browsers reset selected here\n}\n\n\n/**\n * Manage tags having the 'each'\n * @param   { Object } dom - DOM node we need to loop\n * @param   { Tag } parent - parent tag instance where the dom node is contained\n * @param   { String } expr - string contained in the 'each' attribute\n */\nfunction _each(dom, parent, expr) {\n\n  // remove the each property from the original tag\n  remAttr(dom, 'each')\n\n  var mustReorder = typeof getAttr(dom, 'no-reorder') !== T_STRING || remAttr(dom, 'no-reorder'),\n    tagName = getTagName(dom),\n    impl = __tagImpl[tagName] || { tmpl: getOuterHTML(dom) },\n    useRoot = SPECIAL_TAGS_REGEX.test(tagName),\n    root = dom.parentNode,\n    ref = document.createTextNode(''),\n    child = getTag(dom),\n    isOption = tagName.toLowerCase() === 'option', // the option tags must be treated differently\n    tags = [],\n    oldItems = [],\n    hasKeys,\n    isVirtual = dom.tagName == 'VIRTUAL'\n\n  // parse the each expression\n  expr = tmpl.loopKeys(expr)\n\n  // insert a marked where the loop tags will be injected\n  root.insertBefore(ref, dom)\n\n  // clean template code\n  parent.one('before-mount', function () {\n\n    // remove the original DOM node\n    dom.parentNode.removeChild(dom)\n    if (root.stub) root = parent.root\n\n  }).on('update', function () {\n    // get the new items collection\n    var items = tmpl(expr.val, parent),\n      // create a fragment to hold the new DOM nodes to inject in the parent tag\n      frag = document.createDocumentFragment()\n\n    // object loop. any changes cause full redraw\n    if (!isArray(items)) {\n      hasKeys = items || false\n      items = hasKeys ?\n        Object.keys(items).map(function (key) {\n          return mkitem(expr, key, items[key])\n        }) : []\n    }\n\n    // loop all the new items\n    var i = 0,\n      itemsLength = items.length\n\n    for (; i < itemsLength; i++) {\n      // reorder only if the items are objects\n      var\n        item = items[i],\n        _mustReorder = mustReorder && typeof item == T_OBJECT && !hasKeys,\n        oldPos = oldItems.indexOf(item),\n        pos = ~oldPos && _mustReorder ? oldPos : i,\n        // does a tag exist in this position?\n        tag = tags[pos]\n\n      item = !hasKeys && expr.key ? mkitem(expr, item, i) : item\n\n      // new tag\n      if (\n        !_mustReorder && !tag // with no-reorder we just update the old tags\n        ||\n        _mustReorder && !~oldPos || !tag // by default we always try to reorder the DOM elements\n      ) {\n\n        tag = new Tag(impl, {\n          parent: parent,\n          isLoop: true,\n          hasImpl: !!__tagImpl[tagName],\n          root: useRoot ? root : dom.cloneNode(),\n          item: item\n        }, dom.innerHTML)\n\n        tag.mount()\n\n        if (isVirtual) tag._root = tag.root.firstChild // save reference for further moves or inserts\n        // this tag must be appended\n        if (i == tags.length || !tags[i]) { // fix 1581\n          if (isVirtual)\n            addVirtual(tag, frag)\n          else frag.appendChild(tag.root)\n        }\n        // this tag must be insert\n        else {\n          insertTag(isVirtual, tag, tags[i], root, tags, addVirtual, dom)\n          oldItems.splice(i, 0, item)\n        }\n\n        tags.splice(i, 0, tag)\n        pos = i // handled here so no move\n      } else tag.update(item, true)\n\n      // reorder the tag if it's not located in its previous position\n      if (\n        pos !== i && _mustReorder &&\n        tags[i] // fix 1581 unable to reproduce it in a test!\n      ) {\n        // #closes 2040 PLEASE DON'T REMOVE IT!\n        // there are no tests for this feature\n        if (contains(items, oldItems[i]))\n          insertTag(isVirtual, tag, tags[i], root, tags, moveVirtual, dom)\n\n        // update the position attribute if it exists\n        if (expr.pos)\n          tag[expr.pos] = i\n        // move the old tag instance\n        tags.splice(i, 0, tags.splice(pos, 1)[0])\n        // move the old item\n        oldItems.splice(i, 0, oldItems.splice(pos, 1)[0])\n        // if the loop tags are not custom\n        // we need to move all their custom tags into the right position\n        if (!child && tag.tags) moveNestedTags(tag, i)\n      }\n\n      // cache the original item to use it in the events bound to this node\n      // and its children\n      tag._item = item\n      // cache the real parent tag internally\n      defineProperty(tag, '_parent', parent)\n    }\n\n    // remove the redundant tags\n    unmountRedundant(items, tags)\n\n    // insert the new nodes\n    root.insertBefore(frag, ref)\n    if (isOption) {\n\n      // #1374 FireFox bug in <option selected={expression}>\n      if (FIREFOX && !root.multiple) {\n        for (var n = 0; n < root.length; n++) {\n          if (root[n].__riot1374) {\n            root.selectedIndex = n  // clear other options\n            delete root[n].__riot1374\n            break\n          }\n        }\n      }\n    }\n\n    // set the 'tags' property of the parent tag\n    // if child is 'undefined' it means that we don't need to set this property\n    // for example:\n    // we don't need store the `myTag.tags['div']` property if we are looping a div tag\n    // but we need to track the `myTag.tags['child']` property looping a custom child node named `child`\n    if (child) parent.tags[tagName] = tags\n\n    // clone the items array\n    oldItems = items.slice()\n\n  })\n\n}\n/**\n * Object that will be used to inject and manage the css of every tag instance\n */\nvar styleManager = (function(_riot) {\n\n  if (!window) return { // skip injection on the server\n    add: function () {},\n    inject: function () {}\n  }\n\n  var styleNode = (function () {\n    // create a new style element with the correct type\n    var newNode = mkEl('style')\n    setAttr(newNode, 'type', 'text/css')\n\n    // replace any user node or insert the new one into the head\n    var userNode = $('style[type=riot]')\n    if (userNode) {\n      if (userNode.id) newNode.id = userNode.id\n      userNode.parentNode.replaceChild(newNode, userNode)\n    }\n    else document.getElementsByTagName('head')[0].appendChild(newNode)\n\n    return newNode\n  })()\n\n  // Create cache and shortcut to the correct property\n  var cssTextProp = styleNode.styleSheet,\n    stylesToInject = ''\n\n  // Expose the style node in a non-modificable property\n  Object.defineProperty(_riot, 'styleNode', {\n    value: styleNode,\n    writable: true\n  })\n\n  /**\n   * Public api\n   */\n  return {\n    /**\n     * Save a tag style to be later injected into DOM\n     * @param   { String } css [description]\n     */\n    add: function(css) {\n      stylesToInject += css\n    },\n    /**\n     * Inject all previously saved tag styles into DOM\n     * innerHTML seems slow: http://jsperf.com/riot-insert-style\n     */\n    inject: function() {\n      if (stylesToInject) {\n        if (cssTextProp) cssTextProp.cssText += stylesToInject\n        else styleNode.innerHTML += stylesToInject\n        stylesToInject = ''\n      }\n    }\n  }\n\n})(riot)\n\n\nfunction parseNamedElements(root, tag, childTags, forceParsingNamed) {\n\n  walk(root, function(dom) {\n    if (dom.nodeType == 1) {\n      dom.isLoop = dom.isLoop ||\n                  (dom.parentNode && dom.parentNode.isLoop || getAttr(dom, 'each'))\n                    ? 1 : 0\n\n      // custom child tag\n      if (childTags) {\n        var child = getTag(dom)\n\n        if (child && !dom.isLoop)\n          childTags.push(initChildTag(child, {root: dom, parent: tag}, dom.innerHTML, tag))\n      }\n\n      if (!dom.isLoop || forceParsingNamed)\n        setNamed(dom, tag, [])\n    }\n\n  })\n\n}\n\nfunction parseExpressions(root, tag, expressions) {\n\n  function addExpr(dom, val, extra) {\n    if (tmpl.hasExpr(val)) {\n      expressions.push(extend({ dom: dom, expr: val }, extra))\n    }\n  }\n\n  walk(root, function(dom) {\n    var type = dom.nodeType,\n      attr\n\n    // text node\n    if (type == 3 && dom.parentNode.tagName != 'STYLE') addExpr(dom, dom.nodeValue)\n    if (type != 1) return\n\n    /* element */\n\n    // loop\n    attr = getAttr(dom, 'each')\n\n    if (attr) { _each(dom, tag, attr); return false }\n\n    // attribute expressions\n    each(dom.attributes, function(attr) {\n      var name = attr.name,\n        bool = name.split('__')[1]\n\n      addExpr(dom, attr.value, { attr: bool || name, bool: bool })\n      if (bool) { remAttr(dom, name); return false }\n\n    })\n\n    // skip custom tags\n    if (getTag(dom)) return false\n\n  })\n\n}\nfunction Tag(impl, conf, innerHTML) {\n\n  var self = riot.observable(this),\n    opts = inherit(conf.opts) || {},\n    parent = conf.parent,\n    isLoop = conf.isLoop,\n    hasImpl = conf.hasImpl,\n    item = cleanUpData(conf.item),\n    expressions = [],\n    childTags = [],\n    root = conf.root,\n    tagName = root.tagName.toLowerCase(),\n    attr = {},\n    propsInSyncWithParent = [],\n    dom\n\n  // only call unmount if we have a valid __tagImpl (has name property)\n  if (impl.name && root._tag) root._tag.unmount(true)\n\n  // not yet mounted\n  this.isMounted = false\n  root.isLoop = isLoop\n\n  // keep a reference to the tag just created\n  // so we will be able to mount this tag multiple times\n  root._tag = this\n\n  // create a unique id to this tag\n  // it could be handy to use it also to improve the virtual dom rendering speed\n  defineProperty(this, '_riot_id', ++__uid) // base 1 allows test !t._riot_id\n\n  extend(this, { parent: parent, root: root, opts: opts}, item)\n  // protect the \"tags\" property from being overridden\n  defineProperty(this, 'tags', {})\n\n  // grab attributes\n  each(root.attributes, function(el) {\n    var val = el.value\n    // remember attributes with expressions only\n    if (tmpl.hasExpr(val)) attr[el.name] = val\n  })\n\n  dom = mkdom(impl.tmpl, innerHTML, isLoop)\n\n  // options\n  function updateOpts() {\n    var ctx = hasImpl && isLoop ? self : parent || self\n\n    // update opts from current DOM attributes\n    each(root.attributes, function(el) {\n      if (el.name in attr) return\n      var val = el.value\n      opts[toCamel(el.name)] = tmpl.hasExpr(val) ? tmpl(val, ctx) : val\n    })\n    // recover those with expressions\n    each(Object.keys(attr), function(name) {\n      opts[toCamel(name)] = tmpl(attr[name], ctx)\n    })\n  }\n\n  function normalizeData(data) {\n    for (var key in item) {\n      if (typeof self[key] !== T_UNDEF && isWritable(self, key))\n        self[key] = data[key]\n    }\n  }\n\n  function inheritFrom(target) {\n    each(Object.keys(target), function(k) {\n      // some properties must be always in sync with the parent tag\n      var mustSync = !RESERVED_WORDS_BLACKLIST.test(k) && contains(propsInSyncWithParent, k)\n\n      if (typeof self[k] === T_UNDEF || mustSync) {\n        // track the property to keep in sync\n        // so we can keep it updated\n        if (!mustSync) propsInSyncWithParent.push(k)\n        self[k] = target[k]\n      }\n    })\n  }\n\n  /**\n   * Update the tag expressions and options\n   * @param   { * }  data - data we want to use to extend the tag properties\n   * @param   { Boolean } isInherited - is this update coming from a parent tag?\n   * @returns { self }\n   */\n  defineProperty(this, 'update', function(data, isInherited) {\n\n    // make sure the data passed will not override\n    // the component core methods\n    data = cleanUpData(data)\n    // inherit properties from the parent in loop\n    if (isLoop) {\n      inheritFrom(self.parent)\n    }\n    // normalize the tag properties in case an item object was initially passed\n    if (data && isObject(item)) {\n      normalizeData(data)\n      item = data\n    }\n    extend(self, data)\n    updateOpts()\n    self.trigger('update', data)\n    update(expressions, self)\n\n    // the updated event will be triggered\n    // once the DOM will be ready and all the re-flows are completed\n    // this is useful if you want to get the \"real\" root properties\n    // 4 ex: root.offsetWidth ...\n    if (isInherited && self.parent)\n      // closes #1599\n      self.parent.one('updated', function() { self.trigger('updated') })\n    else rAF(function() { self.trigger('updated') })\n\n    return this\n  })\n\n  defineProperty(this, 'mixin', function() {\n    each(arguments, function(mix) {\n      var instance,\n        props = [],\n        obj\n\n      mix = typeof mix === T_STRING ? riot.mixin(mix) : mix\n\n      // check if the mixin is a function\n      if (isFunction(mix)) {\n        // create the new mixin instance\n        instance = new mix()\n      } else instance = mix\n\n      var proto = Object.getPrototypeOf(instance)\n\n      // build multilevel prototype inheritance chain property list\n      do props = props.concat(Object.getOwnPropertyNames(obj || instance))\n      while (obj = Object.getPrototypeOf(obj || instance))\n\n      // loop the keys in the function prototype or the all object keys\n      each(props, function(key) {\n        // bind methods to self\n        // allow mixins to override other properties/parent mixins\n        if (key != 'init') {\n          // check for getters/setters\n          var descriptor = Object.getOwnPropertyDescriptor(instance, key) || Object.getOwnPropertyDescriptor(proto, key)\n          var hasGetterSetter = descriptor && (descriptor.get || descriptor.set)\n\n          // apply method only if it does not already exist on the instance\n          if (!self.hasOwnProperty(key) && hasGetterSetter) {\n            Object.defineProperty(self, key, descriptor)\n          } else {\n            self[key] = isFunction(instance[key]) ?\n              instance[key].bind(self) :\n              instance[key]\n          }\n        }\n      })\n\n      // init method will be called automatically\n      if (instance.init) instance.init.bind(self)()\n    })\n    return this\n  })\n\n  defineProperty(this, 'mount', function() {\n\n    updateOpts()\n\n    // add global mixins\n    var globalMixin = riot.mixin(GLOBAL_MIXIN)\n\n    if (globalMixin)\n      for (var i in globalMixin)\n        if (globalMixin.hasOwnProperty(i))\n          self.mixin(globalMixin[i])\n\n    // children in loop should inherit from true parent\n    if (self._parent && self._parent.root.isLoop) {\n      inheritFrom(self._parent)\n    }\n\n    // initialiation\n    if (impl.fn) impl.fn.call(self, opts)\n\n    // parse layout after init. fn may calculate args for nested custom tags\n    parseExpressions(dom, self, expressions)\n\n    // mount the child tags\n    toggle(true)\n\n    // update the root adding custom attributes coming from the compiler\n    // it fixes also #1087\n    if (impl.attrs)\n      walkAttributes(impl.attrs, function (k, v) { setAttr(root, k, v) })\n    if (impl.attrs || hasImpl)\n      parseExpressions(self.root, self, expressions)\n\n    if (!self.parent || isLoop) self.update(item)\n\n    // internal use only, fixes #403\n    self.trigger('before-mount')\n\n    if (isLoop && !hasImpl) {\n      // update the root attribute for the looped elements\n      root = dom.firstChild\n    } else {\n      while (dom.firstChild) root.appendChild(dom.firstChild)\n      if (root.stub) root = parent.root\n    }\n\n    defineProperty(self, 'root', root)\n\n    // parse the named dom nodes in the looped child\n    // adding them to the parent as well\n    if (isLoop)\n      parseNamedElements(self.root, self.parent, null, true)\n\n    // if it's not a child tag we can trigger its mount event\n    if (!self.parent || self.parent.isMounted) {\n      self.isMounted = true\n      self.trigger('mount')\n    }\n    // otherwise we need to wait that the parent event gets triggered\n    else self.parent.one('mount', function() {\n      // avoid to trigger the `mount` event for the tags\n      // not visible included in an if statement\n      if (!isInStub(self.root)) {\n        self.parent.isMounted = self.isMounted = true\n        self.trigger('mount')\n      }\n    })\n  })\n\n\n  defineProperty(this, 'unmount', function(keepRootTag) {\n    var el = root,\n      p = el.parentNode,\n      ptag,\n      tagIndex = __virtualDom.indexOf(self)\n\n    self.trigger('before-unmount')\n\n    // remove this tag instance from the global virtualDom variable\n    if (~tagIndex)\n      __virtualDom.splice(tagIndex, 1)\n\n    if (p) {\n\n      if (parent) {\n        ptag = getImmediateCustomParentTag(parent)\n        // remove this tag from the parent tags object\n        // if there are multiple nested tags with same name..\n        // remove this element form the array\n        if (isArray(ptag.tags[tagName]))\n          each(ptag.tags[tagName], function(tag, i) {\n            if (tag._riot_id == self._riot_id)\n              ptag.tags[tagName].splice(i, 1)\n          })\n        else\n          // otherwise just delete the tag instance\n          ptag.tags[tagName] = undefined\n      }\n\n      else\n        while (el.firstChild) el.removeChild(el.firstChild)\n\n      if (!keepRootTag)\n        p.removeChild(el)\n      else {\n        // the riot-tag and the data-is attributes aren't needed anymore, remove them\n        remAttr(p, RIOT_TAG_IS)\n        remAttr(p, RIOT_TAG) // this will be removed in riot 3.0.0\n      }\n\n    }\n\n    if (this._virts) {\n      each(this._virts, function(v) {\n        if (v.parentNode) v.parentNode.removeChild(v)\n      })\n    }\n\n    self.trigger('unmount')\n    toggle()\n    self.off('*')\n    self.isMounted = false\n    delete root._tag\n\n  })\n\n  // proxy function to bind updates\n  // dispatched from a parent tag\n  function onChildUpdate(data) { self.update(data, true) }\n\n  function toggle(isMount) {\n\n    // mount/unmount children\n    each(childTags, function(child) { child[isMount ? 'mount' : 'unmount']() })\n\n    // listen/unlisten parent (events flow one way from parent to children)\n    if (!parent) return\n    var evt = isMount ? 'on' : 'off'\n\n    // the loop tags will be always in sync with the parent automatically\n    if (isLoop)\n      parent[evt]('unmount', self.unmount)\n    else {\n      parent[evt]('update', onChildUpdate)[evt]('unmount', self.unmount)\n    }\n  }\n\n\n  // named elements available for fn\n  parseNamedElements(dom, this, childTags)\n\n}\n/**\n * Attach an event to a DOM node\n * @param { String } name - event name\n * @param { Function } handler - event callback\n * @param { Object } dom - dom node\n * @param { Tag } tag - tag instance\n */\nfunction setEventHandler(name, handler, dom, tag) {\n\n  dom[name] = function(e) {\n\n    var ptag = tag._parent,\n      item = tag._item,\n      el\n\n    if (!item)\n      while (ptag && !item) {\n        item = ptag._item\n        ptag = ptag._parent\n      }\n\n    // cross browser event fix\n    e = e || window.event\n\n    // override the event properties\n    if (isWritable(e, 'currentTarget')) e.currentTarget = dom\n    if (isWritable(e, 'target')) e.target = e.srcElement\n    if (isWritable(e, 'which')) e.which = e.charCode || e.keyCode\n\n    e.item = item\n\n    // prevent default behaviour (by default)\n    if (handler.call(tag, e) !== true && !/radio|check/.test(dom.type)) {\n      if (e.preventDefault) e.preventDefault()\n      e.returnValue = false\n    }\n\n    if (!e.preventUpdate) {\n      el = item ? getImmediateCustomParentTag(ptag) : tag\n      el.update()\n    }\n\n  }\n\n}\n\n\n/**\n * Insert a DOM node replacing another one (used by if- attribute)\n * @param   { Object } root - parent node\n * @param   { Object } node - node replaced\n * @param   { Object } before - node added\n */\nfunction insertTo(root, node, before) {\n  if (!root) return\n  root.insertBefore(before, node)\n  root.removeChild(node)\n}\n\n/**\n * Update the expressions in a Tag instance\n * @param   { Array } expressions - expression that must be re evaluated\n * @param   { Tag } tag - tag instance\n */\nfunction update(expressions, tag) {\n\n  each(expressions, function(expr, i) {\n\n    var dom = expr.dom,\n      attrName = expr.attr,\n      value = tmpl(expr.expr, tag),\n      parent = expr.parent || expr.dom.parentNode\n\n    if (expr.bool) {\n      value = !!value\n    } else if (value == null) {\n      value = ''\n    }\n\n    // #1638: regression of #1612, update the dom only if the value of the\n    // expression was changed\n    if (expr.value === value) {\n      return\n    }\n    expr.value = value\n\n    // textarea and text nodes has no attribute name\n    if (!attrName) {\n      // about #815 w/o replace: the browser converts the value to a string,\n      // the comparison by \"==\" does too, but not in the server\n      value += ''\n      // test for parent avoids error with invalid assignment to nodeValue\n      if (parent) {\n        // cache the parent node because somehow it will become null on IE\n        // on the next iteration\n        expr.parent = parent\n        if (parent.tagName === 'TEXTAREA') {\n          parent.value = value                    // #1113\n          if (!IE_VERSION) dom.nodeValue = value  // #1625 IE throws here, nodeValue\n        }                                         // will be available on 'updated'\n        else dom.nodeValue = value\n      }\n      return\n    }\n\n    // ~~#1612: look for changes in dom.value when updating the value~~\n    if (attrName === 'value') {\n      if (dom.value !== value) {\n        dom.value = value\n        setAttr(dom, attrName, value)\n      }\n      return\n    } else {\n      // remove original attribute\n      remAttr(dom, attrName)\n    }\n\n    // event handler\n    if (isFunction(value)) {\n      setEventHandler(attrName, value, dom, tag)\n\n    // if- conditional\n    } else if (attrName == 'if') {\n      var stub = expr.stub,\n        add = function() { insertTo(stub.parentNode, stub, dom) },\n        remove = function() { insertTo(dom.parentNode, dom, stub) }\n\n      // add to DOM\n      if (value) {\n        if (stub) {\n          add()\n          dom.inStub = false\n          // avoid to trigger the mount event if the tags is not visible yet\n          // maybe we can optimize this avoiding to mount the tag at all\n          if (!isInStub(dom)) {\n            walk(dom, function(el) {\n              if (el._tag && !el._tag.isMounted)\n                el._tag.isMounted = !!el._tag.trigger('mount')\n            })\n          }\n        }\n      // remove from DOM\n      } else {\n        stub = expr.stub = stub || document.createTextNode('')\n        // if the parentNode is defined we can easily replace the tag\n        if (dom.parentNode)\n          remove()\n        // otherwise we need to wait the updated event\n        else (tag.parent || tag).one('updated', remove)\n\n        dom.inStub = true\n      }\n    // show / hide\n    } else if (attrName === 'show') {\n      dom.style.display = value ? '' : 'none'\n\n    } else if (attrName === 'hide') {\n      dom.style.display = value ? 'none' : ''\n\n    } else if (expr.bool) {\n      dom[attrName] = value\n      if (value) setAttr(dom, attrName, attrName)\n      if (FIREFOX && attrName === 'selected' && dom.tagName === 'OPTION') {\n        dom.__riot1374 = value   // #1374\n      }\n\n    } else if (value === 0 || value && typeof value !== T_OBJECT) {\n      // <img src=\"{ expr }\">\n      if (startsWith(attrName, RIOT_PREFIX) && attrName != RIOT_TAG) {\n        attrName = attrName.slice(RIOT_PREFIX.length)\n      }\n      setAttr(dom, attrName, value)\n    }\n\n  })\n\n}\n/**\n * Specialized function for looping an array-like collection with `each={}`\n * @param   { Array } els - collection of items\n * @param   {Function} fn - callback function\n * @returns { Array } the array looped\n */\nfunction each(els, fn) {\n  var len = els ? els.length : 0\n\n  for (var i = 0, el; i < len; i++) {\n    el = els[i]\n    // return false -> current item was removed by fn during the loop\n    if (el != null && fn(el, i) === false) i--\n  }\n  return els\n}\n\n/**\n * Detect if the argument passed is a function\n * @param   { * } v - whatever you want to pass to this function\n * @returns { Boolean } -\n */\nfunction isFunction(v) {\n  return typeof v === T_FUNCTION || false   // avoid IE problems\n}\n\n/**\n * Get the outer html of any DOM node SVGs included\n * @param   { Object } el - DOM node to parse\n * @returns { String } el.outerHTML\n */\nfunction getOuterHTML(el) {\n  if (el.outerHTML) return el.outerHTML\n  // some browsers do not support outerHTML on the SVGs tags\n  else {\n    var container = mkEl('div')\n    container.appendChild(el.cloneNode(true))\n    return container.innerHTML\n  }\n}\n\n/**\n * Set the inner html of any DOM node SVGs included\n * @param { Object } container - DOM node where we will inject the new html\n * @param { String } html - html to inject\n */\nfunction setInnerHTML(container, html) {\n  if (typeof container.innerHTML != T_UNDEF) container.innerHTML = html\n  // some browsers do not support innerHTML on the SVGs tags\n  else {\n    var doc = new DOMParser().parseFromString(html, 'application/xml')\n    container.appendChild(\n      container.ownerDocument.importNode(doc.documentElement, true)\n    )\n  }\n}\n\n/**\n * Checks wether a DOM node must be considered part of an svg document\n * @param   { String }  name - tag name\n * @returns { Boolean } -\n */\nfunction isSVGTag(name) {\n  return ~SVG_TAGS_LIST.indexOf(name)\n}\n\n/**\n * Detect if the argument passed is an object, exclude null.\n * NOTE: Use isObject(x) && !isArray(x) to excludes arrays.\n * @param   { * } v - whatever you want to pass to this function\n * @returns { Boolean } -\n */\nfunction isObject(v) {\n  return v && typeof v === T_OBJECT         // typeof null is 'object'\n}\n\n/**\n * Remove any DOM attribute from a node\n * @param   { Object } dom - DOM node we want to update\n * @param   { String } name - name of the property we want to remove\n */\nfunction remAttr(dom, name) {\n  dom.removeAttribute(name)\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 */\nfunction toCamel(string) {\n  return string.replace(/-(\\w)/g, function(_, c) {\n    return c.toUpperCase()\n  })\n}\n\n/**\n * Get the value of any DOM attribute on a node\n * @param   { Object } dom - DOM node we want to parse\n * @param   { String } name - name of the attribute we want to get\n * @returns { String | undefined } name of the node attribute whether it exists\n */\nfunction getAttr(dom, name) {\n  return dom.getAttribute(name)\n}\n\n/**\n * Set any DOM/SVG attribute\n * @param { Object } dom - DOM node we want to update\n * @param { String } name - name of the property we want to set\n * @param { String } val - value of the property we want to set\n */\nfunction setAttr(dom, name, val) {\n  var xlink = XLINK_REGEX.exec(name)\n  if (xlink && xlink[1])\n    dom.setAttributeNS(XLINK_NS, xlink[1], val)\n  else\n    dom.setAttribute(name, val)\n}\n\n/**\n * Detect the tag implementation by a DOM node\n * @param   { Object } dom - DOM node we need to parse to get its tag implementation\n * @returns { Object } it returns an object containing the implementation of a custom tag (template and boot function)\n */\nfunction getTag(dom) {\n  return dom.tagName && __tagImpl[getAttr(dom, RIOT_TAG_IS) ||\n    getAttr(dom, RIOT_TAG) || dom.tagName.toLowerCase()]\n}\n/**\n * Add a child tag to its parent into the `tags` object\n * @param   { Object } tag - child tag instance\n * @param   { String } tagName - key where the new tag will be stored\n * @param   { Object } parent - tag instance where the new child tag will be included\n */\nfunction addChildTag(tag, tagName, parent) {\n  var cachedTag = parent.tags[tagName]\n\n  // if there are multiple children tags having the same name\n  if (cachedTag) {\n    // if the parent tags property is not yet an array\n    // create it adding the first cached tag\n    if (!isArray(cachedTag))\n      // don't add the same tag twice\n      if (cachedTag !== tag)\n        parent.tags[tagName] = [cachedTag]\n    // add the new nested tag to the array\n    if (!contains(parent.tags[tagName], tag))\n      parent.tags[tagName].push(tag)\n  } else {\n    parent.tags[tagName] = tag\n  }\n}\n\n/**\n * Move the position of a custom tag in its parent tag\n * @param   { Object } tag - child tag instance\n * @param   { String } tagName - key where the tag was stored\n * @param   { Number } newPos - index where the new tag will be stored\n */\nfunction moveChildTag(tag, tagName, newPos) {\n  var parent = tag.parent,\n    tags\n  // no parent no move\n  if (!parent) return\n\n  tags = parent.tags[tagName]\n\n  if (isArray(tags))\n    tags.splice(newPos, 0, tags.splice(tags.indexOf(tag), 1)[0])\n  else addChildTag(tag, tagName, parent)\n}\n\n/**\n * Create a new child tag including it correctly into its parent\n * @param   { Object } child - child tag implementation\n * @param   { Object } opts - tag options containing the DOM node where the tag will be mounted\n * @param   { String } innerHTML - inner html of the child node\n * @param   { Object } parent - instance of the parent tag including the child custom tag\n * @returns { Object } instance of the new child tag just created\n */\nfunction initChildTag(child, opts, innerHTML, parent) {\n  var tag = new Tag(child, opts, innerHTML),\n    tagName = getTagName(opts.root),\n    ptag = getImmediateCustomParentTag(parent)\n  // fix for the parent attribute in the looped elements\n  tag.parent = ptag\n  // store the real parent tag\n  // in some cases this could be different from the custom parent tag\n  // for example in nested loops\n  tag._parent = parent\n\n  // add this tag to the custom parent tag\n  addChildTag(tag, tagName, ptag)\n  // and also to the real parent tag\n  if (ptag !== parent)\n    addChildTag(tag, tagName, parent)\n  // empty the child node once we got its template\n  // to avoid that its children get compiled multiple times\n  opts.root.innerHTML = ''\n\n  return tag\n}\n\n/**\n * Loop backward all the parents tree to detect the first custom parent tag\n * @param   { Object } tag - a Tag instance\n * @returns { Object } the instance of the first custom parent tag found\n */\nfunction getImmediateCustomParentTag(tag) {\n  var ptag = tag\n  while (!getTag(ptag.root)) {\n    if (!ptag.parent) break\n    ptag = ptag.parent\n  }\n  return ptag\n}\n\n/**\n * Helper function to set an immutable property\n * @param   { Object } el - object where the new property will be set\n * @param   { String } key - object key where the new property will be stored\n * @param   { * } value - value of the new property\n* @param   { Object } options - set the propery overriding the default options\n * @returns { Object } - the initial object\n */\nfunction defineProperty(el, key, value, options) {\n  Object.defineProperty(el, key, extend({\n    value: value,\n    enumerable: false,\n    writable: false,\n    configurable: true\n  }, options))\n  return el\n}\n\n/**\n * Get the tag name of any DOM node\n * @param   { Object } dom - DOM node we want to parse\n * @returns { String } name to identify this dom node in riot\n */\nfunction getTagName(dom) {\n  var child = getTag(dom),\n    namedTag = getAttr(dom, 'name'),\n    tagName = namedTag && !tmpl.hasExpr(namedTag) ?\n                namedTag :\n              child ? child.name : dom.tagName.toLowerCase()\n\n  return tagName\n}\n\n/**\n * Extend any object with other properties\n * @param   { Object } src - source object\n * @returns { Object } the resulting extended object\n *\n * var obj = { foo: 'baz' }\n * extend(obj, {bar: 'bar', foo: 'bar'})\n * console.log(obj) => {bar: 'bar', foo: 'bar'}\n *\n */\nfunction extend(src) {\n  var obj, args = arguments\n  for (var i = 1; i < args.length; ++i) {\n    if (obj = args[i]) {\n      for (var key in obj) {\n        // check if this property of the source object could be overridden\n        if (isWritable(src, key))\n          src[key] = obj[key]\n      }\n    }\n  }\n  return src\n}\n\n/**\n * Check whether an array contains an item\n * @param   { Array } arr - target array\n * @param   { * } item - item to test\n * @returns { Boolean } Does 'arr' contain 'item'?\n */\nfunction contains(arr, item) {\n  return ~arr.indexOf(item)\n}\n\n/**\n * Check whether an object is a kind of array\n * @param   { * } a - anything\n * @returns {Boolean} is 'a' an array?\n */\nfunction isArray(a) { return Array.isArray(a) || a instanceof Array }\n\n/**\n * Detect whether a property of an object could be overridden\n * @param   { Object }  obj - source object\n * @param   { String }  key - object property\n * @returns { Boolean } is this property writable?\n */\nfunction isWritable(obj, key) {\n  var props = Object.getOwnPropertyDescriptor(obj, key)\n  return typeof obj[key] === T_UNDEF || props && props.writable\n}\n\n\n/**\n * With this function we avoid that the internal Tag methods get overridden\n * @param   { Object } data - options we want to use to extend the tag instance\n * @returns { Object } clean object without containing the riot internal reserved words\n */\nfunction cleanUpData(data) {\n  if (!(data instanceof Tag) && !(data && typeof data.trigger == T_FUNCTION))\n    return data\n\n  var o = {}\n  for (var key in data) {\n    if (!RESERVED_WORDS_BLACKLIST.test(key)) o[key] = data[key]\n  }\n  return o\n}\n\n/**\n * Walk down recursively all the children tags starting dom node\n * @param   { Object }   dom - starting node where we will start the recursion\n * @param   { Function } fn - callback to transform the child node just found\n */\nfunction walk(dom, fn) {\n  if (dom) {\n    // stop the recursion\n    if (fn(dom) === false) return\n    else {\n      dom = dom.firstChild\n\n      while (dom) {\n        walk(dom, fn)\n        dom = dom.nextSibling\n      }\n    }\n  }\n}\n\n/**\n * Minimize risk: only zero or one _space_ between attr & value\n * @param   { String }   html - html string we want to parse\n * @param   { Function } fn - callback function to apply on any attribute found\n */\nfunction walkAttributes(html, fn) {\n  var m,\n    re = /([-\\w]+) ?= ?(?:\"([^\"]*)|'([^']*)|({[^}]*}))/g\n\n  while (m = re.exec(html)) {\n    fn(m[1].toLowerCase(), m[2] || m[3] || m[4])\n  }\n}\n\n/**\n * Check whether a DOM node is in stub mode, useful for the riot 'if' directive\n * @param   { Object }  dom - DOM node we want to parse\n * @returns { Boolean } -\n */\nfunction isInStub(dom) {\n  while (dom) {\n    if (dom.inStub) return true\n    dom = dom.parentNode\n  }\n  return false\n}\n\n/**\n * Create a generic DOM node\n * @param   { String } name - name of the DOM node we want to create\n * @param   { Boolean } isSvg - should we use a SVG as parent node?\n * @returns { Object } DOM node just created\n */\nfunction mkEl(name, isSvg) {\n  return isSvg ?\n    document.createElementNS('http://www.w3.org/2000/svg', 'svg') :\n    document.createElement(name)\n}\n\n/**\n * Shorter and fast way to select multiple nodes in the DOM\n * @param   { String } selector - DOM selector\n * @param   { Object } ctx - DOM node where the targets of our search will is located\n * @returns { Object } dom nodes found\n */\nfunction $$(selector, ctx) {\n  return (ctx || document).querySelectorAll(selector)\n}\n\n/**\n * Shorter and fast way to select a single node in the DOM\n * @param   { String } selector - unique dom selector\n * @param   { Object } ctx - DOM node where the target of our search will is located\n * @returns { Object } dom node found\n */\nfunction $(selector, ctx) {\n  return (ctx || document).querySelector(selector)\n}\n\n/**\n * Simple object prototypal inheritance\n * @param   { Object } parent - parent object\n * @returns { Object } child instance\n */\nfunction inherit(parent) {\n  return Object.create(parent || null)\n}\n\n/**\n * Get the name property needed to identify a DOM node in riot\n * @param   { Object } dom - DOM node we need to parse\n * @returns { String | undefined } give us back a string to identify this dom node\n */\nfunction getNamedKey(dom) {\n  return getAttr(dom, 'id') || getAttr(dom, 'name')\n}\n\n/**\n * Set the named properties of a tag element\n * @param { Object } dom - DOM node we need to parse\n * @param { Object } parent - tag instance where the named dom element will be eventually added\n * @param { Array } keys - list of all the tag instance properties\n */\nfunction setNamed(dom, parent, keys) {\n  // get the key value we want to add to the tag instance\n  var key = getNamedKey(dom),\n    isArr,\n    // add the node detected to a tag instance using the named property\n    add = function(value) {\n      // avoid to override the tag properties already set\n      if (contains(keys, key)) return\n      // check whether this value is an array\n      isArr = isArray(value)\n      // if the key was never set\n      if (!value)\n        // set it once on the tag instance\n        parent[key] = dom\n      // if it was an array and not yet set\n      else if (!isArr || isArr && !contains(value, dom)) {\n        // add the dom node into the array\n        if (isArr)\n          value.push(dom)\n        else\n          parent[key] = [value, dom]\n      }\n    }\n\n  // skip the elements with no named properties\n  if (!key) return\n\n  // check whether this key has been already evaluated\n  if (tmpl.hasExpr(key))\n    // wait the first updated event only once\n    parent.one('mount', function() {\n      key = getNamedKey(dom)\n      add(parent[key])\n    })\n  else\n    add(parent[key])\n\n}\n\n/**\n * Faster String startsWith alternative\n * @param   { String } src - source string\n * @param   { String } str - test string\n * @returns { Boolean } -\n */\nfunction startsWith(src, str) {\n  return src.slice(0, str.length) === str\n}\n\n/**\n * requestAnimationFrame function\n * Adapted from https://gist.github.com/paulirish/1579671, license MIT\n */\nvar rAF = (function (w) {\n  var raf = w.requestAnimationFrame    ||\n            w.mozRequestAnimationFrame || w.webkitRequestAnimationFrame\n\n  if (!raf || /iP(ad|hone|od).*OS 6/.test(w.navigator.userAgent)) {  // buggy iOS6\n    var lastTime = 0\n\n    raf = function (cb) {\n      var nowtime = Date.now(), timeout = Math.max(16 - (nowtime - lastTime), 0)\n      setTimeout(function () { cb(lastTime = nowtime + timeout) }, timeout)\n    }\n  }\n  return raf\n\n})(window || {})\n\n/**\n * Mount a tag creating new Tag instance\n * @param   { Object } root - dom node where the tag will be mounted\n * @param   { String } tagName - name of the riot tag we want to mount\n * @param   { Object } opts - options to pass to the Tag instance\n * @returns { Tag } a new Tag instance\n */\nfunction mountTo(root, tagName, opts) {\n  var tag = __tagImpl[tagName],\n    // cache the inner HTML to fix #855\n    innerHTML = root._innerHTML = root._innerHTML || root.innerHTML\n\n  // clear the inner html\n  root.innerHTML = ''\n\n  if (tag && root) tag = new Tag(tag, { root: root, opts: opts }, innerHTML)\n\n  if (tag && tag.mount) {\n    tag.mount()\n    // add this tag to the virtualDom variable\n    if (!contains(__virtualDom, tag)) __virtualDom.push(tag)\n  }\n\n  return tag\n}\n/**\n * Riot public api\n */\n\n// share methods for other riot parts, e.g. compiler\nriot.util = { brackets: brackets, tmpl: tmpl }\n\n/**\n * Create a mixin that could be globally shared across all the tags\n */\nriot.mixin = (function() {\n  var mixins = {},\n    globals = mixins[GLOBAL_MIXIN] = {},\n    _id = 0\n\n  /**\n   * Create/Return a mixin by its name\n   * @param   { String }  name - mixin name (global mixin if object)\n   * @param   { Object }  mixin - mixin logic\n   * @param   { Boolean } g - is global?\n   * @returns { Object }  the mixin logic\n   */\n  return function(name, mixin, g) {\n    // Unnamed global\n    if (isObject(name)) {\n      riot.mixin('__unnamed_'+_id++, name, true)\n      return\n    }\n\n    var store = g ? globals : mixins\n\n    // Getter\n    if (!mixin) {\n      if (typeof store[name] === T_UNDEF) {\n        throw new Error('Unregistered mixin: ' + name)\n      }\n      return store[name]\n    }\n    // Setter\n    if (isFunction(mixin)) {\n      extend(mixin.prototype, store[name] || {})\n      store[name] = mixin\n    }\n    else {\n      store[name] = extend(store[name] || {}, mixin)\n    }\n  }\n\n})()\n\n/**\n * Create a new riot tag implementation\n * @param   { String }   name - name/id of the new riot tag\n * @param   { String }   html - tag template\n * @param   { String }   css - custom tag css\n * @param   { String }   attrs - root tag attributes\n * @param   { Function } fn - user function\n * @returns { String } name/id of the tag just created\n */\nriot.tag = function(name, html, css, attrs, fn) {\n  if (isFunction(attrs)) {\n    fn = attrs\n    if (/^[\\w\\-]+\\s?=/.test(css)) {\n      attrs = css\n      css = ''\n    } else attrs = ''\n  }\n  if (css) {\n    if (isFunction(css)) fn = css\n    else styleManager.add(css)\n  }\n  name = name.toLowerCase()\n  __tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }\n  return name\n}\n\n/**\n * Create a new riot tag implementation (for use by the compiler)\n * @param   { String }   name - name/id of the new riot tag\n * @param   { String }   html - tag template\n * @param   { String }   css - custom tag css\n * @param   { String }   attrs - root tag attributes\n * @param   { Function } fn - user function\n * @returns { String } name/id of the tag just created\n */\nriot.tag2 = function(name, html, css, attrs, fn) {\n  if (css) styleManager.add(css)\n  //if (bpair) riot.settings.brackets = bpair\n  __tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }\n  return name\n}\n\n/**\n * Mount a tag using a specific tag implementation\n * @param   { String } selector - tag DOM selector\n * @param   { String } tagName - tag implementation name\n * @param   { Object } opts - tag logic\n * @returns { Array } new tags instances\n */\nriot.mount = function(selector, tagName, opts) {\n\n  var els,\n    allTags,\n    tags = []\n\n  // helper functions\n\n  function addRiotTags(arr) {\n    var list = ''\n    each(arr, function (e) {\n      if (!/[^-\\w]/.test(e)) {\n        e = e.trim().toLowerCase()\n        list += ',[' + RIOT_TAG_IS + '=\"' + e + '\"],[' + RIOT_TAG + '=\"' + e + '\"]'\n      }\n    })\n    return list\n  }\n\n  function selectAllTags() {\n    var keys = Object.keys(__tagImpl)\n    return keys + addRiotTags(keys)\n  }\n\n  function pushTags(root) {\n    if (root.tagName) {\n      var riotTag = getAttr(root, RIOT_TAG_IS) || getAttr(root, RIOT_TAG)\n\n      // have tagName? force riot-tag to be the same\n      if (tagName && riotTag !== tagName) {\n        riotTag = tagName\n        setAttr(root, RIOT_TAG_IS, tagName)\n        setAttr(root, RIOT_TAG, tagName) // this will be removed in riot 3.0.0\n      }\n      var tag = mountTo(root, riotTag || root.tagName.toLowerCase(), opts)\n\n      if (tag) tags.push(tag)\n    } else if (root.length) {\n      each(root, pushTags)   // assume nodeList\n    }\n  }\n\n  // ----- mount code -----\n\n  // inject styles into DOM\n  styleManager.inject()\n\n  if (isObject(tagName)) {\n    opts = tagName\n    tagName = 0\n  }\n\n  // crawl the DOM to find the tag\n  if (typeof selector === T_STRING) {\n    if (selector === '*')\n      // select all the tags registered\n      // and also the tags found with the riot-tag attribute set\n      selector = allTags = selectAllTags()\n    else\n      // or just the ones named like the selector\n      selector += addRiotTags(selector.split(/, */))\n\n    // make sure to pass always a selector\n    // to the querySelectorAll function\n    els = selector ? $$(selector) : []\n  }\n  else\n    // probably you have passed already a tag or a NodeList\n    els = selector\n\n  // select all the registered and mount them inside their root elements\n  if (tagName === '*') {\n    // get all custom tags\n    tagName = allTags || selectAllTags()\n    // if the root els it's just a single tag\n    if (els.tagName)\n      els = $$(tagName, els)\n    else {\n      // select all the children for all the different root elements\n      var nodeList = []\n      each(els, function (_el) {\n        nodeList.push($$(tagName, _el))\n      })\n      els = nodeList\n    }\n    // get rid of the tagName\n    tagName = 0\n  }\n\n  pushTags(els)\n\n  return tags\n}\n\n/**\n * Update all the tags instances created\n * @returns { Array } all the tags instances\n */\nriot.update = function() {\n  return each(__virtualDom, function(tag) {\n    tag.update()\n  })\n}\n\n/**\n * Export the Virtual DOM\n */\nriot.vdom = __virtualDom\n\n/**\n * Export the Tag constructor\n */\nriot.Tag = Tag\n  // support CommonJS, AMD & browser\n  /* istanbul ignore next */\n  if (typeof exports === T_OBJECT)\n    module.exports = riot\n  else if (typeof define === T_FUNCTION && typeof define.amd !== T_UNDEF)\n    define(function() { return riot })\n  else\n    window.riot = riot\n\n})(typeof window != 'undefined' ? window : void 0);\n","var $ = require('../internals/export');\nvar bind = require('../internals/function-bind');\n\n// `Function.prototype.bind` method\n// https://tc39.es/ecma262/#sec-function.prototype.bind\n$({ target: 'Function', proto: true }, {\n  bind: bind\n});\n","var bind = require('../function/virtual/bind');\n\nvar FunctionPrototype = Function.prototype;\n\nmodule.exports = function (it) {\n  var own = it.bind;\n  return it === FunctionPrototype || (it instanceof Function && own === FunctionPrototype.bind) ? bind : own;\n};\n","require('../../../modules/es.string.trim');\nvar entryVirtual = require('../../../internals/entry-virtual');\n\nmodule.exports = entryVirtual('String').trim;\n","module.exports = require(\"core-js-pure/stable/object/create\");"],"sourceRoot":""}