{"version":3,"sources":["webpack:///./node_modules/core-js-pure/modules/es.object.create.js","webpack:///./node_modules/core-js-pure/stable/object/create.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/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/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/@babel/runtime-corejs3/core-js-stable/object/create.js"],"names":["$","target","stat","sham","create","parent","module","exports","entryVirtual","bind","Object","P","D","restArguments","func","startIndex","length","Math","max","arguments","rest","Array","index","call","this","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","proto","prototype","prop","isEmpty","isArray","isString","isMatch","object","attrs","_keys","_","_wrapped","toBufferView","bufferSource","Uint8Array","byteOffset","VERSION","valueOf","toJSON","toString","String","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","forced","root","ArrayProto","ObjProto","SymbolProto","hasOwnProperty","supportsArrayBuffer","supportsDataView","nativeIsArray","nativeKeys","nativeCreate","nativeIsView","isView","_isNaN","_isFinite","isFinite","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","MAX_ARRAY_INDEX","pow","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","trim","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","it","own"],"mappings":"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","file":"script/chunks/chunk.2.293d9da9ff.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/object/create');\n\nmodule.exports = parent;\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","// 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\");","/* 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","module.exports = require(\"core-js-pure/stable/object/create\");"],"sourceRoot":""}