Initial boiler plate project

node_modules/next/dist/esm/lib/metadata/clone-metadata.js

@@ -0,0 +1,23 @@
+const TYPE_URL = "__METADATA_URL";
+function replacer(_key, val) {
+    // clone URL as string but recover it as URL
+    if (val instanceof URL) {
+        return {
+            _type: TYPE_URL,
+            value: val.href
+        };
+    }
+    return val;
+}
+function reviver(_key, val) {
+    if (typeof val === "object" && val !== null && val._type === TYPE_URL) {
+        return new URL(val.value);
+    }
+    return val;
+}
+export function cloneMetadata(metadata) {
+    const jsonString = JSON.stringify(metadata, replacer);
+    return JSON.parse(jsonString, reviver);
+}
+
+//# sourceMappingURL=clone-metadata.js.map

node_modules/next/dist/esm/lib/metadata/clone-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/clone-metadata.ts"],"names":["TYPE_URL","replacer","_key","val","URL","_type","value","href","reviver","cloneMetadata","metadata","jsonString","JSON","stringify","parse"],"mappings":"AAEA,MAAMA,WAAW;AAEjB,SAASC,SAASC,IAAY,EAAEC,GAAQ;IACtC,4CAA4C;IAC5C,IAAIA,eAAeC,KAAK;QACtB,OAAO;YAAEC,OAAOL;YAAUM,OAAOH,IAAII,IAAI;QAAC;IAC5C;IACA,OAAOJ;AACT;AAEA,SAASK,QAAQN,IAAY,EAAEC,GAAQ;IACrC,IAAI,OAAOA,QAAQ,YAAYA,QAAQ,QAAQA,IAAIE,KAAK,KAAKL,UAAU;QACrE,OAAO,IAAII,IAAID,IAAIG,KAAK;IAC1B;IACA,OAAOH;AACT;AAEA,OAAO,SAASM,cAAcC,QAA0B;IACtD,MAAMC,aAAaC,KAAKC,SAAS,CAACH,UAAUT;IAC5C,OAAOW,KAAKE,KAAK,CAACH,YAAYH;AAChC"}

node_modules/next/dist/esm/lib/metadata/constants.js

@@ -0,0 +1,18 @@
+export const ViewportMetaKeys = {
+    width: "width",
+    height: "height",
+    initialScale: "initial-scale",
+    minimumScale: "minimum-scale",
+    maximumScale: "maximum-scale",
+    viewportFit: "viewport-fit",
+    userScalable: "user-scalable",
+    interactiveWidget: "interactive-widget"
+};
+export const IconKeys = [
+    "icon",
+    "shortcut",
+    "apple",
+    "other"
+];
+
+//# sourceMappingURL=constants.js.map

node_modules/next/dist/esm/lib/metadata/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/constants.ts"],"names":["ViewportMetaKeys","width","height","initialScale","minimumScale","maximumScale","viewportFit","userScalable","interactiveWidget","IconKeys"],"mappings":"AAGA,OAAO,MAAMA,mBAA4D;IACvEC,OAAO;IACPC,QAAQ;IACRC,cAAc;IACdC,cAAc;IACdC,cAAc;IACdC,aAAa;IACbC,cAAc;IACdC,mBAAmB;AACrB,EAAU;AAEV,OAAO,MAAMC,WAA4B;IAAC;IAAQ;IAAY;IAAS;CAAQ,CAAA"}

node_modules/next/dist/esm/lib/metadata/default-metadata.js

@@ -0,0 +1,55 @@
+export function createDefaultViewport() {
+    return {
+        // name=viewport
+        width: "device-width",
+        initialScale: 1,
+        // visual metadata
+        themeColor: null,
+        colorScheme: null
+    };
+}
+export function createDefaultMetadata() {
+    return {
+        // Deprecated ones
+        viewport: null,
+        themeColor: null,
+        colorScheme: null,
+        metadataBase: null,
+        // Other values are all null
+        title: null,
+        description: null,
+        applicationName: null,
+        authors: null,
+        generator: null,
+        keywords: null,
+        referrer: null,
+        creator: null,
+        publisher: null,
+        robots: null,
+        manifest: null,
+        alternates: {
+            canonical: null,
+            languages: null,
+            media: null,
+            types: null
+        },
+        icons: null,
+        openGraph: null,
+        twitter: null,
+        verification: {},
+        appleWebApp: null,
+        formatDetection: null,
+        itunes: null,
+        facebook: null,
+        abstract: null,
+        appLinks: null,
+        archives: null,
+        assets: null,
+        bookmarks: null,
+        category: null,
+        classification: null,
+        other: {}
+    };
+}
+
+//# sourceMappingURL=default-metadata.js.map

node_modules/next/dist/esm/lib/metadata/default-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/default-metadata.tsx"],"names":["createDefaultViewport","width","initialScale","themeColor","colorScheme","createDefaultMetadata","viewport","metadataBase","title","description","applicationName","authors","generator","keywords","referrer","creator","publisher","robots","manifest","alternates","canonical","languages","media","types","icons","openGraph","twitter","verification","appleWebApp","formatDetection","itunes","facebook","abstract","appLinks","archives","assets","bookmarks","category","classification","other"],"mappings":"AAKA,OAAO,SAASA;IACd,OAAO;QACL,gBAAgB;QAChBC,OAAO;QACPC,cAAc;QACd,kBAAkB;QAClBC,YAAY;QACZC,aAAa;IACf;AACF;AAEA,OAAO,SAASC;IACd,OAAO;QACL,kBAAkB;QAClBC,UAAU;QACVH,YAAY;QACZC,aAAa;QAEbG,cAAc;QACd,4BAA4B;QAC5BC,OAAO;QACPC,aAAa;QACbC,iBAAiB;QACjBC,SAAS;QACTC,WAAW;QACXC,UAAU;QACVC,UAAU;QACVC,SAAS;QACTC,WAAW;QACXC,QAAQ;QACRC,UAAU;QACVC,YAAY;YACVC,WAAW;YACXC,WAAW;YACXC,OAAO;YACPC,OAAO;QACT;QACAC,OAAO;QACPC,WAAW;QACXC,SAAS;QACTC,cAAc,CAAC;QACfC,aAAa;QACbC,iBAAiB;QACjBC,QAAQ;QACRC,UAAU;QACVC,UAAU;QACVC,UAAU;QACVC,UAAU;QACVC,QAAQ;QACRC,WAAW;QACXC,UAAU;QACVC,gBAAgB;QAChBC,OAAO,CAAC;IACV;AACF"}

node_modules/next/dist/esm/lib/metadata/generate/alternate.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { MetaFilter } from "./meta";
+function AlternateLink({ descriptor, ...props }) {
+    if (!descriptor.url) return null;
+    return /*#__PURE__*/ _jsx("link", {
+        ...props,
+        ...descriptor.title && {
+            title: descriptor.title
+        },
+        href: descriptor.url.toString()
+    });
+}
+export function AlternatesMetadata({ alternates }) {
+    if (!alternates) return null;
+    const { canonical, languages, media, types } = alternates;
+    return MetaFilter([
+        canonical ? AlternateLink({
+            rel: "canonical",
+            descriptor: canonical
+        }) : null,
+        languages ? Object.entries(languages).flatMap(([locale, descriptors])=>descriptors == null ? void 0 : descriptors.map((descriptor)=>AlternateLink({
+                    rel: "alternate",
+                    hrefLang: locale,
+                    descriptor
+                }))) : null,
+        media ? Object.entries(media).flatMap(([mediaName, descriptors])=>descriptors == null ? void 0 : descriptors.map((descriptor)=>AlternateLink({
+                    rel: "alternate",
+                    media: mediaName,
+                    descriptor
+                }))) : null,
+        types ? Object.entries(types).flatMap(([type, descriptors])=>descriptors == null ? void 0 : descriptors.map((descriptor)=>AlternateLink({
+                    rel: "alternate",
+                    type,
+                    descriptor
+                }))) : null
+    ]);
+}
+
+//# sourceMappingURL=alternate.js.map

node_modules/next/dist/esm/lib/metadata/generate/alternate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/alternate.tsx"],"names":["React","MetaFilter","AlternateLink","descriptor","props","url","link","title","href","toString","AlternatesMetadata","alternates","canonical","languages","media","types","rel","Object","entries","flatMap","locale","descriptors","map","hrefLang","mediaName","type"],"mappings":";AAGA,OAAOA,WAAW,QAAO;AACzB,SAASC,UAAU,QAAQ,SAAQ;AAEnC,SAASC,cAAc,EACrBC,UAAU,EACV,GAAGC,OAGwC;IAC3C,IAAI,CAACD,WAAWE,GAAG,EAAE,OAAO;IAC5B,qBACE,KAACC;QACE,GAAGF,KAAK;QACR,GAAID,WAAWI,KAAK,IAAI;YAAEA,OAAOJ,WAAWI,KAAK;QAAC,CAAC;QACpDC,MAAML,WAAWE,GAAG,CAACI,QAAQ;;AAGnC;AAEA,OAAO,SAASC,mBAAmB,EACjCC,UAAU,EAGX;IACC,IAAI,CAACA,YAAY,OAAO;IAExB,MAAM,EAAEC,SAAS,EAAEC,SAAS,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGJ;IAE/C,OAAOV,WAAW;QAChBW,YACIV,cAAc;YAAEc,KAAK;YAAab,YAAYS;QAAU,KACxD;QACJC,YACII,OAAOC,OAAO,CAACL,WAAWM,OAAO,CAAC,CAAC,CAACC,QAAQC,YAAY,GACtDA,+BAAAA,YAAaC,GAAG,CAAC,CAACnB,aAChBD,cAAc;oBAAEc,KAAK;oBAAaO,UAAUH;oBAAQjB;gBAAW,OAGnE;QACJW,QACIG,OAAOC,OAAO,CAACJ,OAAOK,OAAO,CAAC,CAAC,CAACK,WAAWH,YAAY,GACrDA,+BAAAA,YAAaC,GAAG,CAAC,CAACnB,aAChBD,cAAc;oBAAEc,KAAK;oBAAaF,OAAOU;oBAAWrB;gBAAW,OAGnE;QACJY,QACIE,OAAOC,OAAO,CAACH,OAAOI,OAAO,CAAC,CAAC,CAACM,MAAMJ,YAAY,GAChDA,+BAAAA,YAAaC,GAAG,CAAC,CAACnB,aAChBD,cAAc;oBAAEc,KAAK;oBAAaS;oBAAMtB;gBAAW,OAGvD;KACL;AACH"}

node_modules/next/dist/esm/lib/metadata/generate/basic.js

@@ -0,0 +1,234 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { Meta, MetaFilter, MultiMeta } from "./meta";
+import { ViewportMetaKeys } from "../constants";
+// convert viewport object to string for viewport meta tag
+function resolveViewportLayout(viewport) {
+    let resolved = null;
+    if (viewport && typeof viewport === "object") {
+        resolved = "";
+        for(const viewportKey_ in ViewportMetaKeys){
+            const viewportKey = viewportKey_;
+            if (viewportKey in viewport) {
+                let value = viewport[viewportKey];
+                if (typeof value === "boolean") value = value ? "yes" : "no";
+                if (resolved) resolved += ", ";
+                resolved += `${ViewportMetaKeys[viewportKey]}=${value}`;
+            }
+        }
+    }
+    return resolved;
+}
+export function ViewportMeta({ viewport }) {
+    return MetaFilter([
+        Meta({
+            name: "viewport",
+            content: resolveViewportLayout(viewport)
+        }),
+        ...viewport.themeColor ? viewport.themeColor.map((themeColor)=>Meta({
+                name: "theme-color",
+                content: themeColor.color,
+                media: themeColor.media
+            })) : [],
+        Meta({
+            name: "color-scheme",
+            content: viewport.colorScheme
+        })
+    ]);
+}
+export function BasicMeta({ metadata }) {
+    var _metadata_keywords, _metadata_robots, _metadata_robots1;
+    return MetaFilter([
+        /*#__PURE__*/ _jsx("meta", {
+            charSet: "utf-8"
+        }),
+        metadata.title !== null && metadata.title.absolute ? /*#__PURE__*/ _jsx("title", {
+            children: metadata.title.absolute
+        }) : null,
+        Meta({
+            name: "description",
+            content: metadata.description
+        }),
+        Meta({
+            name: "application-name",
+            content: metadata.applicationName
+        }),
+        ...metadata.authors ? metadata.authors.map((author)=>[
+                author.url ? /*#__PURE__*/ _jsx("link", {
+                    rel: "author",
+                    href: author.url.toString()
+                }) : null,
+                Meta({
+                    name: "author",
+                    content: author.name
+                })
+            ]) : [],
+        metadata.manifest ? /*#__PURE__*/ _jsx("link", {
+            rel: "manifest",
+            href: metadata.manifest.toString(),
+            crossOrigin: "use-credentials"
+        }) : null,
+        Meta({
+            name: "generator",
+            content: metadata.generator
+        }),
+        Meta({
+            name: "keywords",
+            content: (_metadata_keywords = metadata.keywords) == null ? void 0 : _metadata_keywords.join(",")
+        }),
+        Meta({
+            name: "referrer",
+            content: metadata.referrer
+        }),
+        Meta({
+            name: "creator",
+            content: metadata.creator
+        }),
+        Meta({
+            name: "publisher",
+            content: metadata.publisher
+        }),
+        Meta({
+            name: "robots",
+            content: (_metadata_robots = metadata.robots) == null ? void 0 : _metadata_robots.basic
+        }),
+        Meta({
+            name: "googlebot",
+            content: (_metadata_robots1 = metadata.robots) == null ? void 0 : _metadata_robots1.googleBot
+        }),
+        Meta({
+            name: "abstract",
+            content: metadata.abstract
+        }),
+        ...metadata.archives ? metadata.archives.map((archive)=>/*#__PURE__*/ _jsx("link", {
+                rel: "archives",
+                href: archive
+            })) : [],
+        ...metadata.assets ? metadata.assets.map((asset)=>/*#__PURE__*/ _jsx("link", {
+                rel: "assets",
+                href: asset
+            })) : [],
+        ...metadata.bookmarks ? metadata.bookmarks.map((bookmark)=>/*#__PURE__*/ _jsx("link", {
+                rel: "bookmarks",
+                href: bookmark
+            })) : [],
+        Meta({
+            name: "category",
+            content: metadata.category
+        }),
+        Meta({
+            name: "classification",
+            content: metadata.classification
+        }),
+        ...metadata.other ? Object.entries(metadata.other).map(([name, content])=>{
+            if (Array.isArray(content)) {
+                return content.map((contentItem)=>Meta({
+                        name,
+                        content: contentItem
+                    }));
+            } else {
+                return Meta({
+                    name,
+                    content
+                });
+            }
+        }) : []
+    ]);
+}
+export function ItunesMeta({ itunes }) {
+    if (!itunes) return null;
+    const { appId, appArgument } = itunes;
+    let content = `app-id=${appId}`;
+    if (appArgument) {
+        content += `, app-argument=${appArgument}`;
+    }
+    return /*#__PURE__*/ _jsx("meta", {
+        name: "apple-itunes-app",
+        content: content
+    });
+}
+export function FacebookMeta({ facebook }) {
+    if (!facebook) return null;
+    const { appId, admins } = facebook;
+    return MetaFilter([
+        appId ? /*#__PURE__*/ _jsx("meta", {
+            property: "fb:app_id",
+            content: appId
+        }) : null,
+        ...admins ? admins.map((admin)=>/*#__PURE__*/ _jsx("meta", {
+                property: "fb:admins",
+                content: admin
+            })) : []
+    ]);
+}
+const formatDetectionKeys = [
+    "telephone",
+    "date",
+    "address",
+    "email",
+    "url"
+];
+export function FormatDetectionMeta({ formatDetection }) {
+    if (!formatDetection) return null;
+    let content = "";
+    for (const key of formatDetectionKeys){
+        if (key in formatDetection) {
+            if (content) content += ", ";
+            content += `${key}=no`;
+        }
+    }
+    return /*#__PURE__*/ _jsx("meta", {
+        name: "format-detection",
+        content: content
+    });
+}
+export function AppleWebAppMeta({ appleWebApp }) {
+    if (!appleWebApp) return null;
+    const { capable, title, startupImage, statusBarStyle } = appleWebApp;
+    return MetaFilter([
+        capable ? Meta({
+            name: "apple-mobile-web-app-capable",
+            content: "yes"
+        }) : null,
+        Meta({
+            name: "apple-mobile-web-app-title",
+            content: title
+        }),
+        startupImage ? startupImage.map((image)=>/*#__PURE__*/ _jsx("link", {
+                href: image.url,
+                media: image.media,
+                rel: "apple-touch-startup-image"
+            })) : null,
+        statusBarStyle ? Meta({
+            name: "apple-mobile-web-app-status-bar-style",
+            content: statusBarStyle
+        }) : null
+    ]);
+}
+export function VerificationMeta({ verification }) {
+    if (!verification) return null;
+    return MetaFilter([
+        MultiMeta({
+            namePrefix: "google-site-verification",
+            contents: verification.google
+        }),
+        MultiMeta({
+            namePrefix: "y_key",
+            contents: verification.yahoo
+        }),
+        MultiMeta({
+            namePrefix: "yandex-verification",
+            contents: verification.yandex
+        }),
+        MultiMeta({
+            namePrefix: "me",
+            contents: verification.me
+        }),
+        ...verification.other ? Object.entries(verification.other).map(([key, value])=>MultiMeta({
+                namePrefix: key,
+                contents: value
+            })) : []
+    ]);
+}
+
+//# sourceMappingURL=basic.js.map

node_modules/next/dist/esm/lib/metadata/generate/icons.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { MetaFilter } from "./meta";
+function IconDescriptorLink({ icon }) {
+    const { url, rel = "icon", ...props } = icon;
+    return /*#__PURE__*/ _jsx("link", {
+        rel: rel,
+        href: url.toString(),
+        ...props
+    });
+}
+function IconLink({ rel, icon }) {
+    if (typeof icon === "object" && !(icon instanceof URL)) {
+        if (!icon.rel && rel) icon.rel = rel;
+        return IconDescriptorLink({
+            icon
+        });
+    } else {
+        const href = icon.toString();
+        return /*#__PURE__*/ _jsx("link", {
+            rel: rel,
+            href: href
+        });
+    }
+}
+export function IconsMetadata({ icons }) {
+    if (!icons) return null;
+    const shortcutList = icons.shortcut;
+    const iconList = icons.icon;
+    const appleList = icons.apple;
+    const otherList = icons.other;
+    return MetaFilter([
+        shortcutList ? shortcutList.map((icon)=>IconLink({
+                rel: "shortcut icon",
+                icon
+            })) : null,
+        iconList ? iconList.map((icon)=>IconLink({
+                rel: "icon",
+                icon
+            })) : null,
+        appleList ? appleList.map((icon)=>IconLink({
+                rel: "apple-touch-icon",
+                icon
+            })) : null,
+        otherList ? otherList.map((icon)=>IconDescriptorLink({
+                icon
+            })) : null
+    ]);
+}
+
+//# sourceMappingURL=icons.js.map

node_modules/next/dist/esm/lib/metadata/generate/icons.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/icons.tsx"],"names":["React","MetaFilter","IconDescriptorLink","icon","url","rel","props","link","href","toString","IconLink","URL","IconsMetadata","icons","shortcutList","shortcut","iconList","appleList","apple","otherList","other","map"],"mappings":";AAGA,OAAOA,WAAW,QAAO;AACzB,SAASC,UAAU,QAAQ,SAAQ;AAEnC,SAASC,mBAAmB,EAAEC,IAAI,EAA4B;IAC5D,MAAM,EAAEC,GAAG,EAAEC,MAAM,MAAM,EAAE,GAAGC,OAAO,GAAGH;IAExC,qBAAO,KAACI;QAAKF,KAAKA;QAAKG,MAAMJ,IAAIK,QAAQ;QAAK,GAAGH,KAAK;;AACxD;AAEA,SAASI,SAAS,EAAEL,GAAG,EAAEF,IAAI,EAAgC;IAC3D,IAAI,OAAOA,SAAS,YAAY,CAAEA,CAAAA,gBAAgBQ,GAAE,GAAI;QACtD,IAAI,CAACR,KAAKE,GAAG,IAAIA,KAAKF,KAAKE,GAAG,GAAGA;QACjC,OAAOH,mBAAmB;YAAEC;QAAK;IACnC,OAAO;QACL,MAAMK,OAAOL,KAAKM,QAAQ;QAC1B,qBAAO,KAACF;YAAKF,KAAKA;YAAKG,MAAMA;;IAC/B;AACF;AAEA,OAAO,SAASI,cAAc,EAAEC,KAAK,EAAwC;IAC3E,IAAI,CAACA,OAAO,OAAO;IAEnB,MAAMC,eAAeD,MAAME,QAAQ;IACnC,MAAMC,WAAWH,MAAMV,IAAI;IAC3B,MAAMc,YAAYJ,MAAMK,KAAK;IAC7B,MAAMC,YAAYN,MAAMO,KAAK;IAE7B,OAAOnB,WAAW;QAChBa,eACIA,aAAaO,GAAG,CAAC,CAAClB,OAASO,SAAS;gBAAEL,KAAK;gBAAiBF;YAAK,MACjE;QACJa,WAAWA,SAASK,GAAG,CAAC,CAAClB,OAASO,SAAS;gBAAEL,KAAK;gBAAQF;YAAK,MAAM;QACrEc,YACIA,UAAUI,GAAG,CAAC,CAAClB,OAASO,SAAS;gBAAEL,KAAK;gBAAoBF;YAAK,MACjE;QACJgB,YAAYA,UAAUE,GAAG,CAAC,CAAClB,OAASD,mBAAmB;gBAAEC;YAAK,MAAM;KACrE;AACH"}

node_modules/next/dist/esm/lib/metadata/generate/meta.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { nonNullable } from "../../non-nullable";
+export function Meta({ name, property, content, media }) {
+    if (typeof content !== "undefined" && content !== null && content !== "") {
+        return /*#__PURE__*/ _jsx("meta", {
+            ...name ? {
+                name
+            } : {
+                property
+            },
+            ...media ? {
+                media
+            } : undefined,
+            content: typeof content === "string" ? content : content.toString()
+        });
+    }
+    return null;
+}
+export function MetaFilter(items) {
+    const acc = [];
+    for (const item of items){
+        if (Array.isArray(item)) {
+            acc.push(...item.filter(nonNullable));
+        } else if (nonNullable(item)) {
+            acc.push(item);
+        }
+    }
+    return acc;
+}
+function camelToSnake(camelCaseStr) {
+    return camelCaseStr.replace(/([A-Z])/g, function(match) {
+        return "_" + match.toLowerCase();
+    });
+}
+const aliasPropPrefixes = new Set([
+    "og:image",
+    "twitter:image",
+    "og:video",
+    "og:audio"
+]);
+function getMetaKey(prefix, key) {
+    // Use `twitter:image` and `og:image` instead of `twitter:image:url` and `og:image:url`
+    // to be more compatible as it's a more common format.
+    // `og:video` & `og:audio` do not have a `:url` suffix alias
+    if (aliasPropPrefixes.has(prefix) && key === "url") {
+        return prefix;
+    }
+    if (prefix.startsWith("og:") || prefix.startsWith("twitter:")) {
+        key = camelToSnake(key);
+    }
+    return prefix + ":" + key;
+}
+function ExtendMeta({ content, namePrefix, propertyPrefix }) {
+    if (!content) return null;
+    return MetaFilter(Object.entries(content).map(([k, v])=>{
+        return typeof v === "undefined" ? null : Meta({
+            ...propertyPrefix && {
+                property: getMetaKey(propertyPrefix, k)
+            },
+            ...namePrefix && {
+                name: getMetaKey(namePrefix, k)
+            },
+            content: typeof v === "string" ? v : v == null ? void 0 : v.toString()
+        });
+    }));
+}
+export function MultiMeta({ propertyPrefix, namePrefix, contents }) {
+    if (typeof contents === "undefined" || contents === null) {
+        return null;
+    }
+    return MetaFilter(contents.map((content)=>{
+        if (typeof content === "string" || typeof content === "number" || content instanceof URL) {
+            return Meta({
+                ...propertyPrefix ? {
+                    property: propertyPrefix
+                } : {
+                    name: namePrefix
+                },
+                content
+            });
+        } else {
+            return ExtendMeta({
+                namePrefix,
+                propertyPrefix,
+                content
+            });
+        }
+    }));
+}
+
+//# sourceMappingURL=meta.js.map

node_modules/next/dist/esm/lib/metadata/generate/meta.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/meta.tsx"],"names":["React","nonNullable","Meta","name","property","content","media","meta","undefined","toString","MetaFilter","items","acc","item","Array","isArray","push","filter","camelToSnake","camelCaseStr","replace","match","toLowerCase","aliasPropPrefixes","Set","getMetaKey","prefix","key","has","startsWith","ExtendMeta","namePrefix","propertyPrefix","Object","entries","map","k","v","MultiMeta","contents","URL"],"mappings":";AAAA,OAAOA,WAAW,QAAO;AACzB,SAASC,WAAW,QAAQ,qBAAoB;AAEhD,OAAO,SAASC,KAAK,EACnBC,IAAI,EACJC,QAAQ,EACRC,OAAO,EACPC,KAAK,EAMN;IACC,IAAI,OAAOD,YAAY,eAAeA,YAAY,QAAQA,YAAY,IAAI;QACxE,qBACE,KAACE;YACE,GAAIJ,OAAO;gBAAEA;YAAK,IAAI;gBAAEC;YAAS,CAAC;YAClC,GAAIE,QAAQ;gBAAEA;YAAM,IAAIE,SAAS;YAClCH,SAAS,OAAOA,YAAY,WAAWA,UAAUA,QAAQI,QAAQ;;IAGvE;IACA,OAAO;AACT;AAEA,OAAO,SAASC,WACdC,KAAmB;IAEnB,MAAMC,MAAwB,EAAE;IAChC,KAAK,MAAMC,QAAQF,MAAO;QACxB,IAAIG,MAAMC,OAAO,CAACF,OAAO;YACvBD,IAAII,IAAI,IAAIH,KAAKI,MAAM,CAAChB;QAC1B,OAAO,IAAIA,YAAYY,OAAO;YAC5BD,IAAII,IAAI,CAACH;QACX;IACF;IACA,OAAOD;AACT;AAWA,SAASM,aAAaC,YAAoB;IACxC,OAAOA,aAAaC,OAAO,CAAC,YAAY,SAAUC,KAAK;QACrD,OAAO,MAAMA,MAAMC,WAAW;IAChC;AACF;AAEA,MAAMC,oBAAoB,IAAIC,IAAI;IAChC;IACA;IACA;IACA;CACD;AACD,SAASC,WAAWC,MAAc,EAAEC,GAAW;IAC7C,uFAAuF;IACvF,sDAAsD;IACtD,4DAA4D;IAC5D,IAAIJ,kBAAkBK,GAAG,CAACF,WAAWC,QAAQ,OAAO;QAClD,OAAOD;IACT;IACA,IAAIA,OAAOG,UAAU,CAAC,UAAUH,OAAOG,UAAU,CAAC,aAAa;QAC7DF,MAAMT,aAAaS;IACrB;IACA,OAAOD,SAAS,MAAMC;AACxB;AAEA,SAASG,WAAW,EAClBzB,OAAO,EACP0B,UAAU,EACVC,cAAc,EAKf;IACC,IAAI,CAAC3B,SAAS,OAAO;IACrB,OAAOK,WACLuB,OAAOC,OAAO,CAAC7B,SAAS8B,GAAG,CAAC,CAAC,CAACC,GAAGC,EAAE;QACjC,OAAO,OAAOA,MAAM,cAChB,OACAnC,KAAK;YACH,GAAI8B,kBAAkB;gBAAE5B,UAAUqB,WAAWO,gBAAgBI;YAAG,CAAC;YACjE,GAAIL,cAAc;gBAAE5B,MAAMsB,WAAWM,YAAYK;YAAG,CAAC;YACrD/B,SAAS,OAAOgC,MAAM,WAAWA,IAAIA,qBAAAA,EAAG5B,QAAQ;QAClD;IACN;AAEJ;AAEA,OAAO,SAAS6B,UAAU,EACxBN,cAAc,EACdD,UAAU,EACVQ,QAAQ,EAKT;IACC,IAAI,OAAOA,aAAa,eAAeA,aAAa,MAAM;QACxD,OAAO;IACT;IAEA,OAAO7B,WACL6B,SAASJ,GAAG,CAAC,CAAC9B;QACZ,IACE,OAAOA,YAAY,YACnB,OAAOA,YAAY,YACnBA,mBAAmBmC,KACnB;YACA,OAAOtC,KAAK;gBACV,GAAI8B,iBACA;oBAAE5B,UAAU4B;gBAAe,IAC3B;oBAAE7B,MAAM4B;gBAAW,CAAC;gBACxB1B;YACF;QACF,OAAO;YACL,OAAOyB,WAAW;gBAChBC;gBACAC;gBACA3B;YACF;QACF;IACF;AAEJ"}

node_modules/next/dist/esm/lib/metadata/generate/opengraph.js

@@ -0,0 +1,448 @@
+import { Meta, MetaFilter, MultiMeta } from "./meta";
+export function OpenGraphMetadata({ openGraph }) {
+    var _openGraph_title, _openGraph_url, _openGraph_ttl;
+    if (!openGraph) {
+        return null;
+    }
+    let typedOpenGraph;
+    if ("type" in openGraph) {
+        const openGraphType = openGraph.type;
+        switch(openGraphType){
+            case "website":
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "website"
+                    })
+                ];
+                break;
+            case "article":
+                var _openGraph_publishedTime, _openGraph_modifiedTime, _openGraph_expirationTime;
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "article"
+                    }),
+                    Meta({
+                        property: "article:published_time",
+                        content: (_openGraph_publishedTime = openGraph.publishedTime) == null ? void 0 : _openGraph_publishedTime.toString()
+                    }),
+                    Meta({
+                        property: "article:modified_time",
+                        content: (_openGraph_modifiedTime = openGraph.modifiedTime) == null ? void 0 : _openGraph_modifiedTime.toString()
+                    }),
+                    Meta({
+                        property: "article:expiration_time",
+                        content: (_openGraph_expirationTime = openGraph.expirationTime) == null ? void 0 : _openGraph_expirationTime.toString()
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "article:author",
+                        contents: openGraph.authors
+                    }),
+                    Meta({
+                        property: "article:section",
+                        content: openGraph.section
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "article:tag",
+                        contents: openGraph.tags
+                    })
+                ];
+                break;
+            case "book":
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "book"
+                    }),
+                    Meta({
+                        property: "book:isbn",
+                        content: openGraph.isbn
+                    }),
+                    Meta({
+                        property: "book:release_date",
+                        content: openGraph.releaseDate
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "book:author",
+                        contents: openGraph.authors
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "book:tag",
+                        contents: openGraph.tags
+                    })
+                ];
+                break;
+            case "profile":
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "profile"
+                    }),
+                    Meta({
+                        property: "profile:first_name",
+                        content: openGraph.firstName
+                    }),
+                    Meta({
+                        property: "profile:last_name",
+                        content: openGraph.lastName
+                    }),
+                    Meta({
+                        property: "profile:username",
+                        content: openGraph.username
+                    }),
+                    Meta({
+                        property: "profile:gender",
+                        content: openGraph.gender
+                    })
+                ];
+                break;
+            case "music.song":
+                var _openGraph_duration;
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "music.song"
+                    }),
+                    Meta({
+                        property: "music:duration",
+                        content: (_openGraph_duration = openGraph.duration) == null ? void 0 : _openGraph_duration.toString()
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "music:album",
+                        contents: openGraph.albums
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "music:musician",
+                        contents: openGraph.musicians
+                    })
+                ];
+                break;
+            case "music.album":
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "music.album"
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "music:song",
+                        contents: openGraph.songs
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "music:musician",
+                        contents: openGraph.musicians
+                    }),
+                    Meta({
+                        property: "music:release_date",
+                        content: openGraph.releaseDate
+                    })
+                ];
+                break;
+            case "music.playlist":
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "music.playlist"
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "music:song",
+                        contents: openGraph.songs
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "music:creator",
+                        contents: openGraph.creators
+                    })
+                ];
+                break;
+            case "music.radio_station":
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "music.radio_station"
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "music:creator",
+                        contents: openGraph.creators
+                    })
+                ];
+                break;
+            case "video.movie":
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "video.movie"
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "video:actor",
+                        contents: openGraph.actors
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "video:director",
+                        contents: openGraph.directors
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "video:writer",
+                        contents: openGraph.writers
+                    }),
+                    Meta({
+                        property: "video:duration",
+                        content: openGraph.duration
+                    }),
+                    Meta({
+                        property: "video:release_date",
+                        content: openGraph.releaseDate
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "video:tag",
+                        contents: openGraph.tags
+                    })
+                ];
+                break;
+            case "video.episode":
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "video.episode"
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "video:actor",
+                        contents: openGraph.actors
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "video:director",
+                        contents: openGraph.directors
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "video:writer",
+                        contents: openGraph.writers
+                    }),
+                    Meta({
+                        property: "video:duration",
+                        content: openGraph.duration
+                    }),
+                    Meta({
+                        property: "video:release_date",
+                        content: openGraph.releaseDate
+                    }),
+                    MultiMeta({
+                        propertyPrefix: "video:tag",
+                        contents: openGraph.tags
+                    }),
+                    Meta({
+                        property: "video:series",
+                        content: openGraph.series
+                    })
+                ];
+                break;
+            case "video.tv_show":
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "video.tv_show"
+                    })
+                ];
+                break;
+            case "video.other":
+                typedOpenGraph = [
+                    Meta({
+                        property: "og:type",
+                        content: "video.other"
+                    })
+                ];
+                break;
+            default:
+                const _exhaustiveCheck = openGraphType;
+                throw new Error(`Invalid OpenGraph type: ${_exhaustiveCheck}`);
+        }
+    }
+    return MetaFilter([
+        Meta({
+            property: "og:determiner",
+            content: openGraph.determiner
+        }),
+        Meta({
+            property: "og:title",
+            content: (_openGraph_title = openGraph.title) == null ? void 0 : _openGraph_title.absolute
+        }),
+        Meta({
+            property: "og:description",
+            content: openGraph.description
+        }),
+        Meta({
+            property: "og:url",
+            content: (_openGraph_url = openGraph.url) == null ? void 0 : _openGraph_url.toString()
+        }),
+        Meta({
+            property: "og:site_name",
+            content: openGraph.siteName
+        }),
+        Meta({
+            property: "og:locale",
+            content: openGraph.locale
+        }),
+        Meta({
+            property: "og:country_name",
+            content: openGraph.countryName
+        }),
+        Meta({
+            property: "og:ttl",
+            content: (_openGraph_ttl = openGraph.ttl) == null ? void 0 : _openGraph_ttl.toString()
+        }),
+        MultiMeta({
+            propertyPrefix: "og:image",
+            contents: openGraph.images
+        }),
+        MultiMeta({
+            propertyPrefix: "og:video",
+            contents: openGraph.videos
+        }),
+        MultiMeta({
+            propertyPrefix: "og:audio",
+            contents: openGraph.audio
+        }),
+        MultiMeta({
+            propertyPrefix: "og:email",
+            contents: openGraph.emails
+        }),
+        MultiMeta({
+            propertyPrefix: "og:phone_number",
+            contents: openGraph.phoneNumbers
+        }),
+        MultiMeta({
+            propertyPrefix: "og:fax_number",
+            contents: openGraph.faxNumbers
+        }),
+        MultiMeta({
+            propertyPrefix: "og:locale:alternate",
+            contents: openGraph.alternateLocale
+        }),
+        ...typedOpenGraph ? typedOpenGraph : []
+    ]);
+}
+function TwitterAppItem({ app, type }) {
+    var _app_url_type, _app_url;
+    return [
+        Meta({
+            name: `twitter:app:name:${type}`,
+            content: app.name
+        }),
+        Meta({
+            name: `twitter:app:id:${type}`,
+            content: app.id[type]
+        }),
+        Meta({
+            name: `twitter:app:url:${type}`,
+            content: (_app_url = app.url) == null ? void 0 : (_app_url_type = _app_url[type]) == null ? void 0 : _app_url_type.toString()
+        })
+    ];
+}
+export function TwitterMetadata({ twitter }) {
+    var _twitter_title;
+    if (!twitter) return null;
+    const { card } = twitter;
+    return MetaFilter([
+        Meta({
+            name: "twitter:card",
+            content: card
+        }),
+        Meta({
+            name: "twitter:site",
+            content: twitter.site
+        }),
+        Meta({
+            name: "twitter:site:id",
+            content: twitter.siteId
+        }),
+        Meta({
+            name: "twitter:creator",
+            content: twitter.creator
+        }),
+        Meta({
+            name: "twitter:creator:id",
+            content: twitter.creatorId
+        }),
+        Meta({
+            name: "twitter:title",
+            content: (_twitter_title = twitter.title) == null ? void 0 : _twitter_title.absolute
+        }),
+        Meta({
+            name: "twitter:description",
+            content: twitter.description
+        }),
+        MultiMeta({
+            namePrefix: "twitter:image",
+            contents: twitter.images
+        }),
+        ...card === "player" ? twitter.players.flatMap((player)=>[
+                Meta({
+                    name: "twitter:player",
+                    content: player.playerUrl.toString()
+                }),
+                Meta({
+                    name: "twitter:player:stream",
+                    content: player.streamUrl.toString()
+                }),
+                Meta({
+                    name: "twitter:player:width",
+                    content: player.width
+                }),
+                Meta({
+                    name: "twitter:player:height",
+                    content: player.height
+                })
+            ]) : [],
+        ...card === "app" ? [
+            TwitterAppItem({
+                app: twitter.app,
+                type: "iphone"
+            }),
+            TwitterAppItem({
+                app: twitter.app,
+                type: "ipad"
+            }),
+            TwitterAppItem({
+                app: twitter.app,
+                type: "googleplay"
+            })
+        ] : []
+    ]);
+}
+export function AppLinksMeta({ appLinks }) {
+    if (!appLinks) return null;
+    return MetaFilter([
+        MultiMeta({
+            propertyPrefix: "al:ios",
+            contents: appLinks.ios
+        }),
+        MultiMeta({
+            propertyPrefix: "al:iphone",
+            contents: appLinks.iphone
+        }),
+        MultiMeta({
+            propertyPrefix: "al:ipad",
+            contents: appLinks.ipad
+        }),
+        MultiMeta({
+            propertyPrefix: "al:android",
+            contents: appLinks.android
+        }),
+        MultiMeta({
+            propertyPrefix: "al:windows_phone",
+            contents: appLinks.windows_phone
+        }),
+        MultiMeta({
+            propertyPrefix: "al:windows",
+            contents: appLinks.windows
+        }),
+        MultiMeta({
+            propertyPrefix: "al:windows_universal",
+            contents: appLinks.windows_universal
+        }),
+        MultiMeta({
+            propertyPrefix: "al:web",
+            contents: appLinks.web
+        })
+    ]);
+}
+
+//# sourceMappingURL=opengraph.js.map

node_modules/next/dist/esm/lib/metadata/generate/utils.js

@@ -0,0 +1,17 @@
+function resolveArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [
+        value
+    ];
+}
+function resolveAsArrayOrUndefined(value) {
+    if (typeof value === "undefined" || value === null) {
+        return undefined;
+    }
+    return resolveArray(value);
+}
+export { resolveAsArrayOrUndefined, resolveArray };
+
+//# sourceMappingURL=utils.js.map

node_modules/next/dist/esm/lib/metadata/generate/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/utils.ts"],"names":["resolveArray","value","Array","isArray","resolveAsArrayOrUndefined","undefined"],"mappings":"AAAA,SAASA,aAAgBC,KAAc;IACrC,IAAIC,MAAMC,OAAO,CAACF,QAAQ;QACxB,OAAOA;IACT;IACA,OAAO;QAACA;KAAM;AAChB;AAEA,SAASG,0BACPH,KAAiC;IAEjC,IAAI,OAAOA,UAAU,eAAeA,UAAU,MAAM;QAClD,OAAOI;IACT;IACA,OAAOL,aAAaC;AACtB;AAEA,SAASG,yBAAyB,EAAEJ,YAAY,GAAE"}

node_modules/next/dist/esm/lib/metadata/get-metadata-route.js

@@ -0,0 +1,72 @@
+import { isMetadataRoute, isStaticMetadataRoute } from "./is-metadata-route";
+import path from "../../shared/lib/isomorphic/path";
+import { interpolateDynamicPath } from "../../server/server-utils";
+import { getNamedRouteRegex } from "../../shared/lib/router/utils/route-regex";
+import { djb2Hash } from "../../shared/lib/hash";
+import { normalizeAppPath } from "../../shared/lib/router/utils/app-paths";
+import { normalizePathSep } from "../../shared/lib/page-path/normalize-path-sep";
+/*
+ * If there's special convention like (...) or @ in the page path,
+ * Give it a unique hash suffix to avoid conflicts
+ *
+ * e.g.
+ * /app/open-graph.tsx -> /open-graph/route
+ * /app/(post)/open-graph.tsx -> /open-graph/route-[0-9a-z]{6}
+ */ function getMetadataRouteSuffix(page) {
+    let suffix = "";
+    if (page.includes("(") && page.includes(")") || page.includes("@")) {
+        suffix = djb2Hash(page).toString(36).slice(0, 6);
+    }
+    return suffix;
+}
+/**
+ * Fill the dynamic segment in the metadata route
+ *
+ * Example:
+ * fillMetadataSegment('/a/[slug]', { params: { slug: 'b' } }, 'open-graph') -> '/a/b/open-graph'
+ *
+ */ export function fillMetadataSegment(segment, params, imageSegment) {
+    const pathname = normalizeAppPath(segment);
+    const routeRegex = getNamedRouteRegex(pathname, false);
+    const route = interpolateDynamicPath(pathname, params, routeRegex);
+    const suffix = getMetadataRouteSuffix(segment);
+    const routeSuffix = suffix ? `-${suffix}` : "";
+    const { name, ext } = path.parse(imageSegment);
+    return normalizePathSep(path.join(route, `${name}${routeSuffix}${ext}`));
+}
+/**
+ * Map metadata page key to the corresponding route
+ *
+ * static file page key:    /app/robots.txt -> /robots.xml -> /robots.txt/route
+ * dynamic route page key:  /app/robots.tsx -> /robots -> /robots.txt/route
+ *
+ * @param page
+ * @returns
+ */ export function normalizeMetadataRoute(page) {
+    if (!isMetadataRoute(page)) {
+        return page;
+    }
+    let route = page;
+    let suffix = "";
+    if (page === "/robots") {
+        route += ".txt";
+    } else if (page === "/manifest") {
+        route += ".webmanifest";
+    } else if (page.endsWith("/sitemap")) {
+        route += ".xml";
+    } else {
+        // Remove the file extension, e.g. /route-path/robots.txt -> /route-path
+        const pathnamePrefix = page.slice(0, -(path.basename(page).length + 1));
+        suffix = getMetadataRouteSuffix(pathnamePrefix);
+    }
+    // Support both /<metadata-route.ext> and custom routes /<metadata-route>/route.ts.
+    // If it's a metadata file route, we need to append /[id]/route to the page.
+    if (!route.endsWith("/route")) {
+        const { dir, name: baseName, ext } = path.parse(route);
+        const isStaticRoute = isStaticMetadataRoute(page);
+        route = path.posix.join(dir, `${baseName}${suffix ? `-${suffix}` : ""}${ext}`, isStaticRoute ? "" : "[[...__metadata_id__]]", "route");
+    }
+    return route;
+}
+
+//# sourceMappingURL=get-metadata-route.js.map

node_modules/next/dist/esm/lib/metadata/get-metadata-route.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/get-metadata-route.ts"],"names":["isMetadataRoute","isStaticMetadataRoute","path","interpolateDynamicPath","getNamedRouteRegex","djb2Hash","normalizeAppPath","normalizePathSep","getMetadataRouteSuffix","page","suffix","includes","toString","slice","fillMetadataSegment","segment","params","imageSegment","pathname","routeRegex","route","routeSuffix","name","ext","parse","join","normalizeMetadataRoute","endsWith","pathnamePrefix","basename","length","dir","baseName","isStaticRoute","posix"],"mappings":"AAAA,SAASA,eAAe,EAAEC,qBAAqB,QAAQ,sBAAqB;AAC5E,OAAOC,UAAU,mCAAkC;AACnD,SAASC,sBAAsB,QAAQ,4BAA2B;AAClE,SAASC,kBAAkB,QAAQ,4CAA2C;AAC9E,SAASC,QAAQ,QAAQ,wBAAuB;AAChD,SAASC,gBAAgB,QAAQ,0CAAyC;AAC1E,SAASC,gBAAgB,QAAQ,gDAA+C;AAEhF;;;;;;;CAOC,GACD,SAASC,uBAAuBC,IAAY;IAC1C,IAAIC,SAAS;IAEb,IAAI,AAACD,KAAKE,QAAQ,CAAC,QAAQF,KAAKE,QAAQ,CAAC,QAASF,KAAKE,QAAQ,CAAC,MAAM;QACpED,SAASL,SAASI,MAAMG,QAAQ,CAAC,IAAIC,KAAK,CAAC,GAAG;IAChD;IACA,OAAOH;AACT;AAEA;;;;;;CAMC,GACD,OAAO,SAASI,oBACdC,OAAe,EACfC,MAAW,EACXC,YAAoB;IAEpB,MAAMC,WAAWZ,iBAAiBS;IAClC,MAAMI,aAAaf,mBAAmBc,UAAU;IAChD,MAAME,QAAQjB,uBAAuBe,UAAUF,QAAQG;IACvD,MAAMT,SAASF,uBAAuBO;IACtC,MAAMM,cAAcX,SAAS,CAAC,CAAC,EAAEA,OAAO,CAAC,GAAG;IAE5C,MAAM,EAAEY,IAAI,EAAEC,GAAG,EAAE,GAAGrB,KAAKsB,KAAK,CAACP;IAEjC,OAAOV,iBAAiBL,KAAKuB,IAAI,CAACL,OAAO,CAAC,EAAEE,KAAK,EAAED,YAAY,EAAEE,IAAI,CAAC;AACxE;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASG,uBAAuBjB,IAAY;IACjD,IAAI,CAACT,gBAAgBS,OAAO;QAC1B,OAAOA;IACT;IACA,IAAIW,QAAQX;IACZ,IAAIC,SAAS;IACb,IAAID,SAAS,WAAW;QACtBW,SAAS;IACX,OAAO,IAAIX,SAAS,aAAa;QAC/BW,SAAS;IACX,OAAO,IAAIX,KAAKkB,QAAQ,CAAC,aAAa;QACpCP,SAAS;IACX,OAAO;QACL,wEAAwE;QACxE,MAAMQ,iBAAiBnB,KAAKI,KAAK,CAAC,GAAG,CAAEX,CAAAA,KAAK2B,QAAQ,CAACpB,MAAMqB,MAAM,GAAG,CAAA;QACpEpB,SAASF,uBAAuBoB;IAClC;IACA,mFAAmF;IACnF,4EAA4E;IAC5E,IAAI,CAACR,MAAMO,QAAQ,CAAC,WAAW;QAC7B,MAAM,EAAEI,GAAG,EAAET,MAAMU,QAAQ,EAAET,GAAG,EAAE,GAAGrB,KAAKsB,KAAK,CAACJ;QAChD,MAAMa,gBAAgBhC,sBAAsBQ;QAE5CW,QAAQlB,KAAKgC,KAAK,CAACT,IAAI,CACrBM,KACA,CAAC,EAAEC,SAAS,EAAEtB,SAAS,CAAC,CAAC,EAAEA,OAAO,CAAC,GAAG,GAAG,EAAEa,IAAI,CAAC,EAChDU,gBAAgB,KAAK,0BACrB;IAEJ;IAEA,OAAOb;AACT"}

node_modules/next/dist/esm/lib/metadata/is-metadata-route.js

@@ -0,0 +1,93 @@
+import { normalizePathSep } from "../../shared/lib/page-path/normalize-path-sep";
+export const STATIC_METADATA_IMAGES = {
+    icon: {
+        filename: "icon",
+        extensions: [
+            "ico",
+            "jpg",
+            "jpeg",
+            "png",
+            "svg"
+        ]
+    },
+    apple: {
+        filename: "apple-icon",
+        extensions: [
+            "jpg",
+            "jpeg",
+            "png"
+        ]
+    },
+    favicon: {
+        filename: "favicon",
+        extensions: [
+            "ico"
+        ]
+    },
+    openGraph: {
+        filename: "opengraph-image",
+        extensions: [
+            "jpg",
+            "jpeg",
+            "png",
+            "gif"
+        ]
+    },
+    twitter: {
+        filename: "twitter-image",
+        extensions: [
+            "jpg",
+            "jpeg",
+            "png",
+            "gif"
+        ]
+    }
+};
+// Match routes that are metadata routes, e.g. /sitemap.xml, /favicon.<ext>, /<icon>.<ext>, etc.
+// TODO-METADATA: support more metadata routes with more extensions
+const defaultExtensions = [
+    "js",
+    "jsx",
+    "ts",
+    "tsx"
+];
+const getExtensionRegexString = (extensions)=>`(?:${extensions.join("|")})`;
+// When you only pass the file extension as `[]`, it will only match the static convention files
+// e.g. /robots.txt, /sitemap.xml, /favicon.ico, /manifest.json
+// When you pass the file extension as `['js', 'jsx', 'ts', 'tsx']`, it will also match the dynamic convention files
+// e.g. /robots.js, /sitemap.tsx, /favicon.jsx, /manifest.ts
+// When `withExtension` is false, it will match the static convention files without the extension, by default it's true
+// e.g. /robots, /sitemap, /favicon, /manifest, use to match dynamic API routes like app/robots.ts
+export function isMetadataRouteFile(appDirRelativePath, pageExtensions, withExtension) {
+    const metadataRouteFilesRegex = [
+        new RegExp(`^[\\\\/]robots${withExtension ? `\\.${getExtensionRegexString(pageExtensions.concat("txt"))}$` : ""}`),
+        new RegExp(`^[\\\\/]manifest${withExtension ? `\\.${getExtensionRegexString(pageExtensions.concat("webmanifest", "json"))}$` : ""}`),
+        new RegExp(`^[\\\\/]favicon\\.ico$`),
+        new RegExp(`[\\\\/]sitemap${withExtension ? `\\.${getExtensionRegexString(pageExtensions.concat("xml"))}$` : ""}`),
+        new RegExp(`[\\\\/]${STATIC_METADATA_IMAGES.icon.filename}\\d?${withExtension ? `\\.${getExtensionRegexString(pageExtensions.concat(STATIC_METADATA_IMAGES.icon.extensions))}$` : ""}`),
+        new RegExp(`[\\\\/]${STATIC_METADATA_IMAGES.apple.filename}\\d?${withExtension ? `\\.${getExtensionRegexString(pageExtensions.concat(STATIC_METADATA_IMAGES.apple.extensions))}$` : ""}`),
+        new RegExp(`[\\\\/]${STATIC_METADATA_IMAGES.openGraph.filename}\\d?${withExtension ? `\\.${getExtensionRegexString(pageExtensions.concat(STATIC_METADATA_IMAGES.openGraph.extensions))}$` : ""}`),
+        new RegExp(`[\\\\/]${STATIC_METADATA_IMAGES.twitter.filename}\\d?${withExtension ? `\\.${getExtensionRegexString(pageExtensions.concat(STATIC_METADATA_IMAGES.twitter.extensions))}$` : ""}`)
+    ];
+    const normalizedAppDirRelativePath = normalizePathSep(appDirRelativePath);
+    return metadataRouteFilesRegex.some((r)=>r.test(normalizedAppDirRelativePath));
+}
+export function isStaticMetadataRouteFile(appDirRelativePath) {
+    return isMetadataRouteFile(appDirRelativePath, [], true);
+}
+export function isStaticMetadataRoute(page) {
+    return page === "/robots" || page === "/manifest" || isStaticMetadataRouteFile(page);
+}
+/*
+ * Remove the 'app' prefix or '/route' suffix, only check the route name since they're only allowed in root app directory
+ * e.g.
+ * /app/robots -> /robots
+ * app/robots -> /robots
+ * /robots -> /robots
+ */ export function isMetadataRoute(route) {
+    let page = route.replace(/^\/?app\//, "").replace(/\/route$/, "");
+    if (page[0] !== "/") page = "/" + page;
+    return !page.endsWith("/page") && isMetadataRouteFile(page, defaultExtensions, false);
+}
+
+//# sourceMappingURL=is-metadata-route.js.map

node_modules/next/dist/esm/lib/metadata/is-metadata-route.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/is-metadata-route.ts"],"names":["normalizePathSep","STATIC_METADATA_IMAGES","icon","filename","extensions","apple","favicon","openGraph","twitter","defaultExtensions","getExtensionRegexString","join","isMetadataRouteFile","appDirRelativePath","pageExtensions","withExtension","metadataRouteFilesRegex","RegExp","concat","normalizedAppDirRelativePath","some","r","test","isStaticMetadataRouteFile","isStaticMetadataRoute","page","isMetadataRoute","route","replace","endsWith"],"mappings":"AACA,SAASA,gBAAgB,QAAQ,gDAA+C;AAEhF,OAAO,MAAMC,yBAAyB;IACpCC,MAAM;QACJC,UAAU;QACVC,YAAY;YAAC;YAAO;YAAO;YAAQ;YAAO;SAAM;IAClD;IACAC,OAAO;QACLF,UAAU;QACVC,YAAY;YAAC;YAAO;YAAQ;SAAM;IACpC;IACAE,SAAS;QACPH,UAAU;QACVC,YAAY;YAAC;SAAM;IACrB;IACAG,WAAW;QACTJ,UAAU;QACVC,YAAY;YAAC;YAAO;YAAQ;YAAO;SAAM;IAC3C;IACAI,SAAS;QACPL,UAAU;QACVC,YAAY;YAAC;YAAO;YAAQ;YAAO;SAAM;IAC3C;AACF,EAAU;AAEV,gGAAgG;AAChG,mEAAmE;AACnE,MAAMK,oBAAoB;IAAC;IAAM;IAAO;IAAM;CAAM;AAEpD,MAAMC,0BAA0B,CAACN,aAC/B,CAAC,GAAG,EAAEA,WAAWO,IAAI,CAAC,KAAK,CAAC,CAAC;AAE/B,gGAAgG;AAChG,+DAA+D;AAC/D,oHAAoH;AACpH,4DAA4D;AAC5D,uHAAuH;AACvH,kGAAkG;AAClG,OAAO,SAASC,oBACdC,kBAA0B,EAC1BC,cAA8B,EAC9BC,aAAsB;IAEtB,MAAMC,0BAA0B;QAC9B,IAAIC,OACF,CAAC,cAAc,EACbF,gBACI,CAAC,GAAG,EAAEL,wBAAwBI,eAAeI,MAAM,CAAC,QAAQ,CAAC,CAAC,GAC9D,GACL,CAAC;QAEJ,IAAID,OACF,CAAC,gBAAgB,EACfF,gBACI,CAAC,GAAG,EAAEL,wBACJI,eAAeI,MAAM,CAAC,eAAe,SACrC,CAAC,CAAC,GACJ,GACL,CAAC;QAEJ,IAAID,OAAO,CAAC,sBAAsB,CAAC;QACnC,IAAIA,OACF,CAAC,cAAc,EACbF,gBACI,CAAC,GAAG,EAAEL,wBAAwBI,eAAeI,MAAM,CAAC,QAAQ,CAAC,CAAC,GAC9D,GACL,CAAC;QAEJ,IAAID,OACF,CAAC,OAAO,EAAEhB,uBAAuBC,IAAI,CAACC,QAAQ,CAAC,IAAI,EACjDY,gBACI,CAAC,GAAG,EAAEL,wBACJI,eAAeI,MAAM,CAACjB,uBAAuBC,IAAI,CAACE,UAAU,GAC5D,CAAC,CAAC,GACJ,GACL,CAAC;QAEJ,IAAIa,OACF,CAAC,OAAO,EAAEhB,uBAAuBI,KAAK,CAACF,QAAQ,CAAC,IAAI,EAClDY,gBACI,CAAC,GAAG,EAAEL,wBACJI,eAAeI,MAAM,CAACjB,uBAAuBI,KAAK,CAACD,UAAU,GAC7D,CAAC,CAAC,GACJ,GACL,CAAC;QAEJ,IAAIa,OACF,CAAC,OAAO,EAAEhB,uBAAuBM,SAAS,CAACJ,QAAQ,CAAC,IAAI,EACtDY,gBACI,CAAC,GAAG,EAAEL,wBACJI,eAAeI,MAAM,CAACjB,uBAAuBM,SAAS,CAACH,UAAU,GACjE,CAAC,CAAC,GACJ,GACL,CAAC;QAEJ,IAAIa,OACF,CAAC,OAAO,EAAEhB,uBAAuBO,OAAO,CAACL,QAAQ,CAAC,IAAI,EACpDY,gBACI,CAAC,GAAG,EAAEL,wBACJI,eAAeI,MAAM,CAACjB,uBAAuBO,OAAO,CAACJ,UAAU,GAC/D,CAAC,CAAC,GACJ,GACL,CAAC;KAEL;IAED,MAAMe,+BAA+BnB,iBAAiBa;IACtD,OAAOG,wBAAwBI,IAAI,CAAC,CAACC,IACnCA,EAAEC,IAAI,CAACH;AAEX;AAEA,OAAO,SAASI,0BAA0BV,kBAA0B;IAClE,OAAOD,oBAAoBC,oBAAoB,EAAE,EAAE;AACrD;AAEA,OAAO,SAASW,sBAAsBC,IAAY;IAChD,OACEA,SAAS,aACTA,SAAS,eACTF,0BAA0BE;AAE9B;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,gBAAgBC,KAAa;IAC3C,IAAIF,OAAOE,MAAMC,OAAO,CAAC,aAAa,IAAIA,OAAO,CAAC,YAAY;IAC9D,IAAIH,IAAI,CAAC,EAAE,KAAK,KAAKA,OAAO,MAAMA;IAElC,OACE,CAACA,KAAKI,QAAQ,CAAC,YACfjB,oBAAoBa,MAAMhB,mBAAmB;AAEjD"}

node_modules/next/dist/esm/lib/metadata/metadata.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import React from "react";
+import { AppleWebAppMeta, FormatDetectionMeta, ItunesMeta, BasicMeta, ViewportMeta, VerificationMeta, FacebookMeta } from "./generate/basic";
+import { AlternatesMetadata } from "./generate/alternate";
+import { OpenGraphMetadata, TwitterMetadata, AppLinksMeta } from "./generate/opengraph";
+import { IconsMetadata } from "./generate/icons";
+import { resolveMetadata } from "./resolve-metadata";
+import { MetaFilter } from "./generate/meta";
+import { createDefaultMetadata, createDefaultViewport } from "./default-metadata";
+import { isNotFoundError } from "../../client/components/not-found";
+export function createMetadataContext(urlPathname, renderOpts) {
+    return {
+        pathname: urlPathname.split("?")[0],
+        trailingSlash: renderOpts.trailingSlash,
+        isStandaloneMode: renderOpts.nextConfigOutput === "standalone"
+    };
+}
+// Use a promise to share the status of the metadata resolving,
+// returning two components `MetadataTree` and `MetadataOutlet`
+// `MetadataTree` is the one that will be rendered at first in the content sequence for metadata tags.
+// `MetadataOutlet` is the one that will be rendered under error boundaries for metadata resolving errors.
+// In this way we can let the metadata tags always render successfully,
+// and the error will be caught by the error boundary and trigger fallbacks.
+export function createMetadataComponents({ tree, query, metadataContext, getDynamicParamFromSegment, appUsingSizeAdjustment, errorType, createDynamicallyTrackedSearchParams }) {
+    let resolve;
+    // Only use promise.resolve here to avoid unhandled rejections
+    const metadataErrorResolving = new Promise((res)=>{
+        resolve = res;
+    });
+    async function MetadataTree() {
+        const defaultMetadata = createDefaultMetadata();
+        const defaultViewport = createDefaultViewport();
+        let metadata = defaultMetadata;
+        let viewport = defaultViewport;
+        let error;
+        const errorMetadataItem = [
+            null,
+            null,
+            null
+        ];
+        const errorConvention = errorType === "redirect" ? undefined : errorType;
+        const searchParams = createDynamicallyTrackedSearchParams(query);
+        const [resolvedError, resolvedMetadata, resolvedViewport] = await resolveMetadata({
+            tree,
+            parentParams: {},
+            metadataItems: [],
+            errorMetadataItem,
+            searchParams,
+            getDynamicParamFromSegment,
+            errorConvention,
+            metadataContext
+        });
+        if (!resolvedError) {
+            viewport = resolvedViewport;
+            metadata = resolvedMetadata;
+            resolve(undefined);
+        } else {
+            error = resolvedError;
+            // If the error triggers in initial metadata resolving, re-resolve with proper error type.
+            // They'll be saved for flight data, when hydrates, it will replaces the SSR'd metadata with this.
+            // for not-found error: resolve not-found metadata
+            if (!errorType && isNotFoundError(resolvedError)) {
+                const [notFoundMetadataError, notFoundMetadata, notFoundViewport] = await resolveMetadata({
+                    tree,
+                    parentParams: {},
+                    metadataItems: [],
+                    errorMetadataItem,
+                    searchParams,
+                    getDynamicParamFromSegment,
+                    errorConvention: "not-found",
+                    metadataContext
+                });
+                viewport = notFoundViewport;
+                metadata = notFoundMetadata;
+                error = notFoundMetadataError || error;
+            }
+            resolve(error);
+        }
+        const elements = MetaFilter([
+            ViewportMeta({
+                viewport: viewport
+            }),
+            BasicMeta({
+                metadata
+            }),
+            AlternatesMetadata({
+                alternates: metadata.alternates
+            }),
+            ItunesMeta({
+                itunes: metadata.itunes
+            }),
+            FacebookMeta({
+                facebook: metadata.facebook
+            }),
+            FormatDetectionMeta({
+                formatDetection: metadata.formatDetection
+            }),
+            VerificationMeta({
+                verification: metadata.verification
+            }),
+            AppleWebAppMeta({
+                appleWebApp: metadata.appleWebApp
+            }),
+            OpenGraphMetadata({
+                openGraph: metadata.openGraph
+            }),
+            TwitterMetadata({
+                twitter: metadata.twitter
+            }),
+            AppLinksMeta({
+                appLinks: metadata.appLinks
+            }),
+            IconsMetadata({
+                icons: metadata.icons
+            })
+        ]);
+        if (appUsingSizeAdjustment) elements.push(/*#__PURE__*/ _jsx("meta", {
+            name: "next-size-adjust"
+        }));
+        return /*#__PURE__*/ _jsx(_Fragment, {
+            children: elements.map((el, index)=>{
+                return /*#__PURE__*/ React.cloneElement(el, {
+                    key: index
+                });
+            })
+        });
+    }
+    async function MetadataOutlet() {
+        const error = await metadataErrorResolving;
+        if (error) {
+            throw error;
+        }
+        return null;
+    }
+    return [
+        MetadataTree,
+        MetadataOutlet
+    ];
+}
+
+//# sourceMappingURL=metadata.js.map

node_modules/next/dist/esm/lib/metadata/metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/metadata.tsx"],"names":["React","AppleWebAppMeta","FormatDetectionMeta","ItunesMeta","BasicMeta","ViewportMeta","VerificationMeta","FacebookMeta","AlternatesMetadata","OpenGraphMetadata","TwitterMetadata","AppLinksMeta","IconsMetadata","resolveMetadata","MetaFilter","createDefaultMetadata","createDefaultViewport","isNotFoundError","createMetadataContext","urlPathname","renderOpts","pathname","split","trailingSlash","isStandaloneMode","nextConfigOutput","createMetadataComponents","tree","query","metadataContext","getDynamicParamFromSegment","appUsingSizeAdjustment","errorType","createDynamicallyTrackedSearchParams","resolve","metadataErrorResolving","Promise","res","MetadataTree","defaultMetadata","defaultViewport","metadata","viewport","error","errorMetadataItem","errorConvention","undefined","searchParams","resolvedError","resolvedMetadata","resolvedViewport","parentParams","metadataItems","notFoundMetadataError","notFoundMetadata","notFoundViewport","elements","alternates","itunes","facebook","formatDetection","verification","appleWebApp","openGraph","twitter","appLinks","icons","push","meta","name","map","el","index","cloneElement","key","MetadataOutlet"],"mappings":"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"}

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

@@ -0,0 +1,564 @@
+import { createDefaultMetadata, createDefaultViewport } from "./default-metadata";
+import { resolveOpenGraph, resolveTwitter } from "./resolvers/resolve-opengraph";
+import { resolveTitle } from "./resolvers/resolve-title";
+import { resolveAsArrayOrUndefined } from "./generate/utils";
+import { isClientReference } from "../client-reference";
+import { getComponentTypeModule, getLayoutOrPageModule } from "../../server/lib/app-dir-module";
+import { interopDefault } from "../interop-default";
+import { resolveAlternates, resolveAppleWebApp, resolveAppLinks, resolveRobots, resolveThemeColor, resolveVerification, resolveItunes, resolveFacebook } from "./resolvers/resolve-basics";
+import { resolveIcons } from "./resolvers/resolve-icons";
+import { getTracer } from "../../server/lib/trace/tracer";
+import { ResolveMetadataSpan } from "../../server/lib/trace/constants";
+import { PAGE_SEGMENT_KEY } from "../../shared/lib/segment";
+import * as Log from "../../build/output/log";
+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 = resolveTwitter({
+            ...target.twitter,
+            images: twitter
+        }, target.metadataBase, metadataContext, 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 = resolveOpenGraph({
+            ...target.openGraph,
+            images: openGraph
+        }, target.metadataBase, metadataContext, 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 = resolveTitle(source.title, titleTemplates.title);
+                    break;
+                }
+            case "alternates":
+                {
+                    target.alternates = resolveAlternates(source.alternates, metadataBase, metadataContext);
+                    break;
+                }
+            case "openGraph":
+                {
+                    target.openGraph = resolveOpenGraph(source.openGraph, metadataBase, metadataContext, titleTemplates.openGraph);
+                    break;
+                }
+            case "twitter":
+                {
+                    target.twitter = resolveTwitter(source.twitter, metadataBase, metadataContext, titleTemplates.twitter);
+                    break;
+                }
+            case "facebook":
+                target.facebook = resolveFacebook(source.facebook);
+                break;
+            case "verification":
+                target.verification = resolveVerification(source.verification);
+                break;
+            case "icons":
+                {
+                    target.icons = resolveIcons(source.icons);
+                    break;
+                }
+            case "appleWebApp":
+                target.appleWebApp = resolveAppleWebApp(source.appleWebApp);
+                break;
+            case "appLinks":
+                target.appLinks = resolveAppLinks(source.appLinks);
+                break;
+            case "robots":
+                {
+                    target.robots = resolveRobots(source.robots);
+                    break;
+                }
+            case "archives":
+            case "assets":
+            case "bookmarks":
+            case "keywords":
+                {
+                    target[key] = resolveAsArrayOrUndefined(source[key]);
+                    break;
+                }
+            case "authors":
+                {
+                    target[key] = resolveAsArrayOrUndefined(source.authors);
+                    break;
+                }
+            case "itunes":
+                {
+                    target[key] = resolveItunes(source.itunes, 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":
+                // @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 = resolveThemeColor(source.themeColor);
+                    break;
+                }
+            case "colorScheme":
+                target.colorScheme = source.colorScheme || null;
+                break;
+            default:
+                if (typeof source[key] !== "undefined") {
+                    // @ts-ignore viewport properties
+                    target[key] = source[key];
+                }
+                break;
+        }
+    }
+}
+async function getDefinedViewport(mod, props, tracingProps) {
+    if (isClientReference(mod)) {
+        return null;
+    }
+    if (typeof mod.generateViewport === "function") {
+        const { route } = tracingProps;
+        return (parent)=>getTracer().trace(ResolveMetadataSpan.generateViewport, {
+                spanName: `generateViewport ${route}`,
+                attributes: {
+                    "next.page": route
+                }
+            }, ()=>mod.generateViewport(props, parent));
+    }
+    return mod.viewport || null;
+}
+async function getDefinedMetadata(mod, props, tracingProps) {
+    // Layer is a client component, we just skip it. It can't have metadata exported.
+    // Return early to avoid accessing properties error for client references.
+    if (isClientReference(mod)) {
+        return null;
+    }
+    if (typeof mod.generateMetadata === "function") {
+        const { route } = tracingProps;
+        return (parent)=>getTracer().trace(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)=>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(components, props) {
+    const { metadata } = components;
+    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]
+export async function collectMetadata({ tree, metadataItems, errorMetadataItem, props, route, errorConvention }) {
+    let mod;
+    let modType;
+    const hasErrorConventionComponent = Boolean(errorConvention && tree[2][errorConvention]);
+    if (errorConvention) {
+        mod = await getComponentTypeModule(tree, "layout");
+        modType = errorConvention;
+    } else {
+        [mod, modType] = await getLayoutOrPageModule(tree);
+    }
+    if (modType) {
+        route += `/${modType}`;
+    }
+    const staticFilesMetadata = await resolveStaticMetadata(tree[2], props);
+    const metadataExport = mod ? await getDefinedMetadata(mod, props, {
+        route
+    }) : null;
+    const viewportExport = mod ? await getDefinedViewport(mod, props, {
+        route
+    }) : null;
+    metadataItems.push([
+        metadataExport,
+        staticFilesMetadata,
+        viewportExport
+    ]);
+    if (hasErrorConventionComponent && errorConvention) {
+        const errorMod = await getComponentTypeModule(tree, errorConvention);
+        const errorViewportExport = errorMod ? await getDefinedViewport(errorMod, props, {
+            route
+        }) : null;
+        const errorMetadataExport = errorMod ? await getDefinedMetadata(errorMod, props, {
+            route
+        }) : null;
+        errorMetadataItem[0] = errorMetadataExport;
+        errorMetadataItem[1] = staticFilesMetadata;
+        errorMetadataItem[2] = errorViewportExport;
+    }
+}
+export async function resolveMetadataItems({ tree, parentParams, metadataItems, errorMetadataItem, treePrefix = [], getDynamicParamFromSegment, searchParams, errorConvention }) {
+    const [segment, parallelRoutes, { page }] = tree;
+    const currentTreePrefix = [
+        ...treePrefix,
+        segment
+    ];
+    const isPage = typeof page !== "undefined";
+    // Handle dynamic segment params.
+    const segmentParam = getDynamicParamFromSegment(segment);
+    /**
+   * Create object holding the parent params and current params
+   */ const currentParams = // Handle null case where dynamic param is optional
+    segmentParam && segmentParam.value !== null ? {
+        ...parentParams,
+        [segmentParam.param]: segmentParam.value
+    } : parentParams;
+    let layerProps;
+    if (isPage) {
+        layerProps = {
+            params: currentParams,
+            searchParams
+        };
+    } else {
+        layerProps = {
+            params: currentParams
+        };
+    }
+    await collectMetadata({
+        tree,
+        metadataItems,
+        errorMetadataItem,
+        errorConvention,
+        props: layerProps,
+        route: currentTreePrefix// __PAGE__ shouldn't be shown in a route
+        .filter((s)=>s !== PAGE_SEGMENT_KEY).join("/")
+    });
+    for(const key in parallelRoutes){
+        const childTree = parallelRoutes[key];
+        await resolveMetadataItems({
+            tree: childTree,
+            metadataItems,
+            errorMetadataItem,
+            parentParams: currentParams,
+            treePrefix: currentTreePrefix,
+            searchParams,
+            getDynamicParamFromSegment,
+            errorConvention
+        });
+    }
+    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 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;
+        }
+    }
+}
+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 = 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 collectMetadataExportPreloading(results, dynamicMetadataExportFn, resolvers) {
+    const result = dynamicMetadataExportFn(new Promise((resolve)=>{
+        resolvers.push(resolve);
+    }));
+    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
+            };
+        });
+    }
+    results.push(result);
+}
+async function getMetadataFromExport(getPreloadMetadataExport, dynamicMetadataResolveState, metadataItems, currentIndex, resolvedMetadata, metadataResults) {
+    const metadataExport = getPreloadMetadataExport(metadataItems[currentIndex]);
+    const dynamicMetadataResolvers = dynamicMetadataResolveState.resolvers;
+    let metadata = null;
+    if (typeof metadataExport === "function") {
+        // Only preload at the beginning when resolves are empty
+        if (!dynamicMetadataResolvers.length) {
+            for(let j = currentIndex; j < metadataItems.length; j++){
+                const preloadMetadataExport = getPreloadMetadataExport(metadataItems[j]);
+                // call each `generateMetadata function concurrently and stash their resolver
+                if (typeof preloadMetadataExport === "function") {
+                    collectMetadataExportPreloading(metadataResults, preloadMetadataExport, dynamicMetadataResolvers);
+                }
+            }
+        }
+        const resolveParent = dynamicMetadataResolvers[dynamicMetadataResolveState.resolvingIndex];
+        const metadataResult = metadataResults[dynamicMetadataResolveState.resolvingIndex++];
+        // In dev we clone and freeze to prevent relying on mutating resolvedMetadata directly.
+        // In prod we just pass resolvedMetadata through without any copying.
+        const currentResolvedMetadata = process.env.NODE_ENV === "development" ? Object.freeze(require("./clone-metadata").cloneMetadata(resolvedMetadata)) : resolvedMetadata;
+        // This resolve should unblock the generateMetadata function if it awaited the parent
+        // argument. If it didn't await the parent argument it might already have a value since it was
+        // called concurrently. Regardless we await the return value before continuing on to the next layer
+        resolveParent(currentResolvedMetadata);
+        metadata = metadataResult instanceof Promise ? await metadataResult : metadataResult;
+        if (metadata && typeof metadata === "object" && "__nextError" in metadata) {
+            // re-throw caught metadata error from preloading
+            throw metadata["__nextError"];
+        }
+    } else if (metadataExport !== null && typeof metadataExport === "object") {
+        // This metadataExport is the object form
+        metadata = metadataExport;
+    }
+    return metadata;
+}
+export async function accumulateMetadata(metadataItems, metadataContext) {
+    const resolvedMetadata = createDefaultMetadata();
+    const metadataResults = [];
+    let titleTemplates = {
+        title: null,
+        twitter: null,
+        openGraph: null
+    };
+    // Loop over all metadata items again, merging synchronously any static object exports,
+    // awaiting any static promise exports, and resolving parent metadata and awaiting any generated metadata
+    const dynamicMetadataResolvers = {
+        resolvers: [],
+        resolvingIndex: 0
+    };
+    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: []
+    };
+    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;
+        }
+        const metadata = await getMetadataFromExport((metadataItem)=>metadataItem[0], dynamicMetadataResolvers, metadataItems, i, resolvedMetadata, metadataResults);
+        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);
+}
+export async function accumulateViewport(metadataItems) {
+    const resolvedViewport = createDefaultViewport();
+    const viewportResults = [];
+    const dynamicMetadataResolvers = {
+        resolvers: [],
+        resolvingIndex: 0
+    };
+    for(let i = 0; i < metadataItems.length; i++){
+        const viewport = await getMetadataFromExport((metadataItem)=>metadataItem[2], dynamicMetadataResolvers, metadataItems, i, resolvedViewport, viewportResults);
+        mergeViewport({
+            target: resolvedViewport,
+            source: viewport
+        });
+    }
+    return resolvedViewport;
+}
+export async function resolveMetadata({ tree, parentParams, metadataItems, errorMetadataItem, getDynamicParamFromSegment, searchParams, errorConvention, metadataContext }) {
+    const resolvedMetadataItems = await resolveMetadataItems({
+        tree,
+        parentParams,
+        metadataItems,
+        errorMetadataItem,
+        getDynamicParamFromSegment,
+        searchParams,
+        errorConvention
+    });
+    let error;
+    let metadata = createDefaultMetadata();
+    let viewport = createDefaultViewport();
+    try {
+        viewport = await accumulateViewport(resolvedMetadataItems);
+        metadata = await accumulateMetadata(resolvedMetadataItems, metadataContext);
+    } catch (err) {
+        error = err;
+    }
+    return [
+        error,
+        metadata,
+        viewport
+    ];
+}
+
+//# sourceMappingURL=resolve-metadata.js.map

node_modules/next/dist/esm/lib/metadata/resolvers/resolve-basics.js

@@ -0,0 +1,172 @@
+import { resolveAsArrayOrUndefined } from "../generate/utils";
+import { resolveAbsoluteUrlWithPathname } from "./resolve-url";
+function resolveAlternateUrl(url, metadataBase, metadataContext) {
+    // If alter native url is an URL instance,
+    // we treat it as a URL base and resolve with current pathname
+    if (url instanceof URL) {
+        url = new URL(metadataContext.pathname, url);
+    }
+    return resolveAbsoluteUrlWithPathname(url, metadataBase, metadataContext);
+}
+export const resolveThemeColor = (themeColor)=>{
+    var _resolveAsArrayOrUndefined;
+    if (!themeColor) return null;
+    const themeColorDescriptors = [];
+    (_resolveAsArrayOrUndefined = resolveAsArrayOrUndefined(themeColor)) == null ? void 0 : _resolveAsArrayOrUndefined.forEach((descriptor)=>{
+        if (typeof descriptor === "string") themeColorDescriptors.push({
+            color: descriptor
+        });
+        else if (typeof descriptor === "object") themeColorDescriptors.push({
+            color: descriptor.color,
+            media: descriptor.media
+        });
+    });
+    return themeColorDescriptors;
+};
+function resolveUrlValuesOfObject(obj, metadataBase, metadataContext) {
+    if (!obj) return null;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)){
+        if (typeof value === "string" || value instanceof URL) {
+            result[key] = [
+                {
+                    url: resolveAlternateUrl(value, metadataBase, metadataContext)
+                }
+            ];
+        } else {
+            result[key] = [];
+            value == null ? void 0 : value.forEach((item, index)=>{
+                const url = resolveAlternateUrl(item.url, metadataBase, metadataContext);
+                result[key][index] = {
+                    url,
+                    title: item.title
+                };
+            });
+        }
+    }
+    return result;
+}
+function resolveCanonicalUrl(urlOrDescriptor, metadataBase, metadataContext) {
+    if (!urlOrDescriptor) return null;
+    const url = typeof urlOrDescriptor === "string" || urlOrDescriptor instanceof URL ? urlOrDescriptor : urlOrDescriptor.url;
+    // Return string url because structureClone can't handle URL instance
+    return {
+        url: resolveAlternateUrl(url, metadataBase, metadataContext)
+    };
+}
+export const resolveAlternates = (alternates, metadataBase, context)=>{
+    if (!alternates) return null;
+    const canonical = resolveCanonicalUrl(alternates.canonical, metadataBase, context);
+    const languages = resolveUrlValuesOfObject(alternates.languages, metadataBase, context);
+    const media = resolveUrlValuesOfObject(alternates.media, metadataBase, context);
+    const types = resolveUrlValuesOfObject(alternates.types, metadataBase, context);
+    const result = {
+        canonical,
+        languages,
+        media,
+        types
+    };
+    return result;
+};
+const robotsKeys = [
+    "noarchive",
+    "nosnippet",
+    "noimageindex",
+    "nocache",
+    "notranslate",
+    "indexifembedded",
+    "nositelinkssearchbox",
+    "unavailable_after",
+    "max-video-preview",
+    "max-image-preview",
+    "max-snippet"
+];
+const resolveRobotsValue = (robots)=>{
+    if (!robots) return null;
+    if (typeof robots === "string") return robots;
+    const values = [];
+    if (robots.index) values.push("index");
+    else if (typeof robots.index === "boolean") values.push("noindex");
+    if (robots.follow) values.push("follow");
+    else if (typeof robots.follow === "boolean") values.push("nofollow");
+    for (const key of robotsKeys){
+        const value = robots[key];
+        if (typeof value !== "undefined" && value !== false) {
+            values.push(typeof value === "boolean" ? key : `${key}:${value}`);
+        }
+    }
+    return values.join(", ");
+};
+export const resolveRobots = (robots)=>{
+    if (!robots) return null;
+    return {
+        basic: resolveRobotsValue(robots),
+        googleBot: typeof robots !== "string" ? resolveRobotsValue(robots.googleBot) : null
+    };
+};
+const VerificationKeys = [
+    "google",
+    "yahoo",
+    "yandex",
+    "me",
+    "other"
+];
+export const resolveVerification = (verification)=>{
+    if (!verification) return null;
+    const res = {};
+    for (const key of VerificationKeys){
+        const value = verification[key];
+        if (value) {
+            if (key === "other") {
+                res.other = {};
+                for(const otherKey in verification.other){
+                    const otherValue = resolveAsArrayOrUndefined(verification.other[otherKey]);
+                    if (otherValue) res.other[otherKey] = otherValue;
+                }
+            } else res[key] = resolveAsArrayOrUndefined(value);
+        }
+    }
+    return res;
+};
+export const resolveAppleWebApp = (appWebApp)=>{
+    var _resolveAsArrayOrUndefined;
+    if (!appWebApp) return null;
+    if (appWebApp === true) {
+        return {
+            capable: true
+        };
+    }
+    const startupImages = appWebApp.startupImage ? (_resolveAsArrayOrUndefined = resolveAsArrayOrUndefined(appWebApp.startupImage)) == null ? void 0 : _resolveAsArrayOrUndefined.map((item)=>typeof item === "string" ? {
+            url: item
+        } : item) : null;
+    return {
+        capable: "capable" in appWebApp ? !!appWebApp.capable : true,
+        title: appWebApp.title || null,
+        startupImage: startupImages,
+        statusBarStyle: appWebApp.statusBarStyle || "default"
+    };
+};
+export const resolveAppLinks = (appLinks)=>{
+    if (!appLinks) return null;
+    for(const key in appLinks){
+        // @ts-ignore // TODO: type infer
+        appLinks[key] = resolveAsArrayOrUndefined(appLinks[key]);
+    }
+    return appLinks;
+};
+export const resolveItunes = (itunes, metadataBase, context)=>{
+    if (!itunes) return null;
+    return {
+        appId: itunes.appId,
+        appArgument: itunes.appArgument ? resolveAlternateUrl(itunes.appArgument, metadataBase, context) : undefined
+    };
+};
+export const resolveFacebook = (facebook)=>{
+    if (!facebook) return null;
+    return {
+        appId: facebook.appId,
+        admins: resolveAsArrayOrUndefined(facebook.admins)
+    };
+};
+
+//# sourceMappingURL=resolve-basics.js.map

node_modules/next/dist/esm/lib/metadata/resolvers/resolve-basics.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/resolvers/resolve-basics.ts"],"names":["resolveAsArrayOrUndefined","resolveAbsoluteUrlWithPathname","resolveAlternateUrl","url","metadataBase","metadataContext","URL","pathname","resolveThemeColor","themeColor","themeColorDescriptors","forEach","descriptor","push","color","media","resolveUrlValuesOfObject","obj","result","key","value","Object","entries","item","index","title","resolveCanonicalUrl","urlOrDescriptor","resolveAlternates","alternates","context","canonical","languages","types","robotsKeys","resolveRobotsValue","robots","values","follow","join","resolveRobots","basic","googleBot","VerificationKeys","resolveVerification","verification","res","other","otherKey","otherValue","resolveAppleWebApp","appWebApp","capable","startupImages","startupImage","map","statusBarStyle","resolveAppLinks","appLinks","resolveItunes","itunes","appId","appArgument","undefined","resolveFacebook","facebook","admins"],"mappings":"AAeA,SAASA,yBAAyB,QAAQ,oBAAmB;AAC7D,SAASC,8BAA8B,QAAQ,gBAAe;AAE9D,SAASC,oBACPC,GAAiB,EACjBC,YAAwB,EACxBC,eAAgC;IAEhC,0CAA0C;IAC1C,8DAA8D;IAC9D,IAAIF,eAAeG,KAAK;QACtBH,MAAM,IAAIG,IAAID,gBAAgBE,QAAQ,EAAEJ;IAC1C;IACA,OAAOF,+BAA+BE,KAAKC,cAAcC;AAC3D;AAEA,OAAO,MAAMG,oBAA2D,CACtEC;QAKAT;IAHA,IAAI,CAACS,YAAY,OAAO;IACxB,MAAMC,wBAAgD,EAAE;KAExDV,6BAAAA,0BAA0BS,gCAA1BT,2BAAuCW,OAAO,CAAC,CAACC;QAC9C,IAAI,OAAOA,eAAe,UACxBF,sBAAsBG,IAAI,CAAC;YAAEC,OAAOF;QAAW;aAC5C,IAAI,OAAOA,eAAe,UAC7BF,sBAAsBG,IAAI,CAAC;YACzBC,OAAOF,WAAWE,KAAK;YACvBC,OAAOH,WAAWG,KAAK;QACzB;IACJ;IAEA,OAAOL;AACT,EAAC;AAED,SAASM,yBACPC,GAMa,EACbb,YAA8C,EAC9CC,eAAgC;IAEhC,IAAI,CAACY,KAAK,OAAO;IAEjB,MAAMC,SAAoD,CAAC;IAC3D,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACL,KAAM;QAC9C,IAAI,OAAOG,UAAU,YAAYA,iBAAiBd,KAAK;YACrDY,MAAM,CAACC,IAAI,GAAG;gBACZ;oBACEhB,KAAKD,oBAAoBkB,OAAOhB,cAAcC;gBAChD;aACD;QACH,OAAO;YACLa,MAAM,CAACC,IAAI,GAAG,EAAE;YAChBC,yBAAAA,MAAOT,OAAO,CAAC,CAACY,MAAMC;gBACpB,MAAMrB,MAAMD,oBAAoBqB,KAAKpB,GAAG,EAAEC,cAAcC;gBACxDa,MAAM,CAACC,IAAI,CAACK,MAAM,GAAG;oBACnBrB;oBACAsB,OAAOF,KAAKE,KAAK;gBACnB;YACF;QACF;IACF;IACA,OAAOP;AACT;AAEA,SAASQ,oBACPC,eAA0E,EAC1EvB,YAAwB,EACxBC,eAAgC;IAEhC,IAAI,CAACsB,iBAAiB,OAAO;IAE7B,MAAMxB,MACJ,OAAOwB,oBAAoB,YAAYA,2BAA2BrB,MAC9DqB,kBACAA,gBAAgBxB,GAAG;IAEzB,qEAAqE;IACrE,OAAO;QACLA,KAAKD,oBAAoBC,KAAKC,cAAcC;IAC9C;AACF;AAEA,OAAO,MAAMuB,oBAGT,CAACC,YAAYzB,cAAc0B;IAC7B,IAAI,CAACD,YAAY,OAAO;IAExB,MAAME,YAAYL,oBAChBG,WAAWE,SAAS,EACpB3B,cACA0B;IAEF,MAAME,YAAYhB,yBAChBa,WAAWG,SAAS,EACpB5B,cACA0B;IAEF,MAAMf,QAAQC,yBACZa,WAAWd,KAAK,EAChBX,cACA0B;IAEF,MAAMG,QAAQjB,yBACZa,WAAWI,KAAK,EAChB7B,cACA0B;IAGF,MAAMZ,SAAgC;QACpCa;QACAC;QACAjB;QACAkB;IACF;IAEA,OAAOf;AACT,EAAC;AAED,MAAMgB,aAAa;IACjB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AACD,MAAMC,qBAAoE,CACxEC;IAEA,IAAI,CAACA,QAAQ,OAAO;IACpB,IAAI,OAAOA,WAAW,UAAU,OAAOA;IAEvC,MAAMC,SAAmB,EAAE;IAE3B,IAAID,OAAOZ,KAAK,EAAEa,OAAOxB,IAAI,CAAC;SACzB,IAAI,OAAOuB,OAAOZ,KAAK,KAAK,WAAWa,OAAOxB,IAAI,CAAC;IAExD,IAAIuB,OAAOE,MAAM,EAAED,OAAOxB,IAAI,CAAC;SAC1B,IAAI,OAAOuB,OAAOE,MAAM,KAAK,WAAWD,OAAOxB,IAAI,CAAC;IAEzD,KAAK,MAAMM,OAAOe,WAAY;QAC5B,MAAMd,QAAQgB,MAAM,CAACjB,IAAI;QACzB,IAAI,OAAOC,UAAU,eAAeA,UAAU,OAAO;YACnDiB,OAAOxB,IAAI,CAAC,OAAOO,UAAU,YAAYD,MAAM,CAAC,EAAEA,IAAI,CAAC,EAAEC,MAAM,CAAC;QAClE;IACF;IAEA,OAAOiB,OAAOE,IAAI,CAAC;AACrB;AAEA,OAAO,MAAMC,gBAAyC,CAACJ;IACrD,IAAI,CAACA,QAAQ,OAAO;IACpB,OAAO;QACLK,OAAON,mBAAmBC;QAC1BM,WACE,OAAON,WAAW,WAAWD,mBAAmBC,OAAOM,SAAS,IAAI;IACxE;AACF,EAAC;AAED,MAAMC,mBAAmB;IAAC;IAAU;IAAS;IAAU;IAAM;CAAQ;AACrE,OAAO,MAAMC,sBAAqD,CAChEC;IAEA,IAAI,CAACA,cAAc,OAAO;IAC1B,MAAMC,MAA4B,CAAC;IAEnC,KAAK,MAAM3B,OAAOwB,iBAAkB;QAClC,MAAMvB,QAAQyB,YAAY,CAAC1B,IAAI;QAC/B,IAAIC,OAAO;YACT,IAAID,QAAQ,SAAS;gBACnB2B,IAAIC,KAAK,GAAG,CAAC;gBACb,IAAK,MAAMC,YAAYH,aAAaE,KAAK,CAAE;oBACzC,MAAME,aAAajD,0BACjB6C,aAAaE,KAAK,CAACC,SAAS;oBAE9B,IAAIC,YAAYH,IAAIC,KAAK,CAACC,SAAS,GAAGC;gBACxC;YACF,OAAOH,GAAG,CAAC3B,IAAI,GAAGnB,0BAA0BoB;QAC9C;IACF;IACA,OAAO0B;AACT,EAAC;AAED,OAAO,MAAMI,qBAAmD,CAACC;QAS3DnD;IARJ,IAAI,CAACmD,WAAW,OAAO;IACvB,IAAIA,cAAc,MAAM;QACtB,OAAO;YACLC,SAAS;QACX;IACF;IAEA,MAAMC,gBAAgBF,UAAUG,YAAY,IACxCtD,6BAAAA,0BAA0BmD,UAAUG,YAAY,sBAAhDtD,2BAAmDuD,GAAG,CAAC,CAAChC,OACtD,OAAOA,SAAS,WAAW;YAAEpB,KAAKoB;QAAK,IAAIA,QAE7C;IAEJ,OAAO;QACL6B,SAAS,aAAaD,YAAY,CAAC,CAACA,UAAUC,OAAO,GAAG;QACxD3B,OAAO0B,UAAU1B,KAAK,IAAI;QAC1B6B,cAAcD;QACdG,gBAAgBL,UAAUK,cAAc,IAAI;IAC9C;AACF,EAAC;AAED,OAAO,MAAMC,kBAA6C,CAACC;IACzD,IAAI,CAACA,UAAU,OAAO;IACtB,IAAK,MAAMvC,OAAOuC,SAAU;QAC1B,iCAAiC;QACjCA,QAAQ,CAACvC,IAAI,GAAGnB,0BAA0B0D,QAAQ,CAACvC,IAAI;IACzD;IACA,OAAOuC;AACT,EAAC;AAED,OAAO,MAAMC,gBAGT,CAACC,QAAQxD,cAAc0B;IACzB,IAAI,CAAC8B,QAAQ,OAAO;IACpB,OAAO;QACLC,OAAOD,OAAOC,KAAK;QACnBC,aAAaF,OAAOE,WAAW,GAC3B5D,oBAAoB0D,OAAOE,WAAW,EAAE1D,cAAc0B,WACtDiC;IACN;AACF,EAAC;AAED,OAAO,MAAMC,kBAA6C,CAACC;IACzD,IAAI,CAACA,UAAU,OAAO;IACtB,OAAO;QACLJ,OAAOI,SAASJ,KAAK;QACrBK,QAAQlE,0BAA0BiE,SAASC,MAAM;IACnD;AACF,EAAC"}

node_modules/next/dist/esm/lib/metadata/resolvers/resolve-icons.js

@@ -0,0 +1,34 @@
+import { resolveAsArrayOrUndefined } from "../generate/utils";
+import { isStringOrURL } from "./resolve-url";
+import { IconKeys } from "../constants";
+export function resolveIcon(icon) {
+    if (isStringOrURL(icon)) return {
+        url: icon
+    };
+    else if (Array.isArray(icon)) return icon;
+    return icon;
+}
+export const resolveIcons = (icons)=>{
+    if (!icons) {
+        return null;
+    }
+    const resolved = {
+        icon: [],
+        apple: []
+    };
+    if (Array.isArray(icons)) {
+        resolved.icon = icons.map(resolveIcon).filter(Boolean);
+    } else if (isStringOrURL(icons)) {
+        resolved.icon = [
+            resolveIcon(icons)
+        ];
+    } else {
+        for (const key of IconKeys){
+            const values = resolveAsArrayOrUndefined(icons[key]);
+            if (values) resolved[key] = values.map(resolveIcon);
+        }
+    }
+    return resolved;
+};
+
+//# sourceMappingURL=resolve-icons.js.map

node_modules/next/dist/esm/lib/metadata/resolvers/resolve-icons.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/resolvers/resolve-icons.ts"],"names":["resolveAsArrayOrUndefined","isStringOrURL","IconKeys","resolveIcon","icon","url","Array","isArray","resolveIcons","icons","resolved","apple","map","filter","Boolean","key","values"],"mappings":"AAGA,SAASA,yBAAyB,QAAQ,oBAAmB;AAC7D,SAASC,aAAa,QAAQ,gBAAe;AAC7C,SAASC,QAAQ,QAAQ,eAAc;AAEvC,OAAO,SAASC,YAAYC,IAAU;IACpC,IAAIH,cAAcG,OAAO,OAAO;QAAEC,KAAKD;IAAK;SACvC,IAAIE,MAAMC,OAAO,CAACH,OAAO,OAAOA;IACrC,OAAOA;AACT;AAEA,OAAO,MAAMI,eAAuC,CAACC;IACnD,IAAI,CAACA,OAAO;QACV,OAAO;IACT;IAEA,MAAMC,WAAsC;QAC1CN,MAAM,EAAE;QACRO,OAAO,EAAE;IACX;IACA,IAAIL,MAAMC,OAAO,CAACE,QAAQ;QACxBC,SAASN,IAAI,GAAGK,MAAMG,GAAG,CAACT,aAAaU,MAAM,CAACC;IAChD,OAAO,IAAIb,cAAcQ,QAAQ;QAC/BC,SAASN,IAAI,GAAG;YAACD,YAAYM;SAAO;IACtC,OAAO;QACL,KAAK,MAAMM,OAAOb,SAAU;YAC1B,MAAMc,SAAShB,0BAA0BS,KAAK,CAACM,IAAI;YACnD,IAAIC,QAAQN,QAAQ,CAACK,IAAI,GAAGC,OAAOJ,GAAG,CAACT;QACzC;IACF;IACA,OAAOO;AACT,EAAC"}

node_modules/next/dist/esm/lib/metadata/resolvers/resolve-opengraph.js

@@ -0,0 +1,152 @@
+import { resolveAsArrayOrUndefined } from "../generate/utils";
+import { getSocialImageFallbackMetadataBase, isStringOrURL, resolveUrl, resolveAbsoluteUrlWithPathname } from "./resolve-url";
+import { resolveTitle } from "./resolve-title";
+import { isFullStringUrl } from "../../url";
+import { warnOnce } from "../../../build/output/log";
+const OgTypeFields = {
+    article: [
+        "authors",
+        "tags"
+    ],
+    song: [
+        "albums",
+        "musicians"
+    ],
+    playlist: [
+        "albums",
+        "musicians"
+    ],
+    radio: [
+        "creators"
+    ],
+    video: [
+        "actors",
+        "directors",
+        "writers",
+        "tags"
+    ],
+    basic: [
+        "emails",
+        "phoneNumbers",
+        "faxNumbers",
+        "alternateLocale",
+        "audio",
+        "videos"
+    ]
+};
+function resolveAndValidateImage(item, metadataBase, isMetadataBaseMissing, isStandaloneMode) {
+    if (!item) return undefined;
+    const isItemUrl = isStringOrURL(item);
+    const inputUrl = isItemUrl ? item : item.url;
+    if (!inputUrl) return undefined;
+    const isNonVercelDeployment = !process.env.VERCEL && process.env.NODE_ENV === "production";
+    // Validate url in self-host standalone mode or non-Vercel deployment
+    if (isStandaloneMode || isNonVercelDeployment) {
+        validateResolvedImageUrl(inputUrl, metadataBase, isMetadataBaseMissing);
+    }
+    return isItemUrl ? {
+        url: resolveUrl(inputUrl, metadataBase)
+    } : {
+        ...item,
+        // Update image descriptor url
+        url: resolveUrl(inputUrl, metadataBase)
+    };
+}
+export function resolveImages(images, metadataBase, isStandaloneMode) {
+    const resolvedImages = resolveAsArrayOrUndefined(images);
+    if (!resolvedImages) return resolvedImages;
+    const { isMetadataBaseMissing, fallbackMetadataBase } = getSocialImageFallbackMetadataBase(metadataBase);
+    const nonNullableImages = [];
+    for (const item of resolvedImages){
+        const resolvedItem = resolveAndValidateImage(item, fallbackMetadataBase, isMetadataBaseMissing, isStandaloneMode);
+        if (!resolvedItem) continue;
+        nonNullableImages.push(resolvedItem);
+    }
+    return nonNullableImages;
+}
+const ogTypeToFields = {
+    article: OgTypeFields.article,
+    book: OgTypeFields.article,
+    "music.song": OgTypeFields.song,
+    "music.album": OgTypeFields.song,
+    "music.playlist": OgTypeFields.playlist,
+    "music.radio_station": OgTypeFields.radio,
+    "video.movie": OgTypeFields.video,
+    "video.episode": OgTypeFields.video
+};
+function getFieldsByOgType(ogType) {
+    if (!ogType || !(ogType in ogTypeToFields)) return OgTypeFields.basic;
+    return ogTypeToFields[ogType].concat(OgTypeFields.basic);
+}
+function validateResolvedImageUrl(inputUrl, fallbackMetadataBase, isMetadataBaseMissing) {
+    // Only warn on the image url that needs to be resolved with metadataBase
+    if (typeof inputUrl === "string" && !isFullStringUrl(inputUrl) && isMetadataBaseMissing) {
+        warnOnce(`metadataBase property in metadata export is not set for resolving social open graph or twitter images, using "${fallbackMetadataBase.origin}". See https://nextjs.org/docs/app/api-reference/functions/generate-metadata#metadatabase`);
+    }
+}
+export const resolveOpenGraph = (openGraph, metadataBase, metadataContext, titleTemplate)=>{
+    if (!openGraph) return null;
+    function resolveProps(target, og) {
+        const ogType = og && "type" in og ? og.type : undefined;
+        const keys = getFieldsByOgType(ogType);
+        for (const k of keys){
+            const key = k;
+            if (key in og && key !== "url") {
+                const value = og[key];
+                if (value) {
+                    const arrayValue = resolveAsArrayOrUndefined(value);
+                    target[key] = arrayValue;
+                }
+            }
+        }
+        target.images = resolveImages(og.images, metadataBase, metadataContext.isStandaloneMode);
+    }
+    const resolved = {
+        ...openGraph,
+        title: resolveTitle(openGraph.title, titleTemplate)
+    };
+    resolveProps(resolved, openGraph);
+    resolved.url = openGraph.url ? resolveAbsoluteUrlWithPathname(openGraph.url, metadataBase, metadataContext) : null;
+    return resolved;
+};
+const TwitterBasicInfoKeys = [
+    "site",
+    "siteId",
+    "creator",
+    "creatorId",
+    "description"
+];
+export const resolveTwitter = (twitter, metadataBase, metadataContext, titleTemplate)=>{
+    var _resolved_images;
+    if (!twitter) return null;
+    let card = "card" in twitter ? twitter.card : undefined;
+    const resolved = {
+        ...twitter,
+        title: resolveTitle(twitter.title, titleTemplate)
+    };
+    for (const infoKey of TwitterBasicInfoKeys){
+        resolved[infoKey] = twitter[infoKey] || null;
+    }
+    resolved.images = resolveImages(twitter.images, metadataBase, metadataContext.isStandaloneMode);
+    card = card || (((_resolved_images = resolved.images) == null ? void 0 : _resolved_images.length) ? "summary_large_image" : "summary");
+    resolved.card = card;
+    if ("card" in resolved) {
+        switch(resolved.card){
+            case "player":
+                {
+                    resolved.players = resolveAsArrayOrUndefined(resolved.players) || [];
+                    break;
+                }
+            case "app":
+                {
+                    resolved.app = resolved.app || {};
+                    break;
+                }
+            default:
+                break;
+        }
+    }
+    return resolved;
+};
+
+//# sourceMappingURL=resolve-opengraph.js.map

node_modules/next/dist/esm/lib/metadata/resolvers/resolve-opengraph.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/resolvers/resolve-opengraph.ts"],"names":["resolveAsArrayOrUndefined","getSocialImageFallbackMetadataBase","isStringOrURL","resolveUrl","resolveAbsoluteUrlWithPathname","resolveTitle","isFullStringUrl","warnOnce","OgTypeFields","article","song","playlist","radio","video","basic","resolveAndValidateImage","item","metadataBase","isMetadataBaseMissing","isStandaloneMode","undefined","isItemUrl","inputUrl","url","isNonVercelDeployment","process","env","VERCEL","NODE_ENV","validateResolvedImageUrl","resolveImages","images","resolvedImages","fallbackMetadataBase","nonNullableImages","resolvedItem","push","ogTypeToFields","book","getFieldsByOgType","ogType","concat","origin","resolveOpenGraph","openGraph","metadataContext","titleTemplate","resolveProps","target","og","type","keys","k","key","value","arrayValue","resolved","title","TwitterBasicInfoKeys","resolveTwitter","twitter","card","infoKey","length","players","app"],"mappings":"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"}

node_modules/next/dist/esm/lib/metadata/resolvers/resolve-title.js

@@ -0,0 +1,30 @@
+function resolveTitleTemplate(template, title) {
+    return template ? template.replace(/%s/g, title) : title;
+}
+export function resolveTitle(title, stashedTemplate) {
+    let resolved;
+    const template = typeof title !== "string" && title && "template" in title ? title.template : null;
+    if (typeof title === "string") {
+        resolved = resolveTitleTemplate(stashedTemplate, title);
+    } else if (title) {
+        if ("default" in title) {
+            resolved = resolveTitleTemplate(stashedTemplate, title.default);
+        }
+        if ("absolute" in title && title.absolute) {
+            resolved = title.absolute;
+        }
+    }
+    if (title && typeof title !== "string") {
+        return {
+            template,
+            absolute: resolved || ""
+        };
+    } else {
+        return {
+            absolute: resolved || title || "",
+            template
+        };
+    }
+}
+
+//# sourceMappingURL=resolve-title.js.map

node_modules/next/dist/esm/lib/metadata/resolvers/resolve-title.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/resolvers/resolve-title.ts"],"names":["resolveTitleTemplate","template","title","replace","resolveTitle","stashedTemplate","resolved","default","absolute"],"mappings":"AAGA,SAASA,qBACPC,QAAmC,EACnCC,KAAa;IAEb,OAAOD,WAAWA,SAASE,OAAO,CAAC,OAAOD,SAASA;AACrD;AAEA,OAAO,SAASE,aACdF,KAAwB,EACxBG,eAA0C;IAE1C,IAAIC;IACJ,MAAML,WACJ,OAAOC,UAAU,YAAYA,SAAS,cAAcA,QAChDA,MAAMD,QAAQ,GACd;IAEN,IAAI,OAAOC,UAAU,UAAU;QAC7BI,WAAWN,qBAAqBK,iBAAiBH;IACnD,OAAO,IAAIA,OAAO;QAChB,IAAI,aAAaA,OAAO;YACtBI,WAAWN,qBAAqBK,iBAAiBH,MAAMK,OAAO;QAChE;QACA,IAAI,cAAcL,SAASA,MAAMM,QAAQ,EAAE;YACzCF,WAAWJ,MAAMM,QAAQ;QAC3B;IACF;IAEA,IAAIN,SAAS,OAAOA,UAAU,UAAU;QACtC,OAAO;YACLD;YACAO,UAAUF,YAAY;QACxB;IACF,OAAO;QACL,OAAO;YAAEE,UAAUF,YAAYJ,SAAS;YAAID;QAAS;IACvD;AACF"}

node_modules/next/dist/esm/lib/metadata/resolvers/resolve-url.js

@@ -0,0 +1,100 @@
+import path from "../../../shared/lib/isomorphic/path";
+function isStringOrURL(icon) {
+    return typeof icon === "string" || icon instanceof URL;
+}
+function createLocalMetadataBase() {
+    return new URL(`http://localhost:${process.env.PORT || 3000}`);
+}
+function getPreviewDeploymentUrl() {
+    const origin = process.env.VERCEL_BRANCH_URL || process.env.VERCEL_URL;
+    return origin ? new URL(`https://${origin}`) : undefined;
+}
+function getProductionDeploymentUrl() {
+    const origin = process.env.VERCEL_PROJECT_PRODUCTION_URL;
+    return origin ? new URL(`https://${origin}`) : undefined;
+}
+// For deployment url for metadata routes, prefer to use the deployment url if possible
+// as these routes are unique to the deployments url.
+export function getSocialImageFallbackMetadataBase(metadataBase) {
+    const isMetadataBaseMissing = !metadataBase;
+    const defaultMetadataBase = createLocalMetadataBase();
+    const previewDeploymentUrl = getPreviewDeploymentUrl();
+    const productionDeploymentUrl = getProductionDeploymentUrl();
+    let fallbackMetadataBase;
+    if (process.env.NODE_ENV === "development") {
+        fallbackMetadataBase = defaultMetadataBase;
+    } else {
+        fallbackMetadataBase = process.env.NODE_ENV === "production" && previewDeploymentUrl && process.env.VERCEL_ENV === "preview" ? previewDeploymentUrl : metadataBase || productionDeploymentUrl || defaultMetadataBase;
+    }
+    return {
+        fallbackMetadataBase,
+        isMetadataBaseMissing
+    };
+}
+function resolveUrl(url, metadataBase) {
+    if (url instanceof URL) return url;
+    if (!url) return null;
+    try {
+        // If we can construct a URL instance from url, ignore metadataBase
+        const parsedUrl = new URL(url);
+        return parsedUrl;
+    } catch  {}
+    if (!metadataBase) {
+        metadataBase = createLocalMetadataBase();
+    }
+    // Handle relative or absolute paths
+    const basePath = metadataBase.pathname || "";
+    const joinedPath = path.posix.join(basePath, url);
+    return new URL(joinedPath, metadataBase);
+}
+// Resolve with `pathname` if `url` is a relative path.
+function resolveRelativeUrl(url, pathname) {
+    if (typeof url === "string" && url.startsWith("./")) {
+        return path.posix.resolve(pathname, url);
+    }
+    return url;
+}
+// The regex is matching logic from packages/next/src/lib/load-custom-routes.ts
+const FILE_REGEX = /^(?:\/((?!\.well-known(?:\/.*)?)(?:[^/]+\/)*[^/]+\.\w+))(\/?|$)/i;
+function isFilePattern(pathname) {
+    return FILE_REGEX.test(pathname);
+}
+// Resolve `pathname` if `url` is a relative path the compose with `metadataBase`.
+function resolveAbsoluteUrlWithPathname(url, metadataBase, { trailingSlash, pathname }) {
+    // Resolve url with pathname that always starts with `/`
+    url = resolveRelativeUrl(url, pathname);
+    // Convert string url or URL instance to absolute url string,
+    // if there's case needs to be resolved with metadataBase
+    let resolvedUrl = "";
+    const result = metadataBase ? resolveUrl(url, metadataBase) : url;
+    if (typeof result === "string") {
+        resolvedUrl = result;
+    } else {
+        resolvedUrl = result.pathname === "/" ? result.origin : result.href;
+    }
+    // Add trailing slash if it's enabled for urls matches the condition
+    // - Not external, same origin with metadataBase
+    // - Doesn't have query
+    if (trailingSlash && !resolvedUrl.endsWith("/")) {
+        let isRelative = resolvedUrl.startsWith("/");
+        let hasQuery = resolvedUrl.includes("?");
+        let isExternal = false;
+        let isFileUrl = false;
+        if (!isRelative) {
+            try {
+                const parsedUrl = new URL(resolvedUrl);
+                isExternal = metadataBase != null && parsedUrl.origin !== metadataBase.origin;
+                isFileUrl = isFilePattern(parsedUrl.pathname);
+            } catch  {
+                // If it's not a valid URL, treat it as external
+                isExternal = true;
+            }
+            if (// Do not apply trailing slash for file like urls, aligning with the behavior with `trailingSlash`
+            !isFileUrl && !isExternal && !hasQuery) return `${resolvedUrl}/`;
+        }
+    }
+    return resolvedUrl;
+}
+export { isStringOrURL, resolveUrl, resolveRelativeUrl, resolveAbsoluteUrlWithPathname,  };
+
+//# sourceMappingURL=resolve-url.js.map

node_modules/next/dist/esm/lib/metadata/resolvers/resolve-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/resolvers/resolve-url.ts"],"names":["path","isStringOrURL","icon","URL","createLocalMetadataBase","process","env","PORT","getPreviewDeploymentUrl","origin","VERCEL_BRANCH_URL","VERCEL_URL","undefined","getProductionDeploymentUrl","VERCEL_PROJECT_PRODUCTION_URL","getSocialImageFallbackMetadataBase","metadataBase","isMetadataBaseMissing","defaultMetadataBase","previewDeploymentUrl","productionDeploymentUrl","fallbackMetadataBase","NODE_ENV","VERCEL_ENV","resolveUrl","url","parsedUrl","basePath","pathname","joinedPath","posix","join","resolveRelativeUrl","startsWith","resolve","FILE_REGEX","isFilePattern","test","resolveAbsoluteUrlWithPathname","trailingSlash","resolvedUrl","result","href","endsWith","isRelative","hasQuery","includes","isExternal","isFileUrl"],"mappings":"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"}

node_modules/next/dist/esm/lib/metadata/types/alternative-urls-types.js

@@ -0,0 +1,4 @@
+// Reference: https://hreflang.org/what-is-a-valid-hreflang
+export { };
+
+//# sourceMappingURL=alternative-urls-types.js.map

node_modules/next/dist/esm/lib/metadata/types/alternative-urls-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/alternative-urls-types.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAgc3D,WASC"}

node_modules/next/dist/esm/lib/metadata/types/extra-types.js

@@ -0,0 +1,13 @@
+// When rendering applink meta tags add a namespace tag before each array instance
+// if more than one member exists.
+// ref: https://developers.facebook.com/docs/applinks/metadata-reference
+// Format Detection
+// This is a poorly specified metadata export type that is supposed to
+// control whether the device attempts to conver text that matches
+// certain formats into links for action. The most supported example
+// is how mobile devices detect phone numbers and make them into links
+// that can initiate a phone call
+// https://www.goodemailcode.com/email-code/template.html
+export { };
+
+//# sourceMappingURL=extra-types.js.map

node_modules/next/dist/esm/lib/metadata/types/extra-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/extra-types.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,kCAAkC;AAClC,wEAAwE;AAsGxE,mBAAmB;AACnB,sEAAsE;AACtE,kEAAkE;AAClE,oEAAoE;AACpE,sEAAsE;AACtE,iCAAiC;AACjC,yDAAyD;AACzD,WAMC"}

node_modules/next/dist/esm/lib/metadata/types/icons.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=icons.js.map

node_modules/next/dist/esm/lib/metadata/types/icons.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/icons.ts"],"names":[],"mappings":"AAAA,WAMQ"}

node_modules/next/dist/esm/lib/metadata/types/manifest-types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=manifest-types.js.map

node_modules/next/dist/esm/lib/metadata/types/manifest-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/manifest-types.ts"],"names":[],"mappings":"AAAA,WAmGC"}

node_modules/next/dist/esm/lib/metadata/types/metadata-interface.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=metadata-interface.js.map

node_modules/next/dist/esm/lib/metadata/types/metadata-interface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/metadata-interface.ts"],"names":[],"mappings":"AAopBA,WAQC"}

node_modules/next/dist/esm/lib/metadata/types/metadata-types.js

@@ -0,0 +1,7 @@
+/**
+ *
+ * Metadata types
+ *
+ */ export { };
+
+//# sourceMappingURL=metadata-types.js.map

node_modules/next/dist/esm/lib/metadata/types/metadata-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/metadata-types.ts"],"names":[],"mappings":"AAAA;;;;CAIC,GAsJD,WAGC"}

node_modules/next/dist/esm/lib/metadata/types/opengraph-types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=opengraph-types.js.map

node_modules/next/dist/esm/lib/metadata/types/opengraph-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/opengraph-types.ts"],"names":[],"mappings":"AAoJA,WAa6B"}

node_modules/next/dist/esm/lib/metadata/types/resolvers.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=resolvers.js.map

node_modules/next/dist/esm/lib/metadata/types/resolvers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/resolvers.ts"],"names":[],"mappings":"AAeA,WAIC"}

node_modules/next/dist/esm/lib/metadata/types/twitter-types.js

@@ -0,0 +1,4 @@
+// Reference: https://developer.twitter.com/en/docs/twitter-for-websites/cards/overview/markup
+export { };
+
+//# sourceMappingURL=twitter-types.js.map

node_modules/next/dist/esm/lib/metadata/types/twitter-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/twitter-types.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAuF9F,WAI0C"}