@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.30 → 3.5.0-ultramodern.32

package/dist/cjs/plugins/deploy/platforms/templates/cloudflare-entry.mjs

@@ -1,879 +0,0 @@
-const ASSETS_BINDING = 'ASSETS';
-const MODERN_WORKER_MANIFEST = p_workerManifest;
-const WORKER_MODULE_LOADERS = p_workerModuleLoaders;
-const workerModulePromises = new Map();
-const effectBffDispatcherPromises = new Map();
-let effectEdgeRuntimePromise;
-const remoteJsonPromises = new Map();
-const CORS_POLICY = MODERN_WORKER_MANIFEST.security?.cors || {};
-const ASSET_CORS_ENABLED = false !== CORS_POLICY.assets;
-const APP_CORS_ALLOWED_ORIGINS = (CORS_POLICY.allowedOrigins || []).map((origin)=>String(origin).toLowerCase());
-const APP_CORS_ALLOWED_METHODS = (CORS_POLICY.allowedMethods?.length ? CORS_POLICY.allowedMethods : [
-    'GET',
-    'HEAD',
-    'POST',
-    'PUT',
-    'PATCH',
-    'DELETE',
-    'OPTIONS'
-]).join(', ');
-const APP_CORS_ALLOWED_HEADERS = (CORS_POLICY.allowedHeaders?.length ? CORS_POLICY.allowedHeaders : [
-    '*'
-]).join(', ');
-const ASSET_CORS_HEADERS = {
-    'access-control-allow-headers': '*',
-    'access-control-allow-methods': 'GET, HEAD, OPTIONS',
-    'access-control-allow-origin': '*'
-};
-globalThis.__dirname ??= '/';
-globalThis.__filename ??= '/index.js';
-function getAllowedAppCorsOrigin(request) {
-    if (0 === APP_CORS_ALLOWED_ORIGINS.length) return null;
-    const origin = request.headers.get('origin');
-    if (!origin) return null;
-    if (APP_CORS_ALLOWED_ORIGINS.includes('*')) return '*';
-    return APP_CORS_ALLOWED_ORIGINS.includes(origin.toLowerCase()) ? origin : null;
-}
-function appendVaryOrigin(headers) {
-    const vary = headers.get('vary');
-    if (!vary) return void headers.set('vary', 'origin');
-    const varyValues = vary.split(',').map((value)=>value.trim().toLowerCase());
-    if (!varyValues.includes('origin')) headers.set('vary', `${vary}, origin`);
-}
-function withAppCorsHeaders(response, request) {
-    const allowedOrigin = getAllowedAppCorsOrigin(request);
-    if (!allowedOrigin) return response;
-    const headers = new Headers(response.headers);
-    if (!headers.has('access-control-allow-origin')) headers.set('access-control-allow-origin', allowedOrigin);
-    if ('*' !== allowedOrigin) appendVaryOrigin(headers);
-    return new Response(response.body, {
-        headers,
-        status: response.status,
-        statusText: response.statusText
-    });
-}
-function withAssetCorsHeaders(response) {
-    if (!ASSET_CORS_ENABLED) return response;
-    const headers = new Headers(response.headers);
-    for (const [name, value] of Object.entries(ASSET_CORS_HEADERS))if (!headers.has(name)) headers.set(name, value);
-    return new Response(response.body, {
-        headers,
-        status: response.status,
-        statusText: response.statusText
-    });
-}
-function setHeaderIfEnabled(headers, name, value) {
-    if (false === value || 'string' != typeof value || '' === value.trim()) return;
-    if (!headers.has(name)) headers.set(name, value);
-}
-function renderContentSecurityPolicy(directives) {
-    return Object.entries(directives || {}).filter(([, values])=>Array.isArray(values) && values.length > 0).sort(([left], [right])=>left.localeCompare(right)).map(([name, values])=>`${name} ${values.join(' ')}`).join('; ');
-}
-function isHtmlResponse(response) {
-    return (response.headers.get('content-type') || '').includes('text/html');
-}
-function matchesPreviewHostname(hostname, pattern) {
-    const normalizedHostname = hostname.toLowerCase();
-    const normalizedPattern = String(pattern || '').toLowerCase();
-    if (!normalizedPattern) return false;
-    if (normalizedPattern.startsWith('*.')) return normalizedHostname.endsWith(normalizedPattern.slice(1));
-    return normalizedHostname === normalizedPattern;
-}
-function shouldNoindex(request, noindex) {
-    if (!noindex || false === noindex) return false;
-    const { hostname } = new URL(request.url);
-    const normalizedHostname = hostname.toLowerCase();
-    if (false !== noindex.localhost && ('localhost' === normalizedHostname || '127.0.0.1' === normalizedHostname || '[::1]' === normalizedHostname)) return true;
-    if (false !== noindex.workersDev && normalizedHostname.endsWith('.workers.dev')) return true;
-    return (noindex.previewHostnames || []).some((pattern)=>matchesPreviewHostname(normalizedHostname, pattern));
-}
-function withCloudflareSecurityHeaders(response, request) {
-    const security = MODERN_WORKER_MANIFEST.security;
-    if (!security || false === security.enabled) return response;
-    const headers = new Headers(response.headers);
-    const configuredHeaders = security.headers || {};
-    setHeaderIfEnabled(headers, 'referrer-policy', configuredHeaders.referrerPolicy);
-    setHeaderIfEnabled(headers, 'x-content-type-options', configuredHeaders.contentTypeOptions);
-    setHeaderIfEnabled(headers, 'permissions-policy', configuredHeaders.permissionsPolicy);
-    const csp = security.contentSecurityPolicy;
-    const cspHeader = csp?.mode === 'enforce' ? 'content-security-policy' : 'content-security-policy-report-only';
-    const cspValue = renderContentSecurityPolicy(csp?.directives);
-    if (isHtmlResponse(response) && csp?.mode !== 'off' && cspValue && !headers.has(cspHeader)) headers.set(cspHeader, cspValue);
-    if (shouldNoindex(request, security.noindex)) headers.set('x-robots-tag', 'noindex, nofollow');
-    return new Response(response.body, {
-        headers,
-        status: response.status,
-        statusText: response.statusText
-    });
-}
-function createRenderableRequest(request) {
-    if ('HEAD' !== request.method) return request;
-    return new Request(request, {
-        method: 'GET'
-    });
-}
-function finalizeResponseForRequest(response, request) {
-    const securedResponse = withCloudflareSecurityHeaders(response, request);
-    if ('HEAD' !== request.method) return securedResponse;
-    const headers = new Headers(securedResponse.headers);
-    headers.delete('content-length');
-    return new Response(null, {
-        headers,
-        status: securedResponse.status,
-        statusText: securedResponse.statusText
-    });
-}
-function isFingerprintedAssetPathname(pathname) {
-    return /(?:^|\/)[^/]+\.[a-f0-9]{8,}\.(?:css|js|mjs|json|svg|png|jpe?g|webp|avif|gif|woff2?|ttf)$/iu.test(pathname);
-}
-function withAssetHeaders(response, request) {
-    const corsResponse = withAssetCorsHeaders(response);
-    const headers = new Headers(corsResponse.headers);
-    const { pathname } = new URL(request.url);
-    if (isFingerprintedAssetPathname(pathname)) headers.set('cache-control', 'public, max-age=31536000, immutable');
-    return new Response(corsResponse.body, {
-        headers,
-        status: corsResponse.status,
-        statusText: corsResponse.statusText
-    });
-}
-async function createCorsPreflightResponse(request, env) {
-    if ('OPTIONS' !== request.method) return null;
-    const allowedOrigin = getAllowedAppCorsOrigin(request);
-    if (allowedOrigin) {
-        const headers = new Headers({
-            'access-control-allow-headers': APP_CORS_ALLOWED_HEADERS,
-            'access-control-allow-methods': APP_CORS_ALLOWED_METHODS,
-            'access-control-allow-origin': allowedOrigin
-        });
-        if ('*' !== allowedOrigin) headers.set('vary', 'origin');
-        return new Response(null, {
-            headers,
-            status: 204
-        });
-    }
-    return null;
-}
-async function fetchAsset(request, env) {
-    if ('GET' !== request.method && 'HEAD' !== request.method) return null;
-    const assets = env?.[ASSETS_BINDING];
-    if (!assets || 'function' != typeof assets.fetch) return null;
-    const response = await assets.fetch(request);
-    if (404 === response.status) return null;
-    return withAssetHeaders(response, request);
-}
-async function fetchAssetByPath(pathname, request, env) {
-    const url = new URL(request.url);
-    url.pathname = `/${pathname.replace(/^\/+/u, '')}`;
-    return fetchAsset(new Request(url, request), env);
-}
-async function fetchAssetByPathFollowingRedirects(pathname, request, env, visited = new Set()) {
-    const normalizedPathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
-    if (visited.has(normalizedPathname)) return null;
-    visited.add(normalizedPathname);
-    const response = await fetchAssetByPath(normalizedPathname, request, env);
-    if (response && response.status >= 300 && response.status < 400 && response.headers.has('location')) {
-        const location = response.headers.get('location');
-        if (location) {
-            const nextUrl = new URL(location, request.url);
-            const currentUrl = new URL(request.url);
-            if (nextUrl.origin === currentUrl.origin) return fetchAssetByPathFollowingRedirects(nextUrl.pathname, request, env, visited);
-        }
-    }
-    return response;
-}
-async function readAssetText(pathname, request, env) {
-    const response = await fetchAssetByPathFollowingRedirects(pathname, request, env);
-    if (!response || !response.ok) return;
-    return response.text();
-}
-async function readAssetJson(pathname, request, env) {
-    const text = await readAssetText(pathname, request, env);
-    if (!text) return {};
-    return JSON.parse(text);
-}
-function normalizeRoutePath(pathname) {
-    if ('/' === pathname) return pathname;
-    return pathname.replace(/\/+$/u, '');
-}
-function getPathExtension(pathname) {
-    const lastSegment = pathname.split('/').pop() || '';
-    const dotIndex = lastSegment.lastIndexOf('.');
-    if (dotIndex <= 0 || dotIndex === lastSegment.length - 1) return '';
-    return lastSegment.slice(dotIndex).toLowerCase();
-}
-function isAssetLikePathname(pathname) {
-    const extension = getPathExtension(pathname);
-    return '' !== extension;
-}
-function routeMatchesExactly(route, pathname) {
-    if ('string' != typeof route?.urlPath) return false;
-    return normalizeRoutePath(route.urlPath) === normalizeRoutePath(pathname);
-}
-function routeMatches(route, pathname) {
-    if ('string' != typeof route.urlPath) return false;
-    const routePath = normalizeRoutePath(route.urlPath);
-    const requestPath = normalizeRoutePath(pathname);
-    return routePath === requestPath || '/' === routePath && route.isSSR || requestPath.startsWith(`${routePath}/`);
-}
-function getRouteI18nEntry(route) {
-    if (!route || 'string' != typeof route.entryName) return;
-    return MODERN_WORKER_MANIFEST.i18n?.entries?.[route.entryName];
-}
-function getRouteBasePath(route) {
-    const routePath = 'string' == typeof route?.urlPath ? normalizeRoutePath(route.urlPath) : '/';
-    return routePath || '/';
-}
-function getRouteRemainingPathname(route, pathname) {
-    const basePath = getRouteBasePath(route);
-    if ('/' === basePath) return pathname || '/';
-    if (!matchesPrefix(pathname, basePath)) return pathname || '/';
-    const remaining = pathname.slice(basePath.length);
-    return remaining ? remaining.startsWith('/') ? remaining : `/${remaining}` : '/';
-}
-function normalizeLanguage(value, languages) {
-    if ('string' != typeof value || '' === value.trim()) return null;
-    const normalized = value.trim().toLowerCase();
-    const exact = languages.find((language)=>language.toLowerCase() === normalized);
-    if (exact) return exact;
-    const baseLanguage = normalized.split(/[-_]/u)[0];
-    return languages.find((language)=>language.toLowerCase() === baseLanguage) || null;
-}
-function getLanguageFromPath(route, pathname, languages) {
-    const remainingPathname = getRouteRemainingPathname(route, pathname);
-    const firstSegment = remainingPathname.split('/').filter(Boolean)[0];
-    return normalizeLanguage(firstSegment, languages);
-}
-function safeDecodeURIComponent(value) {
-    try {
-        return decodeURIComponent(value);
-    } catch  {
-        return value;
-    }
-}
-function detectLanguageFromCookie(cookieHeader, lookupCookie, languages) {
-    if (!cookieHeader) return null;
-    for (const cookiePart of cookieHeader.split(';')){
-        const [rawName, ...rawValue] = cookiePart.trim().split('=');
-        if (rawName === lookupCookie && 0 !== rawValue.length) return normalizeLanguage(safeDecodeURIComponent(rawValue.join('=')), languages);
-    }
-    return null;
-}
-function detectLanguageFromAcceptLanguage(acceptLanguage, languages) {
-    if (!acceptLanguage) return null;
-    return acceptLanguage.split(',').map((entry, index)=>{
-        const [rawRange, ...rawParameters] = entry.trim().split(';');
-        const qualityParameter = rawParameters.find((parameter)=>parameter.trim().startsWith('q='));
-        const quality = qualityParameter ? Number.parseFloat(qualityParameter.split('=')[1] || '') : 1;
-        return {
-            index,
-            language: normalizeLanguage(rawRange, languages),
-            quality: Number.isFinite(quality) ? quality : 1
-        };
-    }).filter((candidate)=>candidate.language && candidate.quality > 0).sort((left, right)=>right.quality - left.quality || left.index - right.index)[0]?.language || null;
-}
-function detectRedirectLanguage(request, entry) {
-    if (!entry.i18nextDetector) return null;
-    const url = new URL(request.url);
-    const detection = entry.detection || {};
-    const order = Array.isArray(detection.order) ? detection.order : [
-        'querystring',
-        'cookie',
-        'header'
-    ];
-    for (const method of order){
-        const language = 'querystring' === method ? normalizeLanguage(url.searchParams.get(detection.lookupQuerystring || 'lng'), entry.languages) : 'cookie' === method ? detectLanguageFromCookie(request.headers.get('cookie'), detection.lookupCookie || 'i18next', entry.languages) : 'header' === method ? detectLanguageFromAcceptLanguage(request.headers.get(detection.lookupHeader || 'accept-language'), entry.languages) : null;
-        if (language) return language;
-    }
-    return null;
-}
-function normaliseSlashes(pathname) {
-    const withoutDuplicateSlashes = pathname.replace(/\/+/g, '/');
-    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
-    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/u, '') : withLeadingSlash;
-}
-function normalisePathPattern(pathname) {
-    return normaliseSlashes(pathname).replace(/\[(.+?)\]/g, ':$1');
-}
-function stripLanguagePrefix(pathname, languages) {
-    const segments = pathname.split('/').filter(Boolean);
-    const firstSegment = segments[0];
-    if (firstSegment && normalizeLanguage(firstSegment, languages)) return `/${segments.slice(1).join('/')}` || '/';
-    return pathname || '/';
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function getPatternParamName(segment) {
-    return segment.slice(1).replace(/\?$/, '');
-}
-function compilePathPattern(pattern) {
-    const names = [];
-    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
-    const source = segments.map((segment)=>{
-        if (segment.startsWith(':')) {
-            names.push(getPatternParamName(segment));
-            return segment.endsWith('?') ? '(?:/([^/]+))?' : '/([^/]+)';
-        }
-        if ('*' === segment) {
-            names.push('*');
-            return '/(.*)';
-        }
-        return `/${escapeRegExp(segment)}`;
-    }).join('');
-    return {
-        names,
-        regexp: new RegExp(`^${source || '/'}$`)
-    };
-}
-function matchPathPattern(pathname, pattern) {
-    const { names, regexp } = compilePathPattern(pattern);
-    const match = regexp.exec(normaliseSlashes(pathname));
-    if (!match) return null;
-    const params = {};
-    for(let index = 0; index < names.length; index++)try {
-        params[names[index]] = decodeURIComponent(match[index + 1] || '');
-    } catch  {
-        return null;
-    }
-    return params;
-}
-function buildPathFromPattern(pattern, params) {
-    const path = normalisePathPattern(pattern).split('/').filter(Boolean).map((segment)=>{
-        if (segment.startsWith(':')) {
-            const param = params[getPatternParamName(segment)];
-            return param ? encodeURIComponent(param) : '';
-        }
-        if ('*' === segment) return params['*'] || '';
-        return segment;
-    }).filter(Boolean).join('/');
-    return `/${path}`;
-}
-function patternSpecificity(pattern) {
-    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
-    let staticSegments = 0;
-    let dynamicSegments = 0;
-    let splatSegments = 0;
-    for (const segment of segments)if ('*' === segment) splatSegments++;
-    else if (segment.startsWith(':')) dynamicSegments++;
-    else staticSegments++;
-    return {
-        dynamicSegments,
-        splatSegments,
-        staticSegments,
-        totalSegments: segments.length
-    };
-}
-function comparePatternSpecificity(left, right) {
-    const leftSpecificity = patternSpecificity(left);
-    const rightSpecificity = patternSpecificity(right);
-    return rightSpecificity.staticSegments - leftSpecificity.staticSegments || rightSpecificity.totalSegments - leftSpecificity.totalSegments || leftSpecificity.splatSegments - rightSpecificity.splatSegments || leftSpecificity.dynamicSegments - rightSpecificity.dynamicSegments;
-}
-function sortLocalisedPatterns(patterns) {
-    return patterns.map((pattern, index)=>({
-            pattern,
-            index
-        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
-}
-function resolveLocalisedPath(pathname, targetLanguage, languages, localisedUrls) {
-    const normalizedPathname = normaliseSlashes(pathname);
-    const canonicalCandidates = sortLocalisedPatterns(Object.entries(localisedUrls || {}).map(([canonicalPattern, localisedUrlEntry])=>({
-            canonicalPattern,
-            localisedUrlEntry,
-            pattern: canonicalPattern
-        })));
-    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
-        const targetPattern = localisedUrlEntry[targetLanguage];
-        const params = targetPattern ? matchPathPattern(normalizedPathname, canonicalPattern) : null;
-        if (params) return buildPathFromPattern(targetPattern, params);
-    }
-    const localisedCandidates = sortLocalisedPatterns(Object.values(localisedUrls || {}).flatMap((localisedUrlEntry)=>{
-        const targetPattern = localisedUrlEntry[targetLanguage];
-        if (!targetPattern) return [];
-        return languages.map((language)=>localisedUrlEntry[language]).filter(Boolean).map((sourcePattern)=>({
-                pattern: sourcePattern,
-                sourcePattern,
-                targetPattern
-            }));
-    }));
-    for (const { sourcePattern, targetPattern } of localisedCandidates){
-        const params = matchPathPattern(normalizedPathname, sourcePattern);
-        if (params) return buildPathFromPattern(targetPattern, params);
-    }
-    return normalizedPathname;
-}
-function localiseTargetPathname(pathname, language, languages, localisedUrls) {
-    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
-    const resolvedPath = localisedUrls ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrls) : pathWithoutLanguage;
-    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
-    return `/${[
-        language,
-        ...resolvedSegments
-    ].join('/')}`;
-}
-function shouldIgnoreLocaleRedirect(pathname, route, entry) {
-    const remainingPathname = getRouteRemainingPathname(route, pathname);
-    const normalizedPathname = remainingPathname.startsWith('/') ? remainingPathname : `/${remainingPathname}`;
-    const ignoredPrefixes = [
-        ...entry.ignoreRedirectRoutes || [],
-        ...entry.staticRoutePrefixes || [],
-        '/static',
-        '/upload'
-    ];
-    return ignoredPrefixes.some((prefix)=>{
-        const normalizedPrefix = normaliseSlashes(prefix);
-        return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
-    });
-}
-function buildLocalizedUrl(route, request, language, entry) {
-    const url = new URL(request.url);
-    const basePath = getRouteBasePath(route);
-    const remainingPathname = getRouteRemainingPathname(route, url.pathname);
-    const localizedPathname = localiseTargetPathname(remainingPathname, language, entry.languages, entry.localisedUrls);
-    const nextPathname = '/' === basePath ? localizedPathname : normaliseSlashes(`${basePath}/${localizedPathname}`);
-    return `${nextPathname}${url.search}`;
-}
-function createLocaleRedirectResponse(location, entry) {
-    const headers = new Headers({
-        'cache-control': 'private, no-store',
-        location
-    });
-    const vary = [];
-    const detectionOrder = entry.i18nextDetector ? entry.detection?.order || [] : [];
-    if (detectionOrder.includes('header')) vary.push('Accept-Language');
-    if (detectionOrder.includes('cookie')) vary.push('Cookie');
-    if (vary.length > 0) headers.set('vary', vary.join(', '));
-    return new Response(null, {
-        headers,
-        status: 302
-    });
-}
-function createLocaleRedirectResponseForRequest(route, request) {
-    const entry = getRouteI18nEntry(route);
-    if (!entry || !Array.isArray(entry.languages) || 0 === entry.languages.length) return null;
-    const { pathname, search } = new URL(request.url);
-    if (isAssetLikePathname(pathname)) return null;
-    if (shouldIgnoreLocaleRedirect(pathname, route, entry)) return null;
-    const language = getLanguageFromPath(route, pathname, entry.languages);
-    if (!language) {
-        const targetLanguage = detectRedirectLanguage(request, entry) || entry.fallbackLanguage;
-        return createLocaleRedirectResponse(buildLocalizedUrl(route, request, targetLanguage, entry), entry);
-    }
-    if (entry.localisedUrls) {
-        const expectedUrl = buildLocalizedUrl(route, request, language, entry);
-        if (expectedUrl !== `${pathname}${search}`) return createLocaleRedirectResponse(expectedUrl, entry);
-    }
-    return null;
-}
-function findRoute(request) {
-    const { pathname } = new URL(request.url);
-    const routes = MODERN_WORKER_MANIFEST.routeSpec.routes;
-    return [
-        ...routes
-    ].sort((left, right)=>{
-        const leftLength = left.urlPath?.length || 0;
-        const rightLength = right.urlPath?.length || 0;
-        return rightLength - leftLength;
-    }).find((route)=>routeMatches(route, pathname));
-}
-async function fetchRouteHtml(route, request, env) {
-    if (!route?.entryPath) return null;
-    return fetchAssetByPath(route.entryPath, request, env);
-}
-function createNoopMonitors() {
-    const noop = ()=>{};
-    return {
-        debug: noop,
-        error: noop,
-        info: noop,
-        warn: noop
-    };
-}
-function createRequestHandlerOptions({ route, htmlTemplate, routeManifest, loadableStats }) {
-    const monitors = createNoopMonitors();
-    return {
-        resource: {
-            route,
-            routeManifest,
-            loadableStats,
-            htmlTemplate,
-            entryName: route.entryName
-        },
-        params: {},
-        loaderContext: {},
-        config: {},
-        locals: {},
-        staticGenerate: false,
-        monitors,
-        onError (error) {
-            monitors.error(error);
-        },
-        onTiming () {},
-        reporter: {
-            reportTiming: ()=>{}
-        }
-    };
-}
-function collectRouteCssAssets(route, routeManifest) {
-    const routeAssets = routeManifest?.routeAssets || {};
-    const candidateKeys = [
-        route.entryName,
-        `async-${route.entryName}`
-    ].filter(Boolean);
-    const assets = new Set();
-    for (const key of candidateKeys){
-        const routeAsset = routeAssets[key];
-        const cssAssets = [
-            ...Array.isArray(routeAsset?.referenceCssAssets) ? routeAsset.referenceCssAssets : [],
-            ...Array.isArray(routeAsset?.assets) ? routeAsset.assets : []
-        ];
-        for (const asset of cssAssets)if ('string' == typeof asset && asset.endsWith('.css')) assets.add(asset);
-    }
-    return [
-        ...assets
-    ];
-}
-function collectRenderedFederatedExposes(html) {
-    const renderedExposes = [];
-    const tagPattern = /<[^>]*data-modern-(?:boundary-id|mf-expose)=["'][^"']+["'][^>]*>/g;
-    const attributePattern = /\s(data-modern-(?:boundary-id|mf-expose))=["']([^"']+)["']/g;
-    for (const [tag] of html.matchAll(tagPattern)){
-        const attributes = {};
-        for (const [, name, value] of tag.matchAll(attributePattern))attributes[name] = value;
-        const boundaryId = attributes['data-modern-boundary-id'];
-        const expose = attributes['data-modern-mf-expose'];
-        if (boundaryId && expose) renderedExposes.push({
-            boundaryId,
-            expose
-        });
-    }
-    return renderedExposes;
-}
-function getRemoteManifestUrl(remote, request) {
-    const entry = remote?.entry;
-    if ('string' != typeof entry || 0 === entry.length) return;
-    return new URL(entry, request.url).toString();
-}
-function ensureTrailingSlash(value) {
-    return value.endsWith('/') ? value : `${value}/`;
-}
-function getRemoteAssetBase(remoteManifest, manifestUrl) {
-    const publicPath = 'string' == typeof remoteManifest?.metaData?.publicPath ? remoteManifest.metaData.publicPath : void 0;
-    const fallbackBase = new URL('.', manifestUrl).toString();
-    if (!publicPath || 'auto' === publicPath) return fallbackBase;
-    try {
-        return new URL(ensureTrailingSlash(publicPath), manifestUrl).toString();
-    } catch  {
-        return fallbackBase;
-    }
-}
-async function fetchRemoteJson(jsonUrl) {
-    if (!remoteJsonPromises.has(jsonUrl)) remoteJsonPromises.set(jsonUrl, fetch(jsonUrl).then((response)=>{
-        if (!response.ok) {
-            remoteJsonPromises.delete(jsonUrl);
-            return {};
-        }
-        return response.json().catch(()=>{
-            remoteJsonPromises.delete(jsonUrl);
-            return {};
-        });
-    }).catch(()=>{
-        remoteJsonPromises.delete(jsonUrl);
-        return {};
-    }));
-    return remoteJsonPromises.get(jsonUrl);
-}
-function findRemoteExpose(remoteManifest, exposePath) {
-    const exposes = Array.isArray(remoteManifest?.exposes) ? remoteManifest.exposes : [];
-    const normalizedExpose = exposePath.replace(/^\.\//u, '');
-    return exposes.find((expose)=>{
-        if (!expose || 'object' != typeof expose) return false;
-        return expose.path === exposePath || expose.path === `./${normalizedExpose}` || expose.name === normalizedExpose;
-    });
-}
-function collectCssAssetEntries(assets) {
-    const cssAssets = assets?.css;
-    return [
-        ...Array.isArray(cssAssets?.sync) ? cssAssets.sync : [],
-        ...Array.isArray(cssAssets?.async) ? cssAssets.async : []
-    ].filter((asset)=>'string' == typeof asset && asset.endsWith('.css'));
-}
-function collectRouteManifestCssAssets(routeManifest) {
-    const routeAssets = routeManifest?.routeAssets || {};
-    const assets = new Set();
-    for (const routeAsset of Object.values(routeAssets)){
-        const cssAssets = [
-            ...Array.isArray(routeAsset?.referenceCssAssets) ? routeAsset.referenceCssAssets : [],
-            ...Array.isArray(routeAsset?.assets) ? routeAsset.assets : []
-        ];
-        for (const asset of cssAssets)if ('string' == typeof asset && asset.endsWith('.css')) assets.add(asset);
-    }
-    return [
-        ...assets
-    ];
-}
-async function collectRenderedRemoteCssHrefs(html, request, env) {
-    const renderedExposes = collectRenderedFederatedExposes(html);
-    if (0 === renderedExposes.length) return [];
-    const hostManifest = await readAssetJson('mf-manifest.json', request, env);
-    const remotes = Array.isArray(hostManifest?.remotes) ? hostManifest.remotes : [];
-    const remoteByBoundary = new Map();
-    const hrefs = new Set();
-    for (const remote of remotes){
-        if ('string' == typeof remote?.alias) remoteByBoundary.set(remote.alias, remote);
-        if ('string' == typeof remote?.federationContainerName) remoteByBoundary.set(remote.federationContainerName, remote);
-    }
-    await Promise.all(renderedExposes.map(async ({ boundaryId, expose })=>{
-        const remote = remoteByBoundary.get(boundaryId);
-        const manifestUrl = remote ? getRemoteManifestUrl(remote, request) : void 0;
-        if (!manifestUrl) return;
-        const remoteManifest = await fetchRemoteJson(manifestUrl);
-        const remoteExpose = findRemoteExpose(remoteManifest, expose);
-        const publicPath = getRemoteAssetBase(remoteManifest, manifestUrl);
-        const remoteRouteManifest = await fetchRemoteJson(new URL('routes-manifest.json', publicPath).toString());
-        for (const asset of collectCssAssetEntries(remoteExpose?.assets))hrefs.add(new URL(asset, publicPath).toString());
-        for (const asset of collectRouteManifestCssAssets(remoteRouteManifest))hrefs.add(new URL(asset, publicPath).toString());
-    }));
-    return [
-        ...hrefs
-    ];
-}
-function escapeAttribute(value) {
-    return String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-}
-function isAbsoluteUrl(value) {
-    return /^[a-z][a-z\d+.-]*:/iu.test(value);
-}
-function toRouteCssHtmlHref(asset) {
-    if (isAbsoluteUrl(asset) || asset.startsWith('/')) return asset;
-    return `/${asset.replace(/^\/+/u, '')}`;
-}
-async function withRouteCssLinks(response, route, routeManifest, request, env) {
-    const contentType = response.headers.get('content-type') || '';
-    if (!contentType.includes('text/html')) return response;
-    const html = await response.text();
-    const cssEntries = [
-        ...collectRouteCssAssets(route, routeManifest).map((asset)=>{
-            const href = toRouteCssHtmlHref(asset);
-            return {
-                href,
-                preloadHref: new URL(href, request.url).toString()
-            };
-        }),
-        ...(await collectRenderedRemoteCssHrefs(html, request, env)).map((href)=>({
-                href,
-                preloadHref: new URL(href, request.url).toString()
-            }))
-    ];
-    if (0 === cssEntries.length) return response;
-    const seenCssHrefs = new Set();
-    const uniqueCssEntries = cssEntries.filter((entry)=>{
-        if (seenCssHrefs.has(entry.preloadHref)) return false;
-        seenCssHrefs.add(entry.preloadHref);
-        return true;
-    });
-    const headers = new Headers(response.headers);
-    for (const { preloadHref } of uniqueCssEntries)headers.append('link', `<${preloadHref}>; rel=preload; as=style`);
-    const links = uniqueCssEntries.filter(({ href, preloadHref })=>!html.includes(href) && !html.includes(preloadHref)).map(({ href })=>`<link rel="stylesheet" href="${escapeAttribute(href)}">`);
-    if (0 === links.length || !html.includes('</head>')) return new Response(html, {
-        headers,
-        status: response.status,
-        statusText: response.statusText
-    });
-    return new Response(html.replace('</head>', `${links.join('')}</head>`), {
-        headers,
-        status: response.status,
-        statusText: response.statusText
-    });
-}
-async function getRequestHandlerOptions(route, request, env) {
-    const [htmlTemplate, routeManifest, loadableStats] = await Promise.all([
-        readAssetText(route.entryPath, request, env),
-        readAssetJson(MODERN_WORKER_MANIFEST.resources.routeManifest, request, env),
-        readAssetJson(MODERN_WORKER_MANIFEST.resources.loadableStats, request, env)
-    ]);
-    return createRequestHandlerOptions({
-        route,
-        htmlTemplate: htmlTemplate || '',
-        routeManifest,
-        loadableStats
-    });
-}
-async function loadWorkerModule(workerPath) {
-    const loader = WORKER_MODULE_LOADERS[workerPath];
-    if (!loader) return;
-    if (!workerModulePromises.has(workerPath)) workerModulePromises.set(workerPath, loader());
-    return workerModulePromises.get(workerPath);
-}
-async function loadEffectEdgeRuntime() {
-    effectEdgeRuntimePromise ??= import('@modern-js/plugin-bff/effect-edge');
-    return effectEdgeRuntimePromise;
-}
-function getRuntimeModule(workerModule) {
-    const defaultExport = workerModule.default;
-    const nestedDefaultExport = defaultExport && 'object' == typeof defaultExport ? defaultExport.default : void 0;
-    return defaultExport && 'object' == typeof defaultExport ? {
-        ...workerModule,
-        ...defaultExport,
-        ...nestedDefaultExport && 'object' == typeof nestedDefaultExport ? nestedDefaultExport : {}
-    } : workerModule;
-}
-function getFetchHandler(workerModule) {
-    const defaultExport = workerModule.default;
-    const runtime = getRuntimeModule(workerModule);
-    return 'function' == typeof runtime.fetch && runtime.fetch.bind(runtime) || 'function' == typeof defaultExport && defaultExport.fetch?.bind?.(defaultExport);
-}
-async function getRequestHandler(workerModule) {
-    const defaultExport = workerModule.default;
-    const runtime = getRuntimeModule(workerModule);
-    return await workerModule.requestHandler || await runtime.requestHandler || ('function' == typeof defaultExport ? defaultExport : void 0);
-}
-async function dispatchRouteWorker(route, request, env, ctx) {
-    const workerPath = route.worker;
-    if (!workerPath) return new Response('Worker bundle not configured for SSR route', {
-        status: 500,
-        headers: {
-            'content-type': 'text/plain; charset=utf-8'
-        }
-    });
-    const workerModule = await loadWorkerModule(workerPath);
-    if (!workerModule) return new Response(`Worker bundle not found: ${workerPath}`, {
-        status: 500,
-        headers: {
-            'content-type': 'text/plain; charset=utf-8',
-            'x-modern-js-route-worker': workerPath
-        }
-    });
-    const fetchHandler = getFetchHandler(workerModule);
-    if (fetchHandler) return fetchHandler(request, env, ctx);
-    const requestHandler = await getRequestHandler(workerModule);
-    if ('function' == typeof requestHandler) {
-        const requestHandlerOptions = await getRequestHandlerOptions(route, request, env);
-        return withRouteCssLinks(await requestHandler(request, requestHandlerOptions), route, requestHandlerOptions.resource.routeManifest, request, env);
-    }
-    return new Response(`Worker bundle has no fetch or requestHandler export: ${workerPath}`, {
-        status: 500,
-        headers: {
-            'content-type': 'text/plain; charset=utf-8',
-            'x-modern-js-route-worker': workerPath
-        }
-    });
-}
-function matchesPrefix(pathname, prefix) {
-    if (!prefix || '/' === prefix) return true;
-    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-    return pathname === normalized || pathname.startsWith(`${normalized}/`);
-}
-function createRequestForMountedPrefix(request, prefix) {
-    if (!prefix || '/' === prefix) return request;
-    const url = new URL(request.url);
-    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-    if (!matchesPrefix(url.pathname, normalized)) return request;
-    const nextPath = url.pathname.slice(normalized.length) || '/';
-    url.pathname = nextPath.startsWith('/') ? nextPath : `/${nextPath}`;
-    return new Request(url, request);
-}
-async function dispatchBffRequest(request, env) {
-    const bff = MODERN_WORKER_MANIFEST.bff;
-    if (!bff?.worker || !matchesPrefix(new URL(request.url).pathname, bff.prefix)) return null;
-    const workerModule = await loadWorkerModule(bff.worker);
-    if (!workerModule) return new Response(`BFF worker bundle not found: ${bff.worker}`, {
-        status: 500,
-        headers: {
-            'content-type': 'text/plain; charset=utf-8',
-            'x-modern-js-bff-worker': bff.worker
-        }
-    });
-    const mountedRequest = createRequestForMountedPrefix(request, bff.prefix);
-    const defaultExport = workerModule.default;
-    const runtime = getRuntimeModule(workerModule);
-    if ('effect' === bff.runtimeFramework) {
-        let effectDispatcherPromise = effectBffDispatcherPromises.get(bff.worker);
-        if (!effectDispatcherPromise) {
-            const { createEffectBffEdgeDispatcher } = await loadEffectEdgeRuntime();
-            effectDispatcherPromise = createEffectBffEdgeDispatcher({
-                module: runtime,
-                prefix: bff.prefix
-            });
-            effectBffDispatcherPromises.set(bff.worker, effectDispatcherPromise);
-        }
-        const effectDispatcher = await effectDispatcherPromise;
-        return effectDispatcher.dispatch(request, {
-            env
-        });
-    }
-    const directHandler = 'function' == typeof runtime.handler && runtime.handler || 'function' == typeof defaultExport && defaultExport;
-    const createdHandler = 'function' == typeof runtime.createHandler ? runtime.createHandler().handler : void 0;
-    const handler = directHandler || createdHandler;
-    if ('function' != typeof handler) return new Response(`BFF worker bundle has no handler export: ${bff.worker}`, {
-        status: 500,
-        headers: {
-            'content-type': 'text/plain; charset=utf-8',
-            'x-modern-js-bff-worker': bff.worker
-        }
-    });
-    const effectContext = {
-        request: mountedRequest,
-        env: env || {},
-        path: new URL(request.url).pathname,
-        method: request.method,
-        operationContext: {
-            request: mountedRequest,
-            env: env || {},
-            path: new URL(request.url).pathname,
-            method: request.method
-        }
-    };
-    return handler(mountedRequest, effectContext);
-}
-async function dispatchServiceBindingRequest(request, env) {
-    const serviceBindings = MODERN_WORKER_MANIFEST.serviceBindings;
-    if (!Array.isArray(serviceBindings) || 0 === serviceBindings.length) return null;
-    const pathname = new URL(request.url).pathname;
-    for (const binding of serviceBindings){
-        if (!binding?.binding || !binding?.prefix) continue;
-        if (!matchesPrefix(pathname, binding.prefix)) continue;
-        const service = env?.[binding.binding];
-        if (!service || 'function' != typeof service.fetch) return new Response(`Cloudflare service binding not available: ${binding.binding}`, {
-            status: 502,
-            headers: {
-                'content-type': 'text/plain; charset=utf-8',
-                'x-modern-js-service-binding': binding.binding
-            }
-        });
-        return service.fetch(request);
-    }
-    return null;
-}
-export default {
-    async fetch (request, env, ctx) {
-        const corsPreflightResponse = await createCorsPreflightResponse(request, env);
-        if (corsPreflightResponse) return finalizeResponseForRequest(corsPreflightResponse, request);
-        const bffResponse = await dispatchBffRequest(request, env);
-        if (bffResponse) return finalizeResponseForRequest(withAppCorsHeaders(bffResponse, request), request);
-        const serviceBindingResponse = await dispatchServiceBindingRequest(request, env);
-        if (serviceBindingResponse) return finalizeResponseForRequest(withAppCorsHeaders(serviceBindingResponse, request), request);
-        const route = findRoute(request);
-        const { pathname } = new URL(request.url);
-        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) {
-            const assetResponse = await fetchAsset(request, env);
-            if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
-            return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
-                status: 404
-            }), request), request);
-        }
-        const localeRedirectResponse = createLocaleRedirectResponseForRequest(route, request);
-        if (localeRedirectResponse) return finalizeResponseForRequest(withAppCorsHeaders(localeRedirectResponse, request), request);
-        if (route?.worker) {
-            const renderableRequest = createRenderableRequest(request);
-            return finalizeResponseForRequest(withAppCorsHeaders(await dispatchRouteWorker(route, renderableRequest, env, ctx), request), request);
-        }
-        const htmlResponse = await fetchRouteHtml(route, request, env);
-        if (htmlResponse) return finalizeResponseForRequest(htmlResponse, request);
-        const assetResponse = await fetchAsset(request, env);
-        if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
-        return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
-            status: 404
-        }), request), request);
-    }
-};