vinext 1.0.1 → 1.1.0

package/dist/utils/mdx-scan.d.ts

@@ -5,6 +5,11 @@ export declare const mdxScanCache: Map<string, boolean>;
  * Check if the project has .mdx files in app/ or pages/ directories.
  */
 export declare function hasMdxFiles(root: string, appDir: string | null, pagesDir: string | null): boolean;
+/**
+ * Whether page extensions discover MDX sources, including compound extensions
+ * such as `page.mdx`.
+ */
+export declare function pageExtensionsIncludeMdx(pageExtensions: readonly string[]): boolean;
 /**
  * Load a reader that keeps only the ESM of an MDX module, so the JavaScript
  * export helpers can read it. It takes the ESM nodes from the MDX parser that

package/dist/utils/mdx-scan.js

@@ -33,6 +33,13 @@ function scanDirForMdx(dir) {
 	return false;
 }
 /**
+* Whether page extensions discover MDX sources, including compound extensions
+* such as `page.mdx`.
+*/
+function pageExtensionsIncludeMdx(pageExtensions) {
+	return pageExtensions.some((extension) => extension.toLowerCase().split(".").at(-1) === "mdx");
+}
+/**
 * Load a reader that keeps only the ESM of an MDX module, so the JavaScript
 * export helpers can read it. It takes the ESM nodes from the MDX parser that
 * `@mdx-js/rollup` compiles with, resolved beside the plugin vinext
@@ -57,4 +64,4 @@ async function loadMdxEsmReader(root) {
 	return (source) => processor.parse(source).children.flatMap((node) => node.type === "mdxjsEsm" && typeof node.value === "string" ? [node.value] : []).join("\n\n");
 }
 //#endregion
-export { hasMdxFiles, loadMdxEsmReader, mdxScanCache };
+export { hasMdxFiles, loadMdxEsmReader, mdxScanCache, pageExtensionsIncludeMdx };

package/dist/utils/regex-safety.d.ts

@@ -1,7 +1,17 @@
 //#region src/utils/regex-safety.d.ts
 export type RegexSafetyIssue = "nested repetition" | "ambiguous alternatives under repetition" | "ambiguous sequence expansion" | "overlapping sequential repetition" | "analysis budget exceeded";
+/**
+ * Whether a RegExp source declares a named group, which turns `\k<name>` into
+ * a backreference. Escaped characters and character classes cannot open one.
+ */
+export declare function mayHaveNamedGroups(pattern: string): boolean;
+/**
+ * `namedGroups` must describe the whole compiled RegExp when `pattern` is only
+ * a fragment of it. It defaults to scanning `pattern` itself.
+ */
 export declare function analyzeRegexSafety(pattern: string, options?: {
   ignoreCase?: boolean;
+  namedGroups?: boolean;
 }): RegexSafetyIssue | null;
 export declare function regexAtomsMayOverlap(left: string, right: string, ignoreCase?: boolean): boolean;
 //#endregion

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",
@@ -241,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",