diff options
Diffstat (limited to 'build/server/pages/_document.js')
| -rw-r--r-- | build/server/pages/_document.js | 1209 |
1 files changed, 1209 insertions, 0 deletions
diff --git a/build/server/pages/_document.js b/build/server/pages/_document.js new file mode 100644 index 0000000..f4167fc --- /dev/null +++ b/build/server/pages/_document.js @@ -0,0 +1,1209 @@ +(function() { +var exports = {}; +exports.id = 660; +exports.ids = [660]; +exports.modules = { + +/***/ 154: +/***/ (function(module) { + +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; + +/***/ }), + +/***/ 318: +/***/ (function(module) { + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + "default": obj + }; +} + +module.exports = _interopRequireDefault; + +/***/ }), + +/***/ 316: +/***/ (function(module) { + +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; + +/***/ }), + +/***/ 792: +/***/ (function(__unused_webpack_module, exports) { + +"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 => { + if ( // If the font tag is loaded only on client navigation + // it won't be inlined. In this case revert to the original behavior + h.type === 'link' && h.props['data-optimized-fonts'] && !document.querySelector(`style[data-href="${h.props['data-href']}"]`)) { + h.props.href = h.props['data-href']; + h.props['data-href'] = undefined; + } + + 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] || []); + }); + }); + } + }; +} + +/***/ }), + +/***/ 447: +/***/ (function(__unused_webpack_module, exports) { + +"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; + +/***/ }), + +/***/ 926: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + + +var _interopRequireDefault = __webpack_require__(318); + +exports.__esModule = true; +exports.initScriptLoader = initScriptLoader; +exports.default = void 0; + +var _extends2 = _interopRequireDefault(__webpack_require__(154)); + +var _objectWithoutPropertiesLoose2 = _interopRequireDefault(__webpack_require__(316)); + +var _react = __webpack_require__(297); + +var _headManagerContext = __webpack_require__(816); + +var _headManager = __webpack_require__(792); + +var _requestIdleCallback = __webpack_require__(447); + +const ScriptCache = new Map(); +const LoadCache = new Set(); +const ignoreProps = ['onLoad', 'dangerouslySetInnerHTML', 'children', 'onError', 'strategy']; + +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 = 'afterInteractive' + } = props; + + if (strategy === 'afterInteractive') { + loadScript(props); + } else if (strategy === 'lazyOnload') { + 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 = () => {}, + strategy = 'afterInteractive', + onError + } = props, + restProps = (0, _objectWithoutPropertiesLoose2.default)(props, ["src", "onLoad", "dangerouslySetInnerHTML", "strategy", "onError"]); // Context is available only during SSR + + const { + updateScripts, + scripts + } = (0, _react.useContext)(_headManagerContext.HeadManagerContext); + (0, _react.useEffect)(() => { + if (strategy === 'afterInteractive') { + loadScript(props); + } else if (strategy === 'lazyOnload') { + loadLazyScript(props); + } + }, [props, strategy]); + + if (strategy === 'beforeInteractive') { + if (updateScripts) { + scripts.beforeInteractive = (scripts.beforeInteractive || []).concat([(0, _extends2.default)({ + src, + onLoad, + onError + }, restProps)]); + updateScripts(scripts); + } + } + + return null; +} + +var _default = Script; +exports.default = _default; + +/***/ }), + +/***/ 881: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + + +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; } + +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; } + +exports.__esModule = true; +exports.Html = Html; +exports.Main = Main; +exports.NextScript = exports.Head = exports.default = void 0; + +var _propTypes = _interopRequireDefault(__webpack_require__(229)); + +var _react = _interopRequireWildcard(__webpack_require__(297)); + +var _server = _interopRequireDefault(__webpack_require__(168)); + +var _constants = __webpack_require__(227); + +var _documentContext = __webpack_require__(932); + +var _utils = __webpack_require__(579); + +exports.DocumentContext = _utils.DocumentContext; +exports.DocumentInitialProps = _utils.DocumentInitialProps; +exports.DocumentProps = _utils.DocumentProps; + +var _getPageFiles = __webpack_require__(171); + +var _utils2 = __webpack_require__(105); + +var _htmlescape = __webpack_require__(630); + +var _script = _interopRequireDefault(__webpack_require__(926)); + +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 _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + +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])] + }; +} + +function getPolyfillScripts(context, props) { + // polyfills.js has to be rendered as nomodule without async + // It also has to be the first script to load + const { + assetPrefix, + buildManifest, + devOnlyCacheBusterQueryString, + disableOptimizedLoading + } = context; + return buildManifest.polyfillFiles.filter(polyfill => polyfill.endsWith('.js') && !polyfill.endsWith('.module.js')).map(polyfill => /*#__PURE__*/_react.default.createElement("script", { + key: polyfill, + defer: !disableOptimizedLoading, + nonce: props.nonce, + crossOrigin: props.crossOrigin || undefined, + noModule: true, + src: `${assetPrefix}/_next/${polyfill}${devOnlyCacheBusterQueryString}` + })); +} + +function getPreNextScripts(context, props) { + const { + scriptLoader, + disableOptimizedLoading + } = context; + return (scriptLoader.beforeInteractive || []).map(file => { + const { + strategy + } = file, + scriptProps = _objectWithoutProperties(file, ["strategy"]); + + return /*#__PURE__*/_react.default.createElement("script", Object.assign({}, scriptProps, { + defer: !disableOptimizedLoading, + nonce: props.nonce, + crossOrigin: props.crossOrigin || undefined + })); + }); +} + +function getDynamicChunks(context, props, files) { + const { + dynamicImports, + assetPrefix, + isDevelopment, + devOnlyCacheBusterQueryString, + disableOptimizedLoading + } = context; + return dynamicImports.map(file => { + if (!file.endsWith('.js') || files.allFiles.includes(file)) return null; + return /*#__PURE__*/_react.default.createElement("script", { + async: !isDevelopment && disableOptimizedLoading, + defer: !disableOptimizedLoading, + key: file, + src: `${assetPrefix}/_next/${encodeURI(file)}${devOnlyCacheBusterQueryString}`, + nonce: props.nonce, + crossOrigin: props.crossOrigin || undefined + }); + }); +} + +function getScripts(context, props, files) { + var _buildManifest$lowPri; + + const { + assetPrefix, + buildManifest, + isDevelopment, + devOnlyCacheBusterQueryString, + disableOptimizedLoading + } = 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: props.nonce, + async: !isDevelopment && disableOptimizedLoading, + defer: !disableOptimizedLoading, + crossOrigin: props.crossOrigin || undefined + }); + }); +} +/** +* `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; + +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 = Array.from(new Set(dynamicImports.filter(file => file.endsWith('.css')))); + + 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 (true) { + cssLinkElements = this.makeStylesheetInert(cssLinkElements); + } + + return cssLinkElements.length === 0 ? null : cssLinkElements; + } + + getPreloadDynamicChunks() { + const { + dynamicImports, + assetPrefix, + devOnlyCacheBusterQueryString + } = this.context; + return dynamicImports.map(file => { + if (!file.endsWith('.js')) { + return null; + } + + return /*#__PURE__*/_react.default.createElement("link", { + rel: "preload", + key: file, + href: `${assetPrefix}/_next/${encodeURI(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.beforeInteractive || []).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 + }))]; + } + + getDynamicChunks(files) { + return getDynamicChunks(this.context, this.props, files); + } + + getPreNextScripts() { + return getPreNextScripts(this.context, this.props); + } + + getScripts(files) { + return getScripts(this.context, this.props, files); + } + + getPolyfillScripts() { + return getPolyfillScripts(this.context, this.props); + } + + handleDocumentScriptLoaderItems(children) { + const { + scriptLoader + } = this.context; + const scriptLoaderItems = []; + const filteredChildren = []; + + _react.default.Children.forEach(children, child => { + if (child.type === _script.default) { + if (child.props.strategy === 'beforeInteractive') { + scriptLoader.beforeInteractive = (scriptLoader.beforeInteractive || []).concat([_objectSpread({}, child.props)]); + return; + } else if (['lazyOnload', 'afterInteractive'].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, + disableOptimizedLoading + } = this.context; + const disableRuntimeJS = unstable_runtimeJS === false; + const disableJsPreload = unstable_JsPreload === false || !disableOptimizedLoading; + 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 = _react.default.Children.toArray(this.props.children).filter(Boolean); // show a warning if Head contains <title> (only in development) + + + if (false) {} + + if ( true && !inAmpMode) { + children = this.makeStylesheetInert(children); + } + + children = this.handleDocumentScriptLoaderItems(children); + 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, true && /*#__PURE__*/_react.default.createElement("meta", { + name: "next-font-preconnect" + }), 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 : '' + }), false && /*#__PURE__*/0, !disableRuntimeJS && !disableJsPreload && this.getPreloadDynamicChunks(), !disableRuntimeJS && !disableJsPreload && this.getPreloadMainLinks(files), !disableOptimizedLoading && !disableRuntimeJS && this.getPolyfillScripts(), !disableOptimizedLoading && !disableRuntimeJS && this.getPreNextScripts(), !disableOptimizedLoading && !disableRuntimeJS && this.getDynamicChunks(files), !disableOptimizedLoading && !disableRuntimeJS && this.getScripts(files), false && 0, false && /*#__PURE__*/0, 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) { + return getDynamicChunks(this.context, this.props, files); + } + + getPreNextScripts() { + return getPreNextScripts(this.context, this.props); + } + + getScripts(files) { + return getScripts(this.context, this.props, files); + } + + getPolyfillScripts() { + return getPolyfillScripts(this.context, this.props); + } + + 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, + disableOptimizedLoading + } = 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) + } + }), disableOptimizedLoading && !disableRuntimeJS && this.getPolyfillScripts(), disableOptimizedLoading && !disableRuntimeJS && this.getPreNextScripts(), disableOptimizedLoading && !disableRuntimeJS && this.getDynamicChunks(files), disableOptimizedLoading && !disableRuntimeJS && 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`; +} + +/***/ }), + +/***/ 630: +/***/ (function(__unused_webpack_module, exports) { + +"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 + +/***/ }), + +/***/ 227: +/***/ (function(module) { + +"use strict"; +module.exports = require("next/dist/next-server/lib/constants.js");; + +/***/ }), + +/***/ 932: +/***/ (function(module) { + +"use strict"; +module.exports = require("next/dist/next-server/lib/document-context.js");; + +/***/ }), + +/***/ 816: +/***/ (function(module) { + +"use strict"; +module.exports = require("next/dist/next-server/lib/head-manager-context.js");; + +/***/ }), + +/***/ 579: +/***/ (function(module) { + +"use strict"; +module.exports = require("next/dist/next-server/lib/utils.js");; + +/***/ }), + +/***/ 171: +/***/ (function(module) { + +"use strict"; +module.exports = require("next/dist/next-server/server/get-page-files.js");; + +/***/ }), + +/***/ 105: +/***/ (function(module) { + +"use strict"; +module.exports = require("next/dist/next-server/server/utils.js");; + +/***/ }), + +/***/ 229: +/***/ (function(module) { + +"use strict"; +module.exports = require("prop-types");; + +/***/ }), + +/***/ 297: +/***/ (function(module) { + +"use strict"; +module.exports = require("react");; + +/***/ }), + +/***/ 168: +/***/ (function(module) { + +"use strict"; +module.exports = require("styled-jsx/server");; + +/***/ }) + +}; +; + +// load runtime +var __webpack_require__ = require("../webpack-runtime.js"); +__webpack_require__.C(exports); +var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); } +var __webpack_exports__ = (__webpack_exec__(881)); +module.exports = __webpack_exports__; + +})();
\ No newline at end of file |