1209 lines
No EOL
38 KiB
JavaScript
1209 lines
No EOL
38 KiB
JavaScript
(function() {
|
|
var exports = {};
|
|
exports.id = 660;
|
|
exports.ids = [660];
|
|
exports.modules = {
|
|
|
|
/***/ 6792:
|
|
/***/ (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] || []);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3447:
|
|
/***/ (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;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7926:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _interopRequireDefault = __webpack_require__(2426);
|
|
|
|
exports.__esModule = true;
|
|
exports.initScriptLoader = initScriptLoader;
|
|
exports.default = void 0;
|
|
|
|
var _extends2 = _interopRequireDefault(__webpack_require__(9566));
|
|
|
|
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(__webpack_require__(6169));
|
|
|
|
var _react = __webpack_require__(9297);
|
|
|
|
var _headManagerContext = __webpack_require__(816);
|
|
|
|
var _headManager = __webpack_require__(6792);
|
|
|
|
var _requestIdleCallback = __webpack_require__(3447);
|
|
|
|
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;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8881:
|
|
/***/ (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__(4229));
|
|
|
|
var _react = _interopRequireWildcard(__webpack_require__(9297));
|
|
|
|
var _server = _interopRequireDefault(__webpack_require__(1168));
|
|
|
|
var _constants = __webpack_require__(227);
|
|
|
|
var _documentContext = __webpack_require__(3932);
|
|
|
|
var _utils = __webpack_require__(7579);
|
|
|
|
exports.DocumentContext = _utils.DocumentContext;
|
|
exports.DocumentInitialProps = _utils.DocumentInitialProps;
|
|
exports.DocumentProps = _utils.DocumentProps;
|
|
|
|
var _getPageFiles = __webpack_require__(6171);
|
|
|
|
var _utils2 = __webpack_require__(5105);
|
|
|
|
var _htmlescape = __webpack_require__(9630);
|
|
|
|
var _script = _interopRequireDefault(__webpack_require__(7926));
|
|
|
|
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`;
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9630:
|
|
/***/ (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
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9566:
|
|
/***/ (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;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2426:
|
|
/***/ (function(module) {
|
|
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : {
|
|
"default": obj
|
|
};
|
|
}
|
|
|
|
module.exports = _interopRequireDefault;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6169:
|
|
/***/ (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;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 227:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
module.exports = require("next/dist/next-server/lib/constants.js");;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3932:
|
|
/***/ (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");;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7579:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
module.exports = require("next/dist/next-server/lib/utils.js");;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6171:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
module.exports = require("next/dist/next-server/server/get-page-files.js");;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5105:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
module.exports = require("next/dist/next-server/server/utils.js");;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4229:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
module.exports = require("prop-types");;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9297:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
module.exports = require("react");;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1168:
|
|
/***/ (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__(8881));
|
|
module.exports = __webpack_exports__;
|
|
|
|
})(); |