Initial commit

node_modules/next/dist/lib/metadata/resolve-metadata.js

@@ -0,0 +1,741 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    accumulateMetadata: null,
+    accumulateViewport: null,
+    resolveMetadata: null,
+    resolveViewport: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    accumulateMetadata: function() {
+        return accumulateMetadata;
+    },
+    accumulateViewport: function() {
+        return accumulateViewport;
+    },
+    resolveMetadata: function() {
+        return resolveMetadata;
+    },
+    resolveViewport: function() {
+        return resolveViewport;
+    }
+});
+require("server-only");
+const _react = require("react");
+const _defaultmetadata = require("./default-metadata");
+const _resolveopengraph = require("./resolvers/resolve-opengraph");
+const _resolvetitle = require("./resolvers/resolve-title");
+const _utils = require("./generate/utils");
+const _appdirmodule = require("../../server/lib/app-dir-module");
+const _interopdefault = require("../interop-default");
+const _resolvebasics = require("./resolvers/resolve-basics");
+const _resolveicons = require("./resolvers/resolve-icons");
+const _tracer = require("../../server/lib/trace/tracer");
+const _constants = require("../../server/lib/trace/constants");
+const _segment = require("../../shared/lib/segment");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
+const _params = require("../../server/request/params");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(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 = {
+        __proto__: null
+    };
+    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 isFavicon(icon) {
+    if (!icon) {
+        return false;
+    }
+    // turbopack appends a hash to all images
+    return (icon.url === '/favicon.ico' || icon.url.toString().startsWith('/favicon.ico?')) && icon.type === 'image/x-icon';
+}
+function mergeStaticMetadata(source, target, staticFilesMetadata, metadataContext, titleTemplates, leafSegmentStaticIcons) {
+    var _source_twitter, _source_openGraph;
+    if (!staticFilesMetadata) return;
+    const { icon, apple, openGraph, twitter, manifest } = staticFilesMetadata;
+    // Keep updating the static icons in the most leaf node
+    if (icon) {
+        leafSegmentStaticIcons.icon = icon;
+    }
+    if (apple) {
+        leafSegmentStaticIcons.apple = apple;
+    }
+    // file based metadata is specified and current level metadata twitter.images is not specified
+    if (twitter && !(source == null ? void 0 : (_source_twitter = source.twitter) == null ? void 0 : _source_twitter.hasOwnProperty('images'))) {
+        const resolvedTwitter = (0, _resolveopengraph.resolveTwitter)({
+            ...target.twitter,
+            images: twitter
+        }, target.metadataBase, {
+            ...metadataContext,
+            isStaticMetadataRouteFile: true
+        }, titleTemplates.twitter);
+        target.twitter = resolvedTwitter;
+    }
+    // file based metadata is specified and current level metadata openGraph.images is not specified
+    if (openGraph && !(source == null ? void 0 : (_source_openGraph = source.openGraph) == null ? void 0 : _source_openGraph.hasOwnProperty('images'))) {
+        const resolvedOpenGraph = (0, _resolveopengraph.resolveOpenGraph)({
+            ...target.openGraph,
+            images: openGraph
+        }, target.metadataBase, {
+            ...metadataContext,
+            isStaticMetadataRouteFile: true
+        }, titleTemplates.openGraph);
+        target.openGraph = resolvedOpenGraph;
+    }
+    if (manifest) {
+        target.manifest = manifest;
+    }
+    return target;
+}
+// Merge the source metadata into the resolved target metadata.
+function mergeMetadata({ source, target, staticFilesMetadata, titleTemplates, metadataContext, buildState, leafSegmentStaticIcons }) {
+    // If there's override metadata, prefer it otherwise fallback to the default metadata.
+    const metadataBase = typeof (source == null ? void 0 : source.metadataBase) !== 'undefined' ? source.metadataBase : target.metadataBase;
+    for(const key_ in source){
+        const key = key_;
+        switch(key){
+            case 'title':
+                {
+                    target.title = (0, _resolvetitle.resolveTitle)(source.title, titleTemplates.title);
+                    break;
+                }
+            case 'alternates':
+                {
+                    target.alternates = (0, _resolvebasics.resolveAlternates)(source.alternates, metadataBase, metadataContext);
+                    break;
+                }
+            case 'openGraph':
+                {
+                    target.openGraph = (0, _resolveopengraph.resolveOpenGraph)(source.openGraph, metadataBase, metadataContext, titleTemplates.openGraph);
+                    break;
+                }
+            case 'twitter':
+                {
+                    target.twitter = (0, _resolveopengraph.resolveTwitter)(source.twitter, metadataBase, metadataContext, titleTemplates.twitter);
+                    break;
+                }
+            case 'facebook':
+                target.facebook = (0, _resolvebasics.resolveFacebook)(source.facebook);
+                break;
+            case 'verification':
+                target.verification = (0, _resolvebasics.resolveVerification)(source.verification);
+                break;
+            case 'icons':
+                {
+                    target.icons = (0, _resolveicons.resolveIcons)(source.icons);
+                    break;
+                }
+            case 'appleWebApp':
+                target.appleWebApp = (0, _resolvebasics.resolveAppleWebApp)(source.appleWebApp);
+                break;
+            case 'appLinks':
+                target.appLinks = (0, _resolvebasics.resolveAppLinks)(source.appLinks);
+                break;
+            case 'robots':
+                {
+                    target.robots = (0, _resolvebasics.resolveRobots)(source.robots);
+                    break;
+                }
+            case 'archives':
+            case 'assets':
+            case 'bookmarks':
+            case 'keywords':
+                {
+                    target[key] = (0, _utils.resolveAsArrayOrUndefined)(source[key]);
+                    break;
+                }
+            case 'authors':
+                {
+                    target[key] = (0, _utils.resolveAsArrayOrUndefined)(source.authors);
+                    break;
+                }
+            case 'itunes':
+                {
+                    target[key] = (0, _resolvebasics.resolveItunes)(source.itunes, metadataBase, metadataContext);
+                    break;
+                }
+            case 'pagination':
+                {
+                    target.pagination = (0, _resolvebasics.resolvePagination)(source.pagination, metadataBase, metadataContext);
+                    break;
+                }
+            // directly assign fields that fallback to null
+            case 'applicationName':
+            case 'description':
+            case 'generator':
+            case 'creator':
+            case 'publisher':
+            case 'category':
+            case 'classification':
+            case 'referrer':
+            case 'formatDetection':
+            case 'manifest':
+            case 'pinterest':
+                // @ts-ignore TODO: support inferring
+                target[key] = source[key] || null;
+                break;
+            case 'other':
+                target.other = Object.assign({}, target.other, source.other);
+                break;
+            case 'metadataBase':
+                target.metadataBase = metadataBase;
+                break;
+            default:
+                {
+                    if ((key === 'viewport' || key === 'themeColor' || key === 'colorScheme') && source[key] != null) {
+                        buildState.warnings.add(`Unsupported metadata ${key} is configured in metadata export in ${metadataContext.pathname}. Please move it to viewport export instead.\nRead more: https://nextjs.org/docs/app/api-reference/functions/generate-viewport`);
+                    }
+                    break;
+                }
+        }
+    }
+    mergeStaticMetadata(source, target, staticFilesMetadata, metadataContext, titleTemplates, leafSegmentStaticIcons);
+}
+function mergeViewport({ target, source }) {
+    if (!source) return;
+    for(const key_ in source){
+        const key = key_;
+        switch(key){
+            case 'themeColor':
+                {
+                    target.themeColor = (0, _resolvebasics.resolveThemeColor)(source.themeColor);
+                    break;
+                }
+            case 'colorScheme':
+                target.colorScheme = source.colorScheme || null;
+                break;
+            default:
+                // always override the target with the source
+                // @ts-ignore viewport properties
+                target[key] = source[key];
+                break;
+        }
+    }
+}
+function getDefinedViewport(mod, props, tracingProps) {
+    if (typeof mod.generateViewport === 'function') {
+        const { route } = tracingProps;
+        return (parent)=>(0, _tracer.getTracer)().trace(_constants.ResolveMetadataSpan.generateViewport, {
+                spanName: `generateViewport ${route}`,
+                attributes: {
+                    'next.page': route
+                }
+            }, ()=>mod.generateViewport(props, parent));
+    }
+    return mod.viewport || null;
+}
+function getDefinedMetadata(mod, props, tracingProps) {
+    if (typeof mod.generateMetadata === 'function') {
+        const { route } = tracingProps;
+        return (parent)=>(0, _tracer.getTracer)().trace(_constants.ResolveMetadataSpan.generateMetadata, {
+                spanName: `generateMetadata ${route}`,
+                attributes: {
+                    'next.page': route
+                }
+            }, ()=>mod.generateMetadata(props, parent));
+    }
+    return mod.metadata || null;
+}
+async function collectStaticImagesFiles(metadata, props, type) {
+    var _this;
+    if (!(metadata == null ? void 0 : metadata[type])) return undefined;
+    const iconPromises = metadata[type].map(async (imageModule)=>(0, _interopdefault.interopDefault)(await imageModule(props)));
+    return (iconPromises == null ? void 0 : iconPromises.length) > 0 ? (_this = await Promise.all(iconPromises)) == null ? void 0 : _this.flat() : undefined;
+}
+async function resolveStaticMetadata(modules, props) {
+    const { metadata } = modules;
+    if (!metadata) return null;
+    const [icon, apple, openGraph, twitter] = await Promise.all([
+        collectStaticImagesFiles(metadata, props, 'icon'),
+        collectStaticImagesFiles(metadata, props, 'apple'),
+        collectStaticImagesFiles(metadata, props, 'openGraph'),
+        collectStaticImagesFiles(metadata, props, 'twitter')
+    ]);
+    const staticMetadata = {
+        icon,
+        apple,
+        openGraph,
+        twitter,
+        manifest: metadata.manifest
+    };
+    return staticMetadata;
+}
+// [layout.metadata, static files metadata] -> ... -> [page.metadata, static files metadata]
+async function collectMetadata({ tree, metadataItems, errorMetadataItem, props, route, errorConvention }) {
+    let mod;
+    let modType;
+    const hasErrorConventionComponent = Boolean(errorConvention && tree[2][errorConvention]);
+    if (errorConvention) {
+        mod = await (0, _appdirmodule.getComponentTypeModule)(tree, 'layout');
+        modType = errorConvention;
+    } else {
+        const { mod: layoutOrPageMod, modType: layoutOrPageModType } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+        mod = layoutOrPageMod;
+        modType = layoutOrPageModType;
+    }
+    if (modType) {
+        route += `/${modType}`;
+    }
+    const staticFilesMetadata = await resolveStaticMetadata(tree[2], props);
+    const metadataExport = mod ? getDefinedMetadata(mod, props, {
+        route
+    }) : null;
+    metadataItems.push([
+        metadataExport,
+        staticFilesMetadata
+    ]);
+    if (hasErrorConventionComponent && errorConvention) {
+        const errorMod = await (0, _appdirmodule.getComponentTypeModule)(tree, errorConvention);
+        const errorMetadataExport = errorMod ? getDefinedMetadata(errorMod, props, {
+            route
+        }) : null;
+        errorMetadataItem[0] = errorMetadataExport;
+        errorMetadataItem[1] = staticFilesMetadata;
+    }
+}
+// [layout.metadata, static files metadata] -> ... -> [page.metadata, static files metadata]
+async function collectViewport({ tree, viewportItems, errorViewportItemRef, props, route, errorConvention }) {
+    let mod;
+    let modType;
+    const hasErrorConventionComponent = Boolean(errorConvention && tree[2][errorConvention]);
+    if (errorConvention) {
+        mod = await (0, _appdirmodule.getComponentTypeModule)(tree, 'layout');
+        modType = errorConvention;
+    } else {
+        const { mod: layoutOrPageMod, modType: layoutOrPageModType } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+        mod = layoutOrPageMod;
+        modType = layoutOrPageModType;
+    }
+    if (modType) {
+        route += `/${modType}`;
+    }
+    const viewportExport = mod ? getDefinedViewport(mod, props, {
+        route
+    }) : null;
+    viewportItems.push(viewportExport);
+    if (hasErrorConventionComponent && errorConvention) {
+        const errorMod = await (0, _appdirmodule.getComponentTypeModule)(tree, errorConvention);
+        const errorViewportExport = errorMod ? getDefinedViewport(errorMod, props, {
+            route
+        }) : null;
+        errorViewportItemRef.current = errorViewportExport;
+    }
+}
+const resolveMetadataItems = (0, _react.cache)(async function(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore) {
+    const parentParams = {};
+    const metadataItems = [];
+    const errorMetadataItem = [
+        null,
+        null
+    ];
+    const treePrefix = undefined;
+    return resolveMetadataItemsImpl(metadataItems, tree, treePrefix, parentParams, searchParams, errorConvention, errorMetadataItem, getDynamicParamFromSegment, workStore);
+});
+async function resolveMetadataItemsImpl(metadataItems, tree, /** Provided tree can be nested subtree, this argument says what is the path of such subtree */ treePrefix, parentParams, searchParams, errorConvention, errorMetadataItem, getDynamicParamFromSegment, workStore) {
+    const [segment, parallelRoutes, { page }] = tree;
+    const currentTreePrefix = treePrefix && treePrefix.length ? [
+        ...treePrefix,
+        segment
+    ] : [
+        segment
+    ];
+    const isPage = typeof page !== 'undefined';
+    // Handle dynamic segment params.
+    const segmentParam = getDynamicParamFromSegment(segment);
+    /**
+   * Create object holding the parent params and current params
+   */ let currentParams = parentParams;
+    if (segmentParam && segmentParam.value !== null) {
+        currentParams = {
+            ...parentParams,
+            [segmentParam.param]: segmentParam.value
+        };
+    }
+    const params = (0, _params.createServerParamsForMetadata)(currentParams, workStore);
+    let layerProps;
+    if (isPage) {
+        layerProps = {
+            params,
+            searchParams
+        };
+    } else {
+        layerProps = {
+            params
+        };
+    }
+    await collectMetadata({
+        tree,
+        metadataItems,
+        errorMetadataItem,
+        errorConvention,
+        props: layerProps,
+        route: currentTreePrefix// __PAGE__ shouldn't be shown in a route
+        .filter((s)=>s !== _segment.PAGE_SEGMENT_KEY).join('/')
+    });
+    for(const key in parallelRoutes){
+        const childTree = parallelRoutes[key];
+        await resolveMetadataItemsImpl(metadataItems, childTree, currentTreePrefix, currentParams, searchParams, errorConvention, errorMetadataItem, getDynamicParamFromSegment, workStore);
+    }
+    if (Object.keys(parallelRoutes).length === 0 && errorConvention) {
+        // If there are no parallel routes, place error metadata as the last item.
+        // e.g. layout -> layout -> not-found
+        metadataItems.push(errorMetadataItem);
+    }
+    return metadataItems;
+}
+const resolveViewportItems = (0, _react.cache)(async function(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore) {
+    const parentParams = {};
+    const viewportItems = [];
+    const errorViewportItemRef = {
+        current: null
+    };
+    const treePrefix = undefined;
+    return resolveViewportItemsImpl(viewportItems, tree, treePrefix, parentParams, searchParams, errorConvention, errorViewportItemRef, getDynamicParamFromSegment, workStore);
+});
+async function resolveViewportItemsImpl(viewportItems, tree, /** Provided tree can be nested subtree, this argument says what is the path of such subtree */ treePrefix, parentParams, searchParams, errorConvention, errorViewportItemRef, getDynamicParamFromSegment, workStore) {
+    const [segment, parallelRoutes, { page }] = tree;
+    const currentTreePrefix = treePrefix && treePrefix.length ? [
+        ...treePrefix,
+        segment
+    ] : [
+        segment
+    ];
+    const isPage = typeof page !== 'undefined';
+    // Handle dynamic segment params.
+    const segmentParam = getDynamicParamFromSegment(segment);
+    /**
+   * Create object holding the parent params and current params
+   */ let currentParams = parentParams;
+    if (segmentParam && segmentParam.value !== null) {
+        currentParams = {
+            ...parentParams,
+            [segmentParam.param]: segmentParam.value
+        };
+    }
+    const params = (0, _params.createServerParamsForMetadata)(currentParams, workStore);
+    let layerProps;
+    if (isPage) {
+        layerProps = {
+            params,
+            searchParams
+        };
+    } else {
+        layerProps = {
+            params
+        };
+    }
+    await collectViewport({
+        tree,
+        viewportItems,
+        errorViewportItemRef,
+        errorConvention,
+        props: layerProps,
+        route: currentTreePrefix// __PAGE__ shouldn't be shown in a route
+        .filter((s)=>s !== _segment.PAGE_SEGMENT_KEY).join('/')
+    });
+    for(const key in parallelRoutes){
+        const childTree = parallelRoutes[key];
+        await resolveViewportItemsImpl(viewportItems, childTree, currentTreePrefix, currentParams, searchParams, errorConvention, errorViewportItemRef, getDynamicParamFromSegment, workStore);
+    }
+    if (Object.keys(parallelRoutes).length === 0 && errorConvention) {
+        // If there are no parallel routes, place error metadata as the last item.
+        // e.g. layout -> layout -> not-found
+        viewportItems.push(errorViewportItemRef.current);
+    }
+    return viewportItems;
+}
+const isTitleTruthy = (title)=>!!(title == null ? void 0 : title.absolute);
+const hasTitle = (metadata)=>isTitleTruthy(metadata == null ? void 0 : metadata.title);
+function inheritFromMetadata(target, metadata) {
+    if (target) {
+        if (!hasTitle(target) && hasTitle(metadata)) {
+            target.title = metadata.title;
+        }
+        if (!target.description && metadata.description) {
+            target.description = metadata.description;
+        }
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const commonOgKeys = [
+    'title',
+    'description',
+    'images'
+];
+function postProcessMetadata(metadata, favicon, titleTemplates, metadataContext) {
+    const { openGraph, twitter } = metadata;
+    if (openGraph) {
+        // If there's openGraph information but not configured in twitter,
+        // inherit them from openGraph metadata.
+        let autoFillProps = {};
+        const hasTwTitle = hasTitle(twitter);
+        const hasTwDescription = twitter == null ? void 0 : twitter.description;
+        const hasTwImages = Boolean((twitter == null ? void 0 : twitter.hasOwnProperty('images')) && twitter.images);
+        if (!hasTwTitle) {
+            if (isTitleTruthy(openGraph.title)) {
+                autoFillProps.title = openGraph.title;
+            } else if (metadata.title && isTitleTruthy(metadata.title)) {
+                autoFillProps.title = metadata.title;
+            }
+        }
+        if (!hasTwDescription) autoFillProps.description = openGraph.description || metadata.description || undefined;
+        if (!hasTwImages) autoFillProps.images = openGraph.images;
+        if (Object.keys(autoFillProps).length > 0) {
+            const partialTwitter = (0, _resolveopengraph.resolveTwitter)(autoFillProps, metadata.metadataBase, metadataContext, titleTemplates.twitter);
+            if (metadata.twitter) {
+                metadata.twitter = Object.assign({}, metadata.twitter, {
+                    ...!hasTwTitle && {
+                        title: partialTwitter == null ? void 0 : partialTwitter.title
+                    },
+                    ...!hasTwDescription && {
+                        description: partialTwitter == null ? void 0 : partialTwitter.description
+                    },
+                    ...!hasTwImages && {
+                        images: partialTwitter == null ? void 0 : partialTwitter.images
+                    }
+                });
+            } else {
+                metadata.twitter = partialTwitter;
+            }
+        }
+    }
+    // If there's no title and description configured in openGraph or twitter,
+    // use the title and description from metadata.
+    inheritFromMetadata(openGraph, metadata);
+    inheritFromMetadata(twitter, metadata);
+    if (favicon) {
+        if (!metadata.icons) {
+            metadata.icons = {
+                icon: [],
+                apple: []
+            };
+        }
+        metadata.icons.icon.unshift(favicon);
+    }
+    return metadata;
+}
+function prerenderMetadata(metadataItems) {
+    // If the index is a function then it is a resolver and the next slot
+    // is the corresponding result. If the index is not a function it is the result
+    // itself.
+    const resolversAndResults = [];
+    for(let i = 0; i < metadataItems.length; i++){
+        const metadataExport = metadataItems[i][0];
+        getResult(resolversAndResults, metadataExport);
+    }
+    return resolversAndResults;
+}
+function prerenderViewport(viewportItems) {
+    // If the index is a function then it is a resolver and the next slot
+    // is the corresponding result. If the index is not a function it is the result
+    // itself.
+    const resolversAndResults = [];
+    for(let i = 0; i < viewportItems.length; i++){
+        const viewportExport = viewportItems[i];
+        getResult(resolversAndResults, viewportExport);
+    }
+    return resolversAndResults;
+}
+function getResult(resolversAndResults, exportForResult) {
+    if (typeof exportForResult === 'function') {
+        const result = exportForResult(new Promise((resolve)=>resolversAndResults.push(resolve)));
+        resolversAndResults.push(result);
+        if (result instanceof Promise) {
+            // since we eager execute generateMetadata and
+            // they can reject at anytime we need to ensure
+            // we attach the catch handler right away to
+            // prevent unhandled rejections crashing the process
+            result.catch((err)=>{
+                return {
+                    __nextError: err
+                };
+            });
+        }
+    } else if (typeof exportForResult === 'object') {
+        resolversAndResults.push(exportForResult);
+    } else {
+        resolversAndResults.push(null);
+    }
+}
+function resolvePendingResult(parentResult, resolveParentResult) {
+    // In dev we clone and freeze to prevent relying on mutating resolvedMetadata directly.
+    // In prod we just pass resolvedMetadata through without any copying.
+    if (process.env.NODE_ENV === 'development') {
+        parentResult = require('../../shared/lib/deep-freeze').deepFreeze(require('./clone-metadata').cloneMetadata(parentResult));
+    }
+    resolveParentResult(parentResult);
+}
+async function accumulateMetadata(metadataItems, metadataContext) {
+    const resolvedMetadata = (0, _defaultmetadata.createDefaultMetadata)();
+    let titleTemplates = {
+        title: null,
+        twitter: null,
+        openGraph: null
+    };
+    const buildState = {
+        warnings: new Set()
+    };
+    let favicon;
+    // Collect the static icons in the most leaf node,
+    // since we don't collect all the static metadata icons in the parent segments.
+    const leafSegmentStaticIcons = {
+        icon: [],
+        apple: []
+    };
+    const resolversAndResults = prerenderMetadata(metadataItems);
+    let resultIndex = 0;
+    for(let i = 0; i < metadataItems.length; i++){
+        var _staticFilesMetadata_icon;
+        const staticFilesMetadata = metadataItems[i][1];
+        // Treat favicon as special case, it should be the first icon in the list
+        // i <= 1 represents root layout, and if current page is also at root
+        if (i <= 1 && isFavicon(staticFilesMetadata == null ? void 0 : (_staticFilesMetadata_icon = staticFilesMetadata.icon) == null ? void 0 : _staticFilesMetadata_icon[0])) {
+            var _staticFilesMetadata_icon1;
+            const iconMod = staticFilesMetadata == null ? void 0 : (_staticFilesMetadata_icon1 = staticFilesMetadata.icon) == null ? void 0 : _staticFilesMetadata_icon1.shift();
+            if (i === 0) favicon = iconMod;
+        }
+        let pendingMetadata = resolversAndResults[resultIndex++];
+        if (typeof pendingMetadata === 'function') {
+            // This metadata item had a `generateMetadata` and
+            // we need to provide the currently resolved metadata
+            // to it before we continue;
+            const resolveParentMetadata = pendingMetadata;
+            // we know that the next item is a result if this item
+            // was a resolver
+            pendingMetadata = resolversAndResults[resultIndex++];
+            resolvePendingResult(resolvedMetadata, resolveParentMetadata);
+        }
+        // Otherwise the item was either null or a static export
+        let metadata;
+        if (isPromiseLike(pendingMetadata)) {
+            metadata = await pendingMetadata;
+        } else {
+            metadata = pendingMetadata;
+        }
+        mergeMetadata({
+            target: resolvedMetadata,
+            source: metadata,
+            metadataContext,
+            staticFilesMetadata,
+            titleTemplates,
+            buildState,
+            leafSegmentStaticIcons
+        });
+        // If the layout is the same layer with page, skip the leaf layout and leaf page
+        // The leaf layout and page are the last two items
+        if (i < metadataItems.length - 2) {
+            var _resolvedMetadata_title, _resolvedMetadata_openGraph, _resolvedMetadata_twitter;
+            titleTemplates = {
+                title: ((_resolvedMetadata_title = resolvedMetadata.title) == null ? void 0 : _resolvedMetadata_title.template) || null,
+                openGraph: ((_resolvedMetadata_openGraph = resolvedMetadata.openGraph) == null ? void 0 : _resolvedMetadata_openGraph.title.template) || null,
+                twitter: ((_resolvedMetadata_twitter = resolvedMetadata.twitter) == null ? void 0 : _resolvedMetadata_twitter.title.template) || null
+            };
+        }
+    }
+    if (leafSegmentStaticIcons.icon.length > 0 || leafSegmentStaticIcons.apple.length > 0) {
+        if (!resolvedMetadata.icons) {
+            resolvedMetadata.icons = {
+                icon: [],
+                apple: []
+            };
+            if (leafSegmentStaticIcons.icon.length > 0) {
+                resolvedMetadata.icons.icon.unshift(...leafSegmentStaticIcons.icon);
+            }
+            if (leafSegmentStaticIcons.apple.length > 0) {
+                resolvedMetadata.icons.apple.unshift(...leafSegmentStaticIcons.apple);
+            }
+        }
+    }
+    // Only log warnings if there are any, and only once after the metadata resolving process is finished
+    if (buildState.warnings.size > 0) {
+        for (const warning of buildState.warnings){
+            _log.warn(warning);
+        }
+    }
+    return postProcessMetadata(resolvedMetadata, favicon, titleTemplates, metadataContext);
+}
+async function accumulateViewport(viewportItems) {
+    const resolvedViewport = (0, _defaultmetadata.createDefaultViewport)();
+    const resolversAndResults = prerenderViewport(viewportItems);
+    let i = 0;
+    while(i < resolversAndResults.length){
+        let pendingViewport = resolversAndResults[i++];
+        if (typeof pendingViewport === 'function') {
+            // this viewport item had a `generateViewport` and
+            // we need to provide the currently resolved viewport
+            // to it before we continue;
+            const resolveParentViewport = pendingViewport;
+            // we know that the next item is a result if this item
+            // was a resolver
+            pendingViewport = resolversAndResults[i++];
+            resolvePendingResult(resolvedViewport, resolveParentViewport);
+        }
+        // Otherwise the item was either null or a static export
+        let viewport;
+        if (isPromiseLike(pendingViewport)) {
+            viewport = await pendingViewport;
+        } else {
+            viewport = pendingViewport;
+        }
+        mergeViewport({
+            target: resolvedViewport,
+            source: viewport
+        });
+    }
+    return resolvedViewport;
+}
+async function resolveMetadata(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore, metadataContext) {
+    const metadataItems = await resolveMetadataItems(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore);
+    return accumulateMetadata(metadataItems, metadataContext);
+}
+async function resolveViewport(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore) {
+    const viewportItems = await resolveViewportItems(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore);
+    return accumulateViewport(viewportItems);
+}
+function isPromiseLike(value) {
+    return typeof value === 'object' && value !== null && typeof value.then === 'function';
+}
+
+//# sourceMappingURL=resolve-metadata.js.map