vite-react-ssg 0.7.3 → 0.8.0-beta.1

package/dist/node.mjs

@@ -1,1707 +1,17 @@
-import { join, isAbsolute, parse, dirname } from 'node:path';
-import { createRequire } from 'node:module';
-import { gray, yellow, blue, dim, cyan, red, green, reset, bold, bgLightCyan } from 'kolorist';
-import fs from 'fs-extra';
-import { resolveConfig, createLogger, build as build$1, mergeConfig, version as version$1, send, createServer } from 'vite';
-import { JSDOM } from 'jsdom';
-import { s as serializeState } from './shared/vite-react-ssg.579feabb.mjs';
-import { a as withTrailingSlash, r as removeLeadingSlash, c as convertRoutesToDataRoutes, j as joinUrlSegments } from './shared/vite-react-ssg.054e813a.mjs';
-import { readFileSync } from 'node:fs';
-import React from 'react';
-import { HelmetProvider } from 'react-helmet-async';
-import { Writable, Readable } from 'node:stream';
-import { renderToPipeableStream } from 'react-dom/server';
-import { matchRoutes, json } from 'react-router-dom';
-import { once } from 'node:events';
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var eventemitter3 = {exports: {}};
-
-(function (module) {
-
-	var has = Object.prototype.hasOwnProperty
-	  , prefix = '~';
-
-	/**
-	 * Constructor to create a storage for our `EE` objects.
-	 * An `Events` instance is a plain object whose properties are event names.
-	 *
-	 * @constructor
-	 * @private
-	 */
-	function Events() {}
-
-	//
-	// We try to not inherit from `Object.prototype`. In some engines creating an
-	// instance in this way is faster than calling `Object.create(null)` directly.
-	// If `Object.create(null)` is not supported we prefix the event names with a
-	// character to make sure that the built-in object properties are not
-	// overridden or used as an attack vector.
-	//
-	if (Object.create) {
-	  Events.prototype = Object.create(null);
-
-	  //
-	  // This hack is needed because the `__proto__` property is still inherited in
-	  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
-	  //
-	  if (!new Events().__proto__) prefix = false;
-	}
-
-	/**
-	 * Representation of a single event listener.
-	 *
-	 * @param {Function} fn The listener function.
-	 * @param {*} context The context to invoke the listener with.
-	 * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
-	 * @constructor
-	 * @private
-	 */
-	function EE(fn, context, once) {
-	  this.fn = fn;
-	  this.context = context;
-	  this.once = once || false;
-	}
-
-	/**
-	 * Add a listener for a given event.
-	 *
-	 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
-	 * @param {(String|Symbol)} event The event name.
-	 * @param {Function} fn The listener function.
-	 * @param {*} context The context to invoke the listener with.
-	 * @param {Boolean} once Specify if the listener is a one-time listener.
-	 * @returns {EventEmitter}
-	 * @private
-	 */
-	function addListener(emitter, event, fn, context, once) {
-	  if (typeof fn !== 'function') {
-	    throw new TypeError('The listener must be a function');
-	  }
-
-	  var listener = new EE(fn, context || emitter, once)
-	    , evt = prefix ? prefix + event : event;
-
-	  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
-	  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
-	  else emitter._events[evt] = [emitter._events[evt], listener];
-
-	  return emitter;
-	}
-
-	/**
-	 * Clear event by name.
-	 *
-	 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
-	 * @param {(String|Symbol)} evt The Event name.
-	 * @private
-	 */
-	function clearEvent(emitter, evt) {
-	  if (--emitter._eventsCount === 0) emitter._events = new Events();
-	  else delete emitter._events[evt];
-	}
-
-	/**
-	 * Minimal `EventEmitter` interface that is molded against the Node.js
-	 * `EventEmitter` interface.
-	 *
-	 * @constructor
-	 * @public
-	 */
-	function EventEmitter() {
-	  this._events = new Events();
-	  this._eventsCount = 0;
-	}
-
-	/**
-	 * Return an array listing the events for which the emitter has registered
-	 * listeners.
-	 *
-	 * @returns {Array}
-	 * @public
-	 */
-	EventEmitter.prototype.eventNames = function eventNames() {
-	  var names = []
-	    , events
-	    , name;
-
-	  if (this._eventsCount === 0) return names;
-
-	  for (name in (events = this._events)) {
-	    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
-	  }
-
-	  if (Object.getOwnPropertySymbols) {
-	    return names.concat(Object.getOwnPropertySymbols(events));
-	  }
-
-	  return names;
-	};
-
-	/**
-	 * Return the listeners registered for a given event.
-	 *
-	 * @param {(String|Symbol)} event The event name.
-	 * @returns {Array} The registered listeners.
-	 * @public
-	 */
-	EventEmitter.prototype.listeners = function listeners(event) {
-	  var evt = prefix ? prefix + event : event
-	    , handlers = this._events[evt];
-
-	  if (!handlers) return [];
-	  if (handlers.fn) return [handlers.fn];
-
-	  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
-	    ee[i] = handlers[i].fn;
-	  }
-
-	  return ee;
-	};
-
-	/**
-	 * Return the number of listeners listening to a given event.
-	 *
-	 * @param {(String|Symbol)} event The event name.
-	 * @returns {Number} The number of listeners.
-	 * @public
-	 */
-	EventEmitter.prototype.listenerCount = function listenerCount(event) {
-	  var evt = prefix ? prefix + event : event
-	    , listeners = this._events[evt];
-
-	  if (!listeners) return 0;
-	  if (listeners.fn) return 1;
-	  return listeners.length;
-	};
-
-	/**
-	 * Calls each of the listeners registered for a given event.
-	 *
-	 * @param {(String|Symbol)} event The event name.
-	 * @returns {Boolean} `true` if the event had listeners, else `false`.
-	 * @public
-	 */
-	EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-	  var evt = prefix ? prefix + event : event;
-
-	  if (!this._events[evt]) return false;
-
-	  var listeners = this._events[evt]
-	    , len = arguments.length
-	    , args
-	    , i;
-
-	  if (listeners.fn) {
-	    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
-
-	    switch (len) {
-	      case 1: return listeners.fn.call(listeners.context), true;
-	      case 2: return listeners.fn.call(listeners.context, a1), true;
-	      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
-	      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
-	      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
-	      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
-	    }
-
-	    for (i = 1, args = new Array(len -1); i < len; i++) {
-	      args[i - 1] = arguments[i];
-	    }
-
-	    listeners.fn.apply(listeners.context, args);
-	  } else {
-	    var length = listeners.length
-	      , j;
-
-	    for (i = 0; i < length; i++) {
-	      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
-
-	      switch (len) {
-	        case 1: listeners[i].fn.call(listeners[i].context); break;
-	        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
-	        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
-	        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
-	        default:
-	          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
-	            args[j - 1] = arguments[j];
-	          }
-
-	          listeners[i].fn.apply(listeners[i].context, args);
-	      }
-	    }
-	  }
-
-	  return true;
-	};
-
-	/**
-	 * Add a listener for a given event.
-	 *
-	 * @param {(String|Symbol)} event The event name.
-	 * @param {Function} fn The listener function.
-	 * @param {*} [context=this] The context to invoke the listener with.
-	 * @returns {EventEmitter} `this`.
-	 * @public
-	 */
-	EventEmitter.prototype.on = function on(event, fn, context) {
-	  return addListener(this, event, fn, context, false);
-	};
-
-	/**
-	 * Add a one-time listener for a given event.
-	 *
-	 * @param {(String|Symbol)} event The event name.
-	 * @param {Function} fn The listener function.
-	 * @param {*} [context=this] The context to invoke the listener with.
-	 * @returns {EventEmitter} `this`.
-	 * @public
-	 */
-	EventEmitter.prototype.once = function once(event, fn, context) {
-	  return addListener(this, event, fn, context, true);
-	};
-
-	/**
-	 * Remove the listeners of a given event.
-	 *
-	 * @param {(String|Symbol)} event The event name.
-	 * @param {Function} fn Only remove the listeners that match this function.
-	 * @param {*} context Only remove the listeners that have this context.
-	 * @param {Boolean} once Only remove one-time listeners.
-	 * @returns {EventEmitter} `this`.
-	 * @public
-	 */
-	EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
-	  var evt = prefix ? prefix + event : event;
-
-	  if (!this._events[evt]) return this;
-	  if (!fn) {
-	    clearEvent(this, evt);
-	    return this;
-	  }
-
-	  var listeners = this._events[evt];
-
-	  if (listeners.fn) {
-	    if (
-	      listeners.fn === fn &&
-	      (!once || listeners.once) &&
-	      (!context || listeners.context === context)
-	    ) {
-	      clearEvent(this, evt);
-	    }
-	  } else {
-	    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
-	      if (
-	        listeners[i].fn !== fn ||
-	        (once && !listeners[i].once) ||
-	        (context && listeners[i].context !== context)
-	      ) {
-	        events.push(listeners[i]);
-	      }
-	    }
-
-	    //
-	    // Reset the array, or remove it completely if we have no more listeners.
-	    //
-	    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
-	    else clearEvent(this, evt);
-	  }
-
-	  return this;
-	};
-
-	/**
-	 * Remove all listeners, or those of the specified event.
-	 *
-	 * @param {(String|Symbol)} [event] The event name.
-	 * @returns {EventEmitter} `this`.
-	 * @public
-	 */
-	EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
-	  var evt;
-
-	  if (event) {
-	    evt = prefix ? prefix + event : event;
-	    if (this._events[evt]) clearEvent(this, evt);
-	  } else {
-	    this._events = new Events();
-	    this._eventsCount = 0;
-	  }
-
-	  return this;
-	};
-
-	//
-	// Alias methods names because people roll like that.
-	//
-	EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-	EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-
-	//
-	// Expose the prefix.
-	//
-	EventEmitter.prefixed = prefix;
-
-	//
-	// Allow `EventEmitter` to be imported as module namespace.
-	//
-	EventEmitter.EventEmitter = EventEmitter;
-
-	//
-	// Expose the module.
-	//
-	{
-	  module.exports = EventEmitter;
-	} 
-} (eventemitter3));
-
-var eventemitter3Exports = eventemitter3.exports;
-const EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
-
-class TimeoutError extends Error {
-	constructor(message) {
-		super(message);
-		this.name = 'TimeoutError';
-	}
-}
-
-/**
-An error to be thrown when the request is aborted by AbortController.
-DOMException is thrown instead of this Error when DOMException is available.
-*/
-class AbortError extends Error {
-	constructor(message) {
-		super();
-		this.name = 'AbortError';
-		this.message = message;
-	}
-}
-
-/**
-TODO: Remove AbortError and just throw DOMException when targeting Node 18.
-*/
-const getDOMException = errorMessage => globalThis.DOMException === undefined
-	? new AbortError(errorMessage)
-	: new DOMException(errorMessage);
-
-/**
-TODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.
-*/
-const getAbortedReason = signal => {
-	const reason = signal.reason === undefined
-		? getDOMException('This operation was aborted.')
-		: signal.reason;
-
-	return reason instanceof Error ? reason : getDOMException(reason);
-};
-
-function pTimeout(promise, options) {
-	const {
-		milliseconds,
-		fallback,
-		message,
-		customTimers = {setTimeout, clearTimeout},
-	} = options;
-
-	let timer;
-
-	const wrappedPromise = new Promise((resolve, reject) => {
-		if (typeof milliseconds !== 'number' || Math.sign(milliseconds) !== 1) {
-			throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
-		}
-
-		if (options.signal) {
-			const {signal} = options;
-			if (signal.aborted) {
-				reject(getAbortedReason(signal));
-			}
-
-			signal.addEventListener('abort', () => {
-				reject(getAbortedReason(signal));
-			});
-		}
-
-		if (milliseconds === Number.POSITIVE_INFINITY) {
-			promise.then(resolve, reject);
-			return;
-		}
-
-		// We create the error outside of `setTimeout` to preserve the stack trace.
-		const timeoutError = new TimeoutError();
-
-		timer = customTimers.setTimeout.call(undefined, () => {
-			if (fallback) {
-				try {
-					resolve(fallback());
-				} catch (error) {
-					reject(error);
-				}
-
-				return;
-			}
-
-			if (typeof promise.cancel === 'function') {
-				promise.cancel();
-			}
-
-			if (message === false) {
-				resolve();
-			} else if (message instanceof Error) {
-				reject(message);
-			} else {
-				timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
-				reject(timeoutError);
-			}
-		}, milliseconds);
-
-		(async () => {
-			try {
-				resolve(await promise);
-			} catch (error) {
-				reject(error);
-			}
-		})();
-	});
-
-	const cancelablePromise = wrappedPromise.finally(() => {
-		cancelablePromise.clear();
-	});
-
-	cancelablePromise.clear = () => {
-		customTimers.clearTimeout.call(undefined, timer);
-		timer = undefined;
-	};
-
-	return cancelablePromise;
-}
-
-// Port of lower_bound from https://en.cppreference.com/w/cpp/algorithm/lower_bound
-// Used to compute insertion index to keep queue sorted after insertion
-function lowerBound(array, value, comparator) {
-    let first = 0;
-    let count = array.length;
-    while (count > 0) {
-        const step = Math.trunc(count / 2);
-        let it = first + step;
-        if (comparator(array[it], value) <= 0) {
-            first = ++it;
-            count -= step + 1;
-        }
-        else {
-            count = step;
-        }
-    }
-    return first;
-}
-
-class PriorityQueue {
-    #queue = [];
-    enqueue(run, options) {
-        options = {
-            priority: 0,
-            ...options,
-        };
-        const element = {
-            priority: options.priority,
-            run,
-        };
-        if (this.size && this.#queue[this.size - 1].priority >= options.priority) {
-            this.#queue.push(element);
-            return;
-        }
-        const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
-        this.#queue.splice(index, 0, element);
-    }
-    dequeue() {
-        const item = this.#queue.shift();
-        return item?.run;
-    }
-    filter(options) {
-        return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
-    }
-    get size() {
-        return this.#queue.length;
-    }
-}
-
-/**
-Promise queue with concurrency control.
-*/
-class PQueue extends EventEmitter {
-    #carryoverConcurrencyCount;
-    #isIntervalIgnored;
-    #intervalCount = 0;
-    #intervalCap;
-    #interval;
-    #intervalEnd = 0;
-    #intervalId;
-    #timeoutId;
-    #queue;
-    #queueClass;
-    #pending = 0;
-    // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
-    #concurrency;
-    #isPaused;
-    #throwOnTimeout;
-    /**
-    Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
-
-    Applies to each future operation.
-    */
-    timeout;
-    // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`
-    constructor(options) {
-        super();
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        options = {
-            carryoverConcurrencyCount: false,
-            intervalCap: Number.POSITIVE_INFINITY,
-            interval: 0,
-            concurrency: Number.POSITIVE_INFINITY,
-            autoStart: true,
-            queueClass: PriorityQueue,
-            ...options,
-        };
-        if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {
-            throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ''}\` (${typeof options.intervalCap})`);
-        }
-        if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
-            throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ''}\` (${typeof options.interval})`);
-        }
-        this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;
-        this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
-        this.#intervalCap = options.intervalCap;
-        this.#interval = options.interval;
-        this.#queue = new options.queueClass();
-        this.#queueClass = options.queueClass;
-        this.concurrency = options.concurrency;
-        this.timeout = options.timeout;
-        this.#throwOnTimeout = options.throwOnTimeout === true;
-        this.#isPaused = options.autoStart === false;
-    }
-    get #doesIntervalAllowAnother() {
-        return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
-    }
-    get #doesConcurrentAllowAnother() {
-        return this.#pending < this.#concurrency;
-    }
-    #next() {
-        this.#pending--;
-        this.#tryToStartAnother();
-        this.emit('next');
-    }
-    #onResumeInterval() {
-        this.#onInterval();
-        this.#initializeIntervalIfNeeded();
-        this.#timeoutId = undefined;
-    }
-    get #isIntervalPaused() {
-        const now = Date.now();
-        if (this.#intervalId === undefined) {
-            const delay = this.#intervalEnd - now;
-            if (delay < 0) {
-                // Act as the interval was done
-                // We don't need to resume it here because it will be resumed on line 160
-                this.#intervalCount = (this.#carryoverConcurrencyCount) ? this.#pending : 0;
-            }
-            else {
-                // Act as the interval is pending
-                if (this.#timeoutId === undefined) {
-                    this.#timeoutId = setTimeout(() => {
-                        this.#onResumeInterval();
-                    }, delay);
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    #tryToStartAnother() {
-        if (this.#queue.size === 0) {
-            // We can clear the interval ("pause")
-            // Because we can redo it later ("resume")
-            if (this.#intervalId) {
-                clearInterval(this.#intervalId);
-            }
-            this.#intervalId = undefined;
-            this.emit('empty');
-            if (this.#pending === 0) {
-                this.emit('idle');
-            }
-            return false;
-        }
-        if (!this.#isPaused) {
-            const canInitializeInterval = !this.#isIntervalPaused;
-            if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
-                const job = this.#queue.dequeue();
-                if (!job) {
-                    return false;
-                }
-                this.emit('active');
-                job();
-                if (canInitializeInterval) {
-                    this.#initializeIntervalIfNeeded();
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    #initializeIntervalIfNeeded() {
-        if (this.#isIntervalIgnored || this.#intervalId !== undefined) {
-            return;
-        }
-        this.#intervalId = setInterval(() => {
-            this.#onInterval();
-        }, this.#interval);
-        this.#intervalEnd = Date.now() + this.#interval;
-    }
-    #onInterval() {
-        if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
-            clearInterval(this.#intervalId);
-            this.#intervalId = undefined;
-        }
-        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
-        this.#processQueue();
-    }
-    /**
-    Executes all queued functions until it reaches the limit.
-    */
-    #processQueue() {
-        // eslint-disable-next-line no-empty
-        while (this.#tryToStartAnother()) { }
-    }
-    get concurrency() {
-        return this.#concurrency;
-    }
-    set concurrency(newConcurrency) {
-        if (!(typeof newConcurrency === 'number' && newConcurrency >= 1)) {
-            throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
-        }
-        this.#concurrency = newConcurrency;
-        this.#processQueue();
-    }
-    async #throwOnAbort(signal) {
-        return new Promise((_resolve, reject) => {
-            signal.addEventListener('abort', () => {
-                reject(signal.reason);
-            }, { once: true });
-        });
-    }
-    async add(function_, options = {}) {
-        options = {
-            timeout: this.timeout,
-            throwOnTimeout: this.#throwOnTimeout,
-            ...options,
-        };
-        return new Promise((resolve, reject) => {
-            this.#queue.enqueue(async () => {
-                this.#pending++;
-                this.#intervalCount++;
-                try {
-                    options.signal?.throwIfAborted();
-                    let operation = function_({ signal: options.signal });
-                    if (options.timeout) {
-                        operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
-                    }
-                    if (options.signal) {
-                        operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
-                    }
-                    const result = await operation;
-                    resolve(result);
-                    this.emit('completed', result);
-                }
-                catch (error) {
-                    if (error instanceof TimeoutError && !options.throwOnTimeout) {
-                        resolve();
-                        return;
-                    }
-                    reject(error);
-                    this.emit('error', error);
-                }
-                finally {
-                    this.#next();
-                }
-            }, options);
-            this.emit('add');
-            this.#tryToStartAnother();
-        });
-    }
-    async addAll(functions, options) {
-        return Promise.all(functions.map(async (function_) => this.add(function_, options)));
-    }
-    /**
-    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
-    */
-    start() {
-        if (!this.#isPaused) {
-            return this;
-        }
-        this.#isPaused = false;
-        this.#processQueue();
-        return this;
-    }
-    /**
-    Put queue execution on hold.
-    */
-    pause() {
-        this.#isPaused = true;
-    }
-    /**
-    Clear the queue.
-    */
-    clear() {
-        this.#queue = new this.#queueClass();
-    }
-    /**
-    Can be called multiple times. Useful if you for example add additional items at a later time.
-
-    @returns A promise that settles when the queue becomes empty.
-    */
-    async onEmpty() {
-        // Instantly resolve if the queue is empty
-        if (this.#queue.size === 0) {
-            return;
-        }
-        await this.#onEvent('empty');
-    }
-    /**
-    @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
-
-    If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
-
-    Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
-    */
-    async onSizeLessThan(limit) {
-        // Instantly resolve if the queue is empty.
-        if (this.#queue.size < limit) {
-            return;
-        }
-        await this.#onEvent('next', () => this.#queue.size < limit);
-    }
-    /**
-    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
-
-    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
-    */
-    async onIdle() {
-        // Instantly resolve if none pending and if nothing else is queued
-        if (this.#pending === 0 && this.#queue.size === 0) {
-            return;
-        }
-        await this.#onEvent('idle');
-    }
-    async #onEvent(event, filter) {
-        return new Promise(resolve => {
-            const listener = () => {
-                if (filter && !filter()) {
-                    return;
-                }
-                this.off(event, listener);
-                resolve();
-            };
-            this.on(event, listener);
-        });
-    }
-    /**
-    Size of the queue, the number of queued items waiting to run.
-    */
-    get size() {
-        return this.#queue.size;
-    }
-    /**
-    Size of the queue, filtered by the given options.
-
-    For example, this can be used to find the number of items remaining in the queue with a specific priority level.
-    */
-    sizeBy(options) {
-        // eslint-disable-next-line unicorn/no-array-callback-reference
-        return this.#queue.filter(options).length;
-    }
-    /**
-    Number of running items (no longer in the queue).
-    */
-    get pending() {
-        return this.#pending;
-    }
-    /**
-    Whether the queue is currently paused.
-    */
-    get isPaused() {
-        return this.#isPaused;
-    }
-}
-
-function buildLog(text, count) {
-  console.log(`
-${gray("[vite-react-ssg]")} ${yellow(text)}${count ? blue(` (${count})`) : ""}`);
-}
-function getSize(str) {
-  return `${(str.length / 1024).toFixed(2)} KiB`;
-}
-async function routesToPaths(routes) {
-  if (!routes || routes.length === 0)
-    return { paths: ["/"] };
-  const paths = /* @__PURE__ */ new Set();
-  const getPaths = async (routes2, prefix = "") => {
-    prefix = prefix.replace(/\/$/g, "");
-    for (let route of routes2) {
-      if (route.lazy) {
-        const lazyData = await route.lazy();
-        if (lazyData) {
-          route = {
-            ...route,
-            ...lazyData
-          };
-        }
-      }
-      let path = route.path;
-      path = handlePath(path, prefix);
-      if (route.getStaticPaths && isDynamicSegmentsRoute(path)) {
-        const staticPaths = await route.getStaticPaths();
-        for (let staticPath of staticPaths) {
-          staticPath = handlePath(staticPath, prefix);
-          if (Array.isArray(route.children))
-            await getPaths(route.children, staticPath);
-        }
-      }
-      if (route.index && !path) {
-        paths.add("/");
-      }
-      if (Array.isArray(route.children))
-        await getPaths(route.children, path);
-    }
-  };
-  await getPaths(routes);
-  return { paths: Array.from(paths) };
-  function handlePath(path, prefix) {
-    if (path != null) {
-      path = prefix && !path.startsWith("/") ? `${prefix}${path ? `/${path}` : ""}` : path;
-      paths.add(path);
-    }
-    return path;
-  }
-}
-async function resolveAlias(config, entry) {
-  const resolver = config.createResolver();
-  const result = await resolver(entry, config.root);
-  return result || join(config.root, entry);
-}
-const { version } = JSON.parse(
-  readFileSync(new URL("../package.json", import.meta.url)).toString()
-);
-function createRequest(path) {
-  const url = new URL(path, "http://vite-react-ssg.com");
-  url.search = "";
-  url.hash = "";
-  url.pathname = path;
-  return new Request(url.href);
-}
-const dynamicRE = /[:*?]/;
-function isDynamicSegmentsRoute(route) {
-  if (!route)
-    return false;
-  return dynamicRE.test(route);
-}
-
-async function getCritters(outDir, options = {}) {
-  try {
-    const CrittersClass = (await import('critters')).default;
-    return new CrittersClass({
-      path: outDir,
-      logLevel: "warn",
-      external: true,
-      inlineFonts: true,
-      preloadFonts: true,
-      ...options
-    });
-  } catch (e) {
-    return void 0;
-  }
-}
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-async function renderStaticApp(app) {
-  const writableStream = new WritableAsPromise();
-  const { pipe } = renderToPipeableStream(app, {
-    onError(error) {
-      writableStream.destroy(error);
-    },
-    onAllReady() {
-      pipe(writableStream);
-    }
-  });
-  return writableStream.getPromise();
-}
-class WritableAsPromise extends Writable {
-  constructor() {
-    super();
-    __publicField(this, "_output");
-    __publicField(this, "_deferred");
-    this._output = "";
-    this._deferred = {
-      promise: null,
-      resolve: () => null,
-      reject: () => null
-    };
-    this._deferred.promise = new Promise((resolve, reject) => {
-      this._deferred.resolve = resolve;
-      this._deferred.reject = reject;
-    });
-  }
-  _write(chunk, _enc, next) {
-    this._output += chunk.toString();
-    next();
-  }
-  _destroy(error, next) {
-    if (error instanceof Error)
-      this._deferred.reject(error);
-    else
-      next();
-  }
-  end() {
-    this._deferred.resolve(this._output);
-    return this.destroy();
-  }
-  getPromise() {
-    return this._deferred.promise;
-  }
-}
-
-async function render(routesOrApp, request, styleCollector, basename) {
-  const helmetContext = {};
-  let inner;
-  let context = null;
-  if (Array.isArray(routesOrApp)) {
-    const { StaticRouterProvider, createStaticHandler, createStaticRouter } = await import('react-router-dom/server.js');
-    const { dataRoutes, query } = createStaticHandler(routesOrApp, { basename });
-    const _context = await query(request);
-    if (_context instanceof Response)
-      throw _context;
-    context = _context;
-    const router = createStaticRouter(dataRoutes, context);
-    inner = /* @__PURE__ */ React.createElement(StaticRouterProvider, { router, context });
-  } else {
-    inner = routesOrApp;
-  }
-  let app = /* @__PURE__ */ React.createElement(HelmetProvider, { context: helmetContext }, inner);
-  if (styleCollector)
-    app = styleCollector.collect(app);
-  const appHTML = await renderStaticApp(app);
-  const { htmlAttributes, bodyAttributes, metaAttributes, styleTag } = extractHelmet(helmetContext, styleCollector);
-  return { appHTML, htmlAttributes, bodyAttributes, metaAttributes, styleTag, routerContext: context };
-}
-function extractHelmet(context, styleCollector) {
-  const { helmet } = context;
-  const htmlAttributes = helmet.htmlAttributes.toString();
-  const bodyAttributes = helmet.bodyAttributes.toString();
-  let titleString = helmet.title.toString();
-  if (titleString.split(">")[1] === "</title") {
-    titleString = "";
-  }
-  const metaStrings = [
-    titleString,
-    helmet.meta.toString(),
-    helmet.link.toString(),
-    helmet.script.toString()
-  ];
-  const styleTag = styleCollector?.toString?.("") ?? "";
-  const metaAttributes = metaStrings.filter(Boolean);
-  return { htmlAttributes, bodyAttributes, metaAttributes, styleTag };
-}
-
-const SCRIPT_COMMENT_PLACEHOLDER = "/* SCRIPT_COMMENT_PLACEHOLDER */";
-async function renderHTML({
-  rootContainerId,
-  indexHTML,
-  appHTML,
-  metaAttributes,
-  bodyAttributes,
-  htmlAttributes,
-  initialState
-}) {
-  const stateScript = initialState ? `
-<script>window.__INITIAL_STATE__=${initialState}<\/script>` : "";
-  const scriptPlaceHolder = `
-<script>${SCRIPT_COMMENT_PLACEHOLDER}<\/script>`;
-  const headStartTag = "<head>";
-  const metaTags = metaAttributes.join("");
-  indexHTML = indexHTML.replace(headStartTag, headStartTag + metaTags);
-  const bodyStartTag = "<body";
-  indexHTML = indexHTML.replace(bodyStartTag, `${bodyStartTag} ${bodyAttributes}`);
-  const htmlStartTag = "<html";
-  indexHTML = indexHTML.replace(htmlStartTag, `${htmlStartTag} ${htmlAttributes}`);
-  const container = `<div id="${rootContainerId}"></div>`;
-  if (indexHTML.includes(container)) {
-    return indexHTML.replace(
-      container,
-      `<div id="${rootContainerId}" data-server-rendered="true">${appHTML}</div>${stateScript}${scriptPlaceHolder}`
-    );
-  }
-  const html5Parser = await import('html5parser');
-  const ast = html5Parser.parse(indexHTML);
-  let renderedOutput;
-  html5Parser.walk(ast, {
-    enter: (node) => {
-      if (!renderedOutput && node?.type === html5Parser.SyntaxKind.Tag && Array.isArray(node.attributes) && node.attributes.length > 0 && node.attributes.some((attr) => attr.name.value === "id" && attr.value?.value === rootContainerId)) {
-        const attributesStringified = [...node.attributes.map(({ name: { value: name }, value }) => `${name}="${value.value}"`)].join(" ");
-        const indexHTMLBefore = indexHTML.slice(0, node.start);
-        const indexHTMLAfter = indexHTML.slice(node.end);
-        renderedOutput = `${indexHTMLBefore}<${node.name} ${attributesStringified} data-server-rendered="true">${appHTML}</${node.name}>${stateScript}${indexHTMLAfter}`;
-      }
-    }
-  });
-  if (!renderedOutput)
-    throw new Error(`Could not find a tag with id="${rootContainerId}" to replace it with server-side rendered HTML`);
-  return renderedOutput;
-}
-async function detectEntry(root) {
-  const scriptSrcReg = /<script(?:.*?)src=["'](.+?)["'](?!<)(?:.*)\>(?:[\n\r\s]*?)(?:<\/script>)/gim;
-  const html = await fs.readFile(join(root, "index.html"), "utf-8");
-  const scripts = [...html.matchAll(scriptSrcReg)];
-  const [, entry] = scripts.find((matchResult) => {
-    const [script] = matchResult;
-    const [, scriptType] = script.match(/.*\stype=(?:'|")?([^>'"\s]+)/i) || [];
-    return scriptType === "module";
-  }) || [];
-  return entry || "src/main.ts";
-}
-function createLink$1(href) {
-  return `<link rel="stylesheet" href="${href}">`;
-}
-
-function renderPreloadLinks(document, assets) {
-  const seen = /* @__PURE__ */ new Set();
-  if (assets) {
-    assets.forEach((file) => {
-      if (!seen.has(file)) {
-        seen.add(file);
-        renderPreloadLink(document, file);
-      }
-    });
-  }
-}
-function renderPreloadLink(document, file) {
-  if (file.endsWith(".js")) {
-    appendLink(document, {
-      rel: "modulepreload",
-      crossOrigin: "",
-      href: file
-    });
-  } else if (file.endsWith(".css")) {
-    appendLink(document, {
-      rel: "stylesheet",
-      href: file,
-      crossOrigin: ""
-    });
-  } else if (file.endsWith(".woff") || file.endsWith(".woff2") || file.endsWith(".ttf")) {
-    appendLink(document, {
-      rel: "preload",
-      as: "font",
-      type: "font/woff2",
-      href: file,
-      crossOrigin: ""
-    });
-  } else if (file.endsWith(".png") || file.endsWith(".jpg") || file.endsWith(".jpeg") || file.endsWith(".webp") || file.endsWith(".gif") || file.endsWith(".ico") || file.endsWith(".svg")) {
-    appendLink(document, {
-      rel: "preload",
-      as: "image",
-      href: file,
-      crossOrigin: ""
-    });
-  }
-}
-function createLink(document) {
-  return document.createElement("link");
-}
-function setAttrs(el, attrs) {
-  const keys = Object.keys(attrs);
-  for (const key of keys)
-    el.setAttribute(key, attrs[key]);
-}
-function appendLink(document, attrs) {
-  const exits = document.head.querySelector(`link[href='${attrs.file}']`);
-  if (exits)
-    return;
-  const link = createLink(document);
-  setAttrs(link, attrs);
-  document.head.appendChild(link);
-}
-
-const DYNAMIC_IMPORT_REGEX = /import\("([^)]+)"\)/g;
-function collectAssets({
-  routes,
-  locationArg,
-  base,
-  serverManifest,
-  manifest,
-  ssrManifest
-}) {
-  const matches = matchRoutes([...routes], locationArg, base);
-  const routeEntries = matches?.map((item) => item.route.entry).filter(Boolean) ?? [];
-  const dynamicImports = /* @__PURE__ */ new Set();
-  matches?.forEach((item) => {
-    let lazyStr = "";
-    if (item.route.lazy) {
-      lazyStr += item.route.lazy.toString();
-    }
-    if (item.route.Component?._payload?._result) {
-      lazyStr += item.route.Component._payload._result.toString();
-    }
-    const match = lazyStr.matchAll(DYNAMIC_IMPORT_REGEX);
-    for (const m of match) {
-      dynamicImports.add(m[1].split("/").at(-1) ?? "");
-    }
-  });
-  const entries = /* @__PURE__ */ new Set();
-  routeEntries.forEach((e) => entries.add(e));
-  const manifestEntries = [...Object.entries(serverManifest)];
-  dynamicImports.forEach((name) => {
-    const result = manifestEntries.find(([_, value]) => value.file.endsWith(name));
-    if (result) {
-      entries.add(result[0]);
-    }
-  });
-  const modules = collectModulesForEntries(manifest, entries);
-  const assets = /* @__PURE__ */ new Set();
-  Array.from(modules).forEach((id) => {
-    const files = ssrManifest[id] || [];
-    files.forEach((file) => {
-      assets.add(file);
-    });
-  });
-  return assets;
-}
-function collectModulesForEntries(manifest, entries) {
-  const mods = /* @__PURE__ */ new Set();
-  if (!entries)
-    return mods;
-  for (const entry of entries)
-    collectModules(manifest, entry, mods);
-  return mods;
-}
-function collectModules(manifest, entry, mods = /* @__PURE__ */ new Set()) {
-  if (!entry)
-    return mods;
-  mods.add(entry);
-  manifest[entry]?.dynamicImports?.forEach((item) => {
-    collectModules(manifest, item, mods);
-  });
-  return mods;
-}
-
-const dotVitedir = Number.parseInt(version$1) >= 5 ? [".vite"] : [];
-function DefaultIncludedRoutes(paths, _routes) {
-  return paths.filter((i) => !i.includes(":") && !i.includes("*"));
-}
-async function build(ssgOptions = {}, viteConfig = {}) {
-  const mode = process.env.MODE || process.env.NODE_ENV || ssgOptions.mode || "production";
-  const config = await resolveConfig(viteConfig, "build", mode, mode);
-  const cwd = process.cwd();
-  const root = config.root || cwd;
-  const hash = Math.random().toString(36).substring(2, 12);
-  const ssgOut = join(root, ".vite-react-ssg-temp", hash);
-  const outDir = config.build.outDir || "dist";
-  const out = isAbsolute(outDir) ? outDir : join(root, outDir);
-  const configBase = config.base;
-  const {
-    script = "sync",
-    mock = false,
-    entry = await detectEntry(root),
-    formatting = "none",
-    crittersOptions = {},
-    includedRoutes: configIncludedRoutes = DefaultIncludedRoutes,
-    onBeforePageRender,
-    onPageRendered,
-    onFinished,
-    dirStyle = "flat",
-    includeAllRoutes = false,
-    format = "esm",
-    concurrency = 20,
-    rootContainerId = "root"
-  } = Object.assign({}, config.ssgOptions || {}, ssgOptions);
-  if (fs.existsSync(ssgOut))
-    await fs.remove(ssgOut);
-  const clientLogger = createLogger();
-  const loggerWarn = clientLogger.warn;
-  clientLogger.warn = (msg, options) => {
-    if (msg.includes("vite:resolve") && msg.includes("externalized for browser compatibility"))
-      return;
-    loggerWarn(msg, options);
-  };
-  buildLog("Build for client...");
-  await build$1(mergeConfig(viteConfig, {
-    build: {
-      manifest: true,
-      ssrManifest: true,
-      rollupOptions: {
-        input: {
-          app: join(root, "./index.html")
-        },
-        // @ts-expect-error rollup type
-        onLog(level, log, handler) {
-          if (log.message.includes("react-helmet-async"))
-            return;
-          handler(level, log);
-        }
-      }
-    },
-    customLogger: clientLogger,
-    mode: config.mode,
-    ssr: { noExternal: ["vite-react-ssg"] }
-  }));
-  if (mock) {
-    const { jsdomGlobal } = await import('./chunks/jsdomGlobal.mjs');
-    jsdomGlobal();
-  }
-  buildLog("Build for server...");
-  process.env.VITE_SSG = "true";
-  const ssrEntry = await resolveAlias(config, entry);
-  await build$1(mergeConfig(viteConfig, {
-    build: {
-      ssr: ssrEntry,
-      manifest: true,
-      outDir: ssgOut,
-      minify: false,
-      cssCodeSplit: false,
-      rollupOptions: {
-        output: format === "esm" ? {
-          entryFileNames: "[name].mjs",
-          format: "esm"
-        } : {
-          entryFileNames: "[name].cjs",
-          format: "cjs"
-        }
-      }
-    },
-    mode: config.mode,
-    ssr: { noExternal: ["vite-react-ssg"] }
-  }));
-  const prefix = format === "esm" && process.platform === "win32" ? "file://" : "";
-  const ext = format === "esm" ? ".mjs" : ".cjs";
-  const serverEntry = join(prefix, ssgOut, parse(ssrEntry).name + ext);
-  const serverManifest = JSON.parse(await fs.readFile(join(ssgOut, ...dotVitedir, "manifest.json"), "utf-8"));
-  const _require = createRequire(import.meta.url);
-  const { createRoot, includedRoutes: serverEntryIncludedRoutes } = format === "esm" ? await import(serverEntry) : _require(serverEntry);
-  const includedRoutes = serverEntryIncludedRoutes || configIncludedRoutes;
-  const { routes } = await createRoot(false);
-  const { paths } = await routesToPaths(routes);
-  let routesPaths = includeAllRoutes ? paths : await includedRoutes(paths, routes || []);
-  routesPaths = DefaultIncludedRoutes(routesPaths);
-  routesPaths = Array.from(new Set(routesPaths));
-  buildLog("Rendering Pages...", routesPaths.length);
-  const critters = crittersOptions !== false ? await getCritters(outDir, { publicPath: configBase, ...crittersOptions }) : void 0;
-  if (critters)
-    console.log(`${gray("[vite-react-ssg]")} ${blue("Critical CSS generation enabled via `critters`")}`);
-  const ssrManifest = JSON.parse(await fs.readFile(join(out, ...dotVitedir, "ssr-manifest.json"), "utf-8"));
-  const manifest = JSON.parse(await fs.readFile(join(out, ...dotVitedir, "manifest.json"), "utf-8"));
-  let indexHTML = await fs.readFile(join(out, "index.html"), "utf-8");
-  indexHTML = rewriteScripts(indexHTML, script);
-  const queue = new PQueue({ concurrency });
-  const crittersQueue = new PQueue({ concurrency: 1 });
-  const staticLoaderDataManifest = {};
-  for (const path of routesPaths) {
-    queue.add(async () => {
-      try {
-        const appCtx = await createRoot(false, path);
-        const { initialState, base, routes: routes2, triggerOnSSRAppRendered, transformState = serializeState, getStyleCollector, app } = appCtx;
-        const styleCollector = getStyleCollector ? await getStyleCollector() : null;
-        const transformedIndexHTML = await onBeforePageRender?.(path, indexHTML, appCtx) || indexHTML;
-        const fetchUrl = `${withTrailingSlash(base)}${removeLeadingSlash(path)}`;
-        const request = createRequest(fetchUrl);
-        const assets = !app ? collectAssets({ routes: [...routes2], locationArg: fetchUrl, base, serverManifest, manifest, ssrManifest }) : /* @__PURE__ */ new Set();
-        const { appHTML, bodyAttributes, htmlAttributes, metaAttributes, styleTag, routerContext } = await render(app ?? [...routes2], request, styleCollector, base);
-        staticLoaderDataManifest[path] = routerContext?.loaderData;
-        await triggerOnSSRAppRendered?.(path, appHTML, appCtx);
-        const renderedHTML = await renderHTML({
-          rootContainerId,
-          appHTML,
-          indexHTML: transformedIndexHTML,
-          metaAttributes,
-          bodyAttributes,
-          htmlAttributes,
-          initialState: null
-        });
-        const jsdom = new JSDOM(renderedHTML);
-        renderPreloadLinks(jsdom.window.document, assets);
-        const html = jsdom.serialize();
-        let transformed = await onPageRendered?.(path, html, appCtx) || html;
-        transformed = transformed.replace(SCRIPT_COMMENT_PLACEHOLDER, `window.__VITE_REACT_SSG_HASH__ = '${hash}'`);
-        if (critters) {
-          transformed = await crittersQueue.add(() => critters.process(transformed));
-          transformed = transformed.replace(/<link\srel="stylesheet"/g, '<link rel="stylesheet" crossorigin');
-        }
-        if (styleTag)
-          transformed = transformed.replace("<head>", `<head>${styleTag}`);
-        const formatted = await formatHtml(transformed, formatting);
-        const relativeRouteFile = `${(path.endsWith("/") ? `${path}index` : path).replace(/^\//g, "")}.html`;
-        const filename = dirStyle === "nested" ? join(path.replace(/^\//g, ""), "index.html") : relativeRouteFile;
-        await fs.ensureDir(join(out, dirname(filename)));
-        await fs.writeFile(join(out, filename), formatted, "utf-8");
-        config.logger.info(
-          `${dim(`${outDir}/`)}${cyan(filename.padEnd(15, " "))}  ${dim(getSize(formatted))}`
-        );
-      } catch (err) {
-        throw new Error(`${gray("[vite-react-ssg]")} ${red(`Error on page: ${cyan(path)}`)}
-${err.stack}`);
-      }
-    });
-  }
-  await queue.start().onIdle();
-  buildLog("Generating static loader data manifest...");
-  const staticLoaderDataManifestString = JSON.stringify(staticLoaderDataManifest, null, 0);
-  await fs.writeFile(join(out, `static-loader-data-manifest-${hash}.json`), staticLoaderDataManifestString);
-  config.logger.info(
-    `${dim(`${outDir}/`)}${cyan(`static-loader-data-manifest-${hash}.json`.padEnd(15, " "))}  ${dim(getSize(staticLoaderDataManifestString))}`
-  );
-  await fs.remove(join(root, ".vite-react-ssg-temp"));
-  const pwaPlugin = config.plugins.find((i) => i.name === "vite-plugin-pwa")?.api;
-  if (pwaPlugin && !pwaPlugin.disabled && pwaPlugin.generateSW) {
-    buildLog("Regenerate PWA...");
-    await pwaPlugin.generateSW();
-  }
-  console.log(`
-${gray("[vite-react-ssg]")} ${green("Build finished.")}`);
-  await onFinished?.();
-  const waitInSeconds = 15;
-  const timeout = setTimeout(() => {
-    console.log(`${gray("[vite-react-ssg]")} ${yellow(`Build process still running after ${waitInSeconds}s`)}.  There might be something misconfigured in your setup. Force exit.`);
-    process.exit(0);
-  }, waitInSeconds * 1e3);
-  timeout.unref();
-}
-function rewriteScripts(indexHTML, mode) {
-  if (!mode || mode === "sync")
-    return indexHTML;
-  return indexHTML.replace(/<script type="module" /g, `<script type="module" ${mode} `);
-}
-async function formatHtml(html, formatting) {
-  if (formatting === "prettify") {
-    try {
-      const prettier = (await import('prettier/esm/standalone.mjs')).default;
-      const parserHTML = (await import('prettier/esm/parser-html.mjs')).default;
-      return prettier.format(html, { semi: false, parser: "html", plugins: [parserHTML] });
-    } catch (e) {
-      console.error(`${gray("[vite-react-ssg]")} ${red(`Error formatting html: ${e?.message}`)}`);
-      return html;
-    }
-  }
-  return html;
-}
-
-function invariant(value, message) {
-  if (value === false || value === null || typeof value === "undefined") {
-    console.error(
-      "The following error is a bug in Vite-react-ssg; please open an issue! https://github.com/Daydreamer-riri/vite-react-ssg/issues/new"
-    );
-    throw new Error(message);
-  }
-}
-
-function fromNodeHeaders(nodeHeaders) {
-  const headers = new Headers();
-  for (const [key, values] of Object.entries(nodeHeaders)) {
-    if (values) {
-      if (Array.isArray(values)) {
-        for (const value of values)
-          headers.append(key, value);
-      } else {
-        headers.set(key, values);
-      }
-    }
-  }
-  return headers;
-}
-function fromNodeRequest(nodeReq) {
-  const origin = nodeReq.headers.origin && nodeReq.headers.origin !== "null" ? nodeReq.headers.origin : `http://${nodeReq.headers.host}`;
-  invariant(
-    nodeReq.originalUrl,
-    "Expected `nodeReq.originalUrl` to be defined"
-  );
-  const url = new URL(nodeReq.originalUrl, origin);
-  const init = {
-    method: nodeReq.method,
-    headers: fromNodeHeaders(nodeReq.headers)
-  };
-  return new Request(url.href, init);
-}
-async function toNodeRequest(res, nodeRes) {
-  nodeRes.statusCode = res.status;
-  nodeRes.statusMessage = res.statusText;
-  for (const [name, value] of res.headers) {
-    nodeRes.setHeader(name, value);
-  }
-  if (res.body) {
-    const responseBody = res.body;
-    const readable = Readable.from(responseBody);
-    readable.pipe(nodeRes);
-    await once(readable, "end");
-  } else {
-    nodeRes.end();
-  }
-}
-
-function ssrServerPlugin({
-  template,
-  ssrEntry,
-  onBeforePageRender,
-  entry,
-  rootContainerId,
-  onPageRendered
-}) {
-  return {
-    name: "vite-react-ssg:dev-server-remix",
-    configureServer(server) {
-      const renderMiddleware = async (req, res, _next) => {
-        try {
-          const url = req.originalUrl;
-          const createRoot = await server.ssrLoadModule(ssrEntry).then((m) => m.createRoot);
-          const appCtx = await createRoot(false, url);
-          const { routes, getStyleCollector, base, app } = appCtx;
-          const searchParams = new URLSearchParams(url.split("?")[1]);
-          if (!app && searchParams.has("_data")) {
-            const request = fromNodeRequest(req);
-            const url2 = new URL(request.url);
-            const routeId = decodeURIComponent(searchParams.get("_data"));
-            const matches = matchRoutes(
-              convertRoutesToDataRoutes([...routes], (route) => route),
-              {
-                pathname: url2.pathname,
-                search: url2.search,
-                hash: url2.hash,
-                state: null,
-                key: "default"
-              },
-              base
-            );
-            if (!matches) {
-              res.statusCode = 404;
-              res.end(`Route not found: ${routeId}`);
-              return;
-            }
-            const match = matches.find((m) => m.route.id === routeId);
-            if (!match) {
-              res.statusCode = 404;
-              res.end(`Route not found: ${routeId}`);
-              return;
-            }
-            const loader = match.route.loader ?? await match.route.lazy?.().then((m) => m.loader);
-            if (!loader) {
-              res.statusCode = 200;
-              res.end(`There is no loader for the route: ${routeId}`);
-              return;
-            }
-            const response = await callRouteLoader({
-              loader,
-              params: match.params,
-              request,
-              routeId
-            });
-            await toNodeRequest(response, res);
-            return;
-          }
-          const indexHTML = await server.transformIndexHtml(url, template);
-          const transformedIndexHTML = await onBeforePageRender?.(url, indexHTML, appCtx) || indexHTML;
-          const styleCollector = getStyleCollector ? await getStyleCollector() : null;
-          const { appHTML, bodyAttributes, htmlAttributes, metaAttributes, styleTag } = await render(app ?? [...routes], fromNodeRequest(req), styleCollector, base);
-          metaAttributes.push(styleTag);
-          const mods = await Promise.all(
-            [ssrEntry, entry].map(async (entry2) => await server.moduleGraph.getModuleByUrl(entry2))
-          );
-          const assetsUrls = /* @__PURE__ */ new Set();
-          const collectAssets = async (mod) => {
-            if (!mod || !mod?.ssrTransformResult)
-              return;
-            const { deps = [], dynamicDeps = [] } = mod?.ssrTransformResult;
-            const allDeps = [...deps, ...dynamicDeps];
-            for (const dep of allDeps) {
-              if (dep.endsWith(".css") || dep.endsWith(".scss") || dep.endsWith(".sass") || dep.endsWith(".less")) {
-                assetsUrls.add(dep);
-              } else if (dep.endsWith(".ts") || dep.endsWith(".tsx")) {
-                const depModule = await server.moduleGraph.getModuleByUrl(dep);
-                depModule && await collectAssets(depModule);
-              }
-            }
-          };
-          await Promise.all(mods.map(async (mod) => collectAssets(mod)));
-          const preloadLink = [...assetsUrls].map((item) => createLink$1(joinUrlSegments(server.config.base, item)));
-          metaAttributes.push(...preloadLink);
-          const renderedHTML = await renderHTML({
-            rootContainerId,
-            appHTML,
-            indexHTML: transformedIndexHTML,
-            metaAttributes,
-            bodyAttributes,
-            htmlAttributes,
-            initialState: null
-          });
-          const transformed = await onPageRendered?.(url, renderedHTML, appCtx) || renderedHTML;
-          res.statusCode = 200;
-          res.setHeader("Content-Type", "text/html");
-          const isDev = "pluginContainer" in server;
-          const headers = isDev ? server.config.server.headers : server.config.preview.headers;
-          send(req, res, transformed, "html", { headers });
-        } catch (e) {
-          server.ssrFixStacktrace(e);
-          console.error(`[vite-react-ssg] error: ${e.stack}`);
-          res.statusCode = 500;
-          res.end(e.stack);
-        }
-      };
-      return () => {
-        server.middlewares.use(renderMiddleware);
-      };
-    }
-  };
-}
-async function callRouteLoader({
-  // loadContext,
-  loader,
-  params,
-  request,
-  routeId
-  // singleFetch,
-  // response,
-}) {
-  const result = await loader({
-    request: stripDataParam(stripIndexParam(request)),
-    // context: loadContext,
-    params
-    // Only provided when single fetch is enabled, and made available via
-    // `defineLoader` types, not `LoaderFunctionArgs`
-    // ...(singleFetch ? { response } : null),
-  });
-  if (result === void 0) {
-    throw new Error(
-      `You defined a loader for route "${routeId}" but didn't return anything from your \`loader\` function. Please return a value or \`null\`.`
-    );
-  }
-  return isResponse(result) ? result : json(result);
-}
-function isResponse(value) {
-  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
-}
-function stripIndexParam(request) {
-  const url = new URL(request.url);
-  const indexValues = url.searchParams.getAll("index");
-  url.searchParams.delete("index");
-  const indexValuesToKeep = [];
-  for (const indexValue of indexValues) {
-    if (indexValue) {
-      indexValuesToKeep.push(indexValue);
-    }
-  }
-  for (const toKeep of indexValuesToKeep) {
-    url.searchParams.append("index", toKeep);
-  }
-  const init = {
-    method: request.method,
-    body: request.body,
-    headers: request.headers,
-    signal: request.signal
-  };
-  if (init.body) {
-    init.duplex = "half";
-  }
-  return new Request(url.href, init);
-}
-function stripDataParam(request) {
-  const url = new URL(request.url);
-  url.searchParams.delete("_data");
-  const init = {
-    method: request.method,
-    body: request.body,
-    headers: request.headers,
-    signal: request.signal
-  };
-  if (init.body) {
-    init.duplex = "half";
-  }
-  return new Request(url.href, init);
-}
-
-async function dev(ssgOptions = {}, viteConfig = {}, customOptions) {
-  const mode = process.env.MODE || process.env.NODE_ENV || ssgOptions.mode || "development";
-  const config = await resolveConfig(viteConfig, "serve", mode, mode);
-  const cwd = process.cwd();
-  const root = config.root || cwd;
-  const {
-    entry = await detectEntry(root),
-    onBeforePageRender,
-    onPageRendered,
-    rootContainerId = "root",
-    mock = false
-  } = Object.assign({}, config.ssgOptions || {}, ssgOptions);
-  const ssrEntry = await resolveAlias(config, entry);
-  const template = await fs.readFile(join(root, "index.html"), "utf-8");
-  let viteServer;
-  globalThis.__ssr_start_time = performance.now();
-  createServer$1().catch((err) => {
-    console.error(
-      `${red(`failed to start server. error:`)}
-${err.stack}`
-    );
-    process.exit(1);
-  });
-  async function createServer$1() {
-    process.env.__DEV_MODE_SSR = "true";
-    if (mock) {
-      const { jsdomGlobal } = await import('./chunks/jsdomGlobal.mjs');
-      jsdomGlobal();
-    }
-    viteServer = await createServer({
-      ...viteConfig,
-      plugins: [
-        ...viteConfig.plugins ?? [],
-        ssrServerPlugin({
-          template,
-          ssrEntry,
-          onBeforePageRender,
-          onPageRendered,
-          entry,
-          rootContainerId
-        })
-      ]
-    });
-    await viteServer.listen();
-    printServerInfo(viteServer, !!customOptions);
-    viteServer.bindCLIShortcuts({ print: true });
-    return viteServer;
-  }
-}
-async function printServerInfo(server, onlyUrl = false) {
-  if (onlyUrl)
-    return server.printUrls();
-  const info = server.config.logger.info;
-  let ssrReadyMessage = " -- SSR";
-  if (globalThis.__ssr_start_time) {
-    ssrReadyMessage += ` ready in ${reset(bold(`${Math.round(
-      // @ts-expect-error global var
-      performance.now() - globalThis.__ssr_start_time
-    )}ms`))}`;
-  }
-  info(
-    `
- ${bgLightCyan(` VITE-REACT-SSG v${version} `)}`,
-    { clear: !server.config.logger.hasWarned }
-  );
-  info(
-    `${cyan(`
-  VITE v${version$1}`) + dim(ssrReadyMessage)}
-`
-  );
-  info(
-    green("  dev server running at:")
-  );
-  server.printUrls();
-}
-
-export { build, dev };
+export { b as build, d as dev } from './shared/vite-react-ssg.CZ2uxKni.mjs';
+import 'node:path';
+import 'node:module';
+import 'kolorist';
+import 'p-queue';
+import 'fs-extra';
+import 'vite';
+import 'jsdom';
+import './shared/vite-react-ssg.C6pK7rvr.mjs';
+import './shared/vite-react-ssg.CjIppNIS.mjs';
+import 'react/jsx-runtime';
+import 'react-helmet-async';
+import 'node:stream';
+import 'react-dom/server';
+import 'node:events';
+import './shared/vite-react-ssg.C0y5wbxl.mjs';
+import './shared/vite-react-ssg.4y2OEiyV.mjs';