@obsfx/trekker 0.1.7 → 0.1.9

package/webapp-dist/vendor/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

package/webapp-dist/vendor/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

package/webapp-dist/vendor/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

package/webapp-dist/vendor/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