vinext 1.0.0 → 1.1.0

package/dist/utils/regex-safety.js

@@ -88,13 +88,15 @@ function simpleClassSymbol(raw, ignoreCase) {
 var RegexParser = class {
 	pattern;
 	ignoreCase;
+	namedGroups;
 	index = 0;
 	nodes = 0;
 	depth = 0;
 	exceededBudget = false;
-	constructor(pattern, ignoreCase) {
+	constructor(pattern, ignoreCase, namedGroups) {
 		this.pattern = pattern;
 		this.ignoreCase = ignoreCase;
+		this.namedGroups = namedGroups;
 	}
 	parse() {
 		return this.parseAlternation();
@@ -157,7 +159,7 @@ var RegexParser = class {
 			kind: "atom",
 			symbol: {
 				kind: "opaque",
-				key: ".",
+				key: "opaque:.",
 				pattern: ".",
 				ignoreCase: this.ignoreCase
 			},
@@ -240,7 +242,7 @@ var RegexParser = class {
 			kind: "atom",
 			symbol: simpleClassSymbol(raw, this.ignoreCase) ?? {
 				kind: "opaque",
-				key: raw,
+				key: `opaque:${raw}`,
 				pattern: raw,
 				ignoreCase: this.ignoreCase
 			},
@@ -267,6 +269,15 @@ var RegexParser = class {
 			symbol: shorthand,
 			fixedWidth: true
 		});
+		if (escaped === "k" && this.namedGroups && this.pattern[this.index] === "<") {
+			const nameEnd = this.pattern.indexOf(">", this.index);
+			this.index = nameEnd === -1 ? this.pattern.length : nameEnd + 1;
+			return this.node({
+				kind: "atom",
+				symbol: null,
+				fixedWidth: false
+			});
+		}
 		if (/\d/.test(escaped)) return this.node({
 			kind: "atom",
 			symbol: null,
@@ -279,6 +290,15 @@ var RegexParser = class {
 		} else if (escaped === "u" && /^[\da-fA-F]{4}/.test(this.pattern.slice(this.index, this.index + 4))) {
 			literal = String.fromCharCode(Number.parseInt(this.pattern.slice(this.index, this.index + 4), 16));
 			this.index += 4;
+		} else if (escaped === "c") {
+			const letter = this.pattern[this.index];
+			if (letter !== void 0 && /[A-Za-z]/.test(letter)) {
+				literal = String.fromCharCode(letter.charCodeAt(0) % 32);
+				this.index++;
+			} else {
+				literal = "\\";
+				this.index--;
+			}
 		} else if ("nrtvf0".includes(escaped)) literal = {
 			n: "\n",
 			r: "\r",
@@ -298,7 +318,7 @@ var RegexParser = class {
 			kind: "atom",
 			symbol: {
 				kind: "opaque",
-				key: raw,
+				key: `opaque:${raw}`,
 				pattern: raw,
 				ignoreCase: this.ignoreCase
 			},
@@ -444,11 +464,12 @@ function fixedWords(node, budget) {
 			return words;
 		}
 		case "repeat": {
-			if (node.min !== node.max || !Number.isFinite(node.max)) return null;
+			if (!Number.isFinite(node.max) || node.min > node.max) return null;
 			let words = [[]];
 			const childWords = fixedWords(node.child, budget);
 			if (!childWords) return null;
-			for (let count = 0; count < node.min; count++) {
+			const repeated = node.min === 0 ? [[]] : [];
+			for (let count = 1; count <= node.max; count++) {
 				const next = [];
 				for (const prefix of words) for (const suffix of childWords) {
 					if (++budget.words > MAX_WORDS) {
@@ -464,8 +485,9 @@ function fixedWords(node, budget) {
 					next.push(word);
 				}
 				words = next;
+				if (count >= node.min) repeated.push(...words);
 			}
-			return words;
+			return repeated;
 		}
 	}
 }
@@ -508,17 +530,27 @@ function symbolsMayOverlap(left, right) {
 	if (left.kind === "literal" && right.kind === "opaque") return opaqueMatchesLiteral(right, left);
 	return true;
 }
+function wordMayCollide(node, word, index, comparisons, branched) {
+	if (node.terminal) return true;
+	if (index === word.length) return node.edges.size > 0;
+	if (branched && ++comparisons.count > MAX_OPAQUE_COMPARISONS) return true;
+	const symbol = word[index];
+	const exact = node.edges.get(symbol.key);
+	if (exact && wordMayCollide(exact.node, word, index + 1, comparisons, branched)) return true;
+	const candidates = symbol.kind === "literal" ? node.complexEdges : node.edges.values();
+	for (const candidate of candidates) {
+		if (candidate === exact) continue;
+		if (++comparisons.count > MAX_OPAQUE_COMPARISONS) return true;
+		if (symbolsMayOverlap(candidate.symbol, symbol) && wordMayCollide(candidate.node, word, index + 1, comparisons, true)) return true;
+	}
+	return false;
+}
 function insertPrefixFreeWord(root, word, comparisons) {
+	if (wordMayCollide(root, word, 0, comparisons, false)) return false;
 	let node = root;
 	for (const symbol of word) {
-		if (node.terminal) return false;
 		let edge = node.edges.get(symbol.key);
 		if (!edge) {
-			const candidates = symbol.kind === "literal" ? node.complexEdges : node.edges.values();
-			for (const candidate of candidates) {
-				if (++comparisons.count > MAX_OPAQUE_COMPARISONS) return false;
-				if (symbolsMayOverlap(candidate.symbol, symbol)) return false;
-			}
 			edge = {
 				symbol,
 				node: createTrieNode()
@@ -528,7 +560,6 @@ function insertPrefixFreeWord(root, word, comparisons) {
 		}
 		node = edge.node;
 	}
-	if (node.terminal || node.edges.size > 0) return false;
 	node.terminal = true;
 	return true;
 }
@@ -578,6 +609,7 @@ function ambiguousExpansionFactor(node) {
 		case "repeat": {
 			if (node.min !== node.max || !Number.isFinite(node.max)) return 1;
 			const childFactor = ambiguousExpansionFactor(node.child);
+			if (childFactor === 1) return 1;
 			let factor = 1;
 			for (let count = 0; count < node.max; count++) {
 				factor *= childFactor;
@@ -705,16 +737,36 @@ function findSafetyIssue(node) {
 		}
 	}
 }
+/**
+* Whether a RegExp source declares a named group, which turns `\k<name>` into
+* a backreference. Escaped characters and character classes cannot open one.
+*/
+function mayHaveNamedGroups(pattern) {
+	let inClass = false;
+	for (let index = 0; index < pattern.length; index++) {
+		const character = pattern[index];
+		if (character === "\\") index++;
+		else if (inClass) {
+			if (character === "]") inClass = false;
+		} else if (character === "[") inClass = true;
+		else if (character === "(" && pattern.startsWith("?<", index + 1) && pattern[index + 3] !== "=" && pattern[index + 3] !== "!") return true;
+	}
+	return false;
+}
+/**
+* `namedGroups` must describe the whole compiled RegExp when `pattern` is only
+* a fragment of it. It defaults to scanning `pattern` itself.
+*/
 function analyzeRegexSafety(pattern, options = {}) {
 	if (pattern.length > MAX_PATTERN_LENGTH) return "analysis budget exceeded";
-	const parser = new RegexParser(pattern, options.ignoreCase === true);
+	const parser = new RegexParser(pattern, options.ignoreCase === true, options.namedGroups ?? mayHaveNamedGroups(pattern));
 	const node = parser.parse();
 	if (parser.exceededBudget) return "analysis budget exceeded";
 	return findSafetyIssue(node);
 }
 function regexAtomsMayOverlap(left, right, ignoreCase = false) {
-	const leftParser = new RegexParser(left, ignoreCase);
-	const rightParser = new RegexParser(right, ignoreCase);
+	const leftParser = new RegexParser(left, ignoreCase, true);
+	const rightParser = new RegexParser(right, ignoreCase, true);
 	const leftNode = leftParser.parse();
 	const rightNode = rightParser.parse();
 	const leftWords = fixedWords(leftNode, {
@@ -734,4 +786,4 @@ function regexAtomsMayOverlap(left, right, ignoreCase = false) {
 	return symbolsMayOverlap(leftSymbol, rightSymbol);
 }
 //#endregion
-export { analyzeRegexSafety, regexAtomsMayOverlap };
+export { analyzeRegexSafety, mayHaveNamedGroups, regexAtomsMayOverlap };

package/dist/utils/vite-cli-invocation.js

@@ -1,5 +1,6 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { findViteConfigPath } from "./project.js";
+import fs from "node:fs";
 //#region src/utils/vite-cli-invocation.ts
 let buildClaimed = false;
 const valued = new Set("--config -c --mode -m --logLevel -l --filter -f --configLoader --port --outDir --target --assetsDir --assetsInlineLimit".split(" "));
@@ -72,9 +73,15 @@ function findViteRoot(command, args) {
 		shouldPreflight: preflight
 	};
 }
+function isViteEntry(entry) {
+	return entry.endsWith("/vite/bin/vite.js") || entry.endsWith("/vite/node/cli.js") || entry.endsWith("/dist/vite/node/cli.js");
+}
 function commandArguments(argv) {
 	const entry = toSlash(argv[1] ?? "");
-	const vite = entry.endsWith("/vite/bin/vite.js") || entry.endsWith("/vite/node/cli.js") || entry.endsWith("/dist/vite/node/cli.js");
+	let vite = isViteEntry(entry);
+	if (!vite && entry && path.basename(entry) !== "vp") try {
+		vite = isViteEntry(toSlash(fs.realpathSync.native(entry)));
+	} catch {}
 	let args = argv.slice(2);
 	if (!vite) {
 		if (path.basename(entry) !== "vp") return void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",
@@ -90,6 +90,10 @@
       "types": "./dist/server/pages-router-entry.d.ts",
       "import": "./dist/server/pages-router-entry.js"
     },
+    "./internal/client/vinext-next-data": {
+      "types": "./dist/client/vinext-next-data.d.ts",
+      "import": "./dist/client/vinext-next-data.js"
+    },
     "./internal/server/headers": {
       "types": "./dist/server/headers.d.ts",
       "import": "./dist/server/headers.js"
@@ -222,7 +226,7 @@
     "magic-string": "^0.30.21",
     "vite-plugin-commonjs": "^0.10.4",
     "web-vitals": "^4.2.4",
-    "@vinext/types": "^1.0.0"
+    "@vinext/types": "^1.0.1"
   },
   "devDependencies": {
     "@types/node": "^25.9.2",
@@ -237,8 +241,8 @@
     "pathslash": "^0.1.0",
     "react-server-dom-webpack": "^19.2.7",
     "ua-parser-js": "1.0.35",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.3.2",
-    "vite-plus": "0.3.2"
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
+    "vite-plus": "1.1.0"
   },
   "peerDependencies": {
     "@mdx-js/rollup": "^3.0.0",

package/dist/server/metadata-route-cache-policy.d.ts

@@ -1,5 +0,0 @@
-//#region src/server/metadata-route-cache-policy.d.ts
-export declare function isMetadataResponseCacheable(response: {
-  headers: Headers;
-}): boolean;
-//#endregion

package/dist/server/metadata-route-cache-policy.js

@@ -1,6 +0,0 @@
-//#region src/server/metadata-route-cache-policy.ts
-function isMetadataResponseCacheable(response) {
-	return !(response.headers.get("cache-control")?.toLowerCase() ?? "").split(",").map((directive) => directive.trim().split("=", 1)[0]).some((directive) => directive === "no-cache" || directive === "no-store");
-}
-//#endregion
-export { isMetadataResponseCacheable };