{"version":3,"sources":["source-webpack:///./.modernizrrc.js","source-webpack:///./bertschi-driver-server/assets/src/js/app/main/config.js","source-webpack:///./bertschi-driver-server/assets/src/js/app/util/polyfills/polyfill-registry.js","source-webpack:///./bertschi-driver-server/assets/src/js/app/util/polyfills/index.js","source-webpack:///./bertschi-driver-server/assets/src/js/app/main/index.js","source-webpack:///./bertschi-driver-server/assets/src/js/app/main/webpack-config.js","source-webpack:///./bertschi-driver-server/assets/src/js/app/util/fixes/ie-detect/index.js","source-webpack:///./bertschi-driver-server/assets/src/js/app/util/fixes/ie-mobile-viewport-fix/index.js","source-webpack:///./bertschi-driver-server/assets/src/js/app/util/fixes/ios-active-state-fix/index.js","source-webpack:///./bertschi-driver-server/assets/src/js/app/util/fixes/svg-symbols/index.js","source-webpack:///./node_modules/process/browser.js","source-webpack:///./node_modules/promise-polyfill/src/allSettled.js","source-webpack:///./node_modules/promise-polyfill/src/any.js","source-webpack:///./node_modules/promise-polyfill/src/finally.js","source-webpack:///./node_modules/promise-polyfill/src/index.js","source-webpack:///./node_modules/setimmediate/setImmediate.js","source-webpack:///./node_modules/svg4everybody/dist/svg4everybody.js","source-webpack:///./node_modules/timers-browserify/main.js","source-webpack:///(webpack)/buildin/global.js"],"names":["window","hadGlobal","oldGlobal","Modernizr","scriptGlobalObject","document","undefined","tests","ModernizrProto","_version","_config","_q","on","test","cb","self","this","setTimeout","addTest","name","fn","options","push","addAsyncTest","classes","prototype","is","obj","type","docElement","documentElement","isSVG","nodeName","toLowerCase","omPrefixes","cssomPrefixes","usePrefixes","split","createElement","createElementNS","call","apply","arguments","_cssomPrefixes","modElem","elem","mStyle","style","injectElementWithStyles","rule","callback","nodes","testnames","ret","node","docOverflow","body","mod","div","fake","parseInt","id","appendChild","styleSheet","cssText","createTextNode","background","overflow","parentNode","removeChild","offsetHeight","domToCSS","replace","str","m1","computedStyle","pseudo","prop","result","console","getComputedStyle","getPropertyValue","error","currentStyle","cssToDOM","m2","toUpperCase","testProps","props","prefixed","value","skipValueTest","i","length","CSS","supports","conditionText","join","nativeTestProps","afterInit","propsLength","before","elems","shift","cleanElems","indexOf","e","unshift","domPrefixes","testPropsAll","ucProp","charAt","slice","testDOMProps","that","item","atRule","prefixes","cssrule","CSSRule","prefix","_domPrefixes","testAllProps","matchMedia","featureNames","feature","aliasIdx","nameIdx","featureNameSplit","featureIdx","reJS","className","classPrefix","mq","_prefixes","msMatchMedia","mql","matches","bool","TouchEvent","DocumentTouch","query","externalHost","hasOwnProperty","aliases","Boolean","baseVal","enableJSClass","RegExp","enableClasses","module","exports","config","__js_bridge","state","svgSymbolsLoaded","hasNativeSupport","String","includes","polyfill","resolve","require","Array","from","every","of","find","findIndex","fill","some","Object","assign","entries","URLSearchParams","IntersectionObserverEntry","Promise","polyfillPromises","polyfills","forEach","all","then","app","init","initFirebase","catch","err","Error","warn","__webpack_public_path__","globals","static","documentMode","detection","seal","isIE","version","detect","isIE11","msViewportStyle","navigator","userAgent","match","getElementsByTagName","addEventListener","$$container","$body","setAttribute","querySelector","$svg","url","getAttribute","urlConnector","cacheBustingUrl","Date","now","onLoadSVG","innerHTML","responseText","insertBefore","firstChild","svg4everybody","onErrorSVG","jqXHR","textStatus","errorThrown","log","selector","SVGRequest","XMLHttpRequest","open","send","src","removeAttribute","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","defaultClearTimeout","clearTimeout","runTimeout","fun","currentQueue","queue","draining","queueIndex","cleanUpNextTick","concat","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","args","title","browser","env","argv","versions","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","arr","reject","TypeError","remaining","res","val","status","reason","AggregateError","errors","message","P","rejectionReasons","ex","constructor","setTimeoutFunc","isArray","x","_state","_handled","_value","_deferreds","doResolve","handle","deferred","_immediateFn","onFulfilled","onRejected","promise","newValue","finale","thisArg","_unhandledRejectionFn","Handler","done","prom","any","allSettled","race","setImmediate","nextHandle","tasksByHandle","currentlyRunningATask","doc","registerImmediate","html","channel","attachTo","clearImmediate","runIfPresent","task","installPostMessageImplementation","onGlobalMessage","event","source","global","data","messagePrefix","Math","random","attachEvent","postMessage","getPrototypeOf","toString","postMessageIsAsynchronous","oldOnMessage","importScripts","onmessage","canUsePostMessage","MessageChannel","port1","port2","script","onreadystatechange","Function","root","rawopts","opts","inIframe","top","requests","requestAnimationFrame","uses","numberOfSvgUseElementsToBypass","oninterval","index","xhr","use","parent","svg","getSVGAncestor","attributeName","validate","srcSplit","_embeds","cachedDocument","readyState","_cachedDocument","implementation","createHTMLDocument","_cachedTarget","splice","map","target","getElementById","embed","loadreadystatechange","fragment","createDocumentFragment","viewBox","hasAttribute","clone","cloneNode","childNodes","Timeout","clearFn","_id","_clearFn","scope","setInterval","clearInterval","close","unref","ref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","g"],"mappings":"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","file":"entry/app/index.js","sourcesContent":[";(function(window){\nvar hadGlobal = 'Modernizr' in window;\nvar oldGlobal = window.Modernizr;\n/*!\n * modernizr v3.12.0\n * Build https://modernizr.com/download?-adownload-touchevents-prefixed-setclasses-dontmin\n *\n * Copyright (c)\n *  Faruk Ates\n *  Paul Irish\n *  Alex Sexton\n *  Ryan Seddon\n *  Patrick Kettner\n *  Stu Cox\n *  Richard Herrera\n *  Veeck\n\n * MIT License\n */\n\n/*\n * Modernizr tests which native CSS3 and HTML5 features are available in the\n * current UA and makes the results available to you in two ways: as properties on\n * a global `Modernizr` object, and as classes on the `<html>` element. This\n * information allows you to progressively enhance your pages with a granular level\n * of control over the experience.\n*/\n\n;(function(scriptGlobalObject, window, document, undefined){\n\n  var tests = [];\n  \n\n  /**\n   * ModernizrProto is the constructor for Modernizr\n   *\n   * @class\n   * @access public\n   */\n  var ModernizrProto = {\n    _version: '3.12.0',\n\n    // Any settings that don't work as separate modules\n    // can go in here as configuration.\n    _config: {\n      'classPrefix': '',\n      'enableClasses': true,\n      'enableJSClass': true,\n      'usePrefixes': true\n    },\n\n    // Queue of tests\n    _q: [],\n\n    // Stub these for people who are listening\n    on: function(test, cb) {\n      // I don't really think people should do this, but we can\n      // safe guard it a bit.\n      // -- NOTE:: this gets WAY overridden in src/addTest for actual async tests.\n      // This is in case people listen to synchronous tests. I would leave it out,\n      // but the code to *disallow* sync tests in the real version of this\n      // function is actually larger than this.\n      var self = this;\n      setTimeout(function() {\n        cb(self[test]);\n      }, 0);\n    },\n\n    addTest: function(name, fn, options) {\n      tests.push({name: name, fn: fn, options: options});\n    },\n\n    addAsyncTest: function(fn) {\n      tests.push({name: null, fn: fn});\n    }\n  };\n\n  \n\n  // Fake some of Object.create so we can force non test results to be non \"own\" properties.\n  var Modernizr = function() {};\n  Modernizr.prototype = ModernizrProto;\n\n  // Leak modernizr globally when you `require` it rather than force it here.\n  // Overwrite name so constructor name is nicer :D\n  Modernizr = new Modernizr();\n\n  \n\n  var classes = [];\n  \n\n  /**\n   * is returns a boolean if the typeof an obj is exactly type.\n   *\n   * @access private\n   * @function is\n   * @param {*} obj - A thing we want to check the type of\n   * @param {string} type - A string to compare the typeof against\n   * @returns {boolean} true if the typeof the first parameter is exactly the specified type, false otherwise\n   */\n  function is(obj, type) {\n    return typeof obj === type;\n  }\n\n  ;\n\n  /**\n   * Run through all tests and detect their support in the current UA.\n   *\n   * @access private\n   * @returns {void}\n   */\n  function testRunner() {\n    var featureNames;\n    var feature;\n    var aliasIdx;\n    var result;\n    var nameIdx;\n    var featureName;\n    var featureNameSplit;\n\n    for (var featureIdx in tests) {\n      if (tests.hasOwnProperty(featureIdx)) {\n        featureNames = [];\n        feature = tests[featureIdx];\n        // run the test, throw the return value into the Modernizr,\n        // then based on that boolean, define an appropriate className\n        // and push it into an array of classes we'll join later.\n        //\n        // If there is no name, it's an 'async' test that is run,\n        // but not directly added to the object. That should\n        // be done with a post-run addTest call.\n        if (feature.name) {\n          featureNames.push(feature.name.toLowerCase());\n\n          if (feature.options && feature.options.aliases && feature.options.aliases.length) {\n            // Add all the aliases into the names list\n            for (aliasIdx = 0; aliasIdx < feature.options.aliases.length; aliasIdx++) {\n              featureNames.push(feature.options.aliases[aliasIdx].toLowerCase());\n            }\n          }\n        }\n\n        // Run the test, or use the raw value if it's not a function\n        result = is(feature.fn, 'function') ? feature.fn() : feature.fn;\n\n        // Set each of the names on the Modernizr object\n        for (nameIdx = 0; nameIdx < featureNames.length; nameIdx++) {\n          featureName = featureNames[nameIdx];\n          // Support dot properties as sub tests. We don't do checking to make sure\n          // that the implied parent tests have been added. You must call them in\n          // order (either in the test, or make the parent test a dependency).\n          //\n          // Cap it to TWO to make the logic simple and because who needs that kind of subtesting\n          // hashtag famous last words\n          featureNameSplit = featureName.split('.');\n\n          if (featureNameSplit.length === 1) {\n            Modernizr[featureNameSplit[0]] = result;\n          } else {\n            // cast to a Boolean, if not one already or if it doesnt exist yet (like inputtypes)\n            if (!Modernizr[featureNameSplit[0]] || Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) {\n              Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]);\n            }\n\n            Modernizr[featureNameSplit[0]][featureNameSplit[1]] = result;\n          }\n\n          classes.push((result ? '' : 'no-') + featureNameSplit.join('-'));\n        }\n      }\n    }\n  }\n  ;\n\n  /**\n   * docElement is a convenience wrapper to grab the root element of the document\n   *\n   * @access private\n   * @returns {HTMLElement|SVGElement} The root element of the document\n   */\n  var docElement = document.documentElement;\n  \n\n  /**\n   * A convenience helper to check if the document we are running in is an SVG document\n   *\n   * @access private\n   * @returns {boolean}\n   */\n  var isSVG = docElement.nodeName.toLowerCase() === 'svg';\n\n  \n\n  /**\n   * setClasses takes an array of class names and adds them to the root element\n   *\n   * @access private\n   * @function setClasses\n   * @param {string[]} classes - Array of class names\n   */\n  // Pass in an and array of class names, e.g.:\n  //  ['no-webp', 'borderradius', ...]\n  function setClasses(classes) {\n    var className = docElement.className;\n    var classPrefix = Modernizr._config.classPrefix || '';\n\n    if (isSVG) {\n      className = className.baseVal;\n    }\n\n    // Change `no-js` to `js` (independently of the `enableClasses` option)\n    // Handle classPrefix on this too\n    if (Modernizr._config.enableJSClass) {\n      var reJS = new RegExp('(^|\\\\s)' + classPrefix + 'no-js(\\\\s|$)');\n      className = className.replace(reJS, '$1' + classPrefix + 'js$2');\n    }\n\n    if (Modernizr._config.enableClasses) {\n      // Add the new classes\n      if (classes.length > 0) {\n        className += ' ' + classPrefix + classes.join(' ' + classPrefix);\n      }\n      if (isSVG) {\n        docElement.className.baseVal = className;\n      } else {\n        docElement.className = className;\n      }\n    }\n  }\n\n  ;\n\n  /**\n   * If the browsers follow the spec, then they would expose vendor-specific styles as:\n   *   elem.style.WebkitBorderRadius\n   * instead of something like the following (which is technically incorrect):\n   *   elem.style.webkitBorderRadius\n   *\n   * WebKit ghosts their properties in lowercase but Opera & Moz do not.\n   * Microsoft uses a lowercase `ms` instead of the correct `Ms` in IE8+\n   *   erik.eae.net/archives/2008/03/10/21.48.10/\n   *\n   * More here: github.com/Modernizr/Modernizr/issues/issue/21\n   *\n   * @access private\n   * @returns {string} The string representing the vendor-specific style properties\n   */\n  var omPrefixes = 'Moz O ms Webkit';\n  \n\n  var cssomPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.split(' ') : []);\n  ModernizrProto._cssomPrefixes = cssomPrefixes;\n  \n\n  /**\n   * contains checks to see if a string contains another string\n   *\n   * @access private\n   * @function contains\n   * @param {string} str - The string we want to check for substrings\n   * @param {string} substr - The substring we want to search the first string for\n   * @returns {boolean} true if and only if the first string 'str' contains the second string 'substr'\n   */\n  function contains(str, substr) {\n    return !!~('' + str).indexOf(substr);\n  }\n\n  ;\n\n  /**\n   * createElement is a convenience wrapper around document.createElement. Since we\n   * use createElement all over the place, this allows for (slightly) smaller code\n   * as well as abstracting away issues with creating elements in contexts other than\n   * HTML documents (e.g. SVG documents).\n   *\n   * @access private\n   * @function createElement\n   * @returns {HTMLElement|SVGElement} An HTML or SVG element\n   */\n  function createElement() {\n    if (typeof document.createElement !== 'function') {\n      // This is the case in IE7, where the type of createElement is \"object\".\n      // For this reason, we cannot call apply() as Object is not a Function.\n      return document.createElement(arguments[0]);\n    } else if (isSVG) {\n      return document.createElementNS.call(document, 'http://www.w3.org/2000/svg', arguments[0]);\n    } else {\n      return document.createElement.apply(document, arguments);\n    }\n  }\n\n  ;\n\n  /**\n   * Create our \"modernizr\" element that we do most feature tests on.\n   *\n   * @access private\n   */\n  var modElem = {\n    elem: createElement('modernizr')\n  };\n\n  // Clean up this element\n  Modernizr._q.push(function() {\n    delete modElem.elem;\n  });\n\n  \n\n  var mStyle = {\n    style: modElem.elem.style\n  };\n\n  // kill ref for gc, must happen before mod.elem is removed, so we unshift on to\n  // the front of the queue.\n  Modernizr._q.unshift(function() {\n    delete mStyle.style;\n  });\n\n  \n\n  /**\n   * getBody returns the body of a document, or an element that can stand in for\n   * the body if a real body does not exist\n   *\n   * @access private\n   * @function getBody\n   * @returns {HTMLElement|SVGElement} Returns the real body of a document, or an\n   * artificially created element that stands in for the body\n   */\n  function getBody() {\n    // After page load injecting a fake body doesn't work so check if body exists\n    var body = document.body;\n\n    if (!body) {\n      // Can't use the real body create a fake one.\n      body = createElement(isSVG ? 'svg' : 'body');\n      body.fake = true;\n    }\n\n    return body;\n  }\n\n  ;\n\n  /**\n   * injectElementWithStyles injects an element with style element and some CSS rules\n   *\n   * @access private\n   * @function injectElementWithStyles\n   * @param {string} rule - String representing a css rule\n   * @param {Function} callback - A function that is used to test the injected element\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\n   * @returns {boolean} the result of the specified callback test\n   */\n  function injectElementWithStyles(rule, callback, nodes, testnames) {\n    var mod = 'modernizr';\n    var style;\n    var ret;\n    var node;\n    var docOverflow;\n    var div = createElement('div');\n    var body = getBody();\n\n    if (parseInt(nodes, 10)) {\n      // In order not to give false positives we create a node for each test\n      // This also allows the method to scale for unspecified uses\n      while (nodes--) {\n        node = createElement('div');\n        node.id = testnames ? testnames[nodes] : mod + (nodes + 1);\n        div.appendChild(node);\n      }\n    }\n\n    style = createElement('style');\n    style.type = 'text/css';\n    style.id = 's' + mod;\n\n    // IE6 will false positive on some tests due to the style element inside the test div somehow interfering offsetHeight, so insert it into body or fakebody.\n    // Opera will act all quirky when injecting elements in documentElement when page is served as xml, needs fakebody too. #270\n    (!body.fake ? div : body).appendChild(style);\n    body.appendChild(div);\n\n    if (style.styleSheet) {\n      style.styleSheet.cssText = rule;\n    } else {\n      style.appendChild(document.createTextNode(rule));\n    }\n    div.id = mod;\n\n    if (body.fake) {\n      //avoid crashing IE8, if background image is used\n      body.style.background = '';\n      //Safari 5.13/5.1.4 OSX stops loading if ::-webkit-scrollbar is used and scrollbars are visible\n      body.style.overflow = 'hidden';\n      docOverflow = docElement.style.overflow;\n      docElement.style.overflow = 'hidden';\n      docElement.appendChild(body);\n    }\n\n    ret = callback(div, rule);\n    // If this is done after page load we don't want to remove the body so check if body exists\n    if (body.fake && body.parentNode) {\n      body.parentNode.removeChild(body);\n      docElement.style.overflow = docOverflow;\n      // Trigger layout so kinetic scrolling isn't disabled in iOS6+\n      // eslint-disable-next-line\n      docElement.offsetHeight;\n    } else {\n      div.parentNode.removeChild(div);\n    }\n\n    return !!ret;\n  }\n\n  ;\n\n  /**\n   * domToCSS takes a camelCase string and converts it to hyphen-case\n   * e.g. boxSizing -> box-sizing\n   *\n   * @access private\n   * @function domToCSS\n   * @param {string} name - String name of camelCase prop we want to convert\n   * @returns {string} The hyphen-case version of the supplied name\n   */\n  function domToCSS(name) {\n    return name.replace(/([A-Z])/g, function(str, m1) {\n      return '-' + m1.toLowerCase();\n    }).replace(/^ms-/, '-ms-');\n  }\n\n  ;\n\n\n  /**\n   * wrapper around getComputedStyle, to fix issues with Firefox returning null when\n   * called inside of a hidden iframe\n   *\n   * @access private\n   * @function computedStyle\n   * @param {HTMLElement|SVGElement} elem - The element we want to find the computed styles of\n   * @param {string|null} [pseudo] - An optional pseudo element selector (e.g. :before), of null if none\n   * @param {string} prop - A CSS property\n   * @returns {CSSStyleDeclaration} the value of the specified CSS property\n   */\n  function computedStyle(elem, pseudo, prop) {\n    var result;\n\n    if ('getComputedStyle' in window) {\n      result = getComputedStyle.call(window, elem, pseudo);\n      var console = window.console;\n\n      if (result !== null) {\n        if (prop) {\n          result = result.getPropertyValue(prop);\n        }\n      } else {\n        if (console) {\n          var method = console.error ? 'error' : 'log';\n          console[method].call(console, 'getComputedStyle returning null, its possible modernizr test results are inaccurate');\n        }\n      }\n    } else {\n      result = !pseudo && elem.currentStyle && elem.currentStyle[prop];\n    }\n\n    return result;\n  }\n\n  ;\n\n  /**\n   * nativeTestProps allows for us to use native feature detection functionality if available.\n   * some prefixed form, or false, in the case of an unsupported rule\n   *\n   * @access private\n   * @function nativeTestProps\n   * @param {Array} props - An array of property names\n   * @param {string} value - A string representing the value we want to check via @supports\n   * @returns {boolean|undefined} A boolean when @supports exists, undefined otherwise\n   */\n  // Accepts a list of property names and a single value\n  // Returns `undefined` if native detection not available\n  function nativeTestProps(props, value) {\n    var i = props.length;\n    // Start with the JS API: https://www.w3.org/TR/css3-conditional/#the-css-interface\n    if ('CSS' in window && 'supports' in window.CSS) {\n      // Try every prefixed variant of the property\n      while (i--) {\n        if (window.CSS.supports(domToCSS(props[i]), value)) {\n          return true;\n        }\n      }\n      return false;\n    }\n    // Otherwise fall back to at-rule (for Opera 12.x)\n    else if ('CSSSupportsRule' in window) {\n      // Build a condition string for every prefixed variant\n      var conditionText = [];\n      while (i--) {\n        conditionText.push('(' + domToCSS(props[i]) + ':' + value + ')');\n      }\n      conditionText = conditionText.join(' or ');\n      return injectElementWithStyles('@supports (' + conditionText + ') { #modernizr { position: absolute; } }', function(node) {\n        return computedStyle(node, null, 'position') === 'absolute';\n      });\n    }\n    return undefined;\n  }\n  ;\n\n  /**\n   * cssToDOM takes a hyphen-case string and converts it to camelCase\n   * e.g. box-sizing -> boxSizing\n   *\n   * @access private\n   * @function cssToDOM\n   * @param {string} name - String name of hyphen-case prop we want to convert\n   * @returns {string} The camelCase version of the supplied name\n   */\n  function cssToDOM(name) {\n    return name.replace(/([a-z])-([a-z])/g, function(str, m1, m2) {\n      return m1 + m2.toUpperCase();\n    }).replace(/^-/, '');\n  }\n\n  ;\n\n  // testProps is a generic CSS / DOM property test.\n\n  // In testing support for a given CSS property, it's legit to test:\n  //    `elem.style[styleName] !== undefined`\n  // If the property is supported it will return an empty string,\n  // if unsupported it will return undefined.\n\n  // We'll take advantage of this quick test and skip setting a style\n  // on our modernizr element, but instead just testing undefined vs\n  // empty string.\n\n  // Property names can be provided in either camelCase or hyphen-case.\n\n  function testProps(props, prefixed, value, skipValueTest) {\n    skipValueTest = is(skipValueTest, 'undefined') ? false : skipValueTest;\n\n    // Try native detect first\n    if (!is(value, 'undefined')) {\n      var result = nativeTestProps(props, value);\n      if (!is(result, 'undefined')) {\n        return result;\n      }\n    }\n\n    // Otherwise do it properly\n    var afterInit, i, propsLength, prop, before;\n\n    // If we don't have a style element, that means we're running async or after\n    // the core tests, so we'll need to create our own elements to use.\n\n    // Inside of an SVG element, in certain browsers, the `style` element is only\n    // defined for valid tags. Therefore, if `modernizr` does not have one, we\n    // fall back to a less used element and hope for the best.\n    // For strict XHTML browsers the hardly used samp element is used.\n    var elems = ['modernizr', 'tspan', 'samp'];\n    while (!mStyle.style && elems.length) {\n      afterInit = true;\n      mStyle.modElem = createElement(elems.shift());\n      mStyle.style = mStyle.modElem.style;\n    }\n\n    // Delete the objects if we created them.\n    function cleanElems() {\n      if (afterInit) {\n        delete mStyle.style;\n        delete mStyle.modElem;\n      }\n    }\n\n    propsLength = props.length;\n    for (i = 0; i < propsLength; i++) {\n      prop = props[i];\n      before = mStyle.style[prop];\n\n      if (contains(prop, '-')) {\n        prop = cssToDOM(prop);\n      }\n\n      if (mStyle.style[prop] !== undefined) {\n\n        // If value to test has been passed in, do a set-and-check test.\n        // 0 (integer) is a valid property value, so check that `value` isn't\n        // undefined, rather than just checking it's truthy.\n        if (!skipValueTest && !is(value, 'undefined')) {\n\n          // Needs a try catch block because of old IE. This is slow, but will\n          // be avoided in most cases because `skipValueTest` will be used.\n          try {\n            mStyle.style[prop] = value;\n          } catch (e) {}\n\n          // If the property value has changed, we assume the value used is\n          // supported. If `value` is empty string, it'll fail here (because\n          // it hasn't changed), which matches how browsers have implemented\n          // CSS.supports()\n          if (mStyle.style[prop] !== before) {\n            cleanElems();\n            return prefixed === 'pfx' ? prop : true;\n          }\n        }\n        // Otherwise just return true, or the property name if this is a\n        // `prefixed()` call\n        else {\n          cleanElems();\n          return prefixed === 'pfx' ? prop : true;\n        }\n      }\n    }\n    cleanElems();\n    return false;\n  }\n\n  ;\n\n  /**\n   * List of JavaScript DOM values used for tests\n   *\n   * @memberOf Modernizr\n   * @name Modernizr._domPrefixes\n   * @optionName Modernizr._domPrefixes\n   * @optionProp domPrefixes\n   * @access public\n   * @example\n   *\n   * Modernizr._domPrefixes is exactly the same as [_prefixes](#modernizr-_prefixes), but rather\n   * than hyphen-case properties, all properties are their Capitalized variant\n   *\n   * ```js\n   * Modernizr._domPrefixes === [ \"Moz\", \"O\", \"ms\", \"Webkit\" ];\n   * ```\n   */\n  var domPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.toLowerCase().split(' ') : []);\n  ModernizrProto._domPrefixes = domPrefixes;\n  \n\n  /**\n   * fnBind is a super small [bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind) polyfill.\n   *\n   * @access private\n   * @function fnBind\n   * @param {Function} fn - a function you want to change `this` reference to\n   * @param {object} that - the `this` you want to call the function with\n   * @returns {Function} The wrapped version of the supplied function\n   */\n  function fnBind(fn, that) {\n    return function() {\n      return fn.apply(that, arguments);\n    };\n  }\n\n  ;\n\n  /**\n   * testDOMProps is a generic DOM property test; if a browser supports\n   *   a certain property, it won't return undefined for it.\n   *\n   * @access private\n   * @function testDOMProps\n   * @param {Array<string>} props - An array of properties to test for\n   * @param {object} obj - An object or Element you want to use to test the parameters again\n   * @param {boolean|object} elem - An Element to bind the property lookup again. Use `false` to prevent the check\n   * @returns {boolean|*} returns `false` if the prop is unsupported, otherwise the value that is supported\n   */\n  function testDOMProps(props, obj, elem) {\n    var item;\n\n    for (var i in props) {\n      if (props[i] in obj) {\n\n        // return the property name as a string\n        if (elem === false) {\n          return props[i];\n        }\n\n        item = obj[props[i]];\n\n        // let's bind a function\n        if (is(item, 'function')) {\n          // bind to obj unless overridden\n          return fnBind(item, elem || obj);\n        }\n\n        // return the unbound function or obj or value\n        return item;\n      }\n    }\n    return false;\n  }\n\n  ;\n\n  /**\n   * testPropsAll tests a list of DOM properties we want to check against.\n   * We specify literally ALL possible (known and/or likely) properties on\n   * the element including the non-vendor prefixed one, for forward-\n   * compatibility.\n   *\n   * @access private\n   * @function testPropsAll\n   * @param {string} prop - A string of the property to test for\n   * @param {string|object} [prefixed] - An object to check the prefixed properties on. Use a string to skip\n   * @param {HTMLElement|SVGElement} [elem] - An element used to test the property and value against\n   * @param {string} [value] - A string of a css value\n   * @param {boolean} [skipValueTest] - An boolean representing if you want to test if value sticks when set\n   * @returns {string|boolean} returns the string version of the property, or `false` if it is unsupported\n   */\n  function testPropsAll(prop, prefixed, elem, value, skipValueTest) {\n\n    var ucProp = prop.charAt(0).toUpperCase() + prop.slice(1),\n      props = (prop + ' ' + cssomPrefixes.join(ucProp + ' ') + ucProp).split(' ');\n\n    // did they call .prefixed('boxSizing') or are we just testing a prop?\n    if (is(prefixed, 'string') || is(prefixed, 'undefined')) {\n      return testProps(props, prefixed, value, skipValueTest);\n\n      // otherwise, they called .prefixed('requestAnimationFrame', window[, elem])\n    } else {\n      props = (prop + ' ' + (domPrefixes).join(ucProp + ' ') + ucProp).split(' ');\n      return testDOMProps(props, prefixed, elem);\n    }\n  }\n\n  // Modernizr.testAllProps() investigates whether a given style property,\n  // or any of its vendor-prefixed variants, is recognized\n  //\n  // Note that the property names must be provided in the camelCase variant.\n  // Modernizr.testAllProps('boxSizing')\n  ModernizrProto.testAllProps = testPropsAll;\n\n  \n\n  /**\n   * atRule returns a given CSS property at-rule (eg @keyframes), possibly in\n   * some prefixed form, or false, in the case of an unsupported rule\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.atRule\n   * @optionName Modernizr.atRule()\n   * @optionProp atRule\n   * @access public\n   * @function atRule\n   * @param {string} prop - String name of the @-rule to test for\n   * @returns {string|boolean} The string representing the (possibly prefixed)\n   * valid version of the @-rule, or `false` when it is unsupported.\n   * @example\n   * ```js\n   *  var keyframes = Modernizr.atRule('@keyframes');\n   *\n   *  if (keyframes) {\n   *    // keyframes are supported\n   *    // could be `@-webkit-keyframes` or `@keyframes`\n   *  } else {\n   *    // keyframes === `false`\n   *  }\n   * ```\n   */\n  var atRule = function(prop) {\n    var length = prefixes.length;\n    var cssrule = window.CSSRule;\n    var rule;\n\n    if (typeof cssrule === 'undefined') {\n      return undefined;\n    }\n\n    if (!prop) {\n      return false;\n    }\n\n    // remove literal @ from beginning of provided property\n    prop = prop.replace(/^@/, '');\n\n    // CSSRules use underscores instead of dashes\n    rule = prop.replace(/-/g, '_').toUpperCase() + '_RULE';\n\n    if (rule in cssrule) {\n      return '@' + prop;\n    }\n\n    for (var i = 0; i < length; i++) {\n      // prefixes gives us something like -o-, and we want O_\n      var prefix = prefixes[i];\n      var thisRule = prefix.toUpperCase() + '_' + rule;\n\n      if (thisRule in cssrule) {\n        return '@-' + prefix.toLowerCase() + '-' + prop;\n      }\n    }\n\n    return false;\n  };\n\n  ModernizrProto.atRule = atRule;\n\n  \n\n  /**\n   * prefixed returns the prefixed or nonprefixed property name variant of your input\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.prefixed\n   * @optionName Modernizr.prefixed()\n   * @optionProp prefixed\n   * @access public\n   * @function prefixed\n   * @param {string} prop - String name of the property to test for\n   * @param {object} [obj] - An object to test for the prefixed properties on\n   * @param {HTMLElement} [elem] - An element used to test specific properties against\n   * @returns {string|boolean} The string representing the (possibly prefixed) valid\n   * version of the property, or `false` when it is unsupported.\n   * @example\n   *\n   * Modernizr.prefixed takes a string css value in the DOM style camelCase (as\n   * opposed to the css style hyphen-case) form and returns the (possibly prefixed)\n   * version of that property that the browser actually supports.\n   *\n   * For example, in older Firefox...\n   * ```js\n   * prefixed('boxSizing')\n   * ```\n   * returns 'MozBoxSizing'\n   *\n   * In newer Firefox, as well as any other browser that support the unprefixed\n   * version would simply return `boxSizing`. Any browser that does not support\n   * the property at all, it will return `false`.\n   *\n   * By default, prefixed is checked against a DOM element. If you want to check\n   * for a property on another object, just pass it as a second argument\n   *\n   * ```js\n   * var rAF = prefixed('requestAnimationFrame', window);\n   *\n   * raf(function() {\n   *  renderFunction();\n   * })\n   * ```\n   *\n   * Note that this will return _the actual function_ - not the name of the function.\n   * If you need the actual name of the property, pass in `false` as a third argument\n   *\n   * ```js\n   * var rAFProp = prefixed('requestAnimationFrame', window, false);\n   *\n   * rafProp === 'WebkitRequestAnimationFrame' // in older webkit\n   * ```\n   *\n   * One common use case for prefixed is if you're trying to determine which transition\n   * end event to bind to, you might do something like...\n   * ```js\n   * var transEndEventNames = {\n   *     'WebkitTransition' : 'webkitTransitionEnd', * Saf 6, Android Browser\n   *     'MozTransition'    : 'transitionend',       * only for FF < 15\n   *     'transition'       : 'transitionend'        * IE10, Opera, Chrome, FF 15+, Saf 7+\n   * };\n   *\n   * var transEndEventName = transEndEventNames[ Modernizr.prefixed('transition') ];\n   * ```\n   *\n   * If you want a similar lookup, but in hyphen-case, you can use [prefixedCSS](#modernizr-prefixedcss).\n   */\n  var prefixed = ModernizrProto.prefixed = function(prop, obj, elem) {\n    if (prop.indexOf('@') === 0) {\n      return atRule(prop);\n    }\n\n    if (prop.indexOf('-') !== -1) {\n      // Convert hyphen-case to camelCase\n      prop = cssToDOM(prop);\n    }\n    if (!obj) {\n      return testPropsAll(prop, 'pfx');\n    } else {\n      // Testing DOM property e.g. Modernizr.prefixed('requestAnimationFrame', window) // 'mozRequestAnimationFrame'\n      return testPropsAll(prop, obj, elem);\n    }\n  };\n\n  \n\n  /**\n   * List of property values to set for css tests. See ticket #21\n   * https://github.com/modernizr/modernizr/issues/21\n   *\n   * @memberOf Modernizr\n   * @name Modernizr._prefixes\n   * @optionName Modernizr._prefixes\n   * @optionProp prefixes\n   * @access public\n   * @example\n   *\n   * Modernizr._prefixes is the internal list of prefixes that we test against\n   * inside of things like [prefixed](#modernizr-prefixed) and [prefixedCSS](#-code-modernizr-prefixedcss). It is simply\n   * an array of hyphen-case vendor prefixes you can use within your code.\n   *\n   * Some common use cases include\n   *\n   * Generating all possible prefixed version of a CSS property\n   * ```js\n   * var rule = Modernizr._prefixes.join('transform: rotate(20deg); ');\n   *\n   * rule === 'transform: rotate(20deg); webkit-transform: rotate(20deg); moz-transform: rotate(20deg); o-transform: rotate(20deg); ms-transform: rotate(20deg);'\n   * ```\n   *\n   * Generating all possible prefixed version of a CSS value\n   * ```js\n   * rule = 'display:' +  Modernizr._prefixes.join('flex; display:') + 'flex';\n   *\n   * rule === 'display:flex; display:-webkit-flex; display:-moz-flex; display:-o-flex; display:-ms-flex; display:flex'\n   * ```\n   */\n  // we use ['',''] rather than an empty array in order to allow a pattern of .`join()`ing prefixes to test\n  // values in feature detects to continue to work\n  var prefixes = (ModernizrProto._config.usePrefixes ? ' -webkit- -moz- -o- -ms- '.split(' ') : ['','']);\n\n  // expose these for the plugin API. Look in the source for how to join() them against your input\n  ModernizrProto._prefixes = prefixes;\n\n  \n\n  /**\n   * Modernizr.mq tests a given media query, live against the current state of the window\n   * adapted from matchMedia polyfill by Scott Jehl and Paul Irish\n   * gist.github.com/786768\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.mq\n   * @optionName Modernizr.mq()\n   * @optionProp mq\n   * @access public\n   * @function mq\n   * @param {string} mq - String of the media query we want to test\n   * @returns {boolean}\n   * @example\n   * Modernizr.mq allows for you to programmatically check if the current browser\n   * window state matches a media query.\n   *\n   * ```js\n   *  var query = Modernizr.mq('(min-width: 900px)');\n   *\n   *  if (query) {\n   *    // the browser window is larger than 900px\n   *  }\n   * ```\n   *\n   * Only valid media queries are supported, therefore you must always include values\n   * with your media query\n   *\n   * ```js\n   * // good\n   *  Modernizr.mq('(min-width: 900px)');\n   *\n   * // bad\n   *  Modernizr.mq('min-width');\n   * ```\n   *\n   * If you would just like to test that media queries are supported in general, use\n   *\n   * ```js\n   *  Modernizr.mq('only all'); // true if MQ are supported, false if not\n   * ```\n   *\n   * Note that if the browser does not support media queries (e.g. old IE) mq will\n   * always return false.\n   */\n  var mq = (function() {\n    var matchMedia = window.matchMedia || window.msMatchMedia;\n    if (matchMedia) {\n      return function(mq) {\n        var mql = matchMedia(mq);\n        return mql && mql.matches || false;\n      };\n    }\n\n    return function(mq) {\n      var bool = false;\n\n      injectElementWithStyles('@media ' + mq + ' { #modernizr { position: absolute; } }', function(node) {\n        bool = computedStyle(node, null, 'position') === 'absolute';\n      });\n\n      return bool;\n    };\n  })();\n\n  ModernizrProto.mq = mq;\n\n  \n/*!\n{\n  \"name\": \"Touch Events\",\n  \"property\": \"touchevents\",\n  \"caniuse\": \"touch\",\n  \"tags\": [\"media\", \"attribute\"],\n  \"notes\": [{\n    \"name\": \"Touch Events spec\",\n    \"href\": \"https://www.w3.org/TR/2013/WD-touch-events-20130124/\"\n  }],\n  \"warnings\": [\n    \"** DEPRECATED see https://github.com/Modernizr/Modernizr/pull/2432 **\",\n    \"Indicates if the browser supports the Touch Events spec, and does not necessarily reflect a touchscreen device\"\n  ],\n  \"knownBugs\": [\n    \"False-positive on some configurations of Nokia N900\",\n    \"False-positive on some BlackBerry 6.0 builds – https://github.com/Modernizr/Modernizr/issues/372#issuecomment-3112695\"\n  ]\n}\n!*/\n/* DOC\nIndicates if the browser supports the W3C Touch Events API.\n\nThis *does not* necessarily reflect a touchscreen device:\n\n* Older touchscreen devices only emulate mouse events\n* Modern IE touch devices implement the Pointer Events API instead: use `Modernizr.pointerevents` to detect support for that\n* Some browsers & OS setups may enable touch APIs when no touchscreen is connected\n* Future browsers may implement other event models for touch interactions\n\nSee this article: [You Can't Detect A Touchscreen](http://www.stucox.com/blog/you-cant-detect-a-touchscreen/).\n\nIt's recommended to bind both mouse and touch/pointer events simultaneously – see [this HTML5 Rocks tutorial](https://www.html5rocks.com/en/mobile/touchandmouse/).\n\nThis test will also return `true` for Firefox 4 Multitouch support.\n*/\n\n  // Chrome (desktop) used to lie about its support on this, but that has since been rectified: https://bugs.chromium.org/p/chromium/issues/detail?id=36415\n  // Chrome also changed its behaviour since v70 and recommends the TouchEvent object for detection: https://www.chromestatus.com/feature/4764225348042752\n  Modernizr.addTest('touchevents', function() {\n    if (('ontouchstart' in window) || window.TouchEvent || window.DocumentTouch && document instanceof DocumentTouch) {\n      return true;\n    }\n\n    // include the 'heartz' as a way to have a non matching MQ to help terminate the join\n    // https://github.com/Modernizr/Modernizr/issues/1814\n    var query = ['(', prefixes.join('touch-enabled),('), 'heartz', ')'].join('');\n    return mq(query);\n  });\n\n/*!\n{\n  \"name\": \"a[download] Attribute\",\n  \"property\": \"adownload\",\n  \"caniuse\": \"download\",\n  \"tags\": [\"media\", \"attribute\"],\n  \"builderAliases\": [\"a_download\"],\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://developers.whatwg.org/links.html#downloading-resources\"\n  }]\n}\n!*/\n/* DOC\nWhen used on an `<a>`, this attribute signifies that the resource it points to should be downloaded by the browser rather than navigating to it.\n*/\n\n  Modernizr.addTest('adownload', !window.externalHost && 'download' in createElement('a'));\n\n\n  // Run each test\n  testRunner();\n\n  // Remove the \"no-js\" class if it exists\n  setClasses(classes);\n\n  delete ModernizrProto.addTest;\n  delete ModernizrProto.addAsyncTest;\n\n  // Run the things that are supposed to run after the tests\n  for (var i = 0; i < Modernizr._q.length; i++) {\n    Modernizr._q[i]();\n  }\n\n  // Leak Modernizr namespace\n  scriptGlobalObject.Modernizr = Modernizr;\n\n\n;\n\n})(window, window, document);\n\nmodule.exports = window.Modernizr;\nif (hadGlobal) { window.Modernizr = oldGlobal; }\nelse { delete window.Modernizr; }\n})(window);","module.exports = {\n    config: window.__js_bridge,\n    state: {\n        svgSymbolsLoaded: false,\n    },\n};\n\n\n","/* eslint-disable global-require */\nexport default [\n    {\n        hasNativeSupport: () => typeof String.prototype.includes === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.string.includes'));\n            }, null, 'polyfills/string-includes');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof Array.from === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.array.from'));\n            }, null, 'polyfills/array-from');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof Array.every === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.array.every'));\n            }, null, 'polyfills/array-every');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof Array.of === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.array.of'));\n            }, null, 'polyfills/array-of');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof Array.prototype.find === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.array.find'));\n            }, null, 'polyfills/array-find');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof Array.prototype.findIndex === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.array.find-index'));\n            }, null, 'polyfills/array-find-index');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof Array.prototype.fill === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.array.fill'));\n            }, null, 'polyfills/array-fill');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof Array.prototype.some === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.array.some'));\n            }, null, 'polyfills/array-some');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof Array.prototype.includes === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.array.includes'));\n            }, null, 'polyfills/array-includes');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof Object.assign === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.object.assign'));\n            }, null, 'polyfills/object-assign');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof Object.entries === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('core-js/modules/es.object.entries'));\n            }, null, 'polyfills/object-entries');\n        },\n    },\n    {\n        hasNativeSupport: () => typeof window.URLSearchParams === 'function',\n        polyfill(resolve) {\n            require.ensure([], () => {\n                window.URLSearchParams = require('url-search-params');\n                resolve();\n            }, null, 'polyfills/url-search-params');\n        },\n    },\n    {\n        hasNativeSupport: () => {\n            return 'IntersectionObserver' in window && 'IntersectionObserverEntry' in window && 'intersectionRatio' in window.IntersectionObserverEntry.prototype && 'isIntersecting' in window.IntersectionObserverEntry.prototype;\n        },\n        polyfill(resolve) {\n            require.ensure([], () => {\n                resolve(require('intersection-observer'));\n            }, null, 'polyfills/intersection-observer');\n        },\n    },\n];\n","import Promise from 'promise-polyfill';\nimport polyfills from './polyfill-registry';\n\nwindow.Promise = window.Promise || Promise;\n\nexport const installPolyfills = (function() {\n    const polyfillPromises = [];\n\n    polyfills.forEach(({ hasNativeSupport, polyfill }) => {\n        if (!hasNativeSupport()) {\n            polyfillPromises.push(new Promise(polyfill));\n        }\n    });\n\n    return Promise.all(polyfillPromises);\n}());\n\nexport const handleErrors = (err) => {\n    setTimeout(() => {\n        if (err instanceof Error) {\n            throw err;\n        } else {\n            console.warn(err);\n        }\n    });\n};\n","if (module.hot) {\n    module.hot.accept();\n}\n\nimport 'modernizr';\nimport 'main/webpack-config';\nimport 'util/fixes';\nimport { installPolyfills, handleErrors } from 'util/polyfills';\n\n\n// /**\n//  * Main entry point to the js app. Javascript execution starts here\n//  * 1. Webpack config and general fixes are initialized via `import` statement\n//  * 2. Polyfills are imported and asynchronously processed via `Promise` API\n//  * 3. In case of success, the vue app is initialized\n//  */\ninstallPolyfills\n    .then(() => require.ensure([], () => require('framework/base'), null, 'app-boot')) // eslint-disable-line global-require\n    .then(app => app.init())\n    .then(() => require.ensure([], () => require('util/firebase'), null, 'firebase-boot')) // eslint-disable-line global-require\n    .then(({ init: initFirebase }) => initFirebase())\n    .catch(handleErrors);\n","/**\n * Set the webpack public path (for bundles) dynamically\n * The static path comes from the server\n * @type {string}\n * @private\n * @link https://github.com/webpack/docs/wiki/configuration#outputpublicpath\n */\n__webpack_public_path__ = `${ globals.config.static }js/`; // eslint-disable-line\n","const { documentElement, documentMode } = window.document;\nconst detection = Object.seal({ isIE: null, version: null });\n\n/**\n * Detect any Internet Explorer version\n * Important: The \"cc_on\" comment within this method must not be stripped by any means!\n * @return {object} An object containing a flag and the IE version (if applicable)\n */\nfunction detect() {\n    if (detection.isIE != null) {\n        return detection;\n    }\n\n    const isIE11 = ('-ms-scroll-limit' in documentElement.style) && ('-ms-ime-align' in documentElement.style) && document.documentMode;\n    let reportedJscriptVersion = (function() {\n        /*@cc_on switch(@_jscript_version) {case 1.0: return 3; case 3.0: return 4; case 5.0: return 5; case 5.1: return 5; case 5.5: return 5.5; case 5.6: return 6; case 5.7: return 7; case 5.8: return 8; case 9: return 9; case 10: return 10;} @*/\n        return null;\n    }());\n\n    detection.version = documentMode || (isIE11 ? 11 : reportedJscriptVersion);\n    detection.isIE = detection.version != null;\n    addDetectionClasses(detection.version);\n\n    return detection;\n};\n\n/**\n * Adds IE detection classes to an element\n * @param {number} version - A number indicating the IE version\n */\nfunction addDetectionClasses(version) {\n    switch (version) {\n        case (3):\n        case (4):\n        case (5):\n        case (5.5):\n        case (6):\n        case (7):\n            documentElement.className += ' lt-ie8 lt-edge';\n            break;\n        case (8):\n            documentElement.className += ' ie8 lt-edge';\n            break;\n        case (9):\n            documentElement.className += ' ie9 lt-edge';\n            break;\n        case (10):\n            documentElement.className += ' ie10 lt-edge';\n            break;\n        case (11):\n            documentElement.className += ' ie11 lt-edge';\n            break;\n        default:\n            break;\n    }\n}\n\n\nexport const isIE = detect().isIE;\nexport const version = detect().version;\n","/**\n * Fixes wrong viewport behaviour on ieMobile.\n * This function depends on further css styling, that should be present on the site:\n * @-webkit-viewport   { width: device-width; }\n * @-moz-viewport      { width: device-width; }\n * @-ms-viewport       { width: device-width; }\n * @-o-viewport        { width: device-width; }\n * @viewport           { width: device-width; }\n */\n(function ieMobileFix() {\n    if (navigator.userAgent.match(/IEMobile\\/10\\.0/)) {\n        var msViewportStyle = document.createElement('style');\n        msViewportStyle.appendChild(\n            document.createTextNode('@-ms-viewport{width:auto!important}')\n        );\n        document.getElementsByTagName('head')[0].appendChild(msViewportStyle);\n    }\n}());\n","/**\n * This event listener forces iOS safari to display active states on links and buttons.\n * Otherwhise this state wouldn't be applied.\n */\ndocument.addEventListener('touchstart', function() {}, false);\n","import svg4everybody from 'svg4everybody';\nimport { version } from 'util/fixes/ie-detect';\n\n/**\n * Polyfills SVG usage for older browsers and helps using the browser cache for symbols.\n */\ndocument.addEventListener('DOMContentLoaded', () => {\n    const $$container = document.createElement('div');\n    $$container.setAttribute('aria-hidden', 'true');\n    $$container.className = 'u-icon-sprite';\n\n    const $body = document.querySelector('body');\n    const $svg = document.querySelector('img.u-icon-source');\n\n    const url = $svg.getAttribute('data-src');\n    const urlConnector = ~url.indexOf('?') ? '&' : '?';\n    const cacheBustingUrl = `${ url }${ urlConnector }_=${ Date.now() }`;\n\n    if (!$svg) {\n        console.warn(`\n            utils/fixes/svg-symbols: No distinct spritemap source found.\n            selector: ${ $svg.selector }\n            occurrences: ${ $svg.length }\n        `);\n    }\n\n    // Register an event on image load\n    $svg.addEventListener('load', onLoadImg);\n\n    // Load the image\n    $svg.src = url;\n    $svg.removeAttribute('data-src');\n\n    function onLoadImg() {\n        // Load the SVG separately without cache\n        const SVGRequest = new XMLHttpRequest();\n\n        SVGRequest.addEventListener('load', onLoadSVG);\n        SVGRequest.addEventListener('error', onErrorSVG);\n        SVGRequest.addEventListener('abort', onErrorSVG);\n\n        SVGRequest.open('GET', cacheBustingUrl, true);\n        SVGRequest.send();\n    }\n\n    // Handle the loaded, cache-busted SVG\n    function onLoadSVG() {\n        $$container.innerHTML = this.responseText;\n        $body.insertBefore($$container, $body.firstChild);\n\n        if (version >= 9 && version <= 11) {\n            // it is save now to exchange the use tags for IE9+\n            svg4everybody({\n                polyfill: true,\n            });\n        } else {\n            svg4everybody();\n        }\n    \n        globals.state.svgSymbolsLoaded = true;\n    }\n\n    function onErrorSVG(jqXHR, textStatus, errorThrown) {\n        console.log(jqXHR);\n        console.log(textStatus);\n        console.log(errorThrown);\n    }\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","function allSettled(arr) {\n  var P = this;\n  return new P(function(resolve, reject) {\n    if (!(arr && typeof arr.length !== 'undefined')) {\n      return reject(\n        new TypeError(\n          typeof arr +\n            ' ' +\n            arr +\n            ' is not iterable(cannot read property Symbol(Symbol.iterator))'\n        )\n      );\n    }\n    var args = Array.prototype.slice.call(arr);\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n\n    function res(i, val) {\n      if (val && (typeof val === 'object' || typeof val === 'function')) {\n        var then = val.then;\n        if (typeof then === 'function') {\n          then.call(\n            val,\n            function(val) {\n              res(i, val);\n            },\n            function(e) {\n              args[i] = { status: 'rejected', reason: e };\n              if (--remaining === 0) {\n                resolve(args);\n              }\n            }\n          );\n          return;\n        }\n      }\n      args[i] = { status: 'fulfilled', value: val };\n      if (--remaining === 0) {\n        resolve(args);\n      }\n    }\n\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n}\n\nexport default allSettled;\n","/**\n * @constructor\n */\nfunction AggregateError(errors, message) {\n  (this.name = 'AggregateError'), (this.errors = errors);\n  this.message = message || '';\n}\nAggregateError.prototype = Error.prototype;\n\nfunction any(arr) {\n  var P = this;\n  return new P(function(resolve, reject) {\n    if (!(arr && typeof arr.length !== 'undefined')) {\n      return reject(new TypeError('Promise.any accepts an array'));\n    }\n\n    var args = Array.prototype.slice.call(arr);\n    if (args.length === 0) return reject();\n\n    var rejectionReasons = [];\n    for (var i = 0; i < args.length; i++) {\n      try {\n        P.resolve(args[i])\n          .then(resolve)\n          .catch(function(error) {\n            rejectionReasons.push(error);\n            if (rejectionReasons.length === args.length) {\n              reject(\n                new AggregateError(\n                  rejectionReasons,\n                  'All promises were rejected'\n                )\n              );\n            }\n          });\n      } catch (ex) {\n        reject(ex);\n      }\n    }\n  });\n}\n\nexport default any;\n","/**\n * @this {Promise}\n */\nfunction finallyConstructor(callback) {\n  var constructor = this.constructor;\n  return this.then(\n    function(value) {\n      // @ts-ignore\n      return constructor.resolve(callback()).then(function() {\n        return value;\n      });\n    },\n    function(reason) {\n      // @ts-ignore\n      return constructor.resolve(callback()).then(function() {\n        // @ts-ignore\n        return constructor.reject(reason);\n      });\n    }\n  );\n}\n\nexport default finallyConstructor;\n","import promiseFinally from './finally';\nimport allSettled from './allSettled';\nimport any from './any';\n\n// Store setTimeout reference so promise-polyfill will be unaffected by\n// other code modifying setTimeout (like sinon.useFakeTimers())\nvar setTimeoutFunc = setTimeout;\n\nfunction isArray(x) {\n  return Boolean(x && typeof x.length !== 'undefined');\n}\n\nfunction noop() {}\n\n// Polyfill for Function.prototype.bind\nfunction bind(fn, thisArg) {\n  return function() {\n    fn.apply(thisArg, arguments);\n  };\n}\n\n/**\n * @constructor\n * @param {Function} fn\n */\nfunction Promise(fn) {\n  if (!(this instanceof Promise))\n    throw new TypeError('Promises must be constructed via new');\n  if (typeof fn !== 'function') throw new TypeError('not a function');\n  /** @type {!number} */\n  this._state = 0;\n  /** @type {!boolean} */\n  this._handled = false;\n  /** @type {Promise|undefined} */\n  this._value = undefined;\n  /** @type {!Array<!Function>} */\n  this._deferreds = [];\n\n  doResolve(fn, this);\n}\n\nfunction handle(self, deferred) {\n  while (self._state === 3) {\n    self = self._value;\n  }\n  if (self._state === 0) {\n    self._deferreds.push(deferred);\n    return;\n  }\n  self._handled = true;\n  Promise._immediateFn(function() {\n    var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n    if (cb === null) {\n      (self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n      return;\n    }\n    var ret;\n    try {\n      ret = cb(self._value);\n    } catch (e) {\n      reject(deferred.promise, e);\n      return;\n    }\n    resolve(deferred.promise, ret);\n  });\n}\n\nfunction resolve(self, newValue) {\n  try {\n    // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n    if (newValue === self)\n      throw new TypeError('A promise cannot be resolved with itself.');\n    if (\n      newValue &&\n      (typeof newValue === 'object' || typeof newValue === 'function')\n    ) {\n      var then = newValue.then;\n      if (newValue instanceof Promise) {\n        self._state = 3;\n        self._value = newValue;\n        finale(self);\n        return;\n      } else if (typeof then === 'function') {\n        doResolve(bind(then, newValue), self);\n        return;\n      }\n    }\n    self._state = 1;\n    self._value = newValue;\n    finale(self);\n  } catch (e) {\n    reject(self, e);\n  }\n}\n\nfunction reject(self, newValue) {\n  self._state = 2;\n  self._value = newValue;\n  finale(self);\n}\n\nfunction finale(self) {\n  if (self._state === 2 && self._deferreds.length === 0) {\n    Promise._immediateFn(function() {\n      if (!self._handled) {\n        Promise._unhandledRejectionFn(self._value);\n      }\n    });\n  }\n\n  for (var i = 0, len = self._deferreds.length; i < len; i++) {\n    handle(self, self._deferreds[i]);\n  }\n  self._deferreds = null;\n}\n\n/**\n * @constructor\n */\nfunction Handler(onFulfilled, onRejected, promise) {\n  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n  this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n  this.promise = promise;\n}\n\n/**\n * Take a potentially misbehaving resolver function and make sure\n * onFulfilled and onRejected are only called once.\n *\n * Makes no guarantees about asynchrony.\n */\nfunction doResolve(fn, self) {\n  var done = false;\n  try {\n    fn(\n      function(value) {\n        if (done) return;\n        done = true;\n        resolve(self, value);\n      },\n      function(reason) {\n        if (done) return;\n        done = true;\n        reject(self, reason);\n      }\n    );\n  } catch (ex) {\n    if (done) return;\n    done = true;\n    reject(self, ex);\n  }\n}\n\nPromise.prototype['catch'] = function(onRejected) {\n  return this.then(null, onRejected);\n};\n\nPromise.prototype.then = function(onFulfilled, onRejected) {\n  // @ts-ignore\n  var prom = new this.constructor(noop);\n\n  handle(this, new Handler(onFulfilled, onRejected, prom));\n  return prom;\n};\n\nPromise.prototype['finally'] = promiseFinally;\n\nPromise.all = function(arr) {\n  return new Promise(function(resolve, reject) {\n    if (!isArray(arr)) {\n      return reject(new TypeError('Promise.all accepts an array'));\n    }\n\n    var args = Array.prototype.slice.call(arr);\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n\n    function res(i, val) {\n      try {\n        if (val && (typeof val === 'object' || typeof val === 'function')) {\n          var then = val.then;\n          if (typeof then === 'function') {\n            then.call(\n              val,\n              function(val) {\n                res(i, val);\n              },\n              reject\n            );\n            return;\n          }\n        }\n        args[i] = val;\n        if (--remaining === 0) {\n          resolve(args);\n        }\n      } catch (ex) {\n        reject(ex);\n      }\n    }\n\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n};\n\nPromise.any = any;\n\nPromise.allSettled = allSettled;\n\nPromise.resolve = function(value) {\n  if (value && typeof value === 'object' && value.constructor === Promise) {\n    return value;\n  }\n\n  return new Promise(function(resolve) {\n    resolve(value);\n  });\n};\n\nPromise.reject = function(value) {\n  return new Promise(function(resolve, reject) {\n    reject(value);\n  });\n};\n\nPromise.race = function(arr) {\n  return new Promise(function(resolve, reject) {\n    if (!isArray(arr)) {\n      return reject(new TypeError('Promise.race accepts an array'));\n    }\n\n    for (var i = 0, len = arr.length; i < len; i++) {\n      Promise.resolve(arr[i]).then(resolve, reject);\n    }\n  });\n};\n\n// Use polyfill for setImmediate for performance gains\nPromise._immediateFn =\n  // @ts-ignore\n  (typeof setImmediate === 'function' &&\n    function(fn) {\n      // @ts-ignore\n      setImmediate(fn);\n    }) ||\n  function(fn) {\n    setTimeoutFunc(fn, 0);\n  };\n\nPromise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n  if (typeof console !== 'undefined' && console) {\n    console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n  }\n};\n\nexport default Promise;\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n","!function(root, factory) {\n    \"function\" == typeof define && define.amd ? // AMD. Register as an anonymous module unless amdModuleId is set\n    define([], function() {\n        return root.svg4everybody = factory();\n    }) : \"object\" == typeof module && module.exports ? // Node. Does not work with strict CommonJS, but\n    // only CommonJS-like environments that support module.exports,\n    // like Node.\n    module.exports = factory() : root.svg4everybody = factory();\n}(this, function() {\n    /*! svg4everybody v2.1.9 | github.com/jonathantneal/svg4everybody */\n    function embed(parent, svg, target) {\n        // if the target exists\n        if (target) {\n            // create a document fragment to hold the contents of the target\n            var fragment = document.createDocumentFragment(), viewBox = !svg.hasAttribute(\"viewBox\") && target.getAttribute(\"viewBox\");\n            // conditionally set the viewBox on the svg\n            viewBox && svg.setAttribute(\"viewBox\", viewBox);\n            // copy the contents of the clone into the fragment\n            for (// clone the target\n            var clone = target.cloneNode(!0); clone.childNodes.length; ) {\n                fragment.appendChild(clone.firstChild);\n            }\n            // append the fragment into the svg\n            parent.appendChild(fragment);\n        }\n    }\n    function loadreadystatechange(xhr) {\n        // listen to changes in the request\n        xhr.onreadystatechange = function() {\n            // if the request is ready\n            if (4 === xhr.readyState) {\n                // get the cached html document\n                var cachedDocument = xhr._cachedDocument;\n                // ensure the cached html document based on the xhr response\n                cachedDocument || (cachedDocument = xhr._cachedDocument = document.implementation.createHTMLDocument(\"\"), \n                cachedDocument.body.innerHTML = xhr.responseText, xhr._cachedTarget = {}), // clear the xhr embeds list and embed each item\n                xhr._embeds.splice(0).map(function(item) {\n                    // get the cached target\n                    var target = xhr._cachedTarget[item.id];\n                    // ensure the cached target\n                    target || (target = xhr._cachedTarget[item.id] = cachedDocument.getElementById(item.id)), \n                    // embed the target into the svg\n                    embed(item.parent, item.svg, target);\n                });\n            }\n        }, // test the ready state change immediately\n        xhr.onreadystatechange();\n    }\n    function svg4everybody(rawopts) {\n        function oninterval() {\n            // while the index exists in the live <use> collection\n            for (// get the cached <use> index\n            var index = 0; index < uses.length; ) {\n                // get the current <use>\n                var use = uses[index], parent = use.parentNode, svg = getSVGAncestor(parent), src = use.getAttribute(\"xlink:href\") || use.getAttribute(\"href\");\n                if (!src && opts.attributeName && (src = use.getAttribute(opts.attributeName)), \n                svg && src) {\n                    if (polyfill) {\n                        if (!opts.validate || opts.validate(src, svg, use)) {\n                            // remove the <use> element\n                            parent.removeChild(use);\n                            // parse the src and get the url and id\n                            var srcSplit = src.split(\"#\"), url = srcSplit.shift(), id = srcSplit.join(\"#\");\n                            // if the link is external\n                            if (url.length) {\n                                // get the cached xhr request\n                                var xhr = requests[url];\n                                // ensure the xhr request exists\n                                xhr || (xhr = requests[url] = new XMLHttpRequest(), xhr.open(\"GET\", url), xhr.send(), \n                                xhr._embeds = []), // add the svg and id as an item to the xhr embeds list\n                                xhr._embeds.push({\n                                    parent: parent,\n                                    svg: svg,\n                                    id: id\n                                }), // prepare the xhr ready state change event\n                                loadreadystatechange(xhr);\n                            } else {\n                                // embed the local id into the svg\n                                embed(parent, svg, document.getElementById(id));\n                            }\n                        } else {\n                            // increase the index when the previous value was not \"valid\"\n                            ++index, ++numberOfSvgUseElementsToBypass;\n                        }\n                    }\n                } else {\n                    // increase the index when the previous value was not \"valid\"\n                    ++index;\n                }\n            }\n            // continue the interval\n            (!uses.length || uses.length - numberOfSvgUseElementsToBypass > 0) && requestAnimationFrame(oninterval, 67);\n        }\n        var polyfill, opts = Object(rawopts), newerIEUA = /\\bTrident\\/[567]\\b|\\bMSIE (?:9|10)\\.0\\b/, webkitUA = /\\bAppleWebKit\\/(\\d+)\\b/, olderEdgeUA = /\\bEdge\\/12\\.(\\d+)\\b/, edgeUA = /\\bEdge\\/.(\\d+)\\b/, inIframe = window.top !== window.self;\n        polyfill = \"polyfill\" in opts ? opts.polyfill : newerIEUA.test(navigator.userAgent) || (navigator.userAgent.match(olderEdgeUA) || [])[1] < 10547 || (navigator.userAgent.match(webkitUA) || [])[1] < 537 || edgeUA.test(navigator.userAgent) && inIframe;\n        // create xhr requests object\n        var requests = {}, requestAnimationFrame = window.requestAnimationFrame || setTimeout, uses = document.getElementsByTagName(\"use\"), numberOfSvgUseElementsToBypass = 0;\n        // conditionally start the interval if the polyfill is active\n        polyfill && oninterval();\n    }\n    function getSVGAncestor(node) {\n        for (var svg = node; \"svg\" !== svg.nodeName.toLowerCase() && (svg = svg.parentNode); ) {}\n        return svg;\n    }\n    return svg4everybody;\n});","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n"],"sourceRoot":""}