Initial boiler plate project

node_modules/next/dist/lib/metadata/clone-metadata.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedMetadata } from './types/metadata-interface';
+export declare function cloneMetadata(metadata: ResolvedMetadata): ResolvedMetadata;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cloneMetadata", {
+    enumerable: true,
+    get: function() {
+        return cloneMetadata;
+    }
+});
+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;
+}
+function cloneMetadata(metadata) {
+    const jsonString = JSON.stringify(metadata, replacer);
+    return JSON.parse(jsonString, reviver);
+}
+
+//# sourceMappingURL=clone-metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/clone-metadata.ts"],"names":["cloneMetadata","TYPE_URL","replacer","_key","val","URL","_type","value","href","reviver","metadata","jsonString","JSON","stringify","parse"],"mappings":";;;;+BAmBgBA;;;eAAAA;;;AAjBhB,MAAMC,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;AAEO,SAASJ,cAAcU,QAA0B;IACtD,MAAMC,aAAaC,KAAKC,SAAS,CAACH,UAAUR;IAC5C,OAAOU,KAAKE,KAAK,CAACH,YAAYF;AAChC"}

node_modules/next/dist/lib/metadata/constants.d.ts

@@ -0,0 +1,6 @@
+import type { ViewportLayout } from './types/extra-types';
+import type { Icons } from './types/metadata-types';
+export declare const ViewportMetaKeys: {
+    [k in keyof ViewportLayout]: string;
+};
+export declare const IconKeys: (keyof Icons)[];

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    IconKeys: null,
+    ViewportMetaKeys: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    IconKeys: function() {
+        return IconKeys;
+    },
+    ViewportMetaKeys: function() {
+        return ViewportMetaKeys;
+    }
+});
+const ViewportMetaKeys = {
+    width: "width",
+    height: "height",
+    initialScale: "initial-scale",
+    minimumScale: "minimum-scale",
+    maximumScale: "maximum-scale",
+    viewportFit: "viewport-fit",
+    userScalable: "user-scalable",
+    interactiveWidget: "interactive-widget"
+};
+const IconKeys = [
+    "icon",
+    "shortcut",
+    "apple",
+    "other"
+];
+
+//# sourceMappingURL=constants.js.map

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

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

node_modules/next/dist/lib/metadata/default-metadata.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedMetadata, ResolvedViewport } from './types/metadata-interface';
+export declare function createDefaultViewport(): ResolvedViewport;
+export declare function createDefaultMetadata(): ResolvedMetadata;

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createDefaultMetadata: null,
+    createDefaultViewport: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createDefaultMetadata: function() {
+        return createDefaultMetadata;
+    },
+    createDefaultViewport: function() {
+        return createDefaultViewport;
+    }
+});
+function createDefaultViewport() {
+    return {
+        // name=viewport
+        width: "device-width",
+        initialScale: 1,
+        // visual metadata
+        themeColor: null,
+        colorScheme: null
+    };
+}
+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/lib/metadata/default-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/default-metadata.tsx"],"names":["createDefaultMetadata","createDefaultViewport","width","initialScale","themeColor","colorScheme","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":";;;;;;;;;;;;;;;IAgBgBA,qBAAqB;eAArBA;;IAXAC,qBAAqB;eAArBA;;;AAAT,SAASA;IACd,OAAO;QACL,gBAAgB;QAChBC,OAAO;QACPC,cAAc;QACd,kBAAkB;QAClBC,YAAY;QACZC,aAAa;IACf;AACF;AAEO,SAASL;IACd,OAAO;QACL,kBAAkB;QAClBM,UAAU;QACVF,YAAY;QACZC,aAAa;QAEbE,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/lib/metadata/generate/alternate.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedMetadata } from '../types/metadata-interface';
+export declare function AlternatesMetadata({ alternates, }: {
+    alternates: ResolvedMetadata['alternates'];
+}): NonNullable<import("react/jsx-runtime").JSX.Element | (import("react/jsx-runtime").JSX.Element | null | undefined)[]>[] | null;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AlternatesMetadata", {
+    enumerable: true,
+    get: function() {
+        return AlternatesMetadata;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _meta = require("./meta");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function AlternateLink({ descriptor, ...props }) {
+    if (!descriptor.url) return null;
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)("link", {
+        ...props,
+        ...descriptor.title && {
+            title: descriptor.title
+        },
+        href: descriptor.url.toString()
+    });
+}
+function AlternatesMetadata({ alternates }) {
+    if (!alternates) return null;
+    const { canonical, languages, media, types } = alternates;
+    return (0, _meta.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/lib/metadata/generate/alternate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/alternate.tsx"],"names":["AlternatesMetadata","AlternateLink","descriptor","props","url","link","title","href","toString","alternates","canonical","languages","media","types","MetaFilter","rel","Object","entries","flatMap","locale","descriptors","map","hrefLang","mediaName","type"],"mappings":";;;;+BAsBgBA;;;eAAAA;;;;8DAnBE;sBACS;;;;;;AAE3B,SAASC,cAAc,EACrBC,UAAU,EACV,GAAGC,OAGwC;IAC3C,IAAI,CAACD,WAAWE,GAAG,EAAE,OAAO;IAC5B,qBACE,qBAACC;QACE,GAAGF,KAAK;QACR,GAAID,WAAWI,KAAK,IAAI;YAAEA,OAAOJ,WAAWI,KAAK;QAAC,CAAC;QACpDC,MAAML,WAAWE,GAAG,CAACI,QAAQ;;AAGnC;AAEO,SAASR,mBAAmB,EACjCS,UAAU,EAGX;IACC,IAAI,CAACA,YAAY,OAAO;IAExB,MAAM,EAAEC,SAAS,EAAEC,SAAS,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGJ;IAE/C,OAAOK,IAAAA,gBAAU,EAAC;QAChBJ,YACIT,cAAc;YAAEc,KAAK;YAAab,YAAYQ;QAAU,KACxD;QACJC,YACIK,OAAOC,OAAO,CAACN,WAAWO,OAAO,CAAC,CAAC,CAACC,QAAQC,YAAY,GACtDA,+BAAAA,YAAaC,GAAG,CAAC,CAACnB,aAChBD,cAAc;oBAAEc,KAAK;oBAAaO,UAAUH;oBAAQjB;gBAAW,OAGnE;QACJU,QACII,OAAOC,OAAO,CAACL,OAAOM,OAAO,CAAC,CAAC,CAACK,WAAWH,YAAY,GACrDA,+BAAAA,YAAaC,GAAG,CAAC,CAACnB,aAChBD,cAAc;oBAAEc,KAAK;oBAAaH,OAAOW;oBAAWrB;gBAAW,OAGnE;QACJW,QACIG,OAAOC,OAAO,CAACJ,OAAOK,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/lib/metadata/generate/basic.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedMetadata, ResolvedViewport } from '../types/metadata-interface';
+import React from 'react';
+export declare function ViewportMeta({ viewport }: {
+    viewport: ResolvedViewport;
+}): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+export declare function BasicMeta({ metadata }: {
+    metadata: ResolvedMetadata;
+}): NonNullable<import("react/jsx-runtime").JSX.Element | (import("react/jsx-runtime").JSX.Element | null)[]>[];
+export declare function ItunesMeta({ itunes }: {
+    itunes: ResolvedMetadata['itunes'];
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function FacebookMeta({ facebook, }: {
+    facebook: ResolvedMetadata['facebook'];
+}): import("react/jsx-runtime").JSX.Element[] | null;
+export declare function FormatDetectionMeta({ formatDetection, }: {
+    formatDetection: ResolvedMetadata['formatDetection'];
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function AppleWebAppMeta({ appleWebApp, }: {
+    appleWebApp: ResolvedMetadata['appleWebApp'];
+}): NonNullable<React.ReactElement<any, string | React.JSXElementConstructor<any>> | import("react/jsx-runtime").JSX.Element[]>[] | null;
+export declare function VerificationMeta({ verification, }: {
+    verification: ResolvedMetadata['verification'];
+}): NonNullable<React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[]>[][] | null;

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

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

node_modules/next/dist/lib/metadata/generate/icons.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedMetadata } from '../types/metadata-interface';
+export declare function IconsMetadata({ icons }: {
+    icons: ResolvedMetadata['icons'];
+}): import("react/jsx-runtime").JSX.Element[][] | null;

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IconsMetadata", {
+    enumerable: true,
+    get: function() {
+        return IconsMetadata;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _meta = require("./meta");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function IconDescriptorLink({ icon }) {
+    const { url, rel = "icon", ...props } = icon;
+    return /*#__PURE__*/ (0, _jsxruntime.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__*/ (0, _jsxruntime.jsx)("link", {
+            rel: rel,
+            href: href
+        });
+    }
+}
+function IconsMetadata({ icons }) {
+    if (!icons) return null;
+    const shortcutList = icons.shortcut;
+    const iconList = icons.icon;
+    const appleList = icons.apple;
+    const otherList = icons.other;
+    return (0, _meta.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/lib/metadata/generate/icons.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/icons.tsx"],"names":["IconsMetadata","IconDescriptorLink","icon","url","rel","props","link","href","toString","IconLink","URL","icons","shortcutList","shortcut","iconList","appleList","apple","otherList","other","MetaFilter","map"],"mappings":";;;;+BAsBgBA;;;eAAAA;;;;8DAnBE;sBACS;;;;;;AAE3B,SAASC,mBAAmB,EAAEC,IAAI,EAA4B;IAC5D,MAAM,EAAEC,GAAG,EAAEC,MAAM,MAAM,EAAE,GAAGC,OAAO,GAAGH;IAExC,qBAAO,qBAACI;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,qBAACF;YAAKF,KAAKA;YAAKG,MAAMA;;IAC/B;AACF;AAEO,SAASP,cAAc,EAAEW,KAAK,EAAwC;IAC3E,IAAI,CAACA,OAAO,OAAO;IAEnB,MAAMC,eAAeD,MAAME,QAAQ;IACnC,MAAMC,WAAWH,MAAMT,IAAI;IAC3B,MAAMa,YAAYJ,MAAMK,KAAK;IAC7B,MAAMC,YAAYN,MAAMO,KAAK;IAE7B,OAAOC,IAAAA,gBAAU,EAAC;QAChBP,eACIA,aAAaQ,GAAG,CAAC,CAAClB,OAASO,SAAS;gBAAEL,KAAK;gBAAiBF;YAAK,MACjE;QACJY,WAAWA,SAASM,GAAG,CAAC,CAAClB,OAASO,SAAS;gBAAEL,KAAK;gBAAQF;YAAK,MAAM;QACrEa,YACIA,UAAUK,GAAG,CAAC,CAAClB,OAASO,SAAS;gBAAEL,KAAK;gBAAoBF;YAAK,MACjE;QACJe,YAAYA,UAAUG,GAAG,CAAC,CAAClB,OAASD,mBAAmB;gBAAEC;YAAK,MAAM;KACrE;AACH"}

node_modules/next/dist/lib/metadata/generate/meta.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+export declare function Meta({ name, property, content, media, }: {
+    name?: string;
+    property?: string;
+    media?: string;
+    content: string | number | URL | null | undefined;
+}): React.ReactElement | null;
+export declare function MetaFilter<T extends {} | {}[]>(items: (T | null)[]): NonNullable<T>[];
+type ExtendMetaContent = Record<string, undefined | string | URL | number | boolean | null | undefined>;
+type MultiMetaContent = (ExtendMetaContent | string | URL | number)[] | null | undefined;
+export declare function MultiMeta({ propertyPrefix, namePrefix, contents, }: {
+    propertyPrefix?: string;
+    namePrefix?: string;
+    contents?: MultiMetaContent | null;
+}): NonNullable<React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[]>[] | null;
+export {};

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

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    Meta: null,
+    MetaFilter: null,
+    MultiMeta: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Meta: function() {
+        return Meta;
+    },
+    MetaFilter: function() {
+        return MetaFilter;
+    },
+    MultiMeta: function() {
+        return MultiMeta;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _nonnullable = require("../../non-nullable");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function Meta({ name, property, content, media }) {
+    if (typeof content !== "undefined" && content !== null && content !== "") {
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+            ...name ? {
+                name
+            } : {
+                property
+            },
+            ...media ? {
+                media
+            } : undefined,
+            content: typeof content === "string" ? content : content.toString()
+        });
+    }
+    return null;
+}
+function MetaFilter(items) {
+    const acc = [];
+    for (const item of items){
+        if (Array.isArray(item)) {
+            acc.push(...item.filter(_nonnullable.nonNullable));
+        } else if ((0, _nonnullable.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()
+        });
+    }));
+}
+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/lib/metadata/generate/meta.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/meta.tsx"],"names":["Meta","MetaFilter","MultiMeta","name","property","content","media","meta","undefined","toString","items","acc","item","Array","isArray","push","filter","nonNullable","camelToSnake","camelCaseStr","replace","match","toLowerCase","aliasPropPrefixes","Set","getMetaKey","prefix","key","has","startsWith","ExtendMeta","namePrefix","propertyPrefix","Object","entries","map","k","v","contents","URL"],"mappings":";;;;;;;;;;;;;;;;IAGgBA,IAAI;eAAJA;;IAuBAC,UAAU;eAAVA;;IAuEAC,SAAS;eAATA;;;;8DAjGE;6BACU;;;;;;AAErB,SAASF,KAAK,EACnBG,IAAI,EACJC,QAAQ,EACRC,OAAO,EACPC,KAAK,EAMN;IACC,IAAI,OAAOD,YAAY,eAAeA,YAAY,QAAQA,YAAY,IAAI;QACxE,qBACE,qBAACE;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;AAEO,SAASR,WACdS,KAAmB;IAEnB,MAAMC,MAAwB,EAAE;IAChC,KAAK,MAAMC,QAAQF,MAAO;QACxB,IAAIG,MAAMC,OAAO,CAACF,OAAO;YACvBD,IAAII,IAAI,IAAIH,KAAKI,MAAM,CAACC,wBAAW;QACrC,OAAO,IAAIA,IAAAA,wBAAW,EAACL,OAAO;YAC5BD,IAAII,IAAI,CAACH;QACX;IACF;IACA,OAAOD;AACT;AAWA,SAASO,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,OAAOJ,WACLgC,OAAOC,OAAO,CAAC7B,SAAS8B,GAAG,CAAC,CAAC,CAACC,GAAGC,EAAE;QACjC,OAAO,OAAOA,MAAM,cAChB,OACArC,KAAK;YACH,GAAIgC,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;AAEO,SAASP,UAAU,EACxB8B,cAAc,EACdD,UAAU,EACVO,QAAQ,EAKT;IACC,IAAI,OAAOA,aAAa,eAAeA,aAAa,MAAM;QACxD,OAAO;IACT;IAEA,OAAOrC,WACLqC,SAASH,GAAG,CAAC,CAAC9B;QACZ,IACE,OAAOA,YAAY,YACnB,OAAOA,YAAY,YACnBA,mBAAmBkC,KACnB;YACA,OAAOvC,KAAK;gBACV,GAAIgC,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/lib/metadata/generate/opengraph.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { ResolvedMetadata } from '../types/metadata-interface';
+export declare function OpenGraphMetadata({ openGraph, }: {
+    openGraph: ResolvedMetadata['openGraph'];
+}): NonNullable<import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | NonNullable<import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>[]>[]>[] | null;
+export declare function TwitterMetadata({ twitter, }: {
+    twitter: ResolvedMetadata['twitter'];
+}): NonNullable<import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | (import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | null)[] | NonNullable<import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>[]>[]>[] | null;
+export declare function AppLinksMeta({ appLinks, }: {
+    appLinks: ResolvedMetadata['appLinks'];
+}): NonNullable<import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>[]>[][] | null;

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

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

node_modules/next/dist/lib/metadata/generate/utils.d.ts

@@ -0,0 +1,3 @@
+declare function resolveArray<T>(value: T | T[]): T[];
+declare function resolveAsArrayOrUndefined<T>(value: T | T[] | undefined | null): T extends undefined | null ? undefined : T[];
+export { resolveAsArrayOrUndefined, resolveArray };

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    resolveArray: null,
+    resolveAsArrayOrUndefined: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    resolveArray: function() {
+        return resolveArray;
+    },
+    resolveAsArrayOrUndefined: function() {
+        return resolveAsArrayOrUndefined;
+    }
+});
+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);
+}
+
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/utils.ts"],"names":["resolveArray","resolveAsArrayOrUndefined","value","Array","isArray","undefined"],"mappings":";;;;;;;;;;;;;;;IAgBoCA,YAAY;eAAZA;;IAA3BC,yBAAyB;eAAzBA;;;AAhBT,SAASD,aAAgBE,KAAc;IACrC,IAAIC,MAAMC,OAAO,CAACF,QAAQ;QACxB,OAAOA;IACT;IACA,OAAO;QAACA;KAAM;AAChB;AAEA,SAASD,0BACPC,KAAiC;IAEjC,IAAI,OAAOA,UAAU,eAAeA,UAAU,MAAM;QAClD,OAAOG;IACT;IACA,OAAOL,aAAaE;AACtB"}

node_modules/next/dist/lib/metadata/get-metadata-route.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Fill the dynamic segment in the metadata route
+ *
+ * Example:
+ * fillMetadataSegment('/a/[slug]', { params: { slug: 'b' } }, 'open-graph') -> '/a/b/open-graph'
+ *
+ */
+export declare function fillMetadataSegment(segment: string, params: any, imageSegment: string): string;
+/**
+ * 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 declare function normalizeMetadataRoute(page: string): string;

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    fillMetadataSegment: null,
+    normalizeMetadataRoute: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    fillMetadataSegment: function() {
+        return fillMetadataSegment;
+    },
+    normalizeMetadataRoute: function() {
+        return normalizeMetadataRoute;
+    }
+});
+const _ismetadataroute = require("./is-metadata-route");
+const _path = /*#__PURE__*/ _interop_require_default(require("../../shared/lib/isomorphic/path"));
+const _serverutils = require("../../server/server-utils");
+const _routeregex = require("../../shared/lib/router/utils/route-regex");
+const _hash = require("../../shared/lib/hash");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _normalizepathsep = require("../../shared/lib/page-path/normalize-path-sep");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/*
+ * 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 = (0, _hash.djb2Hash)(page).toString(36).slice(0, 6);
+    }
+    return suffix;
+}
+function fillMetadataSegment(segment, params, imageSegment) {
+    const pathname = (0, _apppaths.normalizeAppPath)(segment);
+    const routeRegex = (0, _routeregex.getNamedRouteRegex)(pathname, false);
+    const route = (0, _serverutils.interpolateDynamicPath)(pathname, params, routeRegex);
+    const suffix = getMetadataRouteSuffix(segment);
+    const routeSuffix = suffix ? `-${suffix}` : "";
+    const { name, ext } = _path.default.parse(imageSegment);
+    return (0, _normalizepathsep.normalizePathSep)(_path.default.join(route, `${name}${routeSuffix}${ext}`));
+}
+function normalizeMetadataRoute(page) {
+    if (!(0, _ismetadataroute.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.default.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.default.parse(route);
+        const isStaticRoute = (0, _ismetadataroute.isStaticMetadataRoute)(page);
+        route = _path.default.posix.join(dir, `${baseName}${suffix ? `-${suffix}` : ""}${ext}`, isStaticRoute ? "" : "[[...__metadata_id__]]", "route");
+    }
+    return route;
+}
+
+//# sourceMappingURL=get-metadata-route.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/get-metadata-route.ts"],"names":["fillMetadataSegment","normalizeMetadataRoute","getMetadataRouteSuffix","page","suffix","includes","djb2Hash","toString","slice","segment","params","imageSegment","pathname","normalizeAppPath","routeRegex","getNamedRouteRegex","route","interpolateDynamicPath","routeSuffix","name","ext","path","parse","normalizePathSep","join","isMetadataRoute","endsWith","pathnamePrefix","basename","length","dir","baseName","isStaticRoute","isStaticMetadataRoute","posix"],"mappings":";;;;;;;;;;;;;;;IAgCgBA,mBAAmB;eAAnBA;;IAyBAC,sBAAsB;eAAtBA;;;iCAzDuC;6DACtC;6BACsB;4BACJ;sBACV;0BACQ;kCACA;;;;;;AAEjC;;;;;;;CAOC,GACD,SAASC,uBAAuBC,IAAY;IAC1C,IAAIC,SAAS;IAEb,IAAI,AAACD,KAAKE,QAAQ,CAAC,QAAQF,KAAKE,QAAQ,CAAC,QAASF,KAAKE,QAAQ,CAAC,MAAM;QACpED,SAASE,IAAAA,cAAQ,EAACH,MAAMI,QAAQ,CAAC,IAAIC,KAAK,CAAC,GAAG;IAChD;IACA,OAAOJ;AACT;AASO,SAASJ,oBACdS,OAAe,EACfC,MAAW,EACXC,YAAoB;IAEpB,MAAMC,WAAWC,IAAAA,0BAAgB,EAACJ;IAClC,MAAMK,aAAaC,IAAAA,8BAAkB,EAACH,UAAU;IAChD,MAAMI,QAAQC,IAAAA,mCAAsB,EAACL,UAAUF,QAAQI;IACvD,MAAMV,SAASF,uBAAuBO;IACtC,MAAMS,cAAcd,SAAS,CAAC,CAAC,EAAEA,OAAO,CAAC,GAAG;IAE5C,MAAM,EAAEe,IAAI,EAAEC,GAAG,EAAE,GAAGC,aAAI,CAACC,KAAK,CAACX;IAEjC,OAAOY,IAAAA,kCAAgB,EAACF,aAAI,CAACG,IAAI,CAACR,OAAO,CAAC,EAAEG,KAAK,EAAED,YAAY,EAAEE,IAAI,CAAC;AACxE;AAWO,SAASnB,uBAAuBE,IAAY;IACjD,IAAI,CAACsB,IAAAA,gCAAe,EAACtB,OAAO;QAC1B,OAAOA;IACT;IACA,IAAIa,QAAQb;IACZ,IAAIC,SAAS;IACb,IAAID,SAAS,WAAW;QACtBa,SAAS;IACX,OAAO,IAAIb,SAAS,aAAa;QAC/Ba,SAAS;IACX,OAAO,IAAIb,KAAKuB,QAAQ,CAAC,aAAa;QACpCV,SAAS;IACX,OAAO;QACL,wEAAwE;QACxE,MAAMW,iBAAiBxB,KAAKK,KAAK,CAAC,GAAG,CAAEa,CAAAA,aAAI,CAACO,QAAQ,CAACzB,MAAM0B,MAAM,GAAG,CAAA;QACpEzB,SAASF,uBAAuByB;IAClC;IACA,mFAAmF;IACnF,4EAA4E;IAC5E,IAAI,CAACX,MAAMU,QAAQ,CAAC,WAAW;QAC7B,MAAM,EAAEI,GAAG,EAAEX,MAAMY,QAAQ,EAAEX,GAAG,EAAE,GAAGC,aAAI,CAACC,KAAK,CAACN;QAChD,MAAMgB,gBAAgBC,IAAAA,sCAAqB,EAAC9B;QAE5Ca,QAAQK,aAAI,CAACa,KAAK,CAACV,IAAI,CACrBM,KACA,CAAC,EAAEC,SAAS,EAAE3B,SAAS,CAAC,CAAC,EAAEA,OAAO,CAAC,GAAG,GAAG,EAAEgB,IAAI,CAAC,EAChDY,gBAAgB,KAAK,0BACrB;IAEJ;IAEA,OAAOhB;AACT"}

node_modules/next/dist/lib/metadata/is-metadata-route.d.ts

@@ -0,0 +1,27 @@
+import type { PageExtensions } from '../../build/page-extensions-type';
+export declare const STATIC_METADATA_IMAGES: {
+    readonly icon: {
+        readonly filename: "icon";
+        readonly extensions: readonly ["ico", "jpg", "jpeg", "png", "svg"];
+    };
+    readonly apple: {
+        readonly filename: "apple-icon";
+        readonly extensions: readonly ["jpg", "jpeg", "png"];
+    };
+    readonly favicon: {
+        readonly filename: "favicon";
+        readonly extensions: readonly ["ico"];
+    };
+    readonly openGraph: {
+        readonly filename: "opengraph-image";
+        readonly extensions: readonly ["jpg", "jpeg", "png", "gif"];
+    };
+    readonly twitter: {
+        readonly filename: "twitter-image";
+        readonly extensions: readonly ["jpg", "jpeg", "png", "gif"];
+    };
+};
+export declare function isMetadataRouteFile(appDirRelativePath: string, pageExtensions: PageExtensions, withExtension: boolean): boolean;
+export declare function isStaticMetadataRouteFile(appDirRelativePath: string): boolean;
+export declare function isStaticMetadataRoute(page: string): boolean;
+export declare function isMetadataRoute(route: string): boolean;

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    STATIC_METADATA_IMAGES: null,
+    isMetadataRoute: null,
+    isMetadataRouteFile: null,
+    isStaticMetadataRoute: null,
+    isStaticMetadataRouteFile: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    STATIC_METADATA_IMAGES: function() {
+        return STATIC_METADATA_IMAGES;
+    },
+    isMetadataRoute: function() {
+        return isMetadataRoute;
+    },
+    isMetadataRouteFile: function() {
+        return isMetadataRouteFile;
+    },
+    isStaticMetadataRoute: function() {
+        return isStaticMetadataRoute;
+    },
+    isStaticMetadataRouteFile: function() {
+        return isStaticMetadataRouteFile;
+    }
+});
+const _normalizepathsep = require("../../shared/lib/page-path/normalize-path-sep");
+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("|")})`;
+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 = (0, _normalizepathsep.normalizePathSep)(appDirRelativePath);
+    return metadataRouteFilesRegex.some((r)=>r.test(normalizedAppDirRelativePath));
+}
+function isStaticMetadataRouteFile(appDirRelativePath) {
+    return isMetadataRouteFile(appDirRelativePath, [], true);
+}
+function isStaticMetadataRoute(page) {
+    return page === "/robots" || page === "/manifest" || isStaticMetadataRouteFile(page);
+}
+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/lib/metadata/is-metadata-route.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/is-metadata-route.ts"],"names":["STATIC_METADATA_IMAGES","isMetadataRoute","isMetadataRouteFile","isStaticMetadataRoute","isStaticMetadataRouteFile","icon","filename","extensions","apple","favicon","openGraph","twitter","defaultExtensions","getExtensionRegexString","join","appDirRelativePath","pageExtensions","withExtension","metadataRouteFilesRegex","RegExp","concat","normalizedAppDirRelativePath","normalizePathSep","some","r","test","page","route","replace","endsWith"],"mappings":"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"}

node_modules/next/dist/lib/metadata/metadata.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import type { ParsedUrlQuery } from 'querystring';
+import type { AppRenderContext, GetDynamicParamFromSegment } from '../../server/app-render/app-render';
+import type { LoaderTree } from '../../server/lib/app-dir-module';
+import React from 'react';
+import type { MetadataContext } from './types/resolvers';
+export declare function createMetadataContext(urlPathname: string, renderOpts: AppRenderContext['renderOpts']): MetadataContext;
+export declare function createMetadataComponents({ tree, query, metadataContext, getDynamicParamFromSegment, appUsingSizeAdjustment, errorType, createDynamicallyTrackedSearchParams, }: {
+    tree: LoaderTree;
+    query: ParsedUrlQuery;
+    metadataContext: MetadataContext;
+    getDynamicParamFromSegment: GetDynamicParamFromSegment;
+    appUsingSizeAdjustment: boolean;
+    errorType?: 'not-found' | 'redirect';
+    createDynamicallyTrackedSearchParams: (searchParams: ParsedUrlQuery) => ParsedUrlQuery;
+}): [React.ComponentType, React.ComponentType];

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createMetadataComponents: null,
+    createMetadataContext: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createMetadataComponents: function() {
+        return createMetadataComponents;
+    },
+    createMetadataContext: function() {
+        return createMetadataContext;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _basic = require("./generate/basic");
+const _alternate = require("./generate/alternate");
+const _opengraph = require("./generate/opengraph");
+const _icons = require("./generate/icons");
+const _resolvemetadata = require("./resolve-metadata");
+const _meta = require("./generate/meta");
+const _defaultmetadata = require("./default-metadata");
+const _notfound = require("../../client/components/not-found");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function createMetadataContext(urlPathname, renderOpts) {
+    return {
+        pathname: urlPathname.split("?")[0],
+        trailingSlash: renderOpts.trailingSlash,
+        isStandaloneMode: renderOpts.nextConfigOutput === "standalone"
+    };
+}
+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 = (0, _defaultmetadata.createDefaultMetadata)();
+        const defaultViewport = (0, _defaultmetadata.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 (0, _resolvemetadata.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 && (0, _notfound.isNotFoundError)(resolvedError)) {
+                const [notFoundMetadataError, notFoundMetadata, notFoundViewport] = await (0, _resolvemetadata.resolveMetadata)({
+                    tree,
+                    parentParams: {},
+                    metadataItems: [],
+                    errorMetadataItem,
+                    searchParams,
+                    getDynamicParamFromSegment,
+                    errorConvention: "not-found",
+                    metadataContext
+                });
+                viewport = notFoundViewport;
+                metadata = notFoundMetadata;
+                error = notFoundMetadataError || error;
+            }
+            resolve(error);
+        }
+        const elements = (0, _meta.MetaFilter)([
+            (0, _basic.ViewportMeta)({
+                viewport: viewport
+            }),
+            (0, _basic.BasicMeta)({
+                metadata
+            }),
+            (0, _alternate.AlternatesMetadata)({
+                alternates: metadata.alternates
+            }),
+            (0, _basic.ItunesMeta)({
+                itunes: metadata.itunes
+            }),
+            (0, _basic.FacebookMeta)({
+                facebook: metadata.facebook
+            }),
+            (0, _basic.FormatDetectionMeta)({
+                formatDetection: metadata.formatDetection
+            }),
+            (0, _basic.VerificationMeta)({
+                verification: metadata.verification
+            }),
+            (0, _basic.AppleWebAppMeta)({
+                appleWebApp: metadata.appleWebApp
+            }),
+            (0, _opengraph.OpenGraphMetadata)({
+                openGraph: metadata.openGraph
+            }),
+            (0, _opengraph.TwitterMetadata)({
+                twitter: metadata.twitter
+            }),
+            (0, _opengraph.AppLinksMeta)({
+                appLinks: metadata.appLinks
+            }),
+            (0, _icons.IconsMetadata)({
+                icons: metadata.icons
+            })
+        ]);
+        if (appUsingSizeAdjustment) elements.push(/*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+            name: "next-size-adjust"
+        }));
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
+            children: elements.map((el, index)=>{
+                return /*#__PURE__*/ _react.default.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/lib/metadata/metadata.js.map

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

node_modules/next/dist/lib/metadata/resolve-metadata.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import type { Metadata, ResolvedMetadata, ResolvedViewport, ResolvingMetadata, ResolvingViewport, Viewport } from './types/metadata-interface';
+import type { GetDynamicParamFromSegment } from '../../server/app-render/app-render';
+import type { MetadataContext } from './types/resolvers';
+import type { LoaderTree } from '../../server/lib/app-dir-module';
+import type { ParsedUrlQuery } from 'querystring';
+import type { StaticMetadata } from './types/icons';
+type MetadataResolver = (parent: ResolvingMetadata) => Metadata | Promise<Metadata>;
+type ViewportResolver = (parent: ResolvingViewport) => Viewport | Promise<Viewport>;
+export type MetadataItems = [
+    Metadata | MetadataResolver | null,
+    StaticMetadata,
+    Viewport | ViewportResolver | null
+][];
+export declare function collectMetadata({ tree, metadataItems, errorMetadataItem, props, route, errorConvention, }: {
+    tree: LoaderTree;
+    metadataItems: MetadataItems;
+    errorMetadataItem: MetadataItems[number];
+    props: any;
+    route: string;
+    errorConvention?: 'not-found';
+}): Promise<void>;
+export declare function resolveMetadataItems({ tree, parentParams, metadataItems, errorMetadataItem, treePrefix, getDynamicParamFromSegment, searchParams, errorConvention, }: {
+    tree: LoaderTree;
+    parentParams: {
+        [key: string]: any;
+    };
+    metadataItems: MetadataItems;
+    errorMetadataItem: MetadataItems[number];
+    /** Provided tree can be nested subtree, this argument says what is the path of such subtree */
+    treePrefix?: string[];
+    getDynamicParamFromSegment: GetDynamicParamFromSegment;
+    searchParams: ParsedUrlQuery;
+    errorConvention: 'not-found' | undefined;
+}): Promise<MetadataItems>;
+export declare function accumulateMetadata(metadataItems: MetadataItems, metadataContext: MetadataContext): Promise<ResolvedMetadata>;
+export declare function accumulateViewport(metadataItems: MetadataItems): Promise<ResolvedViewport>;
+export declare function resolveMetadata({ tree, parentParams, metadataItems, errorMetadataItem, getDynamicParamFromSegment, searchParams, errorConvention, metadataContext, }: {
+    tree: LoaderTree;
+    parentParams: {
+        [key: string]: any;
+    };
+    metadataItems: MetadataItems;
+    errorMetadataItem: MetadataItems[number];
+    /** Provided tree can be nested subtree, this argument says what is the path of such subtree */
+    treePrefix?: string[];
+    getDynamicParamFromSegment: GetDynamicParamFromSegment;
+    searchParams: {
+        [key: string]: any;
+    };
+    errorConvention: 'not-found' | undefined;
+    metadataContext: MetadataContext;
+}): Promise<[any, ResolvedMetadata, ResolvedViewport]>;
+export {};

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

@@ -0,0 +1,638 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    accumulateMetadata: null,
+    accumulateViewport: null,
+    collectMetadata: null,
+    resolveMetadata: null,
+    resolveMetadataItems: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    accumulateMetadata: function() {
+        return accumulateMetadata;
+    },
+    accumulateViewport: function() {
+        return accumulateViewport;
+    },
+    collectMetadata: function() {
+        return collectMetadata;
+    },
+    resolveMetadata: function() {
+        return resolveMetadata;
+    },
+    resolveMetadataItems: function() {
+        return resolveMetadataItems;
+    }
+});
+const _defaultmetadata = require("./default-metadata");
+const _resolveopengraph = require("./resolvers/resolve-opengraph");
+const _resolvetitle = require("./resolvers/resolve-title");
+const _utils = require("./generate/utils");
+const _clientreference = require("../client-reference");
+const _appdirmodule = require("../../server/lib/app-dir-module");
+const _interopdefault = require("../interop-default");
+const _resolvebasics = require("./resolvers/resolve-basics");
+const _resolveicons = require("./resolvers/resolve-icons");
+const _tracer = require("../../server/lib/trace/tracer");
+const _constants = require("../../server/lib/trace/constants");
+const _segment = require("../../shared/lib/segment");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function isFavicon(icon) {
+    if (!icon) {
+        return false;
+    }
+    // turbopack appends a hash to all images
+    return (icon.url === "/favicon.ico" || icon.url.toString().startsWith("/favicon.ico?")) && icon.type === "image/x-icon";
+}
+function mergeStaticMetadata(source, target, staticFilesMetadata, metadataContext, titleTemplates, leafSegmentStaticIcons) {
+    var _source_twitter, _source_openGraph;
+    if (!staticFilesMetadata) return;
+    const { icon, apple, openGraph, twitter, manifest } = staticFilesMetadata;
+    // Keep updating the static icons in the most leaf node
+    if (icon) {
+        leafSegmentStaticIcons.icon = icon;
+    }
+    if (apple) {
+        leafSegmentStaticIcons.apple = apple;
+    }
+    // file based metadata is specified and current level metadata twitter.images is not specified
+    if (twitter && !(source == null ? void 0 : (_source_twitter = source.twitter) == null ? void 0 : _source_twitter.hasOwnProperty("images"))) {
+        const resolvedTwitter = (0, _resolveopengraph.resolveTwitter)({
+            ...target.twitter,
+            images: twitter
+        }, target.metadataBase, metadataContext, titleTemplates.twitter);
+        target.twitter = resolvedTwitter;
+    }
+    // file based metadata is specified and current level metadata openGraph.images is not specified
+    if (openGraph && !(source == null ? void 0 : (_source_openGraph = source.openGraph) == null ? void 0 : _source_openGraph.hasOwnProperty("images"))) {
+        const resolvedOpenGraph = (0, _resolveopengraph.resolveOpenGraph)({
+            ...target.openGraph,
+            images: openGraph
+        }, target.metadataBase, metadataContext, titleTemplates.openGraph);
+        target.openGraph = resolvedOpenGraph;
+    }
+    if (manifest) {
+        target.manifest = manifest;
+    }
+    return target;
+}
+// Merge the source metadata into the resolved target metadata.
+function mergeMetadata({ source, target, staticFilesMetadata, titleTemplates, metadataContext, buildState, leafSegmentStaticIcons }) {
+    // If there's override metadata, prefer it otherwise fallback to the default metadata.
+    const metadataBase = typeof (source == null ? void 0 : source.metadataBase) !== "undefined" ? source.metadataBase : target.metadataBase;
+    for(const key_ in source){
+        const key = key_;
+        switch(key){
+            case "title":
+                {
+                    target.title = (0, _resolvetitle.resolveTitle)(source.title, titleTemplates.title);
+                    break;
+                }
+            case "alternates":
+                {
+                    target.alternates = (0, _resolvebasics.resolveAlternates)(source.alternates, metadataBase, metadataContext);
+                    break;
+                }
+            case "openGraph":
+                {
+                    target.openGraph = (0, _resolveopengraph.resolveOpenGraph)(source.openGraph, metadataBase, metadataContext, titleTemplates.openGraph);
+                    break;
+                }
+            case "twitter":
+                {
+                    target.twitter = (0, _resolveopengraph.resolveTwitter)(source.twitter, metadataBase, metadataContext, titleTemplates.twitter);
+                    break;
+                }
+            case "facebook":
+                target.facebook = (0, _resolvebasics.resolveFacebook)(source.facebook);
+                break;
+            case "verification":
+                target.verification = (0, _resolvebasics.resolveVerification)(source.verification);
+                break;
+            case "icons":
+                {
+                    target.icons = (0, _resolveicons.resolveIcons)(source.icons);
+                    break;
+                }
+            case "appleWebApp":
+                target.appleWebApp = (0, _resolvebasics.resolveAppleWebApp)(source.appleWebApp);
+                break;
+            case "appLinks":
+                target.appLinks = (0, _resolvebasics.resolveAppLinks)(source.appLinks);
+                break;
+            case "robots":
+                {
+                    target.robots = (0, _resolvebasics.resolveRobots)(source.robots);
+                    break;
+                }
+            case "archives":
+            case "assets":
+            case "bookmarks":
+            case "keywords":
+                {
+                    target[key] = (0, _utils.resolveAsArrayOrUndefined)(source[key]);
+                    break;
+                }
+            case "authors":
+                {
+                    target[key] = (0, _utils.resolveAsArrayOrUndefined)(source.authors);
+                    break;
+                }
+            case "itunes":
+                {
+                    target[key] = (0, _resolvebasics.resolveItunes)(source.itunes, metadataBase, metadataContext);
+                    break;
+                }
+            // 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 = (0, _resolvebasics.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 ((0, _clientreference.isClientReference)(mod)) {
+        return null;
+    }
+    if (typeof mod.generateViewport === "function") {
+        const { route } = tracingProps;
+        return (parent)=>(0, _tracer.getTracer)().trace(_constants.ResolveMetadataSpan.generateViewport, {
+                spanName: `generateViewport ${route}`,
+                attributes: {
+                    "next.page": route
+                }
+            }, ()=>mod.generateViewport(props, parent));
+    }
+    return mod.viewport || null;
+}
+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 ((0, _clientreference.isClientReference)(mod)) {
+        return null;
+    }
+    if (typeof mod.generateMetadata === "function") {
+        const { route } = tracingProps;
+        return (parent)=>(0, _tracer.getTracer)().trace(_constants.ResolveMetadataSpan.generateMetadata, {
+                spanName: `generateMetadata ${route}`,
+                attributes: {
+                    "next.page": route
+                }
+            }, ()=>mod.generateMetadata(props, parent));
+    }
+    return mod.metadata || null;
+}
+async function collectStaticImagesFiles(metadata, props, type) {
+    var _this;
+    if (!(metadata == null ? void 0 : metadata[type])) return undefined;
+    const iconPromises = metadata[type].map(async (imageModule)=>(0, _interopdefault.interopDefault)(await imageModule(props)));
+    return (iconPromises == null ? void 0 : iconPromises.length) > 0 ? (_this = await Promise.all(iconPromises)) == null ? void 0 : _this.flat() : undefined;
+}
+async function resolveStaticMetadata(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;
+}
+async function collectMetadata({ tree, metadataItems, errorMetadataItem, props, route, errorConvention }) {
+    let mod;
+    let modType;
+    const hasErrorConventionComponent = Boolean(errorConvention && tree[2][errorConvention]);
+    if (errorConvention) {
+        mod = await (0, _appdirmodule.getComponentTypeModule)(tree, "layout");
+        modType = errorConvention;
+    } else {
+        [mod, modType] = await (0, _appdirmodule.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 (0, _appdirmodule.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;
+    }
+}
+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 !== _segment.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 = (0, _resolveopengraph.resolveTwitter)(autoFillProps, metadata.metadataBase, metadataContext, titleTemplates.twitter);
+            if (metadata.twitter) {
+                metadata.twitter = Object.assign({}, metadata.twitter, {
+                    ...!hasTwTitle && {
+                        title: partialTwitter == null ? void 0 : partialTwitter.title
+                    },
+                    ...!hasTwDescription && {
+                        description: partialTwitter == null ? void 0 : partialTwitter.description
+                    },
+                    ...!hasTwImages && {
+                        images: partialTwitter == null ? void 0 : partialTwitter.images
+                    }
+                });
+            } else {
+                metadata.twitter = partialTwitter;
+            }
+        }
+    }
+    // If there's no title and description configured in openGraph or twitter,
+    // use the title and description from metadata.
+    inheritFromMetadata(openGraph, metadata);
+    inheritFromMetadata(twitter, metadata);
+    if (favicon) {
+        if (!metadata.icons) {
+            metadata.icons = {
+                icon: [],
+                apple: []
+            };
+        }
+        metadata.icons.icon.unshift(favicon);
+    }
+    return metadata;
+}
+function 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;
+}
+async function accumulateMetadata(metadataItems, metadataContext) {
+    const resolvedMetadata = (0, _defaultmetadata.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);
+}
+async function accumulateViewport(metadataItems) {
+    const resolvedViewport = (0, _defaultmetadata.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;
+}
+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 = (0, _defaultmetadata.createDefaultMetadata)();
+    let viewport = (0, _defaultmetadata.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/lib/metadata/resolve-metadata.test.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/next/dist/lib/metadata/resolvers/resolve-basics.d.ts

@@ -0,0 +1,16 @@
+import type { ResolvedMetadata, Viewport } from '../types/metadata-interface';
+import type { FieldResolver, FieldResolverExtraArgs, MetadataContext } from '../types/resolvers';
+export declare const resolveThemeColor: FieldResolver<'themeColor', Viewport>;
+export declare const resolveAlternates: FieldResolverExtraArgs<'alternates', [
+    ResolvedMetadata['metadataBase'],
+    MetadataContext
+]>;
+export declare const resolveRobots: FieldResolver<'robots'>;
+export declare const resolveVerification: FieldResolver<'verification'>;
+export declare const resolveAppleWebApp: FieldResolver<'appleWebApp'>;
+export declare const resolveAppLinks: FieldResolver<'appLinks'>;
+export declare const resolveItunes: FieldResolverExtraArgs<'itunes', [
+    ResolvedMetadata['metadataBase'],
+    MetadataContext
+]>;
+export declare const resolveFacebook: FieldResolver<'facebook'>;

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

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    resolveAlternates: null,
+    resolveAppLinks: null,
+    resolveAppleWebApp: null,
+    resolveFacebook: null,
+    resolveItunes: null,
+    resolveRobots: null,
+    resolveThemeColor: null,
+    resolveVerification: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    resolveAlternates: function() {
+        return resolveAlternates;
+    },
+    resolveAppLinks: function() {
+        return resolveAppLinks;
+    },
+    resolveAppleWebApp: function() {
+        return resolveAppleWebApp;
+    },
+    resolveFacebook: function() {
+        return resolveFacebook;
+    },
+    resolveItunes: function() {
+        return resolveItunes;
+    },
+    resolveRobots: function() {
+        return resolveRobots;
+    },
+    resolveThemeColor: function() {
+        return resolveThemeColor;
+    },
+    resolveVerification: function() {
+        return resolveVerification;
+    }
+});
+const _utils = require("../generate/utils");
+const _resolveurl = require("./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 (0, _resolveurl.resolveAbsoluteUrlWithPathname)(url, metadataBase, metadataContext);
+}
+const resolveThemeColor = (themeColor)=>{
+    var _resolveAsArrayOrUndefined;
+    if (!themeColor) return null;
+    const themeColorDescriptors = [];
+    (_resolveAsArrayOrUndefined = (0, _utils.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)
+    };
+}
+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(", ");
+};
+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"
+];
+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 = (0, _utils.resolveAsArrayOrUndefined)(verification.other[otherKey]);
+                    if (otherValue) res.other[otherKey] = otherValue;
+                }
+            } else res[key] = (0, _utils.resolveAsArrayOrUndefined)(value);
+        }
+    }
+    return res;
+};
+const resolveAppleWebApp = (appWebApp)=>{
+    var _resolveAsArrayOrUndefined;
+    if (!appWebApp) return null;
+    if (appWebApp === true) {
+        return {
+            capable: true
+        };
+    }
+    const startupImages = appWebApp.startupImage ? (_resolveAsArrayOrUndefined = (0, _utils.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"
+    };
+};
+const resolveAppLinks = (appLinks)=>{
+    if (!appLinks) return null;
+    for(const key in appLinks){
+        // @ts-ignore // TODO: type infer
+        appLinks[key] = (0, _utils.resolveAsArrayOrUndefined)(appLinks[key]);
+    }
+    return appLinks;
+};
+const resolveItunes = (itunes, metadataBase, context)=>{
+    if (!itunes) return null;
+    return {
+        appId: itunes.appId,
+        appArgument: itunes.appArgument ? resolveAlternateUrl(itunes.appArgument, metadataBase, context) : undefined
+    };
+};
+const resolveFacebook = (facebook)=>{
+    if (!facebook) return null;
+    return {
+        appId: facebook.appId,
+        admins: (0, _utils.resolveAsArrayOrUndefined)(facebook.admins)
+    };
+};
+
+//# sourceMappingURL=resolve-basics.js.map

node_modules/next/dist/lib/metadata/resolvers/resolve-icons.d.ts

@@ -0,0 +1,4 @@
+import type { Icon, IconDescriptor } from '../types/metadata-types';
+import type { FieldResolver } from '../types/resolvers';
+export declare function resolveIcon(icon: Icon): IconDescriptor;
+export declare const resolveIcons: FieldResolver<'icons'>;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    resolveIcon: null,
+    resolveIcons: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    resolveIcon: function() {
+        return resolveIcon;
+    },
+    resolveIcons: function() {
+        return resolveIcons;
+    }
+});
+const _utils = require("../generate/utils");
+const _resolveurl = require("./resolve-url");
+const _constants = require("../constants");
+function resolveIcon(icon) {
+    if ((0, _resolveurl.isStringOrURL)(icon)) return {
+        url: icon
+    };
+    else if (Array.isArray(icon)) return icon;
+    return icon;
+}
+const resolveIcons = (icons)=>{
+    if (!icons) {
+        return null;
+    }
+    const resolved = {
+        icon: [],
+        apple: []
+    };
+    if (Array.isArray(icons)) {
+        resolved.icon = icons.map(resolveIcon).filter(Boolean);
+    } else if ((0, _resolveurl.isStringOrURL)(icons)) {
+        resolved.icon = [
+            resolveIcon(icons)
+        ];
+    } else {
+        for (const key of _constants.IconKeys){
+            const values = (0, _utils.resolveAsArrayOrUndefined)(icons[key]);
+            if (values) resolved[key] = values.map(resolveIcon);
+        }
+    }
+    return resolved;
+};
+
+//# sourceMappingURL=resolve-icons.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/resolvers/resolve-icons.ts"],"names":["resolveIcon","resolveIcons","icon","isStringOrURL","url","Array","isArray","icons","resolved","apple","map","filter","Boolean","key","IconKeys","values","resolveAsArrayOrUndefined"],"mappings":";;;;;;;;;;;;;;;IAOgBA,WAAW;eAAXA;;IAMHC,YAAY;eAAZA;;;uBAV6B;4BACZ;2BACL;AAElB,SAASD,YAAYE,IAAU;IACpC,IAAIC,IAAAA,yBAAa,EAACD,OAAO,OAAO;QAAEE,KAAKF;IAAK;SACvC,IAAIG,MAAMC,OAAO,CAACJ,OAAO,OAAOA;IACrC,OAAOA;AACT;AAEO,MAAMD,eAAuC,CAACM;IACnD,IAAI,CAACA,OAAO;QACV,OAAO;IACT;IAEA,MAAMC,WAAsC;QAC1CN,MAAM,EAAE;QACRO,OAAO,EAAE;IACX;IACA,IAAIJ,MAAMC,OAAO,CAACC,QAAQ;QACxBC,SAASN,IAAI,GAAGK,MAAMG,GAAG,CAACV,aAAaW,MAAM,CAACC;IAChD,OAAO,IAAIT,IAAAA,yBAAa,EAACI,QAAQ;QAC/BC,SAASN,IAAI,GAAG;YAACF,YAAYO;SAAO;IACtC,OAAO;QACL,KAAK,MAAMM,OAAOC,mBAAQ,CAAE;YAC1B,MAAMC,SAASC,IAAAA,gCAAyB,EAACT,KAAK,CAACM,IAAI;YACnD,IAAIE,QAAQP,QAAQ,CAACK,IAAI,GAAGE,OAAOL,GAAG,CAACV;QACzC;IACF;IACA,OAAOQ;AACT"}

node_modules/next/dist/lib/metadata/resolvers/resolve-opengraph.d.ts

@@ -0,0 +1,18 @@
+import type { ResolvedMetadata } from '../types/metadata-interface';
+import type { OpenGraph } from '../types/opengraph-types';
+import type { FieldResolverExtraArgs, MetadataContext } from '../types/resolvers';
+import type { Twitter } from '../types/twitter-types';
+type ResolvedMetadataBase = ResolvedMetadata['metadataBase'];
+export declare function resolveImages(images: Twitter['images'], metadataBase: ResolvedMetadataBase, isStandaloneMode: boolean): NonNullable<ResolvedMetadata['twitter']>['images'];
+export declare function resolveImages(images: OpenGraph['images'], metadataBase: ResolvedMetadataBase, isStandaloneMode: boolean): NonNullable<ResolvedMetadata['openGraph']>['images'];
+export declare const resolveOpenGraph: FieldResolverExtraArgs<'openGraph', [
+    ResolvedMetadataBase,
+    MetadataContext,
+    string | null
+]>;
+export declare const resolveTwitter: FieldResolverExtraArgs<'twitter', [
+    ResolvedMetadataBase,
+    MetadataContext,
+    string | null
+]>;
+export {};

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

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    resolveImages: null,
+    resolveOpenGraph: null,
+    resolveTwitter: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    resolveImages: function() {
+        return resolveImages;
+    },
+    resolveOpenGraph: function() {
+        return resolveOpenGraph;
+    },
+    resolveTwitter: function() {
+        return resolveTwitter;
+    }
+});
+const _utils = require("../generate/utils");
+const _resolveurl = require("./resolve-url");
+const _resolvetitle = require("./resolve-title");
+const _url = require("../../url");
+const _log = require("../../../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 = (0, _resolveurl.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: (0, _resolveurl.resolveUrl)(inputUrl, metadataBase)
+    } : {
+        ...item,
+        // Update image descriptor url
+        url: (0, _resolveurl.resolveUrl)(inputUrl, metadataBase)
+    };
+}
+function resolveImages(images, metadataBase, isStandaloneMode) {
+    const resolvedImages = (0, _utils.resolveAsArrayOrUndefined)(images);
+    if (!resolvedImages) return resolvedImages;
+    const { isMetadataBaseMissing, fallbackMetadataBase } = (0, _resolveurl.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" && !(0, _url.isFullStringUrl)(inputUrl) && isMetadataBaseMissing) {
+        (0, _log.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`);
+    }
+}
+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 = (0, _utils.resolveAsArrayOrUndefined)(value);
+                    target[key] = arrayValue;
+                }
+            }
+        }
+        target.images = resolveImages(og.images, metadataBase, metadataContext.isStandaloneMode);
+    }
+    const resolved = {
+        ...openGraph,
+        title: (0, _resolvetitle.resolveTitle)(openGraph.title, titleTemplate)
+    };
+    resolveProps(resolved, openGraph);
+    resolved.url = openGraph.url ? (0, _resolveurl.resolveAbsoluteUrlWithPathname)(openGraph.url, metadataBase, metadataContext) : null;
+    return resolved;
+};
+const TwitterBasicInfoKeys = [
+    "site",
+    "siteId",
+    "creator",
+    "creatorId",
+    "description"
+];
+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: (0, _resolvetitle.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 = (0, _utils.resolveAsArrayOrUndefined)(resolved.players) || [];
+                    break;
+                }
+            case "app":
+                {
+                    resolved.app = resolved.app || {};
+                    break;
+                }
+            default:
+                break;
+        }
+    }
+    return resolved;
+};
+
+//# sourceMappingURL=resolve-opengraph.js.map

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

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

node_modules/next/dist/lib/metadata/resolvers/resolve-opengraph.test.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/next/dist/lib/metadata/resolvers/resolve-title.d.ts

@@ -0,0 +1,3 @@
+import type { Metadata } from '../types/metadata-interface';
+import type { AbsoluteTemplateString } from '../types/metadata-types';
+export declare function resolveTitle(title: Metadata['title'], stashedTemplate: string | null | undefined): AbsoluteTemplateString;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveTitle", {
+    enumerable: true,
+    get: function() {
+        return resolveTitle;
+    }
+});
+function resolveTitleTemplate(template, title) {
+    return template ? template.replace(/%s/g, title) : title;
+}
+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/lib/metadata/resolvers/resolve-title.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/resolvers/resolve-title.ts"],"names":["resolveTitle","resolveTitleTemplate","template","title","replace","stashedTemplate","resolved","default","absolute"],"mappings":";;;;+BAUgBA;;;eAAAA;;;AAPhB,SAASC,qBACPC,QAAmC,EACnCC,KAAa;IAEb,OAAOD,WAAWA,SAASE,OAAO,CAAC,OAAOD,SAASA;AACrD;AAEO,SAASH,aACdG,KAAwB,EACxBE,eAA0C;IAE1C,IAAIC;IACJ,MAAMJ,WACJ,OAAOC,UAAU,YAAYA,SAAS,cAAcA,QAChDA,MAAMD,QAAQ,GACd;IAEN,IAAI,OAAOC,UAAU,UAAU;QAC7BG,WAAWL,qBAAqBI,iBAAiBF;IACnD,OAAO,IAAIA,OAAO;QAChB,IAAI,aAAaA,OAAO;YACtBG,WAAWL,qBAAqBI,iBAAiBF,MAAMI,OAAO;QAChE;QACA,IAAI,cAAcJ,SAASA,MAAMK,QAAQ,EAAE;YACzCF,WAAWH,MAAMK,QAAQ;QAC3B;IACF;IAEA,IAAIL,SAAS,OAAOA,UAAU,UAAU;QACtC,OAAO;YACLD;YACAM,UAAUF,YAAY;QACxB;IACF,OAAO;QACL,OAAO;YAAEE,UAAUF,YAAYH,SAAS;YAAID;QAAS;IACvD;AACF"}

node_modules/next/dist/lib/metadata/resolvers/resolve-title.test.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/next/dist/lib/metadata/resolvers/resolve-url.d.ts

@@ -0,0 +1,12 @@
+import type { MetadataContext } from '../types/resolvers';
+declare function isStringOrURL(icon: any): icon is string | URL;
+export declare function getSocialImageFallbackMetadataBase(metadataBase: URL | null): {
+    fallbackMetadataBase: URL;
+    isMetadataBaseMissing: boolean;
+};
+declare function resolveUrl(url: null | undefined, metadataBase: URL | null): null;
+declare function resolveUrl(url: string | URL, metadataBase: URL | null): URL;
+declare function resolveUrl(url: string | URL | null | undefined, metadataBase: URL | null): URL | null;
+declare function resolveRelativeUrl(url: string | URL, pathname: string): string | URL;
+declare function resolveAbsoluteUrlWithPathname(url: string | URL, metadataBase: URL | null, { trailingSlash, pathname }: MetadataContext): string;
+export { isStringOrURL, resolveUrl, resolveRelativeUrl, resolveAbsoluteUrlWithPathname, };

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getSocialImageFallbackMetadataBase: null,
+    isStringOrURL: null,
+    resolveAbsoluteUrlWithPathname: null,
+    resolveRelativeUrl: null,
+    resolveUrl: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getSocialImageFallbackMetadataBase: function() {
+        return getSocialImageFallbackMetadataBase;
+    },
+    isStringOrURL: function() {
+        return isStringOrURL;
+    },
+    resolveAbsoluteUrlWithPathname: function() {
+        return resolveAbsoluteUrlWithPathname;
+    },
+    resolveRelativeUrl: function() {
+        return resolveRelativeUrl;
+    },
+    resolveUrl: function() {
+        return resolveUrl;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("../../../shared/lib/isomorphic/path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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;
+}
+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.default.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.default.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;
+}
+
+//# sourceMappingURL=resolve-url.js.map

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

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

node_modules/next/dist/lib/metadata/resolvers/resolve-url.test.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/next/dist/lib/metadata/types/alternative-urls-types.d.ts

@@ -0,0 +1,31 @@
+type LangCode = 'aa' | 'ab' | 'ae' | 'af' | 'ak' | 'am' | 'an' | 'ar' | 'as' | 'av' | 'ay' | 'az' | 'ba' | 'be' | 'bg' | 'bh' | 'bi' | 'bm' | 'bn' | 'bo' | 'br' | 'bs' | 'ca' | 'ce' | 'ch' | 'co' | 'cr' | 'cs' | 'cu' | 'cv' | 'cy' | 'da' | 'de' | 'dv' | 'dz' | 'ee' | 'el' | 'en' | 'eo' | 'es' | 'et' | 'eu' | 'fa' | 'ff' | 'fi' | 'fj' | 'fo' | 'fr' | 'fy' | 'ga' | 'gd' | 'gl' | 'gn' | 'gu' | 'gv' | 'ha' | 'he' | 'hi' | 'ho' | 'hr' | 'ht' | 'hu' | 'hy' | 'hz' | 'ia' | 'id' | 'ie' | 'ig' | 'ii' | 'ik' | 'io' | 'is' | 'it' | 'iu' | 'ja' | 'jv' | 'ka' | 'kg' | 'ki' | 'kj' | 'kk' | 'kl' | 'km' | 'kn' | 'ko' | 'kr' | 'ks' | 'ku' | 'kv' | 'kw' | 'ky' | 'la' | 'lb' | 'lg' | 'li' | 'ln' | 'lo' | 'lt' | 'lu' | 'lv' | 'mg' | 'mh' | 'mi' | 'mk' | 'ml' | 'mn' | 'mr' | 'ms' | 'mt' | 'my' | 'na' | 'nb' | 'nd' | 'ne' | 'ng' | 'nl' | 'nn' | 'no' | 'nr' | 'nv' | 'ny' | 'oc' | 'oj' | 'om' | 'or' | 'os' | 'pa' | 'pi' | 'pl' | 'ps' | 'pt' | 'qu' | 'rm' | 'rn' | 'ro' | 'ru' | 'rw' | 'sa' | 'sc' | 'sd' | 'se' | 'sg' | 'si' | 'sk' | 'sl' | 'sm' | 'sn' | 'so' | 'sq' | 'sr' | 'ss' | 'st' | 'su' | 'sv' | 'sw' | 'ta' | 'te' | 'tg' | 'th' | 'ti' | 'tk' | 'tl' | 'tn' | 'to' | 'tr' | 'ts' | 'tt' | 'tw' | 'ty' | 'ug' | 'uk' | 'ur' | 'uz' | 've' | 'vi' | 'vo' | 'wa' | 'wo' | 'xh' | 'yi' | 'yo' | 'za' | 'zh' | 'zu' | 'af-ZA' | 'am-ET' | 'ar-AE' | 'ar-BH' | 'ar-DZ' | 'ar-EG' | 'ar-IQ' | 'ar-JO' | 'ar-KW' | 'ar-LB' | 'ar-LY' | 'ar-MA' | 'arn-CL' | 'ar-OM' | 'ar-QA' | 'ar-SA' | 'ar-SD' | 'ar-SY' | 'ar-TN' | 'ar-YE' | 'as-IN' | 'az-az' | 'az-Cyrl-AZ' | 'az-Latn-AZ' | 'ba-RU' | 'be-BY' | 'bg-BG' | 'bn-BD' | 'bn-IN' | 'bo-CN' | 'br-FR' | 'bs-Cyrl-BA' | 'bs-Latn-BA' | 'ca-ES' | 'co-FR' | 'cs-CZ' | 'cy-GB' | 'da-DK' | 'de-AT' | 'de-CH' | 'de-DE' | 'de-LI' | 'de-LU' | 'dsb-DE' | 'dv-MV' | 'el-CY' | 'el-GR' | 'en-029' | 'en-AU' | 'en-BZ' | 'en-CA' | 'en-cb' | 'en-GB' | 'en-IE' | 'en-IN' | 'en-JM' | 'en-MT' | 'en-MY' | 'en-NZ' | 'en-PH' | 'en-SG' | 'en-TT' | 'en-US' | 'en-ZA' | 'en-ZW' | 'es-AR' | 'es-BO' | 'es-CL' | 'es-CO' | 'es-CR' | 'es-DO' | 'es-EC' | 'es-ES' | 'es-GT' | 'es-HN' | 'es-MX' | 'es-NI' | 'es-PA' | 'es-PE' | 'es-PR' | 'es-PY' | 'es-SV' | 'es-US' | 'es-UY' | 'es-VE' | 'et-EE' | 'eu-ES' | 'fa-IR' | 'fi-FI' | 'fil-PH' | 'fo-FO' | 'fr-BE' | 'fr-CA' | 'fr-CH' | 'fr-FR' | 'fr-LU' | 'fr-MC' | 'fy-NL' | 'ga-IE' | 'gd-GB' | 'gd-ie' | 'gl-ES' | 'gsw-FR' | 'gu-IN' | 'ha-Latn-NG' | 'he-IL' | 'hi-IN' | 'hr-BA' | 'hr-HR' | 'hsb-DE' | 'hu-HU' | 'hy-AM' | 'id-ID' | 'ig-NG' | 'ii-CN' | 'in-ID' | 'is-IS' | 'it-CH' | 'it-IT' | 'iu-Cans-CA' | 'iu-Latn-CA' | 'iw-IL' | 'ja-JP' | 'ka-GE' | 'kk-KZ' | 'kl-GL' | 'km-KH' | 'kn-IN' | 'kok-IN' | 'ko-KR' | 'ky-KG' | 'lb-LU' | 'lo-LA' | 'lt-LT' | 'lv-LV' | 'mi-NZ' | 'mk-MK' | 'ml-IN' | 'mn-MN' | 'mn-Mong-CN' | 'moh-CA' | 'mr-IN' | 'ms-BN' | 'ms-MY' | 'mt-MT' | 'nb-NO' | 'ne-NP' | 'nl-BE' | 'nl-NL' | 'nn-NO' | 'no-no' | 'nso-ZA' | 'oc-FR' | 'or-IN' | 'pa-IN' | 'pl-PL' | 'prs-AF' | 'ps-AF' | 'pt-BR' | 'pt-PT' | 'qut-GT' | 'quz-BO' | 'quz-EC' | 'quz-PE' | 'rm-CH' | 'ro-mo' | 'ro-RO' | 'ru-mo' | 'ru-RU' | 'rw-RW' | 'sah-RU' | 'sa-IN' | 'se-FI' | 'se-NO' | 'se-SE' | 'si-LK' | 'sk-SK' | 'sl-SI' | 'sma-NO' | 'sma-SE' | 'smj-NO' | 'smj-SE' | 'smn-FI' | 'sms-FI' | 'sq-AL' | 'sr-BA' | 'sr-CS' | 'sr-Cyrl-BA' | 'sr-Cyrl-CS' | 'sr-Cyrl-ME' | 'sr-Cyrl-RS' | 'sr-Latn-BA' | 'sr-Latn-CS' | 'sr-Latn-ME' | 'sr-Latn-RS' | 'sr-ME' | 'sr-RS' | 'sr-sp' | 'sv-FI' | 'sv-SE' | 'sw-KE' | 'syr-SY' | 'ta-IN' | 'te-IN' | 'tg-Cyrl-TJ' | 'th-TH' | 'tk-TM' | 'tlh-QS' | 'tn-ZA' | 'tr-TR' | 'tt-RU' | 'tzm-Latn-DZ' | 'ug-CN' | 'uk-UA' | 'ur-PK' | 'uz-Cyrl-UZ' | 'uz-Latn-UZ' | 'uz-uz' | 'vi-VN' | 'wo-SN' | 'xh-ZA' | 'yo-NG' | 'zh-CN' | 'zh-HK' | 'zh-MO' | 'zh-SG' | 'zh-TW' | 'zh-Hans' | 'zh-Hant' | 'zu-ZA' | `${Lowercase<string>}-${string}`;
+type UnmatchedLang = 'x-default';
+type HrefLang = LangCode | UnmatchedLang;
+export type Languages<T> = {
+    [s in HrefLang]?: T;
+};
+export type AlternateLinkDescriptor = {
+    title?: string;
+    url: string | URL;
+};
+export type AlternateURLs = {
+    canonical?: null | string | URL | AlternateLinkDescriptor;
+    languages?: Languages<null | string | URL | AlternateLinkDescriptor[]>;
+    media?: {
+        [media: string]: null | string | URL | AlternateLinkDescriptor[];
+    };
+    types?: {
+        [types: string]: null | string | URL | AlternateLinkDescriptor[];
+    };
+};
+export type ResolvedAlternateURLs = {
+    canonical: null | AlternateLinkDescriptor;
+    languages: null | Languages<AlternateLinkDescriptor[]>;
+    media: null | {
+        [media: string]: null | AlternateLinkDescriptor[];
+    };
+    types: null | {
+        [types: string]: null | AlternateLinkDescriptor[];
+    };
+};
+export {};

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

@@ -0,0 +1,7 @@
+// Reference: https://hreflang.org/what-is-a-valid-hreflang
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=alternative-urls-types.js.map

node_modules/next/dist/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"}

node_modules/next/dist/lib/metadata/types/extra-types.d.ts

@@ -0,0 +1,91 @@
+export type AppLinks = {
+    ios?: AppLinksApple | Array<AppLinksApple>;
+    iphone?: AppLinksApple | Array<AppLinksApple>;
+    ipad?: AppLinksApple | Array<AppLinksApple>;
+    android?: AppLinksAndroid | Array<AppLinksAndroid>;
+    windows_phone?: AppLinksWindows | Array<AppLinksWindows>;
+    windows?: AppLinksWindows | Array<AppLinksWindows>;
+    windows_universal?: AppLinksWindows | Array<AppLinksWindows>;
+    web?: AppLinksWeb | Array<AppLinksWeb>;
+};
+export type ResolvedAppLinks = {
+    ios?: Array<AppLinksApple>;
+    iphone?: Array<AppLinksApple>;
+    ipad?: Array<AppLinksApple>;
+    android?: Array<AppLinksAndroid>;
+    windows_phone?: Array<AppLinksWindows>;
+    windows?: Array<AppLinksWindows>;
+    windows_universal?: Array<AppLinksWindows>;
+    web?: Array<AppLinksWeb>;
+};
+export type AppLinksApple = {
+    url: string | URL;
+    app_store_id?: string | number;
+    app_name?: string;
+};
+export type AppLinksAndroid = {
+    package: string;
+    url?: string | URL;
+    class?: string;
+    app_name?: string;
+};
+export type AppLinksWindows = {
+    url: string | URL;
+    app_id?: string;
+    app_name?: string;
+};
+export type AppLinksWeb = {
+    url: string | URL;
+    should_fallback?: boolean;
+};
+export type ItunesApp = {
+    appId: string;
+    appArgument?: string;
+};
+export type ViewportLayout = {
+    width?: string | number;
+    height?: string | number;
+    initialScale?: number;
+    minimumScale?: number;
+    maximumScale?: number;
+    userScalable?: boolean;
+    viewportFit?: 'auto' | 'cover' | 'contain';
+    interactiveWidget?: 'resizes-visual' | 'resizes-content' | 'overlays-content';
+};
+export type AppleWebApp = {
+    capable?: boolean;
+    title?: string;
+    startupImage?: AppleImage | Array<AppleImage>;
+    statusBarStyle?: 'default' | 'black' | 'black-translucent';
+};
+export type AppleImage = string | AppleImageDescriptor;
+export type AppleImageDescriptor = {
+    url: string;
+    media?: string;
+};
+export type ResolvedAppleWebApp = {
+    capable: boolean;
+    title?: string | null;
+    startupImage?: AppleImageDescriptor[] | null;
+    statusBarStyle?: 'default' | 'black' | 'black-translucent';
+};
+export type Facebook = FacebookAppId | FacebookAdmins;
+export type FacebookAppId = {
+    appId: string;
+    admins?: never;
+};
+export type FacebookAdmins = {
+    appId?: never;
+    admins: string | string[];
+};
+export type ResolvedFacebook = {
+    appId?: string;
+    admins?: string[];
+};
+export type FormatDetection = {
+    telephone?: boolean;
+    date?: boolean;
+    address?: boolean;
+    email?: boolean;
+    url?: boolean;
+};

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

@@ -0,0 +1,9 @@
+// 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
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=extra-types.js.map

node_modules/next/dist/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"}

node_modules/next/dist/lib/metadata/types/icons.d.ts

@@ -0,0 +1,7 @@
+export type StaticMetadata = {
+    icon: any[] | undefined;
+    apple: any[] | undefined;
+    openGraph: any[] | undefined;
+    twitter: any[] | undefined;
+    manifest: string | undefined;
+} | null;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=icons.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

node_modules/next/dist/lib/metadata/types/manifest-types.d.ts

@@ -0,0 +1,83 @@
+export type Manifest = {
+    background_color?: string;
+    categories?: string[];
+    description?: string;
+    dir?: 'ltr' | 'rtl' | 'auto';
+    display?: 'fullscreen' | 'standalone' | 'minimal-ui' | 'browser';
+    display_override?: ('fullscreen' | 'standalone' | 'minimal-ui' | 'browser' | 'window-controls-overlay')[];
+    file_handlers?: {
+        action: string;
+        accept: {
+            [mimeType: string]: string[];
+        }[];
+    }[];
+    icons?: {
+        src: string;
+        type?: string;
+        sizes?: string;
+        purpose?: 'any' | 'maskable' | 'monochrome' | 'badge';
+    }[];
+    id?: string;
+    lang?: string;
+    launch_handler?: {
+        platform?: 'windows' | 'macos' | 'linux';
+        url?: string;
+    };
+    name?: string;
+    orientation?: 'any' | 'natural' | 'landscape' | 'portrait' | 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';
+    prefer_related_applications?: boolean;
+    protocol_handlers?: {
+        protocol: string;
+        url: string;
+        title?: string;
+    }[];
+    related_applications?: {
+        platform: string;
+        url: string;
+        id?: string;
+    }[];
+    scope?: string;
+    screenshots?: {
+        src: string;
+        type?: string;
+        sizes?: string;
+    }[];
+    serviceworker?: {
+        src?: string;
+        scope?: string;
+        type?: string;
+        update_via_cache?: 'import' | 'none' | 'all';
+    };
+    share_target?: {
+        action?: string;
+        method?: 'get' | 'post';
+        enctype?: 'application/x-www-form-urlencoded' | 'multipart/form-data' | 'text/plain';
+        params?: {
+            name: string;
+            value: string;
+            required?: boolean;
+        }[];
+        url?: string;
+        title?: string;
+        text?: string;
+        files?: {
+            accept?: string[];
+            name?: string;
+        }[];
+    };
+    short_name?: string;
+    shortcuts?: {
+        name: string;
+        short_name?: string;
+        description?: string;
+        url: string;
+        icons?: {
+            src: string;
+            type?: string;
+            sizes?: string;
+            purpose?: 'any' | 'maskable' | 'monochrome' | 'badge';
+        }[];
+    }[];
+    start_url?: string;
+    theme_color?: string;
+};

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=manifest-types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

node_modules/next/dist/lib/metadata/types/metadata-interface.d.ts

@@ -0,0 +1,524 @@
+import type { AlternateURLs, Languages, ResolvedAlternateURLs } from './alternative-urls-types';
+import type { AppleWebApp, AppLinks, Facebook, FormatDetection, ItunesApp, ResolvedAppleWebApp, ResolvedAppLinks, ResolvedFacebook, ViewportLayout } from './extra-types';
+import type { DeprecatedMetadataFields, AbsoluteTemplateString, Author, ColorSchemeEnum, Icon, Icons, IconURL, ReferrerEnum, ResolvedIcons, ResolvedVerification, Robots, ResolvedRobots, TemplateString, Verification, ThemeColorDescriptor } from './metadata-types';
+import type { Manifest as ManifestFile } from './manifest-types';
+import type { OpenGraph, ResolvedOpenGraph } from './opengraph-types';
+import type { ResolvedTwitterMetadata, Twitter } from './twitter-types';
+/**
+ * Metadata interface to describe all the metadata fields that can be set in a document.
+ * @interface
+ */
+interface Metadata extends DeprecatedMetadataFields {
+    /**
+     * The base path and origin for absolute urls for various metadata links such as OpenGraph images.
+     */
+    metadataBase?: null | URL;
+    /**
+     * The document title.
+     * @example
+     * ```tsx
+     * "My Blog"
+     * <title>My Blog</title>
+     *
+     * { default: "Dashboard", template: "%s | My Website" }
+     * <title>Dashboard | My Website</title>
+     *
+     * { absolute: "My Blog", template: "%s | My Website" }
+     * <title>My Blog</title>
+     * ```
+     */
+    title?: null | string | TemplateString;
+    /**
+     * The document description, and optionally the OpenGraph and twitter descriptions.
+     * @example
+     * ```tsx
+     * "My Blog Description"
+     * <meta name="description" content="My Blog Description" />
+     * ```
+     */
+    description?: null | string;
+    /**
+     * The application name.
+     * @example
+     * ```tsx
+     * "My Blog"
+     * <meta name="application-name" content="My Blog" />
+     * ```
+     */
+    applicationName?: null | string;
+    /**
+     * The authors of the document.
+     * @example
+     * ```tsx
+     * [{ name: "Next.js Team", url: "https://nextjs.org" }]
+     *
+     * <meta name="author" content="Next.js Team" />
+     * <link rel="author" href="https://nextjs.org" />
+     * ```
+     */
+    authors?: null | Author | Array<Author>;
+    /**
+     * The generator used for the document.
+     * @example
+     * ```tsx
+     * "Next.js"
+     *
+     * <meta name="generator" content="Next.js" />
+     * ```
+     */
+    generator?: null | string;
+    /**
+     * The keywords for the document. If an array is provided, it will be flattened into a single tag with comma separation.
+     * @example
+     * ```tsx
+     * "nextjs, react, blog"
+     * <meta name="keywords" content="nextjs, react, blog" />
+     *
+     * ["react", "server components"]
+     * <meta name="keywords" content="react, server components" />
+     * ```
+     */
+    keywords?: null | string | Array<string>;
+    /**
+     * The referrer setting for the document.
+     * @example
+     * ```tsx
+     * "origin"
+     * <meta name="referrer" content="origin" />
+     * ```
+     */
+    referrer?: null | ReferrerEnum;
+    /**
+     * The theme color for the document.
+     * @example
+     * @deprecated
+     *
+     * ```tsx
+     * "#000000"
+     * <meta name="theme-color" content="#000000" />
+     *
+     * { media: "(prefers-color-scheme: dark)", color: "#000000" }
+     * <meta name="theme-color" media="(prefers-color-scheme: dark)" content="#000000" />
+     *
+     * [
+     *  { media: "(prefers-color-scheme: dark)", color: "#000000" },
+     *  { media: "(prefers-color-scheme: light)", color: "#ffffff" }
+     * ]
+     * <meta name="theme-color" media="(prefers-color-scheme: dark)" content="#000000" />
+     * <meta name="theme-color" media="(prefers-color-scheme: light)" content="#ffffff" />
+     * ```
+     */
+    themeColor?: null | string | ThemeColorDescriptor | ThemeColorDescriptor[];
+    /**
+     * The color scheme for the document.
+     * @example
+     * @deprecated
+     *
+     * ```tsx
+     * "dark"
+     * <meta name="color-scheme" content="dark" />
+     * ```
+     */
+    colorScheme?: null | ColorSchemeEnum;
+    /**
+     * The viewport setting for the document.
+     * @example
+     * @deprecated
+     *
+     * ```tsx
+     *
+     * { width: "device-width", initialScale: 1 }
+     * <meta name="viewport" content="width=device-width, initial-scale=1" />
+     * ```
+     */
+    viewport?: null | string | ViewportLayout;
+    /**
+     * The creator of the document.
+     * @example
+     * ```tsx
+     * "Next.js Team"
+     * <meta name="creator" content="Next.js Team" />
+     * ```
+     */
+    creator?: null | string;
+    /**
+     * The publisher of the document.
+     * @example
+     *
+     * ```tsx
+     * "Vercel"
+     * <meta name="publisher" content="Vercel" />
+     * ```
+     */
+    publisher?: null | string;
+    /**
+     * The robots setting for the document.
+     *
+     * @see https://developer.mozilla.org/docs/Glossary/Robots.txt
+     * @example
+     * ```tsx
+     * "index, follow"
+     * <meta name="robots" content="index, follow" />
+     *
+     * { index: false, follow: false }
+     * <meta name="robots" content="noindex, nofollow" />
+     * ```
+     */
+    robots?: null | string | Robots;
+    /**
+     * The canonical and alternate URLs for the document.
+     * @example
+     * ```tsx
+     * { canonical: "https://example.com" }
+     * <link rel="canonical" href="https://example.com" />
+     *
+     * { canonical: "https://example.com", hreflang: { "en-US": "https://example.com/en-US" } }
+     * <link rel="canonical" href="https://example.com" />
+     * <link rel="alternate" href="https://example.com/en-US" hreflang="en-US" />
+     * ```
+     *
+     * Multiple titles example for alternate URLs except `canonical`:
+     * ```tsx
+     * {
+     *   canonical: "https://example.com",
+     *   types: {
+     *     'application/rss+xml': [
+     *       { url: 'blog.rss', title: 'rss' },
+     *       { url: 'blog/js.rss', title: 'js title' },
+     *     ],
+     *   },
+     * }
+     * <link rel="canonical" href="https://example.com" />
+     * <link rel="alternate" href="https://example.com/blog.rss" type="application/rss+xml" title="rss" />
+     * <link rel="alternate" href="https://example.com/blog/js.rss" type="application/rss+xml" title="js title" />
+     * ```
+     */
+    alternates?: null | AlternateURLs;
+    /**
+     * The icons for the document. Defaults to rel="icon".
+     *
+     * @see https://developer.mozilla.org/docs/Web/HTML/Attributes/rel#attr-icon
+     * @example
+     * ```tsx
+     * "https://example.com/icon.png"
+     * <link rel="icon" href="https://example.com/icon.png" />
+     *
+     * { icon: "https://example.com/icon.png", apple: "https://example.com/apple-icon.png" }
+     * <link rel="icon" href="https://example.com/icon.png" />
+     * <link rel="apple-touch-icon" href="https://example.com/apple-icon.png" />
+     *
+     * [{ rel: "icon", url: "https://example.com/icon.png" }, { rel: "apple-touch-icon", url: "https://example.com/apple-icon.png" }]
+     * <link rel="icon" href="https://example.com/icon.png" />
+     * <link rel="apple-touch-icon" href="https://example.com/apple-icon.png" />
+     * ```
+     */
+    icons?: null | IconURL | Array<Icon> | Icons;
+    /**
+     * A web application manifest, as defined in the Web Application Manifest specification.
+     *
+     * @see https://developer.mozilla.org/docs/Web/Manifest
+     * @example
+     * ```tsx
+     * "https://example.com/manifest.json"
+     * <link rel="manifest" href="https://example.com/manifest.json" />
+     * ```
+     *
+     */
+    manifest?: null | string | URL;
+    /**
+     * The Open Graph metadata for the document.
+     *
+     * @see https://ogp.me
+     * @example
+     * ```tsx
+     * {
+     *   type: "website",
+     *   url: "https://example.com",
+     *   title: "My Website",
+     *   description: "My Website Description",
+     *   siteName: "My Website",
+     *   images: [{
+     *     url: "https://example.com/og.png",
+     *   }],
+     * }
+     *
+     * <meta property="og:type" content="website" />
+     * <meta property="og:url" content="https://example.com" />
+     * <meta property="og:site_name" content="My Website" />
+     * <meta property="og:title" content="My Website" />
+     * <meta property="og:description" content="My Website Description" />
+     * <meta property="og:image" content="https://example.com/og.png" />
+     * ```
+     */
+    openGraph?: null | OpenGraph;
+    /**
+     * The Twitter metadata for the document.
+     * @example
+     * ```tsx
+     * { card: "summary_large_image", site: "@site", creator: "@creator", "images": "https://example.com/og.png" }
+     *
+     * <meta name="twitter:card" content="summary_large_image" />
+     * <meta name="twitter:site" content="@site" />
+     * <meta name="twitter:creator" content="@creator" />
+     * <meta name="twitter:title" content="My Website" />
+     * <meta name="twitter:description" content="My Website Description" />
+     * <meta name="twitter:image" content="https://example.com/og.png" />
+     * ```
+     *
+     */
+    twitter?: null | Twitter;
+    /**
+     * The Facebook metadata for the document.
+     * You can specify either appId or admins, but not both.
+     * @example
+     * ```tsx
+     * { appId: "12345678" }
+     *
+     * <meta property="fb:app_id" content="12345678" />
+     * ```
+     *
+     * @example
+     * ```tsx
+     * { admins: ["12345678"] }
+     *
+     * <meta property="fb:admins" content="12345678" />
+     * ```
+     */
+    facebook?: null | Facebook;
+    /**
+     * The common verification tokens for the document.
+     * @example
+     * ```tsx
+     * { verification: { google: "1234567890", yandex: "1234567890", "me": "1234567890" } }
+     * <meta name="google-site-verification" content="1234567890" />
+     * <meta name="yandex-verification" content="1234567890" />
+     * <meta name="me" content="@me" />
+     * ```
+     */
+    verification?: Verification;
+    /**
+     * The Apple web app metadata for the document.
+     *
+     * @see https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariHTMLRef/Articles/MetaTags.html
+     * @example
+     * ```tsx
+     * { capable: true, title: "My Website", statusBarStyle: "black-translucent" }
+     * <meta name="apple-mobile-web-app-capable" content="yes" />
+     * <meta name="apple-mobile-web-app-title" content="My Website" />
+     * <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+     * ```
+     *
+     */
+    appleWebApp?: null | boolean | AppleWebApp;
+    /**
+     * Indicates if devices should try to interpret various formats and make actionable links out of them. For example it controles
+     * if telephone numbers on mobile that can be clicked to dial or not.
+     * @example
+     * ```tsx
+     * { telephone: false }
+     * <meta name="format-detection" content="telephone=no" />
+     * ```
+     *
+     */
+    formatDetection?: null | FormatDetection;
+    /**
+     * The metadata for the iTunes App.
+     * It adds the `name="apple-itunes-app"` meta tag.
+     *
+     * @example
+     * ```tsx
+     * { app: { id: "123456789", affiliateData: "123456789", appArguments: "123456789" } }
+     * <meta name="apple-itunes-app" content="app-id=123456789, affiliate-data=123456789, app-arguments=123456789" />
+     * ```
+     */
+    itunes?: null | ItunesApp;
+    /**
+     * A brief description of what this web-page is about. Not recommended, superseded by description.
+     * It adds the `name="abstract"` meta tag.
+     *
+     * @see https://www.metatags.org/all-meta-tags-overview/meta-name-abstract/
+     * @example
+     * ```tsx
+     * "My Website Description"
+     * <meta name="abstract" content="My Website Description" />
+     * ```
+     */
+    abstract?: null | string;
+    /**
+     * The Facebook AppLinks metadata for the document.
+     * @example
+     * ```tsx
+     * { ios: { appStoreId: "123456789", url: "https://example.com" }, android: { packageName: "com.example", url: "https://example.com" } }
+     *
+     * <meta property="al:ios:app_store_id" content="123456789" />
+     * <meta property="al:ios:url" content="https://example.com" />
+     * <meta property="al:android:package" content="com.example" />
+     * <meta property="al:android:url" content="https://example.com" />
+     * ```
+     */
+    appLinks?: null | AppLinks;
+    /**
+     * The archives link rel property.
+     * @example
+     * ```tsx
+     * { archives: "https://example.com/archives" }
+     * <link rel="archives" href="https://example.com/archives" />
+     * ```
+     */
+    archives?: null | string | Array<string>;
+    /**
+     * The assets link rel property.
+     * @example
+     * ```tsx
+     * "https://example.com/assets"
+     * <link rel="assets" href="https://example.com/assets" />
+     * ```
+     */
+    assets?: null | string | Array<string>;
+    /**
+     * The bookmarks link rel property.
+     * @example
+     * ```tsx
+     * "https://example.com/bookmarks"
+     * <link rel="bookmarks" href="https://example.com/bookmarks" />
+     * ```
+     */
+    bookmarks?: null | string | Array<string>;
+    /**
+     * The category meta name property.
+     * @example
+     * ```tsx
+     * "My Category"
+     * <meta name="category" content="My Category" />
+     * ```
+     */
+    category?: null | string;
+    /**
+     * The classification meta name property.
+     * @example
+     * ```tsx
+     * "My Classification"
+     * <meta name="classification" content="My Classification" />
+     * ```
+     */
+    classification?: null | string;
+    /**
+     * Arbitrary name/value pairs for the document.
+     */
+    other?: {
+        [name: string]: string | number | Array<string | number>;
+    } & DeprecatedMetadataFields;
+}
+interface ResolvedMetadata extends DeprecatedMetadataFields {
+    metadataBase: null | URL;
+    title: null | AbsoluteTemplateString;
+    description: null | string;
+    applicationName: null | string;
+    authors: null | Array<Author>;
+    generator: null | string;
+    keywords: null | Array<string>;
+    referrer: null | ReferrerEnum;
+    /**
+     * @deprecated
+     */
+    themeColor: null | ThemeColorDescriptor[];
+    /**
+     * @deprecated
+     */
+    colorScheme: null | ColorSchemeEnum;
+    /**
+     * @deprecated
+     */
+    viewport: null | string;
+    creator: null | string;
+    publisher: null | string;
+    robots: null | ResolvedRobots;
+    alternates: null | ResolvedAlternateURLs;
+    icons: null | ResolvedIcons;
+    openGraph: null | ResolvedOpenGraph;
+    manifest: null | string | URL;
+    twitter: null | ResolvedTwitterMetadata;
+    facebook: null | ResolvedFacebook;
+    verification: null | ResolvedVerification;
+    appleWebApp: null | ResolvedAppleWebApp;
+    formatDetection: null | FormatDetection;
+    itunes: null | ItunesApp;
+    abstract: null | string;
+    appLinks: null | ResolvedAppLinks;
+    archives: null | Array<string>;
+    assets: null | Array<string>;
+    bookmarks: null | Array<string>;
+    category: null | string;
+    classification: null | string;
+    other: null | ({
+        [name: string]: string | number | Array<string | number>;
+    } & DeprecatedMetadataFields);
+}
+type RobotsFile = {
+    rules: {
+        userAgent?: string | string[];
+        allow?: string | string[];
+        disallow?: string | string[];
+        crawlDelay?: number;
+    } | Array<{
+        userAgent: string | string[];
+        allow?: string | string[];
+        disallow?: string | string[];
+        crawlDelay?: number;
+    }>;
+    sitemap?: string | string[];
+    host?: string;
+};
+type SitemapFile = Array<{
+    url: string;
+    lastModified?: string | Date;
+    changeFrequency?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+    priority?: number;
+    alternates?: {
+        languages?: Languages<string>;
+    };
+}>;
+type ResolvingMetadata = Promise<ResolvedMetadata>;
+declare namespace MetadataRoute {
+    type Robots = RobotsFile;
+    type Sitemap = SitemapFile;
+    type Manifest = ManifestFile;
+}
+interface Viewport extends ViewportLayout {
+    /**
+     * The theme color for the document.
+     * @example
+     *
+     * ```tsx
+     * "#000000"
+     * <meta name="theme-color" content="#000000" />
+     *
+     * { media: "(prefers-color-scheme: dark)", color: "#000000" }
+     * <meta name="theme-color" media="(prefers-color-scheme: dark)" content="#000000" />
+     *
+     * [
+     *  { media: "(prefers-color-scheme: dark)", color: "#000000" },
+     *  { media: "(prefers-color-scheme: light)", color: "#ffffff" }
+     * ]
+     * <meta name="theme-color" media="(prefers-color-scheme: dark)" content="#000000" />
+     * <meta name="theme-color" media="(prefers-color-scheme: light)" content="#ffffff" />
+     * ```
+     */
+    themeColor?: null | string | ThemeColorDescriptor | ThemeColorDescriptor[];
+    /**
+     * The color scheme for the document.
+     * @example
+     *
+     * ```tsx
+     * "dark"
+     * <meta name="color-scheme" content="dark" />
+     * ```
+     */
+    colorScheme?: null | ColorSchemeEnum;
+}
+type ResolvingViewport = Promise<Viewport>;
+interface ResolvedViewport extends ViewportLayout {
+    themeColor: null | ThemeColorDescriptor[];
+    colorScheme: null | ColorSchemeEnum;
+}
+export type { Metadata, ResolvedMetadata, ResolvingMetadata, MetadataRoute, Viewport, ResolvingViewport, ResolvedViewport, };

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=metadata-interface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

node_modules/next/dist/lib/metadata/types/metadata-types.d.ts

@@ -0,0 +1,120 @@
+/**
+ *
+ * Metadata types
+ *
+ */
+export interface DeprecatedMetadataFields {
+    /**
+     * Deprecated options that have a preferred method
+     * @deprecated Use appWebApp to configure apple-mobile-web-app-capable which provides
+     * @see https://www.appsloveworld.com/coding/iphone/11/difference-between-apple-mobile-web-app-capable-and-apple-touch-fullscreen-ipho
+     */
+    'apple-touch-fullscreen'?: never;
+    /**
+     * Obsolete since iOS 7.
+     * @see https://web.dev/apple-touch-icon/
+     * @deprecated use icons.apple or instead
+     */
+    'apple-touch-icon-precomposed'?: never;
+}
+export type TemplateString = DefaultTemplateString | AbsoluteTemplateString | AbsoluteString;
+export type DefaultTemplateString = {
+    default: string;
+    template: string;
+};
+export type AbsoluteTemplateString = {
+    absolute: string;
+    template: string | null;
+};
+export type AbsoluteString = {
+    absolute: string;
+};
+export type Author = {
+    url?: string | URL;
+    name?: string;
+};
+export type ReferrerEnum = 'no-referrer' | 'origin' | 'no-referrer-when-downgrade' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin';
+export type ColorSchemeEnum = 'normal' | 'light' | 'dark' | 'light dark' | 'dark light' | 'only light';
+type RobotsInfo = {
+    index?: boolean;
+    follow?: boolean;
+    /** @deprecated set index to false instead */
+    noindex?: never;
+    /** @deprecated set follow to false instead */
+    nofollow?: never;
+    noarchive?: boolean;
+    nosnippet?: boolean;
+    noimageindex?: boolean;
+    nocache?: boolean;
+    notranslate?: boolean;
+    indexifembedded?: boolean;
+    nositelinkssearchbox?: boolean;
+    unavailable_after?: string;
+    'max-video-preview'?: number | string;
+    'max-image-preview'?: 'none' | 'standard' | 'large';
+    'max-snippet'?: number;
+};
+export type Robots = RobotsInfo & {
+    googleBot?: string | RobotsInfo;
+};
+export type ResolvedRobots = {
+    basic: string | null;
+    googleBot: string | null;
+};
+export type IconURL = string | URL;
+export type Icon = IconURL | IconDescriptor;
+export type IconDescriptor = {
+    url: string | URL;
+    type?: string;
+    sizes?: string;
+    color?: string;
+    /** defaults to rel="icon" unless superseded by Icons map */
+    rel?: string;
+    media?: string;
+    /**
+     * @see https://developer.mozilla.org/docs/Web/API/HTMLImageElement/fetchPriority
+     */
+    fetchPriority?: 'high' | 'low' | 'auto';
+};
+export type Icons = {
+    /** rel="icon" */
+    icon?: Icon | Icon[];
+    /** rel="shortcut icon" */
+    shortcut?: Icon | Icon[];
+    /**
+     * @see https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/ConfiguringWebApplications/ConfiguringWebApplications.html
+     * rel="apple-touch-icon"
+     */
+    apple?: Icon | Icon[];
+    /** rel inferred from descriptor, defaults to "icon" */
+    other?: IconDescriptor | IconDescriptor[];
+};
+export type Verification = {
+    google?: null | string | number | (string | number)[];
+    yahoo?: null | string | number | (string | number)[];
+    yandex?: null | string | number | (string | number)[];
+    me?: null | string | number | (string | number)[];
+    other?: {
+        [name: string]: string | number | (string | number)[];
+    };
+};
+export type ResolvedVerification = {
+    google?: null | (string | number)[];
+    yahoo?: null | (string | number)[];
+    yandex?: null | (string | number)[];
+    me?: null | (string | number)[];
+    other?: {
+        [name: string]: (string | number)[];
+    };
+};
+export type ResolvedIcons = {
+    icon: IconDescriptor[];
+    apple: IconDescriptor[];
+    shortcut?: IconDescriptor[];
+    other?: IconDescriptor[];
+};
+export type ThemeColorDescriptor = {
+    color: string;
+    media?: string;
+};
+export {};

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

@@ -0,0 +1,10 @@
+/**
+ *
+ * Metadata types
+ *
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=metadata-types.js.map

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

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

node_modules/next/dist/lib/metadata/types/opengraph-types.d.ts

@@ -0,0 +1,221 @@
+import type { AbsoluteTemplateString, TemplateString } from './metadata-types';
+export type OpenGraphType = 'article' | 'book' | 'music.song' | 'music.album' | 'music.playlist' | 'music.radio_station' | 'profile' | 'website' | 'video.tv_show' | 'video.other' | 'video.movie' | 'video.episode';
+export type OpenGraph = OpenGraphWebsite | OpenGraphArticle | OpenGraphBook | OpenGraphProfile | OpenGraphMusicSong | OpenGraphMusicAlbum | OpenGraphMusicPlaylist | OpenGraphRadioStation | OpenGraphVideoMovie | OpenGraphVideoEpisode | OpenGraphVideoTVShow | OpenGraphVideoOther | OpenGraphMetadata;
+type Locale = string;
+type OpenGraphMetadata = {
+    determiner?: 'a' | 'an' | 'the' | 'auto' | '';
+    title?: string | TemplateString;
+    description?: string;
+    emails?: string | Array<string>;
+    phoneNumbers?: string | Array<string>;
+    faxNumbers?: string | Array<string>;
+    siteName?: string;
+    locale?: Locale;
+    alternateLocale?: Locale | Array<Locale>;
+    images?: OGImage | Array<OGImage>;
+    audio?: OGAudio | Array<OGAudio>;
+    videos?: OGVideo | Array<OGVideo>;
+    url?: string | URL;
+    countryName?: string;
+    ttl?: number;
+};
+type OpenGraphWebsite = OpenGraphMetadata & {
+    type: 'website';
+};
+type OpenGraphArticle = OpenGraphMetadata & {
+    type: 'article';
+    publishedTime?: string;
+    modifiedTime?: string;
+    expirationTime?: string;
+    authors?: null | string | URL | Array<string | URL>;
+    section?: null | string;
+    tags?: null | string | Array<string>;
+};
+type OpenGraphBook = OpenGraphMetadata & {
+    type: 'book';
+    isbn?: null | string;
+    releaseDate?: null | string;
+    authors?: null | string | URL | Array<string | URL>;
+    tags?: null | string | Array<string>;
+};
+type OpenGraphProfile = OpenGraphMetadata & {
+    type: 'profile';
+    firstName?: null | string;
+    lastName?: null | string;
+    username?: null | string;
+    gender?: null | string;
+};
+type OpenGraphMusicSong = OpenGraphMetadata & {
+    type: 'music.song';
+    duration?: null | number;
+    albums?: null | string | URL | OGAlbum | Array<string | URL | OGAlbum>;
+    musicians?: null | string | URL | Array<string | URL>;
+};
+type OpenGraphMusicAlbum = OpenGraphMetadata & {
+    type: 'music.album';
+    songs?: null | string | URL | OGSong | Array<string | URL | OGSong>;
+    musicians?: null | string | URL | Array<string | URL>;
+    releaseDate?: null | string;
+};
+type OpenGraphMusicPlaylist = OpenGraphMetadata & {
+    type: 'music.playlist';
+    songs?: null | string | URL | OGSong | Array<string | URL | OGSong>;
+    creators?: null | string | URL | Array<string | URL>;
+};
+type OpenGraphRadioStation = OpenGraphMetadata & {
+    type: 'music.radio_station';
+    creators?: null | string | URL | Array<string | URL>;
+};
+type OpenGraphVideoMovie = OpenGraphMetadata & {
+    type: 'video.movie';
+    actors?: null | string | URL | OGActor | Array<string | URL | OGActor>;
+    directors?: null | string | URL | Array<string | URL>;
+    writers?: null | string | URL | Array<string | URL>;
+    duration?: null | number;
+    releaseDate?: null | string;
+    tags?: null | string | Array<string>;
+};
+type OpenGraphVideoEpisode = OpenGraphMetadata & {
+    type: 'video.episode';
+    actors?: null | string | URL | OGActor | Array<string | URL | OGActor>;
+    directors?: null | string | URL | Array<string | URL>;
+    writers?: null | string | URL | Array<string | URL>;
+    duration?: null | number;
+    releaseDate?: null | string;
+    tags?: null | string | Array<string>;
+    series?: null | string | URL;
+};
+type OpenGraphVideoTVShow = OpenGraphMetadata & {
+    type: 'video.tv_show';
+};
+type OpenGraphVideoOther = OpenGraphMetadata & {
+    type: 'video.other';
+};
+type OGImage = string | OGImageDescriptor | URL;
+type OGImageDescriptor = {
+    url: string | URL;
+    secureUrl?: string | URL;
+    alt?: string;
+    type?: string;
+    width?: string | number;
+    height?: string | number;
+};
+type OGAudio = string | OGAudioDescriptor | URL;
+type OGAudioDescriptor = {
+    url: string | URL;
+    secureUrl?: string | URL;
+    type?: string;
+};
+type OGVideo = string | OGVideoDescriptor | URL;
+type OGVideoDescriptor = {
+    url: string | URL;
+    secureUrl?: string | URL;
+    type?: string;
+    width?: string | number;
+    height?: string | number;
+};
+export type ResolvedOpenGraph = ResolvedOpenGraphWebsite | ResolvedOpenGraphArticle | ResolvedOpenGraphBook | ResolvedOpenGraphProfile | ResolvedOpenGraphMusicSong | ResolvedOpenGraphMusicAlbum | ResolvedOpenGraphMusicPlaylist | ResolvedOpenGraphRadioStation | ResolvedOpenGraphVideoMovie | ResolvedOpenGraphVideoEpisode | ResolvedOpenGraphVideoTVShow | ResolvedOpenGraphVideoOther | ResolvedOpenGraphMetadata;
+type ResolvedOpenGraphMetadata = {
+    determiner?: 'a' | 'an' | 'the' | 'auto' | '';
+    title: AbsoluteTemplateString;
+    description?: string;
+    emails?: Array<string>;
+    phoneNumbers?: Array<string>;
+    faxNumbers?: Array<string>;
+    siteName?: string;
+    locale?: Locale;
+    alternateLocale?: Array<Locale>;
+    images?: Array<OGImage>;
+    audio?: Array<OGAudio>;
+    videos?: Array<OGVideo>;
+    url: null | URL | string;
+    countryName?: string;
+    ttl?: number;
+};
+type ResolvedOpenGraphWebsite = ResolvedOpenGraphMetadata & {
+    type: 'website';
+};
+type ResolvedOpenGraphArticle = ResolvedOpenGraphMetadata & {
+    type: 'article';
+    publishedTime?: string;
+    modifiedTime?: string;
+    expirationTime?: string;
+    authors?: Array<string>;
+    section?: string;
+    tags?: Array<string>;
+};
+type ResolvedOpenGraphBook = ResolvedOpenGraphMetadata & {
+    type: 'book';
+    isbn?: string;
+    releaseDate?: string;
+    authors?: Array<string>;
+    tags?: Array<string>;
+};
+type ResolvedOpenGraphProfile = ResolvedOpenGraphMetadata & {
+    type: 'profile';
+    firstName?: string;
+    lastName?: string;
+    username?: string;
+    gender?: string;
+};
+type ResolvedOpenGraphMusicSong = ResolvedOpenGraphMetadata & {
+    type: 'music.song';
+    duration?: number;
+    albums?: Array<OGAlbum>;
+    musicians?: Array<string | URL>;
+};
+type ResolvedOpenGraphMusicAlbum = ResolvedOpenGraphMetadata & {
+    type: 'music.album';
+    songs?: Array<string | URL | OGSong>;
+    musicians?: Array<string | URL>;
+    releaseDate?: string;
+};
+type ResolvedOpenGraphMusicPlaylist = ResolvedOpenGraphMetadata & {
+    type: 'music.playlist';
+    songs?: Array<string | URL | OGSong>;
+    creators?: Array<string | URL>;
+};
+type ResolvedOpenGraphRadioStation = ResolvedOpenGraphMetadata & {
+    type: 'music.radio_station';
+    creators?: Array<string | URL>;
+};
+type ResolvedOpenGraphVideoMovie = ResolvedOpenGraphMetadata & {
+    type: 'video.movie';
+    actors?: Array<string | URL | OGActor>;
+    directors?: Array<string | URL>;
+    writers?: Array<string | URL>;
+    duration?: number;
+    releaseDate?: string;
+    tags?: Array<string>;
+};
+type ResolvedOpenGraphVideoEpisode = ResolvedOpenGraphMetadata & {
+    type: 'video.episode';
+    actors?: Array<string | URL | OGActor>;
+    directors?: Array<string | URL>;
+    writers?: Array<string | URL>;
+    duration?: number;
+    releaseDate?: string;
+    tags?: Array<string>;
+    series?: string | URL;
+};
+type ResolvedOpenGraphVideoTVShow = ResolvedOpenGraphMetadata & {
+    type: 'video.tv_show';
+};
+type ResolvedOpenGraphVideoOther = ResolvedOpenGraphMetadata & {
+    type: 'video.other';
+};
+type OGSong = {
+    url: string | URL;
+    disc?: number;
+    track?: number;
+};
+type OGAlbum = {
+    url: string | URL;
+    disc?: number;
+    track?: number;
+};
+type OGActor = {
+    url: string | URL;
+    role?: string;
+};
+export {};

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=opengraph-types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

node_modules/next/dist/lib/metadata/types/resolvers.d.ts

@@ -0,0 +1,8 @@
+import type { Metadata, ResolvedMetadata } from './metadata-interface';
+export type FieldResolver<Key extends keyof Data & keyof ResolvedData, Data = Metadata, ResolvedData = ResolvedMetadata> = (T: Data[Key]) => ResolvedData[Key];
+export type FieldResolverExtraArgs<Key extends keyof Data & keyof ResolvedData, ExtraArgs extends unknown[] = any[], Data = Metadata, ResolvedData = ResolvedMetadata> = (T: Data[Key], ...args: ExtraArgs) => ResolvedData[Key];
+export type MetadataContext = {
+    pathname: string;
+    trailingSlash: boolean;
+    isStandaloneMode: boolean;
+};

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=resolvers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

node_modules/next/dist/lib/metadata/types/twitter-types.d.ts

@@ -0,0 +1,86 @@
+import type { AbsoluteTemplateString, TemplateString } from './metadata-types';
+export type Twitter = TwitterSummary | TwitterSummaryLargeImage | TwitterPlayer | TwitterApp | TwitterMetadata;
+type TwitterMetadata = {
+    site?: string;
+    siteId?: string;
+    creator?: string;
+    creatorId?: string;
+    description?: string;
+    title?: string | TemplateString;
+    images?: TwitterImage | Array<TwitterImage>;
+};
+type TwitterSummary = TwitterMetadata & {
+    card: 'summary';
+};
+type TwitterSummaryLargeImage = TwitterMetadata & {
+    card: 'summary_large_image';
+};
+type TwitterPlayer = TwitterMetadata & {
+    card: 'player';
+    players: TwitterPlayerDescriptor | Array<TwitterPlayerDescriptor>;
+};
+type TwitterApp = TwitterMetadata & {
+    card: 'app';
+    app: TwitterAppDescriptor;
+};
+export type TwitterAppDescriptor = {
+    id: {
+        iphone?: string | number;
+        ipad?: string | number;
+        googleplay?: string;
+    };
+    url?: {
+        iphone?: string | URL;
+        ipad?: string | URL;
+        googleplay?: string | URL;
+    };
+    name?: string;
+};
+type TwitterImage = string | TwitterImageDescriptor | URL;
+type TwitterImageDescriptor = {
+    url: string | URL;
+    alt?: string;
+    secureUrl?: string | URL;
+    type?: string;
+    width?: string | number;
+    height?: string | number;
+};
+type TwitterPlayerDescriptor = {
+    playerUrl: string | URL;
+    streamUrl: string | URL;
+    width: number;
+    height: number;
+};
+type ResolvedTwitterImage = {
+    url: string | URL;
+    alt?: string;
+    secureUrl?: string | URL;
+    type?: string;
+    width?: string | number;
+    height?: string | number;
+};
+type ResolvedTwitterSummary = {
+    site: string | null;
+    siteId: string | null;
+    creator: string | null;
+    creatorId: string | null;
+    description: string | null;
+    title: AbsoluteTemplateString;
+    images?: Array<ResolvedTwitterImage>;
+};
+type ResolvedTwitterPlayer = ResolvedTwitterSummary & {
+    players: Array<TwitterPlayerDescriptor>;
+};
+type ResolvedTwitterApp = ResolvedTwitterSummary & {
+    app: TwitterAppDescriptor;
+};
+export type ResolvedTwitterMetadata = ({
+    card: 'summary';
+} & ResolvedTwitterSummary) | ({
+    card: 'summary_large_image';
+} & ResolvedTwitterSummary) | ({
+    card: 'player';
+} & ResolvedTwitterPlayer) | ({
+    card: 'app';
+} & ResolvedTwitterApp);
+export {};

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

@@ -0,0 +1,7 @@
+// Reference: https://developer.twitter.com/en/docs/twitter-for-websites/cards/overview/markup
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=twitter-types.js.map

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

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