Graybyt3 Was Here

Linux vps-4656817-x.dattaweb.com 5.14.0-570.33.2.el9_6.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Aug 14 07:37:35 EDT 2025 x86_64
Apache
200.58.107.103

File Name : _@astrojs-ssr-adapter_BPR9fzy2.mjs

import { j as decryptString, k as createSlotValueFromString, l as isAstroComponentFactory, r as renderTemplate, a as renderComponent, R as ROUTE_TYPE_HEADER, n as REROUTE_DIRECTIVE_HEADER, A as AstroError, o as i18nNoLocaleFoundInPath, p as ResponseSentError, M as MiddlewareNoDataOrNextCalled, q as MiddlewareNotAResponse, s as RewriteWithBodyUsed, t as originPathnameSymbol, G as GetStaticPathsRequired, I as InvalidGetStaticPathsReturn, v as InvalidGetStaticPathsEntry, w as GetStaticPathsExpectedParams, x as GetStaticPathsInvalidRouteParam, P as PageNumberParamNotFound, D as DEFAULT_404_COMPONENT, N as NoMatchingStaticPathFound, y as PrerenderDynamicEndpointPathCollide, z as ReservedSlotName, B as renderSlotToString, C as renderJSX, E as chunkToString, H as isRenderInstruction, J as ForbiddenRewrite, S as SessionStorageSaveError, K as SessionStorageInitError, L as LocalsReassigned, O as AstroResponseHeadersReassigned, Q as PrerenderClientAddressNotAvailable, T as clientAddressSymbol, U as ClientAddressNotAvailable, V as StaticClientAddressNotAvailable, W as ASTRO_VERSION, X as responseSentSymbol$1, Y as renderPage, Z as REWRITE_DIRECTIVE_HEADER_KEY, _ as REWRITE_DIRECTIVE_HEADER_VALUE, $ as renderEndpoint, a0 as LocalsNotAnObject, a1 as REROUTABLE_STATUS_CODES } from './astro/server_WNk0quGO.mjs';
import { appendForwardSlash as appendForwardSlash$1, joinPaths, removeTrailingForwardSlash, trimSlashes, fileExtension, slash, prependForwardSlash as prependForwardSlash$1, collapseDuplicateTrailingSlashes, hasFileExtension } from '@astrojs/internal-helpers/path';
import { bold, red, yellow, dim, blue } from 'kleur/colors';
import 'clsx';
import { serialize, parse } from 'cookie';
import { g as getActionQueryString, d as deserializeActionResult, D as DEFAULT_404_ROUTE, a as default404Instance, N as NOOP_MIDDLEWARE_FN, e as ensure404Route } from './astro-designed-error-pages_DkGPf607.mjs';
import 'es-module-lexer';
import buffer from 'node:buffer';
import crypto$1 from 'node:crypto';
import { Http2ServerResponse } from 'node:http2';
import { unflatten as unflatten$1, stringify as stringify$1 } from 'devalue';
import { createStorage, builtinDrivers } from 'unstorage';
import { s as setGetEnv } from './runtime_x9uYhqlb.mjs';
import { AsyncLocalStorage } from 'node:async_hooks';
import fs from 'node:fs';
import http from 'node:http';
import https from 'node:https';
import enableDestroy from 'server-destroy';
import os from 'node:os';
import path from 'node:path';
import url from 'node:url';
import send from 'send';

const ACTION_API_CONTEXT_SYMBOL = Symbol.for("astro.actionAPIContext");

async function callMiddleware(onRequest, apiContext, responseFunction) {
  let nextCalled = false;
  let responseFunctionPromise = undefined;
  const next = async (payload) => {
    nextCalled = true;
    responseFunctionPromise = responseFunction(apiContext, payload);
    return responseFunctionPromise;
  };
  let middlewarePromise = onRequest(apiContext, next);
  return await Promise.resolve(middlewarePromise).then(async (value) => {
    if (nextCalled) {
      if (typeof value !== "undefined") {
        if (value instanceof Response === false) {
          throw new AstroError(MiddlewareNotAResponse);
        }
        return value;
      } else {
        if (responseFunctionPromise) {
          return responseFunctionPromise;
        } else {
          throw new AstroError(MiddlewareNotAResponse);
        }
      }
    } else if (typeof value === "undefined") {
      throw new AstroError(MiddlewareNoDataOrNextCalled);
    } else if (value instanceof Response === false) {
      throw new AstroError(MiddlewareNotAResponse);
    } else {
      return value;
    }
  });
}

async function callGetStaticPaths({
  mod,
  route,
  routeCache,
  logger,
  ssr,
  base
}) {
  const cached = routeCache.get(route);
  if (!mod) {
    throw new Error("This is an error caused by Astro and not your code. Please file an issue.");
  }
  if (cached?.staticPaths) {
    return cached.staticPaths;
  }
  validateDynamicRouteModule(mod, { ssr, route });
  if (ssr && !route.prerender) {
    const entry = Object.assign([], { keyed: /* @__PURE__ */ new Map() });
    routeCache.set(route, { ...cached, staticPaths: entry });
    return entry;
  }
  let staticPaths = [];
  if (!mod.getStaticPaths) {
    throw new Error("Unexpected Error.");
  }
  staticPaths = await mod.getStaticPaths({
    // Q: Why the cast?
    // A: So users downstream can have nicer typings, we have to make some sacrifice in our internal typings, which necessitate a cast here
    paginate: generatePaginateFunction(route, base)
  });
  validateGetStaticPathsResult(staticPaths, logger, route);
  const keyedStaticPaths = staticPaths;
  keyedStaticPaths.keyed = /* @__PURE__ */ new Map();
  for (const sp of keyedStaticPaths) {
    const paramsKey = stringifyParams(sp.params, route);
    keyedStaticPaths.keyed.set(paramsKey, sp);
  }
  routeCache.set(route, { ...cached, staticPaths: keyedStaticPaths });
  return keyedStaticPaths;
}
class RouteCache {
  logger;
  cache = {};
  runtimeMode;
  constructor(logger, runtimeMode = "production") {
    this.logger = logger;
    this.runtimeMode = runtimeMode;
  }
  /** Clear the cache. */
  clearAll() {
    this.cache = {};
  }
  set(route, entry) {
    const key = this.key(route);
    if (this.runtimeMode === "production" && this.cache[key]?.staticPaths) {
      this.logger.warn(null, `Internal Warning: route cache overwritten. (${key})`);
    }
    this.cache[key] = entry;
  }
  get(route) {
    return this.cache[this.key(route)];
  }
  key(route) {
    return `${route.route}_${route.component}`;
  }
}
function findPathItemByKey(staticPaths, params, route, logger) {
  const paramsKey = stringifyParams(params, route);
  const matchedStaticPath = staticPaths.keyed.get(paramsKey);
  if (matchedStaticPath) {
    return matchedStaticPath;
  }
  logger.debug("router", `findPathItemByKey() - Unexpected cache miss looking for ${paramsKey}`);
}

function createDefaultRoutes(manifest) {
  const root = new URL(manifest.hrefRoot);
  return [
    {
      instance: default404Instance,
      matchesComponent: (filePath) => filePath.href === new URL(DEFAULT_404_COMPONENT, root).href,
      route: DEFAULT_404_ROUTE.route,
      component: DEFAULT_404_COMPONENT
    },
    {
      instance: createEndpoint(manifest),
      matchesComponent: (filePath) => filePath.href === new URL(SERVER_ISLAND_COMPONENT, root).href,
      route: SERVER_ISLAND_ROUTE,
      component: SERVER_ISLAND_COMPONENT
    }
  ];
}

class Pipeline {
  constructor(logger, manifest, runtimeMode, renderers, resolve, serverLike, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, inlinedScripts = manifest.inlinedScripts, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, runtimeMode), site = manifest.site ? new URL(manifest.site) : undefined, defaultRoutes = createDefaultRoutes(manifest)) {
    this.logger = logger;
    this.manifest = manifest;
    this.runtimeMode = runtimeMode;
    this.renderers = renderers;
    this.resolve = resolve;
    this.serverLike = serverLike;
    this.streaming = streaming;
    this.adapterName = adapterName;
    this.clientDirectives = clientDirectives;
    this.inlinedScripts = inlinedScripts;
    this.compressHTML = compressHTML;
    this.i18n = i18n;
    this.middleware = middleware;
    this.routeCache = routeCache;
    this.site = site;
    this.defaultRoutes = defaultRoutes;
    this.internalMiddleware = [];
    if (i18n?.strategy !== "manual") {
      this.internalMiddleware.push(
        createI18nMiddleware(i18n, manifest.base, manifest.trailingSlash, manifest.buildFormat)
      );
    }
  }
  internalMiddleware;
  resolvedMiddleware = undefined;
  /**
   * Resolves the middleware from the manifest, and returns the `onRequest` function. If `onRequest` isn't there,
   * it returns a no-op function
   */
  async getMiddleware() {
    if (this.resolvedMiddleware) {
      return this.resolvedMiddleware;
    } else if (this.middleware) {
      const middlewareInstance = await this.middleware();
      const onRequest = middlewareInstance.onRequest ?? NOOP_MIDDLEWARE_FN;
      if (this.manifest.checkOrigin) {
        this.resolvedMiddleware = sequence(createOriginCheckMiddleware(), onRequest);
      } else {
        this.resolvedMiddleware = onRequest;
      }
      return this.resolvedMiddleware;
    } else {
      this.resolvedMiddleware = NOOP_MIDDLEWARE_FN;
      return this.resolvedMiddleware;
    }
  }
}

function routeIsRedirect(route) {
  return route?.type === "redirect";
}
function routeIsFallback(route) {
  return route?.type === "fallback";
}

async function getProps(opts) {
  const { logger, mod, routeData: route, routeCache, pathname, serverLike, base } = opts;
  if (!route || route.pathname) {
    return {};
  }
  if (routeIsRedirect(route) || routeIsFallback(route) || route.component === DEFAULT_404_COMPONENT) {
    return {};
  }
  const staticPaths = await callGetStaticPaths({
    mod,
    route,
    routeCache,
    logger,
    ssr: serverLike,
    base
  });
  const params = getParams(route, pathname);
  const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger);
  if (!matchedStaticPath && (serverLike ? route.prerender : true)) {
    throw new AstroError({
      ...NoMatchingStaticPathFound,
      message: NoMatchingStaticPathFound.message(pathname),
      hint: NoMatchingStaticPathFound.hint([route.component])
    });
  }
  if (mod) {
    validatePrerenderEndpointCollision(route, mod, params);
  }
  const props = matchedStaticPath?.props ? { ...matchedStaticPath.props } : {};
  return props;
}
function getParams(route, pathname) {
  if (!route.params.length) return {};
  const paramsMatch = route.pattern.exec(pathname) || route.fallbackRoutes.map((fallbackRoute) => fallbackRoute.pattern.exec(pathname)).find((x) => x);
  if (!paramsMatch) return {};
  const params = {};
  route.params.forEach((key, i) => {
    if (key.startsWith("...")) {
      params[key.slice(3)] = paramsMatch[i + 1] ? paramsMatch[i + 1] : undefined;
    } else {
      params[key] = paramsMatch[i + 1];
    }
  });
  return params;
}
function validatePrerenderEndpointCollision(route, mod, params) {
  if (route.type === "endpoint" && mod.getStaticPaths) {
    const lastSegment = route.segments[route.segments.length - 1];
    const paramValues = Object.values(params);
    const lastParam = paramValues[paramValues.length - 1];
    if (lastSegment.length === 1 && lastSegment[0].dynamic && lastParam === undefined) {
      throw new AstroError({
        ...PrerenderDynamicEndpointPathCollide,
        message: PrerenderDynamicEndpointPathCollide.message(route.route),
        hint: PrerenderDynamicEndpointPathCollide.hint(route.component),
        location: {
          file: route.component
        }
      });
    }
  }
}

function defineMiddleware(fn) {
  return fn;
}

function getAssetsPrefix(fileExtension, assetsPrefix) {
  if (!assetsPrefix) return "";
  if (typeof assetsPrefix === "string") return assetsPrefix;
  const dotLessFileExtension = fileExtension.slice(1);
  if (assetsPrefix[dotLessFileExtension]) {
    return assetsPrefix[dotLessFileExtension];
  }
  return assetsPrefix.fallback;
}

class AppPipeline extends Pipeline {
  #manifestData;
  static create(manifestData, {
    logger,
    manifest,
    runtimeMode,
    renderers,
    resolve,
    serverLike,
    streaming,
    defaultRoutes
  }) {
    const pipeline = new AppPipeline(
      logger,
      manifest,
      runtimeMode,
      renderers,
      resolve,
      serverLike,
      streaming,
      undefined,
      undefined,
      undefined,
      undefined,
      undefined,
      undefined,
      undefined,
      undefined,
      defaultRoutes
    );
    pipeline.#manifestData = manifestData;
    return pipeline;
  }
  headElements(routeData) {
    const routeInfo = this.manifest.routes.find((route) => route.routeData === routeData);
    const links = /* @__PURE__ */ new Set();
    const scripts = /* @__PURE__ */ new Set();
    const styles = createStylesheetElementSet(routeInfo?.styles ?? []);
    for (const script of routeInfo?.scripts ?? []) {
      if ("stage" in script) {
        if (script.stage === "head-inline") {
          scripts.add({
            props: {},
            children: script.children
          });
        }
      } else {
        scripts.add(createModuleScriptElement(script));
      }
    }
    return { links, styles, scripts };
  }
  componentMetadata() {
  }
  async getComponentByRoute(routeData) {
    const module = await this.getModuleForRoute(routeData);
    return module.page();
  }
  async tryRewrite(payload, request) {
    const { newUrl, pathname, routeData } = findRouteToRewrite({
      payload,
      request,
      routes: this.manifest?.routes.map((r) => r.routeData),
      trailingSlash: this.manifest.trailingSlash,
      buildFormat: this.manifest.buildFormat,
      base: this.manifest.base
    });
    const componentInstance = await this.getComponentByRoute(routeData);
    return { newUrl, pathname, componentInstance, routeData };
  }
  async getModuleForRoute(route) {
    for (const defaultRoute of this.defaultRoutes) {
      if (route.component === defaultRoute.component) {
        return {
          page: () => Promise.resolve(defaultRoute.instance),
          renderers: []
        };
      }
    }
    if (route.type === "redirect") {
      return RedirectSinglePageBuiltModule;
    } else {
      if (this.manifest.pageMap) {
        const importComponentInstance = this.manifest.pageMap.get(route.component);
        if (!importComponentInstance) {
          throw new Error(
            `Unexpectedly unable to find a component instance for route ${route.route}`
          );
        }
        return await importComponentInstance();
      } else if (this.manifest.pageModule) {
        return this.manifest.pageModule;
      }
      throw new Error(
        "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
      );
    }
  }
}

class App {
  #manifest;
  #manifestData;
  #logger = new Logger({
    dest: consoleLogDestination,
    level: "info"
  });
  #baseWithoutTrailingSlash;
  #pipeline;
  #adapterLogger;
  #renderOptionsDeprecationWarningShown = false;
  constructor(manifest, streaming = true) {
    this.#manifest = manifest;
    this.#manifestData = {
      routes: manifest.routes.map((route) => route.routeData)
    };
    ensure404Route(this.#manifestData);
    this.#baseWithoutTrailingSlash = removeTrailingForwardSlash(this.#manifest.base);
    this.#pipeline = this.#createPipeline(this.#manifestData, streaming);
    this.#adapterLogger = new AstroIntegrationLogger(
      this.#logger.options,
      this.#manifest.adapterName
    );
  }
  getAdapterLogger() {
    return this.#adapterLogger;
  }
  /**
   * Creates a pipeline by reading the stored manifest
   *
   * @param manifestData
   * @param streaming
   * @private
   */
  #createPipeline(manifestData, streaming = false) {
    return AppPipeline.create(manifestData, {
      logger: this.#logger,
      manifest: this.#manifest,
      runtimeMode: "production",
      renderers: this.#manifest.renderers,
      defaultRoutes: createDefaultRoutes(this.#manifest),
      resolve: async (specifier) => {
        if (!(specifier in this.#manifest.entryModules)) {
          throw new Error(`Unable to resolve [${specifier}]`);
        }
        const bundlePath = this.#manifest.entryModules[specifier];
        if (bundlePath.startsWith("data:") || bundlePath.length === 0) {
          return bundlePath;
        } else {
          return createAssetLink(bundlePath, this.#manifest.base, this.#manifest.assetsPrefix);
        }
      },
      serverLike: true,
      streaming
    });
  }
  set setManifestData(newManifestData) {
    this.#manifestData = newManifestData;
  }
  removeBase(pathname) {
    if (pathname.startsWith(this.#manifest.base)) {
      return pathname.slice(this.#baseWithoutTrailingSlash.length + 1);
    }
    return pathname;
  }
  /**
   * It removes the base from the request URL, prepends it with a forward slash and attempts to decoded it.
   *
   * If the decoding fails, it logs the error and return the pathname as is.
   * @param request
   * @private
   */
  #getPathnameFromRequest(request) {
    const url = new URL(request.url);
    const pathname = prependForwardSlash$1(this.removeBase(url.pathname));
    try {
      return decodeURI(pathname);
    } catch (e) {
      this.getAdapterLogger().error(e.toString());
      return pathname;
    }
  }
  match(request) {
    const url = new URL(request.url);
    if (this.#manifest.assets.has(url.pathname)) return undefined;
    let pathname = this.#computePathnameFromDomain(request);
    if (!pathname) {
      pathname = prependForwardSlash$1(this.removeBase(url.pathname));
    }
    let routeData = matchRoute(pathname, this.#manifestData);
    if (!routeData || routeData.prerender) return undefined;
    return routeData;
  }
  #computePathnameFromDomain(request) {
    let pathname = undefined;
    const url = new URL(request.url);
    if (this.#manifest.i18n && (this.#manifest.i18n.strategy === "domains-prefix-always" || this.#manifest.i18n.strategy === "domains-prefix-other-locales" || this.#manifest.i18n.strategy === "domains-prefix-always-no-redirect")) {
      let host = request.headers.get("X-Forwarded-Host");
      let protocol = request.headers.get("X-Forwarded-Proto");
      if (protocol) {
        protocol = protocol + ":";
      } else {
        protocol = url.protocol;
      }
      if (!host) {
        host = request.headers.get("Host");
      }
      if (host && protocol) {
        host = host.split(":")[0];
        try {
          let locale;
          const hostAsUrl = new URL(`${protocol}//${host}`);
          for (const [domainKey, localeValue] of Object.entries(
            this.#manifest.i18n.domainLookupTable
          )) {
            const domainKeyAsUrl = new URL(domainKey);
            if (hostAsUrl.host === domainKeyAsUrl.host && hostAsUrl.protocol === domainKeyAsUrl.protocol) {
              locale = localeValue;
              break;
            }
          }
          if (locale) {
            pathname = prependForwardSlash$1(
              joinPaths(normalizeTheLocale(locale), this.removeBase(url.pathname))
            );
            if (url.pathname.endsWith("/")) {
              pathname = appendForwardSlash$1(pathname);
            }
          }
        } catch (e) {
          this.#logger.error(
            "router",
            `Astro tried to parse ${protocol}//${host} as an URL, but it threw a parsing error. Check the X-Forwarded-Host and X-Forwarded-Proto headers.`
          );
          this.#logger.error("router", `Error: ${e}`);
        }
      }
    }
    return pathname;
  }
  #redirectTrailingSlash(pathname) {
    const { trailingSlash } = this.#manifest;
    if (pathname === "/" || pathname.startsWith("/_")) {
      return pathname;
    }
    const path = collapseDuplicateTrailingSlashes(pathname, trailingSlash !== "never");
    if (path !== pathname) {
      return path;
    }
    if (trailingSlash === "ignore") {
      return pathname;
    }
    if (trailingSlash === "always" && !hasFileExtension(pathname)) {
      return appendForwardSlash$1(pathname);
    }
    if (trailingSlash === "never") {
      return removeTrailingForwardSlash(pathname);
    }
    return pathname;
  }
  async render(request, renderOptions) {
    let routeData;
    let locals;
    let clientAddress;
    let addCookieHeader;
    const url = new URL(request.url);
    const redirect = this.#redirectTrailingSlash(url.pathname);
    if (redirect !== url.pathname) {
      const status = request.method === "GET" ? 301 : 308;
      return new Response(redirectTemplate({ status, location: redirect, from: request.url }), {
        status,
        headers: {
          location: redirect + url.search
        }
      });
    }
    addCookieHeader = renderOptions?.addCookieHeader;
    clientAddress = renderOptions?.clientAddress ?? Reflect.get(request, clientAddressSymbol);
    routeData = renderOptions?.routeData;
    locals = renderOptions?.locals;
    if (routeData) {
      this.#logger.debug(
        "router",
        "The adapter " + this.#manifest.adapterName + " provided a custom RouteData for ",
        request.url
      );
      this.#logger.debug("router", "RouteData:\n" + routeData);
    }
    if (locals) {
      if (typeof locals !== "object") {
        const error = new AstroError(LocalsNotAnObject);
        this.#logger.error(null, error.stack);
        return this.#renderError(request, { status: 500, error, clientAddress });
      }
    }
    if (!routeData) {
      routeData = this.match(request);
      this.#logger.debug("router", "Astro matched the following route for " + request.url);
      this.#logger.debug("router", "RouteData:\n" + routeData);
    }
    if (!routeData) {
      this.#logger.debug("router", "Astro hasn't found routes that match " + request.url);
      this.#logger.debug("router", "Here's the available routes:\n", this.#manifestData);
      return this.#renderError(request, { locals, status: 404, clientAddress });
    }
    const pathname = this.#getPathnameFromRequest(request);
    const defaultStatus = this.#getDefaultStatusCode(routeData, pathname);
    let response;
    let session;
    try {
      const mod = await this.#pipeline.getModuleForRoute(routeData);
      const renderContext = await RenderContext.create({
        pipeline: this.#pipeline,
        locals,
        pathname,
        request,
        routeData,
        status: defaultStatus,
        clientAddress
      });
      session = renderContext.session;
      response = await renderContext.render(await mod.page());
    } catch (err) {
      this.#logger.error(null, err.stack || err.message || String(err));
      return this.#renderError(request, { locals, status: 500, error: err, clientAddress });
    } finally {
      await session?.[PERSIST_SYMBOL]();
    }
    if (REROUTABLE_STATUS_CODES.includes(response.status) && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
      return this.#renderError(request, {
        locals,
        response,
        status: response.status,
        // We don't have an error to report here. Passing null means we pass nothing intentionally
        // while undefined means there's no error
        error: response.status === 500 ? null : undefined,
        clientAddress
      });
    }
    if (response.headers.has(REROUTE_DIRECTIVE_HEADER)) {
      response.headers.delete(REROUTE_DIRECTIVE_HEADER);
    }
    if (addCookieHeader) {
      for (const setCookieHeaderValue of App.getSetCookieFromResponse(response)) {
        response.headers.append("set-cookie", setCookieHeaderValue);
      }
    }
    Reflect.set(response, responseSentSymbol$1, true);
    return response;
  }
  setCookieHeaders(response) {
    return getSetCookiesFromResponse(response);
  }
  /**
   * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.
   * For example,
   * ```ts
   * for (const cookie_ of App.getSetCookieFromResponse(response)) {
   *     const cookie: string = cookie_
   * }
   * ```
   * @param response The response to read cookies from.
   * @returns An iterator that yields key-value pairs as equal-sign-separated strings.
   */
  static getSetCookieFromResponse = getSetCookiesFromResponse;
  /**
   * If it is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
   * This also handles pre-rendered /404 or /500 routes
   */
  async #renderError(request, {
    locals,
    status,
    response: originalResponse,
    skipMiddleware = false,
    error,
    clientAddress
  }) {
    const errorRoutePath = `/${status}${this.#manifest.trailingSlash === "always" ? "/" : ""}`;
    const errorRouteData = matchRoute(errorRoutePath, this.#manifestData);
    const url = new URL(request.url);
    if (errorRouteData) {
      if (errorRouteData.prerender) {
        const maybeDotHtml = errorRouteData.route.endsWith(`/${status}`) ? ".html" : "";
        const statusURL = new URL(
          `${this.#baseWithoutTrailingSlash}/${status}${maybeDotHtml}`,
          url
        );
        if (statusURL.toString() !== request.url) {
          const response2 = await fetch(statusURL.toString());
          const override = { status };
          return this.#mergeResponses(response2, originalResponse, override);
        }
      }
      const mod = await this.#pipeline.getModuleForRoute(errorRouteData);
      let session;
      try {
        const renderContext = await RenderContext.create({
          locals,
          pipeline: this.#pipeline,
          middleware: skipMiddleware ? NOOP_MIDDLEWARE_FN : void 0,
          pathname: this.#getPathnameFromRequest(request),
          request,
          routeData: errorRouteData,
          status,
          props: { error },
          clientAddress
        });
        session = renderContext.session;
        const response2 = await renderContext.render(await mod.page());
        return this.#mergeResponses(response2, originalResponse);
      } catch {
        if (skipMiddleware === false) {
          return this.#renderError(request, {
            locals,
            status,
            response: originalResponse,
            skipMiddleware: true,
            clientAddress
          });
        }
      } finally {
        await session?.[PERSIST_SYMBOL]();
      }
    }
    const response = this.#mergeResponses(new Response(null, { status }), originalResponse);
    Reflect.set(response, responseSentSymbol$1, true);
    return response;
  }
  #mergeResponses(newResponse, originalResponse, override) {
    if (!originalResponse) {
      if (override !== undefined) {
        return new Response(newResponse.body, {
          status: override.status,
          statusText: newResponse.statusText,
          headers: newResponse.headers
        });
      }
      return newResponse;
    }
    const status = override?.status ? override.status : originalResponse.status === 200 ? newResponse.status : originalResponse.status;
    try {
      originalResponse.headers.delete("Content-type");
    } catch {
    }
    const mergedHeaders = new Map([
      ...Array.from(newResponse.headers),
      ...Array.from(originalResponse.headers)
    ]);
    const newHeaders = new Headers();
    for (const [name, value] of mergedHeaders) {
      newHeaders.set(name, value);
    }
    return new Response(newResponse.body, {
      status,
      statusText: status === 200 ? newResponse.statusText : originalResponse.statusText,
      // If you're looking at here for possible bugs, it means that it's not a bug.
      // With the middleware, users can meddle with headers, and we should pass to the 404/500.
      // If users see something weird, it's because they are setting some headers they should not.
      //
      // Although, we don't want it to replace the content-type, because the error page must return `text/html`
      headers: newHeaders
    });
  }
  #getDefaultStatusCode(routeData, pathname) {
    if (!routeData.pattern.test(pathname)) {
      for (const fallbackRoute of routeData.fallbackRoutes) {
        if (fallbackRoute.pattern.test(pathname)) {
          return 302;
        }
      }
    }
    const route = removeTrailingForwardSlash(routeData.route);
    if (route.endsWith("/404")) return 404;
    if (route.endsWith("/500")) return 500;
    return 200;
  }
}

function apply() {
  if (!globalThis.crypto) {
    Object.defineProperty(globalThis, "crypto", {
      value: crypto$1.webcrypto
    });
  }
  if (!globalThis.File) {
    Object.defineProperty(globalThis, "File", {
      value: buffer.File
    });
  }
}

class NodeApp extends App {
  match(req) {
    if (!(req instanceof Request)) {
      req = NodeApp.createRequest(req, {
        skipBody: true
      });
    }
    return super.match(req);
  }
  render(req, routeDataOrOptions, maybeLocals) {
    if (!(req instanceof Request)) {
      req = NodeApp.createRequest(req);
    }
    return super.render(req, routeDataOrOptions, maybeLocals);
  }
  /**
   * Converts a NodeJS IncomingMessage into a web standard Request.
   * ```js
   * import { NodeApp } from 'astro/app/node';
   * import { createServer } from 'node:http';
   *
   * const server = createServer(async (req, res) => {
   *     const request = NodeApp.createRequest(req);
   *     const response = await app.render(request);
   *     await NodeApp.writeResponse(response, res);
   * })
   * ```
   */
  static createRequest(req, { skipBody = false } = {}) {
    const isEncrypted = "encrypted" in req.socket && req.socket.encrypted;
    const getFirstForwardedValue = (multiValueHeader) => {
      return multiValueHeader?.toString()?.split(",").map((e) => e.trim())?.[0];
    };
    const forwardedProtocol = getFirstForwardedValue(req.headers["x-forwarded-proto"]);
    const protocol = forwardedProtocol ?? (isEncrypted ? "https" : "http");
    const forwardedHostname = getFirstForwardedValue(req.headers["x-forwarded-host"]);
    const hostname = forwardedHostname ?? req.headers.host ?? req.headers[":authority"];
    const port = getFirstForwardedValue(req.headers["x-forwarded-port"]);
    const portInHostname = typeof hostname === "string" && /:\d+$/.test(hostname);
    const hostnamePort = portInHostname ? hostname : `${hostname}${port ? `:${port}` : ""}`;
    const url = `${protocol}://${hostnamePort}${req.url}`;
    const options = {
      method: req.method || "GET",
      headers: makeRequestHeaders(req)
    };
    const bodyAllowed = options.method !== "HEAD" && options.method !== "GET" && skipBody === false;
    if (bodyAllowed) {
      Object.assign(options, makeRequestBody(req));
    }
    const request = new Request(url, options);
    const forwardedClientIp = getFirstForwardedValue(req.headers["x-forwarded-for"]);
    const clientIp = forwardedClientIp || req.socket?.remoteAddress;
    if (clientIp) {
      Reflect.set(request, clientAddressSymbol, clientIp);
    }
    return request;
  }
  /**
   * Streams a web-standard Response into a NodeJS Server Response.
   * ```js
   * import { NodeApp } from 'astro/app/node';
   * import { createServer } from 'node:http';
   *
   * const server = createServer(async (req, res) => {
   *     const request = NodeApp.createRequest(req);
   *     const response = await app.render(request);
   *     await NodeApp.writeResponse(response, res);
   * })
   * ```
   * @param source WhatWG Response
   * @param destination NodeJS ServerResponse
   */
  static async writeResponse(source, destination) {
    const { status, headers, body, statusText } = source;
    if (!(destination instanceof Http2ServerResponse)) {
      destination.statusMessage = statusText;
    }
    destination.writeHead(status, createOutgoingHttpHeaders(headers));
    if (!body) return destination.end();
    try {
      const reader = body.getReader();
      destination.on("close", () => {
        reader.cancel().catch((err) => {
          console.error(
            `There was an uncaught error in the middle of the stream while rendering ${destination.req.url}.`,
            err
          );
        });
      });
      let result = await reader.read();
      while (!result.done) {
        destination.write(result.value);
        result = await reader.read();
      }
      destination.end();
    } catch (err) {
      destination.write("Internal server error", () => {
        err instanceof Error ? destination.destroy(err) : destination.destroy();
      });
    }
  }
}
function makeRequestHeaders(req) {
  const headers = new Headers();
  for (const [name, value] of Object.entries(req.headers)) {
    if (value === undefined) {
      continue;
    }
    if (Array.isArray(value)) {
      for (const item of value) {
        headers.append(name, item);
      }
    } else {
      headers.append(name, value);
    }
  }
  return headers;
}
function makeRequestBody(req) {
  if (req.body !== undefined) {
    if (typeof req.body === "string" && req.body.length > 0) {
      return { body: Buffer.from(req.body) };
    }
    if (typeof req.body === "object" && req.body !== null && Object.keys(req.body).length > 0) {
      return { body: Buffer.from(JSON.stringify(req.body)) };
    }
    if (typeof req.body === "object" && req.body !== null && typeof req.body[Symbol.asyncIterator] !== "undefined") {
      return asyncIterableToBodyProps(req.body);
    }
  }
  return asyncIterableToBodyProps(req);
}
function asyncIterableToBodyProps(iterable) {
  return {
    // Node uses undici for the Request implementation. Undici accepts
    // a non-standard async iterable for the body.
    // @ts-expect-error
    body: iterable,
    // The duplex property is required when using a ReadableStream or async
    // iterable for the body. The type definitions do not include the duplex
    // property because they are not up-to-date.
    duplex: "half"
  };
}

apply();

/**
 * Creates a Node.js http listener for on-demand rendered pages, compatible with http.createServer and Connect middleware.
 * If the next callback is provided, it will be called if the request does not have a matching route.
 * Intended to be used in both standalone and middleware mode.
 */
function createAppHandler(app) {
    /**
     * Keep track of the current request path using AsyncLocalStorage.
     * Used to log unhandled rejections with a helpful message.
     */
    const als = new AsyncLocalStorage();
    const logger = app.getAdapterLogger();
    process.on('unhandledRejection', (reason) => {
        const requestUrl = als.getStore();
        logger.error(`Unhandled rejection while rendering ${requestUrl}`);
        console.error(reason);
    });
    return async (req, res, next, locals) => {
        let request;
        try {
            request = NodeApp.createRequest(req);
        }
        catch (err) {
            logger.error(`Could not render ${req.url}`);
            console.error(err);
            res.statusCode = 500;
            res.end('Internal Server Error');
            return;
        }
        const routeData = app.match(request);
        if (routeData) {
            const response = await als.run(request.url, () => app.render(request, {
                addCookieHeader: true,
                locals,
                routeData,
            }));
            await NodeApp.writeResponse(response, res);
        }
        else if (next) {
            return next();
        }
        else {
            const response = await app.render(req);
            await NodeApp.writeResponse(response, res);
        }
    };
}

/**
 * Creates a middleware that can be used with Express, Connect, etc.
 *
 * Similar to `createAppHandler` but can additionally be placed in the express
 * chain as an error middleware.
 *
 * https://expressjs.com/en/guide/using-middleware.html#middleware.error-handling
 */
function createMiddleware(app) {
    const handler = createAppHandler(app);
    const logger = app.getAdapterLogger();
    // using spread args because express trips up if the function's
    // stringified body includes req, res, next, locals directly
    return async (...args) => {
        // assume normal invocation at first
        const [req, res, next, locals] = args;
        // short circuit if it is an error invocation
        if (req instanceof Error) {
            const error = req;
            if (next) {
                return next(error);
                // biome-ignore lint/style/noUselessElse: <explanation>
            }
            else {
                throw error;
            }
        }
        try {
            await handler(req, res, next, locals);
        }
        catch (err) {
            logger.error(`Could not render ${req.url}`);
            console.error(err);
            if (!res.headersSent) {
                // biome-ignore lint/style/noUnusedTemplateLiteral: <explanation>
                res.writeHead(500, `Server error`);
                res.end();
            }
        }
    };
}

// check for a dot followed by a extension made up of lowercase characters
const isSubresourceRegex = /.+\.[a-z]+$/i;
/**
 * Creates a Node.js http listener for static files and prerendered pages.
 * In standalone mode, the static handler is queried first for the static files.
 * If one matching the request path is not found, it relegates to the SSR handler.
 * Intended to be used only in the standalone mode.
 */
function createStaticHandler(app, options) {
    const client = resolveClientDir(options);
    /**
     * @param ssr The SSR handler to be called if the static handler does not find a matching file.
     */
    return (req, res, ssr) => {
        if (req.url) {
            const [urlPath, urlQuery] = req.url.split('?');
            const filePath = path.join(client, app.removeBase(urlPath));
            let isDirectory = false;
            try {
                isDirectory = fs.lstatSync(filePath).isDirectory();
            }
            catch { }
            const { trailingSlash = 'ignore' } = options;
            const hasSlash = urlPath.endsWith('/');
            let pathname = urlPath;
            switch (trailingSlash) {
                case 'never': {
                    if (isDirectory && urlPath !== '/' && hasSlash) {
                        // biome-ignore lint/style/useTemplate: more readable like this
                        pathname = urlPath.slice(0, -1) + (urlQuery ? '?' + urlQuery : '');
                        res.statusCode = 301;
                        res.setHeader('Location', pathname);
                        return res.end();
                    }
                    if (isDirectory && !hasSlash) {
                        pathname = `${urlPath}/index.html`;
                    }
                    break;
                }
                case 'ignore': {
                    if (isDirectory && !hasSlash) {
                        pathname = `${urlPath}/index.html`;
                    }
                    break;
                }
                case 'always': {
                    // trailing slash is not added to "subresources"
                    if (!hasSlash && !isSubresourceRegex.test(urlPath)) {
                        // biome-ignore lint/style/useTemplate: more readable like this
                        pathname = urlPath + '/' + (urlQuery ? '?' + urlQuery : '');
                        res.statusCode = 301;
                        res.setHeader('Location', pathname);
                        return res.end();
                    }
                    break;
                }
            }
            // app.removeBase sometimes returns a path without a leading slash
            pathname = prependForwardSlash(app.removeBase(pathname));
            const stream = send(req, pathname, {
                root: client,
                dotfiles: pathname.startsWith('/.well-known/') ? 'allow' : 'deny',
            });
            let forwardError = false;
            stream.on('error', (err) => {
                if (forwardError) {
                    console.error(err.toString());
                    res.writeHead(500);
                    res.end('Internal server error');
                    return;
                }
                // File not found, forward to the SSR handler
                ssr();
            });
            stream.on('headers', (_res) => {
                // assets in dist/_astro are hashed and should get the immutable header
                if (pathname.startsWith(`/${options.assets}/`)) {
                    // This is the "far future" cache header, used for static files whose name includes their digest hash.
                    // 1 year (31,536,000 seconds) is convention.
                    // Taken from https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#immutable
                    _res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
                }
            });
            stream.on('file', () => {
                forwardError = true;
            });
            stream.pipe(res);
        }
        else {
            ssr();
        }
    };
}
function resolveClientDir(options) {
    const clientURLRaw = new URL(options.client);
    const serverURLRaw = new URL(options.server);
    const rel = path.relative(url.fileURLToPath(serverURLRaw), url.fileURLToPath(clientURLRaw));
    // walk up the parent folders until you find the one that is the root of the server entry folder. This is how we find the client folder relatively.
    const serverFolder = path.basename(options.server);
    let serverEntryFolderURL = path.dirname(import.meta.url);
    while (!serverEntryFolderURL.endsWith(serverFolder)) {
        serverEntryFolderURL = path.dirname(serverEntryFolderURL);
    }
    // biome-ignore lint/style/useTemplate: <explanation>
    const serverEntryURL = serverEntryFolderURL + '/entry.mjs';
    const clientURL = new URL(appendForwardSlash(rel), serverEntryURL);
    const client = url.fileURLToPath(clientURL);
    return client;
}
function prependForwardSlash(pth) {
    // biome-ignore lint/style/useTemplate: <explanation>
    return pth.startsWith('/') ? pth : '/' + pth;
}
function appendForwardSlash(pth) {
    // biome-ignore lint/style/useTemplate: <explanation>
    return pth.endsWith('/') ? pth : pth + '/';
}

// Used to get Host Value at Runtime
const hostOptions = (host) => {
    if (typeof host === 'boolean') {
        return host ? '0.0.0.0' : 'localhost';
    }
    return host;
};
function standalone(app, options) {
    const port = process.env.PORT ? Number(process.env.PORT) : (options.port ?? 8080);
    const host = process.env.HOST ?? hostOptions(options.host);
    const handler = createStandaloneHandler(app, options);
    const server = createServer(handler, host, port);
    server.server.listen(port, host);
    if (process.env.ASTRO_NODE_LOGGING !== 'disabled') {
        logListeningOn(app.getAdapterLogger(), server.server, host);
    }
    return {
        server,
        done: server.closed(),
    };
}
// also used by server entrypoint
function createStandaloneHandler(app, options) {
    const appHandler = createAppHandler(app);
    const staticHandler = createStaticHandler(app, options);
    return (req, res) => {
        try {
            // validate request path
            // biome-ignore lint/style/noNonNullAssertion: <explanation>
            decodeURI(req.url);
        }
        catch {
            res.writeHead(400);
            res.end('Bad request.');
            return;
        }
        staticHandler(req, res, () => appHandler(req, res));
    };
}
// also used by preview entrypoint
function createServer(listener, host, port) {
    let httpServer;
    if (process.env.SERVER_CERT_PATH && process.env.SERVER_KEY_PATH) {
        httpServer = https.createServer({
            key: fs.readFileSync(process.env.SERVER_KEY_PATH),
            cert: fs.readFileSync(process.env.SERVER_CERT_PATH),
        }, listener);
    }
    else {
        httpServer = http.createServer(listener);
    }
    enableDestroy(httpServer);
    // Resolves once the server is closed
    const closed = new Promise((resolve, reject) => {
        httpServer.addListener('close', resolve);
        httpServer.addListener('error', reject);
    });
    const previewable = {
        host,
        port,
        closed() {
            return closed;
        },
        async stop() {
            await new Promise((resolve, reject) => {
                httpServer.destroy((err) => (err ? reject(err) : resolve(undefined)));
            });
        },
    };
    return {
        server: httpServer,
        ...previewable,
    };
}

// Keep at the top
setGetEnv();
function createExports(manifest, options) {
    const app = new NodeApp(manifest);
    options.trailingSlash = manifest.trailingSlash;
    return {
        options: options,
        handler: options.mode === 'middleware' ? createMiddleware(app) : createStandaloneHandler(app, options),
        startServer: () => standalone(app, options),
    };
}
function start(manifest, options) {
    if (options.mode !== 'standalone' || process.env.ASTRO_NODE_AUTOSTART === 'disabled') {
        return;
    }
    const app = new NodeApp(manifest);
    standalone(app, options);
}

const serverEntrypointModule = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
  __proto__: null,
  createExports,
  start
}, Symbol.toStringTag, { value: 'Module' }));

export { start as a, createExports as c, serverEntrypointModule as s };

System Information
*ReClick For Close
File : BlackDragon /acciones/about.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	bienesraicess/bienesraicess	0755	2025-09-05 12:48:58
..	dir	-	bienesraicess/bienesraicess	0755	2025-09-05 12:48:58
astro	dir	-	bienesraicess/bienesraicess	0755	2025-09-05 12:48:52
ArticleCard_DPhL0nsu.mjs	file	2.64 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
ArticlesServer_Cpq4J6Ti.mjs	file	1.69 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
ArticulosRecientes_vDzMH-hZ.mjs	file	1.72 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
Articulos_C96Y3914.mjs	file	3.76 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
BasicCarousel_B6Am-FLB.mjs	file	2.23 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
CategoriaDeArticulos_CjunLsyq.mjs	file	10.31 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
Categorias_C0GVFzHM.mjs	file	1.52 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
ChevronRightIcon_BsddeYKJ.mjs	file	738 B	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
Entradas_nt0W94mG.mjs	file	1.66 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
HeroInfo_D9Hr9jQ4.mjs	file	1.6 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
Hero_D6uZF__b.mjs	file	9.18 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
Layout_wJpKgGM0.mjs	file	67.54 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
NavegadorArticulos_CqDEqi3B.mjs	file	4.76 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
Programas_BauLw7Xn.mjs	file	204 B	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
Programas_CW-gB71s.mjs	file	6.5 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
PublicidadInfo_CCSbPzit.mjs	file	2.3 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
RequestBuilder_C2bIFHdN.mjs	file	3.83 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
SearchBlogServer_Ch6TbmUH.mjs	file	5.8 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
SearchBlogServer_CpDOKbsr.mjs	file	177 B	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
TestimoniosServer_C4IaX9ul.mjs	file	3 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
TypographyH3_Ds2wPrcP.mjs	file	695 B	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
Views_CZvWgjcp.mjs	file	1.04 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
_@astrojs-ssr-adapter_BPR9fzy2.mjs	file	118.31 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
_astro_assets_F1kC6fBq.mjs	file	45.63 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
astro-designed-error-pages_DkGPf607.mjs	file	9.53 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
button-loading_CCFgxrS-.mjs	file	14.04 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
button_CQS6_H2L.mjs	file	2.05 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
custom-buttons_0K9387vH.mjs	file	1.32 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
index_Dsm2WsH8.mjs	file	11.1 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
runtime_x9uYhqlb.mjs	file	177 B	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
sharp_BL_OD2Pu.mjs	file	2.51 KB	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52
utils_B05Dmz_H.mjs	file	152 B	bienesraicess/bienesraicess	0644	2025-09-05 12:48:52