text: module.exports =
  /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = require('../ssr-module-cache.js');
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		var threw = true;
  /******/ 		try {
  /******/ 			modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/ 			threw = false;
  /******/ 		} finally {
  /******/ 			if(threw) delete installedModules[moduleId];
  /******/ 		}
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 4);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ "0G5g":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.cancelIdleCallback = exports.requestIdleCallback = void 0;
  
  const requestIdleCallback = typeof self !== 'undefined' && self.requestIdleCallback || function (cb) {
    let start = Date.now();
    return setTimeout(function () {
      cb({
        didTimeout: false,
        timeRemaining: function () {
          return Math.max(0, 50 - (Date.now() - start));
        }
      });
    }, 1);
  };
  
  exports.requestIdleCallback = requestIdleCallback;
  
  const cancelIdleCallback = typeof self !== 'undefined' && self.cancelIdleCallback || function (id) {
    return clearTimeout(id);
  };
  
  exports.cancelIdleCallback = cancelIdleCallback;
  
  /***/ }),
  
  /***/ "2+G7":
  /***/ (function(module, exports) {
  
  module.exports = require("styled-jsx/server");
  
  /***/ }),
  
  /***/ "24z6":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var _interopRequireWildcard = __webpack_require__("284h");
  
  var _interopRequireDefault = __webpack_require__("TqRt");
  
  exports.__esModule = true;
  exports.initScriptLoader = initScriptLoader;
  exports.default = void 0;
  
  var _extends2 = _interopRequireDefault(__webpack_require__("pVnL"));
  
  var _objectWithoutPropertiesLoose2 = _interopRequireDefault(__webpack_require__("8OQS"));
  
  var _react = _interopRequireWildcard(__webpack_require__("cDcd"));
  
  var _headManagerContext = __webpack_require__("Y8yu");
  
  var _headManager = __webpack_require__("DqTX");
  
  var _requestIdleCallback = __webpack_require__("0G5g");
  
  const ScriptCache = new Map();
  const LoadCache = new Set();
  const ignoreProps = ['onLoad', 'dangerouslySetInnerHTML', 'children', 'onError', 'strategy', 'preload'];
  
  const loadScript = props => {
    const {
      src,
      id,
      onLoad = () => {},
      dangerouslySetInnerHTML,
      children = '',
      onError
    } = props;
    const cacheKey = id || src;
  
    if (ScriptCache.has(src)) {
      if (!LoadCache.has(cacheKey)) {
        LoadCache.add(cacheKey); // Execute onLoad since the script loading has begun
  
        ScriptCache.get(src).then(onLoad, onError);
      }
  
      return;
    }
  
    const el = document.createElement('script');
    const loadPromise = new Promise((resolve, reject) => {
      el.addEventListener('load', function () {
        resolve();
  
        if (onLoad) {
          onLoad.call(this);
        }
      });
      el.addEventListener('error', function () {
        reject();
  
        if (onError) {
          onError();
        }
      });
    });
  
    if (src) {
      ScriptCache.set(src, loadPromise);
      LoadCache.add(cacheKey);
    }
  
    if (dangerouslySetInnerHTML) {
      el.innerHTML = dangerouslySetInnerHTML.__html || '';
    } else if (children) {
      el.textContent = typeof children === 'string' ? children : Array.isArray(children) ? children.join('') : '';
    } else if (src) {
      el.src = src;
    }
  
    for (const [k, value] of Object.entries(props)) {
      if (value === undefined || ignoreProps.includes(k)) {
        continue;
      }
  
      const attr = _headManager.DOMAttributeNames[k] || k.toLowerCase();
      el.setAttribute(attr, value);
    }
  
    document.body.appendChild(el);
  };
  
  function handleClientScriptLoad(props) {
    const {
      strategy = 'defer'
    } = props;
  
    if (strategy === 'defer') {
      loadScript(props);
    } else if (strategy === 'lazy') {
      window.addEventListener('load', () => {
        (0, _requestIdleCallback.requestIdleCallback)(() => loadScript(props));
      });
    }
  }
  
  function loadLazyScript(props) {
    if (document.readyState === 'complete') {
      (0, _requestIdleCallback.requestIdleCallback)(() => loadScript(props));
    } else {
      window.addEventListener('load', () => {
        (0, _requestIdleCallback.requestIdleCallback)(() => loadScript(props));
      });
    }
  }
  
  function initScriptLoader(scriptLoaderItems) {
    scriptLoaderItems.forEach(handleClientScriptLoad);
  }
  
  function Script(props) {
    const {
      src = '',
      onLoad = () => {},
      dangerouslySetInnerHTML,
      children = '',
      strategy = 'defer',
      onError,
      preload = false
    } = props,
          restProps = (0, _objectWithoutPropertiesLoose2.default)(props, ["src", "onLoad", "dangerouslySetInnerHTML", "children", "strategy", "onError", "preload"]); // Context is available only during SSR
  
    const {
      updateScripts,
      scripts
    } = (0, _react.useContext)(_headManagerContext.HeadManagerContext);
    (0, _react.useEffect)(() => {
      if (strategy === 'defer') {
        loadScript(props);
      } else if (strategy === 'lazy') {
        loadLazyScript(props);
      }
    }, [props, strategy]);
  
    if (true) {
      return null;
    }
  
    if (strategy === 'dangerouslyBlockRendering') {
      const syncProps = (0, _extends2.default)({}, restProps);
  
      for (const [k, value] of Object.entries({
        src,
        onLoad,
        onError,
        dangerouslySetInnerHTML,
        children
      })) {
        if (!value) {
          continue;
        }
  
        if (k === 'children') {
          syncProps.dangerouslySetInnerHTML = {
            __html: typeof value === 'string' ? value : Array.isArray(value) ? value.join('') : ''
          };
        } else {
          ;
          syncProps[k] = value;
        }
      }
  
      return /*#__PURE__*/_react.default.createElement("script", syncProps);
    } else if (strategy === 'defer') {
      if (updateScripts && preload) {
        scripts.defer = (scripts.defer || []).concat([src]);
        updateScripts(scripts);
      }
    } else if (strategy === 'eager') {
      if (updateScripts) {
        scripts.eager = (scripts.eager || []).concat([(0, _extends2.default)({
          src,
          onLoad,
          onError
        }, restProps)]);
        updateScripts(scripts);
      }
    }
  
    return null;
  }
  
  var _default = Script;
  exports.default = _default;
  
  /***/ }),
  
  /***/ "284h":
  /***/ (function(module, exports, __webpack_require__) {
  
  var _typeof = __webpack_require__("cDf5");
  
  function _getRequireWildcardCache() {
    if (typeof WeakMap !== "function") return null;
    var cache = new WeakMap();
  
    _getRequireWildcardCache = function _getRequireWildcardCache() {
      return cache;
    };
  
    return cache;
  }
  
  function _interopRequireWildcard(obj) {
    if (obj && obj.__esModule) {
      return obj;
    }
  
    if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
      return {
        "default": obj
      };
    }
  
    var cache = _getRequireWildcardCache();
  
    if (cache && cache.has(obj)) {
      return cache.get(obj);
    }
  
    var newObj = {};
    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
  
    for (var key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
  
        if (desc && (desc.get || desc.set)) {
          Object.defineProperty(newObj, key, desc);
        } else {
          newObj[key] = obj[key];
        }
      }
    }
  
    newObj["default"] = obj;
  
    if (cache) {
      cache.set(obj, newObj);
    }
  
    return newObj;
  }
  
  module.exports = _interopRequireWildcard;
  
  /***/ }),
  
  /***/ 4:
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__("VDXt");
  
  
  /***/ }),
  
  /***/ "8OQS":
  /***/ (function(module, exports) {
  
  function _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;
  
    for (i = 0; i < sourceKeys.length; i++) {
      key = sourceKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      target[key] = source[key];
    }
  
    return target;
  }
  
  module.exports = _objectWithoutPropertiesLoose;
  
  /***/ }),
  
  /***/ "AXZJ":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  exports.__esModule=true;exports.htmlEscapeJsonString=htmlEscapeJsonString;// This utility is based on https://github.com/zertosh/htmlescape
  // License: https://github.com/zertosh/htmlescape/blob/0527ca7156a524d256101bb310a9f970f63078ad/LICENSE
  const ESCAPE_LOOKUP={'&':'\\u0026','>':'\\u003e','<':'\\u003c','\u2028':'\\u2028','\u2029':'\\u2029'};const ESCAPE_REGEX=/[&><\u2028\u2029]/g;function htmlEscapeJsonString(str){return str.replace(ESCAPE_REGEX,match=>ESCAPE_LOOKUP[match]);}
  //# sourceMappingURL=htmlescape.js.map
  
  /***/ }),
  
  /***/ "DqTX":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.default = initHeadManager;
  exports.DOMAttributeNames = void 0;
  const DOMAttributeNames = {
    acceptCharset: 'accept-charset',
    className: 'class',
    htmlFor: 'for',
    httpEquiv: 'http-equiv',
    noModule: 'noModule'
  };
  exports.DOMAttributeNames = DOMAttributeNames;
  
  function reactElementToDOM({
    type,
    props
  }) {
    const el = document.createElement(type);
  
    for (const p in props) {
      if (!props.hasOwnProperty(p)) continue;
      if (p === 'children' || p === 'dangerouslySetInnerHTML') continue; // we don't render undefined props to the DOM
  
      if (props[p] === undefined) continue;
      const attr = DOMAttributeNames[p] || p.toLowerCase();
  
      if (type === 'script' && (attr === 'async' || attr === 'defer' || attr === 'noModule')) {
        ;
        el[attr] = !!props[p];
      } else {
        el.setAttribute(attr, props[p]);
      }
    }
  
    const {
      children,
      dangerouslySetInnerHTML
    } = props;
  
    if (dangerouslySetInnerHTML) {
      el.innerHTML = dangerouslySetInnerHTML.__html || '';
    } else if (children) {
      el.textContent = typeof children === 'string' ? children : Array.isArray(children) ? children.join('') : '';
    }
  
    return el;
  }
  
  function updateElements(type, components) {
    const headEl = document.getElementsByTagName('head')[0];
    const headCountEl = headEl.querySelector('meta[name=next-head-count]');
  
    if (false) {}
  
    const headCount = Number(headCountEl.content);
    const oldTags = [];
  
    for (let i = 0, j = headCountEl.previousElementSibling; i < headCount; i++, j = j.previousElementSibling) {
      if (j.tagName.toLowerCase() === type) {
        oldTags.push(j);
      }
    }
  
    const newTags = components.map(reactElementToDOM).filter(newTag => {
      for (let k = 0, len = oldTags.length; k < len; k++) {
        const oldTag = oldTags[k];
  
        if (oldTag.isEqualNode(newTag)) {
          oldTags.splice(k, 1);
          return false;
        }
      }
  
      return true;
    });
    oldTags.forEach(t => t.parentNode.removeChild(t));
    newTags.forEach(t => headEl.insertBefore(t, headCountEl));
    headCountEl.content = (headCount - oldTags.length + newTags.length).toString();
  }
  
  function initHeadManager() {
    let updatePromise = null;
    return {
      mountedInstances: new Set(),
      updateHead: head => {
        const promise = updatePromise = Promise.resolve().then(() => {
          if (promise !== updatePromise) return;
          updatePromise = null;
          const tags = {};
          head.forEach(h => {
            const components = tags[h.type] || [];
            components.push(h);
            tags[h.type] = components;
          });
          const titleComponent = tags.title ? tags.title[0] : null;
          let title = '';
  
          if (titleComponent) {
            const {
              children
            } = titleComponent.props;
            title = typeof children === 'string' ? children : Array.isArray(children) ? children.join('') : '';
          }
  
          if (title !== document.title) document.title = title;
          ['meta', 'base', 'link', 'style', 'script'].forEach(type => {
            updateElements(type, tags[type] || []);
          });
        });
      }
    };
  }
  
  /***/ }),
  
  /***/ "TqRt":
  /***/ (function(module, exports) {
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      "default": obj
    };
  }
  
  module.exports = _interopRequireDefault;
  
  /***/ }),
  
  /***/ "UJjI":
  /***/ (function(module, exports) {
  
  module.exports = require("next/dist/next-server/lib/constants.js");
  
  /***/ }),
  
  /***/ "VDXt":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
  
  function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
  
  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
  
  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
  
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  exports.__esModule = true;
  exports.Html = Html;
  exports.Main = Main;
  exports.NextScript = exports.Head = exports.default = void 0;
  
  var _propTypes = _interopRequireDefault(__webpack_require__("rf6O"));
  
  var _react = _interopRequireWildcard(__webpack_require__("cDcd"));
  
  var _server = _interopRequireDefault(__webpack_require__("2+G7"));
  
  var _constants = __webpack_require__("UJjI");
  
  var _documentContext = __webpack_require__("nMq/");
  
  var _utils = __webpack_require__("kYf9");
  
  exports.DocumentContext = _utils.DocumentContext;
  exports.DocumentInitialProps = _utils.DocumentInitialProps;
  exports.DocumentProps = _utils.DocumentProps;
  
  var _getPageFiles = __webpack_require__("vHio");
  
  var _utils2 = __webpack_require__("ri/Y");
  
  var _htmlescape = __webpack_require__("AXZJ");
  
  var _experimentalScript = _interopRequireDefault(__webpack_require__("24z6"));
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }
  
  function _getRequireWildcardCache() {
    if (typeof WeakMap !== "function") return null;
    var cache = new WeakMap();
  
    _getRequireWildcardCache = function () {
      return cache;
    };
  
    return cache;
  }
  
  function _interopRequireWildcard(obj) {
    if (obj && obj.__esModule) {
      return obj;
    }
  
    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
      return {
        default: obj
      };
    }
  
    var cache = _getRequireWildcardCache();
  
    if (cache && cache.has(obj)) {
      return cache.get(obj);
    }
  
    var newObj = {};
    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
  
    for (var key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
  
        if (desc && (desc.get || desc.set)) {
          Object.defineProperty(newObj, key, desc);
        } else {
          newObj[key] = obj[key];
        }
      }
    }
  
    newObj.default = obj;
  
    if (cache) {
      cache.set(obj, newObj);
    }
  
    return newObj;
  }
  
  function dedupe(bundles) {
    const files = new Set();
    const kept = [];
  
    for (const bundle of bundles) {
      if (files.has(bundle.file)) continue;
      files.add(bundle.file);
      kept.push(bundle);
    }
  
    return kept;
  }
  
  function getDocumentFiles(buildManifest, pathname, inAmpMode) {
    const sharedFiles = (0, _getPageFiles.getPageFiles)(buildManifest, '/_app');
    const pageFiles = inAmpMode ? [] : (0, _getPageFiles.getPageFiles)(buildManifest, pathname);
    return {
      sharedFiles,
      pageFiles,
      allFiles: [...new Set([...sharedFiles, ...pageFiles])]
    };
  }
  /**
  * `Document` component handles the initial `document` markup and renders only on the server side.
  * Commonly used for implementing server side rendering for `css-in-js` libraries.
  */
  
  
  class Document extends _react.Component {
    /**
    * `getInitialProps` hook returns the context object with the addition of `renderPage`.
    * `renderPage` callback executes `React` rendering logic synchronously to support server-rendering wrappers
    */
    static async getInitialProps(ctx) {
      const enhanceApp = App => {
        return props => /*#__PURE__*/_react.default.createElement(App, props);
      };
  
      const {
        html,
        head
      } = await ctx.renderPage({
        enhanceApp
      });
      const styles = [...(0, _server.default)()];
      return {
        html,
        head,
        styles
      };
    }
  
    static renderDocument(DocumentComponent, props) {
      return /*#__PURE__*/_react.default.createElement(_documentContext.DocumentContext.Provider, {
        value: props
      }, /*#__PURE__*/_react.default.createElement(DocumentComponent, props));
    }
  
    render() {
      return /*#__PURE__*/_react.default.createElement(Html, null, /*#__PURE__*/_react.default.createElement(Head, null), /*#__PURE__*/_react.default.createElement("body", null, /*#__PURE__*/_react.default.createElement(Main, null), /*#__PURE__*/_react.default.createElement(NextScript, null)));
    }
  
  }
  
  exports.default = Document;
  Document.headTagsMiddleware =  false ? undefined : () => [];
  
  function Html(props) {
    const {
      inAmpMode,
      docComponentsRendered,
      locale
    } = (0, _react.useContext)(_documentContext.DocumentContext);
    docComponentsRendered.Html = true;
    return /*#__PURE__*/_react.default.createElement("html", Object.assign({}, props, {
      lang: props.lang || locale || undefined,
      amp: inAmpMode ? '' : undefined,
      "data-ampdevmode": inAmpMode && false ? '' : undefined
    }));
  }
  
  class Head extends _react.Component {
    constructor(...args) {
      super(...args);
      this.context = void 0;
    }
  
    getCssLinks(files) {
      const {
        assetPrefix,
        devOnlyCacheBusterQueryString,
        dynamicImports
      } = this.context;
      const cssFiles = files.allFiles.filter(f => f.endsWith('.css'));
      const sharedFiles = new Set(files.sharedFiles); // Unmanaged files are CSS files that will be handled directly by the
      // webpack runtime (`mini-css-extract-plugin`).
  
      let unmangedFiles = new Set([]);
      let dynamicCssFiles = dedupe(dynamicImports.filter(f => f.file.endsWith('.css'))).map(f => f.file);
  
      if (dynamicCssFiles.length) {
        const existing = new Set(cssFiles);
        dynamicCssFiles = dynamicCssFiles.filter(f => !(existing.has(f) || sharedFiles.has(f)));
        unmangedFiles = new Set(dynamicCssFiles);
        cssFiles.push(...dynamicCssFiles);
      }
  
      let cssLinkElements = [];
      cssFiles.forEach(file => {
        const isSharedFile = sharedFiles.has(file);
  
        if (true) {
          cssLinkElements.push( /*#__PURE__*/_react.default.createElement("link", {
            key: `${file}-preload`,
            nonce: this.props.nonce,
            rel: "preload",
            href: `${assetPrefix}/_next/${encodeURI(file)}${devOnlyCacheBusterQueryString}`,
            as: "style",
            crossOrigin: this.props.crossOrigin || undefined
          }));
        }
  
        const isUnmanagedFile = unmangedFiles.has(file);
        cssLinkElements.push( /*#__PURE__*/_react.default.createElement("link", {
          key: file,
          nonce: this.props.nonce,
          rel: "stylesheet",
          href: `${assetPrefix}/_next/${encodeURI(file)}${devOnlyCacheBusterQueryString}`,
          crossOrigin: this.props.crossOrigin || undefined,
          "data-n-g": isUnmanagedFile ? undefined : isSharedFile ? '' : undefined,
          "data-n-p": isUnmanagedFile ? undefined : isSharedFile ? undefined : ''
        }));
      });
  
      if (false) {}
  
      return cssLinkElements.length === 0 ? null : cssLinkElements;
    }
  
    getPreloadDynamicChunks() {
      const {
        dynamicImports,
        assetPrefix,
        devOnlyCacheBusterQueryString
      } = this.context;
      return dedupe(dynamicImports).map(bundle => {
        if (!bundle.file.endsWith('.js')) {
          return null;
        }
  
        return /*#__PURE__*/_react.default.createElement("link", {
          rel: "preload",
          key: bundle.file,
          href: `${assetPrefix}/_next/${encodeURI(bundle.file)}${devOnlyCacheBusterQueryString}`,
          as: "script",
          nonce: this.props.nonce,
          crossOrigin: this.props.crossOrigin || undefined
        });
      }) // Filter out nulled scripts
      .filter(Boolean);
    }
  
    getPreloadMainLinks(files) {
      const {
        assetPrefix,
        devOnlyCacheBusterQueryString,
        scriptLoader
      } = this.context;
      const preloadFiles = files.allFiles.filter(file => {
        return file.endsWith('.js');
      });
      return [...(scriptLoader.eager || []).map(file => /*#__PURE__*/_react.default.createElement("link", {
        key: file.src,
        nonce: this.props.nonce,
        rel: "preload",
        href: file.src,
        as: "script",
        crossOrigin: this.props.crossOrigin || undefined
      })), ...preloadFiles.map(file => /*#__PURE__*/_react.default.createElement("link", {
        key: file,
        nonce: this.props.nonce,
        rel: "preload",
        href: `${assetPrefix}/_next/${encodeURI(file)}${devOnlyCacheBusterQueryString}`,
        as: "script",
        crossOrigin: this.props.crossOrigin || undefined
      })), ...(scriptLoader.defer || []).map(file => /*#__PURE__*/_react.default.createElement("link", {
        key: file,
        nonce: this.props.nonce,
        rel: "preload",
        href: file,
        as: "script",
        crossOrigin: this.props.crossOrigin || undefined
      }))];
    }
  
    handleDocumentScriptLoaderItems(children) {
      const {
        scriptLoader
      } = this.context;
      const scriptLoaderItems = [];
      const filteredChildren = [];
  
      _react.default.Children.forEach(children, child => {
        if (child.type === _experimentalScript.default) {
          if (child.props.strategy === 'eager') {
            scriptLoader.eager = (scriptLoader.eager || []).concat([_objectSpread({}, child.props)]);
            return;
          } else if (['lazy', 'defer'].includes(child.props.strategy)) {
            scriptLoaderItems.push(child.props);
            return;
          }
        }
  
        filteredChildren.push(child);
      });
  
      this.context.__NEXT_DATA__.scriptLoader = scriptLoaderItems;
      return filteredChildren;
    }
  
    makeStylesheetInert(node) {
      return _react.default.Children.map(node, c => {
        if (c.type === 'link' && c.props['href'] && _constants.OPTIMIZED_FONT_PROVIDERS.some(url => c.props['href'].startsWith(url))) {
          const newProps = _objectSpread({}, c.props || {});
  
          newProps['data-href'] = newProps['href'];
          newProps['href'] = undefined;
          return /*#__PURE__*/_react.default.cloneElement(c, newProps);
        } else if (c.props && c.props['children']) {
          c.props['children'] = this.makeStylesheetInert(c.props['children']);
        }
  
        return c;
      });
    }
  
    render() {
      var _this$props$nonce, _this$props$nonce2;
  
      const {
        styles,
        ampPath,
        inAmpMode,
        hybridAmp,
        canonicalBase,
        __NEXT_DATA__,
        dangerousAsPath,
        headTags,
        unstable_runtimeJS,
        unstable_JsPreload
      } = this.context;
      const disableRuntimeJS = unstable_runtimeJS === false;
      const disableJsPreload = unstable_JsPreload === false;
      this.context.docComponentsRendered.Head = true;
      let {
        head
      } = this.context;
      let cssPreloads = [];
      let otherHeadElements = [];
  
      if (head) {
        head.forEach(c => {
          if (c && c.type === 'link' && c.props['rel'] === 'preload' && c.props['as'] === 'style') {
            cssPreloads.push(c);
          } else {
            c && otherHeadElements.push(c);
          }
        });
        head = cssPreloads.concat(otherHeadElements);
      }
  
      let children = this.props.children; // show a warning if Head contains <title> (only in development)
  
      if (false) {}
  
      if (false) {}
  
      if (false) {}
  
      let hasAmphtmlRel = false;
      let hasCanonicalRel = false; // show warning and remove conflicting amp head tags
  
      head = _react.default.Children.map(head || [], child => {
        if (!child) return child;
        const {
          type,
          props
        } = child;
  
        if (inAmpMode) {
          let badProp = '';
  
          if (type === 'meta' && props.name === 'viewport') {
            badProp = 'name="viewport"';
          } else if (type === 'link' && props.rel === 'canonical') {
            hasCanonicalRel = true;
          } else if (type === 'script') {
            // only block if
            // 1. it has a src and isn't pointing to ampproject's CDN
            // 2. it is using dangerouslySetInnerHTML without a type or
            // a type of text/javascript
            if (props.src && props.src.indexOf('ampproject') < -1 || props.dangerouslySetInnerHTML && (!props.type || props.type === 'text/javascript')) {
              badProp = '<script';
              Object.keys(props).forEach(prop => {
                badProp += ` ${prop}="${props[prop]}"`;
              });
              badProp += '/>';
            }
          }
  
          if (badProp) {
            console.warn(`Found conflicting amp tag "${child.type}" with conflicting prop ${badProp} in ${__NEXT_DATA__.page}. https://nextjs.org/docs/messages/conflicting-amp-tag`);
            return null;
          }
        } else {
          // non-amp mode
          if (type === 'link' && props.rel === 'amphtml') {
            hasAmphtmlRel = true;
          }
        }
  
        return child;
      }); // try to parse styles from fragment for backwards compat
  
      const curStyles = Array.isArray(styles) ? styles : [];
  
      if (inAmpMode && styles && // @ts-ignore Property 'props' does not exist on type ReactElement
      styles.props && // @ts-ignore Property 'props' does not exist on type ReactElement
      Array.isArray(styles.props.children)) {
        const hasStyles = el => {
          var _el$props, _el$props$dangerously;
  
          return el == null ? void 0 : (_el$props = el.props) == null ? void 0 : (_el$props$dangerously = _el$props.dangerouslySetInnerHTML) == null ? void 0 : _el$props$dangerously.__html;
        }; // @ts-ignore Property 'props' does not exist on type ReactElement
  
  
        styles.props.children.forEach(child => {
          if (Array.isArray(child)) {
            child.forEach(el => hasStyles(el) && curStyles.push(el));
          } else if (hasStyles(child)) {
            curStyles.push(child);
          }
        });
      }
  
      const files = getDocumentFiles(this.context.buildManifest, this.context.__NEXT_DATA__.page, inAmpMode);
      return /*#__PURE__*/_react.default.createElement("head", this.props, this.context.isDevelopment && /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement("style", {
        "data-next-hide-fouc": true,
        "data-ampdevmode": inAmpMode ? 'true' : undefined,
        dangerouslySetInnerHTML: {
          __html: `body{display:none}`
        }
      }), /*#__PURE__*/_react.default.createElement("noscript", {
        "data-next-hide-fouc": true,
        "data-ampdevmode": inAmpMode ? 'true' : undefined
      }, /*#__PURE__*/_react.default.createElement("style", {
        dangerouslySetInnerHTML: {
          __html: `body{display:block}`
        }
      }))), children, head, /*#__PURE__*/_react.default.createElement("meta", {
        name: "next-head-count",
        content: _react.default.Children.count(head || []).toString()
      }), inAmpMode && /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement("meta", {
        name: "viewport",
        content: "width=device-width,minimum-scale=1,initial-scale=1"
      }), !hasCanonicalRel && /*#__PURE__*/_react.default.createElement("link", {
        rel: "canonical",
        href: canonicalBase + (0, _utils2.cleanAmpPath)(dangerousAsPath)
      }), /*#__PURE__*/_react.default.createElement("link", {
        rel: "preload",
        as: "script",
        href: "https://cdn.ampproject.org/v0.js"
      }), styles && /*#__PURE__*/_react.default.createElement("style", {
        "amp-custom": "",
        dangerouslySetInnerHTML: {
          __html: curStyles.map(style => style.props.dangerouslySetInnerHTML.__html).join('').replace(/\/\*# sourceMappingURL=.*\*\//g, '').replace(/\/\*@ sourceURL=.*?\*\//g, '')
        }
      }), /*#__PURE__*/_react.default.createElement("style", {
        "amp-boilerplate": "",
        dangerouslySetInnerHTML: {
          __html: `body{-webkit-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-moz-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-ms-animation:-amp-start 8s steps(1,end) 0s 1 normal both;animation:-amp-start 8s steps(1,end) 0s 1 normal both}@-webkit-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-moz-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-ms-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-o-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}`
        }
      }), /*#__PURE__*/_react.default.createElement("noscript", null, /*#__PURE__*/_react.default.createElement("style", {
        "amp-boilerplate": "",
        dangerouslySetInnerHTML: {
          __html: `body{-webkit-animation:none;-moz-animation:none;-ms-animation:none;animation:none}`
        }
      })), /*#__PURE__*/_react.default.createElement("script", {
        async: true,
        src: "https://cdn.ampproject.org/v0.js"
      })), !inAmpMode && /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, !hasAmphtmlRel && hybridAmp && /*#__PURE__*/_react.default.createElement("link", {
        rel: "amphtml",
        href: canonicalBase + getAmpPath(ampPath, dangerousAsPath)
      }),  true && this.getCssLinks(files),  true && /*#__PURE__*/_react.default.createElement("noscript", {
        "data-n-css": (_this$props$nonce = this.props.nonce) != null ? _this$props$nonce : ''
      }), !disableRuntimeJS && !disableJsPreload && this.getPreloadDynamicChunks(), !disableRuntimeJS && !disableJsPreload && this.getPreloadMainLinks(files),  false && false,  false && /*#__PURE__*/false, this.context.isDevelopment &&
      /*#__PURE__*/
      // this element is used to mount development styles so the
      // ordering matches production
      // (by default, style-loader injects at the bottom of <head />)
      _react.default.createElement("noscript", {
        id: "__next_css__DO_NOT_USE__"
      }), styles || null), /*#__PURE__*/_react.default.createElement(_react.default.Fragment, {}, ...(headTags || [])));
    }
  
  }
  
  exports.Head = Head;
  Head.contextType = _documentContext.DocumentContext;
  Head.propTypes = {
    nonce: _propTypes.default.string,
    crossOrigin: _propTypes.default.string
  };
  
  function Main() {
    const {
      inAmpMode,
      html,
      docComponentsRendered
    } = (0, _react.useContext)(_documentContext.DocumentContext);
    docComponentsRendered.Main = true;
    if (inAmpMode) return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, _constants.AMP_RENDER_TARGET);
    return /*#__PURE__*/_react.default.createElement("div", {
      id: "__next",
      dangerouslySetInnerHTML: {
        __html: html
      }
    });
  }
  
  class NextScript extends _react.Component {
    constructor(...args) {
      super(...args);
      this.context = void 0;
    }
  
    getDynamicChunks(files) {
      const {
        dynamicImports,
        assetPrefix,
        isDevelopment,
        devOnlyCacheBusterQueryString
      } = this.context;
      return dedupe(dynamicImports).map(bundle => {
        if (!bundle.file.endsWith('.js') || files.allFiles.includes(bundle.file)) return null;
        return /*#__PURE__*/_react.default.createElement("script", {
          async: !isDevelopment,
          key: bundle.file,
          src: `${assetPrefix}/_next/${encodeURI(bundle.file)}${devOnlyCacheBusterQueryString}`,
          nonce: this.props.nonce,
          crossOrigin: this.props.crossOrigin || undefined
        });
      });
    }
  
    getPreNextScripts() {
      const {
        scriptLoader
      } = this.context;
      return (scriptLoader.eager || []).map(file => {
        const {
          strategy
        } = file,
              props = _objectWithoutProperties(file, ["strategy"]);
  
        return /*#__PURE__*/_react.default.createElement("script", Object.assign({}, props, {
          nonce: this.props.nonce,
          crossOrigin: this.props.crossOrigin || undefined
        }));
      });
    }
  
    getScripts(files) {
      var _buildManifest$lowPri;
  
      const {
        assetPrefix,
        buildManifest,
        isDevelopment,
        devOnlyCacheBusterQueryString
      } = this.context;
      const normalScripts = files.allFiles.filter(file => file.endsWith('.js'));
      const lowPriorityScripts = (_buildManifest$lowPri = buildManifest.lowPriorityFiles) == null ? void 0 : _buildManifest$lowPri.filter(file => file.endsWith('.js'));
      return [...normalScripts, ...lowPriorityScripts].map(file => {
        return /*#__PURE__*/_react.default.createElement("script", {
          key: file,
          src: `${assetPrefix}/_next/${encodeURI(file)}${devOnlyCacheBusterQueryString}`,
          nonce: this.props.nonce,
          async: !isDevelopment,
          crossOrigin: this.props.crossOrigin || undefined
        });
      });
    }
  
    getPolyfillScripts() {
      // polyfills.js has to be rendered as nomodule without async
      // It also has to be the first script to load
      const {
        assetPrefix,
        buildManifest,
        devOnlyCacheBusterQueryString
      } = this.context;
      return buildManifest.polyfillFiles.filter(polyfill => polyfill.endsWith('.js') && !polyfill.endsWith('.module.js')).map(polyfill => /*#__PURE__*/_react.default.createElement("script", {
        key: polyfill,
        nonce: this.props.nonce,
        crossOrigin: this.props.crossOrigin || undefined,
        noModule: true,
        src: `${assetPrefix}/_next/${polyfill}${devOnlyCacheBusterQueryString}`
      }));
    }
  
    static getInlineScriptSource(documentProps) {
      const {
        __NEXT_DATA__
      } = documentProps;
  
      try {
        const data = JSON.stringify(__NEXT_DATA__);
        return (0, _htmlescape.htmlEscapeJsonString)(data);
      } catch (err) {
        if (err.message.indexOf('circular structure')) {
          throw new Error(`Circular structure in "getInitialProps" result of page "${__NEXT_DATA__.page}". https://nextjs.org/docs/messages/circular-structure`);
        }
  
        throw err;
      }
    }
  
    render() {
      const {
        assetPrefix,
        inAmpMode,
        buildManifest,
        unstable_runtimeJS,
        docComponentsRendered,
        devOnlyCacheBusterQueryString
      } = this.context;
      const disableRuntimeJS = unstable_runtimeJS === false;
      docComponentsRendered.NextScript = true;
  
      if (inAmpMode) {
        if (true) {
          return null;
        }
  
        const ampDevFiles = [...buildManifest.devFiles, ...buildManifest.polyfillFiles, ...buildManifest.ampDevFiles];
        return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, disableRuntimeJS ? null : /*#__PURE__*/_react.default.createElement("script", {
          id: "__NEXT_DATA__",
          type: "application/json",
          nonce: this.props.nonce,
          crossOrigin: this.props.crossOrigin || undefined,
          dangerouslySetInnerHTML: {
            __html: NextScript.getInlineScriptSource(this.context)
          },
          "data-ampdevmode": true
        }), ampDevFiles.map(file => /*#__PURE__*/_react.default.createElement("script", {
          key: file,
          src: `${assetPrefix}/_next/${file}${devOnlyCacheBusterQueryString}`,
          nonce: this.props.nonce,
          crossOrigin: this.props.crossOrigin || undefined,
          "data-ampdevmode": true
        })));
      }
  
      if (false) {}
  
      const files = getDocumentFiles(this.context.buildManifest, this.context.__NEXT_DATA__.page, inAmpMode);
      return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, !disableRuntimeJS && buildManifest.devFiles ? buildManifest.devFiles.map(file => /*#__PURE__*/_react.default.createElement("script", {
        key: file,
        src: `${assetPrefix}/_next/${encodeURI(file)}${devOnlyCacheBusterQueryString}`,
        nonce: this.props.nonce,
        crossOrigin: this.props.crossOrigin || undefined
      })) : null, disableRuntimeJS ? null : /*#__PURE__*/_react.default.createElement("script", {
        id: "__NEXT_DATA__",
        type: "application/json",
        nonce: this.props.nonce,
        crossOrigin: this.props.crossOrigin || undefined,
        dangerouslySetInnerHTML: {
          __html: NextScript.getInlineScriptSource(this.context)
        }
      }), !disableRuntimeJS && this.getPolyfillScripts(), !disableRuntimeJS && this.getPreNextScripts(), disableRuntimeJS ? null : this.getDynamicChunks(files), disableRuntimeJS ? null : this.getScripts(files));
    }
  
  }
  
  exports.NextScript = NextScript;
  NextScript.contextType = _documentContext.DocumentContext;
  NextScript.propTypes = {
    nonce: _propTypes.default.string,
    crossOrigin: _propTypes.default.string
  };
  NextScript.safariNomoduleFix = '!function(){var e=document,t=e.createElement("script");if(!("noModule"in t)&&"onbeforeload"in t){var n=!1;e.addEventListener("beforeload",function(e){if(e.target===t)n=!0;else if(!e.target.hasAttribute("nomodule")||!n)return;e.preventDefault()},!0),t.type="module",t.src=".",e.head.appendChild(t),t.remove()}}();';
  
  function getAmpPath(ampPath, asPath) {
    return ampPath || `${asPath}${asPath.includes('?') ? '&' : '?'}amp=1`;
  }
  
  /***/ }),
  
  /***/ "Y8yu":
  /***/ (function(module, exports) {
  
  module.exports = require("next/dist/next-server/lib/head-manager-context.js");
  
  /***/ }),
  
  /***/ "cDcd":
  /***/ (function(module, exports) {
  
  module.exports = require("react");
  
  /***/ }),
  
  /***/ "cDf5":
  /***/ (function(module, exports) {
  
  function _typeof(obj) {
    "@babel/helpers - typeof";
  
    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      module.exports = _typeof = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      module.exports = _typeof = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }
  
    return _typeof(obj);
  }
  
  module.exports = _typeof;
  
  /***/ }),
  
  /***/ "kYf9":
  /***/ (function(module, exports) {
  
  module.exports = require("next/dist/next-server/lib/utils.js");
  
  /***/ }),
  
  /***/ "nMq/":
  /***/ (function(module, exports) {
  
  module.exports = require("next/dist/next-server/lib/document-context.js");
  
  /***/ }),
  
  /***/ "pVnL":
  /***/ (function(module, exports) {
  
  function _extends() {
    module.exports = _extends = Object.assign || function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];
  
        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }
  
      return target;
    };
  
    return _extends.apply(this, arguments);
  }
  
  module.exports = _extends;
  
  /***/ }),
  
  /***/ "rf6O":
  /***/ (function(module, exports) {
  
  module.exports = require("prop-types");
  
  /***/ }),
  
  /***/ "ri/Y":
  /***/ (function(module, exports) {
  
  module.exports = require("next/dist/next-server/server/utils.js");
  
  /***/ }),
  
  /***/ "vHio":
  /***/ (function(module, exports) {
  
  module.exports = require("next/dist/next-server/server/get-page-files.js");
  
  /***/ })
  
  /******/ });