@qzsy/vinext 0.1.12 → 0.1.80

package/dist/node_modules/.pnpm/am-i-vibing@0.5.0/node_modules/am-i-vibing/dist/detector-1yx2Hoe0.js

@@ -0,0 +1,294 @@
+import { getProcessAncestry } from "../../../../process-ancestry@0.1.0/node_modules/process-ancestry/dist/index.js";
+//#region ../../node_modules/.pnpm/am-i-vibing@0.5.0/node_modules/am-i-vibing/dist/detector-1yx2Hoe0.mjs
+/**
+* Provider configurations for major AI coding tools
+*/
+const providers = [
+	{
+		id: "opencode",
+		name: "OpenCode",
+		type: "agent",
+		envVars: [{ any: [
+			"OPENCODE",
+			"OPENCODE_BIN_PATH",
+			"OPENCODE_SERVER",
+			"OPENCODE_APP_INFO",
+			"OPENCODE_MODES"
+		] }]
+	},
+	{
+		id: "jules",
+		name: "Jules",
+		type: "agent",
+		envVars: [{ all: [["HOME", "/home/jules"], ["USER", "swebot"]] }]
+	},
+	{
+		id: "claude-code",
+		name: "Claude Code",
+		type: "agent",
+		envVars: ["CLAUDECODE"]
+	},
+	{
+		id: "cursor-agent",
+		name: "Cursor Agent",
+		type: "agent",
+		envVars: [{ all: ["CURSOR_TRACE_ID", ["PAGER", "head -n 10000 | cat"]] }]
+	},
+	{
+		id: "cursor",
+		name: "Cursor",
+		type: "interactive",
+		envVars: ["CURSOR_TRACE_ID"]
+	},
+	{
+		id: "antigravity",
+		name: "Antigravity",
+		type: "agent",
+		envVars: [{ any: ["ANTIGRAVITY_AGENT", "ANTIGRAVITY_PROJECT_ID"] }]
+	},
+	{
+		id: "gemini-agent",
+		name: "Gemini CLI",
+		type: "agent",
+		envVars: [["GEMINI_CLI", "1"]],
+		processChecks: ["gemini"]
+	},
+	{
+		id: "codex",
+		name: "OpenAI Codex",
+		type: "agent",
+		envVars: ["CODEX_THREAD_ID"],
+		processChecks: ["codex"]
+	},
+	{
+		id: "replit",
+		name: "Replit",
+		type: "agent",
+		envVars: ["REPL_ID"]
+	},
+	{
+		id: "aider",
+		name: "Aider",
+		type: "agent",
+		envVars: ["AIDER_API_KEY"],
+		processChecks: ["aider"]
+	},
+	{
+		id: "bolt-agent",
+		name: "Bolt.new Agent",
+		type: "agent",
+		envVars: [{ all: [["SHELL", "/bin/jsh"], "npm_config_yes"] }]
+	},
+	{
+		id: "bolt",
+		name: "Bolt.new",
+		type: "interactive",
+		envVars: [{
+			all: [["SHELL", "/bin/jsh"]],
+			none: ["npm_config_yes"]
+		}]
+	},
+	{
+		id: "zed-agent",
+		name: "Zed Agent",
+		type: "agent",
+		envVars: [{ all: [["TERM_PROGRAM", "zed"], ["PAGER", "cat"]] }]
+	},
+	{
+		id: "zed",
+		name: "Zed",
+		type: "interactive",
+		envVars: [{
+			all: [["TERM_PROGRAM", "zed"]],
+			none: [["PAGER", "cat"]]
+		}]
+	},
+	{
+		id: "replit-assistant",
+		name: "Replit Assistant",
+		type: "agent",
+		envVars: [{ all: ["REPL_ID", ["REPLIT_MODE", "assistant"]] }]
+	},
+	{
+		id: "replit",
+		name: "Replit",
+		type: "interactive",
+		envVars: [{
+			all: ["REPL_ID"],
+			none: [["REPLIT_MODE", "assistant"]]
+		}]
+	},
+	{
+		id: "windsurf",
+		name: "Windsurf",
+		type: "agent",
+		envVars: ["CODEIUM_EDITOR_APP_ROOT"]
+	},
+	{
+		id: "crush",
+		name: "Crush",
+		type: "agent",
+		envVars: [{ any: [
+			["CRUSH", "1"],
+			["AGENT", "crush"],
+			["AI_AGENT", "crush"]
+		] }],
+		processChecks: ["crush"]
+	},
+	{
+		id: "amp",
+		name: "Amp",
+		type: "agent",
+		envVars: [{ any: ["AMP_CURRENT_THREAD_ID", ["AGENT", "amp"]] }]
+	},
+	{
+		id: "auggie",
+		name: "Auggie",
+		type: "agent",
+		envVars: [["AUGMENT_AGENT", "1"]]
+	},
+	{
+		id: "qwen-code",
+		name: "Qwen Code",
+		type: "agent",
+		envVars: [["QWEN_CODE", "1"]]
+	},
+	{
+		id: "vscode-copilot-agent",
+		name: "GitHub Copilot in VS Code",
+		type: "agent",
+		envVars: [{ all: [["TERM_PROGRAM", "vscode"], ["GIT_PAGER", "cat"]] }]
+	},
+	{
+		id: "warp",
+		name: "Warp Terminal",
+		type: "hybrid",
+		envVars: [{ all: [["TERM_PROGRAM", "WarpTerminal"]] }]
+	},
+	{
+		id: "octofriend",
+		name: "Octofriend",
+		type: "agent",
+		processChecks: ["octofriend"]
+	},
+	{
+		id: "devin",
+		name: "Devin",
+		type: "agent",
+		processChecks: ["devin"]
+	},
+	{
+		id: "droid",
+		name: "Factory Droid",
+		type: "agent",
+		processChecks: ["droid"]
+	},
+	{
+		id: "pi",
+		name: "Pi",
+		type: "agent",
+		envVars: [["PI_CODING_AGENT", "true"]]
+	}
+];
+/**
+* Check if a specific environment variable exists (handles both strings and tuples)
+*/
+function checkEnvVar(envVarDef, env = process.env) {
+	const [envVar, expectedValue] = typeof envVarDef === "string" ? [envVarDef, void 0] : envVarDef;
+	const actualValue = env[envVar];
+	return Boolean(actualValue && (!expectedValue || actualValue === expectedValue));
+}
+/**
+* Check if a process is running in the process tree
+*/
+function checkProcess(processName, processAncestry) {
+	for (const ancestorProcess of processAncestry) if (ancestorProcess.command?.includes(processName)) return true;
+	return false;
+}
+/**
+* Check if an environment variable group matches based on its properties
+*/
+function checkEnvVars(definition, env = process.env) {
+	if (typeof definition === "string" || Array.isArray(definition)) return checkEnvVar(definition, env);
+	const { any, all, none } = definition;
+	const anyResult = !any?.length || any.some((envVar) => checkEnvVar(envVar, env));
+	const allResult = !all?.length || all.every((envVar) => checkEnvVar(envVar, env));
+	const noneResult = !none?.length || !none.some((envVar) => checkEnvVar(envVar, env));
+	return anyResult && allResult && noneResult;
+}
+/**
+* Run custom detectors for a provider
+*/
+function runCustomDetectors(provider) {
+	return provider.customDetectors?.some((detector) => {
+		try {
+			return detector();
+		} catch {
+			return false;
+		}
+	}) ?? false;
+}
+/**
+* Create a positive detection result
+*/
+function createDetectedResult(provider) {
+	return {
+		isAgentic: true,
+		id: provider.id,
+		name: provider.name,
+		type: provider.type
+	};
+}
+/**
+* Normalize the various supported argument shapes into a DetectOptions object.
+*
+* Supported shapes:
+*   - detectAgenticEnvironment()
+*   - detectAgenticEnvironment(options)
+*   - detectAgenticEnvironment(env)                       // legacy
+*   - detectAgenticEnvironment(env, processAncestry)      // legacy
+*/
+function normalizeOptions(envOrOptions, legacyAncestry) {
+	if (envOrOptions != null && typeof envOrOptions === "object" && ("env" in envOrOptions || "processAncestry" in envOrOptions || "checkProcesses" in envOrOptions)) {
+		const opts = envOrOptions;
+		return {
+			env: opts.env ?? process.env,
+			processAncestry: opts.processAncestry,
+			checkProcesses: opts.checkProcesses ?? opts.processAncestry !== void 0
+		};
+	}
+	return {
+		env: envOrOptions ?? process.env,
+		processAncestry: legacyAncestry,
+		checkProcesses: legacyAncestry !== void 0
+	};
+}
+function detectAgenticEnvironment(envOrOptions, legacyAncestry) {
+	const { env, processAncestry, checkProcesses } = normalizeOptions(envOrOptions, legacyAncestry);
+	for (const provider of providers) if (provider.envVars?.some((group) => checkEnvVars(group, env))) return createDetectedResult(provider);
+	for (const provider of providers) if (runCustomDetectors(provider)) return createDetectedResult(provider);
+	if (checkProcesses) {
+		let cachedAncestry = processAncestry;
+		const getAncestry = () => {
+			if (cachedAncestry === void 0) try {
+				cachedAncestry = getProcessAncestry();
+			} catch {
+				cachedAncestry = [];
+			}
+			return cachedAncestry;
+		};
+		for (const provider of providers) if (provider.processChecks?.some((processName) => checkProcess(processName, getAncestry()))) return createDetectedResult(provider);
+	}
+	return {
+		isAgentic: false,
+		id: null,
+		name: null,
+		type: null
+	};
+}
+function isAgent(envOrOptions, legacyAncestry) {
+	const result = detectAgenticEnvironment(envOrOptions, legacyAncestry);
+	return result.type === "agent" || result.type === "hybrid";
+}
+//#endregion
+export { isAgent };

package/dist/node_modules/.pnpm/process-ancestry@0.1.0/node_modules/process-ancestry/dist/index.js

@@ -0,0 +1,94 @@
+import os from "os";
+import { execSync } from "child_process";
+//#region ../../node_modules/.pnpm/process-ancestry@0.1.0/node_modules/process-ancestry/dist/index.js
+function getProcessInfo(pid) {
+	try {
+		const output = execSync(`ps -p ${pid} -o pid=,ppid=,command=`, {
+			encoding: "utf8",
+			timeout: 5e3
+		}).trim();
+		if (!output) return null;
+		const [pidStr, ppidStr, ...commandParts] = output.split(/\s+/);
+		const parsedPid = pidStr ? parseInt(pidStr, 10) : NaN;
+		const parsedPpid = ppidStr ? parseInt(ppidStr, 10) : NaN;
+		if (isNaN(parsedPid) || isNaN(parsedPpid)) return null;
+		return {
+			pid: parsedPid,
+			ppid: parsedPpid,
+			command: commandParts.join(" ") || void 0
+		};
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("timeout")) console.warn(`Process lookup timed out for PID ${pid}`);
+		return null;
+	}
+}
+function getAncestryUnix(startPid) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	let currentPid = startPid;
+	let maxDepth = 1e3;
+	while (currentPid && maxDepth > 0) {
+		if (visited.has(currentPid)) {
+			console.warn(`Detected cycle in process tree at PID ${currentPid}`);
+			break;
+		}
+		visited.add(currentPid);
+		const info = getProcessInfo(currentPid);
+		if (!info || info.ppid === 0 || info.ppid === 1) break;
+		result.push(info);
+		currentPid = info.ppid;
+		maxDepth--;
+	}
+	if (maxDepth === 0) console.warn(`Reached maximum depth limit while traversing process tree from PID ${startPid}`);
+	return result;
+}
+function getProcessInfo2(pid) {
+	try {
+		const output = execSync(`wmic process where (ProcessId=${pid}) get ProcessId,ParentProcessId,CommandLine /format:csv`, {
+			encoding: "utf8",
+			timeout: 1e4
+		});
+		if (!output) return null;
+		const fields = output.split("\n").filter((line) => line.trim() && !line.startsWith("Node")).pop()?.split(",");
+		if (!fields || fields.length < 4) return null;
+		const [_node, commandLine, parentPid, thisPid] = fields;
+		const parsedPid = thisPid ? parseInt(thisPid.trim(), 10) : NaN;
+		const parsedPpid = parentPid ? parseInt(parentPid.trim(), 10) : NaN;
+		if (isNaN(parsedPid) || isNaN(parsedPpid)) return null;
+		return {
+			pid: parsedPid,
+			ppid: parsedPpid,
+			command: commandLine?.trim() || void 0
+		};
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("timeout")) console.warn(`Process lookup timed out for PID ${pid}`);
+		return null;
+	}
+}
+function getAncestryWindows(startPid) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	let currentPid = startPid;
+	let maxDepth = 1e3;
+	while (currentPid && maxDepth > 0) {
+		if (visited.has(currentPid)) {
+			console.warn(`Detected cycle in process tree at PID ${currentPid}`);
+			break;
+		}
+		visited.add(currentPid);
+		const info = getProcessInfo2(currentPid);
+		if (!info || info.ppid === 0 || info.ppid === 4) break;
+		result.push(info);
+		currentPid = info.ppid;
+		maxDepth--;
+	}
+	if (maxDepth === 0) console.warn(`Reached maximum depth limit while traversing process tree from PID ${startPid}`);
+	return result;
+}
+function getProcessAncestry(pid = process.pid) {
+	if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) throw new Error("PID must be a positive integer");
+	if (os.platform() === "win32") return getAncestryWindows(pid);
+	else return getAncestryUnix(pid);
+}
+//#endregion
+export { getProcessAncestry };

package/dist/{cloudflare → packages/cloudflare}/src/cache/cdn-adapter.runtime.js

@@ -1,4 +1,4 @@
-import { getRequestExecutionContext } from "../../../shims/request-context.js";
+import { getRequestExecutionContext } from "../../../../shims/request-context.js";
 //#region ../cloudflare/src/cache/cdn-adapter.runtime.ts
 function getWorkersCache() {
 	const cache = getRequestExecutionContext()?.cache;

package/dist/{cloudflare → packages/cloudflare}/src/cache/kv-data-adapter.runtime.d.ts

@@ -1,5 +1,5 @@
-import { CacheHandler, CacheHandlerValue, IncrementalCacheValue } from "../../../shims/cache-handler.js";
-import { ExecutionContextLike } from "../../../shims/request-context.js";
+import { CacheHandler, CacheHandlerValue, IncrementalCacheValue } from "../../../../shims/cache-handler.js";
+import { ExecutionContextLike } from "../../../../shims/request-context.js";
 
 //#region ../cloudflare/src/cache/kv-data-adapter.runtime.d.ts
 type KVNamespace = {

package/dist/{cloudflare → packages/cloudflare}/src/cache/kv-data-adapter.runtime.js

@@ -1,4 +1,4 @@
-import { getRequestExecutionContext } from "../../../shims/request-context.js";
+import { getRequestExecutionContext } from "../../../../shims/request-context.js";
 import { isUnknownRecord, readCacheControlNumberField } from "../utils/cache-control-metadata.js";
 import { Buffer } from "node:buffer";
 //#region ../cloudflare/src/cache/kv-data-adapter.runtime.ts

package/dist/plugins/ast-scope.d.ts

@@ -0,0 +1,16 @@
+import { AstRecord } from "./ast-utils.js";
+
+//#region src/plugins/ast-scope.d.ts
+type AstScope = {
+  parent: AstScope | null;
+  bindings: Set<string>;
+};
+declare function createAstScope<T extends AstScope>(parent: T | null): AstScope;
+declare function hasAstBinding(scope: AstScope, name: string): boolean;
+declare function isFunctionNode(node: AstRecord): boolean;
+declare function collectDirectScopeBindings(node: AstRecord, scope: AstScope, onVariableDeclarator?: (declaration: AstRecord, declarator: AstRecord) => void): void;
+declare function collectLoopScopeBindings(node: AstRecord, scope: AstScope, onVariableDeclarator?: (declaration: AstRecord, declarator: AstRecord) => void): void;
+declare function collectSwitchScopeBindings(node: AstRecord, scope: AstScope, onVariableDeclarator?: (declaration: AstRecord, declarator: AstRecord) => void): void;
+declare function collectVarScopeBindings(node: AstRecord, scope: AstScope, root?: boolean): void;
+//#endregion
+export { AstScope, collectDirectScopeBindings, collectLoopScopeBindings, collectSwitchScopeBindings, collectVarScopeBindings, createAstScope, hasAstBinding, isFunctionNode };

package/dist/plugins/ast-scope.js

@@ -0,0 +1,62 @@
+import { collectBindingNames, forEachAstChild, isAstRecord, nodeArray } from "./ast-utils.js";
+//#region src/plugins/ast-scope.ts
+function createAstScope(parent) {
+	return {
+		parent,
+		bindings: /* @__PURE__ */ new Set()
+	};
+}
+function hasAstBinding(scope, name) {
+	for (let current = scope; current; current = current.parent) if (current.bindings.has(name)) return true;
+	return false;
+}
+function isFunctionNode(node) {
+	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function collectDirectScopeBindings(node, scope, onVariableDeclarator) {
+	for (const statementValue of nodeArray(node.body)) {
+		const statement = isAstRecord(statementValue) ? statementValue : null;
+		if (!statement) continue;
+		const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? isAstRecord(statement.declaration) ? statement.declaration : null : statement;
+		if (!declaration) continue;
+		if (declaration.type === "ImportDeclaration") {
+			if (declaration.importKind === "type") continue;
+			for (const specifier of nodeArray(declaration.specifiers)) if (isAstRecord(specifier) && specifier.importKind !== "type") collectBindingNames(specifier.local, scope.bindings);
+		} else if (declaration.type === "TSImportEqualsDeclaration" && declaration.importKind !== "type") collectBindingNames(declaration.id, scope.bindings);
+		else if (declaration.type === "VariableDeclaration" && declaration.declare !== true) for (const declarator of nodeArray(declaration.declarations)) {
+			if (!isAstRecord(declarator)) continue;
+			collectBindingNames(declarator.id, scope.bindings);
+			onVariableDeclarator?.(declaration, declarator);
+		}
+		else if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.declare !== true) collectBindingNames(declaration.id, scope.bindings);
+		else if ((declaration.type === "TSEnumDeclaration" || declaration.type === "TSModuleDeclaration") && declaration.declare !== true) collectBindingNames(declaration.id, scope.bindings);
+	}
+}
+function collectLoopScopeBindings(node, scope, onVariableDeclarator) {
+	const declarationValue = node.type === "ForStatement" ? node.init : node.left;
+	if (!isAstRecord(declarationValue)) return;
+	if (declarationValue.type !== "VariableDeclaration" || declarationValue.declare === true) return;
+	for (const declarator of nodeArray(declarationValue.declarations)) {
+		if (!isAstRecord(declarator)) continue;
+		collectBindingNames(declarator.id, scope.bindings);
+		onVariableDeclarator?.(declarationValue, declarator);
+	}
+}
+function collectSwitchScopeBindings(node, scope, onVariableDeclarator) {
+	for (const caseValue of nodeArray(node.cases)) {
+		if (!isAstRecord(caseValue)) continue;
+		collectDirectScopeBindings({
+			type: "BlockStatement",
+			body: nodeArray(caseValue.consequent)
+		}, scope, onVariableDeclarator);
+	}
+}
+function collectVarScopeBindings(node, scope, root = true) {
+	if (!root && (isFunctionNode(node) || node.type === "StaticBlock" || node.type === "TSModuleBlock")) return;
+	if (node.type === "VariableDeclaration" && node.kind === "var" && node.declare !== true) {
+		for (const declarator of nodeArray(node.declarations)) if (isAstRecord(declarator)) collectBindingNames(declarator.id, scope.bindings);
+	}
+	forEachAstChild(node, (child) => collectVarScopeBindings(child, scope, false));
+}
+//#endregion
+export { collectDirectScopeBindings, collectLoopScopeBindings, collectSwitchScopeBindings, collectVarScopeBindings, createAstScope, hasAstBinding, isFunctionNode };

package/dist/plugins/ast-utils.js

@@ -59,6 +59,9 @@ function collectBindingNames(pattern, target) {
 		case "AssignmentPattern":
 			collectBindingNames(node.left, target);
 			return;
+		case "TSParameterProperty":
+			collectBindingNames(node.parameter, target);
+			return;
 		case "ArrayPattern":
 			for (const element of nodeArray(node.elements)) collectBindingNames(element, target);
 			return;

package/dist/plugins/css-module-imports.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from "vite";
+import MagicString from "magic-string";
+
+//#region src/plugins/css-module-imports.d.ts
+type ScriptLanguage = "js" | "jsx" | "ts" | "tsx";
+declare function rewriteCssModuleNamespaceImports(code: string, lang?: ScriptLanguage): {
+  code: string;
+  map: ReturnType<MagicString["generateMap"]>;
+} | null;
+declare function createCssModuleImportCompatibilityPlugin(options?: {
+  compiledMdx?: boolean;
+}): Plugin;
+//#endregion
+export { createCssModuleImportCompatibilityPlugin, rewriteCssModuleNamespaceImports };

package/dist/plugins/css-module-imports.js

@@ -0,0 +1,59 @@
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/css-module-imports.ts
+const CSS_MODULE_RE = /\.module\.(?:css|scss|sass)$/i;
+const CSS_MODULE_HINT_RE = /\.module\.(?:css|scss|sass)/i;
+const SCRIPT_RE = /\.(?:[cm]?[jt]sx?)(?:[?#].*)?$/i;
+const MDX_RE = /\.mdx$/i;
+function scriptLanguage(id) {
+	const cleanId = id.split("?", 1)[0].toLowerCase();
+	if (cleanId.endsWith(".tsx")) return "tsx";
+	if (cleanId.endsWith(".ts") || cleanId.endsWith(".mts") || cleanId.endsWith(".cts")) return "ts";
+	return "jsx";
+}
+function rewriteCssModuleNamespaceImports(code, lang = "js") {
+	let ast;
+	try {
+		ast = parseAst(code, { lang });
+	} catch {
+		return null;
+	}
+	let output = null;
+	for (const statement of ast.body) {
+		if (statement.type !== "ImportDeclaration") continue;
+		if (statement.importKind === "type") continue;
+		if (typeof statement.source?.value !== "string") continue;
+		if (!CSS_MODULE_RE.test(statement.source.value)) continue;
+		if (statement.attributes && statement.attributes.length > 0) continue;
+		if (statement.specifiers?.length !== 1) continue;
+		const specifier = statement.specifiers[0];
+		if (specifier.type !== "ImportNamespaceSpecifier") continue;
+		if (typeof specifier.start !== "number" || typeof specifier.end !== "number") continue;
+		if (typeof specifier.local?.name !== "string") continue;
+		output ??= new MagicString(code);
+		output.overwrite(specifier.start, specifier.end, specifier.local.name);
+	}
+	if (!output) return null;
+	return {
+		code: output.toString(),
+		map: output.generateMap({ hires: true })
+	};
+}
+function createCssModuleImportCompatibilityPlugin(options = {}) {
+	const idFilter = options.compiledMdx ? MDX_RE : SCRIPT_RE;
+	return {
+		name: options.compiledMdx ? "vinext:css-module-import-compatibility-mdx" : "vinext:css-module-import-compatibility",
+		enforce: options.compiledMdx ? "post" : "pre",
+		transform: {
+			filter: {
+				id: idFilter,
+				code: CSS_MODULE_HINT_RE
+			},
+			handler(code, id) {
+				return rewriteCssModuleNamespaceImports(code, options.compiledMdx ? "jsx" : scriptLanguage(id));
+			}
+		}
+	};
+}
+//#endregion
+export { createCssModuleImportCompatibilityPlugin, rewriteCssModuleNamespaceImports };

package/dist/plugins/ignore-dynamic-requests.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/ignore-dynamic-requests.d.ts
+declare function transformVeryDynamicRequests(code: string, id: string): {
+  code: string;
+  map: import("magic-string").SourceMap;
+} | null;
+declare function createIgnoreDynamicRequestsPlugin(getTranspiledPackages?: () => readonly string[]): Plugin;
+declare const _transformVeryDynamicRequests: typeof transformVeryDynamicRequests;
+//#endregion
+export { _transformVeryDynamicRequests, createIgnoreDynamicRequestsPlugin };