{"version":3,"sources":["webpack:///webpack/bootstrap 913461977fe55b6ac4bd","webpack:///./node_modules/lodash/_root.js","webpack:///./node_modules/lodash/_getNative.js","webpack:///./node_modules/lodash/_ListCache.js","webpack:///./node_modules/lodash/_assocIndexOf.js","webpack:///./node_modules/lodash/_baseGetTag.js","webpack:///./node_modules/lodash/_nativeCreate.js","webpack:///./node_modules/lodash/_getMapData.js","webpack:///./node_modules/lodash/isObjectLike.js","webpack:///./node_modules/preact-compat/dist/preact-compat.es.js","webpack:///./node_modules/prop-types/index.js","webpack:///./node_modules/es5-ext/object/is-value.js","webpack:///./node_modules/lodash/_Map.js","webpack:///./node_modules/lodash/_Symbol.js","webpack:///./node_modules/lodash/isArray.js","webpack:///./src/i18n/index.js","webpack:///./src/helpers.js","webpack:///./node_modules/lodash/eq.js","webpack:///./node_modules/lodash/isFunction.js","webpack:///./node_modules/lodash/_freeGlobal.js","webpack:///./node_modules/lodash/isObject.js","webpack:///./node_modules/lodash/_toSource.js","webpack:///./node_modules/lodash/_MapCache.js","webpack:///./node_modules/lodash/_equalArrays.js","webpack:///./node_modules/lodash/isBuffer.js","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/lodash/isTypedArray.js","webpack:///./node_modules/lodash/isLength.js","webpack:///./src/index.js","webpack:///./node_modules/jed/jed.js","webpack:///./src/speech.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/prop-types/factoryWithThrowingShims.js","webpack:///./node_modules/fbjs/lib/emptyFunction.js","webpack:///./node_modules/fbjs/lib/invariant.js","webpack:///./node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack:///./node_modules/preact/dist/preact.esm.js","webpack:///./node_modules/event-emitter/index.js","webpack:///./node_modules/d/index.js","webpack:///./node_modules/es5-ext/object/assign/index.js","webpack:///./node_modules/es5-ext/object/assign/is-implemented.js","webpack:///./node_modules/es5-ext/object/assign/shim.js","webpack:///./node_modules/es5-ext/object/keys/index.js","webpack:///./node_modules/es5-ext/object/keys/is-implemented.js","webpack:///./node_modules/es5-ext/object/keys/shim.js","webpack:///./node_modules/es5-ext/function/noop.js","webpack:///./node_modules/es5-ext/object/valid-value.js","webpack:///./node_modules/es5-ext/object/normalize-options.js","webpack:///./node_modules/es5-ext/object/is-callable.js","webpack:///./node_modules/es5-ext/string/#/contains/index.js","webpack:///./node_modules/es5-ext/string/#/contains/is-implemented.js","webpack:///./node_modules/es5-ext/string/#/contains/shim.js","webpack:///./node_modules/es5-ext/object/valid-callable.js","webpack:///./src/chunkify.js","webpack:///./src/voices.js","webpack:///./src/components/PlaybackControls.js","webpack:///./src/components/PlaybackButton.js","webpack:///./node_modules/lodash/isEqual.js","webpack:///./node_modules/lodash/_baseIsEqual.js","webpack:///./node_modules/lodash/_baseIsEqualDeep.js","webpack:///./node_modules/lodash/_Stack.js","webpack:///./node_modules/lodash/_listCacheClear.js","webpack:///./node_modules/lodash/_listCacheDelete.js","webpack:///./node_modules/lodash/_listCacheGet.js","webpack:///./node_modules/lodash/_listCacheHas.js","webpack:///./node_modules/lodash/_listCacheSet.js","webpack:///./node_modules/lodash/_stackClear.js","webpack:///./node_modules/lodash/_stackDelete.js","webpack:///./node_modules/lodash/_stackGet.js","webpack:///./node_modules/lodash/_stackHas.js","webpack:///./node_modules/lodash/_stackSet.js","webpack:///./node_modules/lodash/_baseIsNative.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/lodash/_getRawTag.js","webpack:///./node_modules/lodash/_objectToString.js","webpack:///./node_modules/lodash/_isMasked.js","webpack:///./node_modules/lodash/_coreJsData.js","webpack:///./node_modules/lodash/_getValue.js","webpack:///./node_modules/lodash/_mapCacheClear.js","webpack:///./node_modules/lodash/_Hash.js","webpack:///./node_modules/lodash/_hashClear.js","webpack:///./node_modules/lodash/_hashDelete.js","webpack:///./node_modules/lodash/_hashGet.js","webpack:///./node_modules/lodash/_hashHas.js","webpack:///./node_modules/lodash/_hashSet.js","webpack:///./node_modules/lodash/_mapCacheDelete.js","webpack:///./node_modules/lodash/_isKeyable.js","webpack:///./node_modules/lodash/_mapCacheGet.js","webpack:///./node_modules/lodash/_mapCacheHas.js","webpack:///./node_modules/lodash/_mapCacheSet.js","webpack:///./node_modules/lodash/_SetCache.js","webpack:///./node_modules/lodash/_setCacheAdd.js","webpack:///./node_modules/lodash/_setCacheHas.js","webpack:///./node_modules/lodash/_arraySome.js","webpack:///./node_modules/lodash/_cacheHas.js","webpack:///./node_modules/lodash/_equalByTag.js","webpack:///./node_modules/lodash/_Uint8Array.js","webpack:///./node_modules/lodash/_mapToArray.js","webpack:///./node_modules/lodash/_setToArray.js","webpack:///./node_modules/lodash/_equalObjects.js","webpack:///./node_modules/lodash/_getAllKeys.js","webpack:///./node_modules/lodash/_baseGetAllKeys.js","webpack:///./node_modules/lodash/_arrayPush.js","webpack:///./node_modules/lodash/_getSymbols.js","webpack:///./node_modules/lodash/_arrayFilter.js","webpack:///./node_modules/lodash/stubArray.js","webpack:///./node_modules/lodash/keys.js","webpack:///./node_modules/lodash/_arrayLikeKeys.js","webpack:///./node_modules/lodash/_baseTimes.js","webpack:///./node_modules/lodash/isArguments.js","webpack:///./node_modules/lodash/_baseIsArguments.js","webpack:///./node_modules/lodash/stubFalse.js","webpack:///./node_modules/lodash/_isIndex.js","webpack:///./node_modules/lodash/_baseIsTypedArray.js","webpack:///./node_modules/lodash/_baseUnary.js","webpack:///./node_modules/lodash/_nodeUtil.js","webpack:///./node_modules/lodash/_baseKeys.js","webpack:///./node_modules/lodash/_isPrototype.js","webpack:///./node_modules/lodash/_nativeKeys.js","webpack:///./node_modules/lodash/_overArg.js","webpack:///./node_modules/lodash/isArrayLike.js","webpack:///./node_modules/lodash/_getTag.js","webpack:///./node_modules/lodash/_DataView.js","webpack:///./node_modules/lodash/_Promise.js","webpack:///./node_modules/lodash/_Set.js","webpack:///./node_modules/lodash/_WeakMap.js"],"names":["__webpack_require__","moduleId","installedModules","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","freeGlobal","freeSelf","self","root","Function","baseIsNative","getValue","key","value","undefined","ListCache","entries","index","length","this","clear","entry","set","listCacheClear","listCacheDelete","listCacheGet","listCacheHas","listCacheSet","has","eq","array","Symbol","getRawTag","objectToString","nullTag","undefinedTag","symToStringTag","toStringTag","nativeCreate","getNative","isKeyable","map","data","__data__","EmptyComponent","render$1","vnode","parent","callback","prev","_preactCompatRendered","base","parentNode","firstElementChild","childNodes","removeChild","out","__WEBPACK_IMPORTED_MODULE_1_preact__","_component","renderSubtreeIntoContainer","parentComponent","container","renderContainer","ContextProvider","context","component","unmountComponentAtNode","existing","createFactory","type","createElement","bind","upgradeToVNodes","arr","offset","obj","Array","isArray","isValidElement","props","attributes","nodeName","children","statelessComponentHook","Ctor","Wrapped","COMPONENT_WRAPPER_KEY","WrappedComponent","createClass","displayName","render","wrapStatelessComponent","propTypes","defaultProps","args","len","arguments","normalizeVNode","apply","preactCompatNormalized","a","classNameDescriptor","className","class","applyClassName","isStatelessComponent","ref","currentComponent","_refProxies","resolved","refs","createStringRefProxy","toLowerCase","ondoubleclick","ondblclick","onchange","test","normalized","oninput","multihook","applyEventNormalization","cloneElement$1","element","elementProps","cloneArgs","push","VNode","$$typeof","REACT_ELEMENT_TYPE","extend","arguments$1","shallowDiffers","b","i$1","findDOMNode","F","cl","ctx","v","__bound","AUTOBIND_BLACKLIST","bindAll","Component$1","BYPASS_HOOK","newComponentHook","constructor","mixins","proto","concat","ARR","applyMixins","keyed","mixin","collateMixins","statics","getDefaultProps","callMethod","hooks","skipDuplicates","ret","r","propsHook","componentWillReceiveProps","beforeRender","afterRender","DEV","ctor","__WEBPACK_IMPORTED_MODULE_0_prop_types___default","checkPropTypes","opts","state","getInitialState","PureComponent","version","ELEMENTS","split","for","shouldComponentUpdate","componentWillUpdate","componentDidUpdate","componentWillMount","componentDidMount","componentWillUnmount","componentDidUnmount","CAMEL_PROPS","process","env","preactCompatUpgraded","oldEventHook","event","e","persist","nativeEvent","oldVnodeHook","tag","attrs","String","handleComponentVNode","defaultValue","shouldSanitize","replace","handleElementVNode","getChildContext","Children","fn","toArray","forEach","count","only","Error","DOM","isReactComponent","replaceState","setState","getDOMNode","isMounted","isPureReactComponent","PropTypes","cloneElement","Component","unstable_renderSubtreeIntoContainer","__spread","__webpack_exports__","_undefined","val","Map","setLocaleData","i18n","_jed2","default","getI18n","","__","text","gettext","_x","pgettext","_n","single","plural","number","ngettext","_nx","npgettext","sprintf","equalRanges","range1","range2","startContainer","startOffset","endContainer","endOffset","uniqueId","lastId","scrollElementIntoViewIfNeeded","clientBoundingRect","getBoundingClientRect","top","left","bottom","document","documentElement","clientHeight","right","clientWidth","scrollIntoView","behavior","block","other","baseGetTag","isObject","asyncTag","funcTag","genTag","proxyTag","global","funcToString","toString","func","MapCache","mapCacheClear","mapCacheDelete","mapCacheGet","mapCacheHas","mapCacheSet","SetCache","arraySome","cacheHas","COMPARE_PARTIAL_FLAG","COMPARE_UNORDERED_FLAG","bitmask","customizer","equalFunc","stack","isPartial","arrLength","othLength","stacked","result","seen","arrValue","othValue","compared","othIndex","stubFalse","freeExports","nodeType","freeModule","Buffer","isBuffer","webpackPolyfill","deprecate","paths","baseIsTypedArray","baseUnary","nodeUtil","nodeIsTypedArray","isTypedArray","MAX_SAFE_INTEGER","findContentRoots","selector","matches","_toConsumableArray","querySelectorAll","createSpeeches","_ref","contentSelector","chunkifyOptions","useDashicons","rootElements","_loop","rootElement","speechRootMap","speech","_speech4","utteranceOptions","getUtteranceOptions","on","playing","_iteratorNormalCompletion2","_didIteratorError2","_iteratorError2","_step2","_iterator2","values","iterator","next","done","otherSpeech","stop","err","return","sharedState","localStorage","setItem","STATE_STORAGE_KEY","JSON","stringify","_iteratorNormalCompletion3","_didIteratorError3","_iteratorError3","_step3","_iterator3","initialize","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","assign","DEFAULT_UTTERANCE_OPTIONS","customDefaultUtteranceOptions","getItem","parse","_iteratorNormalCompletion5","_didIteratorError5","_iteratorError5","_step5","_iterator5","keys","removeItem","destroySpeeches","_ref2","speechRoots","_iteratorNormalCompletion6","_didIteratorError6","_iteratorError6","_step6","_iterator6","destroy","delete","getInstances","_ref3","_ref3$contentSelector","CONTENT_SELECTOR","_ref3$defaultUtteranc","defaultUtteranceOptions","_ref3$hasSystemSuppor","hasSystemSupport","HAS_SYSTEM_SUPPORT","Promise","resolve","reject","speechSynthesis","SpeechSynthesisUtterance","mutationObserver","MutationObserver","mutations","_iteratorNormalCompletion7","_didIteratorError7","_iteratorError7","_step7","_iterator7","mutation","_iteratorNormalCompletion8","_didIteratorError8","_iteratorError8","_step8","_iterator8","addedNodes","filter","node","Node","ELEMENT_NODE","_iteratorNormalCompletion9","_didIteratorError9","_iteratorError9","_step9","_iterator9","removedNodes","uponReady","body","window","addEventListener","cancel","observe","childList","subtree","readyState","pitch","rate","languageVoices","storageArea","_iteratorNormalCompletion4","_didIteratorError4","_iteratorError4","_step4","_iterator4","navigator","userAgent","undef","getPluralFormFunc","plural_form_string","Jed","PF","compile","Chain","_key","_i18n","ArrayProto","ObjProto","slice","hasOwnProp","nativeForEach","breaker","_","source","prop","options","defaults","locale_data","messages","domain","lang","plural_forms","debug","textdomain","context_delimiter","fromCharCode","onDomain","_domain","withContext","_context","ifPlural","num","pkey","_val","_pkey","fetch","sArr","x","dcnpgettext","translate","_textdomain","dgettext","dcgettext","skey","dngettext","dcngettext","dpgettext","dcpgettext","dnpgettext","singular_key","plural_key","fallback","val_list","res","val_idx","dict","defaultConf","pluralForms","parseInt","isNaN","missing_key_callback","console","log","get_type","variable","str_repeat","input","multiplier","output","join","str_format","cache","format","parse_tree","argv","arg","k","match","pad","pad_character","pad_length","cursor","tree_length","node_type","toExponential","parseFloat","toFixed","substring","Math","abs","toUpperCase","charAt","fmt","_fmt","arg_names","exec","field_list","replacement_field","field_match","parse_plural","parse_expression","unshift","vsprintf","plural_str","extractPluralExpr","parser","ast","imply","interpreter","expr","truthy","falsey","plural_matches","nplurals_re","nplurals_matches","nplurals","trace","yy","symbols_","error","expressions","EOF","?",":","||","&&","<","<=",">",">=","!=","==","%","(",")","NUMBER","$accept","$end","terminals_","2","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","productions_","performAction","yytext","yyleng","yylineno","yystate","$$","_$","$0","$","Number","table","3","4","1","defaultActions","parseError","str","hash","popStack","vstack","lstack","lex","token","lexer","recovering","setInput","yylloc","yyloc","symbol","preErrorSymbol","action","newState","expected","yyval","errStr","showPosition","line","loc","first_line","last_line","first_column","last_column","_input","_more","_less","matched","conditionStack","ch","unput","more","pastInput","past","substr","upcomingInput","pre","lines","rules","_currentRules","begin","condition","popState","pop","conditions","topState","pushState","yy_","$avoiding_name_collisions","YY_START","INITIAL","inclusive","_preactCompat","_chunkify2","voices","_helpers","HEADING_SELECTOR","PARAGRAPH_PAUSE_SELECTOR","DEFAULT_PAUSE_DURATIONS","heading","paragraph","Speech","_ref$useDashicons","_ref$utteranceOptions","_ref$pauseDurations","pauseDurations","_classCallCheck","controlsElement","currentUtterance","_arr","_i","method","containsSelection","settingsShown","speakTimeoutId","chunkIndex","chunkRangeOffset","chunkify","injectControls","setupStateMachine","updateContainsSelectionState","handleEscapeKeydown","isDialogSupported","dialogPolyfill","renderControls","_ref2$suppressEvents","suppressEvents","oldProps","newProps","changeCount","_isEqual2","emit","_this","startPlayingCurrentChunkAndQueueNext","clearTimeout","newTimeoutId","oldTimeoutId","selected","classList","toggle","isVisible","isLoaded","load","then","selection","getSelection","range","createRange","chunk","chunks","firstNode","nodes","lastNode","removeAllRanges","setStart","setEnd","playbackAddedRange","addRange","parentElement","handleChunkChange","voicePropChanged","_chunkify3","containerElement","add","insertBefore","firstChild","_availableVoices","availableVoices","getVoices","voice","localService","sort","voiceURIs","Set","voiceURI","endsWith","getAvailableVoices","_this2","weightedLanguages","getWeightedChunkLanguages","presentLanguages","play","previous","onShowSettings","onHideSettings","getLanguageVoices","setProps","updatedProps","_preactCompat2","_PlaybackControls2","language","getVoice","baseLanguage","resultingVoice","find","startsWith","_this3","initialSkippedNodesLength","nextNodes","shift","firstNodeOffset","currentTextNode","nodeValue","textNode","trim","onpause","previousSpokenNodesLength","currentChunkRangeOffset","onboundary","charIndex","currentToken","currentTarget","min","onend","onerror","speak","selectedRange","rangeCount","getRangeAt","TEXT_NODE","contains","chunkSelection","getChunkPositionFromRange","which","thisChunk","nextChunk","_this4","reason","speakingStoppedPromise","speaking","setTimeout","queueNextChunk","pauseDuration","getInterChunkPause","currentChunk","round","all","speakChunk","max","removeEventListener","_eventEmitter2","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","timeout","run","marker","cachedClearTimeout","runClearTimeout","Item","noop","nextTick","title","browser","versions","addListener","once","off","removeListener","removeAllListeners","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","emptyFunction","invariant","ReactPropTypesSecret","shim","propName","componentName","location","propFullName","secret","getShim","isRequired","ReactPropTypes","bool","string","any","arrayOf","instanceOf","objectOf","oneOf","oneOfType","shape","exact","makeEmptyFunction","thatReturns","thatReturnsFalse","thatReturnsTrue","thatReturnsNull","thatReturnsThis","thatReturnsArgument","validateFormat","f","argIndex","framesToPop","h","lastSimple","child","simple","EMPTY_CHILDREN","enqueueRender","_dirty","items","debounceRendering","defer","rerender","list","renderComponent","isSameNodeType","hydrating","splitText","_componentConstructor","isNamedNode","normalizedNodeName","getNodeProps","removeNode","setAccessor","old","isSvg","style","cssText","IS_NON_DIMENSIONAL","innerHTML","__html","useCapture","eventProxy","_listeners","setProperty","removeAttribute","ns","removeAttributeNS","setAttributeNS","setAttribute","flushMounts","mounts","afterMount","diff","dom","mountAll","componentRoot","diffLevel","isSvgMode","ownerSVGElement","idiff","appendChild","prevSvgMode","createTextNode","replaceChild","recollectNodeTree","vnodeName","originalComponent","oldDom","isDirectOwner","isOwner","_parentComponent","setComponentProps","unmountComponent","createComponent","nextBase","buildComponentFromVNode","createElementNS","createNode","fc","vchildren","nextSibling","isHydrating","j","vchild","originalChildren","keyedLen","childrenLen","vlen","_child","__key","innerDiffNode","dangerouslySetInnerHTML","diffAttributes","unmountOnly","removeChildren","lastChild","previousSibling","inst","components","doRender","splice","_disable","__ref","prevContext","prevProps","syncComponentUpdates","isChild","rendered","cbase","previousProps","previousState","prevState","previousContext","isUpdate","initialBase","initialChildComponent","skip","toUnmount","childComponent","childProps","baseParent","componentRef","t","afterUpdate","_renderCallbacks","beforeUnmount","inner","collectComponent","merge","forceUpdate","methods","descriptors","callable","create","defineProperties","descriptor","writable","listener","__ee__","__eeOnceListener__","candidate","normalizeOpts","isCallable","dscr","w","desc","gs","foo","bar","trzy","dest","src","isValue","TypeError","opts1","indexOf","searchString","_ref$excludeCountry","excludeCountry","languageSizes","reduce","current","_ref2$chunkRootInclud","chunkRootIncludeFilter","DEFAULT_ROOT_WHITELIST_SELECTOR","_ref2$chunkLeafExclud","chunkLeafExcludeFilter","rootIncludeFilter","leafExcludeFilter","DEFAULT_LEAF_BLACKLIST_SELECTOR","rootIncludeSelector","leafExcludeSelector","rootElementStack","addChunkNode","processElement","elementLanguage","startElement","findLanguage","isRootChunkElement","childNode","loaded","pendingPromiseCallbacks","previousOnVoicesChanged","onvoiceschanged","PlaybackControls","idPrefix","updateDialogState","dialog","showModal","registerDialog","preventDefault","open","close","previousActiveElement","focus","activeElement","updateLanguageVoice","_defineProperty","target","dataset","selects","presentLanguage","voicesInLanguage","id","htmlFor","data-language","onBlur","onChange","includes","handleNumericPropInputChange","valueAsNumber","validity","valid","href","rel","data-prop","step","renderLanguageVoiceSelects","onClick","_PlaybackButton2","useDashicon","dashicon","emoji","label","renderSettings","_propTypes2","PlaybackButton","buttonClassNames","aria-label","baseIsEqual","isObjectLike","baseIsEqualDeep","Stack","equalArrays","equalByTag","equalObjects","getTag","argsTag","arrayTag","objectTag","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","size","stackClear","stackDelete","stackGet","stackHas","stackSet","assocIndexOf","LARGE_ARRAY_SIZE","pairs","isFunction","isMasked","toSource","reIsHostCtor","funcProto","objectProto","reIsNative","RegExp","g","eval","nativeObjectToString","isOwn","unmasked","coreJsData","maskSrcKey","uid","IE_PROTO","Hash","hashClear","hashDelete","hashGet","hashHas","hashSet","HASH_UNDEFINED","getMapData","setCacheAdd","setCacheHas","predicate","Uint8Array","mapToArray","setToArray","boolTag","dateTag","errorTag","mapTag","numberTag","regexpTag","setTag","stringTag","symbolTag","arrayBufferTag","dataViewTag","symbolProto","symbolValueOf","valueOf","byteLength","byteOffset","buffer","message","convert","getAllKeys","objProps","objLength","skipCtor","objValue","objCtor","othCtor","baseGetAllKeys","getSymbols","arrayPush","keysFunc","symbolsFunc","arrayFilter","stubArray","propertyIsEnumerable","nativeGetSymbols","getOwnPropertySymbols","resIndex","arrayLikeKeys","baseKeys","isArrayLike","baseTimes","isArguments","isIndex","inherited","isArr","isArg","isBuff","isType","skipIndexes","iteratee","baseIsArguments","reIsUint","isLength","typedArrayTags","freeProcess","isPrototype","nativeKeys","overArg","transform","DataView","WeakMap","promiseTag","weakMapTag","dataViewCtorString","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","ArrayBuffer","ctorString"],"mappings":"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","file":"spoken-word.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 27);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 913461977fe55b6ac4bd","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_root.js\n// module id = 0\n// module chunks = 0","var baseIsNative = require('./_baseIsNative'),\n    getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_getNative.js\n// module id = 1\n// module chunks = 0","var listCacheClear = require('./_listCacheClear'),\n    listCacheDelete = require('./_listCacheDelete'),\n    listCacheGet = require('./_listCacheGet'),\n    listCacheHas = require('./_listCacheHas'),\n    listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_ListCache.js\n// module id = 2\n// module chunks = 0","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = assocIndexOf;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_assocIndexOf.js\n// module id = 3\n// module chunks = 0","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseGetTag.js\n// module id = 4\n// module chunks = 0","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_nativeCreate.js\n// module id = 5\n// module chunks = 0","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nmodule.exports = getMapData;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_getMapData.js\n// module id = 6\n// module chunks = 0","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isObjectLike.js\n// module id = 7\n// module chunks = 0","import PropTypes from 'prop-types';\nimport { Component, cloneElement, h, options, render } from 'preact';\n\nvar version = '15.1.0'; // trick libraries to think we are react\n\nvar ELEMENTS = 'a abbr address area article aside audio b base bdi bdo big blockquote body br button canvas caption cite code col colgroup data datalist dd del details dfn dialog div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hgroup hr html i iframe img input ins kbd keygen label legend li link main map mark menu menuitem meta meter nav noscript object ol optgroup option output p param picture pre progress q rp rt ruby s samp script section select small source span strong style sub summary sup table tbody td textarea tfoot th thead time title tr track u ul var video wbr circle clipPath defs ellipse g image line linearGradient mask path pattern polygon polyline radialGradient rect stop svg text tspan'.split(' ');\n\nvar REACT_ELEMENT_TYPE = (typeof Symbol!=='undefined' && Symbol.for && Symbol.for('react.element')) || 0xeac7;\n\nvar COMPONENT_WRAPPER_KEY = typeof Symbol!=='undefined' ? Symbol.for('__preactCompatWrapper') : '__preactCompatWrapper';\n\n// don't autobind these methods since they already have guaranteed context.\nvar AUTOBIND_BLACKLIST = {\n\tconstructor: 1,\n\trender: 1,\n\tshouldComponentUpdate: 1,\n\tcomponentWillReceiveProps: 1,\n\tcomponentWillUpdate: 1,\n\tcomponentDidUpdate: 1,\n\tcomponentWillMount: 1,\n\tcomponentDidMount: 1,\n\tcomponentWillUnmount: 1,\n\tcomponentDidUnmount: 1\n};\n\n\nvar CAMEL_PROPS = /^(?:accent|alignment|arabic|baseline|cap|clip|color|fill|flood|font|glyph|horiz|marker|overline|paint|stop|strikethrough|stroke|text|underline|unicode|units|v|vector|vert|word|writing|x)[A-Z]/;\n\n\nvar BYPASS_HOOK = {};\n\n/*global process*/\nvar DEV = typeof process==='undefined' || !process.env || process.env.NODE_ENV!=='production';\n\n// a component that renders nothing. Used to replace components for unmountComponentAtNode.\nfunction EmptyComponent() { return null; }\n\n\n\n// make react think we're react.\nvar VNode = h('a', null).constructor;\nVNode.prototype.$$typeof = REACT_ELEMENT_TYPE;\nVNode.prototype.preactCompatUpgraded = false;\nVNode.prototype.preactCompatNormalized = false;\n\nObject.defineProperty(VNode.prototype, 'type', {\n\tget: function() { return this.nodeName; },\n\tset: function(v) { this.nodeName = v; },\n\tconfigurable:true\n});\n\nObject.defineProperty(VNode.prototype, 'props', {\n\tget: function() { return this.attributes; },\n\tset: function(v) { this.attributes = v; },\n\tconfigurable:true\n});\n\n\n\nvar oldEventHook = options.event;\noptions.event = function (e) {\n\tif (oldEventHook) { e = oldEventHook(e); }\n\te.persist = Object;\n\te.nativeEvent = e;\n\treturn e;\n};\n\n\nvar oldVnodeHook = options.vnode;\noptions.vnode = function (vnode) {\n\tif (!vnode.preactCompatUpgraded) {\n\t\tvnode.preactCompatUpgraded = true;\n\n\t\tvar tag = vnode.nodeName,\n\t\t\tattrs = vnode.attributes = extend({}, vnode.attributes);\n\n\t\tif (typeof tag==='function') {\n\t\t\tif (tag[COMPONENT_WRAPPER_KEY]===true || (tag.prototype && 'isReactComponent' in tag.prototype)) {\n\t\t\t\tif (vnode.children && String(vnode.children)==='') { vnode.children = undefined; }\n\t\t\t\tif (vnode.children) { attrs.children = vnode.children; }\n\n\t\t\t\tif (!vnode.preactCompatNormalized) {\n\t\t\t\t\tnormalizeVNode(vnode);\n\t\t\t\t}\n\t\t\t\thandleComponentVNode(vnode);\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tif (vnode.children && String(vnode.children)==='') { vnode.children = undefined; }\n\t\t\tif (vnode.children) { attrs.children = vnode.children; }\n\n\t\t\tif (attrs.defaultValue) {\n\t\t\t\tif (!attrs.value && attrs.value!==0) {\n\t\t\t\t\tattrs.value = attrs.defaultValue;\n\t\t\t\t}\n\t\t\t\tdelete attrs.defaultValue;\n\t\t\t}\n\n\t\t\thandleElementVNode(vnode, attrs);\n\t\t}\n\t}\n\n\tif (oldVnodeHook) { oldVnodeHook(vnode); }\n};\n\nfunction handleComponentVNode(vnode) {\n\tvar tag = vnode.nodeName,\n\t\ta = vnode.attributes;\n\n\tvnode.attributes = {};\n\tif (tag.defaultProps) { extend(vnode.attributes, tag.defaultProps); }\n\tif (a) { extend(vnode.attributes, a); }\n}\n\nfunction handleElementVNode(vnode, a) {\n\tvar shouldSanitize, attrs, i;\n\tif (a) {\n\t\tfor (i in a) { if ((shouldSanitize = CAMEL_PROPS.test(i))) { break; } }\n\t\tif (shouldSanitize) {\n\t\t\tattrs = vnode.attributes = {};\n\t\t\tfor (i in a) {\n\t\t\t\tif (a.hasOwnProperty(i)) {\n\t\t\t\t\tattrs[ CAMEL_PROPS.test(i) ? i.replace(/([A-Z0-9])/, '-$1').toLowerCase() : i ] = a[i];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n\n\n// proxy render() since React returns a Component reference.\nfunction render$1(vnode, parent, callback) {\n\tvar prev = parent && parent._preactCompatRendered && parent._preactCompatRendered.base;\n\n\t// ignore impossible previous renders\n\tif (prev && prev.parentNode!==parent) { prev = null; }\n\n\t// default to first Element child\n\tif (!prev && parent) { prev = parent.firstElementChild; }\n\n\t// remove unaffected siblings\n\tfor (var i=parent.childNodes.length; i--; ) {\n\t\tif (parent.childNodes[i]!==prev) {\n\t\t\tparent.removeChild(parent.childNodes[i]);\n\t\t}\n\t}\n\n\tvar out = render(vnode, parent, prev);\n\tif (parent) { parent._preactCompatRendered = out && (out._component || { base: out }); }\n\tif (typeof callback==='function') { callback(); }\n\treturn out && out._component || out;\n}\n\n\nvar ContextProvider = function () {};\n\nContextProvider.prototype.getChildContext = function () {\n\treturn this.props.context;\n};\nContextProvider.prototype.render = function (props) {\n\treturn props.children[0];\n};\n\nfunction renderSubtreeIntoContainer(parentComponent, vnode, container, callback) {\n\tvar wrap = h(ContextProvider, { context: parentComponent.context }, vnode);\n\tvar renderContainer = render$1(wrap, container);\n\tvar component = renderContainer._component || renderContainer.base;\n\tif (callback) { callback.call(component, renderContainer); }\n\treturn component;\n}\n\n\nfunction unmountComponentAtNode(container) {\n\tvar existing = container._preactCompatRendered && container._preactCompatRendered.base;\n\tif (existing && existing.parentNode===container) {\n\t\trender(h(EmptyComponent), container, existing);\n\t\treturn true;\n\t}\n\treturn false;\n}\n\n\n\nvar ARR = [];\n\n// This API is completely unnecessary for Preact, so it's basically passthrough.\nvar Children = {\n\tmap: function(children, fn, ctx) {\n\t\tif (children == null) { return null; }\n\t\tchildren = Children.toArray(children);\n\t\tif (ctx && ctx!==children) { fn = fn.bind(ctx); }\n\t\treturn children.map(fn);\n\t},\n\tforEach: function(children, fn, ctx) {\n\t\tif (children == null) { return null; }\n\t\tchildren = Children.toArray(children);\n\t\tif (ctx && ctx!==children) { fn = fn.bind(ctx); }\n\t\tchildren.forEach(fn);\n\t},\n\tcount: function(children) {\n\t\treturn children && children.length || 0;\n\t},\n\tonly: function(children) {\n\t\tchildren = Children.toArray(children);\n\t\tif (children.length!==1) { throw new Error('Children.only() expects only one child.'); }\n\t\treturn children[0];\n\t},\n\ttoArray: function(children) {\n\t\tif (children == null) { return []; }\n\t\treturn ARR.concat(children);\n\t}\n};\n\n\n/** Track current render() component for ref assignment */\nvar currentComponent;\n\n\nfunction createFactory(type) {\n\treturn createElement.bind(null, type);\n}\n\n\nvar DOM = {};\nfor (var i=ELEMENTS.length; i--; ) {\n\tDOM[ELEMENTS[i]] = createFactory(ELEMENTS[i]);\n}\n\nfunction upgradeToVNodes(arr, offset) {\n\tfor (var i=offset || 0; i<arr.length; i++) {\n\t\tvar obj = arr[i];\n\t\tif (Array.isArray(obj)) {\n\t\t\tupgradeToVNodes(obj);\n\t\t}\n\t\telse if (obj && typeof obj==='object' && !isValidElement(obj) && ((obj.props && obj.type) || (obj.attributes && obj.nodeName) || obj.children)) {\n\t\t\tarr[i] = createElement(obj.type || obj.nodeName, obj.props || obj.attributes, obj.children);\n\t\t}\n\t}\n}\n\nfunction isStatelessComponent(c) {\n\treturn typeof c==='function' && !(c.prototype && c.prototype.render);\n}\n\n\n// wraps stateless functional components in a PropTypes validator\nfunction wrapStatelessComponent(WrappedComponent) {\n\treturn createClass({\n\t\tdisplayName: WrappedComponent.displayName || WrappedComponent.name,\n\t\trender: function() {\n\t\t\treturn WrappedComponent(this.props, this.context);\n\t\t}\n\t});\n}\n\n\nfunction statelessComponentHook(Ctor) {\n\tvar Wrapped = Ctor[COMPONENT_WRAPPER_KEY];\n\tif (Wrapped) { return Wrapped===true ? Ctor : Wrapped; }\n\n\tWrapped = wrapStatelessComponent(Ctor);\n\n\tObject.defineProperty(Wrapped, COMPONENT_WRAPPER_KEY, { configurable:true, value:true });\n\tWrapped.displayName = Ctor.displayName;\n\tWrapped.propTypes = Ctor.propTypes;\n\tWrapped.defaultProps = Ctor.defaultProps;\n\n\tObject.defineProperty(Ctor, COMPONENT_WRAPPER_KEY, { configurable:true, value:Wrapped });\n\n\treturn Wrapped;\n}\n\n\nfunction createElement() {\n\tvar args = [], len = arguments.length;\n\twhile ( len-- ) args[ len ] = arguments[ len ];\n\n\tupgradeToVNodes(args, 2);\n\treturn normalizeVNode(h.apply(void 0, args));\n}\n\n\nfunction normalizeVNode(vnode) {\n\tvnode.preactCompatNormalized = true;\n\n\tapplyClassName(vnode);\n\n\tif (isStatelessComponent(vnode.nodeName)) {\n\t\tvnode.nodeName = statelessComponentHook(vnode.nodeName);\n\t}\n\n\tvar ref = vnode.attributes.ref,\n\t\ttype = ref && typeof ref;\n\tif (currentComponent && (type==='string' || type==='number')) {\n\t\tvnode.attributes.ref = createStringRefProxy(ref, currentComponent);\n\t}\n\n\tapplyEventNormalization(vnode);\n\n\treturn vnode;\n}\n\n\nfunction cloneElement$1(element, props) {\n\tvar children = [], len = arguments.length - 2;\n\twhile ( len-- > 0 ) children[ len ] = arguments[ len + 2 ];\n\n\tif (!isValidElement(element)) { return element; }\n\tvar elementProps = element.attributes || element.props;\n\tvar node = h(\n\t\telement.nodeName || element.type,\n\t\telementProps,\n\t\telement.children || elementProps && elementProps.children\n\t);\n\t// Only provide the 3rd argument if needed.\n\t// Arguments 3+ overwrite element.children in preactCloneElement\n\tvar cloneArgs = [node, props];\n\tif (children && children.length) {\n\t\tcloneArgs.push(children);\n\t}\n\telse if (props && props.children) {\n\t\tcloneArgs.push(props.children);\n\t}\n\treturn normalizeVNode(cloneElement.apply(void 0, cloneArgs));\n}\n\n\nfunction isValidElement(element) {\n\treturn element && ((element instanceof VNode) || element.$$typeof===REACT_ELEMENT_TYPE);\n}\n\n\nfunction createStringRefProxy(name, component) {\n\treturn component._refProxies[name] || (component._refProxies[name] = function (resolved) {\n\t\tif (component && component.refs) {\n\t\t\tcomponent.refs[name] = resolved;\n\t\t\tif (resolved===null) {\n\t\t\t\tdelete component._refProxies[name];\n\t\t\t\tcomponent = null;\n\t\t\t}\n\t\t}\n\t});\n}\n\n\nfunction applyEventNormalization(ref) {\n\tvar nodeName = ref.nodeName;\n\tvar attributes = ref.attributes;\n\n\tif (!attributes || typeof nodeName!=='string') { return; }\n\tvar props = {};\n\tfor (var i in attributes) {\n\t\tprops[i.toLowerCase()] = i;\n\t}\n\tif (props.ondoubleclick) {\n\t\tattributes.ondblclick = attributes[props.ondoubleclick];\n\t\tdelete attributes[props.ondoubleclick];\n\t}\n\t// for *textual inputs* (incl textarea), normalize `onChange` -> `onInput`:\n\tif (props.onchange && (nodeName==='textarea' || (nodeName.toLowerCase()==='input' && !/^fil|che|rad/i.test(attributes.type)))) {\n\t\tvar normalized = props.oninput || 'oninput';\n\t\tif (!attributes[normalized]) {\n\t\t\tattributes[normalized] = multihook([attributes[normalized], attributes[props.onchange]]);\n\t\t\tdelete attributes[props.onchange];\n\t\t}\n\t}\n}\n\n\nfunction applyClassName(vnode) {\n\tvar a = vnode.attributes || (vnode.attributes = {});\n\tclassNameDescriptor.enumerable = 'className' in a;\n\tif (a.className) { a.class = a.className; }\n\tObject.defineProperty(a, 'className', classNameDescriptor);\n}\n\n\nvar classNameDescriptor = {\n\tconfigurable: true,\n\tget: function() { return this.class; },\n\tset: function(v) { this.class = v; }\n};\n\nfunction extend(base, props) {\n\tvar arguments$1 = arguments;\n\n\tfor (var i=1, obj = (void 0); i<arguments.length; i++) {\n\t\tif ((obj = arguments$1[i])) {\n\t\t\tfor (var key in obj) {\n\t\t\t\tif (obj.hasOwnProperty(key)) {\n\t\t\t\t\tbase[key] = obj[key];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn base;\n}\n\n\nfunction shallowDiffers(a, b) {\n\tfor (var i in a) { if (!(i in b)) { return true; } }\n\tfor (var i$1 in b) { if (a[i$1]!==b[i$1]) { return true; } }\n\treturn false;\n}\n\n\nfunction findDOMNode(component) {\n\treturn component && component.base || component;\n}\n\n\nfunction F(){}\n\nfunction createClass(obj) {\n\tfunction cl(props, context) {\n\t\tbindAll(this);\n\t\tComponent$1.call(this, props, context, BYPASS_HOOK);\n\t\tnewComponentHook.call(this, props, context);\n\t}\n\n\tobj = extend({ constructor: cl }, obj);\n\n\t// We need to apply mixins here so that getDefaultProps is correctly mixed\n\tif (obj.mixins) {\n\t\tapplyMixins(obj, collateMixins(obj.mixins));\n\t}\n\tif (obj.statics) {\n\t\textend(cl, obj.statics);\n\t}\n\tif (obj.propTypes) {\n\t\tcl.propTypes = obj.propTypes;\n\t}\n\tif (obj.defaultProps) {\n\t\tcl.defaultProps = obj.defaultProps;\n\t}\n\tif (obj.getDefaultProps) {\n\t\tcl.defaultProps = obj.getDefaultProps();\n\t}\n\n\tF.prototype = Component$1.prototype;\n\tcl.prototype = extend(new F(), obj);\n\n\tcl.displayName = obj.displayName || 'Component';\n\n\treturn cl;\n}\n\n\n// Flatten an Array of mixins to a map of method name to mixin implementations\nfunction collateMixins(mixins) {\n\tvar keyed = {};\n\tfor (var i=0; i<mixins.length; i++) {\n\t\tvar mixin = mixins[i];\n\t\tfor (var key in mixin) {\n\t\t\tif (mixin.hasOwnProperty(key) && typeof mixin[key]==='function') {\n\t\t\t\t(keyed[key] || (keyed[key]=[])).push(mixin[key]);\n\t\t\t}\n\t\t}\n\t}\n\treturn keyed;\n}\n\n\n// apply a mapping of Arrays of mixin methods to a component prototype\nfunction applyMixins(proto, mixins) {\n\tfor (var key in mixins) { if (mixins.hasOwnProperty(key)) {\n\t\tproto[key] = multihook(\n\t\t\tmixins[key].concat(proto[key] || ARR),\n\t\t\tkey==='getDefaultProps' || key==='getInitialState' || key==='getChildContext'\n\t\t);\n\t} }\n}\n\n\nfunction bindAll(ctx) {\n\tfor (var i in ctx) {\n\t\tvar v = ctx[i];\n\t\tif (typeof v==='function' && !v.__bound && !AUTOBIND_BLACKLIST.hasOwnProperty(i)) {\n\t\t\t(ctx[i] = v.bind(ctx)).__bound = true;\n\t\t}\n\t}\n}\n\n\nfunction callMethod(ctx, m, args) {\n\tif (typeof m==='string') {\n\t\tm = ctx.constructor.prototype[m];\n\t}\n\tif (typeof m==='function') {\n\t\treturn m.apply(ctx, args);\n\t}\n}\n\nfunction multihook(hooks, skipDuplicates) {\n\treturn function() {\n\t\tvar arguments$1 = arguments;\n\t\tvar this$1 = this;\n\n\t\tvar ret;\n\t\tfor (var i=0; i<hooks.length; i++) {\n\t\t\tvar r = callMethod(this$1, hooks[i], arguments$1);\n\n\t\t\tif (skipDuplicates && r!=null) {\n\t\t\t\tif (!ret) { ret = {}; }\n\t\t\t\tfor (var key in r) { if (r.hasOwnProperty(key)) {\n\t\t\t\t\tret[key] = r[key];\n\t\t\t\t} }\n\t\t\t}\n\t\t\telse if (typeof r!=='undefined') { ret = r; }\n\t\t}\n\t\treturn ret;\n\t};\n}\n\n\nfunction newComponentHook(props, context) {\n\tpropsHook.call(this, props, context);\n\tthis.componentWillReceiveProps = multihook([propsHook, this.componentWillReceiveProps || 'componentWillReceiveProps']);\n\tthis.render = multihook([propsHook, beforeRender, this.render || 'render', afterRender]);\n}\n\n\nfunction propsHook(props, context) {\n\tif (!props) { return; }\n\n\t// React annoyingly special-cases single children, and some react components are ridiculously strict about this.\n\tvar c = props.children;\n\tif (c && Array.isArray(c) && c.length===1 && (typeof c[0]==='string' || typeof c[0]==='function' || c[0] instanceof VNode)) {\n\t\tprops.children = c[0];\n\n\t\t// but its totally still going to be an Array.\n\t\tif (props.children && typeof props.children==='object') {\n\t\t\tprops.children.length = 1;\n\t\t\tprops.children[0] = props.children;\n\t\t}\n\t}\n\n\t// add proptype checking\n\tif (DEV) {\n\t\tvar ctor = typeof this==='function' ? this : this.constructor,\n\t\t\tpropTypes = this.propTypes || ctor.propTypes;\n\t\tvar displayName = this.displayName || ctor.name;\n\n\t\tif (propTypes) {\n\t\t\tPropTypes.checkPropTypes(propTypes, props, 'prop', displayName);\n\t\t}\n\t}\n}\n\n\nfunction beforeRender(props) {\n\tcurrentComponent = this;\n}\n\nfunction afterRender() {\n\tif (currentComponent===this) {\n\t\tcurrentComponent = null;\n\t}\n}\n\n\n\nfunction Component$1(props, context, opts) {\n\tComponent.call(this, props, context);\n\tthis.state = this.getInitialState ? this.getInitialState() : {};\n\tthis.refs = {};\n\tthis._refProxies = {};\n\tif (opts!==BYPASS_HOOK) {\n\t\tnewComponentHook.call(this, props, context);\n\t}\n}\nextend(Component$1.prototype = new Component(), {\n\tconstructor: Component$1,\n\n\tisReactComponent: {},\n\n\treplaceState: function(state, callback) {\n\t\tvar this$1 = this;\n\n\t\tthis.setState(state, callback);\n\t\tfor (var i in this$1.state) {\n\t\t\tif (!(i in state)) {\n\t\t\t\tdelete this$1.state[i];\n\t\t\t}\n\t\t}\n\t},\n\n\tgetDOMNode: function() {\n\t\treturn this.base;\n\t},\n\n\tisMounted: function() {\n\t\treturn !!this.base;\n\t}\n});\n\n\n\nfunction PureComponent(props, context) {\n\tComponent$1.call(this, props, context);\n}\nF.prototype = Component$1.prototype;\nPureComponent.prototype = new F();\nPureComponent.prototype.isPureReactComponent = true;\nPureComponent.prototype.shouldComponentUpdate = function(props, state) {\n\treturn shallowDiffers(this.props, props) || shallowDiffers(this.state, state);\n};\n\nvar index = {\n\tversion: version,\n\tDOM: DOM,\n\tPropTypes: PropTypes,\n\tChildren: Children,\n\trender: render$1,\n\tcreateClass: createClass,\n\tcreateFactory: createFactory,\n\tcreateElement: createElement,\n\tcloneElement: cloneElement$1,\n\tisValidElement: isValidElement,\n\tfindDOMNode: findDOMNode,\n\tunmountComponentAtNode: unmountComponentAtNode,\n\tComponent: Component$1,\n\tPureComponent: PureComponent,\n\tunstable_renderSubtreeIntoContainer: renderSubtreeIntoContainer,\n\t__spread: extend\n};\n\nexport { version, DOM, PropTypes, Children, render$1 as render, createClass, createFactory, createElement, cloneElement$1 as cloneElement, isValidElement, findDOMNode, unmountComponentAtNode, Component$1 as Component, PureComponent, renderSubtreeIntoContainer as unstable_renderSubtreeIntoContainer, extend as __spread };export default index;\n//# sourceMappingURL=preact-compat.es.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/preact-compat/dist/preact-compat.es.js\n// module id = 8\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&\n    Symbol.for &&\n    Symbol.for('react.element')) ||\n    0xeac7;\n\n  var isValidElement = function(object) {\n    return typeof object === 'object' &&\n      object !== null &&\n      object.$$typeof === REACT_ELEMENT_TYPE;\n  };\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(isValidElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/prop-types/index.js\n// module id = 9\n// module chunks = 0","\"use strict\";\n\nvar _undefined = require(\"../function/noop\")(); // Support ES3 engines\n\nmodule.exports = function (val) {\n return (val !== _undefined) && (val !== null);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/is-value.js\n// module id = 10\n// module chunks = 0","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_Map.js\n// module id = 11\n// module chunks = 0","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_Symbol.js\n// module id = 12\n// module chunks = 0","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isArray.js\n// module id = 13\n// module chunks = 0","/**\n * Package copied from https://github.com/WordPress/gutenberg/raw/3408d9e13a4368334c202872eed347327006d7bd/i18n/index.js\n */\n\n/**\n * External dependencies\n */\nimport Jed from 'jed';\n\nlet i18n;\n\n/**\n * Creates a new Jed instance with specified locale data configuration.\n *\n * @see http://messageformat.github.io/Jed/\n *\n * @param {Object} data Locale data configuration\n */\nexport function setLocaleData( data ) {\n\ti18n = new Jed( data );\n}\n\n/**\n * Returns the current Jed instance, initializing with a default configuration\n * if not already assigned.\n *\n * @return {Jed} Jed instance\n */\nexport function getI18n() {\n\tif ( ! i18n ) {\n\t\tsetLocaleData( { '': {} } );\n\t}\n\n\treturn i18n;\n}\n\n/**\n * Retrieve the translation of text.\n *\n * @see https://developer.wordpress.org/reference/functions/__/\n *\n * @param  {string} text Text to translate\n * @return {string}      Translated text\n */\nexport function __( text ) {\n\treturn getI18n().gettext( text );\n}\n\n/**\n * Retrieve translated string with gettext context.\n *\n * @see https://developer.wordpress.org/reference/functions/_x/\n *\n * @param  {string} text    Text to translate\n * @param  {string} context Context information for the translators\n * @return {string}         Translated context string without pipe\n */\nexport function _x( text, context ) {\n\treturn getI18n().pgettext( context, text );\n}\n\n/**\n * Translates and retrieves the singular or plural form based on the supplied\n * number.\n *\n * @see https://developer.wordpress.org/reference/functions/_n/\n *\n * @param  {string} single The text to be used if the number is singular\n * @param  {string} plural The text to be used if the number is plural\n * @param  {Number} number The number to compare against to use either the\n *                         singular or plural form\n * @return {string}        The translated singular or plural form\n */\nexport function _n( single, plural, number ) {\n\treturn getI18n().ngettext( single, plural, number );\n}\n\n/**\n * Translates and retrieves the singular or plural form based on the supplied\n * number, with gettext context.\n *\n * @see https://developer.wordpress.org/reference/functions/_nx/\n *\n * @param  {string} single  The text to be used if the number is singular\n * @param  {string} plural  The text to be used if the number is plural\n * @param  {Number} number  The number to compare against to use either the\n *                          singular or plural form\n * @param  {string} context Context information for the translators\n * @return {string}         The translated singular or plural form\n */\nexport function _nx( single, plural, number, context ) {\n\treturn getI18n().npgettext( context, single, plural, number );\n}\n\n/**\n * Returns a formatted string.\n *\n * @see http://www.diveintojavascript.com/projects/javascript-sprintf\n *\n * @type {Function}\n */\nexport const sprintf = Jed.sprintf;\n\n\n\n// WEBPACK FOOTER //\n// ./src/i18n/index.js","\n/**\n * Compare if two ranges have the same containers and offsets.\n *\n * @param {Range} range1 - First range.\n * @param {Range} range2 - Second range.\n * @return {boolean} Whether same.\n */\nexport function equalRanges( range1, range2 ) {\n\treturn (\n\t\trange1.startContainer === range2.startContainer &&\n\t\trange1.startOffset === range2.startOffset &&\n\t\trange1.endContainer === range2.endContainer &&\n\t\trange1.endOffset === range2.endOffset\n\t);\n}\n\nlet lastId = 0;\n\n/**\n * Generate unique (auto-incremented) ID.\n *\n * @return {number} ID.\n */\nexport function uniqueId() {\n\tlastId++;\n\treturn lastId;\n}\n\n/**\n * Scroll element into view if needed.\n *\n * @param {Element} element - Element to scroll into view.\n * @returns {bool} Whether the element was scrolled into view.\n */\nexport function scrollElementIntoViewIfNeeded( element ) {\n\tconst clientBoundingRect = element.getBoundingClientRect();\n\tconst isVisible = (\n\t\tclientBoundingRect.top >= 0 &&\n\t\tclientBoundingRect.left >= 0 &&\n\t\tclientBoundingRect.bottom <= document.documentElement.clientHeight &&\n\t\tclientBoundingRect.right <= document.documentElement.clientWidth\n\t);\n\tif ( ! isVisible ) {\n\t\telement.scrollIntoView( {\n\t\t\tbehavior: 'smooth',\n\t\t\tblock: clientBoundingRect.top < 0 ? 'start' : 'end',\n\t\t} );\n\t\treturn true;\n\t}\n\treturn false;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/helpers.js","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/eq.js\n// module id = 16\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isFunction.js\n// module id = 17\n// module chunks = 0","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_freeGlobal.js\n// module id = 18\n// module chunks = 0","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isObject.js\n// module id = 19\n// module chunks = 0","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nmodule.exports = toSource;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_toSource.js\n// module id = 20\n// module chunks = 0","var mapCacheClear = require('./_mapCacheClear'),\n    mapCacheDelete = require('./_mapCacheDelete'),\n    mapCacheGet = require('./_mapCacheGet'),\n    mapCacheHas = require('./_mapCacheHas'),\n    mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_MapCache.js\n// module id = 21\n// module chunks = 0","var SetCache = require('./_SetCache'),\n    arraySome = require('./_arraySome'),\n    cacheHas = require('./_cacheHas');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n    return false;\n  }\n  // Assume cyclic values are equal.\n  var stacked = stack.get(array);\n  if (stacked && stack.get(other)) {\n    return stacked == other;\n  }\n  var index = -1,\n      result = true,\n      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n  stack.set(array, other);\n  stack.set(other, array);\n\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, arrValue, index, other, array, stack)\n        : customizer(arrValue, othValue, index, array, other, stack);\n    }\n    if (compared !== undefined) {\n      if (compared) {\n        continue;\n      }\n      result = false;\n      break;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (seen) {\n      if (!arraySome(other, function(othValue, othIndex) {\n            if (!cacheHas(seen, othIndex) &&\n                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              return seen.push(othIndex);\n            }\n          })) {\n        result = false;\n        break;\n      }\n    } else if (!(\n          arrValue === othValue ||\n            equalFunc(arrValue, othValue, bitmask, customizer, stack)\n        )) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\n\nmodule.exports = equalArrays;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_equalArrays.js\n// module id = 22\n// module chunks = 0","var root = require('./_root'),\n    stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isBuffer.js\n// module id = 23\n// module chunks = 0","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/module.js\n// module id = 24\n// module chunks = 0","var baseIsTypedArray = require('./_baseIsTypedArray'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isTypedArray.js\n// module id = 25\n// module chunks = 0","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isLength.js\n// module id = 26\n// module chunks = 0","\nimport Speech from './speech';\nexport { setLocaleData } from './i18n';\n\n/**\n * Key for localStorage state persistence.\n *\n * @type {string}\n */\nconst STATE_STORAGE_KEY = 'spokenWordState';\n\n/**\n * Mapping speech root elements to their corresponding Speech instances.\n *\n * @type {Map<Element, Speech>}\n */\nconst speechRootMap = new Map();\n\n/**\n * Get iterator for all Speech instances.\n *\n * @returns {Iterator.<Speech>} Instances.\n */\nexport function getInstances() {\n\treturn speechRootMap.values();\n}\n\n/**\n * Default utterance options.\n *\n * @type {{pitch: number, rate: number, languageVoices: Object<string, string>}}\n */\nconst DEFAULT_UTTERANCE_OPTIONS = {\n\tpitch: 1.0,\n\trate: 1.0,\n\tlanguageVoices: {},\n};\n\n/**\n * Default utterance options.\n *\n * This is set when calling initialize() with a defaultUtteranceOptions param. Any options storage in localStorage\n * get merged on top of this.\n *\n * @type {Object}\n */\nlet customDefaultUtteranceOptions = {};\n\n/**\n * CSS selector for finding the content element.\n *\n * @type {string}\n */\nconst CONTENT_SELECTOR = '.hentry .entry-content, .h-entry .e-content, [itemprop=\"articleBody\"]';\n\n/**\n * Find article roots.\n *\n * @param {Element} root     - Root element.\n * @param {string}  selector - Selector.\n * @returns {Array} Article roots.\n */\nfunction findContentRoots( root, selector ) {\n\tif ( root.matches( selector ) ) {\n\t\treturn [ root ];\n\t}\n\n\t// @todo What about nested content?\n\treturn [ ...root.querySelectorAll( selector ) ];\n}\n\n/**\n * Create Speech instances.\n *\n * @param {Element} element         - Element to look for content.\n * @param {string}  contentSelector - Selector for content elements.\n * @param {object}  chunkifyOptions - Options passed to chunkify().\n * @param {bool}    useDashicons    - Whether to use Dashicons in playback controls.\n */\nfunction createSpeeches( { element, contentSelector, chunkifyOptions, useDashicons } ) {\n\tconst rootElements = findContentRoots( element, contentSelector );\n\tfor ( const rootElement of rootElements ) {\n\t\t// Skip elements already added.\n\t\tif ( speechRootMap.has( rootElement ) ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst speech = new Speech( {\n\t\t\trootElement,\n\t\t\tchunkifyOptions,\n\t\t\tuseDashicons,\n\t\t\tutteranceOptions: getUtteranceOptions(),\n\t\t} );\n\n\t\tspeechRootMap.set( rootElement, speech );\n\n\t\t// Stop playing all other speeches when playing one.\n\t\tspeech.on( 'change:playing', ( playing ) => {\n\t\t\tif ( ! playing ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tfor ( const otherSpeech of speechRootMap.values() ) {\n\t\t\t\tif ( otherSpeech !== speech ) {\n\t\t\t\t\totherSpeech.stop();\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\n\t\tspeech.on( 'sharedStateChange', ( sharedState ) => {\n\t\t\tlocalStorage.setItem( STATE_STORAGE_KEY, JSON.stringify( sharedState ) );\n\n\t\t\tfor ( const otherSpeech of speechRootMap.values() ) {\n\t\t\t\tif ( otherSpeech !== speech ) {\n\t\t\t\t\totherSpeech.setState( sharedState );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\n\t\tspeech.initialize();\n\t}\n}\n\n// Update speech instances in response to saved state changing in another tab.\nwindow.addEventListener( 'storage', ( event ) => {\n\tif ( STATE_STORAGE_KEY !== event.key || event.storageArea !== localStorage ) {\n\t\treturn;\n\t}\n\tfor ( const speech of speechRootMap.values() ) {\n\t\tspeech.setState( getUtteranceOptions() );\n\t}\n} );\n\n/**\n * Get utterance options merging defaults with custom defaults and localStorage overrides.\n *\n * @return {{pitch: number, rate: number, languageVoices: Object<string, string>}} Utterance options.\n */\nfunction getUtteranceOptions() {\n\tconst utteranceOptions = Object.assign(\n\t\t{},\n\t\tDEFAULT_UTTERANCE_OPTIONS,\n\t\tcustomDefaultUtteranceOptions\n\t);\n\tif ( ! localStorage.getItem( STATE_STORAGE_KEY ) ) {\n\t\treturn utteranceOptions;\n\t}\n\ttry {\n\t\tconst sharedState = JSON.parse( localStorage.getItem( STATE_STORAGE_KEY ) );\n\t\tfor ( const key of Object.keys( DEFAULT_UTTERANCE_OPTIONS ) ) {\n\t\t\tif ( 'undefined' !== typeof sharedState[ key ] ) {\n\t\t\t\tutteranceOptions[ key ] = sharedState[ key ];\n\t\t\t}\n\t\t}\n\t} catch ( e ) {\n\t\tlocalStorage.removeItem( STATE_STORAGE_KEY );\n\t}\n\treturn utteranceOptions;\n}\n\n/**\n * Destroy Speech instances in element.\n *\n * @param {Element} element         - Element to look for content.\n * @param {string}  contentSelector - Selector for content elements.\n */\nfunction destroySpeeches( { element, contentSelector } ) {\n\tconst speechRoots = findContentRoots( element, contentSelector );\n\tfor ( const rootElement of speechRoots ) {\n\t\tconst speech = speechRootMap.get( rootElement );\n\t\tif ( speech ) {\n\t\t\tspeech.destroy();\n\t\t\tspeechRootMap.delete( rootElement );\n\t\t}\n\t}\n}\n\n/**\n * Determine if system has support.\n *\n * @todo This needs to be revisited in the future.\n * @return {boolean} Whether the system has support. Returns if not Android or iOS.\n */\nconst HAS_SYSTEM_SUPPORT = () => {\n\treturn ! /\\b(Android|iPhone|iPad|iPod)\\b/i.test( navigator.userAgent );\n};\n\n/**\n * Initialize.\n *\n * @param {string}   contentSelector         - CSS Selector to find the elements for speaking.\n * @param {Element}  rootElement             - Root element within which to look for content\n * @param {Object}   chunkifyOptions         - Options passed into chunkify.\n * @param {boolean}  useDashicons            - Whether to use Dashicons.\n * @param {Object}   defaultUtteranceOptions - Default utterance options when none are supplied from localStorage.\n * @param {Function} hasSystemSupport        - Function which determines whether the user's operating supports the functionality. Defaults to return false on iOS or Android.\n * @returns {Promise} Promise.\n */\nexport function initialize( {\n\trootElement,\n\tcontentSelector = CONTENT_SELECTOR,\n\tuseDashicons,\n\tchunkifyOptions,\n\tdefaultUtteranceOptions = DEFAULT_UTTERANCE_OPTIONS,\n\thasSystemSupport = HAS_SYSTEM_SUPPORT,\n} = {} ) {\n\tcustomDefaultUtteranceOptions = defaultUtteranceOptions;\n\n\treturn new Promise( ( resolve, reject ) => {\n\t\tif ( typeof speechSynthesis === 'undefined' || typeof SpeechSynthesisUtterance === 'undefined' ) {\n\t\t\treject( 'speech_synthesis_not_supported' );\n\t\t\treturn;\n\t\t}\n\t\tif ( ! hasSystemSupport() ) {\n\t\t\treject( 'system_not_supported' );\n\t\t\treturn;\n\t\t}\n\n\t\tconst mutationObserver = new MutationObserver( ( mutations ) => {\n\t\t\tfor ( const mutation of mutations ) {\n\t\t\t\tfor ( const addedNode of [ ...mutation.addedNodes ].filter( ( node ) => node.nodeType === Node.ELEMENT_NODE ) ) {\n\t\t\t\t\tcreateSpeeches( {\n\t\t\t\t\t\telement: addedNode,\n\t\t\t\t\t\tcontentSelector,\n\t\t\t\t\t\tuseDashicons,\n\t\t\t\t\t\tchunkifyOptions,\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t\tfor ( const removedNode of [ ...mutation.removedNodes ].filter( ( node ) => node.nodeType === Node.ELEMENT_NODE ) ) {\n\t\t\t\t\tdestroySpeeches( {\n\t\t\t\t\t\telement: removedNode,\n\t\t\t\t\t\tcontentSelector,\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\n\t\tconst uponReady = () => {\n\t\t\tconst element = rootElement || document.body;\n\n\t\t\t// Probably a bug in Chrome that utterance is not canceled upon unload.\n\t\t\twindow.addEventListener( 'unload', () => {\n\t\t\t\tspeechSynthesis.cancel();\n\t\t\t} );\n\n\t\t\tcreateSpeeches( {\n\t\t\t\telement,\n\t\t\t\tcontentSelector,\n\t\t\t\tchunkifyOptions,\n\t\t\t\tuseDashicons,\n\t\t\t} );\n\n\t\t\tmutationObserver.observe( element, {\n\t\t\t\tchildList: true,\n\t\t\t\tsubtree: true,\n\t\t\t} );\n\n\t\t\tresolve();\n\t\t};\n\n\t\tif ( 'complete' === document.readyState ) {\n\t\t\tuponReady();\n\t\t} else {\n\t\t\tdocument.addEventListener( 'DOMContentLoaded', uponReady );\n\t\t}\n\t} );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/index.js","/**\n * @preserve jed.js https://github.com/SlexAxton/Jed\n */\n/*\n-----------\nA gettext compatible i18n library for modern JavaScript Applications\n\nby Alex Sexton - AlexSexton [at] gmail - @SlexAxton\n\nMIT License\n\nA jQuery Foundation project - requires CLA to contribute -\nhttps://contribute.jquery.org/CLA/\n\n\n\nJed offers the entire applicable GNU gettext spec'd set of\nfunctions, but also offers some nicer wrappers around them.\nThe api for gettext was written for a language with no function\noverloading, so Jed allows a little more of that.\n\nMany thanks to Joshua I. Miller - unrtst@cpan.org - who wrote\ngettext.js back in 2008. I was able to vet a lot of my ideas\nagainst his. I also made sure Jed passed against his tests\nin order to offer easy upgrades -- jsgettext.berlios.de\n*/\n(function (root, undef) {\n\n  // Set up some underscore-style functions, if you already have\n  // underscore, feel free to delete this section, and use it\n  // directly, however, the amount of functions used doesn't\n  // warrant having underscore as a full dependency.\n  // Underscore 1.3.0 was used to port and is licensed\n  // under the MIT License by Jeremy Ashkenas.\n  var ArrayProto    = Array.prototype,\n      ObjProto      = Object.prototype,\n      slice         = ArrayProto.slice,\n      hasOwnProp    = ObjProto.hasOwnProperty,\n      nativeForEach = ArrayProto.forEach,\n      breaker       = {};\n\n  // We're not using the OOP style _ so we don't need the\n  // extra level of indirection. This still means that you\n  // sub out for real `_` though.\n  var _ = {\n    forEach : function( obj, iterator, context ) {\n      var i, l, key;\n      if ( obj === null ) {\n        return;\n      }\n\n      if ( nativeForEach && obj.forEach === nativeForEach ) {\n        obj.forEach( iterator, context );\n      }\n      else if ( obj.length === +obj.length ) {\n        for ( i = 0, l = obj.length; i < l; i++ ) {\n          if ( i in obj && iterator.call( context, obj[i], i, obj ) === breaker ) {\n            return;\n          }\n        }\n      }\n      else {\n        for ( key in obj) {\n          if ( hasOwnProp.call( obj, key ) ) {\n            if ( iterator.call (context, obj[key], key, obj ) === breaker ) {\n              return;\n            }\n          }\n        }\n      }\n    },\n    extend : function( obj ) {\n      this.forEach( slice.call( arguments, 1 ), function ( source ) {\n        for ( var prop in source ) {\n          obj[prop] = source[prop];\n        }\n      });\n      return obj;\n    }\n  };\n  // END Miniature underscore impl\n\n  // Jed is a constructor function\n  var Jed = function ( options ) {\n    // Some minimal defaults\n    this.defaults = {\n      \"locale_data\" : {\n        \"messages\" : {\n          \"\" : {\n            \"domain\"       : \"messages\",\n            \"lang\"         : \"en\",\n            \"plural_forms\" : \"nplurals=2; plural=(n != 1);\"\n          }\n          // There are no default keys, though\n        }\n      },\n      // The default domain if one is missing\n      \"domain\" : \"messages\",\n      // enable debug mode to log untranslated strings to the console\n      \"debug\" : false\n    };\n\n    // Mix in the sent options with the default options\n    this.options = _.extend( {}, this.defaults, options );\n    this.textdomain( this.options.domain );\n\n    if ( options.domain && ! this.options.locale_data[ this.options.domain ] ) {\n      throw new Error('Text domain set to non-existent domain: `' + options.domain + '`');\n    }\n  };\n\n  // The gettext spec sets this character as the default\n  // delimiter for context lookups.\n  // e.g.: context\\u0004key\n  // If your translation company uses something different,\n  // just change this at any time and it will use that instead.\n  Jed.context_delimiter = String.fromCharCode( 4 );\n\n  function getPluralFormFunc ( plural_form_string ) {\n    return Jed.PF.compile( plural_form_string || \"nplurals=2; plural=(n != 1);\");\n  }\n\n  function Chain( key, i18n ){\n    this._key = key;\n    this._i18n = i18n;\n  }\n\n  // Create a chainable api for adding args prettily\n  _.extend( Chain.prototype, {\n    onDomain : function ( domain ) {\n      this._domain = domain;\n      return this;\n    },\n    withContext : function ( context ) {\n      this._context = context;\n      return this;\n    },\n    ifPlural : function ( num, pkey ) {\n      this._val = num;\n      this._pkey = pkey;\n      return this;\n    },\n    fetch : function ( sArr ) {\n      if ( {}.toString.call( sArr ) != '[object Array]' ) {\n        sArr = [].slice.call(arguments, 0);\n      }\n      return ( sArr && sArr.length ? Jed.sprintf : function(x){ return x; } )(\n        this._i18n.dcnpgettext(this._domain, this._context, this._key, this._pkey, this._val),\n        sArr\n      );\n    }\n  });\n\n  // Add functions to the Jed prototype.\n  // These will be the functions on the object that's returned\n  // from creating a `new Jed()`\n  // These seem redundant, but they gzip pretty well.\n  _.extend( Jed.prototype, {\n    // The sexier api start point\n    translate : function ( key ) {\n      return new Chain( key, this );\n    },\n\n    textdomain : function ( domain ) {\n      if ( ! domain ) {\n        return this._textdomain;\n      }\n      this._textdomain = domain;\n    },\n\n    gettext : function ( key ) {\n      return this.dcnpgettext.call( this, undef, undef, key );\n    },\n\n    dgettext : function ( domain, key ) {\n     return this.dcnpgettext.call( this, domain, undef, key );\n    },\n\n    dcgettext : function ( domain , key /*, category */ ) {\n      // Ignores the category anyways\n      return this.dcnpgettext.call( this, domain, undef, key );\n    },\n\n    ngettext : function ( skey, pkey, val ) {\n      return this.dcnpgettext.call( this, undef, undef, skey, pkey, val );\n    },\n\n    dngettext : function ( domain, skey, pkey, val ) {\n      return this.dcnpgettext.call( this, domain, undef, skey, pkey, val );\n    },\n\n    dcngettext : function ( domain, skey, pkey, val/*, category */) {\n      return this.dcnpgettext.call( this, domain, undef, skey, pkey, val );\n    },\n\n    pgettext : function ( context, key ) {\n      return this.dcnpgettext.call( this, undef, context, key );\n    },\n\n    dpgettext : function ( domain, context, key ) {\n      return this.dcnpgettext.call( this, domain, context, key );\n    },\n\n    dcpgettext : function ( domain, context, key/*, category */) {\n      return this.dcnpgettext.call( this, domain, context, key );\n    },\n\n    npgettext : function ( context, skey, pkey, val ) {\n      return this.dcnpgettext.call( this, undef, context, skey, pkey, val );\n    },\n\n    dnpgettext : function ( domain, context, skey, pkey, val ) {\n      return this.dcnpgettext.call( this, domain, context, skey, pkey, val );\n    },\n\n    // The most fully qualified gettext function. It has every option.\n    // Since it has every option, we can use it from every other method.\n    // This is the bread and butter.\n    // Technically there should be one more argument in this function for 'Category',\n    // but since we never use it, we might as well not waste the bytes to define it.\n    dcnpgettext : function ( domain, context, singular_key, plural_key, val ) {\n      // Set some defaults\n\n      plural_key = plural_key || singular_key;\n\n      // Use the global domain default if one\n      // isn't explicitly passed in\n      domain = domain || this._textdomain;\n\n      var fallback;\n\n      // Handle special cases\n\n      // No options found\n      if ( ! this.options ) {\n        // There's likely something wrong, but we'll return the correct key for english\n        // We do this by instantiating a brand new Jed instance with the default set\n        // for everything that could be broken.\n        fallback = new Jed();\n        return fallback.dcnpgettext.call( fallback, undefined, undefined, singular_key, plural_key, val );\n      }\n\n      // No translation data provided\n      if ( ! this.options.locale_data ) {\n        throw new Error('No locale data provided.');\n      }\n\n      if ( ! this.options.locale_data[ domain ] ) {\n        throw new Error('Domain `' + domain + '` was not found.');\n      }\n\n      if ( ! this.options.locale_data[ domain ][ \"\" ] ) {\n        throw new Error('No locale meta information provided.');\n      }\n\n      // Make sure we have a truthy key. Otherwise we might start looking\n      // into the empty string key, which is the options for the locale\n      // data.\n      if ( ! singular_key ) {\n        throw new Error('No translation key found.');\n      }\n\n      var key  = context ? context + Jed.context_delimiter + singular_key : singular_key,\n          locale_data = this.options.locale_data,\n          dict = locale_data[ domain ],\n          defaultConf = (locale_data.messages || this.defaults.locale_data.messages)[\"\"],\n          pluralForms = dict[\"\"].plural_forms || dict[\"\"][\"Plural-Forms\"] || dict[\"\"][\"plural-forms\"] || defaultConf.plural_forms || defaultConf[\"Plural-Forms\"] || defaultConf[\"plural-forms\"],\n          val_list,\n          res;\n\n      var val_idx;\n      if (val === undefined) {\n        // No value passed in; assume singular key lookup.\n        val_idx = 0;\n\n      } else {\n        // Value has been passed in; use plural-forms calculations.\n\n        // Handle invalid numbers, but try casting strings for good measure\n        if ( typeof val != 'number' ) {\n          val = parseInt( val, 10 );\n\n          if ( isNaN( val ) ) {\n            throw new Error('The number that was passed in is not a number.');\n          }\n        }\n\n        val_idx = getPluralFormFunc(pluralForms)(val);\n      }\n\n      // Throw an error if a domain isn't found\n      if ( ! dict ) {\n        throw new Error('No domain named `' + domain + '` could be found.');\n      }\n\n      val_list = dict[ key ];\n\n      // If there is no match, then revert back to\n      // english style singular/plural with the keys passed in.\n      if ( ! val_list || val_idx > val_list.length ) {\n        if (this.options.missing_key_callback) {\n          this.options.missing_key_callback(key, domain);\n        }\n        res = [ singular_key, plural_key ];\n\n        // collect untranslated strings\n        if (this.options.debug===true) {\n          console.log(res[ getPluralFormFunc(pluralForms)( val ) ]);\n        }\n        return res[ getPluralFormFunc()( val ) ];\n      }\n\n      res = val_list[ val_idx ];\n\n      // This includes empty strings on purpose\n      if ( ! res  ) {\n        res = [ singular_key, plural_key ];\n        return res[ getPluralFormFunc()( val ) ];\n      }\n      return res;\n    }\n  });\n\n\n  // We add in sprintf capabilities for post translation value interolation\n  // This is not internally used, so you can remove it if you have this\n  // available somewhere else, or want to use a different system.\n\n  // We _slightly_ modify the normal sprintf behavior to more gracefully handle\n  // undefined values.\n\n  /**\n   sprintf() for JavaScript 0.7-beta1\n   http://www.diveintojavascript.com/projects/javascript-sprintf\n\n   Copyright (c) Alexandru Marasteanu <alexaholic [at) gmail (dot] com>\n   All rights reserved.\n\n   Redistribution and use in source and binary forms, with or without\n   modification, are permitted provided that the following conditions are met:\n       * Redistributions of source code must retain the above copyright\n         notice, this list of conditions and the following disclaimer.\n       * Redistributions in binary form must reproduce the above copyright\n         notice, this list of conditions and the following disclaimer in the\n         documentation and/or other materials provided with the distribution.\n       * Neither the name of sprintf() for JavaScript nor the\n         names of its contributors may be used to endorse or promote products\n         derived from this software without specific prior written permission.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n   DISCLAIMED. IN NO EVENT SHALL Alexandru Marasteanu BE LIABLE FOR ANY\n   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n  */\n  var sprintf = (function() {\n    function get_type(variable) {\n      return Object.prototype.toString.call(variable).slice(8, -1).toLowerCase();\n    }\n    function str_repeat(input, multiplier) {\n      for (var output = []; multiplier > 0; output[--multiplier] = input) {/* do nothing */}\n      return output.join('');\n    }\n\n    var str_format = function() {\n      if (!str_format.cache.hasOwnProperty(arguments[0])) {\n        str_format.cache[arguments[0]] = str_format.parse(arguments[0]);\n      }\n      return str_format.format.call(null, str_format.cache[arguments[0]], arguments);\n    };\n\n    str_format.format = function(parse_tree, argv) {\n      var cursor = 1, tree_length = parse_tree.length, node_type = '', arg, output = [], i, k, match, pad, pad_character, pad_length;\n      for (i = 0; i < tree_length; i++) {\n        node_type = get_type(parse_tree[i]);\n        if (node_type === 'string') {\n          output.push(parse_tree[i]);\n        }\n        else if (node_type === 'array') {\n          match = parse_tree[i]; // convenience purposes only\n          if (match[2]) { // keyword argument\n            arg = argv[cursor];\n            for (k = 0; k < match[2].length; k++) {\n              if (!arg.hasOwnProperty(match[2][k])) {\n                throw(sprintf('[sprintf] property \"%s\" does not exist', match[2][k]));\n              }\n              arg = arg[match[2][k]];\n            }\n          }\n          else if (match[1]) { // positional argument (explicit)\n            arg = argv[match[1]];\n          }\n          else { // positional argument (implicit)\n            arg = argv[cursor++];\n          }\n\n          if (/[^s]/.test(match[8]) && (get_type(arg) != 'number')) {\n            throw(sprintf('[sprintf] expecting number but found %s', get_type(arg)));\n          }\n\n          // Jed EDIT\n          if ( typeof arg == 'undefined' || arg === null ) {\n            arg = '';\n          }\n          // Jed EDIT\n\n          switch (match[8]) {\n            case 'b': arg = arg.toString(2); break;\n            case 'c': arg = String.fromCharCode(arg); break;\n            case 'd': arg = parseInt(arg, 10); break;\n            case 'e': arg = match[7] ? arg.toExponential(match[7]) : arg.toExponential(); break;\n            case 'f': arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg); break;\n            case 'o': arg = arg.toString(8); break;\n            case 's': arg = ((arg = String(arg)) && match[7] ? arg.substring(0, match[7]) : arg); break;\n            case 'u': arg = Math.abs(arg); break;\n            case 'x': arg = arg.toString(16); break;\n            case 'X': arg = arg.toString(16).toUpperCase(); break;\n          }\n          arg = (/[def]/.test(match[8]) && match[3] && arg >= 0 ? '+'+ arg : arg);\n          pad_character = match[4] ? match[4] == '0' ? '0' : match[4].charAt(1) : ' ';\n          pad_length = match[6] - String(arg).length;\n          pad = match[6] ? str_repeat(pad_character, pad_length) : '';\n          output.push(match[5] ? arg + pad : pad + arg);\n        }\n      }\n      return output.join('');\n    };\n\n    str_format.cache = {};\n\n    str_format.parse = function(fmt) {\n      var _fmt = fmt, match = [], parse_tree = [], arg_names = 0;\n      while (_fmt) {\n        if ((match = /^[^\\x25]+/.exec(_fmt)) !== null) {\n          parse_tree.push(match[0]);\n        }\n        else if ((match = /^\\x25{2}/.exec(_fmt)) !== null) {\n          parse_tree.push('%');\n        }\n        else if ((match = /^\\x25(?:([1-9]\\d*)\\$|\\(([^\\)]+)\\))?(\\+)?(0|'[^$])?(-)?(\\d+)?(?:\\.(\\d+))?([b-fosuxX])/.exec(_fmt)) !== null) {\n          if (match[2]) {\n            arg_names |= 1;\n            var field_list = [], replacement_field = match[2], field_match = [];\n            if ((field_match = /^([a-z_][a-z_\\d]*)/i.exec(replacement_field)) !== null) {\n              field_list.push(field_match[1]);\n              while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {\n                if ((field_match = /^\\.([a-z_][a-z_\\d]*)/i.exec(replacement_field)) !== null) {\n                  field_list.push(field_match[1]);\n                }\n                else if ((field_match = /^\\[(\\d+)\\]/.exec(replacement_field)) !== null) {\n                  field_list.push(field_match[1]);\n                }\n                else {\n                  throw('[sprintf] huh?');\n                }\n              }\n            }\n            else {\n              throw('[sprintf] huh?');\n            }\n            match[2] = field_list;\n          }\n          else {\n            arg_names |= 2;\n          }\n          if (arg_names === 3) {\n            throw('[sprintf] mixing positional and named placeholders is not (yet) supported');\n          }\n          parse_tree.push(match);\n        }\n        else {\n          throw('[sprintf] huh?');\n        }\n        _fmt = _fmt.substring(match[0].length);\n      }\n      return parse_tree;\n    };\n\n    return str_format;\n  })();\n\n  var vsprintf = function(fmt, argv) {\n    argv.unshift(fmt);\n    return sprintf.apply(null, argv);\n  };\n\n  Jed.parse_plural = function ( plural_forms, n ) {\n    plural_forms = plural_forms.replace(/n/g, n);\n    return Jed.parse_expression(plural_forms);\n  };\n\n  Jed.sprintf = function ( fmt, args ) {\n    if ( {}.toString.call( args ) == '[object Array]' ) {\n      return vsprintf( fmt, [].slice.call(args) );\n    }\n    return sprintf.apply(this, [].slice.call(arguments) );\n  };\n\n  Jed.prototype.sprintf = function () {\n    return Jed.sprintf.apply(this, arguments);\n  };\n  // END sprintf Implementation\n\n  // Start the Plural forms section\n  // This is a full plural form expression parser. It is used to avoid\n  // running 'eval' or 'new Function' directly against the plural\n  // forms.\n  //\n  // This can be important if you get translations done through a 3rd\n  // party vendor. I encourage you to use this instead, however, I\n  // also will provide a 'precompiler' that you can use at build time\n  // to output valid/safe function representations of the plural form\n  // expressions. This means you can build this code out for the most\n  // part.\n  Jed.PF = {};\n\n  Jed.PF.parse = function ( p ) {\n    var plural_str = Jed.PF.extractPluralExpr( p );\n    return Jed.PF.parser.parse.call(Jed.PF.parser, plural_str);\n  };\n\n  Jed.PF.compile = function ( p ) {\n    // Handle trues and falses as 0 and 1\n    function imply( val ) {\n      return (val === true ? 1 : val ? val : 0);\n    }\n\n    var ast = Jed.PF.parse( p );\n    return function ( n ) {\n      return imply( Jed.PF.interpreter( ast )( n ) );\n    };\n  };\n\n  Jed.PF.interpreter = function ( ast ) {\n    return function ( n ) {\n      var res;\n      switch ( ast.type ) {\n        case 'GROUP':\n          return Jed.PF.interpreter( ast.expr )( n );\n        case 'TERNARY':\n          if ( Jed.PF.interpreter( ast.expr )( n ) ) {\n            return Jed.PF.interpreter( ast.truthy )( n );\n          }\n          return Jed.PF.interpreter( ast.falsey )( n );\n        case 'OR':\n          return Jed.PF.interpreter( ast.left )( n ) || Jed.PF.interpreter( ast.right )( n );\n        case 'AND':\n          return Jed.PF.interpreter( ast.left )( n ) && Jed.PF.interpreter( ast.right )( n );\n        case 'LT':\n          return Jed.PF.interpreter( ast.left )( n ) < Jed.PF.interpreter( ast.right )( n );\n        case 'GT':\n          return Jed.PF.interpreter( ast.left )( n ) > Jed.PF.interpreter( ast.right )( n );\n        case 'LTE':\n          return Jed.PF.interpreter( ast.left )( n ) <= Jed.PF.interpreter( ast.right )( n );\n        case 'GTE':\n          return Jed.PF.interpreter( ast.left )( n ) >= Jed.PF.interpreter( ast.right )( n );\n        case 'EQ':\n          return Jed.PF.interpreter( ast.left )( n ) == Jed.PF.interpreter( ast.right )( n );\n        case 'NEQ':\n          return Jed.PF.interpreter( ast.left )( n ) != Jed.PF.interpreter( ast.right )( n );\n        case 'MOD':\n          return Jed.PF.interpreter( ast.left )( n ) % Jed.PF.interpreter( ast.right )( n );\n        case 'VAR':\n          return n;\n        case 'NUM':\n          return ast.val;\n        default:\n          throw new Error(\"Invalid Token found.\");\n      }\n    };\n  };\n\n  Jed.PF.extractPluralExpr = function ( p ) {\n    // trim first\n    p = p.replace(/^\\s\\s*/, '').replace(/\\s\\s*$/, '');\n\n    if (! /;\\s*$/.test(p)) {\n      p = p.concat(';');\n    }\n\n    var nplurals_re = /nplurals\\=(\\d+);/,\n        plural_re = /plural\\=(.*);/,\n        nplurals_matches = p.match( nplurals_re ),\n        res = {},\n        plural_matches;\n\n    // Find the nplurals number\n    if ( nplurals_matches.length > 1 ) {\n      res.nplurals = nplurals_matches[1];\n    }\n    else {\n      throw new Error('nplurals not found in plural_forms string: ' + p );\n    }\n\n    // remove that data to get to the formula\n    p = p.replace( nplurals_re, \"\" );\n    plural_matches = p.match( plural_re );\n\n    if (!( plural_matches && plural_matches.length > 1 ) ) {\n      throw new Error('`plural` expression not found: ' + p);\n    }\n    return plural_matches[ 1 ];\n  };\n\n  /* Jison generated parser */\n  Jed.PF.parser = (function(){\n\nvar parser = {trace: function trace() { },\nyy: {},\nsymbols_: {\"error\":2,\"expressions\":3,\"e\":4,\"EOF\":5,\"?\":6,\":\":7,\"||\":8,\"&&\":9,\"<\":10,\"<=\":11,\">\":12,\">=\":13,\"!=\":14,\"==\":15,\"%\":16,\"(\":17,\")\":18,\"n\":19,\"NUMBER\":20,\"$accept\":0,\"$end\":1},\nterminals_: {2:\"error\",5:\"EOF\",6:\"?\",7:\":\",8:\"||\",9:\"&&\",10:\"<\",11:\"<=\",12:\">\",13:\">=\",14:\"!=\",15:\"==\",16:\"%\",17:\"(\",18:\")\",19:\"n\",20:\"NUMBER\"},\nproductions_: [0,[3,2],[4,5],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,1],[4,1]],\nperformAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) {\n\nvar $0 = $$.length - 1;\nswitch (yystate) {\ncase 1: return { type : 'GROUP', expr: $$[$0-1] };\nbreak;\ncase 2:this.$ = { type: 'TERNARY', expr: $$[$0-4], truthy : $$[$0-2], falsey: $$[$0] };\nbreak;\ncase 3:this.$ = { type: \"OR\", left: $$[$0-2], right: $$[$0] };\nbreak;\ncase 4:this.$ = { type: \"AND\", left: $$[$0-2], right: $$[$0] };\nbreak;\ncase 5:this.$ = { type: 'LT', left: $$[$0-2], right: $$[$0] };\nbreak;\ncase 6:this.$ = { type: 'LTE', left: $$[$0-2], right: $$[$0] };\nbreak;\ncase 7:this.$ = { type: 'GT', left: $$[$0-2], right: $$[$0] };\nbreak;\ncase 8:this.$ = { type: 'GTE', left: $$[$0-2], right: $$[$0] };\nbreak;\ncase 9:this.$ = { type: 'NEQ', left: $$[$0-2], right: $$[$0] };\nbreak;\ncase 10:this.$ = { type: 'EQ', left: $$[$0-2], right: $$[$0] };\nbreak;\ncase 11:this.$ = { type: 'MOD', left: $$[$0-2], right: $$[$0] };\nbreak;\ncase 12:this.$ = { type: 'GROUP', expr: $$[$0-1] };\nbreak;\ncase 13:this.$ = { type: 'VAR' };\nbreak;\ncase 14:this.$ = { type: 'NUM', val: Number(yytext) };\nbreak;\n}\n},\ntable: [{3:1,4:2,17:[1,3],19:[1,4],20:[1,5]},{1:[3]},{5:[1,6],6:[1,7],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16]},{4:17,17:[1,3],19:[1,4],20:[1,5]},{5:[2,13],6:[2,13],7:[2,13],8:[2,13],9:[2,13],10:[2,13],11:[2,13],12:[2,13],13:[2,13],14:[2,13],15:[2,13],16:[2,13],18:[2,13]},{5:[2,14],6:[2,14],7:[2,14],8:[2,14],9:[2,14],10:[2,14],11:[2,14],12:[2,14],13:[2,14],14:[2,14],15:[2,14],16:[2,14],18:[2,14]},{1:[2,1]},{4:18,17:[1,3],19:[1,4],20:[1,5]},{4:19,17:[1,3],19:[1,4],20:[1,5]},{4:20,17:[1,3],19:[1,4],20:[1,5]},{4:21,17:[1,3],19:[1,4],20:[1,5]},{4:22,17:[1,3],19:[1,4],20:[1,5]},{4:23,17:[1,3],19:[1,4],20:[1,5]},{4:24,17:[1,3],19:[1,4],20:[1,5]},{4:25,17:[1,3],19:[1,4],20:[1,5]},{4:26,17:[1,3],19:[1,4],20:[1,5]},{4:27,17:[1,3],19:[1,4],20:[1,5]},{6:[1,7],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[1,28]},{6:[1,7],7:[1,29],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16]},{5:[2,3],6:[2,3],7:[2,3],8:[2,3],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[2,3]},{5:[2,4],6:[2,4],7:[2,4],8:[2,4],9:[2,4],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[2,4]},{5:[2,5],6:[2,5],7:[2,5],8:[2,5],9:[2,5],10:[2,5],11:[2,5],12:[2,5],13:[2,5],14:[2,5],15:[2,5],16:[1,16],18:[2,5]},{5:[2,6],6:[2,6],7:[2,6],8:[2,6],9:[2,6],10:[2,6],11:[2,6],12:[2,6],13:[2,6],14:[2,6],15:[2,6],16:[1,16],18:[2,6]},{5:[2,7],6:[2,7],7:[2,7],8:[2,7],9:[2,7],10:[2,7],11:[2,7],12:[2,7],13:[2,7],14:[2,7],15:[2,7],16:[1,16],18:[2,7]},{5:[2,8],6:[2,8],7:[2,8],8:[2,8],9:[2,8],10:[2,8],11:[2,8],12:[2,8],13:[2,8],14:[2,8],15:[2,8],16:[1,16],18:[2,8]},{5:[2,9],6:[2,9],7:[2,9],8:[2,9],9:[2,9],10:[2,9],11:[2,9],12:[2,9],13:[2,9],14:[2,9],15:[2,9],16:[1,16],18:[2,9]},{5:[2,10],6:[2,10],7:[2,10],8:[2,10],9:[2,10],10:[2,10],11:[2,10],12:[2,10],13:[2,10],14:[2,10],15:[2,10],16:[1,16],18:[2,10]},{5:[2,11],6:[2,11],7:[2,11],8:[2,11],9:[2,11],10:[2,11],11:[2,11],12:[2,11],13:[2,11],14:[2,11],15:[2,11],16:[2,11],18:[2,11]},{5:[2,12],6:[2,12],7:[2,12],8:[2,12],9:[2,12],10:[2,12],11:[2,12],12:[2,12],13:[2,12],14:[2,12],15:[2,12],16:[2,12],18:[2,12]},{4:30,17:[1,3],19:[1,4],20:[1,5]},{5:[2,2],6:[1,7],7:[2,2],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[2,2]}],\ndefaultActions: {6:[2,1]},\nparseError: function parseError(str, hash) {\n    throw new Error(str);\n},\nparse: function parse(input) {\n    var self = this,\n        stack = [0],\n        vstack = [null], // semantic value stack\n        lstack = [], // location stack\n        table = this.table,\n        yytext = '',\n        yylineno = 0,\n        yyleng = 0,\n        recovering = 0,\n        TERROR = 2,\n        EOF = 1;\n\n    //this.reductionCount = this.shiftCount = 0;\n\n    this.lexer.setInput(input);\n    this.lexer.yy = this.yy;\n    this.yy.lexer = this.lexer;\n    if (typeof this.lexer.yylloc == 'undefined')\n        this.lexer.yylloc = {};\n    var yyloc = this.lexer.yylloc;\n    lstack.push(yyloc);\n\n    if (typeof this.yy.parseError === 'function')\n        this.parseError = this.yy.parseError;\n\n    function popStack (n) {\n        stack.length = stack.length - 2*n;\n        vstack.length = vstack.length - n;\n        lstack.length = lstack.length - n;\n    }\n\n    function lex() {\n        var token;\n        token = self.lexer.lex() || 1; // $end = 1\n        // if token isn't its numeric value, convert\n        if (typeof token !== 'number') {\n            token = self.symbols_[token] || token;\n        }\n        return token;\n    }\n\n    var symbol, preErrorSymbol, state, action, a, r, yyval={},p,len,newState, expected;\n    while (true) {\n        // retreive state number from top of stack\n        state = stack[stack.length-1];\n\n        // use default actions if available\n        if (this.defaultActions[state]) {\n            action = this.defaultActions[state];\n        } else {\n            if (symbol == null)\n                symbol = lex();\n            // read action for current state and first input\n            action = table[state] && table[state][symbol];\n        }\n\n        // handle parse error\n        _handle_error:\n        if (typeof action === 'undefined' || !action.length || !action[0]) {\n\n            if (!recovering) {\n                // Report error\n                expected = [];\n                for (p in table[state]) if (this.terminals_[p] && p > 2) {\n                    expected.push(\"'\"+this.terminals_[p]+\"'\");\n                }\n                var errStr = '';\n                if (this.lexer.showPosition) {\n                    errStr = 'Parse error on line '+(yylineno+1)+\":\\n\"+this.lexer.showPosition()+\"\\nExpecting \"+expected.join(', ') + \", got '\" + this.terminals_[symbol]+ \"'\";\n                } else {\n                    errStr = 'Parse error on line '+(yylineno+1)+\": Unexpected \" +\n                                  (symbol == 1 /*EOF*/ ? \"end of input\" :\n                                              (\"'\"+(this.terminals_[symbol] || symbol)+\"'\"));\n                }\n                this.parseError(errStr,\n                    {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected});\n            }\n\n            // just recovered from another error\n            if (recovering == 3) {\n                if (symbol == EOF) {\n                    throw new Error(errStr || 'Parsing halted.');\n                }\n\n                // discard current lookahead and grab another\n                yyleng = this.lexer.yyleng;\n                yytext = this.lexer.yytext;\n                yylineno = this.lexer.yylineno;\n                yyloc = this.lexer.yylloc;\n                symbol = lex();\n            }\n\n            // try to recover from error\n            while (1) {\n                // check for error recovery rule in this state\n                if ((TERROR.toString()) in table[state]) {\n                    break;\n                }\n                if (state == 0) {\n                    throw new Error(errStr || 'Parsing halted.');\n                }\n                popStack(1);\n                state = stack[stack.length-1];\n            }\n\n            preErrorSymbol = symbol; // save the lookahead token\n            symbol = TERROR;         // insert generic error symbol as new lookahead\n            state = stack[stack.length-1];\n            action = table[state] && table[state][TERROR];\n            recovering = 3; // allow 3 real symbols to be shifted before reporting a new error\n        }\n\n        // this shouldn't happen, unless resolve defaults are off\n        if (action[0] instanceof Array && action.length > 1) {\n            throw new Error('Parse Error: multiple actions possible at state: '+state+', token: '+symbol);\n        }\n\n        switch (action[0]) {\n\n            case 1: // shift\n                //this.shiftCount++;\n\n                stack.push(symbol);\n                vstack.push(this.lexer.yytext);\n                lstack.push(this.lexer.yylloc);\n                stack.push(action[1]); // push state\n                symbol = null;\n                if (!preErrorSymbol) { // normal execution/no error\n                    yyleng = this.lexer.yyleng;\n                    yytext = this.lexer.yytext;\n                    yylineno = this.lexer.yylineno;\n                    yyloc = this.lexer.yylloc;\n                    if (recovering > 0)\n                        recovering--;\n                } else { // error just occurred, resume old lookahead f/ before error\n                    symbol = preErrorSymbol;\n                    preErrorSymbol = null;\n                }\n                break;\n\n            case 2: // reduce\n                //this.reductionCount++;\n\n                len = this.productions_[action[1]][1];\n\n                // perform semantic action\n                yyval.$ = vstack[vstack.length-len]; // default to $$ = $1\n                // default location, uses first token for firsts, last for lasts\n                yyval._$ = {\n                    first_line: lstack[lstack.length-(len||1)].first_line,\n                    last_line: lstack[lstack.length-1].last_line,\n                    first_column: lstack[lstack.length-(len||1)].first_column,\n                    last_column: lstack[lstack.length-1].last_column\n                };\n                r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);\n\n                if (typeof r !== 'undefined') {\n                    return r;\n                }\n\n                // pop off stack\n                if (len) {\n                    stack = stack.slice(0,-1*len*2);\n                    vstack = vstack.slice(0, -1*len);\n                    lstack = lstack.slice(0, -1*len);\n                }\n\n                stack.push(this.productions_[action[1]][0]);    // push nonterminal (reduce)\n                vstack.push(yyval.$);\n                lstack.push(yyval._$);\n                // goto new state = table[STATE][NONTERMINAL]\n                newState = table[stack[stack.length-2]][stack[stack.length-1]];\n                stack.push(newState);\n                break;\n\n            case 3: // accept\n                return true;\n        }\n\n    }\n\n    return true;\n}};/* Jison generated lexer */\nvar lexer = (function(){\n\nvar lexer = ({EOF:1,\nparseError:function parseError(str, hash) {\n        if (this.yy.parseError) {\n            this.yy.parseError(str, hash);\n        } else {\n            throw new Error(str);\n        }\n    },\nsetInput:function (input) {\n        this._input = input;\n        this._more = this._less = this.done = false;\n        this.yylineno = this.yyleng = 0;\n        this.yytext = this.matched = this.match = '';\n        this.conditionStack = ['INITIAL'];\n        this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0};\n        return this;\n    },\ninput:function () {\n        var ch = this._input[0];\n        this.yytext+=ch;\n        this.yyleng++;\n        this.match+=ch;\n        this.matched+=ch;\n        var lines = ch.match(/\\n/);\n        if (lines) this.yylineno++;\n        this._input = this._input.slice(1);\n        return ch;\n    },\nunput:function (ch) {\n        this._input = ch + this._input;\n        return this;\n    },\nmore:function () {\n        this._more = true;\n        return this;\n    },\npastInput:function () {\n        var past = this.matched.substr(0, this.matched.length - this.match.length);\n        return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\\n/g, \"\");\n    },\nupcomingInput:function () {\n        var next = this.match;\n        if (next.length < 20) {\n            next += this._input.substr(0, 20-next.length);\n        }\n        return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\\n/g, \"\");\n    },\nshowPosition:function () {\n        var pre = this.pastInput();\n        var c = new Array(pre.length + 1).join(\"-\");\n        return pre + this.upcomingInput() + \"\\n\" + c+\"^\";\n    },\nnext:function () {\n        if (this.done) {\n            return this.EOF;\n        }\n        if (!this._input) this.done = true;\n\n        var token,\n            match,\n            col,\n            lines;\n        if (!this._more) {\n            this.yytext = '';\n            this.match = '';\n        }\n        var rules = this._currentRules();\n        for (var i=0;i < rules.length; i++) {\n            match = this._input.match(this.rules[rules[i]]);\n            if (match) {\n                lines = match[0].match(/\\n.*/g);\n                if (lines) this.yylineno += lines.length;\n                this.yylloc = {first_line: this.yylloc.last_line,\n                               last_line: this.yylineno+1,\n                               first_column: this.yylloc.last_column,\n                               last_column: lines ? lines[lines.length-1].length-1 : this.yylloc.last_column + match[0].length}\n                this.yytext += match[0];\n                this.match += match[0];\n                this.matches = match;\n                this.yyleng = this.yytext.length;\n                this._more = false;\n                this._input = this._input.slice(match[0].length);\n                this.matched += match[0];\n                token = this.performAction.call(this, this.yy, this, rules[i],this.conditionStack[this.conditionStack.length-1]);\n                if (token) return token;\n                else return;\n            }\n        }\n        if (this._input === \"\") {\n            return this.EOF;\n        } else {\n            this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\\n'+this.showPosition(),\n                    {text: \"\", token: null, line: this.yylineno});\n        }\n    },\nlex:function lex() {\n        var r = this.next();\n        if (typeof r !== 'undefined') {\n            return r;\n        } else {\n            return this.lex();\n        }\n    },\nbegin:function begin(condition) {\n        this.conditionStack.push(condition);\n    },\npopState:function popState() {\n        return this.conditionStack.pop();\n    },\n_currentRules:function _currentRules() {\n        return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules;\n    },\ntopState:function () {\n        return this.conditionStack[this.conditionStack.length-2];\n    },\npushState:function begin(condition) {\n        this.begin(condition);\n    }});\nlexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {\n\nvar YYSTATE=YY_START;\nswitch($avoiding_name_collisions) {\ncase 0:/* skip whitespace */\nbreak;\ncase 1:return 20\nbreak;\ncase 2:return 19\nbreak;\ncase 3:return 8\nbreak;\ncase 4:return 9\nbreak;\ncase 5:return 6\nbreak;\ncase 6:return 7\nbreak;\ncase 7:return 11\nbreak;\ncase 8:return 13\nbreak;\ncase 9:return 10\nbreak;\ncase 10:return 12\nbreak;\ncase 11:return 14\nbreak;\ncase 12:return 15\nbreak;\ncase 13:return 16\nbreak;\ncase 14:return 17\nbreak;\ncase 15:return 18\nbreak;\ncase 16:return 5\nbreak;\ncase 17:return 'INVALID'\nbreak;\n}\n};\nlexer.rules = [/^\\s+/,/^[0-9]+(\\.[0-9]+)?\\b/,/^n\\b/,/^\\|\\|/,/^&&/,/^\\?/,/^:/,/^<=/,/^>=/,/^</,/^>/,/^!=/,/^==/,/^%/,/^\\(/,/^\\)/,/^$/,/^./];\nlexer.conditions = {\"INITIAL\":{\"rules\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],\"inclusive\":true}};return lexer;})()\nparser.lexer = lexer;\nreturn parser;\n})();\n// End parser\n\n  // Handle node, amd, and global systems\n  if (typeof exports !== 'undefined') {\n    if (typeof module !== 'undefined' && module.exports) {\n      exports = module.exports = Jed;\n    }\n    exports.Jed = Jed;\n  }\n  else {\n    if (typeof define === 'function' && define.amd) {\n      define(function() {\n        return Jed;\n      });\n    }\n    // Leak a global regardless of module system\n    root['Jed'] = Jed;\n  }\n\n})(this);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/jed/jed.js\n// module id = 28\n// module chunks = 0","\nimport React, { render, unmountComponentAtNode } from 'preact-compat';\nimport EventEmitter from 'event-emitter';\nimport chunkify, { getWeightedChunkLanguages } from './chunkify';\nimport * as voices from './voices';\nimport { equalRanges, scrollElementIntoViewIfNeeded } from './helpers';\nimport PlaybackControls from './components/PlaybackControls';\nimport isEqual from 'lodash/isEqual';\n\n/**\n * ASCII code for ESC.\n *\n * @type {number}\n */\nconst ESCAPE_KEY_CODE = 27;\n\n/**\n * A segment of text nodes that are to be read by the TTS engine.\n *\n * @typedef {object} Chunk\n * @property {Array}   nodes    - Text nodes.\n * @property {string}  language - Language for text nodes.\n * @property {Element} root     - Container element, not necessarily the parent.\n */\n\n/**\n * CSS selector for headings.\n *\n * @type {string}\n */\nconst HEADING_SELECTOR = 'h1, h2, h3, h4, h5, h6';\n\n/**\n * CSS selector for which elements should get paragraph pauses.\n *\n * @type {string}\n */\nconst PARAGRAPH_PAUSE_SELECTOR = 'blockquote, p, dt';\n\n/**\n * Pauses (in milliseconds) where the TTS engine should pause between speaking chunks.\n *\n * @type {object}\n */\nconst DEFAULT_PAUSE_DURATIONS = {\n\theading: 1000,\n\tparagraph: 500,\n};\n\n/**\n * Number of characters within which an offset is considered to be at the beginning of a chunk.\n *\n * If previous() is called when the offset is less than this number, then the previous chunk will be navigated to.\n * Otherwise, the offset will be set to zero to move the cursor to the beginning of the current chunk.\n *\n * @type {number}\n */\nconst CHUNK_BEGINNING_OFFSET_THRESHOLD = 10;\n\n/**\n * Representing a spoken section.\n *\n * @todo Switch to higher-order React.Component.\n * @augments EventEmitter\n */\nexport default class Speech {\n\t/**\n\t * Construct.\n\t *\n\t * @param {Object}  args                    - Args.\n\t * @param {Element} args.rootElement        - Element.\n\t * @param {Object}  args.utteranceOptions   - Default utterance options.\n\t * @param {Object}  args.chunkifyOptions    - Chunkify options.\n\t * @param {Object}  args.pauseDurations     - Pause durations.\n\t * @param {boolean} args.useDashicons=false - Whether to use Dashicons (as opposed to Emoji).\n\t */\n\tconstructor( {\n\t\trootElement,\n\t\tuseDashicons = false,\n\t\tutteranceOptions = {},\n\t\tchunkifyOptions,\n\t\tpauseDurations = DEFAULT_PAUSE_DURATIONS,\n\t} ) {\n\t\tthis.rootElement = rootElement;\n\t\tthis.chunkifyOptions = chunkifyOptions;\n\t\tthis.pauseDurations = pauseDurations;\n\t\tthis.useDashicons = useDashicons;\n\t\tthis.controlsElement = null;\n\t\tthis.currentUtterance = null;\n\n\t\tfor ( const method of [ 'play', 'stop', 'next', 'previous', 'updateContainsSelectionState', 'handleEscapeKeydown', 'renderControls' ] ) {\n\t\t\tthis[ method ] = this[ method ].bind( this );\n\t\t}\n\n\t\tthis.state = {\n\t\t\tcontainsSelection: false,\n\t\t\tsettingsShown: false,\n\t\t\tspeakTimeoutId: 0, // @todo This can be removed from the state.\n\t\t\tplaying: false,\n\t\t\tchunkIndex: 0, // Which chunk is playing.\n\t\t\tchunkRangeOffset: 0, // Which character inside the chunk's nodes was last spoken.\n\t\t\tlanguageVoices: {},\n\t\t\tpitch: 1.0,\n\t\t\trate: 1.0,\n\t\t};\n\t\tObject.assign( this.state, utteranceOptions );\n\t}\n\n\t/**\n\t * Initialize.\n\t *\n\t * See destroy method for inverse.\n\t */\n\tinitialize() {\n\t\tthis.chunkify();\n\t\tthis.injectControls();\n\t\tthis.setupStateMachine();\n\n\t\t// @todo Also if focus removed from container?\n\t\tdocument.addEventListener( 'selectionchange', this.updateContainsSelectionState );\n\t\tdocument.addEventListener( 'keydown', this.handleEscapeKeydown );\n\t\tthis.isDialogSupported = 'showModal' in document.createElement( 'dialog' ) || 'undefined' !== typeof dialogPolyfill;\n\n\t\tthis.renderControls();\n\t\tthis.on( 'change', this.renderControls );\n\n\t\t// @todo Add mutationObserver for this element to call this.chunkify() again.\n\t}\n\n\t/**\n\t * Set state.\n\t *\n\t * @param {Object}  props - Props.\n\t * @param {Object}  options - Options.\n\t * @param {boolean} options.suppressEvents - Whether to suppress change event.\n\t */\n\tsetState( props, { suppressEvents = false } = {} ) {\n\t\tconst oldProps = this.state;\n\t\tconst newProps = Object.assign( {}, oldProps, props );\n\t\tthis.state = newProps;\n\n\t\tlet changeCount = 0;\n\n\t\t// @todo Instead of emitting an event, just allow an onChange prop to be sent down, and make use of componentDidUpdate to call.\n\t\tfor ( const key of Object.keys( props ) ) {\n\t\t\tif ( isEqual( newProps[ key ], oldProps[ key ] ) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif ( ! suppressEvents ) {\n\t\t\t\tif ( typeof newProps[ key ] === 'string' ) {\n\t\t\t\t\tthis.emit( 'change:' + key + ':' + newProps[ key ], oldProps[ key ] );\n\t\t\t\t}\n\t\t\t\tthis.emit( 'change:' + key, newProps[ key ], oldProps[ key ] );\n\t\t\t}\n\t\t\tchangeCount += 1;\n\t\t}\n\t\tif ( ! suppressEvents && changeCount > 0 ) {\n\t\t\tthis.emit( 'change', newProps, oldProps );\n\t\t}\n\t}\n\n\t/**\n\t * Set up state machine.\n\t *\n\t * @todo This can be handled in componentDidUpdate.\n\t */\n\tsetupStateMachine() {\n\t\tthis.on( 'change:playing', ( playing ) => {\n\t\t\tif ( playing ) {\n\t\t\t\tthis.startPlayingCurrentChunkAndQueueNext();\n\t\t\t} else {\n\t\t\t\tclearTimeout( this.state.speakTimeoutId );\n\t\t\t\tspeechSynthesis.cancel();\n\t\t\t}\n\t\t} );\n\n\t\tthis.on( 'change:speakTimeoutId', ( newTimeoutId, oldTimeoutId ) => {\n\t\t\tclearTimeout( oldTimeoutId );\n\t\t} );\n\n\t\tconst handleChunkChange = () => {\n\t\t\tif ( this.state.playing ) {\n\t\t\t\tthis.startPlayingCurrentChunkAndQueueNext();\n\t\t\t} else {\n\t\t\t\tconst selection = window.getSelection();\n\t\t\t\tconst range = document.createRange();\n\t\t\t\tconst chunk = this.chunks[ this.state.chunkIndex ];\n\t\t\t\tconst firstNode = chunk.nodes[ 0 ];\n\t\t\t\tconst lastNode = chunk.nodes[ chunk.nodes.length - 1 ];\n\t\t\t\tselection.removeAllRanges();\n\t\t\t\trange.setStart( firstNode, 0 );\n\t\t\t\trange.setEnd( lastNode, lastNode.length );\n\t\t\t\tthis.playbackAddedRange = range;\n\t\t\t\tselection.addRange( range );\n\t\t\t\tfirstNode.parentElement.scrollIntoView( { behavior: 'smooth' } );\n\t\t\t}\n\t\t};\n\n\t\tthis.on( 'change:containsSelection', ( selected ) => {\n\t\t\tthis.controlsElement.classList.toggle( 'spoken-word--active', selected );\n\t\t} );\n\n\t\t// Make sure voices get loaded when the settings are shown.\n\t\tthis.on( 'change:settingsShown', ( isVisible ) => {\n\t\t\tif ( isVisible && ! voices.isLoaded() ) {\n\t\t\t\tvoices.load().then( this.renderControls );\n\t\t\t}\n\t\t} );\n\n\t\tconst handleVoicePropChangeDuringPlayback = () => {\n\t\t\tif ( this.state.playing ) {\n\t\t\t\tthis.voicePropChanged = true; // Prevent playback from stopping onend.\n\t\t\t\tthis.startPlayingCurrentChunkAndQueueNext();\n\t\t\t}\n\n\t\t\tthis.emit( 'sharedStateChange', {\n\t\t\t\tlanguageVoices: this.state.languageVoices,\n\t\t\t\trate: this.state.rate,\n\t\t\t\tpitch: this.state.pitch,\n\t\t\t} );\n\t\t};\n\n\t\tthis.on( 'change', ( newProps, oldProps ) => {\n\t\t\tif ( newProps.chunkIndex !== oldProps.chunkIndex || newProps.chunkRangeOffset !== oldProps.chunkRangeOffset ) {\n\t\t\t\thandleChunkChange();\n\t\t\t}\n\t\t\tif (\n\t\t\t\tnewProps.rate !== oldProps.rate ||\n\t\t\t\tnewProps.pitch !== oldProps.pitch ||\n\t\t\t\t( newProps.languageVoices !== oldProps.languageVoices && ! isEqual( newProps.languageVoices, oldProps.languageVoices ) )\n\t\t\t) {\n\t\t\t\thandleVoicePropChangeDuringPlayback();\n\t\t\t}\n\t\t} );\n\t}\n\n\t/**\n\t * Chunkify text nodes in content.\n\t */\n\tchunkify() {\n\t\tthis.chunks = chunkify( Object.assign(\n\t\t\t{},\n\t\t\tthis.chunkifyOptions,\n\t\t\t{ containerElement: this.rootElement }\n\t\t) );\n\t}\n\n\t/**\n\t * Inject controls into content.\n\t */\n\tinjectControls() {\n\t\tthis.controlsElement = document.createElement( 'div' ); // @todo Check to see if this element is already present, and use merge data-* with props.\n\t\tthis.controlsElement.classList.add( 'spoken-word' );\n\t\tthis.rootElement.insertBefore( this.controlsElement, this.rootElement.firstChild );\n\t}\n\n\t/**\n\t * Get available voices.\n\t *\n\t * @returns {SpeechSynthesisVoice[]} Local voices sorted by name.\n\t */\n\tgetAvailableVoices() {\n\t\tif ( this._availableVoices && this._availableVoices.length > 0 ) {\n\t\t\treturn this._availableVoices;\n\t\t}\n\t\tconst availableVoices = speechSynthesis.getVoices().filter( ( voice ) => voice.localService );\n\t\tavailableVoices.sort( ( a, b ) => {\n\t\t\tif ( a.name === b.name ) {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t\treturn a.name < b.name ? -1 : 1;\n\t\t} );\n\n\t\t// Remove duplicate non-premium which can occur in Safari.\n\t\tconst voiceURIs = new Set( availableVoices.map( ( voice ) => voice.voiceURI ) );\n\t\tthis._availableVoices = availableVoices.filter( ( voice ) => {\n\t\t\treturn voice.voiceURI.endsWith( '.premium' ) || ! voiceURIs.has( voice.voiceURI + '.premium' );\n\t\t} );\n\n\t\treturn availableVoices;\n\t}\n\n\t/**\n\t * Get voice for each language.\n\t *\n\t * @return {Object<string, string>} Mapping of language to voiceURI.\n\t */\n\tgetLanguageVoices() {\n\t\tconst languageVoices = {};\n\t\tfor ( const voice of this.getAvailableVoices() ) {\n\t\t\tconst lang = voice.lang.replace( /-.*/, '' );\n\t\t\tif ( voice.default || ! ( lang in languageVoices ) ) {\n\t\t\t\tlanguageVoices[ lang ] = voice.voiceURI;\n\t\t\t}\n\t\t}\n\t\tObject.assign( languageVoices, this.state.languageVoices );\n\t\treturn languageVoices;\n\t}\n\n\t/**\n\t * Render controls.\n\t */\n\trenderControls() {\n\t\tconst weightedLanguages = getWeightedChunkLanguages( this.chunks );\n\t\tconst presentLanguages = Object.keys( weightedLanguages );\n\t\tpresentLanguages.sort( ( a, b ) => {\n\t\t\treturn weightedLanguages[ b ] - weightedLanguages[ a ];\n\t\t} );\n\n\t\tconst props = Object.assign(\n\t\t\t{},\n\t\t\tthis.state,\n\t\t\t{\n\t\t\t\tplay: this.play,\n\t\t\t\tstop: this.stop,\n\t\t\t\tnext: this.next,\n\t\t\t\tprevious: this.previous,\n\t\t\t\tuseDashicons: this.useDashicons,\n\t\t\t\tonShowSettings: () => {\n\t\t\t\t\tthis.setState( { settingsShown: true } );\n\t\t\t\t},\n\t\t\t\tonHideSettings: () => {\n\t\t\t\t\tthis.setState( { settingsShown: false } );\n\t\t\t\t},\n\t\t\t\tpresentLanguages,\n\t\t\t\tavailableVoices: this.getAvailableVoices(),\n\t\t\t\tlanguageVoices: this.getLanguageVoices(),\n\t\t\t\tsetProps: ( updatedProps ) => {\n\t\t\t\t\tthis.setState( updatedProps );\n\t\t\t\t},\n\t\t\t\tisDialogSupported: this.isDialogSupported,\n\t\t\t}\n\t\t);\n\t\trender( <PlaybackControls { ...props } />, this.controlsElement );\n\t}\n\n\t/**\n\t * Get voice.\n\t *\n\t * @todo Allow different voices for quotations and headings.\n\t * @param {Chunk} chunk - Chunk\n\t * @returns {Object} Props for voice, pitch, and rate.\n\t */\n\tgetUtteranceOptions( chunk ) {\n\t\tconst props = {\n\t\t\tpitch: this.state.pitch,\n\t\t\trate: this.state.rate,\n\t\t};\n\t\tif ( chunk.language ) {\n\t\t\tprops.voice = this.getVoice( chunk );\n\t\t\tprops.lang = chunk.language; // @todo This doesn't work at all in Safari.\n\t\t}\n\t\treturn props;\n\t}\n\n\t/**\n\t * Get voice for chunk.\n\t *\n\t * @param {Chunk} chunk - Speech chunk.\n\t * @return {SpeechSynthesisVoice|null} Voice.\n\t */\n\tgetVoice( chunk ) {\n\t\tconst languageVoices = this.getLanguageVoices();\n\t\tconst baseLanguage = chunk.language.replace( /-.*/, '' ).toLowerCase();\n\t\tlet resultingVoice = speechSynthesis.getVoices().find(\n\t\t\t( voice ) => voice.voiceURI === languageVoices[ baseLanguage ]\n\t\t);\n\t\tif ( ! resultingVoice ) {\n\t\t\tresultingVoice = speechSynthesis.getVoices().find(\n\t\t\t\t( voice ) => voice.lang.startsWith( baseLanguage )\n\t\t\t);\n\t\t}\n\t\treturn resultingVoice;\n\t}\n\n\t/**\n\t * Speak chunk.\n\t *\n\t * @returns {Promise} Resolves when completed.\n\t */\n\tspeakChunk() {\n\t\tconst chunkIndex = this.state.chunkIndex;\n\t\treturn new Promise( ( resolve, reject ) => {\n\t\t\tconst chunk = this.chunks[ chunkIndex ];\n\t\t\tif ( ! chunk ) {\n\t\t\t\treject();\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst selection = window.getSelection();\n\t\t\tconst range = document.createRange();\n\n\t\t\t// Obtain the text nodes to read, skipping every chunk node that is completely read and calculating the skip distance.\n\t\t\tlet initialSkippedNodesLength = 0;\n\t\t\tconst nextNodes = [ ...chunk.nodes ];\n\t\t\twhile ( nextNodes[ 0 ] && initialSkippedNodesLength + nextNodes[ 0 ].length < this.state.chunkRangeOffset ) {\n\t\t\t\tinitialSkippedNodesLength += nextNodes.shift().length;\n\t\t\t}\n\n\t\t\t// Obtain the text to read.\n\t\t\tconst firstNodeOffset = this.state.chunkRangeOffset - initialSkippedNodesLength;\n\t\t\tlet currentTextNode = nextNodes.shift();\n\t\t\tconst text = [\n\t\t\t\tcurrentTextNode.nodeValue.substr( firstNodeOffset ),\n\t\t\t].concat(\n\t\t\t\tnextNodes.map( ( textNode ) => textNode.nodeValue )\n\t\t\t).join( '' );\n\n\t\t\tif ( ! text.trim() ) {\n\t\t\t\tresolve();\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.currentUtterance = new SpeechSynthesisUtterance( text );\n\t\t\tObject.assign( this.currentUtterance, this.getUtteranceOptions( chunk ) );\n\n\t\t\t// Make sure the app state matches the utterance state if it gets interacted with directly.\n\t\t\tthis.currentUtterance.onpause = () => this.setState( { playing: false } );\n\n\t\t\tlet previousSpokenNodesLength = 0;\n\t\t\tlet currentChunkRangeOffset = this.state.chunkRangeOffset;\n\n\t\t\t/**\n\t\t\t * On boundary change.\n\t\t\t *\n\t\t\t * @param {Event} event - Boundary event.\n\t\t\t * @param {string} event.name - Type of boundary.\n\t\t\t * @param {number} event.charIndex - Index in text which is being spoken.\n\t\t\t * @param {SpeechSynthesisUtterance} event.currentTarget - Current utterance.\n\t\t\t */\n\t\t\tthis.currentUtterance.onboundary = ( event ) => {\n\t\t\t\tif ( 'word' !== event.name ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// Keep track of the last word that was spoken.\n\t\t\t\tcurrentChunkRangeOffset = initialSkippedNodesLength + firstNodeOffset + event.charIndex;\n\t\t\t\tthis.setState(\n\t\t\t\t\t{ chunkRangeOffset: currentChunkRangeOffset },\n\t\t\t\t\t{ suppressEvents: true }\n\t\t\t\t);\n\n\t\t\t\tscrollElementIntoViewIfNeeded( currentTextNode.parentElement );\n\n\t\t\t\twhile ( nextNodes.length && event.charIndex + firstNodeOffset >= previousSpokenNodesLength + currentTextNode.length ) {\n\t\t\t\t\tpreviousSpokenNodesLength += currentTextNode.length;\n\t\t\t\t\tcurrentTextNode = nextNodes.shift();\n\t\t\t\t}\n\n\t\t\t\t// Skip highlighting if settings are shown.\n\t\t\t\tif ( ! this.state.settingsShown ) {\n\t\t\t\t\tconst startOffset = event.charIndex - previousSpokenNodesLength + firstNodeOffset;\n\n\t\t\t\t\t// This could be improved to better exclude punctuation, but this is very engine- and language-dependent.\n\t\t\t\t\tconst currentToken = event.currentTarget.text.substr( event.charIndex ).replace( /\\s.+/, '' );\n\n\t\t\t\t\t/*\n\t\t\t\t\t * Note: The token may span text nodes. If currentToken.length > currentTextNode.length then we have to\n\t\t\t\t\t * eventually start looping over nextNodes until we have enough nodes to select. It would be unusual\n\t\t\t\t\t * for a text node to be split in the middle of the word, so this is not currently accounted for.\n\t\t\t\t\t */\n\t\t\t\t\tselection.removeAllRanges();\n\t\t\t\t\trange.setStart( currentTextNode, startOffset );\n\t\t\t\t\trange.setEnd( currentTextNode, Math.min( startOffset + currentToken.length, currentTextNode.length ) );\n\t\t\t\t\tthis.playbackAddedRange = range;\n\t\t\t\t\tselection.addRange( range );\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t\t\t * Resolve or reject the promise when the utterance ends depending on why it ended.\n\t\t\t */\n\t\t\tconst onFinish = () => {\n\t\t\t\tthis.currentUtterance = null;\n\t\t\t\tif ( ! this.state.settingsShown ) {\n\t\t\t\t\tselection.removeAllRanges();\n\t\t\t\t}\n\n\t\t\t\tif ( this.voicePropChanged ) {\n\t\t\t\t\tthis.voicePropChanged = false;\n\t\t\t\t\treject( 'voice_prop_changed' );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( this.state.chunkIndex !== chunkIndex ) {\n\t\t\t\t\treject( 'chunk_change' );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( currentChunkRangeOffset !== this.state.chunkRangeOffset ) {\n\t\t\t\t\treject( 'chunk_change' );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( ! this.state.playing ) {\n\t\t\t\t\treject( 'playback_stopped' );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( 0 !== nextNodes.length ) {\n\t\t\t\t\treject( 'playback_interrupted' );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tresolve();\n\t\t\t};\n\n\t\t\tthis.currentUtterance.onend = onFinish;\n\n\t\t\t/**\n\t\t\t * Clear voicePropChanged flag when error event happens in Safari when changing voice during playback.\n\t\t\t *\n\t\t\t * Cancelling speech in Safari causes an error event to happen.\n\t\t\t */\n\t\t\tthis.currentUtterance.onerror = () => {\n\t\t\t\tif ( this.voicePropChanged ) {\n\t\t\t\t\tthis.voicePropChanged = false;\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tspeechSynthesis.speak( this.currentUtterance );\n\t\t} );\n\t}\n\n\t/**\n\t * Get chunk index for the current selected range.\n\t *\n\t * @param {Range} [range] - Range. Defaults to current selection range.\n\t * @returns {Object|null} Chunk index and char offset for current selection, or null if not selected.\n\t */\n\tgetChunkPositionFromRange( range = null ) {\n\t\tlet selectedRange = range;\n\t\tif ( ! selectedRange ) {\n\t\t\tconst selection = window.getSelection();\n\t\t\tif ( 1 !== selection.rangeCount ) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\tselectedRange = selection.getRangeAt( 0 );\n\t\t}\n\t\ttry {\n\t\t\tif ( selectedRange.startContainer.nodeType !== Node.TEXT_NODE ) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t} catch ( e ) {\n\t\t\treturn null; // Firefox sometimes errors with Permission denied to access property \"nodeType\".\n\t\t}\n\t\tfor ( let chunkIndex = 0; chunkIndex < this.chunks.length; chunkIndex++ ) {\n\t\t\tlet chunkRangeOffset = 0;\n\t\t\tfor ( const node of this.chunks[ chunkIndex ].nodes ) {\n\t\t\t\tif ( selectedRange.startContainer === node ) {\n\t\t\t\t\tchunkRangeOffset += selectedRange.startOffset;\n\t\t\t\t\treturn { chunkIndex, chunkRangeOffset };\n\t\t\t\t}\n\t\t\t\tchunkRangeOffset += node.length;\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n\n\t/**\n\t * Update containsSelection state based on whether range is inside of root element; update selected chunk position if user-selected range.\n\t */\n\tupdateContainsSelectionState() {\n\t\tconst selection = window.getSelection();\n\t\tif ( 0 !== selection.rangeCount ) {\n\t\t\tconst range = selection.getRangeAt( 0 );\n\t\t\tconst props = {\n\t\t\t\tcontainsSelection: false,\n\t\t\t};\n\t\t\ttry {\n\t\t\t\t// @todo Firefox Permission denied to access property \"nodeType\"\n\t\t\t\tprops.containsSelection = this.rootElement.contains( range.startContainer ) || this.rootElement.contains( range.endContainer );\n\t\t\t} catch ( e ) {\n\t\t\t\t// Firefox.\n\t\t\t}\n\n\t\t\t// Move current playback to newly selected range if not added programmatically.\n\t\t\tif ( this.state.playing && this.playbackAddedRange && ! equalRanges( range, this.playbackAddedRange ) ) {\n\t\t\t\tconst chunkSelection = this.getChunkPositionFromRange( range );\n\t\t\t\tif ( chunkSelection ) {\n\t\t\t\t\tObject.assign( props, chunkSelection );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tthis.setState( props );\n\t\t}\n\t}\n\n\t/**\n\t * Handle keydown event for Escape key press to stop playback (unless the settings are shown, as ESC closes them).\n\t *\n\t * @param {Event} event - The keydown event.\n\t */\n\thandleEscapeKeydown( event ) {\n\t\tif ( this.state.playing && ESCAPE_KEY_CODE === event.which && ! this.state.settingsShown ) {\n\t\t\tthis.stop();\n\t\t}\n\t}\n\n\t/**\n\t * Play content.\n\t *\n\t * @returns {void}\n\t */\n\tplay() {\n\t\tconst props = {\n\t\t\tplaying: true,\n\t\t};\n\n\t\tconst chunkSelection = this.getChunkPositionFromRange();\n\t\tif ( chunkSelection ) {\n\t\t\tObject.assign( props, chunkSelection );\n\t\t} else if ( this.state.chunkIndex + 1 === this.chunks.length ) { // @todo This needs to also account for chunkRangeOffset.\n\t\t\tprops.chunkIndex = 0;\n\t\t\tprops.chunkRangeOffset = 0;\n\t\t}\n\t\tthis.setState( props );\n\t}\n\n\t/**\n\t * Get inter-chunk reading pause.\n\t *\n\t * @param {Chunk} thisChunk - Current chunk.\n\t * @param {Chunk} nextChunk - Next chunk.\n\t * @return {number} Milliseconds to pause between speaking chunks.\n\t */\n\tgetInterChunkPause( thisChunk, nextChunk ) {\n\t\tif ( thisChunk.root !== nextChunk.root ) {\n\t\t\tif ( thisChunk.root.matches( HEADING_SELECTOR ) || nextChunk.root.matches( HEADING_SELECTOR ) ) {\n\t\t\t\treturn this.pauseDurations.heading; // @todo Let the heading level also very the pause?\n\t\t\t} else if ( thisChunk.root.matches( PARAGRAPH_PAUSE_SELECTOR ) || nextChunk.root.matches( PARAGRAPH_PAUSE_SELECTOR ) ) {\n\t\t\t\treturn this.pauseDurations.paragraph;\n\t\t\t}\n\t\t}\n\t\treturn 0;\n\t}\n\n\t/**\n\t * Start playing current chunk and queue playing the next.\n\t */\n\tstartPlayingCurrentChunkAndQueueNext() {\n\t\tclearTimeout( this.state.speakTimeoutId );\n\n\t\tconst reject = ( reason ) => {\n\t\t\tif ( ! reason || 'playback_interrupted' === reason || 'playback_completed' === reason ) {\n\t\t\t\tthis.setState( { playing: false } );\n\t\t\t}\n\t\t};\n\n\t\tconst speakingStoppedPromise = new Promise( ( resolve ) => {\n\t\t\t// Wait for cancelled speaking to be confirmed to be ended. Needed in Chrome.\n\t\t\tif ( speechSynthesis.speaking ) {\n\t\t\t\tconst CANCEL_WAIT_TIMEOUT = 100;\n\t\t\t\tif ( this.currentUtterance ) {\n\t\t\t\t\tthis.currentUtterance.addEventListener( 'end', resolve );\n\t\t\t\t}\n\t\t\t\tsetTimeout( resolve, CANCEL_WAIT_TIMEOUT );\n\t\t\t\tspeechSynthesis.cancel();\n\t\t\t} else {\n\t\t\t\tresolve();\n\t\t\t}\n\t\t} );\n\n\t\tconst queueNextChunk = () => {\n\t\t\tif ( this.state.chunkIndex + 1 === this.chunks.length ) {\n\t\t\t\treject( 'playback_completed' );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst thisChunk = this.chunks[ this.state.chunkIndex ];\n\t\t\tconst nextChunk = this.chunks[ this.state.chunkIndex + 1 ];\n\t\t\tconst pauseDuration = this.getInterChunkPause( thisChunk, nextChunk );\n\t\t\tconst currentChunk = this.state.chunkIndex;\n\t\t\tthis.setState( {\n\t\t\t\tspeakTimeoutId: setTimeout( () => {\n\t\t\t\t\tthis.setState( {\n\t\t\t\t\t\tchunkIndex: currentChunk + 1, // This state change will cause startPlayingCurrentChunkAndQueueNext to be called.\n\t\t\t\t\t\tchunkRangeOffset: 0, // Start at beginning of chunk.\n\t\t\t\t\t} );\n\t\t\t\t}, Math.round( pauseDuration * ( 1 / this.state.rate ) ) ),\n\t\t\t} );\n\t\t};\n\n\t\t// Make sure voices are loaded and speech synthesis has been completely stopped (since cancel is apparently async).\n\t\tPromise.all( [ voices.load(), speakingStoppedPromise ] ).then( () => {\n\t\t\tthis.setState( {\n\t\t\t\tspeakTimeoutId: setTimeout( () => {\n\t\t\t\t\tthis.speakChunk().then( queueNextChunk, reject );\n\t\t\t\t} ),\n\t\t\t} );\n\t\t}, reject );\n\t}\n\n\t/**\n\t * Go to previous chunk and play.\n\t */\n\tprevious() {\n\t\tconst props = {\n\t\t\tchunkRangeOffset: 0,\n\t\t};\n\n\t\t// Only move to previous chunk if already at beginning of this chunk.\n\t\tif ( this.state.chunkRangeOffset < CHUNK_BEGINNING_OFFSET_THRESHOLD ) {\n\t\t\tprops.chunkIndex = Math.max( this.state.chunkIndex - 1, 0 );\n\t\t}\n\n\t\tthis.setState( props );\n\t}\n\n\t/**\n\t * Go to next chunk and play, or just stop if at the end.\n\t */\n\tnext() {\n\t\tif ( this.state.chunkIndex + 1 === this.chunks.length ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst props = {\n\t\t\tchunkIndex: this.state.chunkIndex + 1,\n\t\t\tchunkRangeOffset: 0,\n\t\t};\n\t\tthis.setState( props );\n\t}\n\n\t/**\n\t * Stop speaking utterance.\n\t */\n\tstop() {\n\t\tthis.setState( { playing: false } );\n\t}\n\n\t/**\n\t * Destroy speech.\n\t */\n\tdestroy() {\n\t\tif ( this.state.playing ) {\n\t\t\tspeechSynthesis.cancel();\n\t\t}\n\t\tdocument.removeEventListener( 'selectionchange', this.updateContainsSelectionState );\n\t\tdocument.removeEventListener( 'keydown', this.handleEscapeKeydown );\n\t\tunmountComponentAtNode( this.controlsElement );\n\t}\n}\n\nEventEmitter( Speech.prototype );\n\n\n\n// WEBPACK FOOTER //\n// ./src/speech.js","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/process/browser.js\n// module id = 30\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar invariant = require('fbjs/lib/invariant');\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    invariant(\n      false,\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim\n  };\n\n  ReactPropTypes.checkPropTypes = emptyFunction;\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/prop-types/factoryWithThrowingShims.js\n// module id = 31\n// module chunks = 0","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nfunction makeEmptyFunction(arg) {\n  return function () {\n    return arg;\n  };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nvar emptyFunction = function emptyFunction() {};\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function () {\n  return this;\n};\nemptyFunction.thatReturnsArgument = function (arg) {\n  return arg;\n};\n\nmodule.exports = emptyFunction;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/emptyFunction.js\n// module id = 32\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar validateFormat = function validateFormat(format) {};\n\nif (process.env.NODE_ENV !== 'production') {\n  validateFormat = function validateFormat(format) {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  };\n}\n\nfunction invariant(condition, format, a, b, c, d, e, f) {\n  validateFormat(format);\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(format.replace(/%s/g, function () {\n        return args[argIndex++];\n      }));\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n}\n\nmodule.exports = invariant;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/invariant.js\n// module id = 33\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/prop-types/lib/ReactPropTypesSecret.js\n// module id = 34\n// module chunks = 0","/** Virtual DOM Node */\nfunction VNode() {}\n\n/** Global options\n *\t@public\n *\t@namespace options {Object}\n */\nvar options = {\n\n\t/** If `true`, `prop` changes trigger synchronous component updates.\n  *\t@name syncComponentUpdates\n  *\t@type Boolean\n  *\t@default true\n  */\n\t//syncComponentUpdates: true,\n\n\t/** Processes all created VNodes.\n  *\t@param {VNode} vnode\tA newly-created VNode to normalize/process\n  */\n\t//vnode(vnode) { }\n\n\t/** Hook invoked after a component is mounted. */\n\t// afterMount(component) { }\n\n\t/** Hook invoked after the DOM is updated with a component's latest render. */\n\t// afterUpdate(component) { }\n\n\t/** Hook invoked immediately before a component is unmounted. */\n\t// beforeUnmount(component) { }\n};\n\nvar stack = [];\n\nvar EMPTY_CHILDREN = [];\n\n/**\n * JSX/hyperscript reviver.\n * @see http://jasonformat.com/wtf-is-jsx\n * Benchmarks: https://esbench.com/bench/57ee8f8e330ab09900a1a1a0\n *\n * Note: this is exported as both `h()` and `createElement()` for compatibility reasons.\n *\n * Creates a VNode (virtual DOM element). A tree of VNodes can be used as a lightweight representation\n * of the structure of a DOM tree. This structure can be realized by recursively comparing it against\n * the current _actual_ DOM structure, and applying only the differences.\n *\n * `h()`/`createElement()` accepts an element name, a list of attributes/props,\n * and optionally children to append to the element.\n *\n * @example The following DOM tree\n *\n * `<div id=\"foo\" name=\"bar\">Hello!</div>`\n *\n * can be constructed using this function as:\n *\n * `h('div', { id: 'foo', name : 'bar' }, 'Hello!');`\n *\n * @param {string} nodeName\tAn element name. Ex: `div`, `a`, `span`, etc.\n * @param {Object} attributes\tAny attributes/props to set on the created element.\n * @param rest\t\t\tAdditional arguments are taken to be children to append. Can be infinitely nested Arrays.\n *\n * @public\n */\nfunction h(nodeName, attributes) {\n\tvar children = EMPTY_CHILDREN,\n\t    lastSimple,\n\t    child,\n\t    simple,\n\t    i;\n\tfor (i = arguments.length; i-- > 2;) {\n\t\tstack.push(arguments[i]);\n\t}\n\tif (attributes && attributes.children != null) {\n\t\tif (!stack.length) stack.push(attributes.children);\n\t\tdelete attributes.children;\n\t}\n\twhile (stack.length) {\n\t\tif ((child = stack.pop()) && child.pop !== undefined) {\n\t\t\tfor (i = child.length; i--;) {\n\t\t\t\tstack.push(child[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tif (typeof child === 'boolean') child = null;\n\n\t\t\tif (simple = typeof nodeName !== 'function') {\n\t\t\t\tif (child == null) child = '';else if (typeof child === 'number') child = String(child);else if (typeof child !== 'string') simple = false;\n\t\t\t}\n\n\t\t\tif (simple && lastSimple) {\n\t\t\t\tchildren[children.length - 1] += child;\n\t\t\t} else if (children === EMPTY_CHILDREN) {\n\t\t\t\tchildren = [child];\n\t\t\t} else {\n\t\t\t\tchildren.push(child);\n\t\t\t}\n\n\t\t\tlastSimple = simple;\n\t\t}\n\t}\n\n\tvar p = new VNode();\n\tp.nodeName = nodeName;\n\tp.children = children;\n\tp.attributes = attributes == null ? undefined : attributes;\n\tp.key = attributes == null ? undefined : attributes.key;\n\n\t// if a \"vnode hook\" is defined, pass every created VNode to it\n\tif (options.vnode !== undefined) options.vnode(p);\n\n\treturn p;\n}\n\n/**\n *  Copy all properties from `props` onto `obj`.\n *  @param {Object} obj\t\tObject onto which properties should be copied.\n *  @param {Object} props\tObject from which to copy properties.\n *  @returns obj\n *  @private\n */\nfunction extend(obj, props) {\n  for (var i in props) {\n    obj[i] = props[i];\n  }return obj;\n}\n\n/**\n * Call a function asynchronously, as soon as possible. Makes\n * use of HTML Promise to schedule the callback if available,\n * otherwise falling back to `setTimeout` (mainly for IE<11).\n *\n * @param {Function} callback\n */\nvar defer = typeof Promise == 'function' ? Promise.resolve().then.bind(Promise.resolve()) : setTimeout;\n\n/**\n * Clones the given VNode, optionally adding attributes/props and replacing its children.\n * @param {VNode} vnode\t\tThe virutal DOM element to clone\n * @param {Object} props\tAttributes/props to add when cloning\n * @param {VNode} rest\t\tAny additional arguments will be used as replacement children.\n */\nfunction cloneElement(vnode, props) {\n  return h(vnode.nodeName, extend(extend({}, vnode.attributes), props), arguments.length > 2 ? [].slice.call(arguments, 2) : vnode.children);\n}\n\n// DOM properties that should NOT have \"px\" added when numeric\nvar IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;\n\n/** Managed queue of dirty components to be re-rendered */\n\nvar items = [];\n\nfunction enqueueRender(component) {\n\tif (!component._dirty && (component._dirty = true) && items.push(component) == 1) {\n\t\t(options.debounceRendering || defer)(rerender);\n\t}\n}\n\nfunction rerender() {\n\tvar p,\n\t    list = items;\n\titems = [];\n\twhile (p = list.pop()) {\n\t\tif (p._dirty) renderComponent(p);\n\t}\n}\n\n/**\n * Check if two nodes are equivalent.\n *\n * @param {Node} node\t\t\tDOM Node to compare\n * @param {VNode} vnode\t\t\tVirtual DOM node to compare\n * @param {boolean} [hyrdating=false]\tIf true, ignores component constructors when comparing.\n * @private\n */\nfunction isSameNodeType(node, vnode, hydrating) {\n  if (typeof vnode === 'string' || typeof vnode === 'number') {\n    return node.splitText !== undefined;\n  }\n  if (typeof vnode.nodeName === 'string') {\n    return !node._componentConstructor && isNamedNode(node, vnode.nodeName);\n  }\n  return hydrating || node._componentConstructor === vnode.nodeName;\n}\n\n/**\n * Check if an Element has a given nodeName, case-insensitively.\n *\n * @param {Element} node\tA DOM Element to inspect the name of.\n * @param {String} nodeName\tUnnormalized name to compare against.\n */\nfunction isNamedNode(node, nodeName) {\n  return node.normalizedNodeName === nodeName || node.nodeName.toLowerCase() === nodeName.toLowerCase();\n}\n\n/**\n * Reconstruct Component-style `props` from a VNode.\n * Ensures default/fallback values from `defaultProps`:\n * Own-properties of `defaultProps` not present in `vnode.attributes` are added.\n *\n * @param {VNode} vnode\n * @returns {Object} props\n */\nfunction getNodeProps(vnode) {\n  var props = extend({}, vnode.attributes);\n  props.children = vnode.children;\n\n  var defaultProps = vnode.nodeName.defaultProps;\n  if (defaultProps !== undefined) {\n    for (var i in defaultProps) {\n      if (props[i] === undefined) {\n        props[i] = defaultProps[i];\n      }\n    }\n  }\n\n  return props;\n}\n\n/** Create an element with the given nodeName.\n *\t@param {String} nodeName\n *\t@param {Boolean} [isSvg=false]\tIf `true`, creates an element within the SVG namespace.\n *\t@returns {Element} node\n */\nfunction createNode(nodeName, isSvg) {\n\tvar node = isSvg ? document.createElementNS('http://www.w3.org/2000/svg', nodeName) : document.createElement(nodeName);\n\tnode.normalizedNodeName = nodeName;\n\treturn node;\n}\n\n/** Remove a child node from its parent if attached.\n *\t@param {Element} node\t\tThe node to remove\n */\nfunction removeNode(node) {\n\tvar parentNode = node.parentNode;\n\tif (parentNode) parentNode.removeChild(node);\n}\n\n/** Set a named attribute on the given Node, with special behavior for some names and event handlers.\n *\tIf `value` is `null`, the attribute/handler will be removed.\n *\t@param {Element} node\tAn element to mutate\n *\t@param {string} name\tThe name/key to set, such as an event or attribute name\n *\t@param {any} old\tThe last value that was set for this name/node pair\n *\t@param {any} value\tAn attribute value, such as a function to be used as an event handler\n *\t@param {Boolean} isSvg\tAre we currently diffing inside an svg?\n *\t@private\n */\nfunction setAccessor(node, name, old, value, isSvg) {\n\tif (name === 'className') name = 'class';\n\n\tif (name === 'key') {\n\t\t// ignore\n\t} else if (name === 'ref') {\n\t\tif (old) old(null);\n\t\tif (value) value(node);\n\t} else if (name === 'class' && !isSvg) {\n\t\tnode.className = value || '';\n\t} else if (name === 'style') {\n\t\tif (!value || typeof value === 'string' || typeof old === 'string') {\n\t\t\tnode.style.cssText = value || '';\n\t\t}\n\t\tif (value && typeof value === 'object') {\n\t\t\tif (typeof old !== 'string') {\n\t\t\t\tfor (var i in old) {\n\t\t\t\t\tif (!(i in value)) node.style[i] = '';\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (var i in value) {\n\t\t\t\tnode.style[i] = typeof value[i] === 'number' && IS_NON_DIMENSIONAL.test(i) === false ? value[i] + 'px' : value[i];\n\t\t\t}\n\t\t}\n\t} else if (name === 'dangerouslySetInnerHTML') {\n\t\tif (value) node.innerHTML = value.__html || '';\n\t} else if (name[0] == 'o' && name[1] == 'n') {\n\t\tvar useCapture = name !== (name = name.replace(/Capture$/, ''));\n\t\tname = name.toLowerCase().substring(2);\n\t\tif (value) {\n\t\t\tif (!old) node.addEventListener(name, eventProxy, useCapture);\n\t\t} else {\n\t\t\tnode.removeEventListener(name, eventProxy, useCapture);\n\t\t}\n\t\t(node._listeners || (node._listeners = {}))[name] = value;\n\t} else if (name !== 'list' && name !== 'type' && !isSvg && name in node) {\n\t\tsetProperty(node, name, value == null ? '' : value);\n\t\tif (value == null || value === false) node.removeAttribute(name);\n\t} else {\n\t\tvar ns = isSvg && name !== (name = name.replace(/^xlink\\:?/, ''));\n\t\tif (value == null || value === false) {\n\t\t\tif (ns) node.removeAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase());else node.removeAttribute(name);\n\t\t} else if (typeof value !== 'function') {\n\t\t\tif (ns) node.setAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase(), value);else node.setAttribute(name, value);\n\t\t}\n\t}\n}\n\n/** Attempt to set a DOM property to the given value.\n *\tIE & FF throw for certain property-value combinations.\n */\nfunction setProperty(node, name, value) {\n\ttry {\n\t\tnode[name] = value;\n\t} catch (e) {}\n}\n\n/** Proxy an event to hooked event handlers\n *\t@private\n */\nfunction eventProxy(e) {\n\treturn this._listeners[e.type](options.event && options.event(e) || e);\n}\n\n/** Queue of components that have been mounted and are awaiting componentDidMount */\nvar mounts = [];\n\n/** Diff recursion count, used to track the end of the diff cycle. */\nvar diffLevel = 0;\n\n/** Global flag indicating if the diff is currently within an SVG */\nvar isSvgMode = false;\n\n/** Global flag indicating if the diff is performing hydration */\nvar hydrating = false;\n\n/** Invoke queued componentDidMount lifecycle methods */\nfunction flushMounts() {\n\tvar c;\n\twhile (c = mounts.pop()) {\n\t\tif (options.afterMount) options.afterMount(c);\n\t\tif (c.componentDidMount) c.componentDidMount();\n\t}\n}\n\n/** Apply differences in a given vnode (and it's deep children) to a real DOM Node.\n *\t@param {Element} [dom=null]\t\tA DOM node to mutate into the shape of the `vnode`\n *\t@param {VNode} vnode\t\t\tA VNode (with descendants forming a tree) representing the desired DOM structure\n *\t@returns {Element} dom\t\t\tThe created/mutated element\n *\t@private\n */\nfunction diff(dom, vnode, context, mountAll, parent, componentRoot) {\n\t// diffLevel having been 0 here indicates initial entry into the diff (not a subdiff)\n\tif (!diffLevel++) {\n\t\t// when first starting the diff, check if we're diffing an SVG or within an SVG\n\t\tisSvgMode = parent != null && parent.ownerSVGElement !== undefined;\n\n\t\t// hydration is indicated by the existing element to be diffed not having a prop cache\n\t\thydrating = dom != null && !('__preactattr_' in dom);\n\t}\n\n\tvar ret = idiff(dom, vnode, context, mountAll, componentRoot);\n\n\t// append the element if its a new parent\n\tif (parent && ret.parentNode !== parent) parent.appendChild(ret);\n\n\t// diffLevel being reduced to 0 means we're exiting the diff\n\tif (! --diffLevel) {\n\t\thydrating = false;\n\t\t// invoke queued componentDidMount lifecycle methods\n\t\tif (!componentRoot) flushMounts();\n\t}\n\n\treturn ret;\n}\n\n/** Internals of `diff()`, separated to allow bypassing diffLevel / mount flushing. */\nfunction idiff(dom, vnode, context, mountAll, componentRoot) {\n\tvar out = dom,\n\t    prevSvgMode = isSvgMode;\n\n\t// empty values (null, undefined, booleans) render as empty Text nodes\n\tif (vnode == null || typeof vnode === 'boolean') vnode = '';\n\n\t// Fast case: Strings & Numbers create/update Text nodes.\n\tif (typeof vnode === 'string' || typeof vnode === 'number') {\n\n\t\t// update if it's already a Text node:\n\t\tif (dom && dom.splitText !== undefined && dom.parentNode && (!dom._component || componentRoot)) {\n\t\t\t/* istanbul ignore if */ /* Browser quirk that can't be covered: https://github.com/developit/preact/commit/fd4f21f5c45dfd75151bd27b4c217d8003aa5eb9 */\n\t\t\tif (dom.nodeValue != vnode) {\n\t\t\t\tdom.nodeValue = vnode;\n\t\t\t}\n\t\t} else {\n\t\t\t// it wasn't a Text node: replace it with one and recycle the old Element\n\t\t\tout = document.createTextNode(vnode);\n\t\t\tif (dom) {\n\t\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\t\t\t\trecollectNodeTree(dom, true);\n\t\t\t}\n\t\t}\n\n\t\tout['__preactattr_'] = true;\n\n\t\treturn out;\n\t}\n\n\t// If the VNode represents a Component, perform a component diff:\n\tvar vnodeName = vnode.nodeName;\n\tif (typeof vnodeName === 'function') {\n\t\treturn buildComponentFromVNode(dom, vnode, context, mountAll);\n\t}\n\n\t// Tracks entering and exiting SVG namespace when descending through the tree.\n\tisSvgMode = vnodeName === 'svg' ? true : vnodeName === 'foreignObject' ? false : isSvgMode;\n\n\t// If there's no existing element or it's the wrong type, create a new one:\n\tvnodeName = String(vnodeName);\n\tif (!dom || !isNamedNode(dom, vnodeName)) {\n\t\tout = createNode(vnodeName, isSvgMode);\n\n\t\tif (dom) {\n\t\t\t// move children into the replacement node\n\t\t\twhile (dom.firstChild) {\n\t\t\t\tout.appendChild(dom.firstChild);\n\t\t\t} // if the previous Element was mounted into the DOM, replace it inline\n\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\n\t\t\t// recycle the old element (skips non-Element node types)\n\t\t\trecollectNodeTree(dom, true);\n\t\t}\n\t}\n\n\tvar fc = out.firstChild,\n\t    props = out['__preactattr_'],\n\t    vchildren = vnode.children;\n\n\tif (props == null) {\n\t\tprops = out['__preactattr_'] = {};\n\t\tfor (var a = out.attributes, i = a.length; i--;) {\n\t\t\tprops[a[i].name] = a[i].value;\n\t\t}\n\t}\n\n\t// Optimization: fast-path for elements containing a single TextNode:\n\tif (!hydrating && vchildren && vchildren.length === 1 && typeof vchildren[0] === 'string' && fc != null && fc.splitText !== undefined && fc.nextSibling == null) {\n\t\tif (fc.nodeValue != vchildren[0]) {\n\t\t\tfc.nodeValue = vchildren[0];\n\t\t}\n\t}\n\t// otherwise, if there are existing or new children, diff them:\n\telse if (vchildren && vchildren.length || fc != null) {\n\t\t\tinnerDiffNode(out, vchildren, context, mountAll, hydrating || props.dangerouslySetInnerHTML != null);\n\t\t}\n\n\t// Apply attributes/props from VNode to the DOM Element:\n\tdiffAttributes(out, vnode.attributes, props);\n\n\t// restore previous SVG mode: (in case we're exiting an SVG namespace)\n\tisSvgMode = prevSvgMode;\n\n\treturn out;\n}\n\n/** Apply child and attribute changes between a VNode and a DOM Node to the DOM.\n *\t@param {Element} dom\t\t\tElement whose children should be compared & mutated\n *\t@param {Array} vchildren\t\tArray of VNodes to compare to `dom.childNodes`\n *\t@param {Object} context\t\t\tImplicitly descendant context object (from most recent `getChildContext()`)\n *\t@param {Boolean} mountAll\n *\t@param {Boolean} isHydrating\tIf `true`, consumes externally created elements similar to hydration\n */\nfunction innerDiffNode(dom, vchildren, context, mountAll, isHydrating) {\n\tvar originalChildren = dom.childNodes,\n\t    children = [],\n\t    keyed = {},\n\t    keyedLen = 0,\n\t    min = 0,\n\t    len = originalChildren.length,\n\t    childrenLen = 0,\n\t    vlen = vchildren ? vchildren.length : 0,\n\t    j,\n\t    c,\n\t    f,\n\t    vchild,\n\t    child;\n\n\t// Build up a map of keyed children and an Array of unkeyed children:\n\tif (len !== 0) {\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tvar _child = originalChildren[i],\n\t\t\t    props = _child['__preactattr_'],\n\t\t\t    key = vlen && props ? _child._component ? _child._component.__key : props.key : null;\n\t\t\tif (key != null) {\n\t\t\t\tkeyedLen++;\n\t\t\t\tkeyed[key] = _child;\n\t\t\t} else if (props || (_child.splitText !== undefined ? isHydrating ? _child.nodeValue.trim() : true : isHydrating)) {\n\t\t\t\tchildren[childrenLen++] = _child;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (vlen !== 0) {\n\t\tfor (var i = 0; i < vlen; i++) {\n\t\t\tvchild = vchildren[i];\n\t\t\tchild = null;\n\n\t\t\t// attempt to find a node based on key matching\n\t\t\tvar key = vchild.key;\n\t\t\tif (key != null) {\n\t\t\t\tif (keyedLen && keyed[key] !== undefined) {\n\t\t\t\t\tchild = keyed[key];\n\t\t\t\t\tkeyed[key] = undefined;\n\t\t\t\t\tkeyedLen--;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// attempt to pluck a node of the same type from the existing children\n\t\t\telse if (!child && min < childrenLen) {\n\t\t\t\t\tfor (j = min; j < childrenLen; j++) {\n\t\t\t\t\t\tif (children[j] !== undefined && isSameNodeType(c = children[j], vchild, isHydrating)) {\n\t\t\t\t\t\t\tchild = c;\n\t\t\t\t\t\t\tchildren[j] = undefined;\n\t\t\t\t\t\t\tif (j === childrenLen - 1) childrenLen--;\n\t\t\t\t\t\t\tif (j === min) min++;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// morph the matched/found/created DOM child to match vchild (deep)\n\t\t\tchild = idiff(child, vchild, context, mountAll);\n\n\t\t\tf = originalChildren[i];\n\t\t\tif (child && child !== dom && child !== f) {\n\t\t\t\tif (f == null) {\n\t\t\t\t\tdom.appendChild(child);\n\t\t\t\t} else if (child === f.nextSibling) {\n\t\t\t\t\tremoveNode(f);\n\t\t\t\t} else {\n\t\t\t\t\tdom.insertBefore(child, f);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// remove unused keyed children:\n\tif (keyedLen) {\n\t\tfor (var i in keyed) {\n\t\t\tif (keyed[i] !== undefined) recollectNodeTree(keyed[i], false);\n\t\t}\n\t}\n\n\t// remove orphaned unkeyed children:\n\twhile (min <= childrenLen) {\n\t\tif ((child = children[childrenLen--]) !== undefined) recollectNodeTree(child, false);\n\t}\n}\n\n/** Recursively recycle (or just unmount) a node and its descendants.\n *\t@param {Node} node\t\t\t\t\t\tDOM node to start unmount/removal from\n *\t@param {Boolean} [unmountOnly=false]\tIf `true`, only triggers unmount lifecycle, skips removal\n */\nfunction recollectNodeTree(node, unmountOnly) {\n\tvar component = node._component;\n\tif (component) {\n\t\t// if node is owned by a Component, unmount that component (ends up recursing back here)\n\t\tunmountComponent(component);\n\t} else {\n\t\t// If the node's VNode had a ref function, invoke it with null here.\n\t\t// (this is part of the React spec, and smart for unsetting references)\n\t\tif (node['__preactattr_'] != null && node['__preactattr_'].ref) node['__preactattr_'].ref(null);\n\n\t\tif (unmountOnly === false || node['__preactattr_'] == null) {\n\t\t\tremoveNode(node);\n\t\t}\n\n\t\tremoveChildren(node);\n\t}\n}\n\n/** Recollect/unmount all children.\n *\t- we use .lastChild here because it causes less reflow than .firstChild\n *\t- it's also cheaper than accessing the .childNodes Live NodeList\n */\nfunction removeChildren(node) {\n\tnode = node.lastChild;\n\twhile (node) {\n\t\tvar next = node.previousSibling;\n\t\trecollectNodeTree(node, true);\n\t\tnode = next;\n\t}\n}\n\n/** Apply differences in attributes from a VNode to the given DOM Element.\n *\t@param {Element} dom\t\tElement with attributes to diff `attrs` against\n *\t@param {Object} attrs\t\tThe desired end-state key-value attribute pairs\n *\t@param {Object} old\t\t\tCurrent/previous attributes (from previous VNode or element's prop cache)\n */\nfunction diffAttributes(dom, attrs, old) {\n\tvar name;\n\n\t// remove attributes no longer present on the vnode by setting them to undefined\n\tfor (name in old) {\n\t\tif (!(attrs && attrs[name] != null) && old[name] != null) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = undefined, isSvgMode);\n\t\t}\n\t}\n\n\t// add new & update changed attributes\n\tfor (name in attrs) {\n\t\tif (name !== 'children' && name !== 'innerHTML' && (!(name in old) || attrs[name] !== (name === 'value' || name === 'checked' ? dom[name] : old[name]))) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = attrs[name], isSvgMode);\n\t\t}\n\t}\n}\n\n/** Retains a pool of Components for re-use, keyed on component name.\n *\tNote: since component names are not unique or even necessarily available, these are primarily a form of sharding.\n *\t@private\n */\nvar components = {};\n\n/** Reclaim a component for later re-use by the recycler. */\nfunction collectComponent(component) {\n\tvar name = component.constructor.name;\n\t(components[name] || (components[name] = [])).push(component);\n}\n\n/** Create a component. Normalizes differences between PFC's and classful Components. */\nfunction createComponent(Ctor, props, context) {\n\tvar list = components[Ctor.name],\n\t    inst;\n\n\tif (Ctor.prototype && Ctor.prototype.render) {\n\t\tinst = new Ctor(props, context);\n\t\tComponent.call(inst, props, context);\n\t} else {\n\t\tinst = new Component(props, context);\n\t\tinst.constructor = Ctor;\n\t\tinst.render = doRender;\n\t}\n\n\tif (list) {\n\t\tfor (var i = list.length; i--;) {\n\t\t\tif (list[i].constructor === Ctor) {\n\t\t\t\tinst.nextBase = list[i].nextBase;\n\t\t\t\tlist.splice(i, 1);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\treturn inst;\n}\n\n/** The `.render()` method for a PFC backing instance. */\nfunction doRender(props, state, context) {\n\treturn this.constructor(props, context);\n}\n\n/** Set a component's `props` (generally derived from JSX attributes).\n *\t@param {Object} props\n *\t@param {Object} [opts]\n *\t@param {boolean} [opts.renderSync=false]\tIf `true` and {@link options.syncComponentUpdates} is `true`, triggers synchronous rendering.\n *\t@param {boolean} [opts.render=true]\t\t\tIf `false`, no render will be triggered.\n */\nfunction setComponentProps(component, props, opts, context, mountAll) {\n\tif (component._disable) return;\n\tcomponent._disable = true;\n\n\tif (component.__ref = props.ref) delete props.ref;\n\tif (component.__key = props.key) delete props.key;\n\n\tif (!component.base || mountAll) {\n\t\tif (component.componentWillMount) component.componentWillMount();\n\t} else if (component.componentWillReceiveProps) {\n\t\tcomponent.componentWillReceiveProps(props, context);\n\t}\n\n\tif (context && context !== component.context) {\n\t\tif (!component.prevContext) component.prevContext = component.context;\n\t\tcomponent.context = context;\n\t}\n\n\tif (!component.prevProps) component.prevProps = component.props;\n\tcomponent.props = props;\n\n\tcomponent._disable = false;\n\n\tif (opts !== 0) {\n\t\tif (opts === 1 || options.syncComponentUpdates !== false || !component.base) {\n\t\t\trenderComponent(component, 1, mountAll);\n\t\t} else {\n\t\t\tenqueueRender(component);\n\t\t}\n\t}\n\n\tif (component.__ref) component.__ref(component);\n}\n\n/** Render a Component, triggering necessary lifecycle events and taking High-Order Components into account.\n *\t@param {Component} component\n *\t@param {Object} [opts]\n *\t@param {boolean} [opts.build=false]\t\tIf `true`, component will build and store a DOM node if not already associated with one.\n *\t@private\n */\nfunction renderComponent(component, opts, mountAll, isChild) {\n\tif (component._disable) return;\n\n\tvar props = component.props,\n\t    state = component.state,\n\t    context = component.context,\n\t    previousProps = component.prevProps || props,\n\t    previousState = component.prevState || state,\n\t    previousContext = component.prevContext || context,\n\t    isUpdate = component.base,\n\t    nextBase = component.nextBase,\n\t    initialBase = isUpdate || nextBase,\n\t    initialChildComponent = component._component,\n\t    skip = false,\n\t    rendered,\n\t    inst,\n\t    cbase;\n\n\t// if updating\n\tif (isUpdate) {\n\t\tcomponent.props = previousProps;\n\t\tcomponent.state = previousState;\n\t\tcomponent.context = previousContext;\n\t\tif (opts !== 2 && component.shouldComponentUpdate && component.shouldComponentUpdate(props, state, context) === false) {\n\t\t\tskip = true;\n\t\t} else if (component.componentWillUpdate) {\n\t\t\tcomponent.componentWillUpdate(props, state, context);\n\t\t}\n\t\tcomponent.props = props;\n\t\tcomponent.state = state;\n\t\tcomponent.context = context;\n\t}\n\n\tcomponent.prevProps = component.prevState = component.prevContext = component.nextBase = null;\n\tcomponent._dirty = false;\n\n\tif (!skip) {\n\t\trendered = component.render(props, state, context);\n\n\t\t// context to pass to the child, can be updated via (grand-)parent component\n\t\tif (component.getChildContext) {\n\t\t\tcontext = extend(extend({}, context), component.getChildContext());\n\t\t}\n\n\t\tvar childComponent = rendered && rendered.nodeName,\n\t\t    toUnmount,\n\t\t    base;\n\n\t\tif (typeof childComponent === 'function') {\n\t\t\t// set up high order component link\n\n\t\t\tvar childProps = getNodeProps(rendered);\n\t\t\tinst = initialChildComponent;\n\n\t\t\tif (inst && inst.constructor === childComponent && childProps.key == inst.__key) {\n\t\t\t\tsetComponentProps(inst, childProps, 1, context, false);\n\t\t\t} else {\n\t\t\t\ttoUnmount = inst;\n\n\t\t\t\tcomponent._component = inst = createComponent(childComponent, childProps, context);\n\t\t\t\tinst.nextBase = inst.nextBase || nextBase;\n\t\t\t\tinst._parentComponent = component;\n\t\t\t\tsetComponentProps(inst, childProps, 0, context, false);\n\t\t\t\trenderComponent(inst, 1, mountAll, true);\n\t\t\t}\n\n\t\t\tbase = inst.base;\n\t\t} else {\n\t\t\tcbase = initialBase;\n\n\t\t\t// destroy high order component link\n\t\t\ttoUnmount = initialChildComponent;\n\t\t\tif (toUnmount) {\n\t\t\t\tcbase = component._component = null;\n\t\t\t}\n\n\t\t\tif (initialBase || opts === 1) {\n\t\t\t\tif (cbase) cbase._component = null;\n\t\t\t\tbase = diff(cbase, rendered, context, mountAll || !isUpdate, initialBase && initialBase.parentNode, true);\n\t\t\t}\n\t\t}\n\n\t\tif (initialBase && base !== initialBase && inst !== initialChildComponent) {\n\t\t\tvar baseParent = initialBase.parentNode;\n\t\t\tif (baseParent && base !== baseParent) {\n\t\t\t\tbaseParent.replaceChild(base, initialBase);\n\n\t\t\t\tif (!toUnmount) {\n\t\t\t\t\tinitialBase._component = null;\n\t\t\t\t\trecollectNodeTree(initialBase, false);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (toUnmount) {\n\t\t\tunmountComponent(toUnmount);\n\t\t}\n\n\t\tcomponent.base = base;\n\t\tif (base && !isChild) {\n\t\t\tvar componentRef = component,\n\t\t\t    t = component;\n\t\t\twhile (t = t._parentComponent) {\n\t\t\t\t(componentRef = t).base = base;\n\t\t\t}\n\t\t\tbase._component = componentRef;\n\t\t\tbase._componentConstructor = componentRef.constructor;\n\t\t}\n\t}\n\n\tif (!isUpdate || mountAll) {\n\t\tmounts.unshift(component);\n\t} else if (!skip) {\n\t\t// Ensure that pending componentDidMount() hooks of child components\n\t\t// are called before the componentDidUpdate() hook in the parent.\n\t\t// Note: disabled as it causes duplicate hooks, see https://github.com/developit/preact/issues/750\n\t\t// flushMounts();\n\n\t\tif (component.componentDidUpdate) {\n\t\t\tcomponent.componentDidUpdate(previousProps, previousState, previousContext);\n\t\t}\n\t\tif (options.afterUpdate) options.afterUpdate(component);\n\t}\n\n\tif (component._renderCallbacks != null) {\n\t\twhile (component._renderCallbacks.length) {\n\t\t\tcomponent._renderCallbacks.pop().call(component);\n\t\t}\n\t}\n\n\tif (!diffLevel && !isChild) flushMounts();\n}\n\n/** Apply the Component referenced by a VNode to the DOM.\n *\t@param {Element} dom\tThe DOM node to mutate\n *\t@param {VNode} vnode\tA Component-referencing VNode\n *\t@returns {Element} dom\tThe created/mutated element\n *\t@private\n */\nfunction buildComponentFromVNode(dom, vnode, context, mountAll) {\n\tvar c = dom && dom._component,\n\t    originalComponent = c,\n\t    oldDom = dom,\n\t    isDirectOwner = c && dom._componentConstructor === vnode.nodeName,\n\t    isOwner = isDirectOwner,\n\t    props = getNodeProps(vnode);\n\twhile (c && !isOwner && (c = c._parentComponent)) {\n\t\tisOwner = c.constructor === vnode.nodeName;\n\t}\n\n\tif (c && isOwner && (!mountAll || c._component)) {\n\t\tsetComponentProps(c, props, 3, context, mountAll);\n\t\tdom = c.base;\n\t} else {\n\t\tif (originalComponent && !isDirectOwner) {\n\t\t\tunmountComponent(originalComponent);\n\t\t\tdom = oldDom = null;\n\t\t}\n\n\t\tc = createComponent(vnode.nodeName, props, context);\n\t\tif (dom && !c.nextBase) {\n\t\t\tc.nextBase = dom;\n\t\t\t// passing dom/oldDom as nextBase will recycle it if unused, so bypass recycling on L229:\n\t\t\toldDom = null;\n\t\t}\n\t\tsetComponentProps(c, props, 1, context, mountAll);\n\t\tdom = c.base;\n\n\t\tif (oldDom && dom !== oldDom) {\n\t\t\toldDom._component = null;\n\t\t\trecollectNodeTree(oldDom, false);\n\t\t}\n\t}\n\n\treturn dom;\n}\n\n/** Remove a component from the DOM and recycle it.\n *\t@param {Component} component\tThe Component instance to unmount\n *\t@private\n */\nfunction unmountComponent(component) {\n\tif (options.beforeUnmount) options.beforeUnmount(component);\n\n\tvar base = component.base;\n\n\tcomponent._disable = true;\n\n\tif (component.componentWillUnmount) component.componentWillUnmount();\n\n\tcomponent.base = null;\n\n\t// recursively tear down & recollect high-order component children:\n\tvar inner = component._component;\n\tif (inner) {\n\t\tunmountComponent(inner);\n\t} else if (base) {\n\t\tif (base['__preactattr_'] && base['__preactattr_'].ref) base['__preactattr_'].ref(null);\n\n\t\tcomponent.nextBase = base;\n\n\t\tremoveNode(base);\n\t\tcollectComponent(component);\n\n\t\tremoveChildren(base);\n\t}\n\n\tif (component.__ref) component.__ref(null);\n}\n\n/** Base Component class.\n *\tProvides `setState()` and `forceUpdate()`, which trigger rendering.\n *\t@public\n *\n *\t@example\n *\tclass MyFoo extends Component {\n *\t\trender(props, state) {\n *\t\t\treturn <div />;\n *\t\t}\n *\t}\n */\nfunction Component(props, context) {\n\tthis._dirty = true;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.context = context;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.props = props;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.state = this.state || {};\n}\n\nextend(Component.prototype, {\n\n\t/** Returns a `boolean` indicating if the component should re-render when receiving the given `props` and `state`.\n  *\t@param {object} nextProps\n  *\t@param {object} nextState\n  *\t@param {object} nextContext\n  *\t@returns {Boolean} should the component re-render\n  *\t@name shouldComponentUpdate\n  *\t@function\n  */\n\n\t/** Update component state by copying properties from `state` to `this.state`.\n  *\t@param {object} state\t\tA hash of state properties to update with new values\n  *\t@param {function} callback\tA function to be called once component state is updated\n  */\n\tsetState: function setState(state, callback) {\n\t\tvar s = this.state;\n\t\tif (!this.prevState) this.prevState = extend({}, s);\n\t\textend(s, typeof state === 'function' ? state(s, this.props) : state);\n\t\tif (callback) (this._renderCallbacks = this._renderCallbacks || []).push(callback);\n\t\tenqueueRender(this);\n\t},\n\n\n\t/** Immediately perform a synchronous re-render of the component.\n  *\t@param {function} callback\t\tA function to be called after component is re-rendered.\n  *\t@private\n  */\n\tforceUpdate: function forceUpdate(callback) {\n\t\tif (callback) (this._renderCallbacks = this._renderCallbacks || []).push(callback);\n\t\trenderComponent(this, 2);\n\t},\n\n\n\t/** Accepts `props` and `state`, and returns a new Virtual DOM tree to build.\n  *\tVirtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).\n  *\t@param {object} props\t\tProps (eg: JSX attributes) received from parent element/component\n  *\t@param {object} state\t\tThe component's current state\n  *\t@param {object} context\t\tContext object (if a parent component has provided context)\n  *\t@returns VNode\n  */\n\trender: function render() {}\n});\n\n/** Render JSX into a `parent` Element.\n *\t@param {VNode} vnode\t\tA (JSX) VNode to render\n *\t@param {Element} parent\t\tDOM element to render into\n *\t@param {Element} [merge]\tAttempt to re-use an existing DOM tree rooted at `merge`\n *\t@public\n *\n *\t@example\n *\t// render a div into <body>:\n *\trender(<div id=\"hello\">hello!</div>, document.body);\n *\n *\t@example\n *\t// render a \"Thing\" component into #foo:\n *\tconst Thing = ({ name }) => <span>{ name }</span>;\n *\trender(<Thing name=\"one\" />, document.querySelector('#foo'));\n */\nfunction render(vnode, parent, merge) {\n  return diff(merge, vnode, {}, false, parent, false);\n}\n\nvar preact = {\n\th: h,\n\tcreateElement: h,\n\tcloneElement: cloneElement,\n\tComponent: Component,\n\trender: render,\n\trerender: rerender,\n\toptions: options\n};\n\nexport { h, h as createElement, cloneElement, Component, render, rerender, options };\nexport default preact;\n//# sourceMappingURL=preact.esm.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/preact/dist/preact.esm.js\n// module id = 35\n// module chunks = 0","'use strict';\n\nvar d        = require('d')\n  , callable = require('es5-ext/object/valid-callable')\n\n  , apply = Function.prototype.apply, call = Function.prototype.call\n  , create = Object.create, defineProperty = Object.defineProperty\n  , defineProperties = Object.defineProperties\n  , hasOwnProperty = Object.prototype.hasOwnProperty\n  , descriptor = { configurable: true, enumerable: false, writable: true }\n\n  , on, once, off, emit, methods, descriptors, base;\n\non = function (type, listener) {\n\tvar data;\n\n\tcallable(listener);\n\n\tif (!hasOwnProperty.call(this, '__ee__')) {\n\t\tdata = descriptor.value = create(null);\n\t\tdefineProperty(this, '__ee__', descriptor);\n\t\tdescriptor.value = null;\n\t} else {\n\t\tdata = this.__ee__;\n\t}\n\tif (!data[type]) data[type] = listener;\n\telse if (typeof data[type] === 'object') data[type].push(listener);\n\telse data[type] = [data[type], listener];\n\n\treturn this;\n};\n\nonce = function (type, listener) {\n\tvar once, self;\n\n\tcallable(listener);\n\tself = this;\n\ton.call(this, type, once = function () {\n\t\toff.call(self, type, once);\n\t\tapply.call(listener, this, arguments);\n\t});\n\n\tonce.__eeOnceListener__ = listener;\n\treturn this;\n};\n\noff = function (type, listener) {\n\tvar data, listeners, candidate, i;\n\n\tcallable(listener);\n\n\tif (!hasOwnProperty.call(this, '__ee__')) return this;\n\tdata = this.__ee__;\n\tif (!data[type]) return this;\n\tlisteners = data[type];\n\n\tif (typeof listeners === 'object') {\n\t\tfor (i = 0; (candidate = listeners[i]); ++i) {\n\t\t\tif ((candidate === listener) ||\n\t\t\t\t\t(candidate.__eeOnceListener__ === listener)) {\n\t\t\t\tif (listeners.length === 2) data[type] = listeners[i ? 0 : 1];\n\t\t\t\telse listeners.splice(i, 1);\n\t\t\t}\n\t\t}\n\t} else {\n\t\tif ((listeners === listener) ||\n\t\t\t\t(listeners.__eeOnceListener__ === listener)) {\n\t\t\tdelete data[type];\n\t\t}\n\t}\n\n\treturn this;\n};\n\nemit = function (type) {\n\tvar i, l, listener, listeners, args;\n\n\tif (!hasOwnProperty.call(this, '__ee__')) return;\n\tlisteners = this.__ee__[type];\n\tif (!listeners) return;\n\n\tif (typeof listeners === 'object') {\n\t\tl = arguments.length;\n\t\targs = new Array(l - 1);\n\t\tfor (i = 1; i < l; ++i) args[i - 1] = arguments[i];\n\n\t\tlisteners = listeners.slice();\n\t\tfor (i = 0; (listener = listeners[i]); ++i) {\n\t\t\tapply.call(listener, this, args);\n\t\t}\n\t} else {\n\t\tswitch (arguments.length) {\n\t\tcase 1:\n\t\t\tcall.call(listeners, this);\n\t\t\tbreak;\n\t\tcase 2:\n\t\t\tcall.call(listeners, this, arguments[1]);\n\t\t\tbreak;\n\t\tcase 3:\n\t\t\tcall.call(listeners, this, arguments[1], arguments[2]);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tl = arguments.length;\n\t\t\targs = new Array(l - 1);\n\t\t\tfor (i = 1; i < l; ++i) {\n\t\t\t\targs[i - 1] = arguments[i];\n\t\t\t}\n\t\t\tapply.call(listeners, this, args);\n\t\t}\n\t}\n};\n\nmethods = {\n\ton: on,\n\tonce: once,\n\toff: off,\n\temit: emit\n};\n\ndescriptors = {\n\ton: d(on),\n\tonce: d(once),\n\toff: d(off),\n\temit: d(emit)\n};\n\nbase = defineProperties({}, descriptors);\n\nmodule.exports = exports = function (o) {\n\treturn (o == null) ? create(base) : defineProperties(Object(o), descriptors);\n};\nexports.methods = methods;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/event-emitter/index.js\n// module id = 36\n// module chunks = 0","'use strict';\n\nvar assign        = require('es5-ext/object/assign')\n  , normalizeOpts = require('es5-ext/object/normalize-options')\n  , isCallable    = require('es5-ext/object/is-callable')\n  , contains      = require('es5-ext/string/#/contains')\n\n  , d;\n\nd = module.exports = function (dscr, value/*, options*/) {\n\tvar c, e, w, options, desc;\n\tif ((arguments.length < 2) || (typeof dscr !== 'string')) {\n\t\toptions = value;\n\t\tvalue = dscr;\n\t\tdscr = null;\n\t} else {\n\t\toptions = arguments[2];\n\t}\n\tif (dscr == null) {\n\t\tc = w = true;\n\t\te = false;\n\t} else {\n\t\tc = contains.call(dscr, 'c');\n\t\te = contains.call(dscr, 'e');\n\t\tw = contains.call(dscr, 'w');\n\t}\n\n\tdesc = { value: value, configurable: c, enumerable: e, writable: w };\n\treturn !options ? desc : assign(normalizeOpts(options), desc);\n};\n\nd.gs = function (dscr, get, set/*, options*/) {\n\tvar c, e, options, desc;\n\tif (typeof dscr !== 'string') {\n\t\toptions = set;\n\t\tset = get;\n\t\tget = dscr;\n\t\tdscr = null;\n\t} else {\n\t\toptions = arguments[3];\n\t}\n\tif (get == null) {\n\t\tget = undefined;\n\t} else if (!isCallable(get)) {\n\t\toptions = get;\n\t\tget = set = undefined;\n\t} else if (set == null) {\n\t\tset = undefined;\n\t} else if (!isCallable(set)) {\n\t\toptions = set;\n\t\tset = undefined;\n\t}\n\tif (dscr == null) {\n\t\tc = true;\n\t\te = false;\n\t} else {\n\t\tc = contains.call(dscr, 'c');\n\t\te = contains.call(dscr, 'e');\n\t}\n\n\tdesc = { get: get, set: set, configurable: c, enumerable: e };\n\treturn !options ? desc : assign(normalizeOpts(options), desc);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/d/index.js\n// module id = 37\n// module chunks = 0","\"use strict\";\n\nmodule.exports = require(\"./is-implemented\")()\n\t? Object.assign\n\t: require(\"./shim\");\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/assign/index.js\n// module id = 38\n// module chunks = 0","\"use strict\";\n\nmodule.exports = function () {\n\tvar assign = Object.assign, obj;\n\tif (typeof assign !== \"function\") return false;\n\tobj = { foo: \"raz\" };\n\tassign(obj, { bar: \"dwa\" }, { trzy: \"trzy\" });\n\treturn (obj.foo + obj.bar + obj.trzy) === \"razdwatrzy\";\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/assign/is-implemented.js\n// module id = 39\n// module chunks = 0","\"use strict\";\n\nvar keys  = require(\"../keys\")\n  , value = require(\"../valid-value\")\n  , max   = Math.max;\n\nmodule.exports = function (dest, src /*, …srcn*/) {\n\tvar error, i, length = max(arguments.length, 2), assign;\n\tdest = Object(value(dest));\n\tassign = function (key) {\n\t\ttry {\n\t\t\tdest[key] = src[key];\n\t\t} catch (e) {\n\t\t\tif (!error) error = e;\n\t\t}\n\t};\n\tfor (i = 1; i < length; ++i) {\n\t\tsrc = arguments[i];\n\t\tkeys(src).forEach(assign);\n\t}\n\tif (error !== undefined) throw error;\n\treturn dest;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/assign/shim.js\n// module id = 40\n// module chunks = 0","\"use strict\";\n\nmodule.exports = require(\"./is-implemented\")()\n\t? Object.keys\n\t: require(\"./shim\");\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/keys/index.js\n// module id = 41\n// module chunks = 0","\"use strict\";\n\nmodule.exports = function () {\n\ttry {\n\t\tObject.keys(\"primitive\");\n\t\treturn true;\n\t} catch (e) {\n return false;\n}\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/keys/is-implemented.js\n// module id = 42\n// module chunks = 0","\"use strict\";\n\nvar isValue = require(\"../is-value\");\n\nvar keys = Object.keys;\n\nmodule.exports = function (object) {\n\treturn keys(isValue(object) ? Object(object) : object);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/keys/shim.js\n// module id = 43\n// module chunks = 0","\"use strict\";\n\n// eslint-disable-next-line no-empty-function\nmodule.exports = function () {};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/function/noop.js\n// module id = 44\n// module chunks = 0","\"use strict\";\n\nvar isValue = require(\"./is-value\");\n\nmodule.exports = function (value) {\n\tif (!isValue(value)) throw new TypeError(\"Cannot use null or undefined\");\n\treturn value;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/valid-value.js\n// module id = 45\n// module chunks = 0","\"use strict\";\n\nvar isValue = require(\"./is-value\");\n\nvar forEach = Array.prototype.forEach, create = Object.create;\n\nvar process = function (src, obj) {\n\tvar key;\n\tfor (key in src) obj[key] = src[key];\n};\n\n// eslint-disable-next-line no-unused-vars\nmodule.exports = function (opts1 /*, …options*/) {\n\tvar result = create(null);\n\tforEach.call(arguments, function (options) {\n\t\tif (!isValue(options)) return;\n\t\tprocess(Object(options), result);\n\t});\n\treturn result;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/normalize-options.js\n// module id = 46\n// module chunks = 0","// Deprecated\n\n\"use strict\";\n\nmodule.exports = function (obj) {\n return typeof obj === \"function\";\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/is-callable.js\n// module id = 47\n// module chunks = 0","\"use strict\";\n\nmodule.exports = require(\"./is-implemented\")()\n\t? String.prototype.contains\n\t: require(\"./shim\");\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/string/#/contains/index.js\n// module id = 48\n// module chunks = 0","\"use strict\";\n\nvar str = \"razdwatrzy\";\n\nmodule.exports = function () {\n\tif (typeof str.contains !== \"function\") return false;\n\treturn (str.contains(\"dwa\") === true) && (str.contains(\"foo\") === false);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/string/#/contains/is-implemented.js\n// module id = 49\n// module chunks = 0","\"use strict\";\n\nvar indexOf = String.prototype.indexOf;\n\nmodule.exports = function (searchString/*, position*/) {\n\treturn indexOf.call(this, searchString, arguments[1]) > -1;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/string/#/contains/shim.js\n// module id = 50\n// module chunks = 0","\"use strict\";\n\nmodule.exports = function (fn) {\n\tif (typeof fn !== \"function\") throw new TypeError(fn + \" is not a function\");\n\treturn fn;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/es5-ext/object/valid-callable.js\n// module id = 51\n// module chunks = 0","/**\n * A segment of text nodes that are to be read by the TTS engine.\n *\n * @typedef {object} Chunk\n * @property {Array}   nodes    - Text nodes.\n * @property {string}  language - Language for text nodes.\n * @property {Element} root     - Container element, not necessarily the parent.\n */\n\nconst DEFAULT_ROOT_WHITELIST_SELECTOR = 'h1, h2, h3, h4, h5, h6, p, th, td, caption, li, blockquote, q, dt, dd, figcaption';\nconst DEFAULT_LEAF_BLACKLIST_SELECTOR = 'sup, sub';\n\n/**\n * Find language for element.\n *\n * @param {Element} startElement - Start element.\n * @returns {string|null} Language code or null if no language can be found.\n */\nfunction findLanguage( startElement ) {\n\tlet element = startElement;\n\twhile ( element && element.nodeType === Node.ELEMENT_NODE ) {\n\t\tif ( element.lang ) {\n\t\t\treturn element.lang.toLowerCase();\n\t\t}\n\t\telement = element.parentNode;\n\t}\n\treturn null;\n}\n\n/**\n * Get weighted chunk languages.\n *\n * @param {Chunk[]} chunks                - Chunks.\n * @param {boolean} [excludeCountry=true] - Exclude country code.\n * @returns {Object<string, number>} Mapping language code to size.\n */\nexport function getWeightedChunkLanguages( chunks, { excludeCountry = true } = {} ) {\n\tconst languageSizes = {};\n\tfor ( const chunk of chunks ) {\n\t\tlet lang = chunk.language;\n\t\tif ( excludeCountry ) {\n\t\t\tlang = lang.replace( /-.*/, '' );\n\t\t}\n\t\tif ( ! languageSizes[ lang ] ) {\n\t\t\tlanguageSizes[ lang ] = 0;\n\t\t}\n\t\tlanguageSizes[ lang ] += chunk.nodes.reduce(\n\t\t\t( previous, current ) => previous + current.length,\n\t\t\t0\n\t\t);\n\t}\n\treturn languageSizes;\n}\n\n/**\n * Omit including containers for text nodes that are for image captions or\n * superscripts. Build list of text nodes first, then remove ones that are\n * omitted (consider weak set), and then concatenate for synthesis followed\n * by iteration. Chunk up nodes by language, queue of stuff to read informed\n * by subsequent element to know pause.\n *\n * @param {Object}          args                        - Arguments\n * @param {Element}         args.containerElement       - Container element.\n * @param {string|Function} args.chunkRootIncludeFilter - CSS selector or function which is used to find chunk root elements.\n * @param {string|Function} args.chunkLeafExcludeFilter - CSS selector or function which is used to exclude text node parent elements inside chunk roots.\n * @returns {Chunk[]} Chunks.\n */\nexport default function chunkify( {\n\tcontainerElement,\n\tchunkRootIncludeFilter = DEFAULT_ROOT_WHITELIST_SELECTOR,\n\tchunkLeafExcludeFilter = DEFAULT_LEAF_BLACKLIST_SELECTOR,\n} ) {\n\tlet rootIncludeFilter = chunkRootIncludeFilter;\n\tlet leafExcludeFilter = chunkLeafExcludeFilter;\n\n\t// Make sure filters are functions when selector strings are supplied.\n\tif ( 'string' === typeof rootIncludeFilter ) {\n\t\tconst rootIncludeSelector = rootIncludeFilter;\n\t\trootIncludeFilter = ( element ) => element.matches( rootIncludeSelector );\n\t}\n\tif ( 'string' === typeof leafExcludeFilter ) {\n\t\tconst leafExcludeSelector = leafExcludeFilter;\n\t\tleafExcludeFilter = ( element ) => element.matches( leafExcludeSelector );\n\t}\n\n\t/**\n\t * Chunks.\n\t *\n\t * @type {Chunk[]}\n\t */\n\tconst chunks = [];\n\n\t/**\n\t * Root element stack.\n\t *\n\t * @type {Element[]}\n\t */\n\tconst rootElementStack = [];\n\n\t/**\n\t * Add chunk text node.\n\t *\n\t * @param {Node}   textNode - Text node.\n\t * @param {string} language - Language.\n\t * @returns {void}\n\t */\n\tconst addChunkNode = ( textNode, language ) => {\n\t\t// Skip nodes that don't contain words.\n\t\tif ( ! /\\w/.test( textNode.nodeValue ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst root = rootElementStack[ rootElementStack.length - 1 ];\n\t\tif ( ! root ) {\n\t\t\treturn;\n\t\t}\n\t\tlet currentChunk = chunks[ chunks.length - 1 ];\n\t\tif ( ! currentChunk || currentChunk.language !== language || root !== currentChunk.root ) {\n\t\t\tcurrentChunk = {\n\t\t\t\tlanguage,\n\t\t\t\tnodes: [],\n\t\t\t\troot,\n\t\t\t};\n\t\t\tchunks.push( currentChunk );\n\t\t}\n\t\tcurrentChunk.nodes.push( textNode );\n\t};\n\n\t/**\n\t * Process element.\n\t *\n\t * @param {Element} element - DOM Element.\n\t * @returns {void}\n\t */\n\tconst processElement = ( element ) => {\n\t\tconst elementLanguage = findLanguage( element );\n\t\tconst isRootChunkElement = rootIncludeFilter( element );\n\t\tif ( isRootChunkElement ) {\n\t\t\trootElementStack.push( element );\n\t\t}\n\n\t\tfor ( const childNode of element.childNodes ) {\n\t\t\tswitch ( childNode.nodeType ) {\n\t\t\t\tcase Node.ELEMENT_NODE:\n\t\t\t\t\tif ( ! leafExcludeFilter( childNode ) ) {\n\t\t\t\t\t\tprocessElement( childNode );\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase Node.TEXT_NODE:\n\t\t\t\t\tif ( 0 !== rootElementStack.length ) {\n\t\t\t\t\t\taddChunkNode( childNode, elementLanguage );\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif ( isRootChunkElement ) {\n\t\t\trootElementStack.pop();\n\t\t}\n\t};\n\n\tprocessElement( containerElement );\n\n\treturn chunks;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/chunkify.js","\n/**\n * Pending promise callbacks.\n *\n * @type {Array.<Object>}\n */\nconst pendingPromiseCallbacks = [];\n\n/**\n * Whether voices have been loaded.\n *\n * @type {boolean}\n */\nlet loaded = false;\n\nconst previousOnVoicesChanged = speechSynthesis.onvoiceschanged;\n\n/*\n * Listen for changes to loaded voices and resolve when non-empty.\n * Note that Safari doesn't yet support speechSynthesis.addEventListener()\n * so that is why setting onvoiceschanged is done here.\n */\nspeechSynthesis.onvoiceschanged = function( event ) {\n\tif ( previousOnVoicesChanged ) {\n\t\tpreviousOnVoicesChanged.call( this, event );\n\t}\n\tconst list = speechSynthesis.getVoices();\n\tfor ( const { resolve, reject } of pendingPromiseCallbacks ) {\n\t\tif ( list.length > 0 ) {\n\t\t\tloaded = true;\n\t\t\tresolve();\n\t\t} else {\n\t\t\treject();\n\t\t}\n\t}\n};\n\n/**\n * Determine whether list is loaded.\n *\n * @return {boolean} Is loaded.\n */\nexport function isLoaded() {\n\treturn loaded;\n}\n\n/**\n * Get voices.\n *\n * @returns {Promise} Resolves to list of speechSynthesis voices.\n */\nexport function load() {\n\treturn new Promise( ( resolve, reject ) => {\n\t\tconst list = speechSynthesis.getVoices();\n\n\t\tif ( list.length > 0 ) {\n\t\t\tloaded = true;\n\t\t\tresolve();\n\t\t\treturn;\n\t\t}\n\n\t\tpendingPromiseCallbacks.push( { resolve, reject } );\n\t} );\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/voices.js","/* global dialogPolyfill */\n\nimport { __, sprintf } from '../i18n';\nimport React, { Component } from 'preact-compat';\nimport PropTypes from 'prop-types';\nimport PlaybackButton from './PlaybackButton';\nimport { uniqueId } from '../helpers';\n\nexport default class PlaybackControls extends Component {\n\tcomponentWillMount() {\n\t\tthis.idPrefix = `input${ uniqueId() }-`;\n\t}\n\n\tcomponentDidMount() {\n\t\tthis.updateDialogState();\n\t\tif ( ! this.dialog.showModal && typeof dialogPolyfill !== 'undefined' ) {\n\t\t\tdialogPolyfill.registerDialog( this.dialog );\n\t\t}\n\t\tthis.dialog.addEventListener( 'cancel', ( event ) => {\n\t\t\tevent.preventDefault();\n\t\t\tthis.props.onHideSettings();\n\t\t} );\n\t}\n\n\tcomponentDidUpdate() {\n\t\tthis.updateDialogState();\n\t}\n\n\t/**\n\t * Update dialog state.\n\t */\n\tupdateDialogState() {\n\t\tif ( ! this.props.settingsShown && this.dialog.open ) {\n\t\t\tthis.dialog.close();\n\t\t\tif ( this.previousActiveElement && ! this.props.playing ) {\n\t\t\t\tthis.previousActiveElement.focus();\n\t\t\t}\n\t\t} else if ( this.props.settingsShown && ! this.dialog.open ) {\n\t\t\tthis.previousActiveElement = document.activeElement;\n\t\t\tthis.dialog.showModal();\n\t\t}\n\t}\n\n\t/**\n\t * Render language voice select dropdowns.\n\t *\n\t * @return {VNode[]|null} Elements or null if no available voices or no present languages.\n\t */\n\trenderLanguageVoiceSelects() {\n\t\tif ( 0 === this.props.availableVoices.length || 0 === this.props.presentLanguages.length ) {\n\t\t\treturn null;\n\t\t}\n\n\t\tconst updateLanguageVoice = ( event ) => {\n\t\t\tconst languageVoices = Object.assign(\n\t\t\t\t{},\n\t\t\t\tthis.props.languageVoices,\n\t\t\t\t{\n\t\t\t\t\t[ event.target.dataset.language ]: event.target.value,\n\t\t\t\t}\n\t\t\t);\n\t\t\tthis.props.setProps( { languageVoices } );\n\t\t};\n\n\t\tconst selects = [];\n\t\tfor ( const presentLanguage of this.props.presentLanguages ) {\n\t\t\tconst voicesInLanguage = this.props.availableVoices.filter(\n\t\t\t\t( voice ) => voice.lang.startsWith( presentLanguage )\n\t\t\t);\n\t\t\tif ( 0 === voicesInLanguage.length ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst id = this.idPrefix + 'voice-' + presentLanguage;\n\t\t\tselects.push(\n\t\t\t\t<p key={ presentLanguage }>\n\t\t\t\t\t<label className=\"spoken-word-playback-controls__label\" htmlFor={ id }>\n\t\t\t\t\t\t{ sprintf( __( 'Voice (%s):' ), presentLanguage ) }\n\t\t\t\t\t</label>\n\t\t\t\t\t{ ' ' }\n\t\t\t\t\t{\n\t\t\t\t\t\t<select\n\t\t\t\t\t\t\tid={ id }\n\t\t\t\t\t\t\tclassName=\"spoken-word-playback-controls__input\"\n\t\t\t\t\t\t\tdata-language={ presentLanguage }\n\t\t\t\t\t\t\tvalue={ this.props.languageVoices[ presentLanguage ] }\n\t\t\t\t\t\t\tonBlur={ updateLanguageVoice }\n\t\t\t\t\t\t\tonChange={ updateLanguageVoice }\n\t\t\t\t\t\t>\n\t\t\t\t\t\t\t{ voicesInLanguage.map(\n\t\t\t\t\t\t\t\t( voice ) =>\n\t\t\t\t\t\t\t\t\t<option key={ voice.voiceURI } value={ voice.voiceURI }>\n\t\t\t\t\t\t\t\t\t\t{ voice.lang.includes( '-' ) ?\n\t\t\t\t\t\t\t\t\t\t\tsprintf( __( '%s (%s)' ), voice.name, voice.lang ) :\n\t\t\t\t\t\t\t\t\t\t\tvoice.name }\n\t\t\t\t\t\t\t\t\t</option>\n\t\t\t\t\t\t\t) }\n\t\t\t\t\t\t</select>\n\t\t\t\t\t}\n\t\t\t\t</p>\n\t\t\t);\n\t\t}\n\n\t\treturn selects;\n\t}\n\n\t/**\n\t * Render settings.\n\t *\n\t * @returns {VNode|null} Settings.\n\t */\n\trenderSettings() {\n\t\tif ( ! this.props.isDialogSupported ) {\n\t\t\treturn null;\n\t\t}\n\n\t\tconst saveDialogRef = ( dialog ) => {\n\t\t\tthis.dialog = dialog;\n\t\t};\n\t\tconst handleNumericPropInputChange = ( event ) => {\n\t\t\tif ( isNaN( event.target.valueAsNumber ) || ! event.target.validity.valid ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tthis.props.setProps( {\n\t\t\t\t[ event.target.dataset.prop ]: event.target.valueAsNumber,\n\t\t\t} );\n\t\t};\n\n\t\treturn (\n\t\t\t<dialog className=\"spoken-word-playback-controls__dialog\" ref={ saveDialogRef }>\n\t\t\t\t<h1 className=\"spoken-word-playback-controls__heading\">\n\t\t\t\t\t<a href=\"https://github.com/westonruter/spoken-word\" target=\"_blank\" rel=\"noopener noreferrer\">{ __( 'Spoken Word' ) }</a>\n\t\t\t\t</h1>\n\t\t\t\t<p>\n\t\t\t\t\t<label className=\"spoken-word-playback-controls__label\" htmlFor={ this.idPrefix + 'rate' }>{ __( 'Rate:' ) }</label>\n\t\t\t\t\t{ ' ' }\n\t\t\t\t\t<input\n\t\t\t\t\t\tid={ this.idPrefix + 'rate' }\n\t\t\t\t\t\tclassName=\"spoken-word-playback-controls__input\"\n\t\t\t\t\t\ttype=\"number\"\n\t\t\t\t\t\tdata-prop=\"rate\"\n\t\t\t\t\t\tvalue={ this.props.rate }\n\t\t\t\t\t\tstep={ 0.1 }\n\t\t\t\t\t\tmin={ 0.1 }\n\t\t\t\t\t\tmax={ 10 }\n\t\t\t\t\t\tonChange={ handleNumericPropInputChange }\n\t\t\t\t\t/>\n\t\t\t\t</p>\n\t\t\t\t<p>\n\t\t\t\t\t<label className=\"spoken-word-playback-controls__label\" htmlFor={ this.idPrefix + 'pitch' }>{ __( 'Pitch:' ) }</label>\n\t\t\t\t\t{ ' ' }\n\t\t\t\t\t<input\n\t\t\t\t\t\tid={ this.idPrefix + 'pitch' }\n\t\t\t\t\t\tclassName=\"spoken-word-playback-controls__input\"\n\t\t\t\t\t\ttype=\"number\"\n\t\t\t\t\t\tdata-prop=\"pitch\"\n\t\t\t\t\t\tvalue={ this.props.pitch }\n\t\t\t\t\t\tmin={ 0 }\n\t\t\t\t\t\tmax={ 2 }\n\t\t\t\t\t\tstep={ 0.1 }\n\t\t\t\t\t\tonChange={ handleNumericPropInputChange }\n\t\t\t\t\t/>\n\t\t\t\t</p>\n\t\t\t\t{ this.renderLanguageVoiceSelects() }\n\t\t\t\t<button onClick={ this.props.onHideSettings }>{ __( 'Close' ) }</button>\n\t\t\t</dialog>\n\t\t);\n\t}\n\n\t/**\n\t * Render.\n\t *\n\t * @return {VNode} Element.\n\t */\n\trender() {\n\t\tconst classNames = [ 'spoken-word-playback-controls' ];\n\n\t\treturn (\n\t\t\t<fieldset className={ classNames.join( ' ' ) }>\n\t\t\t\t<legend className=\"spoken-word-playback-controls__legend\">{ __( 'Text to Speech' ) }</legend>\n\n\t\t\t\t<PlaybackButton\n\t\t\t\t\tuseDashicon={ this.props.useDashicons }\n\t\t\t\t\tdashicon={ this.props.playing ? 'controls-pause' : 'controls-play' }\n\t\t\t\t\temoji={ this.props.playing ? '⏸️' : '▶' }\n\t\t\t\t\tlabel={ this.props.playing ? __( 'Pause' ) : __( 'Play' ) }\n\t\t\t\t\tonClick={ this.props.playing ? this.props.stop : this.props.play }\n\t\t\t\t/>\n\n\t\t\t\t<PlaybackButton useDashicon={ this.props.useDashicons } dashicon=\"controls-back\" emoji=\"⏪\" label={ __( 'Previous' ) } onClick={ this.props.previous } />\n\t\t\t\t<PlaybackButton useDashicon={ this.props.useDashicons } dashicon=\"controls-forward\" emoji=\"⏩\" label={ __( 'Forward' ) } onClick={ this.props.next } />\n\t\t\t\t{ this.props.isDialogSupported ?\n\t\t\t\t\t<PlaybackButton useDashicon={ this.props.useDashicons } dashicon=\"admin-settings\" emoji=\"⚙\" label={ __( 'Settings' ) } onClick={ this.props.onShowSettings } /> : '' }\n\t\t\t\t{ this.renderSettings() }\n\t\t\t</fieldset>\n\t\t);\n\t}\n}\n\nPlaybackControls.propTypes = {\n\tplaying: PropTypes.bool.isRequired,\n\tplay: PropTypes.func.isRequired,\n\tonShowSettings: PropTypes.func.isRequired,\n\tonHideSettings: PropTypes.func.isRequired,\n\tstop: PropTypes.func.isRequired,\n\tprevious: PropTypes.func.isRequired,\n\tnext: PropTypes.func.isRequired,\n\tuseDashicons: PropTypes.bool,\n\tsettingsShown: PropTypes.bool,\n\tisDialogSupported: PropTypes.bool,\n\tpresentLanguages: PropTypes.array.isRequired,\n\tavailableVoices: PropTypes.array.isRequired,\n\tlanguageVoices: PropTypes.object.isRequired,\n\tsetProps: PropTypes.func.isRequired,\n};\n\nPlaybackControls.defaultProps = {\n\tuseDashicons: false,\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/components/PlaybackControls.js","import React, { Component } from 'preact-compat';\nimport PropTypes from 'prop-types';\n\nexport default class PlaybackButton extends Component {\n\trender() {\n\t\tconst style = {};\n\t\tconst buttonClassNames = [ 'spoken-word-playback-controls__button' ];\n\n\t\tif ( this.props.useDashicon ) {\n\t\t\tbuttonClassNames.push( 'spoken-word-playback-controls__button--dashicon' );\n\t\t} else {\n\t\t\t// Prevent MutationObserver in wpEmoji from interfering with React-rendered element.\n\t\t\tbuttonClassNames.push( 'wp-exclude-emoji' );\n\t\t\tbuttonClassNames.push( 'spoken-word-playback-controls__button--emoji' );\n\t\t}\n\n\t\treturn (\n\t\t\t<button type=\"button\" className={ buttonClassNames.join( ' ' ) } style={ style } aria-label={ this.props.label } onClick={ this.props.onClick }>\n\t\t\t\t{ this.props.useDashicon ?\n\t\t\t\t\t<span className={ 'dashicons dashicons-' + this.props.dashicon } /> :\n\t\t\t\t\tthis.props.emoji\n\t\t\t\t}\n\t\t\t</button>\n\t\t);\n\t}\n}\n\nPlaybackButton.propTypes = {\n\tlabel: PropTypes.string.isRequired,\n\temoji: PropTypes.string.isRequired,\n\tdashicon: PropTypes.string.isRequired,\n\tuseDashicon: PropTypes.bool.isRequired,\n\tonClick: PropTypes.func.isRequired,\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/components/PlaybackButton.js","var baseIsEqual = require('./_baseIsEqual');\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\nmodule.exports = isEqual;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isEqual.js\n// module id = 56\n// module chunks = 0","var baseIsEqualDeep = require('./_baseIsEqualDeep'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Unordered comparison\n *  2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\nmodule.exports = baseIsEqual;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseIsEqual.js\n// module id = 57\n// module chunks = 0","var Stack = require('./_Stack'),\n    equalArrays = require('./_equalArrays'),\n    equalByTag = require('./_equalByTag'),\n    equalObjects = require('./_equalObjects'),\n    getTag = require('./_getTag'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = objIsArr ? arrayTag : getTag(object),\n      othTag = othIsArr ? arrayTag : getTag(other);\n\n  objTag = objTag == argsTag ? objectTag : objTag;\n  othTag = othTag == argsTag ? objectTag : othTag;\n\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && isBuffer(object)) {\n    if (!isBuffer(other)) {\n      return false;\n    }\n    objIsArr = true;\n    objIsObj = false;\n  }\n  if (isSameTag && !objIsObj) {\n    stack || (stack = new Stack);\n    return (objIsArr || isTypedArray(object))\n      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n  }\n  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      var objUnwrapped = objIsWrapped ? object.value() : object,\n          othUnwrapped = othIsWrapped ? other.value() : other;\n\n      stack || (stack = new Stack);\n      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  stack || (stack = new Stack);\n  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\nmodule.exports = baseIsEqualDeep;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseIsEqualDeep.js\n// module id = 58\n// module chunks = 0","var ListCache = require('./_ListCache'),\n    stackClear = require('./_stackClear'),\n    stackDelete = require('./_stackDelete'),\n    stackGet = require('./_stackGet'),\n    stackHas = require('./_stackHas'),\n    stackSet = require('./_stackSet');\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nmodule.exports = Stack;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_Stack.js\n// module id = 59\n// module chunks = 0","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_listCacheClear.js\n// module id = 60\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nmodule.exports = listCacheDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_listCacheDelete.js\n// module id = 61\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_listCacheGet.js\n// module id = 62\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_listCacheHas.js\n// module id = 63\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nmodule.exports = listCacheSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_listCacheSet.js\n// module id = 64\n// module chunks = 0","var ListCache = require('./_ListCache');\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\nmodule.exports = stackClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_stackClear.js\n// module id = 65\n// module chunks = 0","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nmodule.exports = stackDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_stackDelete.js\n// module id = 66\n// module chunks = 0","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nmodule.exports = stackGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_stackGet.js\n// module id = 67\n// module chunks = 0","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nmodule.exports = stackHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_stackHas.js\n// module id = 68\n// module chunks = 0","var ListCache = require('./_ListCache'),\n    Map = require('./_Map'),\n    MapCache = require('./_MapCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nmodule.exports = stackSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_stackSet.js\n// module id = 69\n// module chunks = 0","var isFunction = require('./isFunction'),\n    isMasked = require('./_isMasked'),\n    isObject = require('./isObject'),\n    toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseIsNative.js\n// module id = 70\n// module chunks = 0","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 71\n// module chunks = 0","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_getRawTag.js\n// module id = 72\n// module chunks = 0","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_objectToString.js\n// module id = 73\n// module chunks = 0","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_isMasked.js\n// module id = 74\n// module chunks = 0","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_coreJsData.js\n// module id = 75\n// module chunks = 0","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_getValue.js\n// module id = 76\n// module chunks = 0","var Hash = require('./_Hash'),\n    ListCache = require('./_ListCache'),\n    Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\nmodule.exports = mapCacheClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_mapCacheClear.js\n// module id = 77\n// module chunks = 0","var hashClear = require('./_hashClear'),\n    hashDelete = require('./_hashDelete'),\n    hashGet = require('./_hashGet'),\n    hashHas = require('./_hashHas'),\n    hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_Hash.js\n// module id = 78\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\nmodule.exports = hashClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_hashClear.js\n// module id = 79\n// module chunks = 0","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = hashDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_hashDelete.js\n// module id = 80\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_hashGet.js\n// module id = 81\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_hashHas.js\n// module id = 82\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\nmodule.exports = hashSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_hashSet.js\n// module id = 83\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = mapCacheDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_mapCacheDelete.js\n// module id = 84\n// module chunks = 0","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nmodule.exports = isKeyable;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_isKeyable.js\n// module id = 85\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_mapCacheGet.js\n// module id = 86\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_mapCacheHas.js\n// module id = 87\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nmodule.exports = mapCacheSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_mapCacheSet.js\n// module id = 88\n// module chunks = 0","var MapCache = require('./_MapCache'),\n    setCacheAdd = require('./_setCacheAdd'),\n    setCacheHas = require('./_setCacheHas');\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values == null ? 0 : values.length;\n\n  this.__data__ = new MapCache;\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nmodule.exports = SetCache;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_SetCache.js\n// module id = 89\n// module chunks = 0","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\nmodule.exports = setCacheAdd;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_setCacheAdd.js\n// module id = 90\n// module chunks = 0","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\nmodule.exports = setCacheHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_setCacheHas.js\n// module id = 91\n// module chunks = 0","/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nmodule.exports = arraySome;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_arraySome.js\n// module id = 92\n// module chunks = 0","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n\nmodule.exports = cacheHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_cacheHas.js\n// module id = 93\n// module chunks = 0","var Symbol = require('./_Symbol'),\n    Uint8Array = require('./_Uint8Array'),\n    eq = require('./eq'),\n    equalArrays = require('./_equalArrays'),\n    mapToArray = require('./_mapToArray'),\n    setToArray = require('./_setToArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n  switch (tag) {\n    case dataViewTag:\n      if ((object.byteLength != other.byteLength) ||\n          (object.byteOffset != other.byteOffset)) {\n        return false;\n      }\n      object = object.buffer;\n      other = other.buffer;\n\n    case arrayBufferTag:\n      if ((object.byteLength != other.byteLength) ||\n          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n        return false;\n      }\n      return true;\n\n    case boolTag:\n    case dateTag:\n    case numberTag:\n      // Coerce booleans to `1` or `0` and dates to milliseconds.\n      // Invalid dates are coerced to `NaN`.\n      return eq(+object, +other);\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings, primitives and objects,\n      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n      // for more details.\n      return object == (other + '');\n\n    case mapTag:\n      var convert = mapToArray;\n\n    case setTag:\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n      convert || (convert = setToArray);\n\n      if (object.size != other.size && !isPartial) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked) {\n        return stacked == other;\n      }\n      bitmask |= COMPARE_UNORDERED_FLAG;\n\n      // Recursively compare objects (susceptible to call stack limits).\n      stack.set(object, other);\n      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n      stack['delete'](object);\n      return result;\n\n    case symbolTag:\n      if (symbolValueOf) {\n        return symbolValueOf.call(object) == symbolValueOf.call(other);\n      }\n  }\n  return false;\n}\n\nmodule.exports = equalByTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_equalByTag.js\n// module id = 94\n// module chunks = 0","var root = require('./_root');\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nmodule.exports = Uint8Array;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_Uint8Array.js\n// module id = 95\n// module chunks = 0","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\nmodule.exports = mapToArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_mapToArray.js\n// module id = 96\n// module chunks = 0","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\nmodule.exports = setToArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_setToArray.js\n// module id = 97\n// module chunks = 0","var getAllKeys = require('./_getAllKeys');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      objProps = getAllKeys(object),\n      objLength = objProps.length,\n      othProps = getAllKeys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isPartial) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  // Assume cyclic values are equal.\n  var stacked = stack.get(object);\n  if (stacked && stack.get(other)) {\n    return stacked == other;\n  }\n  var result = true;\n  stack.set(object, other);\n  stack.set(other, object);\n\n  var skipCtor = isPartial;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, objValue, key, other, object, stack)\n        : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined\n          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n          : compared\n        )) {\n      result = false;\n      break;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (result && !skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\nmodule.exports = equalObjects;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_equalObjects.js\n// module id = 98\n// module chunks = 0","var baseGetAllKeys = require('./_baseGetAllKeys'),\n    getSymbols = require('./_getSymbols'),\n    keys = require('./keys');\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\nmodule.exports = getAllKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_getAllKeys.js\n// module id = 99\n// module chunks = 0","var arrayPush = require('./_arrayPush'),\n    isArray = require('./isArray');\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nmodule.exports = baseGetAllKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseGetAllKeys.js\n// module id = 100\n// module chunks = 0","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\nmodule.exports = arrayPush;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_arrayPush.js\n// module id = 101\n// module chunks = 0","var arrayFilter = require('./_arrayFilter'),\n    stubArray = require('./stubArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\nmodule.exports = getSymbols;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_getSymbols.js\n// module id = 102\n// module chunks = 0","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayFilter;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_arrayFilter.js\n// module id = 103\n// module chunks = 0","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\nmodule.exports = stubArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/stubArray.js\n// module id = 104\n// module chunks = 0","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeys = require('./_baseKeys'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nmodule.exports = keys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/keys.js\n// module id = 105\n// module chunks = 0","var baseTimes = require('./_baseTimes'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isIndex = require('./_isIndex'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayLikeKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_arrayLikeKeys.js\n// module id = 106\n// module chunks = 0","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nmodule.exports = baseTimes;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseTimes.js\n// module id = 107\n// module chunks = 0","var baseIsArguments = require('./_baseIsArguments'),\n    isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isArguments.js\n// module id = 108\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseIsArguments.js\n// module id = 109\n// module chunks = 0","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = stubFalse;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/stubFalse.js\n// module id = 110\n// module chunks = 0","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_isIndex.js\n// module id = 111\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isLength = require('./isLength'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseIsTypedArray.js\n// module id = 112\n// module chunks = 0","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nmodule.exports = baseUnary;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseUnary.js\n// module id = 113\n// module chunks = 0","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_nodeUtil.js\n// module id = 114\n// module chunks = 0","var isPrototype = require('./_isPrototype'),\n    nativeKeys = require('./_nativeKeys');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_baseKeys.js\n// module id = 115\n// module chunks = 0","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\nmodule.exports = isPrototype;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_isPrototype.js\n// module id = 116\n// module chunks = 0","var overArg = require('./_overArg');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nmodule.exports = nativeKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_nativeKeys.js\n// module id = 117\n// module chunks = 0","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nmodule.exports = overArg;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_overArg.js\n// module id = 118\n// module chunks = 0","var isFunction = require('./isFunction'),\n    isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/isArrayLike.js\n// module id = 119\n// module chunks = 0","var DataView = require('./_DataView'),\n    Map = require('./_Map'),\n    Promise = require('./_Promise'),\n    Set = require('./_Set'),\n    WeakMap = require('./_WeakMap'),\n    baseGetTag = require('./_baseGetTag'),\n    toSource = require('./_toSource');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    setTag = '[object Set]',\n    weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\nmodule.exports = getTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_getTag.js\n// module id = 120\n// module chunks = 0","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nmodule.exports = DataView;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_DataView.js\n// module id = 121\n// module chunks = 0","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nmodule.exports = Promise;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_Promise.js\n// module id = 122\n// module chunks = 0","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nmodule.exports = Set;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_Set.js\n// module id = 123\n// module chunks = 0","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nmodule.exports = WeakMap;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash/_WeakMap.js\n// module id = 124\n// module chunks = 0"],"sourceRoot":""}