feat(blog): add file-based blog with dynamic slugs, MDX content and layout shell

- Introduced blog routing using Next.js App Router
- Implemented dynamic [slug] pages for blog posts
- Added MDX-based content loading via lib/posts
- Integrated shared TopBar layout with navigation
- Established clear content, lib and component separation

apps/public-web/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)[];

apps/public-web/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

apps/public-web/node_modules/next/dist/lib/metadata/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/constants.ts"],"sourcesContent":["import type { ViewportLayout } from './types/extra-types'\nimport type { Icons } from './types/metadata-types'\n\nexport const ViewportMetaKeys: { [k in keyof ViewportLayout]: string } = {\n  width: 'width',\n  height: 'height',\n  initialScale: 'initial-scale',\n  minimumScale: 'minimum-scale',\n  maximumScale: 'maximum-scale',\n  viewportFit: 'viewport-fit',\n  userScalable: 'user-scalable',\n  interactiveWidget: 'interactive-widget',\n} as const\n\nexport const IconKeys: (keyof Icons)[] = ['icon', 'shortcut', 'apple', 'other']\n"],"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","ignoreList":[0]}

apps/public-web/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;

apps/public-web/node_modules/next/dist/lib/metadata/default-metadata.js

@@ -0,0 +1,82 @@
+"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,
+        pinterest: null,
+        abstract: null,
+        appLinks: null,
+        archives: null,
+        assets: null,
+        bookmarks: null,
+        category: null,
+        classification: null,
+        pagination: {
+            previous: null,
+            next: null
+        },
+        other: {}
+    };
+}
+
+//# sourceMappingURL=default-metadata.js.map

apps/public-web/node_modules/next/dist/lib/metadata/default-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/default-metadata.tsx"],"sourcesContent":["import type {\n  ResolvedMetadata,\n  ResolvedViewport,\n} from './types/metadata-interface'\n\nexport function createDefaultViewport(): ResolvedViewport {\n  return {\n    // name=viewport\n    width: 'device-width',\n    initialScale: 1,\n    // visual metadata\n    themeColor: null,\n    colorScheme: null,\n  }\n}\n\nexport function createDefaultMetadata(): ResolvedMetadata {\n  return {\n    // Deprecated ones\n    viewport: null,\n    themeColor: null,\n    colorScheme: null,\n\n    metadataBase: null,\n    // Other values are all null\n    title: null,\n    description: null,\n    applicationName: null,\n    authors: null,\n    generator: null,\n    keywords: null,\n    referrer: null,\n    creator: null,\n    publisher: null,\n    robots: null,\n    manifest: null,\n    alternates: {\n      canonical: null,\n      languages: null,\n      media: null,\n      types: null,\n    },\n    icons: null,\n    openGraph: null,\n    twitter: null,\n    verification: {},\n    appleWebApp: null,\n    formatDetection: null,\n    itunes: null,\n    facebook: null,\n    pinterest: null,\n    abstract: null,\n    appLinks: null,\n    archives: null,\n    assets: null,\n    bookmarks: null,\n    category: null,\n    classification: null,\n    pagination: {\n      previous: null,\n      next: null,\n    },\n    other: {},\n  }\n}\n"],"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","pinterest","abstract","appLinks","archives","assets","bookmarks","category","classification","pagination","previous","next","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,WAAW;QACXC,UAAU;QACVC,UAAU;QACVC,UAAU;QACVC,QAAQ;QACRC,WAAW;QACXC,UAAU;QACVC,gBAAgB;QAChBC,YAAY;YACVC,UAAU;YACVC,MAAM;QACR;QACAC,OAAO,CAAC;IACV;AACF","ignoreList":[0]}

apps/public-web/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;

apps/public-web/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

apps/public-web/node_modules/next/dist/lib/metadata/generate/alternate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/alternate.tsx"],"sourcesContent":["import type { ResolvedMetadata } from '../types/metadata-interface'\nimport type { AlternateLinkDescriptor } from '../types/alternative-urls-types'\n\nimport React from 'react'\nimport { MetaFilter } from './meta'\n\nfunction AlternateLink({\n  descriptor,\n  ...props\n}: {\n  descriptor: AlternateLinkDescriptor\n} & React.LinkHTMLAttributes<HTMLLinkElement>) {\n  if (!descriptor.url) return null\n  return (\n    <link\n      {...props}\n      {...(descriptor.title && { title: descriptor.title })}\n      href={descriptor.url.toString()}\n    />\n  )\n}\n\nexport function AlternatesMetadata({\n  alternates,\n}: {\n  alternates: ResolvedMetadata['alternates']\n}) {\n  if (!alternates) return null\n\n  const { canonical, languages, media, types } = alternates\n\n  return MetaFilter([\n    canonical\n      ? AlternateLink({ rel: 'canonical', descriptor: canonical })\n      : null,\n    languages\n      ? Object.entries(languages).flatMap(([locale, descriptors]) =>\n          descriptors?.map((descriptor) =>\n            AlternateLink({ rel: 'alternate', hrefLang: locale, descriptor })\n          )\n        )\n      : null,\n    media\n      ? Object.entries(media).flatMap(([mediaName, descriptors]) =>\n          descriptors?.map((descriptor) =>\n            AlternateLink({ rel: 'alternate', media: mediaName, descriptor })\n          )\n        )\n      : null,\n    types\n      ? Object.entries(types).flatMap(([type, descriptors]) =>\n          descriptors?.map((descriptor) =>\n            AlternateLink({ rel: 'alternate', type, descriptor })\n          )\n        )\n      : null,\n  ])\n}\n"],"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","ignoreList":[0]}

apps/public-web/node_modules/next/dist/lib/metadata/generate/basic.d.ts

@@ -0,0 +1,25 @@
+import type { ResolvedMetadata, ResolvedViewport } from '../types/metadata-interface';
+export declare function ViewportMeta({ viewport }: {
+    viewport: ResolvedViewport;
+}): import("react/jsx-runtime").JSX.Element[];
+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 PinterestMeta({ pinterest, }: {
+    pinterest: ResolvedMetadata['pinterest'];
+}): 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<import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react/jsx-runtime").JSX.Element[]>[] | null;
+export declare function VerificationMeta({ verification, }: {
+    verification: ResolvedMetadata['verification'];
+}): NonNullable<import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>[]>[][] | null;

apps/public-web/node_modules/next/dist/lib/metadata/generate/basic.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AppleWebAppMeta: null,
+    BasicMeta: null,
+    FacebookMeta: null,
+    FormatDetectionMeta: null,
+    ItunesMeta: null,
+    PinterestMeta: 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;
+    },
+    PinterestMeta: function() {
+        return PinterestMeta;
+    },
+    VerificationMeta: function() {
+        return VerificationMeta;
+    },
+    ViewportMeta: function() {
+        return ViewportMeta;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _meta = require("./meta");
+const _constants = require("../constants");
+const _utils = require("./utils");
+// 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';
+                } else if (!value && viewportKey === 'initialScale') {
+                    value = undefined;
+                }
+                if (value) {
+                    if (resolved) resolved += ', ';
+                    resolved += `${_constants.ViewportMetaKeys[viewportKey]}=${value}`;
+                }
+            }
+        }
+    }
+    return resolved;
+}
+function ViewportMeta({ viewport }) {
+    return (0, _meta.MetaFilter)([
+        /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+            charSet: "utf-8"
+        }),
+        (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;
+    const manifestOrigin = metadata.manifest ? (0, _utils.getOrigin)(metadata.manifest) : undefined;
+    return (0, _meta.MetaFilter)([
+        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(),
+            // If it's same origin, and it's a preview deployment,
+            // including credentials for manifest request.
+            crossOrigin: !manifestOrigin && process.env.VERCEL_ENV === 'preview' ? 'use-credentials' : undefined
+        }) : 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
+            })) : [],
+        ...metadata.pagination ? [
+            metadata.pagination.previous ? /*#__PURE__*/ (0, _jsxruntime.jsx)("link", {
+                rel: "prev",
+                href: metadata.pagination.previous
+            }) : null,
+            metadata.pagination.next ? /*#__PURE__*/ (0, _jsxruntime.jsx)("link", {
+                rel: "next",
+                href: metadata.pagination.next
+            }) : null
+        ] : [],
+        (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
+            })) : []
+    ]);
+}
+function PinterestMeta({ pinterest }) {
+    if (!pinterest || pinterest.richPin === undefined) return null;
+    const { richPin } = pinterest;
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+        property: "pinterest-rich-pin",
+        content: richPin.toString()
+    });
+}
+const formatDetectionKeys = [
+    'telephone',
+    'date',
+    'address',
+    'email',
+    'url'
+];
+function FormatDetectionMeta({ formatDetection }) {
+    if (!formatDetection) return null;
+    let content = '';
+    for (const key of formatDetectionKeys){
+        if (formatDetection[key] === false) {
+            if (content) content += ', ';
+            content += `${key}=no`;
+        }
+    }
+    return content ? /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+        name: "format-detection",
+        content: content
+    }) : null;
+}
+function AppleWebAppMeta({ appleWebApp }) {
+    if (!appleWebApp) return null;
+    const { capable, title, startupImage, statusBarStyle } = appleWebApp;
+    return (0, _meta.MetaFilter)([
+        capable ? (0, _meta.Meta)({
+            name: '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

apps/public-web/node_modules/next/dist/lib/metadata/generate/icon-mark.d.ts

@@ -0,0 +1 @@
+export declare const IconMark: () => import("react/jsx-runtime").JSX.Element | null;

apps/public-web/node_modules/next/dist/lib/metadata/generate/icon-mark.js

@@ -0,0 +1,22 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IconMark", {
+    enumerable: true,
+    get: function() {
+        return IconMark;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const IconMark = ()=>{
+    if (typeof window !== 'undefined') {
+        return null;
+    }
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+        name: "\xabnxt-icon\xbb"
+    });
+};
+
+//# sourceMappingURL=icon-mark.js.map

apps/public-web/node_modules/next/dist/lib/metadata/generate/icon-mark.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/icon-mark.tsx"],"sourcesContent":["'use client'\n\n// This is a client component that only renders during SSR,\n// but will be replaced during streaming with an icon insertion script tag.\n// We don't want it to be presented anywhere so it's only visible during streaming,\n// right after the icon meta tags so that browser can pick it up as soon as it's rendered.\n// Note: we don't just emit the script here because we only need the script if it's not in the head,\n// and we need it to be hoistable alongside the other metadata but sync scripts are not hoistable.\nexport const IconMark = () => {\n  if (typeof window !== 'undefined') {\n    return null\n  }\n  return <meta name=\"«nxt-icon»\" />\n}\n"],"names":["IconMark","window","meta","name"],"mappings":"AAAA;;;;;+BAQaA;;;eAAAA;;;;AAAN,MAAMA,WAAW;IACtB,IAAI,OAAOC,WAAW,aAAa;QACjC,OAAO;IACT;IACA,qBAAO,qBAACC;QAAKC,MAAK;;AACpB","ignoreList":[0]}

apps/public-web/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'];
+}): NonNullable<import("react/jsx-runtime").JSX.Element | import("react/jsx-runtime").JSX.Element[]>[] | null;

apps/public-web/node_modules/next/dist/lib/metadata/generate/icons.js

@@ -0,0 +1,64 @@
+"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 _iconmark = require("./icon-mark");
+const _meta = require("./meta");
+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;
+    const hasIcon = Boolean((shortcutList == null ? void 0 : shortcutList.length) || (iconList == null ? void 0 : iconList.length) || (appleList == null ? void 0 : appleList.length) || (otherList == null ? void 0 : otherList.length));
+    if (!hasIcon) return null;
+    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,
+        hasIcon ? /*#__PURE__*/ (0, _jsxruntime.jsx)(_iconmark.IconMark, {}) : null
+    ]);
+}
+
+//# sourceMappingURL=icons.js.map

apps/public-web/node_modules/next/dist/lib/metadata/generate/icons.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/icons.tsx"],"sourcesContent":["import type { ResolvedMetadata } from '../types/metadata-interface'\nimport type { Icon, IconDescriptor } from '../types/metadata-types'\nimport { IconMark } from './icon-mark'\n\nimport { MetaFilter } from './meta'\n\nfunction IconDescriptorLink({ icon }: { icon: IconDescriptor }) {\n  const { url, rel = 'icon', ...props } = icon\n\n  return <link rel={rel} href={url.toString()} {...props} />\n}\n\nfunction IconLink({ rel, icon }: { rel?: string; icon: Icon }) {\n  if (typeof icon === 'object' && !(icon instanceof URL)) {\n    if (!icon.rel && rel) icon.rel = rel\n    return IconDescriptorLink({ icon })\n  } else {\n    const href = icon.toString()\n    return <link rel={rel} href={href} />\n  }\n}\n\nexport function IconsMetadata({ icons }: { icons: ResolvedMetadata['icons'] }) {\n  if (!icons) return null\n\n  const shortcutList = icons.shortcut\n  const iconList = icons.icon\n  const appleList = icons.apple\n  const otherList = icons.other\n\n  const hasIcon = Boolean(\n    shortcutList?.length ||\n      iconList?.length ||\n      appleList?.length ||\n      otherList?.length\n  )\n  if (!hasIcon) return null\n\n  return MetaFilter([\n    shortcutList\n      ? shortcutList.map((icon) => IconLink({ rel: 'shortcut icon', icon }))\n      : null,\n    iconList ? iconList.map((icon) => IconLink({ rel: 'icon', icon })) : null,\n    appleList\n      ? appleList.map((icon) => IconLink({ rel: 'apple-touch-icon', icon }))\n      : null,\n    otherList ? otherList.map((icon) => IconDescriptorLink({ icon })) : null,\n    hasIcon ? <IconMark /> : null,\n  ])\n}\n"],"names":["IconsMetadata","IconDescriptorLink","icon","url","rel","props","link","href","toString","IconLink","URL","icons","shortcutList","shortcut","iconList","appleList","apple","otherList","other","hasIcon","Boolean","length","MetaFilter","map","IconMark"],"mappings":";;;;+BAsBgBA;;;eAAAA;;;;0BApBS;sBAEE;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,MAAMC,UAAUC,QACdR,CAAAA,gCAAAA,aAAcS,MAAM,MAClBP,4BAAAA,SAAUO,MAAM,MAChBN,6BAAAA,UAAWM,MAAM,MACjBJ,6BAAAA,UAAWI,MAAM;IAErB,IAAI,CAACF,SAAS,OAAO;IAErB,OAAOG,IAAAA,gBAAU,EAAC;QAChBV,eACIA,aAAaW,GAAG,CAAC,CAACrB,OAASO,SAAS;gBAAEL,KAAK;gBAAiBF;YAAK,MACjE;QACJY,WAAWA,SAASS,GAAG,CAAC,CAACrB,OAASO,SAAS;gBAAEL,KAAK;gBAAQF;YAAK,MAAM;QACrEa,YACIA,UAAUQ,GAAG,CAAC,CAACrB,OAASO,SAAS;gBAAEL,KAAK;gBAAoBF;YAAK,MACjE;QACJe,YAAYA,UAAUM,GAAG,CAAC,CAACrB,OAASD,mBAAmB;gBAAEC;YAAK,MAAM;QACpEiB,wBAAU,qBAACK,kBAAQ,QAAM;KAC1B;AACH","ignoreList":[0]}

apps/public-web/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<unknown, string | React.JSXElementConstructor<any>> | React.ReactElement<unknown, string | React.JSXElementConstructor<any>>[]>[] | null;
+export {};

apps/public-web/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

apps/public-web/node_modules/next/dist/lib/metadata/generate/opengraph.d.ts

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

apps/public-web/node_modules/next/dist/lib/metadata/generate/opengraph.js

@@ -0,0 +1,478 @@
+"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 Object.defineProperty(new Error(`Invalid OpenGraph type: ${_exhaustiveCheck}`), "__NEXT_ERROR_CODE", {
+                    value: "E237",
+                    enumerable: false,
+                    configurable: true
+                });
+        }
+    }
+    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

apps/public-web/node_modules/next/dist/lib/metadata/generate/utils.d.ts

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

apps/public-web/node_modules/next/dist/lib/metadata/generate/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getOrigin: null,
+    resolveArray: null,
+    resolveAsArrayOrUndefined: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getOrigin: function() {
+        return getOrigin;
+    },
+    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);
+}
+function getOrigin(url) {
+    let origin = undefined;
+    if (typeof url === 'string') {
+        try {
+            url = new URL(url);
+            origin = url.origin;
+        } catch  {}
+    }
+    return origin;
+}
+
+//# sourceMappingURL=utils.js.map

apps/public-web/node_modules/next/dist/lib/metadata/generate/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/generate/utils.ts"],"sourcesContent":["function resolveArray<T>(value: T | T[]): T[] {\n  if (Array.isArray(value)) {\n    return value as any\n  }\n  return [value] as any\n}\n\nfunction resolveAsArrayOrUndefined<T>(\n  value: T | T[] | undefined | null\n): T extends undefined | null ? undefined : T[] {\n  if (typeof value === 'undefined' || value === null) {\n    return undefined as any\n  }\n  return resolveArray(value) as any\n}\n\nfunction getOrigin(url: string | URL): string | undefined {\n  let origin = undefined\n  if (typeof url === 'string') {\n    try {\n      url = new URL(url)\n      origin = url.origin\n    } catch {}\n  }\n  return origin\n}\n\nexport { resolveAsArrayOrUndefined, resolveArray, getOrigin }\n"],"names":["getOrigin","resolveArray","resolveAsArrayOrUndefined","value","Array","isArray","undefined","url","origin","URL"],"mappings":";;;;;;;;;;;;;;;;IA2BkDA,SAAS;eAATA;;IAAdC,YAAY;eAAZA;;IAA3BC,yBAAyB;eAAzBA;;;AA3BT,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;AAEA,SAASH,UAAUO,GAAiB;IAClC,IAAIC,SAASF;IACb,IAAI,OAAOC,QAAQ,UAAU;QAC3B,IAAI;YACFA,MAAM,IAAIE,IAAIF;YACdC,SAASD,IAAIC,MAAM;QACrB,EAAE,OAAM,CAAC;IACX;IACA,OAAOA;AACT","ignoreList":[0]}

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

@@ -0,0 +1,19 @@
+/**
+ * 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, lastSegment: 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;
+export declare function normalizeMetadataPageToRoute(page: string, isDynamic: boolean): string;

apps/public-web/node_modules/next/dist/lib/metadata/get-metadata-route.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    fillMetadataSegment: null,
+    normalizeMetadataPageToRoute: 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;
+    },
+    normalizeMetadataPageToRoute: function() {
+        return normalizeMetadataPageToRoute;
+    },
+    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");
+const _segment = require("../../shared/lib/segment");
+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.
+ * /opengraph-image -> /opengraph-image
+ * /(post)/opengraph-image.tsx -> /opengraph-image-[0-9a-z]{6}
+ *
+ * Sitemap is an exception, it should not have a suffix.
+ * Each sitemap contains all the urls of sub routes, we don't have the case of duplicates `/(group)/sitemap.[ext]` and `/sitemap.[ext]` since they should be the same.
+ * Hence we always normalize the urls for sitemap and do not append hash suffix, and ensure user-land only contains one sitemap per pathname.
+ *
+ * /sitemap -> /sitemap
+ * /(post)/sitemap -> /sitemap
+ */ function getMetadataRouteSuffix(page) {
+    // Remove the last segment and get the parent pathname
+    // e.g. /parent/a/b/c -> /parent/a/b
+    // e.g. /parent/opengraph-image -> /parent
+    const parentPathname = _path.default.dirname(page);
+    // Only apply suffix to metadata routes except for sitemaps
+    if (page.endsWith('/sitemap') || page.endsWith('/sitemap.xml')) {
+        return '';
+    }
+    // Calculate the hash suffix based on the parent path
+    let suffix = '';
+    // Check if there's any special characters in the parent pathname.
+    const segments = parentPathname.split('/');
+    if (segments.some((seg)=>(0, _segment.isGroupSegment)(seg) || (0, _segment.isParallelRouteSegment)(seg))) {
+        // Hash the parent path to get a unique suffix
+        suffix = (0, _hash.djb2Hash)(parentPathname).toString(36).slice(0, 6);
+    }
+    return suffix;
+}
+function fillMetadataSegment(segment, params, lastSegment) {
+    const pathname = (0, _apppaths.normalizeAppPath)(segment);
+    const routeRegex = (0, _routeregex.getNamedRouteRegex)(pathname, {
+        prefixRouteKeys: false
+    });
+    const route = (0, _serverutils.interpolateDynamicPath)(pathname, params, routeRegex);
+    const { name, ext } = _path.default.parse(lastSegment);
+    const pagePath = _path.default.posix.join(segment, name);
+    const suffix = getMetadataRouteSuffix(pagePath);
+    const routeSuffix = suffix ? `-${suffix}` : '';
+    return (0, _normalizepathsep.normalizePathSep)(_path.default.join(route, `${name}${routeSuffix}${ext}`));
+}
+function normalizeMetadataRoute(page) {
+    if (!(0, _ismetadataroute.isMetadataPage)(page)) {
+        return page;
+    }
+    let route = page;
+    let suffix = '';
+    if (page === '/robots') {
+        route += '.txt';
+    } else if (page === '/manifest') {
+        route += '.webmanifest';
+    } else {
+        suffix = getMetadataRouteSuffix(page);
+    }
+    // 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);
+        route = _path.default.posix.join(dir, `${baseName}${suffix ? `-${suffix}` : ''}${ext}`, 'route');
+    }
+    return route;
+}
+function normalizeMetadataPageToRoute(page, isDynamic) {
+    const isRoute = page.endsWith('/route');
+    const routePagePath = isRoute ? page.slice(0, -'/route'.length) : page;
+    const metadataRouteExtension = routePagePath.endsWith('/sitemap') ? '.xml' : '';
+    const mapped = isDynamic ? `${routePagePath}/[__metadata_id__]` : `${routePagePath}${metadataRouteExtension}`;
+    return mapped + (isRoute ? '/route' : '');
+}
+
+//# sourceMappingURL=get-metadata-route.js.map

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

@@ -0,0 +1,53 @@
+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 const DEFAULT_METADATA_ROUTE_EXTENSIONS: string[];
+export declare const getExtensionRegexString: (staticExtensions: readonly string[], dynamicExtensions: readonly string[] | null) => string;
+/**
+ * Matches the static metadata files, e.g. /robots.txt, /sitemap.xml, /favicon.ico, etc.
+ * @param appDirRelativePath the relative file path to app/
+ * @returns if the path is a static metadata file route
+ */
+export declare function isStaticMetadataFile(appDirRelativePath: string): boolean;
+/**
+ * Determine if the file is a metadata route file entry
+ * @param appDirRelativePath the relative file path to app/
+ * @param pageExtensions the js extensions, such as ['js', 'jsx', 'ts', 'tsx']
+ * @param strictlyMatchExtensions if it's true, match the file with page extension, otherwise match the file with default corresponding extension
+ * @returns if the file is a metadata route file
+ */
+export declare function isMetadataRouteFile(appDirRelativePath: string, pageExtensions: PageExtensions, strictlyMatchExtensions: boolean): boolean;
+export declare function isStaticMetadataRoute(route: string): boolean;
+/**
+ * Determine if a page or pathname is a metadata page.
+ *
+ * The input is a page or pathname, which can be with or without page suffix /foo/page or /foo.
+ * But it will not contain the /route suffix.
+ *
+ * .e.g
+ * /robots -> true
+ * /sitemap -> true
+ * /foo -> false
+ */
+export declare function isMetadataPage(page: string): boolean;
+export declare function isMetadataRoute(route: string): boolean;

apps/public-web/node_modules/next/dist/lib/metadata/is-metadata-route.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    DEFAULT_METADATA_ROUTE_EXTENSIONS: null,
+    STATIC_METADATA_IMAGES: null,
+    getExtensionRegexString: null,
+    isMetadataPage: null,
+    isMetadataRoute: null,
+    isMetadataRouteFile: null,
+    isStaticMetadataFile: null,
+    isStaticMetadataRoute: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DEFAULT_METADATA_ROUTE_EXTENSIONS: function() {
+        return DEFAULT_METADATA_ROUTE_EXTENSIONS;
+    },
+    STATIC_METADATA_IMAGES: function() {
+        return STATIC_METADATA_IMAGES;
+    },
+    getExtensionRegexString: function() {
+        return getExtensionRegexString;
+    },
+    isMetadataPage: function() {
+        return isMetadataPage;
+    },
+    isMetadataRoute: function() {
+        return isMetadataRoute;
+    },
+    isMetadataRouteFile: function() {
+        return isMetadataRouteFile;
+    },
+    isStaticMetadataFile: function() {
+        return isStaticMetadataFile;
+    },
+    isStaticMetadataRoute: function() {
+        return isStaticMetadataRoute;
+    }
+});
+const _normalizepathsep = require("../../shared/lib/page-path/normalize-path-sep");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _isapprouteroute = require("../is-app-route-route");
+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'
+        ]
+    }
+};
+const DEFAULT_METADATA_ROUTE_EXTENSIONS = [
+    'js',
+    'jsx',
+    'ts',
+    'tsx'
+];
+const getExtensionRegexString = (staticExtensions, dynamicExtensions)=>{
+    let result;
+    // If there's no possible multi dynamic routes, will not match any <name>[].<ext> files
+    if (!dynamicExtensions || dynamicExtensions.length === 0) {
+        result = `(\\.(?:${staticExtensions.join('|')}))`;
+    } else {
+        result = `(?:\\.(${staticExtensions.join('|')})|(\\.(${dynamicExtensions.join('|')})))`;
+    }
+    return result;
+};
+function isStaticMetadataFile(appDirRelativePath) {
+    return isMetadataRouteFile(appDirRelativePath, [], true);
+}
+// Pre-compiled static regexes for common cases
+const FAVICON_REGEX = /^[\\/]favicon\.ico$/;
+const ROBOTS_TXT_REGEX = /^[\\/]robots\.txt$/;
+const MANIFEST_JSON_REGEX = /^[\\/]manifest\.json$/;
+const MANIFEST_WEBMANIFEST_REGEX = /^[\\/]manifest\.webmanifest$/;
+const SITEMAP_XML_REGEX = /[\\/]sitemap\.xml$/;
+// Cache for compiled regex patterns based on parameters
+const compiledRegexCache = new Map();
+// Fast path checks for common metadata files
+function fastPathCheck(normalizedPath) {
+    // Check favicon.ico first (most common)
+    if (FAVICON_REGEX.test(normalizedPath)) return true;
+    // Check other common static files
+    if (ROBOTS_TXT_REGEX.test(normalizedPath)) return true;
+    if (MANIFEST_JSON_REGEX.test(normalizedPath)) return true;
+    if (MANIFEST_WEBMANIFEST_REGEX.test(normalizedPath)) return true;
+    if (SITEMAP_XML_REGEX.test(normalizedPath)) return true;
+    // Quick negative check - if it doesn't contain any metadata keywords, skip
+    if (!normalizedPath.includes('robots') && !normalizedPath.includes('manifest') && !normalizedPath.includes('sitemap') && !normalizedPath.includes('icon') && !normalizedPath.includes('apple-icon') && !normalizedPath.includes('opengraph-image') && !normalizedPath.includes('twitter-image') && !normalizedPath.includes('favicon')) {
+        return false;
+    }
+    return null // Continue with full regex matching
+    ;
+}
+function getCompiledRegexes(pageExtensions, strictlyMatchExtensions) {
+    // Create cache key
+    const cacheKey = `${pageExtensions.join(',')}|${strictlyMatchExtensions}`;
+    const cached = compiledRegexCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    // Pre-compute common strings
+    const trailingMatcher = strictlyMatchExtensions ? '$' : '?$';
+    const variantsMatcher = '\\d?';
+    const groupSuffix = strictlyMatchExtensions ? '' : '(-\\w{6})?';
+    const suffixMatcher = variantsMatcher + groupSuffix;
+    // Pre-compute extension arrays to avoid repeated concatenation
+    const robotsExts = pageExtensions.length > 0 ? [
+        ...pageExtensions,
+        'txt'
+    ] : [
+        'txt'
+    ];
+    const manifestExts = pageExtensions.length > 0 ? [
+        ...pageExtensions,
+        'webmanifest',
+        'json'
+    ] : [
+        'webmanifest',
+        'json'
+    ];
+    const regexes = [
+        new RegExp(`^[\\\\/]robots${getExtensionRegexString(robotsExts, null)}${trailingMatcher}`),
+        new RegExp(`^[\\\\/]manifest${getExtensionRegexString(manifestExts, null)}${trailingMatcher}`),
+        // FAVICON_REGEX removed - already handled in fastPathCheck
+        new RegExp(`[\\\\/]sitemap${getExtensionRegexString([
+            'xml'
+        ], pageExtensions)}${trailingMatcher}`),
+        new RegExp(`[\\\\/]icon${suffixMatcher}${getExtensionRegexString(STATIC_METADATA_IMAGES.icon.extensions, pageExtensions)}${trailingMatcher}`),
+        new RegExp(`[\\\\/]apple-icon${suffixMatcher}${getExtensionRegexString(STATIC_METADATA_IMAGES.apple.extensions, pageExtensions)}${trailingMatcher}`),
+        new RegExp(`[\\\\/]opengraph-image${suffixMatcher}${getExtensionRegexString(STATIC_METADATA_IMAGES.openGraph.extensions, pageExtensions)}${trailingMatcher}`),
+        new RegExp(`[\\\\/]twitter-image${suffixMatcher}${getExtensionRegexString(STATIC_METADATA_IMAGES.twitter.extensions, pageExtensions)}${trailingMatcher}`)
+    ];
+    compiledRegexCache.set(cacheKey, regexes);
+    return regexes;
+}
+function isMetadataRouteFile(appDirRelativePath, pageExtensions, strictlyMatchExtensions) {
+    // Early exit for empty or obviously non-metadata paths
+    if (!appDirRelativePath || appDirRelativePath.length < 2) {
+        return false;
+    }
+    const normalizedPath = (0, _normalizepathsep.normalizePathSep)(appDirRelativePath);
+    // Fast path check for common cases
+    const fastResult = fastPathCheck(normalizedPath);
+    if (fastResult !== null) {
+        return fastResult;
+    }
+    // Get compiled regexes from cache
+    const regexes = getCompiledRegexes(pageExtensions, strictlyMatchExtensions);
+    // Use for loop instead of .some() for better performance
+    for(let i = 0; i < regexes.length; i++){
+        if (regexes[i].test(normalizedPath)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isStaticMetadataRoute(route) {
+    // extract ext with regex
+    const pathname = route.replace(/\/route$/, '');
+    const matched = (0, _isapprouteroute.isAppRouteRoute)(route) && isMetadataRouteFile(pathname, [], true) && // These routes can either be built by static or dynamic entrypoints,
+    // so we assume they're dynamic
+    pathname !== '/robots.txt' && pathname !== '/manifest.webmanifest' && !pathname.endsWith('/sitemap.xml');
+    return matched;
+}
+function isMetadataPage(page) {
+    const matched = !(0, _isapprouteroute.isAppRouteRoute)(page) && isMetadataRouteFile(page, [], false);
+    return matched;
+}
+function isMetadataRoute(route) {
+    let page = (0, _apppaths.normalizeAppPath)(route).replace(/^\/?app\//, '')// Remove the dynamic route id
+    .replace('/[__metadata_id__]', '')// Remove the /route suffix
+    .replace(/\/route$/, '');
+    if (page[0] !== '/') page = '/' + page;
+    const matched = (0, _isapprouteroute.isAppRouteRoute)(route) && isMetadataRouteFile(page, [], false);
+    return matched;
+}
+
+//# sourceMappingURL=is-metadata-route.js.map

apps/public-web/node_modules/next/dist/lib/metadata/metadata-context.d.ts

@@ -0,0 +1,3 @@
+import type { AppRenderContext } from '../../server/app-render/app-render';
+import type { MetadataContext } from './types/resolvers';
+export declare function createMetadataContext(renderOpts: AppRenderContext['renderOpts']): MetadataContext;

apps/public-web/node_modules/next/dist/lib/metadata/metadata-context.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createMetadataContext", {
+    enumerable: true,
+    get: function() {
+        return createMetadataContext;
+    }
+});
+function createMetadataContext(renderOpts) {
+    return {
+        trailingSlash: renderOpts.trailingSlash,
+        isStaticMetadataRouteFile: false
+    };
+}
+
+//# sourceMappingURL=metadata-context.js.map

apps/public-web/node_modules/next/dist/lib/metadata/metadata-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/metadata/metadata-context.tsx"],"sourcesContent":["import type { AppRenderContext } from '../../server/app-render/app-render'\nimport type { MetadataContext } from './types/resolvers'\n\nexport function createMetadataContext(\n  renderOpts: AppRenderContext['renderOpts']\n): MetadataContext {\n  return {\n    trailingSlash: renderOpts.trailingSlash,\n    isStaticMetadataRouteFile: false,\n  }\n}\n"],"names":["createMetadataContext","renderOpts","trailingSlash","isStaticMetadataRouteFile"],"mappings":";;;;+BAGgBA;;;eAAAA;;;AAAT,SAASA,sBACdC,UAA0C;IAE1C,OAAO;QACLC,eAAeD,WAAWC,aAAa;QACvCC,2BAA2B;IAC7B;AACF","ignoreList":[0]}

apps/public-web/node_modules/next/dist/lib/metadata/metadata.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { GetDynamicParamFromSegment } from '../../server/app-render/app-render';
+import type { LoaderTree } from '../../server/lib/app-dir-module';
+import type { SearchParams } from '../../server/request/search-params';
+import { type MetadataErrorType } from './resolve-metadata';
+import type { MetadataContext } from './types/resolvers';
+import type { WorkStore } from '../../server/app-render/work-async-storage.external';
+export declare function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext, getDynamicParamFromSegment, errorType, workStore, serveStreamingMetadata, }: {
+    tree: LoaderTree;
+    pathname: string;
+    parsedQuery: SearchParams;
+    metadataContext: MetadataContext;
+    getDynamicParamFromSegment: GetDynamicParamFromSegment;
+    errorType?: MetadataErrorType | 'redirect';
+    workStore: WorkStore;
+    serveStreamingMetadata: boolean;
+}): {
+    Viewport: React.ComponentType;
+    Metadata: React.ComponentType;
+    MetadataOutlet: React.ComponentType;
+};

apps/public-web/node_modules/next/dist/lib/metadata/metadata.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createMetadataComponents", {
+    enumerable: true,
+    get: function() {
+        return createMetadataComponents;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard(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 _httpaccessfallback = require("../../client/components/http-access-fallback/http-access-fallback");
+const _searchparams = require("../../server/request/search-params");
+const _pathname = require("../../server/request/pathname");
+const _ispostpone = require("../../server/lib/router-utils/is-postpone");
+const _boundarycomponents = require("../framework/boundary-components");
+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 createMetadataComponents({ tree, pathname, parsedQuery, metadataContext, getDynamicParamFromSegment, errorType, workStore, serveStreamingMetadata }) {
+    const searchParams = (0, _searchparams.createServerSearchParamsForMetadata)(parsedQuery, workStore);
+    const pathnameForMetadata = (0, _pathname.createServerPathnameForMetadata)(pathname, workStore);
+    async function Viewport() {
+        const tags = await getResolvedViewport(tree, searchParams, getDynamicParamFromSegment, workStore, errorType).catch((viewportErr)=>{
+            // When Legacy PPR is enabled viewport can reject with a Postpone type
+            // This will go away once Legacy PPR is removed and dynamic metadata will
+            // stay pending until after the prerender is complete when it is dynamic
+            if ((0, _ispostpone.isPostpone)(viewportErr)) {
+                throw viewportErr;
+            }
+            if (!errorType && (0, _httpaccessfallback.isHTTPAccessFallbackError)(viewportErr)) {
+                return getNotFoundViewport(tree, searchParams, getDynamicParamFromSegment, workStore).catch(()=>null);
+            }
+            // We're going to throw the error from the metadata outlet so we just render null here instead
+            return null;
+        });
+        return tags;
+    }
+    Viewport.displayName = 'Next.Viewport';
+    function ViewportWrapper() {
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundarycomponents.ViewportBoundary, {
+            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(Viewport, {})
+        });
+    }
+    async function Metadata() {
+        const tags = await getResolvedMetadata(tree, pathnameForMetadata, searchParams, getDynamicParamFromSegment, metadataContext, workStore, errorType).catch((metadataErr)=>{
+            // When Legacy PPR is enabled metadata can reject with a Postpone type
+            // This will go away once Legacy PPR is removed and dynamic metadata will
+            // stay pending until after the prerender is complete when it is dynamic
+            if ((0, _ispostpone.isPostpone)(metadataErr)) {
+                throw metadataErr;
+            }
+            if (!errorType && (0, _httpaccessfallback.isHTTPAccessFallbackError)(metadataErr)) {
+                return getNotFoundMetadata(tree, pathnameForMetadata, searchParams, getDynamicParamFromSegment, metadataContext, workStore).catch(()=>null);
+            }
+            // We're going to throw the error from the metadata outlet so we just render null here instead
+            return null;
+        });
+        return tags;
+    }
+    Metadata.displayName = 'Next.Metadata';
+    function MetadataWrapper() {
+        // TODO: We shouldn't change what we render based on whether we are streaming or not.
+        // If we aren't streaming we should just block the response until we have resolved the
+        // metadata.
+        if (!serveStreamingMetadata) {
+            return /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundarycomponents.MetadataBoundary, {
+                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(Metadata, {})
+            });
+        }
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+            hidden: true,
+            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundarycomponents.MetadataBoundary, {
+                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Suspense, {
+                    name: "Next.Metadata",
+                    children: /*#__PURE__*/ (0, _jsxruntime.jsx)(Metadata, {})
+                })
+            })
+        });
+    }
+    function MetadataOutlet() {
+        const pendingOutlet = Promise.all([
+            getResolvedMetadata(tree, pathnameForMetadata, searchParams, getDynamicParamFromSegment, metadataContext, workStore, errorType),
+            getResolvedViewport(tree, searchParams, getDynamicParamFromSegment, workStore, errorType)
+        ]).then(()=>null);
+        // TODO: We shouldn't change what we render based on whether we are streaming or not.
+        // If we aren't streaming we should just block the response until we have resolved the
+        // metadata.
+        if (!serveStreamingMetadata) {
+            return /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundarycomponents.OutletBoundary, {
+                children: pendingOutlet
+            });
+        }
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundarycomponents.OutletBoundary, {
+            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Suspense, {
+                name: "Next.MetadataOutlet",
+                children: pendingOutlet
+            })
+        });
+    }
+    MetadataOutlet.displayName = 'Next.MetadataOutlet';
+    return {
+        Viewport: ViewportWrapper,
+        Metadata: MetadataWrapper,
+        MetadataOutlet
+    };
+}
+const getResolvedMetadata = (0, _react.cache)(getResolvedMetadataImpl);
+async function getResolvedMetadataImpl(tree, pathname, searchParams, getDynamicParamFromSegment, metadataContext, workStore, errorType) {
+    const errorConvention = errorType === 'redirect' ? undefined : errorType;
+    return renderMetadata(tree, pathname, searchParams, getDynamicParamFromSegment, metadataContext, workStore, errorConvention);
+}
+const getNotFoundMetadata = (0, _react.cache)(getNotFoundMetadataImpl);
+async function getNotFoundMetadataImpl(tree, pathname, searchParams, getDynamicParamFromSegment, metadataContext, workStore) {
+    const notFoundErrorConvention = 'not-found';
+    return renderMetadata(tree, pathname, searchParams, getDynamicParamFromSegment, metadataContext, workStore, notFoundErrorConvention);
+}
+const getResolvedViewport = (0, _react.cache)(getResolvedViewportImpl);
+async function getResolvedViewportImpl(tree, searchParams, getDynamicParamFromSegment, workStore, errorType) {
+    const errorConvention = errorType === 'redirect' ? undefined : errorType;
+    return renderViewport(tree, searchParams, getDynamicParamFromSegment, workStore, errorConvention);
+}
+const getNotFoundViewport = (0, _react.cache)(getNotFoundViewportImpl);
+async function getNotFoundViewportImpl(tree, searchParams, getDynamicParamFromSegment, workStore) {
+    const notFoundErrorConvention = 'not-found';
+    return renderViewport(tree, searchParams, getDynamicParamFromSegment, workStore, notFoundErrorConvention);
+}
+async function renderMetadata(tree, pathname, searchParams, getDynamicParamFromSegment, metadataContext, workStore, errorConvention) {
+    const resolvedMetadata = await (0, _resolvemetadata.resolveMetadata)(tree, pathname, searchParams, errorConvention, getDynamicParamFromSegment, workStore, metadataContext);
+    const elements = createMetadataElements(resolvedMetadata);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
+        children: elements.map((el, index)=>{
+            return /*#__PURE__*/ (0, _react.cloneElement)(el, {
+                key: index
+            });
+        })
+    });
+}
+async function renderViewport(tree, searchParams, getDynamicParamFromSegment, workStore, errorConvention) {
+    const resolvedViewport = await (0, _resolvemetadata.resolveViewport)(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore);
+    const elements = createViewportElements(resolvedViewport);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
+        children: elements.map((el, index)=>{
+            return /*#__PURE__*/ (0, _react.cloneElement)(el, {
+                key: index
+            });
+        })
+    });
+}
+function createMetadataElements(metadata) {
+    return (0, _meta.MetaFilter)([
+        (0, _basic.BasicMeta)({
+            metadata
+        }),
+        (0, _alternate.AlternatesMetadata)({
+            alternates: metadata.alternates
+        }),
+        (0, _basic.ItunesMeta)({
+            itunes: metadata.itunes
+        }),
+        (0, _basic.FacebookMeta)({
+            facebook: metadata.facebook
+        }),
+        (0, _basic.PinterestMeta)({
+            pinterest: metadata.pinterest
+        }),
+        (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
+        })
+    ]);
+}
+function createViewportElements(viewport) {
+    return (0, _meta.MetaFilter)([
+        (0, _basic.ViewportMeta)({
+            viewport: viewport
+        })
+    ]);
+}
+
+//# sourceMappingURL=metadata.js.map

apps/public-web/node_modules/next/dist/lib/metadata/resolve-metadata.d.ts

@@ -0,0 +1,25 @@
+import type { Metadata, ResolvedMetadata, ResolvedViewport, 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';
+import type { WorkStore } from '../../server/app-render/work-async-storage.external';
+import 'server-only';
+type Resolved<T> = T extends Metadata ? ResolvedMetadata : ResolvedViewport;
+type InstrumentedResolver<TData> = ((parent: Promise<Resolved<TData>>) => TData | Promise<TData>) & {
+    $$original: (props: unknown, parent: Promise<Resolved<TData>>) => TData | Promise<TData>;
+};
+type MetadataResolver = InstrumentedResolver<Metadata>;
+type ViewportResolver = InstrumentedResolver<Viewport>;
+export type MetadataErrorType = 'not-found' | 'forbidden' | 'unauthorized';
+export type MetadataItems = Array<[
+    Metadata | MetadataResolver | null,
+    StaticMetadata
+]>;
+export type ViewportItems = Array<Viewport | ViewportResolver | null>;
+export declare function accumulateMetadata(route: string, metadataItems: MetadataItems, pathname: Promise<string>, metadataContext: MetadataContext): Promise<ResolvedMetadata>;
+export declare function accumulateViewport(viewportItems: ViewportItems): Promise<ResolvedViewport>;
+export declare function resolveMetadata(tree: LoaderTree, pathname: Promise<string>, searchParams: Promise<ParsedUrlQuery>, errorConvention: MetadataErrorType | undefined, getDynamicParamFromSegment: GetDynamicParamFromSegment, workStore: WorkStore, metadataContext: MetadataContext): Promise<ResolvedMetadata>;
+export declare function resolveViewport(tree: LoaderTree, searchParams: Promise<ParsedUrlQuery>, errorConvention: MetadataErrorType | undefined, getDynamicParamFromSegment: GetDynamicParamFromSegment, workStore: WorkStore): Promise<ResolvedViewport>;
+export {};

apps/public-web/node_modules/next/dist/lib/metadata/resolve-metadata.js

@@ -0,0 +1,859 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    accumulateMetadata: null,
+    accumulateViewport: null,
+    resolveMetadata: null,
+    resolveViewport: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    accumulateMetadata: function() {
+        return accumulateMetadata;
+    },
+    accumulateViewport: function() {
+        return accumulateViewport;
+    },
+    resolveMetadata: function() {
+        return resolveMetadata;
+    },
+    resolveViewport: function() {
+        return resolveViewport;
+    }
+});
+require("server-only");
+const _react = require("react");
+const _defaultmetadata = require("./default-metadata");
+const _resolveopengraph = require("./resolvers/resolve-opengraph");
+const _resolvetitle = require("./resolvers/resolve-title");
+const _utils = require("./generate/utils");
+const _appdirmodule = require("../../server/lib/app-dir-module");
+const _interopdefault = require("../interop-default");
+const _resolvebasics = require("./resolvers/resolve-basics");
+const _resolveicons = require("./resolvers/resolve-icons");
+const _tracer = require("../../server/lib/trace/tracer");
+const _constants = require("../../server/lib/trace/constants");
+const _segment = require("../../shared/lib/segment");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
+const _params = require("../../server/request/params");
+const _clientandserverreferences = require("../client-and-server-references");
+const _lazyresult = require("../../server/lib/lazy-result");
+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 convertUrlsToStrings(input) {
+    if (input instanceof URL) {
+        return input.toString();
+    } else if (Array.isArray(input)) {
+        return input.map((item)=>convertUrlsToStrings(item));
+    } else if (input && typeof input === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(input)){
+            result[key] = convertUrlsToStrings(value);
+        }
+        return result;
+    }
+    return input;
+}
+function normalizeMetadataBase(metadataBase) {
+    if (typeof metadataBase === 'string') {
+        try {
+            metadataBase = new URL(metadataBase);
+        } catch  {
+            throw Object.defineProperty(new Error(`metadataBase is not a valid URL: ${metadataBase}`), "__NEXT_ERROR_CODE", {
+                value: "E850",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    return metadataBase;
+}
+async function mergeStaticMetadata(metadataBase, source, target, staticFilesMetadata, metadataContext, titleTemplates, leafSegmentStaticIcons, pathname) {
+    var _source_twitter, _source_openGraph;
+    if (!staticFilesMetadata) return target;
+    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
+        }, metadataBase, {
+            ...metadataContext,
+            isStaticMetadataRouteFile: true
+        }, titleTemplates.twitter);
+        target.twitter = convertUrlsToStrings(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 = await (0, _resolveopengraph.resolveOpenGraph)({
+            ...target.openGraph,
+            images: openGraph
+        }, metadataBase, pathname, {
+            ...metadataContext,
+            isStaticMetadataRouteFile: true
+        }, titleTemplates.openGraph);
+        target.openGraph = convertUrlsToStrings(resolvedOpenGraph);
+    }
+    if (manifest) {
+        target.manifest = manifest;
+    }
+    return target;
+}
+/**
+ * Merges the given metadata with the resolved metadata. Returns a new object.
+ */ async function mergeMetadata(route, pathname, { metadata, resolvedMetadata, staticFilesMetadata, titleTemplates, metadataContext, buildState, leafSegmentStaticIcons }) {
+    const newResolvedMetadata = structuredClone(resolvedMetadata);
+    const metadataBase = normalizeMetadataBase((metadata == null ? void 0 : metadata.metadataBase) !== undefined ? metadata.metadataBase : resolvedMetadata.metadataBase);
+    for(const key_ in metadata){
+        const key = key_;
+        switch(key){
+            case 'title':
+                {
+                    newResolvedMetadata.title = (0, _resolvetitle.resolveTitle)(metadata.title, titleTemplates.title);
+                    break;
+                }
+            case 'alternates':
+                {
+                    newResolvedMetadata.alternates = convertUrlsToStrings(await (0, _resolvebasics.resolveAlternates)(metadata.alternates, metadataBase, pathname, metadataContext));
+                    break;
+                }
+            case 'openGraph':
+                {
+                    newResolvedMetadata.openGraph = convertUrlsToStrings(await (0, _resolveopengraph.resolveOpenGraph)(metadata.openGraph, metadataBase, pathname, metadataContext, titleTemplates.openGraph));
+                    break;
+                }
+            case 'twitter':
+                {
+                    newResolvedMetadata.twitter = convertUrlsToStrings((0, _resolveopengraph.resolveTwitter)(metadata.twitter, metadataBase, metadataContext, titleTemplates.twitter));
+                    break;
+                }
+            case 'facebook':
+                newResolvedMetadata.facebook = (0, _resolvebasics.resolveFacebook)(metadata.facebook);
+                break;
+            case 'verification':
+                newResolvedMetadata.verification = (0, _resolvebasics.resolveVerification)(metadata.verification);
+                break;
+            case 'icons':
+                {
+                    newResolvedMetadata.icons = convertUrlsToStrings((0, _resolveicons.resolveIcons)(metadata.icons));
+                    break;
+                }
+            case 'appleWebApp':
+                newResolvedMetadata.appleWebApp = (0, _resolvebasics.resolveAppleWebApp)(metadata.appleWebApp);
+                break;
+            case 'appLinks':
+                newResolvedMetadata.appLinks = convertUrlsToStrings((0, _resolvebasics.resolveAppLinks)(metadata.appLinks));
+                break;
+            case 'robots':
+                {
+                    newResolvedMetadata.robots = (0, _resolvebasics.resolveRobots)(metadata.robots);
+                    break;
+                }
+            case 'archives':
+            case 'assets':
+            case 'bookmarks':
+            case 'keywords':
+                {
+                    newResolvedMetadata[key] = (0, _utils.resolveAsArrayOrUndefined)(metadata[key]);
+                    break;
+                }
+            case 'authors':
+                {
+                    newResolvedMetadata[key] = convertUrlsToStrings((0, _utils.resolveAsArrayOrUndefined)(metadata.authors));
+                    break;
+                }
+            case 'itunes':
+                {
+                    newResolvedMetadata[key] = await (0, _resolvebasics.resolveItunes)(metadata.itunes, metadataBase, pathname, metadataContext);
+                    break;
+                }
+            case 'pagination':
+                {
+                    newResolvedMetadata.pagination = await (0, _resolvebasics.resolvePagination)(metadata.pagination, metadataBase, pathname, metadataContext);
+                    break;
+                }
+            // directly assign fields that fallback to null
+            case 'abstract':
+                newResolvedMetadata[key] = metadata[key] ?? null;
+                break;
+            case 'applicationName':
+                newResolvedMetadata[key] = metadata[key] ?? null;
+                break;
+            case 'description':
+                newResolvedMetadata[key] = metadata[key] ?? null;
+                break;
+            case 'generator':
+                newResolvedMetadata[key] = metadata[key] ?? null;
+                break;
+            case 'creator':
+                newResolvedMetadata[key] = metadata[key] ?? null;
+                break;
+            case 'publisher':
+                newResolvedMetadata[key] = metadata[key] ?? null;
+                break;
+            case 'category':
+                newResolvedMetadata[key] = metadata[key] ?? null;
+                break;
+            case 'classification':
+                newResolvedMetadata[key] = metadata[key] ?? null;
+                break;
+            case 'referrer':
+                newResolvedMetadata[key] = metadata[key] ?? null;
+                break;
+            case 'formatDetection':
+                newResolvedMetadata[key] = metadata[key] ?? null;
+                break;
+            case 'manifest':
+                newResolvedMetadata[key] = convertUrlsToStrings(metadata[key]) ?? null;
+                break;
+            case 'pinterest':
+                newResolvedMetadata[key] = convertUrlsToStrings(metadata[key]) ?? null;
+                break;
+            case 'other':
+                newResolvedMetadata.other = Object.assign({}, newResolvedMetadata.other, metadata.other);
+                break;
+            case 'metadataBase':
+                newResolvedMetadata.metadataBase = metadataBase ? metadataBase.toString() : null;
+                break;
+            case 'apple-touch-fullscreen':
+                {
+                    buildState.warnings.add(`Use appleWebApp instead\nRead more: https://nextjs.org/docs/app/api-reference/functions/generate-metadata`);
+                    break;
+                }
+            case 'apple-touch-icon-precomposed':
+                {
+                    buildState.warnings.add(`Use icons.apple instead\nRead more: https://nextjs.org/docs/app/api-reference/functions/generate-metadata`);
+                    break;
+                }
+            case 'themeColor':
+            case 'colorScheme':
+            case 'viewport':
+                if (metadata[key] != null) {
+                    buildState.warnings.add(`Unsupported metadata ${key} is configured in metadata export in ${route}. Please move it to viewport export instead.\nRead more: https://nextjs.org/docs/app/api-reference/functions/generate-viewport`);
+                }
+                break;
+            default:
+                {
+                    key;
+                }
+        }
+    }
+    return mergeStaticMetadata(metadataBase, metadata, newResolvedMetadata, staticFilesMetadata, metadataContext, titleTemplates, leafSegmentStaticIcons, pathname);
+}
+/**
+ * Merges the given viewport with the resolved viewport. Returns a new object.
+ */ function mergeViewport({ resolvedViewport, viewport }) {
+    const newResolvedViewport = structuredClone(resolvedViewport);
+    if (viewport) {
+        for(const key_ in viewport){
+            const key = key_;
+            switch(key){
+                case 'themeColor':
+                    {
+                        newResolvedViewport.themeColor = (0, _resolvebasics.resolveThemeColor)(viewport.themeColor);
+                        break;
+                    }
+                case 'colorScheme':
+                    newResolvedViewport.colorScheme = viewport.colorScheme || null;
+                    break;
+                case 'width':
+                case 'height':
+                case 'initialScale':
+                case 'minimumScale':
+                case 'maximumScale':
+                case 'userScalable':
+                case 'viewportFit':
+                case 'interactiveWidget':
+                    // always override the target with the source
+                    // @ts-ignore viewport properties
+                    newResolvedViewport[key] = viewport[key];
+                    break;
+                default:
+                    key;
+            }
+        }
+    }
+    return newResolvedViewport;
+}
+function getDefinedViewport(mod, props, tracingProps) {
+    if (typeof mod.generateViewport === 'function') {
+        const { route } = tracingProps;
+        const segmentProps = createSegmentProps(mod.generateViewport, props);
+        return Object.assign((parent)=>(0, _tracer.getTracer)().trace(_constants.ResolveMetadataSpan.generateViewport, {
+                spanName: `generateViewport ${route}`,
+                attributes: {
+                    'next.page': route
+                }
+            }, ()=>mod.generateViewport(segmentProps, parent)), {
+            $$original: mod.generateViewport
+        });
+    }
+    return mod.viewport || null;
+}
+function getDefinedMetadata(mod, props, tracingProps) {
+    if (typeof mod.generateMetadata === 'function') {
+        const { route } = tracingProps;
+        const segmentProps = createSegmentProps(mod.generateMetadata, props);
+        return Object.assign((parent)=>(0, _tracer.getTracer)().trace(_constants.ResolveMetadataSpan.generateMetadata, {
+                spanName: `generateMetadata ${route}`,
+                attributes: {
+                    'next.page': route
+                }
+            }, ()=>mod.generateMetadata(segmentProps, parent)), {
+            $$original: mod.generateMetadata
+        });
+    }
+    return mod.metadata || null;
+}
+/**
+ * If `fn` is a `'use cache'` function, we add special markers to the props,
+ * that the cache wrapper reads and removes, before passing the props to the
+ * user function.
+ */ function createSegmentProps(fn, props) {
+    return (0, _clientandserverreferences.isUseCacheFunction)(fn) ? 'searchParams' in props ? {
+        ...props,
+        $$isPage: true
+    } : {
+        ...props,
+        $$isLayout: true
+    } : props;
+}
+async function collectStaticImagesFiles(metadata, props, type) {
+    var _this;
+    if (!(metadata == null ? void 0 : metadata[type])) return undefined;
+    const iconPromises = metadata[type].map(async (imageModule)=>(0, _interopdefault.interopDefault)(await imageModule(props)));
+    return (iconPromises == null ? void 0 : iconPromises.length) > 0 ? (_this = await Promise.all(iconPromises)) == null ? void 0 : _this.flat() : undefined;
+}
+async function resolveStaticMetadata(modules, props) {
+    const { metadata } = modules;
+    if (!metadata) return null;
+    const [icon, apple, openGraph, twitter] = await Promise.all([
+        collectStaticImagesFiles(metadata, props, 'icon'),
+        collectStaticImagesFiles(metadata, props, 'apple'),
+        collectStaticImagesFiles(metadata, props, 'openGraph'),
+        collectStaticImagesFiles(metadata, props, 'twitter')
+    ]);
+    const staticMetadata = {
+        icon,
+        apple,
+        openGraph,
+        twitter,
+        manifest: metadata.manifest
+    };
+    return staticMetadata;
+}
+// [layout.metadata, static files metadata] -> ... -> [page.metadata, static files metadata]
+async function collectMetadata({ tree, metadataItems, errorMetadataItem, props, route, errorConvention }) {
+    let mod;
+    let modType;
+    const hasErrorConventionComponent = Boolean(errorConvention && tree[2][errorConvention]);
+    if (errorConvention) {
+        mod = await (0, _appdirmodule.getComponentTypeModule)(tree, 'layout');
+        modType = errorConvention;
+    } else {
+        const { mod: layoutOrPageMod, modType: layoutOrPageModType } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+        mod = layoutOrPageMod;
+        modType = layoutOrPageModType;
+    }
+    if (modType) {
+        route += `/${modType}`;
+    }
+    const staticFilesMetadata = await resolveStaticMetadata(tree[2], props);
+    const metadataExport = mod ? getDefinedMetadata(mod, props, {
+        route
+    }) : null;
+    metadataItems.push([
+        metadataExport,
+        staticFilesMetadata
+    ]);
+    if (hasErrorConventionComponent && errorConvention) {
+        const errorMod = await (0, _appdirmodule.getComponentTypeModule)(tree, errorConvention);
+        const errorMetadataExport = errorMod ? getDefinedMetadata(errorMod, props, {
+            route
+        }) : null;
+        errorMetadataItem[0] = errorMetadataExport;
+        errorMetadataItem[1] = staticFilesMetadata;
+    }
+}
+// [layout.metadata, static files metadata] -> ... -> [page.metadata, static files metadata]
+async function collectViewport({ tree, viewportItems, errorViewportItemRef, props, route, errorConvention }) {
+    let mod;
+    let modType;
+    const hasErrorConventionComponent = Boolean(errorConvention && tree[2][errorConvention]);
+    if (errorConvention) {
+        mod = await (0, _appdirmodule.getComponentTypeModule)(tree, 'layout');
+        modType = errorConvention;
+    } else {
+        const { mod: layoutOrPageMod, modType: layoutOrPageModType } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+        mod = layoutOrPageMod;
+        modType = layoutOrPageModType;
+    }
+    if (modType) {
+        route += `/${modType}`;
+    }
+    const viewportExport = mod ? getDefinedViewport(mod, props, {
+        route
+    }) : null;
+    viewportItems.push(viewportExport);
+    if (hasErrorConventionComponent && errorConvention) {
+        const errorMod = await (0, _appdirmodule.getComponentTypeModule)(tree, errorConvention);
+        const errorViewportExport = errorMod ? getDefinedViewport(errorMod, props, {
+            route
+        }) : null;
+        errorViewportItemRef.current = errorViewportExport;
+    }
+}
+const resolveMetadataItems = (0, _react.cache)(async function(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore) {
+    const parentParams = {};
+    const metadataItems = [];
+    const errorMetadataItem = [
+        null,
+        null
+    ];
+    const treePrefix = undefined;
+    return resolveMetadataItemsImpl(metadataItems, tree, treePrefix, parentParams, searchParams, errorConvention, errorMetadataItem, getDynamicParamFromSegment, workStore);
+});
+async function resolveMetadataItemsImpl(metadataItems, tree, /** Provided tree can be nested subtree, this argument says what is the path of such subtree */ treePrefix, parentParams, searchParams, errorConvention, errorMetadataItem, getDynamicParamFromSegment, workStore) {
+    const [segment, parallelRoutes, { page }] = tree;
+    const currentTreePrefix = treePrefix && treePrefix.length ? [
+        ...treePrefix,
+        segment
+    ] : [
+        segment
+    ];
+    const isPage = typeof page !== 'undefined';
+    // Handle dynamic segment params.
+    const segmentParam = getDynamicParamFromSegment(segment);
+    /**
+   * Create object holding the parent params and current params
+   */ let currentParams = parentParams;
+    if (segmentParam && segmentParam.value !== null) {
+        currentParams = {
+            ...parentParams,
+            [segmentParam.param]: segmentParam.value
+        };
+    }
+    const params = (0, _params.createServerParamsForMetadata)(currentParams, workStore);
+    const props = isPage ? {
+        params,
+        searchParams
+    } : {
+        params
+    };
+    await collectMetadata({
+        tree,
+        metadataItems,
+        errorMetadataItem,
+        errorConvention,
+        props,
+        route: currentTreePrefix// __PAGE__ shouldn't be shown in a route
+        .filter((s)=>s !== _segment.PAGE_SEGMENT_KEY).join('/')
+    });
+    for(const key in parallelRoutes){
+        const childTree = parallelRoutes[key];
+        await resolveMetadataItemsImpl(metadataItems, childTree, currentTreePrefix, currentParams, searchParams, errorConvention, errorMetadataItem, getDynamicParamFromSegment, workStore);
+    }
+    if (Object.keys(parallelRoutes).length === 0 && errorConvention) {
+        // If there are no parallel routes, place error metadata as the last item.
+        // e.g. layout -> layout -> not-found
+        metadataItems.push(errorMetadataItem);
+    }
+    return metadataItems;
+}
+const resolveViewportItems = (0, _react.cache)(async function(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore) {
+    const parentParams = {};
+    const viewportItems = [];
+    const errorViewportItemRef = {
+        current: null
+    };
+    const treePrefix = undefined;
+    return resolveViewportItemsImpl(viewportItems, tree, treePrefix, parentParams, searchParams, errorConvention, errorViewportItemRef, getDynamicParamFromSegment, workStore);
+});
+async function resolveViewportItemsImpl(viewportItems, tree, /** Provided tree can be nested subtree, this argument says what is the path of such subtree */ treePrefix, parentParams, searchParams, errorConvention, errorViewportItemRef, getDynamicParamFromSegment, workStore) {
+    const [segment, parallelRoutes, { page }] = tree;
+    const currentTreePrefix = treePrefix && treePrefix.length ? [
+        ...treePrefix,
+        segment
+    ] : [
+        segment
+    ];
+    const isPage = typeof page !== 'undefined';
+    // Handle dynamic segment params.
+    const segmentParam = getDynamicParamFromSegment(segment);
+    /**
+   * Create object holding the parent params and current params
+   */ let currentParams = parentParams;
+    if (segmentParam && segmentParam.value !== null) {
+        currentParams = {
+            ...parentParams,
+            [segmentParam.param]: segmentParam.value
+        };
+    }
+    const params = (0, _params.createServerParamsForMetadata)(currentParams, workStore);
+    let layerProps;
+    if (isPage) {
+        layerProps = {
+            params,
+            searchParams
+        };
+    } else {
+        layerProps = {
+            params
+        };
+    }
+    await collectViewport({
+        tree,
+        viewportItems,
+        errorViewportItemRef,
+        errorConvention,
+        props: layerProps,
+        route: currentTreePrefix// __PAGE__ shouldn't be shown in a route
+        .filter((s)=>s !== _segment.PAGE_SEGMENT_KEY).join('/')
+    });
+    for(const key in parallelRoutes){
+        const childTree = parallelRoutes[key];
+        await resolveViewportItemsImpl(viewportItems, childTree, currentTreePrefix, currentParams, searchParams, errorConvention, errorViewportItemRef, getDynamicParamFromSegment, workStore);
+    }
+    if (Object.keys(parallelRoutes).length === 0 && errorConvention) {
+        // If there are no parallel routes, place error metadata as the last item.
+        // e.g. layout -> layout -> not-found
+        viewportItems.push(errorViewportItemRef.current);
+    }
+    return viewportItems;
+}
+const isTitleTruthy = (title)=>!!(title == null ? void 0 : title.absolute);
+const hasTitle = (metadata)=>isTitleTruthy(metadata == null ? void 0 : metadata.title);
+function inheritFromMetadata(target, metadata) {
+    if (target) {
+        if (!hasTitle(target) && hasTitle(metadata)) {
+            target.title = metadata.title;
+        }
+        if (!target.description && metadata.description) {
+            target.description = metadata.description;
+        }
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const commonOgKeys = [
+    'title',
+    'description',
+    'images'
+];
+function postProcessMetadata(metadata, favicon, titleTemplates, metadataContext) {
+    const { openGraph, twitter } = metadata;
+    if (openGraph) {
+        // If there's openGraph information but not configured in twitter,
+        // inherit them from openGraph metadata.
+        let autoFillProps = {};
+        const hasTwTitle = hasTitle(twitter);
+        const hasTwDescription = twitter == null ? void 0 : twitter.description;
+        const hasTwImages = Boolean((twitter == null ? void 0 : twitter.hasOwnProperty('images')) && twitter.images);
+        if (!hasTwTitle) {
+            if (isTitleTruthy(openGraph.title)) {
+                autoFillProps.title = openGraph.title;
+            } else if (metadata.title && isTitleTruthy(metadata.title)) {
+                autoFillProps.title = metadata.title;
+            }
+        }
+        if (!hasTwDescription) autoFillProps.description = openGraph.description || metadata.description || undefined;
+        if (!hasTwImages) autoFillProps.images = openGraph.images;
+        if (Object.keys(autoFillProps).length > 0) {
+            const partialTwitter = (0, _resolveopengraph.resolveTwitter)(autoFillProps, normalizeMetadataBase(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 = convertUrlsToStrings(partialTwitter);
+            }
+        }
+    }
+    // If there's no title and description configured in openGraph or twitter,
+    // use the title and description from metadata.
+    inheritFromMetadata(openGraph, metadata);
+    inheritFromMetadata(twitter, metadata);
+    if (favicon) {
+        if (!metadata.icons) {
+            metadata.icons = {
+                icon: [],
+                apple: []
+            };
+        }
+        metadata.icons.icon.unshift(favicon);
+    }
+    return metadata;
+}
+function prerenderMetadata(metadataItems) {
+    // If the index is a function then it is a resolver and the next slot
+    // is the corresponding result. If the index is not a function it is the result
+    // itself.
+    const resolversAndResults = [];
+    for(let i = 0; i < metadataItems.length; i++){
+        const metadataExport = metadataItems[i][0];
+        getResult(resolversAndResults, metadataExport);
+    }
+    return resolversAndResults;
+}
+function prerenderViewport(viewportItems) {
+    // If the index is a function then it is a resolver and the next slot
+    // is the corresponding result. If the index is not a function it is the result
+    // itself.
+    const resolversAndResults = [];
+    for(let i = 0; i < viewportItems.length; i++){
+        const viewportExport = viewportItems[i];
+        getResult(resolversAndResults, viewportExport);
+    }
+    return resolversAndResults;
+}
+const noop = ()=>{};
+function getResult(resolversAndResults, exportForResult) {
+    if (typeof exportForResult === 'function') {
+        // If the function is a 'use cache' function that uses the parent data as
+        // the second argument, we don't want to eagerly execute it during
+        // metadata/viewport pre-rendering, as the parent data might also be
+        // computed from another 'use cache' function. To ensure that the hanging
+        // input abort signal handling works in this case (i.e. the depending
+        // function waits for the cached input to resolve while encoding its args),
+        // they must be called sequentially. This can be accomplished by wrapping
+        // the call in a lazy promise, so that the original function is only called
+        // when the result is actually awaited.
+        const useCacheFunctionInfo = (0, _clientandserverreferences.getUseCacheFunctionInfo)(exportForResult.$$original);
+        if (useCacheFunctionInfo && useCacheFunctionInfo.usedArgs[1]) {
+            const promise = new Promise((resolve)=>resolversAndResults.push(resolve));
+            resolversAndResults.push((0, _lazyresult.createLazyResult)(async ()=>exportForResult(promise)));
+        } else {
+            let result;
+            if (useCacheFunctionInfo) {
+                resolversAndResults.push(noop);
+                // @ts-expect-error We intentionally omit the parent argument, because
+                // we know from the check above that the 'use cache' function does not
+                // use it.
+                result = exportForResult();
+            } else {
+                result = exportForResult(new Promise((resolve)=>resolversAndResults.push(resolve)));
+            }
+            resolversAndResults.push(result);
+            if (result instanceof Promise) {
+                // since we eager execute generateMetadata and
+                // they can reject at anytime we need to ensure
+                // we attach the catch handler right away to
+                // prevent unhandled rejections crashing the process
+                result.catch((err)=>{
+                    return {
+                        __nextError: err
+                    };
+                });
+            }
+        }
+    } else if (typeof exportForResult === 'object') {
+        resolversAndResults.push(exportForResult);
+    } else {
+        resolversAndResults.push(null);
+    }
+}
+function freezeInDev(obj) {
+    if (process.env.NODE_ENV === 'development') {
+        return require('../../shared/lib/deep-freeze').deepFreeze(obj);
+    }
+    return obj;
+}
+async function accumulateMetadata(route, metadataItems, pathname, metadataContext) {
+    let resolvedMetadata = (0, _defaultmetadata.createDefaultMetadata)();
+    let titleTemplates = {
+        title: null,
+        twitter: null,
+        openGraph: null
+    };
+    const buildState = {
+        warnings: new Set()
+    };
+    let favicon;
+    // Collect the static icons in the most leaf node,
+    // since we don't collect all the static metadata icons in the parent segments.
+    const leafSegmentStaticIcons = {
+        icon: [],
+        apple: []
+    };
+    const resolversAndResults = prerenderMetadata(metadataItems);
+    let resultIndex = 0;
+    for(let i = 0; i < metadataItems.length; i++){
+        var _staticFilesMetadata_icon;
+        const staticFilesMetadata = metadataItems[i][1];
+        // Treat favicon as special case, it should be the first icon in the list
+        // i <= 1 represents root layout, and if current page is also at root
+        if (i <= 1 && isFavicon(staticFilesMetadata == null ? void 0 : (_staticFilesMetadata_icon = staticFilesMetadata.icon) == null ? void 0 : _staticFilesMetadata_icon[0])) {
+            var _staticFilesMetadata_icon1;
+            const iconMod = staticFilesMetadata == null ? void 0 : (_staticFilesMetadata_icon1 = staticFilesMetadata.icon) == null ? void 0 : _staticFilesMetadata_icon1.shift();
+            if (i === 0) favicon = iconMod;
+        }
+        let pendingMetadata = resolversAndResults[resultIndex++];
+        if (typeof pendingMetadata === 'function') {
+            // This metadata item had a `generateMetadata` and
+            // we need to provide the currently resolved metadata
+            // to it before we continue;
+            const resolveParentMetadata = pendingMetadata;
+            // we know that the next item is a result if this item
+            // was a resolver
+            pendingMetadata = resolversAndResults[resultIndex++];
+            resolveParentMetadata(freezeInDev(resolvedMetadata));
+        }
+        // Otherwise the item was either null or a static export
+        let metadata;
+        if (isPromiseLike(pendingMetadata)) {
+            metadata = await pendingMetadata;
+        } else {
+            metadata = pendingMetadata;
+        }
+        resolvedMetadata = await mergeMetadata(route, pathname, {
+            resolvedMetadata,
+            metadata,
+            metadataContext,
+            staticFilesMetadata,
+            titleTemplates,
+            buildState,
+            leafSegmentStaticIcons
+        });
+        // If the layout is the same layer with page, skip the leaf layout and leaf page
+        // The leaf layout and page are the last two items
+        if (i < metadataItems.length - 2) {
+            var _resolvedMetadata_title, _resolvedMetadata_openGraph, _resolvedMetadata_twitter;
+            titleTemplates = {
+                title: ((_resolvedMetadata_title = resolvedMetadata.title) == null ? void 0 : _resolvedMetadata_title.template) || null,
+                openGraph: ((_resolvedMetadata_openGraph = resolvedMetadata.openGraph) == null ? void 0 : _resolvedMetadata_openGraph.title.template) || null,
+                twitter: ((_resolvedMetadata_twitter = resolvedMetadata.twitter) == null ? void 0 : _resolvedMetadata_twitter.title.template) || null
+            };
+        }
+    }
+    if (leafSegmentStaticIcons.icon.length > 0 || leafSegmentStaticIcons.apple.length > 0) {
+        if (!resolvedMetadata.icons) {
+            resolvedMetadata.icons = {
+                icon: [],
+                apple: []
+            };
+            if (leafSegmentStaticIcons.icon.length > 0) {
+                resolvedMetadata.icons.icon.unshift(...leafSegmentStaticIcons.icon);
+            }
+            if (leafSegmentStaticIcons.apple.length > 0) {
+                resolvedMetadata.icons.apple.unshift(...leafSegmentStaticIcons.apple);
+            }
+        }
+    }
+    // Only log warnings if there are any, and only once after the metadata resolving process is finished
+    if (buildState.warnings.size > 0) {
+        for (const warning of buildState.warnings){
+            _log.warn(warning);
+        }
+    }
+    return postProcessMetadata(resolvedMetadata, favicon, titleTemplates, metadataContext);
+}
+async function accumulateViewport(viewportItems) {
+    let resolvedViewport = (0, _defaultmetadata.createDefaultViewport)();
+    const resolversAndResults = prerenderViewport(viewportItems);
+    let i = 0;
+    while(i < resolversAndResults.length){
+        let pendingViewport = resolversAndResults[i++];
+        if (typeof pendingViewport === 'function') {
+            // this viewport item had a `generateViewport` and
+            // we need to provide the currently resolved viewport
+            // to it before we continue;
+            const resolveParentViewport = pendingViewport;
+            // we know that the next item is a result if this item
+            // was a resolver
+            pendingViewport = resolversAndResults[i++];
+            resolveParentViewport(freezeInDev(resolvedViewport));
+        }
+        // Otherwise the item was either null or a static export
+        let viewport;
+        if (isPromiseLike(pendingViewport)) {
+            viewport = await pendingViewport;
+        } else {
+            viewport = pendingViewport;
+        }
+        resolvedViewport = mergeViewport({
+            resolvedViewport,
+            viewport
+        });
+    }
+    return resolvedViewport;
+}
+async function resolveMetadata(tree, pathname, searchParams, errorConvention, getDynamicParamFromSegment, workStore, metadataContext) {
+    const metadataItems = await resolveMetadataItems(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore);
+    return accumulateMetadata(workStore.route, metadataItems, pathname, metadataContext);
+}
+async function resolveViewport(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore) {
+    const viewportItems = await resolveViewportItems(tree, searchParams, errorConvention, getDynamicParamFromSegment, workStore);
+    return accumulateViewport(viewportItems);
+}
+function isPromiseLike(value) {
+    return typeof value === 'object' && value !== null && typeof value.then === 'function';
+}
+
+//# sourceMappingURL=resolve-metadata.js.map

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

@@ -0,0 +1,24 @@
+import type { Viewport } from '../types/metadata-interface';
+import type { FieldResolver, AsyncFieldResolverExtraArgs, MetadataContext } from '../types/resolvers';
+import { type MetadataBaseURL } from './resolve-url';
+export declare const resolveThemeColor: FieldResolver<'themeColor', Viewport>;
+export declare const resolveAlternates: AsyncFieldResolverExtraArgs<'alternates', [
+    MetadataBaseURL,
+    Promise<string>,
+    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: AsyncFieldResolverExtraArgs<'itunes', [
+    MetadataBaseURL,
+    Promise<string>,
+    MetadataContext
+]>;
+export declare const resolveFacebook: FieldResolver<'facebook'>;
+export declare const resolvePagination: AsyncFieldResolverExtraArgs<'pagination', [
+    MetadataBaseURL,
+    Promise<string>,
+    MetadataContext
+]>;

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

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    resolveAlternates: null,
+    resolveAppLinks: null,
+    resolveAppleWebApp: null,
+    resolveFacebook: null,
+    resolveItunes: null,
+    resolvePagination: 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;
+    },
+    resolvePagination: function() {
+        return resolvePagination;
+    },
+    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, pathname, 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) {
+        const newUrl = new URL(pathname, url);
+        url.searchParams.forEach((value, key)=>newUrl.searchParams.set(key, value));
+        url = newUrl;
+    }
+    return (0, _resolveurl.resolveAbsoluteUrlWithPathname)(url, metadataBase, pathname, 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;
+};
+async function resolveUrlValuesOfObject(obj, metadataBase, pathname, metadataContext) {
+    if (!obj) return null;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)){
+        if (typeof value === 'string' || value instanceof URL) {
+            const pathnameForUrl = await pathname;
+            result[key] = [
+                {
+                    url: resolveAlternateUrl(value, metadataBase, pathnameForUrl, metadataContext)
+                }
+            ];
+        } else if (value && value.length) {
+            result[key] = [];
+            const pathnameForUrl = await pathname;
+            value.forEach((item, index)=>{
+                const url = resolveAlternateUrl(item.url, metadataBase, pathnameForUrl, metadataContext);
+                result[key][index] = {
+                    url,
+                    title: item.title
+                };
+            });
+        }
+    }
+    return result;
+}
+async function resolveCanonicalUrl(urlOrDescriptor, metadataBase, pathname, metadataContext) {
+    if (!urlOrDescriptor) return null;
+    const url = typeof urlOrDescriptor === 'string' || urlOrDescriptor instanceof URL ? urlOrDescriptor : urlOrDescriptor.url;
+    const pathnameForUrl = await pathname;
+    // Return string url because structureClone can't handle URL instance
+    return {
+        url: resolveAlternateUrl(url, metadataBase, pathnameForUrl, metadataContext)
+    };
+}
+const resolveAlternates = async (alternates, metadataBase, pathname, context)=>{
+    if (!alternates) return null;
+    const canonical = await resolveCanonicalUrl(alternates.canonical, metadataBase, pathname, context);
+    const languages = await resolveUrlValuesOfObject(alternates.languages, metadataBase, pathname, context);
+    const media = await resolveUrlValuesOfObject(alternates.media, metadataBase, pathname, context);
+    const types = await resolveUrlValuesOfObject(alternates.types, metadataBase, pathname, context);
+    return {
+        canonical,
+        languages,
+        media,
+        types
+    };
+};
+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 = async (itunes, metadataBase, pathname, context)=>{
+    if (!itunes) return null;
+    return {
+        appId: itunes.appId,
+        appArgument: itunes.appArgument ? resolveAlternateUrl(itunes.appArgument, metadataBase, await pathname, context) : undefined
+    };
+};
+const resolveFacebook = (facebook)=>{
+    if (!facebook) return null;
+    return {
+        appId: facebook.appId,
+        admins: (0, _utils.resolveAsArrayOrUndefined)(facebook.admins)
+    };
+};
+const resolvePagination = async (pagination, metadataBase, pathname, context)=>{
+    return {
+        previous: (pagination == null ? void 0 : pagination.previous) ? resolveAlternateUrl(pagination.previous, metadataBase, await pathname, context) : null,
+        next: (pagination == null ? void 0 : pagination.next) ? resolveAlternateUrl(pagination.next, metadataBase, await pathname, context) : null
+    };
+};
+
+//# sourceMappingURL=resolve-basics.js.map

apps/public-web/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'>;

apps/public-web/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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/resolvers/resolve-icons.ts"],"sourcesContent":["import type { ResolvedMetadataWithURLs } from '../types/metadata-interface'\nimport type { Icon, IconDescriptor } from '../types/metadata-types'\nimport type { FieldResolver } from '../types/resolvers'\nimport { resolveAsArrayOrUndefined } from '../generate/utils'\nimport { isStringOrURL } from './resolve-url'\nimport { IconKeys } from '../constants'\n\nexport function resolveIcon(icon: Icon): IconDescriptor {\n  if (isStringOrURL(icon)) return { url: icon }\n  else if (Array.isArray(icon)) return icon\n  return icon\n}\n\nexport const resolveIcons: FieldResolver<'icons'> = (icons) => {\n  if (!icons) {\n    return null\n  }\n\n  const resolved: ResolvedMetadataWithURLs['icons'] = {\n    icon: [],\n    apple: [],\n  }\n  if (Array.isArray(icons)) {\n    resolved.icon = icons.map(resolveIcon).filter(Boolean)\n  } else if (isStringOrURL(icons)) {\n    resolved.icon = [resolveIcon(icons)]\n  } else {\n    for (const key of IconKeys) {\n      const values = resolveAsArrayOrUndefined(icons[key])\n      if (values) resolved[key] = values.map(resolveIcon)\n    }\n  }\n  return resolved\n}\n"],"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,WAA8C;QAClDN,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","ignoreList":[0]}

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

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

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

@@ -0,0 +1,199 @@
+"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, isStaticMetadataRouteFile) {
+    if (!item) return undefined;
+    const isItemUrl = (0, _resolveurl.isStringOrURL)(item);
+    const inputUrl = isItemUrl ? item : item.url;
+    if (!inputUrl) return undefined;
+    // process.env.VERCEL is set to "1" when System Environment Variables are
+    // exposed. When exposed, validation is not necessary since we are falling back to
+    // process.env.VERCEL_PROJECT_PRODUCTION_URL, process.env.VERCEL_BRANCH_URL, or
+    // process.env.VERCEL_URL for the `metadataBase`. process.env.VERCEL is undefined
+    // when System Environment Variables are not exposed. When not exposed, we cannot
+    // detect in the build environment if the deployment is a Vercel deployment or not.
+    //
+    // x-ref: https://vercel.com/docs/projects/environment-variables/system-environment-variables#system-environment-variables
+    const isUsingVercelSystemEnvironmentVariables = Boolean(process.env.VERCEL);
+    const isRelativeUrl = typeof inputUrl === 'string' && !(0, _url.isFullStringUrl)(inputUrl);
+    // When no explicit metadataBase is specified by the user, we'll override it with the fallback metadata
+    // under the following conditions:
+    // - The provided URL is relative (ie ./og-image).
+    // - The image is statically generated by Next.js (such as the special `opengraph-image` route)
+    // In both cases, we want to ensure that across all environments, the ogImage is a fully qualified URL.
+    // In the `opengraph-image` case, since the user isn't explicitly passing a relative path, this ensures
+    // the ogImage will be properly discovered across different environments without the user needing to
+    // have a bunch of `process.env` checks when defining their `metadataBase`.
+    if (isRelativeUrl && (!metadataBase || isStaticMetadataRouteFile)) {
+        const fallbackMetadataBase = (0, _resolveurl.getSocialImageMetadataBaseFallback)(metadataBase);
+        // When not using Vercel environment variables for URL injection, we aren't able to determine
+        // a fallback value for `metadataBase`. For self-hosted setups, we want to warn
+        // about this since the only fallback we'll be able to generate is `localhost`.
+        // In development, we'll only warn for relative metadata that isn't part of the static
+        // metadata conventions (eg `opengraph-image`), as otherwise it's currently very noisy
+        // for common cases. Eventually we should remove this warning all together in favor of
+        // devtools.
+        const shouldWarn = !isUsingVercelSystemEnvironmentVariables && !metadataBase && (process.env.NODE_ENV === 'production' || !isStaticMetadataRouteFile);
+        if (shouldWarn) {
+            (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`);
+        }
+        metadataBase = fallbackMetadataBase;
+    }
+    return isItemUrl ? {
+        url: (0, _resolveurl.resolveUrl)(inputUrl, metadataBase)
+    } : {
+        ...item,
+        // Update image descriptor url
+        url: (0, _resolveurl.resolveUrl)(inputUrl, metadataBase)
+    };
+}
+function resolveImages(images, metadataBase, isStaticMetadataRouteFile) {
+    const resolvedImages = (0, _utils.resolveAsArrayOrUndefined)(images);
+    if (!resolvedImages) return resolvedImages;
+    const nonNullableImages = [];
+    for (const item of resolvedImages){
+        const resolvedItem = resolveAndValidateImage(item, metadataBase, isStaticMetadataRouteFile);
+        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);
+}
+const resolveOpenGraph = async (openGraph, metadataBase, pathname, 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];
+                target[key] = value ? (0, _utils.resolveArray)(value) : null;
+            }
+        }
+        target.images = resolveImages(og.images, metadataBase, metadataContext.isStaticMetadataRouteFile);
+    }
+    const resolved = {
+        ...openGraph,
+        title: (0, _resolvetitle.resolveTitle)(openGraph.title, titleTemplate)
+    };
+    resolveProps(resolved, openGraph);
+    resolved.url = openGraph.url ? (0, _resolveurl.resolveAbsoluteUrlWithPathname)(openGraph.url, metadataBase, await pathname, 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.isStaticMetadataRouteFile);
+    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;
+                }
+            case 'summary':
+            case 'summary_large_image':
+                break;
+            default:
+                resolved;
+        }
+    }
+    return resolved;
+};
+
+//# sourceMappingURL=resolve-opengraph.js.map

apps/public-web/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;

apps/public-web/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

apps/public-web/node_modules/next/dist/lib/metadata/resolvers/resolve-title.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/resolvers/resolve-title.ts"],"sourcesContent":["import type { Metadata } from '../types/metadata-interface'\nimport type { AbsoluteTemplateString } from '../types/metadata-types'\n\nfunction resolveTitleTemplate(\n  template: string | null | undefined,\n  title: string\n) {\n  return template ? template.replace(/%s/g, title) : title\n}\n\nexport function resolveTitle(\n  title: Metadata['title'],\n  stashedTemplate: string | null | undefined\n): AbsoluteTemplateString {\n  let resolved\n  const template =\n    typeof title !== 'string' && title && 'template' in title\n      ? title.template\n      : null\n\n  if (typeof title === 'string') {\n    resolved = resolveTitleTemplate(stashedTemplate, title)\n  } else if (title) {\n    if ('default' in title) {\n      resolved = resolveTitleTemplate(stashedTemplate, title.default)\n    }\n    if ('absolute' in title && title.absolute) {\n      resolved = title.absolute\n    }\n  }\n\n  if (title && typeof title !== 'string') {\n    return {\n      template,\n      absolute: resolved || '',\n    }\n  } else {\n    return { absolute: resolved || title || '', template }\n  }\n}\n"],"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","ignoreList":[0]}

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

@@ -0,0 +1,18 @@
+import type { MetadataContext } from '../types/resolvers';
+export type MetadataBaseURL = URL | null;
+declare function isStringOrURL(icon: any): icon is string | URL;
+/**
+ * Given an optional user-provided metadataBase, this determines what the metadataBase should
+ * fallback to. Specifically:
+ * - In dev, it should always be localhost
+ * - In Vercel preview builds, it should be the preview build ID
+ * - In start, it should be the user-provided metadataBase value. Otherwise,
+ * it'll fall back to the Vercel production deployment, and localhost as a last resort.
+ */
+export declare function getSocialImageMetadataBaseFallback(metadataBase: MetadataBaseURL): URL;
+declare function resolveUrl(url: null | undefined, metadataBase: MetadataBaseURL): null;
+declare function resolveUrl(url: string | URL, metadataBase: MetadataBaseURL): URL;
+declare function resolveUrl(url: string | MetadataBaseURL | undefined, metadataBase: MetadataBaseURL): MetadataBaseURL;
+declare function resolveRelativeUrl(url: string | URL, pathname: string): string | URL;
+declare function resolveAbsoluteUrlWithPathname(url: string | URL, metadataBase: MetadataBaseURL, pathname: string, { trailingSlash }: MetadataContext): string;
+export { isStringOrURL, resolveUrl, resolveRelativeUrl, resolveAbsoluteUrlWithPathname, };

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getSocialImageMetadataBaseFallback: 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, {
+    getSocialImageMetadataBaseFallback: function() {
+        return getSocialImageMetadataBaseFallback;
+    },
+    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() {
+    // Check if experimental HTTPS is enabled
+    const isExperimentalHttps = Boolean(process.env.__NEXT_EXPERIMENTAL_HTTPS);
+    const protocol = isExperimentalHttps ? 'https' : 'http';
+    return new URL(`${protocol}://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 getSocialImageMetadataBaseFallback(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;
+}
+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 pathname = metadataBase.pathname || '';
+    const joinedPath = _path.default.posix.join(pathname, 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, pathname, { trailingSlash }) {
+    // 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.searchParams.size === 0 ? 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

apps/public-web/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 | undefined;
+};
+export type AlternateLinkDescriptor = {
+    title?: string | undefined;
+    url: string | URL;
+};
+export type AlternateURLs = {
+    canonical?: null | string | URL | AlternateLinkDescriptor | undefined;
+    languages?: Languages<null | string | URL | AlternateLinkDescriptor[]> | undefined;
+    media?: {
+        [media: string]: null | string | URL | AlternateLinkDescriptor[];
+    } | undefined;
+    types?: {
+        [types: string]: null | string | URL | AlternateLinkDescriptor[];
+    } | undefined;
+};
+export type ResolvedAlternateURLs = {
+    canonical: null | AlternateLinkDescriptor;
+    languages: null | Languages<AlternateLinkDescriptor[]>;
+    media: null | {
+        [media: string]: null | AlternateLinkDescriptor[];
+    };
+    types: null | {
+        [types: string]: null | AlternateLinkDescriptor[];
+    };
+};
+export {};

apps/public-web/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

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

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

apps/public-web/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

apps/public-web/node_modules/next/dist/lib/metadata/types/extra-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/extra-types.ts"],"sourcesContent":["// When rendering applink meta tags add a namespace tag before each array instance\n// if more than one member exists.\n// ref: https://developers.facebook.com/docs/applinks/metadata-reference\n\nexport type AppLinks = {\n  ios?: AppLinksApple | Array<AppLinksApple> | undefined\n  iphone?: AppLinksApple | Array<AppLinksApple> | undefined\n  ipad?: AppLinksApple | Array<AppLinksApple> | undefined\n  android?: AppLinksAndroid | Array<AppLinksAndroid> | undefined\n  windows_phone?: AppLinksWindows | Array<AppLinksWindows> | undefined\n  windows?: AppLinksWindows | Array<AppLinksWindows> | undefined\n  windows_universal?: AppLinksWindows | Array<AppLinksWindows> | undefined\n  web?: AppLinksWeb | Array<AppLinksWeb> | undefined\n}\nexport type ResolvedAppLinks = {\n  ios?: Array<AppLinksApple> | undefined\n  iphone?: Array<AppLinksApple> | undefined\n  ipad?: Array<AppLinksApple> | undefined\n  android?: Array<AppLinksAndroid> | undefined\n  windows_phone?: Array<AppLinksWindows> | undefined\n  windows?: Array<AppLinksWindows> | undefined\n  windows_universal?: Array<AppLinksWindows> | undefined\n  web?: Array<AppLinksWeb> | undefined\n}\nexport type AppLinksApple = {\n  url: string | URL\n  app_store_id?: string | number | undefined\n  app_name?: string | undefined\n}\nexport type AppLinksAndroid = {\n  package: string\n  url?: string | URL | undefined\n  class?: string | undefined\n  app_name?: string | undefined\n}\nexport type AppLinksWindows = {\n  url: string | URL\n  app_id?: string | undefined\n  app_name?: string | undefined\n}\nexport type AppLinksWeb = {\n  url: string | URL\n  should_fallback?: boolean | undefined\n}\n\n// Apple Itunes APp\n// https://developer.apple.com/documentation/webkit/promoting_apps_with_smart_app_banners\nexport type ItunesApp = {\n  appId: string\n  appArgument?: string | undefined\n}\n\n// Viewport meta structure\n// https://developer.mozilla.org/docs/Web/HTML/Viewport_meta_tag\n// intentionally leaving out user-scalable, use a string if you want that behavior\nexport type ViewportLayout = {\n  width?: string | number | undefined\n  height?: string | number | undefined\n  initialScale?: number | undefined\n  minimumScale?: number | undefined\n  maximumScale?: number | undefined\n  userScalable?: boolean | undefined\n  viewportFit?: 'auto' | 'cover' | 'contain' | undefined\n  interactiveWidget?:\n    | 'resizes-visual'\n    | 'resizes-content'\n    | 'overlays-content'\n    | undefined\n}\n\n// Apple Web App\n// https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariHTMLRef/Articles/MetaTags.html\n// https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/ConfiguringWebApplications/ConfiguringWebApplications.html\nexport type AppleWebApp = {\n  // default true\n  capable?: boolean | undefined\n  title?: string | undefined\n  startupImage?: AppleImage | Array<AppleImage> | undefined\n  // default \"default\"\n  statusBarStyle?: 'default' | 'black' | 'black-translucent' | undefined\n}\nexport type AppleImage = string | AppleImageDescriptor\nexport type AppleImageDescriptor = {\n  url: string\n  media?: string | undefined\n}\n\nexport type ResolvedAppleWebApp = {\n  capable: boolean\n  title?: string | null | undefined\n  startupImage?: AppleImageDescriptor[] | null | undefined\n  statusBarStyle?: 'default' | 'black' | 'black-translucent' | undefined\n}\n\nexport type Facebook = FacebookAppId | FacebookAdmins\nexport type FacebookAppId = {\n  appId: string\n  admins?: never | undefined\n}\nexport type FacebookAdmins = {\n  appId?: never | undefined\n  admins: string | string[]\n}\nexport type ResolvedFacebook = {\n  appId?: string | undefined\n  admins?: string[] | undefined\n}\n\nexport type Pinterest = PinterestRichPin\nexport type PinterestRichPin = {\n  richPin: string | boolean\n}\n\nexport type ResolvedPinterest = {\n  richPin?: string | boolean\n}\n\n// Format Detection\n// This is a poorly specified metadata export type that is supposed to\n// control whether the device attempts to conver text that matches\n// certain formats into links for action. The most supported example\n// is how mobile devices detect phone numbers and make them into links\n// that can initiate a phone call\n// https://www.goodemailcode.com/email-code/template.html\nexport type FormatDetection = {\n  telephone?: boolean | undefined\n  date?: boolean | undefined\n  address?: boolean | undefined\n  email?: boolean | undefined\n  url?: boolean | undefined\n}\n"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,kCAAkC;AAClC,wEAAwE","ignoreList":[0]}

apps/public-web/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;

apps/public-web/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

apps/public-web/node_modules/next/dist/lib/metadata/types/icons.js.map

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

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

@@ -0,0 +1,74 @@
+type ClientModeEnum = 'auto' | 'focus-existing' | 'navigate-existing' | 'navigate-new';
+type File = {
+    name: string;
+    accept: string | string[];
+};
+type Icon = {
+    src: string;
+    type?: string | undefined;
+    sizes?: string | undefined;
+    purpose?: 'any' | 'maskable' | 'monochrome' | undefined;
+};
+export type Manifest = {
+    background_color?: string | undefined;
+    categories?: string[] | undefined;
+    description?: string | undefined;
+    dir?: 'ltr' | 'rtl' | 'auto' | undefined;
+    display?: 'fullscreen' | 'standalone' | 'minimal-ui' | 'browser' | undefined;
+    display_override?: ('fullscreen' | 'standalone' | 'minimal-ui' | 'browser' | 'window-controls-overlay')[] | undefined;
+    file_handlers?: {
+        action: string;
+        accept: {
+            [mimeType: string]: string[];
+        };
+    }[] | undefined;
+    icons?: Icon[] | undefined;
+    id?: string | undefined;
+    lang?: string | undefined;
+    launch_handler?: {
+        client_mode: ClientModeEnum | ClientModeEnum[];
+    } | undefined;
+    name?: string | undefined;
+    orientation?: 'any' | 'natural' | 'landscape' | 'portrait' | 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary' | undefined;
+    prefer_related_applications?: boolean | undefined;
+    protocol_handlers?: {
+        protocol: string;
+        url: string;
+    }[] | undefined;
+    related_applications?: {
+        platform: string;
+        url: string;
+        id?: string | undefined;
+    }[] | undefined;
+    scope?: string | undefined;
+    screenshots?: {
+        form_factor?: 'narrow' | 'wide' | undefined;
+        label?: string | undefined;
+        platform?: 'android' | 'chromeos' | 'ipados' | 'ios' | 'kaios' | 'macos' | 'windows' | 'xbox' | 'chrome_web_store' | 'itunes' | 'microsoft-inbox' | 'microsoft-store' | 'play' | undefined;
+        src: string;
+        type?: string | undefined;
+        sizes?: string | undefined;
+    }[] | undefined;
+    share_target?: {
+        action: string;
+        method?: 'get' | 'post' | 'GET' | 'POST' | undefined;
+        enctype?: 'application/x-www-form-urlencoded' | 'multipart/form-data' | undefined;
+        params: {
+            title?: string | undefined;
+            text?: string | undefined;
+            url?: string | undefined;
+            files?: File | File[] | undefined;
+        };
+    } | undefined;
+    short_name?: string | undefined;
+    shortcuts?: {
+        name: string;
+        short_name?: string | undefined;
+        description?: string | undefined;
+        url: string;
+        icons?: Icon[] | undefined;
+    }[] | undefined;
+    start_url?: string | undefined;
+    theme_color?: string | undefined;
+};
+export {};

apps/public-web/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

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

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

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

@@ -0,0 +1,636 @@
+/**
+ * Next.js Metadata API
+ *
+ * This file defines the types used by Next.js to configure metadata
+ * through static exports or dynamic `generateMetadata` functions in Server Components.
+ *
+ * @remarks
+ * - The static `metadata` object and `generateMetadata` function are only supported in Server Components.
+ * - Do not export both a `metadata` object and a `generateMetadata` function from the same route segment.
+ * - You can still render metadata in client components directly as part of the component's JSX.
+ *
+ * @see https://nextjs.org/docs/app/api-reference/metadata
+ */
+import type { AlternateURLs, Languages, ResolvedAlternateURLs } from './alternative-urls-types';
+import type { AppleWebApp, AppLinks, Facebook, FormatDetection, ItunesApp, Pinterest, ResolvedAppleWebApp, ResolvedAppLinks, ResolvedFacebook, ResolvedPinterest, ViewportLayout } from './extra-types';
+import type { DeprecatedMetadataFields, AbsoluteTemplateString, Author, ColorSchemeEnum, Icon, Icons, IconURL, ReferrerEnum, ResolvedIcons, ResolvedVerification, Robots, ResolvedRobots, TemplateString, Verification, ThemeColorDescriptor, Videos } 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.
+ *
+ * @remarks
+ * This interface covers all the metadata fields available in Next.js including title, description,
+ * icons, openGraph, twitter, and more. Fields such as `metadataBase` help in composing absolute URLs
+ * from relative ones. The `title` field supports both simple strings and a template object with `default`,
+ * `template`, and `absolute` properties.
+ *
+ * @example
+ * ```tsx
+ * // Static metadata export in a layout or page:
+ * import type { Metadata } from 'next'
+ *
+ * export const metadata: Metadata = {
+ *   metadataBase: new URL('https://example.com'),
+ *   title: { default: 'My Site', template: '%s | My Site' },
+ *   description: 'Welcome to My Site',
+ *   alternates: {
+ *     canonical: 'https://example.com',
+ *     languages: {
+ *       'en-US': 'https://example.com/en-US',
+ *       'de-DE': 'https://example.com/de-DE'
+ *     }
+ *   },
+ *   openGraph: {
+ *     title: 'My Site',
+ *     description: 'Welcome to My Site',
+ *     url: 'https://example.com',
+ *     siteName: 'My Site',
+ *     images: [{ url: 'https://example.com/og.png' }]
+ *   },
+ * }
+ * ```
+ */
+interface Metadata extends DeprecatedMetadataFields {
+    /**
+     * The base path and origin for absolute URLs in various metadata fields.
+     *
+     * @remarks
+     * When relative URLs (for Open Graph images, alternates, etc.) are used, they are composed with this base.
+     * If not provided, Next.js will populate a default value based on environment variables.
+     */
+    metadataBase?: null | string | URL | undefined;
+    /**
+     * The document title.
+     *
+     * @remarks
+     * The title can be a simple string (e.g., `"My Blog"`) or an object with:
+     * - `default`: A fallback title for child segments.
+     * - `template`: A title template (e.g., `"%s | My Website"`) applied to child titles.
+     * - `absolute`: A title that overrides parent templates.
+     *
+     * @example
+     * ```tsx
+     * // As a simple string:
+     * title: "My Blog"
+     *
+     * // As a template object:
+     * title: { default: "Dashboard", template: "%s | My Website" }
+     *
+     * // Using absolute value (ignores parent template):
+     * title: { absolute: "My Blog", template: "%s | My Website" }
+     * ```
+     */
+    title?: null | string | TemplateString | undefined;
+    /**
+     * The document description, and optionally the Open Graph and Twitter descriptions.
+     *
+     * @example
+     * ```tsx
+     * description: "My Blog Description"
+     * // Renders: <meta name="description" content="My Blog Description" />
+     * ```
+     */
+    description?: null | string | undefined;
+    /**
+     * The application name.
+     *
+     * @example
+     * ```tsx
+     * applicationName: "My Blog"
+     * // Renders: <meta name="application-name" content="My Blog" />
+     * ```
+     */
+    applicationName?: null | string | undefined;
+    /**
+     * The authors of the document.
+     *
+     * @example
+     * ```tsx
+     * authors: [{ name: "Next.js Team", url: "https://nextjs.org" }]
+     * // Renders:
+     * // <meta name="author" content="Next.js Team" />
+     * // <link rel="author" href="https://nextjs.org" />
+     * ```
+     */
+    authors?: null | Author | Array<Author> | undefined;
+    /**
+     * The generator used for the document.
+     *
+     * @example
+     * ```tsx
+     * generator: "Next.js"
+     * // Renders: <meta name="generator" content="Next.js" />
+     * ```
+     */
+    generator?: null | string | undefined;
+    /**
+     * The keywords for the document.
+     *
+     * @remarks
+     * When an array is provided, keywords are flattened into a comma-separated string.
+     *
+     * @example
+     * ```tsx
+     * keywords: "nextjs, react, blog"
+     * // or
+     * keywords: ["react", "server components"]
+     * ```
+     */
+    keywords?: null | string | Array<string> | undefined;
+    /**
+     * The referrer setting for the document.
+     *
+     * @example
+     * ```tsx
+     * referrer: "origin"
+     * // Renders: <meta name="referrer" content="origin" />
+     * ```
+     */
+    referrer?: null | ReferrerEnum | undefined;
+    /**
+     * The theme color for the document.
+     *
+     * @deprecated Use the new viewport configuration (`export const viewport: Viewport = { ... }`) instead.
+     */
+    themeColor?: null | string | ThemeColorDescriptor | ThemeColorDescriptor[] | undefined;
+    /**
+     * The color scheme for the document.
+     *
+     * @deprecated Use the new viewport configuration (`export const viewport: Viewport = { ... }`) instead.
+     */
+    colorScheme?: null | ColorSchemeEnum | undefined;
+    /**
+     * The viewport setting for the document.
+     *
+     * @deprecated Use the new viewport configuration (`export const viewport: Viewport = { ... }`) instead.
+     */
+    viewport?: null | string | ViewportLayout | undefined;
+    /**
+     * The creator of the document.
+     *
+     * @example
+     * ```tsx
+     * creator: "Next.js Team"
+     * // Renders: <meta name="creator" content="Next.js Team" />
+     * ```
+     */
+    creator?: null | string | undefined;
+    /**
+     * The publisher of the document.
+     *
+     * @example
+     * ```tsx
+     * publisher: "Vercel"
+     * // Renders: <meta name="publisher" content="Vercel" />
+     * ```
+     */
+    publisher?: null | string | undefined;
+    /**
+     * The robots setting for the document.
+     *
+     * @remarks
+     * Can be a string (e.g., "index, follow") or an object with more granular rules.
+     *
+     * @example
+     * ```tsx
+     * robots: "index, follow"
+     * // or
+     * robots: { index: true, follow: true }
+     * ```
+     *
+     * @see https://developer.mozilla.org/docs/Glossary/Robots.txt
+     */
+    robots?: null | string | Robots | undefined;
+    /**
+     * The canonical and alternate URLs for the document.
+     *
+     * @remarks
+     * This field allows defining a canonical URL as well as alternate URLs (such as for multiple languages).
+     *
+     * @example
+     * ```tsx
+     * alternates: {
+     *   canonical: "https://example.com",
+     *   languages: {
+     *     "en-US": "https://example.com/en-US"
+     *   }
+     * }
+     * ```
+     */
+    alternates?: null | AlternateURLs | undefined;
+    /**
+     * The icons for the document. Defaults to rel="icon".
+     *
+     * @remarks
+     * You can specify a simple URL or an object to differentiate between icon types (e.g., apple-touch-icon).
+     *
+     * @example
+     * ```tsx
+     * icons: "https://example.com/icon.png"
+     * // or
+     * icons: {
+     *   icon: "https://example.com/icon.png",
+     *   apple: "https://example.com/apple-icon.png"
+     * }
+     * ```
+     *
+     * @see https://developer.mozilla.org/docs/Web/HTML/Attributes/rel#attr-icon
+     */
+    icons?: null | IconURL | Array<Icon> | Icons | undefined;
+    /**
+     * A web application manifest, as defined in the Web Application Manifest specification.
+     *
+     * @example
+     * ```tsx
+     * manifest: "https://example.com/manifest.json"
+     * // Renders: <link rel="manifest" href="https://example.com/manifest.json" />
+     * ```
+     *
+     * @see https://developer.mozilla.org/docs/Web/Manifest
+     */
+    manifest?: null | string | URL | undefined;
+    /**
+     * The Open Graph metadata for the document.
+     *
+     * @remarks
+     * Follows the Open Graph protocol to enrich link previews.
+     *
+     * @example
+     * ```tsx
+     * openGraph: {
+     *   type: "website",
+     *   url: "https://example.com",
+     *   title: "My Website",
+     *   description: "My Website Description",
+     *   siteName: "My Website",
+     *   images: [{ url: "https://example.com/og.png" }]
+     * }
+     * ```
+     *
+     * @see https://ogp.me/
+     */
+    openGraph?: null | OpenGraph | undefined;
+    /**
+     * The Twitter metadata for the document.
+     *
+     * @remarks
+     * - Used for configuring Twitter Cards and can include details such as `card`, `site`, and `creator`.
+     * - Notably, more sites than just Twitter (now X) use this format.
+     *
+     * @example
+     * ```tsx
+     * twitter: {
+     *   card: "summary_large_image",
+     *   site: "@site",
+     *   creator: "@creator",
+     *   images: "https://example.com/og.png"
+     * }
+     * ```
+     */
+    twitter?: null | Twitter | undefined;
+    /**
+     * The Facebook metadata for the document.
+     *
+     * @remarks
+     * Specify either `appId` or `admins` (but not both) to configure Facebook integration.
+     *
+     * @example
+     * ```tsx
+     * facebook: { appId: "12345678" }
+     * // Renders <meta property="fb:app_id" content="12345678" />
+     * // or
+     * facebook: { admins: ["12345678"] }
+     * // Renders <meta property="fb:admins" content="12345678" />
+     * ```
+     */
+    facebook?: null | Facebook | undefined;
+    /**
+     * The Pinterest metadata for the document to choose whether opt out of rich pin data.
+     *
+     * @example
+     * ```tsx
+     * pinterest: { richPin: true }
+     * // Renders <meta name="pinterest-rich-pin" content="true" />
+     * ```
+     */
+    pinterest?: null | Pinterest;
+    /**
+     * The common verification tokens for the document.
+     *
+     * @example
+     * ```tsx
+     * verification: { google: "1234567890", yandex: "1234567890", "me": "1234567890" }
+     * // Renders <meta name="google-site-verification" content="1234567890" />
+     * // <meta name="yandex-verification" content="1234567890" />
+     * // <meta name="me" content="@me" />
+     * ```
+     */
+    verification?: Verification | undefined;
+    /**
+     * The Apple web app metadata for the document.
+     *
+     * @example
+     * ```tsx
+     * appleWebApp: { capable: true, title: "My Website", statusBarStyle: "black-translucent" }
+     * ```
+     *
+     * @see https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariHTMLRef/Articles/MetaTags.html
+     */
+    appleWebApp?: null | boolean | AppleWebApp | undefined;
+    /**
+     * Indicates whether devices should interpret certain formats (such as telephone numbers) as actionable links.
+     *
+     * @example
+     * ```tsx
+     * formatDetection: { telephone: false }
+     * // Renders: <meta name="format-detection" content="telephone=no" />
+     * ```
+     */
+    formatDetection?: null | FormatDetection | undefined;
+    /**
+     * The metadata for the iTunes App.
+     *
+     * @remarks
+     * Adds the `name="apple-itunes-app"` meta tag.
+     *
+     * @example
+     * ```tsx
+     * itunes: { app: { id: "123456789", affiliateData: "123456789", appArguments: "123456789" } }
+     * // Renders <meta name="apple-itunes-app" content="app-id=123456789, affiliate-data=123456789, app-arguments=123456789" />
+     * ```
+     */
+    itunes?: null | ItunesApp | undefined;
+    /**
+     * A brief description of the web page.
+     *
+     * @remarks
+     * Rendered as the `abstract` meta tag. This is *not recommended* as it is superseded by `description`.
+     *
+     * @example
+     * ```tsx
+     * abstract: "My Website Description"
+     * // Renders <meta name="abstract" content="My Website Description" />
+     * ```
+     */
+    abstract?: null | string | undefined;
+    /**
+     * The Facebook AppLinks metadata for the document.
+     *
+     * @example
+     * ```tsx
+     * appLinks: {
+     *   ios: { appStoreId: "123456789", url: "https://example.com" },
+     *   android: { packageName: "com.example", url: "https://example.com" }
+     * }
+     *
+     * // Renders
+     * <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 | undefined;
+    /**
+     * The archives link rel property.
+     *
+     * @example
+     * ```tsx
+     * archives: "https://example.com/archives"
+     * // Renders <link rel="archives" href="https://example.com/archives" />
+     * ```
+     */
+    archives?: null | string | Array<string> | undefined;
+    /**
+     * The assets link rel property.
+     *
+     * @example
+     * ```tsx
+     * assets: "https://example.com/assets"
+     * // Renders <link rel="assets" href="https://example.com/assets" />
+     * ```
+     */
+    assets?: null | string | Array<string> | undefined;
+    /**
+     * The bookmarks link rel property.
+     *
+     * @remarks
+     * Although technically against the HTML spec, this is used in practice.
+     *
+     * @example
+     * ```tsx
+     * bookmarks: "https://example.com/bookmarks"
+     * // Renders <link rel="bookmarks" href="https://example.com/bookmarks" />
+     * ```
+     */
+    bookmarks?: null | string | Array<string> | undefined;
+    /**
+     * The pagination link rel properties.
+     *
+     * @example
+     * ```tsx
+     * pagination: {
+     *   previous: "https://example.com/items?page=1",
+     *   next: "https://example.com/items?page=3"
+     * }
+     *
+     * // Renders
+     * <link rel="prev" href="https://example.com/items?page=1" />
+     * <link rel="next" href="https://example.com/items?page=3" />
+     * ```
+     *
+     * @see https://developers.google.com/search/blog/2011/09/pagination-with-relnext-and-relprev
+     */
+    pagination?: {
+        previous?: null | string | URL | undefined;
+        next?: null | string | URL | undefined;
+    };
+    /**
+     * The category meta name property.
+     *
+     * @example
+     * ```tsx
+     * category: "My Category"
+     * // Renders <meta name="category" content="My Category" />
+     * ```
+     */
+    category?: null | string | undefined;
+    /**
+     * The classification meta name property.
+     *
+     * @example
+     * ```tsx
+     * classification: "My Classification"
+     * // Renders <meta name="classification" content="My Classification" />
+     * ```
+     */
+    classification?: null | string | undefined;
+    /**
+     * Arbitrary name/value pairs for additional metadata.
+     *
+     * @remarks
+     * Use this field to define custom meta tags that are not directly supported.
+     *
+     * @example
+     * ```tsx
+     * other: { custom: ["meta1", "meta2"] }
+     * ```
+     */
+    other?: ({
+        [name: string]: string | number | Array<string | number>;
+    } & DeprecatedMetadataFields) | undefined;
+}
+/**
+ * ResolvedMetadataWithURLs represents the fully processed metadata after
+ * defaults are applied and relative URLs are composed with `metadataBase`.
+ */
+interface ResolvedMetadataWithURLs extends DeprecatedMetadataFields {
+    metadataBase: string | 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;
+    pinterest: null | ResolvedPinterest;
+    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>;
+    pagination: {
+        previous: null | string;
+        next: null | string;
+    };
+    category: null | string;
+    classification: null | string;
+    other: null | ({
+        [name: string]: string | number | Array<string | number>;
+    } & DeprecatedMetadataFields);
+}
+export type WithStringifiedURLs<T> = T extends URL ? string : T extends object ? {
+    [K in keyof T]: WithStringifiedURLs<T[K]>;
+} : T;
+/**
+ * ResolvedMetadata represents the fully processed metadata after defaults are
+ * applied and relative URLs are composed with `metadataBase`.
+ */
+type ResolvedMetadata = WithStringifiedURLs<ResolvedMetadataWithURLs>;
+type RobotsFile = {
+    rules: {
+        userAgent?: string | string[] | undefined;
+        allow?: string | string[] | undefined;
+        disallow?: string | string[] | undefined;
+        crawlDelay?: number | undefined;
+    } | Array<{
+        userAgent: string | string[];
+        allow?: string | string[] | undefined;
+        disallow?: string | string[] | undefined;
+        crawlDelay?: number | undefined;
+    }>;
+    sitemap?: string | string[] | undefined;
+    host?: string | undefined;
+};
+type SitemapFile = Array<{
+    url: string;
+    lastModified?: string | Date | undefined;
+    changeFrequency?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never' | undefined;
+    priority?: number | undefined;
+    alternates?: {
+        languages?: Languages<string> | undefined;
+    } | undefined;
+    images?: string[] | undefined;
+    videos?: Videos[] | undefined;
+}>;
+type ResolvingMetadata = Promise<ResolvedMetadata>;
+declare namespace MetadataRoute {
+    type Robots = RobotsFile;
+    type Sitemap = SitemapFile;
+    type Manifest = ManifestFile;
+}
+/**
+ * Interface for the viewport configuration.
+ *
+ * @remarks
+ * This configuration allows defining properties such as width, initial scale, theme colors,
+ * and color scheme.
+ *
+ * @example
+ * ```tsx
+ * export const viewport: Viewport = {
+ *   width: "device-width",
+ *   initialScale: 1,
+ *   themeColor: [
+ *     { media: "(prefers-color-scheme: dark)", color: "#000000" },
+ *     { media: "(prefers-color-scheme: light)", color: "#ffffff" }
+ *   ],
+ *   colorScheme: "dark"
+ * }
+ * ```
+ */
+interface Viewport extends ViewportLayout {
+    /**
+     * The theme color for the document.
+     *
+     * @example
+     * ```tsx
+     * themeColor: "#000000"
+     * // Renders <meta name="theme-color" content="#000000" />
+     *
+     * themeColor: { media: "(prefers-color-scheme: dark)", color: "#000000" }
+     * // Renders <meta name="theme-color" media="(prefers-color-scheme: dark)" content="#000000" />
+     *
+     * themeColor: [
+     *  { media: "(prefers-color-scheme: dark)", color: "#000000" },
+     *  { media: "(prefers-color-scheme: light)", color: "#ffffff" }
+     * ]
+     * // Renders <meta name="theme-color" media="(prefers-color-scheme: dark)" content="#000000" />
+     * // Renders <meta name="theme-color" media="(prefers-color-scheme: light)" content="#ffffff" />
+     * ```
+     */
+    themeColor?: null | string | ThemeColorDescriptor | ThemeColorDescriptor[] | undefined;
+    /**
+     * The color scheme for the document.
+     *
+     * @example
+     * ```tsx
+     * colorScheme: "dark"
+     * // Renders <meta name="color-scheme" content="dark" />
+     * ```
+     */
+    colorScheme?: null | ColorSchemeEnum | undefined;
+}
+interface ResolvedViewport extends ViewportLayout {
+    themeColor: null | ThemeColorDescriptor[];
+    colorScheme: null | ColorSchemeEnum;
+}
+type ResolvingViewport = Promise<ResolvedViewport>;
+export type { Metadata, ResolvedMetadata, ResolvedMetadataWithURLs, ResolvingMetadata, MetadataRoute, Viewport, ResolvingViewport, ResolvedViewport, };

apps/public-web/node_modules/next/dist/lib/metadata/types/metadata-interface.js

@@ -0,0 +1,18 @@
+/**
+ * Next.js Metadata API
+ *
+ * This file defines the types used by Next.js to configure metadata
+ * through static exports or dynamic `generateMetadata` functions in Server Components.
+ *
+ * @remarks
+ * - The static `metadata` object and `generateMetadata` function are only supported in Server Components.
+ * - Do not export both a `metadata` object and a `generateMetadata` function from the same route segment.
+ * - You can still render metadata in client components directly as part of the component's JSX.
+ *
+ * @see https://nextjs.org/docs/app/api-reference/metadata
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=metadata-interface.js.map

apps/public-web/node_modules/next/dist/lib/metadata/types/metadata-types.d.ts

@@ -0,0 +1,145 @@
+/**
+ *
+ * Metadata types
+ *
+ */
+export interface DeprecatedMetadataFields {
+    /**
+     * Deprecated options that have a preferred method
+     * @deprecated Use appleWebApp instead
+     */
+    'apple-touch-fullscreen'?: never | undefined;
+    /**
+     * Obsolete since iOS 7.
+     * @see https://web.dev/apple-touch-icon/
+     * @deprecated Use icons.apple instead
+     */
+    'apple-touch-icon-precomposed'?: never | undefined;
+}
+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 | undefined;
+    name?: string | undefined;
+};
+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 | undefined;
+    follow?: boolean | undefined;
+    /** @deprecated set index to false instead */
+    noindex?: never | undefined;
+    /** @deprecated set follow to false instead */
+    nofollow?: never | undefined;
+    noarchive?: boolean | undefined;
+    nosnippet?: boolean | undefined;
+    noimageindex?: boolean | undefined;
+    nocache?: boolean | undefined;
+    notranslate?: boolean | undefined;
+    indexifembedded?: boolean | undefined;
+    nositelinkssearchbox?: boolean | undefined;
+    unavailable_after?: string | undefined;
+    'max-video-preview'?: number | string | undefined;
+    'max-image-preview'?: 'none' | 'standard' | 'large' | undefined;
+    'max-snippet'?: number | undefined;
+};
+export type Robots = RobotsInfo & {
+    googleBot?: string | RobotsInfo | undefined;
+};
+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 | undefined;
+    sizes?: string | undefined;
+    color?: string | undefined;
+    /** defaults to rel="icon" unless superseded by Icons map */
+    rel?: string | undefined;
+    media?: string | undefined;
+    /**
+     * @see https://developer.mozilla.org/docs/Web/API/HTMLImageElement/fetchPriority
+     */
+    fetchPriority?: 'high' | 'low' | 'auto' | undefined;
+};
+export type Icons = {
+    /** rel="icon" */
+    icon?: Icon | Icon[] | undefined;
+    /** rel="shortcut icon" */
+    shortcut?: Icon | Icon[] | undefined;
+    /**
+     * @see https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/ConfiguringWebApplications/ConfiguringWebApplications.html
+     * rel="apple-touch-icon"
+     */
+    apple?: Icon | Icon[] | undefined;
+    /** rel inferred from descriptor, defaults to "icon" */
+    other?: IconDescriptor | IconDescriptor[] | undefined;
+};
+export type Verification = {
+    google?: null | string | number | (string | number)[] | undefined;
+    yahoo?: null | string | number | (string | number)[] | undefined;
+    yandex?: null | string | number | (string | number)[] | undefined;
+    me?: null | string | number | (string | number)[] | undefined;
+    other?: {
+        [name: string]: string | number | (string | number)[];
+    } | undefined;
+};
+export type ResolvedVerification = {
+    google?: null | (string | number)[] | undefined;
+    yahoo?: null | (string | number)[] | undefined;
+    yandex?: null | (string | number)[] | undefined;
+    me?: null | (string | number)[] | undefined;
+    other?: {
+        [name: string]: (string | number)[];
+    } | undefined;
+};
+export type ResolvedIcons = {
+    icon: IconDescriptor[];
+    apple: IconDescriptor[];
+    shortcut?: IconDescriptor[] | undefined;
+    other?: IconDescriptor[] | undefined;
+};
+export type ThemeColorDescriptor = {
+    color: string;
+    media?: string | undefined;
+};
+export type Restriction = {
+    relationship: 'allow' | 'deny';
+    content: string;
+};
+export type Videos = {
+    title: string;
+    thumbnail_loc: string;
+    description: string;
+    content_loc?: string | undefined;
+    player_loc?: string | undefined;
+    duration?: number | undefined;
+    expiration_date?: Date | string | undefined;
+    rating?: number | undefined;
+    view_count?: number | undefined;
+    publication_date?: Date | string | undefined;
+    family_friendly?: 'yes' | 'no' | undefined;
+    restriction?: Restriction | undefined;
+    platform?: Restriction | undefined;
+    requires_subscription?: 'yes' | 'no' | undefined;
+    uploader?: {
+        info?: string | undefined;
+        content?: string | undefined;
+    } | undefined;
+    live?: 'yes' | 'no' | undefined;
+    tag?: string | undefined;
+};
+export {};

apps/public-web/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

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

apps/public-web/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

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

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

apps/public-web/node_modules/next/dist/lib/metadata/types/resolvers.d.ts

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

apps/public-web/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

apps/public-web/node_modules/next/dist/lib/metadata/types/resolvers.js.map

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

apps/public-web/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 | undefined;
+    siteId?: string | undefined;
+    creator?: string | undefined;
+    creatorId?: string | undefined;
+    description?: string | undefined;
+    title?: string | TemplateString | undefined;
+    images?: TwitterImage | Array<TwitterImage> | undefined;
+};
+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 | undefined;
+        ipad?: string | number | undefined;
+        googleplay?: string | undefined;
+    };
+    url?: {
+        iphone?: string | URL | undefined;
+        ipad?: string | URL | undefined;
+        googleplay?: string | URL | undefined;
+    } | undefined;
+    name?: string | undefined;
+};
+type TwitterImage = string | TwitterImageDescriptor | URL;
+type TwitterImageDescriptor = {
+    url: string | URL;
+    alt?: string | undefined;
+    secureUrl?: string | URL | undefined;
+    type?: string | undefined;
+    width?: string | number | undefined;
+    height?: string | number | undefined;
+};
+type TwitterPlayerDescriptor = {
+    playerUrl: string | URL;
+    streamUrl: string | URL;
+    width: number;
+    height: number;
+};
+type ResolvedTwitterImage = {
+    url: string | URL;
+    alt?: string | undefined;
+    secureUrl?: string | URL | undefined;
+    type?: string | undefined;
+    width?: string | number | undefined;
+    height?: string | number | undefined;
+};
+type ResolvedTwitterSummary = {
+    site: string | null;
+    siteId: string | null;
+    creator: string | null;
+    creatorId: string | null;
+    description: string | null;
+    title: AbsoluteTemplateString;
+    images?: Array<ResolvedTwitterImage> | undefined;
+};
+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 {};

apps/public-web/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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/metadata/types/twitter-types.ts"],"sourcesContent":["// Reference: https://developer.twitter.com/en/docs/twitter-for-websites/cards/overview/markup\n\nimport type { AbsoluteTemplateString, TemplateString } from './metadata-types'\n\nexport type Twitter =\n  | TwitterSummary\n  | TwitterSummaryLargeImage\n  | TwitterPlayer\n  | TwitterApp\n  | TwitterMetadata\n\ntype TwitterMetadata = {\n  // defaults to card=\"summary\"\n  site?: string | undefined // username for account associated to the site itself\n  siteId?: string | undefined // id for account associated to the site itself\n  creator?: string | undefined // username for the account associated to the creator of the content on the site\n  creatorId?: string | undefined // id for the account associated to the creator of the content on the site\n  description?: string | undefined\n  title?: string | TemplateString | undefined\n  images?: TwitterImage | Array<TwitterImage> | undefined\n}\ntype TwitterSummary = TwitterMetadata & {\n  card: 'summary'\n}\ntype TwitterSummaryLargeImage = TwitterMetadata & {\n  card: 'summary_large_image'\n}\ntype TwitterPlayer = TwitterMetadata & {\n  card: 'player'\n  players: TwitterPlayerDescriptor | Array<TwitterPlayerDescriptor>\n}\ntype TwitterApp = TwitterMetadata & {\n  card: 'app'\n  app: TwitterAppDescriptor\n}\nexport type TwitterAppDescriptor = {\n  id: {\n    iphone?: string | number | undefined\n    ipad?: string | number | undefined\n    googleplay?: string | undefined\n  }\n  url?:\n    | {\n        iphone?: string | URL | undefined\n        ipad?: string | URL | undefined\n        googleplay?: string | URL | undefined\n      }\n    | undefined\n  name?: string | undefined\n}\n\ntype TwitterImage = string | TwitterImageDescriptor | URL\ntype TwitterImageDescriptor = {\n  url: string | URL\n  alt?: string | undefined\n  secureUrl?: string | URL | undefined\n  type?: string | undefined\n  width?: string | number | undefined\n  height?: string | number | undefined\n}\ntype TwitterPlayerDescriptor = {\n  playerUrl: string | URL\n  streamUrl: string | URL\n  width: number\n  height: number\n}\n\ntype ResolvedTwitterImage = {\n  url: string | URL\n  alt?: string | undefined\n  secureUrl?: string | URL | undefined\n  type?: string | undefined\n  width?: string | number | undefined\n  height?: string | number | undefined\n}\ntype ResolvedTwitterSummary = {\n  site: string | null\n  siteId: string | null\n  creator: string | null\n  creatorId: string | null\n  description: string | null\n  title: AbsoluteTemplateString\n  images?: Array<ResolvedTwitterImage> | undefined\n}\ntype ResolvedTwitterPlayer = ResolvedTwitterSummary & {\n  players: Array<TwitterPlayerDescriptor>\n}\ntype ResolvedTwitterApp = ResolvedTwitterSummary & { app: TwitterAppDescriptor }\n\nexport type ResolvedTwitterMetadata =\n  | ({ card: 'summary' } & ResolvedTwitterSummary)\n  | ({ card: 'summary_large_image' } & ResolvedTwitterSummary)\n  | ({ card: 'player' } & ResolvedTwitterPlayer)\n  | ({ card: 'app' } & ResolvedTwitterApp)\n"],"names":[],"mappings":"AAAA,8FAA8F","ignoreList":[0]}