vite-react-ssg 0.4.0 → 0.5.0

package/dist/node.cjs

@@ -434,50 +434,47 @@ class TimeoutError extends Error {
 An error to be thrown when the request is aborted by AbortController.
 DOMException is thrown instead of this Error when DOMException is available.
 */
-let AbortError$1 = class AbortError extends Error {
+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$1(errorMessage) :
-	new DOMException(errorMessage);
+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;
+	const reason = signal.reason === undefined
+		? getDOMException('This operation was aborted.')
+		: signal.reason;
 
 	return reason instanceof Error ? reason : getDOMException(reason);
 };
 
-function pTimeout(promise, milliseconds, fallback, options) {
+function pTimeout(promise, options) {
+	const {
+		milliseconds,
+		fallback,
+		message,
+		customTimers = {setTimeout, clearTimeout},
+	} = options;
+
 	let timer;
 
-	const cancelablePromise = new Promise((resolve, reject) => {
+	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 (milliseconds === Number.POSITIVE_INFINITY) {
-			resolve(promise);
-			return;
-		}
-
-		options = {
-			customTimers: {setTimeout, clearTimeout},
-			...options
-		};
-
 		if (options.signal) {
 			const {signal} = options;
 			if (signal.aborted) {
@@ -489,8 +486,16 @@ function pTimeout(promise, milliseconds, fallback, options) {
 			});
 		}
 
-		timer = options.customTimers.setTimeout.call(undefined, () => {
-			if (typeof fallback === 'function') {
+		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) {
@@ -500,14 +505,18 @@ function pTimeout(promise, milliseconds, fallback, options) {
 				return;
 			}
 
-			const message = typeof fallback === 'string' ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
-			const timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message);
-
 			if (typeof promise.cancel === 'function') {
 				promise.cancel();
 			}
 
-			reject(timeoutError);
+			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 () => {
@@ -515,14 +524,16 @@ function pTimeout(promise, milliseconds, fallback, options) {
 				resolve(await promise);
 			} catch (error) {
 				reject(error);
-			} finally {
-				options.customTimers.clearTimeout.call(undefined, timer);
 			}
 		})();
 	});
 
+	const cancelablePromise = wrappedPromise.finally(() => {
+		cancelablePromise.clear();
+	});
+
 	cancelablePromise.clear = () => {
-		clearTimeout(timer);
+		customTimers.clearTimeout.call(undefined, timer);
 		timer = undefined;
 	};
 
@@ -548,16 +559,8 @@ function lowerBound(array, value, comparator) {
     return first;
 }
 
-var __classPrivateFieldGet$1 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _PriorityQueue_queue;
 class PriorityQueue {
-    constructor() {
-        _PriorityQueue_queue.set(this, []);
-    }
+    #queue = [];
     enqueue(run, options) {
         options = {
             priority: 0,
@@ -567,78 +570,53 @@ class PriorityQueue {
             priority: options.priority,
             run,
         };
-        if (this.size && __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f")[this.size - 1].priority >= options.priority) {
-            __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").push(element);
+        if (this.size && this.#queue[this.size - 1].priority >= options.priority) {
+            this.#queue.push(element);
             return;
         }
-        const index = lowerBound(__classPrivateFieldGet$1(this, _PriorityQueue_queue, "f"), element, (a, b) => b.priority - a.priority);
-        __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").splice(index, 0, element);
+        const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
+        this.#queue.splice(index, 0, element);
     }
     dequeue() {
-        const item = __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").shift();
-        return item === null || item === void 0 ? void 0 : item.run;
+        const item = this.#queue.shift();
+        return item?.run;
     }
     filter(options) {
-        return __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").filter((element) => element.priority === options.priority).map((element) => element.run);
+        return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
     }
     get size() {
-        return __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").length;
+        return this.#queue.length;
     }
 }
-_PriorityQueue_queue = new WeakMap();
 
-var __classPrivateFieldSet = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _PQueue_instances, _PQueue_carryoverConcurrencyCount, _PQueue_isIntervalIgnored, _PQueue_intervalCount, _PQueue_intervalCap, _PQueue_interval, _PQueue_intervalEnd, _PQueue_intervalId, _PQueue_timeoutId, _PQueue_queue, _PQueue_queueClass, _PQueue_pending, _PQueue_concurrency, _PQueue_isPaused, _PQueue_throwOnTimeout, _PQueue_doesIntervalAllowAnother_get, _PQueue_doesConcurrentAllowAnother_get, _PQueue_next, _PQueue_onResumeInterval, _PQueue_isIntervalPaused_get, _PQueue_tryToStartAnother, _PQueue_initializeIntervalIfNeeded, _PQueue_onInterval, _PQueue_processQueue, _PQueue_throwOnAbort, _PQueue_onEvent;
-/**
-The error thrown by `queue.add()` when a job is aborted before it is run. See `signal`.
-*/
-class AbortError extends Error {
-}
 /**
 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) {
-        var _a, _b, _c, _d;
         super();
-        _PQueue_instances.add(this);
-        _PQueue_carryoverConcurrencyCount.set(this, void 0);
-        _PQueue_isIntervalIgnored.set(this, void 0);
-        _PQueue_intervalCount.set(this, 0);
-        _PQueue_intervalCap.set(this, void 0);
-        _PQueue_interval.set(this, void 0);
-        _PQueue_intervalEnd.set(this, 0);
-        _PQueue_intervalId.set(this, void 0);
-        _PQueue_timeoutId.set(this, void 0);
-        _PQueue_queue.set(this, void 0);
-        _PQueue_queueClass.set(this, void 0);
-        _PQueue_pending.set(this, 0);
-        // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
-        _PQueue_concurrency.set(this, void 0);
-        _PQueue_isPaused.set(this, void 0);
-        _PQueue_throwOnTimeout.set(this, void 0);
-        /**
-        Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
-    
-        Applies to each future operation.
-        */
-        Object.defineProperty(this, "timeout", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         options = {
             carryoverConcurrencyCount: false,
@@ -650,56 +628,149 @@ class PQueue extends EventEmitter {
             ...options,
         };
         if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {
-            throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ''}\` (${typeof options.intervalCap})`);
+            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 \`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ''}\` (${typeof options.interval})`);
+            throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ''}\` (${typeof options.interval})`);
         }
-        __classPrivateFieldSet(this, _PQueue_carryoverConcurrencyCount, options.carryoverConcurrencyCount, "f");
-        __classPrivateFieldSet(this, _PQueue_isIntervalIgnored, options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0, "f");
-        __classPrivateFieldSet(this, _PQueue_intervalCap, options.intervalCap, "f");
-        __classPrivateFieldSet(this, _PQueue_interval, options.interval, "f");
-        __classPrivateFieldSet(this, _PQueue_queue, new options.queueClass(), "f");
-        __classPrivateFieldSet(this, _PQueue_queueClass, options.queueClass, "f");
+        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;
-        __classPrivateFieldSet(this, _PQueue_throwOnTimeout, options.throwOnTimeout === true, "f");
-        __classPrivateFieldSet(this, _PQueue_isPaused, options.autoStart === false, "f");
+        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 __classPrivateFieldGet(this, _PQueue_concurrency, "f");
+        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})`);
         }
-        __classPrivateFieldSet(this, _PQueue_concurrency, newConcurrency, "f");
-        __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
+        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: __classPrivateFieldGet(this, _PQueue_throwOnTimeout, "f"),
+            throwOnTimeout: this.#throwOnTimeout,
             ...options,
         };
         return new Promise((resolve, reject) => {
-            __classPrivateFieldGet(this, _PQueue_queue, "f").enqueue(async () => {
-                var _a;
-                var _b, _c;
-                __classPrivateFieldSet(this, _PQueue_pending, (_b = __classPrivateFieldGet(this, _PQueue_pending, "f"), _b++, _b), "f");
-                __classPrivateFieldSet(this, _PQueue_intervalCount, (_c = __classPrivateFieldGet(this, _PQueue_intervalCount, "f"), _c++, _c), "f");
+            this.#queue.enqueue(async () => {
+                this.#pending++;
+                this.#intervalCount++;
                 try {
-                    // TODO: Use options.signal?.throwIfAborted() when targeting Node.js 18
-                    if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
-                        // TODO: Use ABORT_ERR code when targeting Node.js 16 (https://nodejs.org/docs/latest-v16.x/api/errors.html#abort_err)
-                        throw new AbortError('The task was aborted.');
-                    }
+                    options.signal?.throwIfAborted();
                     let operation = function_({ signal: options.signal });
                     if (options.timeout) {
-                        operation = pTimeout(Promise.resolve(operation), options.timeout);
+                        operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
                     }
                     if (options.signal) {
-                        operation = Promise.race([operation, __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_throwOnAbort).call(this, options.signal)]);
+                        operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
                     }
                     const result = await operation;
                     resolve(result);
@@ -714,11 +785,11 @@ class PQueue extends EventEmitter {
                     this.emit('error', error);
                 }
                 finally {
-                    __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_next).call(this);
+                    this.#next();
                 }
             }, options);
             this.emit('add');
-            __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this);
+            this.#tryToStartAnother();
         });
     }
     async addAll(functions, options) {
@@ -728,24 +799,24 @@ class PQueue extends EventEmitter {
     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 (!__classPrivateFieldGet(this, _PQueue_isPaused, "f")) {
+        if (!this.#isPaused) {
             return this;
         }
-        __classPrivateFieldSet(this, _PQueue_isPaused, false, "f");
-        __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
+        this.#isPaused = false;
+        this.#processQueue();
         return this;
     }
     /**
     Put queue execution on hold.
     */
     pause() {
-        __classPrivateFieldSet(this, _PQueue_isPaused, true, "f");
+        this.#isPaused = true;
     }
     /**
     Clear the queue.
     */
     clear() {
-        __classPrivateFieldSet(this, _PQueue_queue, new (__classPrivateFieldGet(this, _PQueue_queueClass, "f"))(), "f");
+        this.#queue = new this.#queueClass();
     }
     /**
     Can be called multiple times. Useful if you for example add additional items at a later time.
@@ -754,10 +825,10 @@ class PQueue extends EventEmitter {
     */
     async onEmpty() {
         // Instantly resolve if the queue is empty
-        if (__classPrivateFieldGet(this, _PQueue_queue, "f").size === 0) {
+        if (this.#queue.size === 0) {
             return;
         }
-        await __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, 'empty');
+        await this.#onEvent('empty');
     }
     /**
     @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
@@ -768,10 +839,10 @@ class PQueue extends EventEmitter {
     */
     async onSizeLessThan(limit) {
         // Instantly resolve if the queue is empty.
-        if (__classPrivateFieldGet(this, _PQueue_queue, "f").size < limit) {
+        if (this.#queue.size < limit) {
             return;
         }
-        await __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, 'next', () => __classPrivateFieldGet(this, _PQueue_queue, "f").size < limit);
+        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.
@@ -780,16 +851,28 @@ class PQueue extends EventEmitter {
     */
     async onIdle() {
         // Instantly resolve if none pending and if nothing else is queued
-        if (__classPrivateFieldGet(this, _PQueue_pending, "f") === 0 && __classPrivateFieldGet(this, _PQueue_queue, "f").size === 0) {
+        if (this.#pending === 0 && this.#queue.size === 0) {
             return;
         }
-        await __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, 'idle');
+        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 __classPrivateFieldGet(this, _PQueue_queue, "f").size;
+        return this.#queue.size;
     }
     /**
     Size of the queue, filtered by the given options.
@@ -798,122 +881,21 @@ class PQueue extends EventEmitter {
     */
     sizeBy(options) {
         // eslint-disable-next-line unicorn/no-array-callback-reference
-        return __classPrivateFieldGet(this, _PQueue_queue, "f").filter(options).length;
+        return this.#queue.filter(options).length;
     }
     /**
     Number of running items (no longer in the queue).
     */
     get pending() {
-        return __classPrivateFieldGet(this, _PQueue_pending, "f");
+        return this.#pending;
     }
     /**
     Whether the queue is currently paused.
     */
     get isPaused() {
-        return __classPrivateFieldGet(this, _PQueue_isPaused, "f");
+        return this.#isPaused;
     }
 }
-_PQueue_carryoverConcurrencyCount = new WeakMap(), _PQueue_isIntervalIgnored = new WeakMap(), _PQueue_intervalCount = new WeakMap(), _PQueue_intervalCap = new WeakMap(), _PQueue_interval = new WeakMap(), _PQueue_intervalEnd = new WeakMap(), _PQueue_intervalId = new WeakMap(), _PQueue_timeoutId = new WeakMap(), _PQueue_queue = new WeakMap(), _PQueue_queueClass = new WeakMap(), _PQueue_pending = new WeakMap(), _PQueue_concurrency = new WeakMap(), _PQueue_isPaused = new WeakMap(), _PQueue_throwOnTimeout = new WeakMap(), _PQueue_instances = new WeakSet(), _PQueue_doesIntervalAllowAnother_get = function _PQueue_doesIntervalAllowAnother_get() {
-    return __classPrivateFieldGet(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet(this, _PQueue_intervalCount, "f") < __classPrivateFieldGet(this, _PQueue_intervalCap, "f");
-}, _PQueue_doesConcurrentAllowAnother_get = function _PQueue_doesConcurrentAllowAnother_get() {
-    return __classPrivateFieldGet(this, _PQueue_pending, "f") < __classPrivateFieldGet(this, _PQueue_concurrency, "f");
-}, _PQueue_next = function _PQueue_next() {
-    var _a;
-    __classPrivateFieldSet(this, _PQueue_pending, (_a = __classPrivateFieldGet(this, _PQueue_pending, "f"), _a--, _a), "f");
-    __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this);
-    this.emit('next');
-}, _PQueue_onResumeInterval = function _PQueue_onResumeInterval() {
-    __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
-    __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
-    __classPrivateFieldSet(this, _PQueue_timeoutId, undefined, "f");
-}, _PQueue_isIntervalPaused_get = function _PQueue_isIntervalPaused_get() {
-    const now = Date.now();
-    if (__classPrivateFieldGet(this, _PQueue_intervalId, "f") === undefined) {
-        const delay = __classPrivateFieldGet(this, _PQueue_intervalEnd, "f") - 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
-            __classPrivateFieldSet(this, _PQueue_intervalCount, (__classPrivateFieldGet(this, _PQueue_carryoverConcurrencyCount, "f")) ? __classPrivateFieldGet(this, _PQueue_pending, "f") : 0, "f");
-        }
-        else {
-            // Act as the interval is pending
-            if (__classPrivateFieldGet(this, _PQueue_timeoutId, "f") === undefined) {
-                __classPrivateFieldSet(this, _PQueue_timeoutId, setTimeout(() => {
-                    __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onResumeInterval).call(this);
-                }, delay), "f");
-            }
-            return true;
-        }
-    }
-    return false;
-}, _PQueue_tryToStartAnother = function _PQueue_tryToStartAnother() {
-    if (__classPrivateFieldGet(this, _PQueue_queue, "f").size === 0) {
-        // We can clear the interval ("pause")
-        // Because we can redo it later ("resume")
-        if (__classPrivateFieldGet(this, _PQueue_intervalId, "f")) {
-            clearInterval(__classPrivateFieldGet(this, _PQueue_intervalId, "f"));
-        }
-        __classPrivateFieldSet(this, _PQueue_intervalId, undefined, "f");
-        this.emit('empty');
-        if (__classPrivateFieldGet(this, _PQueue_pending, "f") === 0) {
-            this.emit('idle');
-        }
-        return false;
-    }
-    if (!__classPrivateFieldGet(this, _PQueue_isPaused, "f")) {
-        const canInitializeInterval = !__classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_isIntervalPaused_get);
-        if (__classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_doesIntervalAllowAnother_get) && __classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_doesConcurrentAllowAnother_get)) {
-            const job = __classPrivateFieldGet(this, _PQueue_queue, "f").dequeue();
-            if (!job) {
-                return false;
-            }
-            this.emit('active');
-            job();
-            if (canInitializeInterval) {
-                __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
-            }
-            return true;
-        }
-    }
-    return false;
-}, _PQueue_initializeIntervalIfNeeded = function _PQueue_initializeIntervalIfNeeded() {
-    if (__classPrivateFieldGet(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet(this, _PQueue_intervalId, "f") !== undefined) {
-        return;
-    }
-    __classPrivateFieldSet(this, _PQueue_intervalId, setInterval(() => {
-        __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
-    }, __classPrivateFieldGet(this, _PQueue_interval, "f")), "f");
-    __classPrivateFieldSet(this, _PQueue_intervalEnd, Date.now() + __classPrivateFieldGet(this, _PQueue_interval, "f"), "f");
-}, _PQueue_onInterval = function _PQueue_onInterval() {
-    if (__classPrivateFieldGet(this, _PQueue_intervalCount, "f") === 0 && __classPrivateFieldGet(this, _PQueue_pending, "f") === 0 && __classPrivateFieldGet(this, _PQueue_intervalId, "f")) {
-        clearInterval(__classPrivateFieldGet(this, _PQueue_intervalId, "f"));
-        __classPrivateFieldSet(this, _PQueue_intervalId, undefined, "f");
-    }
-    __classPrivateFieldSet(this, _PQueue_intervalCount, __classPrivateFieldGet(this, _PQueue_carryoverConcurrencyCount, "f") ? __classPrivateFieldGet(this, _PQueue_pending, "f") : 0, "f");
-    __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
-}, _PQueue_processQueue = function _PQueue_processQueue() {
-    // eslint-disable-next-line no-empty
-    while (__classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this)) { }
-}, _PQueue_throwOnAbort = async function _PQueue_throwOnAbort(signal) {
-    return new Promise((_resolve, reject) => {
-        signal.addEventListener('abort', () => {
-            // TODO: Reject with signal.throwIfAborted() when targeting Node.js 18
-            // TODO: Use ABORT_ERR code when targeting Node.js 16 (https://nodejs.org/docs/latest-v16.x/api/errors.html#abort_err)
-            reject(new AbortError('The task was aborted.'));
-        }, { once: true });
-    });
-}, _PQueue_onEvent = async function _PQueue_onEvent(event, filter) {
-    return new Promise(resolve => {
-        const listener = () => {
-            if (filter && !filter()) {
-                return;
-            }
-            this.off(event, listener);
-            resolve();
-        };
-        this.on(event, listener);
-    });
-};
 
 function buildLog(text, count) {
   console.log(`
@@ -1263,6 +1245,12 @@ async function build(ssgOptions = {}, viteConfig = {}) {
       rollupOptions: {
         input: {
           app: node_path.join(root, "./index.html")
+        },
+        // @ts-expect-error rollup type
+        onLog(level, log, handler) {
+          if (log.message.includes("react-helmet-async"))
+            return;
+          handler(level, log);
         }
       }
     },
@@ -1310,8 +1298,9 @@ async function build(ssgOptions = {}, viteConfig = {}) {
   const critters = crittersOptions !== false ? await getCritters(outDir, crittersOptions) : void 0;
   if (critters)
     console.log(`${kolorist.gray("[vite-react-ssg]")} ${kolorist.blue("Critical CSS generation enabled via `critters`")}`);
-  const ssrManifest = JSON.parse(await fs__default.readFile(node_path.join(out, "ssr-manifest.json"), "utf-8"));
-  const manifest = JSON.parse(await fs__default.readFile(node_path.join(out, "manifest.json"), "utf-8"));
+  const dotVitedir = Number.parseInt(vite.version) >= 5 ? [".vite"] : [];
+  const ssrManifest = JSON.parse(await fs__default.readFile(node_path.join(out, ...dotVitedir, "ssr-manifest.json"), "utf-8"));
+  const manifest = JSON.parse(await fs__default.readFile(node_path.join(out, ...dotVitedir, "manifest.json"), "utf-8"));
   let indexHTML = await fs__default.readFile(node_path.join(out, "index.html"), "utf-8");
   indexHTML = rewriteScripts(indexHTML, script);
   const queue = new PQueue({ concurrency });