{"version":3,"sources":["webpack:///index-f166dd.js","webpack:///webpack/bootstrap f166dd96d0848cfd7ef6","webpack:///./~/get-intrinsic/index.js","webpack:///./src/shared/stylesheets/background.css","webpack:///./~/call-bind/callBound.js","webpack:///./~/es-abstract/2021/Type.js","webpack:///./~/has/src/index.js","webpack:///./~/define-properties/index.js","webpack:///./src/shared/stylesheets/alignment/index.css","webpack:///./src/shared/utils/imageUtils.js","webpack:///./~/es-abstract/2021/IsPropertyKey.js","webpack:///./~/es-abstract/2021/IsCallable.js","webpack:///./~/es-abstract/helpers/isNaN.js","webpack:///./src/shared/stylesheets/video.css","webpack:///./~/has-tostringtag/shams.js","webpack:///./src/shared/utils/googleAnalytics.js","webpack:///./src/shared/utils/renderUtils.js","webpack:///./~/call-bind/index.js","webpack:///./~/es-abstract/2021/IsArray.js","webpack:///./~/es-abstract/2021/RequireObjectCoercible.js","webpack:///./~/es-abstract/2021/ToLength.js","webpack:///./~/es-abstract/2021/ToObject.js","webpack:///./~/es-abstract/helpers/assertRecord.js","webpack:///./src/shared/stylesheets/mood.css","webpack:///./~/function-bind/index.js","webpack:///./~/has-symbols/index.js","webpack:///./~/has-symbols/shams.js","webpack:///./~/is-callable/index.js","webpack:///./~/lodash/isObject.js","webpack:///./~/lodash/throttle.js","webpack:///./~/@nrk/serum-imagecrop-utils/lib/index.js","webpack:///./~/array-includes/implementation.js","webpack:///./~/array-includes/polyfill.js","webpack:///./~/array.from/implementation.js","webpack:///./~/array.from/polyfill.js","webpack:///./~/array.prototype.find/implementation.js","webpack:///./~/array.prototype.find/polyfill.js","webpack:///./src/shared/components/index.js","webpack:///./src/shared/utils/general.js","webpack:///./~/es-abstract/2021/Call.js","webpack:///./~/es-abstract/2021/FromPropertyDescriptor.js","webpack:///./~/es-abstract/2021/IsDataDescriptor.js","webpack:///./~/es-abstract/2021/SameValue.js","webpack:///./~/es-abstract/2021/ToBoolean.js","webpack:///./~/es-abstract/2021/ToIntegerOrInfinity.js","webpack:///./~/es-abstract/2021/ToPropertyDescriptor.js","webpack:///./~/es-abstract/helpers/DefineOwnProperty.js","webpack:///./~/es-abstract/helpers/isFinite.js","webpack:///./~/es-abstract/helpers/isPrimitive.js","webpack:///./~/es-to-primitive/helpers/isPrimitive.js","webpack:///./src/shared/index.css","webpack:///./~/is-string/index.js","webpack:///./~/lodash/_Symbol.js","webpack:///./~/lodash/_root.js","webpack:///./~/lodash/debounce.js","webpack:///./~/object-keys/isArguments.js","webpack:///./~/process/browser.js","webpack:///(webpack)/buildin/global.js","webpack:///./config/polyfills.js","webpack:///./src/client/index.js","webpack:///./~/array-includes/index.js","webpack:///./~/array-includes/shim.js","webpack:///./~/array.from/index.js","webpack:///./~/array.from/shim.js","webpack:///./~/array.prototype.find/index.js","webpack:///./~/array.prototype.find/shim.js","webpack:///./src/client/intersection.js","webpack:///./src/client/reducer.js","webpack:///./src/client/transitionManager.js","webpack:///./src/client/utils/featuretests.js","webpack:///./src/shared/components/animateVideo.js","webpack:///./src/shared/components/animation.js","webpack:///./src/shared/components/byline.js","webpack:///./src/shared/components/color.js","webpack:///./src/shared/components/flipScroll.js","webpack:///./src/shared/components/image.js","webpack:///./src/shared/components/panorama.js","webpack:///./src/shared/components/polopoly.js","webpack:///./src/shared/components/renderless/activeClass.js","webpack:///./src/shared/components/triggerOnScroll.js","webpack:///./src/shared/components/video.js","webpack:///./src/shared/utils/muteButtons.js","webpack:///./~/es-abstract/2020/IsArray.js","webpack:///./~/es-abstract/2021/CreateDataProperty.js","webpack:///./~/es-abstract/2021/CreateDataPropertyOrThrow.js","webpack:///./~/es-abstract/2021/DefinePropertyOrThrow.js","webpack:///./~/es-abstract/2021/Get.js","webpack:///./~/es-abstract/2021/IsAccessorDescriptor.js","webpack:///./~/es-abstract/2021/IsConstructor.js","webpack:///./~/es-abstract/2021/IsExtensible.js","webpack:///./~/es-abstract/2021/IsRegExp.js","webpack:///./~/es-abstract/2021/OrdinaryGetOwnProperty.js","webpack:///./~/es-abstract/2021/SameValueZero.js","webpack:///./~/es-abstract/2021/ToNumber.js","webpack:///./~/es-abstract/2021/ToPrimitive.js","webpack:///./~/es-abstract/2021/ToString.js","webpack:///./~/es-abstract/5/CheckObjectCoercible.js","webpack:///./~/es-abstract/5/ToInteger.js","webpack:///./~/es-abstract/5/ToNumber.js","webpack:///./~/es-abstract/5/ToPrimitive.js","webpack:///./~/es-abstract/5/Type.js","webpack:///./~/es-abstract/5/abs.js","webpack:///./~/es-abstract/5/floor.js","webpack:///./~/es-abstract/GetIntrinsic.js","webpack:///./~/es-abstract/helpers/getOwnPropertyDescriptor.js","webpack:///./~/es-abstract/helpers/isPropertyDescriptor.js","webpack:///./~/es-abstract/helpers/maxSafeInteger.js","webpack:///./~/es-abstract/helpers/regexTester.js","webpack:///./~/es-abstract/helpers/sign.js","webpack:///./~/es-get-iterator/index.js","webpack:///./~/es-to-primitive/es2015.js","webpack:///./~/es-to-primitive/es5.js","webpack:///./~/es6-promise/dist/es6-promise.js","webpack:///./src/shared/stylesheets/animations.css","webpack:///./src/shared/stylesheets/block.css","webpack:///./src/shared/stylesheets/byline.css","webpack:///./src/shared/stylesheets/transitions.css","webpack:///./~/function-bind/implementation.js","webpack:///./~/intersection-observer/intersection-observer.js","webpack:///./~/is-arguments/index.js","webpack:///./~/is-date-object/index.js","webpack:///./~/is-map/index.js","webpack:///./~/is-regex/index.js","webpack:///./~/is-set/index.js","webpack:///./~/is-symbol/index.js","webpack:///./~/isarray/index.js","webpack:///./~/iterate-iterator/index.js","webpack:///./~/iterate-value/index.js","webpack:///./~/lodash/_baseGetTag.js","webpack:///./~/lodash/_baseTrim.js","webpack:///./~/lodash/_freeGlobal.js","webpack:///./~/lodash/_getRawTag.js","webpack:///./~/lodash/_objectToString.js","webpack:///./~/lodash/_trimmedEndIndex.js","webpack:///./~/lodash/isObjectLike.js","webpack:///./~/lodash/isSymbol.js","webpack:///./~/lodash/now.js","webpack:///./~/lodash/toNumber.js","webpack:///./~/object-inspect/index.js","webpack:///./~/object-keys/implementation.js","webpack:///./~/object-keys/index.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","m","c","value","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","$SyntaxError","SyntaxError","$Function","Function","$TypeError","TypeError","getEvalledConstructor","expressionSyntax","e","$gOPD","getOwnPropertyDescriptor","throwTypeError","ThrowTypeError","arguments","callee","calleeThrows","gOPDthrows","hasSymbols","getProto","getPrototypeOf","x","__proto__","needsEval","TypedArray","Uint8Array","undefined","INTRINSICS","AggregateError","Array","ArrayBuffer","Symbol","iterator","Atomics","BigInt","Boolean","DataView","Date","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","Error","eval","EvalError","Float32Array","Float64Array","FinalizationRegistry","Int8Array","Int16Array","Int32Array","isFinite","isNaN","JSON","Map","Math","Number","parseFloat","parseInt","Promise","Proxy","RangeError","ReferenceError","Reflect","RegExp","Set","SharedArrayBuffer","String","Uint8ClampedArray","Uint16Array","Uint32Array","URIError","WeakMap","WeakRef","WeakSet","doEval","fn","gen","LEGACY_ALIASES","bind","hasOwn","$concat","concat","$spliceApply","apply","splice","$replace","replace","$strSlice","slice","rePropName","reEscapeChar","stringToPath","string","first","last","result","match","number","quote","subString","length","getBaseIntrinsic","allowMissing","alias","intrinsicName","parts","intrinsicBaseName","intrinsic","intrinsicRealName","skipFurtherCaching","isOwn","part","desc","GetIntrinsic","callBind","$indexOf","ES5Type","keys","toStr","toString","origDefineProperty","isFunction","supportsDescriptors","obj","_","predicate","writable","defineProperties","map","predicates","props","getOwnPropertySymbols","createSrcSet","imageId","ratio","supportedWidths","width","createImageUrl","id","quality","join","prepareUrl","url","getPolopolyImageElement","polopolyId","alignmentClasses","imgStyle","pictureStyle","defaultUrl","getImageForegroundElement","imageUrl","getImageElement","argument","a","toStringTag","initialize","trackingEnabled","isTrackingEnabled","trackAction","action","sendToGoogleAnalytics","category","label","window","ga","console","log","getOverlayElement","overlay","defaultOverlay","opacity","color","backgroundOverlay","assign","$apply","$call","$reflectApply","$defineProperty","$max","originalFunction","func","applyBind","$Array","isArray","MAX_SAFE_INTEGER","ToIntegerOrInfinity","len","$Object","RequireObjectCoercible","has","Type","Desc","allowed","key","isData","IsAccessor","recordType","argumentName","implementation","origSymbol","hasSymbolSham","sym","symObj","getOwnPropertyNames","syms","propertyIsEnumerable","descriptor","badArrayLike","isCallableMarker","fnToStr","reflectApply","constructorRegex","isES6ClassFn","fnStr","test","tryFunctionObject","hasToStringTag","documentDotAll","document","all","strClass","isObject","type","throttle","wait","options","leading","trailing","FUNC_ERROR_TEXT","debounce","global","factory","this","isPolopolyId","isPolopolyIdRegex","createUrl","_ref","_baseUrl","queryString","createQueryString","_ref2","getClosestNumber","goal","targets","isValidGoal","isValidTargets","reduce","prev","curr","abs","isValid","isValidRatio","supportedRatios","includes","isValidQuality","supportedQualities","args","hasOption","ratios","qualities","isNumber","errorMessage","isSupportedWidth","widths","closestWidth","option","isInteger","ToLength","ToObject","SameValueZero","$isNaN","$isFinite","callBound","isString","$charAt","searchElement","fromIndex","O","k","Call","CreateDataPropertyOrThrow","Get","IsCallable","IsConstructor","ToString","iterate","items","C","mapFn","T","values","kValue","mappedValue","arrayLike","A","Pk","IsArray","tryCall","from","origArrayFrom","arr","entries","Infinity","list","thisArg","find","components","setActiveElementClass","imageComponent","colorComponent","bylineComponent","videoComponent","animationComponent","panoramaComponent","triggerOnScrollComponent","flipScrollComponent","animateVideoComponent","constrain","min","max","F","V","argumentsList","assertRecord","set","y","ES5ToInteger","ToNumber","ToBoolean","Obj","setter","hasArrayLengthDefineBug","$isEnumerable","IsDataDescriptor","SameValue","FromPropertyDescriptor","P","strValue","valueOf","tryStringObject","root","freeGlobal","freeSelf","self","invokeFunc","time","lastArgs","lastThis","lastInvokeTime","leadingEdge","timerId","setTimeout","timerExpired","remainingWait","timeSinceLastCall","lastCallTime","timeSinceLastInvoke","timeWaiting","maxing","nativeMin","maxWait","shouldInvoke","now","trailingEdge","cancel","clearTimeout","flush","debounced","isInvoking","toNumber","nativeMax","str","isArgs","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","runClearTimeout","marker","cachedClearTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","timeout","run","Item","array","noop","process","nextTick","push","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","g","require","shim","polyfill","floor","_interopRequireDefault","default","_toConsumableArray","arr2","_classCallCheck","instance","Constructor","_extends","target","source","_index2","_index","_video2","_video","App","container","initialState","setSectionId","sectionId","mount","sectionElements","querySelectorAll","styles","section","state","sections","canAutoplay","foregroundElement","backgroundElement","getElementById","shareButtons","querySelector","shareButtonGroup","muteButton","videoStyles","videoMuteButton","addEventListener","toggleMuteVideo","initializeGoogleAnalytic","mountListeners","error","renderError","gaInitialized","getAttribute","unmount","unmountListeners","innerHTML","ioCallback","changes","intersectionObserverCallback","dispatch","threshold","observer","IntersectionObserver","POLL_INTERVAL","forEach","observe","render","stopPropagation","muted","onStateChanged","showMuteButton","classList","add","visible","remove","showShareButtons","getMutedButton","getUnmutedButton","filter","component","videoElements","appParams","mountingNode","ROOT_MOUNT_ID","parse","style","transition","define","getPolyfill","$slice","boundShim","boundFromShim","boundFindShim","currentSection","change","isIntersecting","nextSection","pop","currentIndex","indexOf","previousIndex","direction","previousSection","transitionManager","shareIcons","onCurrentChanged","_transitions2","_transitions","currentElement","previousElement","transitionName","transitionClass","transitionStyles","animateInto","allTransitionClasses","tClass","animateAway","callback","videoAutoPlayCache","videoElm","createElement","isPlaying","setAttribute","canPlayType","src","load","play","oncanplay","onplay","_debounce","eventListener","handleAnimateVideo","bgInnerHTML","video","alignment","mp4","poster","webm","subtitles","trackElement","hasSound","background","hidePlay","removeEventListener","requestAnimationFrame","getBoundingClientRect","top","height","innerHeight","videoElement","innerWidth","pxInViewFromStart","howMuchBigger","percentInView","newCurrentTime","duration","currentTime","backgroundColor","_mood2","_mood","mood","sectionMoodClass","moodStyles","handleFlipScroll","_throttle2","_throttle","polopolyIds","uncropped","flipFade","alignMiddle","alignCenter","imageStyle","imageElements","uncroppedImageContainer","passive","element","getElementsByTagName","numberOfImages","pxInView","idx","backgroundImage","imageElement","handlePanoramaScroll","panoramaImageContainer","imgElement","elWidth","translateX","transform","webkitTransform","msTransform","polopolyComponent","desktopSourceSet","mobileSourceSet","overlayElement","addOrRemoveClass","el","className","contains","shouldBeActive","index","fgEls","bgEls","buffer","fg","bg","_background2","_background","bgStyle","activeEls","fgEl","bgEl","handleTriggerOnScroll","onScroll","actions","lastParsedHeight","lastScroll","actionsToDo","parsedWhen","parseWhen","when","parsedBreakpoints","reverse","breakpoint","isAnimated","classes","isBetweenBreakpoints","to","shouldAnimateIn","targetElement","getTarget","doAnimation","undoAnimation","bp","parseFunction","val","isTargetArray","tE","bgVideos","loop","v","pause","bgVideo","catch","paused","getInitialMuteButton","DefineOwnProperty","OrdinaryGetOwnProperty","IsExtensible","IsPropertyKey","oldDesc","extensible","CreateDataProperty","success","isPropertyDescriptor","IsAccessorDescriptor","ToPropertyDescriptor","inspect","$construct","DefinePropertyOrThrow","isConstructorMarker","err","isPrimitive","$preventExtensions","preventExtensions","$isExtensible","isExtensible","$match","hasRegExpMatcher","isRegExp","IsRegExp","arrayLength","regexLastIndex","$Number","$RegExp","$parseInteger","regexTester","isBinary","isOctal","isInvalidHexLiteral","nonWS","nonWSregex","hasNonWS","ws","trimRegex","$trim","ToPrimitive","NaN","trimmed","toPrimitive","input","$String","optMessage","$sign","prim","$abs","$floor","ES","$Math","pow","$test","regex","isArguments","$iterator","iterable","$Map","$Set","$arrayPush","$charCodeAt","$stringSlice","advanceStringIndex","S","second","getArrayIterator","arraylike","next","done","getNonCollectionIterator","noPrimordialCollections","nextIndex","isMap","isSet","$mapForEach","$setForEach","node","$mapIterator","$setIterator","getStopIterationIterator","$mapAtAtIterator","$setAtAtIterator","getCollectionIterator","isCallable","isDate","isSymbol","ordinaryToPrimitive","hint","method","methodNames","GetMethod","exoticToPrim","ES5internalSlots","actualHint","methods","objectOrFunction","setScheduler","scheduleFn","customSchedulerFn","setAsap","asapFn","asap","useVertxTimer","vertxNext","useSetTimeout","globalSetTimeout","then","onFulfillment","onRejection","parent","child","constructor","PROMISE_ID","makePromise","_state","invokeCallback","_result","subscribe","resolve$1","promise","resolve","selfFulfillment","cannotReturnOwn","tryThen","then$$1","fulfillmentHandler","rejectionHandler","handleForeignThenable","thenable","sealed","fulfill","reason","reject","_label","handleOwnThenable","FULFILLED","REJECTED","handleMaybeThenable","maybeThenable","publishRejection","_onerror","publish","PENDING","_subscribers","subscribers","settled","detail","hasCallback","succeeded","initializePromise","resolver","nextId","validationError","Enumerator","race","reject$1","needsResolver","needsNew","local","promiseToString","cast","Promise$1","_isArray","arg","scheduleFlush","browserWindow","browserGlobal","BrowserMutationObserver","MutationObserver","WebKitMutationObserver","isNode","isWorker","importScripts","MessageChannel","iterations","createTextNode","characterData","data","channel","port1","onmessage","port2","postMessage","vertx","runOnLoop","runOnContext","random","substring","_instanceConstructor","_remaining","_enumerate","_eachEntry","entry","resolve$$1","_then","didError","_settledAt","_willSettleAt","enumerator","finally","_setScheduler","_setAsap","_asap","that","bound","binder","boundLength","boundArgs","Empty","IntersectionObserverEntry","rootBounds","boundingClientRect","intersectionRect","getEmptyRect","targetRect","targetArea","intersectionArea","intersectionRatio","opt_options","nodeType","_checkForIntersections","THROTTLE_TIMEOUT","_callback","_observationTargets","_queuedEntries","_rootMarginValues","_parseRootMargin","rootMargin","thresholds","_initThresholds","margin","unit","performance","timer","addEvent","event","opt_useCapture","attachEvent","removeEvent","detatchEvent","computeRectIntersection","rect1","rect2","bottom","left","right","rect","containsDeep","getParentNode","parentNode","host","registry","some","item","_registerInstance","_monitorIntersections","unobserve","_unmonitorIntersections","_unregisterInstance","disconnect","takeRecords","records","opt_threshold","sort","t","opt_rootMargin","marginString","margins","split","exec","_monitoringIntersections","_monitoringInterval","setInterval","_domObserver","attributes","childList","subtree","clearInterval","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","rootContainsTarget","_rootContainsTarget","oldEntry","_computeTargetAndRootIntersection","newEntry","_hasCrossedThreshold","getComputedStyle","display","atRoot","parentRect","parentComputedStyle","body","documentElement","overflow","html","clientWidth","clientHeight","_expandRectByRootMargin","newRect","oldRatio","newRatio","$toString","isStandardArguments","isLegacyArguments","supportsStandardArguments","getDay","tryDateObject","exported","$mapHas","$setHas","$exec","isRegexMarker","badStringifier","throwRegexMarker","gOPD","symToStr","symStringRegex","isSymbolObject","getIterator","baseGetTag","undefinedTag","nullTag","symToStringTag","getRawTag","objectToString","baseTrim","trimmedEndIndex","reTrimStart","tag","unmasked","nativeObjectToString","objectProto","reWhitespace","charAt","isObjectLike","symbolTag","NAN","other","reIsBinary","reIsOctal","freeParseInt","reIsBadHex","addNumericSeparator","num","sepRegex","int","intStr","dec","wrapQuotes","defaultStyle","opts","quoteChar","quoteStyle","isError","isBoolean","hasShammedSymbols","symToString","isBigInt","bigIntValueOf","nameOf","f","functionToString","xs","mapSize","setSize","isWeakMap","weakMapHas","weakSetHas","isWeakRef","weakRefDeref","isWeakSet","isElement","HTMLElement","nodeName","inspectString","maxStringLength","remaining","trailer","lowbyte","charCodeAt","8","9","10","12","13","$toUpperCase","markBoxed","weakCollectionOf","collectionOf","size","indent","indentedJoin","$join","singleLineValues","getIndent","depth","baseIndent","base","lineJoiner","arrObjKeys","isArr","symMap","gOPS","j","isEnumerable","hasMap","mapSizeDescriptor","mapForEach","hasSet","setSizeDescriptor","setForEach","hasWeakMap","hasWeakSet","hasWeakRef","deref","booleanValueOf","toUpperCase","$toLowerCase","toLowerCase","$arrSlice","gPO","inspectCustom","custom","inspectSymbol","inspect_","seen","noIndent","newOpts","customInspect","numericSeparator","bigIntStr","maxDepth","symString","attrs","childNodes","cause","mapParts","setParts","ys","isPlainObject","protoTag","stringTag","constructorTag","keysShim","hasDontEnumBug","hasProtoEnumBug","dontEnums","equalsConstructorPrototype","ctor","excludedKeys","$applicationCache","$console","$external","$frame","$frameElement","$frames","$innerHeight","$innerWidth","$onmozfullscreenchange","$onmozfullscreenerror","$outerHeight","$outerWidth","$pageXOffset","$pageYOffset","$parent","$scrollLeft","$scrollTop","$scrollX","$scrollY","$self","$webkitIndexedDB","$webkitStorageInfo","$window","hasAutomationEqualityBug","equalsConstructorPrototypeIfNotBuggy","theKeys","skipProto","skipConstructor","origKeys","originalKeys"],"mappings":"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","file":"index-f166dd.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \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// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\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 = 140);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar undefined;\n\nvar $SyntaxError = SyntaxError;\nvar $Function = Function;\nvar $TypeError = TypeError;\n\n// eslint-disable-next-line consistent-return\nvar getEvalledConstructor = function (expressionSyntax) {\n\ttry {\n\t\treturn $Function('\"use strict\"; return (' + expressionSyntax + ').constructor;')();\n\t} catch (e) {}\n};\n\nvar $gOPD = Object.getOwnPropertyDescriptor;\nif ($gOPD) {\n\ttry {\n\t\t$gOPD({}, '');\n\t} catch (e) {\n\t\t$gOPD = null; // this is IE 8, which has a broken gOPD\n\t}\n}\n\nvar throwTypeError = function () {\n\tthrow new $TypeError();\n};\nvar ThrowTypeError = $gOPD\n\t? (function () {\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties\n\t\t\targuments.callee; // IE 8 does not throw here\n\t\t\treturn throwTypeError;\n\t\t} catch (calleeThrows) {\n\t\t\ttry {\n\t\t\t\t// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')\n\t\t\t\treturn $gOPD(arguments, 'callee').get;\n\t\t\t} catch (gOPDthrows) {\n\t\t\t\treturn throwTypeError;\n\t\t\t}\n\t\t}\n\t}())\n\t: throwTypeError;\n\nvar hasSymbols = __webpack_require__(23)();\n\nvar getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto\n\nvar needsEval = {};\n\nvar TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);\n\nvar INTRINSICS = {\n\t'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,\n\t'%Array%': Array,\n\t'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,\n\t'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,\n\t'%AsyncFromSyncIteratorPrototype%': undefined,\n\t'%AsyncFunction%': needsEval,\n\t'%AsyncGenerator%': needsEval,\n\t'%AsyncGeneratorFunction%': needsEval,\n\t'%AsyncIteratorPrototype%': needsEval,\n\t'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,\n\t'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,\n\t'%Boolean%': Boolean,\n\t'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,\n\t'%Date%': Date,\n\t'%decodeURI%': decodeURI,\n\t'%decodeURIComponent%': decodeURIComponent,\n\t'%encodeURI%': encodeURI,\n\t'%encodeURIComponent%': encodeURIComponent,\n\t'%Error%': Error,\n\t'%eval%': eval, // eslint-disable-line no-eval\n\t'%EvalError%': EvalError,\n\t'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,\n\t'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,\n\t'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,\n\t'%Function%': $Function,\n\t'%GeneratorFunction%': needsEval,\n\t'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,\n\t'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,\n\t'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,\n\t'%isFinite%': isFinite,\n\t'%isNaN%': isNaN,\n\t'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,\n\t'%JSON%': typeof JSON === 'object' ? JSON : undefined,\n\t'%Map%': typeof Map === 'undefined' ? undefined : Map,\n\t'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),\n\t'%Math%': Math,\n\t'%Number%': Number,\n\t'%Object%': Object,\n\t'%parseFloat%': parseFloat,\n\t'%parseInt%': parseInt,\n\t'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,\n\t'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,\n\t'%RangeError%': RangeError,\n\t'%ReferenceError%': ReferenceError,\n\t'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,\n\t'%RegExp%': RegExp,\n\t'%Set%': typeof Set === 'undefined' ? undefined : Set,\n\t'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),\n\t'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,\n\t'%String%': String,\n\t'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,\n\t'%Symbol%': hasSymbols ? Symbol : undefined,\n\t'%SyntaxError%': $SyntaxError,\n\t'%ThrowTypeError%': ThrowTypeError,\n\t'%TypedArray%': TypedArray,\n\t'%TypeError%': $TypeError,\n\t'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,\n\t'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,\n\t'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,\n\t'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,\n\t'%URIError%': URIError,\n\t'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,\n\t'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,\n\t'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet\n};\n\nvar doEval = function doEval(name) {\n\tvar value;\n\tif (name === '%AsyncFunction%') {\n\t\tvalue = getEvalledConstructor('async function () {}');\n\t} else if (name === '%GeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('function* () {}');\n\t} else if (name === '%AsyncGeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('async function* () {}');\n\t} else if (name === '%AsyncGenerator%') {\n\t\tvar fn = doEval('%AsyncGeneratorFunction%');\n\t\tif (fn) {\n\t\t\tvalue = fn.prototype;\n\t\t}\n\t} else if (name === '%AsyncIteratorPrototype%') {\n\t\tvar gen = doEval('%AsyncGenerator%');\n\t\tif (gen) {\n\t\t\tvalue = getProto(gen.prototype);\n\t\t}\n\t}\n\n\tINTRINSICS[name] = value;\n\n\treturn value;\n};\n\nvar LEGACY_ALIASES = {\n\t'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],\n\t'%ArrayPrototype%': ['Array', 'prototype'],\n\t'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],\n\t'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],\n\t'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],\n\t'%ArrayProto_values%': ['Array', 'prototype', 'values'],\n\t'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],\n\t'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],\n\t'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],\n\t'%BooleanPrototype%': ['Boolean', 'prototype'],\n\t'%DataViewPrototype%': ['DataView', 'prototype'],\n\t'%DatePrototype%': ['Date', 'prototype'],\n\t'%ErrorPrototype%': ['Error', 'prototype'],\n\t'%EvalErrorPrototype%': ['EvalError', 'prototype'],\n\t'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],\n\t'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],\n\t'%FunctionPrototype%': ['Function', 'prototype'],\n\t'%Generator%': ['GeneratorFunction', 'prototype'],\n\t'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],\n\t'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],\n\t'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],\n\t'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],\n\t'%JSONParse%': ['JSON', 'parse'],\n\t'%JSONStringify%': ['JSON', 'stringify'],\n\t'%MapPrototype%': ['Map', 'prototype'],\n\t'%NumberPrototype%': ['Number', 'prototype'],\n\t'%ObjectPrototype%': ['Object', 'prototype'],\n\t'%ObjProto_toString%': ['Object', 'prototype', 'toString'],\n\t'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],\n\t'%PromisePrototype%': ['Promise', 'prototype'],\n\t'%PromiseProto_then%': ['Promise', 'prototype', 'then'],\n\t'%Promise_all%': ['Promise', 'all'],\n\t'%Promise_reject%': ['Promise', 'reject'],\n\t'%Promise_resolve%': ['Promise', 'resolve'],\n\t'%RangeErrorPrototype%': ['RangeError', 'prototype'],\n\t'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],\n\t'%RegExpPrototype%': ['RegExp', 'prototype'],\n\t'%SetPrototype%': ['Set', 'prototype'],\n\t'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],\n\t'%StringPrototype%': ['String', 'prototype'],\n\t'%SymbolPrototype%': ['Symbol', 'prototype'],\n\t'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],\n\t'%TypedArrayPrototype%': ['TypedArray', 'prototype'],\n\t'%TypeErrorPrototype%': ['TypeError', 'prototype'],\n\t'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],\n\t'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],\n\t'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],\n\t'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],\n\t'%URIErrorPrototype%': ['URIError', 'prototype'],\n\t'%WeakMapPrototype%': ['WeakMap', 'prototype'],\n\t'%WeakSetPrototype%': ['WeakSet', 'prototype']\n};\n\nvar bind = __webpack_require__(22);\nvar hasOwn = __webpack_require__(4);\nvar $concat = bind.call(Function.call, Array.prototype.concat);\nvar $spliceApply = bind.call(Function.apply, Array.prototype.splice);\nvar $replace = bind.call(Function.call, String.prototype.replace);\nvar $strSlice = bind.call(Function.call, String.prototype.slice);\n\n/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */\nvar rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\nvar reEscapeChar = /\\\\(\\\\)?/g; /** Used to match backslashes in property paths. */\nvar stringToPath = function stringToPath(string) {\n\tvar first = $strSlice(string, 0, 1);\n\tvar last = $strSlice(string, -1);\n\tif (first === '%' && last !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected closing `%`');\n\t} else if (last === '%' && first !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected opening `%`');\n\t}\n\tvar result = [];\n\t$replace(string, rePropName, function (match, number, quote, subString) {\n\t\tresult[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;\n\t});\n\treturn result;\n};\n/* end adaptation */\n\nvar getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {\n\tvar intrinsicName = name;\n\tvar alias;\n\tif (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n\t\talias = LEGACY_ALIASES[intrinsicName];\n\t\tintrinsicName = '%' + alias[0] + '%';\n\t}\n\n\tif (hasOwn(INTRINSICS, intrinsicName)) {\n\t\tvar value = INTRINSICS[intrinsicName];\n\t\tif (value === needsEval) {\n\t\t\tvalue = doEval(intrinsicName);\n\t\t}\n\t\tif (typeof value === 'undefined' && !allowMissing) {\n\t\t\tthrow new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');\n\t\t}\n\n\t\treturn {\n\t\t\talias: alias,\n\t\t\tname: intrinsicName,\n\t\t\tvalue: value\n\t\t};\n\t}\n\n\tthrow new $SyntaxError('intrinsic ' + name + ' does not exist!');\n};\n\nmodule.exports = function GetIntrinsic(name, allowMissing) {\n\tif (typeof name !== 'string' || name.length === 0) {\n\t\tthrow new $TypeError('intrinsic name must be a non-empty string');\n\t}\n\tif (arguments.length > 1 && typeof allowMissing !== 'boolean') {\n\t\tthrow new $TypeError('\"allowMissing\" argument must be a boolean');\n\t}\n\n\tvar parts = stringToPath(name);\n\tvar intrinsicBaseName = parts.length > 0 ? parts[0] : '';\n\n\tvar intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);\n\tvar intrinsicRealName = intrinsic.name;\n\tvar value = intrinsic.value;\n\tvar skipFurtherCaching = false;\n\n\tvar alias = intrinsic.alias;\n\tif (alias) {\n\t\tintrinsicBaseName = alias[0];\n\t\t$spliceApply(parts, $concat([0, 1], alias));\n\t}\n\n\tfor (var i = 1, isOwn = true; i < parts.length; i += 1) {\n\t\tvar part = parts[i];\n\t\tvar first = $strSlice(part, 0, 1);\n\t\tvar last = $strSlice(part, -1);\n\t\tif (\n\t\t\t(\n\t\t\t\t(first === '\"' || first === \"'\" || first === '`')\n\t\t\t\t|| (last === '\"' || last === \"'\" || last === '`')\n\t\t\t)\n\t\t\t&& first !== last\n\t\t) {\n\t\t\tthrow new $SyntaxError('property names with quotes must have matching quotes');\n\t\t}\n\t\tif (part === 'constructor' || !isOwn) {\n\t\t\tskipFurtherCaching = true;\n\t\t}\n\n\t\tintrinsicBaseName += '.' + part;\n\t\tintrinsicRealName = '%' + intrinsicBaseName + '%';\n\n\t\tif (hasOwn(INTRINSICS, intrinsicRealName)) {\n\t\t\tvalue = INTRINSICS[intrinsicRealName];\n\t\t} else if (value != null) {\n\t\t\tif (!(part in value)) {\n\t\t\t\tif (!allowMissing) {\n\t\t\t\t\tthrow new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');\n\t\t\t\t}\n\t\t\t\treturn void undefined;\n\t\t\t}\n\t\t\tif ($gOPD && (i + 1) >= parts.length) {\n\t\t\t\tvar desc = $gOPD(value, part);\n\t\t\t\tisOwn = !!desc;\n\n\t\t\t\t// By convention, when a data property is converted to an accessor\n\t\t\t\t// property to emulate a data property that does not suffer from\n\t\t\t\t// the override mistake, that accessor's getter is marked with\n\t\t\t\t// an `originalValue` property. Here, when we detect this, we\n\t\t\t\t// uphold the illusion by pretending to see that original data\n\t\t\t\t// property, i.e., returning the value rather than the getter\n\t\t\t\t// itself.\n\t\t\t\tif (isOwn && 'get' in desc && !('originalValue' in desc.get)) {\n\t\t\t\t\tvalue = desc.get;\n\t\t\t\t} else {\n\t\t\t\t\tvalue = value[part];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tisOwn = hasOwn(value, part);\n\t\t\t\tvalue = value[part];\n\t\t\t}\n\n\t\t\tif (isOwn && !skipFurtherCaching) {\n\t\t\t\tINTRINSICS[intrinsicRealName] = value;\n\t\t\t}\n\t\t}\n\t}\n\treturn value;\n};\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"backgrounds\":\"nrk-filmavis-liersykehus-backgrounds\",\"background\":\"nrk-filmavis-liersykehus-background\",\"visible\":\"nrk-filmavis-liersykehus-visible\",\"background--active\":\"nrk-filmavis-liersykehus-background--active\",\"backgroundActive\":\"nrk-filmavis-liersykehus-background--active\",\"background--ready\":\"nrk-filmavis-liersykehus-background--ready\",\"backgroundReady\":\"nrk-filmavis-liersykehus-background--ready\",\"superoverlay\":\"nrk-filmavis-liersykehus-superoverlay\",\"backgroundGradient\":\"nrk-filmavis-liersykehus-backgroundGradient\",\"uncropped-image-container\":\"nrk-filmavis-liersykehus-uncropped-image-container\",\"uncroppedImageContainer\":\"nrk-filmavis-liersykehus-uncropped-image-container\",\"panorama-image-container\":\"nrk-filmavis-liersykehus-panorama-image-container\",\"panoramaImageContainer\":\"nrk-filmavis-liersykehus-panorama-image-container\",\"trigger-on-scroll-container\":\"nrk-filmavis-liersykehus-trigger-on-scroll-container\",\"triggerOnScrollContainer\":\"nrk-filmavis-liersykehus-trigger-on-scroll-container\",\"background-overlay\":\"nrk-filmavis-liersykehus-background-overlay\",\"backgroundOverlay\":\"nrk-filmavis-liersykehus-background-overlay\"};\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar callBind = __webpack_require__(15);\n\nvar $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));\n\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\tvar intrinsic = GetIntrinsic(name, !!allowMissing);\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBind(intrinsic);\n\t}\n\treturn intrinsic;\n};\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar ES5Type = __webpack_require__(98);\n\n// https://262.ecma-international.org/11.0/#sec-ecmascript-data-types-and-values\n\nmodule.exports = function Type(x) {\n\tif (typeof x === 'symbol') {\n\t\treturn 'Symbol';\n\t}\n\tif (typeof x === 'bigint') {\n\t\treturn 'BigInt';\n\t}\n\treturn ES5Type(x);\n};\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar bind = __webpack_require__(22);\n\nmodule.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar keys = __webpack_require__(138);\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';\n\nvar toStr = Object.prototype.toString;\nvar concat = Array.prototype.concat;\nvar origDefineProperty = Object.defineProperty;\n\nvar isFunction = function (fn) {\n\treturn typeof fn === 'function' && toStr.call(fn) === '[object Function]';\n};\n\nvar arePropertyDescriptorsSupported = function () {\n\tvar obj = {};\n\ttry {\n\t\torigDefineProperty(obj, 'x', { enumerable: false, value: obj });\n\t\t// eslint-disable-next-line no-unused-vars, no-restricted-syntax\n\t\tfor (var _ in obj) { // jscs:ignore disallowUnusedVariables\n\t\t\treturn false;\n\t\t}\n\t\treturn obj.x === obj;\n\t} catch (e) { /* this is IE 8. */\n\t\treturn false;\n\t}\n};\nvar supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();\n\nvar defineProperty = function (object, name, value, predicate) {\n\tif (name in object && (!isFunction(predicate) || !predicate())) {\n\t\treturn;\n\t}\n\tif (supportsDescriptors) {\n\t\torigDefineProperty(object, name, {\n\t\t\tconfigurable: true,\n\t\t\tenumerable: false,\n\t\t\tvalue: value,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\tobject[name] = value;\n\t}\n};\n\nvar defineProperties = function (object, map) {\n\tvar predicates = arguments.length > 2 ? arguments[2] : {};\n\tvar props = keys(map);\n\tif (hasSymbols) {\n\t\tprops = concat.call(props, Object.getOwnPropertySymbols(map));\n\t}\n\tfor (var i = 0; i < props.length; i += 1) {\n\t\tdefineProperty(object, props[i], map[props[i]], predicates[props[i]]);\n\t}\n};\n\ndefineProperties.supportsDescriptors = !!supportsDescriptors;\n\nmodule.exports = defineProperties;\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"align-top\":\"nrk-filmavis-liersykehus-align-top\",\"alignTop\":\"nrk-filmavis-liersykehus-align-top\",\"align-center\":\"nrk-filmavis-liersykehus-align-center\",\"alignCenter\":\"nrk-filmavis-liersykehus-align-center\",\"align-left\":\"nrk-filmavis-liersykehus-align-left\",\"alignLeft\":\"nrk-filmavis-liersykehus-align-left\",\"align-right\":\"nrk-filmavis-liersykehus-align-right\",\"alignRight\":\"nrk-filmavis-liersykehus-align-right\",\"align-middle\":\"nrk-filmavis-liersykehus-align-middle\",\"alignMiddle\":\"nrk-filmavis-liersykehus-align-middle\",\"align-bottom\":\"nrk-filmavis-liersykehus-align-bottom\",\"alignBottom\":\"nrk-filmavis-liersykehus-align-bottom\",\"mobile-align-top\":\"nrk-filmavis-liersykehus-mobile-align-top\",\"mobileAlignTop\":\"nrk-filmavis-liersykehus-mobile-align-top\",\"mobile-align-center\":\"nrk-filmavis-liersykehus-mobile-align-center\",\"mobileAlignCenter\":\"nrk-filmavis-liersykehus-mobile-align-center\",\"mobile-align-left\":\"nrk-filmavis-liersykehus-mobile-align-left\",\"mobileAlignLeft\":\"nrk-filmavis-liersykehus-mobile-align-left\",\"mobile-align-right\":\"nrk-filmavis-liersykehus-mobile-align-right\",\"mobileAlignRight\":\"nrk-filmavis-liersykehus-mobile-align-right\",\"mobile-align-middle\":\"nrk-filmavis-liersykehus-mobile-align-middle\",\"mobileAlignMiddle\":\"nrk-filmavis-liersykehus-mobile-align-middle\",\"mobile-align-bottom\":\"nrk-filmavis-liersykehus-mobile-align-bottom\",\"mobileAlignBottom\":\"nrk-filmavis-liersykehus-mobile-align-bottom\"};\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.supportedWidths = undefined;\nexports.createSrcSet = createSrcSet;\nexports.prepareUrl = prepareUrl;\nexports.getPolopolyImageElement = getPolopolyImageElement;\nexports.getImageForegroundElement = getImageForegroundElement;\nexports.getImageElement = getImageElement;\n\nvar _serumImagecropUtils = __webpack_require__(28);\n\nvar supportedWidths = exports.supportedWidths = [320, 450, 650, 768, 900, 1280, 1600, 1920, 2400];\n\nfunction createSrcSet(imageId, ratio, supportedWidths) {\n  return supportedWidths.map(function (width) {\n    var imageUrl = (0, _serumImagecropUtils.createImageUrl)({ id: imageId, width: width, ratio: ratio, quality: 0.7 });\n    return imageUrl + ' ' + width + 'w';\n  }).join(', ');\n}\n\nfunction prepareUrl(url, ratio, width) {\n  return url.replace('{{ratio}}', ratio).replace('{{width}}', width);\n}\n\nfunction getPolopolyImageElement(polopolyId) {\n  var alignmentClasses = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n  var imgStyle = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n  var pictureStyle = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';\n\n  // const defaultUrl = createImageUrl({ id: polopolyId, width: 1600, ratio: '1:1', quality: 0.7 })\n  // const desktopSourceSet = createSrcSet(polopolyId, '1:1', supportedWidths)\n  var defaultUrl = (0, _serumImagecropUtils.createImageUrl)({\n    id: polopolyId,\n    width: 1600,\n    ratio: '16:9',\n    quality: 0.7\n  });\n  var desktopSourceSet = createSrcSet(polopolyId, '16:9', supportedWidths);\n\n  var mobileSourceSet = createSrcSet(polopolyId, '3:4', supportedWidths);\n\n  return '\\n    <picture style=\"' + pictureStyle + '\">\\n      <source media=\"(min-aspect-ratio: 3/4)\" srcset=\"' + desktopSourceSet + '\">\\n      <img src=\"' + defaultUrl + '\" srcset=\"' + mobileSourceSet + '\" class=\"' + alignmentClasses + '\" style=\"' + imgStyle + '\">\\n    </picture>';\n}\n\nfunction getImageForegroundElement(imageUrl) {\n  var alignmentClasses = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n  var imgStyle = '';\n  return '<img src=\"' + imageUrl + '\" class=\"' + alignmentClasses + '\" style=\"' + imgStyle + '\">';\n}\n\nfunction getImageElement(imageUrl) {\n  var alignmentClasses = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n  var imgStyle = 'min-width: 100%; min-height: 100%; position: relative;';\n  return '<img src=\"' + imageUrl + '\" class=\"' + alignmentClasses + '\" style=\"' + imgStyle + '\">';\n}\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// https://ecma-international.org/ecma-262/6.0/#sec-ispropertykey\n\nmodule.exports = function IsPropertyKey(argument) {\n\treturn typeof argument === 'string' || typeof argument === 'symbol';\n};\n\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// http://262.ecma-international.org/5.1/#sec-9.11\n\nmodule.exports = __webpack_require__(25);\n\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = Number.isNaN || function isNaN(a) {\n\treturn a !== a;\n};\n\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"video\":\"nrk-filmavis-liersykehus-video\",\"darkedout\":\"nrk-filmavis-liersykehus-darkedout\",\"fullscreen--video\":\"nrk-filmavis-liersykehus-fullscreen--video\",\"fullscreenVideo\":\"nrk-filmavis-liersykehus-fullscreen--video\",\"fullscreen--video--container\":\"nrk-filmavis-liersykehus-fullscreen--video--container\",\"fullscreenVideoContainer\":\"nrk-filmavis-liersykehus-fullscreen--video--container\",\"video-mute-button\":\"nrk-filmavis-liersykehus-video-mute-button\",\"videoMuteButton\":\"nrk-filmavis-liersykehus-video-mute-button\",\"video-mute-svg-muted-hover\":\"nrk-filmavis-liersykehus-video-mute-svg-muted-hover\",\"videoMuteSvgMutedHover\":\"nrk-filmavis-liersykehus-video-mute-svg-muted-hover\",\"video-mute-svg-unmuted-hover\":\"nrk-filmavis-liersykehus-video-mute-svg-unmuted-hover\",\"videoMuteSvgUnmutedHover\":\"nrk-filmavis-liersykehus-video-mute-svg-unmuted-hover\",\"visible\":\"nrk-filmavis-liersykehus-visible\",\"hide-play\":\"nrk-filmavis-liersykehus-hide-play\",\"hidePlay\":\"nrk-filmavis-liersykehus-hide-play\",\"subtitlescontainer\":\"nrk-filmavis-liersykehus-subtitlescontainer\",\"subtitles\":\"nrk-filmavis-liersykehus-subtitles\"};\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar hasSymbols = __webpack_require__(24);\n\nmodule.exports = function hasToStringTagShams() {\n\treturn hasSymbols() && !!Symbol.toStringTag;\n};\n\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.initialize = initialize;\nexports.trackAction = trackAction;\nvar label = 'snapchat-saken';\nvar isTrackingEnabled = false;\n\nfunction initialize(trackingEnabled) {\n  isTrackingEnabled = trackingEnabled;\n  // label = name\n}\n\nfunction trackAction(action) {\n  sendToGoogleAnalytics({\n    category: 'dh-richer-feature',\n    action: action,\n    label: label\n  });\n}\n\nfunction sendToGoogleAnalytics(_ref) {\n  var category = _ref.category,\n      action = _ref.action,\n      label = _ref.label;\n\n  if (window.ga && isTrackingEnabled) {\n    window.ga('send', 'event', category, action, label);\n  } else {\n    if (typeof console !== 'undefined') {\n      console.log(category, action, label);\n    }\n  }\n}\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getOverlayElement = undefined;\n\nvar _background = __webpack_require__(1);\n\nvar getOverlayElement = exports.getOverlayElement = function getOverlayElement(overlay) {\n  var defaultOverlay = {\n    opacity: 0.6,\n    color: '#000'\n  };\n\n  if (overlay === true) {\n    return '<div class=\"' + _background.backgroundOverlay + '\" style=\"background-color: ' + defaultOverlay.color + '; opacity: ' + defaultOverlay.opacity + '\"></div>';\n  }\n\n  if (overlay) {\n    Object.assign(defaultOverlay, overlay);\n    return '<div class=\"' + _background.backgroundOverlay + '\" style=\"background-color: ' + defaultOverlay.color + '; opacity: ' + defaultOverlay.opacity + '\"></div>';\n  }\n\n  return '';\n};\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar bind = __webpack_require__(22);\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $apply = GetIntrinsic('%Function.prototype.apply%');\nvar $call = GetIntrinsic('%Function.prototype.call%');\nvar $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true);\nvar $max = GetIntrinsic('%Math.max%');\n\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = null;\n\t}\n}\n\nmodule.exports = function callBind(originalFunction) {\n\tvar func = $reflectApply(bind, $call, arguments);\n\tif ($gOPD && $defineProperty) {\n\t\tvar desc = $gOPD(func, 'length');\n\t\tif (desc.configurable) {\n\t\t\t// original length, plus the receiver, minus any additional arguments (after the receiver)\n\t\t\t$defineProperty(\n\t\t\t\tfunc,\n\t\t\t\t'length',\n\t\t\t\t{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }\n\t\t\t);\n\t\t}\n\t}\n\treturn func;\n};\n\nvar applyBind = function applyBind() {\n\treturn $reflectApply(bind, $apply, arguments);\n};\n\nif ($defineProperty) {\n\t$defineProperty(module.exports, 'apply', { value: applyBind });\n} else {\n\tmodule.exports.apply = applyBind;\n}\n\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $Array = GetIntrinsic('%Array%');\n\n// eslint-disable-next-line global-require\nvar toStr = !$Array.isArray && __webpack_require__(2)('Object.prototype.toString');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isarray\n\nmodule.exports = $Array.isArray || function IsArray(argument) {\n\treturn toStr(argument) === '[object Array]';\n};\n\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(94);\n\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar MAX_SAFE_INTEGER = __webpack_require__(104);\n\nvar ToIntegerOrInfinity = __webpack_require__(42);\n\nmodule.exports = function ToLength(argument) {\n\tvar len = ToIntegerOrInfinity(argument);\n\tif (len <= 0) { return 0; } // includes converting -0 to +0\n\tif (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; }\n\treturn len;\n};\n\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $Object = GetIntrinsic('%Object%');\n\nvar RequireObjectCoercible = __webpack_require__(17);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-toobject\n\nmodule.exports = function ToObject(value) {\n\tRequireObjectCoercible(value);\n\treturn $Object(value);\n};\n\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $TypeError = GetIntrinsic('%TypeError%');\nvar $SyntaxError = GetIntrinsic('%SyntaxError%');\n\nvar has = __webpack_require__(4);\n\nvar predicates = {\n\t// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type\n\t'Property Descriptor': function isPropertyDescriptor(Type, Desc) {\n\t\tif (Type(Desc) !== 'Object') {\n\t\t\treturn false;\n\t\t}\n\t\tvar allowed = {\n\t\t\t'[[Configurable]]': true,\n\t\t\t'[[Enumerable]]': true,\n\t\t\t'[[Get]]': true,\n\t\t\t'[[Set]]': true,\n\t\t\t'[[Value]]': true,\n\t\t\t'[[Writable]]': true\n\t\t};\n\n\t\tfor (var key in Desc) { // eslint-disable-line\n\t\t\tif (has(Desc, key) && !allowed[key]) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tvar isData = has(Desc, '[[Value]]');\n\t\tvar IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]');\n\t\tif (isData && IsAccessor) {\n\t\t\tthrow new $TypeError('Property Descriptors may not be both accessor and data descriptors');\n\t\t}\n\t\treturn true;\n\t}\n};\n\nmodule.exports = function assertRecord(Type, recordType, argumentName, value) {\n\tvar predicate = predicates[recordType];\n\tif (typeof predicate !== 'function') {\n\t\tthrow new $SyntaxError('unknown record type: ' + recordType);\n\t}\n\tif (!predicate(Type, value)) {\n\t\tthrow new $TypeError(argumentName + ' must be a ' + recordType);\n\t}\n};\n\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"mood--background-light\":\"nrk-filmavis-liersykehus-mood--background-light\",\"moodBackgroundLight\":\"nrk-filmavis-liersykehus-mood--background-light\",\"mood--background-medium\":\"nrk-filmavis-liersykehus-mood--background-medium\",\"moodBackgroundMedium\":\"nrk-filmavis-liersykehus-mood--background-medium\",\"mood--background-dark\":\"nrk-filmavis-liersykehus-mood--background-dark\",\"moodBackgroundDark\":\"nrk-filmavis-liersykehus-mood--background-dark\",\"mood--background-default\":\"nrk-filmavis-liersykehus-mood--background-default\",\"moodBackgroundDefault\":\"nrk-filmavis-liersykehus-mood--background-default\",\"mood--foreground-light\":\"nrk-filmavis-liersykehus-mood--foreground-light\",\"moodForegroundLight\":\"nrk-filmavis-liersykehus-mood--foreground-light\",\"mood--foreground-medium\":\"nrk-filmavis-liersykehus-mood--foreground-medium\",\"moodForegroundMedium\":\"nrk-filmavis-liersykehus-mood--foreground-medium\",\"mood--foreground-dark\":\"nrk-filmavis-liersykehus-mood--foreground-dark\",\"moodForegroundDark\":\"nrk-filmavis-liersykehus-mood--foreground-dark\",\"mood--foreground-default\":\"nrk-filmavis-liersykehus-mood--foreground-default\",\"moodForegroundDefault\":\"nrk-filmavis-liersykehus-mood--foreground-default\",\"type--image\":\"nrk-filmavis-liersykehus-type--image\",\"typeImage\":\"nrk-filmavis-liersykehus-type--image\"};\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar implementation = __webpack_require__(115);\n\nmodule.exports = Function.prototype.bind || implementation;\n\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar origSymbol = typeof Symbol !== 'undefined' && Symbol;\nvar hasSymbolSham = __webpack_require__(24);\n\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/* eslint complexity: [2, 18], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\tvar descriptor = Object.getOwnPropertyDescriptor(obj, sym);\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike;\nvar isCallableMarker;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n\ttry {\n\t\tbadArrayLike = Object.defineProperty({}, 'length', {\n\t\t\tget: function () {\n\t\t\t\tthrow isCallableMarker;\n\t\t\t}\n\t\t});\n\t\tisCallableMarker = {};\n\t\t// eslint-disable-next-line no-throw-literal\n\t\treflectApply(function () { throw 42; }, null, badArrayLike);\n\t} catch (_) {\n\t\tif (_ !== isCallableMarker) {\n\t\t\treflectApply = null;\n\t\t}\n\t}\n} else {\n\treflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value) {\n\ttry {\n\t\tvar fnStr = fnToStr.call(value);\n\t\treturn constructorRegex.test(fnStr);\n\t} catch (e) {\n\t\treturn false; // not a function\n\t}\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value) {\n\ttry {\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tfnToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n/* globals document: false */\nvar documentDotAll = typeof document === 'object' && typeof document.all === 'undefined' && document.all !== undefined ? document.all : {};\n\nmodule.exports = reflectApply\n\t? function isCallable(value) {\n\t\tif (value === documentDotAll) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (typeof value === 'function' && !value.prototype) { return true; }\n\t\ttry {\n\t\t\treflectApply(value, null, badArrayLike);\n\t\t} catch (e) {\n\t\t\tif (e !== isCallableMarker) { return false; }\n\t\t}\n\t\treturn !isES6ClassFn(value);\n\t}\n\t: function isCallable(value) {\n\t\tif (value === documentDotAll) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (typeof value === 'function' && !value.prototype) { return true; }\n\t\tif (hasToStringTag) { return tryFunctionObject(value); }\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tvar strClass = toStr.call(value);\n\t\treturn strClass === fnClass || strClass === genClass;\n\t};\n\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports) {\n\n/**\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/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar debounce = __webpack_require__(52),\n    isObject = __webpack_require__(26);\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\nmodule.exports = throttle;\n\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n(function (global, factory) {\n   true ? factory(exports) :\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n  (factory((global.nrkSerumImagecropUtils = {})));\n}(this, (function (exports) { 'use strict';\n\n  var isPolopolyIdRegex = /^[1-9]{1,2}\\.\\d+$/;\n\n  function isPolopolyId(id) {\n    if (!id) {\n      return false;\n    }\n    return isPolopolyIdRegex.test(id);\n  }\n\n  // prettier-ignore\n  var widths = [100, 120, 150, 174, 200, 206, 225, 244, 250, 252, 300, 320, 350, 400, 450, 452, 460, 462, 500, 600, 650, 665, 682, 700, 734, 768, 900, 974, 1200, 1280, 1360, 1450, 1550, 1600, 1700, 1800, 1920, 2000, 2100, 2200, 2300, 2400];\n\n  // prettier-ignore\n  var ratios = ['1:1', '11', '16:9', '169', '16:3', '163', '3:4', '34'];\n\n  // prettier-ignore\n  var qualities = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0];\n\n  var _baseUrl = 'https://nrk.no/serum/api/imagecrop/';\n\n  function createUrl(_ref) {\n    var id = _ref.id,\n        ratio = _ref.ratio,\n        width = _ref.width,\n        quality = _ref.quality;\n\n    var url = '' + _baseUrl + id;\n    var queryString = createQueryString({ ratio: ratio, width: width, quality: quality });\n    if (queryString) {\n      url += '?' + queryString;\n    }\n    return url;\n  }\n\n  function createQueryString(_ref2) {\n    var ratio = _ref2.ratio,\n        width = _ref2.width,\n        quality = _ref2.quality;\n\n    if (!ratio && !width) {\n      return quality ? 'quality=' + quality : '';\n    }\n    var ratioPart = ratio ? 'f' + ratio.replace(':', '') : '';\n    var widthPart = width ? 'w' + width : '';\n    var qualityPart = quality ? '&quality=' + quality : '';\n    return 'cropid=' + ratioPart + widthPart + qualityPart;\n  }\n\n  function getClosestNumber(goal, targets) {\n    if (!isValidGoal(goal)) {\n      throw new Error('\\n      getClosestNumber(goal, targets): passing a goal of ' + goal + '\\n      is not supported. Pass a number');\n    }\n    if (!isValidTargets(targets)) {\n      throw new Error('\\n      getClosestNumber(goal, targets): targets ' + targets.toString() + ' is invald.\\n      Pass an array of numbers');\n    }\n    if (!targets.length) {\n      // eslint-disable-next-line no-undefined\n      return undefined;\n    }\n    return targets.reduce(function (prev, curr) {\n      return Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev;\n    });\n  }\n\n  function isValidGoal(goal) {\n    return typeof goal === 'number';\n  }\n\n  function isValidTargets(targets) {\n    if (!targets) {\n      return false;\n    }\n    var isValid = true;\n    for (var i = 0; i < targets.length; i++) {\n      if (typeof targets[i] !== 'number') {\n        isValid = false;\n        break;\n      }\n    }\n    // return targets.some((target) => {\n    //   return (typeof target !== 'number')\n    // })\n    return isValid;\n  }\n\n  function isValidRatio(ratio, supportedRatios) {\n    if (!Array.isArray(supportedRatios)) {\n      // eslint-disable-next-line no-useless-escape\n      throw new Error(\"isValidRatio(ratio, supportedRatios): supportedRatios '\" + supportedRatios + \"' is not supported. Pass an array of supported ratios\");\n    }\n    if (!ratio) {\n      return false;\n    }\n    return supportedRatios.includes(ratio);\n  }\n\n  function isValidQuality(quality, supportedQualities) {\n    if (!Array.isArray(supportedQualities)) {\n      // eslint-disable-next-line no-useless-escape\n      throw new Error(\"isValidQuality(quality, supportedQualities): supportedQualities '\" + supportedQualities + \"' is not supported. Pass an array of supported qualities\");\n    }\n    if (!quality) {\n      return false;\n    }\n    return supportedQualities.includes(quality);\n  }\n\n  function createImageUrl(options) {\n    var polopolyId = options.id,\n        width = options.width,\n        ratio = options.ratio,\n        quality = options.quality;\n\n\n    if (!isPolopolyId(polopolyId)) {\n      throw new Error('createSerumImageUrl(): invalid polopolyId. Got ' + polopolyId);\n    }\n\n    var args = {\n      id: polopolyId,\n      ratio: null,\n      quality: 0.8,\n      width: 0\n\n      // If a ratio is provided, ensure that it is valid\n    };if (hasOption(ratio)) {\n      if (!isValidRatio(ratio, ratios)) {\n        throw new Error('\\n      createSerumImageUrl(): ratio ' + ratio + ' is not supported.\\n      Supported ratios are ' + ratios.toString());\n      }\n      args.ratio = ratio;\n    }\n\n    // If a quality is provided, ensure that it is valid\n    if (hasOption(quality)) {\n      if (!isValidQuality(quality, qualities)) {\n        throw new Error('\\n      createSerumImageUrl(): quality ' + quality + ' is not supported.\\n      Supported qualities are ' + qualities.toString());\n      }\n      args.quality = quality;\n    }\n\n    // If a width is provided, ensure that is is a positive integer\n    if (hasOption(width)) {\n      if (!isNumber(width) || width <= 0) {\n        var errorMessage = 'createSerumImageUrl(): width must be a positive integer, got ' + width;\n        throw new Error(errorMessage);\n      }\n      var isSupportedWidth = widths.includes(width);\n      var closestWidth = getClosestNumber(width, widths);\n      if (typeof closestWidth !== 'undefined' && closestWidth) {\n        args.width = isSupportedWidth ? width : closestWidth;\n      }\n    }\n\n    return createUrl(args);\n  }\n\n  function hasOption(option) {\n    return typeof option !== 'undefined' && option;\n  }\n\n  function isNumber(number) {\n    return Number.isInteger(number);\n  }\n\n  exports.createImageUrl = createImageUrl;\n  exports.ratios = ratios;\n  exports.widths = widths;\n  exports.qualities = qualities;\n  exports.isPolopolyId = isPolopolyId;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar ToIntegerOrInfinity = __webpack_require__(42);\nvar ToLength = __webpack_require__(18);\nvar ToObject = __webpack_require__(19);\nvar SameValueZero = __webpack_require__(90);\nvar $isNaN = __webpack_require__(10);\nvar $isFinite = __webpack_require__(45);\nvar GetIntrinsic = __webpack_require__(0);\nvar callBound = __webpack_require__(2);\nvar isString = __webpack_require__(49);\n\nvar $charAt = callBound('String.prototype.charAt');\nvar $indexOf = GetIntrinsic('%Array.prototype.indexOf%'); // TODO: use callBind.apply without breaking IE 8\nvar $max = GetIntrinsic('%Math.max%');\n\nmodule.exports = function includes(searchElement) {\n\tvar fromIndex = arguments.length > 1 ? ToIntegerOrInfinity(arguments[1]) : 0;\n\tif ($indexOf && !$isNaN(searchElement) && $isFinite(fromIndex) && typeof searchElement !== 'undefined') {\n\t\treturn $indexOf.apply(this, arguments) > -1;\n\t}\n\n\tvar O = ToObject(this);\n\tvar length = ToLength(O.length);\n\tif (length === 0) {\n\t\treturn false;\n\t}\n\tvar k = fromIndex >= 0 ? fromIndex : $max(0, length + fromIndex);\n\twhile (k < length) {\n\t\tif (SameValueZero(searchElement, isString(O) ? $charAt(O, k) : O[k])) {\n\t\t\treturn true;\n\t\t}\n\t\tk += 1;\n\t}\n\treturn false;\n};\n\n\n/***/ }),\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar implementation = __webpack_require__(29);\n\nmodule.exports = function getPolyfill() {\n\treturn Array.prototype.includes || implementation;\n};\n\n\n/***/ }),\n/* 31 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Call = __webpack_require__(37);\nvar CreateDataPropertyOrThrow = __webpack_require__(82);\nvar Get = __webpack_require__(84);\nvar IsCallable = __webpack_require__(9);\nvar IsConstructor = __webpack_require__(86);\nvar ToObject = __webpack_require__(19);\nvar ToLength = __webpack_require__(18);\nvar ToString = __webpack_require__(93);\n\nvar iterate = __webpack_require__(125);\n\nmodule.exports = function from(items) {\n\tvar C = this;\n\tif (items === null || typeof items === 'undefined') {\n\t\tthrow new TypeError('`Array.from` requires an array-like object, not `null` or `undefined`');\n\t}\n\tvar mapFn, T;\n\tif (typeof arguments[1] !== 'undefined') {\n\t\tmapFn = arguments[1];\n\t\tif (!IsCallable(mapFn)) {\n\t\t\tthrow new TypeError('When provided, the second argument to `Array.from` must be a function');\n\t\t}\n\t\tif (arguments.length > 2) {\n\t\t\tT = arguments[2];\n\t\t}\n\t}\n\n\tvar values;\n\ttry {\n\t\tvalues = iterate(items);\n\t} catch (e) {\n\t\tvalues = items;\n\t}\n\n\tvar arrayLike = ToObject(values);\n\tvar len = ToLength(arrayLike.length);\n\tvar A = IsConstructor(C) ? ToObject(new C(len)) : new Array(len);\n\tvar k = 0;\n\tvar kValue, mappedValue;\n\n\twhile (k < len) {\n\t\tvar Pk = ToString(k);\n\t\tkValue = Get(arrayLike, Pk);\n\t\tif (mapFn) {\n\t\t\tmappedValue = typeof T === 'undefined' ? mapFn(kValue, k) : Call(mapFn, T, [kValue, k]);\n\t\t} else {\n\t\t\tmappedValue = kValue;\n\t\t}\n\t\tCreateDataPropertyOrThrow(A, Pk, mappedValue);\n\t\tk += 1;\n\t}\n\tA.length = len;\n\treturn A;\n};\n\n\n/***/ }),\n/* 32 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Call = __webpack_require__(37);\nvar IsArray = __webpack_require__(16);\nvar IsCallable = __webpack_require__(9);\n\nvar implementation = __webpack_require__(31);\n\nvar tryCall = function (fn) {\n\ttry {\n\t\treturn fn();\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nmodule.exports = function getPolyfill() {\n\tif (IsCallable(Array.from)) {\n\t\tvar handlesUndefMapper = tryCall(function () {\n\t\t\t// Microsoft Edge v0.11 throws if the mapFn argument is *provided* but undefined,\n\t\t\t// but the spec doesn't care if it's provided or not - undefined doesn't throw.\n\t\t\treturn Array.from([0], undefined);\n\t\t});\n\t\tif (!handlesUndefMapper) {\n\t\t\tvar origArrayFrom = Array.from;\n\t\t\treturn function from(items) {\n\t\t\t\t/* eslint no-invalid-this: 0 */\n\t\t\t\tif (arguments.length > 1 && typeof arguments[1] !== 'undefined') {\n\t\t\t\t\treturn Call(origArrayFrom, this, arguments);\n\t\t\t\t}\n\t\t\t\treturn Call(origArrayFrom, this, [items]);\n\n\t\t\t};\n\t\t}\n\t\tvar implemented = tryCall(function () {\n\t\t\t// Detects a Firefox bug in v32\n\t\t\t// https://bugzilla.mozilla.org/show_bug.cgi?id=1063993\n\t\t\treturn Array.from({ 'length': -1 }) === 0;\n\t\t}) && tryCall(function () {\n\t\t\t// Detects a bug in Webkit nightly r181886\n\t\t\tvar arr = Array.from([0].entries());\n\t\t\treturn arr.length === 1 && IsArray(arr[0]) && arr[0][0] === 0 && arr[0][1] === 0;\n\t\t}) && tryCall(function () {\n\t\t\treturn Array.from({ 'length': -Infinity });\n\t\t});\n\t\tif (implemented) {\n\t\t\treturn Array.from;\n\t\t}\n\t}\n\n\treturn implementation;\n};\n\n\n/***/ }),\n/* 33 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar ToObject = __webpack_require__(19);\nvar ToLength = __webpack_require__(18);\nvar IsCallable = __webpack_require__(9);\n\nmodule.exports = function find(predicate) {\n\tvar list = ToObject(this);\n\tvar length = ToLength(list.length);\n\tif (!IsCallable(predicate)) {\n\t\tthrow new TypeError('Array#find: predicate must be a function');\n\t}\n\tif (length === 0) {\n\t\treturn void 0;\n\t}\n\tvar thisArg;\n\tif (arguments.length > 0) {\n\t\tthisArg = arguments[1];\n\t}\n\n\tfor (var i = 0, value; i < length; i++) {\n\t\tvalue = list[i];\n\t\t// inlined for performance: if (Call(predicate, thisArg, [value, i, list])) {\n\t\tif (predicate.apply(thisArg, [value, i, list])) {\n\t\t\treturn value;\n\t\t}\n\t}\n\treturn void 0;\n};\n\n\n/***/ }),\n/* 34 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function getPolyfill() {\n\t// Detect if an implementation exists\n\t// Detect early implementations which skipped holes in sparse arrays\n\t// eslint-disable-next-line no-sparse-arrays\n\tvar implemented = Array.prototype.find && [, 1].find(function () {\n\t\treturn true;\n\t}) !== 1;\n\n\t// eslint-disable-next-line global-require\n\treturn implemented ? Array.prototype.find : __webpack_require__(33);\n};\n\n\n/***/ }),\n/* 35 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.components = undefined;\n\nvar _image = __webpack_require__(73);\n\nvar _color = __webpack_require__(71);\n\nvar _video = __webpack_require__(78);\n\nvar _byline = __webpack_require__(70);\n\nvar _animation = __webpack_require__(69);\n\nvar _panorama = __webpack_require__(74);\n\nvar _flipScroll = __webpack_require__(72);\n\nvar _triggerOnScroll = __webpack_require__(77);\n\nvar _animateVideo = __webpack_require__(68);\n\nvar _activeClass = __webpack_require__(76);\n\nvar components = exports.components = [_activeClass.setActiveElementClass, _image.imageComponent, _color.colorComponent, _byline.bylineComponent, _video.videoComponent, _animation.animationComponent,\n// polopolyComponent,\n// uncroppedComponent,\n_panorama.panoramaComponent, _triggerOnScroll.triggerOnScrollComponent, _flipScroll.flipScrollComponent, _animateVideo.animateVideoComponent];\n// import { polopolyComponent } from './polopoly'\n// import { uncroppedComponent } from './uncropped'\n\n/***/ }),\n/* 36 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.constrain = constrain;\nfunction constrain(value, min, max) {\n  return Math.min(Math.max(value, min), max);\n}\n\n/***/ }),\n/* 37 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\nvar callBound = __webpack_require__(2);\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar IsArray = __webpack_require__(16);\n\nvar $apply = GetIntrinsic('%Reflect.apply%', true) || callBound('%Function.prototype.apply%');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-call\n\nmodule.exports = function Call(F, V) {\n\tvar argumentsList = arguments.length > 2 ? arguments[2] : [];\n\tif (!IsArray(argumentsList)) {\n\t\tthrow new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List');\n\t}\n\treturn $apply(F, V, argumentsList);\n};\n\n\n/***/ }),\n/* 38 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar assertRecord = __webpack_require__(20);\n\nvar Type = __webpack_require__(3);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor\n\nmodule.exports = function FromPropertyDescriptor(Desc) {\n\tif (typeof Desc === 'undefined') {\n\t\treturn Desc;\n\t}\n\n\tassertRecord(Type, 'Property Descriptor', 'Desc', Desc);\n\n\tvar obj = {};\n\tif ('[[Value]]' in Desc) {\n\t\tobj.value = Desc['[[Value]]'];\n\t}\n\tif ('[[Writable]]' in Desc) {\n\t\tobj.writable = Desc['[[Writable]]'];\n\t}\n\tif ('[[Get]]' in Desc) {\n\t\tobj.get = Desc['[[Get]]'];\n\t}\n\tif ('[[Set]]' in Desc) {\n\t\tobj.set = Desc['[[Set]]'];\n\t}\n\tif ('[[Enumerable]]' in Desc) {\n\t\tobj.enumerable = Desc['[[Enumerable]]'];\n\t}\n\tif ('[[Configurable]]' in Desc) {\n\t\tobj.configurable = Desc['[[Configurable]]'];\n\t}\n\treturn obj;\n};\n\n\n/***/ }),\n/* 39 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar has = __webpack_require__(4);\n\nvar assertRecord = __webpack_require__(20);\n\nvar Type = __webpack_require__(3);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isdatadescriptor\n\nmodule.exports = function IsDataDescriptor(Desc) {\n\tif (typeof Desc === 'undefined') {\n\t\treturn false;\n\t}\n\n\tassertRecord(Type, 'Property Descriptor', 'Desc', Desc);\n\n\tif (!has(Desc, '[[Value]]') && !has(Desc, '[[Writable]]')) {\n\t\treturn false;\n\t}\n\n\treturn true;\n};\n\n\n/***/ }),\n/* 40 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar $isNaN = __webpack_require__(10);\n\n// http://262.ecma-international.org/5.1/#sec-9.12\n\nmodule.exports = function SameValue(x, y) {\n\tif (x === y) { // 0 === -0, but they are not identical.\n\t\tif (x === 0) { return 1 / x === 1 / y; }\n\t\treturn true;\n\t}\n\treturn $isNaN(x) && $isNaN(y);\n};\n\n\n/***/ }),\n/* 41 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// http://262.ecma-international.org/5.1/#sec-9.2\n\nmodule.exports = function ToBoolean(value) { return !!value; };\n\n\n/***/ }),\n/* 42 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar ES5ToInteger = __webpack_require__(95);\n\nvar ToNumber = __webpack_require__(91);\n\n// https://www.ecma-international.org/ecma-262/11.0/#sec-tointeger\n\nmodule.exports = function ToInteger(value) {\n\tvar number = ToNumber(value);\n\tif (number !== 0) {\n\t\tnumber = ES5ToInteger(number);\n\t}\n\treturn number === 0 ? 0 : number;\n};\n\n\n/***/ }),\n/* 43 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar has = __webpack_require__(4);\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar Type = __webpack_require__(3);\nvar ToBoolean = __webpack_require__(41);\nvar IsCallable = __webpack_require__(9);\n\n// https://262.ecma-international.org/5.1/#sec-8.10.5\n\nmodule.exports = function ToPropertyDescriptor(Obj) {\n\tif (Type(Obj) !== 'Object') {\n\t\tthrow new $TypeError('ToPropertyDescriptor requires an object');\n\t}\n\n\tvar desc = {};\n\tif (has(Obj, 'enumerable')) {\n\t\tdesc['[[Enumerable]]'] = ToBoolean(Obj.enumerable);\n\t}\n\tif (has(Obj, 'configurable')) {\n\t\tdesc['[[Configurable]]'] = ToBoolean(Obj.configurable);\n\t}\n\tif (has(Obj, 'value')) {\n\t\tdesc['[[Value]]'] = Obj.value;\n\t}\n\tif (has(Obj, 'writable')) {\n\t\tdesc['[[Writable]]'] = ToBoolean(Obj.writable);\n\t}\n\tif (has(Obj, 'get')) {\n\t\tvar getter = Obj.get;\n\t\tif (typeof getter !== 'undefined' && !IsCallable(getter)) {\n\t\t\tthrow new $TypeError('getter must be a function');\n\t\t}\n\t\tdesc['[[Get]]'] = getter;\n\t}\n\tif (has(Obj, 'set')) {\n\t\tvar setter = Obj.set;\n\t\tif (typeof setter !== 'undefined' && !IsCallable(setter)) {\n\t\t\tthrow new $TypeError('setter must be a function');\n\t\t}\n\t\tdesc['[[Set]]'] = setter;\n\t}\n\n\tif ((has(desc, '[[Get]]') || has(desc, '[[Set]]')) && (has(desc, '[[Value]]') || has(desc, '[[Writable]]'))) {\n\t\tthrow new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');\n\t}\n\treturn desc;\n};\n\n\n/***/ }),\n/* 44 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true);\n\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = null;\n\t}\n}\n\n// node v0.6 has a bug where array lengths can be Set but not Defined\nvar hasArrayLengthDefineBug = Object.defineProperty && Object.defineProperty([], 'length', { value: 1 }).length === 0;\n\n// eslint-disable-next-line global-require\nvar isArray = hasArrayLengthDefineBug && __webpack_require__(80); // this does not depend on any other AOs.\n\nvar callBound = __webpack_require__(2);\n\nvar $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');\n\n// eslint-disable-next-line max-params\nmodule.exports = function DefineOwnProperty(IsDataDescriptor, SameValue, FromPropertyDescriptor, O, P, desc) {\n\tif (!$defineProperty) {\n\t\tif (!IsDataDescriptor(desc)) {\n\t\t\t// ES3 does not support getters/setters\n\t\t\treturn false;\n\t\t}\n\t\tif (!desc['[[Configurable]]'] || !desc['[[Writable]]']) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// fallback for ES3\n\t\tif (P in O && $isEnumerable(O, P) !== !!desc['[[Enumerable]]']) {\n\t\t\t// a non-enumerable existing property\n\t\t\treturn false;\n\t\t}\n\n\t\t// property does not exist at all, or exists but is enumerable\n\t\tvar V = desc['[[Value]]'];\n\t\t// eslint-disable-next-line no-param-reassign\n\t\tO[P] = V; // will use [[Define]]\n\t\treturn SameValue(O[P], V);\n\t}\n\tif (\n\t\thasArrayLengthDefineBug\n\t\t&& P === 'length'\n\t\t&& '[[Value]]' in desc\n\t\t&& isArray(O)\n\t\t&& O.length !== desc['[[Value]]']\n\t) {\n\t\t// eslint-disable-next-line no-param-reassign\n\t\tO.length = desc['[[Value]]'];\n\t\treturn O.length === desc['[[Value]]'];\n\t}\n\n\t$defineProperty(O, P, FromPropertyDescriptor(desc));\n\treturn true;\n};\n\n\n/***/ }),\n/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar $isNaN = Number.isNaN || function (a) { return a !== a; };\n\nmodule.exports = Number.isFinite || function (x) { return typeof x === 'number' && !$isNaN(x) && x !== Infinity && x !== -Infinity; };\n\n\n/***/ }),\n/* 46 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function isPrimitive(value) {\n\treturn value === null || (typeof value !== 'function' && typeof value !== 'object');\n};\n\n\n/***/ }),\n/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function isPrimitive(value) {\n\treturn value === null || (typeof value !== 'function' && typeof value !== 'object');\n};\n\n\n/***/ }),\n/* 48 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"sections\":\"nrk-filmavis-liersykehus-sections\",\"section\":\"nrk-filmavis-liersykehus-section\",\"section--no-min-height\":\"nrk-filmavis-liersykehus-section--no-min-height\",\"sectionNoMinHeight\":\"nrk-filmavis-liersykehus-section--no-min-height\",\"section--ready\":\"nrk-filmavis-liersykehus-section--ready\",\"sectionReady\":\"nrk-filmavis-liersykehus-section--ready\",\"section--active\":\"nrk-filmavis-liersykehus-section--active\",\"sectionActive\":\"nrk-filmavis-liersykehus-section--active\",\"section-text-shadow\":\"nrk-filmavis-liersykehus-section-text-shadow\",\"sectionTextShadow\":\"nrk-filmavis-liersykehus-section-text-shadow\",\"type--image\":\"nrk-filmavis-liersykehus-type--image\",\"typeImage\":\"nrk-filmavis-liersykehus-type--image\",\"type--video\":\"nrk-filmavis-liersykehus-type--video\",\"typeVideo\":\"nrk-filmavis-liersykehus-type--video\",\"type--color\":\"nrk-filmavis-liersykehus-type--color\",\"typeColor\":\"nrk-filmavis-liersykehus-type--color\",\"type--byline\":\"nrk-filmavis-liersykehus-type--byline\",\"typeByline\":\"nrk-filmavis-liersykehus-type--byline\",\"animation\":\"nrk-filmavis-liersykehus-animation\",\"sectionAfterStandup\":\"nrk-filmavis-liersykehus-sectionAfterStandup\",\"sectionBeforeStandup\":\"nrk-filmavis-liersykehus-sectionBeforeStandup\",\"standup\":\"nrk-filmavis-liersykehus-standup\",\"super\":\"nrk-filmavis-liersykehus-super\",\"super__content\":\"nrk-filmavis-liersykehus-super__content\",\"superContent\":\"nrk-filmavis-liersykehus-super__content\",\"blurred\":\"nrk-filmavis-liersykehus-blurred\",\"overlay\":\"nrk-filmavis-liersykehus-overlay\",\"darkedout\":\"nrk-filmavis-liersykehus-darkedout\",\"NRKlogo\":\"nrk-filmavis-liersykehus-NRKlogo\",\"nrKlogo\":\"nrk-filmavis-liersykehus-NRKlogo\",\"shareButtonGroup\":\"nrk-filmavis-liersykehus-shareButtonGroup\",\"visible\":\"nrk-filmavis-liersykehus-visible\",\"shareButton\":\"nrk-filmavis-liersykehus-shareButton\",\"to-top\":\"nrk-filmavis-liersykehus-to-top\",\"toTop\":\"nrk-filmavis-liersykehus-to-top\",\"intro-block-arrow\":\"nrk-filmavis-liersykehus-intro-block-arrow\",\"introBlockArrow\":\"nrk-filmavis-liersykehus-intro-block-arrow\",\"fadeIn\":\"nrk-filmavis-liersykehus-fadeIn\",\"arrowBlink\":\"nrk-filmavis-liersykehus-arrowBlink\"};\n\n/***/ }),\n/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar strValue = String.prototype.valueOf;\nvar tryStringObject = function tryStringObject(value) {\n\ttry {\n\t\tstrValue.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar strClass = '[object String]';\nvar hasToStringTag = __webpack_require__(12)();\n\nmodule.exports = function isString(value) {\n\tif (typeof value === 'string') {\n\t\treturn true;\n\t}\n\tif (typeof value !== 'object') {\n\t\treturn false;\n\t}\n\treturn hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass;\n};\n\n\n/***/ }),\n/* 50 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar root = __webpack_require__(51);\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n\n\n/***/ }),\n/* 51 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar freeGlobal = __webpack_require__(128);\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/* 52 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar isObject = __webpack_require__(26),\n    now = __webpack_require__(134),\n    toNumber = __webpack_require__(135);\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n\n\n/***/ }),\n/* 53 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar toStr = Object.prototype.toString;\n\nmodule.exports = function isArguments(value) {\n\tvar str = toStr.call(value);\n\tvar isArgs = str === '[object Arguments]';\n\tif (!isArgs) {\n\t\tisArgs = str !== '[object Array]' &&\n\t\t\tvalue !== null &&\n\t\t\ttypeof value === 'object' &&\n\t\t\ttypeof value.length === 'number' &&\n\t\t\tvalue.length >= 0 &&\n\t\t\ttoStr.call(value.callee) === '[object Function]';\n\t}\n\treturn isArgs;\n};\n\n\n/***/ }),\n/* 54 */\n/***/ (function(module, exports) {\n\n// 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/* 55 */\n/***/ (function(module, exports) {\n\nvar 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/* 56 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/* eslint-disable global-require */\n\n__webpack_require__(62).shim();\n__webpack_require__(60).shim();\n__webpack_require__(58).shim();\n\n__webpack_require__(116);\n\n// Object.assign() is commonly used.\n// This polyfill use the native implementation if it's present and isn't buggy.\n// Object.assign = require('object-assign')\n\nif (typeof Promise === 'undefined') {\n  __webpack_require__(110).polyfill();\n}\n\nNumber.isInteger = Number.isInteger || function (value) {\n  return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;\n};\n\n/***/ }),\n/* 57 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _index = __webpack_require__(48);\n\nvar _index2 = _interopRequireDefault(_index);\n\n__webpack_require__(113);\n\n__webpack_require__(21);\n\nvar _background = __webpack_require__(1);\n\n__webpack_require__(6);\n\nvar _video = __webpack_require__(11);\n\nvar _video2 = _interopRequireDefault(_video);\n\n__webpack_require__(111);\n\n__webpack_require__(112);\n\nvar _muteButtons = __webpack_require__(79);\n\nvar _googleAnalytics = __webpack_require__(13);\n\nvar _featuretests = __webpack_require__(67);\n\nvar _intersection = __webpack_require__(64);\n\nvar _reducer = __webpack_require__(65);\n\nvar _components = __webpack_require__(35);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /* global __NAMESPACE__, ROOT_MOUNT_ID */\n/* eslint-disable max-params */\n\nvar App = function App(container, initialState) {\n  var _this = this;\n\n  _classCallCheck(this, App);\n\n  this.setSectionId = function (id) {\n    _this.sectionId = id;\n  };\n\n  this.mount = function () {\n    try {\n      var sectionElements = [].concat(_toConsumableArray(document.querySelectorAll('.' + _index2.default.section)));\n\n      _this.state.sections = _this.state.sections.map(function (s, i) {\n        return _extends({}, s, {\n          canAutoplay: _this.state.canAutoplay,\n          foregroundElement: sectionElements[i],\n          backgroundElement: document.getElementById(s.id)\n        });\n      });\n\n      _this.shareButtons = document.querySelector('.' + _index2.default.shareButtonGroup);\n      var muteButton = document.querySelector('.' + _video2.default.videoMuteButton);\n      if (muteButton) {\n        _this.muteButton = muteButton;\n        _this.muteButton.addEventListener('click', _this.toggleMuteVideo, false);\n      }\n\n      _this.initializeGoogleAnalytic();\n      _this.mountListeners();\n    } catch (error) {\n      console.error(error);\n      _this.renderError();\n    }\n  };\n\n  this.initializeGoogleAnalytic = function () {\n    if (!_this.gaInitialized) {\n      (0, _googleAnalytics.initialize)(_this.container.getAttribute('data-tracking'));\n    }\n    _this.gaInitialized = true;\n  };\n\n  this.unmount = function () {\n    _this.unmountListeners();\n    _this.container.innerHTML = '';\n  };\n\n  this.ioCallback = function (changes) {\n    return (0, _intersection.intersectionObserverCallback)(changes, _this.state, _this.dispatch);\n  };\n\n  this.mountListeners = function () {\n    var options = {\n      threshold: [0]\n    };\n\n    _this.observer = new IntersectionObserver(_this.ioCallback, options);\n    _this.observer.POLL_INTERVAL = 500;\n    _this.state.sections.forEach(function (_ref) {\n      var foregroundElement = _ref.foregroundElement;\n      return _this.observer.observe(foregroundElement);\n    });\n\n    var muteButton = document.querySelector('.' + _video2.default.videoMuteButton);\n    if (muteButton) {\n      _this.muteButton = muteButton;\n      _this.muteButton.addEventListener('click', _this.toggleMuteVideo, false);\n    }\n  };\n\n  this.render = function () {\n    if (_this.error) {\n      _this.renderError();\n    }\n  };\n\n  this.renderError = function () {\n    _this.container.innerHTML = '<pre class=\"App--error\">' + _this.error + '</pre>';\n  };\n\n  this.toggleMuteVideo = function (e) {\n    e.stopPropagation();\n\n    _this.dispatch({ type: 'toggleMute' });\n    if (_this.state.muted) {\n      (0, _googleAnalytics.trackAction)('MUTE/' + _this.sectionId);\n    } else {\n      (0, _googleAnalytics.trackAction)('UNMUTE/' + _this.sectionId);\n    }\n  };\n\n  this.dispatch = function (action) {\n    _this.state = (0, _reducer.reduce)(_this.state, action);\n    _this.onStateChanged(_this.state);\n  };\n\n  this.onStateChanged = function (state) {\n    if (state.showMuteButton) {\n      _this.muteButton.classList.add(_background.visible);\n    } else {\n      _this.muteButton.classList.remove(_background.visible);\n    }\n\n    if (_this.shareButtons && state.showShareButtons) {\n      _this.shareButtons.classList.add(_background.visible);\n    } else {\n      _this.shareButtons.classList.remove(_background.visible);\n    }\n\n    if (state.muted) {\n      _this.muteButton.innerHTML = (0, _muteButtons.getMutedButton)();\n    } else {\n      _this.muteButton.innerHTML = (0, _muteButtons.getUnmutedButton)();\n    }\n\n    _components.components.filter(function (component) {\n      return component.onStateChanged;\n    }).forEach(function (component) {\n      return component.onStateChanged(state);\n    });\n  };\n\n  this.container = container;\n  this.error = null;\n  this.muted = true;\n  this.videoElements = [];\n  this.state = initialState;\n  // console.log('This.state')\n\n  this.gaInitialized = false;\n  this.sectionId = 0;\n  window.appParams = this;\n};\n\nexports.default = App;\n\n\nwindow.App = App;\n\nif (false) module.hot.accept();\n\nvar mountingNode = document.getElementById(ROOT_MOUNT_ID);\nvar initialState = JSON.parse(mountingNode.getAttribute('data-initial-state'));\n\nvar app = new App(mountingNode, initialState);\napp.mount();\n\nmountingNode.style.transition = '.5s .5s opacity ease-in';\nmountingNode.style.opacity = 1;\n\n/***/ }),\n/* 58 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar define = __webpack_require__(5);\nvar RequireObjectCoercible = __webpack_require__(17);\nvar callBind = __webpack_require__(15);\nvar callBound = __webpack_require__(2);\n\nvar implementation = __webpack_require__(29);\nvar getPolyfill = __webpack_require__(30);\nvar polyfill = callBind.apply(getPolyfill());\nvar shim = __webpack_require__(59);\n\nvar $slice = callBound('Array.prototype.slice');\n\n/* eslint-disable no-unused-vars */\nvar boundShim = function includes(array, searchElement) {\n/* eslint-enable no-unused-vars */\n\tRequireObjectCoercible(array);\n\treturn polyfill(array, $slice(arguments, 1));\n};\ndefine(boundShim, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = boundShim;\n\n\n/***/ }),\n/* 59 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar define = __webpack_require__(5);\nvar getPolyfill = __webpack_require__(30);\n\nmodule.exports = function shimArrayPrototypeIncludes() {\n\tvar polyfill = getPolyfill();\n\tdefine(\n\t\tArray.prototype,\n\t\t{ includes: polyfill },\n\t\t{ includes: function () { return Array.prototype.includes !== polyfill; } }\n\t);\n\treturn polyfill;\n};\n\n\n/***/ }),\n/* 60 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar define = __webpack_require__(5);\n\nvar implementation = __webpack_require__(31);\nvar getPolyfill = __webpack_require__(32);\nvar shim = __webpack_require__(61);\n\nvar polyfill = getPolyfill();\n\n// eslint-disable-next-line no-unused-vars\nvar boundFromShim = function from(items) {\n\t// eslint-disable-next-line no-invalid-this\n\treturn polyfill.apply(this || Array, arguments);\n};\n\ndefine(boundFromShim, {\n\t'getPolyfill': getPolyfill,\n\t'implementation': implementation,\n\t'shim': shim\n});\n\nmodule.exports = boundFromShim;\n\n\n/***/ }),\n/* 61 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar define = __webpack_require__(5);\nvar getPolyfill = __webpack_require__(32);\n\nmodule.exports = function shimArrayFrom() {\n\tvar polyfill = getPolyfill();\n\n\tdefine(\n\t\tArray,\n\t\t{ 'from': polyfill },\n\t\t{\n\t\t\t'from': function () {\n\t\t\t\treturn Array.from !== polyfill;\n\t\t\t}\n\t\t}\n\t);\n\n\treturn polyfill;\n};\n\n\n/***/ }),\n/* 62 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar define = __webpack_require__(5);\nvar callBound = __webpack_require__(2);\nvar RequireObjectCoercible = __webpack_require__(17);\n\nvar implementation = __webpack_require__(33);\nvar getPolyfill = __webpack_require__(34);\nvar shim = __webpack_require__(63);\n\nvar $slice = callBound('Array.prototype.slice');\n\nvar polyfill = getPolyfill();\n\nvar boundFindShim = function find(array, predicate) { // eslint-disable-line no-unused-vars\n\tRequireObjectCoercible(array);\n\tvar args = $slice(arguments, 1);\n\treturn polyfill.apply(array, args);\n};\n\ndefine(boundFindShim, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = boundFindShim;\n\n\n/***/ }),\n/* 63 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar define = __webpack_require__(5);\nvar getPolyfill = __webpack_require__(34);\n\nmodule.exports = function shimArrayPrototypeFind() {\n\tvar polyfill = getPolyfill();\n\n\tdefine(Array.prototype, { find: polyfill }, {\n\t\tfind: function () {\n\t\t\treturn Array.prototype.find !== polyfill;\n\t\t}\n\t});\n\n\treturn polyfill;\n};\n\n\n/***/ }),\n/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.intersectionObserverCallback = undefined;\n\nvar _transitionManager = __webpack_require__(66);\n\nvar _components = __webpack_require__(35);\n\nvar _googleAnalytics = __webpack_require__(13);\n\nvar currentSection = null;\n\nvar intersectionObserverCallback = exports.intersectionObserverCallback = function intersectionObserverCallback(changes, state, dispatch) {\n  if (!changes) return;\n\n  var sections = state.sections;\n\n  // Update state\n  changes.forEach(function (change) {\n    var changedElement = sections.find(function (_ref) {\n      var foregroundElement = _ref.foregroundElement;\n      return change.target === foregroundElement;\n    });\n    changedElement.isIntersecting = change.isIntersecting;\n  });\n\n  var nextSection = sections.filter(function (e) {\n    return e.isIntersecting;\n  }).pop();\n\n  if (!currentSection || currentSection.foregroundElement !== nextSection.foregroundElement) {\n    (0, _googleAnalytics.trackAction)('LOAD_SUCCESS/' + nextSection.foregroundElement.getAttribute('data-background-id'));\n\n    var currentIndex = sections.indexOf(nextSection);\n    var previousIndex = currentSection ? sections.indexOf(currentSection) : null;\n\n    var direction = currentIndex > previousIndex ? 'forwards' : 'backwards';\n\n    var previousSection = sections[previousIndex];\n\n    currentSection = nextSection;\n\n    (0, _transitionManager.transitionManager)(nextSection, previousSection, direction);\n\n    // dispatch({ type: 'showShareButtons', value: nextSection.shareIcons })\n    dispatch({ type: 'showShareButtons', value: nextSection.props.shareIcons });\n    _components.components.filter(function (component) {\n      return component.onCurrentChanged;\n    }).forEach(function (component) {\n      component.onCurrentChanged(nextSection, dispatch);\n    });\n  }\n};\n\n/***/ }),\n/* 65 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nexports.reduce = reduce;\nfunction reduce(state, action) {\n  switch (action.type) {\n    case 'showMuteButton':\n      return _extends({}, state, {\n        showMuteButton: action.value\n      });\n\n    case 'showShareButtons':\n      return _extends({}, state, {\n        showShareButtons: action.value\n      });\n\n    case 'toggleMute':\n      return _extends({}, state, {\n        muted: !state.muted\n      });\n\n    default:\n      return state;\n  }\n}\n\n/***/ }),\n/* 66 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.transitionManager = undefined;\n\nvar _transitions = __webpack_require__(114);\n\nvar _transitions2 = _interopRequireDefault(_transitions);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar transitionManager = exports.transitionManager = function transitionManager(currentElement, previousElement) {\n  var direction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'forwards';\n\n  // console.log('currentElement:', currentElement)\n  if (!previousElement || previousElement === currentElement) {\n    // const transitionClass = currentElement.transition\n    var _transitionName = currentElement.props.transition;\n    var _transitionClass = _transitions2.default[_transitionName];\n    // console.log('transitionClass:', transitionClass)\n\n    currentElement.backgroundElement.classList.add(_transitions2.default.animateInto);\n    currentElement.backgroundElement.classList.add(_transitionClass);\n    return;\n  }\n\n  var allTransitionClasses = Object.keys(_transitions2.default).map(function (key) {\n    return _transitions2.default[key];\n  });\n\n  var transitionName = direction === 'forwards' ? currentElement.props.transition : previousElement.props.transition;\n\n  var transitionClass = _transitions2.default[transitionName];\n\n  allTransitionClasses.forEach(function (tClass) {\n    previousElement.backgroundElement.classList.remove(tClass);\n    currentElement.backgroundElement.classList.remove(tClass);\n  });\n\n  previousElement.backgroundElement.classList.add(_transitions2.default.animateAway);\n  previousElement.backgroundElement.classList.add(transitionClass);\n\n  currentElement.backgroundElement.classList.add(_transitions2.default.animateInto);\n  currentElement.backgroundElement.classList.add(transitionClass);\n};\n\n/***/ }),\n/* 67 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.canAutoplay = canAutoplay;\n\n\nvar videoAutoPlayCache = null;\n\n/* eslint-disable standard/no-callback-literal */\n\nfunction canAutoplay(callback) {\n  try {\n    if (typeof window === 'undefined') {\n      return callback(false);\n    }\n\n    if (typeof videoAutoPlayCache === 'boolean') {\n      return callback(videoAutoPlayCache);\n    }\n\n    var videoElm = document.createElement('video');\n\n    var isPlaying = false;\n\n    videoElm.setAttribute('autoplay', '');\n    videoElm.setAttribute('muted', '');\n    videoElm.setAttribute('webkit-playsinline', 'webkit-playsinline');\n    videoElm.setAttribute('playsinline', 'playsinline');\n\n    try {\n      if (videoElm.canPlayType('video/ogg')) {\n        videoElm.src = 'data:video/ogg;base64,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';\n      } else if (videoElm.canPlayType('video/mp4')) {\n        videoElm.src = 'data:video/mp4;base64,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';\n      } else {\n        return callback(false);\n      }\n    } catch (_) {\n      return callback(false);\n    }\n\n    videoElm.load();\n    videoElm.play();\n\n    videoElm.oncanplay = function () {\n      videoAutoPlayCache = isPlaying;\n      callback(videoAutoPlayCache);\n    };\n\n    videoElm.onplay = function () {\n      isPlaying = true;\n    };\n  } catch (error) {\n    return callback(false);\n  }\n}\n\n/***/ }),\n/* 68 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.animateVideoComponent = undefined;\n\nvar _debounce = __webpack_require__(52);\n\nvar _debounce2 = _interopRequireDefault(_debounce);\n\nvar _imageUtils = __webpack_require__(7);\n\nvar _general = __webpack_require__(36);\n\nvar _video = __webpack_require__(11);\n\nvar _video2 = _interopRequireDefault(_video);\n\nvar _background = __webpack_require__(1);\n\nvar _index = __webpack_require__(6);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar eventListener = null;\n\nvar animateVideoComponent = exports.animateVideoComponent = {\n  type: 'animate-video',\n\n  render: function render(id, props) {\n    var bgInnerHTML = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n    var video = props.video,\n        alignment = props.alignment;\n    var mp4 = video.mp4,\n        webm = video.webm,\n        poster = video.poster,\n        subtitles = video.subtitles,\n        hasSound = video.hasSound;\n\n\n    var trackElement = subtitles ? '<track src=\"' + subtitles + '\" kind=\"caption\" srclang=\"no\" label=\"Norwegian\" default=\"\" />' : '';\n\n    var alignmentClasses = alignment.join(' ');\n\n    return '\\n      <div id=\"' + id + '\" class=\"' + _background.background + ' ' + _video2.default.hidePlay + '\" >\\n        <video\\n          loop\\n          muted\\n          preload=\"auto\"\\n          poster=\"' + poster + '\"\\n          playsinline\\n          webkit-playsinline\\n          class=\"' + _video2.default.video + ' ' + alignmentClasses + '\">\\n          <source type=\"video/mp4\" src=\"' + mp4 + '\">\\n          ' + trackElement + '\\n          Your browser does not support the video tag. We suggest you upgrade your browser.\\n        </video>\\n        <div class=\"' + _video2.default['subtitlescontainer'] + '\"></div>\\n        ' + bgInnerHTML + '\\n      </div>\\n    ';\n  },\n  onCurrentChanged: function onCurrentChanged(currentSection) {\n    if (eventListener) {\n      document.removeEventListener('scroll', eventListener);\n      eventListener = null;\n    }\n\n    var type = currentSection.type;\n\n    if (type === 'animate-video') {\n      eventListener = function eventListener() {\n        return window.requestAnimationFrame(function () {\n          return handleAnimateVideo(currentSection);\n        });\n      };\n      document.addEventListener('scroll', eventListener);\n    }\n  }\n};\nvar i = 0;\nvar handleAnimateVideo = function handleAnimateVideo(section, e) {\n  var _section$foregroundEl = section.foregroundElement.getBoundingClientRect(),\n      y = _section$foregroundEl.y,\n      top = _section$foregroundEl.top,\n      height = _section$foregroundEl.height;\n\n  var _window = window,\n      innerHeight = _window.innerHeight,\n      innerWidth = _window.innerWidth;\n\n\n  var videoElement = document.querySelector('video');\n\n  var pxInViewFromStart = height + (top || y) - innerHeight;\n  var howMuchBigger = height - innerHeight;\n\n  if (pxInViewFromStart >= howMuchBigger - 1) {\n    pxInViewFromStart = howMuchBigger;\n  } else if (pxInViewFromStart <= 0) {\n    pxInViewFromStart = 0;\n  }\n  var percentInView = 1 - pxInViewFromStart / howMuchBigger;\n\n  var newCurrentTime = videoElement.duration * percentInView;\n  // videoElement.play()\n  if (!isNaN(newCurrentTime)) {\n    videoElement.currentTime = newCurrentTime;\n  }\n  // console.log('asd', newCurrentTime)\n};\n\n/***/ }),\n/* 69 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.animationComponent = undefined;\n\nvar _background = __webpack_require__(1);\n\nvar animationComponent = exports.animationComponent = {\n  type: 'animation',\n  render: function render(id, props) {\n    var bgInnerHTML = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n    var backgroundColor = props.backgroundColor;\n\n    var style = 'background-color: #c8e4ec;';\n    // const style = `background-color: ${backgroundColor};`\n\n    return '\\n      <div id=\"' + id + '\" class=\"animation ' + _background.background + '\" style=\"' + style + '\">\\n        ' + bgInnerHTML + '\\n        <svg id=\"silhouette\" data-name=\"silhouette\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"100 0 1300 500\" style=\"position:fixed; top:0; left:0; height:100%; width:100%\">\\n          <g>\\n            <animateTransform attributeName=\"transform\"\\n                                  attributeType=\"XML\"\\n                                  type=\"rotate\"\\n                                  from=\"0 50 400\"\\n                                  to=\"15 20 0\"\\n                                  dur=\"15s\"\\n                                  repeatCount=\"indefinite\"/>\\n            <animateTransform attributeName=\"transform\" type=\"scale\" additive=\"sum\" from=\"1.2 1.2\" to=\"1.4\" begin=\"0s\" dur=\"10s\" repeatCount=\"indefinite\"></animateTransform>\\n            <filter id=\"blur\">\\n            <feGaussianBlur stdDeviation=\"6\" id=\"blurE\" in=\"SourceGraphic\"  />\\n            </filter>\\n            <path fill=\"#bedbe2\" filter=\"url(#blur)\" d=\"M671.09,294.62c-2.13-22.25-3.88-50.33-16.43-69.81-4.15-6.44-11.09-10.58-17.81-13.94-13.45-6.72-25.34-10.88-40.43-10.6-8.18.15-14.9-2-22.88-4-7.5-1.86-15.26-2.71-22.91-3.81S541.3,189,536.68,183c-3.76-4.91-11.29-11.61-12.11-18.24-.45-3.65,1.91-5.38,3.13-9,1.06-3.15,1.09-6.91,1.52-10.22,1-7.88,1.64-15.64,2.28-23.55a191.21,191.21,0,0,0,.61-23.13c-.09-2.68,1.05-6.72.5-9.11-.27-1.17-2.64-.28-2.88-1-.46-1.49.74-4.51.88-6,1.29-13.71.11-30.75-5.87-43.45C518.58,26.07,505.54,15.17,494,7A36.66,36.66,0,0,0,456.85,4.3C449.3,8,441.46,11.24,434.43,16c-6,4-10.24,10.34-14.7,16.06-4.22,5.42-9.86,11.46-12.83,17.6-2.81,5.82-1.4,13-1.29,19.64.22,13.39,5,26.32,4.59,39.47-.23,7.59,2.13,14.62,5.38,21.24,1.3,2.65,2.6,5.12,4.12,7.63,2.47,4.09,5.14,6.3,7.91,9.57,4.29,5.05,6.45,14.68,8.83,21,1.85,4.91,3.24,10.68,2.6,16.1s-3.67,11.59-5.55,16.9c-3.25,9.18-4.43,14.12-14.87,16.55-3.53.82-7.07-.42-10.62-.44-1.75,0-2.92-1-4.35-.37s-2.43,3.24-3.87,4.17c-3.31,2.13-8.17,2.35-11.75,4.13A71,71,0,0,0,377.2,232c-9.83,7.51-13.51,29.38-28.65,26.05-7.07-1.55-14.3-8.84-20.75-11.86-5.9-2.76-11.94-1.08-18.56-.53-7.58.63-15.61.56-23.1,1.92-7.74,1.4-15.2,5.49-23,6.43-5.78.69-11.92-2.1-17.63-3.65,5.72-7.44,9.22-16.45,14.15-24.43,4.36-7.06,11.54-13.84,14.58-21.5,1.66-4.18,1.13-9.24,2.84-13.41,1.79-4.37,5.28-9,8-12.9,4.84-7.08,13.08-14.25,13.73-23.42.27-3.79-1.74-8.23-2.06-12.16a35.59,35.59,0,0,1,1.59-14.72c2.56-8.95-.85-20.41-12.48-16.88-9.16,2.78-15.61,10.78-20.23,18.81-2.56,4.45-1.74,7.94-3.32,12.8-1.25,3.88-4.77,6.82-7.23,10.17-5.39,7.34-7.81,15.41-18.3,14.92-11-.51-18.39-9.85-26.16-16.37s-14.75-11.7-20.83-19.87c-5.74-7.72-8.9-15.07-13-23.77-8.35-17.58-18.75-33.59-29.06-50-4.82-7.69-8.44-16.31-13.63-23.73-3.52-5-12.46-16.58-19.74-16.64-5.73,0-11.44,6.06-12.69,11.23-1.33,5.52.94,9.2,2.92,14.4,4.1,10.73,9.27,20.92,14.27,31.26,8.87,18.33,16.49,37.11,25,55.63-6.68-1.54-13.32-16-17.52-21.25-5-6.36-10.17-13-15.75-18.87C98,76.46,82.32,67.18,68,56.37,60.33,50.61,54.24,45.12,44,46.3c-8.83,1-15.92,11.33-12.6,20.2,1.06,2.83,6,7.09,8.35,9.37C44.1,80.05,50.09,82.3,55,85.68c6.12,4.21,11,11.07,16.52,16.25A124.22,124.22,0,0,1,89,122.31c2.84,4.13,5.46,8.64,8.8,12.37s8.46,6.25,8.9,11.85c-12.15-12.25-23.75-25.38-39.22-33.44-14.79-7.71-27.92-18.14-41-28.46l-12.67-6L8.57,82.15.86,87.33.12,95.71l3.54,7.54,20.25,16.16c11.65,9.4,23.69,18.42,34.72,28.55,5.73,5.26,11.72,10.29,16.88,16.11,3.13,3.54,7.85,7.61,10.08,11.77,1.73,3.22,1.31,4.72.95,8.86-19.73-7.17-36.5-15-53.73-27L12.21,144l-8.37,2.31L0,154.28,6,167l21.61,19.32c12.25,9.48,23.76,19.9,37.47,27.17,5.48,2.91,11.82,5.1,16.26,9.34,6.27,6,11.1,13.95,16.73,20.55,8.22,9.64,17.79,20.14,27.73,27.95,5.64,4.43,12.77,7.63,18.9,11.33,5.94,3.58,12.37,4.66,17.87,8.34,7.59,5.08,14.19,11.77,21.52,17.22,4.36,3.24,9,4.9,14.06,7,6.34,2.66,14.14,4.69,20,8.39,5.66,3.6,10.71,9.41,15.73,13.82,5.2,4.57,10.83,11.47,16.9,14.85,3.32,1.85,8.13,2.27,11.82,3.21,17.31,4.39,34.58,9.07,52,13.19,5.39,1.28,10.85,2.05,16.32,2.94,7.24,1.18,14,3.92,20.61.8,6-2.81,13.09-8.46,19.06-8.79,7.85-.44,16.73,2,24.56,2.95,0,0,3.65,64.36,3.59,66.66a7.46,7.46,0,0,1-.21,2.42l121.87.61,0,.2s154.52-.09,156.63,0S674.46,329.8,671.09,294.62Z\" />\\n          </g>\\n        </svg>\\n      </div>\\n    ';\n  }\n};\n\n/***/ }),\n/* 70 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.bylineComponent = undefined;\n\nvar _background = __webpack_require__(1);\n\nvar bylineComponent = exports.bylineComponent = {\n  type: 'byline',\n  render: function render(id, props) {\n    var bgInnerHTML = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n    var backgroundColor = props.backgroundColor;\n\n    var style = 'background-color: ' + backgroundColor + ';';\n\n    return '\\n      <div id=\"' + id + '\" class=\"' + _background.background + '\" style=\"' + style + '\">\\n        ' + bgInnerHTML + '\\n      </div>\\n    ';\n  }\n};\n\n/***/ }),\n/* 71 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.colorComponent = undefined;\n\nvar _background = __webpack_require__(1);\n\nvar _mood = __webpack_require__(21);\n\nvar _mood2 = _interopRequireDefault(_mood);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar colorComponent = exports.colorComponent = {\n  type: 'color',\n  render: function render(id, props) {\n    var bgInnerHTML = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n    var backgroundColor = props.backgroundColor,\n        mood = props.mood;\n\n    var style = 'background-color: ' + backgroundColor + ';';\n    var sectionMoodClass = mood ? 'mood--background-' + mood : 'mood--background-default';\n\n    return '\\n      <div id=\"' + id + '\" class=\"' + _background.background + ' ' + _mood2.default[sectionMoodClass] + '\" style=\"' + style + '\">\\n        ' + bgInnerHTML + '\\n      </div>\\n    ';\n  }\n};\n\n/***/ }),\n/* 72 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.handleFlipScroll = exports.flipScrollComponent = undefined;\n\nvar _throttle = __webpack_require__(27);\n\nvar _throttle2 = _interopRequireDefault(_throttle);\n\nvar _imageUtils = __webpack_require__(7);\n\nvar _renderUtils = __webpack_require__(14);\n\nvar _general = __webpack_require__(36);\n\nvar _background = __webpack_require__(1);\n\nvar _index = __webpack_require__(6);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar eventListener = null;\nvar flipScrollComponent = exports.flipScrollComponent = {\n  type: 'flip-scroll',\n  render: function render(id, props) {\n    var bgInnerHTML = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n    var alignment = props.alignment,\n        polopolyIds = props.polopolyIds,\n        overlay = props.overlay,\n        uncropped = props.uncropped,\n        _props$flipFade = props.flipFade,\n        flipFade = _props$flipFade === undefined ? false : _props$flipFade;\n\n    var alignmentClasses = alignment ? alignment.join(' ') : [_index.alignMiddle, _index.alignCenter].join(' ');\n\n    var imageStyle = uncropped ? 'position: absolute' : 'min-width: 100%; min-height: 100%; position: absolute;';\n\n    var imageElements = polopolyIds.map(function (polopolyId) {\n      return (0, _imageUtils.getPolopolyImageElement)(polopolyId, alignmentClasses, imageStyle, flipFade ? 'transition: .5s opacity ease-in-out' : '');\n    });\n\n    return '\\n      <div id=\"' + id + '\" class=\"' + _background.background + '\">\\n        ' + (uncropped ? '<div class=\"' + _background.uncroppedImageContainer + '\">' : '') + '\\n          ' + imageElements.join('') + '\\n        ' + (uncropped ? '</div>' : '') + '\\n        ' + bgInnerHTML + '\\n        ' + (0, _renderUtils.getOverlayElement)(overlay) + '\\n      </div>\\n    ';\n  },\n  onCurrentChanged: function onCurrentChanged(currentSection) {\n    if (eventListener) {\n      document.removeEventListener('scroll', eventListener);\n      eventListener = null;\n    }\n\n    var type = currentSection.type;\n\n    if (type === 'flip-scroll') {\n      eventListener = (0, _throttle2.default)(function () {\n        return handleFlipScroll(currentSection);\n      }, 30);\n      document.addEventListener('scroll', eventListener, {\n        passive: true\n      });\n    }\n  }\n};\n\nvar handleFlipScroll = exports.handleFlipScroll = function handleFlipScroll(element) {\n  var _element$foregroundEl = element.foregroundElement.getBoundingClientRect(),\n      y = _element$foregroundEl.y,\n      top = _element$foregroundEl.top;\n\n  var _window = window,\n      innerHeight = _window.innerHeight;\n\n  var imageElements = element.backgroundElement.getElementsByTagName('picture');\n  var numberOfImages = imageElements.length;\n\n  var pxInView = innerHeight - (y || top);\n  var percentInView = (0, _general.constrain)(pxInView / innerHeight, 0, 0.99);\n  var idx = Math.floor(percentInView * numberOfImages);\n\n  for (var i = 0; i < numberOfImages; i++) {\n    imageElements[i].style.opacity = i === idx ? '1' : '0';\n  }\n};\n\n/***/ }),\n/* 73 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.imageComponent = undefined;\n\nvar _imageUtils = __webpack_require__(7);\n\nvar _renderUtils = __webpack_require__(14);\n\nvar _index = __webpack_require__(6);\n\nvar _background = __webpack_require__(1);\n\nvar _mood = __webpack_require__(21);\n\nvar _mood2 = _interopRequireDefault(_mood);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar imageComponent = exports.imageComponent = {\n  type: 'image',\n  render: function render(id, props) {\n    var bgInnerHTML = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n    var backgroundImage = props.backgroundImage,\n        polopolyId = props.polopolyId,\n        mood = props.mood,\n        _props$uncropped = props.uncropped,\n        uncropped = _props$uncropped === undefined ? false : _props$uncropped,\n        overlay = props.overlay,\n        alignment = props.alignment;\n\n\n    var alignmentClasses = '';\n\n    var imageStyle = uncropped ? 'position: relative' : 'min-width: 100%; min-height: 100%; position: relative;';\n\n    var sectionMoodClass = mood ? 'mood--background-' + mood : 'mood--background-default';\n\n    // console.log('smc', sectionMoodClass)\n\n    var imageElement = '';\n    if (polopolyId) {\n      imageElement = (0, _imageUtils.getPolopolyImageElement)(polopolyId, alignmentClasses, imageStyle);\n    } else if (backgroundImage) {\n      imageElement = (0, _imageUtils.getImageElement)(backgroundImage, alignmentClasses, imageStyle);\n    }\n\n    return '\\n      <div id=\"' + id + '\" class=\"' + _background.background + ' ' + _mood2.default[sectionMoodClass] + '\">\\n        ' + (uncropped ? '<div class=\"' + _background.uncroppedImageContainer + '\">' : '') + '\\n          ' + imageElement + '\\n        ' + (uncropped ? '</div>' : '') + '\\n        ' + (0, _renderUtils.getOverlayElement)(overlay) + '\\n        ' + bgInnerHTML + '\\n      </div>\\n    ';\n  }\n};\n\n/***/ }),\n/* 74 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.panoramaComponent = undefined;\n\nvar _throttle = __webpack_require__(27);\n\nvar _throttle2 = _interopRequireDefault(_throttle);\n\nvar _background = __webpack_require__(1);\n\nvar _polopoly = __webpack_require__(75);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar eventListener = null;\nvar panoramaComponent = exports.panoramaComponent = {\n  type: 'panorama',\n  render: function render(id, props) {\n    var bgInnerHTML = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n    var backgroundImage = props.backgroundImage,\n        polopolyId = props.polopolyId,\n        _props$backgroundColo = props.backgroundColor,\n        backgroundColor = _props$backgroundColo === undefined ? '#333' : _props$backgroundColo;\n\n    var style = 'background-color: ' + backgroundColor + ';';\n\n    var imageElement = '<img src=\"' + backgroundImage + '\"></img>';\n\n    if (!backgroundImage && polopolyId) {\n      imageElement = (0, _polopoly.getPolopolyImageElement)(polopolyId);\n    }\n\n    return '\\n    <div id=\"' + id + '\" class=\"' + _background.background + '\" style=\"' + style + '\">\\n      <div class=\"' + _background.panoramaImageContainer + '\">\\n        ' + imageElement + '\\n        ' + bgInnerHTML + '\\n      </div>\\n    </div>\\n  ';\n  },\n  onCurrentChanged: function onCurrentChanged(currentSection) {\n    if (eventListener) {\n      document.removeEventListener('scroll', eventListener);\n      eventListener = null;\n    }\n\n    var type = currentSection.type;\n\n    if (type === 'panorama') {\n      eventListener = (0, _throttle2.default)(function () {\n        return handlePanoramaScroll(currentSection);\n      }, 30);\n      document.addEventListener('scroll', eventListener, {\n        passive: true\n      });\n    }\n  }\n};\n\nvar handlePanoramaScroll = function handlePanoramaScroll(element) {\n  var _element$foregroundEl = element.foregroundElement.getBoundingClientRect(),\n      y = _element$foregroundEl.y,\n      top = _element$foregroundEl.top,\n      height = _element$foregroundEl.height;\n\n  var _window = window,\n      innerHeight = _window.innerHeight,\n      innerWidth = _window.innerWidth;\n\n\n  var pxInView = innerHeight - (y || top);\n\n  if (pxInView >= height) {\n    pxInView = height;\n  } else if (pxInView <= 0) {\n    pxInView = 0;\n  }\n  var percentInView = pxInView / height * 100;\n  if (percentInView >= 100) percentInView = 100;\n  if (percentInView <= 0) percentInView = 0;\n\n  var imgElement = element.backgroundElement.querySelector('img');\n\n  var _imgElement$getBoundi = imgElement.getBoundingClientRect(),\n      elWidth = _imgElement$getBoundi.width;\n\n  var translateX = -(elWidth - innerWidth) * percentInView / 100;\n  imgElement.style.transform = 'translateX(' + translateX + 'px)';\n  imgElement.style.webkitTransform = 'translateX(' + translateX + 'px)';\n  imgElement.style.msTransform = 'translateX(' + translateX + 'px)';\n};\n\n/***/ }),\n/* 75 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.polopolyComponent = undefined;\nexports.getPolopolyImageElement = getPolopolyImageElement;\n\nvar _serumImagecropUtils = __webpack_require__(28);\n\nvar _background = __webpack_require__(1);\n\nvar _index = __webpack_require__(6);\n\nvar _imageUtils = __webpack_require__(7);\n\nvar polopolyComponent = exports.polopolyComponent = {\n  type: 'polopoly',\n  render: function render(id, props) {\n    var bgInnerHTML = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n    var polopolyId = props.polopolyId,\n        alignment = props.alignment,\n        overlay = props.overlay;\n\n\n    var defaultUrl = (0, _serumImagecropUtils.createImageUrl)({ id: polopolyId, width: 1600, ratio: '1:1' });\n    var desktopSourceSet = (0, _imageUtils.createSrcSet)(polopolyId, '1:1', _imageUtils.supportedWidths);\n    var mobileSourceSet = (0, _imageUtils.createSrcSet)(polopolyId, '3:4', _imageUtils.supportedWidths);\n\n    var overlayElement = overlay ? '<div class=\"' + _background.backgroundOverlay + '\" style=\"background-color: ' + (props.overlay.color || '#000') + '; opacity: ' + (props.overlay.opacity || 0.8) + '\"></div>' : '';\n\n    var imgStyle = 'min-width: 100%; min-height: 100%; position: relative;';\n    var alignmentClasses = alignment ? alignment.join(' ') : [_index.alignMiddle, _index.alignCenter].join(' ');\n\n    return '\\n      <div id=\"' + id + '\" class=\"' + _background.background + '\">\\n        <picture style=\"object-fit: cover;\">\\n        <source media=\"(min-aspect-ratio: 3/4)\" srcset=\"' + desktopSourceSet + '\">\\n        <img src=\"' + defaultUrl + '\" srcset=\"' + mobileSourceSet + '\" class=\"' + alignmentClasses + '\" style=\"' + imgStyle + '\">\\n        </picture>\\n        ' + bgInnerHTML + '\\n        ' + overlayElement + '\\n      </div>';\n  }\n};\n\nfunction getPolopolyImageElement(polopolyId) {\n  var alignmentClasses = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n\n  var defaultUrl = (0, _serumImagecropUtils.createImageUrl)({ id: polopolyId, width: 1600, ratio: '1:1' });\n  var desktopSourceSet = (0, _imageUtils.createSrcSet)(polopolyId, '1:1', _imageUtils.supportedWidths);\n  var mobileSourceSet = (0, _imageUtils.createSrcSet)(polopolyId, '3:4', _imageUtils.supportedWidths);\n\n  var imgStyle = 'position: absolute; top: 50%; left: 50%; -webkit-transform: translate(-50%, -50%);-ms-transform: translate(-50%, -50%);transform: translate(-50%, -50%);';\n  return '\\n    <picture>\\n      <source media=\"(min-aspect-ratio: 3/4)\" srcset=\"' + desktopSourceSet + '\">\\n      <img src=\"' + defaultUrl + '\" srcset=\"' + mobileSourceSet + '\" class=\"' + alignmentClasses + '\" style=\"' + imgStyle + '\">\\n    </picture>';\n}\n\n/***/ }),\n/* 76 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.setActiveElementClass = undefined;\n\nvar _index = __webpack_require__(48);\n\nvar _index2 = _interopRequireDefault(_index);\n\nvar _background = __webpack_require__(1);\n\nvar _background2 = _interopRequireDefault(_background);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nvar fgEls = [];\nvar bgEls = [];\n\nvar setActiveElementClass = exports.setActiveElementClass = {\n  onCurrentChanged: function onCurrentChanged(currentSection, dispatch) {\n    var foregroundElement = currentSection.foregroundElement,\n        backgroundElement = currentSection.backgroundElement;\n\n\n    if (!fgEls || !fgEls.length) {\n      fgEls = [].concat(_toConsumableArray(document.querySelectorAll('.' + _index2.default.section)));\n      bgEls = [].concat(_toConsumableArray(document.querySelectorAll('.' + _background2.default.background)));\n    }\n\n    var index = fgEls.indexOf(foregroundElement);\n    var activeEls = shouldBeActive(index, fgEls, bgEls);\n\n    fgEls.forEach(function (fgEl) {\n      if (fgEl === foregroundElement) {\n        addOrRemoveClass(fgEl, _index2.default['section--ready'], 'remove');\n        addOrRemoveClass(fgEl, _index2.default['section--active'], 'add');\n      } else if (activeEls.fgEls.indexOf(fgEl) >= 0) {\n        addOrRemoveClass(fgEl, _index2.default['section--active'], 'remove');\n        addOrRemoveClass(fgEl, _index2.default['section--ready'], 'add');\n      } else {\n        addOrRemoveClass(fgEl, _index2.default['section--ready'], 'remove');\n        addOrRemoveClass(fgEl, _index2.default['section--active'], 'remove');\n      }\n    });\n\n    bgEls.forEach(function (bgEl) {\n      if (bgEl === backgroundElement) {\n        addOrRemoveClass(bgEl, _background2.default['background--ready'], 'remove');\n        addOrRemoveClass(bgEl, _background2.default['background--active'], 'add');\n      } else if (activeEls.bgEls.indexOf(bgEl) >= 0) {\n        addOrRemoveClass(bgEl, _background2.default['background--active'], 'remove');\n        addOrRemoveClass(bgEl, _background2.default['background--ready'], 'add');\n      } else {\n        addOrRemoveClass(bgEl, _background2.default['background--active'], 'remove');\n        addOrRemoveClass(bgEl, _background2.default['background--ready'], 'remove');\n      }\n    });\n  }\n};\n\nfunction addOrRemoveClass(el, className) {\n  var action = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'add';\n\n  if (!el || !el.classList || !className) return;\n  if (action === 'remove') {\n    return el.classList.contains(className) && el.classList.remove(className);\n  }\n  if (!el.classList.contains(className)) return el.classList.add(className);\n}\n\nfunction shouldBeActive(index, fgEls, bgEls) {\n  var buffer = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 3;\n\n  if (index < 0) return { fg: [], bg: [] };\n  if (index === 0 && fgEls.length > buffer) {\n    return {\n      fgEls: fgEls.slice(0, buffer + 1),\n      bgEls: bgEls.slice(0, buffer + 1)\n    };\n  } else if (index > 0) {\n    if (fgEls.length > index + buffer) {\n      var root = index - buffer;\n      return {\n        fgEls: fgEls.slice(root > 0 ? root : 0, index + buffer + 1),\n        bgEls: bgEls.slice(root > 0 ? root : 0, index + buffer + 1)\n      };\n    }\n    return {\n      fgEls: fgEls.slice(index - buffer, fgEls.length),\n      bgEls: bgEls.slice(index - buffer, fgEls.length)\n    };\n  }\n  return { fgEls: [], bgEls: [] };\n}\n\n/***/ }),\n/* 77 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.triggerOnScrollComponent = undefined;\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _imageUtils = __webpack_require__(7);\n\nvar _throttle = __webpack_require__(27);\n\nvar _throttle2 = _interopRequireDefault(_throttle);\n\nvar _background = __webpack_require__(1);\n\nvar _index = __webpack_require__(6);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nvar eventListener = null;\n\nvar triggerOnScrollComponent = exports.triggerOnScrollComponent = {\n  type: 'trigger-on-scroll',\n  render: function render(id, props) {\n    var bgInnerHTML = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n    var backgroundImage = props.backgroundImage,\n        polopolyId = props.polopolyId,\n        alignment = props.alignment,\n        uncropped = props.uncropped,\n        _props$backgroundColo = props.backgroundColor,\n        backgroundColor = _props$backgroundColo === undefined ? '#333' : _props$backgroundColo;\n\n    var style = 'background-color: ' + (backgroundColor || '') + ';';\n    // const style = `background-color: ${backgroundColor};`\n\n    var alignmentClasses = alignment ? alignment.join(' ') : [_index.alignMiddle, _index.alignCenter].join(' ');\n\n    var imageStyle = uncropped ? 'position: relative' : 'min-width: 100%; min-height: 100%; position: relative;';\n\n    var imageElement = '';\n    if (polopolyId) {\n      imageElement = (0, _imageUtils.getPolopolyImageElement)(polopolyId, alignmentClasses, imageStyle);\n    } else if (backgroundImage) {\n      imageElement = (0, _imageUtils.getImageElement)(backgroundImage, alignmentClasses, imageStyle);\n    }\n\n    return '\\n      <div id=\"' + id + '\" class=\"' + _background.background + '\" style=\"' + style + '\">\\n        ' + (uncropped ? '<div class=\"' + _background.uncroppedImageContainer + '\">' : '') + '\\n          ' + imageElement + '\\n          ' + (uncropped ? '</div>' : '') + '\\n\\n          ' + bgInnerHTML + '\\n      </div>\\n    ';\n  },\n  onCurrentChanged: function onCurrentChanged(currentSection) {\n    if (eventListener) {\n      document.removeEventListener('scroll', eventListener);\n      eventListener = null;\n    }\n\n    var type = currentSection.type;\n\n    if (type === 'trigger-on-scroll') {\n      eventListener = (0, _throttle2.default)(function () {\n        return handleTriggerOnScroll(currentSection);\n      }, 30, {\n        passive: true\n      });\n      document.addEventListener('scroll', eventListener);\n    }\n  }\n};\n\nvar handleTriggerOnScroll = function handleTriggerOnScroll(section) {\n  var _section$foregroundEl = section.foregroundElement.getBoundingClientRect(),\n      y = _section$foregroundEl.y,\n      top = _section$foregroundEl.top,\n      height = _section$foregroundEl.height;\n\n  var _window = window,\n      innerHeight = _window.innerHeight,\n      innerWidth = _window.innerWidth;\n  var _section$props$onScro = section.props.onScroll,\n      actions = _section$props$onScro.actions,\n      lastParsedHeight = _section$props$onScro.lastParsedHeight,\n      lastScroll = _section$props$onScro.lastScroll;\n\n\n  var actionsToDo = actions;\n  var direction = lastScroll > (y || top) ? 'forwards' : 'backwards';\n\n  var shouldReparseWhen = !lastParsedHeight || lastParsedHeight > innerWidth + 50 || lastParsedHeight < innerWidth - 50;\n\n  if (shouldReparseWhen) {\n    section.props.onScroll.lastParsedHeight = innerWidth;\n\n    actionsToDo = actions.map(function (action) {\n      return _extends({}, action, {\n        parsedWhen: parseWhen(action.when, height),\n        parsedBreakpoints: innerWidth\n      });\n    });\n  }\n\n  if (direction !== section.props.onScroll.direction) actionsToDo.reverse();\n\n  section.props.onScroll.lastScroll = y || top;\n  section.props.onScroll.direction = direction;\n\n  var pxInView = innerHeight - (y || top);\n\n  if (pxInView >= height) {\n    pxInView = height;\n  } else if (pxInView <= 0) {\n    pxInView = 0;\n  }\n\n  section.props.onScroll.actions = actionsToDo.map(function (action, i) {\n    var breakpoint = action.breakpoint,\n        parsedWhen = action.parsedWhen,\n        isAnimated = action.isAnimated,\n        classes = action.classes,\n        style = action.style;\n\n\n    var isBetweenBreakpoints = innerWidth > breakpoint.from && innerWidth < breakpoint.to;\n\n    var shouldAnimateIn = parsedWhen.from < pxInView && parsedWhen.to > pxInView;\n    if (direction === 'backwards') {\n      shouldAnimateIn = parsedWhen.to > pxInView && parsedWhen.from < pxInView;\n    }\n\n    if (shouldAnimateIn && !isAnimated && isBetweenBreakpoints) {\n      // DO ANIMATION\n\n      var targetElement = getTarget(action, section);\n\n      doAnimation(targetElement, classes, style);\n      isAnimated = true;\n    } else if (!shouldAnimateIn && isAnimated) {\n      // UNDO ANIMATION\n      if (!action.once) {\n        var _targetElement = getTarget(action, section);\n\n        isAnimated = false;\n        undoAnimation(_targetElement, classes, style);\n      }\n    }\n    return _extends({}, action, {\n      isAnimated: isAnimated\n    });\n  });\n};\n\nvar parseWhen = function parseWhen(bp) {\n  var height = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n\n  var parseFunction = function parseFunction(val) {\n    if (typeof val !== 'number') {\n      if (val.indexOf('%') > -1) {\n        return height * (parseFloat(val) / 100);\n      }\n      return parseInt(val);\n    }\n  };\n\n  return {\n    to: parseFunction(bp.to),\n    from: parseFunction(bp.from)\n  };\n};\n\nvar getTarget = function getTarget(action, section) {\n  var target = action.target;\n\n\n  if (!target) return section.backgroundElement;\n  if (Array.isArray(target)) {\n    if (target.length > 1) {\n      var foregroundOrBackground = target[1] === 'foreground' ? 'foregroundElement' : 'backgroundElement';\n\n      return [].concat(_toConsumableArray(section[foregroundOrBackground].querySelectorAll(target[0])));\n    }\n    return [].concat(_toConsumableArray(section.foregroundElement.querySelectorAll(target[0])));\n  }\n  if (typeof target === 'string') {\n    if (target === 'foreground') return section.foregroundElement;\n    if (target === 'background') return section.backgroundElement;\n    return document.querySelector(target);\n  }\n};\n\nvar undoAnimation = function undoAnimation(targetElement, classes, style) {\n  var isTargetArray = Array.isArray(targetElement);\n\n  if (targetElement && classes) {\n    if (isTargetArray) {\n      targetElement.map(function (tE) {\n        return tE.classList.remove(classes);\n      });\n    } else {\n      targetElement.classList.remove(classes);\n    }\n  }\n  if (targetElement && style) {\n    if (isTargetArray) {\n      targetElement.map(function (tE) {\n        Object.keys(style).forEach(function (s) {\n          tE.style[s] = null;\n        });\n      });\n    } else {\n      Object.keys(style).forEach(function (s) {\n        targetElement.style[s] = null;\n      });\n    }\n  }\n};\n\nvar doAnimation = function doAnimation(targetElement, classes, style) {\n  var isTargetArray = Array.isArray(targetElement);\n  if (targetElement && classes) {\n    if (isTargetArray) {\n      targetElement.map(function (tE) {\n        return tE.classList.add(classes);\n      });\n    } else {\n      targetElement.classList.add(classes);\n    }\n  }\n  if (targetElement && style) {\n    if (isTargetArray) {\n      targetElement.map(function (tE) {\n        Object.keys(style).forEach(function (s) {\n          tE.style[s] = style[s];\n        });\n      });\n    } else {\n      Object.keys(style).forEach(function (s) {\n        targetElement.style[s] = style[s];\n      });\n    }\n  }\n};\n\n/***/ }),\n/* 78 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.videoComponent = undefined;\n\nvar _background = __webpack_require__(1);\n\nvar _video = __webpack_require__(11);\n\nvar _video2 = _interopRequireDefault(_video);\n\nvar _googleAnalytics = __webpack_require__(13);\n\nvar _renderUtils = __webpack_require__(14);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar bgVideos = [];\n\nvar videoComponent = exports.videoComponent = {\n  type: 'video',\n  render: function render(id, props) {\n    var bgInnerHTML = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n    var video = props.video,\n        alignment = props.alignment,\n        overlay = props.overlay;\n    // console.log('Video:', video, props)\n\n    var mp4 = video.mp4,\n        webm = video.webm,\n        poster = video.poster,\n        subtitles = video.subtitles,\n        hasSound = video.hasSound,\n        loop = video.loop;\n\n\n    var trackElement = subtitles ? '<track src=\"' + subtitles + '\" kind=\"caption\" srclang=\"no\" label=\"Norwegian\" default=\"\" />' : '';\n\n    var alignmentClasses = alignment.join(' ');\n\n    return '\\n      <div id=\"' + id + '\" class=\"' + _background.background + ' ' + _video2.default.hidePlay + '\" >\\n        <video\\n          muted\\n          ' + (loop === 'none' ? '' : 'loop') + '\\n          preload=\"none\"\\n          poster=\"' + poster + '\"\\n          playsinline\\n          webkit-playsinline\\n          aria-hidden=\"true\"\\n          class=\"' + _video2.default.video + ' ' + alignmentClasses + '\">\\n          <source type=\"video/webm\" src=\"' + webm + '\">\\n          <source type=\"video/mp4\" src=\"' + mp4 + '\">\\n          ' + trackElement + '\\n          Your browser does not support the video tag. We suggest you upgrade your browser.\\n        </video>\\n        <div class=\"' + _video2.default['subtitlescontainer'] + '\"></div>\\n        ' + bgInnerHTML + '\\n        ' + (0, _renderUtils.getOverlayElement)(overlay) + '\\n\\n      </div>\\n    ';\n  },\n  onCurrentChanged: function onCurrentChanged(currentSection, dispatch) {\n    var id = currentSection.id,\n        type = currentSection.type,\n        props = currentSection.props,\n        backgroundElement = currentSection.backgroundElement;\n    // const { video } = ''\n\n    var video = props.video;\n\n\n    dispatch({ type: 'showMuteButton', value: video && video.hasSound });\n\n    try {\n      bgVideos.forEach(function (v) {\n        v.pause();\n      });\n    } catch (error) {\n      console.error('error in pause', error);\n    }\n\n    if (type === 'video') {\n      var bgVideo = backgroundElement.querySelector('video');\n      if (!bgVideo) return;\n\n      try {\n        bgVideo.play().catch(console.error);\n      } catch (error) {\n        console.error('error while playing', error);\n      }\n\n      if (!bgVideo.paused) {\n        (0, _googleAnalytics.trackAction)('VIDEO_PLAYING/' + id);\n      }\n\n      if (bgVideos.indexOf(bgVideo) === -1) {\n        bgVideos.push(bgVideo);\n      }\n    }\n  },\n  onStateChanged: function onStateChanged(state) {\n    if (state.muted) {\n      bgVideos.forEach(function (v) {\n        return v.muted = true;\n      });\n    } else {\n      bgVideos.forEach(function (v) {\n        return v.muted = false;\n      });\n    }\n  }\n};\n\n/***/ }),\n/* 79 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getUnmutedButton = exports.getMutedButton = exports.getInitialMuteButton = undefined;\n\nvar _video = __webpack_require__(11);\n\nvar _video2 = _interopRequireDefault(_video);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar getInitialMuteButton = exports.getInitialMuteButton = function getInitialMuteButton() {\n  return '\\n  <button class=\"' + _video2.default['video-mute-button'] + '\">\\n    ' + getMutedButton() + '\\n  </button>\\n  ';\n};\n\nvar getMutedButton = exports.getMutedButton = function getMutedButton() {\n  return '\\n    <svg class=\"' + _video2.default['video-mute-svg-muted'] + '\" width=\"21\" height=\"19\" viewBox=\"0 0 21 19\" xmlns=\"http://www.w3.org/2000/svg\">\\n      <g stroke=\"#FFF\" fill=\"none\" fill-rule=\"evenodd\">\\n        <path d=\"M11.1.55l-5.2 5.3h-.2l-4.4.34c-.45.03-.8.43-.8.9v4.8c0 .5.34.88.78.9l4.6.36.14.13 5.06 5.14c.17.14.42 0 .42-.25V.8c0-.24-.25-.37-.4-.25z\" />\\n        <path d=\"M20 7l-5 5M15 7l5 5\" stroke-linecap=\"round\" />\\n      </g>\\n    </svg>\\n    <svg class=\"' + _video2.default['video-mute-svg-muted-hover'] + '\" width=\"21\" height=\"19\" viewBox=\"0 0 21 19\" xmlns=\"http://www.w3.org/2000/svg\">\\n      <g fill=\"none\" fill-rule=\"evenodd\">\\n        <path d=\"M10.75.18l-5.1 5.18-4.4.33C.53 5.75 0 6.4 0 7.1v4.8c0 .74.53 1.36 1.25 1.4l4.4.34 5.1 5.18c.5.43 1.25.05 1.25-.63V.77c-.02-.64-.76-1.03-1.25-.6z\" fill=\"#FFF\" fill-rule=\"nonzero\" />\\n        <path d=\"M20 7l-5 5M15 7l5 5\" stroke=\"#FFF\" stroke-linecap=\"round\" />\\n      </g>\\n    </svg>\\n  ';\n};\n\nvar getUnmutedButton = exports.getUnmutedButton = function getUnmutedButton() {\n  return '\\n    <svg class=\"' + _video2.default['video-mute-svg-unmuted'] + '\" width=\"21\" height=\"19\" viewBox=\"0 0 21 19\" xmlns=\"http://www.w3.org/2000/svg\">\\n      <g fill-rule=\"nonzero\" fill=\"none\">\\n        <path d=\"M21 9.48c0-3.3-1.82-6.22-4.56-7.48l-.37.87c2.4 1.1 4.02 3.7 4.02 6.6 0 2.96-1.65 5.56-4.1 6.65l.36.88C19.14 15.76 21 12.8 21 9.48z\" fill=\"#FFF\" />\\n        <path d=\"M18 9.46C18 7.6 17.06 5.9 15.57 5l-.45.86c1.2.73 1.96 2.1 1.96 3.6 0 1.56-.8 2.96-2.08 3.66l.42.88C17 13.13 18 11.4 18 9.46z\" fill=\"#FFF\" />\\n        <path d=\"M11.1.55l-5.2 5.3h-.2l-4.4.34c-.45.03-.8.43-.8.9v4.8c0 .5.34.88.78.9l4.6.36.14.13 5.06 5.14c.17.14.42 0 .42-.25V.8c0-.24-.25-.37-.4-.25z\" stroke=\"#FFF\" />\\n      </g>\\n    </svg>\\n    <svg class=\"' + _video2.default['video-mute-svg-unmuted-hover'] + '\" width=\"21\" height=\"19\" viewBox=\"0 0 21 19\" xmlns=\"http://www.w3.org/2000/svg\">\\n\\n    <g fill-rule=\"nonzero\" fill=\"#FFF\">\\n      <path d=\"M21 9.48c0-3.3-1.82-6.22-4.56-7.48l-.37.87c2.4 1.1 4.02 3.7 4.02 6.6 0 2.96-1.65 5.56-4.1 6.65l.36.88C19.14 15.76 21 12.8 21 9.48z\" />\\n      <path d=\"M18 9.46C18 7.6 17.06 5.9 15.57 5l-.45.86c1.2.73 1.96 2.1 1.96 3.6 0 1.56-.8 2.96-2.08 3.66l.42.88C17 13.13 18 11.4 18 9.46zM10.75.18l-5.1 5.18-4.4.33C.53 5.75 0 6.4 0 7.1v4.8c0 .74.53 1.36 1.25 1.4l4.4.34 5.1 5.18c.5.43 1.25.05 1.25-.63V.77c-.02-.64-.76-1.03-1.25-.6z\" />\\n    </g>\\n  </svg>\\n  ';\n};\n\n/***/ }),\n/* 80 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $Array = GetIntrinsic('%Array%');\n\n// eslint-disable-next-line global-require\nvar toStr = !$Array.isArray && __webpack_require__(2)('Object.prototype.toString');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isarray\n\nmodule.exports = $Array.isArray || function IsArray(argument) {\n\treturn toStr(argument) === '[object Array]';\n};\n\n\n/***/ }),\n/* 81 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar DefineOwnProperty = __webpack_require__(44);\n\nvar FromPropertyDescriptor = __webpack_require__(38);\nvar OrdinaryGetOwnProperty = __webpack_require__(89);\nvar IsDataDescriptor = __webpack_require__(39);\nvar IsExtensible = __webpack_require__(87);\nvar IsPropertyKey = __webpack_require__(8);\nvar SameValue = __webpack_require__(40);\nvar Type = __webpack_require__(3);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-createdataproperty\n\nmodule.exports = function CreateDataProperty(O, P, V) {\n\tif (Type(O) !== 'Object') {\n\t\tthrow new $TypeError('Assertion failed: Type(O) is not Object');\n\t}\n\tif (!IsPropertyKey(P)) {\n\t\tthrow new $TypeError('Assertion failed: IsPropertyKey(P) is not true');\n\t}\n\tvar oldDesc = OrdinaryGetOwnProperty(O, P);\n\tvar extensible = !oldDesc || IsExtensible(O);\n\tvar immutable = oldDesc && (!oldDesc['[[Writable]]'] || !oldDesc['[[Configurable]]']);\n\tif (immutable || !extensible) {\n\t\treturn false;\n\t}\n\treturn DefineOwnProperty(\n\t\tIsDataDescriptor,\n\t\tSameValue,\n\t\tFromPropertyDescriptor,\n\t\tO,\n\t\tP,\n\t\t{\n\t\t\t'[[Configurable]]': true,\n\t\t\t'[[Enumerable]]': true,\n\t\t\t'[[Value]]': V,\n\t\t\t'[[Writable]]': true\n\t\t}\n\t);\n};\n\n\n/***/ }),\n/* 82 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar CreateDataProperty = __webpack_require__(81);\nvar IsPropertyKey = __webpack_require__(8);\nvar Type = __webpack_require__(3);\n\n// // https://ecma-international.org/ecma-262/6.0/#sec-createdatapropertyorthrow\n\nmodule.exports = function CreateDataPropertyOrThrow(O, P, V) {\n\tif (Type(O) !== 'Object') {\n\t\tthrow new $TypeError('Assertion failed: Type(O) is not Object');\n\t}\n\tif (!IsPropertyKey(P)) {\n\t\tthrow new $TypeError('Assertion failed: IsPropertyKey(P) is not true');\n\t}\n\tvar success = CreateDataProperty(O, P, V);\n\tif (!success) {\n\t\tthrow new $TypeError('unable to create data property');\n\t}\n\treturn success;\n};\n\n\n/***/ }),\n/* 83 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar isPropertyDescriptor = __webpack_require__(103);\nvar DefineOwnProperty = __webpack_require__(44);\n\nvar FromPropertyDescriptor = __webpack_require__(38);\nvar IsAccessorDescriptor = __webpack_require__(85);\nvar IsDataDescriptor = __webpack_require__(39);\nvar IsPropertyKey = __webpack_require__(8);\nvar SameValue = __webpack_require__(40);\nvar ToPropertyDescriptor = __webpack_require__(43);\nvar Type = __webpack_require__(3);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-definepropertyorthrow\n\nmodule.exports = function DefinePropertyOrThrow(O, P, desc) {\n\tif (Type(O) !== 'Object') {\n\t\tthrow new $TypeError('Assertion failed: Type(O) is not Object');\n\t}\n\n\tif (!IsPropertyKey(P)) {\n\t\tthrow new $TypeError('Assertion failed: IsPropertyKey(P) is not true');\n\t}\n\n\tvar Desc = isPropertyDescriptor({\n\t\tType: Type,\n\t\tIsDataDescriptor: IsDataDescriptor,\n\t\tIsAccessorDescriptor: IsAccessorDescriptor\n\t}, desc) ? desc : ToPropertyDescriptor(desc);\n\tif (!isPropertyDescriptor({\n\t\tType: Type,\n\t\tIsDataDescriptor: IsDataDescriptor,\n\t\tIsAccessorDescriptor: IsAccessorDescriptor\n\t}, Desc)) {\n\t\tthrow new $TypeError('Assertion failed: Desc is not a valid Property Descriptor');\n\t}\n\n\treturn DefineOwnProperty(\n\t\tIsDataDescriptor,\n\t\tSameValue,\n\t\tFromPropertyDescriptor,\n\t\tO,\n\t\tP,\n\t\tDesc\n\t);\n};\n\n\n/***/ }),\n/* 84 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar inspect = __webpack_require__(136);\n\nvar IsPropertyKey = __webpack_require__(8);\nvar Type = __webpack_require__(3);\n\n/**\n * 7.3.1 Get (O, P) - https://ecma-international.org/ecma-262/6.0/#sec-get-o-p\n * 1. Assert: Type(O) is Object.\n * 2. Assert: IsPropertyKey(P) is true.\n * 3. Return O.[[Get]](P, O).\n */\n\nmodule.exports = function Get(O, P) {\n\t// 7.3.1.1\n\tif (Type(O) !== 'Object') {\n\t\tthrow new $TypeError('Assertion failed: Type(O) is not Object');\n\t}\n\t// 7.3.1.2\n\tif (!IsPropertyKey(P)) {\n\t\tthrow new $TypeError('Assertion failed: IsPropertyKey(P) is not true, got ' + inspect(P));\n\t}\n\t// 7.3.1.3\n\treturn O[P];\n};\n\n\n/***/ }),\n/* 85 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar has = __webpack_require__(4);\n\nvar assertRecord = __webpack_require__(20);\n\nvar Type = __webpack_require__(3);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isaccessordescriptor\n\nmodule.exports = function IsAccessorDescriptor(Desc) {\n\tif (typeof Desc === 'undefined') {\n\t\treturn false;\n\t}\n\n\tassertRecord(Type, 'Property Descriptor', 'Desc', Desc);\n\n\tif (!has(Desc, '[[Get]]') && !has(Desc, '[[Set]]')) {\n\t\treturn false;\n\t}\n\n\treturn true;\n};\n\n\n/***/ }),\n/* 86 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(101);\n\nvar $construct = GetIntrinsic('%Reflect.construct%', true);\n\nvar DefinePropertyOrThrow = __webpack_require__(83);\ntry {\n\tDefinePropertyOrThrow({}, '', { '[[Get]]': function () {} });\n} catch (e) {\n\t// Accessor properties aren't supported\n\tDefinePropertyOrThrow = null;\n}\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isconstructor\n\nif (DefinePropertyOrThrow && $construct) {\n\tvar isConstructorMarker = {};\n\tvar badArrayLike = {};\n\tDefinePropertyOrThrow(badArrayLike, 'length', {\n\t\t'[[Get]]': function () {\n\t\t\tthrow isConstructorMarker;\n\t\t},\n\t\t'[[Enumerable]]': true\n\t});\n\n\tmodule.exports = function IsConstructor(argument) {\n\t\ttry {\n\t\t\t// `Reflect.construct` invokes `IsConstructor(target)` before `Get(args, 'length')`:\n\t\t\t$construct(argument, badArrayLike);\n\t\t} catch (err) {\n\t\t\treturn err === isConstructorMarker;\n\t\t}\n\t};\n} else {\n\tmodule.exports = function IsConstructor(argument) {\n\t\t// unfortunately there's no way to truly check this without try/catch `new argument` in old environments\n\t\treturn typeof argument === 'function' && !!argument.prototype;\n\t};\n}\n\n\n/***/ }),\n/* 87 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $Object = GetIntrinsic('%Object%');\n\nvar isPrimitive = __webpack_require__(46);\n\nvar $preventExtensions = $Object.preventExtensions;\nvar $isExtensible = $Object.isExtensible;\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isextensible-o\n\nmodule.exports = $preventExtensions\n\t? function IsExtensible(obj) {\n\t\treturn !isPrimitive(obj) && $isExtensible(obj);\n\t}\n\t: function IsExtensible(obj) {\n\t\treturn !isPrimitive(obj);\n\t};\n\n\n/***/ }),\n/* 88 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $match = GetIntrinsic('%Symbol.match%', true);\n\nvar hasRegExpMatcher = __webpack_require__(120);\n\nvar ToBoolean = __webpack_require__(41);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isregexp\n\nmodule.exports = function IsRegExp(argument) {\n\tif (!argument || typeof argument !== 'object') {\n\t\treturn false;\n\t}\n\tif ($match) {\n\t\tvar isRegExp = argument[$match];\n\t\tif (typeof isRegExp !== 'undefined') {\n\t\t\treturn ToBoolean(isRegExp);\n\t\t}\n\t}\n\treturn hasRegExpMatcher(argument);\n};\n\n\n/***/ }),\n/* 89 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $gOPD = __webpack_require__(102);\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar callBound = __webpack_require__(2);\n\nvar $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');\n\nvar has = __webpack_require__(4);\n\nvar IsArray = __webpack_require__(16);\nvar IsPropertyKey = __webpack_require__(8);\nvar IsRegExp = __webpack_require__(88);\nvar ToPropertyDescriptor = __webpack_require__(43);\nvar Type = __webpack_require__(3);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-ordinarygetownproperty\n\nmodule.exports = function OrdinaryGetOwnProperty(O, P) {\n\tif (Type(O) !== 'Object') {\n\t\tthrow new $TypeError('Assertion failed: O must be an Object');\n\t}\n\tif (!IsPropertyKey(P)) {\n\t\tthrow new $TypeError('Assertion failed: P must be a Property Key');\n\t}\n\tif (!has(O, P)) {\n\t\treturn void 0;\n\t}\n\tif (!$gOPD) {\n\t\t// ES3 / IE 8 fallback\n\t\tvar arrayLength = IsArray(O) && P === 'length';\n\t\tvar regexLastIndex = IsRegExp(O) && P === 'lastIndex';\n\t\treturn {\n\t\t\t'[[Configurable]]': !(arrayLength || regexLastIndex),\n\t\t\t'[[Enumerable]]': $isEnumerable(O, P),\n\t\t\t'[[Value]]': O[P],\n\t\t\t'[[Writable]]': true\n\t\t};\n\t}\n\treturn ToPropertyDescriptor($gOPD(O, P));\n};\n\n\n/***/ }),\n/* 90 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar $isNaN = __webpack_require__(10);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-samevaluezero\n\nmodule.exports = function SameValueZero(x, y) {\n\treturn (x === y) || ($isNaN(x) && $isNaN(y));\n};\n\n\n/***/ }),\n/* 91 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $TypeError = GetIntrinsic('%TypeError%');\nvar $Number = GetIntrinsic('%Number%');\nvar $RegExp = GetIntrinsic('%RegExp%');\nvar $parseInteger = GetIntrinsic('%parseInt%');\n\nvar callBound = __webpack_require__(2);\nvar regexTester = __webpack_require__(105);\nvar isPrimitive = __webpack_require__(46);\n\nvar $strSlice = callBound('String.prototype.slice');\nvar isBinary = regexTester(/^0b[01]+$/i);\nvar isOctal = regexTester(/^0o[0-7]+$/i);\nvar isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);\nvar nonWS = ['\\u0085', '\\u200b', '\\ufffe'].join('');\nvar nonWSregex = new $RegExp('[' + nonWS + ']', 'g');\nvar hasNonWS = regexTester(nonWSregex);\n\n// whitespace from: https://es5.github.io/#x15.5.4.20\n// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324\nvar ws = [\n\t'\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003',\n\t'\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028',\n\t'\\u2029\\uFEFF'\n].join('');\nvar trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');\nvar $replace = callBound('String.prototype.replace');\nvar $trim = function (value) {\n\treturn $replace(value, trimRegex, '');\n};\n\nvar ToPrimitive = __webpack_require__(92);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-tonumber\n\nmodule.exports = function ToNumber(argument) {\n\tvar value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);\n\tif (typeof value === 'symbol') {\n\t\tthrow new $TypeError('Cannot convert a Symbol value to a number');\n\t}\n\tif (typeof value === 'bigint') {\n\t\tthrow new $TypeError('Conversion from \\'BigInt\\' to \\'number\\' is not allowed.');\n\t}\n\tif (typeof value === 'string') {\n\t\tif (isBinary(value)) {\n\t\t\treturn ToNumber($parseInteger($strSlice(value, 2), 2));\n\t\t} else if (isOctal(value)) {\n\t\t\treturn ToNumber($parseInteger($strSlice(value, 2), 8));\n\t\t} else if (hasNonWS(value) || isInvalidHexLiteral(value)) {\n\t\t\treturn NaN;\n\t\t}\n\t\tvar trimmed = $trim(value);\n\t\tif (trimmed !== value) {\n\t\t\treturn ToNumber(trimmed);\n\t\t}\n\n\t}\n\treturn $Number(value);\n};\n\n\n/***/ }),\n/* 92 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar toPrimitive = __webpack_require__(108);\n\n// https://ecma-international.org/ecma-262/6.0/#sec-toprimitive\n\nmodule.exports = function ToPrimitive(input) {\n\tif (arguments.length > 1) {\n\t\treturn toPrimitive(input, arguments[1]);\n\t}\n\treturn toPrimitive(input);\n};\n\n\n/***/ }),\n/* 93 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $String = GetIntrinsic('%String%');\nvar $TypeError = GetIntrinsic('%TypeError%');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-tostring\n\nmodule.exports = function ToString(argument) {\n\tif (typeof argument === 'symbol') {\n\t\tthrow new $TypeError('Cannot convert a Symbol value to a string');\n\t}\n\treturn $String(argument);\n};\n\n\n/***/ }),\n/* 94 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\n// http://262.ecma-international.org/5.1/#sec-9.10\n\nmodule.exports = function CheckObjectCoercible(value, optMessage) {\n\tif (value == null) {\n\t\tthrow new $TypeError(optMessage || ('Cannot call method on ' + value));\n\t}\n\treturn value;\n};\n\n\n/***/ }),\n/* 95 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar abs = __webpack_require__(99);\nvar floor = __webpack_require__(100);\nvar ToNumber = __webpack_require__(96);\n\nvar $isNaN = __webpack_require__(10);\nvar $isFinite = __webpack_require__(45);\nvar $sign = __webpack_require__(106);\n\n// http://262.ecma-international.org/5.1/#sec-9.4\n\nmodule.exports = function ToInteger(value) {\n\tvar number = ToNumber(value);\n\tif ($isNaN(number)) { return 0; }\n\tif (number === 0 || !$isFinite(number)) { return number; }\n\treturn $sign(number) * floor(abs(number));\n};\n\n\n/***/ }),\n/* 96 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar ToPrimitive = __webpack_require__(97);\n\n// http://262.ecma-international.org/5.1/#sec-9.3\n\nmodule.exports = function ToNumber(value) {\n\tvar prim = ToPrimitive(value, Number);\n\tif (typeof prim !== 'string') {\n\t\treturn +prim; // eslint-disable-line no-implicit-coercion\n\t}\n\n\t// eslint-disable-next-line no-control-regex\n\tvar trimmed = prim.replace(/^[ \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\u0085]+|[ \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\u0085]+$/g, '');\n\tif ((/^0[ob]|^[+-]0x/).test(trimmed)) {\n\t\treturn NaN;\n\t}\n\n\treturn +trimmed; // eslint-disable-line no-implicit-coercion\n};\n\n\n/***/ }),\n/* 97 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// http://262.ecma-international.org/5.1/#sec-9.1\n\nmodule.exports = __webpack_require__(109);\n\n\n/***/ }),\n/* 98 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// https://262.ecma-international.org/5.1/#sec-8\n\nmodule.exports = function Type(x) {\n\tif (x === null) {\n\t\treturn 'Null';\n\t}\n\tif (typeof x === 'undefined') {\n\t\treturn 'Undefined';\n\t}\n\tif (typeof x === 'function' || typeof x === 'object') {\n\t\treturn 'Object';\n\t}\n\tif (typeof x === 'number') {\n\t\treturn 'Number';\n\t}\n\tif (typeof x === 'boolean') {\n\t\treturn 'Boolean';\n\t}\n\tif (typeof x === 'string') {\n\t\treturn 'String';\n\t}\n};\n\n\n/***/ }),\n/* 99 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $abs = GetIntrinsic('%Math.abs%');\n\n// http://262.ecma-international.org/5.1/#sec-5.2\n\nmodule.exports = function abs(x) {\n\treturn $abs(x);\n};\n\n\n/***/ }),\n/* 100 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// var modulo = require('./modulo');\nvar $floor = Math.floor;\n\n// http://262.ecma-international.org/5.1/#sec-5.2\n\nmodule.exports = function floor(x) {\n\t// return x - modulo(x, 1);\n\treturn $floor(x);\n};\n\n\n/***/ }),\n/* 101 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// TODO: remove, semver-major\n\nmodule.exports = __webpack_require__(0);\n\n\n/***/ }),\n/* 102 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\nif ($gOPD) {\n\ttry {\n\t\t$gOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\t$gOPD = null;\n\t}\n}\n\nmodule.exports = $gOPD;\n\n\n/***/ }),\n/* 103 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar has = __webpack_require__(4);\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nmodule.exports = function IsPropertyDescriptor(ES, Desc) {\n\tif (ES.Type(Desc) !== 'Object') {\n\t\treturn false;\n\t}\n\tvar allowed = {\n\t\t'[[Configurable]]': true,\n\t\t'[[Enumerable]]': true,\n\t\t'[[Get]]': true,\n\t\t'[[Set]]': true,\n\t\t'[[Value]]': true,\n\t\t'[[Writable]]': true\n\t};\n\n\tfor (var key in Desc) { // eslint-disable-line no-restricted-syntax\n\t\tif (has(Desc, key) && !allowed[key]) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tif (ES.IsDataDescriptor(Desc) && ES.IsAccessorDescriptor(Desc)) {\n\t\tthrow new $TypeError('Property Descriptors may not be both accessor and data descriptors');\n\t}\n\treturn true;\n};\n\n\n/***/ }),\n/* 104 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $Math = GetIntrinsic('%Math%');\nvar $Number = GetIntrinsic('%Number%');\n\nmodule.exports = $Number.MAX_SAFE_INTEGER || $Math.pow(2, 53) - 1;\n\n\n/***/ }),\n/* 105 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar GetIntrinsic = __webpack_require__(0);\n\nvar $test = GetIntrinsic('RegExp.prototype.test');\n\nvar callBind = __webpack_require__(15);\n\nmodule.exports = function regexTester(regex) {\n\treturn callBind($test, regex);\n};\n\n\n/***/ }),\n/* 106 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function sign(number) {\n\treturn number >= 0 ? 1 : -1;\n};\n\n\n/***/ }),\n/* 107 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\n\n/* eslint global-require: 0 */\n// the code is structured this way so that bundlers can\n// alias out `has-symbols` to `() => true` or `() => false` if your target\n// environments' Symbol capabilities are known, and then use\n// dead code elimination on the rest of this module.\n//\n// Similarly, `isarray` can be aliased to `Array.isArray` if\n// available in all target environments.\n\nvar isArguments = __webpack_require__(117);\n\nif (__webpack_require__(23)() || __webpack_require__(24)()) {\n\tvar $iterator = Symbol.iterator;\n\t// Symbol is available natively or shammed\n\t// natively:\n\t//  - Chrome >= 38\n\t//  - Edge 12-14?, Edge >= 15 for sure\n\t//  - FF >= 36\n\t//  - Safari >= 9\n\t//  - node >= 0.12\n\tmodule.exports = function getIterator(iterable) {\n\t\t// alternatively, `iterable[$iterator]?.()`\n\t\tif (iterable != null && typeof iterable[$iterator] !== 'undefined') {\n\t\t\treturn iterable[$iterator]();\n\t\t}\n\t\tif (isArguments(iterable)) {\n\t\t\t// arguments objects lack Symbol.iterator\n\t\t\t// - node 0.12\n\t\t\treturn Array.prototype[$iterator].call(iterable);\n\t\t}\n\t};\n} else {\n\t// Symbol is not available, native or shammed\n\tvar isArray = __webpack_require__(123);\n\tvar isString = __webpack_require__(49);\n\tvar GetIntrinsic = __webpack_require__(0);\n\tvar $Map = GetIntrinsic('%Map%', true);\n\tvar $Set = GetIntrinsic('%Set%', true);\n\tvar callBound = __webpack_require__(2);\n\tvar $arrayPush = callBound('Array.prototype.push');\n\tvar $charCodeAt = callBound('String.prototype.charCodeAt');\n\tvar $stringSlice = callBound('String.prototype.slice');\n\n\tvar advanceStringIndex = function advanceStringIndex(S, index) {\n\t\tvar length = S.length;\n\t\tif ((index + 1) >= length) {\n\t\t\treturn index + 1;\n\t\t}\n\n\t\tvar first = $charCodeAt(S, index);\n\t\tif (first < 0xD800 || first > 0xDBFF) {\n\t\t\treturn index + 1;\n\t\t}\n\n\t\tvar second = $charCodeAt(S, index + 1);\n\t\tif (second < 0xDC00 || second > 0xDFFF) {\n\t\t\treturn index + 1;\n\t\t}\n\n\t\treturn index + 2;\n\t};\n\n\tvar getArrayIterator = function getArrayIterator(arraylike) {\n\t\tvar i = 0;\n\t\treturn {\n\t\t\tnext: function next() {\n\t\t\t\tvar done = i >= arraylike.length;\n\t\t\t\tvar value;\n\t\t\t\tif (!done) {\n\t\t\t\t\tvalue = arraylike[i];\n\t\t\t\t\ti += 1;\n\t\t\t\t}\n\t\t\t\treturn {\n\t\t\t\t\tdone: done,\n\t\t\t\t\tvalue: value\n\t\t\t\t};\n\t\t\t}\n\t\t};\n\t};\n\n\tvar getNonCollectionIterator = function getNonCollectionIterator(iterable, noPrimordialCollections) {\n\t\tif (isArray(iterable) || isArguments(iterable)) {\n\t\t\treturn getArrayIterator(iterable);\n\t\t}\n\t\tif (isString(iterable)) {\n\t\t\tvar i = 0;\n\t\t\treturn {\n\t\t\t\tnext: function next() {\n\t\t\t\t\tvar nextIndex = advanceStringIndex(iterable, i);\n\t\t\t\t\tvar value = $stringSlice(iterable, i, nextIndex);\n\t\t\t\t\ti = nextIndex;\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: nextIndex > iterable.length,\n\t\t\t\t\t\tvalue: value\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\n\t\t// es6-shim and es-shims' es-map use a string \"_es6-shim iterator_\" property on different iterables, such as MapIterator.\n\t\tif (noPrimordialCollections && typeof iterable['_es6-shim iterator_'] !== 'undefined') {\n\t\t\treturn iterable['_es6-shim iterator_']();\n\t\t}\n\t};\n\n\tif (!$Map && !$Set) {\n\t\t// the only language iterables are Array, String, arguments\n\t\t// - Safari <= 6.0\n\t\t// - Chrome < 38\n\t\t// - node < 0.12\n\t\t// - FF < 13\n\t\t// - IE < 11\n\t\t// - Edge < 11\n\n\t\tmodule.exports = function getIterator(iterable) {\n\t\t\tif (iterable != null) {\n\t\t\t\treturn getNonCollectionIterator(iterable, true);\n\t\t\t}\n\t\t};\n\t} else {\n\t\t// either Map or Set are available, but Symbol is not\n\t\t// - es6-shim on an ES5 browser\n\t\t// - Safari 6.2 (maybe 6.1?)\n\t\t// - FF v[13, 36)\n\t\t// - IE 11\n\t\t// - Edge 11\n\t\t// - Safari v[6, 9)\n\n\t\tvar isMap = __webpack_require__(119);\n\t\tvar isSet = __webpack_require__(121);\n\n\t\t// Firefox >= 27, IE 11, Safari 6.2 - 9, Edge 11, es6-shim in older envs, all have forEach\n\t\tvar $mapForEach = callBound('Map.prototype.forEach', true);\n\t\tvar $setForEach = callBound('Set.prototype.forEach', true);\n\t\tif (typeof process === 'undefined' || !process.versions || !process.versions.node) { // \"if is not node\"\n\n\t\t\t// Firefox 17 - 26 has `.iterator()`, whose iterator `.next()` either\n\t\t\t// returns a value, or throws a StopIteration object. These browsers\n\t\t\t// do not have any other mechanism for iteration.\n\t\t\tvar $mapIterator = callBound('Map.prototype.iterator', true);\n\t\t\tvar $setIterator = callBound('Set.prototype.iterator', true);\n\t\t\tvar getStopIterationIterator = function (iterator) {\n\t\t\t\tvar done = false;\n\t\t\t\treturn {\n\t\t\t\t\tnext: function next() {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tdone: done,\n\t\t\t\t\t\t\t\tvalue: done ? undefined : iterator.next()\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\t\tdone = true;\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tdone: true,\n\t\t\t\t\t\t\t\tvalue: undefined\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\t\t}\n\t\t// Firefox 27-35, and some older es6-shim versions, use a string \"@@iterator\" property\n\t\t// this returns a proper iterator object, so we should use it instead of forEach.\n\t\t// newer es6-shim versions use a string \"_es6-shim iterator_\" property.\n\t\tvar $mapAtAtIterator = callBound('Map.prototype.@@iterator', true) || callBound('Map.prototype._es6-shim iterator_', true);\n\t\tvar $setAtAtIterator = callBound('Set.prototype.@@iterator', true) || callBound('Set.prototype._es6-shim iterator_', true);\n\n\t\tvar getCollectionIterator = function getCollectionIterator(iterable) {\n\t\t\tif (isMap(iterable)) {\n\t\t\t\tif ($mapIterator) {\n\t\t\t\t\treturn getStopIterationIterator($mapIterator(iterable));\n\t\t\t\t}\n\t\t\t\tif ($mapAtAtIterator) {\n\t\t\t\t\treturn $mapAtAtIterator(iterable);\n\t\t\t\t}\n\t\t\t\tif ($mapForEach) {\n\t\t\t\t\tvar entries = [];\n\t\t\t\t\t$mapForEach(iterable, function (v, k) {\n\t\t\t\t\t\t$arrayPush(entries, [k, v]);\n\t\t\t\t\t});\n\t\t\t\t\treturn getArrayIterator(entries);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (isSet(iterable)) {\n\t\t\t\tif ($setIterator) {\n\t\t\t\t\treturn getStopIterationIterator($setIterator(iterable));\n\t\t\t\t}\n\t\t\t\tif ($setAtAtIterator) {\n\t\t\t\t\treturn $setAtAtIterator(iterable);\n\t\t\t\t}\n\t\t\t\tif ($setForEach) {\n\t\t\t\t\tvar values = [];\n\t\t\t\t\t$setForEach(iterable, function (v) {\n\t\t\t\t\t\t$arrayPush(values, v);\n\t\t\t\t\t});\n\t\t\t\t\treturn getArrayIterator(values);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\tmodule.exports = function getIterator(iterable) {\n\t\t\treturn getCollectionIterator(iterable) || getNonCollectionIterator(iterable);\n\t\t};\n\t}\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(54)))\n\n/***/ }),\n/* 108 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';\n\nvar isPrimitive = __webpack_require__(47);\nvar isCallable = __webpack_require__(25);\nvar isDate = __webpack_require__(118);\nvar isSymbol = __webpack_require__(122);\n\nvar ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {\n\tif (typeof O === 'undefined' || O === null) {\n\t\tthrow new TypeError('Cannot call method on ' + O);\n\t}\n\tif (typeof hint !== 'string' || (hint !== 'number' && hint !== 'string')) {\n\t\tthrow new TypeError('hint must be \"string\" or \"number\"');\n\t}\n\tvar methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString'];\n\tvar method, result, i;\n\tfor (i = 0; i < methodNames.length; ++i) {\n\t\tmethod = O[methodNames[i]];\n\t\tif (isCallable(method)) {\n\t\t\tresult = method.call(O);\n\t\t\tif (isPrimitive(result)) {\n\t\t\t\treturn result;\n\t\t\t}\n\t\t}\n\t}\n\tthrow new TypeError('No default value');\n};\n\nvar GetMethod = function GetMethod(O, P) {\n\tvar func = O[P];\n\tif (func !== null && typeof func !== 'undefined') {\n\t\tif (!isCallable(func)) {\n\t\t\tthrow new TypeError(func + ' returned for property ' + P + ' of object ' + O + ' is not a function');\n\t\t}\n\t\treturn func;\n\t}\n\treturn void 0;\n};\n\n// http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive\nmodule.exports = function ToPrimitive(input) {\n\tif (isPrimitive(input)) {\n\t\treturn input;\n\t}\n\tvar hint = 'default';\n\tif (arguments.length > 1) {\n\t\tif (arguments[1] === String) {\n\t\t\thint = 'string';\n\t\t} else if (arguments[1] === Number) {\n\t\t\thint = 'number';\n\t\t}\n\t}\n\n\tvar exoticToPrim;\n\tif (hasSymbols) {\n\t\tif (Symbol.toPrimitive) {\n\t\t\texoticToPrim = GetMethod(input, Symbol.toPrimitive);\n\t\t} else if (isSymbol(input)) {\n\t\t\texoticToPrim = Symbol.prototype.valueOf;\n\t\t}\n\t}\n\tif (typeof exoticToPrim !== 'undefined') {\n\t\tvar result = exoticToPrim.call(input, hint);\n\t\tif (isPrimitive(result)) {\n\t\t\treturn result;\n\t\t}\n\t\tthrow new TypeError('unable to convert exotic object to primitive');\n\t}\n\tif (hint === 'default' && (isDate(input) || isSymbol(input))) {\n\t\thint = 'string';\n\t}\n\treturn ordinaryToPrimitive(input, hint === 'default' ? 'number' : hint);\n};\n\n\n/***/ }),\n/* 109 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar toStr = Object.prototype.toString;\n\nvar isPrimitive = __webpack_require__(47);\n\nvar isCallable = __webpack_require__(25);\n\n// http://ecma-international.org/ecma-262/5.1/#sec-8.12.8\nvar ES5internalSlots = {\n\t'[[DefaultValue]]': function (O) {\n\t\tvar actualHint;\n\t\tif (arguments.length > 1) {\n\t\t\tactualHint = arguments[1];\n\t\t} else {\n\t\t\tactualHint = toStr.call(O) === '[object Date]' ? String : Number;\n\t\t}\n\n\t\tif (actualHint === String || actualHint === Number) {\n\t\t\tvar methods = actualHint === String ? ['toString', 'valueOf'] : ['valueOf', 'toString'];\n\t\t\tvar value, i;\n\t\t\tfor (i = 0; i < methods.length; ++i) {\n\t\t\t\tif (isCallable(O[methods[i]])) {\n\t\t\t\t\tvalue = O[methods[i]]();\n\t\t\t\t\tif (isPrimitive(value)) {\n\t\t\t\t\t\treturn value;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new TypeError('No default value');\n\t\t}\n\t\tthrow new TypeError('invalid [[DefaultValue]] hint supplied');\n\t}\n};\n\n// http://ecma-international.org/ecma-262/5.1/#sec-9.1\nmodule.exports = function ToPrimitive(input) {\n\tif (isPrimitive(input)) {\n\t\treturn input;\n\t}\n\tif (arguments.length > 1) {\n\t\treturn ES5internalSlots['[[DefaultValue]]'](input, arguments[1]);\n\t}\n\treturn ES5internalSlots['[[DefaultValue]]'](input);\n};\n\n\n/***/ }),\n/* 110 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(process, global) {/*!\n * @overview es6-promise - a tiny implementation of Promises/A+.\n * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)\n * @license   Licensed under MIT license\n *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE\n * @version   v4.2.8+1e68dce6\n */\n\n(function (global, factory) {\n\t true ? module.exports = factory() :\n\ttypeof define === 'function' && define.amd ? define(factory) :\n\t(global.ES6Promise = factory());\n}(this, (function () { 'use strict';\n\nfunction objectOrFunction(x) {\n  var type = typeof x;\n  return x !== null && (type === 'object' || type === 'function');\n}\n\nfunction isFunction(x) {\n  return typeof x === 'function';\n}\n\n\n\nvar _isArray = void 0;\nif (Array.isArray) {\n  _isArray = Array.isArray;\n} else {\n  _isArray = function (x) {\n    return Object.prototype.toString.call(x) === '[object Array]';\n  };\n}\n\nvar isArray = _isArray;\n\nvar len = 0;\nvar vertxNext = void 0;\nvar customSchedulerFn = void 0;\n\nvar asap = function asap(callback, arg) {\n  queue[len] = callback;\n  queue[len + 1] = arg;\n  len += 2;\n  if (len === 2) {\n    // If len is 2, that means that we need to schedule an async flush.\n    // If additional callbacks are queued before the queue is flushed, they\n    // will be processed by this flush that we are scheduling.\n    if (customSchedulerFn) {\n      customSchedulerFn(flush);\n    } else {\n      scheduleFlush();\n    }\n  }\n};\n\nfunction setScheduler(scheduleFn) {\n  customSchedulerFn = scheduleFn;\n}\n\nfunction setAsap(asapFn) {\n  asap = asapFn;\n}\n\nvar browserWindow = typeof window !== 'undefined' ? window : undefined;\nvar browserGlobal = browserWindow || {};\nvar BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;\nvar isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';\n\n// test for web worker but not in IE10\nvar isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';\n\n// node\nfunction useNextTick() {\n  // node version 0.10.x displays a deprecation warning when nextTick is used recursively\n  // see https://github.com/cujojs/when/issues/410 for details\n  return function () {\n    return process.nextTick(flush);\n  };\n}\n\n// vertx\nfunction useVertxTimer() {\n  if (typeof vertxNext !== 'undefined') {\n    return function () {\n      vertxNext(flush);\n    };\n  }\n\n  return useSetTimeout();\n}\n\nfunction useMutationObserver() {\n  var iterations = 0;\n  var observer = new BrowserMutationObserver(flush);\n  var node = document.createTextNode('');\n  observer.observe(node, { characterData: true });\n\n  return function () {\n    node.data = iterations = ++iterations % 2;\n  };\n}\n\n// web worker\nfunction useMessageChannel() {\n  var channel = new MessageChannel();\n  channel.port1.onmessage = flush;\n  return function () {\n    return channel.port2.postMessage(0);\n  };\n}\n\nfunction useSetTimeout() {\n  // Store setTimeout reference so es6-promise will be unaffected by\n  // other code modifying setTimeout (like sinon.useFakeTimers())\n  var globalSetTimeout = setTimeout;\n  return function () {\n    return globalSetTimeout(flush, 1);\n  };\n}\n\nvar queue = new Array(1000);\nfunction flush() {\n  for (var i = 0; i < len; i += 2) {\n    var callback = queue[i];\n    var arg = queue[i + 1];\n\n    callback(arg);\n\n    queue[i] = undefined;\n    queue[i + 1] = undefined;\n  }\n\n  len = 0;\n}\n\nfunction attemptVertx() {\n  try {\n    var vertx = Function('return this')().require('vertx');\n    vertxNext = vertx.runOnLoop || vertx.runOnContext;\n    return useVertxTimer();\n  } catch (e) {\n    return useSetTimeout();\n  }\n}\n\nvar scheduleFlush = void 0;\n// Decide what async method to use to triggering processing of queued callbacks:\nif (isNode) {\n  scheduleFlush = useNextTick();\n} else if (BrowserMutationObserver) {\n  scheduleFlush = useMutationObserver();\n} else if (isWorker) {\n  scheduleFlush = useMessageChannel();\n} else if (browserWindow === undefined && \"function\" === 'function') {\n  scheduleFlush = attemptVertx();\n} else {\n  scheduleFlush = useSetTimeout();\n}\n\nfunction then(onFulfillment, onRejection) {\n  var parent = this;\n\n  var child = new this.constructor(noop);\n\n  if (child[PROMISE_ID] === undefined) {\n    makePromise(child);\n  }\n\n  var _state = parent._state;\n\n\n  if (_state) {\n    var callback = arguments[_state - 1];\n    asap(function () {\n      return invokeCallback(_state, child, callback, parent._result);\n    });\n  } else {\n    subscribe(parent, child, onFulfillment, onRejection);\n  }\n\n  return child;\n}\n\n/**\n  `Promise.resolve` returns a promise that will become resolved with the\n  passed `value`. It is shorthand for the following:\n\n  ```javascript\n  let promise = new Promise(function(resolve, reject){\n    resolve(1);\n  });\n\n  promise.then(function(value){\n    // value === 1\n  });\n  ```\n\n  Instead of writing the above, your code now simply becomes the following:\n\n  ```javascript\n  let promise = Promise.resolve(1);\n\n  promise.then(function(value){\n    // value === 1\n  });\n  ```\n\n  @method resolve\n  @static\n  @param {Any} value value that the returned promise will be resolved with\n  Useful for tooling.\n  @return {Promise} a promise that will become fulfilled with the given\n  `value`\n*/\nfunction resolve$1(object) {\n  /*jshint validthis:true */\n  var Constructor = this;\n\n  if (object && typeof object === 'object' && object.constructor === Constructor) {\n    return object;\n  }\n\n  var promise = new Constructor(noop);\n  resolve(promise, object);\n  return promise;\n}\n\nvar PROMISE_ID = Math.random().toString(36).substring(2);\n\nfunction noop() {}\n\nvar PENDING = void 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\n\nfunction selfFulfillment() {\n  return new TypeError(\"You cannot resolve a promise with itself\");\n}\n\nfunction cannotReturnOwn() {\n  return new TypeError('A promises callback cannot return that same promise.');\n}\n\nfunction tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {\n  try {\n    then$$1.call(value, fulfillmentHandler, rejectionHandler);\n  } catch (e) {\n    return e;\n  }\n}\n\nfunction handleForeignThenable(promise, thenable, then$$1) {\n  asap(function (promise) {\n    var sealed = false;\n    var error = tryThen(then$$1, thenable, function (value) {\n      if (sealed) {\n        return;\n      }\n      sealed = true;\n      if (thenable !== value) {\n        resolve(promise, value);\n      } else {\n        fulfill(promise, value);\n      }\n    }, function (reason) {\n      if (sealed) {\n        return;\n      }\n      sealed = true;\n\n      reject(promise, reason);\n    }, 'Settle: ' + (promise._label || ' unknown promise'));\n\n    if (!sealed && error) {\n      sealed = true;\n      reject(promise, error);\n    }\n  }, promise);\n}\n\nfunction handleOwnThenable(promise, thenable) {\n  if (thenable._state === FULFILLED) {\n    fulfill(promise, thenable._result);\n  } else if (thenable._state === REJECTED) {\n    reject(promise, thenable._result);\n  } else {\n    subscribe(thenable, undefined, function (value) {\n      return resolve(promise, value);\n    }, function (reason) {\n      return reject(promise, reason);\n    });\n  }\n}\n\nfunction handleMaybeThenable(promise, maybeThenable, then$$1) {\n  if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {\n    handleOwnThenable(promise, maybeThenable);\n  } else {\n    if (then$$1 === undefined) {\n      fulfill(promise, maybeThenable);\n    } else if (isFunction(then$$1)) {\n      handleForeignThenable(promise, maybeThenable, then$$1);\n    } else {\n      fulfill(promise, maybeThenable);\n    }\n  }\n}\n\nfunction resolve(promise, value) {\n  if (promise === value) {\n    reject(promise, selfFulfillment());\n  } else if (objectOrFunction(value)) {\n    var then$$1 = void 0;\n    try {\n      then$$1 = value.then;\n    } catch (error) {\n      reject(promise, error);\n      return;\n    }\n    handleMaybeThenable(promise, value, then$$1);\n  } else {\n    fulfill(promise, value);\n  }\n}\n\nfunction publishRejection(promise) {\n  if (promise._onerror) {\n    promise._onerror(promise._result);\n  }\n\n  publish(promise);\n}\n\nfunction fulfill(promise, value) {\n  if (promise._state !== PENDING) {\n    return;\n  }\n\n  promise._result = value;\n  promise._state = FULFILLED;\n\n  if (promise._subscribers.length !== 0) {\n    asap(publish, promise);\n  }\n}\n\nfunction reject(promise, reason) {\n  if (promise._state !== PENDING) {\n    return;\n  }\n  promise._state = REJECTED;\n  promise._result = reason;\n\n  asap(publishRejection, promise);\n}\n\nfunction subscribe(parent, child, onFulfillment, onRejection) {\n  var _subscribers = parent._subscribers;\n  var length = _subscribers.length;\n\n\n  parent._onerror = null;\n\n  _subscribers[length] = child;\n  _subscribers[length + FULFILLED] = onFulfillment;\n  _subscribers[length + REJECTED] = onRejection;\n\n  if (length === 0 && parent._state) {\n    asap(publish, parent);\n  }\n}\n\nfunction publish(promise) {\n  var subscribers = promise._subscribers;\n  var settled = promise._state;\n\n  if (subscribers.length === 0) {\n    return;\n  }\n\n  var child = void 0,\n      callback = void 0,\n      detail = promise._result;\n\n  for (var i = 0; i < subscribers.length; i += 3) {\n    child = subscribers[i];\n    callback = subscribers[i + settled];\n\n    if (child) {\n      invokeCallback(settled, child, callback, detail);\n    } else {\n      callback(detail);\n    }\n  }\n\n  promise._subscribers.length = 0;\n}\n\nfunction invokeCallback(settled, promise, callback, detail) {\n  var hasCallback = isFunction(callback),\n      value = void 0,\n      error = void 0,\n      succeeded = true;\n\n  if (hasCallback) {\n    try {\n      value = callback(detail);\n    } catch (e) {\n      succeeded = false;\n      error = e;\n    }\n\n    if (promise === value) {\n      reject(promise, cannotReturnOwn());\n      return;\n    }\n  } else {\n    value = detail;\n  }\n\n  if (promise._state !== PENDING) {\n    // noop\n  } else if (hasCallback && succeeded) {\n    resolve(promise, value);\n  } else if (succeeded === false) {\n    reject(promise, error);\n  } else if (settled === FULFILLED) {\n    fulfill(promise, value);\n  } else if (settled === REJECTED) {\n    reject(promise, value);\n  }\n}\n\nfunction initializePromise(promise, resolver) {\n  try {\n    resolver(function resolvePromise(value) {\n      resolve(promise, value);\n    }, function rejectPromise(reason) {\n      reject(promise, reason);\n    });\n  } catch (e) {\n    reject(promise, e);\n  }\n}\n\nvar id = 0;\nfunction nextId() {\n  return id++;\n}\n\nfunction makePromise(promise) {\n  promise[PROMISE_ID] = id++;\n  promise._state = undefined;\n  promise._result = undefined;\n  promise._subscribers = [];\n}\n\nfunction validationError() {\n  return new Error('Array Methods must be provided an Array');\n}\n\nvar Enumerator = function () {\n  function Enumerator(Constructor, input) {\n    this._instanceConstructor = Constructor;\n    this.promise = new Constructor(noop);\n\n    if (!this.promise[PROMISE_ID]) {\n      makePromise(this.promise);\n    }\n\n    if (isArray(input)) {\n      this.length = input.length;\n      this._remaining = input.length;\n\n      this._result = new Array(this.length);\n\n      if (this.length === 0) {\n        fulfill(this.promise, this._result);\n      } else {\n        this.length = this.length || 0;\n        this._enumerate(input);\n        if (this._remaining === 0) {\n          fulfill(this.promise, this._result);\n        }\n      }\n    } else {\n      reject(this.promise, validationError());\n    }\n  }\n\n  Enumerator.prototype._enumerate = function _enumerate(input) {\n    for (var i = 0; this._state === PENDING && i < input.length; i++) {\n      this._eachEntry(input[i], i);\n    }\n  };\n\n  Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {\n    var c = this._instanceConstructor;\n    var resolve$$1 = c.resolve;\n\n\n    if (resolve$$1 === resolve$1) {\n      var _then = void 0;\n      var error = void 0;\n      var didError = false;\n      try {\n        _then = entry.then;\n      } catch (e) {\n        didError = true;\n        error = e;\n      }\n\n      if (_then === then && entry._state !== PENDING) {\n        this._settledAt(entry._state, i, entry._result);\n      } else if (typeof _then !== 'function') {\n        this._remaining--;\n        this._result[i] = entry;\n      } else if (c === Promise$1) {\n        var promise = new c(noop);\n        if (didError) {\n          reject(promise, error);\n        } else {\n          handleMaybeThenable(promise, entry, _then);\n        }\n        this._willSettleAt(promise, i);\n      } else {\n        this._willSettleAt(new c(function (resolve$$1) {\n          return resolve$$1(entry);\n        }), i);\n      }\n    } else {\n      this._willSettleAt(resolve$$1(entry), i);\n    }\n  };\n\n  Enumerator.prototype._settledAt = function _settledAt(state, i, value) {\n    var promise = this.promise;\n\n\n    if (promise._state === PENDING) {\n      this._remaining--;\n\n      if (state === REJECTED) {\n        reject(promise, value);\n      } else {\n        this._result[i] = value;\n      }\n    }\n\n    if (this._remaining === 0) {\n      fulfill(promise, this._result);\n    }\n  };\n\n  Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {\n    var enumerator = this;\n\n    subscribe(promise, undefined, function (value) {\n      return enumerator._settledAt(FULFILLED, i, value);\n    }, function (reason) {\n      return enumerator._settledAt(REJECTED, i, reason);\n    });\n  };\n\n  return Enumerator;\n}();\n\n/**\n  `Promise.all` accepts an array of promises, and returns a new promise which\n  is fulfilled with an array of fulfillment values for the passed promises, or\n  rejected with the reason of the first passed promise to be rejected. It casts all\n  elements of the passed iterable to promises as it runs this algorithm.\n\n  Example:\n\n  ```javascript\n  let promise1 = resolve(1);\n  let promise2 = resolve(2);\n  let promise3 = resolve(3);\n  let promises = [ promise1, promise2, promise3 ];\n\n  Promise.all(promises).then(function(array){\n    // The array here would be [ 1, 2, 3 ];\n  });\n  ```\n\n  If any of the `promises` given to `all` are rejected, the first promise\n  that is rejected will be given as an argument to the returned promises's\n  rejection handler. For example:\n\n  Example:\n\n  ```javascript\n  let promise1 = resolve(1);\n  let promise2 = reject(new Error(\"2\"));\n  let promise3 = reject(new Error(\"3\"));\n  let promises = [ promise1, promise2, promise3 ];\n\n  Promise.all(promises).then(function(array){\n    // Code here never runs because there are rejected promises!\n  }, function(error) {\n    // error.message === \"2\"\n  });\n  ```\n\n  @method all\n  @static\n  @param {Array} entries array of promises\n  @param {String} label optional string for labeling the promise.\n  Useful for tooling.\n  @return {Promise} promise that is fulfilled when all `promises` have been\n  fulfilled, or rejected if any of them become rejected.\n  @static\n*/\nfunction all(entries) {\n  return new Enumerator(this, entries).promise;\n}\n\n/**\n  `Promise.race` returns a new promise which is settled in the same way as the\n  first passed promise to settle.\n\n  Example:\n\n  ```javascript\n  let promise1 = new Promise(function(resolve, reject){\n    setTimeout(function(){\n      resolve('promise 1');\n    }, 200);\n  });\n\n  let promise2 = new Promise(function(resolve, reject){\n    setTimeout(function(){\n      resolve('promise 2');\n    }, 100);\n  });\n\n  Promise.race([promise1, promise2]).then(function(result){\n    // result === 'promise 2' because it was resolved before promise1\n    // was resolved.\n  });\n  ```\n\n  `Promise.race` is deterministic in that only the state of the first\n  settled promise matters. For example, even if other promises given to the\n  `promises` array argument are resolved, but the first settled promise has\n  become rejected before the other promises became fulfilled, the returned\n  promise will become rejected:\n\n  ```javascript\n  let promise1 = new Promise(function(resolve, reject){\n    setTimeout(function(){\n      resolve('promise 1');\n    }, 200);\n  });\n\n  let promise2 = new Promise(function(resolve, reject){\n    setTimeout(function(){\n      reject(new Error('promise 2'));\n    }, 100);\n  });\n\n  Promise.race([promise1, promise2]).then(function(result){\n    // Code here never runs\n  }, function(reason){\n    // reason.message === 'promise 2' because promise 2 became rejected before\n    // promise 1 became fulfilled\n  });\n  ```\n\n  An example real-world use case is implementing timeouts:\n\n  ```javascript\n  Promise.race([ajax('foo.json'), timeout(5000)])\n  ```\n\n  @method race\n  @static\n  @param {Array} promises array of promises to observe\n  Useful for tooling.\n  @return {Promise} a promise which settles in the same way as the first passed\n  promise to settle.\n*/\nfunction race(entries) {\n  /*jshint validthis:true */\n  var Constructor = this;\n\n  if (!isArray(entries)) {\n    return new Constructor(function (_, reject) {\n      return reject(new TypeError('You must pass an array to race.'));\n    });\n  } else {\n    return new Constructor(function (resolve, reject) {\n      var length = entries.length;\n      for (var i = 0; i < length; i++) {\n        Constructor.resolve(entries[i]).then(resolve, reject);\n      }\n    });\n  }\n}\n\n/**\n  `Promise.reject` returns a promise rejected with the passed `reason`.\n  It is shorthand for the following:\n\n  ```javascript\n  let promise = new Promise(function(resolve, reject){\n    reject(new Error('WHOOPS'));\n  });\n\n  promise.then(function(value){\n    // Code here doesn't run because the promise is rejected!\n  }, function(reason){\n    // reason.message === 'WHOOPS'\n  });\n  ```\n\n  Instead of writing the above, your code now simply becomes the following:\n\n  ```javascript\n  let promise = Promise.reject(new Error('WHOOPS'));\n\n  promise.then(function(value){\n    // Code here doesn't run because the promise is rejected!\n  }, function(reason){\n    // reason.message === 'WHOOPS'\n  });\n  ```\n\n  @method reject\n  @static\n  @param {Any} reason value that the returned promise will be rejected with.\n  Useful for tooling.\n  @return {Promise} a promise rejected with the given `reason`.\n*/\nfunction reject$1(reason) {\n  /*jshint validthis:true */\n  var Constructor = this;\n  var promise = new Constructor(noop);\n  reject(promise, reason);\n  return promise;\n}\n\nfunction needsResolver() {\n  throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');\n}\n\nfunction needsNew() {\n  throw new TypeError(\"Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.\");\n}\n\n/**\n  Promise objects represent the eventual result of an asynchronous operation. The\n  primary way of interacting with a promise is through its `then` method, which\n  registers callbacks to receive either a promise's eventual value or the reason\n  why the promise cannot be fulfilled.\n\n  Terminology\n  -----------\n\n  - `promise` is an object or function with a `then` method whose behavior conforms to this specification.\n  - `thenable` is an object or function that defines a `then` method.\n  - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).\n  - `exception` is a value that is thrown using the throw statement.\n  - `reason` is a value that indicates why a promise was rejected.\n  - `settled` the final resting state of a promise, fulfilled or rejected.\n\n  A promise can be in one of three states: pending, fulfilled, or rejected.\n\n  Promises that are fulfilled have a fulfillment value and are in the fulfilled\n  state.  Promises that are rejected have a rejection reason and are in the\n  rejected state.  A fulfillment value is never a thenable.\n\n  Promises can also be said to *resolve* a value.  If this value is also a\n  promise, then the original promise's settled state will match the value's\n  settled state.  So a promise that *resolves* a promise that rejects will\n  itself reject, and a promise that *resolves* a promise that fulfills will\n  itself fulfill.\n\n\n  Basic Usage:\n  ------------\n\n  ```js\n  let promise = new Promise(function(resolve, reject) {\n    // on success\n    resolve(value);\n\n    // on failure\n    reject(reason);\n  });\n\n  promise.then(function(value) {\n    // on fulfillment\n  }, function(reason) {\n    // on rejection\n  });\n  ```\n\n  Advanced Usage:\n  ---------------\n\n  Promises shine when abstracting away asynchronous interactions such as\n  `XMLHttpRequest`s.\n\n  ```js\n  function getJSON(url) {\n    return new Promise(function(resolve, reject){\n      let xhr = new XMLHttpRequest();\n\n      xhr.open('GET', url);\n      xhr.onreadystatechange = handler;\n      xhr.responseType = 'json';\n      xhr.setRequestHeader('Accept', 'application/json');\n      xhr.send();\n\n      function handler() {\n        if (this.readyState === this.DONE) {\n          if (this.status === 200) {\n            resolve(this.response);\n          } else {\n            reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));\n          }\n        }\n      };\n    });\n  }\n\n  getJSON('/posts.json').then(function(json) {\n    // on fulfillment\n  }, function(reason) {\n    // on rejection\n  });\n  ```\n\n  Unlike callbacks, promises are great composable primitives.\n\n  ```js\n  Promise.all([\n    getJSON('/posts'),\n    getJSON('/comments')\n  ]).then(function(values){\n    values[0] // => postsJSON\n    values[1] // => commentsJSON\n\n    return values;\n  });\n  ```\n\n  @class Promise\n  @param {Function} resolver\n  Useful for tooling.\n  @constructor\n*/\n\nvar Promise$1 = function () {\n  function Promise(resolver) {\n    this[PROMISE_ID] = nextId();\n    this._result = this._state = undefined;\n    this._subscribers = [];\n\n    if (noop !== resolver) {\n      typeof resolver !== 'function' && needsResolver();\n      this instanceof Promise ? initializePromise(this, resolver) : needsNew();\n    }\n  }\n\n  /**\n  The primary way of interacting with a promise is through its `then` method,\n  which registers callbacks to receive either a promise's eventual value or the\n  reason why the promise cannot be fulfilled.\n   ```js\n  findUser().then(function(user){\n    // user is available\n  }, function(reason){\n    // user is unavailable, and you are given the reason why\n  });\n  ```\n   Chaining\n  --------\n   The return value of `then` is itself a promise.  This second, 'downstream'\n  promise is resolved with the return value of the first promise's fulfillment\n  or rejection handler, or rejected if the handler throws an exception.\n   ```js\n  findUser().then(function (user) {\n    return user.name;\n  }, function (reason) {\n    return 'default name';\n  }).then(function (userName) {\n    // If `findUser` fulfilled, `userName` will be the user's name, otherwise it\n    // will be `'default name'`\n  });\n   findUser().then(function (user) {\n    throw new Error('Found user, but still unhappy');\n  }, function (reason) {\n    throw new Error('`findUser` rejected and we're unhappy');\n  }).then(function (value) {\n    // never reached\n  }, function (reason) {\n    // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.\n    // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.\n  });\n  ```\n  If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.\n   ```js\n  findUser().then(function (user) {\n    throw new PedagogicalException('Upstream error');\n  }).then(function (value) {\n    // never reached\n  }).then(function (value) {\n    // never reached\n  }, function (reason) {\n    // The `PedgagocialException` is propagated all the way down to here\n  });\n  ```\n   Assimilation\n  ------------\n   Sometimes the value you want to propagate to a downstream promise can only be\n  retrieved asynchronously. This can be achieved by returning a promise in the\n  fulfillment or rejection handler. The downstream promise will then be pending\n  until the returned promise is settled. This is called *assimilation*.\n   ```js\n  findUser().then(function (user) {\n    return findCommentsByAuthor(user);\n  }).then(function (comments) {\n    // The user's comments are now available\n  });\n  ```\n   If the assimliated promise rejects, then the downstream promise will also reject.\n   ```js\n  findUser().then(function (user) {\n    return findCommentsByAuthor(user);\n  }).then(function (comments) {\n    // If `findCommentsByAuthor` fulfills, we'll have the value here\n  }, function (reason) {\n    // If `findCommentsByAuthor` rejects, we'll have the reason here\n  });\n  ```\n   Simple Example\n  --------------\n   Synchronous Example\n   ```javascript\n  let result;\n   try {\n    result = findResult();\n    // success\n  } catch(reason) {\n    // failure\n  }\n  ```\n   Errback Example\n   ```js\n  findResult(function(result, err){\n    if (err) {\n      // failure\n    } else {\n      // success\n    }\n  });\n  ```\n   Promise Example;\n   ```javascript\n  findResult().then(function(result){\n    // success\n  }, function(reason){\n    // failure\n  });\n  ```\n   Advanced Example\n  --------------\n   Synchronous Example\n   ```javascript\n  let author, books;\n   try {\n    author = findAuthor();\n    books  = findBooksByAuthor(author);\n    // success\n  } catch(reason) {\n    // failure\n  }\n  ```\n   Errback Example\n   ```js\n   function foundBooks(books) {\n   }\n   function failure(reason) {\n   }\n   findAuthor(function(author, err){\n    if (err) {\n      failure(err);\n      // failure\n    } else {\n      try {\n        findBoooksByAuthor(author, function(books, err) {\n          if (err) {\n            failure(err);\n          } else {\n            try {\n              foundBooks(books);\n            } catch(reason) {\n              failure(reason);\n            }\n          }\n        });\n      } catch(error) {\n        failure(err);\n      }\n      // success\n    }\n  });\n  ```\n   Promise Example;\n   ```javascript\n  findAuthor().\n    then(findBooksByAuthor).\n    then(function(books){\n      // found books\n  }).catch(function(reason){\n    // something went wrong\n  });\n  ```\n   @method then\n  @param {Function} onFulfilled\n  @param {Function} onRejected\n  Useful for tooling.\n  @return {Promise}\n  */\n\n  /**\n  `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same\n  as the catch block of a try/catch statement.\n  ```js\n  function findAuthor(){\n  throw new Error('couldn't find that author');\n  }\n  // synchronous\n  try {\n  findAuthor();\n  } catch(reason) {\n  // something went wrong\n  }\n  // async with promises\n  findAuthor().catch(function(reason){\n  // something went wrong\n  });\n  ```\n  @method catch\n  @param {Function} onRejection\n  Useful for tooling.\n  @return {Promise}\n  */\n\n\n  Promise.prototype.catch = function _catch(onRejection) {\n    return this.then(null, onRejection);\n  };\n\n  /**\n    `finally` will be invoked regardless of the promise's fate just as native\n    try/catch/finally behaves\n  \n    Synchronous example:\n  \n    ```js\n    findAuthor() {\n      if (Math.random() > 0.5) {\n        throw new Error();\n      }\n      return new Author();\n    }\n  \n    try {\n      return findAuthor(); // succeed or fail\n    } catch(error) {\n      return findOtherAuther();\n    } finally {\n      // always runs\n      // doesn't affect the return value\n    }\n    ```\n  \n    Asynchronous example:\n  \n    ```js\n    findAuthor().catch(function(reason){\n      return findOtherAuther();\n    }).finally(function(){\n      // author was either found, or not\n    });\n    ```\n  \n    @method finally\n    @param {Function} callback\n    @return {Promise}\n  */\n\n\n  Promise.prototype.finally = function _finally(callback) {\n    var promise = this;\n    var constructor = promise.constructor;\n\n    if (isFunction(callback)) {\n      return promise.then(function (value) {\n        return constructor.resolve(callback()).then(function () {\n          return value;\n        });\n      }, function (reason) {\n        return constructor.resolve(callback()).then(function () {\n          throw reason;\n        });\n      });\n    }\n\n    return promise.then(callback, callback);\n  };\n\n  return Promise;\n}();\n\nPromise$1.prototype.then = then;\nPromise$1.all = all;\nPromise$1.race = race;\nPromise$1.resolve = resolve$1;\nPromise$1.reject = reject$1;\nPromise$1._setScheduler = setScheduler;\nPromise$1._setAsap = setAsap;\nPromise$1._asap = asap;\n\n/*global self*/\nfunction polyfill() {\n  var local = void 0;\n\n  if (typeof global !== 'undefined') {\n    local = global;\n  } else if (typeof self !== 'undefined') {\n    local = self;\n  } else {\n    try {\n      local = Function('return this')();\n    } catch (e) {\n      throw new Error('polyfill failed because global object is unavailable in this environment');\n    }\n  }\n\n  var P = local.Promise;\n\n  if (P) {\n    var promiseToString = null;\n    try {\n      promiseToString = Object.prototype.toString.call(P.resolve());\n    } catch (e) {\n      // silently ignored\n    }\n\n    if (promiseToString === '[object Promise]' && !P.cast) {\n      return;\n    }\n  }\n\n  local.Promise = Promise$1;\n}\n\n// Strange compat..\nPromise$1.polyfill = polyfill;\nPromise$1.Promise = Promise$1;\n\nreturn Promise$1;\n\n})));\n\n\n\n//# sourceMappingURL=es6-promise.map\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(54), __webpack_require__(55)))\n\n/***/ }),\n/* 111 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"section--active\":\"nrk-filmavis-liersykehus-section--active\",\"sectionActive\":\"nrk-filmavis-liersykehus-section--active\",\"animate-pulsate\":\"nrk-filmavis-liersykehus-animate-pulsate\",\"animatePulsate\":\"nrk-filmavis-liersykehus-animate-pulsate\",\"pulsateAndRotate\":\"nrk-filmavis-liersykehus-pulsateAndRotate\"};\n\n/***/ }),\n/* 112 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"intro-block\":\"nrk-filmavis-liersykehus-intro-block\",\"introBlock\":\"nrk-filmavis-liersykehus-intro-block\",\"section--ready\":\"nrk-filmavis-liersykehus-section--ready\",\"sectionReady\":\"nrk-filmavis-liersykehus-section--ready\",\"section--active\":\"nrk-filmavis-liersykehus-section--active\",\"sectionActive\":\"nrk-filmavis-liersykehus-section--active\",\"heading-block\":\"nrk-filmavis-liersykehus-heading-block\",\"headingBlock\":\"nrk-filmavis-liersykehus-heading-block\",\"block-textshadow\":\"nrk-filmavis-liersykehus-block-textshadow\",\"blockTextshadow\":\"nrk-filmavis-liersykehus-block-textshadow\",\"block\":\"nrk-filmavis-liersykehus-block\",\"block--shadow\":\"nrk-filmavis-liersykehus-block--shadow\",\"blockShadow\":\"nrk-filmavis-liersykehus-block--shadow\",\"block__right\":\"nrk-filmavis-liersykehus-block__right\",\"blockRight\":\"nrk-filmavis-liersykehus-block--right\",\"block__left\":\"nrk-filmavis-liersykehus-block__left\",\"blockLeft\":\"nrk-filmavis-liersykehus-block--left\",\"block__spaceAfter\":\"nrk-filmavis-liersykehus-block__spaceAfter\",\"blockSpaceAfter\":\"nrk-filmavis-liersykehus-block__spaceAfter\",\"block__lessPadding\":\"nrk-filmavis-liersykehus-block__lessPadding\",\"blockLessPadding\":\"nrk-filmavis-liersykehus-block__lessPadding\",\"block__map\":\"nrk-filmavis-liersykehus-block__map\",\"blockMap\":\"nrk-filmavis-liersykehus-block__map\",\"block__noMarginBottom\":\"nrk-filmavis-liersykehus-block__noMarginBottom\",\"blockNoMarginBottom\":\"nrk-filmavis-liersykehus-block__noMarginBottom\",\"block__lastBlock\":\"nrk-filmavis-liersykehus-block__lastBlock\",\"blockLastBlock\":\"nrk-filmavis-liersykehus-block__lastBlock\",\"block__full-width\":\"nrk-filmavis-liersykehus-block__full-width\",\"blockFullWidth\":\"nrk-filmavis-liersykehus-block__full-width\",\"block__inverse\":\"nrk-filmavis-liersykehus-block__inverse\",\"blockInverse\":\"nrk-filmavis-liersykehus-block__inverse\",\"blockquote\":\"nrk-filmavis-liersykehus-blockquote\",\"blockquote--sm\":\"nrk-filmavis-liersykehus-blockquote--sm\",\"blockquoteSm\":\"nrk-filmavis-liersykehus-blockquote--sm\",\"blockquote--regular\":\"nrk-filmavis-liersykehus-blockquote--regular\",\"blockquoteRegular\":\"nrk-filmavis-liersykehus-blockquote--regular\",\"blockquote--pullquote\":\"nrk-filmavis-liersykehus-blockquote--pullquote\",\"blockquotePullquote\":\"nrk-filmavis-liersykehus-blockquote--pullquote\",\"cite--fancy\":\"nrk-filmavis-liersykehus-cite--fancy\",\"citeFancy\":\"nrk-filmavis-liersykehus-cite--fancy\",\"block--no-bg\":\"nrk-filmavis-liersykehus-block--no-bg\",\"blockNoBg\":\"nrk-filmavis-liersykehus-block--no-bg\",\"block--big-font\":\"nrk-filmavis-liersykehus-block--big-font\",\"blockBigFont\":\"nrk-filmavis-liersykehus-block--big-font\",\"block--xl-font\":\"nrk-filmavis-liersykehus-block--xl-font\",\"blockXlFont\":\"nrk-filmavis-liersykehus-block--xl-font\",\"block--left\":\"nrk-filmavis-liersykehus-block--left\",\"block--right\":\"nrk-filmavis-liersykehus-block--right\",\"block--center\":\"nrk-filmavis-liersykehus-block--center\",\"blockCenter\":\"nrk-filmavis-liersykehus-block--center\",\"image\":\"nrk-filmavis-liersykehus-image\",\"bylinerole\":\"nrk-filmavis-liersykehus-bylinerole\"};\n\n/***/ }),\n/* 113 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"bylineSection\":\"nrk-filmavis-liersykehus-bylineSection\",\"byline--sharebutton--container\":\"nrk-filmavis-liersykehus-byline--sharebutton--container\",\"bylineSharebuttonContainer\":\"nrk-filmavis-liersykehus-byline--sharebutton--container\",\"byline--sharebutton--group\":\"nrk-filmavis-liersykehus-byline--sharebutton--group\",\"bylineSharebuttonGroup\":\"nrk-filmavis-liersykehus-byline--sharebutton--group\",\"byline--sharebutton--item\":\"nrk-filmavis-liersykehus-byline--sharebutton--item\",\"bylineSharebuttonItem\":\"nrk-filmavis-liersykehus-byline--sharebutton--item\",\"seemore--block\":\"nrk-filmavis-liersykehus-seemore--block\",\"seemoreBlock\":\"nrk-filmavis-liersykehus-seemore--block\",\"byline--block\":\"nrk-filmavis-liersykehus-byline--block\",\"bylineBlock\":\"nrk-filmavis-liersykehus-byline--block\",\"seemore--heading\":\"nrk-filmavis-liersykehus-seemore--heading\",\"seemoreHeading\":\"nrk-filmavis-liersykehus-seemore--heading\",\"seemore--heading-link\":\"nrk-filmavis-liersykehus-seemore--heading-link\",\"seemoreHeadingLink\":\"nrk-filmavis-liersykehus-seemore--heading-link\",\"seemore--link--list--wrapper\":\"nrk-filmavis-liersykehus-seemore--link--list--wrapper\",\"seemoreLinkListWrapper\":\"nrk-filmavis-liersykehus-seemore--link--list--wrapper\",\"seemore--link--list\":\"nrk-filmavis-liersykehus-seemore--link--list\",\"seemoreLinkList\":\"nrk-filmavis-liersykehus-seemore--link--list\",\"seemore--link--item\":\"nrk-filmavis-liersykehus-seemore--link--item\",\"seemoreLinkItem\":\"nrk-filmavis-liersykehus-seemore--link--item\",\"seemore--link--image\":\"nrk-filmavis-liersykehus-seemore--link--image\",\"seemoreLinkImage\":\"nrk-filmavis-liersykehus-seemore--link--image\",\"byline--credit--list\":\"nrk-filmavis-liersykehus-byline--credit--list\",\"bylineCreditList\":\"nrk-filmavis-liersykehus-byline--credit--list\",\"byline--credit--list--item\":\"nrk-filmavis-liersykehus-byline--credit--list--item\",\"bylineCreditListItem\":\"nrk-filmavis-liersykehus-byline--credit--list--item\",\"byline--credit--list--item--role\":\"nrk-filmavis-liersykehus-byline--credit--list--item--role\",\"bylineCreditListItemRole\":\"nrk-filmavis-liersykehus-byline--credit--list--item--role\",\"byline--credit--list--item--names\":\"nrk-filmavis-liersykehus-byline--credit--list--item--names\",\"bylineCreditListItemNames\":\"nrk-filmavis-liersykehus-byline--credit--list--item--names\"};\n\n/***/ }),\n/* 114 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"fade\":\"nrk-filmavis-liersykehus-fade\",\"animate-into\":\"nrk-filmavis-liersykehus-animate-into\",\"animateInto\":\"nrk-filmavis-liersykehus-animate-into\",\"animate-away\":\"nrk-filmavis-liersykehus-animate-away\",\"animateAway\":\"nrk-filmavis-liersykehus-animate-away\",\"none\":\"nrk-filmavis-liersykehus-none\",\"actually-none\":\"nrk-filmavis-liersykehus-actually-none\",\"actuallyNone\":\"nrk-filmavis-liersykehus-actually-none\",\"blur\":\"nrk-filmavis-liersykehus-blur\",\"swipe\":\"nrk-filmavis-liersykehus-swipe\",\"swipe-left\":\"nrk-filmavis-liersykehus-swipe-left\",\"swipeLeft\":\"nrk-filmavis-liersykehus-swipe-left\",\"swipe-right\":\"nrk-filmavis-liersykehus-swipe-right\",\"swipeRight\":\"nrk-filmavis-liersykehus-swipe-right\",\"swipe-down\":\"nrk-filmavis-liersykehus-swipe-down\",\"swipeDown\":\"nrk-filmavis-liersykehus-swipe-down\",\"swipe-up\":\"nrk-filmavis-liersykehus-swipe-up\",\"swipeUp\":\"nrk-filmavis-liersykehus-swipe-up\",\"zoom\":\"nrk-filmavis-liersykehus-zoom\",\"zoom-in\":\"nrk-filmavis-liersykehus-zoom-in\",\"zoomIn\":\"nrk-filmavis-liersykehus-zoom-in\",\"zoom-out\":\"nrk-filmavis-liersykehus-zoom-out\",\"zoomOut\":\"nrk-filmavis-liersykehus-zoom-out\"};\n\n/***/ }),\n/* 115 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar slice = Array.prototype.slice;\nvar toStr = Object.prototype.toString;\nvar funcType = '[object Function]';\n\nmodule.exports = function bind(that) {\n    var target = this;\n    if (typeof target !== 'function' || toStr.call(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n    }\n    var args = slice.call(arguments, 1);\n\n    var bound;\n    var binder = function () {\n        if (this instanceof bound) {\n            var result = target.apply(\n                this,\n                args.concat(slice.call(arguments))\n            );\n            if (Object(result) === result) {\n                return result;\n            }\n            return this;\n        } else {\n            return target.apply(\n                that,\n                args.concat(slice.call(arguments))\n            );\n        }\n    };\n\n    var boundLength = Math.max(0, target.length - args.length);\n    var boundArgs = [];\n    for (var i = 0; i < boundLength; i++) {\n        boundArgs.push('$' + i);\n    }\n\n    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);\n\n    if (target.prototype) {\n        var Empty = function Empty() {};\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n    }\n\n    return bound;\n};\n\n\n/***/ }),\n/* 116 */\n/***/ (function(module, exports) {\n\n/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n * \n */\n\n(function(window, document) {\n'use strict';\n\n\n// Exits early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observering a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = entry.rootBounds;\n  this.boundingClientRect = entry.boundingClientRect;\n  this.intersectionRect = entry.intersectionRect || getEmptyRect();\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    this.intersectionRatio = intersectionArea / targetArea;\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (options.root && options.root.nodeType != 1) {\n    throw new Error('root must be an Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  // If the target is already being observed, do nothing.\n  if (this._observationTargets.some(function(item) {\n    return item.element == target;\n  })) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections();\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n\n    return item.element != target;\n  });\n  if (!this._observationTargets.length) {\n    this._unmonitorIntersections();\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibilty state is visible.\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function() {\n  if (!this._monitoringIntersections) {\n    this._monitoringIntersections = true;\n\n    // If a poll interval is set, use polling instead of listening to\n    // resize and scroll events or DOM mutations.\n    if (this.POLL_INTERVAL) {\n      this._monitoringInterval = setInterval(\n          this._checkForIntersections, this.POLL_INTERVAL);\n    }\n    else {\n      addEvent(window, 'resize', this._checkForIntersections, true);\n      addEvent(document, 'scroll', this._checkForIntersections, true);\n\n      if ('MutationObserver' in window) {\n        this._domObserver = new MutationObserver(this._checkForIntersections);\n        this._domObserver.observe(document, {\n          attributes: true,\n          childList: true,\n          characterData: true,\n          subtree: true\n        });\n      }\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function() {\n  if (this._monitoringIntersections) {\n    this._monitoringIntersections = false;\n\n    clearInterval(this._monitoringInterval);\n    this._monitoringInterval = null;\n\n    removeEvent(window, 'resize', this._checkForIntersections, true);\n    removeEvent(document, 'scroll', this._checkForIntersections, true);\n\n    if (this._domObserver) {\n      this._domObserver.disconnect();\n      this._domObserver = null;\n    }\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, rootRect);\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootRect,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, rootRect) {\n\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var targetRect = getBoundingClientRect(target);\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return;\n\n    if (parent == this.root || parent == document) {\n      atRoot = true;\n      parentRect = rootRect;\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      if (parent != document.body &&\n          parent != document.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n\n      if (!intersectionRect) break;\n    }\n    parent = getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {Object} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var html = document.documentElement;\n    var body = document.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {Object} rect The rect object to expand.\n * @return {Object} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  return containsDeep(this.root || document, target);\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its executiong, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detatchEvent == 'function') {\n    node.detatchEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object} The intersection rect or undefined if no intersection\n *     is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  };\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {Object} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {Object} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n/**\n * Checks to see if a parent element contains a child elemnt (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n  return parent;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}(window, document));\n\n\n/***/ }),\n/* 117 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar hasToStringTag = __webpack_require__(12)();\nvar callBound = __webpack_require__(2);\n\nvar $toString = callBound('Object.prototype.toString');\n\nvar isStandardArguments = function isArguments(value) {\n\tif (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {\n\t\treturn false;\n\t}\n\treturn $toString(value) === '[object Arguments]';\n};\n\nvar isLegacyArguments = function isArguments(value) {\n\tif (isStandardArguments(value)) {\n\t\treturn true;\n\t}\n\treturn value !== null &&\n\t\ttypeof value === 'object' &&\n\t\ttypeof value.length === 'number' &&\n\t\tvalue.length >= 0 &&\n\t\t$toString(value) !== '[object Array]' &&\n\t\t$toString(value.callee) === '[object Function]';\n};\n\nvar supportsStandardArguments = (function () {\n\treturn isStandardArguments(arguments);\n}());\n\nisStandardArguments.isLegacyArguments = isLegacyArguments; // for tests\n\nmodule.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;\n\n\n/***/ }),\n/* 118 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar getDay = Date.prototype.getDay;\nvar tryDateObject = function tryDateGetDayCall(value) {\n\ttry {\n\t\tgetDay.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nvar toStr = Object.prototype.toString;\nvar dateClass = '[object Date]';\nvar hasToStringTag = __webpack_require__(12)();\n\nmodule.exports = function isDateObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\treturn hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;\n};\n\n\n/***/ }),\n/* 119 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar $Map = typeof Map === 'function' && Map.prototype ? Map : null;\nvar $Set = typeof Set === 'function' && Set.prototype ? Set : null;\n\nvar exported;\n\nif (!$Map) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isMap(x) {\n\t\t// `Map` is not present in this environment.\n\t\treturn false;\n\t};\n}\n\nvar $mapHas = $Map ? Map.prototype.has : null;\nvar $setHas = $Set ? Set.prototype.has : null;\nif (!exported && !$mapHas) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isMap(x) {\n\t\t// `Map` does not have a `has` method\n\t\treturn false;\n\t};\n}\n\nmodule.exports = exported || function isMap(x) {\n\tif (!x || typeof x !== 'object') {\n\t\treturn false;\n\t}\n\ttry {\n\t\t$mapHas.call(x);\n\t\tif ($setHas) {\n\t\t\ttry {\n\t\t\t\t$setHas.call(x);\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn x instanceof $Map; // core-js workaround, pre-v2.5.0\n\t} catch (e) {}\n\treturn false;\n};\n\n\n/***/ }),\n/* 120 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar callBound = __webpack_require__(2);\nvar hasToStringTag = __webpack_require__(12)();\nvar has;\nvar $exec;\nvar isRegexMarker;\nvar badStringifier;\n\nif (hasToStringTag) {\n\thas = callBound('Object.prototype.hasOwnProperty');\n\t$exec = callBound('RegExp.prototype.exec');\n\tisRegexMarker = {};\n\n\tvar throwRegexMarker = function () {\n\t\tthrow isRegexMarker;\n\t};\n\tbadStringifier = {\n\t\ttoString: throwRegexMarker,\n\t\tvalueOf: throwRegexMarker\n\t};\n\n\tif (typeof Symbol.toPrimitive === 'symbol') {\n\t\tbadStringifier[Symbol.toPrimitive] = throwRegexMarker;\n\t}\n}\n\nvar $toString = callBound('Object.prototype.toString');\nvar gOPD = Object.getOwnPropertyDescriptor;\nvar regexClass = '[object RegExp]';\n\nmodule.exports = hasToStringTag\n\t// eslint-disable-next-line consistent-return\n\t? function isRegex(value) {\n\t\tif (!value || typeof value !== 'object') {\n\t\t\treturn false;\n\t\t}\n\n\t\tvar descriptor = gOPD(value, 'lastIndex');\n\t\tvar hasLastIndexDataProperty = descriptor && has(descriptor, 'value');\n\t\tif (!hasLastIndexDataProperty) {\n\t\t\treturn false;\n\t\t}\n\n\t\ttry {\n\t\t\t$exec(value, badStringifier);\n\t\t} catch (e) {\n\t\t\treturn e === isRegexMarker;\n\t\t}\n\t}\n\t: function isRegex(value) {\n\t\t// In older browsers, typeof regex incorrectly returns 'function'\n\t\tif (!value || (typeof value !== 'object' && typeof value !== 'function')) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn $toString(value) === regexClass;\n\t};\n\n\n/***/ }),\n/* 121 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar $Map = typeof Map === 'function' && Map.prototype ? Map : null;\nvar $Set = typeof Set === 'function' && Set.prototype ? Set : null;\n\nvar exported;\n\nif (!$Set) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isSet(x) {\n\t\t// `Set` is not present in this environment.\n\t\treturn false;\n\t};\n}\n\nvar $mapHas = $Map ? Map.prototype.has : null;\nvar $setHas = $Set ? Set.prototype.has : null;\nif (!exported && !$setHas) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isSet(x) {\n\t\t// `Set` does not have a `has` method\n\t\treturn false;\n\t};\n}\n\nmodule.exports = exported || function isSet(x) {\n\tif (!x || typeof x !== 'object') {\n\t\treturn false;\n\t}\n\ttry {\n\t\t$setHas.call(x);\n\t\tif ($mapHas) {\n\t\t\ttry {\n\t\t\t\t$mapHas.call(x);\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn x instanceof $Set; // core-js workaround, pre-v2.5.0\n\t} catch (e) {}\n\treturn false;\n};\n\n\n/***/ }),\n/* 122 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar toStr = Object.prototype.toString;\nvar hasSymbols = __webpack_require__(23)();\n\nif (hasSymbols) {\n\tvar symToStr = Symbol.prototype.toString;\n\tvar symStringRegex = /^Symbol\\(.*\\)$/;\n\tvar isSymbolObject = function isRealSymbolObject(value) {\n\t\tif (typeof value.valueOf() !== 'symbol') {\n\t\t\treturn false;\n\t\t}\n\t\treturn symStringRegex.test(symToStr.call(value));\n\t};\n\n\tmodule.exports = function isSymbol(value) {\n\t\tif (typeof value === 'symbol') {\n\t\t\treturn true;\n\t\t}\n\t\tif (toStr.call(value) !== '[object Symbol]') {\n\t\t\treturn false;\n\t\t}\n\t\ttry {\n\t\t\treturn isSymbolObject(value);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n} else {\n\n\tmodule.exports = function isSymbol(value) {\n\t\t// this environment does not support Symbols.\n\t\treturn false && value;\n\t};\n}\n\n\n/***/ }),\n/* 123 */\n/***/ (function(module, exports) {\n\nvar toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n\n/***/ }),\n/* 124 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar $TypeError = TypeError;\n\n// eslint-disable-next-line consistent-return\nmodule.exports = function iterateIterator(iterator) {\n\tif (!iterator || typeof iterator.next !== 'function') {\n\t\tthrow new $TypeError('iterator must be an object with a `next` method');\n\t}\n\tif (arguments.length > 1) {\n\t\tvar callback = arguments[1];\n\t\tif (typeof callback !== 'function') {\n\t\t\tthrow new $TypeError('`callback`, if provided, must be a function');\n\t\t}\n\t}\n\tvar values = callback || [];\n\tvar result;\n\twhile ((result = iterator.next()) && !result.done) {\n\t\tif (callback) {\n\t\t\tcallback(result.value); // eslint-disable-line callback-return\n\t\t} else {\n\t\t\tvalues.push(result.value);\n\t\t}\n\t}\n\tif (!callback) {\n\t\treturn values;\n\t}\n};\n\n\n/***/ }),\n/* 125 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar getIterator = __webpack_require__(107);\nvar $TypeError = TypeError;\nvar iterate = __webpack_require__(124);\n\nmodule.exports = function iterateValue(iterable) {\n\tvar iterator = getIterator(iterable);\n\tif (!iterator) {\n\t\tthrow new $TypeError('non-iterable value provided');\n\t}\n\tif (arguments.length > 1) {\n\t\treturn iterate(iterator, arguments[1]);\n\t}\n\treturn iterate(iterator);\n};\n\n\n/***/ }),\n/* 126 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Symbol = __webpack_require__(50),\n    getRawTag = __webpack_require__(129),\n    objectToString = __webpack_require__(130);\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/* 127 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar trimmedEndIndex = __webpack_require__(131);\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nmodule.exports = baseTrim;\n\n\n/***/ }),\n/* 128 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(55)))\n\n/***/ }),\n/* 129 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Symbol = __webpack_require__(50);\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/* 130 */\n/***/ (function(module, exports) {\n\n/** 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/* 131 */\n/***/ (function(module, exports) {\n\n/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nmodule.exports = trimmedEndIndex;\n\n\n/***/ }),\n/* 132 */\n/***/ (function(module, exports) {\n\n/**\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/* 133 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar baseGetTag = __webpack_require__(126),\n    isObjectLike = __webpack_require__(132);\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or 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 a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n\n\n/***/ }),\n/* 134 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar root = __webpack_require__(51);\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n\n\n/***/ }),\n/* 135 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar baseTrim = __webpack_require__(127),\n    isObject = __webpack_require__(26),\n    isSymbol = __webpack_require__(133);\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n\n\n/***/ }),\n/* 136 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar hasMap = typeof Map === 'function' && Map.prototype;\nvar mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;\nvar mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;\nvar mapForEach = hasMap && Map.prototype.forEach;\nvar hasSet = typeof Set === 'function' && Set.prototype;\nvar setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;\nvar setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;\nvar setForEach = hasSet && Set.prototype.forEach;\nvar hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;\nvar weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;\nvar hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;\nvar weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;\nvar hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;\nvar weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;\nvar booleanValueOf = Boolean.prototype.valueOf;\nvar objectToString = Object.prototype.toString;\nvar functionToString = Function.prototype.toString;\nvar $match = String.prototype.match;\nvar $slice = String.prototype.slice;\nvar $replace = String.prototype.replace;\nvar $toUpperCase = String.prototype.toUpperCase;\nvar $toLowerCase = String.prototype.toLowerCase;\nvar $test = RegExp.prototype.test;\nvar $concat = Array.prototype.concat;\nvar $join = Array.prototype.join;\nvar $arrSlice = Array.prototype.slice;\nvar $floor = Math.floor;\nvar bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;\nvar gOPS = Object.getOwnPropertySymbols;\nvar symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;\nvar hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object';\n// ie, `has-tostringtag/shams\nvar toStringTag = typeof Symbol === 'function' && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? 'object' : 'symbol')\n    ? Symbol.toStringTag\n    : null;\nvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\nvar gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) || (\n    [].__proto__ === Array.prototype // eslint-disable-line no-proto\n        ? function (O) {\n            return O.__proto__; // eslint-disable-line no-proto\n        }\n        : null\n);\n\nfunction addNumericSeparator(num, str) {\n    if (\n        num === Infinity\n        || num === -Infinity\n        || num !== num\n        || (num && num > -1000 && num < 1000)\n        || $test.call(/e/, str)\n    ) {\n        return str;\n    }\n    var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;\n    if (typeof num === 'number') {\n        var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)\n        if (int !== num) {\n            var intStr = String(int);\n            var dec = $slice.call(str, intStr.length + 1);\n            return $replace.call(intStr, sepRegex, '$&_') + '.' + $replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, '');\n        }\n    }\n    return $replace.call(str, sepRegex, '$&_');\n}\n\nvar inspectCustom = __webpack_require__(139).custom;\nvar inspectSymbol = inspectCustom && isSymbol(inspectCustom) ? inspectCustom : null;\n\nmodule.exports = function inspect_(obj, options, depth, seen) {\n    var opts = options || {};\n\n    if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) {\n        throw new TypeError('option \"quoteStyle\" must be \"single\" or \"double\"');\n    }\n    if (\n        has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'\n            ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity\n            : opts.maxStringLength !== null\n        )\n    ) {\n        throw new TypeError('option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`');\n    }\n    var customInspect = has(opts, 'customInspect') ? opts.customInspect : true;\n    if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {\n        throw new TypeError('option \"customInspect\", if provided, must be `true`, `false`, or `\\'symbol\\'`');\n    }\n\n    if (\n        has(opts, 'indent')\n        && opts.indent !== null\n        && opts.indent !== '\\t'\n        && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)\n    ) {\n        throw new TypeError('option \"indent\" must be \"\\\\t\", an integer > 0, or `null`');\n    }\n    if (has(opts, 'numericSeparator') && typeof opts.numericSeparator !== 'boolean') {\n        throw new TypeError('option \"numericSeparator\", if provided, must be `true` or `false`');\n    }\n    var numericSeparator = opts.numericSeparator;\n\n    if (typeof obj === 'undefined') {\n        return 'undefined';\n    }\n    if (obj === null) {\n        return 'null';\n    }\n    if (typeof obj === 'boolean') {\n        return obj ? 'true' : 'false';\n    }\n\n    if (typeof obj === 'string') {\n        return inspectString(obj, opts);\n    }\n    if (typeof obj === 'number') {\n        if (obj === 0) {\n            return Infinity / obj > 0 ? '0' : '-0';\n        }\n        var str = String(obj);\n        return numericSeparator ? addNumericSeparator(obj, str) : str;\n    }\n    if (typeof obj === 'bigint') {\n        var bigIntStr = String(obj) + 'n';\n        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;\n    }\n\n    var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;\n    if (typeof depth === 'undefined') { depth = 0; }\n    if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {\n        return isArray(obj) ? '[Array]' : '[Object]';\n    }\n\n    var indent = getIndent(opts, depth);\n\n    if (typeof seen === 'undefined') {\n        seen = [];\n    } else if (indexOf(seen, obj) >= 0) {\n        return '[Circular]';\n    }\n\n    function inspect(value, from, noIndent) {\n        if (from) {\n            seen = $arrSlice.call(seen);\n            seen.push(from);\n        }\n        if (noIndent) {\n            var newOpts = {\n                depth: opts.depth\n            };\n            if (has(opts, 'quoteStyle')) {\n                newOpts.quoteStyle = opts.quoteStyle;\n            }\n            return inspect_(value, newOpts, depth + 1, seen);\n        }\n        return inspect_(value, opts, depth + 1, seen);\n    }\n\n    if (typeof obj === 'function') {\n        var name = nameOf(obj);\n        var keys = arrObjKeys(obj, inspect);\n        return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : '');\n    }\n    if (isSymbol(obj)) {\n        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\\(.*\\))_[^)]*$/, '$1') : symToString.call(obj);\n        return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString;\n    }\n    if (isElement(obj)) {\n        var s = '<' + $toLowerCase.call(String(obj.nodeName));\n        var attrs = obj.attributes || [];\n        for (var i = 0; i < attrs.length; i++) {\n            s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);\n        }\n        s += '>';\n        if (obj.childNodes && obj.childNodes.length) { s += '...'; }\n        s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>';\n        return s;\n    }\n    if (isArray(obj)) {\n        if (obj.length === 0) { return '[]'; }\n        var xs = arrObjKeys(obj, inspect);\n        if (indent && !singleLineValues(xs)) {\n            return '[' + indentedJoin(xs, indent) + ']';\n        }\n        return '[ ' + $join.call(xs, ', ') + ' ]';\n    }\n    if (isError(obj)) {\n        var parts = arrObjKeys(obj, inspect);\n        if ('cause' in obj && !isEnumerable.call(obj, 'cause')) {\n            return '{ [' + String(obj) + '] ' + $join.call($concat.call('[cause]: ' + inspect(obj.cause), parts), ', ') + ' }';\n        }\n        if (parts.length === 0) { return '[' + String(obj) + ']'; }\n        return '{ [' + String(obj) + '] ' + $join.call(parts, ', ') + ' }';\n    }\n    if (typeof obj === 'object' && customInspect) {\n        if (inspectSymbol && typeof obj[inspectSymbol] === 'function') {\n            return obj[inspectSymbol]();\n        } else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') {\n            return obj.inspect();\n        }\n    }\n    if (isMap(obj)) {\n        var mapParts = [];\n        mapForEach.call(obj, function (value, key) {\n            mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));\n        });\n        return collectionOf('Map', mapSize.call(obj), mapParts, indent);\n    }\n    if (isSet(obj)) {\n        var setParts = [];\n        setForEach.call(obj, function (value) {\n            setParts.push(inspect(value, obj));\n        });\n        return collectionOf('Set', setSize.call(obj), setParts, indent);\n    }\n    if (isWeakMap(obj)) {\n        return weakCollectionOf('WeakMap');\n    }\n    if (isWeakSet(obj)) {\n        return weakCollectionOf('WeakSet');\n    }\n    if (isWeakRef(obj)) {\n        return weakCollectionOf('WeakRef');\n    }\n    if (isNumber(obj)) {\n        return markBoxed(inspect(Number(obj)));\n    }\n    if (isBigInt(obj)) {\n        return markBoxed(inspect(bigIntValueOf.call(obj)));\n    }\n    if (isBoolean(obj)) {\n        return markBoxed(booleanValueOf.call(obj));\n    }\n    if (isString(obj)) {\n        return markBoxed(inspect(String(obj)));\n    }\n    if (!isDate(obj) && !isRegExp(obj)) {\n        var ys = arrObjKeys(obj, inspect);\n        var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;\n        var protoTag = obj instanceof Object ? '' : 'null prototype';\n        var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? 'Object' : '';\n        var constructorTag = isPlainObject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';\n        var tag = constructorTag + (stringTag || protoTag ? '[' + $join.call($concat.call([], stringTag || [], protoTag || []), ': ') + '] ' : '');\n        if (ys.length === 0) { return tag + '{}'; }\n        if (indent) {\n            return tag + '{' + indentedJoin(ys, indent) + '}';\n        }\n        return tag + '{ ' + $join.call(ys, ', ') + ' }';\n    }\n    return String(obj);\n};\n\nfunction wrapQuotes(s, defaultStyle, opts) {\n    var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '\"' : \"'\";\n    return quoteChar + s + quoteChar;\n}\n\nfunction quote(s) {\n    return $replace.call(String(s), /\"/g, '&quot;');\n}\n\nfunction isArray(obj) { return toStr(obj) === '[object Array]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isDate(obj) { return toStr(obj) === '[object Date]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isRegExp(obj) { return toStr(obj) === '[object RegExp]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isError(obj) { return toStr(obj) === '[object Error]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isString(obj) { return toStr(obj) === '[object String]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isNumber(obj) { return toStr(obj) === '[object Number]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isBoolean(obj) { return toStr(obj) === '[object Boolean]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\n\n// Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives\nfunction isSymbol(obj) {\n    if (hasShammedSymbols) {\n        return obj && typeof obj === 'object' && obj instanceof Symbol;\n    }\n    if (typeof obj === 'symbol') {\n        return true;\n    }\n    if (!obj || typeof obj !== 'object' || !symToString) {\n        return false;\n    }\n    try {\n        symToString.call(obj);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nfunction isBigInt(obj) {\n    if (!obj || typeof obj !== 'object' || !bigIntValueOf) {\n        return false;\n    }\n    try {\n        bigIntValueOf.call(obj);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nvar hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };\nfunction has(obj, key) {\n    return hasOwn.call(obj, key);\n}\n\nfunction toStr(obj) {\n    return objectToString.call(obj);\n}\n\nfunction nameOf(f) {\n    if (f.name) { return f.name; }\n    var m = $match.call(functionToString.call(f), /^function\\s*([\\w$]+)/);\n    if (m) { return m[1]; }\n    return null;\n}\n\nfunction indexOf(xs, x) {\n    if (xs.indexOf) { return xs.indexOf(x); }\n    for (var i = 0, l = xs.length; i < l; i++) {\n        if (xs[i] === x) { return i; }\n    }\n    return -1;\n}\n\nfunction isMap(x) {\n    if (!mapSize || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        mapSize.call(x);\n        try {\n            setSize.call(x);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof Map; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakMap(x) {\n    if (!weakMapHas || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakMapHas.call(x, weakMapHas);\n        try {\n            weakSetHas.call(x, weakSetHas);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof WeakMap; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakRef(x) {\n    if (!weakRefDeref || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakRefDeref.call(x);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nfunction isSet(x) {\n    if (!setSize || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        setSize.call(x);\n        try {\n            mapSize.call(x);\n        } catch (m) {\n            return true;\n        }\n        return x instanceof Set; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakSet(x) {\n    if (!weakSetHas || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakSetHas.call(x, weakSetHas);\n        try {\n            weakMapHas.call(x, weakMapHas);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof WeakSet; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isElement(x) {\n    if (!x || typeof x !== 'object') { return false; }\n    if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {\n        return true;\n    }\n    return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';\n}\n\nfunction inspectString(str, opts) {\n    if (str.length > opts.maxStringLength) {\n        var remaining = str.length - opts.maxStringLength;\n        var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');\n        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;\n    }\n    // eslint-disable-next-line no-control-regex\n    var s = $replace.call($replace.call(str, /(['\\\\])/g, '\\\\$1'), /[\\x00-\\x1f]/g, lowbyte);\n    return wrapQuotes(s, 'single', opts);\n}\n\nfunction lowbyte(c) {\n    var n = c.charCodeAt(0);\n    var x = {\n        8: 'b',\n        9: 't',\n        10: 'n',\n        12: 'f',\n        13: 'r'\n    }[n];\n    if (x) { return '\\\\' + x; }\n    return '\\\\x' + (n < 0x10 ? '0' : '') + $toUpperCase.call(n.toString(16));\n}\n\nfunction markBoxed(str) {\n    return 'Object(' + str + ')';\n}\n\nfunction weakCollectionOf(type) {\n    return type + ' { ? }';\n}\n\nfunction collectionOf(type, size, entries, indent) {\n    var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ', ');\n    return type + ' (' + size + ') {' + joinedEntries + '}';\n}\n\nfunction singleLineValues(xs) {\n    for (var i = 0; i < xs.length; i++) {\n        if (indexOf(xs[i], '\\n') >= 0) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction getIndent(opts, depth) {\n    var baseIndent;\n    if (opts.indent === '\\t') {\n        baseIndent = '\\t';\n    } else if (typeof opts.indent === 'number' && opts.indent > 0) {\n        baseIndent = $join.call(Array(opts.indent + 1), ' ');\n    } else {\n        return null;\n    }\n    return {\n        base: baseIndent,\n        prev: $join.call(Array(depth + 1), baseIndent)\n    };\n}\n\nfunction indentedJoin(xs, indent) {\n    if (xs.length === 0) { return ''; }\n    var lineJoiner = '\\n' + indent.prev + indent.base;\n    return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\\n' + indent.prev;\n}\n\nfunction arrObjKeys(obj, inspect) {\n    var isArr = isArray(obj);\n    var xs = [];\n    if (isArr) {\n        xs.length = obj.length;\n        for (var i = 0; i < obj.length; i++) {\n            xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';\n        }\n    }\n    var syms = typeof gOPS === 'function' ? gOPS(obj) : [];\n    var symMap;\n    if (hasShammedSymbols) {\n        symMap = {};\n        for (var k = 0; k < syms.length; k++) {\n            symMap['$' + syms[k]] = syms[k];\n        }\n    }\n\n    for (var key in obj) { // eslint-disable-line no-restricted-syntax\n        if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue\n        if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue\n        if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {\n            // this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section\n            continue; // eslint-disable-line no-restricted-syntax, no-continue\n        } else if ($test.call(/[^\\w$]/, key)) {\n            xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));\n        } else {\n            xs.push(key + ': ' + inspect(obj[key], obj));\n        }\n    }\n    if (typeof gOPS === 'function') {\n        for (var j = 0; j < syms.length; j++) {\n            if (isEnumerable.call(obj, syms[j])) {\n                xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));\n            }\n        }\n    }\n    return xs;\n}\n\n\n/***/ }),\n/* 137 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar keysShim;\nif (!Object.keys) {\n\t// modified from https://github.com/es-shims/es5-shim\n\tvar has = Object.prototype.hasOwnProperty;\n\tvar toStr = Object.prototype.toString;\n\tvar isArgs = __webpack_require__(53); // eslint-disable-line global-require\n\tvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\tvar hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');\n\tvar hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');\n\tvar dontEnums = [\n\t\t'toString',\n\t\t'toLocaleString',\n\t\t'valueOf',\n\t\t'hasOwnProperty',\n\t\t'isPrototypeOf',\n\t\t'propertyIsEnumerable',\n\t\t'constructor'\n\t];\n\tvar equalsConstructorPrototype = function (o) {\n\t\tvar ctor = o.constructor;\n\t\treturn ctor && ctor.prototype === o;\n\t};\n\tvar excludedKeys = {\n\t\t$applicationCache: true,\n\t\t$console: true,\n\t\t$external: true,\n\t\t$frame: true,\n\t\t$frameElement: true,\n\t\t$frames: true,\n\t\t$innerHeight: true,\n\t\t$innerWidth: true,\n\t\t$onmozfullscreenchange: true,\n\t\t$onmozfullscreenerror: true,\n\t\t$outerHeight: true,\n\t\t$outerWidth: true,\n\t\t$pageXOffset: true,\n\t\t$pageYOffset: true,\n\t\t$parent: true,\n\t\t$scrollLeft: true,\n\t\t$scrollTop: true,\n\t\t$scrollX: true,\n\t\t$scrollY: true,\n\t\t$self: true,\n\t\t$webkitIndexedDB: true,\n\t\t$webkitStorageInfo: true,\n\t\t$window: true\n\t};\n\tvar hasAutomationEqualityBug = (function () {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined') { return false; }\n\t\tfor (var k in window) {\n\t\t\ttry {\n\t\t\t\tif (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tequalsConstructorPrototype(window[k]);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}());\n\tvar equalsConstructorPrototypeIfNotBuggy = function (o) {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined' || !hasAutomationEqualityBug) {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t}\n\t\ttry {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n\n\tkeysShim = function keys(object) {\n\t\tvar isObject = object !== null && typeof object === 'object';\n\t\tvar isFunction = toStr.call(object) === '[object Function]';\n\t\tvar isArguments = isArgs(object);\n\t\tvar isString = isObject && toStr.call(object) === '[object String]';\n\t\tvar theKeys = [];\n\n\t\tif (!isObject && !isFunction && !isArguments) {\n\t\t\tthrow new TypeError('Object.keys called on a non-object');\n\t\t}\n\n\t\tvar skipProto = hasProtoEnumBug && isFunction;\n\t\tif (isString && object.length > 0 && !has.call(object, 0)) {\n\t\t\tfor (var i = 0; i < object.length; ++i) {\n\t\t\t\ttheKeys.push(String(i));\n\t\t\t}\n\t\t}\n\n\t\tif (isArguments && object.length > 0) {\n\t\t\tfor (var j = 0; j < object.length; ++j) {\n\t\t\t\ttheKeys.push(String(j));\n\t\t\t}\n\t\t} else {\n\t\t\tfor (var name in object) {\n\t\t\t\tif (!(skipProto && name === 'prototype') && has.call(object, name)) {\n\t\t\t\t\ttheKeys.push(String(name));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (hasDontEnumBug) {\n\t\t\tvar skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);\n\n\t\t\tfor (var k = 0; k < dontEnums.length; ++k) {\n\t\t\t\tif (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {\n\t\t\t\t\ttheKeys.push(dontEnums[k]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn theKeys;\n\t};\n}\nmodule.exports = keysShim;\n\n\n/***/ }),\n/* 138 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar slice = Array.prototype.slice;\nvar isArgs = __webpack_require__(53);\n\nvar origKeys = Object.keys;\nvar keysShim = origKeys ? function keys(o) { return origKeys(o); } : __webpack_require__(137);\n\nvar originalKeys = Object.keys;\n\nkeysShim.shim = function shimObjectKeys() {\n\tif (Object.keys) {\n\t\tvar keysWorksWithArguments = (function () {\n\t\t\t// Safari 5.0 bug\n\t\t\tvar args = Object.keys(arguments);\n\t\t\treturn args && args.length === arguments.length;\n\t\t}(1, 2));\n\t\tif (!keysWorksWithArguments) {\n\t\t\tObject.keys = function keys(object) { // eslint-disable-line func-name-matching\n\t\t\t\tif (isArgs(object)) {\n\t\t\t\t\treturn originalKeys(slice.call(object));\n\t\t\t\t}\n\t\t\t\treturn originalKeys(object);\n\t\t\t};\n\t\t}\n\t} else {\n\t\tObject.keys = keysShim;\n\t}\n\treturn Object.keys || keysShim;\n};\n\nmodule.exports = keysShim;\n\n\n/***/ }),\n/* 139 */\n/***/ (function(module, exports) {\n\n/* (ignored) */\n\n/***/ }),\n/* 140 */\n/***/ (function(module, exports, __webpack_require__) {\n\n__webpack_require__(56);\nmodule.exports = __webpack_require__(57);\n\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// index-f166dd.js"," \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// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\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 = 140);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap f166dd96d0848cfd7ef6","'use strict';\n\nvar undefined;\n\nvar $SyntaxError = SyntaxError;\nvar $Function = Function;\nvar $TypeError = TypeError;\n\n// eslint-disable-next-line consistent-return\nvar getEvalledConstructor = function (expressionSyntax) {\n\ttry {\n\t\treturn $Function('\"use strict\"; return (' + expressionSyntax + ').constructor;')();\n\t} catch (e) {}\n};\n\nvar $gOPD = Object.getOwnPropertyDescriptor;\nif ($gOPD) {\n\ttry {\n\t\t$gOPD({}, '');\n\t} catch (e) {\n\t\t$gOPD = null; // this is IE 8, which has a broken gOPD\n\t}\n}\n\nvar throwTypeError = function () {\n\tthrow new $TypeError();\n};\nvar ThrowTypeError = $gOPD\n\t? (function () {\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties\n\t\t\targuments.callee; // IE 8 does not throw here\n\t\t\treturn throwTypeError;\n\t\t} catch (calleeThrows) {\n\t\t\ttry {\n\t\t\t\t// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')\n\t\t\t\treturn $gOPD(arguments, 'callee').get;\n\t\t\t} catch (gOPDthrows) {\n\t\t\t\treturn throwTypeError;\n\t\t\t}\n\t\t}\n\t}())\n\t: throwTypeError;\n\nvar hasSymbols = require('has-symbols')();\n\nvar getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto\n\nvar needsEval = {};\n\nvar TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);\n\nvar INTRINSICS = {\n\t'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,\n\t'%Array%': Array,\n\t'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,\n\t'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,\n\t'%AsyncFromSyncIteratorPrototype%': undefined,\n\t'%AsyncFunction%': needsEval,\n\t'%AsyncGenerator%': needsEval,\n\t'%AsyncGeneratorFunction%': needsEval,\n\t'%AsyncIteratorPrototype%': needsEval,\n\t'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,\n\t'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,\n\t'%Boolean%': Boolean,\n\t'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,\n\t'%Date%': Date,\n\t'%decodeURI%': decodeURI,\n\t'%decodeURIComponent%': decodeURIComponent,\n\t'%encodeURI%': encodeURI,\n\t'%encodeURIComponent%': encodeURIComponent,\n\t'%Error%': Error,\n\t'%eval%': eval, // eslint-disable-line no-eval\n\t'%EvalError%': EvalError,\n\t'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,\n\t'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,\n\t'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,\n\t'%Function%': $Function,\n\t'%GeneratorFunction%': needsEval,\n\t'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,\n\t'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,\n\t'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,\n\t'%isFinite%': isFinite,\n\t'%isNaN%': isNaN,\n\t'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,\n\t'%JSON%': typeof JSON === 'object' ? JSON : undefined,\n\t'%Map%': typeof Map === 'undefined' ? undefined : Map,\n\t'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),\n\t'%Math%': Math,\n\t'%Number%': Number,\n\t'%Object%': Object,\n\t'%parseFloat%': parseFloat,\n\t'%parseInt%': parseInt,\n\t'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,\n\t'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,\n\t'%RangeError%': RangeError,\n\t'%ReferenceError%': ReferenceError,\n\t'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,\n\t'%RegExp%': RegExp,\n\t'%Set%': typeof Set === 'undefined' ? undefined : Set,\n\t'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),\n\t'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,\n\t'%String%': String,\n\t'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,\n\t'%Symbol%': hasSymbols ? Symbol : undefined,\n\t'%SyntaxError%': $SyntaxError,\n\t'%ThrowTypeError%': ThrowTypeError,\n\t'%TypedArray%': TypedArray,\n\t'%TypeError%': $TypeError,\n\t'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,\n\t'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,\n\t'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,\n\t'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,\n\t'%URIError%': URIError,\n\t'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,\n\t'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,\n\t'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet\n};\n\nvar doEval = function doEval(name) {\n\tvar value;\n\tif (name === '%AsyncFunction%') {\n\t\tvalue = getEvalledConstructor('async function () {}');\n\t} else if (name === '%GeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('function* () {}');\n\t} else if (name === '%AsyncGeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('async function* () {}');\n\t} else if (name === '%AsyncGenerator%') {\n\t\tvar fn = doEval('%AsyncGeneratorFunction%');\n\t\tif (fn) {\n\t\t\tvalue = fn.prototype;\n\t\t}\n\t} else if (name === '%AsyncIteratorPrototype%') {\n\t\tvar gen = doEval('%AsyncGenerator%');\n\t\tif (gen) {\n\t\t\tvalue = getProto(gen.prototype);\n\t\t}\n\t}\n\n\tINTRINSICS[name] = value;\n\n\treturn value;\n};\n\nvar LEGACY_ALIASES = {\n\t'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],\n\t'%ArrayPrototype%': ['Array', 'prototype'],\n\t'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],\n\t'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],\n\t'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],\n\t'%ArrayProto_values%': ['Array', 'prototype', 'values'],\n\t'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],\n\t'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],\n\t'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],\n\t'%BooleanPrototype%': ['Boolean', 'prototype'],\n\t'%DataViewPrototype%': ['DataView', 'prototype'],\n\t'%DatePrototype%': ['Date', 'prototype'],\n\t'%ErrorPrototype%': ['Error', 'prototype'],\n\t'%EvalErrorPrototype%': ['EvalError', 'prototype'],\n\t'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],\n\t'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],\n\t'%FunctionPrototype%': ['Function', 'prototype'],\n\t'%Generator%': ['GeneratorFunction', 'prototype'],\n\t'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],\n\t'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],\n\t'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],\n\t'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],\n\t'%JSONParse%': ['JSON', 'parse'],\n\t'%JSONStringify%': ['JSON', 'stringify'],\n\t'%MapPrototype%': ['Map', 'prototype'],\n\t'%NumberPrototype%': ['Number', 'prototype'],\n\t'%ObjectPrototype%': ['Object', 'prototype'],\n\t'%ObjProto_toString%': ['Object', 'prototype', 'toString'],\n\t'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],\n\t'%PromisePrototype%': ['Promise', 'prototype'],\n\t'%PromiseProto_then%': ['Promise', 'prototype', 'then'],\n\t'%Promise_all%': ['Promise', 'all'],\n\t'%Promise_reject%': ['Promise', 'reject'],\n\t'%Promise_resolve%': ['Promise', 'resolve'],\n\t'%RangeErrorPrototype%': ['RangeError', 'prototype'],\n\t'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],\n\t'%RegExpPrototype%': ['RegExp', 'prototype'],\n\t'%SetPrototype%': ['Set', 'prototype'],\n\t'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],\n\t'%StringPrototype%': ['String', 'prototype'],\n\t'%SymbolPrototype%': ['Symbol', 'prototype'],\n\t'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],\n\t'%TypedArrayPrototype%': ['TypedArray', 'prototype'],\n\t'%TypeErrorPrototype%': ['TypeError', 'prototype'],\n\t'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],\n\t'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],\n\t'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],\n\t'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],\n\t'%URIErrorPrototype%': ['URIError', 'prototype'],\n\t'%WeakMapPrototype%': ['WeakMap', 'prototype'],\n\t'%WeakSetPrototype%': ['WeakSet', 'prototype']\n};\n\nvar bind = require('function-bind');\nvar hasOwn = require('has');\nvar $concat = bind.call(Function.call, Array.prototype.concat);\nvar $spliceApply = bind.call(Function.apply, Array.prototype.splice);\nvar $replace = bind.call(Function.call, String.prototype.replace);\nvar $strSlice = bind.call(Function.call, String.prototype.slice);\n\n/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */\nvar rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\nvar reEscapeChar = /\\\\(\\\\)?/g; /** Used to match backslashes in property paths. */\nvar stringToPath = function stringToPath(string) {\n\tvar first = $strSlice(string, 0, 1);\n\tvar last = $strSlice(string, -1);\n\tif (first === '%' && last !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected closing `%`');\n\t} else if (last === '%' && first !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected opening `%`');\n\t}\n\tvar result = [];\n\t$replace(string, rePropName, function (match, number, quote, subString) {\n\t\tresult[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;\n\t});\n\treturn result;\n};\n/* end adaptation */\n\nvar getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {\n\tvar intrinsicName = name;\n\tvar alias;\n\tif (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n\t\talias = LEGACY_ALIASES[intrinsicName];\n\t\tintrinsicName = '%' + alias[0] + '%';\n\t}\n\n\tif (hasOwn(INTRINSICS, intrinsicName)) {\n\t\tvar value = INTRINSICS[intrinsicName];\n\t\tif (value === needsEval) {\n\t\t\tvalue = doEval(intrinsicName);\n\t\t}\n\t\tif (typeof value === 'undefined' && !allowMissing) {\n\t\t\tthrow new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');\n\t\t}\n\n\t\treturn {\n\t\t\talias: alias,\n\t\t\tname: intrinsicName,\n\t\t\tvalue: value\n\t\t};\n\t}\n\n\tthrow new $SyntaxError('intrinsic ' + name + ' does not exist!');\n};\n\nmodule.exports = function GetIntrinsic(name, allowMissing) {\n\tif (typeof name !== 'string' || name.length === 0) {\n\t\tthrow new $TypeError('intrinsic name must be a non-empty string');\n\t}\n\tif (arguments.length > 1 && typeof allowMissing !== 'boolean') {\n\t\tthrow new $TypeError('\"allowMissing\" argument must be a boolean');\n\t}\n\n\tvar parts = stringToPath(name);\n\tvar intrinsicBaseName = parts.length > 0 ? parts[0] : '';\n\n\tvar intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);\n\tvar intrinsicRealName = intrinsic.name;\n\tvar value = intrinsic.value;\n\tvar skipFurtherCaching = false;\n\n\tvar alias = intrinsic.alias;\n\tif (alias) {\n\t\tintrinsicBaseName = alias[0];\n\t\t$spliceApply(parts, $concat([0, 1], alias));\n\t}\n\n\tfor (var i = 1, isOwn = true; i < parts.length; i += 1) {\n\t\tvar part = parts[i];\n\t\tvar first = $strSlice(part, 0, 1);\n\t\tvar last = $strSlice(part, -1);\n\t\tif (\n\t\t\t(\n\t\t\t\t(first === '\"' || first === \"'\" || first === '`')\n\t\t\t\t|| (last === '\"' || last === \"'\" || last === '`')\n\t\t\t)\n\t\t\t&& first !== last\n\t\t) {\n\t\t\tthrow new $SyntaxError('property names with quotes must have matching quotes');\n\t\t}\n\t\tif (part === 'constructor' || !isOwn) {\n\t\t\tskipFurtherCaching = true;\n\t\t}\n\n\t\tintrinsicBaseName += '.' + part;\n\t\tintrinsicRealName = '%' + intrinsicBaseName + '%';\n\n\t\tif (hasOwn(INTRINSICS, intrinsicRealName)) {\n\t\t\tvalue = INTRINSICS[intrinsicRealName];\n\t\t} else if (value != null) {\n\t\t\tif (!(part in value)) {\n\t\t\t\tif (!allowMissing) {\n\t\t\t\t\tthrow new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');\n\t\t\t\t}\n\t\t\t\treturn void undefined;\n\t\t\t}\n\t\t\tif ($gOPD && (i + 1) >= parts.length) {\n\t\t\t\tvar desc = $gOPD(value, part);\n\t\t\t\tisOwn = !!desc;\n\n\t\t\t\t// By convention, when a data property is converted to an accessor\n\t\t\t\t// property to emulate a data property that does not suffer from\n\t\t\t\t// the override mistake, that accessor's getter is marked with\n\t\t\t\t// an `originalValue` property. Here, when we detect this, we\n\t\t\t\t// uphold the illusion by pretending to see that original data\n\t\t\t\t// property, i.e., returning the value rather than the getter\n\t\t\t\t// itself.\n\t\t\t\tif (isOwn && 'get' in desc && !('originalValue' in desc.get)) {\n\t\t\t\t\tvalue = desc.get;\n\t\t\t\t} else {\n\t\t\t\t\tvalue = value[part];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tisOwn = hasOwn(value, part);\n\t\t\t\tvalue = value[part];\n\t\t\t}\n\n\t\t\tif (isOwn && !skipFurtherCaching) {\n\t\t\t\tINTRINSICS[intrinsicRealName] = value;\n\t\t\t}\n\t\t}\n\t}\n\treturn value;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/get-intrinsic/index.js\n// module id = 0\n// module chunks = 0","// removed by extract-text-webpack-plugin\nmodule.exports = {\"backgrounds\":\"nrk-filmavis-liersykehus-backgrounds\",\"background\":\"nrk-filmavis-liersykehus-background\",\"visible\":\"nrk-filmavis-liersykehus-visible\",\"background--active\":\"nrk-filmavis-liersykehus-background--active\",\"backgroundActive\":\"nrk-filmavis-liersykehus-background--active\",\"background--ready\":\"nrk-filmavis-liersykehus-background--ready\",\"backgroundReady\":\"nrk-filmavis-liersykehus-background--ready\",\"superoverlay\":\"nrk-filmavis-liersykehus-superoverlay\",\"backgroundGradient\":\"nrk-filmavis-liersykehus-backgroundGradient\",\"uncropped-image-container\":\"nrk-filmavis-liersykehus-uncropped-image-container\",\"uncroppedImageContainer\":\"nrk-filmavis-liersykehus-uncropped-image-container\",\"panorama-image-container\":\"nrk-filmavis-liersykehus-panorama-image-container\",\"panoramaImageContainer\":\"nrk-filmavis-liersykehus-panorama-image-container\",\"trigger-on-scroll-container\":\"nrk-filmavis-liersykehus-trigger-on-scroll-container\",\"triggerOnScrollContainer\":\"nrk-filmavis-liersykehus-trigger-on-scroll-container\",\"background-overlay\":\"nrk-filmavis-liersykehus-background-overlay\",\"backgroundOverlay\":\"nrk-filmavis-liersykehus-background-overlay\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/shared/stylesheets/background.css\n// module id = 1\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar callBind = require('./');\n\nvar $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));\n\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\tvar intrinsic = GetIntrinsic(name, !!allowMissing);\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBind(intrinsic);\n\t}\n\treturn intrinsic;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/call-bind/callBound.js\n// module id = 2\n// module chunks = 0","'use strict';\n\nvar ES5Type = require('../5/Type');\n\n// https://262.ecma-international.org/11.0/#sec-ecmascript-data-types-and-values\n\nmodule.exports = function Type(x) {\n\tif (typeof x === 'symbol') {\n\t\treturn 'Symbol';\n\t}\n\tif (typeof x === 'bigint') {\n\t\treturn 'BigInt';\n\t}\n\treturn ES5Type(x);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/Type.js\n// module id = 3\n// module chunks = 0","'use strict';\n\nvar bind = require('function-bind');\n\nmodule.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/has/src/index.js\n// module id = 4\n// module chunks = 0","'use strict';\n\nvar keys = require('object-keys');\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';\n\nvar toStr = Object.prototype.toString;\nvar concat = Array.prototype.concat;\nvar origDefineProperty = Object.defineProperty;\n\nvar isFunction = function (fn) {\n\treturn typeof fn === 'function' && toStr.call(fn) === '[object Function]';\n};\n\nvar arePropertyDescriptorsSupported = function () {\n\tvar obj = {};\n\ttry {\n\t\torigDefineProperty(obj, 'x', { enumerable: false, value: obj });\n\t\t// eslint-disable-next-line no-unused-vars, no-restricted-syntax\n\t\tfor (var _ in obj) { // jscs:ignore disallowUnusedVariables\n\t\t\treturn false;\n\t\t}\n\t\treturn obj.x === obj;\n\t} catch (e) { /* this is IE 8. */\n\t\treturn false;\n\t}\n};\nvar supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();\n\nvar defineProperty = function (object, name, value, predicate) {\n\tif (name in object && (!isFunction(predicate) || !predicate())) {\n\t\treturn;\n\t}\n\tif (supportsDescriptors) {\n\t\torigDefineProperty(object, name, {\n\t\t\tconfigurable: true,\n\t\t\tenumerable: false,\n\t\t\tvalue: value,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\tobject[name] = value;\n\t}\n};\n\nvar defineProperties = function (object, map) {\n\tvar predicates = arguments.length > 2 ? arguments[2] : {};\n\tvar props = keys(map);\n\tif (hasSymbols) {\n\t\tprops = concat.call(props, Object.getOwnPropertySymbols(map));\n\t}\n\tfor (var i = 0; i < props.length; i += 1) {\n\t\tdefineProperty(object, props[i], map[props[i]], predicates[props[i]]);\n\t}\n};\n\ndefineProperties.supportsDescriptors = !!supportsDescriptors;\n\nmodule.exports = defineProperties;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/define-properties/index.js\n// module id = 5\n// module chunks = 0","// removed by extract-text-webpack-plugin\nmodule.exports = {\"align-top\":\"nrk-filmavis-liersykehus-align-top\",\"alignTop\":\"nrk-filmavis-liersykehus-align-top\",\"align-center\":\"nrk-filmavis-liersykehus-align-center\",\"alignCenter\":\"nrk-filmavis-liersykehus-align-center\",\"align-left\":\"nrk-filmavis-liersykehus-align-left\",\"alignLeft\":\"nrk-filmavis-liersykehus-align-left\",\"align-right\":\"nrk-filmavis-liersykehus-align-right\",\"alignRight\":\"nrk-filmavis-liersykehus-align-right\",\"align-middle\":\"nrk-filmavis-liersykehus-align-middle\",\"alignMiddle\":\"nrk-filmavis-liersykehus-align-middle\",\"align-bottom\":\"nrk-filmavis-liersykehus-align-bottom\",\"alignBottom\":\"nrk-filmavis-liersykehus-align-bottom\",\"mobile-align-top\":\"nrk-filmavis-liersykehus-mobile-align-top\",\"mobileAlignTop\":\"nrk-filmavis-liersykehus-mobile-align-top\",\"mobile-align-center\":\"nrk-filmavis-liersykehus-mobile-align-center\",\"mobileAlignCenter\":\"nrk-filmavis-liersykehus-mobile-align-center\",\"mobile-align-left\":\"nrk-filmavis-liersykehus-mobile-align-left\",\"mobileAlignLeft\":\"nrk-filmavis-liersykehus-mobile-align-left\",\"mobile-align-right\":\"nrk-filmavis-liersykehus-mobile-align-right\",\"mobileAlignRight\":\"nrk-filmavis-liersykehus-mobile-align-right\",\"mobile-align-middle\":\"nrk-filmavis-liersykehus-mobile-align-middle\",\"mobileAlignMiddle\":\"nrk-filmavis-liersykehus-mobile-align-middle\",\"mobile-align-bottom\":\"nrk-filmavis-liersykehus-mobile-align-bottom\",\"mobileAlignBottom\":\"nrk-filmavis-liersykehus-mobile-align-bottom\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/shared/stylesheets/alignment/index.css\n// module id = 6\n// module chunks = 0","import { createImageUrl } from '@nrk/serum-imagecrop-utils'\n\nexport const supportedWidths = [320, 450, 650, 768, 900, 1280, 1600, 1920, 2400]\n\nexport function createSrcSet(imageId, ratio, supportedWidths) {\n  return supportedWidths\n    .map(width => {\n      const imageUrl = createImageUrl({ id: imageId, width, ratio, quality: 0.7 })\n      return `${imageUrl} ${width}w`\n    })\n    .join(', ')\n}\n\nexport function prepareUrl(url, ratio, width) {\n  return url.replace('{{ratio}}', ratio).replace('{{width}}', width)\n}\n\nexport function getPolopolyImageElement(\n  polopolyId: string,\n  alignmentClasses: string = '',\n  imgStyle: string = '',\n  pictureStyle: string = ''\n): string {\n  // const defaultUrl = createImageUrl({ id: polopolyId, width: 1600, ratio: '1:1', quality: 0.7 })\n  // const desktopSourceSet = createSrcSet(polopolyId, '1:1', supportedWidths)\n  const defaultUrl = createImageUrl({\n    id: polopolyId,\n    width: 1600,\n    ratio: '16:9',\n    quality: 0.7\n  })\n  const desktopSourceSet = createSrcSet(polopolyId, '16:9', supportedWidths)\n\n  const mobileSourceSet = createSrcSet(polopolyId, '3:4', supportedWidths)\n\n  return `\n    <picture style=\"${pictureStyle}\">\n      <source media=\"(min-aspect-ratio: 3/4)\" srcset=\"${desktopSourceSet}\">\n      <img src=\"${defaultUrl}\" srcset=\"${mobileSourceSet}\" class=\"${\n    alignmentClasses\n  }\" style=\"${imgStyle}\">\n    </picture>`\n}\n\nexport function getImageForegroundElement(imageUrl: string, alignmentClasses: string = ''): string {\n  const imgStyle = ''\n  return `<img src=\"${imageUrl}\" class=\"${alignmentClasses}\" style=\"${imgStyle}\">`\n}\n\nexport function getImageElement(imageUrl: string, alignmentClasses: string = ''): string {\n  const imgStyle = 'min-width: 100%; min-height: 100%; position: relative;'\n  return `<img src=\"${imageUrl}\" class=\"${alignmentClasses}\" style=\"${imgStyle}\">`\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/utils/imageUtils.js","'use strict';\n\n// https://ecma-international.org/ecma-262/6.0/#sec-ispropertykey\n\nmodule.exports = function IsPropertyKey(argument) {\n\treturn typeof argument === 'string' || typeof argument === 'symbol';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/IsPropertyKey.js\n// module id = 8\n// module chunks = 0","'use strict';\n\n// http://262.ecma-international.org/5.1/#sec-9.11\n\nmodule.exports = require('is-callable');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/IsCallable.js\n// module id = 9\n// module chunks = 0","'use strict';\n\nmodule.exports = Number.isNaN || function isNaN(a) {\n\treturn a !== a;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/helpers/isNaN.js\n// module id = 10\n// module chunks = 0","// removed by extract-text-webpack-plugin\nmodule.exports = {\"video\":\"nrk-filmavis-liersykehus-video\",\"darkedout\":\"nrk-filmavis-liersykehus-darkedout\",\"fullscreen--video\":\"nrk-filmavis-liersykehus-fullscreen--video\",\"fullscreenVideo\":\"nrk-filmavis-liersykehus-fullscreen--video\",\"fullscreen--video--container\":\"nrk-filmavis-liersykehus-fullscreen--video--container\",\"fullscreenVideoContainer\":\"nrk-filmavis-liersykehus-fullscreen--video--container\",\"video-mute-button\":\"nrk-filmavis-liersykehus-video-mute-button\",\"videoMuteButton\":\"nrk-filmavis-liersykehus-video-mute-button\",\"video-mute-svg-muted-hover\":\"nrk-filmavis-liersykehus-video-mute-svg-muted-hover\",\"videoMuteSvgMutedHover\":\"nrk-filmavis-liersykehus-video-mute-svg-muted-hover\",\"video-mute-svg-unmuted-hover\":\"nrk-filmavis-liersykehus-video-mute-svg-unmuted-hover\",\"videoMuteSvgUnmutedHover\":\"nrk-filmavis-liersykehus-video-mute-svg-unmuted-hover\",\"visible\":\"nrk-filmavis-liersykehus-visible\",\"hide-play\":\"nrk-filmavis-liersykehus-hide-play\",\"hidePlay\":\"nrk-filmavis-liersykehus-hide-play\",\"subtitlescontainer\":\"nrk-filmavis-liersykehus-subtitlescontainer\",\"subtitles\":\"nrk-filmavis-liersykehus-subtitles\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/shared/stylesheets/video.css\n// module id = 11\n// module chunks = 0","'use strict';\n\nvar hasSymbols = require('has-symbols/shams');\n\nmodule.exports = function hasToStringTagShams() {\n\treturn hasSymbols() && !!Symbol.toStringTag;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/has-tostringtag/shams.js\n// module id = 12\n// module chunks = 0","const label = 'snapchat-saken'\nlet isTrackingEnabled = false\n\nexport function initialize(trackingEnabled) {\n  isTrackingEnabled = trackingEnabled\n  // label = name\n}\n\nexport function trackAction(action) {\n  sendToGoogleAnalytics({\n    category: 'dh-richer-feature',\n    action,\n    label\n  })\n}\n\nfunction sendToGoogleAnalytics({ category, action, label }) {\n  if (window.ga && isTrackingEnabled) {\n    window.ga('send', 'event', category, action, label)\n  } else {\n    if (typeof console !== 'undefined') {\n      console.log(category, action, label)\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/utils/googleAnalytics.js","// @flow\nimport { backgroundOverlay } from '../stylesheets/background.css'\n\nexport const getOverlayElement = (overlay: ?boolean | ?Object): string => {\n  let defaultOverlay = {\n    opacity: 0.6,\n    color: '#000'\n  }\n\n  if (overlay === true) {\n    return `<div class=\"${backgroundOverlay}\" style=\"background-color: ${defaultOverlay.color}; opacity: ${defaultOverlay.opacity}\"></div>`\n  }\n\n  if (overlay) {\n    Object.assign(defaultOverlay, overlay)\n    return `<div class=\"${backgroundOverlay}\" style=\"background-color: ${defaultOverlay.color}; opacity: ${defaultOverlay.opacity}\"></div>`\n  }\n\n  return ''\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/utils/renderUtils.js","'use strict';\n\nvar bind = require('function-bind');\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $apply = GetIntrinsic('%Function.prototype.apply%');\nvar $call = GetIntrinsic('%Function.prototype.call%');\nvar $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true);\nvar $max = GetIntrinsic('%Math.max%');\n\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = null;\n\t}\n}\n\nmodule.exports = function callBind(originalFunction) {\n\tvar func = $reflectApply(bind, $call, arguments);\n\tif ($gOPD && $defineProperty) {\n\t\tvar desc = $gOPD(func, 'length');\n\t\tif (desc.configurable) {\n\t\t\t// original length, plus the receiver, minus any additional arguments (after the receiver)\n\t\t\t$defineProperty(\n\t\t\t\tfunc,\n\t\t\t\t'length',\n\t\t\t\t{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }\n\t\t\t);\n\t\t}\n\t}\n\treturn func;\n};\n\nvar applyBind = function applyBind() {\n\treturn $reflectApply(bind, $apply, arguments);\n};\n\nif ($defineProperty) {\n\t$defineProperty(module.exports, 'apply', { value: applyBind });\n} else {\n\tmodule.exports.apply = applyBind;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/call-bind/index.js\n// module id = 15\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $Array = GetIntrinsic('%Array%');\n\n// eslint-disable-next-line global-require\nvar toStr = !$Array.isArray && require('call-bind/callBound')('Object.prototype.toString');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isarray\n\nmodule.exports = $Array.isArray || function IsArray(argument) {\n\treturn toStr(argument) === '[object Array]';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/IsArray.js\n// module id = 16\n// module chunks = 0","'use strict';\n\nmodule.exports = require('../5/CheckObjectCoercible');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/RequireObjectCoercible.js\n// module id = 17\n// module chunks = 0","'use strict';\n\nvar MAX_SAFE_INTEGER = require('../helpers/maxSafeInteger');\n\nvar ToIntegerOrInfinity = require('./ToIntegerOrInfinity');\n\nmodule.exports = function ToLength(argument) {\n\tvar len = ToIntegerOrInfinity(argument);\n\tif (len <= 0) { return 0; } // includes converting -0 to +0\n\tif (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; }\n\treturn len;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/ToLength.js\n// module id = 18\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $Object = GetIntrinsic('%Object%');\n\nvar RequireObjectCoercible = require('./RequireObjectCoercible');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-toobject\n\nmodule.exports = function ToObject(value) {\n\tRequireObjectCoercible(value);\n\treturn $Object(value);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/ToObject.js\n// module id = 19\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\nvar $SyntaxError = GetIntrinsic('%SyntaxError%');\n\nvar has = require('has');\n\nvar predicates = {\n\t// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type\n\t'Property Descriptor': function isPropertyDescriptor(Type, Desc) {\n\t\tif (Type(Desc) !== 'Object') {\n\t\t\treturn false;\n\t\t}\n\t\tvar allowed = {\n\t\t\t'[[Configurable]]': true,\n\t\t\t'[[Enumerable]]': true,\n\t\t\t'[[Get]]': true,\n\t\t\t'[[Set]]': true,\n\t\t\t'[[Value]]': true,\n\t\t\t'[[Writable]]': true\n\t\t};\n\n\t\tfor (var key in Desc) { // eslint-disable-line\n\t\t\tif (has(Desc, key) && !allowed[key]) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tvar isData = has(Desc, '[[Value]]');\n\t\tvar IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]');\n\t\tif (isData && IsAccessor) {\n\t\t\tthrow new $TypeError('Property Descriptors may not be both accessor and data descriptors');\n\t\t}\n\t\treturn true;\n\t}\n};\n\nmodule.exports = function assertRecord(Type, recordType, argumentName, value) {\n\tvar predicate = predicates[recordType];\n\tif (typeof predicate !== 'function') {\n\t\tthrow new $SyntaxError('unknown record type: ' + recordType);\n\t}\n\tif (!predicate(Type, value)) {\n\t\tthrow new $TypeError(argumentName + ' must be a ' + recordType);\n\t}\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/helpers/assertRecord.js\n// module id = 20\n// module chunks = 0","// removed by extract-text-webpack-plugin\nmodule.exports = {\"mood--background-light\":\"nrk-filmavis-liersykehus-mood--background-light\",\"moodBackgroundLight\":\"nrk-filmavis-liersykehus-mood--background-light\",\"mood--background-medium\":\"nrk-filmavis-liersykehus-mood--background-medium\",\"moodBackgroundMedium\":\"nrk-filmavis-liersykehus-mood--background-medium\",\"mood--background-dark\":\"nrk-filmavis-liersykehus-mood--background-dark\",\"moodBackgroundDark\":\"nrk-filmavis-liersykehus-mood--background-dark\",\"mood--background-default\":\"nrk-filmavis-liersykehus-mood--background-default\",\"moodBackgroundDefault\":\"nrk-filmavis-liersykehus-mood--background-default\",\"mood--foreground-light\":\"nrk-filmavis-liersykehus-mood--foreground-light\",\"moodForegroundLight\":\"nrk-filmavis-liersykehus-mood--foreground-light\",\"mood--foreground-medium\":\"nrk-filmavis-liersykehus-mood--foreground-medium\",\"moodForegroundMedium\":\"nrk-filmavis-liersykehus-mood--foreground-medium\",\"mood--foreground-dark\":\"nrk-filmavis-liersykehus-mood--foreground-dark\",\"moodForegroundDark\":\"nrk-filmavis-liersykehus-mood--foreground-dark\",\"mood--foreground-default\":\"nrk-filmavis-liersykehus-mood--foreground-default\",\"moodForegroundDefault\":\"nrk-filmavis-liersykehus-mood--foreground-default\",\"type--image\":\"nrk-filmavis-liersykehus-type--image\",\"typeImage\":\"nrk-filmavis-liersykehus-type--image\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/shared/stylesheets/mood.css\n// module id = 21\n// module chunks = 0","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = Function.prototype.bind || implementation;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/function-bind/index.js\n// module id = 22\n// module chunks = 0","'use strict';\n\nvar origSymbol = typeof Symbol !== 'undefined' && Symbol;\nvar hasSymbolSham = require('./shams');\n\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/has-symbols/index.js\n// module id = 23\n// module chunks = 0","'use strict';\n\n/* eslint complexity: [2, 18], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\tvar descriptor = Object.getOwnPropertyDescriptor(obj, sym);\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/has-symbols/shams.js\n// module id = 24\n// module chunks = 0","'use strict';\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike;\nvar isCallableMarker;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n\ttry {\n\t\tbadArrayLike = Object.defineProperty({}, 'length', {\n\t\t\tget: function () {\n\t\t\t\tthrow isCallableMarker;\n\t\t\t}\n\t\t});\n\t\tisCallableMarker = {};\n\t\t// eslint-disable-next-line no-throw-literal\n\t\treflectApply(function () { throw 42; }, null, badArrayLike);\n\t} catch (_) {\n\t\tif (_ !== isCallableMarker) {\n\t\t\treflectApply = null;\n\t\t}\n\t}\n} else {\n\treflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value) {\n\ttry {\n\t\tvar fnStr = fnToStr.call(value);\n\t\treturn constructorRegex.test(fnStr);\n\t} catch (e) {\n\t\treturn false; // not a function\n\t}\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value) {\n\ttry {\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tfnToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n/* globals document: false */\nvar documentDotAll = typeof document === 'object' && typeof document.all === 'undefined' && document.all !== undefined ? document.all : {};\n\nmodule.exports = reflectApply\n\t? function isCallable(value) {\n\t\tif (value === documentDotAll) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (typeof value === 'function' && !value.prototype) { return true; }\n\t\ttry {\n\t\t\treflectApply(value, null, badArrayLike);\n\t\t} catch (e) {\n\t\t\tif (e !== isCallableMarker) { return false; }\n\t\t}\n\t\treturn !isES6ClassFn(value);\n\t}\n\t: function isCallable(value) {\n\t\tif (value === documentDotAll) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (typeof value === 'function' && !value.prototype) { return true; }\n\t\tif (hasToStringTag) { return tryFunctionObject(value); }\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tvar strClass = toStr.call(value);\n\t\treturn strClass === fnClass || strClass === genClass;\n\t};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-callable/index.js\n// module id = 25\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// ./~/lodash/isObject.js\n// module id = 26\n// module chunks = 0","var debounce = require('./debounce'),\n    isObject = require('./isObject');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\nmodule.exports = throttle;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/throttle.js\n// module id = 27\n// module chunks = 0","(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n  (factory((global.nrkSerumImagecropUtils = {})));\n}(this, (function (exports) { 'use strict';\n\n  var isPolopolyIdRegex = /^[1-9]{1,2}\\.\\d+$/;\n\n  function isPolopolyId(id) {\n    if (!id) {\n      return false;\n    }\n    return isPolopolyIdRegex.test(id);\n  }\n\n  // prettier-ignore\n  var widths = [100, 120, 150, 174, 200, 206, 225, 244, 250, 252, 300, 320, 350, 400, 450, 452, 460, 462, 500, 600, 650, 665, 682, 700, 734, 768, 900, 974, 1200, 1280, 1360, 1450, 1550, 1600, 1700, 1800, 1920, 2000, 2100, 2200, 2300, 2400];\n\n  // prettier-ignore\n  var ratios = ['1:1', '11', '16:9', '169', '16:3', '163', '3:4', '34'];\n\n  // prettier-ignore\n  var qualities = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0];\n\n  var _baseUrl = 'https://nrk.no/serum/api/imagecrop/';\n\n  function createUrl(_ref) {\n    var id = _ref.id,\n        ratio = _ref.ratio,\n        width = _ref.width,\n        quality = _ref.quality;\n\n    var url = '' + _baseUrl + id;\n    var queryString = createQueryString({ ratio: ratio, width: width, quality: quality });\n    if (queryString) {\n      url += '?' + queryString;\n    }\n    return url;\n  }\n\n  function createQueryString(_ref2) {\n    var ratio = _ref2.ratio,\n        width = _ref2.width,\n        quality = _ref2.quality;\n\n    if (!ratio && !width) {\n      return quality ? 'quality=' + quality : '';\n    }\n    var ratioPart = ratio ? 'f' + ratio.replace(':', '') : '';\n    var widthPart = width ? 'w' + width : '';\n    var qualityPart = quality ? '&quality=' + quality : '';\n    return 'cropid=' + ratioPart + widthPart + qualityPart;\n  }\n\n  function getClosestNumber(goal, targets) {\n    if (!isValidGoal(goal)) {\n      throw new Error('\\n      getClosestNumber(goal, targets): passing a goal of ' + goal + '\\n      is not supported. Pass a number');\n    }\n    if (!isValidTargets(targets)) {\n      throw new Error('\\n      getClosestNumber(goal, targets): targets ' + targets.toString() + ' is invald.\\n      Pass an array of numbers');\n    }\n    if (!targets.length) {\n      // eslint-disable-next-line no-undefined\n      return undefined;\n    }\n    return targets.reduce(function (prev, curr) {\n      return Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev;\n    });\n  }\n\n  function isValidGoal(goal) {\n    return typeof goal === 'number';\n  }\n\n  function isValidTargets(targets) {\n    if (!targets) {\n      return false;\n    }\n    var isValid = true;\n    for (var i = 0; i < targets.length; i++) {\n      if (typeof targets[i] !== 'number') {\n        isValid = false;\n        break;\n      }\n    }\n    // return targets.some((target) => {\n    //   return (typeof target !== 'number')\n    // })\n    return isValid;\n  }\n\n  function isValidRatio(ratio, supportedRatios) {\n    if (!Array.isArray(supportedRatios)) {\n      // eslint-disable-next-line no-useless-escape\n      throw new Error(\"isValidRatio(ratio, supportedRatios): supportedRatios '\" + supportedRatios + \"' is not supported. Pass an array of supported ratios\");\n    }\n    if (!ratio) {\n      return false;\n    }\n    return supportedRatios.includes(ratio);\n  }\n\n  function isValidQuality(quality, supportedQualities) {\n    if (!Array.isArray(supportedQualities)) {\n      // eslint-disable-next-line no-useless-escape\n      throw new Error(\"isValidQuality(quality, supportedQualities): supportedQualities '\" + supportedQualities + \"' is not supported. Pass an array of supported qualities\");\n    }\n    if (!quality) {\n      return false;\n    }\n    return supportedQualities.includes(quality);\n  }\n\n  function createImageUrl(options) {\n    var polopolyId = options.id,\n        width = options.width,\n        ratio = options.ratio,\n        quality = options.quality;\n\n\n    if (!isPolopolyId(polopolyId)) {\n      throw new Error('createSerumImageUrl(): invalid polopolyId. Got ' + polopolyId);\n    }\n\n    var args = {\n      id: polopolyId,\n      ratio: null,\n      quality: 0.8,\n      width: 0\n\n      // If a ratio is provided, ensure that it is valid\n    };if (hasOption(ratio)) {\n      if (!isValidRatio(ratio, ratios)) {\n        throw new Error('\\n      createSerumImageUrl(): ratio ' + ratio + ' is not supported.\\n      Supported ratios are ' + ratios.toString());\n      }\n      args.ratio = ratio;\n    }\n\n    // If a quality is provided, ensure that it is valid\n    if (hasOption(quality)) {\n      if (!isValidQuality(quality, qualities)) {\n        throw new Error('\\n      createSerumImageUrl(): quality ' + quality + ' is not supported.\\n      Supported qualities are ' + qualities.toString());\n      }\n      args.quality = quality;\n    }\n\n    // If a width is provided, ensure that is is a positive integer\n    if (hasOption(width)) {\n      if (!isNumber(width) || width <= 0) {\n        var errorMessage = 'createSerumImageUrl(): width must be a positive integer, got ' + width;\n        throw new Error(errorMessage);\n      }\n      var isSupportedWidth = widths.includes(width);\n      var closestWidth = getClosestNumber(width, widths);\n      if (typeof closestWidth !== 'undefined' && closestWidth) {\n        args.width = isSupportedWidth ? width : closestWidth;\n      }\n    }\n\n    return createUrl(args);\n  }\n\n  function hasOption(option) {\n    return typeof option !== 'undefined' && option;\n  }\n\n  function isNumber(number) {\n    return Number.isInteger(number);\n  }\n\n  exports.createImageUrl = createImageUrl;\n  exports.ratios = ratios;\n  exports.widths = widths;\n  exports.qualities = qualities;\n  exports.isPolopolyId = isPolopolyId;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@nrk/serum-imagecrop-utils/lib/index.js\n// module id = 28\n// module chunks = 0","'use strict';\n\nvar ToIntegerOrInfinity = require('es-abstract/2021/ToIntegerOrInfinity');\nvar ToLength = require('es-abstract/2021/ToLength');\nvar ToObject = require('es-abstract/2021/ToObject');\nvar SameValueZero = require('es-abstract/2021/SameValueZero');\nvar $isNaN = require('es-abstract/helpers/isNaN');\nvar $isFinite = require('es-abstract/helpers/isFinite');\nvar GetIntrinsic = require('get-intrinsic');\nvar callBound = require('call-bind/callBound');\nvar isString = require('is-string');\n\nvar $charAt = callBound('String.prototype.charAt');\nvar $indexOf = GetIntrinsic('%Array.prototype.indexOf%'); // TODO: use callBind.apply without breaking IE 8\nvar $max = GetIntrinsic('%Math.max%');\n\nmodule.exports = function includes(searchElement) {\n\tvar fromIndex = arguments.length > 1 ? ToIntegerOrInfinity(arguments[1]) : 0;\n\tif ($indexOf && !$isNaN(searchElement) && $isFinite(fromIndex) && typeof searchElement !== 'undefined') {\n\t\treturn $indexOf.apply(this, arguments) > -1;\n\t}\n\n\tvar O = ToObject(this);\n\tvar length = ToLength(O.length);\n\tif (length === 0) {\n\t\treturn false;\n\t}\n\tvar k = fromIndex >= 0 ? fromIndex : $max(0, length + fromIndex);\n\twhile (k < length) {\n\t\tif (SameValueZero(searchElement, isString(O) ? $charAt(O, k) : O[k])) {\n\t\t\treturn true;\n\t\t}\n\t\tk += 1;\n\t}\n\treturn false;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array-includes/implementation.js\n// module id = 29\n// module chunks = 0","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = function getPolyfill() {\n\treturn Array.prototype.includes || implementation;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array-includes/polyfill.js\n// module id = 30\n// module chunks = 0","'use strict';\n\nvar Call = require('es-abstract/2021/Call');\nvar CreateDataPropertyOrThrow = require('es-abstract/2021/CreateDataPropertyOrThrow');\nvar Get = require('es-abstract/2021/Get');\nvar IsCallable = require('es-abstract/2021/IsCallable');\nvar IsConstructor = require('es-abstract/2021/IsConstructor');\nvar ToObject = require('es-abstract/2021/ToObject');\nvar ToLength = require('es-abstract/2021/ToLength');\nvar ToString = require('es-abstract/2021/ToString');\n\nvar iterate = require('iterate-value');\n\nmodule.exports = function from(items) {\n\tvar C = this;\n\tif (items === null || typeof items === 'undefined') {\n\t\tthrow new TypeError('`Array.from` requires an array-like object, not `null` or `undefined`');\n\t}\n\tvar mapFn, T;\n\tif (typeof arguments[1] !== 'undefined') {\n\t\tmapFn = arguments[1];\n\t\tif (!IsCallable(mapFn)) {\n\t\t\tthrow new TypeError('When provided, the second argument to `Array.from` must be a function');\n\t\t}\n\t\tif (arguments.length > 2) {\n\t\t\tT = arguments[2];\n\t\t}\n\t}\n\n\tvar values;\n\ttry {\n\t\tvalues = iterate(items);\n\t} catch (e) {\n\t\tvalues = items;\n\t}\n\n\tvar arrayLike = ToObject(values);\n\tvar len = ToLength(arrayLike.length);\n\tvar A = IsConstructor(C) ? ToObject(new C(len)) : new Array(len);\n\tvar k = 0;\n\tvar kValue, mappedValue;\n\n\twhile (k < len) {\n\t\tvar Pk = ToString(k);\n\t\tkValue = Get(arrayLike, Pk);\n\t\tif (mapFn) {\n\t\t\tmappedValue = typeof T === 'undefined' ? mapFn(kValue, k) : Call(mapFn, T, [kValue, k]);\n\t\t} else {\n\t\t\tmappedValue = kValue;\n\t\t}\n\t\tCreateDataPropertyOrThrow(A, Pk, mappedValue);\n\t\tk += 1;\n\t}\n\tA.length = len;\n\treturn A;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array.from/implementation.js\n// module id = 31\n// module chunks = 0","'use strict';\n\nvar Call = require('es-abstract/2021/Call');\nvar IsArray = require('es-abstract/2021/IsArray');\nvar IsCallable = require('es-abstract/2021/IsCallable');\n\nvar implementation = require('./implementation');\n\nvar tryCall = function (fn) {\n\ttry {\n\t\treturn fn();\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nmodule.exports = function getPolyfill() {\n\tif (IsCallable(Array.from)) {\n\t\tvar handlesUndefMapper = tryCall(function () {\n\t\t\t// Microsoft Edge v0.11 throws if the mapFn argument is *provided* but undefined,\n\t\t\t// but the spec doesn't care if it's provided or not - undefined doesn't throw.\n\t\t\treturn Array.from([0], undefined);\n\t\t});\n\t\tif (!handlesUndefMapper) {\n\t\t\tvar origArrayFrom = Array.from;\n\t\t\treturn function from(items) {\n\t\t\t\t/* eslint no-invalid-this: 0 */\n\t\t\t\tif (arguments.length > 1 && typeof arguments[1] !== 'undefined') {\n\t\t\t\t\treturn Call(origArrayFrom, this, arguments);\n\t\t\t\t}\n\t\t\t\treturn Call(origArrayFrom, this, [items]);\n\n\t\t\t};\n\t\t}\n\t\tvar implemented = tryCall(function () {\n\t\t\t// Detects a Firefox bug in v32\n\t\t\t// https://bugzilla.mozilla.org/show_bug.cgi?id=1063993\n\t\t\treturn Array.from({ 'length': -1 }) === 0;\n\t\t}) && tryCall(function () {\n\t\t\t// Detects a bug in Webkit nightly r181886\n\t\t\tvar arr = Array.from([0].entries());\n\t\t\treturn arr.length === 1 && IsArray(arr[0]) && arr[0][0] === 0 && arr[0][1] === 0;\n\t\t}) && tryCall(function () {\n\t\t\treturn Array.from({ 'length': -Infinity });\n\t\t});\n\t\tif (implemented) {\n\t\t\treturn Array.from;\n\t\t}\n\t}\n\n\treturn implementation;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array.from/polyfill.js\n// module id = 32\n// module chunks = 0","'use strict';\n\nvar ToObject = require('es-abstract/2021/ToObject');\nvar ToLength = require('es-abstract/2021/ToLength');\nvar IsCallable = require('es-abstract/2021/IsCallable');\n\nmodule.exports = function find(predicate) {\n\tvar list = ToObject(this);\n\tvar length = ToLength(list.length);\n\tif (!IsCallable(predicate)) {\n\t\tthrow new TypeError('Array#find: predicate must be a function');\n\t}\n\tif (length === 0) {\n\t\treturn void 0;\n\t}\n\tvar thisArg;\n\tif (arguments.length > 0) {\n\t\tthisArg = arguments[1];\n\t}\n\n\tfor (var i = 0, value; i < length; i++) {\n\t\tvalue = list[i];\n\t\t// inlined for performance: if (Call(predicate, thisArg, [value, i, list])) {\n\t\tif (predicate.apply(thisArg, [value, i, list])) {\n\t\t\treturn value;\n\t\t}\n\t}\n\treturn void 0;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array.prototype.find/implementation.js\n// module id = 33\n// module chunks = 0","'use strict';\n\nmodule.exports = function getPolyfill() {\n\t// Detect if an implementation exists\n\t// Detect early implementations which skipped holes in sparse arrays\n\t// eslint-disable-next-line no-sparse-arrays\n\tvar implemented = Array.prototype.find && [, 1].find(function () {\n\t\treturn true;\n\t}) !== 1;\n\n\t// eslint-disable-next-line global-require\n\treturn implemented ? Array.prototype.find : require('./implementation');\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array.prototype.find/polyfill.js\n// module id = 34\n// module chunks = 0","import { imageComponent } from './image'\nimport { colorComponent } from './color'\nimport { videoComponent } from './video'\nimport { bylineComponent } from './byline'\nimport { animationComponent } from './animation'\n// import { polopolyComponent } from './polopoly'\n// import { uncroppedComponent } from './uncropped'\nimport { panoramaComponent } from './panorama'\nimport { flipScrollComponent } from './flipScroll'\nimport { triggerOnScrollComponent } from './triggerOnScroll'\nimport { animateVideoComponent } from './animateVideo'\nimport { setActiveElementClass } from './renderless/activeClass'\n\nexport const components = [\n  setActiveElementClass,\n  imageComponent,\n  colorComponent,\n  bylineComponent,\n  videoComponent,\n  animationComponent,\n  // polopolyComponent,\n  // uncroppedComponent,\n  panoramaComponent,\n  triggerOnScrollComponent,\n  flipScrollComponent,\n  animateVideoComponent\n]\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/index.js","export function constrain(value, min, max) {\n  return Math.min(Math.max(value, min), max)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/utils/general.js","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\nvar callBound = require('call-bind/callBound');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar IsArray = require('./IsArray');\n\nvar $apply = GetIntrinsic('%Reflect.apply%', true) || callBound('%Function.prototype.apply%');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-call\n\nmodule.exports = function Call(F, V) {\n\tvar argumentsList = arguments.length > 2 ? arguments[2] : [];\n\tif (!IsArray(argumentsList)) {\n\t\tthrow new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List');\n\t}\n\treturn $apply(F, V, argumentsList);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/Call.js\n// module id = 37\n// module chunks = 0","'use strict';\n\nvar assertRecord = require('../helpers/assertRecord');\n\nvar Type = require('./Type');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor\n\nmodule.exports = function FromPropertyDescriptor(Desc) {\n\tif (typeof Desc === 'undefined') {\n\t\treturn Desc;\n\t}\n\n\tassertRecord(Type, 'Property Descriptor', 'Desc', Desc);\n\n\tvar obj = {};\n\tif ('[[Value]]' in Desc) {\n\t\tobj.value = Desc['[[Value]]'];\n\t}\n\tif ('[[Writable]]' in Desc) {\n\t\tobj.writable = Desc['[[Writable]]'];\n\t}\n\tif ('[[Get]]' in Desc) {\n\t\tobj.get = Desc['[[Get]]'];\n\t}\n\tif ('[[Set]]' in Desc) {\n\t\tobj.set = Desc['[[Set]]'];\n\t}\n\tif ('[[Enumerable]]' in Desc) {\n\t\tobj.enumerable = Desc['[[Enumerable]]'];\n\t}\n\tif ('[[Configurable]]' in Desc) {\n\t\tobj.configurable = Desc['[[Configurable]]'];\n\t}\n\treturn obj;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/FromPropertyDescriptor.js\n// module id = 38\n// module chunks = 0","'use strict';\n\nvar has = require('has');\n\nvar assertRecord = require('../helpers/assertRecord');\n\nvar Type = require('./Type');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isdatadescriptor\n\nmodule.exports = function IsDataDescriptor(Desc) {\n\tif (typeof Desc === 'undefined') {\n\t\treturn false;\n\t}\n\n\tassertRecord(Type, 'Property Descriptor', 'Desc', Desc);\n\n\tif (!has(Desc, '[[Value]]') && !has(Desc, '[[Writable]]')) {\n\t\treturn false;\n\t}\n\n\treturn true;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/IsDataDescriptor.js\n// module id = 39\n// module chunks = 0","'use strict';\n\nvar $isNaN = require('../helpers/isNaN');\n\n// http://262.ecma-international.org/5.1/#sec-9.12\n\nmodule.exports = function SameValue(x, y) {\n\tif (x === y) { // 0 === -0, but they are not identical.\n\t\tif (x === 0) { return 1 / x === 1 / y; }\n\t\treturn true;\n\t}\n\treturn $isNaN(x) && $isNaN(y);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/SameValue.js\n// module id = 40\n// module chunks = 0","'use strict';\n\n// http://262.ecma-international.org/5.1/#sec-9.2\n\nmodule.exports = function ToBoolean(value) { return !!value; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/ToBoolean.js\n// module id = 41\n// module chunks = 0","'use strict';\n\nvar ES5ToInteger = require('../5/ToInteger');\n\nvar ToNumber = require('./ToNumber');\n\n// https://www.ecma-international.org/ecma-262/11.0/#sec-tointeger\n\nmodule.exports = function ToInteger(value) {\n\tvar number = ToNumber(value);\n\tif (number !== 0) {\n\t\tnumber = ES5ToInteger(number);\n\t}\n\treturn number === 0 ? 0 : number;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/ToIntegerOrInfinity.js\n// module id = 42\n// module chunks = 0","'use strict';\n\nvar has = require('has');\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar Type = require('./Type');\nvar ToBoolean = require('./ToBoolean');\nvar IsCallable = require('./IsCallable');\n\n// https://262.ecma-international.org/5.1/#sec-8.10.5\n\nmodule.exports = function ToPropertyDescriptor(Obj) {\n\tif (Type(Obj) !== 'Object') {\n\t\tthrow new $TypeError('ToPropertyDescriptor requires an object');\n\t}\n\n\tvar desc = {};\n\tif (has(Obj, 'enumerable')) {\n\t\tdesc['[[Enumerable]]'] = ToBoolean(Obj.enumerable);\n\t}\n\tif (has(Obj, 'configurable')) {\n\t\tdesc['[[Configurable]]'] = ToBoolean(Obj.configurable);\n\t}\n\tif (has(Obj, 'value')) {\n\t\tdesc['[[Value]]'] = Obj.value;\n\t}\n\tif (has(Obj, 'writable')) {\n\t\tdesc['[[Writable]]'] = ToBoolean(Obj.writable);\n\t}\n\tif (has(Obj, 'get')) {\n\t\tvar getter = Obj.get;\n\t\tif (typeof getter !== 'undefined' && !IsCallable(getter)) {\n\t\t\tthrow new $TypeError('getter must be a function');\n\t\t}\n\t\tdesc['[[Get]]'] = getter;\n\t}\n\tif (has(Obj, 'set')) {\n\t\tvar setter = Obj.set;\n\t\tif (typeof setter !== 'undefined' && !IsCallable(setter)) {\n\t\t\tthrow new $TypeError('setter must be a function');\n\t\t}\n\t\tdesc['[[Set]]'] = setter;\n\t}\n\n\tif ((has(desc, '[[Get]]') || has(desc, '[[Set]]')) && (has(desc, '[[Value]]') || has(desc, '[[Writable]]'))) {\n\t\tthrow new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');\n\t}\n\treturn desc;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/ToPropertyDescriptor.js\n// module id = 43\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true);\n\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = null;\n\t}\n}\n\n// node v0.6 has a bug where array lengths can be Set but not Defined\nvar hasArrayLengthDefineBug = Object.defineProperty && Object.defineProperty([], 'length', { value: 1 }).length === 0;\n\n// eslint-disable-next-line global-require\nvar isArray = hasArrayLengthDefineBug && require('../2020/IsArray'); // this does not depend on any other AOs.\n\nvar callBound = require('call-bind/callBound');\n\nvar $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');\n\n// eslint-disable-next-line max-params\nmodule.exports = function DefineOwnProperty(IsDataDescriptor, SameValue, FromPropertyDescriptor, O, P, desc) {\n\tif (!$defineProperty) {\n\t\tif (!IsDataDescriptor(desc)) {\n\t\t\t// ES3 does not support getters/setters\n\t\t\treturn false;\n\t\t}\n\t\tif (!desc['[[Configurable]]'] || !desc['[[Writable]]']) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// fallback for ES3\n\t\tif (P in O && $isEnumerable(O, P) !== !!desc['[[Enumerable]]']) {\n\t\t\t// a non-enumerable existing property\n\t\t\treturn false;\n\t\t}\n\n\t\t// property does not exist at all, or exists but is enumerable\n\t\tvar V = desc['[[Value]]'];\n\t\t// eslint-disable-next-line no-param-reassign\n\t\tO[P] = V; // will use [[Define]]\n\t\treturn SameValue(O[P], V);\n\t}\n\tif (\n\t\thasArrayLengthDefineBug\n\t\t&& P === 'length'\n\t\t&& '[[Value]]' in desc\n\t\t&& isArray(O)\n\t\t&& O.length !== desc['[[Value]]']\n\t) {\n\t\t// eslint-disable-next-line no-param-reassign\n\t\tO.length = desc['[[Value]]'];\n\t\treturn O.length === desc['[[Value]]'];\n\t}\n\n\t$defineProperty(O, P, FromPropertyDescriptor(desc));\n\treturn true;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/helpers/DefineOwnProperty.js\n// module id = 44\n// module chunks = 0","'use strict';\n\nvar $isNaN = Number.isNaN || function (a) { return a !== a; };\n\nmodule.exports = Number.isFinite || function (x) { return typeof x === 'number' && !$isNaN(x) && x !== Infinity && x !== -Infinity; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/helpers/isFinite.js\n// module id = 45\n// module chunks = 0","'use strict';\n\nmodule.exports = function isPrimitive(value) {\n\treturn value === null || (typeof value !== 'function' && typeof value !== 'object');\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/helpers/isPrimitive.js\n// module id = 46\n// module chunks = 0","'use strict';\n\nmodule.exports = function isPrimitive(value) {\n\treturn value === null || (typeof value !== 'function' && typeof value !== 'object');\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-to-primitive/helpers/isPrimitive.js\n// module id = 47\n// module chunks = 0","// removed by extract-text-webpack-plugin\nmodule.exports = {\"sections\":\"nrk-filmavis-liersykehus-sections\",\"section\":\"nrk-filmavis-liersykehus-section\",\"section--no-min-height\":\"nrk-filmavis-liersykehus-section--no-min-height\",\"sectionNoMinHeight\":\"nrk-filmavis-liersykehus-section--no-min-height\",\"section--ready\":\"nrk-filmavis-liersykehus-section--ready\",\"sectionReady\":\"nrk-filmavis-liersykehus-section--ready\",\"section--active\":\"nrk-filmavis-liersykehus-section--active\",\"sectionActive\":\"nrk-filmavis-liersykehus-section--active\",\"section-text-shadow\":\"nrk-filmavis-liersykehus-section-text-shadow\",\"sectionTextShadow\":\"nrk-filmavis-liersykehus-section-text-shadow\",\"type--image\":\"nrk-filmavis-liersykehus-type--image\",\"typeImage\":\"nrk-filmavis-liersykehus-type--image\",\"type--video\":\"nrk-filmavis-liersykehus-type--video\",\"typeVideo\":\"nrk-filmavis-liersykehus-type--video\",\"type--color\":\"nrk-filmavis-liersykehus-type--color\",\"typeColor\":\"nrk-filmavis-liersykehus-type--color\",\"type--byline\":\"nrk-filmavis-liersykehus-type--byline\",\"typeByline\":\"nrk-filmavis-liersykehus-type--byline\",\"animation\":\"nrk-filmavis-liersykehus-animation\",\"sectionAfterStandup\":\"nrk-filmavis-liersykehus-sectionAfterStandup\",\"sectionBeforeStandup\":\"nrk-filmavis-liersykehus-sectionBeforeStandup\",\"standup\":\"nrk-filmavis-liersykehus-standup\",\"super\":\"nrk-filmavis-liersykehus-super\",\"super__content\":\"nrk-filmavis-liersykehus-super__content\",\"superContent\":\"nrk-filmavis-liersykehus-super__content\",\"blurred\":\"nrk-filmavis-liersykehus-blurred\",\"overlay\":\"nrk-filmavis-liersykehus-overlay\",\"darkedout\":\"nrk-filmavis-liersykehus-darkedout\",\"NRKlogo\":\"nrk-filmavis-liersykehus-NRKlogo\",\"nrKlogo\":\"nrk-filmavis-liersykehus-NRKlogo\",\"shareButtonGroup\":\"nrk-filmavis-liersykehus-shareButtonGroup\",\"visible\":\"nrk-filmavis-liersykehus-visible\",\"shareButton\":\"nrk-filmavis-liersykehus-shareButton\",\"to-top\":\"nrk-filmavis-liersykehus-to-top\",\"toTop\":\"nrk-filmavis-liersykehus-to-top\",\"intro-block-arrow\":\"nrk-filmavis-liersykehus-intro-block-arrow\",\"introBlockArrow\":\"nrk-filmavis-liersykehus-intro-block-arrow\",\"fadeIn\":\"nrk-filmavis-liersykehus-fadeIn\",\"arrowBlink\":\"nrk-filmavis-liersykehus-arrowBlink\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/shared/index.css\n// module id = 48\n// module chunks = 0","'use strict';\n\nvar strValue = String.prototype.valueOf;\nvar tryStringObject = function tryStringObject(value) {\n\ttry {\n\t\tstrValue.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar strClass = '[object String]';\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nmodule.exports = function isString(value) {\n\tif (typeof value === 'string') {\n\t\treturn true;\n\t}\n\tif (typeof value !== 'object') {\n\t\treturn false;\n\t}\n\treturn hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-string/index.js\n// module id = 49\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// ./~/lodash/_Symbol.js\n// module id = 50\n// module chunks = 0","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// ./~/lodash/_root.js\n// module id = 51\n// module chunks = 0","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/debounce.js\n// module id = 52\n// module chunks = 0","'use strict';\n\nvar toStr = Object.prototype.toString;\n\nmodule.exports = function isArguments(value) {\n\tvar str = toStr.call(value);\n\tvar isArgs = str === '[object Arguments]';\n\tif (!isArgs) {\n\t\tisArgs = str !== '[object Array]' &&\n\t\t\tvalue !== null &&\n\t\t\ttypeof value === 'object' &&\n\t\t\ttypeof value.length === 'number' &&\n\t\t\tvalue.length >= 0 &&\n\t\t\ttoStr.call(value.callee) === '[object Function]';\n\t}\n\treturn isArgs;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/object-keys/isArguments.js\n// module id = 53\n// module chunks = 0","// 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// ./~/process/browser.js\n// module id = 54\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 = 55\n// module chunks = 0","/* eslint-disable global-require */\n\nrequire('array.prototype.find').shim()\nrequire('array.from').shim()\nrequire('array-includes').shim()\n\nrequire('intersection-observer')\n\n// Object.assign() is commonly used.\n// This polyfill use the native implementation if it's present and isn't buggy.\n// Object.assign = require('object-assign')\n\nif (typeof Promise === 'undefined') {\n  require('es6-promise').polyfill()\n}\n\nNumber.isInteger = Number.isInteger || function(value) {\n  return typeof value === 'number' &&\n    isFinite(value) &&\n    Math.floor(value) === value\n}\n\n\n\n// WEBPACK FOOTER //\n// ./config/polyfills.js","/* global __NAMESPACE__, ROOT_MOUNT_ID */\n/* eslint-disable max-params */\n\nimport styles from '../shared/index.css'\nimport '../shared/stylesheets/byline.css'\nimport '../shared/stylesheets/mood.css'\nimport { visible } from '../shared/stylesheets/background.css'\nimport '../shared/stylesheets/alignment/index.css'\nimport videoStyles from '../shared/stylesheets/video.css'\nimport '../shared/stylesheets/animations.css'\nimport '../shared/stylesheets/block.css'\nimport { getMutedButton, getUnmutedButton } from '../shared/utils/muteButtons'\nimport { initialize as gaInitialize, trackAction } from '../shared/utils/googleAnalytics'\nimport { canAutoplay } from './utils/featuretests'\nimport { intersectionObserverCallback } from './intersection'\nimport { reduce } from './reducer'\nimport { components } from '../shared/components'\n\nexport default class App {\n  constructor(container, initialState) {\n    this.container = container\n    this.error = null\n    this.muted = true\n    this.videoElements = []\n    this.state = initialState\n    // console.log('This.state')\n\n    this.gaInitialized = false\n    this.sectionId = 0\n    window.appParams = this\n  }\n\n  setSectionId = id => {\n    this.sectionId = id\n  }\n\n  mount = () => {\n    try {\n      const sectionElements = [...document.querySelectorAll(`.${styles.section}`)]\n\n      this.state.sections = this.state.sections.map((s, i) => {\n        return {\n          ...s,\n          canAutoplay: this.state.canAutoplay,\n          foregroundElement: sectionElements[i],\n          backgroundElement: document.getElementById(s.id)\n        }\n      })\n\n      this.shareButtons = document.querySelector(`.${styles.shareButtonGroup}`)\n      const muteButton = document.querySelector(`.${videoStyles.videoMuteButton}`)\n      if (muteButton) {\n        this.muteButton = muteButton\n        this.muteButton.addEventListener('click', this.toggleMuteVideo, false)\n      }\n\n      this.initializeGoogleAnalytic()\n      this.mountListeners()\n    } catch (error) {\n      console.error(error)\n      this.renderError()\n    }\n  }\n  initializeGoogleAnalytic = () => {\n    if (!this.gaInitialized) {\n      gaInitialize(this.container.getAttribute('data-tracking'))\n    }\n    this.gaInitialized = true\n  }\n\n  unmount = () => {\n    this.unmountListeners()\n    this.container.innerHTML = ''\n  }\n\n  ioCallback = changes => intersectionObserverCallback(changes, this.state, this.dispatch)\n\n  mountListeners = () => {\n    const options = {\n      threshold: [0]\n    }\n\n    this.observer = new IntersectionObserver(this.ioCallback, options)\n    this.observer.POLL_INTERVAL = 500\n    this.state.sections.forEach(({ foregroundElement }) =>\n      this.observer.observe(foregroundElement)\n    )\n\n    const muteButton = document.querySelector(`.${videoStyles.videoMuteButton}`)\n    if (muteButton) {\n      this.muteButton = muteButton\n      this.muteButton.addEventListener('click', this.toggleMuteVideo, false)\n    }\n  }\n\n  render = () => {\n    if (this.error) {\n      this.renderError()\n    }\n  }\n\n  renderError = () => {\n    this.container.innerHTML = `<pre class=\"App--error\">${this.error}</pre>`\n  }\n  toggleMuteVideo = e => {\n    e.stopPropagation()\n\n    this.dispatch({ type: 'toggleMute' })\n    if (this.state.muted) {\n      trackAction(`MUTE/${this.sectionId}`)\n    } else {\n      trackAction(`UNMUTE/${this.sectionId}`)\n    }\n  }\n  dispatch = action => {\n    this.state = reduce(this.state, action)\n    this.onStateChanged(this.state)\n  }\n\n  onStateChanged = state => {\n    if (state.showMuteButton) {\n      this.muteButton.classList.add(visible)\n    } else {\n      this.muteButton.classList.remove(visible)\n    }\n\n    if (this.shareButtons && state.showShareButtons) {\n      this.shareButtons.classList.add(visible)\n    } else {\n      this.shareButtons.classList.remove(visible)\n    }\n\n    if (state.muted) {\n      this.muteButton.innerHTML = getMutedButton()\n    } else {\n      this.muteButton.innerHTML = getUnmutedButton()\n    }\n\n    components\n      .filter(component => component.onStateChanged)\n      .forEach(component => component.onStateChanged(state))\n  }\n}\n\nwindow.App = App\n\nif (module.hot) module.hot.accept()\n\nconst mountingNode = document.getElementById(ROOT_MOUNT_ID)\nconst initialState = JSON.parse(mountingNode.getAttribute('data-initial-state'))\n\nconst app = new App(mountingNode, initialState)\napp.mount()\n\nmountingNode.style.transition = '.5s .5s opacity ease-in'\nmountingNode.style.opacity = 1\n\n\n\n// WEBPACK FOOTER //\n// ./src/client/index.js","'use strict';\n\nvar define = require('define-properties');\nvar RequireObjectCoercible = require('es-abstract/2021/RequireObjectCoercible');\nvar callBind = require('call-bind');\nvar callBound = require('call-bind/callBound');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar polyfill = callBind.apply(getPolyfill());\nvar shim = require('./shim');\n\nvar $slice = callBound('Array.prototype.slice');\n\n/* eslint-disable no-unused-vars */\nvar boundShim = function includes(array, searchElement) {\n/* eslint-enable no-unused-vars */\n\tRequireObjectCoercible(array);\n\treturn polyfill(array, $slice(arguments, 1));\n};\ndefine(boundShim, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = boundShim;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array-includes/index.js\n// module id = 58\n// module chunks = 0","'use strict';\n\nvar define = require('define-properties');\nvar getPolyfill = require('./polyfill');\n\nmodule.exports = function shimArrayPrototypeIncludes() {\n\tvar polyfill = getPolyfill();\n\tdefine(\n\t\tArray.prototype,\n\t\t{ includes: polyfill },\n\t\t{ includes: function () { return Array.prototype.includes !== polyfill; } }\n\t);\n\treturn polyfill;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array-includes/shim.js\n// module id = 59\n// module chunks = 0","'use strict';\n\nvar define = require('define-properties');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar polyfill = getPolyfill();\n\n// eslint-disable-next-line no-unused-vars\nvar boundFromShim = function from(items) {\n\t// eslint-disable-next-line no-invalid-this\n\treturn polyfill.apply(this || Array, arguments);\n};\n\ndefine(boundFromShim, {\n\t'getPolyfill': getPolyfill,\n\t'implementation': implementation,\n\t'shim': shim\n});\n\nmodule.exports = boundFromShim;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array.from/index.js\n// module id = 60\n// module chunks = 0","'use strict';\n\nvar define = require('define-properties');\nvar getPolyfill = require('./polyfill');\n\nmodule.exports = function shimArrayFrom() {\n\tvar polyfill = getPolyfill();\n\n\tdefine(\n\t\tArray,\n\t\t{ 'from': polyfill },\n\t\t{\n\t\t\t'from': function () {\n\t\t\t\treturn Array.from !== polyfill;\n\t\t\t}\n\t\t}\n\t);\n\n\treturn polyfill;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array.from/shim.js\n// module id = 61\n// module chunks = 0","'use strict';\n\nvar define = require('define-properties');\nvar callBound = require('call-bind/callBound');\nvar RequireObjectCoercible = require('es-abstract/2021/RequireObjectCoercible');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar $slice = callBound('Array.prototype.slice');\n\nvar polyfill = getPolyfill();\n\nvar boundFindShim = function find(array, predicate) { // eslint-disable-line no-unused-vars\n\tRequireObjectCoercible(array);\n\tvar args = $slice(arguments, 1);\n\treturn polyfill.apply(array, args);\n};\n\ndefine(boundFindShim, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = boundFindShim;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array.prototype.find/index.js\n// module id = 62\n// module chunks = 0","'use strict';\n\nvar define = require('define-properties');\nvar getPolyfill = require('./polyfill');\n\nmodule.exports = function shimArrayPrototypeFind() {\n\tvar polyfill = getPolyfill();\n\n\tdefine(Array.prototype, { find: polyfill }, {\n\t\tfind: function () {\n\t\t\treturn Array.prototype.find !== polyfill;\n\t\t}\n\t});\n\n\treturn polyfill;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/array.prototype.find/shim.js\n// module id = 63\n// module chunks = 0","import { transitionManager } from './transitionManager'\nimport { components } from '../shared/components'\nimport { trackAction } from '../shared/utils/googleAnalytics'\n\nlet currentSection = null\n\nexport const intersectionObserverCallback = (changes, state, dispatch) => {\n  if (!changes) return\n\n  const sections = state.sections\n\n  // Update state\n  changes.forEach(change => {\n    const changedElement = sections.find(\n      ({ foregroundElement }) => change.target === foregroundElement\n    )\n    changedElement.isIntersecting = change.isIntersecting\n  })\n\n  const nextSection = sections.filter(e => e.isIntersecting).pop()\n\n  if (\n    !currentSection ||\n    currentSection.foregroundElement !== nextSection.foregroundElement\n  ) {\n    trackAction(\n      `LOAD_SUCCESS/${nextSection.foregroundElement.getAttribute('data-background-id')}`\n    )\n\n    const currentIndex = sections.indexOf(nextSection)\n    const previousIndex = currentSection ? sections.indexOf(currentSection) : null\n\n    const direction = currentIndex > previousIndex ? 'forwards' : 'backwards'\n\n    const previousSection = sections[previousIndex]\n\n    currentSection = nextSection\n\n    transitionManager(nextSection, previousSection, direction)\n\n    // dispatch({ type: 'showShareButtons', value: nextSection.shareIcons })\n    dispatch({ type: 'showShareButtons', value: nextSection.props.shareIcons })\n    components.filter(component => component.onCurrentChanged).forEach(component => {\n      component.onCurrentChanged(nextSection, dispatch)\n    })\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/client/intersection.js","export function reduce(state, action) {\n  switch (action.type) {\n    case 'showMuteButton':\n      return {\n        ...state,\n        showMuteButton: action.value\n      }\n\n    case 'showShareButtons':\n      return {\n        ...state,\n        showShareButtons: action.value\n      }\n\n    case 'toggleMute':\n      return {\n        ...state,\n        muted: !state.muted\n      }\n\n    default:\n      return state\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/client/reducer.js","import transitionStyles from '../shared/stylesheets/transitions.css'\n\nexport const transitionManager = (\n  currentElement,\n  previousElement,\n  direction = 'forwards'\n) => {\n  // console.log('currentElement:', currentElement)\n  if (!previousElement || previousElement === currentElement) {\n    // const transitionClass = currentElement.transition\n    const transitionName = currentElement.props.transition\n    const transitionClass = transitionStyles[transitionName]\n    // console.log('transitionClass:', transitionClass)\n\n    currentElement.backgroundElement.classList.add(transitionStyles.animateInto)\n    currentElement.backgroundElement.classList.add(transitionClass)\n    return\n  }\n\n  const allTransitionClasses = Object.keys(transitionStyles).map(\n    key => transitionStyles[key]\n  )\n\n  const transitionName =\n    direction === 'forwards' ?\n      currentElement.props.transition :\n      previousElement.props.transition\n\n  const transitionClass = transitionStyles[transitionName]\n\n  allTransitionClasses.forEach(tClass => {\n    previousElement.backgroundElement.classList.remove(tClass)\n    currentElement.backgroundElement.classList.remove(tClass)\n  })\n\n  previousElement.backgroundElement.classList.add(transitionStyles.animateAway)\n  previousElement.backgroundElement.classList.add(transitionClass)\n\n  currentElement.backgroundElement.classList.add(transitionStyles.animateInto)\n  currentElement.backgroundElement.classList.add(transitionClass)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/client/transitionManager.js","// @flow\n\n/* eslint-disable standard/no-callback-literal */\n\ntype TestCallback = (supported: boolean) => void\n\nlet videoAutoPlayCache = null\nexport function canAutoplay(callback: TestCallback) {\n  try {\n    if (typeof window === 'undefined') {\n      return callback(false)\n    }\n\n    if (typeof videoAutoPlayCache === 'boolean') {\n      return callback(videoAutoPlayCache)\n    }\n\n    const videoElm = document.createElement('video')\n\n    let isPlaying = false\n\n    videoElm.setAttribute('autoplay', '')\n    videoElm.setAttribute('muted', '')\n    videoElm.setAttribute('webkit-playsinline', 'webkit-playsinline')\n    videoElm.setAttribute('playsinline', 'playsinline')\n\n    try {\n      if (videoElm.canPlayType('video/ogg')) {\n        videoElm.src =\n          'data:video/ogg;base64,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'\n      } else if (videoElm.canPlayType('video/mp4')) {\n        videoElm.src =\n          'data:video/mp4;base64,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'\n      } else {\n        return callback(false)\n      }\n    } catch (_) {\n      return callback(false)\n    }\n\n    videoElm.load()\n    videoElm.play()\n\n    videoElm.oncanplay = () => {\n      videoAutoPlayCache = isPlaying\n      callback(videoAutoPlayCache)\n    }\n\n    videoElm.onplay = () => {\n      isPlaying = true\n    }\n  } catch (error) {\n    return callback(false)\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/client/utils/featuretests.js","// @flow\n\nimport debounce from 'lodash/debounce'\nimport { getPolopolyImageElement, getImageElement } from '../utils/imageUtils'\nimport { constrain } from '../utils/general'\n\nimport videoStyles from '../stylesheets/video.css'\nimport { background, uncroppedImageContainer } from '../stylesheets/background.css'\nimport { alignCenter, alignMiddle } from '../stylesheets/alignment/index.css'\n\nlet eventListener = null\n\ntype videoType = {\n  mp4: string,\n  webm: string,\n  poster: string,\n  subtitles: ?Object\n}\n\ntype videoHandlerTypeProps = {\n  video: videoType,\n  alignment: ?Array<string>\n}\n\nexport const animateVideoComponent = {\n  type: 'animate-video',\n\n  render(id: string, props: videoHandlerTypeProps, bgInnerHTML: ?string = '') {\n    const { video, alignment } = props\n    const { mp4, webm, poster, subtitles, hasSound } = video\n\n    const trackElement = subtitles ?\n      `<track src=\"${\n          subtitles\n        }\" kind=\"caption\" srclang=\"no\" label=\"Norwegian\" default=\"\" />` :\n      ''\n\n    const alignmentClasses = alignment.join(' ')\n\n    return `\n      <div id=\"${id}\" class=\"${background} ${videoStyles.hidePlay}\" >\n        <video\n          loop\n          muted\n          preload=\"auto\"\n          poster=\"${poster}\"\n          playsinline\n          webkit-playsinline\n          class=\"${videoStyles.video} ${alignmentClasses}\">\n          <source type=\"video/mp4\" src=\"${mp4}\">\n          ${trackElement}\n          Your browser does not support the video tag. We suggest you upgrade your browser.\n        </video>\n        <div class=\"${videoStyles['subtitlescontainer']}\"></div>\n        ${bgInnerHTML}\n      </div>\n    `\n  },\n  onCurrentChanged(currentSection) {\n    if (eventListener) {\n      document.removeEventListener('scroll', eventListener)\n      eventListener = null\n    }\n\n    const { type } = currentSection\n    if (type === 'animate-video') {\n      eventListener = () =>\n        window.requestAnimationFrame(() => handleAnimateVideo(currentSection))\n      document.addEventListener('scroll', eventListener)\n    }\n  }\n}\nlet i = 0\nconst handleAnimateVideo = (section, e) => {\n  const { y, top, height } = section.foregroundElement.getBoundingClientRect()\n  const { innerHeight, innerWidth } = window\n\n  const videoElement = document.querySelector('video')\n\n  let pxInViewFromStart = height + (top || y) - innerHeight\n  const howMuchBigger = height - innerHeight\n\n  if (pxInViewFromStart >= howMuchBigger - 1) {\n    pxInViewFromStart = howMuchBigger\n  } else if (pxInViewFromStart <= 0) {\n    pxInViewFromStart = 0\n  }\n  const percentInView = 1 - pxInViewFromStart / howMuchBigger\n\n  const newCurrentTime = videoElement.duration * percentInView\n  // videoElement.play()\n  if (!isNaN(newCurrentTime)) {\n    videoElement.currentTime = newCurrentTime\n  }\n  // console.log('asd', newCurrentTime)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/animateVideo.js","// @flow\n\nimport { background } from '../stylesheets/background.css'\n\ntype colorHandlerTypeProps = {\n  backgroundColor: string\n}\n\nexport const animationComponent = {\n  type: 'animation',\n  render(id: string, props: colorHandlerTypeProps, bgInnerHTML: ?string = ''): string {\n    const { backgroundColor } = props\n    const style = `background-color: #c8e4ec;`\n    // const style = `background-color: ${backgroundColor};`\n\n    return `\n      <div id=\"${id}\" class=\"animation ${background}\" style=\"${style}\">\n        ${bgInnerHTML}\n        <svg id=\"silhouette\" data-name=\"silhouette\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"100 0 1300 500\" style=\"position:fixed; top:0; left:0; height:100%; width:100%\">\n          <g>\n            <animateTransform attributeName=\"transform\"\n                                  attributeType=\"XML\"\n                                  type=\"rotate\"\n                                  from=\"0 50 400\"\n                                  to=\"15 20 0\"\n                                  dur=\"15s\"\n                                  repeatCount=\"indefinite\"/>\n            <animateTransform attributeName=\"transform\" type=\"scale\" additive=\"sum\" from=\"1.2 1.2\" to=\"1.4\" begin=\"0s\" dur=\"10s\" repeatCount=\"indefinite\"></animateTransform>\n            <filter id=\"blur\">\n            <feGaussianBlur stdDeviation=\"6\" id=\"blurE\" in=\"SourceGraphic\"  />\n            </filter>\n            <path fill=\"#bedbe2\" filter=\"url(#blur)\" d=\"M671.09,294.62c-2.13-22.25-3.88-50.33-16.43-69.81-4.15-6.44-11.09-10.58-17.81-13.94-13.45-6.72-25.34-10.88-40.43-10.6-8.18.15-14.9-2-22.88-4-7.5-1.86-15.26-2.71-22.91-3.81S541.3,189,536.68,183c-3.76-4.91-11.29-11.61-12.11-18.24-.45-3.65,1.91-5.38,3.13-9,1.06-3.15,1.09-6.91,1.52-10.22,1-7.88,1.64-15.64,2.28-23.55a191.21,191.21,0,0,0,.61-23.13c-.09-2.68,1.05-6.72.5-9.11-.27-1.17-2.64-.28-2.88-1-.46-1.49.74-4.51.88-6,1.29-13.71.11-30.75-5.87-43.45C518.58,26.07,505.54,15.17,494,7A36.66,36.66,0,0,0,456.85,4.3C449.3,8,441.46,11.24,434.43,16c-6,4-10.24,10.34-14.7,16.06-4.22,5.42-9.86,11.46-12.83,17.6-2.81,5.82-1.4,13-1.29,19.64.22,13.39,5,26.32,4.59,39.47-.23,7.59,2.13,14.62,5.38,21.24,1.3,2.65,2.6,5.12,4.12,7.63,2.47,4.09,5.14,6.3,7.91,9.57,4.29,5.05,6.45,14.68,8.83,21,1.85,4.91,3.24,10.68,2.6,16.1s-3.67,11.59-5.55,16.9c-3.25,9.18-4.43,14.12-14.87,16.55-3.53.82-7.07-.42-10.62-.44-1.75,0-2.92-1-4.35-.37s-2.43,3.24-3.87,4.17c-3.31,2.13-8.17,2.35-11.75,4.13A71,71,0,0,0,377.2,232c-9.83,7.51-13.51,29.38-28.65,26.05-7.07-1.55-14.3-8.84-20.75-11.86-5.9-2.76-11.94-1.08-18.56-.53-7.58.63-15.61.56-23.1,1.92-7.74,1.4-15.2,5.49-23,6.43-5.78.69-11.92-2.1-17.63-3.65,5.72-7.44,9.22-16.45,14.15-24.43,4.36-7.06,11.54-13.84,14.58-21.5,1.66-4.18,1.13-9.24,2.84-13.41,1.79-4.37,5.28-9,8-12.9,4.84-7.08,13.08-14.25,13.73-23.42.27-3.79-1.74-8.23-2.06-12.16a35.59,35.59,0,0,1,1.59-14.72c2.56-8.95-.85-20.41-12.48-16.88-9.16,2.78-15.61,10.78-20.23,18.81-2.56,4.45-1.74,7.94-3.32,12.8-1.25,3.88-4.77,6.82-7.23,10.17-5.39,7.34-7.81,15.41-18.3,14.92-11-.51-18.39-9.85-26.16-16.37s-14.75-11.7-20.83-19.87c-5.74-7.72-8.9-15.07-13-23.77-8.35-17.58-18.75-33.59-29.06-50-4.82-7.69-8.44-16.31-13.63-23.73-3.52-5-12.46-16.58-19.74-16.64-5.73,0-11.44,6.06-12.69,11.23-1.33,5.52.94,9.2,2.92,14.4,4.1,10.73,9.27,20.92,14.27,31.26,8.87,18.33,16.49,37.11,25,55.63-6.68-1.54-13.32-16-17.52-21.25-5-6.36-10.17-13-15.75-18.87C98,76.46,82.32,67.18,68,56.37,60.33,50.61,54.24,45.12,44,46.3c-8.83,1-15.92,11.33-12.6,20.2,1.06,2.83,6,7.09,8.35,9.37C44.1,80.05,50.09,82.3,55,85.68c6.12,4.21,11,11.07,16.52,16.25A124.22,124.22,0,0,1,89,122.31c2.84,4.13,5.46,8.64,8.8,12.37s8.46,6.25,8.9,11.85c-12.15-12.25-23.75-25.38-39.22-33.44-14.79-7.71-27.92-18.14-41-28.46l-12.67-6L8.57,82.15.86,87.33.12,95.71l3.54,7.54,20.25,16.16c11.65,9.4,23.69,18.42,34.72,28.55,5.73,5.26,11.72,10.29,16.88,16.11,3.13,3.54,7.85,7.61,10.08,11.77,1.73,3.22,1.31,4.72.95,8.86-19.73-7.17-36.5-15-53.73-27L12.21,144l-8.37,2.31L0,154.28,6,167l21.61,19.32c12.25,9.48,23.76,19.9,37.47,27.17,5.48,2.91,11.82,5.1,16.26,9.34,6.27,6,11.1,13.95,16.73,20.55,8.22,9.64,17.79,20.14,27.73,27.95,5.64,4.43,12.77,7.63,18.9,11.33,5.94,3.58,12.37,4.66,17.87,8.34,7.59,5.08,14.19,11.77,21.52,17.22,4.36,3.24,9,4.9,14.06,7,6.34,2.66,14.14,4.69,20,8.39,5.66,3.6,10.71,9.41,15.73,13.82,5.2,4.57,10.83,11.47,16.9,14.85,3.32,1.85,8.13,2.27,11.82,3.21,17.31,4.39,34.58,9.07,52,13.19,5.39,1.28,10.85,2.05,16.32,2.94,7.24,1.18,14,3.92,20.61.8,6-2.81,13.09-8.46,19.06-8.79,7.85-.44,16.73,2,24.56,2.95,0,0,3.65,64.36,3.59,66.66a7.46,7.46,0,0,1-.21,2.42l121.87.61,0,.2s154.52-.09,156.63,0S674.46,329.8,671.09,294.62Z\" />\n          </g>\n        </svg>\n      </div>\n    `\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/animation.js","// @flow\n\nimport { background } from '../stylesheets/background.css'\n\ntype colorHandlerTypeProps = {\n  backgroundColor: string\n}\n\nexport const bylineComponent = {\n  type: 'byline',\n  render(id: string, props: colorHandlerTypeProps, bgInnerHTML: ?string = ''): string {\n    const { backgroundColor } = props\n    const style = `background-color: ${backgroundColor};`\n\n    return `\n      <div id=\"${id}\" class=\"${background}\" style=\"${style}\">\n        ${bgInnerHTML}\n      </div>\n    `\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/byline.js","// @flow\n\nimport { background } from '../stylesheets/background.css'\nimport moodStyles from '../stylesheets/mood.css'\n\ntype colorHandlerTypeProps = {\n  backgroundColor: string,\n  mood: ?string\n}\n\nexport const colorComponent = {\n  type: 'color',\n  render(id: string, props: colorHandlerTypeProps, bgInnerHTML: ?string = ''): string {\n    const { backgroundColor, mood } = props\n    const style = `background-color: ${backgroundColor};`\n    const sectionMoodClass = mood ? `mood--background-${mood}` : `mood--background-default`\n\n    return `\n      <div id=\"${id}\" class=\"${background} ${moodStyles[sectionMoodClass]}\" style=\"${style}\">\n        ${bgInnerHTML}\n      </div>\n    `\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/color.js","// @flow\n\nimport throttle from 'lodash/throttle'\n\nimport { getPolopolyImageElement } from '../utils/imageUtils'\nimport { getOverlayElement } from '../utils/renderUtils'\nimport { constrain } from '../utils/general'\n\nimport { background, uncroppedImageContainer } from '../stylesheets/background.css'\nimport { alignCenter, alignMiddle } from '../stylesheets/alignment/index.css'\n\ntype flipScrollHandlerTypeProps = {\n  alignment: ?Array<string>,\n  polopolyIds: Array<string>,\n  overlay: ?Boolean | Object,\n  uncropped: ?Boolean,\n  flipFade: ?Boolean\n}\n\nlet eventListener = null\nexport const flipScrollComponent = {\n  type: 'flip-scroll',\n  render(\n    id: string,\n    props: flipScrollHandlerTypeProps,\n    bgInnerHTML: ?string = ''\n  ): string {\n    const { alignment, polopolyIds, overlay, uncropped, flipFade = false } = props\n    const alignmentClasses = alignment ?\n      alignment.join(' ') :\n      [alignMiddle, alignCenter].join(' ')\n\n    let imageStyle = uncropped ?\n      'position: absolute' :\n      'min-width: 100%; min-height: 100%; position: absolute;'\n\n    const imageElements = polopolyIds.map(polopolyId =>\n      getPolopolyImageElement(\n        polopolyId,\n        alignmentClasses,\n        imageStyle,\n        flipFade ? 'transition: .5s opacity ease-in-out' : ''\n      )\n    )\n\n    return `\n      <div id=\"${id}\" class=\"${background}\">\n        ${uncropped ? `<div class=\"${uncroppedImageContainer}\">` : ''}\n          ${imageElements.join('')}\n        ${uncropped ? '</div>' : ''}\n        ${bgInnerHTML}\n        ${getOverlayElement(overlay)}\n      </div>\n    `\n  },\n  onCurrentChanged(currentSection) {\n    if (eventListener) {\n      document.removeEventListener('scroll', eventListener)\n      eventListener = null\n    }\n\n    const { type } = currentSection\n    if (type === 'flip-scroll') {\n      eventListener = throttle(() => handleFlipScroll(currentSection), 30)\n      document.addEventListener('scroll', eventListener, {\n        passive: true\n      })\n    }\n  }\n}\n\nexport const handleFlipScroll = element => {\n  const { y, top } = element.foregroundElement.getBoundingClientRect()\n\n  const { innerHeight } = window\n  const imageElements = element.backgroundElement.getElementsByTagName('picture')\n  const numberOfImages = imageElements.length\n\n  const pxInView = innerHeight - (y || top)\n  const percentInView = constrain(pxInView / innerHeight, 0, 0.99)\n  const idx = Math.floor(percentInView * numberOfImages)\n\n  for (let i = 0; i < numberOfImages; i++) {\n    imageElements[i].style.opacity = i === idx ? '1' : '0'\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/flipScroll.js","// @flow\n\nimport { getPolopolyImageElement, getImageElement } from '../utils/imageUtils'\nimport { getOverlayElement } from '../utils/renderUtils'\n\nimport { alignCenter, alignMiddle } from '../stylesheets/alignment/index.css'\nimport { background, uncroppedImageContainer } from '../stylesheets/background.css'\nimport moodStyles from '../stylesheets/mood.css'\n\ntype propTypes = {\n  backgroundImage: ?string,\n  polopolyId: ?string,\n  uncropped: ?Boolean,\n  overlay: ?Object | ?Boolean,\n  alignment: ?Array<string>,\n  mood: ?string\n}\n\nexport const imageComponent = {\n  type: 'image',\n  render(id: string, props: propTypes, bgInnerHTML: ?string = ''): string {\n    const { backgroundImage, polopolyId, mood, uncropped = false, overlay, alignment } = props\n\n    const alignmentClasses = ''\n\n    const imageStyle = uncropped ?\n      'position: relative' :\n      'min-width: 100%; min-height: 100%; position: relative;'\n\n    const sectionMoodClass = mood ? `mood--background-${mood}` : `mood--background-default`\n\n    // console.log('smc', sectionMoodClass)\n\n    let imageElement = ''\n    if (polopolyId) {\n      imageElement = getPolopolyImageElement(polopolyId, alignmentClasses, imageStyle)\n    } else if (backgroundImage) {\n      imageElement = getImageElement(backgroundImage, alignmentClasses, imageStyle)\n    }\n\n    return `\n      <div id=\"${id}\" class=\"${background} ${moodStyles[sectionMoodClass]}\">\n        ${uncropped ? `<div class=\"${uncroppedImageContainer}\">` : ''}\n          ${imageElement}\n        ${uncropped ? '</div>' : ''}\n        ${getOverlayElement(overlay)}\n        ${bgInnerHTML}\n      </div>\n    `\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/image.js","// @flow\nimport throttle from 'lodash/throttle'\n\nimport { background, panoramaImageContainer } from '../stylesheets/background.css'\nimport { getPolopolyImageElement } from './polopoly'\n\ntype propType = {\n  polopolyId: ?string,\n  backgroundImage: ?string,\n  backgroundColor: ?string\n}\n\nlet eventListener = null\n\nexport const panoramaComponent = {\n  type: 'panorama',\n  render(id: string, props: propType, bgInnerHTML: ?string = ''): string {\n    const { backgroundImage, polopolyId, backgroundColor = '#333' } = props\n    const style = `background-color: ${backgroundColor};`\n\n    let imageElement = `<img src=\"${backgroundImage}\"></img>`\n\n    if (!backgroundImage && polopolyId) {\n      imageElement = getPolopolyImageElement(polopolyId)\n    }\n\n    return `\n    <div id=\"${id}\" class=\"${background}\" style=\"${style}\">\n      <div class=\"${panoramaImageContainer}\">\n        ${imageElement}\n        ${bgInnerHTML}\n      </div>\n    </div>\n  `\n  },\n\n  onCurrentChanged(currentSection) {\n    if (eventListener) {\n      document.removeEventListener('scroll', eventListener)\n      eventListener = null\n    }\n\n    const { type } = currentSection\n    if (type === 'panorama') {\n      eventListener = throttle(() => handlePanoramaScroll(currentSection), 30)\n      document.addEventListener('scroll', eventListener, {\n        passive: true\n      })\n    }\n  }\n}\n\nconst handlePanoramaScroll = element => {\n  const { y, top, height } = element.foregroundElement.getBoundingClientRect()\n\n  const { innerHeight, innerWidth } = window\n\n  let pxInView = innerHeight - (y || top)\n\n  if (pxInView >= height) {\n    pxInView = height\n  } else if (pxInView <= 0) {\n    pxInView = 0\n  }\n  let percentInView = pxInView / height * 100\n  if (percentInView >= 100) percentInView = 100\n  if (percentInView <= 0) percentInView = 0\n\n  const imgElement = element.backgroundElement.querySelector('img')\n\n  const { width: elWidth } = imgElement.getBoundingClientRect()\n  const translateX = -(elWidth - innerWidth) * percentInView / 100\n  imgElement.style.transform = `translateX(${translateX}px)`\n  imgElement.style.webkitTransform = `translateX(${translateX}px)`\n  imgElement.style.msTransform = `translateX(${translateX}px)`\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/panorama.js","// @flow\n\nimport { createImageUrl } from '@nrk/serum-imagecrop-utils'\nimport { background, backgroundOverlay } from '../stylesheets/background.css'\nimport { alignCenter, alignMiddle } from '../stylesheets/alignment/index.css'\nimport { createSrcSet, supportedWidths } from '../utils/imageUtils'\n\ntype overlayType = {\n  opacity: ?string | ?number,\n  color: ?string\n}\n\ntype polopolyHandlerTypeProps = {\n  polopolyId: string,\n  backgroundColor: ?string,\n  alignment: ?Array<string>,\n  overlay: ?overlayType\n}\n\nexport const polopolyComponent = {\n  type: 'polopoly',\n  render(id: string, props: polopolyHandlerTypeProps, bgInnerHTML: ?string = ''): string {\n    const { polopolyId, alignment, overlay } = props\n\n    const defaultUrl = createImageUrl({ id: polopolyId, width: 1600, ratio: '1:1' })\n    const desktopSourceSet = createSrcSet(polopolyId, '1:1', supportedWidths)\n    const mobileSourceSet = createSrcSet(polopolyId, '3:4', supportedWidths)\n\n    const overlayElement = overlay ?\n      `<div class=\"${backgroundOverlay}\" style=\"background-color: ${props.overlay\n          .color || '#000'}; opacity: ${props.overlay.opacity || 0.8}\"></div>` :\n      ''\n\n    const imgStyle = 'min-width: 100%; min-height: 100%; position: relative;'\n    const alignmentClasses = alignment ?\n      alignment.join(' ') :\n      [alignMiddle, alignCenter].join(' ')\n\n    return `\n      <div id=\"${id}\" class=\"${background}\">\n        <picture style=\"object-fit: cover;\">\n        <source media=\"(min-aspect-ratio: 3/4)\" srcset=\"${desktopSourceSet}\">\n        <img src=\"${defaultUrl}\" srcset=\"${mobileSourceSet}\" class=\"${alignmentClasses}\" style=\"${imgStyle}\">\n        </picture>\n        ${bgInnerHTML}\n        ${overlayElement}\n      </div>`\n  }\n}\n\nexport function getPolopolyImageElement(\n  polopolyId: string,\n  alignmentClasses: string = ''\n): string {\n  const defaultUrl = createImageUrl({ id: polopolyId, width: 1600, ratio: '1:1' })\n  const desktopSourceSet = createSrcSet(polopolyId, '1:1', supportedWidths)\n  const mobileSourceSet = createSrcSet(polopolyId, '3:4', supportedWidths)\n\n  const imgStyle =\n    'position: absolute; top: 50%; left: 50%; -webkit-transform: translate(-50%, -50%);-ms-transform: translate(-50%, -50%);transform: translate(-50%, -50%);'\n  return `\n    <picture>\n      <source media=\"(min-aspect-ratio: 3/4)\" srcset=\"${desktopSourceSet}\">\n      <img src=\"${defaultUrl}\" srcset=\"${mobileSourceSet}\" class=\"${alignmentClasses}\" style=\"${imgStyle}\">\n    </picture>`\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/polopoly.js","import style from '../../index.css'\nimport bgStyle from '../../stylesheets/background.css'\n\nlet fgEls = []\nlet bgEls = []\n\nexport const setActiveElementClass = {\n  onCurrentChanged(currentSection, dispatch) {\n    const { foregroundElement, backgroundElement } = currentSection\n\n    if (!fgEls || !fgEls.length) {\n      fgEls = [...document.querySelectorAll(`.${style.section}`)]\n      bgEls = [...document.querySelectorAll(`.${bgStyle.background}`)]\n    }\n\n    const index = fgEls.indexOf(foregroundElement)\n    const activeEls = shouldBeActive(index, fgEls, bgEls)\n\n    fgEls.forEach(fgEl => {\n      if (fgEl === foregroundElement) {\n        addOrRemoveClass(fgEl, style['section--ready'], 'remove')\n        addOrRemoveClass(fgEl, style['section--active'], 'add')\n      } else if (activeEls.fgEls.indexOf(fgEl) >= 0) {\n        addOrRemoveClass(fgEl, style['section--active'], 'remove')\n        addOrRemoveClass(fgEl, style['section--ready'], 'add')\n      } else {\n        addOrRemoveClass(fgEl, style['section--ready'], 'remove')\n        addOrRemoveClass(fgEl, style['section--active'], 'remove')\n      }\n    })\n\n    bgEls.forEach(bgEl => {\n      if (bgEl === backgroundElement) {\n        addOrRemoveClass(bgEl, bgStyle['background--ready'], 'remove')\n        addOrRemoveClass(bgEl, bgStyle['background--active'], 'add')\n      } else if (activeEls.bgEls.indexOf(bgEl) >= 0) {\n        addOrRemoveClass(bgEl, bgStyle['background--active'], 'remove')\n        addOrRemoveClass(bgEl, bgStyle['background--ready'], 'add')\n      } else {\n        addOrRemoveClass(bgEl, bgStyle['background--active'], 'remove')\n        addOrRemoveClass(bgEl, bgStyle['background--ready'], 'remove')\n      }\n    })\n  }\n}\n\nfunction addOrRemoveClass(el, className, action = 'add') {\n  if (!el || !el.classList || !className) return\n  if (action === 'remove') {\n    return el.classList.contains(className) && el.classList.remove(className)\n  }\n  if (!el.classList.contains(className)) return el.classList.add(className)\n}\n\nfunction shouldBeActive(index, fgEls, bgEls, buffer = 3) {\n  if (index < 0) return { fg: [], bg: [] }\n  if (index === 0 && fgEls.length > buffer) {\n    return {\n      fgEls: fgEls.slice(0, buffer + 1),\n      bgEls: bgEls.slice(0, buffer + 1)\n    }\n  } else if (index > 0) {\n    if (fgEls.length > index + buffer) {\n      const root = index - buffer\n      return {\n        fgEls: fgEls.slice(root > 0 ? root : 0, index + buffer + 1),\n        bgEls: bgEls.slice(root > 0 ? root : 0, index + buffer + 1)\n      }\n    }\n    return {\n      fgEls: fgEls.slice(index - buffer, fgEls.length),\n      bgEls: bgEls.slice(index - buffer, fgEls.length)\n    }\n  }\n  return { fgEls: [], bgEls: [] }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/renderless/activeClass.js","// @flow\n\nimport { getPolopolyImageElement, getImageElement } from '../utils/imageUtils'\nimport throttle from 'lodash/throttle'\n\nimport { background, uncroppedImageContainer } from '../stylesheets/background.css'\nimport { alignCenter, alignMiddle } from '../stylesheets/alignment/index.css'\n\nlet eventListener = null\n\ntype onScrollHandlerTypeProps = {\n  polopolyId: ?string,\n  backgroundImage?: string,\n  backgroundColor: ?string,\n  alignment?: Array<string>,\n  uncropped?: boolean\n}\n\nexport const triggerOnScrollComponent = {\n  type: 'trigger-on-scroll',\n  render(id: string, props: onScrollHandlerTypeProps, bgInnerHTML: ?string = ''): string {\n    const {\n      backgroundImage,\n      polopolyId,\n      alignment,\n      uncropped,\n      backgroundColor = '#333'\n    } = props\n    const style = `background-color: ${backgroundColor || ''};`\n    // const style = `background-color: ${backgroundColor};`\n\n    const alignmentClasses = alignment ?\n      alignment.join(' ') :\n      [alignMiddle, alignCenter].join(' ')\n\n    const imageStyle = uncropped ?\n      'position: relative' :\n      'min-width: 100%; min-height: 100%; position: relative;'\n\n    let imageElement = ''\n    if (polopolyId) {\n      imageElement = getPolopolyImageElement(polopolyId, alignmentClasses, imageStyle)\n    } else if (backgroundImage) {\n      imageElement = getImageElement(backgroundImage, alignmentClasses, imageStyle)\n    }\n\n    return `\n      <div id=\"${id}\" class=\"${background}\" style=\"${style}\">\n        ${uncropped ? `<div class=\"${uncroppedImageContainer}\">` : ''}\n          ${imageElement}\n          ${uncropped ? `</div>` : ''}\n\n          ${bgInnerHTML}\n      </div>\n    `\n  },\n  onCurrentChanged(currentSection) {\n    if (eventListener) {\n      document.removeEventListener('scroll', eventListener)\n      eventListener = null\n    }\n\n    const { type } = currentSection\n    if (type === 'trigger-on-scroll') {\n      eventListener = throttle(() => handleTriggerOnScroll(currentSection), 30, {\n        passive: true\n      })\n      document.addEventListener('scroll', eventListener)\n    }\n  }\n}\n\nconst handleTriggerOnScroll = section => {\n  const { y, top, height } = section.foregroundElement.getBoundingClientRect()\n  const { innerHeight, innerWidth } = window\n  const { actions, lastParsedHeight, lastScroll } = section.props.onScroll\n\n  let actionsToDo = actions\n  const direction = lastScroll > (y || top) ? 'forwards' : 'backwards'\n\n  const shouldReparseWhen =\n    !lastParsedHeight ||\n    lastParsedHeight > innerWidth + 50 ||\n    lastParsedHeight < innerWidth - 50\n\n  if (shouldReparseWhen) {\n    section.props.onScroll.lastParsedHeight = innerWidth\n\n    actionsToDo = actions.map(action => {\n      return {\n        ...action,\n        parsedWhen: parseWhen(action.when, height),\n        parsedBreakpoints: innerWidth\n      }\n    })\n  }\n\n  if (direction !== section.props.onScroll.direction) actionsToDo.reverse()\n\n  section.props.onScroll.lastScroll = y || top\n  section.props.onScroll.direction = direction\n\n  let pxInView = innerHeight - (y || top)\n\n  if (pxInView >= height) {\n    pxInView = height\n  } else if (pxInView <= 0) {\n    pxInView = 0\n  }\n\n  section.props.onScroll.actions = actionsToDo.map((action, i) => {\n    let { breakpoint, parsedWhen, isAnimated, classes, style } = action\n\n    const isBetweenBreakpoints =\n      innerWidth > breakpoint.from && innerWidth < breakpoint.to\n\n    let shouldAnimateIn = parsedWhen.from < pxInView && parsedWhen.to > pxInView\n    if (direction === 'backwards') {\n      shouldAnimateIn = parsedWhen.to > pxInView && parsedWhen.from < pxInView\n    }\n\n    if (shouldAnimateIn && !isAnimated && isBetweenBreakpoints) {\n      // DO ANIMATION\n\n      const targetElement = getTarget(action, section)\n\n      doAnimation(targetElement, classes, style)\n      isAnimated = true\n    } else if (!shouldAnimateIn && isAnimated) {\n      // UNDO ANIMATION\n      if (!action.once) {\n        const targetElement = getTarget(action, section)\n\n        isAnimated = false\n        undoAnimation(targetElement, classes, style)\n      }\n    }\n    return {\n      ...action,\n      isAnimated\n    }\n  })\n}\n\nconst parseWhen = (bp, height = 1) => {\n  const parseFunction = val => {\n    if (typeof val !== 'number') {\n      if (val.indexOf('%') > -1) {\n        return height * (parseFloat(val) / 100)\n      }\n      return parseInt(val)\n    }\n  }\n\n  return {\n    to: parseFunction(bp.to),\n    from: parseFunction(bp.from)\n  }\n}\n\nconst getTarget = (action, section) => {\n  const { target } = action\n\n  if (!target) return section.backgroundElement\n  if (Array.isArray(target)) {\n    if (target.length > 1) {\n      const foregroundOrBackground =\n        target[1] === 'foreground' ? 'foregroundElement' : 'backgroundElement'\n\n      return [...section[foregroundOrBackground].querySelectorAll(target[0])]\n    }\n    return [...section.foregroundElement.querySelectorAll(target[0])]\n  }\n  if (typeof target === 'string') {\n    if (target === 'foreground') return section.foregroundElement\n    if (target === 'background') return section.backgroundElement\n    return document.querySelector(target)\n  }\n}\n\nconst undoAnimation = (targetElement, classes, style) => {\n  const isTargetArray = Array.isArray(targetElement)\n\n  if (targetElement && classes) {\n    if (isTargetArray) {\n      targetElement.map(tE => tE.classList.remove(classes))\n    } else {\n      targetElement.classList.remove(classes)\n    }\n  }\n  if (targetElement && style) {\n    if (isTargetArray) {\n      targetElement.map(tE => {\n        Object.keys(style).forEach(s => {\n          tE.style[s] = null\n        })\n      })\n    } else {\n      Object.keys(style).forEach(s => {\n        targetElement.style[s] = null\n      })\n    }\n  }\n}\n\nconst doAnimation = (targetElement, classes, style) => {\n  const isTargetArray = Array.isArray(targetElement)\n  if (targetElement && classes) {\n    if (isTargetArray) {\n      targetElement.map(tE => tE.classList.add(classes))\n    } else {\n      targetElement.classList.add(classes)\n    }\n  }\n  if (targetElement && style) {\n    if (isTargetArray) {\n      targetElement.map(tE => {\n        Object.keys(style).forEach(s => {\n          tE.style[s] = style[s]\n        })\n      })\n    } else {\n      Object.keys(style).forEach(s => {\n        targetElement.style[s] = style[s]\n      })\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/triggerOnScroll.js","// @flow\nimport { background } from '../stylesheets/background.css'\nimport videoStyles from '../stylesheets/video.css'\nimport { trackAction } from '../utils/googleAnalytics'\nimport { getOverlayElement } from '../utils/renderUtils'\n\ntype videoType = {\n  mp4: string,\n  webm: string,\n  poster: string,\n  subtitles: ?Object,\n  loop: ?string\n}\n\ntype videoHandlerTypeProps = {\n  video: videoType,\n  alignment: ?Array<string>\n}\n\nconst bgVideos = []\n\nexport const videoComponent = {\n  type: 'video',\n  render(id: string, props: videoHandlerTypeProps, bgInnerHTML: ?string = '') {\n    const { video, alignment, overlay } = props\n    // console.log('Video:', video, props)\n    const { mp4, webm, poster, subtitles, hasSound, loop } = video\n\n    const trackElement = subtitles ?\n      `<track src=\"${\n          subtitles\n        }\" kind=\"caption\" srclang=\"no\" label=\"Norwegian\" default=\"\" />` :\n      ''\n\n    const alignmentClasses = alignment.join(' ')\n\n    return `\n      <div id=\"${id}\" class=\"${background} ${videoStyles.hidePlay}\" >\n        <video\n          muted\n          ${loop === 'none' ? '' : 'loop'}\n          preload=\"none\"\n          poster=\"${poster}\"\n          playsinline\n          webkit-playsinline\n          aria-hidden=\"true\"\n          class=\"${videoStyles.video} ${alignmentClasses}\">\n          <source type=\"video/webm\" src=\"${webm}\">\n          <source type=\"video/mp4\" src=\"${mp4}\">\n          ${trackElement}\n          Your browser does not support the video tag. We suggest you upgrade your browser.\n        </video>\n        <div class=\"${videoStyles['subtitlescontainer']}\"></div>\n        ${bgInnerHTML}\n        ${getOverlayElement(overlay)}\n\n      </div>\n    `\n  },\n\n  onCurrentChanged(currentSection, dispatch) {\n    const { id, type, props, backgroundElement } = currentSection\n    // const { video } = ''\n    const { video } = props\n\n    dispatch({ type: 'showMuteButton', value: video && video.hasSound })\n\n    try {\n      bgVideos.forEach(v => {\n        v.pause()\n      })\n    } catch (error) {\n      console.error('error in pause', error)\n    }\n\n    if (type === 'video') {\n      const bgVideo = backgroundElement.querySelector('video')\n      if (!bgVideo) return\n\n      try {\n        bgVideo.play().catch(console.error)\n      } catch (error) {\n        console.error('error while playing', error)\n      }\n\n      if (!bgVideo.paused) {\n        trackAction(`VIDEO_PLAYING/${id}`)\n      }\n\n      if (bgVideos.indexOf(bgVideo) === -1) {\n        bgVideos.push(bgVideo)\n      }\n    }\n  },\n\n  onStateChanged(state) {\n    if (state.muted) {\n      bgVideos.forEach(v => (v.muted = true))\n    } else {\n      bgVideos.forEach(v => (v.muted = false))\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/components/video.js","import videoStyles from '../stylesheets/video.css'\n\nexport const getInitialMuteButton = () => {\n  return `\n  <button class=\"${videoStyles['video-mute-button']}\">\n    ${getMutedButton()}\n  </button>\n  `\n}\n\nexport const getMutedButton = () => {\n  return `\n    <svg class=\"${\n      videoStyles['video-mute-svg-muted']\n    }\" width=\"21\" height=\"19\" viewBox=\"0 0 21 19\" xmlns=\"http://www.w3.org/2000/svg\">\n      <g stroke=\"#FFF\" fill=\"none\" fill-rule=\"evenodd\">\n        <path d=\"M11.1.55l-5.2 5.3h-.2l-4.4.34c-.45.03-.8.43-.8.9v4.8c0 .5.34.88.78.9l4.6.36.14.13 5.06 5.14c.17.14.42 0 .42-.25V.8c0-.24-.25-.37-.4-.25z\" />\n        <path d=\"M20 7l-5 5M15 7l5 5\" stroke-linecap=\"round\" />\n      </g>\n    </svg>\n    <svg class=\"${\n      videoStyles['video-mute-svg-muted-hover']\n    }\" width=\"21\" height=\"19\" viewBox=\"0 0 21 19\" xmlns=\"http://www.w3.org/2000/svg\">\n      <g fill=\"none\" fill-rule=\"evenodd\">\n        <path d=\"M10.75.18l-5.1 5.18-4.4.33C.53 5.75 0 6.4 0 7.1v4.8c0 .74.53 1.36 1.25 1.4l4.4.34 5.1 5.18c.5.43 1.25.05 1.25-.63V.77c-.02-.64-.76-1.03-1.25-.6z\" fill=\"#FFF\" fill-rule=\"nonzero\" />\n        <path d=\"M20 7l-5 5M15 7l5 5\" stroke=\"#FFF\" stroke-linecap=\"round\" />\n      </g>\n    </svg>\n  `\n}\n\nexport const getUnmutedButton = () => {\n  return `\n    <svg class=\"${\n      videoStyles['video-mute-svg-unmuted']\n    }\" width=\"21\" height=\"19\" viewBox=\"0 0 21 19\" xmlns=\"http://www.w3.org/2000/svg\">\n      <g fill-rule=\"nonzero\" fill=\"none\">\n        <path d=\"M21 9.48c0-3.3-1.82-6.22-4.56-7.48l-.37.87c2.4 1.1 4.02 3.7 4.02 6.6 0 2.96-1.65 5.56-4.1 6.65l.36.88C19.14 15.76 21 12.8 21 9.48z\" fill=\"#FFF\" />\n        <path d=\"M18 9.46C18 7.6 17.06 5.9 15.57 5l-.45.86c1.2.73 1.96 2.1 1.96 3.6 0 1.56-.8 2.96-2.08 3.66l.42.88C17 13.13 18 11.4 18 9.46z\" fill=\"#FFF\" />\n        <path d=\"M11.1.55l-5.2 5.3h-.2l-4.4.34c-.45.03-.8.43-.8.9v4.8c0 .5.34.88.78.9l4.6.36.14.13 5.06 5.14c.17.14.42 0 .42-.25V.8c0-.24-.25-.37-.4-.25z\" stroke=\"#FFF\" />\n      </g>\n    </svg>\n    <svg class=\"${\n      videoStyles['video-mute-svg-unmuted-hover']\n    }\" width=\"21\" height=\"19\" viewBox=\"0 0 21 19\" xmlns=\"http://www.w3.org/2000/svg\">\n\n    <g fill-rule=\"nonzero\" fill=\"#FFF\">\n      <path d=\"M21 9.48c0-3.3-1.82-6.22-4.56-7.48l-.37.87c2.4 1.1 4.02 3.7 4.02 6.6 0 2.96-1.65 5.56-4.1 6.65l.36.88C19.14 15.76 21 12.8 21 9.48z\" />\n      <path d=\"M18 9.46C18 7.6 17.06 5.9 15.57 5l-.45.86c1.2.73 1.96 2.1 1.96 3.6 0 1.56-.8 2.96-2.08 3.66l.42.88C17 13.13 18 11.4 18 9.46zM10.75.18l-5.1 5.18-4.4.33C.53 5.75 0 6.4 0 7.1v4.8c0 .74.53 1.36 1.25 1.4l4.4.34 5.1 5.18c.5.43 1.25.05 1.25-.63V.77c-.02-.64-.76-1.03-1.25-.6z\" />\n    </g>\n  </svg>\n  `\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/shared/utils/muteButtons.js","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $Array = GetIntrinsic('%Array%');\n\n// eslint-disable-next-line global-require\nvar toStr = !$Array.isArray && require('call-bind/callBound')('Object.prototype.toString');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isarray\n\nmodule.exports = $Array.isArray || function IsArray(argument) {\n\treturn toStr(argument) === '[object Array]';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2020/IsArray.js\n// module id = 80\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar DefineOwnProperty = require('../helpers/DefineOwnProperty');\n\nvar FromPropertyDescriptor = require('./FromPropertyDescriptor');\nvar OrdinaryGetOwnProperty = require('./OrdinaryGetOwnProperty');\nvar IsDataDescriptor = require('./IsDataDescriptor');\nvar IsExtensible = require('./IsExtensible');\nvar IsPropertyKey = require('./IsPropertyKey');\nvar SameValue = require('./SameValue');\nvar Type = require('./Type');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-createdataproperty\n\nmodule.exports = function CreateDataProperty(O, P, V) {\n\tif (Type(O) !== 'Object') {\n\t\tthrow new $TypeError('Assertion failed: Type(O) is not Object');\n\t}\n\tif (!IsPropertyKey(P)) {\n\t\tthrow new $TypeError('Assertion failed: IsPropertyKey(P) is not true');\n\t}\n\tvar oldDesc = OrdinaryGetOwnProperty(O, P);\n\tvar extensible = !oldDesc || IsExtensible(O);\n\tvar immutable = oldDesc && (!oldDesc['[[Writable]]'] || !oldDesc['[[Configurable]]']);\n\tif (immutable || !extensible) {\n\t\treturn false;\n\t}\n\treturn DefineOwnProperty(\n\t\tIsDataDescriptor,\n\t\tSameValue,\n\t\tFromPropertyDescriptor,\n\t\tO,\n\t\tP,\n\t\t{\n\t\t\t'[[Configurable]]': true,\n\t\t\t'[[Enumerable]]': true,\n\t\t\t'[[Value]]': V,\n\t\t\t'[[Writable]]': true\n\t\t}\n\t);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/CreateDataProperty.js\n// module id = 81\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar CreateDataProperty = require('./CreateDataProperty');\nvar IsPropertyKey = require('./IsPropertyKey');\nvar Type = require('./Type');\n\n// // https://ecma-international.org/ecma-262/6.0/#sec-createdatapropertyorthrow\n\nmodule.exports = function CreateDataPropertyOrThrow(O, P, V) {\n\tif (Type(O) !== 'Object') {\n\t\tthrow new $TypeError('Assertion failed: Type(O) is not Object');\n\t}\n\tif (!IsPropertyKey(P)) {\n\t\tthrow new $TypeError('Assertion failed: IsPropertyKey(P) is not true');\n\t}\n\tvar success = CreateDataProperty(O, P, V);\n\tif (!success) {\n\t\tthrow new $TypeError('unable to create data property');\n\t}\n\treturn success;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/CreateDataPropertyOrThrow.js\n// module id = 82\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar isPropertyDescriptor = require('../helpers/isPropertyDescriptor');\nvar DefineOwnProperty = require('../helpers/DefineOwnProperty');\n\nvar FromPropertyDescriptor = require('./FromPropertyDescriptor');\nvar IsAccessorDescriptor = require('./IsAccessorDescriptor');\nvar IsDataDescriptor = require('./IsDataDescriptor');\nvar IsPropertyKey = require('./IsPropertyKey');\nvar SameValue = require('./SameValue');\nvar ToPropertyDescriptor = require('./ToPropertyDescriptor');\nvar Type = require('./Type');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-definepropertyorthrow\n\nmodule.exports = function DefinePropertyOrThrow(O, P, desc) {\n\tif (Type(O) !== 'Object') {\n\t\tthrow new $TypeError('Assertion failed: Type(O) is not Object');\n\t}\n\n\tif (!IsPropertyKey(P)) {\n\t\tthrow new $TypeError('Assertion failed: IsPropertyKey(P) is not true');\n\t}\n\n\tvar Desc = isPropertyDescriptor({\n\t\tType: Type,\n\t\tIsDataDescriptor: IsDataDescriptor,\n\t\tIsAccessorDescriptor: IsAccessorDescriptor\n\t}, desc) ? desc : ToPropertyDescriptor(desc);\n\tif (!isPropertyDescriptor({\n\t\tType: Type,\n\t\tIsDataDescriptor: IsDataDescriptor,\n\t\tIsAccessorDescriptor: IsAccessorDescriptor\n\t}, Desc)) {\n\t\tthrow new $TypeError('Assertion failed: Desc is not a valid Property Descriptor');\n\t}\n\n\treturn DefineOwnProperty(\n\t\tIsDataDescriptor,\n\t\tSameValue,\n\t\tFromPropertyDescriptor,\n\t\tO,\n\t\tP,\n\t\tDesc\n\t);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/DefinePropertyOrThrow.js\n// module id = 83\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar inspect = require('object-inspect');\n\nvar IsPropertyKey = require('./IsPropertyKey');\nvar Type = require('./Type');\n\n/**\n * 7.3.1 Get (O, P) - https://ecma-international.org/ecma-262/6.0/#sec-get-o-p\n * 1. Assert: Type(O) is Object.\n * 2. Assert: IsPropertyKey(P) is true.\n * 3. Return O.[[Get]](P, O).\n */\n\nmodule.exports = function Get(O, P) {\n\t// 7.3.1.1\n\tif (Type(O) !== 'Object') {\n\t\tthrow new $TypeError('Assertion failed: Type(O) is not Object');\n\t}\n\t// 7.3.1.2\n\tif (!IsPropertyKey(P)) {\n\t\tthrow new $TypeError('Assertion failed: IsPropertyKey(P) is not true, got ' + inspect(P));\n\t}\n\t// 7.3.1.3\n\treturn O[P];\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/Get.js\n// module id = 84\n// module chunks = 0","'use strict';\n\nvar has = require('has');\n\nvar assertRecord = require('../helpers/assertRecord');\n\nvar Type = require('./Type');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isaccessordescriptor\n\nmodule.exports = function IsAccessorDescriptor(Desc) {\n\tif (typeof Desc === 'undefined') {\n\t\treturn false;\n\t}\n\n\tassertRecord(Type, 'Property Descriptor', 'Desc', Desc);\n\n\tif (!has(Desc, '[[Get]]') && !has(Desc, '[[Set]]')) {\n\t\treturn false;\n\t}\n\n\treturn true;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/IsAccessorDescriptor.js\n// module id = 85\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('../GetIntrinsic.js');\n\nvar $construct = GetIntrinsic('%Reflect.construct%', true);\n\nvar DefinePropertyOrThrow = require('./DefinePropertyOrThrow');\ntry {\n\tDefinePropertyOrThrow({}, '', { '[[Get]]': function () {} });\n} catch (e) {\n\t// Accessor properties aren't supported\n\tDefinePropertyOrThrow = null;\n}\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isconstructor\n\nif (DefinePropertyOrThrow && $construct) {\n\tvar isConstructorMarker = {};\n\tvar badArrayLike = {};\n\tDefinePropertyOrThrow(badArrayLike, 'length', {\n\t\t'[[Get]]': function () {\n\t\t\tthrow isConstructorMarker;\n\t\t},\n\t\t'[[Enumerable]]': true\n\t});\n\n\tmodule.exports = function IsConstructor(argument) {\n\t\ttry {\n\t\t\t// `Reflect.construct` invokes `IsConstructor(target)` before `Get(args, 'length')`:\n\t\t\t$construct(argument, badArrayLike);\n\t\t} catch (err) {\n\t\t\treturn err === isConstructorMarker;\n\t\t}\n\t};\n} else {\n\tmodule.exports = function IsConstructor(argument) {\n\t\t// unfortunately there's no way to truly check this without try/catch `new argument` in old environments\n\t\treturn typeof argument === 'function' && !!argument.prototype;\n\t};\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/IsConstructor.js\n// module id = 86\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $Object = GetIntrinsic('%Object%');\n\nvar isPrimitive = require('../helpers/isPrimitive');\n\nvar $preventExtensions = $Object.preventExtensions;\nvar $isExtensible = $Object.isExtensible;\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isextensible-o\n\nmodule.exports = $preventExtensions\n\t? function IsExtensible(obj) {\n\t\treturn !isPrimitive(obj) && $isExtensible(obj);\n\t}\n\t: function IsExtensible(obj) {\n\t\treturn !isPrimitive(obj);\n\t};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/IsExtensible.js\n// module id = 87\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $match = GetIntrinsic('%Symbol.match%', true);\n\nvar hasRegExpMatcher = require('is-regex');\n\nvar ToBoolean = require('./ToBoolean');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-isregexp\n\nmodule.exports = function IsRegExp(argument) {\n\tif (!argument || typeof argument !== 'object') {\n\t\treturn false;\n\t}\n\tif ($match) {\n\t\tvar isRegExp = argument[$match];\n\t\tif (typeof isRegExp !== 'undefined') {\n\t\t\treturn ToBoolean(isRegExp);\n\t\t}\n\t}\n\treturn hasRegExpMatcher(argument);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/IsRegExp.js\n// module id = 88\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $gOPD = require('../helpers/getOwnPropertyDescriptor');\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nvar callBound = require('call-bind/callBound');\n\nvar $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');\n\nvar has = require('has');\n\nvar IsArray = require('./IsArray');\nvar IsPropertyKey = require('./IsPropertyKey');\nvar IsRegExp = require('./IsRegExp');\nvar ToPropertyDescriptor = require('./ToPropertyDescriptor');\nvar Type = require('./Type');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-ordinarygetownproperty\n\nmodule.exports = function OrdinaryGetOwnProperty(O, P) {\n\tif (Type(O) !== 'Object') {\n\t\tthrow new $TypeError('Assertion failed: O must be an Object');\n\t}\n\tif (!IsPropertyKey(P)) {\n\t\tthrow new $TypeError('Assertion failed: P must be a Property Key');\n\t}\n\tif (!has(O, P)) {\n\t\treturn void 0;\n\t}\n\tif (!$gOPD) {\n\t\t// ES3 / IE 8 fallback\n\t\tvar arrayLength = IsArray(O) && P === 'length';\n\t\tvar regexLastIndex = IsRegExp(O) && P === 'lastIndex';\n\t\treturn {\n\t\t\t'[[Configurable]]': !(arrayLength || regexLastIndex),\n\t\t\t'[[Enumerable]]': $isEnumerable(O, P),\n\t\t\t'[[Value]]': O[P],\n\t\t\t'[[Writable]]': true\n\t\t};\n\t}\n\treturn ToPropertyDescriptor($gOPD(O, P));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/OrdinaryGetOwnProperty.js\n// module id = 89\n// module chunks = 0","'use strict';\n\nvar $isNaN = require('../helpers/isNaN');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-samevaluezero\n\nmodule.exports = function SameValueZero(x, y) {\n\treturn (x === y) || ($isNaN(x) && $isNaN(y));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/SameValueZero.js\n// module id = 90\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\nvar $Number = GetIntrinsic('%Number%');\nvar $RegExp = GetIntrinsic('%RegExp%');\nvar $parseInteger = GetIntrinsic('%parseInt%');\n\nvar callBound = require('call-bind/callBound');\nvar regexTester = require('../helpers/regexTester');\nvar isPrimitive = require('../helpers/isPrimitive');\n\nvar $strSlice = callBound('String.prototype.slice');\nvar isBinary = regexTester(/^0b[01]+$/i);\nvar isOctal = regexTester(/^0o[0-7]+$/i);\nvar isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);\nvar nonWS = ['\\u0085', '\\u200b', '\\ufffe'].join('');\nvar nonWSregex = new $RegExp('[' + nonWS + ']', 'g');\nvar hasNonWS = regexTester(nonWSregex);\n\n// whitespace from: https://es5.github.io/#x15.5.4.20\n// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324\nvar ws = [\n\t'\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003',\n\t'\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028',\n\t'\\u2029\\uFEFF'\n].join('');\nvar trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');\nvar $replace = callBound('String.prototype.replace');\nvar $trim = function (value) {\n\treturn $replace(value, trimRegex, '');\n};\n\nvar ToPrimitive = require('./ToPrimitive');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-tonumber\n\nmodule.exports = function ToNumber(argument) {\n\tvar value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);\n\tif (typeof value === 'symbol') {\n\t\tthrow new $TypeError('Cannot convert a Symbol value to a number');\n\t}\n\tif (typeof value === 'bigint') {\n\t\tthrow new $TypeError('Conversion from \\'BigInt\\' to \\'number\\' is not allowed.');\n\t}\n\tif (typeof value === 'string') {\n\t\tif (isBinary(value)) {\n\t\t\treturn ToNumber($parseInteger($strSlice(value, 2), 2));\n\t\t} else if (isOctal(value)) {\n\t\t\treturn ToNumber($parseInteger($strSlice(value, 2), 8));\n\t\t} else if (hasNonWS(value) || isInvalidHexLiteral(value)) {\n\t\t\treturn NaN;\n\t\t}\n\t\tvar trimmed = $trim(value);\n\t\tif (trimmed !== value) {\n\t\t\treturn ToNumber(trimmed);\n\t\t}\n\n\t}\n\treturn $Number(value);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/ToNumber.js\n// module id = 91\n// module chunks = 0","'use strict';\n\nvar toPrimitive = require('es-to-primitive/es2015');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-toprimitive\n\nmodule.exports = function ToPrimitive(input) {\n\tif (arguments.length > 1) {\n\t\treturn toPrimitive(input, arguments[1]);\n\t}\n\treturn toPrimitive(input);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/ToPrimitive.js\n// module id = 92\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $String = GetIntrinsic('%String%');\nvar $TypeError = GetIntrinsic('%TypeError%');\n\n// https://ecma-international.org/ecma-262/6.0/#sec-tostring\n\nmodule.exports = function ToString(argument) {\n\tif (typeof argument === 'symbol') {\n\t\tthrow new $TypeError('Cannot convert a Symbol value to a string');\n\t}\n\treturn $String(argument);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/2021/ToString.js\n// module id = 93\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\n\n// http://262.ecma-international.org/5.1/#sec-9.10\n\nmodule.exports = function CheckObjectCoercible(value, optMessage) {\n\tif (value == null) {\n\t\tthrow new $TypeError(optMessage || ('Cannot call method on ' + value));\n\t}\n\treturn value;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/5/CheckObjectCoercible.js\n// module id = 94\n// module chunks = 0","'use strict';\n\nvar abs = require('./abs');\nvar floor = require('./floor');\nvar ToNumber = require('./ToNumber');\n\nvar $isNaN = require('../helpers/isNaN');\nvar $isFinite = require('../helpers/isFinite');\nvar $sign = require('../helpers/sign');\n\n// http://262.ecma-international.org/5.1/#sec-9.4\n\nmodule.exports = function ToInteger(value) {\n\tvar number = ToNumber(value);\n\tif ($isNaN(number)) { return 0; }\n\tif (number === 0 || !$isFinite(number)) { return number; }\n\treturn $sign(number) * floor(abs(number));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/5/ToInteger.js\n// module id = 95\n// module chunks = 0","'use strict';\n\nvar ToPrimitive = require('./ToPrimitive');\n\n// http://262.ecma-international.org/5.1/#sec-9.3\n\nmodule.exports = function ToNumber(value) {\n\tvar prim = ToPrimitive(value, Number);\n\tif (typeof prim !== 'string') {\n\t\treturn +prim; // eslint-disable-line no-implicit-coercion\n\t}\n\n\t// eslint-disable-next-line no-control-regex\n\tvar trimmed = prim.replace(/^[ \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\u0085]+|[ \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\u0085]+$/g, '');\n\tif ((/^0[ob]|^[+-]0x/).test(trimmed)) {\n\t\treturn NaN;\n\t}\n\n\treturn +trimmed; // eslint-disable-line no-implicit-coercion\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/5/ToNumber.js\n// module id = 96\n// module chunks = 0","'use strict';\n\n// http://262.ecma-international.org/5.1/#sec-9.1\n\nmodule.exports = require('es-to-primitive/es5');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/5/ToPrimitive.js\n// module id = 97\n// module chunks = 0","'use strict';\n\n// https://262.ecma-international.org/5.1/#sec-8\n\nmodule.exports = function Type(x) {\n\tif (x === null) {\n\t\treturn 'Null';\n\t}\n\tif (typeof x === 'undefined') {\n\t\treturn 'Undefined';\n\t}\n\tif (typeof x === 'function' || typeof x === 'object') {\n\t\treturn 'Object';\n\t}\n\tif (typeof x === 'number') {\n\t\treturn 'Number';\n\t}\n\tif (typeof x === 'boolean') {\n\t\treturn 'Boolean';\n\t}\n\tif (typeof x === 'string') {\n\t\treturn 'String';\n\t}\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/5/Type.js\n// module id = 98\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $abs = GetIntrinsic('%Math.abs%');\n\n// http://262.ecma-international.org/5.1/#sec-5.2\n\nmodule.exports = function abs(x) {\n\treturn $abs(x);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/5/abs.js\n// module id = 99\n// module chunks = 0","'use strict';\n\n// var modulo = require('./modulo');\nvar $floor = Math.floor;\n\n// http://262.ecma-international.org/5.1/#sec-5.2\n\nmodule.exports = function floor(x) {\n\t// return x - modulo(x, 1);\n\treturn $floor(x);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/5/floor.js\n// module id = 100\n// module chunks = 0","'use strict';\n\n// TODO: remove, semver-major\n\nmodule.exports = require('get-intrinsic');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/GetIntrinsic.js\n// module id = 101\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\nif ($gOPD) {\n\ttry {\n\t\t$gOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\t$gOPD = null;\n\t}\n}\n\nmodule.exports = $gOPD;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/helpers/getOwnPropertyDescriptor.js\n// module id = 102\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar has = require('has');\nvar $TypeError = GetIntrinsic('%TypeError%');\n\nmodule.exports = function IsPropertyDescriptor(ES, Desc) {\n\tif (ES.Type(Desc) !== 'Object') {\n\t\treturn false;\n\t}\n\tvar allowed = {\n\t\t'[[Configurable]]': true,\n\t\t'[[Enumerable]]': true,\n\t\t'[[Get]]': true,\n\t\t'[[Set]]': true,\n\t\t'[[Value]]': true,\n\t\t'[[Writable]]': true\n\t};\n\n\tfor (var key in Desc) { // eslint-disable-line no-restricted-syntax\n\t\tif (has(Desc, key) && !allowed[key]) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tif (ES.IsDataDescriptor(Desc) && ES.IsAccessorDescriptor(Desc)) {\n\t\tthrow new $TypeError('Property Descriptors may not be both accessor and data descriptors');\n\t}\n\treturn true;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/helpers/isPropertyDescriptor.js\n// module id = 103\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $Math = GetIntrinsic('%Math%');\nvar $Number = GetIntrinsic('%Number%');\n\nmodule.exports = $Number.MAX_SAFE_INTEGER || $Math.pow(2, 53) - 1;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/helpers/maxSafeInteger.js\n// module id = 104\n// module chunks = 0","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $test = GetIntrinsic('RegExp.prototype.test');\n\nvar callBind = require('call-bind');\n\nmodule.exports = function regexTester(regex) {\n\treturn callBind($test, regex);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/helpers/regexTester.js\n// module id = 105\n// module chunks = 0","'use strict';\n\nmodule.exports = function sign(number) {\n\treturn number >= 0 ? 1 : -1;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-abstract/helpers/sign.js\n// module id = 106\n// module chunks = 0","'use strict';\n\n/* eslint global-require: 0 */\n// the code is structured this way so that bundlers can\n// alias out `has-symbols` to `() => true` or `() => false` if your target\n// environments' Symbol capabilities are known, and then use\n// dead code elimination on the rest of this module.\n//\n// Similarly, `isarray` can be aliased to `Array.isArray` if\n// available in all target environments.\n\nvar isArguments = require('is-arguments');\n\nif (require('has-symbols')() || require('has-symbols/shams')()) {\n\tvar $iterator = Symbol.iterator;\n\t// Symbol is available natively or shammed\n\t// natively:\n\t//  - Chrome >= 38\n\t//  - Edge 12-14?, Edge >= 15 for sure\n\t//  - FF >= 36\n\t//  - Safari >= 9\n\t//  - node >= 0.12\n\tmodule.exports = function getIterator(iterable) {\n\t\t// alternatively, `iterable[$iterator]?.()`\n\t\tif (iterable != null && typeof iterable[$iterator] !== 'undefined') {\n\t\t\treturn iterable[$iterator]();\n\t\t}\n\t\tif (isArguments(iterable)) {\n\t\t\t// arguments objects lack Symbol.iterator\n\t\t\t// - node 0.12\n\t\t\treturn Array.prototype[$iterator].call(iterable);\n\t\t}\n\t};\n} else {\n\t// Symbol is not available, native or shammed\n\tvar isArray = require('isarray');\n\tvar isString = require('is-string');\n\tvar GetIntrinsic = require('get-intrinsic');\n\tvar $Map = GetIntrinsic('%Map%', true);\n\tvar $Set = GetIntrinsic('%Set%', true);\n\tvar callBound = require('call-bind/callBound');\n\tvar $arrayPush = callBound('Array.prototype.push');\n\tvar $charCodeAt = callBound('String.prototype.charCodeAt');\n\tvar $stringSlice = callBound('String.prototype.slice');\n\n\tvar advanceStringIndex = function advanceStringIndex(S, index) {\n\t\tvar length = S.length;\n\t\tif ((index + 1) >= length) {\n\t\t\treturn index + 1;\n\t\t}\n\n\t\tvar first = $charCodeAt(S, index);\n\t\tif (first < 0xD800 || first > 0xDBFF) {\n\t\t\treturn index + 1;\n\t\t}\n\n\t\tvar second = $charCodeAt(S, index + 1);\n\t\tif (second < 0xDC00 || second > 0xDFFF) {\n\t\t\treturn index + 1;\n\t\t}\n\n\t\treturn index + 2;\n\t};\n\n\tvar getArrayIterator = function getArrayIterator(arraylike) {\n\t\tvar i = 0;\n\t\treturn {\n\t\t\tnext: function next() {\n\t\t\t\tvar done = i >= arraylike.length;\n\t\t\t\tvar value;\n\t\t\t\tif (!done) {\n\t\t\t\t\tvalue = arraylike[i];\n\t\t\t\t\ti += 1;\n\t\t\t\t}\n\t\t\t\treturn {\n\t\t\t\t\tdone: done,\n\t\t\t\t\tvalue: value\n\t\t\t\t};\n\t\t\t}\n\t\t};\n\t};\n\n\tvar getNonCollectionIterator = function getNonCollectionIterator(iterable, noPrimordialCollections) {\n\t\tif (isArray(iterable) || isArguments(iterable)) {\n\t\t\treturn getArrayIterator(iterable);\n\t\t}\n\t\tif (isString(iterable)) {\n\t\t\tvar i = 0;\n\t\t\treturn {\n\t\t\t\tnext: function next() {\n\t\t\t\t\tvar nextIndex = advanceStringIndex(iterable, i);\n\t\t\t\t\tvar value = $stringSlice(iterable, i, nextIndex);\n\t\t\t\t\ti = nextIndex;\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: nextIndex > iterable.length,\n\t\t\t\t\t\tvalue: value\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\n\t\t// es6-shim and es-shims' es-map use a string \"_es6-shim iterator_\" property on different iterables, such as MapIterator.\n\t\tif (noPrimordialCollections && typeof iterable['_es6-shim iterator_'] !== 'undefined') {\n\t\t\treturn iterable['_es6-shim iterator_']();\n\t\t}\n\t};\n\n\tif (!$Map && !$Set) {\n\t\t// the only language iterables are Array, String, arguments\n\t\t// - Safari <= 6.0\n\t\t// - Chrome < 38\n\t\t// - node < 0.12\n\t\t// - FF < 13\n\t\t// - IE < 11\n\t\t// - Edge < 11\n\n\t\tmodule.exports = function getIterator(iterable) {\n\t\t\tif (iterable != null) {\n\t\t\t\treturn getNonCollectionIterator(iterable, true);\n\t\t\t}\n\t\t};\n\t} else {\n\t\t// either Map or Set are available, but Symbol is not\n\t\t// - es6-shim on an ES5 browser\n\t\t// - Safari 6.2 (maybe 6.1?)\n\t\t// - FF v[13, 36)\n\t\t// - IE 11\n\t\t// - Edge 11\n\t\t// - Safari v[6, 9)\n\n\t\tvar isMap = require('is-map');\n\t\tvar isSet = require('is-set');\n\n\t\t// Firefox >= 27, IE 11, Safari 6.2 - 9, Edge 11, es6-shim in older envs, all have forEach\n\t\tvar $mapForEach = callBound('Map.prototype.forEach', true);\n\t\tvar $setForEach = callBound('Set.prototype.forEach', true);\n\t\tif (typeof process === 'undefined' || !process.versions || !process.versions.node) { // \"if is not node\"\n\n\t\t\t// Firefox 17 - 26 has `.iterator()`, whose iterator `.next()` either\n\t\t\t// returns a value, or throws a StopIteration object. These browsers\n\t\t\t// do not have any other mechanism for iteration.\n\t\t\tvar $mapIterator = callBound('Map.prototype.iterator', true);\n\t\t\tvar $setIterator = callBound('Set.prototype.iterator', true);\n\t\t\tvar getStopIterationIterator = function (iterator) {\n\t\t\t\tvar done = false;\n\t\t\t\treturn {\n\t\t\t\t\tnext: function next() {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tdone: done,\n\t\t\t\t\t\t\t\tvalue: done ? undefined : iterator.next()\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\t\tdone = true;\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tdone: true,\n\t\t\t\t\t\t\t\tvalue: undefined\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\t\t}\n\t\t// Firefox 27-35, and some older es6-shim versions, use a string \"@@iterator\" property\n\t\t// this returns a proper iterator object, so we should use it instead of forEach.\n\t\t// newer es6-shim versions use a string \"_es6-shim iterator_\" property.\n\t\tvar $mapAtAtIterator = callBound('Map.prototype.@@iterator', true) || callBound('Map.prototype._es6-shim iterator_', true);\n\t\tvar $setAtAtIterator = callBound('Set.prototype.@@iterator', true) || callBound('Set.prototype._es6-shim iterator_', true);\n\n\t\tvar getCollectionIterator = function getCollectionIterator(iterable) {\n\t\t\tif (isMap(iterable)) {\n\t\t\t\tif ($mapIterator) {\n\t\t\t\t\treturn getStopIterationIterator($mapIterator(iterable));\n\t\t\t\t}\n\t\t\t\tif ($mapAtAtIterator) {\n\t\t\t\t\treturn $mapAtAtIterator(iterable);\n\t\t\t\t}\n\t\t\t\tif ($mapForEach) {\n\t\t\t\t\tvar entries = [];\n\t\t\t\t\t$mapForEach(iterable, function (v, k) {\n\t\t\t\t\t\t$arrayPush(entries, [k, v]);\n\t\t\t\t\t});\n\t\t\t\t\treturn getArrayIterator(entries);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (isSet(iterable)) {\n\t\t\t\tif ($setIterator) {\n\t\t\t\t\treturn getStopIterationIterator($setIterator(iterable));\n\t\t\t\t}\n\t\t\t\tif ($setAtAtIterator) {\n\t\t\t\t\treturn $setAtAtIterator(iterable);\n\t\t\t\t}\n\t\t\t\tif ($setForEach) {\n\t\t\t\t\tvar values = [];\n\t\t\t\t\t$setForEach(iterable, function (v) {\n\t\t\t\t\t\t$arrayPush(values, v);\n\t\t\t\t\t});\n\t\t\t\t\treturn getArrayIterator(values);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\tmodule.exports = function getIterator(iterable) {\n\t\t\treturn getCollectionIterator(iterable) || getNonCollectionIterator(iterable);\n\t\t};\n\t}\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-get-iterator/index.js\n// module id = 107\n// module chunks = 0","'use strict';\n\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';\n\nvar isPrimitive = require('./helpers/isPrimitive');\nvar isCallable = require('is-callable');\nvar isDate = require('is-date-object');\nvar isSymbol = require('is-symbol');\n\nvar ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {\n\tif (typeof O === 'undefined' || O === null) {\n\t\tthrow new TypeError('Cannot call method on ' + O);\n\t}\n\tif (typeof hint !== 'string' || (hint !== 'number' && hint !== 'string')) {\n\t\tthrow new TypeError('hint must be \"string\" or \"number\"');\n\t}\n\tvar methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString'];\n\tvar method, result, i;\n\tfor (i = 0; i < methodNames.length; ++i) {\n\t\tmethod = O[methodNames[i]];\n\t\tif (isCallable(method)) {\n\t\t\tresult = method.call(O);\n\t\t\tif (isPrimitive(result)) {\n\t\t\t\treturn result;\n\t\t\t}\n\t\t}\n\t}\n\tthrow new TypeError('No default value');\n};\n\nvar GetMethod = function GetMethod(O, P) {\n\tvar func = O[P];\n\tif (func !== null && typeof func !== 'undefined') {\n\t\tif (!isCallable(func)) {\n\t\t\tthrow new TypeError(func + ' returned for property ' + P + ' of object ' + O + ' is not a function');\n\t\t}\n\t\treturn func;\n\t}\n\treturn void 0;\n};\n\n// http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive\nmodule.exports = function ToPrimitive(input) {\n\tif (isPrimitive(input)) {\n\t\treturn input;\n\t}\n\tvar hint = 'default';\n\tif (arguments.length > 1) {\n\t\tif (arguments[1] === String) {\n\t\t\thint = 'string';\n\t\t} else if (arguments[1] === Number) {\n\t\t\thint = 'number';\n\t\t}\n\t}\n\n\tvar exoticToPrim;\n\tif (hasSymbols) {\n\t\tif (Symbol.toPrimitive) {\n\t\t\texoticToPrim = GetMethod(input, Symbol.toPrimitive);\n\t\t} else if (isSymbol(input)) {\n\t\t\texoticToPrim = Symbol.prototype.valueOf;\n\t\t}\n\t}\n\tif (typeof exoticToPrim !== 'undefined') {\n\t\tvar result = exoticToPrim.call(input, hint);\n\t\tif (isPrimitive(result)) {\n\t\t\treturn result;\n\t\t}\n\t\tthrow new TypeError('unable to convert exotic object to primitive');\n\t}\n\tif (hint === 'default' && (isDate(input) || isSymbol(input))) {\n\t\thint = 'string';\n\t}\n\treturn ordinaryToPrimitive(input, hint === 'default' ? 'number' : hint);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-to-primitive/es2015.js\n// module id = 108\n// module chunks = 0","'use strict';\n\nvar toStr = Object.prototype.toString;\n\nvar isPrimitive = require('./helpers/isPrimitive');\n\nvar isCallable = require('is-callable');\n\n// http://ecma-international.org/ecma-262/5.1/#sec-8.12.8\nvar ES5internalSlots = {\n\t'[[DefaultValue]]': function (O) {\n\t\tvar actualHint;\n\t\tif (arguments.length > 1) {\n\t\t\tactualHint = arguments[1];\n\t\t} else {\n\t\t\tactualHint = toStr.call(O) === '[object Date]' ? String : Number;\n\t\t}\n\n\t\tif (actualHint === String || actualHint === Number) {\n\t\t\tvar methods = actualHint === String ? ['toString', 'valueOf'] : ['valueOf', 'toString'];\n\t\t\tvar value, i;\n\t\t\tfor (i = 0; i < methods.length; ++i) {\n\t\t\t\tif (isCallable(O[methods[i]])) {\n\t\t\t\t\tvalue = O[methods[i]]();\n\t\t\t\t\tif (isPrimitive(value)) {\n\t\t\t\t\t\treturn value;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new TypeError('No default value');\n\t\t}\n\t\tthrow new TypeError('invalid [[DefaultValue]] hint supplied');\n\t}\n};\n\n// http://ecma-international.org/ecma-262/5.1/#sec-9.1\nmodule.exports = function ToPrimitive(input) {\n\tif (isPrimitive(input)) {\n\t\treturn input;\n\t}\n\tif (arguments.length > 1) {\n\t\treturn ES5internalSlots['[[DefaultValue]]'](input, arguments[1]);\n\t}\n\treturn ES5internalSlots['[[DefaultValue]]'](input);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es-to-primitive/es5.js\n// module id = 109\n// module chunks = 0","/*!\n * @overview es6-promise - a tiny implementation of Promises/A+.\n * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)\n * @license   Licensed under MIT license\n *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE\n * @version   v4.2.8+1e68dce6\n */\n\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n\ttypeof define === 'function' && define.amd ? define(factory) :\n\t(global.ES6Promise = factory());\n}(this, (function () { 'use strict';\n\nfunction objectOrFunction(x) {\n  var type = typeof x;\n  return x !== null && (type === 'object' || type === 'function');\n}\n\nfunction isFunction(x) {\n  return typeof x === 'function';\n}\n\n\n\nvar _isArray = void 0;\nif (Array.isArray) {\n  _isArray = Array.isArray;\n} else {\n  _isArray = function (x) {\n    return Object.prototype.toString.call(x) === '[object Array]';\n  };\n}\n\nvar isArray = _isArray;\n\nvar len = 0;\nvar vertxNext = void 0;\nvar customSchedulerFn = void 0;\n\nvar asap = function asap(callback, arg) {\n  queue[len] = callback;\n  queue[len + 1] = arg;\n  len += 2;\n  if (len === 2) {\n    // If len is 2, that means that we need to schedule an async flush.\n    // If additional callbacks are queued before the queue is flushed, they\n    // will be processed by this flush that we are scheduling.\n    if (customSchedulerFn) {\n      customSchedulerFn(flush);\n    } else {\n      scheduleFlush();\n    }\n  }\n};\n\nfunction setScheduler(scheduleFn) {\n  customSchedulerFn = scheduleFn;\n}\n\nfunction setAsap(asapFn) {\n  asap = asapFn;\n}\n\nvar browserWindow = typeof window !== 'undefined' ? window : undefined;\nvar browserGlobal = browserWindow || {};\nvar BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;\nvar isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';\n\n// test for web worker but not in IE10\nvar isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';\n\n// node\nfunction useNextTick() {\n  // node version 0.10.x displays a deprecation warning when nextTick is used recursively\n  // see https://github.com/cujojs/when/issues/410 for details\n  return function () {\n    return process.nextTick(flush);\n  };\n}\n\n// vertx\nfunction useVertxTimer() {\n  if (typeof vertxNext !== 'undefined') {\n    return function () {\n      vertxNext(flush);\n    };\n  }\n\n  return useSetTimeout();\n}\n\nfunction useMutationObserver() {\n  var iterations = 0;\n  var observer = new BrowserMutationObserver(flush);\n  var node = document.createTextNode('');\n  observer.observe(node, { characterData: true });\n\n  return function () {\n    node.data = iterations = ++iterations % 2;\n  };\n}\n\n// web worker\nfunction useMessageChannel() {\n  var channel = new MessageChannel();\n  channel.port1.onmessage = flush;\n  return function () {\n    return channel.port2.postMessage(0);\n  };\n}\n\nfunction useSetTimeout() {\n  // Store setTimeout reference so es6-promise will be unaffected by\n  // other code modifying setTimeout (like sinon.useFakeTimers())\n  var globalSetTimeout = setTimeout;\n  return function () {\n    return globalSetTimeout(flush, 1);\n  };\n}\n\nvar queue = new Array(1000);\nfunction flush() {\n  for (var i = 0; i < len; i += 2) {\n    var callback = queue[i];\n    var arg = queue[i + 1];\n\n    callback(arg);\n\n    queue[i] = undefined;\n    queue[i + 1] = undefined;\n  }\n\n  len = 0;\n}\n\nfunction attemptVertx() {\n  try {\n    var vertx = Function('return this')().require('vertx');\n    vertxNext = vertx.runOnLoop || vertx.runOnContext;\n    return useVertxTimer();\n  } catch (e) {\n    return useSetTimeout();\n  }\n}\n\nvar scheduleFlush = void 0;\n// Decide what async method to use to triggering processing of queued callbacks:\nif (isNode) {\n  scheduleFlush = useNextTick();\n} else if (BrowserMutationObserver) {\n  scheduleFlush = useMutationObserver();\n} else if (isWorker) {\n  scheduleFlush = useMessageChannel();\n} else if (browserWindow === undefined && typeof require === 'function') {\n  scheduleFlush = attemptVertx();\n} else {\n  scheduleFlush = useSetTimeout();\n}\n\nfunction then(onFulfillment, onRejection) {\n  var parent = this;\n\n  var child = new this.constructor(noop);\n\n  if (child[PROMISE_ID] === undefined) {\n    makePromise(child);\n  }\n\n  var _state = parent._state;\n\n\n  if (_state) {\n    var callback = arguments[_state - 1];\n    asap(function () {\n      return invokeCallback(_state, child, callback, parent._result);\n    });\n  } else {\n    subscribe(parent, child, onFulfillment, onRejection);\n  }\n\n  return child;\n}\n\n/**\n  `Promise.resolve` returns a promise that will become resolved with the\n  passed `value`. It is shorthand for the following:\n\n  ```javascript\n  let promise = new Promise(function(resolve, reject){\n    resolve(1);\n  });\n\n  promise.then(function(value){\n    // value === 1\n  });\n  ```\n\n  Instead of writing the above, your code now simply becomes the following:\n\n  ```javascript\n  let promise = Promise.resolve(1);\n\n  promise.then(function(value){\n    // value === 1\n  });\n  ```\n\n  @method resolve\n  @static\n  @param {Any} value value that the returned promise will be resolved with\n  Useful for tooling.\n  @return {Promise} a promise that will become fulfilled with the given\n  `value`\n*/\nfunction resolve$1(object) {\n  /*jshint validthis:true */\n  var Constructor = this;\n\n  if (object && typeof object === 'object' && object.constructor === Constructor) {\n    return object;\n  }\n\n  var promise = new Constructor(noop);\n  resolve(promise, object);\n  return promise;\n}\n\nvar PROMISE_ID = Math.random().toString(36).substring(2);\n\nfunction noop() {}\n\nvar PENDING = void 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\n\nfunction selfFulfillment() {\n  return new TypeError(\"You cannot resolve a promise with itself\");\n}\n\nfunction cannotReturnOwn() {\n  return new TypeError('A promises callback cannot return that same promise.');\n}\n\nfunction tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {\n  try {\n    then$$1.call(value, fulfillmentHandler, rejectionHandler);\n  } catch (e) {\n    return e;\n  }\n}\n\nfunction handleForeignThenable(promise, thenable, then$$1) {\n  asap(function (promise) {\n    var sealed = false;\n    var error = tryThen(then$$1, thenable, function (value) {\n      if (sealed) {\n        return;\n      }\n      sealed = true;\n      if (thenable !== value) {\n        resolve(promise, value);\n      } else {\n        fulfill(promise, value);\n      }\n    }, function (reason) {\n      if (sealed) {\n        return;\n      }\n      sealed = true;\n\n      reject(promise, reason);\n    }, 'Settle: ' + (promise._label || ' unknown promise'));\n\n    if (!sealed && error) {\n      sealed = true;\n      reject(promise, error);\n    }\n  }, promise);\n}\n\nfunction handleOwnThenable(promise, thenable) {\n  if (thenable._state === FULFILLED) {\n    fulfill(promise, thenable._result);\n  } else if (thenable._state === REJECTED) {\n    reject(promise, thenable._result);\n  } else {\n    subscribe(thenable, undefined, function (value) {\n      return resolve(promise, value);\n    }, function (reason) {\n      return reject(promise, reason);\n    });\n  }\n}\n\nfunction handleMaybeThenable(promise, maybeThenable, then$$1) {\n  if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {\n    handleOwnThenable(promise, maybeThenable);\n  } else {\n    if (then$$1 === undefined) {\n      fulfill(promise, maybeThenable);\n    } else if (isFunction(then$$1)) {\n      handleForeignThenable(promise, maybeThenable, then$$1);\n    } else {\n      fulfill(promise, maybeThenable);\n    }\n  }\n}\n\nfunction resolve(promise, value) {\n  if (promise === value) {\n    reject(promise, selfFulfillment());\n  } else if (objectOrFunction(value)) {\n    var then$$1 = void 0;\n    try {\n      then$$1 = value.then;\n    } catch (error) {\n      reject(promise, error);\n      return;\n    }\n    handleMaybeThenable(promise, value, then$$1);\n  } else {\n    fulfill(promise, value);\n  }\n}\n\nfunction publishRejection(promise) {\n  if (promise._onerror) {\n    promise._onerror(promise._result);\n  }\n\n  publish(promise);\n}\n\nfunction fulfill(promise, value) {\n  if (promise._state !== PENDING) {\n    return;\n  }\n\n  promise._result = value;\n  promise._state = FULFILLED;\n\n  if (promise._subscribers.length !== 0) {\n    asap(publish, promise);\n  }\n}\n\nfunction reject(promise, reason) {\n  if (promise._state !== PENDING) {\n    return;\n  }\n  promise._state = REJECTED;\n  promise._result = reason;\n\n  asap(publishRejection, promise);\n}\n\nfunction subscribe(parent, child, onFulfillment, onRejection) {\n  var _subscribers = parent._subscribers;\n  var length = _subscribers.length;\n\n\n  parent._onerror = null;\n\n  _subscribers[length] = child;\n  _subscribers[length + FULFILLED] = onFulfillment;\n  _subscribers[length + REJECTED] = onRejection;\n\n  if (length === 0 && parent._state) {\n    asap(publish, parent);\n  }\n}\n\nfunction publish(promise) {\n  var subscribers = promise._subscribers;\n  var settled = promise._state;\n\n  if (subscribers.length === 0) {\n    return;\n  }\n\n  var child = void 0,\n      callback = void 0,\n      detail = promise._result;\n\n  for (var i = 0; i < subscribers.length; i += 3) {\n    child = subscribers[i];\n    callback = subscribers[i + settled];\n\n    if (child) {\n      invokeCallback(settled, child, callback, detail);\n    } else {\n      callback(detail);\n    }\n  }\n\n  promise._subscribers.length = 0;\n}\n\nfunction invokeCallback(settled, promise, callback, detail) {\n  var hasCallback = isFunction(callback),\n      value = void 0,\n      error = void 0,\n      succeeded = true;\n\n  if (hasCallback) {\n    try {\n      value = callback(detail);\n    } catch (e) {\n      succeeded = false;\n      error = e;\n    }\n\n    if (promise === value) {\n      reject(promise, cannotReturnOwn());\n      return;\n    }\n  } else {\n    value = detail;\n  }\n\n  if (promise._state !== PENDING) {\n    // noop\n  } else if (hasCallback && succeeded) {\n    resolve(promise, value);\n  } else if (succeeded === false) {\n    reject(promise, error);\n  } else if (settled === FULFILLED) {\n    fulfill(promise, value);\n  } else if (settled === REJECTED) {\n    reject(promise, value);\n  }\n}\n\nfunction initializePromise(promise, resolver) {\n  try {\n    resolver(function resolvePromise(value) {\n      resolve(promise, value);\n    }, function rejectPromise(reason) {\n      reject(promise, reason);\n    });\n  } catch (e) {\n    reject(promise, e);\n  }\n}\n\nvar id = 0;\nfunction nextId() {\n  return id++;\n}\n\nfunction makePromise(promise) {\n  promise[PROMISE_ID] = id++;\n  promise._state = undefined;\n  promise._result = undefined;\n  promise._subscribers = [];\n}\n\nfunction validationError() {\n  return new Error('Array Methods must be provided an Array');\n}\n\nvar Enumerator = function () {\n  function Enumerator(Constructor, input) {\n    this._instanceConstructor = Constructor;\n    this.promise = new Constructor(noop);\n\n    if (!this.promise[PROMISE_ID]) {\n      makePromise(this.promise);\n    }\n\n    if (isArray(input)) {\n      this.length = input.length;\n      this._remaining = input.length;\n\n      this._result = new Array(this.length);\n\n      if (this.length === 0) {\n        fulfill(this.promise, this._result);\n      } else {\n        this.length = this.length || 0;\n        this._enumerate(input);\n        if (this._remaining === 0) {\n          fulfill(this.promise, this._result);\n        }\n      }\n    } else {\n      reject(this.promise, validationError());\n    }\n  }\n\n  Enumerator.prototype._enumerate = function _enumerate(input) {\n    for (var i = 0; this._state === PENDING && i < input.length; i++) {\n      this._eachEntry(input[i], i);\n    }\n  };\n\n  Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {\n    var c = this._instanceConstructor;\n    var resolve$$1 = c.resolve;\n\n\n    if (resolve$$1 === resolve$1) {\n      var _then = void 0;\n      var error = void 0;\n      var didError = false;\n      try {\n        _then = entry.then;\n      } catch (e) {\n        didError = true;\n        error = e;\n      }\n\n      if (_then === then && entry._state !== PENDING) {\n        this._settledAt(entry._state, i, entry._result);\n      } else if (typeof _then !== 'function') {\n        this._remaining--;\n        this._result[i] = entry;\n      } else if (c === Promise$1) {\n        var promise = new c(noop);\n        if (didError) {\n          reject(promise, error);\n        } else {\n          handleMaybeThenable(promise, entry, _then);\n        }\n        this._willSettleAt(promise, i);\n      } else {\n        this._willSettleAt(new c(function (resolve$$1) {\n          return resolve$$1(entry);\n        }), i);\n      }\n    } else {\n      this._willSettleAt(resolve$$1(entry), i);\n    }\n  };\n\n  Enumerator.prototype._settledAt = function _settledAt(state, i, value) {\n    var promise = this.promise;\n\n\n    if (promise._state === PENDING) {\n      this._remaining--;\n\n      if (state === REJECTED) {\n        reject(promise, value);\n      } else {\n        this._result[i] = value;\n      }\n    }\n\n    if (this._remaining === 0) {\n      fulfill(promise, this._result);\n    }\n  };\n\n  Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {\n    var enumerator = this;\n\n    subscribe(promise, undefined, function (value) {\n      return enumerator._settledAt(FULFILLED, i, value);\n    }, function (reason) {\n      return enumerator._settledAt(REJECTED, i, reason);\n    });\n  };\n\n  return Enumerator;\n}();\n\n/**\n  `Promise.all` accepts an array of promises, and returns a new promise which\n  is fulfilled with an array of fulfillment values for the passed promises, or\n  rejected with the reason of the first passed promise to be rejected. It casts all\n  elements of the passed iterable to promises as it runs this algorithm.\n\n  Example:\n\n  ```javascript\n  let promise1 = resolve(1);\n  let promise2 = resolve(2);\n  let promise3 = resolve(3);\n  let promises = [ promise1, promise2, promise3 ];\n\n  Promise.all(promises).then(function(array){\n    // The array here would be [ 1, 2, 3 ];\n  });\n  ```\n\n  If any of the `promises` given to `all` are rejected, the first promise\n  that is rejected will be given as an argument to the returned promises's\n  rejection handler. For example:\n\n  Example:\n\n  ```javascript\n  let promise1 = resolve(1);\n  let promise2 = reject(new Error(\"2\"));\n  let promise3 = reject(new Error(\"3\"));\n  let promises = [ promise1, promise2, promise3 ];\n\n  Promise.all(promises).then(function(array){\n    // Code here never runs because there are rejected promises!\n  }, function(error) {\n    // error.message === \"2\"\n  });\n  ```\n\n  @method all\n  @static\n  @param {Array} entries array of promises\n  @param {String} label optional string for labeling the promise.\n  Useful for tooling.\n  @return {Promise} promise that is fulfilled when all `promises` have been\n  fulfilled, or rejected if any of them become rejected.\n  @static\n*/\nfunction all(entries) {\n  return new Enumerator(this, entries).promise;\n}\n\n/**\n  `Promise.race` returns a new promise which is settled in the same way as the\n  first passed promise to settle.\n\n  Example:\n\n  ```javascript\n  let promise1 = new Promise(function(resolve, reject){\n    setTimeout(function(){\n      resolve('promise 1');\n    }, 200);\n  });\n\n  let promise2 = new Promise(function(resolve, reject){\n    setTimeout(function(){\n      resolve('promise 2');\n    }, 100);\n  });\n\n  Promise.race([promise1, promise2]).then(function(result){\n    // result === 'promise 2' because it was resolved before promise1\n    // was resolved.\n  });\n  ```\n\n  `Promise.race` is deterministic in that only the state of the first\n  settled promise matters. For example, even if other promises given to the\n  `promises` array argument are resolved, but the first settled promise has\n  become rejected before the other promises became fulfilled, the returned\n  promise will become rejected:\n\n  ```javascript\n  let promise1 = new Promise(function(resolve, reject){\n    setTimeout(function(){\n      resolve('promise 1');\n    }, 200);\n  });\n\n  let promise2 = new Promise(function(resolve, reject){\n    setTimeout(function(){\n      reject(new Error('promise 2'));\n    }, 100);\n  });\n\n  Promise.race([promise1, promise2]).then(function(result){\n    // Code here never runs\n  }, function(reason){\n    // reason.message === 'promise 2' because promise 2 became rejected before\n    // promise 1 became fulfilled\n  });\n  ```\n\n  An example real-world use case is implementing timeouts:\n\n  ```javascript\n  Promise.race([ajax('foo.json'), timeout(5000)])\n  ```\n\n  @method race\n  @static\n  @param {Array} promises array of promises to observe\n  Useful for tooling.\n  @return {Promise} a promise which settles in the same way as the first passed\n  promise to settle.\n*/\nfunction race(entries) {\n  /*jshint validthis:true */\n  var Constructor = this;\n\n  if (!isArray(entries)) {\n    return new Constructor(function (_, reject) {\n      return reject(new TypeError('You must pass an array to race.'));\n    });\n  } else {\n    return new Constructor(function (resolve, reject) {\n      var length = entries.length;\n      for (var i = 0; i < length; i++) {\n        Constructor.resolve(entries[i]).then(resolve, reject);\n      }\n    });\n  }\n}\n\n/**\n  `Promise.reject` returns a promise rejected with the passed `reason`.\n  It is shorthand for the following:\n\n  ```javascript\n  let promise = new Promise(function(resolve, reject){\n    reject(new Error('WHOOPS'));\n  });\n\n  promise.then(function(value){\n    // Code here doesn't run because the promise is rejected!\n  }, function(reason){\n    // reason.message === 'WHOOPS'\n  });\n  ```\n\n  Instead of writing the above, your code now simply becomes the following:\n\n  ```javascript\n  let promise = Promise.reject(new Error('WHOOPS'));\n\n  promise.then(function(value){\n    // Code here doesn't run because the promise is rejected!\n  }, function(reason){\n    // reason.message === 'WHOOPS'\n  });\n  ```\n\n  @method reject\n  @static\n  @param {Any} reason value that the returned promise will be rejected with.\n  Useful for tooling.\n  @return {Promise} a promise rejected with the given `reason`.\n*/\nfunction reject$1(reason) {\n  /*jshint validthis:true */\n  var Constructor = this;\n  var promise = new Constructor(noop);\n  reject(promise, reason);\n  return promise;\n}\n\nfunction needsResolver() {\n  throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');\n}\n\nfunction needsNew() {\n  throw new TypeError(\"Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.\");\n}\n\n/**\n  Promise objects represent the eventual result of an asynchronous operation. The\n  primary way of interacting with a promise is through its `then` method, which\n  registers callbacks to receive either a promise's eventual value or the reason\n  why the promise cannot be fulfilled.\n\n  Terminology\n  -----------\n\n  - `promise` is an object or function with a `then` method whose behavior conforms to this specification.\n  - `thenable` is an object or function that defines a `then` method.\n  - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).\n  - `exception` is a value that is thrown using the throw statement.\n  - `reason` is a value that indicates why a promise was rejected.\n  - `settled` the final resting state of a promise, fulfilled or rejected.\n\n  A promise can be in one of three states: pending, fulfilled, or rejected.\n\n  Promises that are fulfilled have a fulfillment value and are in the fulfilled\n  state.  Promises that are rejected have a rejection reason and are in the\n  rejected state.  A fulfillment value is never a thenable.\n\n  Promises can also be said to *resolve* a value.  If this value is also a\n  promise, then the original promise's settled state will match the value's\n  settled state.  So a promise that *resolves* a promise that rejects will\n  itself reject, and a promise that *resolves* a promise that fulfills will\n  itself fulfill.\n\n\n  Basic Usage:\n  ------------\n\n  ```js\n  let promise = new Promise(function(resolve, reject) {\n    // on success\n    resolve(value);\n\n    // on failure\n    reject(reason);\n  });\n\n  promise.then(function(value) {\n    // on fulfillment\n  }, function(reason) {\n    // on rejection\n  });\n  ```\n\n  Advanced Usage:\n  ---------------\n\n  Promises shine when abstracting away asynchronous interactions such as\n  `XMLHttpRequest`s.\n\n  ```js\n  function getJSON(url) {\n    return new Promise(function(resolve, reject){\n      let xhr = new XMLHttpRequest();\n\n      xhr.open('GET', url);\n      xhr.onreadystatechange = handler;\n      xhr.responseType = 'json';\n      xhr.setRequestHeader('Accept', 'application/json');\n      xhr.send();\n\n      function handler() {\n        if (this.readyState === this.DONE) {\n          if (this.status === 200) {\n            resolve(this.response);\n          } else {\n            reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));\n          }\n        }\n      };\n    });\n  }\n\n  getJSON('/posts.json').then(function(json) {\n    // on fulfillment\n  }, function(reason) {\n    // on rejection\n  });\n  ```\n\n  Unlike callbacks, promises are great composable primitives.\n\n  ```js\n  Promise.all([\n    getJSON('/posts'),\n    getJSON('/comments')\n  ]).then(function(values){\n    values[0] // => postsJSON\n    values[1] // => commentsJSON\n\n    return values;\n  });\n  ```\n\n  @class Promise\n  @param {Function} resolver\n  Useful for tooling.\n  @constructor\n*/\n\nvar Promise$1 = function () {\n  function Promise(resolver) {\n    this[PROMISE_ID] = nextId();\n    this._result = this._state = undefined;\n    this._subscribers = [];\n\n    if (noop !== resolver) {\n      typeof resolver !== 'function' && needsResolver();\n      this instanceof Promise ? initializePromise(this, resolver) : needsNew();\n    }\n  }\n\n  /**\n  The primary way of interacting with a promise is through its `then` method,\n  which registers callbacks to receive either a promise's eventual value or the\n  reason why the promise cannot be fulfilled.\n   ```js\n  findUser().then(function(user){\n    // user is available\n  }, function(reason){\n    // user is unavailable, and you are given the reason why\n  });\n  ```\n   Chaining\n  --------\n   The return value of `then` is itself a promise.  This second, 'downstream'\n  promise is resolved with the return value of the first promise's fulfillment\n  or rejection handler, or rejected if the handler throws an exception.\n   ```js\n  findUser().then(function (user) {\n    return user.name;\n  }, function (reason) {\n    return 'default name';\n  }).then(function (userName) {\n    // If `findUser` fulfilled, `userName` will be the user's name, otherwise it\n    // will be `'default name'`\n  });\n   findUser().then(function (user) {\n    throw new Error('Found user, but still unhappy');\n  }, function (reason) {\n    throw new Error('`findUser` rejected and we're unhappy');\n  }).then(function (value) {\n    // never reached\n  }, function (reason) {\n    // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.\n    // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.\n  });\n  ```\n  If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.\n   ```js\n  findUser().then(function (user) {\n    throw new PedagogicalException('Upstream error');\n  }).then(function (value) {\n    // never reached\n  }).then(function (value) {\n    // never reached\n  }, function (reason) {\n    // The `PedgagocialException` is propagated all the way down to here\n  });\n  ```\n   Assimilation\n  ------------\n   Sometimes the value you want to propagate to a downstream promise can only be\n  retrieved asynchronously. This can be achieved by returning a promise in the\n  fulfillment or rejection handler. The downstream promise will then be pending\n  until the returned promise is settled. This is called *assimilation*.\n   ```js\n  findUser().then(function (user) {\n    return findCommentsByAuthor(user);\n  }).then(function (comments) {\n    // The user's comments are now available\n  });\n  ```\n   If the assimliated promise rejects, then the downstream promise will also reject.\n   ```js\n  findUser().then(function (user) {\n    return findCommentsByAuthor(user);\n  }).then(function (comments) {\n    // If `findCommentsByAuthor` fulfills, we'll have the value here\n  }, function (reason) {\n    // If `findCommentsByAuthor` rejects, we'll have the reason here\n  });\n  ```\n   Simple Example\n  --------------\n   Synchronous Example\n   ```javascript\n  let result;\n   try {\n    result = findResult();\n    // success\n  } catch(reason) {\n    // failure\n  }\n  ```\n   Errback Example\n   ```js\n  findResult(function(result, err){\n    if (err) {\n      // failure\n    } else {\n      // success\n    }\n  });\n  ```\n   Promise Example;\n   ```javascript\n  findResult().then(function(result){\n    // success\n  }, function(reason){\n    // failure\n  });\n  ```\n   Advanced Example\n  --------------\n   Synchronous Example\n   ```javascript\n  let author, books;\n   try {\n    author = findAuthor();\n    books  = findBooksByAuthor(author);\n    // success\n  } catch(reason) {\n    // failure\n  }\n  ```\n   Errback Example\n   ```js\n   function foundBooks(books) {\n   }\n   function failure(reason) {\n   }\n   findAuthor(function(author, err){\n    if (err) {\n      failure(err);\n      // failure\n    } else {\n      try {\n        findBoooksByAuthor(author, function(books, err) {\n          if (err) {\n            failure(err);\n          } else {\n            try {\n              foundBooks(books);\n            } catch(reason) {\n              failure(reason);\n            }\n          }\n        });\n      } catch(error) {\n        failure(err);\n      }\n      // success\n    }\n  });\n  ```\n   Promise Example;\n   ```javascript\n  findAuthor().\n    then(findBooksByAuthor).\n    then(function(books){\n      // found books\n  }).catch(function(reason){\n    // something went wrong\n  });\n  ```\n   @method then\n  @param {Function} onFulfilled\n  @param {Function} onRejected\n  Useful for tooling.\n  @return {Promise}\n  */\n\n  /**\n  `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same\n  as the catch block of a try/catch statement.\n  ```js\n  function findAuthor(){\n  throw new Error('couldn't find that author');\n  }\n  // synchronous\n  try {\n  findAuthor();\n  } catch(reason) {\n  // something went wrong\n  }\n  // async with promises\n  findAuthor().catch(function(reason){\n  // something went wrong\n  });\n  ```\n  @method catch\n  @param {Function} onRejection\n  Useful for tooling.\n  @return {Promise}\n  */\n\n\n  Promise.prototype.catch = function _catch(onRejection) {\n    return this.then(null, onRejection);\n  };\n\n  /**\n    `finally` will be invoked regardless of the promise's fate just as native\n    try/catch/finally behaves\n  \n    Synchronous example:\n  \n    ```js\n    findAuthor() {\n      if (Math.random() > 0.5) {\n        throw new Error();\n      }\n      return new Author();\n    }\n  \n    try {\n      return findAuthor(); // succeed or fail\n    } catch(error) {\n      return findOtherAuther();\n    } finally {\n      // always runs\n      // doesn't affect the return value\n    }\n    ```\n  \n    Asynchronous example:\n  \n    ```js\n    findAuthor().catch(function(reason){\n      return findOtherAuther();\n    }).finally(function(){\n      // author was either found, or not\n    });\n    ```\n  \n    @method finally\n    @param {Function} callback\n    @return {Promise}\n  */\n\n\n  Promise.prototype.finally = function _finally(callback) {\n    var promise = this;\n    var constructor = promise.constructor;\n\n    if (isFunction(callback)) {\n      return promise.then(function (value) {\n        return constructor.resolve(callback()).then(function () {\n          return value;\n        });\n      }, function (reason) {\n        return constructor.resolve(callback()).then(function () {\n          throw reason;\n        });\n      });\n    }\n\n    return promise.then(callback, callback);\n  };\n\n  return Promise;\n}();\n\nPromise$1.prototype.then = then;\nPromise$1.all = all;\nPromise$1.race = race;\nPromise$1.resolve = resolve$1;\nPromise$1.reject = reject$1;\nPromise$1._setScheduler = setScheduler;\nPromise$1._setAsap = setAsap;\nPromise$1._asap = asap;\n\n/*global self*/\nfunction polyfill() {\n  var local = void 0;\n\n  if (typeof global !== 'undefined') {\n    local = global;\n  } else if (typeof self !== 'undefined') {\n    local = self;\n  } else {\n    try {\n      local = Function('return this')();\n    } catch (e) {\n      throw new Error('polyfill failed because global object is unavailable in this environment');\n    }\n  }\n\n  var P = local.Promise;\n\n  if (P) {\n    var promiseToString = null;\n    try {\n      promiseToString = Object.prototype.toString.call(P.resolve());\n    } catch (e) {\n      // silently ignored\n    }\n\n    if (promiseToString === '[object Promise]' && !P.cast) {\n      return;\n    }\n  }\n\n  local.Promise = Promise$1;\n}\n\n// Strange compat..\nPromise$1.polyfill = polyfill;\nPromise$1.Promise = Promise$1;\n\nreturn Promise$1;\n\n})));\n\n\n\n//# sourceMappingURL=es6-promise.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/es6-promise/dist/es6-promise.js\n// module id = 110\n// module chunks = 0","// removed by extract-text-webpack-plugin\nmodule.exports = {\"section--active\":\"nrk-filmavis-liersykehus-section--active\",\"sectionActive\":\"nrk-filmavis-liersykehus-section--active\",\"animate-pulsate\":\"nrk-filmavis-liersykehus-animate-pulsate\",\"animatePulsate\":\"nrk-filmavis-liersykehus-animate-pulsate\",\"pulsateAndRotate\":\"nrk-filmavis-liersykehus-pulsateAndRotate\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/shared/stylesheets/animations.css\n// module id = 111\n// module chunks = 0","// removed by extract-text-webpack-plugin\nmodule.exports = {\"intro-block\":\"nrk-filmavis-liersykehus-intro-block\",\"introBlock\":\"nrk-filmavis-liersykehus-intro-block\",\"section--ready\":\"nrk-filmavis-liersykehus-section--ready\",\"sectionReady\":\"nrk-filmavis-liersykehus-section--ready\",\"section--active\":\"nrk-filmavis-liersykehus-section--active\",\"sectionActive\":\"nrk-filmavis-liersykehus-section--active\",\"heading-block\":\"nrk-filmavis-liersykehus-heading-block\",\"headingBlock\":\"nrk-filmavis-liersykehus-heading-block\",\"block-textshadow\":\"nrk-filmavis-liersykehus-block-textshadow\",\"blockTextshadow\":\"nrk-filmavis-liersykehus-block-textshadow\",\"block\":\"nrk-filmavis-liersykehus-block\",\"block--shadow\":\"nrk-filmavis-liersykehus-block--shadow\",\"blockShadow\":\"nrk-filmavis-liersykehus-block--shadow\",\"block__right\":\"nrk-filmavis-liersykehus-block__right\",\"blockRight\":\"nrk-filmavis-liersykehus-block--right\",\"block__left\":\"nrk-filmavis-liersykehus-block__left\",\"blockLeft\":\"nrk-filmavis-liersykehus-block--left\",\"block__spaceAfter\":\"nrk-filmavis-liersykehus-block__spaceAfter\",\"blockSpaceAfter\":\"nrk-filmavis-liersykehus-block__spaceAfter\",\"block__lessPadding\":\"nrk-filmavis-liersykehus-block__lessPadding\",\"blockLessPadding\":\"nrk-filmavis-liersykehus-block__lessPadding\",\"block__map\":\"nrk-filmavis-liersykehus-block__map\",\"blockMap\":\"nrk-filmavis-liersykehus-block__map\",\"block__noMarginBottom\":\"nrk-filmavis-liersykehus-block__noMarginBottom\",\"blockNoMarginBottom\":\"nrk-filmavis-liersykehus-block__noMarginBottom\",\"block__lastBlock\":\"nrk-filmavis-liersykehus-block__lastBlock\",\"blockLastBlock\":\"nrk-filmavis-liersykehus-block__lastBlock\",\"block__full-width\":\"nrk-filmavis-liersykehus-block__full-width\",\"blockFullWidth\":\"nrk-filmavis-liersykehus-block__full-width\",\"block__inverse\":\"nrk-filmavis-liersykehus-block__inverse\",\"blockInverse\":\"nrk-filmavis-liersykehus-block__inverse\",\"blockquote\":\"nrk-filmavis-liersykehus-blockquote\",\"blockquote--sm\":\"nrk-filmavis-liersykehus-blockquote--sm\",\"blockquoteSm\":\"nrk-filmavis-liersykehus-blockquote--sm\",\"blockquote--regular\":\"nrk-filmavis-liersykehus-blockquote--regular\",\"blockquoteRegular\":\"nrk-filmavis-liersykehus-blockquote--regular\",\"blockquote--pullquote\":\"nrk-filmavis-liersykehus-blockquote--pullquote\",\"blockquotePullquote\":\"nrk-filmavis-liersykehus-blockquote--pullquote\",\"cite--fancy\":\"nrk-filmavis-liersykehus-cite--fancy\",\"citeFancy\":\"nrk-filmavis-liersykehus-cite--fancy\",\"block--no-bg\":\"nrk-filmavis-liersykehus-block--no-bg\",\"blockNoBg\":\"nrk-filmavis-liersykehus-block--no-bg\",\"block--big-font\":\"nrk-filmavis-liersykehus-block--big-font\",\"blockBigFont\":\"nrk-filmavis-liersykehus-block--big-font\",\"block--xl-font\":\"nrk-filmavis-liersykehus-block--xl-font\",\"blockXlFont\":\"nrk-filmavis-liersykehus-block--xl-font\",\"block--left\":\"nrk-filmavis-liersykehus-block--left\",\"block--right\":\"nrk-filmavis-liersykehus-block--right\",\"block--center\":\"nrk-filmavis-liersykehus-block--center\",\"blockCenter\":\"nrk-filmavis-liersykehus-block--center\",\"image\":\"nrk-filmavis-liersykehus-image\",\"bylinerole\":\"nrk-filmavis-liersykehus-bylinerole\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/shared/stylesheets/block.css\n// module id = 112\n// module chunks = 0","// removed by extract-text-webpack-plugin\nmodule.exports = {\"bylineSection\":\"nrk-filmavis-liersykehus-bylineSection\",\"byline--sharebutton--container\":\"nrk-filmavis-liersykehus-byline--sharebutton--container\",\"bylineSharebuttonContainer\":\"nrk-filmavis-liersykehus-byline--sharebutton--container\",\"byline--sharebutton--group\":\"nrk-filmavis-liersykehus-byline--sharebutton--group\",\"bylineSharebuttonGroup\":\"nrk-filmavis-liersykehus-byline--sharebutton--group\",\"byline--sharebutton--item\":\"nrk-filmavis-liersykehus-byline--sharebutton--item\",\"bylineSharebuttonItem\":\"nrk-filmavis-liersykehus-byline--sharebutton--item\",\"seemore--block\":\"nrk-filmavis-liersykehus-seemore--block\",\"seemoreBlock\":\"nrk-filmavis-liersykehus-seemore--block\",\"byline--block\":\"nrk-filmavis-liersykehus-byline--block\",\"bylineBlock\":\"nrk-filmavis-liersykehus-byline--block\",\"seemore--heading\":\"nrk-filmavis-liersykehus-seemore--heading\",\"seemoreHeading\":\"nrk-filmavis-liersykehus-seemore--heading\",\"seemore--heading-link\":\"nrk-filmavis-liersykehus-seemore--heading-link\",\"seemoreHeadingLink\":\"nrk-filmavis-liersykehus-seemore--heading-link\",\"seemore--link--list--wrapper\":\"nrk-filmavis-liersykehus-seemore--link--list--wrapper\",\"seemoreLinkListWrapper\":\"nrk-filmavis-liersykehus-seemore--link--list--wrapper\",\"seemore--link--list\":\"nrk-filmavis-liersykehus-seemore--link--list\",\"seemoreLinkList\":\"nrk-filmavis-liersykehus-seemore--link--list\",\"seemore--link--item\":\"nrk-filmavis-liersykehus-seemore--link--item\",\"seemoreLinkItem\":\"nrk-filmavis-liersykehus-seemore--link--item\",\"seemore--link--image\":\"nrk-filmavis-liersykehus-seemore--link--image\",\"seemoreLinkImage\":\"nrk-filmavis-liersykehus-seemore--link--image\",\"byline--credit--list\":\"nrk-filmavis-liersykehus-byline--credit--list\",\"bylineCreditList\":\"nrk-filmavis-liersykehus-byline--credit--list\",\"byline--credit--list--item\":\"nrk-filmavis-liersykehus-byline--credit--list--item\",\"bylineCreditListItem\":\"nrk-filmavis-liersykehus-byline--credit--list--item\",\"byline--credit--list--item--role\":\"nrk-filmavis-liersykehus-byline--credit--list--item--role\",\"bylineCreditListItemRole\":\"nrk-filmavis-liersykehus-byline--credit--list--item--role\",\"byline--credit--list--item--names\":\"nrk-filmavis-liersykehus-byline--credit--list--item--names\",\"bylineCreditListItemNames\":\"nrk-filmavis-liersykehus-byline--credit--list--item--names\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/shared/stylesheets/byline.css\n// module id = 113\n// module chunks = 0","// removed by extract-text-webpack-plugin\nmodule.exports = {\"fade\":\"nrk-filmavis-liersykehus-fade\",\"animate-into\":\"nrk-filmavis-liersykehus-animate-into\",\"animateInto\":\"nrk-filmavis-liersykehus-animate-into\",\"animate-away\":\"nrk-filmavis-liersykehus-animate-away\",\"animateAway\":\"nrk-filmavis-liersykehus-animate-away\",\"none\":\"nrk-filmavis-liersykehus-none\",\"actually-none\":\"nrk-filmavis-liersykehus-actually-none\",\"actuallyNone\":\"nrk-filmavis-liersykehus-actually-none\",\"blur\":\"nrk-filmavis-liersykehus-blur\",\"swipe\":\"nrk-filmavis-liersykehus-swipe\",\"swipe-left\":\"nrk-filmavis-liersykehus-swipe-left\",\"swipeLeft\":\"nrk-filmavis-liersykehus-swipe-left\",\"swipe-right\":\"nrk-filmavis-liersykehus-swipe-right\",\"swipeRight\":\"nrk-filmavis-liersykehus-swipe-right\",\"swipe-down\":\"nrk-filmavis-liersykehus-swipe-down\",\"swipeDown\":\"nrk-filmavis-liersykehus-swipe-down\",\"swipe-up\":\"nrk-filmavis-liersykehus-swipe-up\",\"swipeUp\":\"nrk-filmavis-liersykehus-swipe-up\",\"zoom\":\"nrk-filmavis-liersykehus-zoom\",\"zoom-in\":\"nrk-filmavis-liersykehus-zoom-in\",\"zoomIn\":\"nrk-filmavis-liersykehus-zoom-in\",\"zoom-out\":\"nrk-filmavis-liersykehus-zoom-out\",\"zoomOut\":\"nrk-filmavis-liersykehus-zoom-out\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/shared/stylesheets/transitions.css\n// module id = 114\n// module chunks = 0","'use strict';\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar slice = Array.prototype.slice;\nvar toStr = Object.prototype.toString;\nvar funcType = '[object Function]';\n\nmodule.exports = function bind(that) {\n    var target = this;\n    if (typeof target !== 'function' || toStr.call(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n    }\n    var args = slice.call(arguments, 1);\n\n    var bound;\n    var binder = function () {\n        if (this instanceof bound) {\n            var result = target.apply(\n                this,\n                args.concat(slice.call(arguments))\n            );\n            if (Object(result) === result) {\n                return result;\n            }\n            return this;\n        } else {\n            return target.apply(\n                that,\n                args.concat(slice.call(arguments))\n            );\n        }\n    };\n\n    var boundLength = Math.max(0, target.length - args.length);\n    var boundArgs = [];\n    for (var i = 0; i < boundLength; i++) {\n        boundArgs.push('$' + i);\n    }\n\n    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);\n\n    if (target.prototype) {\n        var Empty = function Empty() {};\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n    }\n\n    return bound;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/function-bind/implementation.js\n// module id = 115\n// module chunks = 0","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n * \n */\n\n(function(window, document) {\n'use strict';\n\n\n// Exits early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observering a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = entry.rootBounds;\n  this.boundingClientRect = entry.boundingClientRect;\n  this.intersectionRect = entry.intersectionRect || getEmptyRect();\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    this.intersectionRatio = intersectionArea / targetArea;\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (options.root && options.root.nodeType != 1) {\n    throw new Error('root must be an Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  // If the target is already being observed, do nothing.\n  if (this._observationTargets.some(function(item) {\n    return item.element == target;\n  })) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections();\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n\n    return item.element != target;\n  });\n  if (!this._observationTargets.length) {\n    this._unmonitorIntersections();\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibilty state is visible.\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function() {\n  if (!this._monitoringIntersections) {\n    this._monitoringIntersections = true;\n\n    // If a poll interval is set, use polling instead of listening to\n    // resize and scroll events or DOM mutations.\n    if (this.POLL_INTERVAL) {\n      this._monitoringInterval = setInterval(\n          this._checkForIntersections, this.POLL_INTERVAL);\n    }\n    else {\n      addEvent(window, 'resize', this._checkForIntersections, true);\n      addEvent(document, 'scroll', this._checkForIntersections, true);\n\n      if ('MutationObserver' in window) {\n        this._domObserver = new MutationObserver(this._checkForIntersections);\n        this._domObserver.observe(document, {\n          attributes: true,\n          childList: true,\n          characterData: true,\n          subtree: true\n        });\n      }\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function() {\n  if (this._monitoringIntersections) {\n    this._monitoringIntersections = false;\n\n    clearInterval(this._monitoringInterval);\n    this._monitoringInterval = null;\n\n    removeEvent(window, 'resize', this._checkForIntersections, true);\n    removeEvent(document, 'scroll', this._checkForIntersections, true);\n\n    if (this._domObserver) {\n      this._domObserver.disconnect();\n      this._domObserver = null;\n    }\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, rootRect);\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootRect,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, rootRect) {\n\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var targetRect = getBoundingClientRect(target);\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return;\n\n    if (parent == this.root || parent == document) {\n      atRoot = true;\n      parentRect = rootRect;\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      if (parent != document.body &&\n          parent != document.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n\n      if (!intersectionRect) break;\n    }\n    parent = getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {Object} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var html = document.documentElement;\n    var body = document.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {Object} rect The rect object to expand.\n * @return {Object} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  return containsDeep(this.root || document, target);\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its executiong, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detatchEvent == 'function') {\n    node.detatchEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object} The intersection rect or undefined if no intersection\n *     is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  };\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {Object} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {Object} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n/**\n * Checks to see if a parent element contains a child elemnt (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n  return parent;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}(window, document));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/intersection-observer/intersection-observer.js\n// module id = 116\n// module chunks = 0","'use strict';\n\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\n\nvar isStandardArguments = function isArguments(value) {\n\tif (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {\n\t\treturn false;\n\t}\n\treturn $toString(value) === '[object Arguments]';\n};\n\nvar isLegacyArguments = function isArguments(value) {\n\tif (isStandardArguments(value)) {\n\t\treturn true;\n\t}\n\treturn value !== null &&\n\t\ttypeof value === 'object' &&\n\t\ttypeof value.length === 'number' &&\n\t\tvalue.length >= 0 &&\n\t\t$toString(value) !== '[object Array]' &&\n\t\t$toString(value.callee) === '[object Function]';\n};\n\nvar supportsStandardArguments = (function () {\n\treturn isStandardArguments(arguments);\n}());\n\nisStandardArguments.isLegacyArguments = isLegacyArguments; // for tests\n\nmodule.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-arguments/index.js\n// module id = 117\n// module chunks = 0","'use strict';\n\nvar getDay = Date.prototype.getDay;\nvar tryDateObject = function tryDateGetDayCall(value) {\n\ttry {\n\t\tgetDay.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nvar toStr = Object.prototype.toString;\nvar dateClass = '[object Date]';\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nmodule.exports = function isDateObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\treturn hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-date-object/index.js\n// module id = 118\n// module chunks = 0","'use strict';\n\nvar $Map = typeof Map === 'function' && Map.prototype ? Map : null;\nvar $Set = typeof Set === 'function' && Set.prototype ? Set : null;\n\nvar exported;\n\nif (!$Map) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isMap(x) {\n\t\t// `Map` is not present in this environment.\n\t\treturn false;\n\t};\n}\n\nvar $mapHas = $Map ? Map.prototype.has : null;\nvar $setHas = $Set ? Set.prototype.has : null;\nif (!exported && !$mapHas) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isMap(x) {\n\t\t// `Map` does not have a `has` method\n\t\treturn false;\n\t};\n}\n\nmodule.exports = exported || function isMap(x) {\n\tif (!x || typeof x !== 'object') {\n\t\treturn false;\n\t}\n\ttry {\n\t\t$mapHas.call(x);\n\t\tif ($setHas) {\n\t\t\ttry {\n\t\t\t\t$setHas.call(x);\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn x instanceof $Map; // core-js workaround, pre-v2.5.0\n\t} catch (e) {}\n\treturn false;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-map/index.js\n// module id = 119\n// module chunks = 0","'use strict';\n\nvar callBound = require('call-bind/callBound');\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar has;\nvar $exec;\nvar isRegexMarker;\nvar badStringifier;\n\nif (hasToStringTag) {\n\thas = callBound('Object.prototype.hasOwnProperty');\n\t$exec = callBound('RegExp.prototype.exec');\n\tisRegexMarker = {};\n\n\tvar throwRegexMarker = function () {\n\t\tthrow isRegexMarker;\n\t};\n\tbadStringifier = {\n\t\ttoString: throwRegexMarker,\n\t\tvalueOf: throwRegexMarker\n\t};\n\n\tif (typeof Symbol.toPrimitive === 'symbol') {\n\t\tbadStringifier[Symbol.toPrimitive] = throwRegexMarker;\n\t}\n}\n\nvar $toString = callBound('Object.prototype.toString');\nvar gOPD = Object.getOwnPropertyDescriptor;\nvar regexClass = '[object RegExp]';\n\nmodule.exports = hasToStringTag\n\t// eslint-disable-next-line consistent-return\n\t? function isRegex(value) {\n\t\tif (!value || typeof value !== 'object') {\n\t\t\treturn false;\n\t\t}\n\n\t\tvar descriptor = gOPD(value, 'lastIndex');\n\t\tvar hasLastIndexDataProperty = descriptor && has(descriptor, 'value');\n\t\tif (!hasLastIndexDataProperty) {\n\t\t\treturn false;\n\t\t}\n\n\t\ttry {\n\t\t\t$exec(value, badStringifier);\n\t\t} catch (e) {\n\t\t\treturn e === isRegexMarker;\n\t\t}\n\t}\n\t: function isRegex(value) {\n\t\t// In older browsers, typeof regex incorrectly returns 'function'\n\t\tif (!value || (typeof value !== 'object' && typeof value !== 'function')) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn $toString(value) === regexClass;\n\t};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-regex/index.js\n// module id = 120\n// module chunks = 0","'use strict';\n\nvar $Map = typeof Map === 'function' && Map.prototype ? Map : null;\nvar $Set = typeof Set === 'function' && Set.prototype ? Set : null;\n\nvar exported;\n\nif (!$Set) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isSet(x) {\n\t\t// `Set` is not present in this environment.\n\t\treturn false;\n\t};\n}\n\nvar $mapHas = $Map ? Map.prototype.has : null;\nvar $setHas = $Set ? Set.prototype.has : null;\nif (!exported && !$setHas) {\n\t// eslint-disable-next-line no-unused-vars\n\texported = function isSet(x) {\n\t\t// `Set` does not have a `has` method\n\t\treturn false;\n\t};\n}\n\nmodule.exports = exported || function isSet(x) {\n\tif (!x || typeof x !== 'object') {\n\t\treturn false;\n\t}\n\ttry {\n\t\t$setHas.call(x);\n\t\tif ($mapHas) {\n\t\t\ttry {\n\t\t\t\t$mapHas.call(x);\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn x instanceof $Set; // core-js workaround, pre-v2.5.0\n\t} catch (e) {}\n\treturn false;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-set/index.js\n// module id = 121\n// module chunks = 0","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar hasSymbols = require('has-symbols')();\n\nif (hasSymbols) {\n\tvar symToStr = Symbol.prototype.toString;\n\tvar symStringRegex = /^Symbol\\(.*\\)$/;\n\tvar isSymbolObject = function isRealSymbolObject(value) {\n\t\tif (typeof value.valueOf() !== 'symbol') {\n\t\t\treturn false;\n\t\t}\n\t\treturn symStringRegex.test(symToStr.call(value));\n\t};\n\n\tmodule.exports = function isSymbol(value) {\n\t\tif (typeof value === 'symbol') {\n\t\t\treturn true;\n\t\t}\n\t\tif (toStr.call(value) !== '[object Symbol]') {\n\t\t\treturn false;\n\t\t}\n\t\ttry {\n\t\t\treturn isSymbolObject(value);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n} else {\n\n\tmodule.exports = function isSymbol(value) {\n\t\t// this environment does not support Symbols.\n\t\treturn false && value;\n\t};\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-symbol/index.js\n// module id = 122\n// module chunks = 0","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/isarray/index.js\n// module id = 123\n// module chunks = 0","'use strict';\n\nvar $TypeError = TypeError;\n\n// eslint-disable-next-line consistent-return\nmodule.exports = function iterateIterator(iterator) {\n\tif (!iterator || typeof iterator.next !== 'function') {\n\t\tthrow new $TypeError('iterator must be an object with a `next` method');\n\t}\n\tif (arguments.length > 1) {\n\t\tvar callback = arguments[1];\n\t\tif (typeof callback !== 'function') {\n\t\t\tthrow new $TypeError('`callback`, if provided, must be a function');\n\t\t}\n\t}\n\tvar values = callback || [];\n\tvar result;\n\twhile ((result = iterator.next()) && !result.done) {\n\t\tif (callback) {\n\t\t\tcallback(result.value); // eslint-disable-line callback-return\n\t\t} else {\n\t\t\tvalues.push(result.value);\n\t\t}\n\t}\n\tif (!callback) {\n\t\treturn values;\n\t}\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/iterate-iterator/index.js\n// module id = 124\n// module chunks = 0","'use strict';\n\nvar getIterator = require('es-get-iterator');\nvar $TypeError = TypeError;\nvar iterate = require('iterate-iterator');\n\nmodule.exports = function iterateValue(iterable) {\n\tvar iterator = getIterator(iterable);\n\tif (!iterator) {\n\t\tthrow new $TypeError('non-iterable value provided');\n\t}\n\tif (arguments.length > 1) {\n\t\treturn iterate(iterator, arguments[1]);\n\t}\n\treturn iterate(iterator);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/iterate-value/index.js\n// module id = 125\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// ./~/lodash/_baseGetTag.js\n// module id = 126\n// module chunks = 0","var trimmedEndIndex = require('./_trimmedEndIndex');\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nmodule.exports = baseTrim;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseTrim.js\n// module id = 127\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// ./~/lodash/_freeGlobal.js\n// module id = 128\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// ./~/lodash/_getRawTag.js\n// module id = 129\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// ./~/lodash/_objectToString.js\n// module id = 130\n// module chunks = 0","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nmodule.exports = trimmedEndIndex;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_trimmedEndIndex.js\n// module id = 131\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// ./~/lodash/isObjectLike.js\n// module id = 132\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or 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 a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isSymbol.js\n// module id = 133\n// module chunks = 0","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/now.js\n// module id = 134\n// module chunks = 0","var baseTrim = require('./_baseTrim'),\n    isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/toNumber.js\n// module id = 135\n// module chunks = 0","var hasMap = typeof Map === 'function' && Map.prototype;\nvar mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;\nvar mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;\nvar mapForEach = hasMap && Map.prototype.forEach;\nvar hasSet = typeof Set === 'function' && Set.prototype;\nvar setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;\nvar setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;\nvar setForEach = hasSet && Set.prototype.forEach;\nvar hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;\nvar weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;\nvar hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;\nvar weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;\nvar hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;\nvar weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;\nvar booleanValueOf = Boolean.prototype.valueOf;\nvar objectToString = Object.prototype.toString;\nvar functionToString = Function.prototype.toString;\nvar $match = String.prototype.match;\nvar $slice = String.prototype.slice;\nvar $replace = String.prototype.replace;\nvar $toUpperCase = String.prototype.toUpperCase;\nvar $toLowerCase = String.prototype.toLowerCase;\nvar $test = RegExp.prototype.test;\nvar $concat = Array.prototype.concat;\nvar $join = Array.prototype.join;\nvar $arrSlice = Array.prototype.slice;\nvar $floor = Math.floor;\nvar bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;\nvar gOPS = Object.getOwnPropertySymbols;\nvar symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;\nvar hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object';\n// ie, `has-tostringtag/shams\nvar toStringTag = typeof Symbol === 'function' && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? 'object' : 'symbol')\n    ? Symbol.toStringTag\n    : null;\nvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\nvar gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) || (\n    [].__proto__ === Array.prototype // eslint-disable-line no-proto\n        ? function (O) {\n            return O.__proto__; // eslint-disable-line no-proto\n        }\n        : null\n);\n\nfunction addNumericSeparator(num, str) {\n    if (\n        num === Infinity\n        || num === -Infinity\n        || num !== num\n        || (num && num > -1000 && num < 1000)\n        || $test.call(/e/, str)\n    ) {\n        return str;\n    }\n    var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;\n    if (typeof num === 'number') {\n        var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)\n        if (int !== num) {\n            var intStr = String(int);\n            var dec = $slice.call(str, intStr.length + 1);\n            return $replace.call(intStr, sepRegex, '$&_') + '.' + $replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, '');\n        }\n    }\n    return $replace.call(str, sepRegex, '$&_');\n}\n\nvar inspectCustom = require('./util.inspect').custom;\nvar inspectSymbol = inspectCustom && isSymbol(inspectCustom) ? inspectCustom : null;\n\nmodule.exports = function inspect_(obj, options, depth, seen) {\n    var opts = options || {};\n\n    if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) {\n        throw new TypeError('option \"quoteStyle\" must be \"single\" or \"double\"');\n    }\n    if (\n        has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'\n            ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity\n            : opts.maxStringLength !== null\n        )\n    ) {\n        throw new TypeError('option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`');\n    }\n    var customInspect = has(opts, 'customInspect') ? opts.customInspect : true;\n    if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {\n        throw new TypeError('option \"customInspect\", if provided, must be `true`, `false`, or `\\'symbol\\'`');\n    }\n\n    if (\n        has(opts, 'indent')\n        && opts.indent !== null\n        && opts.indent !== '\\t'\n        && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)\n    ) {\n        throw new TypeError('option \"indent\" must be \"\\\\t\", an integer > 0, or `null`');\n    }\n    if (has(opts, 'numericSeparator') && typeof opts.numericSeparator !== 'boolean') {\n        throw new TypeError('option \"numericSeparator\", if provided, must be `true` or `false`');\n    }\n    var numericSeparator = opts.numericSeparator;\n\n    if (typeof obj === 'undefined') {\n        return 'undefined';\n    }\n    if (obj === null) {\n        return 'null';\n    }\n    if (typeof obj === 'boolean') {\n        return obj ? 'true' : 'false';\n    }\n\n    if (typeof obj === 'string') {\n        return inspectString(obj, opts);\n    }\n    if (typeof obj === 'number') {\n        if (obj === 0) {\n            return Infinity / obj > 0 ? '0' : '-0';\n        }\n        var str = String(obj);\n        return numericSeparator ? addNumericSeparator(obj, str) : str;\n    }\n    if (typeof obj === 'bigint') {\n        var bigIntStr = String(obj) + 'n';\n        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;\n    }\n\n    var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;\n    if (typeof depth === 'undefined') { depth = 0; }\n    if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {\n        return isArray(obj) ? '[Array]' : '[Object]';\n    }\n\n    var indent = getIndent(opts, depth);\n\n    if (typeof seen === 'undefined') {\n        seen = [];\n    } else if (indexOf(seen, obj) >= 0) {\n        return '[Circular]';\n    }\n\n    function inspect(value, from, noIndent) {\n        if (from) {\n            seen = $arrSlice.call(seen);\n            seen.push(from);\n        }\n        if (noIndent) {\n            var newOpts = {\n                depth: opts.depth\n            };\n            if (has(opts, 'quoteStyle')) {\n                newOpts.quoteStyle = opts.quoteStyle;\n            }\n            return inspect_(value, newOpts, depth + 1, seen);\n        }\n        return inspect_(value, opts, depth + 1, seen);\n    }\n\n    if (typeof obj === 'function') {\n        var name = nameOf(obj);\n        var keys = arrObjKeys(obj, inspect);\n        return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : '');\n    }\n    if (isSymbol(obj)) {\n        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\\(.*\\))_[^)]*$/, '$1') : symToString.call(obj);\n        return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString;\n    }\n    if (isElement(obj)) {\n        var s = '<' + $toLowerCase.call(String(obj.nodeName));\n        var attrs = obj.attributes || [];\n        for (var i = 0; i < attrs.length; i++) {\n            s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);\n        }\n        s += '>';\n        if (obj.childNodes && obj.childNodes.length) { s += '...'; }\n        s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>';\n        return s;\n    }\n    if (isArray(obj)) {\n        if (obj.length === 0) { return '[]'; }\n        var xs = arrObjKeys(obj, inspect);\n        if (indent && !singleLineValues(xs)) {\n            return '[' + indentedJoin(xs, indent) + ']';\n        }\n        return '[ ' + $join.call(xs, ', ') + ' ]';\n    }\n    if (isError(obj)) {\n        var parts = arrObjKeys(obj, inspect);\n        if ('cause' in obj && !isEnumerable.call(obj, 'cause')) {\n            return '{ [' + String(obj) + '] ' + $join.call($concat.call('[cause]: ' + inspect(obj.cause), parts), ', ') + ' }';\n        }\n        if (parts.length === 0) { return '[' + String(obj) + ']'; }\n        return '{ [' + String(obj) + '] ' + $join.call(parts, ', ') + ' }';\n    }\n    if (typeof obj === 'object' && customInspect) {\n        if (inspectSymbol && typeof obj[inspectSymbol] === 'function') {\n            return obj[inspectSymbol]();\n        } else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') {\n            return obj.inspect();\n        }\n    }\n    if (isMap(obj)) {\n        var mapParts = [];\n        mapForEach.call(obj, function (value, key) {\n            mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));\n        });\n        return collectionOf('Map', mapSize.call(obj), mapParts, indent);\n    }\n    if (isSet(obj)) {\n        var setParts = [];\n        setForEach.call(obj, function (value) {\n            setParts.push(inspect(value, obj));\n        });\n        return collectionOf('Set', setSize.call(obj), setParts, indent);\n    }\n    if (isWeakMap(obj)) {\n        return weakCollectionOf('WeakMap');\n    }\n    if (isWeakSet(obj)) {\n        return weakCollectionOf('WeakSet');\n    }\n    if (isWeakRef(obj)) {\n        return weakCollectionOf('WeakRef');\n    }\n    if (isNumber(obj)) {\n        return markBoxed(inspect(Number(obj)));\n    }\n    if (isBigInt(obj)) {\n        return markBoxed(inspect(bigIntValueOf.call(obj)));\n    }\n    if (isBoolean(obj)) {\n        return markBoxed(booleanValueOf.call(obj));\n    }\n    if (isString(obj)) {\n        return markBoxed(inspect(String(obj)));\n    }\n    if (!isDate(obj) && !isRegExp(obj)) {\n        var ys = arrObjKeys(obj, inspect);\n        var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;\n        var protoTag = obj instanceof Object ? '' : 'null prototype';\n        var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? 'Object' : '';\n        var constructorTag = isPlainObject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';\n        var tag = constructorTag + (stringTag || protoTag ? '[' + $join.call($concat.call([], stringTag || [], protoTag || []), ': ') + '] ' : '');\n        if (ys.length === 0) { return tag + '{}'; }\n        if (indent) {\n            return tag + '{' + indentedJoin(ys, indent) + '}';\n        }\n        return tag + '{ ' + $join.call(ys, ', ') + ' }';\n    }\n    return String(obj);\n};\n\nfunction wrapQuotes(s, defaultStyle, opts) {\n    var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '\"' : \"'\";\n    return quoteChar + s + quoteChar;\n}\n\nfunction quote(s) {\n    return $replace.call(String(s), /\"/g, '&quot;');\n}\n\nfunction isArray(obj) { return toStr(obj) === '[object Array]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isDate(obj) { return toStr(obj) === '[object Date]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isRegExp(obj) { return toStr(obj) === '[object RegExp]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isError(obj) { return toStr(obj) === '[object Error]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isString(obj) { return toStr(obj) === '[object String]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isNumber(obj) { return toStr(obj) === '[object Number]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\nfunction isBoolean(obj) { return toStr(obj) === '[object Boolean]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }\n\n// Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives\nfunction isSymbol(obj) {\n    if (hasShammedSymbols) {\n        return obj && typeof obj === 'object' && obj instanceof Symbol;\n    }\n    if (typeof obj === 'symbol') {\n        return true;\n    }\n    if (!obj || typeof obj !== 'object' || !symToString) {\n        return false;\n    }\n    try {\n        symToString.call(obj);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nfunction isBigInt(obj) {\n    if (!obj || typeof obj !== 'object' || !bigIntValueOf) {\n        return false;\n    }\n    try {\n        bigIntValueOf.call(obj);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nvar hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };\nfunction has(obj, key) {\n    return hasOwn.call(obj, key);\n}\n\nfunction toStr(obj) {\n    return objectToString.call(obj);\n}\n\nfunction nameOf(f) {\n    if (f.name) { return f.name; }\n    var m = $match.call(functionToString.call(f), /^function\\s*([\\w$]+)/);\n    if (m) { return m[1]; }\n    return null;\n}\n\nfunction indexOf(xs, x) {\n    if (xs.indexOf) { return xs.indexOf(x); }\n    for (var i = 0, l = xs.length; i < l; i++) {\n        if (xs[i] === x) { return i; }\n    }\n    return -1;\n}\n\nfunction isMap(x) {\n    if (!mapSize || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        mapSize.call(x);\n        try {\n            setSize.call(x);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof Map; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakMap(x) {\n    if (!weakMapHas || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakMapHas.call(x, weakMapHas);\n        try {\n            weakSetHas.call(x, weakSetHas);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof WeakMap; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakRef(x) {\n    if (!weakRefDeref || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakRefDeref.call(x);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nfunction isSet(x) {\n    if (!setSize || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        setSize.call(x);\n        try {\n            mapSize.call(x);\n        } catch (m) {\n            return true;\n        }\n        return x instanceof Set; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakSet(x) {\n    if (!weakSetHas || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakSetHas.call(x, weakSetHas);\n        try {\n            weakMapHas.call(x, weakMapHas);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof WeakSet; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isElement(x) {\n    if (!x || typeof x !== 'object') { return false; }\n    if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {\n        return true;\n    }\n    return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';\n}\n\nfunction inspectString(str, opts) {\n    if (str.length > opts.maxStringLength) {\n        var remaining = str.length - opts.maxStringLength;\n        var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');\n        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;\n    }\n    // eslint-disable-next-line no-control-regex\n    var s = $replace.call($replace.call(str, /(['\\\\])/g, '\\\\$1'), /[\\x00-\\x1f]/g, lowbyte);\n    return wrapQuotes(s, 'single', opts);\n}\n\nfunction lowbyte(c) {\n    var n = c.charCodeAt(0);\n    var x = {\n        8: 'b',\n        9: 't',\n        10: 'n',\n        12: 'f',\n        13: 'r'\n    }[n];\n    if (x) { return '\\\\' + x; }\n    return '\\\\x' + (n < 0x10 ? '0' : '') + $toUpperCase.call(n.toString(16));\n}\n\nfunction markBoxed(str) {\n    return 'Object(' + str + ')';\n}\n\nfunction weakCollectionOf(type) {\n    return type + ' { ? }';\n}\n\nfunction collectionOf(type, size, entries, indent) {\n    var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ', ');\n    return type + ' (' + size + ') {' + joinedEntries + '}';\n}\n\nfunction singleLineValues(xs) {\n    for (var i = 0; i < xs.length; i++) {\n        if (indexOf(xs[i], '\\n') >= 0) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction getIndent(opts, depth) {\n    var baseIndent;\n    if (opts.indent === '\\t') {\n        baseIndent = '\\t';\n    } else if (typeof opts.indent === 'number' && opts.indent > 0) {\n        baseIndent = $join.call(Array(opts.indent + 1), ' ');\n    } else {\n        return null;\n    }\n    return {\n        base: baseIndent,\n        prev: $join.call(Array(depth + 1), baseIndent)\n    };\n}\n\nfunction indentedJoin(xs, indent) {\n    if (xs.length === 0) { return ''; }\n    var lineJoiner = '\\n' + indent.prev + indent.base;\n    return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\\n' + indent.prev;\n}\n\nfunction arrObjKeys(obj, inspect) {\n    var isArr = isArray(obj);\n    var xs = [];\n    if (isArr) {\n        xs.length = obj.length;\n        for (var i = 0; i < obj.length; i++) {\n            xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';\n        }\n    }\n    var syms = typeof gOPS === 'function' ? gOPS(obj) : [];\n    var symMap;\n    if (hasShammedSymbols) {\n        symMap = {};\n        for (var k = 0; k < syms.length; k++) {\n            symMap['$' + syms[k]] = syms[k];\n        }\n    }\n\n    for (var key in obj) { // eslint-disable-line no-restricted-syntax\n        if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue\n        if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue\n        if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {\n            // this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section\n            continue; // eslint-disable-line no-restricted-syntax, no-continue\n        } else if ($test.call(/[^\\w$]/, key)) {\n            xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));\n        } else {\n            xs.push(key + ': ' + inspect(obj[key], obj));\n        }\n    }\n    if (typeof gOPS === 'function') {\n        for (var j = 0; j < syms.length; j++) {\n            if (isEnumerable.call(obj, syms[j])) {\n                xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));\n            }\n        }\n    }\n    return xs;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/object-inspect/index.js\n// module id = 136\n// module chunks = 0","'use strict';\n\nvar keysShim;\nif (!Object.keys) {\n\t// modified from https://github.com/es-shims/es5-shim\n\tvar has = Object.prototype.hasOwnProperty;\n\tvar toStr = Object.prototype.toString;\n\tvar isArgs = require('./isArguments'); // eslint-disable-line global-require\n\tvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\tvar hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');\n\tvar hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');\n\tvar dontEnums = [\n\t\t'toString',\n\t\t'toLocaleString',\n\t\t'valueOf',\n\t\t'hasOwnProperty',\n\t\t'isPrototypeOf',\n\t\t'propertyIsEnumerable',\n\t\t'constructor'\n\t];\n\tvar equalsConstructorPrototype = function (o) {\n\t\tvar ctor = o.constructor;\n\t\treturn ctor && ctor.prototype === o;\n\t};\n\tvar excludedKeys = {\n\t\t$applicationCache: true,\n\t\t$console: true,\n\t\t$external: true,\n\t\t$frame: true,\n\t\t$frameElement: true,\n\t\t$frames: true,\n\t\t$innerHeight: true,\n\t\t$innerWidth: true,\n\t\t$onmozfullscreenchange: true,\n\t\t$onmozfullscreenerror: true,\n\t\t$outerHeight: true,\n\t\t$outerWidth: true,\n\t\t$pageXOffset: true,\n\t\t$pageYOffset: true,\n\t\t$parent: true,\n\t\t$scrollLeft: true,\n\t\t$scrollTop: true,\n\t\t$scrollX: true,\n\t\t$scrollY: true,\n\t\t$self: true,\n\t\t$webkitIndexedDB: true,\n\t\t$webkitStorageInfo: true,\n\t\t$window: true\n\t};\n\tvar hasAutomationEqualityBug = (function () {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined') { return false; }\n\t\tfor (var k in window) {\n\t\t\ttry {\n\t\t\t\tif (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tequalsConstructorPrototype(window[k]);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}());\n\tvar equalsConstructorPrototypeIfNotBuggy = function (o) {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined' || !hasAutomationEqualityBug) {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t}\n\t\ttry {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n\n\tkeysShim = function keys(object) {\n\t\tvar isObject = object !== null && typeof object === 'object';\n\t\tvar isFunction = toStr.call(object) === '[object Function]';\n\t\tvar isArguments = isArgs(object);\n\t\tvar isString = isObject && toStr.call(object) === '[object String]';\n\t\tvar theKeys = [];\n\n\t\tif (!isObject && !isFunction && !isArguments) {\n\t\t\tthrow new TypeError('Object.keys called on a non-object');\n\t\t}\n\n\t\tvar skipProto = hasProtoEnumBug && isFunction;\n\t\tif (isString && object.length > 0 && !has.call(object, 0)) {\n\t\t\tfor (var i = 0; i < object.length; ++i) {\n\t\t\t\ttheKeys.push(String(i));\n\t\t\t}\n\t\t}\n\n\t\tif (isArguments && object.length > 0) {\n\t\t\tfor (var j = 0; j < object.length; ++j) {\n\t\t\t\ttheKeys.push(String(j));\n\t\t\t}\n\t\t} else {\n\t\t\tfor (var name in object) {\n\t\t\t\tif (!(skipProto && name === 'prototype') && has.call(object, name)) {\n\t\t\t\t\ttheKeys.push(String(name));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (hasDontEnumBug) {\n\t\t\tvar skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);\n\n\t\t\tfor (var k = 0; k < dontEnums.length; ++k) {\n\t\t\t\tif (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {\n\t\t\t\t\ttheKeys.push(dontEnums[k]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn theKeys;\n\t};\n}\nmodule.exports = keysShim;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/object-keys/implementation.js\n// module id = 137\n// module chunks = 0","'use strict';\n\nvar slice = Array.prototype.slice;\nvar isArgs = require('./isArguments');\n\nvar origKeys = Object.keys;\nvar keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation');\n\nvar originalKeys = Object.keys;\n\nkeysShim.shim = function shimObjectKeys() {\n\tif (Object.keys) {\n\t\tvar keysWorksWithArguments = (function () {\n\t\t\t// Safari 5.0 bug\n\t\t\tvar args = Object.keys(arguments);\n\t\t\treturn args && args.length === arguments.length;\n\t\t}(1, 2));\n\t\tif (!keysWorksWithArguments) {\n\t\t\tObject.keys = function keys(object) { // eslint-disable-line func-name-matching\n\t\t\t\tif (isArgs(object)) {\n\t\t\t\t\treturn originalKeys(slice.call(object));\n\t\t\t\t}\n\t\t\t\treturn originalKeys(object);\n\t\t\t};\n\t\t}\n\t} else {\n\t\tObject.keys = keysShim;\n\t}\n\treturn Object.keys || keysShim;\n};\n\nmodule.exports = keysShim;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/object-keys/index.js\n// module id = 138\n// module chunks = 0"],"sourceRoot":""}