%PDF-
%PDF-
Mini Shell
Mini Shell
exports.id = 61;
exports.ids = [61];
exports.modules = {
/***/ 932:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
var __webpack_unused_export__;
__webpack_unused_export__ = ({
value: true
});
exports.Z = _asyncToGenerator;
function _asyncToGenerator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
/***/ }),
/***/ 6495:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
var __webpack_unused_export__;
__webpack_unused_export__ = ({
value: true
});
exports.Z = _extends;
function _extends() {
return extends_.apply(this, arguments);
}
function extends_() {
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);
}
/***/ }),
/***/ 2648:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
var __webpack_unused_export__;
__webpack_unused_export__ = ({
value: true
});
exports.Z = _interopRequireDefault;
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
/***/ }),
/***/ 1598:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
var __webpack_unused_export__;
__webpack_unused_export__ = ({
value: true
});
exports.Z = _interopRequireWildcard;
function _interopRequireWildcard(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj;
}
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
return {
default: obj
};
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj);
}
var newObj = {};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for(var key in obj){
if (key !== "default" && 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 _getRequireWildcardCache(nodeInterop1) {
if (typeof WeakMap !== "function") return null;
var cacheBabelInterop = new WeakMap();
var cacheNodeInterop = new WeakMap();
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
})(nodeInterop1);
}
/***/ }),
/***/ 7273:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
var __webpack_unused_export__;
__webpack_unused_export__ = ({
value: true
});
exports.Z = _objectWithoutPropertiesLoose;
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;
}
/***/ }),
/***/ 8684:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.addBasePath = addBasePath;
var _addPathPrefix = __webpack_require__(1751);
var _normalizeTrailingSlash = __webpack_require__(2392);
const basePath = false || "";
function addBasePath(path, required) {
if (false) {}
return (0, _normalizeTrailingSlash).normalizePathTrailingSlash((0, _addPathPrefix).addPathPrefix(path, basePath));
}
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=add-base-path.js.map
/***/ }),
/***/ 2725:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.addLocale = void 0;
var _normalizeTrailingSlash = __webpack_require__(2392);
const addLocale = (path, ...args)=>{
if (false) {}
return path;
};
exports.addLocale = addLocale;
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=add-locale.js.map
/***/ }),
/***/ 8748:
/***/ ((module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.detectDomainLocale = void 0;
const detectDomainLocale = (...args)=>{
if (false) {}
};
exports.detectDomainLocale = detectDomainLocale;
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=detect-domain-locale.js.map
/***/ }),
/***/ 1210:
/***/ ((module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.getDomainLocale = getDomainLocale;
const basePath = (/* unused pure expression or super */ null && ( false || ""));
function getDomainLocale(path, locale, locales, domainLocales) {
if (false) {} else {
return false;
}
}
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=get-domain-locale.js.map
/***/ }),
/***/ 4119:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.hasBasePath = hasBasePath;
var _pathHasPrefix = __webpack_require__(4567);
const basePath = false || "";
function hasBasePath(path) {
return (0, _pathHasPrefix).pathHasPrefix(path, basePath);
}
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=has-base-path.js.map
/***/ }),
/***/ 6007:
/***/ ((module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = initHeadManager;
exports.isEqualNode = isEqualNode;
exports.DOMAttributeNames = void 0;
function initHeadManager() {
return {
mountedInstances: new Set(),
updateHead: (head)=>{
const tags = {};
head.forEach((h)=>{
if (// it won't be inlined. In this case revert to the original behavior
h.type === "link" && h.props["data-optimized-fonts"]) {
if (document.querySelector(`style[data-href="${h.props["data-href"]}"]`)) {
return;
} else {
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] || []);
});
}
};
}
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 isEqualNode(oldTag, newTag) {
if (oldTag instanceof HTMLElement && newTag instanceof HTMLElement) {
const nonce = newTag.getAttribute("nonce");
// Only strip the nonce if `oldTag` has had it stripped. An element's nonce attribute will not
// be stripped if there is no content security policy response header that includes a nonce.
if (nonce && !oldTag.getAttribute("nonce")) {
const cloneTag = newTag.cloneNode(true);
cloneTag.setAttribute("nonce", "");
cloneTag.nonce = nonce;
return nonce === oldTag.nonce && oldTag.isEqualNode(cloneTag);
}
}
return oldTag.isEqualNode(newTag);
}
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 == null ? void 0 : j.previousElementSibling) || null){
var ref;
if ((j == null ? void 0 : (ref = j.tagName) == null ? void 0 : ref.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 (isEqualNode(oldTag, newTag)) {
oldTags.splice(k, 1);
return false;
}
}
return true;
});
oldTags.forEach((t)=>{
var ref;
return (ref = t.parentNode) == null ? void 0 : ref.removeChild(t);
});
newTags.forEach((t)=>headEl.insertBefore(t, headCountEl));
headCountEl.content = (headCount - oldTags.length + newTags.length).toString();
}
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=head-manager.js.map
/***/ }),
/***/ 8045:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
"client";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = Image;
var _extends = (__webpack_require__(6495)/* ["default"] */ .Z);
var _interop_require_default = (__webpack_require__(2648)/* ["default"] */ .Z);
var _interop_require_wildcard = (__webpack_require__(1598)/* ["default"] */ .Z);
var _object_without_properties_loose = (__webpack_require__(7273)/* ["default"] */ .Z);
var _react = _interop_require_wildcard(__webpack_require__(6689));
var _head = _interop_require_default(__webpack_require__(4957));
var _imageConfig = __webpack_require__(5843);
var _useIntersection = __webpack_require__(7190);
var _imageConfigContext = __webpack_require__(744);
var _utils = __webpack_require__(9232);
var _normalizeTrailingSlash = __webpack_require__(2392);
function Image(_param) {
var { src , sizes , unoptimized =false , priority =false , loading , lazyRoot =null , lazyBoundary , className , quality , width , height , style , objectFit , objectPosition , onLoadingComplete , placeholder ="empty" , blurDataURL } = _param, all = _object_without_properties_loose(_param, [
"src",
"sizes",
"unoptimized",
"priority",
"loading",
"lazyRoot",
"lazyBoundary",
"className",
"quality",
"width",
"height",
"style",
"objectFit",
"objectPosition",
"onLoadingComplete",
"placeholder",
"blurDataURL"
]);
const configContext = (0, _react).useContext(_imageConfigContext.ImageConfigContext);
const config = (0, _react).useMemo(()=>{
const c = configEnv || configContext || _imageConfig.imageConfigDefault;
const allSizes = [
...c.deviceSizes,
...c.imageSizes
].sort((a, b)=>a - b);
const deviceSizes = c.deviceSizes.sort((a, b)=>a - b);
return _extends({}, c, {
allSizes,
deviceSizes
});
}, [
configContext
]);
let rest = all;
let layout = sizes ? "responsive" : "intrinsic";
if ("layout" in rest) {
// Override default layout if the user specified one:
if (rest.layout) layout = rest.layout;
// Remove property so it's not spread on <img>:
delete rest.layout;
}
let loader = defaultImageLoader;
if ("loader" in rest) {
if (rest.loader) {
const customImageLoader = rest.loader;
var _tmp;
_tmp = (obj)=>{
const { config: _ } = obj, opts = _object_without_properties_loose(obj, [
"config"
]);
// The config object is internal only so we must
// not pass it to the user-defined loader()
return customImageLoader(opts);
}, loader = _tmp, _tmp;
}
// Remove property so it's not spread on <img>
delete rest.loader;
}
let staticSrc = "";
if (isStaticImport(src)) {
const staticImageData = isStaticRequire(src) ? src.default : src;
if (!staticImageData.src) {
throw new Error(`An object should only be passed to the image component src parameter if it comes from a static image import. It must include src. Received ${JSON.stringify(staticImageData)}`);
}
blurDataURL = blurDataURL || staticImageData.blurDataURL;
staticSrc = staticImageData.src;
if (!layout || layout !== "fill") {
height = height || staticImageData.height;
width = width || staticImageData.width;
if (!staticImageData.height || !staticImageData.width) {
throw new Error(`An object should only be passed to the image component src parameter if it comes from a static image import. It must include height and width. Received ${JSON.stringify(staticImageData)}`);
}
}
}
src = typeof src === "string" ? src : staticSrc;
let isLazy = !priority && (loading === "lazy" || typeof loading === "undefined");
if (src.startsWith("data:") || src.startsWith("blob:")) {
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
unoptimized = true;
isLazy = false;
}
if (false) {}
if (config.unoptimized) {
unoptimized = true;
}
const [blurComplete, setBlurComplete] = (0, _react).useState(false);
const [setIntersection, isIntersected, resetIntersected] = (0, _useIntersection).useIntersection({
rootRef: lazyRoot,
rootMargin: lazyBoundary || "200px",
disabled: !isLazy
});
const isVisible = !isLazy || isIntersected;
const wrapperStyle = {
boxSizing: "border-box",
display: "block",
overflow: "hidden",
width: "initial",
height: "initial",
background: "none",
opacity: 1,
border: 0,
margin: 0,
padding: 0
};
const sizerStyle = {
boxSizing: "border-box",
display: "block",
width: "initial",
height: "initial",
background: "none",
opacity: 1,
border: 0,
margin: 0,
padding: 0
};
let hasSizer = false;
let sizerSvgUrl;
const layoutStyle = {
position: "absolute",
top: 0,
left: 0,
bottom: 0,
right: 0,
boxSizing: "border-box",
padding: 0,
border: "none",
margin: "auto",
display: "block",
width: 0,
height: 0,
minWidth: "100%",
maxWidth: "100%",
minHeight: "100%",
maxHeight: "100%",
objectFit,
objectPosition
};
let widthInt = getInt(width);
let heightInt = getInt(height);
const qualityInt = getInt(quality);
if (false) {}
const imgStyle = Object.assign({}, style, layoutStyle);
const blurStyle = placeholder === "blur" && !blurComplete ? {
backgroundSize: objectFit || "cover",
backgroundPosition: objectPosition || "0% 0%",
filter: "blur(20px)",
backgroundImage: `url("${blurDataURL}")`
} : {};
if (layout === "fill") {
// <Image src="i.png" layout="fill" />
wrapperStyle.display = "block";
wrapperStyle.position = "absolute";
wrapperStyle.top = 0;
wrapperStyle.left = 0;
wrapperStyle.bottom = 0;
wrapperStyle.right = 0;
} else if (typeof widthInt !== "undefined" && typeof heightInt !== "undefined") {
// <Image src="i.png" width="100" height="100" />
const quotient = heightInt / widthInt;
const paddingTop = isNaN(quotient) ? "100%" : `${quotient * 100}%`;
if (layout === "responsive") {
// <Image src="i.png" width="100" height="100" layout="responsive" />
wrapperStyle.display = "block";
wrapperStyle.position = "relative";
hasSizer = true;
sizerStyle.paddingTop = paddingTop;
} else if (layout === "intrinsic") {
// <Image src="i.png" width="100" height="100" layout="intrinsic" />
wrapperStyle.display = "inline-block";
wrapperStyle.position = "relative";
wrapperStyle.maxWidth = "100%";
hasSizer = true;
sizerStyle.maxWidth = "100%";
sizerSvgUrl = `data:image/svg+xml,%3csvg%20xmlns=%27http://www.w3.org/2000/svg%27%20version=%271.1%27%20width=%27${widthInt}%27%20height=%27${heightInt}%27/%3e`;
} else if (layout === "fixed") {
// <Image src="i.png" width="100" height="100" layout="fixed" />
wrapperStyle.display = "inline-block";
wrapperStyle.position = "relative";
wrapperStyle.width = widthInt;
wrapperStyle.height = heightInt;
}
} else {
// <Image src="i.png" />
if (false) {}
}
let imgAttributes = {
src: emptyDataURL,
srcSet: undefined,
sizes: undefined
};
if (isVisible) {
imgAttributes = generateImgAttrs({
config,
src,
unoptimized,
layout,
width: widthInt,
quality: qualityInt,
sizes,
loader
});
}
let srcString = src;
if (false) {}
let imageSrcSetPropName = "imagesrcset";
let imageSizesPropName = "imagesizes";
if (false) {}
const linkProps = {
// Note: imagesrcset and imagesizes are not in the link element type with react 17.
[imageSrcSetPropName]: imgAttributes.srcSet,
[imageSizesPropName]: imgAttributes.sizes,
crossOrigin: rest.crossOrigin
};
const useLayoutEffect = true ? _react.default.useEffect : 0;
const onLoadingCompleteRef = (0, _react).useRef(onLoadingComplete);
const previousImageSrc = (0, _react).useRef(src);
(0, _react).useEffect(()=>{
onLoadingCompleteRef.current = onLoadingComplete;
}, [
onLoadingComplete
]);
useLayoutEffect(()=>{
if (previousImageSrc.current !== src) {
resetIntersected();
previousImageSrc.current = src;
}
}, [
resetIntersected,
src
]);
const imgElementArgs = _extends({
isLazy,
imgAttributes,
heightInt,
widthInt,
qualityInt,
layout,
className,
imgStyle,
blurStyle,
loading,
config,
unoptimized,
placeholder,
loader,
srcString,
onLoadingCompleteRef,
setBlurComplete,
setIntersection,
isVisible,
noscriptSizes: sizes
}, rest);
return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement("span", {
style: wrapperStyle
}, hasSizer ? /*#__PURE__*/ _react.default.createElement("span", {
style: sizerStyle
}, sizerSvgUrl ? /*#__PURE__*/ _react.default.createElement("img", {
style: {
display: "block",
maxWidth: "100%",
width: "initial",
height: "initial",
background: "none",
opacity: 1,
border: 0,
margin: 0,
padding: 0
},
alt: "",
"aria-hidden": true,
src: sizerSvgUrl
}) : null) : null, /*#__PURE__*/ _react.default.createElement(ImageElement, Object.assign({}, imgElementArgs))), priority ? // for browsers that do not support `imagesrcset`, and in those cases
// it would likely cause the incorrect image to be preloaded.
//
// https://html.spec.whatwg.org/multipage/semantics.html#attr-link-imagesrcset
/*#__PURE__*/ _react.default.createElement(_head.default, null, /*#__PURE__*/ _react.default.createElement("link", Object.assign({
key: "__nimg-" + imgAttributes.src + imgAttributes.srcSet + imgAttributes.sizes,
rel: "preload",
as: "image",
href: imgAttributes.srcSet ? undefined : imgAttributes.src
}, linkProps))) : null);
}
"client";
function normalizeSrc(src) {
return src[0] === "/" ? src.slice(1) : src;
}
const configEnv = {"deviceSizes":[640,750,828,1080,1200,1920,2048,3840],"imageSizes":[16,32,48,64,96,128,256,384],"path":"/_next/image","loader":"default","dangerouslyAllowSVG":false,"unoptimized":false};
const loadedImageURLs = new Set();
const allImgs = new Map();
let perfObserver;
const emptyDataURL = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
if (true) {
global.__NEXT_IMAGE_IMPORTED = true;
}
const VALID_LOADING_VALUES = (/* unused pure expression or super */ null && ([
"lazy",
"eager",
undefined
]));
function imgixLoader({ config , src , width , quality }) {
// Demo: https://static.imgix.net/daisy.png?auto=format&fit=max&w=300
const url = new URL(`${config.path}${normalizeSrc(src)}`);
const params = url.searchParams;
// auto params can be combined with comma separation, or reiteration
params.set("auto", params.getAll("auto").join(",") || "format");
params.set("fit", params.get("fit") || "max");
params.set("w", params.get("w") || width.toString());
if (quality) {
params.set("q", quality.toString());
}
return url.href;
}
function akamaiLoader({ config , src , width }) {
return `${config.path}${normalizeSrc(src)}?imwidth=${width}`;
}
function cloudinaryLoader({ config , src , width , quality }) {
// Demo: https://res.cloudinary.com/demo/image/upload/w_300,c_limit,q_auto/turtles.jpg
const params = [
"f_auto",
"c_limit",
"w_" + width,
"q_" + (quality || "auto")
];
const paramsString = params.join(",") + "/";
return `${config.path}${paramsString}${normalizeSrc(src)}`;
}
function customLoader({ src }) {
throw new Error(`Image with src "${src}" is missing "loader" prop.` + `\nRead more: https://nextjs.org/docs/messages/next-image-missing-loader`);
}
function defaultLoader({ config , src , width , quality }) {
if (false) {}
if (src.endsWith(".svg") && !config.dangerouslyAllowSVG) {
// Special case to make svg serve as-is to avoid proxying
// through the built-in Image Optimization API.
return src;
}
return `${(0, _normalizeTrailingSlash).normalizePathTrailingSlash(config.path)}?url=${encodeURIComponent(src)}&w=${width}&q=${quality || 75}`;
}
const loaders = new Map([
[
"default",
defaultLoader
],
[
"imgix",
imgixLoader
],
[
"cloudinary",
cloudinaryLoader
],
[
"akamai",
akamaiLoader
],
[
"custom",
customLoader
],
]);
const VALID_LAYOUT_VALUES = (/* unused pure expression or super */ null && ([
"fill",
"fixed",
"intrinsic",
"responsive",
undefined,
]));
function isStaticRequire(src) {
return src.default !== undefined;
}
function isStaticImageData(src) {
return src.src !== undefined;
}
function isStaticImport(src) {
return typeof src === "object" && (isStaticRequire(src) || isStaticImageData(src));
}
function getWidths({ deviceSizes , allSizes }, width, layout, sizes) {
if (sizes && (layout === "fill" || layout === "responsive")) {
// Find all the "vw" percent sizes used in the sizes prop
const viewportWidthRe = /(^|\s)(1?\d?\d)vw/g;
const percentSizes = [];
for(let match; match = viewportWidthRe.exec(sizes); match){
percentSizes.push(parseInt(match[2]));
}
if (percentSizes.length) {
const smallestRatio = Math.min(...percentSizes) * 0.01;
return {
widths: allSizes.filter((s)=>s >= deviceSizes[0] * smallestRatio),
kind: "w"
};
}
return {
widths: allSizes,
kind: "w"
};
}
if (typeof width !== "number" || layout === "fill" || layout === "responsive") {
return {
widths: deviceSizes,
kind: "w"
};
}
const widths = [
...new Set(// > are actually 3x in the green color, but only 1.5x in the red and
// > blue colors. Showing a 3x resolution image in the app vs a 2x
// > resolution image will be visually the same, though the 3x image
// > takes significantly more data. Even true 3x resolution screens are
// > wasteful as the human eye cannot see that level of detail without
// > something like a magnifying glass.
// https://blog.twitter.com/engineering/en_us/topics/infrastructure/2019/capping-image-fidelity-on-ultra-high-resolution-devices.html
[
width,
width * 2 /*, width * 3*/
].map((w)=>allSizes.find((p)=>p >= w) || allSizes[allSizes.length - 1])),
];
return {
widths,
kind: "x"
};
}
function generateImgAttrs({ config , src , unoptimized , layout , width , quality , sizes , loader }) {
if (unoptimized) {
return {
src,
srcSet: undefined,
sizes: undefined
};
}
const { widths , kind } = getWidths(config, width, layout, sizes);
const last = widths.length - 1;
return {
sizes: !sizes && kind === "w" ? "100vw" : sizes,
srcSet: widths.map((w, i)=>`${loader({
config,
src,
quality,
width: w
})} ${kind === "w" ? w : i + 1}${kind}`).join(", "),
// It's intended to keep `src` the last attribute because React updates
// attributes in order. If we keep `src` the first one, Safari will
// immediately start to fetch `src`, before `sizes` and `srcSet` are even
// updated by React. That causes multiple unnecessary requests if `srcSet`
// and `sizes` are defined.
// This bug cannot be reproduced in Chrome or Firefox.
src: loader({
config,
src,
quality,
width: widths[last]
})
};
}
function getInt(x) {
if (typeof x === "number") {
return x;
}
if (typeof x === "string") {
return parseInt(x, 10);
}
return undefined;
}
function defaultImageLoader(loaderProps) {
var ref;
const loaderKey = ((ref = loaderProps.config) == null ? void 0 : ref.loader) || "default";
const load = loaders.get(loaderKey);
if (load) {
return load(loaderProps);
}
throw new Error(`Unknown "loader" found in "next.config.js". Expected: ${_imageConfig.VALID_LOADERS.join(", ")}. Received: ${loaderKey}`);
}
// See https://stackoverflow.com/q/39777833/266535 for why we use this ref
// handler instead of the img's onLoad attribute.
function handleLoading(img, src, layout, placeholder, onLoadingCompleteRef, setBlurComplete) {
if (!img || img.src === emptyDataURL || img["data-loaded-src"] === src) {
return;
}
img["data-loaded-src"] = src;
const p = "decode" in img ? img.decode() : Promise.resolve();
p.catch(()=>{}).then(()=>{
if (!img.parentNode) {
// Exit early in case of race condition:
// - onload() is called
// - decode() is called but incomplete
// - unmount is called
// - decode() completes
return;
}
loadedImageURLs.add(src);
if (placeholder === "blur") {
setBlurComplete(true);
}
if (onLoadingCompleteRef == null ? void 0 : onLoadingCompleteRef.current) {
const { naturalWidth , naturalHeight } = img;
// Pass back read-only primitive values but not the
// underlying DOM element because it could be misused.
onLoadingCompleteRef.current({
naturalWidth,
naturalHeight
});
}
if (false) { var ref; }
});
}
const ImageElement = (_param)=>{
var { imgAttributes , heightInt , widthInt , qualityInt , layout , className , imgStyle , blurStyle , isLazy , placeholder , loading , srcString , config , unoptimized , loader , onLoadingCompleteRef , setBlurComplete , setIntersection , onLoad , onError , isVisible , noscriptSizes } = _param, rest = _object_without_properties_loose(_param, [
"imgAttributes",
"heightInt",
"widthInt",
"qualityInt",
"layout",
"className",
"imgStyle",
"blurStyle",
"isLazy",
"placeholder",
"loading",
"srcString",
"config",
"unoptimized",
"loader",
"onLoadingCompleteRef",
"setBlurComplete",
"setIntersection",
"onLoad",
"onError",
"isVisible",
"noscriptSizes"
]);
loading = isLazy ? "lazy" : loading;
return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement("img", Object.assign({}, rest, imgAttributes, {
decoding: "async",
"data-nimg": layout,
className: className,
style: _extends({}, imgStyle, blurStyle),
ref: (0, _react).useCallback((img)=>{
if (false) {}
setIntersection(img);
if (img == null ? void 0 : img.complete) {
handleLoading(img, srcString, layout, placeholder, onLoadingCompleteRef, setBlurComplete);
}
}, [
setIntersection,
srcString,
layout,
placeholder,
onLoadingCompleteRef,
setBlurComplete,
]),
onLoad: (event)=>{
const img = event.currentTarget;
handleLoading(img, srcString, layout, placeholder, onLoadingCompleteRef, setBlurComplete);
if (onLoad) {
onLoad(event);
}
},
onError: (event)=>{
if (placeholder === "blur") {
// If the real image fails to load, this will still remove the placeholder.
setBlurComplete(true);
}
if (onError) {
onError(event);
}
}
})), (isLazy || placeholder === "blur") && /*#__PURE__*/ _react.default.createElement("noscript", null, /*#__PURE__*/ _react.default.createElement("img", Object.assign({}, rest, generateImgAttrs({
config,
src: srcString,
unoptimized,
layout,
width: widthInt,
quality: qualityInt,
sizes: noscriptSizes,
loader
}), {
decoding: "async",
"data-nimg": layout,
style: imgStyle,
className: className,
// @ts-ignore - TODO: upgrade to `@types/react@17`
loading: loading
}))));
};
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=image.js.map
/***/ }),
/***/ 8418:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
"client";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = void 0;
var _interop_require_default = (__webpack_require__(2648)/* ["default"] */ .Z);
var _object_without_properties_loose = (__webpack_require__(7273)/* ["default"] */ .Z);
var _react = _interop_require_default(__webpack_require__(6689));
var _router = __webpack_require__(6273);
var _addLocale = __webpack_require__(2725);
var _routerContext = __webpack_require__(4964);
var _appRouterContext = __webpack_require__(3280);
var _useIntersection = __webpack_require__(7190);
var _getDomainLocale = __webpack_require__(1210);
var _addBasePath = __webpack_require__(8684);
"client";
const prefetched = {};
function prefetch(router, href, as, options) {
if (true) return;
if (!(0, _router).isLocalURL(href)) return;
// Prefetch the JSON page if asked (only in the client)
// We need to handle a prefetch error here since we may be
// loading with priority which can reject but we don't
// want to force navigation since this is only a prefetch
Promise.resolve(router.prefetch(href, as, options)).catch((err)=>{
if (false) {}
});
const curLocale = options && typeof options.locale !== "undefined" ? options.locale : router && router.locale;
// Join on an invalid URI character
prefetched[href + "%" + as + (curLocale ? "%" + curLocale : "")] = true;
}
function isModifiedEvent(event) {
const { target } = event.currentTarget;
return target && target !== "_self" || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || event.nativeEvent && event.nativeEvent.which === 2;
}
function linkClicked(e, router, href, as, replace, shallow, scroll, locale, isAppRouter, prefetchEnabled) {
const { nodeName } = e.currentTarget;
// anchors inside an svg have a lowercase nodeName
const isAnchorNodeName = nodeName.toUpperCase() === "A";
if (isAnchorNodeName && (isModifiedEvent(e) || !(0, _router).isLocalURL(href))) {
// ignore click for browser’s default behavior
return;
}
e.preventDefault();
const navigate = ()=>{
// If the router is an NextRouter instance it will have `beforePopState`
if ("beforePopState" in router) {
router[replace ? "replace" : "push"](href, as, {
shallow,
locale,
scroll
});
} else {
// If `beforePopState` doesn't exist on the router it's the AppRouter.
const method = replace ? "replace" : "push";
router[method](href, {
forceOptimisticNavigation: !prefetchEnabled
});
}
};
if (isAppRouter) {
// @ts-expect-error startTransition exists.
_react.default.startTransition(navigate);
} else {
navigate();
}
}
const Link = /*#__PURE__*/ _react.default.forwardRef(function LinkComponent(props, forwardedRef) {
if (false) {}
let children;
const { href: hrefProp , as: asProp , children: childrenProp , prefetch: prefetchProp , passHref , replace , shallow , scroll , locale , onClick , onMouseEnter , onTouchStart , legacyBehavior =Boolean(false) !== true } = props, restProps = _object_without_properties_loose(props, [
"href",
"as",
"children",
"prefetch",
"passHref",
"replace",
"shallow",
"scroll",
"locale",
"onClick",
"onMouseEnter",
"onTouchStart",
"legacyBehavior"
]);
children = childrenProp;
if (legacyBehavior && (typeof children === "string" || typeof children === "number")) {
children = /*#__PURE__*/ _react.default.createElement("a", null, children);
}
const p = prefetchProp !== false;
let router = _react.default.useContext(_routerContext.RouterContext);
// TODO-APP: type error. Remove `as any`
const appRouter = _react.default.useContext(_appRouterContext.AppRouterContext);
if (appRouter) {
router = appRouter;
}
const { href , as } = _react.default.useMemo(()=>{
const [resolvedHref, resolvedAs] = (0, _router).resolveHref(router, hrefProp, true);
return {
href: resolvedHref,
as: asProp ? (0, _router).resolveHref(router, asProp) : resolvedAs || resolvedHref
};
}, [
router,
hrefProp,
asProp
]);
const previousHref = _react.default.useRef(href);
const previousAs = _react.default.useRef(as);
// This will return the first child, if multiple are provided it will throw an error
let child;
if (legacyBehavior) {
if (false) {} else {
child = _react.default.Children.only(children);
}
}
const childRef = legacyBehavior ? child && typeof child === "object" && child.ref : forwardedRef;
const [setIntersectionRef, isVisible, resetVisible] = (0, _useIntersection).useIntersection({
rootMargin: "200px"
});
const setRef = _react.default.useCallback((el)=>{
// Before the link getting observed, check if visible state need to be reset
if (previousAs.current !== as || previousHref.current !== href) {
resetVisible();
previousAs.current = as;
previousHref.current = href;
}
setIntersectionRef(el);
if (childRef) {
if (typeof childRef === "function") childRef(el);
else if (typeof childRef === "object") {
childRef.current = el;
}
}
}, [
as,
childRef,
href,
resetVisible,
setIntersectionRef
]);
_react.default.useEffect(()=>{
const shouldPrefetch = isVisible && p && (0, _router).isLocalURL(href);
const curLocale = typeof locale !== "undefined" ? locale : router && router.locale;
const isPrefetched = prefetched[href + "%" + as + (curLocale ? "%" + curLocale : "")];
if (shouldPrefetch && !isPrefetched) {
prefetch(router, href, as, {
locale: curLocale
});
}
}, [
as,
href,
isVisible,
locale,
p,
router
]);
const childProps = {
ref: setRef,
onClick: (e)=>{
if (false) {}
if (!legacyBehavior && typeof onClick === "function") {
onClick(e);
}
if (legacyBehavior && child.props && typeof child.props.onClick === "function") {
child.props.onClick(e);
}
if (!e.defaultPrevented) {
linkClicked(e, router, href, as, replace, shallow, scroll, locale, Boolean(appRouter), p);
}
},
onMouseEnter: (e)=>{
if (!legacyBehavior && typeof onMouseEnter === "function") {
onMouseEnter(e);
}
if (legacyBehavior && child.props && typeof child.props.onMouseEnter === "function") {
child.props.onMouseEnter(e);
}
// Check for not prefetch disabled in page using appRouter
if (!(!p && appRouter)) {
if ((0, _router).isLocalURL(href)) {
prefetch(router, href, as, {
priority: true
});
}
}
},
onTouchStart: (e)=>{
if (!legacyBehavior && typeof onTouchStart === "function") {
onTouchStart(e);
}
if (legacyBehavior && child.props && typeof child.props.onTouchStart === "function") {
child.props.onTouchStart(e);
}
// Check for not prefetch disabled in page using appRouter
if (!(!p && appRouter)) {
if ((0, _router).isLocalURL(href)) {
prefetch(router, href, as, {
priority: true
});
}
}
}
};
// If child is an <a> tag and doesn't have a href attribute, or if the 'passHref' property is
// defined, we specify the current 'href', so that repetition is not needed by the user
if (!legacyBehavior || passHref || child.type === "a" && !("href" in child.props)) {
const curLocale = typeof locale !== "undefined" ? locale : router && router.locale;
// we only render domain locales if we are currently on a domain locale
// so that locale links are still visitable in development/preview envs
const localeDomain = router && router.isLocaleDomain && (0, _getDomainLocale).getDomainLocale(as, curLocale, router.locales, router.domainLocales);
childProps.href = localeDomain || (0, _addBasePath).addBasePath((0, _addLocale).addLocale(as, curLocale, router && router.defaultLocale));
}
return legacyBehavior ? /*#__PURE__*/ _react.default.cloneElement(child, childProps) : /*#__PURE__*/ _react.default.createElement("a", Object.assign({}, restProps, childProps), children);
});
var _default = Link;
exports["default"] = _default;
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=link.js.map
/***/ }),
/***/ 2392:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.normalizePathTrailingSlash = void 0;
var _removeTrailingSlash = __webpack_require__(3297);
var _parsePath = __webpack_require__(8854);
const normalizePathTrailingSlash = (path)=>{
if (!path.startsWith("/") || undefined) {
return path;
}
const { pathname , query , hash } = (0, _parsePath).parsePath(path);
if (false) {}
return `${(0, _removeTrailingSlash).removeTrailingSlash(pathname)}${query}${hash}`;
};
exports.normalizePathTrailingSlash = normalizePathTrailingSlash;
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=normalize-trailing-slash.js.map
/***/ }),
/***/ 9320:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.removeBasePath = removeBasePath;
var _hasBasePath = __webpack_require__(4119);
const basePath = false || "";
function removeBasePath(path) {
if (false) {}
path = path.slice(basePath.length);
if (!path.startsWith("/")) path = `/${path}`;
return path;
}
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=remove-base-path.js.map
/***/ }),
/***/ 5776:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.removeLocale = removeLocale;
var _parsePath = __webpack_require__(8854);
function removeLocale(path, locale) {
if (false) {}
return path;
}
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=remove-locale.js.map
/***/ }),
/***/ 9311:
/***/ ((module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.cancelIdleCallback = exports.requestIdleCallback = void 0;
const requestIdleCallback = typeof self !== "undefined" && self.requestIdleCallback && self.requestIdleCallback.bind(window) || 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 && self.cancelIdleCallback.bind(window) || function(id) {
return clearTimeout(id);
};
exports.cancelIdleCallback = cancelIdleCallback;
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=request-idle-callback.js.map
/***/ }),
/***/ 2669:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.markAssetError = markAssetError;
exports.isAssetError = isAssetError;
exports.getClientBuildManifest = getClientBuildManifest;
exports.createRouteLoader = createRouteLoader;
var _interop_require_default = (__webpack_require__(2648)/* ["default"] */ .Z);
var _getAssetPathFromRoute = _interop_require_default(__webpack_require__(9565));
var _trustedTypes = __webpack_require__(4991);
var _requestIdleCallback = __webpack_require__(9311);
// 3.8s was arbitrarily chosen as it's what https://web.dev/interactive
// considers as "Good" time-to-interactive. We must assume something went
// wrong beyond this point, and then fall-back to a full page transition to
// show the user something of value.
const MS_MAX_IDLE_DELAY = 3800;
function withFuture(key, map, generator) {
let entry = map.get(key);
if (entry) {
if ("future" in entry) {
return entry.future;
}
return Promise.resolve(entry);
}
let resolver;
const prom = new Promise((resolve)=>{
resolver = resolve;
});
map.set(key, entry = {
resolve: resolver,
future: prom
});
return generator ? generator() // eslint-disable-next-line no-sequences
.then((value)=>(resolver(value), value)).catch((err)=>{
map.delete(key);
throw err;
}) : prom;
}
function hasPrefetch(link) {
try {
link = document.createElement("link");
return(// with relList.support
!!window.MSInputMethodContext && !!document.documentMode || link.relList.supports("prefetch"));
} catch (e) {
return false;
}
}
const canPrefetch = hasPrefetch();
function prefetchViaDom(href, as, link) {
return new Promise((res, rej)=>{
const selector = `
link[rel="prefetch"][href^="${href}"],
link[rel="preload"][href^="${href}"],
script[src^="${href}"]`;
if (document.querySelector(selector)) {
return res();
}
link = document.createElement("link");
// The order of property assignment here is intentional:
if (as) link.as = as;
link.rel = `prefetch`;
link.crossOrigin = undefined;
link.onload = res;
link.onerror = rej;
// `href` should always be last:
link.href = href;
document.head.appendChild(link);
});
}
const ASSET_LOAD_ERROR = Symbol("ASSET_LOAD_ERROR");
function markAssetError(err) {
return Object.defineProperty(err, ASSET_LOAD_ERROR, {});
}
function isAssetError(err) {
return err && ASSET_LOAD_ERROR in err;
}
function appendScript(src, script) {
return new Promise((resolve, reject)=>{
script = document.createElement("script");
// The order of property assignment here is intentional.
// 1. Setup success/failure hooks in case the browser synchronously
// executes when `src` is set.
script.onload = resolve;
script.onerror = ()=>reject(markAssetError(new Error(`Failed to load script: ${src}`)));
// 2. Configure the cross-origin attribute before setting `src` in case the
// browser begins to fetch.
script.crossOrigin = undefined;
// 3. Finally, set the source and inject into the DOM in case the child
// must be appended for fetching to start.
script.src = src;
document.body.appendChild(script);
});
}
// We wait for pages to be built in dev before we start the route transition
// timeout to prevent an un-necessary hard navigation in development.
let devBuildPromise;
// Resolve a promise that times out after given amount of milliseconds.
function resolvePromiseWithTimeout(p, ms, err) {
return new Promise((resolve, reject)=>{
let cancelled = false;
p.then((r)=>{
// Resolved, cancel the timeout
cancelled = true;
resolve(r);
}).catch(reject);
// We wrap these checks separately for better dead-code elimination in
// production bundles.
if (false) {}
if (true) {
(0, _requestIdleCallback).requestIdleCallback(()=>setTimeout(()=>{
if (!cancelled) {
reject(err);
}
}, ms));
}
});
}
function getClientBuildManifest() {
if (self.__BUILD_MANIFEST) {
return Promise.resolve(self.__BUILD_MANIFEST);
}
const onBuildManifest = new Promise((resolve)=>{
// Mandatory because this is not concurrent safe:
const cb = self.__BUILD_MANIFEST_CB;
self.__BUILD_MANIFEST_CB = ()=>{
resolve(self.__BUILD_MANIFEST);
cb && cb();
};
});
return resolvePromiseWithTimeout(onBuildManifest, MS_MAX_IDLE_DELAY, markAssetError(new Error("Failed to load client build manifest")));
}
function getFilesForRoute(assetPrefix, route) {
if (false) {}
return getClientBuildManifest().then((manifest)=>{
if (!(route in manifest)) {
throw markAssetError(new Error(`Failed to lookup route: ${route}`));
}
const allFiles = manifest[route].map((entry)=>assetPrefix + "/_next/" + encodeURI(entry));
return {
scripts: allFiles.filter((v)=>v.endsWith(".js")).map((v)=>(0, _trustedTypes).__unsafeCreateTrustedScriptURL(v)),
css: allFiles.filter((v)=>v.endsWith(".css"))
};
});
}
function createRouteLoader(assetPrefix) {
const entrypoints = new Map();
const loadedScripts = new Map();
const styleSheets = new Map();
const routes = new Map();
function maybeExecuteScript(src) {
// With HMR we might need to "reload" scripts when they are
// disposed and readded. Executing scripts twice has no functional
// differences
if (true) {
let prom = loadedScripts.get(src.toString());
if (prom) {
return prom;
}
// Skip executing script if it's already in the DOM:
if (document.querySelector(`script[src^="${src}"]`)) {
return Promise.resolve();
}
loadedScripts.set(src.toString(), prom = appendScript(src));
return prom;
} else {}
}
function fetchStyleSheet(href) {
let prom = styleSheets.get(href);
if (prom) {
return prom;
}
styleSheets.set(href, prom = fetch(href).then((res)=>{
if (!res.ok) {
throw new Error(`Failed to load stylesheet: ${href}`);
}
return res.text().then((text)=>({
href: href,
content: text
}));
}).catch((err)=>{
throw markAssetError(err);
}));
return prom;
}
return {
whenEntrypoint (route) {
return withFuture(route, entrypoints);
},
onEntrypoint (route, execute) {
(execute ? Promise.resolve().then(()=>execute()).then((exports1)=>({
component: exports1 && exports1.default || exports1,
exports: exports1
}), (err)=>({
error: err
})) : Promise.resolve(undefined)).then((input)=>{
const old = entrypoints.get(route);
if (old && "resolve" in old) {
if (input) {
entrypoints.set(route, input);
old.resolve(input);
}
} else {
if (input) {
entrypoints.set(route, input);
} else {
entrypoints.delete(route);
}
// when this entrypoint has been resolved before
// the route is outdated and we want to invalidate
// this cache entry
routes.delete(route);
}
});
},
loadRoute (route, prefetch) {
return withFuture(route, routes, ()=>{
let devBuildPromiseResolve;
if (false) {}
return resolvePromiseWithTimeout(getFilesForRoute(assetPrefix, route).then(({ scripts , css })=>{
return Promise.all([
entrypoints.has(route) ? [] : Promise.all(scripts.map(maybeExecuteScript)),
Promise.all(css.map(fetchStyleSheet)),
]);
}).then((res)=>{
return this.whenEntrypoint(route).then((entrypoint)=>({
entrypoint,
styles: res[1]
}));
}), MS_MAX_IDLE_DELAY, markAssetError(new Error(`Route did not complete loading: ${route}`))).then(({ entrypoint , styles })=>{
const res = Object.assign({
styles: styles
}, entrypoint);
return "error" in entrypoint ? entrypoint : res;
}).catch((err)=>{
if (prefetch) {
// we don't want to cache errors during prefetch
throw err;
}
return {
error: err
};
}).finally(()=>{
return devBuildPromiseResolve == null ? void 0 : devBuildPromiseResolve();
});
});
},
prefetch (route) {
// https://github.com/GoogleChromeLabs/quicklink/blob/453a661fa1fa940e2d2e044452398e38c67a98fb/src/index.mjs#L115-L118
// License: Apache 2.0
let cn;
if (cn = navigator.connection) {
// Don't prefetch if using 2G or if Save-Data is enabled.
if (cn.saveData || /2g/.test(cn.effectiveType)) return Promise.resolve();
}
return getFilesForRoute(assetPrefix, route).then((output)=>Promise.all(canPrefetch ? output.scripts.map((script)=>prefetchViaDom(script.toString(), "script")) : [])).then(()=>{
(0, _requestIdleCallback).requestIdleCallback(()=>this.loadRoute(route, true).catch(()=>{}));
}).catch(()=>{});
}
};
}
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=route-loader.js.map
/***/ }),
/***/ 699:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
"client";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.handleClientScriptLoad = handleClientScriptLoad;
exports.initScriptLoader = initScriptLoader;
exports["default"] = void 0;
var _extends = (__webpack_require__(6495)/* ["default"] */ .Z);
var _interop_require_wildcard = (__webpack_require__(1598)/* ["default"] */ .Z);
var _object_without_properties_loose = (__webpack_require__(7273)/* ["default"] */ .Z);
var _react = _interop_require_wildcard(__webpack_require__(6689));
var _headManagerContext = __webpack_require__(2796);
var _headManager = __webpack_require__(6007);
var _requestIdleCallback = __webpack_require__(9311);
"client";
const ScriptCache = new Map();
const LoadCache = new Set();
const ignoreProps = [
"onLoad",
"onReady",
"dangerouslySetInnerHTML",
"children",
"onError",
"strategy",
];
const loadScript = (props)=>{
const { src , id , onLoad =()=>{} , onReady =null , dangerouslySetInnerHTML , children ="" , strategy ="afterInteractive" , onError , } = props;
const cacheKey = id || src;
// Script has already loaded
if (cacheKey && LoadCache.has(cacheKey)) {
return;
}
// Contents of this script are already loading/loaded
if (ScriptCache.has(src)) {
LoadCache.add(cacheKey);
// It is possible that multiple `next/script` components all have same "src", but has different "onLoad"
// This is to make sure the same remote script will only load once, but "onLoad" are executed in order
ScriptCache.get(src).then(onLoad, onError);
return;
}
/** Execute after the script first loaded */ const afterLoad = ()=>{
// Run onReady for the first time after load event
if (onReady) {
onReady();
}
// add cacheKey to LoadCache when load successfully
LoadCache.add(cacheKey);
};
const el = document.createElement("script");
const loadPromise = new Promise((resolve, reject)=>{
el.addEventListener("load", function(e) {
resolve();
if (onLoad) {
onLoad.call(this, e);
}
afterLoad();
});
el.addEventListener("error", function(e) {
reject(e);
});
}).catch(function(e) {
if (onError) {
onError(e);
}
});
if (dangerouslySetInnerHTML) {
el.innerHTML = dangerouslySetInnerHTML.__html || "";
afterLoad();
} else if (children) {
el.textContent = typeof children === "string" ? children : Array.isArray(children) ? children.join("") : "";
afterLoad();
} else if (src) {
el.src = src;
// do not add cacheKey into LoadCache for remote script here
// cacheKey will be added to LoadCache when it is actually loaded (see loadPromise above)
ScriptCache.set(src, loadPromise);
}
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);
}
if (strategy === "worker") {
el.setAttribute("type", "text/partytown");
}
el.setAttribute("data-nscript", strategy);
document.body.appendChild(el);
};
function handleClientScriptLoad(props) {
const { strategy ="afterInteractive" } = props;
if (strategy === "lazyOnload") {
window.addEventListener("load", ()=>{
(0, _requestIdleCallback).requestIdleCallback(()=>loadScript(props));
});
} else {
loadScript(props);
}
}
function loadLazyScript(props) {
if (document.readyState === "complete") {
(0, _requestIdleCallback).requestIdleCallback(()=>loadScript(props));
} else {
window.addEventListener("load", ()=>{
(0, _requestIdleCallback).requestIdleCallback(()=>loadScript(props));
});
}
}
function addBeforeInteractiveToCache() {
const scripts = [
...document.querySelectorAll('[data-nscript="beforeInteractive"]'),
...document.querySelectorAll('[data-nscript="beforePageRender"]'),
];
scripts.forEach((script)=>{
const cacheKey = script.id || script.getAttribute("src");
LoadCache.add(cacheKey);
});
}
function initScriptLoader(scriptLoaderItems) {
scriptLoaderItems.forEach(handleClientScriptLoad);
addBeforeInteractiveToCache();
}
function Script(props) {
const { id , src ="" , onLoad =()=>{} , onReady =null , strategy ="afterInteractive" , onError } = props, restProps = _object_without_properties_loose(props, [
"id",
"src",
"onLoad",
"onReady",
"strategy",
"onError"
]);
// Context is available only during SSR
const { updateScripts , scripts , getIsSsr } = (0, _react).useContext(_headManagerContext.HeadManagerContext);
/**
* - First mount:
* 1. The useEffect for onReady executes
* 2. hasOnReadyEffectCalled.current is false, but the script hasn't loaded yet (not in LoadCache)
* onReady is skipped, set hasOnReadyEffectCalled.current to true
* 3. The useEffect for loadScript executes
* 4. hasLoadScriptEffectCalled.current is false, loadScript executes
* Once the script is loaded, the onLoad and onReady will be called by then
* [If strict mode is enabled / is wrapped in <OffScreen /> component]
* 5. The useEffect for onReady executes again
* 6. hasOnReadyEffectCalled.current is true, so entire effect is skipped
* 7. The useEffect for loadScript executes again
* 8. hasLoadScriptEffectCalled.current is true, so entire effect is skipped
*
* - Second mount:
* 1. The useEffect for onReady executes
* 2. hasOnReadyEffectCalled.current is false, but the script has already loaded (found in LoadCache)
* onReady is called, set hasOnReadyEffectCalled.current to true
* 3. The useEffect for loadScript executes
* 4. The script is already loaded, loadScript bails out
* [If strict mode is enabled / is wrapped in <OffScreen /> component]
* 5. The useEffect for onReady executes again
* 6. hasOnReadyEffectCalled.current is true, so entire effect is skipped
* 7. The useEffect for loadScript executes again
* 8. hasLoadScriptEffectCalled.current is true, so entire effect is skipped
*/ const hasOnReadyEffectCalled = (0, _react).useRef(false);
(0, _react).useEffect(()=>{
const cacheKey = id || src;
if (!hasOnReadyEffectCalled.current) {
// Run onReady if script has loaded before but component is re-mounted
if (onReady && cacheKey && LoadCache.has(cacheKey)) {
onReady();
}
hasOnReadyEffectCalled.current = true;
}
}, [
onReady,
id,
src
]);
const hasLoadScriptEffectCalled = (0, _react).useRef(false);
(0, _react).useEffect(()=>{
if (!hasLoadScriptEffectCalled.current) {
if (strategy === "afterInteractive") {
loadScript(props);
} else if (strategy === "lazyOnload") {
loadLazyScript(props);
}
hasLoadScriptEffectCalled.current = true;
}
}, [
props,
strategy
]);
if (strategy === "beforeInteractive" || strategy === "worker") {
if (updateScripts) {
scripts[strategy] = (scripts[strategy] || []).concat([
_extends({
id,
src,
onLoad,
onReady,
onError
}, restProps),
]);
updateScripts(scripts);
} else if (getIsSsr && getIsSsr()) {
// Script has already loaded during SSR
LoadCache.add(id || src);
} else if (getIsSsr && !getIsSsr()) {
loadScript(props);
}
}
return null;
}
Object.defineProperty(Script, "__nextScript", {
value: true
});
var _default = Script;
exports["default"] = _default;
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=script.js.map
/***/ }),
/***/ 4991:
/***/ ((module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.__unsafeCreateTrustedScriptURL = __unsafeCreateTrustedScriptURL;
/**
* Stores the Trusted Types Policy. Starts as undefined and can be set to null
* if Trusted Types is not supported in the browser.
*/ let policy;
/**
* Getter for the Trusted Types Policy. If it is undefined, it is instantiated
* here or set to null if Trusted Types is not supported in the browser.
*/ function getPolicy() {
if (typeof policy === "undefined" && "undefined" !== "undefined") { var ref; }
return policy;
}
function __unsafeCreateTrustedScriptURL(url) {
var ref;
return ((ref = getPolicy()) == null ? void 0 : ref.createScriptURL(url)) || url;
}
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=trusted-types.js.map
/***/ }),
/***/ 7190:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.useIntersection = useIntersection;
var _react = __webpack_require__(6689);
var _requestIdleCallback = __webpack_require__(9311);
const hasIntersectionObserver = typeof IntersectionObserver === "function";
const observers = new Map();
const idList = [];
function createObserver(options) {
const id = {
root: options.root || null,
margin: options.rootMargin || ""
};
const existing = idList.find((obj)=>obj.root === id.root && obj.margin === id.margin);
let instance;
if (existing) {
instance = observers.get(existing);
if (instance) {
return instance;
}
}
const elements = new Map();
const observer = new IntersectionObserver((entries)=>{
entries.forEach((entry)=>{
const callback = elements.get(entry.target);
const isVisible = entry.isIntersecting || entry.intersectionRatio > 0;
if (callback && isVisible) {
callback(isVisible);
}
});
}, options);
instance = {
id,
observer,
elements
};
idList.push(id);
observers.set(id, instance);
return instance;
}
function observe(element, callback, options) {
const { id , observer , elements } = createObserver(options);
elements.set(element, callback);
observer.observe(element);
return function unobserve() {
elements.delete(element);
observer.unobserve(element);
// Destroy observer when there's nothing left to watch:
if (elements.size === 0) {
observer.disconnect();
observers.delete(id);
const index = idList.findIndex((obj)=>obj.root === id.root && obj.margin === id.margin);
if (index > -1) {
idList.splice(index, 1);
}
}
};
}
function useIntersection({ rootRef , rootMargin , disabled }) {
const isDisabled = disabled || !hasIntersectionObserver;
const [visible, setVisible] = (0, _react).useState(false);
const [element, setElement] = (0, _react).useState(null);
(0, _react).useEffect(()=>{
if (hasIntersectionObserver) {
if (isDisabled || visible) return;
if (element && element.tagName) {
const unobserve = observe(element, (isVisible)=>isVisible && setVisible(isVisible), {
root: rootRef == null ? void 0 : rootRef.current,
rootMargin
});
return unobserve;
}
} else {
if (!visible) {
const idleCallback = (0, _requestIdleCallback).requestIdleCallback(()=>setVisible(true));
return ()=>(0, _requestIdleCallback).cancelIdleCallback(idleCallback);
}
}
}, [
element,
isDisabled,
rootMargin,
rootRef,
visible
]);
const resetVisible = (0, _react).useCallback(()=>{
setVisible(false);
}, []);
return [
setElement,
visible,
resetVisible
];
}
if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
Object.defineProperty(exports.default, "__esModule", {
value: true
});
Object.assign(exports.default, exports);
module.exports = exports.default;
} //# sourceMappingURL=use-intersection.js.map
/***/ }),
/***/ 6273:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.matchesMiddleware = matchesMiddleware;
exports.isLocalURL = isLocalURL;
exports.interpolateAs = interpolateAs;
exports.resolveHref = resolveHref;
exports.createKey = createKey;
exports["default"] = void 0;
var _async_to_generator = (__webpack_require__(932)/* ["default"] */ .Z);
var _extends = (__webpack_require__(6495)/* ["default"] */ .Z);
var _interop_require_default = (__webpack_require__(2648)/* ["default"] */ .Z);
var _interop_require_wildcard = (__webpack_require__(1598)/* ["default"] */ .Z);
var _normalizeTrailingSlash = __webpack_require__(2392);
var _removeTrailingSlash = __webpack_require__(3297);
var _routeLoader = __webpack_require__(2669);
var _script = __webpack_require__(699);
var _isError = _interop_require_wildcard(__webpack_require__(676));
var _denormalizePagePath = __webpack_require__(4406);
var _normalizeLocalePath = __webpack_require__(4014);
var _mitt = _interop_require_default(__webpack_require__(8020));
var _utils = __webpack_require__(9232);
var _isDynamic = __webpack_require__(1428);
var _parseRelativeUrl = __webpack_require__(1292);
var _querystring = __webpack_require__(979);
var _resolveRewrites = _interop_require_default(__webpack_require__(6052));
var _routeMatcher = __webpack_require__(4226);
var _routeRegex = __webpack_require__(5052);
var _formatUrl = __webpack_require__(3938);
var _detectDomainLocale = __webpack_require__(8748);
var _parsePath = __webpack_require__(8854);
var _addLocale = __webpack_require__(2725);
var _removeLocale = __webpack_require__(5776);
var _removeBasePath = __webpack_require__(9320);
var _addBasePath = __webpack_require__(8684);
var _hasBasePath = __webpack_require__(4119);
var _getNextPathnameInfo = __webpack_require__(5789);
var _formatNextPathnameInfo = __webpack_require__(299);
var _compareStates = __webpack_require__(6220);
var _isBot = __webpack_require__(1897);
function buildCancellationError() {
return Object.assign(new Error("Route Cancelled"), {
cancelled: true
});
}
function matchesMiddleware(options) {
return _matchesMiddleware.apply(this, arguments);
}
function _matchesMiddleware() {
_matchesMiddleware = _async_to_generator(function*(options) {
const matchers = yield Promise.resolve(options.router.pageLoader.getMiddleware());
if (!matchers) return false;
const { pathname: asPathname } = (0, _parsePath).parsePath(options.asPath);
// remove basePath first since path prefix has to be in the order of `/${basePath}/${locale}`
const cleanedAs = (0, _hasBasePath).hasBasePath(asPathname) ? (0, _removeBasePath).removeBasePath(asPathname) : asPathname;
const asWithBasePathAndLocale = (0, _addBasePath).addBasePath((0, _addLocale).addLocale(cleanedAs, options.locale));
// Check only path match on client. Matching "has" should be done on server
// where we can access more info such as headers, HttpOnly cookie, etc.
return matchers.some((m)=>new RegExp(m.regexp).test(asWithBasePathAndLocale));
});
return _matchesMiddleware.apply(this, arguments);
}
function stripOrigin(url) {
const origin = (0, _utils).getLocationOrigin();
return url.startsWith(origin) ? url.substring(origin.length) : url;
}
function omit(object, keys) {
const omitted = {};
Object.keys(object).forEach((key)=>{
if (!keys.includes(key)) {
omitted[key] = object[key];
}
});
return omitted;
}
function isLocalURL(url) {
// prevent a hydration mismatch on href for url with anchor refs
if (!(0, _utils).isAbsoluteUrl(url)) return true;
try {
// absolute urls can be local if they are on the same origin
const locationOrigin = (0, _utils).getLocationOrigin();
const resolved = new URL(url, locationOrigin);
return resolved.origin === locationOrigin && (0, _hasBasePath).hasBasePath(resolved.pathname);
} catch (_) {
return false;
}
}
function interpolateAs(route, asPathname, query) {
let interpolatedRoute = "";
const dynamicRegex = (0, _routeRegex).getRouteRegex(route);
const dynamicGroups = dynamicRegex.groups;
const dynamicMatches = (asPathname !== route ? (0, _routeMatcher).getRouteMatcher(dynamicRegex)(asPathname) : "") || // Fall back to reading the values from the href
// TODO: should this take priority; also need to change in the router.
query;
interpolatedRoute = route;
const params = Object.keys(dynamicGroups);
if (!params.every((param)=>{
let value = dynamicMatches[param] || "";
const { repeat , optional } = dynamicGroups[param];
// support single-level catch-all
// TODO: more robust handling for user-error (passing `/`)
let replaced = `[${repeat ? "..." : ""}${param}]`;
if (optional) {
replaced = `${!value ? "/" : ""}[${replaced}]`;
}
if (repeat && !Array.isArray(value)) value = [
value
];
return (optional || param in dynamicMatches) && // Interpolate group into data URL if present
(interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map(// path delimiter escaped since they are being inserted
// into the URL and we expect URL encoded segments
// when parsing dynamic route params
(segment)=>encodeURIComponent(segment)).join("/") : encodeURIComponent(value)) || "/");
})) {
interpolatedRoute = "" // did not satisfy all requirements
;
// n.b. We ignore this error because we handle warning for this case in
// development in the `<Link>` component directly.
}
return {
params,
result: interpolatedRoute
};
}
function resolveHref(router, href, resolveAs) {
// we use a dummy base url for relative urls
let base;
let urlAsString = typeof href === "string" ? href : (0, _formatUrl).formatWithValidation(href);
// repeated slashes and backslashes in the URL are considered
// invalid and will never match a Next.js page/file
const urlProtoMatch = urlAsString.match(/^[a-zA-Z]{1,}:\/\//);
const urlAsStringNoProto = urlProtoMatch ? urlAsString.slice(urlProtoMatch[0].length) : urlAsString;
const urlParts = urlAsStringNoProto.split("?");
if ((urlParts[0] || "").match(/(\/\/|\\)/)) {
console.error(`Invalid href passed to next/router: ${urlAsString}, repeated forward-slashes (//) or backslashes \\ are not valid in the href`);
const normalizedUrl = (0, _utils).normalizeRepeatedSlashes(urlAsStringNoProto);
urlAsString = (urlProtoMatch ? urlProtoMatch[0] : "") + normalizedUrl;
}
// Return because it cannot be routed by the Next.js router
if (!isLocalURL(urlAsString)) {
return resolveAs ? [
urlAsString
] : urlAsString;
}
try {
base = new URL(urlAsString.startsWith("#") ? router.asPath : router.pathname, "http://n");
} catch (_) {
// fallback to / for invalid asPath values e.g. //
base = new URL("/", "http://n");
}
try {
const finalUrl = new URL(urlAsString, base);
finalUrl.pathname = (0, _normalizeTrailingSlash).normalizePathTrailingSlash(finalUrl.pathname);
let interpolatedAs = "";
if ((0, _isDynamic).isDynamicRoute(finalUrl.pathname) && finalUrl.searchParams && resolveAs) {
const query = (0, _querystring).searchParamsToUrlQuery(finalUrl.searchParams);
const { result , params } = interpolateAs(finalUrl.pathname, finalUrl.pathname, query);
if (result) {
interpolatedAs = (0, _formatUrl).formatWithValidation({
pathname: result,
hash: finalUrl.hash,
query: omit(query, params)
});
}
}
// if the origin didn't change, it means we received a relative href
const resolvedHref = finalUrl.origin === base.origin ? finalUrl.href.slice(finalUrl.origin.length) : finalUrl.href;
return resolveAs ? [
resolvedHref,
interpolatedAs || resolvedHref
] : resolvedHref;
} catch (_1) {
return resolveAs ? [
urlAsString
] : urlAsString;
}
}
function prepareUrlAs(router, url, as) {
// If url and as provided as an object representation,
// we'll format them into the string version here.
let [resolvedHref, resolvedAs] = resolveHref(router, url, true);
const origin = (0, _utils).getLocationOrigin();
const hrefHadOrigin = resolvedHref.startsWith(origin);
const asHadOrigin = resolvedAs && resolvedAs.startsWith(origin);
resolvedHref = stripOrigin(resolvedHref);
resolvedAs = resolvedAs ? stripOrigin(resolvedAs) : resolvedAs;
const preparedUrl = hrefHadOrigin ? resolvedHref : (0, _addBasePath).addBasePath(resolvedHref);
const preparedAs = as ? stripOrigin(resolveHref(router, as)) : resolvedAs || resolvedHref;
return {
url: preparedUrl,
as: asHadOrigin ? preparedAs : (0, _addBasePath).addBasePath(preparedAs)
};
}
function resolveDynamicRoute(pathname, pages) {
const cleanPathname = (0, _removeTrailingSlash).removeTrailingSlash((0, _denormalizePagePath).denormalizePagePath(pathname));
if (cleanPathname === "/404" || cleanPathname === "/_error") {
return pathname;
}
// handle resolving href for dynamic routes
if (!pages.includes(cleanPathname)) {
// eslint-disable-next-line array-callback-return
pages.some((page)=>{
if ((0, _isDynamic).isDynamicRoute(page) && (0, _routeRegex).getRouteRegex(page).re.test(cleanPathname)) {
pathname = page;
return true;
}
});
}
return (0, _removeTrailingSlash).removeTrailingSlash(pathname);
}
function getMiddlewareData(source, response, options) {
const nextConfig = {
basePath: options.router.basePath,
i18n: {
locales: options.router.locales
},
trailingSlash: Boolean(false)
};
const rewriteHeader = response.headers.get("x-nextjs-rewrite");
let rewriteTarget = rewriteHeader || response.headers.get("x-nextjs-matched-path");
const matchedPath = response.headers.get("x-matched-path");
if (matchedPath && !rewriteTarget && !matchedPath.includes("__next_data_catchall") && !matchedPath.includes("/_error") && !matchedPath.includes("/404")) {
// leverage x-matched-path to detect next.config.js rewrites
rewriteTarget = matchedPath;
}
if (rewriteTarget) {
if (rewriteTarget.startsWith("/")) {
const parsedRewriteTarget = (0, _parseRelativeUrl).parseRelativeUrl(rewriteTarget);
const pathnameInfo = (0, _getNextPathnameInfo).getNextPathnameInfo(parsedRewriteTarget.pathname, {
nextConfig,
parseData: true
});
let fsPathname = (0, _removeTrailingSlash).removeTrailingSlash(pathnameInfo.pathname);
return Promise.all([
options.router.pageLoader.getPageList(),
(0, _routeLoader).getClientBuildManifest(),
]).then(([pages, { __rewrites: rewrites }])=>{
let as = (0, _addLocale).addLocale(pathnameInfo.pathname, pathnameInfo.locale);
if ((0, _isDynamic).isDynamicRoute(as) || !rewriteHeader && pages.includes((0, _normalizeLocalePath).normalizeLocalePath((0, _removeBasePath).removeBasePath(as), options.router.locales).pathname)) {
const parsedSource = (0, _getNextPathnameInfo).getNextPathnameInfo((0, _parseRelativeUrl).parseRelativeUrl(source).pathname, {
parseData: true
});
as = (0, _addBasePath).addBasePath(parsedSource.pathname);
parsedRewriteTarget.pathname = as;
}
if (false) {} else if (!pages.includes(fsPathname)) {
const resolvedPathname = resolveDynamicRoute(fsPathname, pages);
if (resolvedPathname !== fsPathname) {
fsPathname = resolvedPathname;
}
}
const resolvedHref = !pages.includes(fsPathname) ? resolveDynamicRoute((0, _normalizeLocalePath).normalizeLocalePath((0, _removeBasePath).removeBasePath(parsedRewriteTarget.pathname), options.router.locales).pathname, pages) : fsPathname;
if ((0, _isDynamic).isDynamicRoute(resolvedHref)) {
const matches = (0, _routeMatcher).getRouteMatcher((0, _routeRegex).getRouteRegex(resolvedHref))(as);
Object.assign(parsedRewriteTarget.query, matches || {});
}
return {
type: "rewrite",
parsedAs: parsedRewriteTarget,
resolvedHref
};
});
}
const src = (0, _parsePath).parsePath(source);
const pathname = (0, _formatNextPathnameInfo).formatNextPathnameInfo(_extends({}, (0, _getNextPathnameInfo).getNextPathnameInfo(src.pathname, {
nextConfig,
parseData: true
}), {
defaultLocale: options.router.defaultLocale,
buildId: ""
}));
return Promise.resolve({
type: "redirect-external",
destination: `${pathname}${src.query}${src.hash}`
});
}
const redirectTarget = response.headers.get("x-nextjs-redirect");
if (redirectTarget) {
if (redirectTarget.startsWith("/")) {
const src1 = (0, _parsePath).parsePath(redirectTarget);
const pathname1 = (0, _formatNextPathnameInfo).formatNextPathnameInfo(_extends({}, (0, _getNextPathnameInfo).getNextPathnameInfo(src1.pathname, {
nextConfig,
parseData: true
}), {
defaultLocale: options.router.defaultLocale,
buildId: ""
}));
return Promise.resolve({
type: "redirect-internal",
newAs: `${pathname1}${src1.query}${src1.hash}`,
newUrl: `${pathname1}${src1.query}${src1.hash}`
});
}
return Promise.resolve({
type: "redirect-external",
destination: redirectTarget
});
}
return Promise.resolve({
type: "next"
});
}
function withMiddlewareEffects(options) {
return matchesMiddleware(options).then((matches)=>{
if (matches && options.fetchData) {
return options.fetchData().then((data)=>getMiddlewareData(data.dataHref, data.response, options).then((effect)=>({
dataHref: data.dataHref,
cacheKey: data.cacheKey,
json: data.json,
response: data.response,
text: data.text,
effect
}))).catch((_err)=>{
/**
* TODO: Revisit this in the future.
* For now we will not consider middleware data errors to be fatal.
* maybe we should revisit in the future.
*/ return null;
});
}
return null;
});
}
const manualScrollRestoration = false && 0;
const SSG_DATA_NOT_FOUND = Symbol("SSG_DATA_NOT_FOUND");
function fetchRetry(url, attempts, options) {
return fetch(url, {
// Cookies are required to be present for Next.js' SSG "Preview Mode".
// Cookies may also be required for `getServerSideProps`.
//
// > `fetch` won’t send cookies, unless you set the credentials init
// > option.
// https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch
//
// > For maximum browser compatibility when it comes to sending &
// > receiving cookies, always supply the `credentials: 'same-origin'`
// > option instead of relying on the default.
// https://github.com/github/fetch#caveats
credentials: "same-origin",
method: options.method || "GET",
headers: Object.assign({}, options.headers, {
"x-nextjs-data": "1"
})
}).then((response)=>{
return !response.ok && attempts > 1 && response.status >= 500 ? fetchRetry(url, attempts - 1, options) : response;
});
}
const backgroundCache = {};
function handleSmoothScroll(fn) {
const htmlElement = document.documentElement;
const existing = htmlElement.style.scrollBehavior;
htmlElement.style.scrollBehavior = "auto";
fn();
htmlElement.style.scrollBehavior = existing;
}
function tryToParseAsJSON(text) {
try {
return JSON.parse(text);
} catch (error) {
return null;
}
}
function fetchNextData({ dataHref , inflightCache , isPrefetch , hasMiddleware , isServerRender , parseJSON , persistCache , isBackground , unstable_skipClientCache }) {
const { href: cacheKey } = new URL(dataHref, window.location.href);
var ref1;
const getData = (params)=>{
return fetchRetry(dataHref, isServerRender ? 3 : 1, {
headers: isPrefetch ? {
purpose: "prefetch"
} : {},
method: (ref1 = params == null ? void 0 : params.method) != null ? ref1 : "GET"
}).then((response)=>{
if (response.ok && (params == null ? void 0 : params.method) === "HEAD") {
return {
dataHref,
response,
text: "",
json: {},
cacheKey
};
}
return response.text().then((text)=>{
if (!response.ok) {
/**
* When the data response is a redirect because of a middleware
* we do not consider it an error. The headers must bring the
* mapped location.
* TODO: Change the status code in the handler.
*/ if (hasMiddleware && [
301,
302,
307,
308
].includes(response.status)) {
return {
dataHref,
response,
text,
json: {},
cacheKey
};
}
if (!hasMiddleware && response.status === 404) {
var ref;
if ((ref = tryToParseAsJSON(text)) == null ? void 0 : ref.notFound) {
return {
dataHref,
json: {
notFound: SSG_DATA_NOT_FOUND
},
response,
text,
cacheKey
};
}
}
const error = new Error(`Failed to load static props`);
/**
* We should only trigger a server-side transition if this was
* caused on a client-side transition. Otherwise, we'd get into
* an infinite loop.
*/ if (!isServerRender) {
(0, _routeLoader).markAssetError(error);
}
throw error;
}
return {
dataHref,
json: parseJSON ? tryToParseAsJSON(text) : null,
response,
text,
cacheKey
};
});
}).then((data)=>{
if (!persistCache || "production" !== "production" || data.response.headers.get("x-middleware-cache") === "no-cache") {
delete inflightCache[cacheKey];
}
return data;
}).catch((err)=>{
delete inflightCache[cacheKey];
throw err;
});
};
// when skipping client cache we wait to update
// inflight cache until successful data response
// this allows racing click event with fetching newer data
// without blocking navigation when stale data is available
if (unstable_skipClientCache && persistCache) {
return getData({}).then((data)=>{
inflightCache[cacheKey] = Promise.resolve(data);
return data;
});
}
if (inflightCache[cacheKey] !== undefined) {
return inflightCache[cacheKey];
}
return inflightCache[cacheKey] = getData(isBackground ? {
method: "HEAD"
} : {});
}
function createKey() {
return Math.random().toString(36).slice(2, 10);
}
function handleHardNavigation({ url , router }) {
// ensure we don't trigger a hard navigation to the same
// URL as this can end up with an infinite refresh
if (url === (0, _addBasePath).addBasePath((0, _addLocale).addLocale(router.asPath, router.locale))) {
throw new Error(`Invariant: attempted to hard navigate to the same URL ${url} ${location.href}`);
}
window.location.href = url;
}
const getCancelledHandler = ({ route , router })=>{
let cancelled = false;
const cancel = router.clc = ()=>{
cancelled = true;
};
const handleCancelled = ()=>{
if (cancelled) {
const error = new Error(`Abort fetching component for route: "${route}"`);
error.cancelled = true;
throw error;
}
if (cancel === router.clc) {
router.clc = null;
}
};
return handleCancelled;
};
class Router {
reload() {
window.location.reload();
}
/**
* Go back in history
*/ back() {
window.history.back();
}
/**
* Performs a `pushState` with arguments
* @param url of the route
* @param as masks `url` for the browser
* @param options object you can define `shallow` and other options
*/ push(url, as, options = {}) {
if (true) {
// TODO: remove in the future when we update history before route change
// is complete, as the popstate event should handle this capture.
if (manualScrollRestoration) {
try {
// Snapshot scroll position right before navigating to a new page:
sessionStorage.setItem("__next_scroll_" + this._key, JSON.stringify({
x: self.pageXOffset,
y: self.pageYOffset
}));
} catch (e) {}
}
}
({ url , as } = prepareUrlAs(this, url, as));
return this.change("pushState", url, as, options);
}
/**
* Performs a `replaceState` with arguments
* @param url of the route
* @param as masks `url` for the browser
* @param options object you can define `shallow` and other options
*/ replace(url, as, options = {}) {
({ url , as } = prepareUrlAs(this, url, as));
return this.change("replaceState", url, as, options);
}
change(method, url, as, options, forcedScroll) {
var _this = this;
return _async_to_generator(function*() {
if (!isLocalURL(url)) {
handleHardNavigation({
url,
router: _this
});
return false;
}
// WARNING: `_h` is an internal option for handing Next.js client-side
// hydration. Your app should _never_ use this property. It may change at
// any time without notice.
const isQueryUpdating = options._h;
const shouldResolveHref = isQueryUpdating || options._shouldResolveHref || (0, _parsePath).parsePath(url).pathname === (0, _parsePath).parsePath(as).pathname;
const nextState = _extends({}, _this.state);
// for static pages with query params in the URL we delay
// marking the router ready until after the query is updated
// or a navigation has occurred
const readyStateChange = _this.isReady !== true;
_this.isReady = true;
const isSsr = _this.isSsr;
if (!isQueryUpdating) {
_this.isSsr = false;
}
// if a route transition is already in progress before
// the query updating is triggered ignore query updating
if (isQueryUpdating && _this.clc) {
return false;
}
const prevLocale = nextState.locale;
if (false) { var ref; }
// marking route changes as a navigation start entry
if (_utils.ST) {
performance.mark("routeChange");
}
const { shallow =false , scroll =true } = options;
const routeProps = {
shallow
};
if (_this._inFlightRoute && _this.clc) {
if (!isSsr) {
Router.events.emit("routeChangeError", buildCancellationError(), _this._inFlightRoute, routeProps);
}
_this.clc();
_this.clc = null;
}
as = (0, _addBasePath).addBasePath((0, _addLocale).addLocale((0, _hasBasePath).hasBasePath(as) ? (0, _removeBasePath).removeBasePath(as) : as, options.locale, _this.defaultLocale));
const cleanedAs = (0, _removeLocale).removeLocale((0, _hasBasePath).hasBasePath(as) ? (0, _removeBasePath).removeBasePath(as) : as, nextState.locale);
_this._inFlightRoute = as;
const localeChange = prevLocale !== nextState.locale;
// If the url change is only related to a hash change
// We should not proceed. We should only change the state.
if (!isQueryUpdating && _this.onlyAHashChange(cleanedAs) && !localeChange) {
nextState.asPath = cleanedAs;
Router.events.emit("hashChangeStart", as, routeProps);
// TODO: do we need the resolved href when only a hash change?
_this.changeState(method, url, as, _extends({}, options, {
scroll: false
}));
if (scroll) {
_this.scrollToHash(cleanedAs);
}
try {
yield _this.set(nextState, _this.components[nextState.route], null);
} catch (err) {
if ((0, _isError).default(err) && err.cancelled) {
Router.events.emit("routeChangeError", err, cleanedAs, routeProps);
}
throw err;
}
Router.events.emit("hashChangeComplete", as, routeProps);
return true;
}
let parsed = (0, _parseRelativeUrl).parseRelativeUrl(url);
let { pathname , query } = parsed;
// The build manifest needs to be loaded before auto-static dynamic pages
// get their query parameters to allow ensuring they can be parsed properly
// when rewritten to
let pages, rewrites;
try {
[pages, { __rewrites: rewrites }] = yield Promise.all([
_this.pageLoader.getPageList(),
(0, _routeLoader).getClientBuildManifest(),
_this.pageLoader.getMiddleware(),
]);
} catch (err1) {
// If we fail to resolve the page list or client-build manifest, we must
// do a server-side transition:
handleHardNavigation({
url: as,
router: _this
});
return false;
}
// If asked to change the current URL we should reload the current page
// (not location.reload() but reload getInitialProps and other Next.js stuffs)
// We also need to set the method = replaceState always
// as this should not go into the history (That's how browsers work)
// We should compare the new asPath to the current asPath, not the url
if (!_this.urlIsNew(cleanedAs) && !localeChange) {
method = "replaceState";
}
// we need to resolve the as value using rewrites for dynamic SSG
// pages to allow building the data URL correctly
let resolvedAs = as;
// url and as should always be prefixed with basePath by this
// point by either next/link or router.push/replace so strip the
// basePath from the pathname to match the pages dir 1-to-1
pathname = pathname ? (0, _removeTrailingSlash).removeTrailingSlash((0, _removeBasePath).removeBasePath(pathname)) : pathname;
// we don't attempt resolve asPath when we need to execute
// middleware as the resolving will occur server-side
const isMiddlewareMatch = yield matchesMiddleware({
asPath: as,
locale: nextState.locale,
router: _this
});
if (options.shallow && isMiddlewareMatch) {
pathname = _this.pathname;
}
if (shouldResolveHref && pathname !== "/_error") {
options._shouldResolveHref = true;
if (false) {} else {
parsed.pathname = resolveDynamicRoute(pathname, pages);
if (parsed.pathname !== pathname) {
pathname = parsed.pathname;
parsed.pathname = (0, _addBasePath).addBasePath(pathname);
if (!isMiddlewareMatch) {
url = (0, _formatUrl).formatWithValidation(parsed);
}
}
}
}
if (!isLocalURL(as)) {
if (false) {}
handleHardNavigation({
url: as,
router: _this
});
return false;
}
resolvedAs = (0, _removeLocale).removeLocale((0, _removeBasePath).removeBasePath(resolvedAs), nextState.locale);
let route = (0, _removeTrailingSlash).removeTrailingSlash(pathname);
let routeMatch = false;
if ((0, _isDynamic).isDynamicRoute(route)) {
const parsedAs1 = (0, _parseRelativeUrl).parseRelativeUrl(resolvedAs);
const asPathname = parsedAs1.pathname;
const routeRegex = (0, _routeRegex).getRouteRegex(route);
routeMatch = (0, _routeMatcher).getRouteMatcher(routeRegex)(asPathname);
const shouldInterpolate = route === asPathname;
const interpolatedAs = shouldInterpolate ? interpolateAs(route, asPathname, query) : {};
if (!routeMatch || shouldInterpolate && !interpolatedAs.result) {
const missingParams = Object.keys(routeRegex.groups).filter((param)=>!query[param]);
if (missingParams.length > 0 && !isMiddlewareMatch) {
if (false) {}
throw new Error((shouldInterpolate ? `The provided \`href\` (${url}) value is missing query values (${missingParams.join(", ")}) to be interpolated properly. ` : `The provided \`as\` value (${asPathname}) is incompatible with the \`href\` value (${route}). `) + `Read more: https://nextjs.org/docs/messages/${shouldInterpolate ? "href-interpolation-failed" : "incompatible-href-as"}`);
}
} else if (shouldInterpolate) {
as = (0, _formatUrl).formatWithValidation(Object.assign({}, parsedAs1, {
pathname: interpolatedAs.result,
query: omit(query, interpolatedAs.params)
}));
} else {
// Merge params into `query`, overwriting any specified in search
Object.assign(query, routeMatch);
}
}
if (!isQueryUpdating) {
Router.events.emit("routeChangeStart", as, routeProps);
}
try {
var ref2, ref3;
let routeInfo = yield _this.getRouteInfo({
route,
pathname,
query,
as,
resolvedAs,
routeProps,
locale: nextState.locale,
isPreview: nextState.isPreview,
hasMiddleware: isMiddlewareMatch
});
if ("route" in routeInfo && isMiddlewareMatch) {
pathname = routeInfo.route || route;
route = pathname;
if (!routeProps.shallow) {
query = Object.assign({}, routeInfo.query || {}, query);
}
const cleanedParsedPathname = (0, _hasBasePath).hasBasePath(parsed.pathname) ? (0, _removeBasePath).removeBasePath(parsed.pathname) : parsed.pathname;
if (routeMatch && pathname !== cleanedParsedPathname) {
Object.keys(routeMatch).forEach((key)=>{
if (routeMatch && query[key] === routeMatch[key]) {
delete query[key];
}
});
}
if ((0, _isDynamic).isDynamicRoute(pathname)) {
const prefixedAs = !routeProps.shallow && routeInfo.resolvedAs ? routeInfo.resolvedAs : (0, _addBasePath).addBasePath((0, _addLocale).addLocale(new URL(as, location.href).pathname, nextState.locale), true);
let rewriteAs = prefixedAs;
if ((0, _hasBasePath).hasBasePath(rewriteAs)) {
rewriteAs = (0, _removeBasePath).removeBasePath(rewriteAs);
}
if (false) {}
const routeRegex1 = (0, _routeRegex).getRouteRegex(pathname);
const curRouteMatch = (0, _routeMatcher).getRouteMatcher(routeRegex1)(rewriteAs);
if (curRouteMatch) {
Object.assign(query, curRouteMatch);
}
}
}
// If the routeInfo brings a redirect we simply apply it.
if ("type" in routeInfo) {
if (routeInfo.type === "redirect-internal") {
return _this.change(method, routeInfo.newUrl, routeInfo.newAs, options);
} else {
handleHardNavigation({
url: routeInfo.destination,
router: _this
});
return new Promise(()=>{});
}
}
let { error , props , __N_SSG , __N_SSP } = routeInfo;
const component = routeInfo.Component;
if (component && component.unstable_scriptLoader) {
const scripts = [].concat(component.unstable_scriptLoader());
scripts.forEach((script)=>{
(0, _script).handleClientScriptLoad(script.props);
});
}
// handle redirect on client-transition
if ((__N_SSG || __N_SSP) && props) {
if (props.pageProps && props.pageProps.__N_REDIRECT) {
// Use the destination from redirect without adding locale
options.locale = false;
const destination = props.pageProps.__N_REDIRECT;
// check if destination is internal (resolves to a page) and attempt
// client-navigation if it is falling back to hard navigation if
// it's not
if (destination.startsWith("/") && props.pageProps.__N_REDIRECT_BASE_PATH !== false) {
const parsedHref = (0, _parseRelativeUrl).parseRelativeUrl(destination);
parsedHref.pathname = resolveDynamicRoute(parsedHref.pathname, pages);
const { url: newUrl , as: newAs } = prepareUrlAs(_this, destination, destination);
return _this.change(method, newUrl, newAs, options);
}
handleHardNavigation({
url: destination,
router: _this
});
return new Promise(()=>{});
}
nextState.isPreview = !!props.__N_PREVIEW;
// handle SSG data 404
if (props.notFound === SSG_DATA_NOT_FOUND) {
let notFoundRoute;
try {
yield _this.fetchComponent("/404");
notFoundRoute = "/404";
} catch (_) {
notFoundRoute = "/_error";
}
routeInfo = yield _this.getRouteInfo({
route: notFoundRoute,
pathname: notFoundRoute,
query,
as,
resolvedAs,
routeProps: {
shallow: false
},
locale: nextState.locale,
isPreview: nextState.isPreview
});
if ("type" in routeInfo) {
throw new Error(`Unexpected middleware effect on /404`);
}
}
}
Router.events.emit("beforeHistoryChange", as, routeProps);
_this.changeState(method, url, as, options);
if (isQueryUpdating && pathname === "/_error" && ((ref2 = self.__NEXT_DATA__.props) == null ? void 0 : (ref3 = ref2.pageProps) == null ? void 0 : ref3.statusCode) === 500 && (props == null ? void 0 : props.pageProps)) {
// ensure statusCode is still correct for static 500 page
// when updating query information
props.pageProps.statusCode = 500;
}
var _route;
// shallow routing is only allowed for same page URL changes.
const isValidShallowRoute = options.shallow && nextState.route === ((_route = routeInfo.route) != null ? _route : route);
var _scroll;
const shouldScroll = (_scroll = options.scroll) != null ? _scroll : !options._h && !isValidShallowRoute;
const resetScroll = shouldScroll ? {
x: 0,
y: 0
} : null;
// the new state that the router gonna set
const upcomingRouterState = _extends({}, nextState, {
route,
pathname,
query,
asPath: cleanedAs,
isFallback: false
});
const upcomingScrollState = forcedScroll != null ? forcedScroll : resetScroll;
// for query updates we can skip it if the state is unchanged and we don't
// need to scroll
// https://github.com/vercel/next.js/issues/37139
const canSkipUpdating = options._h && !upcomingScrollState && !readyStateChange && !localeChange && (0, _compareStates).compareRouterStates(upcomingRouterState, _this.state);
if (!canSkipUpdating) {
yield _this.set(upcomingRouterState, routeInfo, upcomingScrollState).catch((e)=>{
if (e.cancelled) error = error || e;
else throw e;
});
if (error) {
if (!isQueryUpdating) {
Router.events.emit("routeChangeError", error, cleanedAs, routeProps);
}
throw error;
}
if (false) {}
if (!isQueryUpdating) {
Router.events.emit("routeChangeComplete", as, routeProps);
}
// A hash mark # is the optional last part of a URL
const hashRegex = /#.+$/;
if (shouldScroll && hashRegex.test(as)) {
_this.scrollToHash(as);
}
}
return true;
} catch (err11) {
if ((0, _isError).default(err11) && err11.cancelled) {
return false;
}
throw err11;
}
})();
}
changeState(method, url, as, options = {}) {
if (false) {}
if (method !== "pushState" || (0, _utils).getURL() !== as) {
this._shallow = options.shallow;
window.history[method]({
url,
as,
options,
__N: true,
key: this._key = method !== "pushState" ? this._key : createKey()
}, // Passing the empty string here should be safe against future changes to the method.
// https://developer.mozilla.org/en-US/docs/Web/API/History/replaceState
"", as);
}
}
handleRouteInfoError(err, pathname, query, as, routeProps, loadErrorFail) {
var _this = this;
return _async_to_generator(function*() {
console.error(err);
if (err.cancelled) {
// bubble up cancellation errors
throw err;
}
if ((0, _routeLoader).isAssetError(err) || loadErrorFail) {
Router.events.emit("routeChangeError", err, as, routeProps);
// If we can't load the page it could be one of following reasons
// 1. Page doesn't exists
// 2. Page does exist in a different zone
// 3. Internal error while loading the page
// So, doing a hard reload is the proper way to deal with this.
handleHardNavigation({
url: as,
router: _this
});
// Changing the URL doesn't block executing the current code path.
// So let's throw a cancellation error stop the routing logic.
throw buildCancellationError();
}
try {
let props;
const { page: Component , styleSheets } = yield _this.fetchComponent("/_error");
const routeInfo = {
props,
Component,
styleSheets,
err,
error: err
};
if (!routeInfo.props) {
try {
routeInfo.props = yield _this.getInitialProps(Component, {
err,
pathname,
query
});
} catch (gipErr) {
console.error("Error in error page `getInitialProps`: ", gipErr);
routeInfo.props = {};
}
}
return routeInfo;
} catch (routeInfoErr) {
return _this.handleRouteInfoError((0, _isError).default(routeInfoErr) ? routeInfoErr : new Error(routeInfoErr + ""), pathname, query, as, routeProps, true);
}
})();
}
getRouteInfo({ route: requestedRoute , pathname , query , as , resolvedAs , routeProps , locale , hasMiddleware , isPreview , unstable_skipClientCache }) {
var _this = this;
return _async_to_generator(function*() {
/**
* This `route` binding can change if there's a rewrite
* so we keep a reference to the original requested route
* so we can store the cache for it and avoid re-requesting every time
* for shallow routing purposes.
*/ let route = requestedRoute;
try {
var ref, ref4, ref5;
const handleCancelled = getCancelledHandler({
route,
router: _this
});
let existingInfo = _this.components[route];
if (routeProps.shallow && existingInfo && _this.route === route) {
return existingInfo;
}
if (hasMiddleware) {
existingInfo = undefined;
}
let cachedRouteInfo = existingInfo && !("initial" in existingInfo) && "production" !== "development" ? existingInfo : undefined;
const fetchNextDataParams = {
dataHref: _this.pageLoader.getDataHref({
href: (0, _formatUrl).formatWithValidation({
pathname,
query
}),
skipInterpolation: true,
asPath: resolvedAs,
locale
}),
hasMiddleware: true,
isServerRender: _this.isSsr,
parseJSON: true,
inflightCache: _this.sdc,
persistCache: !isPreview,
isPrefetch: false,
unstable_skipClientCache
};
const data = yield withMiddlewareEffects({
fetchData: ()=>fetchNextData(fetchNextDataParams),
asPath: resolvedAs,
locale: locale,
router: _this
});
handleCancelled();
if ((data == null ? void 0 : (ref = data.effect) == null ? void 0 : ref.type) === "redirect-internal" || (data == null ? void 0 : (ref4 = data.effect) == null ? void 0 : ref4.type) === "redirect-external") {
return data.effect;
}
if ((data == null ? void 0 : (ref5 = data.effect) == null ? void 0 : ref5.type) === "rewrite") {
route = (0, _removeTrailingSlash).removeTrailingSlash(data.effect.resolvedHref);
pathname = data.effect.resolvedHref;
query = _extends({}, query, data.effect.parsedAs.query);
resolvedAs = (0, _removeBasePath).removeBasePath((0, _normalizeLocalePath).normalizeLocalePath(data.effect.parsedAs.pathname, _this.locales).pathname);
// Check again the cache with the new destination.
existingInfo = _this.components[route];
if (routeProps.shallow && existingInfo && _this.route === route && !hasMiddleware) {
// If we have a match with the current route due to rewrite,
// we can copy the existing information to the rewritten one.
// Then, we return the information along with the matched route.
return _extends({}, existingInfo, {
route
});
}
}
if (route === "/api" || route.startsWith("/api/")) {
handleHardNavigation({
url: as,
router: _this
});
return new Promise(()=>{});
}
const routeInfo = cachedRouteInfo || (yield _this.fetchComponent(route).then((res)=>({
Component: res.page,
styleSheets: res.styleSheets,
__N_SSG: res.mod.__N_SSG,
__N_SSP: res.mod.__N_SSP
})));
if (false) {}
const shouldFetchData = routeInfo.__N_SSG || routeInfo.__N_SSP;
const { props , cacheKey } = yield _this._getData(_async_to_generator(function*() {
if (shouldFetchData) {
const { json , cacheKey: _cacheKey } = (data == null ? void 0 : data.json) ? data : yield fetchNextData({
dataHref: _this.pageLoader.getDataHref({
href: (0, _formatUrl).formatWithValidation({
pathname,
query
}),
asPath: resolvedAs,
locale
}),
isServerRender: _this.isSsr,
parseJSON: true,
inflightCache: _this.sdc,
persistCache: !isPreview,
isPrefetch: false,
unstable_skipClientCache
});
return {
cacheKey: _cacheKey,
props: json || {}
};
}
return {
headers: {},
cacheKey: "",
props: yield _this.getInitialProps(routeInfo.Component, {
pathname,
query,
asPath: as,
locale,
locales: _this.locales,
defaultLocale: _this.defaultLocale
})
};
}));
// Only bust the data cache for SSP routes although
// middleware can skip cache per request with
// x-middleware-cache: no-cache as well
if (routeInfo.__N_SSP && fetchNextDataParams.dataHref) {
delete _this.sdc[cacheKey];
}
// we kick off a HEAD request in the background
// when a non-prefetch request is made to signal revalidation
if (!_this.isPreview && routeInfo.__N_SSG && "production" !== "development") {
fetchNextData(Object.assign({}, fetchNextDataParams, {
isBackground: true,
persistCache: false,
inflightCache: backgroundCache
})).catch(()=>{});
}
props.pageProps = Object.assign({}, props.pageProps);
routeInfo.props = props;
routeInfo.route = route;
routeInfo.query = query;
routeInfo.resolvedAs = resolvedAs;
_this.components[route] = routeInfo;
return routeInfo;
} catch (err) {
return _this.handleRouteInfoError((0, _isError).getProperError(err), pathname, query, as, routeProps);
}
})();
}
set(state, data, resetScroll) {
this.state = state;
return this.sub(data, this.components["/_app"].Component, resetScroll);
}
/**
* Callback to execute before replacing router state
* @param cb callback to be executed
*/ beforePopState(cb) {
this._bps = cb;
}
onlyAHashChange(as) {
if (!this.asPath) return false;
const [oldUrlNoHash, oldHash] = this.asPath.split("#");
const [newUrlNoHash, newHash] = as.split("#");
// Makes sure we scroll to the provided hash if the url/hash are the same
if (newHash && oldUrlNoHash === newUrlNoHash && oldHash === newHash) {
return true;
}
// If the urls are change, there's more than a hash change
if (oldUrlNoHash !== newUrlNoHash) {
return false;
}
// If the hash has changed, then it's a hash only change.
// This check is necessary to handle both the enter and
// leave hash === '' cases. The identity case falls through
// and is treated as a next reload.
return oldHash !== newHash;
}
scrollToHash(as) {
const [, hash = ""] = as.split("#");
// Scroll to top if the hash is just `#` with no value or `#top`
// To mirror browsers
if (hash === "" || hash === "top") {
handleSmoothScroll(()=>window.scrollTo(0, 0));
return;
}
// Decode hash to make non-latin anchor works.
const rawHash = decodeURIComponent(hash);
// First we check if the element by id is found
const idEl = document.getElementById(rawHash);
if (idEl) {
handleSmoothScroll(()=>idEl.scrollIntoView());
return;
}
// If there's no element with the id, we check the `name` property
// To mirror browsers
const nameEl = document.getElementsByName(rawHash)[0];
if (nameEl) {
handleSmoothScroll(()=>nameEl.scrollIntoView());
}
}
urlIsNew(asPath) {
return this.asPath !== asPath;
}
/**
* Prefetch page code, you may wait for the data during page rendering.
* This feature only works in production!
* @param url the href of prefetched page
* @param asPath the as path of the prefetched page
*/ prefetch(url, asPath = url, options = {}) {
var _this = this;
return _async_to_generator(function*() {
if (false) {}
let parsed = (0, _parseRelativeUrl).parseRelativeUrl(url);
let { pathname , query } = parsed;
if (false) {}
const pages = yield _this.pageLoader.getPageList();
let resolvedAs = asPath;
const locale = typeof options.locale !== "undefined" ? options.locale || undefined : _this.locale;
if (false) {}
parsed.pathname = resolveDynamicRoute(parsed.pathname, pages);
if ((0, _isDynamic).isDynamicRoute(parsed.pathname)) {
pathname = parsed.pathname;
parsed.pathname = pathname;
Object.assign(query, (0, _routeMatcher).getRouteMatcher((0, _routeRegex).getRouteRegex(parsed.pathname))((0, _parsePath).parsePath(asPath).pathname) || {});
url = (0, _formatUrl).formatWithValidation(parsed);
}
// Prefetch is not supported in development mode because it would trigger on-demand-entries
if (false) {}
const route = (0, _removeTrailingSlash).removeTrailingSlash(pathname);
yield Promise.all([
_this.pageLoader._isSsg(route).then((isSsg)=>{
return isSsg ? fetchNextData({
dataHref: _this.pageLoader.getDataHref({
href: url,
asPath: resolvedAs,
locale: locale
}),
isServerRender: false,
parseJSON: true,
inflightCache: _this.sdc,
persistCache: !_this.isPreview,
isPrefetch: true,
unstable_skipClientCache: options.unstable_skipClientCache || options.priority && !!true
}).then(()=>false) : false;
}),
_this.pageLoader[options.priority ? "loadPage" : "prefetch"](route),
]);
})();
}
fetchComponent(route) {
var _this = this;
return _async_to_generator(function*() {
const handleCancelled = getCancelledHandler({
route,
router: _this
});
try {
const componentResult = yield _this.pageLoader.loadPage(route);
handleCancelled();
return componentResult;
} catch (err) {
handleCancelled();
throw err;
}
})();
}
_getData(fn) {
let cancelled = false;
const cancel = ()=>{
cancelled = true;
};
this.clc = cancel;
return fn().then((data)=>{
if (cancel === this.clc) {
this.clc = null;
}
if (cancelled) {
const err = new Error("Loading initial props cancelled");
err.cancelled = true;
throw err;
}
return data;
});
}
_getFlightData(dataHref) {
// Do not cache RSC flight response since it's not a static resource
return fetchNextData({
dataHref,
isServerRender: true,
parseJSON: false,
inflightCache: this.sdc,
persistCache: false,
isPrefetch: false
}).then(({ text })=>({
data: text
}));
}
getInitialProps(Component, ctx) {
const { Component: App } = this.components["/_app"];
const AppTree = this._wrapApp(App);
ctx.AppTree = AppTree;
return (0, _utils).loadGetInitialProps(App, {
AppTree,
Component,
router: this,
ctx
});
}
get route() {
return this.state.route;
}
get pathname() {
return this.state.pathname;
}
get query() {
return this.state.query;
}
get asPath() {
return this.state.asPath;
}
get locale() {
return this.state.locale;
}
get isFallback() {
return this.state.isFallback;
}
get isPreview() {
return this.state.isPreview;
}
constructor(pathname1, query1, as1, { initialProps , pageLoader , App , wrapApp , Component , err , subscription , isFallback , locale , locales , defaultLocale , domainLocales , isPreview }){
// Server Data Cache
this.sdc = {};
this.isFirstPopStateEvent = true;
this._key = createKey();
this.onPopState = (e)=>{
const { isFirstPopStateEvent } = this;
this.isFirstPopStateEvent = false;
const state = e.state;
if (!state) {
// We get state as undefined for two reasons.
// 1. With older safari (< 8) and older chrome (< 34)
// 2. When the URL changed with #
//
// In the both cases, we don't need to proceed and change the route.
// (as it's already changed)
// But we can simply replace the state with the new changes.
// Actually, for (1) we don't need to nothing. But it's hard to detect that event.
// So, doing the following for (1) does no harm.
const { pathname , query } = this;
this.changeState("replaceState", (0, _formatUrl).formatWithValidation({
pathname: (0, _addBasePath).addBasePath(pathname),
query
}), (0, _utils).getURL());
return;
}
// __NA is used to identify if the history entry can be handled by the app-router.
if (state.__NA) {
window.location.reload();
return;
}
if (!state.__N) {
return;
}
// Safari fires popstateevent when reopening the browser.
if (isFirstPopStateEvent && this.locale === state.options.locale && state.as === this.asPath) {
return;
}
let forcedScroll;
const { url , as , options , key } = state;
if (true) {
if (manualScrollRestoration) {
if (this._key !== key) {
// Snapshot current scroll position:
try {
sessionStorage.setItem("__next_scroll_" + this._key, JSON.stringify({
x: self.pageXOffset,
y: self.pageYOffset
}));
} catch (e1) {}
// Restore old scroll position:
try {
const v = sessionStorage.getItem("__next_scroll_" + key);
forcedScroll = JSON.parse(v);
} catch (e11) {
forcedScroll = {
x: 0,
y: 0
};
}
}
}
}
this._key = key;
const { pathname: pathname1 } = (0, _parseRelativeUrl).parseRelativeUrl(url);
// Make sure we don't re-render on initial load,
// can be caused by navigating back from an external site
if (this.isSsr && as === (0, _addBasePath).addBasePath(this.asPath) && pathname1 === (0, _addBasePath).addBasePath(this.pathname)) {
return;
}
// If the downstream application returns falsy, return.
// They will then be responsible for handling the event.
if (this._bps && !this._bps(state)) {
return;
}
this.change("replaceState", url, as, Object.assign({}, options, {
shallow: options.shallow && this._shallow,
locale: options.locale || this.defaultLocale,
// @ts-ignore internal value not exposed on types
_h: 0
}), forcedScroll);
};
// represents the current component key
const route = (0, _removeTrailingSlash).removeTrailingSlash(pathname1);
// set up the component cache (by route keys)
this.components = {};
// We should not keep the cache, if there's an error
// Otherwise, this cause issues when when going back and
// come again to the errored page.
if (pathname1 !== "/_error") {
this.components[route] = {
Component,
initial: true,
props: initialProps,
err,
__N_SSG: initialProps && initialProps.__N_SSG,
__N_SSP: initialProps && initialProps.__N_SSP
};
}
this.components["/_app"] = {
Component: App,
styleSheets: []
};
// Backwards compat for Router.router.events
// TODO: Should be remove the following major version as it was never documented
this.events = Router.events;
this.pageLoader = pageLoader;
// if auto prerendered and dynamic route wait to update asPath
// until after mount to prevent hydration mismatch
const autoExportDynamic = (0, _isDynamic).isDynamicRoute(pathname1) && self.__NEXT_DATA__.autoExport;
this.basePath = false || "";
this.sub = subscription;
this.clc = null;
this._wrapApp = wrapApp;
// make sure to ignore extra popState in safari on navigating
// back from external site
this.isSsr = true;
this.isLocaleDomain = false;
this.isReady = !!(self.__NEXT_DATA__.gssp || self.__NEXT_DATA__.gip || self.__NEXT_DATA__.appGip && !self.__NEXT_DATA__.gsp || !autoExportDynamic && !self.location.search && !false);
if (false) {}
this.state = {
route,
pathname: pathname1,
query: query1,
asPath: autoExportDynamic ? pathname1 : as1,
isPreview: !!isPreview,
locale: false ? 0 : undefined,
isFallback
};
this._initialMatchesMiddlewarePromise = Promise.resolve(false);
if (false) {}
}
}
Router.events = (0, _mitt).default();
exports["default"] = Router; //# sourceMappingURL=router.js.map
/***/ }),
/***/ 5675:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
module.exports = __webpack_require__(8045)
/***/ }),
/***/ 1664:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
module.exports = __webpack_require__(8418)
/***/ })
};
;
Zerion Mini Shell 1.0