/home/henzagold/oldsite/node_modules/@nuxt/server/dist/ Current File: /home/henzagold/oldsite/node_modules/@nuxt/server/dist/server.js
/*!
 * @nuxt/server v2.15.8 (c) 2016-2021
 * Released under the MIT License
 * Repository: https://github.com/nuxt/nuxt.js
 * Website: https://nuxtjs.org
*/
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

const path = require('path');
const consola = require('consola');
const launchMiddleware = require('launch-editor-middleware');
const serveStatic = require('serve-static');
const servePlaceholder = require('serve-placeholder');
const connect = require('connect');
const compression = require('compression');
const utils = require('@nuxt/utils');
const vueRenderer = require('@nuxt/vue-renderer');
const generateETag = require('etag');
const fresh = require('fresh');
const ufo = require('ufo');
const fs = require('fs-extra');
const Youch = require('@nuxtjs/youch');
const http = require('http');
const https = require('https');
const enableDestroy = require('server-destroy');
const ip = require('ip');
const pify = require('pify');
const onHeaders = require('on-headers');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () {
            return e[k];
          }
        });
      }
    });
  }
  n['default'] = e;
  return Object.freeze(n);
}

const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
const launchMiddleware__default = /*#__PURE__*/_interopDefaultLegacy(launchMiddleware);
const serveStatic__default = /*#__PURE__*/_interopDefaultLegacy(serveStatic);
const servePlaceholder__default = /*#__PURE__*/_interopDefaultLegacy(servePlaceholder);
const connect__default = /*#__PURE__*/_interopDefaultLegacy(connect);
const compression__default = /*#__PURE__*/_interopDefaultLegacy(compression);
const generateETag__default = /*#__PURE__*/_interopDefaultLegacy(generateETag);
const fresh__default = /*#__PURE__*/_interopDefaultLegacy(fresh);
const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
const Youch__default = /*#__PURE__*/_interopDefaultLegacy(Youch);
const http__default = /*#__PURE__*/_interopDefaultLegacy(http);
const https__default = /*#__PURE__*/_interopDefaultLegacy(https);
const enableDestroy__default = /*#__PURE__*/_interopDefaultLegacy(enableDestroy);
const ip__default = /*#__PURE__*/_interopDefaultLegacy(ip);
const pify__default = /*#__PURE__*/_interopDefaultLegacy(pify);
const onHeaders__default = /*#__PURE__*/_interopDefaultLegacy(onHeaders);

class ServerContext {
  constructor (server) {
    this.nuxt = server.nuxt;
    this.globals = server.globals;
    this.options = server.options;
    this.resources = server.resources;
  }
}

async function renderAndGetWindow (
  url = 'http://localhost:3000',
  jsdomOpts = {},
  {
    loadedCallback,
    loadingTimeout = 2000,
    globals
  } = {}
) {
  const jsdom = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('jsdom')); })
    .then(m => m.default || m)
    .catch((e) => {
      consola__default['default'].error(`
         jsdom is not installed. Please install jsdom with:
          $ yarn add --dev jsdom
          OR
          $ npm install --dev jsdom
        `);
      throw e
    });

  const options = Object.assign({
    // Load subresources (https://github.com/tmpvar/jsdom#loading-subresources)
    resources: 'usable',
    runScripts: 'dangerously',
    virtualConsole: true,
    beforeParse (window) {
      // Mock window.scrollTo
      window.scrollTo = () => {};
    }
  }, jsdomOpts);

  const jsdomErrHandler = (err) => {
    throw err
  };

  if (options.virtualConsole) {
    if (options.virtualConsole === true) {
      options.virtualConsole = new jsdom.VirtualConsole().sendTo(consola__default['default']);
    }
    // Throw error when window creation failed
    options.virtualConsole.on('jsdomError', jsdomErrHandler);
  } else {
    // If we get the virtualConsole option as `false` we should delete for don't pass it to `jsdom.JSDOM.fromURL`
    delete options.virtualConsole;
  }

  const { window } = await jsdom.JSDOM.fromURL(url, options);

  // If Nuxt could not be loaded (error from the server-side)
  const nuxtExists = window.document.body.innerHTML.includes(`id="${globals.id}"`);

  if (!nuxtExists) {
    const error = new Error('Could not load the nuxt app');
    error.body = window.document.body.innerHTML;
    window.close();
    throw error
  }

  // Used by Nuxt to say when the components are loaded and the app ready
  await utils.timeout(new Promise((resolve) => {
    window[loadedCallback] = () => resolve(window);
  }), loadingTimeout, `Components loading in renderAndGetWindow was not completed in ${loadingTimeout / 1000}s`);

  if (options.virtualConsole) {
    // After window initialized successfully
    options.virtualConsole.removeListener('jsdomError', jsdomErrHandler);
  }

  // Send back window object
  return window
}

const nuxtMiddleware = ({ options, nuxt, renderRoute, resources }) => async function nuxtMiddleware (req, res, next) {
  // Get context
  const context = utils.getContext(req, res);

  try {
    const url = ufo.normalizeURL(req.url);
    res.statusCode = 200;
    const result = await renderRoute(url, context);

    // If result is falsy, call renderLoading
    if (!result) {
      await nuxt.callHook('server:nuxt:renderLoading', req, res);
      return
    }

    await nuxt.callHook('render:route', url, result, context);
    const {
      html,
      cspScriptSrcHashes,
      error,
      redirected,
      preloadFiles
    } = result;

    if (redirected && context.target !== utils.TARGETS.static) {
      await nuxt.callHook('render:routeDone', url, result, context);
      return html
    }
    if (error) {
      res.statusCode = context.nuxt.error.statusCode || 500;
    }

    if (options.render.csp && cspScriptSrcHashes) {
      const { allowedSources, policies } = options.render.csp;
      const isReportOnly = !!options.render.csp.reportOnly;
      const cspHeader = isReportOnly ? 'Content-Security-Policy-Report-Only' : 'Content-Security-Policy';

      res.setHeader(cspHeader, getCspString({ cspScriptSrcHashes, allowedSources, policies, isReportOnly }));
    }

    // Add ETag header
    if (!error && options.render.etag) {
      const { hash } = options.render.etag;
      const etag = hash ? hash(html, options.render.etag) : generateETag__default['default'](html, options.render.etag);
      if (fresh__default['default'](req.headers, { etag })) {
        res.statusCode = 304;
        await nuxt.callHook('render:beforeResponse', url, result, context);
        res.end();
        await nuxt.callHook('render:routeDone', url, result, context);
        return
      }
      res.setHeader('ETag', etag);
    }

    // HTTP2 push headers for preload assets
    if (!error && options.render.http2.push) {
      // Parse resourceHints to extract HTTP.2 prefetch/push headers
      // https://w3c.github.io/preload/#server-push-http-2
      const { shouldPush, pushAssets } = options.render.http2;
      const { publicPath } = resources.clientManifest;

      const links = pushAssets
        ? pushAssets(req, res, publicPath, preloadFiles)
        : defaultPushAssets(preloadFiles, shouldPush, publicPath, options);

      // Pass with single Link header
      // https://blog.cloudflare.com/http-2-server-push-with-multiple-assets-per-link-header
      // https://www.w3.org/Protocols/9707-link-header.html
      if (links.length > 0) {
        res.setHeader('Link', links.join(', '));
      }
    }

    // Send response
    res.setHeader('Content-Type', 'text/html; charset=utf-8');
    res.setHeader('Accept-Ranges', 'none'); // #3870
    res.setHeader('Content-Length', Buffer.byteLength(html));
    await nuxt.callHook('render:beforeResponse', url, result, context);
    res.end(html, 'utf8');
    await nuxt.callHook('render:routeDone', url, result, context);
    return html
  } catch (err) {
    if (context && context.redirected) {
      consola__default['default'].error(err);
      return err
    }

    if (err.name === 'URIError') {
      err.statusCode = 400;
    }
    next(err);
  }
};

const defaultPushAssets = (preloadFiles, shouldPush, publicPath, options) => {
  if (shouldPush && options.dev) {
    consola__default['default'].warn('http2.shouldPush is deprecated. Use http2.pushAssets function');
  }

  const links = [];
  preloadFiles.forEach(({ file, asType, fileWithoutQuery, modern }) => {
    // By default, we only preload scripts or css
    if (!shouldPush && asType !== 'script' && asType !== 'style') {
      return
    }

    // User wants to explicitly control what to preload
    if (shouldPush && !shouldPush(fileWithoutQuery, asType)) {
      return
    }

    const { crossorigin } = options.render;
    const cors = `${crossorigin ? ` crossorigin=${crossorigin};` : ''}`;
    // `modulepreload` rel attribute only supports script-like `as` value
    // https://html.spec.whatwg.org/multipage/links.html#link-type-modulepreload
    const rel = modern && asType === 'script' ? 'modulepreload' : 'preload';

    links.push(`<${publicPath}${file}>; rel=${rel};${cors} as=${asType}`);
  });
  return links
};

const getCspString = ({ cspScriptSrcHashes, allowedSources, policies, isReportOnly }) => {
  const joinedHashes = cspScriptSrcHashes.join(' ');
  const baseCspStr = `script-src 'self' ${joinedHashes}`;
  const policyObjectAvailable = typeof policies === 'object' && policies !== null && !Array.isArray(policies);

  if (Array.isArray(allowedSources) && allowedSources.length) {
    return isReportOnly && policyObjectAvailable && !!policies['report-uri'] ? `${baseCspStr} ${allowedSources.join(' ')}; report-uri ${policies['report-uri']};` : `${baseCspStr} ${allowedSources.join(' ')}`
  }

  if (policyObjectAvailable) {
    const transformedPolicyObject = transformPolicyObject(policies, cspScriptSrcHashes);
    return Object.entries(transformedPolicyObject).map(([k, v]) => `${k} ${Array.isArray(v) ? v.join(' ') : v}`).join('; ')
  }

  return baseCspStr
};

const transformPolicyObject = (policies, cspScriptSrcHashes) => {
  const userHasDefinedScriptSrc = policies['script-src'] && Array.isArray(policies['script-src']);

  const additionalPolicies = userHasDefinedScriptSrc ? policies['script-src'] : [];

  // Self is always needed for inline-scripts, so add it, no matter if the user specified script-src himself.
  const hashAndPolicyList = cspScriptSrcHashes.concat('\'self\'', additionalPolicies);

  return { ...policies, 'script-src': hashAndPolicyList }
};

const errorMiddleware = ({ resources, options }) => async function errorMiddleware (_error, req, res, next) {
  // Normalize error
  const error = normalizeError(_error, options);

  const sendResponse = (content, type = 'text/html') => {
    // Set Headers
    res.statusCode = error.statusCode;
    res.statusMessage = 'RuntimeError';
    res.setHeader('Content-Type', type + '; charset=utf-8');
    res.setHeader('Content-Length', Buffer.byteLength(content));
    res.setHeader('Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate');

    // Error headers
    if (error.headers) {
      for (const name in error.headers) {
        res.setHeader(name, error.headers[name]);
      }
    }

    // Send Response
    res.end(content, 'utf-8');
  };

  // Check if request accepts JSON
  const hasReqHeader = (header, includes) =>
    req.headers[header] && req.headers[header].toLowerCase().includes(includes);
  const isJson =
    hasReqHeader('accept', 'application/json') ||
    hasReqHeader('user-agent', 'curl/');

  // Use basic errors when debug mode is disabled
  if (!options.debug) {
    // We hide actual errors from end users, so show them on server logs
    if (error.statusCode !== 404) {
      consola__default['default'].error(error);
    }

    // Json format is compatible with Youch json responses
    const json = {
      status: error.statusCode,
      message: error.message,
      name: error.name
    };
    if (isJson) {
      sendResponse(JSON.stringify(json, undefined, 2), 'text/json');
      return
    }
    const html = resources.errorTemplate(json);
    sendResponse(html);
    return
  }

  // Show stack trace
  const youch = new Youch__default['default'](
    error,
    req,
    readSource,
    options.router.base,
    true
  );
  if (isJson) {
    const json = await youch.toJSON();
    sendResponse(JSON.stringify(json, undefined, 2), 'text/json');
    return
  }

  const html = await youch.toHTML();
  sendResponse(html);
};

const sanitizeName = name => name ? name.replace('webpack:///', '').split('?')[0] : null;

const normalizeError = (_error, { srcDir, rootDir, buildDir }) => {
  if (typeof _error === 'string') {
    _error = { message: _error };
  } else if (!_error) {
    _error = { message: '<empty>' };
  }

  const error = new Error(_error.message);
  error.name = _error.name;
  error.statusCode = _error.statusCode || 500;
  error.headers = _error.headers;

  const searchPath = [
    srcDir,
    rootDir,
    path__default['default'].join(buildDir, 'dist', 'server'),
    buildDir,
    process.cwd()
  ];

  const findInPaths = (fileName) => {
    for (const dir of searchPath) {
      const fullPath = path__default['default'].resolve(dir, fileName);
      if (fs__default['default'].existsSync(fullPath)) {
        return fullPath
      }
    }
    return fileName
  };

  error.stack = (_error.stack || '')
    .split('\n')
    .map((line) => {
      const match = line.match(/\(([^)]+)\)|([^\s]+\.[^\s]+):/);
      if (!match) {
        return line
      }
      const src = match[1] || match[2] || '';
      return line.replace(src, findInPaths(sanitizeName(src)))
    })
    .join('\n');

  return error
};

async function readSource (frame) {
  if (fs__default['default'].existsSync(frame.fileName)) {
    frame.fullPath = frame.fileName; // Youch BW compat
    frame.contents = await fs__default['default'].readFile(frame.fileName, 'utf-8');
  }
}

let RANDOM_PORT = '0';

class Listener {
  constructor ({ port, host, socket, https, app, dev, baseURL }) {
    // Options
    this.port = port;
    this.host = host;
    this.socket = socket;
    this.https = https;
    this.app = app;
    this.dev = dev;
    this.baseURL = baseURL;

    // After listen
    this.listening = false;
    this._server = null;
    this.server = null;
    this.address = null;
    this.url = null;
  }

  async close () {
    // Destroy server by forcing every connection to be closed
    if (this.server && this.server.listening) {
      await this.server.destroy();
      consola__default['default'].debug('server closed');
    }

    // Delete references
    this.listening = false;
    this._server = null;
    this.server = null;
    this.address = null;
    this.url = null;
  }

  computeURL () {
    const address = this.server.address();
    if (!this.socket) {
      switch (address.address) {
        case '127.0.0.1': this.host = 'localhost'; break
        case '0.0.0.0': this.host = ip__default['default'].address(); break
      }
      this.port = address.port;
      this.url = `http${this.https ? 's' : ''}://${this.host}:${this.port}${this.baseURL}`;
      this.url = decodeURI(this.url);
      return
    }
    this.url = `unix+http://${address}`;
  }

  async listen () {
    // Prevent multi calls
    if (this.listening) {
      return
    }

    // Initialize underlying http(s) server
    const protocol = this.https ? https__default['default'] : http__default['default'];
    const protocolOpts = this.https ? [this.https] : [];
    this._server = protocol.createServer.apply(protocol, protocolOpts.concat(this.app));

    // Call server.listen
    // Prepare listenArgs
    const listenArgs = this.socket ? { path: this.socket } : { host: this.host, port: this.port };
    listenArgs.exclusive = false;

    // Call server.listen
    try {
      this.server = await new Promise((resolve, reject) => {
        this._server.on('error', error => reject(error));
        const s = this._server.listen(listenArgs, error => error ? reject(error) : resolve(s));
      });
    } catch (error) {
      return this.serverErrorHandler(error)
    }

    // Enable destroy support
    enableDestroy__default['default'](this.server);
    pify__default['default'](this.server.destroy);

    // Compute listen URL
    this.computeURL();

    // Set this.listening to true
    this.listening = true;
  }

  async serverErrorHandler (error) {
    // Detect if port is not available
    const addressInUse = error.code === 'EADDRINUSE';

    // Use better error message
    if (addressInUse) {
      const address = this.socket || `${this.host}:${this.port}`;
      error.message = `Address \`${address}\` is already in use.`;

      // Listen to a random port on dev as a fallback
      if (this.dev && !this.socket && this.port !== RANDOM_PORT) {
        consola__default['default'].warn(error.message);
        consola__default['default'].info('Trying a random port...');
        this.port = RANDOM_PORT;
        await this.close();
        await this.listen();
        RANDOM_PORT = this.port;
        return
      }
    }

    // Throw error
    throw error
  }
}

const createTimingMiddleware = options => (req, res, next) => {
  if (res.timing) {
    consola__default['default'].warn('server-timing is already registered.');
  }
  res.timing = new ServerTiming();

  if (options && options.total) {
    res.timing.start('total', 'Nuxt Server Time');
  }

  onHeaders__default['default'](res, () => {
    res.timing.end('total');

    if (res.timing.headers.length > 0) {
      res.setHeader(
        'Server-Timing',
        []
          .concat(res.getHeader('Server-Timing') || [])
          .concat(res.timing.headers)
          .join(', ')
      );
    }
    res.timing.clear();
  });

  next();
};

class ServerTiming extends utils.Timer {
  constructor (...args) {
    super(...args);
    this.headers = [];
  }

  end (...args) {
    const time = super.end(...args);
    if (time) {
      this.headers.push(this.formatHeader(time));
    }
    return time
  }

  clear () {
    super.clear();
    this.headers.length = 0;
  }

  formatHeader (time) {
    const desc = time.description ? `;desc="${time.description}"` : '';
    return `${time.name};dur=${time.duration}${desc}`
  }
}

class Server {
  constructor (nuxt) {
    this.nuxt = nuxt;
    this.options = nuxt.options;

    this.globals = utils.determineGlobals(nuxt.options.globalName, nuxt.options.globals);

    this.publicPath = utils.isUrl(this.options.build.publicPath)
      ? this.options.build._publicPath
      : this.options.build.publicPath.replace(/^\.+\//, '/');

    // Runtime shared resources
    this.resources = {};

    // Will be set after listen
    this.listeners = [];

    // Create new connect instance
    this.app = connect__default['default']();

    // Close hook
    this.nuxt.hook('close', () => this.close());

    // devMiddleware placeholder
    if (this.options.dev) {
      this.nuxt.hook('server:devMiddleware', (devMiddleware) => {
        this.devMiddleware = devMiddleware;
      });
    }
  }

  async ready () {
    if (this._readyCalled) {
      return this
    }
    this._readyCalled = true;

    await this.nuxt.callHook('render:before', this, this.options.render);

    // Initialize vue-renderer
    this.serverContext = new ServerContext(this);
    this.renderer = new vueRenderer.VueRenderer(this.serverContext);
    await this.renderer.ready();

    // Setup nuxt middleware
    await this.setupMiddleware();

    // Call done hook
    await this.nuxt.callHook('render:done', this);

    return this
  }

  async setupMiddleware () {
    // Apply setupMiddleware from modules first
    await this.nuxt.callHook('render:setupMiddleware', this.app);

    // Compression middleware for production
    if (!this.options.dev) {
      const { compressor } = this.options.render;
      if (typeof compressor === 'object') {
        // If only setting for `compression` are provided, require the module and insert
        this.useMiddleware(compression__default['default'](compressor));
      } else if (compressor) {
        // Else, require own compression middleware if compressor is actually truthy
        this.useMiddleware(compressor);
      }
    }

    if (this.options.server.timing) {
      this.useMiddleware(createTimingMiddleware(this.options.server.timing));
    }

    // For serving static/ files to /
    const staticMiddleware = serveStatic__default['default'](
      path__default['default'].resolve(this.options.srcDir, this.options.dir.static),
      this.options.render.static
    );
    staticMiddleware.prefix = this.options.render.static.prefix;
    this.useMiddleware(staticMiddleware);

    // Serve .nuxt/dist/client files only for production
    // For dev they will be served with devMiddleware
    if (!this.options.dev) {
      const distDir = path__default['default'].resolve(this.options.buildDir, 'dist', 'client');
      this.useMiddleware({
        path: this.publicPath,
        handler: serveStatic__default['default'](
          distDir,
          this.options.render.dist
        )
      });
    }

    // Dev middleware
    if (this.options.dev) {
      this.useMiddleware((req, res, next) => {
        if (!this.devMiddleware) {
          return next()
        }
        // Safari over-caches JS (breaking HMR) and the seemingly only way to turn
        // this off in dev mode is to set Vary: * header
        // #3828, #9034
        if (req.url.startsWith(this.publicPath) && req.url.endsWith('.js')) {
          res.setHeader('Vary', '*');
        }
        this.devMiddleware(req, res, next);
      });

      // open in editor for debug mode only
      if (this.options.debug) {
        this.useMiddleware({
          path: '__open-in-editor',
          handler: launchMiddleware__default['default'](this.options.editor)
        });
      }
    }

    // Add user provided middleware
    for (const m of this.options.serverMiddleware) {
      this.useMiddleware(m);
    }

    // Graceful 404 error handler
    const { fallback } = this.options.render;
    if (fallback) {
      // Dist files
      if (fallback.dist) {
        this.useMiddleware({
          path: this.publicPath,
          handler: servePlaceholder__default['default'](fallback.dist)
        });
      }

      // Other paths
      if (fallback.static) {
        this.useMiddleware({
          path: '/',
          handler: servePlaceholder__default['default'](fallback.static)
        });
      }
    }

    // Finally use nuxtMiddleware
    this.useMiddleware(nuxtMiddleware({
      options: this.options,
      nuxt: this.nuxt,
      renderRoute: this.renderRoute.bind(this),
      resources: this.resources
    }));

    // DX: redirect if router.base in development
    const routerBase = this.nuxt.options.router.base;
    if (this.options.dev && routerBase !== '/') {
      this.useMiddleware({
        prefix: false,
        handler: (req, res, next) => {
          if (decodeURI(req.url).startsWith(decodeURI(routerBase))) {
            return next()
          }
          const to = utils.urlJoin(routerBase, req.url);
          consola__default['default'].info(`[Development] Redirecting from \`${decodeURI(req.url)}\` to \`${decodeURI(to)}\` (router.base specified)`);
          res.writeHead(302, {
            Location: to
          });
          res.end();
        }
      });
    }

    // Apply errorMiddleware from modules first
    await this.nuxt.callHook('render:errorMiddleware', this.app);

    // Error middleware for errors that occurred in middleware that declared above
    this.useMiddleware(errorMiddleware({
      resources: this.resources,
      options: this.options
    }));
  }

  _normalizeMiddleware (middleware) {
    // Normalize plain function
    if (typeof middleware === 'function') {
      middleware = { handle: middleware };
    }

    // If a plain string provided as path to middleware
    if (typeof middleware === 'string') {
      middleware = this._requireMiddleware(middleware);
    }

    // #8584
    // shallow clone the middleware before any change is made,
    // in case any following mutation breaks when applied repeatedly.
    middleware = Object.assign({}, middleware);

    // Normalize handler to handle (backward compatibility)
    if (middleware.handler && !middleware.handle) {
      middleware.handle = middleware.handler;
      delete middleware.handler;
    }

    // Normalize path to route (backward compatibility)
    if (middleware.path && !middleware.route) {
      middleware.route = middleware.path;
      delete middleware.path;
    }

    // If handle is a string pointing to path
    if (typeof middleware.handle === 'string') {
      Object.assign(middleware, this._requireMiddleware(middleware.handle));
    }

    // No handle
    if (!middleware.handle) {
      middleware.handle = (req, res, next) => {
        next(new Error('ServerMiddleware should expose a handle: ' + middleware.entry));
      };
    }

    // Prefix on handle (proxy-module)
    if (middleware.handle.prefix !== undefined && middleware.prefix === undefined) {
      middleware.prefix = middleware.handle.prefix;
    }

    // sub-app (express)
    if (typeof middleware.handle.handle === 'function') {
      const server = middleware.handle;
      middleware.handle = server.handle.bind(server);
    }

    return middleware
  }

  _requireMiddleware (entry) {
    // Resolve entry
    entry = this.nuxt.resolver.resolvePath(entry);

    // Require middleware
    let middleware;
    try {
      middleware = this.nuxt.resolver.requireModule(entry);
    } catch (error) {
      // Show full error
      consola__default['default'].error('ServerMiddleware Error:', error);

      // Placeholder for error
      middleware = (req, res, next) => { next(error); };
    }

    // Normalize
    middleware = this._normalizeMiddleware(middleware);

    // Set entry
    middleware.entry = entry;

    return middleware
  }

  resolveMiddleware (middleware, fallbackRoute = '/') {
    // Ensure middleware is normalized
    middleware = this._normalizeMiddleware(middleware);

    // Fallback route
    if (!middleware.route) {
      middleware.route = fallbackRoute;
    }

    // #8584
    // save the original route before applying defaults
    middleware._originalRoute = middleware.route;

    // Resolve final route
    middleware.route = (
      (middleware.prefix !== false ? this.options.router.base : '') +
      (typeof middleware.route === 'string' ? middleware.route : '')
    ).replace(/\/\//g, '/');

    // Strip trailing slash
    if (middleware.route.endsWith('/')) {
      middleware.route = middleware.route.slice(0, -1);
    }

    // Assign _middleware to handle to make accessible from app.stack
    middleware.handle._middleware = middleware;

    return middleware
  }

  useMiddleware (middleware) {
    const { route, handle } = this.resolveMiddleware(middleware);
    this.app.use(route, handle);
  }

  replaceMiddleware (query, middleware) {
    let serverStackItem;

    if (typeof query === 'string') {
      // Search by entry
      serverStackItem = this.app.stack.find(({ handle }) => handle._middleware && handle._middleware.entry === query);
    } else {
      // Search by reference
      serverStackItem = this.app.stack.find(({ handle }) => handle === query);
    }

    // Stop if item not found
    if (!serverStackItem) {
      return
    }

    // unload middleware
    this.unloadMiddleware(serverStackItem);

    // Resolve middleware
    const { route, handle } = this.resolveMiddleware(
      middleware,
      // #8584 pass the original route as fallback
      serverStackItem.handle._middleware
        ? serverStackItem.handle._middleware._originalRoute
        : serverStackItem.route
    );

    // Update serverStackItem
    serverStackItem.handle = handle;

    // Error State
    serverStackItem.route = route;

    // Return updated item
    return serverStackItem
  }

  unloadMiddleware ({ handle }) {
    if (handle._middleware && typeof handle._middleware.unload === 'function') {
      handle._middleware.unload();
    }
  }

  serverMiddlewarePaths () {
    return this.app.stack.map(({ handle }) => handle._middleware && handle._middleware.entry).filter(Boolean)
  }

  renderRoute () {
    return this.renderer.renderRoute.apply(this.renderer, arguments)
  }

  loadResources () {
    return this.renderer.loadResources.apply(this.renderer, arguments)
  }

  renderAndGetWindow (url, opts = {}, {
    loadingTimeout = 2000,
    loadedCallback = this.globals.loadedCallback,
    globals = this.globals
  } = {}) {
    return renderAndGetWindow(url, opts, {
      loadingTimeout,
      loadedCallback,
      globals
    })
  }

  async listen (port, host, socket) {
    // Ensure nuxt is ready
    await this.nuxt.ready();

    // Create a new listener
    const listener = new Listener({
      port: isNaN(parseInt(port)) ? this.options.server.port : port,
      host: host || this.options.server.host,
      socket: socket || this.options.server.socket,
      https: this.options.server.https,
      app: this.app,
      dev: this.options.dev,
      baseURL: this.options.router.base
    });

    // Listen
    await listener.listen();

    // Push listener to this.listeners
    this.listeners.push(listener);

    await this.nuxt.callHook('listen', listener.server, listener);

    return listener
  }

  async close () {
    if (this.__closed) {
      return
    }
    this.__closed = true;

    await Promise.all(this.listeners.map(l => l.close()));

    this.listeners = [];

    if (typeof this.renderer.close === 'function') {
      await this.renderer.close();
    }

    this.app.stack.forEach(this.unloadMiddleware);
    this.app.removeAllListeners();
    this.app = null;

    for (const key in this.resources) {
      delete this.resources[key];
    }
  }
}

exports.Listener = Listener;
exports.Server = Server;