nitro 3.0.0 → 3.0.1-alpha.1

package/dist/_libs/plugin-replace.mjs

@@ -0,0 +1,104 @@
+import { t as MagicString } from "./magic-string.mjs";
+import { r as createFilter } from "./plugin-commonjs.mjs";
+
+//#region node_modules/.pnpm/@rollup+plugin-replace@6.0.3_rollup@4.53.2/node_modules/@rollup/plugin-replace/dist/es/index.js
+function escape(str) {
+	return str.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&");
+}
+function ensureFunction(functionOrValue) {
+	if (typeof functionOrValue === "function") return functionOrValue;
+	return function() {
+		return functionOrValue;
+	};
+}
+function longest(a, b) {
+	return b.length - a.length;
+}
+function getReplacements(options) {
+	if (options.values) return Object.assign({}, options.values);
+	var values = Object.assign({}, options);
+	delete values.delimiters;
+	delete values.include;
+	delete values.exclude;
+	delete values.sourcemap;
+	delete values.sourceMap;
+	delete values.objectGuards;
+	delete values.preventAssignment;
+	return values;
+}
+function mapToFunctions(object) {
+	return Object.keys(object).reduce(function(fns, key) {
+		var functions = Object.assign({}, fns);
+		functions[key] = ensureFunction(object[key]);
+		return functions;
+	}, {});
+}
+var objKeyRegEx = /^([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)(\.([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*))+$/;
+function expandTypeofReplacements(replacements) {
+	Object.keys(replacements).forEach(function(key) {
+		var objMatch = key.match(objKeyRegEx);
+		if (!objMatch) return;
+		var dotIndex = objMatch[1].length;
+		do {
+			replacements["typeof " + key.slice(0, dotIndex)] = "\"object\"";
+			dotIndex = key.indexOf(".", dotIndex + 1);
+		} while (dotIndex !== -1);
+	});
+}
+function replace(options) {
+	if (options === void 0) options = {};
+	var filter = createFilter(options.include, options.exclude);
+	var delimiters = options.delimiters;
+	if (delimiters === void 0) delimiters = ["(?<![_$a-zA-Z0-9\\xA0-\\uFFFF])", "(?![_$a-zA-Z0-9\\xA0-\\uFFFF])(?!\\.)"];
+	var preventAssignment = options.preventAssignment;
+	var objectGuards = options.objectGuards;
+	var replacements = getReplacements(options);
+	if (objectGuards) expandTypeofReplacements(replacements);
+	var functionValues = mapToFunctions(replacements);
+	var keys = Object.keys(functionValues).sort(longest).map(escape);
+	var lookbehind = preventAssignment ? "(?<!\\b(?:const|let|var)\\s*)" : "";
+	var lookahead = preventAssignment ? "(?!\\s*=[^=])" : "";
+	var pattern = new RegExp("" + lookbehind + delimiters[0] + "(" + keys.join("|") + ")" + delimiters[1] + lookahead, "g");
+	return {
+		name: "replace",
+		buildStart: function buildStart() {
+			if (![true, false].includes(preventAssignment)) this.warn({ message: "@rollup/plugin-replace: 'preventAssignment' currently defaults to false. It is recommended to set this option to `true`, as the next major version will default this option to `true`." });
+		},
+		renderChunk: function renderChunk(code, chunk) {
+			var id = chunk.fileName;
+			if (!keys.length) return null;
+			if (!filter(id)) return null;
+			return executeReplacement(code, id);
+		},
+		transform: function transform(code, id) {
+			if (!keys.length) return null;
+			if (!filter(id)) return null;
+			return executeReplacement(code, id);
+		}
+	};
+	function executeReplacement(code, id) {
+		var magicString = new MagicString(code);
+		if (!codeHasReplacements(code, id, magicString)) return null;
+		var result = { code: magicString.toString() };
+		if (isSourceMapEnabled()) result.map = magicString.generateMap({ hires: true });
+		return result;
+	}
+	function codeHasReplacements(code, id, magicString) {
+		var result = false;
+		var match;
+		while (match = pattern.exec(code)) {
+			result = true;
+			var start = match.index;
+			var end = start + match[0].length;
+			var replacement = String(functionValues[match[1]](id));
+			magicString.overwrite(start, end, replacement);
+		}
+		return result;
+	}
+	function isSourceMapEnabled() {
+		return options.sourceMap !== false && options.sourcemap !== false;
+	}
+}
+
+//#endregion
+export { replace as t };

package/dist/_libs/pretty-bytes.mjs

@@ -0,0 +1,116 @@
+//#region node_modules/.pnpm/pretty-bytes@7.1.0/node_modules/pretty-bytes/index.js
+const BYTE_UNITS = [
+	"B",
+	"kB",
+	"MB",
+	"GB",
+	"TB",
+	"PB",
+	"EB",
+	"ZB",
+	"YB"
+];
+const BIBYTE_UNITS = [
+	"B",
+	"KiB",
+	"MiB",
+	"GiB",
+	"TiB",
+	"PiB",
+	"EiB",
+	"ZiB",
+	"YiB"
+];
+const BIT_UNITS = [
+	"b",
+	"kbit",
+	"Mbit",
+	"Gbit",
+	"Tbit",
+	"Pbit",
+	"Ebit",
+	"Zbit",
+	"Ybit"
+];
+const BIBIT_UNITS = [
+	"b",
+	"kibit",
+	"Mibit",
+	"Gibit",
+	"Tibit",
+	"Pibit",
+	"Eibit",
+	"Zibit",
+	"Yibit"
+];
+const toLocaleString = (number, locale, options) => {
+	let result = number;
+	if (typeof locale === "string" || Array.isArray(locale)) result = number.toLocaleString(locale, options);
+	else if (locale === true || options !== void 0) result = number.toLocaleString(void 0, options);
+	return result;
+};
+const log10 = (numberOrBigInt) => {
+	if (typeof numberOrBigInt === "number") return Math.log10(numberOrBigInt);
+	const string = numberOrBigInt.toString(10);
+	return string.length + Math.log10(`0.${string.slice(0, 15)}`);
+};
+const log = (numberOrBigInt) => {
+	if (typeof numberOrBigInt === "number") return Math.log(numberOrBigInt);
+	return log10(numberOrBigInt) * Math.log(10);
+};
+const divide = (numberOrBigInt, divisor) => {
+	if (typeof numberOrBigInt === "number") return numberOrBigInt / divisor;
+	const integerPart = numberOrBigInt / BigInt(divisor);
+	const remainder = numberOrBigInt % BigInt(divisor);
+	return Number(integerPart) + Number(remainder) / divisor;
+};
+const applyFixedWidth = (result, fixedWidth) => {
+	if (fixedWidth === void 0) return result;
+	if (typeof fixedWidth !== "number" || !Number.isSafeInteger(fixedWidth) || fixedWidth < 0) throw new TypeError(`Expected fixedWidth to be a non-negative integer, got ${typeof fixedWidth}: ${fixedWidth}`);
+	if (fixedWidth === 0) return result;
+	return result.length < fixedWidth ? result.padStart(fixedWidth, " ") : result;
+};
+const buildLocaleOptions = (options) => {
+	const { minimumFractionDigits, maximumFractionDigits } = options;
+	if (minimumFractionDigits === void 0 && maximumFractionDigits === void 0) return;
+	return {
+		...minimumFractionDigits !== void 0 && { minimumFractionDigits },
+		...maximumFractionDigits !== void 0 && { maximumFractionDigits },
+		roundingMode: "trunc"
+	};
+};
+function prettyBytes(number, options) {
+	if (typeof number !== "bigint" && !Number.isFinite(number)) throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
+	options = {
+		bits: false,
+		binary: false,
+		space: true,
+		nonBreakingSpace: false,
+		...options
+	};
+	const UNITS = options.bits ? options.binary ? BIBIT_UNITS : BIT_UNITS : options.binary ? BIBYTE_UNITS : BYTE_UNITS;
+	const separator = options.space ? options.nonBreakingSpace ? "\xA0" : " " : "";
+	const isZero = typeof number === "number" ? number === 0 : number === 0n;
+	if (options.signed && isZero) return applyFixedWidth(` 0${separator}${UNITS[0]}`, options.fixedWidth);
+	const isNegative = number < 0;
+	const prefix = isNegative ? "-" : options.signed ? "+" : "";
+	if (isNegative) number = -number;
+	const localeOptions = buildLocaleOptions(options);
+	let result;
+	if (number < 1) result = prefix + toLocaleString(number, options.locale, localeOptions) + separator + UNITS[0];
+	else {
+		const exponent = Math.min(Math.floor(options.binary ? log(number) / Math.log(1024) : log10(number) / 3), UNITS.length - 1);
+		number = divide(number, (options.binary ? 1024 : 1e3) ** exponent);
+		if (!localeOptions) {
+			const minPrecision = Math.max(3, Math.floor(number).toString().length);
+			number = number.toPrecision(minPrecision);
+		}
+		const numberString = toLocaleString(Number(number), options.locale, localeOptions);
+		const unit = UNITS[exponent];
+		result = prefix + numberString + separator + unit;
+	}
+	return applyFixedWidth(result, options.fixedWidth);
+}
+
+//#endregion
+export { prettyBytes as t };

package/dist/_libs/remapping.mjs

@@ -0,0 +1,117 @@
+import { a as toDecodedMap, c as decodedMappings, i as setSourceContent, l as traceSegment, n as maybeAddSegment, o as toEncodedMap, r as setIgnore, s as TraceMap, t as GenMapping } from "./gen-mapping.mjs";
+
+//#region node_modules/.pnpm/@jridgewell+remapping@2.3.5/node_modules/@jridgewell/remapping/dist/remapping.mjs
+var SOURCELESS_MAPPING = /* @__PURE__ */ SegmentObject("", -1, -1, "", null, false);
+var EMPTY_SOURCES = [];
+function SegmentObject(source, line, column, name, content, ignore) {
+	return {
+		source,
+		line,
+		column,
+		name,
+		content,
+		ignore
+	};
+}
+function Source(map, sources, source, content, ignore) {
+	return {
+		map,
+		sources,
+		source,
+		content,
+		ignore
+	};
+}
+function MapSource(map, sources) {
+	return Source(map, sources, "", null, false);
+}
+function OriginalSource(source, content, ignore) {
+	return Source(null, EMPTY_SOURCES, source, content, ignore);
+}
+function traceMappings(tree) {
+	const gen = new GenMapping({ file: tree.map.file });
+	const { sources: rootSources, map } = tree;
+	const rootNames = map.names;
+	const rootMappings = decodedMappings(map);
+	for (let i = 0; i < rootMappings.length; i++) {
+		const segments = rootMappings[i];
+		for (let j = 0; j < segments.length; j++) {
+			const segment = segments[j];
+			const genCol = segment[0];
+			let traced = SOURCELESS_MAPPING;
+			if (segment.length !== 1) {
+				const source2 = rootSources[segment[1]];
+				traced = originalPositionFor(source2, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : "");
+				if (traced == null) continue;
+			}
+			const { column, line, name, content, source, ignore } = traced;
+			maybeAddSegment(gen, i, genCol, source, line, column, name);
+			if (source && content != null) setSourceContent(gen, source, content);
+			if (ignore) setIgnore(gen, source, true);
+		}
+	}
+	return gen;
+}
+function originalPositionFor(source, line, column, name) {
+	if (!source.map) return SegmentObject(source.source, line, column, name, source.content, source.ignore);
+	const segment = traceSegment(source.map, line, column);
+	if (segment == null) return null;
+	if (segment.length === 1) return SOURCELESS_MAPPING;
+	return originalPositionFor(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name);
+}
+function asArray(value) {
+	if (Array.isArray(value)) return value;
+	return [value];
+}
+function buildSourceMapTree(input, loader) {
+	const maps = asArray(input).map((m) => new TraceMap(m, ""));
+	const map = maps.pop();
+	for (let i = 0; i < maps.length; i++) if (maps[i].sources.length > 1) throw new Error(`Transformation map ${i} must have exactly one source file.
+Did you specify these with the most recent transformation maps first?`);
+	let tree = build(map, loader, "", 0);
+	for (let i = maps.length - 1; i >= 0; i--) tree = MapSource(maps[i], [tree]);
+	return tree;
+}
+function build(map, loader, importer, importerDepth) {
+	const { resolvedSources, sourcesContent, ignoreList } = map;
+	const depth = importerDepth + 1;
+	return MapSource(map, resolvedSources.map((sourceFile, i) => {
+		const ctx = {
+			importer,
+			depth,
+			source: sourceFile || "",
+			content: void 0,
+			ignore: void 0
+		};
+		const sourceMap = loader(ctx.source, ctx);
+		const { source, content, ignore } = ctx;
+		if (sourceMap) return build(new TraceMap(sourceMap, source), loader, source, depth);
+		return OriginalSource(source, content !== void 0 ? content : sourcesContent ? sourcesContent[i] : null, ignore !== void 0 ? ignore : ignoreList ? ignoreList.includes(i) : false);
+	}));
+}
+var SourceMap = class {
+	constructor(map, options) {
+		const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map);
+		this.version = out.version;
+		this.file = out.file;
+		this.mappings = out.mappings;
+		this.names = out.names;
+		this.ignoreList = out.ignoreList;
+		this.sourceRoot = out.sourceRoot;
+		this.sources = out.sources;
+		if (!options.excludeContent) this.sourcesContent = out.sourcesContent;
+	}
+	toString() {
+		return JSON.stringify(this);
+	}
+};
+function remapping(input, loader, options) {
+	const opts = typeof options === "object" ? options : {
+		excludeContent: !!options,
+		decodedMappings: false
+	};
+	return new SourceMap(traceMappings(buildSourceMapTree(input, loader)), opts);
+}
+
+//#endregion
+export { remapping as t };

package/dist/_libs/rou3.mjs

@@ -0,0 +1,319 @@
+//#region node_modules/.pnpm/rou3@0.7.10/node_modules/rou3/dist/index.mjs
+const NullProtoObj = /* @__PURE__ */ (() => {
+	const e = function() {};
+	return e.prototype = Object.create(null), Object.freeze(e.prototype), e;
+})();
+/**
+* Create a new router context.
+*/
+function createRouter() {
+	return {
+		root: { key: "" },
+		static: new NullProtoObj()
+	};
+}
+function splitPath(path) {
+	const [_, ...s] = path.split("/");
+	return s[s.length - 1] === "" ? s.slice(0, -1) : s;
+}
+function getMatchParams(segments, paramsMap) {
+	const params = new NullProtoObj();
+	for (const [index, name] of paramsMap) {
+		const segment = index < 0 ? segments.slice(-1 * index).join("/") : segments[index];
+		if (typeof name === "string") params[name] = segment;
+		else {
+			const match = segment.match(name);
+			if (match) for (const key in match.groups) params[key] = match.groups[key];
+		}
+	}
+	return params;
+}
+/**
+* Add a route to the router context.
+*/
+function addRoute(ctx, method = "", path, data) {
+	method = method.toUpperCase();
+	if (path.charCodeAt(0) !== 47) path = `/${path}`;
+	const segments = splitPath(path);
+	let node = ctx.root;
+	let _unnamedParamIndex = 0;
+	const paramsMap = [];
+	const paramsRegexp = [];
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		if (segment.startsWith("**")) {
+			if (!node.wildcard) node.wildcard = { key: "**" };
+			node = node.wildcard;
+			paramsMap.push([
+				-i,
+				segment.split(":")[1] || "_",
+				segment.length === 2
+			]);
+			break;
+		}
+		if (segment === "*" || segment.includes(":")) {
+			if (!node.param) node.param = { key: "*" };
+			node = node.param;
+			if (segment === "*") paramsMap.push([
+				i,
+				`_${_unnamedParamIndex++}`,
+				true
+			]);
+			else if (segment.includes(":", 1)) {
+				const regexp = getParamRegexp(segment);
+				paramsRegexp[i] = regexp;
+				node.hasRegexParam = true;
+				paramsMap.push([
+					i,
+					regexp,
+					false
+				]);
+			} else paramsMap.push([
+				i,
+				segment.slice(1),
+				false
+			]);
+			continue;
+		}
+		const child = node.static?.[segment];
+		if (child) node = child;
+		else {
+			const staticNode = { key: segment };
+			if (!node.static) node.static = new NullProtoObj();
+			node.static[segment] = staticNode;
+			node = staticNode;
+		}
+	}
+	const hasParams = paramsMap.length > 0;
+	if (!node.methods) node.methods = new NullProtoObj();
+	node.methods[method] ??= [];
+	node.methods[method].push({
+		data: data || null,
+		paramsRegexp,
+		paramsMap: hasParams ? paramsMap : void 0
+	});
+	if (!hasParams) ctx.static[path] = node;
+}
+function getParamRegexp(segment) {
+	const regex = segment.replace(/:(\w+)/g, (_, id) => `(?<${id}>[^/]+)`).replace(/\./g, "\\.");
+	return /* @__PURE__ */ new RegExp(`^${regex}$`);
+}
+/**
+* Find a route by path.
+*/
+function findRoute(ctx, method = "", path, opts) {
+	if (path.charCodeAt(path.length - 1) === 47) path = path.slice(0, -1);
+	const staticNode = ctx.static[path];
+	if (staticNode && staticNode.methods) {
+		const staticMatch = staticNode.methods[method] || staticNode.methods[""];
+		if (staticMatch !== void 0) return staticMatch[0];
+	}
+	const segments = splitPath(path);
+	const match = _lookupTree(ctx, ctx.root, method, segments, 0)?.[0];
+	if (match === void 0) return;
+	if (opts?.params === false) return match;
+	return {
+		data: match.data,
+		params: match.paramsMap ? getMatchParams(segments, match.paramsMap) : void 0
+	};
+}
+function _lookupTree(ctx, node, method, segments, index) {
+	if (index === segments.length) {
+		if (node.methods) {
+			const match = node.methods[method] || node.methods[""];
+			if (match) return match;
+		}
+		if (node.param && node.param.methods) {
+			const match = node.param.methods[method] || node.param.methods[""];
+			if (match) {
+				const pMap = match[0].paramsMap;
+				if (pMap?.[pMap?.length - 1]?.[2]) return match;
+			}
+		}
+		if (node.wildcard && node.wildcard.methods) {
+			const match = node.wildcard.methods[method] || node.wildcard.methods[""];
+			if (match) {
+				const pMap = match[0].paramsMap;
+				if (pMap?.[pMap?.length - 1]?.[2]) return match;
+			}
+		}
+		return;
+	}
+	const segment = segments[index];
+	if (node.static) {
+		const staticChild = node.static[segment];
+		if (staticChild) {
+			const match = _lookupTree(ctx, staticChild, method, segments, index + 1);
+			if (match) return match;
+		}
+	}
+	if (node.param) {
+		const match = _lookupTree(ctx, node.param, method, segments, index + 1);
+		if (match) {
+			if (node.param.hasRegexParam) {
+				const exactMatch = match.find((m) => m.paramsRegexp[index]?.test(segment)) || match.find((m) => !m.paramsRegexp[index]);
+				return exactMatch ? [exactMatch] : void 0;
+			}
+			return match;
+		}
+	}
+	if (node.wildcard && node.wildcard.methods) return node.wildcard.methods[method] || node.wildcard.methods[""];
+}
+/**
+* Find all route patterns that match the given path.
+*/
+function findAllRoutes(ctx, method = "", path, opts) {
+	if (path.charCodeAt(path.length - 1) === 47) path = path.slice(0, -1);
+	const segments = splitPath(path);
+	const matches = _findAll(ctx, ctx.root, method, segments, 0);
+	if (opts?.params === false) return matches;
+	return matches.map((m) => {
+		return {
+			data: m.data,
+			params: m.paramsMap ? getMatchParams(segments, m.paramsMap) : void 0
+		};
+	});
+}
+function _findAll(ctx, node, method, segments, index, matches = []) {
+	const segment = segments[index];
+	if (node.wildcard && node.wildcard.methods) {
+		const match = node.wildcard.methods[method] || node.wildcard.methods[""];
+		if (match) matches.push(...match);
+	}
+	if (node.param) {
+		_findAll(ctx, node.param, method, segments, index + 1, matches);
+		if (index === segments.length && node.param.methods) {
+			const match = node.param.methods[method] || node.param.methods[""];
+			if (match) {
+				const pMap = match[0].paramsMap;
+				if (pMap?.[pMap?.length - 1]?.[2]) matches.push(...match);
+			}
+		}
+	}
+	const staticChild = node.static?.[segment];
+	if (staticChild) _findAll(ctx, staticChild, method, segments, index + 1, matches);
+	if (index === segments.length && node.methods) {
+		const match = node.methods[method] || node.methods[""];
+		if (match) matches.push(...match);
+	}
+	return matches;
+}
+
+//#endregion
+//#region node_modules/.pnpm/rou3@0.7.10/node_modules/rou3/dist/compiler.mjs
+/**
+* Compile the router instance into a compact runnable code.
+*
+* **IMPORTANT:** Route data must be serializable to JSON (i.e., no functions or classes) or implement the `toJSON()` method to render custom code or you can pass custom `serialize` function in options.
+*
+* @example
+* import { createRouter, addRoute } from "rou3";
+* import { compileRouterToString } from "rou3/compiler";
+* const router = createRouter();
+* // [add some routes with serializable data]
+* const compilerCode = compileRouterToString(router, "findRoute");
+* // "const findRoute=(m, p) => {}"
+*/
+function compileRouterToString(router, functionName, opts) {
+	const ctx = {
+		opts: opts || {},
+		router,
+		data: [],
+		compileToString: true
+	};
+	let compiled = `(m,p)=>{${compileRouteMatch(ctx)}}`;
+	if (ctx.data.length > 0) compiled = `/* @__PURE__ */ (() => { ${`const ${ctx.data.map((v, i) => `$${i}=${v}`).join(",")};`}; return ${compiled}})()`;
+	return functionName ? `const ${functionName}=${compiled};` : compiled;
+}
+function compileRouteMatch(ctx) {
+	let code = "";
+	const staticNodes = /* @__PURE__ */ new Set();
+	for (const key in ctx.router.static) {
+		const node = ctx.router.static[key];
+		if (node?.methods) {
+			staticNodes.add(node);
+			code += `if(p===${JSON.stringify(key.replace(/\/$/, "") || "/")}){${compileMethodMatch(ctx, node.methods, [], -1)}}`;
+		}
+	}
+	const match = compileNode(ctx, ctx.router.root, [], 0, staticNodes);
+	if (match) code += `let s=p.split("/"),l=s.length-1;${match}`;
+	if (!code) return ctx.opts?.matchAll ? `return [];` : "";
+	return `${ctx.opts?.matchAll ? `let r=[];` : ""}if(p.charCodeAt(p.length-1)===47)p=p.slice(0,-1)||"/";${code}${ctx.opts?.matchAll ? "return r;" : ""}`;
+}
+function compileMethodMatch(ctx, methods, params, currentIdx) {
+	let code = "";
+	for (const key in methods) {
+		const matchers = methods[key];
+		if (matchers && matchers?.length > 0) {
+			if (key !== "") code += `if(m==="${key}")${matchers.length > 1 ? "{" : ""}`;
+			const _matchers = matchers.map((m) => compileFinalMatch(ctx, m, currentIdx, params)).sort((a, b) => b.weight - a.weight);
+			for (const matcher of _matchers) code += matcher.code;
+			if (key !== "") code += matchers.length > 1 ? "}" : "";
+		}
+	}
+	return code;
+}
+function compileFinalMatch(ctx, data, currentIdx, params) {
+	let ret = `{data:${serializeData(ctx, data.data)}`;
+	const conditions = [];
+	const { paramsMap, paramsRegexp } = data;
+	if (paramsMap && paramsMap.length > 0) {
+		if (!paramsMap[paramsMap.length - 1][2] && currentIdx !== -1) conditions.push(`l>=${currentIdx}`);
+		for (let i = 0; i < paramsRegexp.length; i++) {
+			const regexp = paramsRegexp[i];
+			if (!regexp) continue;
+			conditions.push(`${regexp.toString()}.test(s[${i + 1}])`);
+		}
+		ret += ",params:{";
+		for (let i = 0; i < paramsMap.length; i++) {
+			const map = paramsMap[i];
+			ret += typeof map[1] === "string" ? `${JSON.stringify(map[1])}:${params[i]},` : `...(${map[1].toString()}.exec(${params[i]}))?.groups,`;
+		}
+		ret += "}";
+	}
+	return {
+		code: (conditions.length > 0 ? `if(${conditions.join("&&")})` : "") + (ctx.opts?.matchAll ? `r.unshift(${ret}});` : `return ${ret}};`),
+		weight: conditions.length
+	};
+}
+function compileNode(ctx, node, params, startIdx, staticNodes) {
+	let code = "";
+	if (node.methods && !staticNodes.has(node)) {
+		const match = compileMethodMatch(ctx, node.methods, params, node.key === "*" ? startIdx : -1);
+		if (match) {
+			const hasLastOptionalParam = node.key === "*";
+			code += `if(l===${startIdx}${hasLastOptionalParam ? `||l===${startIdx - 1}` : ""}){${match}}`;
+		}
+	}
+	if (node.static) for (const key in node.static) {
+		const match = compileNode(ctx, node.static[key], params, startIdx + 1, staticNodes);
+		if (match) code += `if(s[${startIdx + 1}]===${JSON.stringify(key)}){${match}}`;
+	}
+	if (node.param) {
+		const match = compileNode(ctx, node.param, [...params, `s[${startIdx + 1}]`], startIdx + 1, staticNodes);
+		if (match) code += match;
+	}
+	if (node.wildcard) {
+		const { wildcard } = node;
+		if (wildcard.static || wildcard.param || wildcard.wildcard) throw new Error("Compiler mode does not support patterns after wildcard");
+		if (wildcard.methods) {
+			const match = compileMethodMatch(ctx, wildcard.methods, [...params, `s.slice(${startIdx + 1}).join('/')`], startIdx);
+			if (match) code += match;
+		}
+	}
+	return code;
+}
+function serializeData(ctx, value) {
+	if (ctx.compileToString) if (ctx.opts?.serialize) value = ctx.opts.serialize(value);
+	else if (typeof value?.toJSON === "function") value = value.toJSON();
+	else value = JSON.stringify(value);
+	let index = ctx.data.indexOf(value);
+	if (index === -1) {
+		ctx.data.push(value);
+		index = ctx.data.length - 1;
+	}
+	return `$${index}`;
+}
+
+//#endregion
+export { findRoute as a, findAllRoutes as i, addRoute as n, createRouter as r, compileRouterToString as t };