@depup/nitro 3.0.260311-beta-depup.0

package/dist/_libs/rou3.mjs

@@ -0,0 +1,496 @@
+//#region node_modules/.pnpm/rou3@0.8.1/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 expandGroupDelimiters(path) {
+	let i = 0;
+	let depth = 0;
+	for (; i < path.length; i++) {
+		const c = path.charCodeAt(i);
+		if (c === 92) {
+			i++;
+			continue;
+		}
+		if (c === 40) {
+			depth++;
+			continue;
+		}
+		if (c === 41 && depth > 0) {
+			depth--;
+			continue;
+		}
+		if (c === 123 && depth === 0) break;
+	}
+	if (i >= path.length) return;
+	let j = i + 1;
+	depth = 0;
+	for (; j < path.length; j++) {
+		const c = path.charCodeAt(j);
+		if (c === 92) {
+			j++;
+			continue;
+		}
+		if (c === 40) {
+			depth++;
+			continue;
+		}
+		if (c === 41 && depth > 0) {
+			depth--;
+			continue;
+		}
+		if (c === 125 && depth === 0) break;
+	}
+	if (j >= path.length) return;
+	const mod = path[j + 1];
+	const hasMod = mod === "?" || mod === "+" || mod === "*";
+	const pre = path.slice(0, i);
+	const body = path.slice(i + 1, j);
+	const suf = path.slice(j + (hasMod ? 2 : 1));
+	if (!hasMod) return [pre + body + suf];
+	if (mod === "?") return [pre + body + suf, pre + suf];
+	if (body.includes("/")) throw new Error("unsupported group repetition across segments");
+	return [`${pre}(?:${body})${mod}${suf}`];
+}
+const UNNAMED_GROUP_PREFIX$1 = "__rou3_unnamed_";
+const _unnamedGroupPrefixLength = 15;
+function hasSegmentWildcard(segment) {
+	let depth = 0;
+	for (let i = 0; i < segment.length; i++) {
+		const ch = segment.charCodeAt(i);
+		if (ch === 92) {
+			i++;
+			continue;
+		}
+		if (ch === 40) {
+			depth++;
+			continue;
+		}
+		if (ch === 41 && depth > 0) {
+			depth--;
+			continue;
+		}
+		if (ch === 42 && depth === 0) return true;
+	}
+	return false;
+}
+function replaceSegmentWildcards(segment, unnamedStart, toGroupKey = toUnnamedGroupKey) {
+	let depth = 0;
+	let nextIndex = unnamedStart;
+	let replaced = "";
+	for (let i = 0; i < segment.length; i++) {
+		const ch = segment.charCodeAt(i);
+		if (ch === 92) {
+			replaced += segment[i];
+			if (i + 1 < segment.length) replaced += segment[++i];
+			continue;
+		}
+		if (ch === 40) {
+			depth++;
+			replaced += segment[i];
+			continue;
+		}
+		if (ch === 41 && depth > 0) {
+			depth--;
+			replaced += segment[i];
+			continue;
+		}
+		if (ch === 42 && depth === 0) {
+			replaced += `(?<${toGroupKey(nextIndex++)}>[^/]*)`;
+			continue;
+		}
+		replaced += segment[i];
+	}
+	return [replaced, nextIndex];
+}
+function toUnnamedGroupKey(index) {
+	return `${UNNAMED_GROUP_PREFIX$1}${index}`;
+}
+function normalizeUnnamedGroupKey(key) {
+	return key.startsWith("__rou3_unnamed_") ? key.slice(_unnamedGroupPrefixLength) : key;
+}
+function encodeEscapes(path) {
+	return path.replace(/\\:/g, "�A").replace(/\\\(/g, "�B").replace(/\\\)/g, "�C").replace(/\\\{/g, "�D").replace(/\\\}/g, "�E");
+}
+function decodeEscaped(segment) {
+	return segment.replace(/\uFFFD([A-E])/g, (_, c) => c === "A" ? ":" : c === "B" ? "(" : c === "C" ? ")" : c === "D" ? "{" : "}");
+}
+function expandModifiers(segments) {
+	for (let i = 0; i < segments.length; i++) {
+		const m = segments[i].match(/^(.*:[\w-]+(?:\([^)]*\))?)([?+*])$/);
+		if (!m) continue;
+		const pre = segments.slice(0, i);
+		const suf = segments.slice(i + 1);
+		if (m[2] === "?") return ["/" + pre.concat(m[1]).concat(suf).join("/"), "/" + pre.concat(suf).join("/")];
+		const name = m[1].match(/:([\w-]+)/)?.[1] || "_";
+		const wc = "/" + [
+			...pre,
+			`**:${name}`,
+			...suf
+		].join("/");
+		const without = "/" + [...pre, ...suf].join("/");
+		return m[2] === "+" ? [wc] : [wc, without];
+	}
+}
+function normalizePath(path) {
+	if (!path.includes("/.")) return path;
+	const r = [];
+	for (const s of path.split("/")) if (s === ".") continue;
+	else if (s === ".." && r.length > 1) r.pop();
+	else r.push(s);
+	return r.join("/") || "/";
+}
+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(-(index + 1)).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[normalizeUnnamedGroupKey(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 groupExpanded = expandGroupDelimiters(path);
+	if (groupExpanded) {
+		for (const expandedPath of groupExpanded) addRoute(ctx, method, expandedPath, data);
+		return;
+	}
+	path = encodeEscapes(path);
+	const segments = splitPath(path);
+	const expanded = expandModifiers(segments);
+	if (expanded) {
+		for (const p of expanded) addRoute(ctx, method, p, data);
+		return;
+	}
+	let node = ctx.root;
+	let _unnamedParamIndex = 0;
+	const paramsMap = [];
+	const paramsRegexp = [];
+	for (let i = 0; i < segments.length; i++) {
+		let segment = segments[i];
+		if (segment.startsWith("**")) {
+			if (!node.wildcard) node.wildcard = { key: "**" };
+			node = node.wildcard;
+			paramsMap.push([
+				-(i + 1),
+				segment.split(":")[1] || "_",
+				segment.length === 2
+			]);
+			break;
+		}
+		if (segment === "*" || segment.includes(":") || segment.includes("(") || hasSegmentWildcard(segment)) {
+			if (!node.param) node.param = { key: "*" };
+			node = node.param;
+			if (segment === "*") paramsMap.push([
+				i,
+				String(_unnamedParamIndex++),
+				true
+			]);
+			else if (segment.includes(":", 1) || segment.includes("(") || hasSegmentWildcard(segment) || !/^:[\w-]+$/.test(segment)) {
+				const [regexp, nextIndex] = getParamRegexp(segment, _unnamedParamIndex);
+				_unnamedParamIndex = nextIndex;
+				paramsRegexp[i] = regexp;
+				node.hasRegexParam = true;
+				paramsMap.push([
+					i,
+					regexp,
+					false
+				]);
+			} else paramsMap.push([
+				i,
+				segment.slice(1),
+				false
+			]);
+			continue;
+		}
+		if (segment === "\\*") segment = segments[i] = "*";
+		else if (segment === "\\*\\*") segment = segments[i] = "**";
+		segment = segments[i] = decodeEscaped(segment);
+		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["/" + segments.join("/")] = node;
+}
+function getParamRegexp(segment, unnamedStart = 0) {
+	let _i = unnamedStart;
+	let _s = "", _d = 0;
+	for (let j = 0; j < segment.length; j++) {
+		const c = segment.charCodeAt(j);
+		if (c === 40) _d++;
+		else if (c === 41 && _d > 0) _d--;
+		else if (c === 92 && _d === 0 && j + 1 < segment.length) {
+			const n = segment[j + 1];
+			if (n !== ":" && n !== "(" && n !== "*" && n !== "\\") {
+				_s += "￾" + n;
+				j++;
+				continue;
+			}
+		}
+		_s += segment[j];
+	}
+	[_s, _i] = replaceSegmentWildcards(_s, _i);
+	const regex = _s.replace(/:([\w-]+)(?:\(([^)]*)\))?/g, (_, id, p) => `(?<${id}>${p || "[^/]+"})`).replace(/\((?![?<])/g, () => `(?<${toUnnamedGroupKey(_i++)}>`).replace(/\./g, "\\.").replace(/\uFFFE(.)/g, (_, c) => /[.*+?^${}()|[\]\\]/.test(c) ? `\\${c}` : c);
+	return [new RegExp(`^${regex}$`), _i];
+}
+/**
+* Find a route by path.
+*/
+function findRoute(ctx, method = "", path, opts) {
+	if (opts?.normalize) path = normalizePath(path);
+	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.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(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(staticChild, method, segments, index + 1);
+			if (match) return match;
+		}
+	}
+	if (node.param) {
+		const match = _lookupTree(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 (opts?.normalize) path = normalizePath(path);
+	if (path.charCodeAt(path.length - 1) === 47) path = path.slice(0, -1);
+	const segments = splitPath(path);
+	const matches = _findAll(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(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(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(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.8.1/node_modules/rou3/dist/compiler.mjs
+const UNNAMED_GROUP_PREFIX = "__rou3_unnamed_";
+/**
+* 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 = "";
+	{
+		let hasIf = false;
+		for (const key in ctx.router.static) {
+			const node = ctx.router.static[key];
+			if (node?.methods) {
+				code += `${hasIf ? "else " : ""}if(p===${JSON.stringify(key.replace(/\/$/, "") || "/")}){${compileMethodMatch(ctx, node.methods, [], -1)}}`;
+				hasIf = true;
+			}
+		}
+	}
+	const match = compileNode(ctx, ctx.router.root, [], 1);
+	if (match) code += `let s=p.split("/"),l=s.length;${match}`;
+	if (!code) return ctx.opts?.matchAll ? `return [];` : "";
+	const normalizeHelper = code.includes("_normalizeGroups(") ? `const _prefix=${JSON.stringify(UNNAMED_GROUP_PREFIX)},_prefixLen=15;const _normalizeGroups=(g)=>{if(!g)return g;for(const k in g){if(k.startsWith(_prefix)){g[k.slice(_prefixLen)]=g[k];delete g[k]}}return g;};` : "";
+	const normalizePathHelper = ctx.opts?.normalize ? `if(p.includes("/.")){let _r=[];for(let _v of p.split("/")){if(_v===".")continue;_v===".."&&_r.length>1?_r.pop():_r.push(_v)}p=_r.join("/")||"/"}` : "";
+	return `${ctx.opts?.matchAll ? `let r=[];` : ""}${normalizeHelper}${normalizePathHelper}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]},` : `..._normalizeGroups((${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, currentIdx) {
+	const hasLastOptionalParam = node.key === "*";
+	let code = "", hasIf = false;
+	if (node.methods && params.length > 0) {
+		const match = compileMethodMatch(ctx, node.methods, params, hasLastOptionalParam ? currentIdx - 1 : -1);
+		if (match) {
+			code += `if(l===${currentIdx}${hasLastOptionalParam ? `||l===${currentIdx - 1}` : ""}){${match}}`;
+			hasIf = true;
+		}
+	}
+	if (node.static) {
+		let staticCode = "";
+		const notNeedBoundCheck = hasIf;
+		for (const key in node.static) {
+			const match = compileNode(ctx, node.static[key], params, currentIdx + 1);
+			if (match) {
+				staticCode += `${hasIf ? "else " : ""}if(s[${currentIdx}]===${JSON.stringify(key)}){${match}}`;
+				hasIf = true;
+			}
+		}
+		if (staticCode) code += notNeedBoundCheck ? staticCode : `if(l>${currentIdx}){${staticCode}}`;
+	}
+	if (node.param) code += compileNode(ctx, node.param, params.concat(`s[${currentIdx}]`), currentIdx + 1);
+	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) code += compileMethodMatch(ctx, wildcard.methods, params.concat(`s.slice(${currentIdx}).join('/')`), currentIdx);
+	}
+	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 };

package/dist/_libs/std-env.d.mts

@@ -0,0 +1,12 @@
+//#region node_modules/.pnpm/std-env@4.0.0/node_modules/std-env/dist/index.d.mts
+//#endregion
+//#region src/providers.d.ts
+/**
+* Represents the name of a CI/CD or Deployment provider.
+*/
+type ProviderName = (string & {}) | "appveyor" | "aws_amplify" | "azure_pipelines" | "azure_static" | "appcircle" | "bamboo" | "bitbucket" | "bitrise" | "buddy" | "buildkite" | "circle" | "cirrus" | "cloudflare_pages" | "cloudflare_workers" | "google_cloudrun" | "google_cloudrun_job" | "codebuild" | "codefresh" | "drone" | "drone" | "dsari" | "github_actions" | "gitlab" | "gocd" | "layerci" | "hudson" | "jenkins" | "magnum" | "netlify" | "nevercode" | "render" | "sail" | "semaphore" | "screwdriver" | "shippable" | "solano" | "strider" | "teamcity" | "travis" | "vercel" | "appcenter" | "codesandbox" | "stackblitz" | "stormkit" | "cleavr" | "zeabur" | "codesphere" | "railway" | "deno-deploy" | "firebase_app_hosting";
+/**
+* Provides information about a CI/CD or Deployment provider, including its name and possibly other metadata.
+*/
+//#endregion
+export { ProviderName as t };

package/dist/_libs/strip-literal.d.mts

@@ -0,0 +1 @@
+export { };