text: /*!
   * modernizr v3.6.0
   * Build https://modernizr.com/download?-setclasses-shiv-dontmin
   *
   * Copyright (c)
   *  Faruk Ates
   *  Paul Irish
   *  Alex Sexton
   *  Ryan Seddon
   *  Patrick Kettner
   *  Stu Cox
   *  Richard Herrera
  
   * MIT License
   */
  
  /*
   * Modernizr tests which native CSS3 and HTML5 features are available in the
   * current UA and makes the results available to you in two ways: as properties on
   * a global `Modernizr` object, and as classes on the `<html>` element. This
   * information allows you to progressively enhance your pages with a granular level
   * of control over the experience.
   */
  
  (function(window, document, undefined) {
    var classes = [];
  
    /**
     * is returns a boolean if the typeof an obj is exactly type.
     *
     * @access private
     * @function is
     * @param {*} obj - A thing we want to check the type of
     * @param {string} type - A string to compare the typeof against
     * @returns {boolean}
     */
  
    function is(obj, type) {
      return typeof obj === type;
    }
    /**
     * docElement is a convenience wrapper to grab the root element of the document
     *
     * @access private
     * @returns {HTMLElement|SVGElement} The root element of the document
     */
  
    var docElement = document.documentElement;
  
    /**
     * A convenience helper to check if the document we are running in is an SVG document
     *
     * @access private
     * @returns {boolean}
     */
  
    var isSVG = docElement.nodeName.toLowerCase() === 'svg';
  
    /**
     * @optionName html5shiv
     * @optionProp html5shiv
     */
  
    // Take the html5 variable out of the html5shiv scope so we can return it.
    var html5;
    if (!isSVG) {
      /**
       * @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
       */
      (function(window, document) {
        /** version */
        var version = '3.7.3';
  
        /** Preset options */
        var options = window.html5 || {};
  
        /** Used to skip problem elements */
        var reSkip = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i;
  
        /** Not all elements can be cloned in IE **/
        var saveClones = /^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i;
  
        /** Detect whether the browser supports default html5 styles */
        var supportsHtml5Styles;
  
        /** Name of the expando, to work with multiple documents or to re-shiv one document */
        var expando = '_html5shiv';
  
        /** The id for the the documents expando */
        var expanID = 0;
  
        /** Cached data for each document */
        var expandoData = {};
  
        /** Detect whether the browser supports unknown elements */
        var supportsUnknownElements;
  
        (function() {
          try {
            var a = document.createElement('a');
            a.innerHTML = '<xyz></xyz>';
            //if the hidden property is implemented we can assume, that the browser supports basic HTML5 Styles
            supportsHtml5Styles = 'hidden' in a;
  
            supportsUnknownElements =
              a.childNodes.length == 1 ||
              (function() {
                // assign a false positive if unable to shiv
                document.createElement('a');
                var frag = document.createDocumentFragment();
                return (
                  typeof frag.cloneNode == 'undefined' ||
                  typeof frag.createDocumentFragment == 'undefined' ||
                  typeof frag.createElement == 'undefined'
                );
              })();
          } catch (e) {
            // assign a false positive if detection fails => unable to shiv
            supportsHtml5Styles = true;
            supportsUnknownElements = true;
          }
        })();
  
        /*--------------------------------------------------------------------------*/
  
        /**
         * Creates a style sheet with the given CSS text and adds it to the document.
         * @private
         * @param {Document} ownerDocument The document.
         * @param {String} cssText The CSS text.
         * @returns {StyleSheet} The style element.
         */
        function addStyleSheet(ownerDocument, cssText) {
          var p = ownerDocument.createElement('p'),
            parent =
              ownerDocument.getElementsByTagName('head')[0] ||
              ownerDocument.documentElement;
  
          p.innerHTML = 'x<style>' + cssText + '</style>';
          return parent.insertBefore(p.lastChild, parent.firstChild);
        }
  
        /**
         * Returns the value of `html5.elements` as an array.
         * @private
         * @returns {Array} An array of shived element node names.
         */
        function getElements() {
          var elements = html5.elements;
          return typeof elements == 'string' ? elements.split(' ') : elements;
        }
  
        /**
         * Extends the built-in list of html5 elements
         * @memberOf html5
         * @param {String|Array} newElements whitespace separated list or array of new element names to shiv
         * @param {Document} ownerDocument The context document.
         */
        function addElements(newElements, ownerDocument) {
          var elements = html5.elements;
          if (typeof elements != 'string') {
            elements = elements.join(' ');
          }
          if (typeof newElements != 'string') {
            newElements = newElements.join(' ');
          }
          html5.elements = elements + ' ' + newElements;
          shivDocument(ownerDocument);
        }
  
        /**
         * Returns the data associated to the given document
         * @private
         * @param {Document} ownerDocument The document.
         * @returns {Object} An object of data.
         */
        function getExpandoData(ownerDocument) {
          var data = expandoData[ownerDocument[expando]];
          if (!data) {
            data = {};
            expanID++;
            ownerDocument[expando] = expanID;
            expandoData[expanID] = data;
          }
          return data;
        }
  
        /**
         * returns a shived element for the given nodeName and document
         * @memberOf html5
         * @param {String} nodeName name of the element
         * @param {Document|DocumentFragment} ownerDocument The context document.
         * @returns {Object} The shived element.
         */
        function createElement(nodeName, ownerDocument, data) {
          if (!ownerDocument) {
            ownerDocument = document;
          }
          if (supportsUnknownElements) {
            return ownerDocument.createElement(nodeName);
          }
          if (!data) {
            data = getExpandoData(ownerDocument);
          }
          var node;
  
          if (data.cache[nodeName]) {
            node = data.cache[nodeName].cloneNode();
          } else if (saveClones.test(nodeName)) {
            node = (data.cache[nodeName] = data.createElem(nodeName)).cloneNode();
          } else {
            node = data.createElem(nodeName);
          }
  
          // Avoid adding some elements to fragments in IE < 9 because
          // * Attributes like `name` or `type` cannot be set/changed once an element
          //   is inserted into a document/fragment
          // * Link elements with `src` attributes that are inaccessible, as with
          //   a 403 response, will cause the tab/window to crash
          // * Script elements appended to fragments will execute when their `src`
          //   or `text` property is set
          return node.canHaveChildren && !reSkip.test(nodeName) && !node.tagUrn
            ? data.frag.appendChild(node)
            : node;
        }
  
        /**
         * returns a shived DocumentFragment for the given document
         * @memberOf html5
         * @param {Document} ownerDocument The context document.
         * @returns {Object} The shived DocumentFragment.
         */
        function createDocumentFragment(ownerDocument, data) {
          if (!ownerDocument) {
            ownerDocument = document;
          }
          if (supportsUnknownElements) {
            return ownerDocument.createDocumentFragment();
          }
          data = data || getExpandoData(ownerDocument);
          var clone = data.frag.cloneNode(),
            i = 0,
            elems = getElements(),
            l = elems.length;
          for (; i < l; i++) {
            clone.createElement(elems[i]);
          }
          return clone;
        }
  
        /**
         * Shivs the `createElement` and `createDocumentFragment` methods of the document.
         * @private
         * @param {Document|DocumentFragment} ownerDocument The document.
         * @param {Object} data of the document.
         */
        function shivMethods(ownerDocument, data) {
          if (!data.cache) {
            data.cache = {};
            data.createElem = ownerDocument.createElement;
            data.createFrag = ownerDocument.createDocumentFragment;
            data.frag = data.createFrag();
          }
  
          ownerDocument.createElement = function(nodeName) {
            //abort shiv
            if (!html5.shivMethods) {
              return data.createElem(nodeName);
            }
            return createElement(nodeName, ownerDocument, data);
          };
  
          ownerDocument.createDocumentFragment = Function(
            'h,f',
            'return function(){' +
              'var n=f.cloneNode(),c=n.createElement;' +
              'h.shivMethods&&(' +
              // unroll the `createElement` calls
              getElements()
                .join()
                .replace(/[\w\-:]+/g, function(nodeName) {
                  data.createElem(nodeName);
                  data.frag.createElement(nodeName);
                  return 'c("' + nodeName + '")';
                }) +
              ');return n}'
          )(html5, data.frag);
        }
  
        /*--------------------------------------------------------------------------*/
  
        /**
         * Shivs the given document.
         * @memberOf html5
         * @param {Document} ownerDocument The document to shiv.
         * @returns {Document} The shived document.
         */
        function shivDocument(ownerDocument) {
          if (!ownerDocument) {
            ownerDocument = document;
          }
          var data = getExpandoData(ownerDocument);
  
          if (html5.shivCSS && !supportsHtml5Styles && !data.hasCSS) {
            data.hasCSS = !!addStyleSheet(
              ownerDocument,
              // corrects block display not defined in IE6/7/8/9
              'article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}' +
                // adds styling not present in IE6/7/8/9
                'mark{background:#FF0;color:#000}' +
                // hides non-rendered elements
                'template{display:none}'
            );
          }
          if (!supportsUnknownElements) {
            shivMethods(ownerDocument, data);
          }
          return ownerDocument;
        }
  
        /*--------------------------------------------------------------------------*/
  
        /**
         * The `html5` object is exposed so that more elements can be shived and
         * existing shiving can be detected on iframes.
         * @type Object
         * @example
         *
         * // options can be changed before the script is included
         * html5 = { 'elements': 'mark section', 'shivCSS': false, 'shivMethods': false };
         */
        var html5 = {
          /**
           * An array or space separated string of node names of the elements to shiv.
           * @memberOf html5
           * @type Array|String
           */
          elements:
            options.elements ||
            'abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video',
  
          /**
           * current version of html5shiv
           */
          version: version,
  
          /**
           * A flag to indicate that the HTML5 style sheet should be inserted.
           * @memberOf html5
           * @type Boolean
           */
          shivCSS: options.shivCSS !== false,
  
          /**
           * Is equal to true if a browser supports creating unknown/HTML5 elements
           * @memberOf html5
           * @type boolean
           */
          supportsUnknownElements: supportsUnknownElements,
  
          /**
           * A flag to indicate that the document's `createElement` and `createDocumentFragment`
           * methods should be overwritten.
           * @memberOf html5
           * @type Boolean
           */
          shivMethods: options.shivMethods !== false,
  
          /**
           * A string to describe the type of `html5` object ("default" or "default print").
           * @memberOf html5
           * @type String
           */
          type: 'default',
  
          // shivs the document according to the specified `html5` object options
          shivDocument: shivDocument,
  
          //creates a shived element
          createElement: createElement,
  
          //creates a shived documentFragment
          createDocumentFragment: createDocumentFragment,
  
          //extends list of elements
          addElements: addElements,
        };
  
        /*--------------------------------------------------------------------------*/
  
        // expose html5
        window.html5 = html5;
  
        // shiv the document
        shivDocument(document);
  
        if (typeof module == 'object' && module.exports) {
          module.exports = html5;
        }
      })(typeof window !== 'undefined' ? window : this, document);
    }
    var tests = [];
  
    /**
     *
     * ModernizrProto is the constructor for Modernizr
     *
     * @class
     * @access public
     */
  
    var ModernizrProto = {
      // The current version, dummy
      _version: '3.6.0',
  
      // Any settings that don't work as separate modules
      // can go in here as configuration.
      _config: {
        classPrefix: '',
        enableClasses: true,
        enableJSClass: true,
        usePrefixes: true,
      },
  
      // Queue of tests
      _q: [],
  
      // Stub these for people who are listening
      on: function(test, cb) {
        // I don't really think people should do this, but we can
        // safe guard it a bit.
        // -- NOTE:: this gets WAY overridden in src/addTest for actual async tests.
        // This is in case people listen to synchronous tests. I would leave it out,
        // but the code to *disallow* sync tests in the real version of this
        // function is actually larger than this.
        var self = this;
        setTimeout(function() {
          cb(self[test]);
        }, 0);
      },
  
      addTest: function(name, fn, options) {
        tests.push({ name: name, fn: fn, options: options });
      },
  
      addAsyncTest: function(fn) {
        tests.push({ name: null, fn: fn });
      },
    };
  
    // Fake some of Object.create so we can force non test results to be non "own" properties.
    var Modernizr = function() {};
    Modernizr.prototype = ModernizrProto;
  
    // Leak modernizr globally when you `require` it rather than force it here.
    // Overwrite name so constructor name is nicer :D
    Modernizr = new Modernizr();
  
    /**
     * Run through all tests and detect their support in the current UA.
     *
     * @access private
     */
  
    function testRunner() {
      var featureNames;
      var feature;
      var aliasIdx;
      var result;
      var nameIdx;
      var featureName;
      var featureNameSplit;
  
      for (var featureIdx in tests) {
        if (tests.hasOwnProperty(featureIdx)) {
          featureNames = [];
          feature = tests[featureIdx];
          // run the test, throw the return value into the Modernizr,
          // then based on that boolean, define an appropriate className
          // and push it into an array of classes we'll join later.
          //
          // If there is no name, it's an 'async' test that is run,
          // but not directly added to the object. That should
          // be done with a post-run addTest call.
          if (feature.name) {
            featureNames.push(feature.name.toLowerCase());
  
            if (
              feature.options &&
              feature.options.aliases &&
              feature.options.aliases.length
            ) {
              // Add all the aliases into the names list
              for (
                aliasIdx = 0;
                aliasIdx < feature.options.aliases.length;
                aliasIdx++
              ) {
                featureNames.push(
                  feature.options.aliases[aliasIdx].toLowerCase()
                );
              }
            }
          }
  
          // Run the test, or use the raw value if it's not a function
          result = is(feature.fn, 'function') ? feature.fn() : feature.fn;
  
          // Set each of the names on the Modernizr object
          for (nameIdx = 0; nameIdx < featureNames.length; nameIdx++) {
            featureName = featureNames[nameIdx];
            // Support dot properties as sub tests. We don't do checking to make sure
            // that the implied parent tests have been added. You must call them in
            // order (either in the test, or make the parent test a dependency).
            //
            // Cap it to TWO to make the logic simple and because who needs that kind of subtesting
            // hashtag famous last words
            featureNameSplit = featureName.split('.');
  
            if (featureNameSplit.length === 1) {
              Modernizr[featureNameSplit[0]] = result;
            } else {
              // cast to a Boolean, if not one already
              if (
                Modernizr[featureNameSplit[0]] &&
                !(Modernizr[featureNameSplit[0]] instanceof Boolean)
              ) {
                Modernizr[featureNameSplit[0]] = new Boolean(
                  Modernizr[featureNameSplit[0]]
                );
              }
  
              Modernizr[featureNameSplit[0]][featureNameSplit[1]] = result;
            }
  
            classes.push((result ? '' : 'no-') + featureNameSplit.join('-'));
          }
        }
      }
    }
    /**
     * setClasses takes an array of class names and adds them to the root element
     *
     * @access private
     * @function setClasses
     * @param {string[]} classes - Array of class names
     */
  
    // Pass in an and array of class names, e.g.:
    //  ['no-webp', 'borderradius', ...]
    function setClasses(classes) {
      var className = docElement.className;
      var classPrefix = Modernizr._config.classPrefix || '';
  
      if (isSVG) {
        className = className.baseVal;
      }
  
      // Change `no-js` to `js` (independently of the `enableClasses` option)
      // Handle classPrefix on this too
      if (Modernizr._config.enableJSClass) {
        var reJS = new RegExp('(^|\\s)' + classPrefix + 'no-js(\\s|$)');
        className = className.replace(reJS, '$1' + classPrefix + 'js$2');
      }
  
      if (Modernizr._config.enableClasses) {
        // Add the new classes
        className += ' ' + classPrefix + classes.join(' ' + classPrefix);
        if (isSVG) {
          docElement.className.baseVal = className;
        } else {
          docElement.className = className;
        }
      }
    }
  
    // Run each test
    testRunner();
  
    // Remove the "no-js" class if it exists
    setClasses(classes);
  
    delete ModernizrProto.addTest;
    delete ModernizrProto.addAsyncTest;
  
    // Run the things that are supposed to run after the tests
    for (var i = 0; i < Modernizr._q.length; i++) {
      Modernizr._q[i]();
    }
  
    // Leak Modernizr namespace
    window.Modernizr = Modernizr;
  })(window, document);
  