@voidzero-dev/vite-plus-core 0.2.3 → 0.2.5

package/dist/tsdown/dist-Pjag7IPt.js

@@ -0,0 +1,3206 @@
+import { r as createDebug } from "./main-BlTcyuFi.js";
+import { _ as filename_dts_to, b as replaceTemplateName, c as RE_CSS, d as RE_JS, f as RE_JSON, g as RE_VUE, h as RE_TS, l as RE_DTS, m as RE_ROLLDOWN_RUNTIME, o as at, p as RE_NODE_MODULES, s as ee, u as RE_DTS_MAP, v as filename_js_to_dts, x as resolveTemplateFn, y as filename_to_dts } from "./build-BlM3pDGJ-C8Uovnt4.js";
+import { i as __require$1, n as globalContext, r as invalidateContextFile, t as createContext } from "./tsc-context-BusiAGCd.js";
+import { createRequire } from "node:module";
+import process from "node:process";
+import { styleText } from "node:util";
+import { fork, spawn } from "node:child_process";
+import path, { dirname, extname } from "node:path";
+import { existsSync } from "node:fs";
+import { access, mkdtemp, readFile, rm } from "node:fs/promises";
+import { importerId, include } from "@voidzero-dev/vite-plus-core/rolldown/filter";
+import { tmpdir } from "node:os";
+import { ResolverFactory, isolatedDeclarationSync } from "@voidzero-dev/vite-plus-core/rolldown/experimental";
+import { print } from "yuku-codegen";
+import { parse as parse$1, walk } from "yuku-parser";
+//#region ../../node_modules/.pnpm/yuku-ast@0.1.7/node_modules/yuku-ast/dist/index.mjs
+const span = {
+	start: 0,
+	end: 0
+};
+const isComputedKey = (key) => key.type !== "Identifier" && key.type !== "PrivateIdentifier";
+const b = {
+	identifier(name, opts = {}) {
+		return {
+			type: "Identifier",
+			name,
+			...opts,
+			...span
+		};
+	},
+	privateIdentifier(name) {
+		return {
+			type: "PrivateIdentifier",
+			name,
+			...span
+		};
+	},
+	stringLiteral(value) {
+		return {
+			type: "Literal",
+			value,
+			raw: JSON.stringify(value),
+			...span
+		};
+	},
+	numericLiteral(value) {
+		return {
+			type: "Literal",
+			value,
+			raw: String(value),
+			...span
+		};
+	},
+	booleanLiteral(value) {
+		return {
+			type: "Literal",
+			value,
+			raw: String(value),
+			...span
+		};
+	},
+	nullLiteral() {
+		return {
+			type: "Literal",
+			value: null,
+			raw: "null",
+			...span
+		};
+	},
+	bigIntLiteral(value) {
+		return {
+			type: "Literal",
+			value,
+			raw: `${value}n`,
+			bigint: String(value),
+			...span
+		};
+	},
+	regExpLiteral(pattern, flags = "") {
+		let value = null;
+		try {
+			value = new RegExp(pattern, flags);
+		} catch {}
+		return {
+			type: "Literal",
+			value,
+			raw: `/${pattern}/${flags}`,
+			regex: {
+				pattern,
+				flags
+			},
+			...span
+		};
+	},
+	templateLiteral(quasis, expressions) {
+		return {
+			type: "TemplateLiteral",
+			quasis,
+			expressions,
+			...span
+		};
+	},
+	templateElement(cooked, tail = false) {
+		return {
+			type: "TemplateElement",
+			value: {
+				raw: cooked,
+				cooked
+			},
+			tail,
+			...span
+		};
+	},
+	thisExpression() {
+		return {
+			type: "ThisExpression",
+			...span
+		};
+	},
+	super() {
+		return {
+			type: "Super",
+			...span
+		};
+	},
+	arrayPattern(elements) {
+		return {
+			type: "ArrayPattern",
+			elements,
+			...span
+		};
+	},
+	objectPattern(properties) {
+		return {
+			type: "ObjectPattern",
+			properties,
+			...span
+		};
+	},
+	assignmentPattern(left, right) {
+		return {
+			type: "AssignmentPattern",
+			left,
+			right,
+			...span
+		};
+	},
+	restElement(argument) {
+		return {
+			type: "RestElement",
+			argument,
+			...span
+		};
+	},
+	/** A member of an `ObjectExpression`. For an `ObjectPattern` member, use {@link bindingProperty}. */
+	objectProperty(key, value, opts = {}) {
+		return {
+			type: "Property",
+			kind: opts.kind ?? "init",
+			key,
+			value,
+			method: opts.method ?? false,
+			shorthand: opts.shorthand ?? false,
+			computed: opts.computed ?? isComputedKey(key),
+			...span
+		};
+	},
+	/** A member of an `ObjectPattern`, whose value is a binding target. For an `ObjectExpression` member, use {@link objectProperty}. */
+	bindingProperty(key, value, opts = {}) {
+		return {
+			type: "Property",
+			kind: "init",
+			key,
+			value,
+			method: false,
+			shorthand: opts.shorthand ?? false,
+			computed: opts.computed ?? isComputedKey(key),
+			...span
+		};
+	},
+	arrayExpression(elements = []) {
+		return {
+			type: "ArrayExpression",
+			elements,
+			...span
+		};
+	},
+	objectExpression(properties = []) {
+		return {
+			type: "ObjectExpression",
+			properties,
+			...span
+		};
+	},
+	spreadElement(argument) {
+		return {
+			type: "SpreadElement",
+			argument,
+			...span
+		};
+	},
+	sequenceExpression(expressions) {
+		return {
+			type: "SequenceExpression",
+			expressions,
+			...span
+		};
+	},
+	parenthesizedExpression(expression) {
+		return {
+			type: "ParenthesizedExpression",
+			expression,
+			...span
+		};
+	},
+	unaryExpression(operator, argument) {
+		return {
+			type: "UnaryExpression",
+			operator,
+			prefix: true,
+			argument,
+			...span
+		};
+	},
+	updateExpression(operator, argument, prefix = false) {
+		return {
+			type: "UpdateExpression",
+			operator,
+			argument,
+			prefix,
+			...span
+		};
+	},
+	binaryExpression(operator, left, right) {
+		return {
+			type: "BinaryExpression",
+			operator,
+			left,
+			right,
+			...span
+		};
+	},
+	logicalExpression(operator, left, right) {
+		return {
+			type: "LogicalExpression",
+			operator,
+			left,
+			right,
+			...span
+		};
+	},
+	assignmentExpression(operator, left, right) {
+		return {
+			type: "AssignmentExpression",
+			operator,
+			left,
+			right,
+			...span
+		};
+	},
+	conditionalExpression(test, consequent, alternate) {
+		return {
+			type: "ConditionalExpression",
+			test,
+			consequent,
+			alternate,
+			...span
+		};
+	},
+	yieldExpression(argument = null, delegate = false) {
+		return {
+			type: "YieldExpression",
+			delegate,
+			argument,
+			...span
+		};
+	},
+	awaitExpression(argument) {
+		return {
+			type: "AwaitExpression",
+			argument,
+			...span
+		};
+	},
+	memberExpression(object, property, opts = {}) {
+		return {
+			type: "MemberExpression",
+			object,
+			property,
+			computed: opts.computed ?? isComputedKey(property),
+			optional: opts.optional ?? false,
+			...span
+		};
+	},
+	callExpression(callee, args = [], opts = {}) {
+		return {
+			type: "CallExpression",
+			callee,
+			arguments: args,
+			optional: opts.optional ?? false,
+			...opts,
+			...span
+		};
+	},
+	newExpression(callee, args = [], opts = {}) {
+		return {
+			type: "NewExpression",
+			callee,
+			arguments: args,
+			...opts,
+			...span
+		};
+	},
+	chainExpression(expression) {
+		return {
+			type: "ChainExpression",
+			expression,
+			...span
+		};
+	},
+	taggedTemplateExpression(tag, quasi, opts = {}) {
+		return {
+			type: "TaggedTemplateExpression",
+			tag,
+			quasi,
+			...opts,
+			...span
+		};
+	},
+	metaProperty(meta, property) {
+		return {
+			type: "MetaProperty",
+			meta: b.identifier(meta),
+			property: b.identifier(property),
+			...span
+		};
+	},
+	importExpression(source, opts = {}) {
+		return {
+			type: "ImportExpression",
+			source,
+			options: opts.options ?? null,
+			phase: opts.phase ?? null,
+			...span
+		};
+	},
+	arrowFunctionExpression(params, body, opts = {}) {
+		return {
+			type: "ArrowFunctionExpression",
+			id: null,
+			generator: false,
+			async: opts.async ?? false,
+			params,
+			body,
+			expression: body.type !== "BlockStatement",
+			...opts,
+			...span
+		};
+	},
+	functionExpression(params, body, opts = {}) {
+		return {
+			type: "FunctionExpression",
+			id: opts.id ?? null,
+			generator: opts.generator ?? false,
+			async: opts.async ?? false,
+			params,
+			body,
+			expression: false,
+			...span
+		};
+	},
+	functionDeclaration(id, params, body, opts = {}) {
+		return {
+			type: "FunctionDeclaration",
+			id,
+			generator: opts.generator ?? false,
+			async: opts.async ?? false,
+			params,
+			body,
+			expression: false,
+			...span
+		};
+	},
+	classDeclaration(id, body, opts = {}) {
+		return {
+			type: "ClassDeclaration",
+			decorators: opts.decorators ?? [],
+			id,
+			superClass: opts.superClass ?? null,
+			body,
+			...opts,
+			...span
+		};
+	},
+	classExpression(id, body, opts = {}) {
+		return {
+			type: "ClassExpression",
+			decorators: opts.decorators ?? [],
+			id,
+			superClass: opts.superClass ?? null,
+			body,
+			...span
+		};
+	},
+	classBody(body = []) {
+		return {
+			type: "ClassBody",
+			body,
+			...span
+		};
+	},
+	methodDefinition(key, value, opts = {}) {
+		return {
+			type: "MethodDefinition",
+			decorators: [],
+			key,
+			value,
+			kind: opts.kind ?? "method",
+			computed: opts.computed ?? isComputedKey(key),
+			static: opts.static ?? false,
+			...span
+		};
+	},
+	propertyDefinition(key, value = null, opts = {}) {
+		return {
+			type: "PropertyDefinition",
+			decorators: opts.decorators ?? [],
+			key,
+			value,
+			computed: opts.computed ?? isComputedKey(key),
+			static: opts.static ?? false,
+			...span
+		};
+	},
+	accessorProperty(key, value = null, opts = {}) {
+		return {
+			type: "AccessorProperty",
+			decorators: [],
+			key,
+			value,
+			computed: opts.computed ?? isComputedKey(key),
+			static: opts.static ?? false,
+			...span
+		};
+	},
+	tsAbstractMethodDefinition(key, value, opts = {}) {
+		return {
+			type: "TSAbstractMethodDefinition",
+			decorators: [],
+			key,
+			value,
+			kind: opts.kind ?? "method",
+			computed: opts.computed ?? isComputedKey(key),
+			static: opts.static ?? false,
+			...span
+		};
+	},
+	tsAbstractPropertyDefinition(key, value = null, opts = {}) {
+		return {
+			type: "TSAbstractPropertyDefinition",
+			decorators: [],
+			key,
+			value,
+			computed: opts.computed ?? isComputedKey(key),
+			static: opts.static ?? false,
+			...span
+		};
+	},
+	tsAbstractAccessorProperty(key, value = null, opts = {}) {
+		return {
+			type: "TSAbstractAccessorProperty",
+			decorators: [],
+			key,
+			value,
+			computed: opts.computed ?? isComputedKey(key),
+			static: opts.static ?? false,
+			...span
+		};
+	},
+	staticBlock(body = []) {
+		return {
+			type: "StaticBlock",
+			body,
+			...span
+		};
+	},
+	decorator(expression) {
+		return {
+			type: "Decorator",
+			expression,
+			...span
+		};
+	},
+	expressionStatement(expression) {
+		return {
+			type: "ExpressionStatement",
+			expression,
+			...span
+		};
+	},
+	directive(value) {
+		return {
+			type: "ExpressionStatement",
+			expression: b.stringLiteral(value),
+			directive: value,
+			...span
+		};
+	},
+	blockStatement(body = []) {
+		return {
+			type: "BlockStatement",
+			body,
+			...span
+		};
+	},
+	emptyStatement() {
+		return {
+			type: "EmptyStatement",
+			...span
+		};
+	},
+	debuggerStatement() {
+		return {
+			type: "DebuggerStatement",
+			...span
+		};
+	},
+	returnStatement(argument = null) {
+		return {
+			type: "ReturnStatement",
+			argument,
+			...span
+		};
+	},
+	ifStatement(test, consequent, alternate = null) {
+		return {
+			type: "IfStatement",
+			test,
+			consequent,
+			alternate,
+			...span
+		};
+	},
+	switchStatement(discriminant, cases) {
+		return {
+			type: "SwitchStatement",
+			discriminant,
+			cases,
+			...span
+		};
+	},
+	switchCase(test, consequent) {
+		return {
+			type: "SwitchCase",
+			test,
+			consequent,
+			...span
+		};
+	},
+	throwStatement(argument) {
+		return {
+			type: "ThrowStatement",
+			argument,
+			...span
+		};
+	},
+	tryStatement(block, handler = null, finalizer = null) {
+		return {
+			type: "TryStatement",
+			block,
+			handler,
+			finalizer,
+			...span
+		};
+	},
+	catchClause(param, body) {
+		return {
+			type: "CatchClause",
+			param,
+			body,
+			...span
+		};
+	},
+	whileStatement(test, body) {
+		return {
+			type: "WhileStatement",
+			test,
+			body,
+			...span
+		};
+	},
+	doWhileStatement(body, test) {
+		return {
+			type: "DoWhileStatement",
+			body,
+			test,
+			...span
+		};
+	},
+	forStatement(init, test, update, body) {
+		return {
+			type: "ForStatement",
+			init,
+			test,
+			update,
+			body,
+			...span
+		};
+	},
+	forInStatement(left, right, body) {
+		return {
+			type: "ForInStatement",
+			left,
+			right,
+			body,
+			...span
+		};
+	},
+	forOfStatement(left, right, body, isAwait = false) {
+		return {
+			type: "ForOfStatement",
+			left,
+			right,
+			body,
+			await: isAwait,
+			...span
+		};
+	},
+	labeledStatement(label, body) {
+		return {
+			type: "LabeledStatement",
+			label,
+			body,
+			...span
+		};
+	},
+	breakStatement(label = null) {
+		return {
+			type: "BreakStatement",
+			label,
+			...span
+		};
+	},
+	continueStatement(label = null) {
+		return {
+			type: "ContinueStatement",
+			label,
+			...span
+		};
+	},
+	withStatement(object, body) {
+		return {
+			type: "WithStatement",
+			object,
+			body,
+			...span
+		};
+	},
+	variableDeclaration(kind, declarations) {
+		return {
+			type: "VariableDeclaration",
+			kind,
+			declarations,
+			...span
+		};
+	},
+	variableDeclarator(id, init = null) {
+		return {
+			type: "VariableDeclarator",
+			id,
+			init,
+			...span
+		};
+	},
+	importDeclaration(specifiers, source, opts = {}) {
+		return {
+			type: "ImportDeclaration",
+			specifiers,
+			source,
+			phase: opts.phase ?? null,
+			attributes: opts.attributes ?? [],
+			...opts,
+			...span
+		};
+	},
+	importSpecifier(imported, local) {
+		return {
+			type: "ImportSpecifier",
+			imported,
+			local,
+			...span
+		};
+	},
+	importDefaultSpecifier(local) {
+		return {
+			type: "ImportDefaultSpecifier",
+			local,
+			...span
+		};
+	},
+	importNamespaceSpecifier(local) {
+		return {
+			type: "ImportNamespaceSpecifier",
+			local,
+			...span
+		};
+	},
+	importAttribute(key, value) {
+		return {
+			type: "ImportAttribute",
+			key,
+			value,
+			...span
+		};
+	},
+	exportNamedDeclaration(declaration, specifiers = [], opts = {}) {
+		return {
+			type: "ExportNamedDeclaration",
+			declaration,
+			specifiers,
+			source: opts.source ?? null,
+			attributes: opts.attributes ?? [],
+			...opts,
+			...span
+		};
+	},
+	exportDefaultDeclaration(declaration) {
+		return {
+			type: "ExportDefaultDeclaration",
+			declaration,
+			...span
+		};
+	},
+	exportAllDeclaration(source, opts = {}) {
+		return {
+			type: "ExportAllDeclaration",
+			exported: opts.exported ?? null,
+			source,
+			attributes: opts.attributes ?? [],
+			...opts,
+			...span
+		};
+	},
+	exportSpecifier(local, exported) {
+		return {
+			type: "ExportSpecifier",
+			local,
+			exported,
+			...span
+		};
+	},
+	jsxIdentifier(name) {
+		return {
+			type: "JSXIdentifier",
+			name,
+			...span
+		};
+	},
+	jsxNamespacedName(namespace, name) {
+		return {
+			type: "JSXNamespacedName",
+			namespace,
+			name,
+			...span
+		};
+	},
+	jsxMemberExpression(object, property) {
+		return {
+			type: "JSXMemberExpression",
+			object,
+			property,
+			...span
+		};
+	},
+	jsxElement(openingElement, children = [], closingElement = null) {
+		return {
+			type: "JSXElement",
+			openingElement,
+			children,
+			closingElement,
+			...span
+		};
+	},
+	jsxOpeningElement(name, attributes = [], selfClosing = false) {
+		return {
+			type: "JSXOpeningElement",
+			name,
+			attributes,
+			selfClosing,
+			...span
+		};
+	},
+	jsxClosingElement(name) {
+		return {
+			type: "JSXClosingElement",
+			name,
+			...span
+		};
+	},
+	jsxOpeningFragment() {
+		return {
+			type: "JSXOpeningFragment",
+			...span
+		};
+	},
+	jsxClosingFragment() {
+		return {
+			type: "JSXClosingFragment",
+			...span
+		};
+	},
+	jsxFragment(children = []) {
+		return {
+			type: "JSXFragment",
+			openingFragment: b.jsxOpeningFragment(),
+			children,
+			closingFragment: b.jsxClosingFragment(),
+			...span
+		};
+	},
+	jsxAttribute(name, value = null) {
+		return {
+			type: "JSXAttribute",
+			name,
+			value,
+			...span
+		};
+	},
+	jsxSpreadAttribute(argument) {
+		return {
+			type: "JSXSpreadAttribute",
+			argument,
+			...span
+		};
+	},
+	jsxExpressionContainer(expression) {
+		return {
+			type: "JSXExpressionContainer",
+			expression,
+			...span
+		};
+	},
+	jsxEmptyExpression() {
+		return {
+			type: "JSXEmptyExpression",
+			...span
+		};
+	},
+	jsxText(value) {
+		return {
+			type: "JSXText",
+			value,
+			raw: value,
+			...span
+		};
+	},
+	jsxSpreadChild(expression) {
+		return {
+			type: "JSXSpreadChild",
+			expression,
+			...span
+		};
+	},
+	tsTypeAnnotation(typeAnnotation) {
+		return {
+			type: "TSTypeAnnotation",
+			typeAnnotation,
+			...span
+		};
+	},
+	tsAnyKeyword: () => ({
+		type: "TSAnyKeyword",
+		...span
+	}),
+	tsUnknownKeyword: () => ({
+		type: "TSUnknownKeyword",
+		...span
+	}),
+	tsNeverKeyword: () => ({
+		type: "TSNeverKeyword",
+		...span
+	}),
+	tsVoidKeyword: () => ({
+		type: "TSVoidKeyword",
+		...span
+	}),
+	tsNullKeyword: () => ({
+		type: "TSNullKeyword",
+		...span
+	}),
+	tsUndefinedKeyword: () => ({
+		type: "TSUndefinedKeyword",
+		...span
+	}),
+	tsStringKeyword: () => ({
+		type: "TSStringKeyword",
+		...span
+	}),
+	tsNumberKeyword: () => ({
+		type: "TSNumberKeyword",
+		...span
+	}),
+	tsBigIntKeyword: () => ({
+		type: "TSBigIntKeyword",
+		...span
+	}),
+	tsBooleanKeyword: () => ({
+		type: "TSBooleanKeyword",
+		...span
+	}),
+	tsSymbolKeyword: () => ({
+		type: "TSSymbolKeyword",
+		...span
+	}),
+	tsObjectKeyword: () => ({
+		type: "TSObjectKeyword",
+		...span
+	}),
+	tsIntrinsicKeyword: () => ({
+		type: "TSIntrinsicKeyword",
+		...span
+	}),
+	tsThisType: () => ({
+		type: "TSThisType",
+		...span
+	}),
+	tsTypeReference(typeName, typeArguments = null) {
+		return {
+			type: "TSTypeReference",
+			typeName,
+			typeArguments,
+			...span
+		};
+	},
+	tsQualifiedName(left, right) {
+		return {
+			type: "TSQualifiedName",
+			left,
+			right,
+			...span
+		};
+	},
+	tsTypeQuery(exprName, typeArguments = null) {
+		return {
+			type: "TSTypeQuery",
+			exprName,
+			typeArguments,
+			...span
+		};
+	},
+	tsImportType(source, opts = {}) {
+		return {
+			type: "TSImportType",
+			source,
+			options: opts.options ?? null,
+			qualifier: opts.qualifier ?? null,
+			typeArguments: opts.typeArguments ?? null,
+			...span
+		};
+	},
+	tsTypeParameter(name, opts = {}) {
+		return {
+			type: "TSTypeParameter",
+			name,
+			constraint: opts.constraint ?? null,
+			default: opts.default ?? null,
+			in: opts.in ?? false,
+			out: opts.out ?? false,
+			const: opts.const ?? false,
+			...span
+		};
+	},
+	tsTypeParameterDeclaration(params) {
+		return {
+			type: "TSTypeParameterDeclaration",
+			params,
+			...span
+		};
+	},
+	tsTypeParameterInstantiation(params) {
+		return {
+			type: "TSTypeParameterInstantiation",
+			params,
+			...span
+		};
+	},
+	tsLiteralType(literal) {
+		return {
+			type: "TSLiteralType",
+			literal,
+			...span
+		};
+	},
+	tsTemplateLiteralType(quasis, types) {
+		return {
+			type: "TSTemplateLiteralType",
+			quasis,
+			types,
+			...span
+		};
+	},
+	tsArrayType(elementType) {
+		return {
+			type: "TSArrayType",
+			elementType,
+			...span
+		};
+	},
+	tsIndexedAccessType(objectType, indexType) {
+		return {
+			type: "TSIndexedAccessType",
+			objectType,
+			indexType,
+			...span
+		};
+	},
+	tsTupleType(elementTypes) {
+		return {
+			type: "TSTupleType",
+			elementTypes,
+			...span
+		};
+	},
+	tsNamedTupleMember(label, elementType, optional = false) {
+		return {
+			type: "TSNamedTupleMember",
+			label,
+			elementType,
+			optional,
+			...span
+		};
+	},
+	tsOptionalType(typeAnnotation) {
+		return {
+			type: "TSOptionalType",
+			typeAnnotation,
+			...span
+		};
+	},
+	tsRestType(typeAnnotation) {
+		return {
+			type: "TSRestType",
+			typeAnnotation,
+			...span
+		};
+	},
+	tsJSDocNullableType(typeAnnotation, postfix = false) {
+		return {
+			type: "TSJSDocNullableType",
+			typeAnnotation,
+			postfix,
+			...span
+		};
+	},
+	tsJSDocNonNullableType(typeAnnotation, postfix = false) {
+		return {
+			type: "TSJSDocNonNullableType",
+			typeAnnotation,
+			postfix,
+			...span
+		};
+	},
+	tsJSDocUnknownType() {
+		return {
+			type: "TSJSDocUnknownType",
+			...span
+		};
+	},
+	tsUnionType(types) {
+		return {
+			type: "TSUnionType",
+			types,
+			...span
+		};
+	},
+	tsIntersectionType(types) {
+		return {
+			type: "TSIntersectionType",
+			types,
+			...span
+		};
+	},
+	tsConditionalType(checkType, extendsType, trueType, falseType) {
+		return {
+			type: "TSConditionalType",
+			checkType,
+			extendsType,
+			trueType,
+			falseType,
+			...span
+		};
+	},
+	tsInferType(typeParameter) {
+		return {
+			type: "TSInferType",
+			typeParameter,
+			...span
+		};
+	},
+	tsTypeOperator(operator, typeAnnotation) {
+		return {
+			type: "TSTypeOperator",
+			operator,
+			typeAnnotation,
+			...span
+		};
+	},
+	tsParenthesizedType(typeAnnotation) {
+		return {
+			type: "TSParenthesizedType",
+			typeAnnotation,
+			...span
+		};
+	},
+	tsFunctionType(params, returnType, typeParameters = null) {
+		return {
+			type: "TSFunctionType",
+			typeParameters,
+			params,
+			returnType,
+			...span
+		};
+	},
+	tsConstructorType(params, returnType, opts = {}) {
+		return {
+			type: "TSConstructorType",
+			abstract: opts.abstract ?? false,
+			typeParameters: opts.typeParameters ?? null,
+			params,
+			returnType,
+			...span
+		};
+	},
+	tsTypePredicate(parameterName, typeAnnotation = null, asserts = false) {
+		return {
+			type: "TSTypePredicate",
+			parameterName,
+			typeAnnotation,
+			asserts,
+			...span
+		};
+	},
+	tsTypeLiteral(members) {
+		return {
+			type: "TSTypeLiteral",
+			members,
+			...span
+		};
+	},
+	tsMappedType(key, constraint, opts = {}) {
+		return {
+			type: "TSMappedType",
+			key,
+			constraint,
+			nameType: opts.nameType ?? null,
+			typeAnnotation: opts.typeAnnotation ?? null,
+			optional: opts.optional ?? false,
+			readonly: opts.readonly ?? null,
+			...span
+		};
+	},
+	tsPropertySignature(key, opts = {}) {
+		return {
+			type: "TSPropertySignature",
+			key,
+			typeAnnotation: opts.typeAnnotation ?? null,
+			computed: opts.computed ?? isComputedKey(key),
+			optional: opts.optional ?? false,
+			readonly: opts.readonly ?? false,
+			accessibility: null,
+			static: false,
+			...span
+		};
+	},
+	tsMethodSignature(key, params, opts = {}) {
+		return {
+			type: "TSMethodSignature",
+			key,
+			computed: opts.computed ?? isComputedKey(key),
+			optional: opts.optional ?? false,
+			kind: opts.kind ?? "method",
+			typeParameters: opts.typeParameters ?? null,
+			params,
+			returnType: opts.returnType ?? null,
+			accessibility: null,
+			readonly: false,
+			static: false,
+			...span
+		};
+	},
+	tsCallSignatureDeclaration(params, returnType = null, typeParameters = null) {
+		return {
+			type: "TSCallSignatureDeclaration",
+			typeParameters,
+			params,
+			returnType,
+			...span
+		};
+	},
+	tsConstructSignatureDeclaration(params, returnType = null, typeParameters = null) {
+		return {
+			type: "TSConstructSignatureDeclaration",
+			typeParameters,
+			params,
+			returnType,
+			...span
+		};
+	},
+	tsIndexSignature(parameters, typeAnnotation, opts = {}) {
+		return {
+			type: "TSIndexSignature",
+			parameters,
+			typeAnnotation,
+			readonly: opts.readonly ?? false,
+			static: opts.static ?? false,
+			accessibility: null,
+			...span
+		};
+	},
+	tsTypeAliasDeclaration(id, typeAnnotation, opts = {}) {
+		return {
+			type: "TSTypeAliasDeclaration",
+			id,
+			typeParameters: opts.typeParameters ?? null,
+			typeAnnotation,
+			declare: opts.declare ?? false,
+			...span
+		};
+	},
+	tsInterfaceDeclaration(id, body, opts = {}) {
+		return {
+			type: "TSInterfaceDeclaration",
+			id,
+			typeParameters: opts.typeParameters ?? null,
+			extends: opts.extends ?? [],
+			body,
+			declare: opts.declare ?? false,
+			...span
+		};
+	},
+	tsInterfaceBody(body) {
+		return {
+			type: "TSInterfaceBody",
+			body,
+			...span
+		};
+	},
+	tsInterfaceHeritage(expression, typeArguments = null) {
+		return {
+			type: "TSInterfaceHeritage",
+			expression,
+			typeArguments,
+			...span
+		};
+	},
+	tsClassImplements(expression, typeArguments = null) {
+		return {
+			type: "TSClassImplements",
+			expression,
+			typeArguments,
+			...span
+		};
+	},
+	tsEnumDeclaration(id, body, opts = {}) {
+		return {
+			type: "TSEnumDeclaration",
+			id,
+			body,
+			const: opts.const ?? false,
+			declare: opts.declare ?? false,
+			...span
+		};
+	},
+	tsEnumBody(members) {
+		return {
+			type: "TSEnumBody",
+			members,
+			...span
+		};
+	},
+	tsEnumMember(id, initializer = null) {
+		return {
+			type: "TSEnumMember",
+			id,
+			initializer,
+			computed: false,
+			...span
+		};
+	},
+	tsModuleDeclaration(id, body, opts = {}) {
+		return {
+			type: "TSModuleDeclaration",
+			id,
+			body,
+			kind: opts.kind ?? "module",
+			declare: opts.declare ?? false,
+			global: opts.global ?? false,
+			...span
+		};
+	},
+	tsModuleBlock(body = []) {
+		return {
+			type: "TSModuleBlock",
+			body,
+			...span
+		};
+	},
+	tsParameterProperty(parameter, opts = {}) {
+		return {
+			type: "TSParameterProperty",
+			decorators: opts.decorators ?? [],
+			parameter,
+			override: opts.override ?? false,
+			readonly: opts.readonly ?? false,
+			accessibility: opts.accessibility ?? null,
+			static: false,
+			...span
+		};
+	},
+	tsAsExpression(expression, typeAnnotation) {
+		return {
+			type: "TSAsExpression",
+			expression,
+			typeAnnotation,
+			...span
+		};
+	},
+	tsSatisfiesExpression(expression, typeAnnotation) {
+		return {
+			type: "TSSatisfiesExpression",
+			expression,
+			typeAnnotation,
+			...span
+		};
+	},
+	tsTypeAssertion(typeAnnotation, expression) {
+		return {
+			type: "TSTypeAssertion",
+			typeAnnotation,
+			expression,
+			...span
+		};
+	},
+	tsNonNullExpression(expression) {
+		return {
+			type: "TSNonNullExpression",
+			expression,
+			...span
+		};
+	},
+	tsInstantiationExpression(expression, typeArguments) {
+		return {
+			type: "TSInstantiationExpression",
+			expression,
+			typeArguments,
+			...span
+		};
+	},
+	tsExportAssignment(expression) {
+		return {
+			type: "TSExportAssignment",
+			expression,
+			...span
+		};
+	},
+	tsNamespaceExportDeclaration(id) {
+		return {
+			type: "TSNamespaceExportDeclaration",
+			id,
+			...span
+		};
+	},
+	tsImportEqualsDeclaration(id, moduleReference, importKind = "value") {
+		return {
+			type: "TSImportEqualsDeclaration",
+			id,
+			moduleReference,
+			importKind,
+			...span
+		};
+	},
+	tsExternalModuleReference(expression) {
+		return {
+			type: "TSExternalModuleReference",
+			expression,
+			...span
+		};
+	},
+	tsDeclareFunction(id, params, opts = {}) {
+		return {
+			type: "TSDeclareFunction",
+			id,
+			generator: opts.generator ?? false,
+			async: opts.async ?? false,
+			params,
+			body: null,
+			expression: false,
+			declare: opts.declare ?? false,
+			typeParameters: opts.typeParameters ?? null,
+			returnType: opts.returnType ?? null,
+			...span
+		};
+	},
+	tsEmptyBodyFunctionExpression(params, opts = {}) {
+		return {
+			type: "TSEmptyBodyFunctionExpression",
+			id: opts.id ?? null,
+			generator: false,
+			async: false,
+			params,
+			body: null,
+			expression: false,
+			declare: false,
+			typeParameters: opts.typeParameters ?? null,
+			returnType: opts.returnType ?? null,
+			...span
+		};
+	},
+	hashbang(value) {
+		return {
+			type: "Hashbang",
+			value,
+			...span
+		};
+	},
+	program(body = [], opts = {}) {
+		return {
+			type: "Program",
+			sourceType: opts.sourceType ?? "module",
+			hashbang: opts.hashbang ?? null,
+			body,
+			...span
+		};
+	}
+};
+/**
+* Node types grouped under a shared alias. Membership is by node `type`, and
+* each group backs an alias guard such as `is.Expression` or `is.Function`.
+*/
+const ALIAS_GROUPS = {
+	Expression: [
+		"Identifier",
+		"Literal",
+		"ThisExpression",
+		"Super",
+		"ArrayExpression",
+		"ObjectExpression",
+		"FunctionExpression",
+		"ArrowFunctionExpression",
+		"ClassExpression",
+		"TaggedTemplateExpression",
+		"TemplateLiteral",
+		"MemberExpression",
+		"CallExpression",
+		"NewExpression",
+		"ChainExpression",
+		"SequenceExpression",
+		"ParenthesizedExpression",
+		"BinaryExpression",
+		"LogicalExpression",
+		"ConditionalExpression",
+		"UnaryExpression",
+		"UpdateExpression",
+		"AssignmentExpression",
+		"YieldExpression",
+		"AwaitExpression",
+		"ImportExpression",
+		"MetaProperty",
+		"TSAsExpression",
+		"TSSatisfiesExpression",
+		"TSTypeAssertion",
+		"TSNonNullExpression",
+		"TSInstantiationExpression",
+		"JSXElement",
+		"JSXFragment"
+	],
+	Statement: [
+		"ExpressionStatement",
+		"BlockStatement",
+		"EmptyStatement",
+		"DebuggerStatement",
+		"ReturnStatement",
+		"LabeledStatement",
+		"BreakStatement",
+		"ContinueStatement",
+		"IfStatement",
+		"SwitchStatement",
+		"ThrowStatement",
+		"TryStatement",
+		"WhileStatement",
+		"DoWhileStatement",
+		"ForStatement",
+		"ForInStatement",
+		"ForOfStatement",
+		"WithStatement",
+		"FunctionDeclaration",
+		"ClassDeclaration",
+		"VariableDeclaration",
+		"TSDeclareFunction",
+		"TSTypeAliasDeclaration",
+		"TSInterfaceDeclaration",
+		"TSEnumDeclaration",
+		"TSModuleDeclaration",
+		"TSImportEqualsDeclaration"
+	],
+	Declaration: [
+		"FunctionDeclaration",
+		"ClassDeclaration",
+		"VariableDeclaration",
+		"TSDeclareFunction",
+		"TSTypeAliasDeclaration",
+		"TSInterfaceDeclaration",
+		"TSEnumDeclaration",
+		"TSModuleDeclaration",
+		"TSImportEqualsDeclaration"
+	],
+	ModuleDeclaration: [
+		"ImportDeclaration",
+		"ExportNamedDeclaration",
+		"ExportDefaultDeclaration",
+		"ExportAllDeclaration",
+		"TSExportAssignment",
+		"TSNamespaceExportDeclaration"
+	],
+	Function: [
+		"FunctionDeclaration",
+		"FunctionExpression",
+		"ArrowFunctionExpression",
+		"TSDeclareFunction",
+		"TSEmptyBodyFunctionExpression"
+	],
+	Class: ["ClassDeclaration", "ClassExpression"],
+	Method: ["MethodDefinition", "TSAbstractMethodDefinition"],
+	Loop: [
+		"ForStatement",
+		"ForInStatement",
+		"ForOfStatement",
+		"WhileStatement",
+		"DoWhileStatement"
+	],
+	Pattern: [
+		"Identifier",
+		"ArrayPattern",
+		"ObjectPattern",
+		"AssignmentPattern",
+		"RestElement"
+	],
+	JSX: [
+		"JSXElement",
+		"JSXOpeningElement",
+		"JSXClosingElement",
+		"JSXFragment",
+		"JSXOpeningFragment",
+		"JSXClosingFragment",
+		"JSXIdentifier",
+		"JSXNamespacedName",
+		"JSXMemberExpression",
+		"JSXAttribute",
+		"JSXSpreadAttribute",
+		"JSXExpressionContainer",
+		"JSXEmptyExpression",
+		"JSXText",
+		"JSXSpreadChild"
+	],
+	TSType: [
+		"TSAnyKeyword",
+		"TSUnknownKeyword",
+		"TSNeverKeyword",
+		"TSVoidKeyword",
+		"TSNullKeyword",
+		"TSUndefinedKeyword",
+		"TSStringKeyword",
+		"TSNumberKeyword",
+		"TSBigIntKeyword",
+		"TSBooleanKeyword",
+		"TSSymbolKeyword",
+		"TSObjectKeyword",
+		"TSIntrinsicKeyword",
+		"TSThisType",
+		"TSTypeReference",
+		"TSTypeQuery",
+		"TSImportType",
+		"TSLiteralType",
+		"TSTemplateLiteralType",
+		"TSArrayType",
+		"TSIndexedAccessType",
+		"TSTupleType",
+		"TSNamedTupleMember",
+		"TSJSDocNullableType",
+		"TSJSDocNonNullableType",
+		"TSJSDocUnknownType",
+		"TSUnionType",
+		"TSIntersectionType",
+		"TSConditionalType",
+		"TSInferType",
+		"TSTypeOperator",
+		"TSParenthesizedType",
+		"TSFunctionType",
+		"TSConstructorType",
+		"TSTypePredicate",
+		"TSTypeLiteral",
+		"TSMappedType"
+	]
+};
+/**
+* Every concrete node `type` in the AST. Drives the per-type guards in `is`.
+* The compile-time checks below keep it exhaustive: a node type added to or
+* removed from the parser fails to build until this list is brought in line.
+*/
+const NODE_TYPES = [
+	"Program",
+	"Hashbang",
+	"Identifier",
+	"PrivateIdentifier",
+	"Literal",
+	"TemplateElement",
+	"Super",
+	"ThisExpression",
+	"ArrayPattern",
+	"ObjectPattern",
+	"AssignmentPattern",
+	"RestElement",
+	"Property",
+	"SequenceExpression",
+	"ParenthesizedExpression",
+	"BinaryExpression",
+	"LogicalExpression",
+	"ConditionalExpression",
+	"UnaryExpression",
+	"UpdateExpression",
+	"AssignmentExpression",
+	"YieldExpression",
+	"AwaitExpression",
+	"ArrayExpression",
+	"ObjectExpression",
+	"SpreadElement",
+	"MemberExpression",
+	"CallExpression",
+	"ChainExpression",
+	"TaggedTemplateExpression",
+	"NewExpression",
+	"MetaProperty",
+	"ImportExpression",
+	"TemplateLiteral",
+	"ExpressionStatement",
+	"BlockStatement",
+	"IfStatement",
+	"SwitchStatement",
+	"SwitchCase",
+	"ForStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"WhileStatement",
+	"DoWhileStatement",
+	"BreakStatement",
+	"ContinueStatement",
+	"LabeledStatement",
+	"WithStatement",
+	"ReturnStatement",
+	"ThrowStatement",
+	"TryStatement",
+	"CatchClause",
+	"DebuggerStatement",
+	"EmptyStatement",
+	"VariableDeclaration",
+	"VariableDeclarator",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression",
+	"ArrowFunctionExpression",
+	"ClassDeclaration",
+	"ClassExpression",
+	"ClassBody",
+	"MethodDefinition",
+	"TSAbstractMethodDefinition",
+	"PropertyDefinition",
+	"TSAbstractPropertyDefinition",
+	"AccessorProperty",
+	"TSAbstractAccessorProperty",
+	"StaticBlock",
+	"Decorator",
+	"ImportDeclaration",
+	"ImportSpecifier",
+	"ImportDefaultSpecifier",
+	"ImportNamespaceSpecifier",
+	"ImportAttribute",
+	"ExportNamedDeclaration",
+	"ExportDefaultDeclaration",
+	"ExportAllDeclaration",
+	"ExportSpecifier",
+	"JSXElement",
+	"JSXOpeningElement",
+	"JSXClosingElement",
+	"JSXFragment",
+	"JSXOpeningFragment",
+	"JSXClosingFragment",
+	"JSXIdentifier",
+	"JSXNamespacedName",
+	"JSXMemberExpression",
+	"JSXAttribute",
+	"JSXSpreadAttribute",
+	"JSXExpressionContainer",
+	"JSXEmptyExpression",
+	"JSXText",
+	"JSXSpreadChild",
+	"TSTypeAnnotation",
+	"TSAnyKeyword",
+	"TSUnknownKeyword",
+	"TSNeverKeyword",
+	"TSVoidKeyword",
+	"TSNullKeyword",
+	"TSUndefinedKeyword",
+	"TSStringKeyword",
+	"TSNumberKeyword",
+	"TSBigIntKeyword",
+	"TSBooleanKeyword",
+	"TSSymbolKeyword",
+	"TSObjectKeyword",
+	"TSIntrinsicKeyword",
+	"TSThisType",
+	"TSTypeReference",
+	"TSQualifiedName",
+	"TSTypeQuery",
+	"TSImportType",
+	"TSTypeParameter",
+	"TSTypeParameterDeclaration",
+	"TSTypeParameterInstantiation",
+	"TSLiteralType",
+	"TSTemplateLiteralType",
+	"TSArrayType",
+	"TSIndexedAccessType",
+	"TSTupleType",
+	"TSNamedTupleMember",
+	"TSOptionalType",
+	"TSRestType",
+	"TSJSDocNullableType",
+	"TSJSDocNonNullableType",
+	"TSJSDocUnknownType",
+	"TSUnionType",
+	"TSIntersectionType",
+	"TSConditionalType",
+	"TSInferType",
+	"TSTypeOperator",
+	"TSParenthesizedType",
+	"TSFunctionType",
+	"TSConstructorType",
+	"TSTypePredicate",
+	"TSTypeLiteral",
+	"TSMappedType",
+	"TSPropertySignature",
+	"TSMethodSignature",
+	"TSCallSignatureDeclaration",
+	"TSConstructSignatureDeclaration",
+	"TSIndexSignature",
+	"TSTypeAliasDeclaration",
+	"TSInterfaceDeclaration",
+	"TSInterfaceBody",
+	"TSInterfaceHeritage",
+	"TSClassImplements",
+	"TSEnumDeclaration",
+	"TSEnumBody",
+	"TSEnumMember",
+	"TSModuleDeclaration",
+	"TSModuleBlock",
+	"TSParameterProperty",
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion",
+	"TSNonNullExpression",
+	"TSInstantiationExpression",
+	"TSExportAssignment",
+	"TSNamespaceExportDeclaration",
+	"TSImportEqualsDeclaration",
+	"TSExternalModuleReference"
+];
+function aliasGuard(name) {
+	const set = new Set(ALIAS_GROUPS[name]);
+	return (node) => node != null && set.has(node.type);
+}
+const is = {
+	...Object.fromEntries(NODE_TYPES.map((type) => [type, (node) => node != null && node.type === type])),
+	/** True when `node`'s `type` is one of `types`, narrowing to that union. */
+	oneOf: (node, types) => node != null && types.includes(node.type),
+	/** An `Identifier`, optionally with the exact `name` (e.g. `is.Identifier(node, "this")`). */
+	Identifier: (node, name) => node?.type === "Identifier" && (name === void 0 || node.name === name),
+	Expression: aliasGuard("Expression"),
+	Statement: aliasGuard("Statement"),
+	Declaration: aliasGuard("Declaration"),
+	ModuleDeclaration: aliasGuard("ModuleDeclaration"),
+	Function: aliasGuard("Function"),
+	Class: aliasGuard("Class"),
+	Method: aliasGuard("Method"),
+	Loop: aliasGuard("Loop"),
+	Pattern: aliasGuard("Pattern"),
+	JSX: aliasGuard("JSX"),
+	TSType: aliasGuard("TSType"),
+	StringLiteral: (node) => node?.type === "Literal" && typeof node.value === "string",
+	NumericLiteral: (node) => node?.type === "Literal" && typeof node.value === "number",
+	BooleanLiteral: (node) => node?.type === "Literal" && typeof node.value === "boolean",
+	NullLiteral: (node) => node?.type === "Literal" && node.raw === "null",
+	BigIntLiteral: (node) => node?.type === "Literal" && "bigint" in node,
+	RegExpLiteral: (node) => node?.type === "Literal" && "regex" in node,
+	ComputedMemberExpression: (node) => node?.type === "MemberExpression" && node.computed,
+	StaticMemberExpression: (node) => node?.type === "MemberExpression" && !node.computed && node.property.type === "Identifier",
+	PrivateFieldExpression: (node) => node?.type === "MemberExpression" && node.property.type === "PrivateIdentifier",
+	Directive: (node) => node?.type === "ExpressionStatement" && node.directive != null
+};
+//#endregion
+//#region ../../node_modules/.pnpm/yuku-ast@0.1.7/node_modules/yuku-ast/dist/identifier.mjs
+const IDENTIFIER_NAME = /^[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*$/u;
+/**
+* Returns `true` if `name` is a valid ECMAScript `IdentifierName`: the grammar
+* an identifier token must satisfy. Validates a raw string, not an AST node.
+*
+* @example
+* isIdentifierName("foo");     // true
+* isIdentifierName("$_0");     // true
+* isIdentifierName("π");       // true
+* isIdentifierName("class");   // true  - syntactically an IdentifierName
+* isIdentifierName("1foo");    // false - starts with a digit
+* isIdentifierName("foo-bar"); // false - `-` is not an identifier character
+* isIdentifierName("");        // false
+*/
+function isIdentifierName(name) {
+	return IDENTIFIER_NAME.test(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/yuku-ast@0.1.7/node_modules/yuku-ast/dist/utils.mjs
+/**
+* The static name a node denotes: an `Identifier`'s `name`, or a string
+* `Literal`'s `value`. Returns `null` for anything else, and for `null` or
+* `undefined`, so the common `Identifier | StringLiteral` name slots (a
+* `ModuleExportName`, or a static property or member key) read in one call.
+*
+* @example
+* nameOf(b.identifier("x")) // "x"
+* nameOf(b.stringLiteral("y")) // "y"
+* nameOf(b.numericLiteral(1)) // null
+*/
+function nameOf(node) {
+	if (node == null) return null;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	return null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/dts-resolver@3.0.0_oxc-resolver@11.21.3/node_modules/dts-resolver/dist/index.mjs
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+function createResolver({ tsconfig, cwd = process.cwd(), resolveNodeModules = false, ResolverFactory } = {}) {
+	ResolverFactory ||= __require("oxc-resolver").ResolverFactory;
+	const resolver = new ResolverFactory({
+		mainFields: [
+			"types",
+			"typings",
+			"module",
+			"main"
+		],
+		conditionNames: [
+			"types",
+			"typings",
+			"import",
+			"require"
+		],
+		extensions: [
+			".d.ts",
+			".d.mts",
+			".d.cts",
+			".ts",
+			".mts",
+			".cts",
+			".tsx",
+			".js",
+			".mjs",
+			".cjs",
+			".jsx"
+		],
+		extensionAlias: {
+			".js": [
+				".d.ts",
+				".ts",
+				".tsx",
+				".js",
+				".jsx"
+			],
+			".jsx": [
+				".d.ts",
+				".ts",
+				".tsx",
+				".jsx",
+				".js"
+			],
+			".mjs": [
+				".d.mts",
+				".mts",
+				".mjs"
+			],
+			".cjs": [
+				".d.cts",
+				".cts",
+				".cjs"
+			],
+			".ts": [
+				".d.ts",
+				".ts",
+				".tsx",
+				".js",
+				".jsx"
+			],
+			".tsx": [
+				".d.ts",
+				".tsx",
+				".ts",
+				".js",
+				".jsx"
+			],
+			".mts": [
+				".d.mts",
+				".mts",
+				".mjs"
+			],
+			".cts": [
+				".d.cts",
+				".cts",
+				".cjs"
+			]
+		},
+		modules: resolveNodeModules ? ["node_modules", "node_modules/@types"] : [],
+		tsconfig: tsconfig ? {
+			configFile: tsconfig,
+			references: "auto"
+		} : void 0
+	});
+	return (id, importer) => {
+		const directory = importer ? dirname(importer) : cwd;
+		const resolution = resolver.sync(directory, id);
+		if (!resolution.path) return null;
+		const resolved = resolution.path;
+		return ensureValue(resolved);
+	};
+}
+const ALLOW_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".cjs",
+	".mjs",
+	".jsx",
+	".ts",
+	".cts",
+	".mts",
+	".tsx",
+	".json",
+	".vue",
+	".svelte",
+	".astro"
+]);
+function ensureValue(value) {
+	return value && ALLOW_EXTENSIONS.has(extname(value)) ? value.replaceAll("\\", "/") : null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.27.9_@typescript+native-preview@7.0.0-dev.20260605.1_oxc-resolver_9f43f644337e3a4030148b21b794fdcf/node_modules/rolldown-plugin-dts/dist/index.mjs
+function createDtsInputPlugin({ sideEffects }) {
+	return {
+		name: "rolldown-plugin-dts:dts-input",
+		options: sideEffects === false ? (options) => {
+			return {
+				treeshake: options.treeshake === false ? false : {
+					...options.treeshake === true ? {} : options.treeshake,
+					moduleSideEffects: false
+				},
+				...options
+			};
+		} : void 0,
+		outputOptions(options) {
+			return {
+				...options,
+				entryFileNames(chunk) {
+					const { entryFileNames } = options;
+					if (entryFileNames) {
+						const nameTemplate = resolveTemplateFn(entryFileNames, chunk);
+						const renderedName = replaceTemplateName(nameTemplate, chunk.name);
+						if (RE_DTS.test(renderedName)) return nameTemplate;
+						const renderedNameWithD = replaceTemplateName(nameTemplate, `${chunk.name}.d`);
+						if (RE_DTS.test(renderedNameWithD)) return renderedNameWithD;
+					}
+					if (RE_DTS.test(chunk.name)) return chunk.name;
+					if (chunk.name.endsWith(".d")) return "[name].ts";
+					return "[name].d.ts";
+				}
+			};
+		}
+	};
+}
+function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
+	let declarationIdx = 0;
+	const declarationMap = /* @__PURE__ */ new Map();
+	const commentsMap = /* @__PURE__ */ new Map();
+	const moduleExportsMap = /* @__PURE__ */ new Map();
+	const warnedCjsDtsInputs = /* @__PURE__ */ new Set();
+	return {
+		name: "rolldown-plugin-dts:fake-js",
+		outputOptions(options) {
+			if (options.format === "cjs" || options.format === "commonjs") throw new Error("[rolldown-plugin-dts] Cannot bundle dts files with `cjs` format.");
+			const { chunkFileNames, entryFileNames } = options;
+			return {
+				...options,
+				sourcemap: options.sourcemap || sourcemap,
+				chunkFileNames(chunk) {
+					const nameTemplate = resolveTemplateFn(chunk.isEntry ? entryFileNames || "[name].js" : chunkFileNames || "[name]-[hash].js", chunk);
+					if (chunk.name.endsWith(".d")) {
+						const renderedNameWithoutD = filename_js_to_dts(replaceTemplateName(nameTemplate, chunk.name.slice(0, -2)));
+						if (RE_DTS.test(renderedNameWithoutD)) return renderedNameWithoutD;
+						const renderedName = filename_js_to_dts(replaceTemplateName(nameTemplate, chunk.name));
+						if (RE_DTS.test(renderedName)) return renderedName;
+					}
+					return nameTemplate;
+				}
+			};
+		},
+		transform: {
+			filter: { id: RE_DTS },
+			handler: transform
+		},
+		renderChunk,
+		generateBundle(options, bundle) {
+			for (const chunk of Object.values(bundle)) {
+				if (!RE_DTS_MAP.test(chunk.fileName)) continue;
+				if (sourcemap) {
+					if (chunk.type === "chunk" || typeof chunk.source !== "string") continue;
+					const map = JSON.parse(chunk.source);
+					map.sourcesContent = void 0;
+					chunk.source = JSON.stringify(map);
+				} else delete bundle[chunk.fileName];
+			}
+		}
+	};
+	async function transform(code, id) {
+		let file;
+		try {
+			file = parse$1(code, {
+				lang: "dts",
+				sourceType: "module",
+				attachComments: true
+			});
+		} catch (error) {
+			throw new Error(`Failed to parse ${id}. This may be caused by a syntax error in the declaration file or a bug in the plugin. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts\n${error}`, { cause: error });
+		}
+		const { program } = file;
+		moduleExportsMap.set(id, await collectModuleExports(this, program.body, id));
+		const identifierMap = Object.create(null);
+		if (!warnedCjsDtsInputs.has(id) && program.body.some(isCjsDtsInputSyntax)) {
+			warnedCjsDtsInputs.add(id);
+			this.warn(`${id} uses CommonJS dts syntax. ${RE_NODE_MODULES.test(id) ? `CommonJS dts modules cannot be bundled by rolldown-plugin-dts. Please mark this module as external in your Rolldown config.` : `rolldown-plugin-dts does not support bundling CommonJS dts input.`}`);
+		}
+		const directives = collectReferenceDirectives(file.comments);
+		if (directives.length) commentsMap.set(id, directives);
+		const appendStmts = [];
+		const namespaceStmts = /* @__PURE__ */ new Map();
+		for (const [i, stmt] of program.body.entries()) {
+			const setStmt = (stmt) => program.body[i] = stmt;
+			if (rewriteImportExport(stmt, setStmt)) continue;
+			const sideEffect = stmt.type === "TSModuleDeclaration" && stmt.kind !== "namespace";
+			if (sideEffect && stmt.type === "TSModuleDeclaration" && is.StringLiteral(stmt.id) && stmt.id.value[0] === ".") this.warn(`\`declare module ${JSON.stringify(stmt.id.value)}\` will be kept as-is in the output. Relative module declaration may cause unexpected issues. Found in ${id}.`);
+			if (sideEffect && id.endsWith(".vue.d.ts") && code.slice(stmt.start, stmt.end).includes("__VLS_")) continue;
+			const isDefaultExport = stmt.type === "ExportDefaultDeclaration";
+			const isExportDecl = is.oneOf(stmt, ["ExportNamedDeclaration", "ExportDefaultDeclaration"]) && !!stmt.declaration;
+			const decl = isExportDecl ? stmt.declaration : stmt;
+			const setDecl = isExportDecl ? (decl) => stmt.declaration = decl : setStmt;
+			if (decl.type !== "TSDeclareFunction" && !is.Declaration(decl)) continue;
+			if (is.oneOf(decl, [
+				"TSEnumDeclaration",
+				"ClassDeclaration",
+				"FunctionDeclaration",
+				"TSDeclareFunction",
+				"TSModuleDeclaration",
+				"VariableDeclaration"
+			])) decl.declare = true;
+			const bindings = [];
+			if (decl.type === "VariableDeclaration") bindings.push(...decl.declarations.map((decl) => decl.id));
+			else if ("id" in decl && decl.id) {
+				let binding = decl.id;
+				if (binding.type === "TSQualifiedName") binding = getIdFromTSEntityName(binding);
+				if (sideEffect) binding = b.identifier(`_${getIdentifierIndex(identifierMap, "")}`);
+				if (binding.type !== "Identifier") throw new Error(`Unexpected ${binding.type} declaration id`);
+				bindings.push(binding);
+			} else {
+				const binding = b.identifier("export_default");
+				bindings.push(binding);
+				decl.id = binding;
+			}
+			const params = collectParams(decl);
+			const childrenSet = /* @__PURE__ */ new Set();
+			const deps = await collectDependencies(this, decl, id, namespaceStmts, childrenSet, identifierMap);
+			const children = Array.from(childrenSet).filter((child) => bindings.every((b) => child !== b));
+			if (decl !== stmt) decl.comments = stmt.comments;
+			const declarationId = registerDeclaration({
+				decl,
+				deps,
+				bindings,
+				params,
+				children
+			});
+			const declarationIdNode = b.numericLiteral(declarationId);
+			const depsBody = b.arrayExpression(deps);
+			const depsNode = b.arrowFunctionExpression(params.map(({ name }) => b.identifier(name)), depsBody);
+			const childrenNode = b.arrayExpression(children.map((node) => {
+				const placeholder = b.stringLiteral("");
+				placeholder.start = node.start;
+				placeholder.end = node.end;
+				return placeholder;
+			}));
+			const sideEffectNode = sideEffect && b.callExpression(b.identifier("sideEffect"), [bindings[0]]);
+			const runtimeArrayNode = runtimeBindingArrayExpression([
+				declarationIdNode,
+				depsNode,
+				childrenNode,
+				...sideEffectNode ? [sideEffectNode] : []
+			]);
+			const runtimeAssignment = b.variableDeclaration("var", [b.variableDeclarator(b.arrayPattern(bindings.map((binding) => ({
+				...binding,
+				typeAnnotation: null
+			}))), runtimeArrayNode)]);
+			if (isDefaultExport) {
+				appendStmts.push(b.exportNamedDeclaration(null, [b.exportSpecifier(bindings[0], b.identifier("default"))]));
+				setStmt(runtimeAssignment);
+			} else setDecl(runtimeAssignment);
+		}
+		if (sideEffects) appendStmts.push(b.expressionStatement(b.callExpression(b.identifier("sideEffect"), [])));
+		program.body = [
+			...Array.from(namespaceStmts.values()).map(({ stmt }) => stmt),
+			...program.body,
+			...appendStmts
+		];
+		const result = print(program, {
+			comments: false,
+			...sourcemap && { sourceMaps: {
+				source: code,
+				sourceFileName: id
+			} }
+		});
+		return {
+			code: result.code,
+			map: result.map ?? null
+		};
+	}
+	function renderChunk(code, chunk) {
+		if (!RE_DTS.test(chunk.fileName)) return;
+		const exportInfo = collectChunkExportInfo(chunk, moduleExportsMap);
+		let file;
+		try {
+			file = parse$1(code, {
+				lang: "ts",
+				sourceType: "module",
+				attachComments: true
+			});
+		} catch (error) {
+			throw new Error(`Failed to parse generated code for chunk ${chunk.fileName}. This may be caused by a bug in the plugin. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts\n${error}`, { cause: error });
+		}
+		const { program } = file;
+		program.body = patchTsNamespace(program.body);
+		program.body = patchReExport(program.body);
+		program.body = program.body.map((node) => {
+			if (isHelperImport(node)) return null;
+			if (node.type === "ExpressionStatement") return null;
+			const newNode = patchImportExport(node, exportInfo, cjsDefault);
+			if (newNode || newNode === false) return newNode;
+			if (node.type !== "VariableDeclaration") return node;
+			if (!isRuntimeBindingVariableDeclaration(node)) return null;
+			const decl = node.declarations[0];
+			const [declarationIdNode, depsFn, children] = decl.init.elements;
+			const declarationId = declarationIdNode.value;
+			const declaration = getDeclaration(declarationId);
+			if (sourcemap) walk(declaration.decl, { enter(node) {
+				node.start = void 0;
+				node.end = void 0;
+			} });
+			for (const [i, id] of decl.id.elements.entries()) {
+				const transformedBinding = {
+					...id,
+					typeAnnotation: declaration.bindings[i].typeAnnotation
+				};
+				overwriteNode(declaration.bindings[i], transformedBinding);
+			}
+			if (sourcemap) for (const [i, child] of children.elements.entries()) Object.assign(declaration.children[i], {
+				start: child.start,
+				end: child.end
+			});
+			const transformedParams = depsFn.params;
+			for (const [i, transformedParam] of transformedParams.entries()) {
+				const transformedName = transformedParam.name;
+				for (const originalTypeParam of declaration.params[i].typeParams) originalTypeParam.name = transformedName;
+			}
+			const transformedDeps = depsFn.body.elements;
+			for (const [i, originalDep] of declaration.deps.entries()) {
+				let transformedDep = transformedDeps[i];
+				if (transformedDep.type === "UnaryExpression" && transformedDep.operator === "void") {
+					const undefinedDep = b.identifier("undefined");
+					undefinedDep.start = transformedDep.start;
+					undefinedDep.end = transformedDep.end;
+					transformedDep = undefinedDep;
+				} else if (isInfer(transformedDep)) transformedDep.name = "__Infer";
+				if (originalDep.replace) originalDep.replace(transformedDep);
+				else Object.assign(originalDep, transformedDep);
+			}
+			return inheritNodeComments(node, declaration.decl);
+		}).filter((node) => !!node);
+		if (program.body.length === 0) return {
+			code: "export { };",
+			map: null
+		};
+		const comments = /* @__PURE__ */ new Set();
+		const commentsValue = /* @__PURE__ */ new Set();
+		for (const id of chunk.moduleIds) {
+			const preserveComments = commentsMap.get(id);
+			if (preserveComments) {
+				preserveComments.forEach((c) => {
+					const id = c.type + c.value;
+					if (commentsValue.has(id)) return;
+					commentsValue.add(id);
+					comments.add(c);
+				});
+				commentsMap.delete(id);
+			}
+		}
+		if (comments.size) {
+			program.body[0].comments ||= [];
+			program.body[0].comments.unshift(...Array.from(comments, (c) => ({
+				type: c.type,
+				value: c.value,
+				position: "before",
+				sameLine: false
+			})));
+		}
+		const result = print(program, {
+			comments: true,
+			...sourcemap && { sourceMaps: {
+				source: code,
+				sourceFileName: chunk.fileName
+			} }
+		});
+		return {
+			code: result.code,
+			map: result.map ?? null
+		};
+	}
+	function registerDeclaration(info) {
+		const declarationId = declarationIdx++;
+		declarationMap.set(declarationId, info);
+		return declarationId;
+	}
+	function getDeclaration(declarationId) {
+		return declarationMap.get(declarationId);
+	}
+}
+async function collectModuleExports(context, nodes, id) {
+	const info = {
+		typeOnlyLocals: /* @__PURE__ */ new Set(),
+		exports: /* @__PURE__ */ new Map(),
+		reExports: [],
+		exportAlls: []
+	};
+	for (const node of nodes) collectTypeOnlyLocals(node, info.typeOnlyLocals);
+	for (const node of nodes) await collectExportInfo(context, node, id, info);
+	return info;
+}
+function collectTypeOnlyLocals(node, typeOnlyLocals) {
+	if (node.type !== "ImportDeclaration") return;
+	for (const specifier of node.specifiers) if (node.importKind === "type" || "importKind" in specifier && specifier.importKind === "type") typeOnlyLocals.add(specifier.local.name);
+}
+function collectDeclarationNames(node) {
+	if (node.type === "VariableDeclaration") return node.declarations.flatMap((decl) => collectPatternNames(decl.id));
+	if ("id" in node && node.id) {
+		if (node.id.type !== "Identifier" && node.id.type !== "TSQualifiedName") return [];
+		const id = getIdFromTSEntityName(node.id);
+		return id.type === "Identifier" ? [id.name] : [];
+	}
+	return [];
+}
+function collectPatternNames(node) {
+	if (!node) return [];
+	if (node.type === "Identifier") return [node.name];
+	if (node.type === "RestElement") return collectPatternNames(node.argument);
+	if (node.type === "AssignmentPattern") return collectPatternNames(node.left);
+	if (node.type === "ArrayPattern") return node.elements.flatMap((element) => collectPatternNames(element));
+	if (node.type === "ObjectPattern") return node.properties.flatMap((property) => {
+		if (property.type === "RestElement") return collectPatternNames(property.argument);
+		return collectPatternNames(property.value);
+	});
+	return [];
+}
+function isTypeOnlyExport(node, specifier) {
+	return node.exportKind === "type" || specifier.exportKind === "type";
+}
+async function collectExportInfo(context, node, id, info) {
+	if (node.type === "ExportNamedDeclaration") {
+		if (node.declaration) {
+			for (const name of collectDeclarationNames(node.declaration)) info.exports.set(name, false);
+			return;
+		}
+		const source = await resolveExportSource(context, node.source, id);
+		for (const specifier of node.specifiers) {
+			const typeOnly = isTypeOnlyExport(node, specifier);
+			const exported = nameOf(specifier.exported);
+			const local = nameOf(specifier.local);
+			if (source) info.reExports.push({
+				source,
+				local,
+				exported,
+				typeOnly
+			});
+			else info.exports.set(exported, typeOnly || info.typeOnlyLocals.has(local));
+		}
+		return;
+	}
+	if (node.type === "ExportDefaultDeclaration") {
+		info.exports.set("default", false);
+		return;
+	}
+	if (node.type === "ExportAllDeclaration") {
+		if (node.exported) {
+			info.exports.set(nameOf(node.exported), node.exportKind === "type");
+			return;
+		}
+		info.exportAlls.push({
+			source: await resolveExportSource(context, node.source, id),
+			rawSource: node.source.value,
+			typeOnly: node.exportKind === "type"
+		});
+	}
+}
+async function resolveExportSource(context, source, importer) {
+	if (!source) return;
+	const resolved = await context.resolve(source.value, importer);
+	if (!resolved || resolved.external) return;
+	return resolved.id;
+}
+function collectChunkExportInfo(chunk, moduleExportsMap) {
+	const exportsByModule = resolveAllModuleExports(moduleExportsMap);
+	const roots = chunk.facadeModuleId && moduleExportsMap.has(chunk.facadeModuleId) ? [chunk.facadeModuleId] : chunk.moduleIds;
+	const mergedExports = /* @__PURE__ */ new Map();
+	const typeOnlyExportAllSources = /* @__PURE__ */ new Set();
+	for (const root of roots) {
+		const exports = exportsByModule.get(root);
+		if (exports) for (const [name, typeOnly] of exports) setExportTypeOnly(mergedExports, name, typeOnly);
+		const moduleExports = moduleExportsMap.get(root);
+		if (!moduleExports) continue;
+		for (const exportAll of moduleExports.exportAlls) {
+			if (!exportAll.typeOnly || exportAll.source) continue;
+			typeOnlyExportAllSources.add(exportAll.rawSource);
+		}
+	}
+	const typeOnlyNames = /* @__PURE__ */ new Set();
+	for (const [name, typeOnly] of mergedExports) if (typeOnly) typeOnlyNames.add(name);
+	return {
+		typeOnlyNames,
+		typeOnlyExportAllSources
+	};
+}
+function resolveAllModuleExports(moduleExportsMap) {
+	const exportsByModule = /* @__PURE__ */ new Map();
+	for (const [id, info] of moduleExportsMap) exportsByModule.set(id, new Map(info.exports));
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const [id, info] of moduleExportsMap) {
+			const exports = exportsByModule.get(id);
+			for (const reExport of info.reExports) {
+				const sourceTypeOnly = (reExport.source ? exportsByModule.get(reExport.source) : void 0)?.get(reExport.local) ?? false;
+				if (setExportTypeOnly(exports, reExport.exported, reExport.typeOnly || sourceTypeOnly)) changed = true;
+			}
+			for (const exportAll of info.exportAlls) {
+				if (!exportAll.source) continue;
+				const sourceExports = exportsByModule.get(exportAll.source);
+				if (!sourceExports) continue;
+				for (const [name, typeOnly] of sourceExports) {
+					if (name === "default") continue;
+					if (setExportTypeOnly(exports, name, exportAll.typeOnly || typeOnly)) changed = true;
+				}
+			}
+		}
+	}
+	return exportsByModule;
+}
+function setExportTypeOnly(exports, name, typeOnly) {
+	const current = exports.get(name);
+	if (current === false || current === typeOnly) return false;
+	if (current === void 0 || !typeOnly) {
+		exports.set(name, typeOnly);
+		return true;
+	}
+	return false;
+}
+/**
+* Collects all TSTypeParameter nodes from the given node and groups them by
+* their name. One name can associate with one or more type parameters. These
+* names will be used as the parameter name in the generated JavaScript
+* dependency function.
+*/
+function collectParams(node) {
+	const typeParams = [];
+	walk(node, { leave(node) {
+		if ("typeParameters" in node && node.typeParameters?.type === "TSTypeParameterDeclaration") typeParams.push(...node.typeParameters.params.map(({ name }) => name));
+	} });
+	const paramMap = /* @__PURE__ */ new Map();
+	for (const typeParam of typeParams) {
+		const name = typeParam.name;
+		const group = paramMap.get(name);
+		if (group) group.push(typeParam);
+		else paramMap.set(name, [typeParam]);
+	}
+	return Array.from(paramMap.entries()).map(([name, typeParams]) => ({
+		name,
+		typeParams
+	}));
+}
+async function collectDependencies(context, node, importer, namespaceStmts, children, identifierMap) {
+	const deps = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const preserveImportTypeCache = /* @__PURE__ */ new Map();
+	const importSources = /* @__PURE__ */ new Set();
+	walk(node, { TSImportType(node) {
+		importSources.add(node.source.value);
+	} });
+	if (importSources.size) await Promise.all(Array.from(importSources, async (source) => {
+		const resolved = await context.resolve(source, importer);
+		preserveImportTypeCache.set(source, !resolved || !!resolved.external);
+	}));
+	const inferredStack = [];
+	let currentInferred = /* @__PURE__ */ new Set();
+	function isInferred(node) {
+		return node.type === "Identifier" && currentInferred.has(node.name);
+	}
+	walk(node, {
+		enter(node) {
+			if (node.type === "TSConditionalType") {
+				const inferred = collectInferredNames(node.extendsType);
+				inferredStack.push(inferred);
+			}
+		},
+		leave(node, path) {
+			const { parent } = path;
+			if (node.type === "TSConditionalType") inferredStack.pop();
+			else if (parent?.type === "TSConditionalType") {
+				const trueBranch = parent.trueType === node;
+				currentInferred = new Set((trueBranch ? inferredStack : inferredStack.slice(0, -1)).flat());
+			} else currentInferred = /* @__PURE__ */ new Set();
+			if (node.type === "ExportNamedDeclaration") {
+				for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") addDependency(specifier.local);
+			} else if (node.type === "TSInterfaceDeclaration" && node.extends) for (const heritage of node.extends || []) addDependency(heritage.expression);
+			else if (node.type === "ClassDeclaration") {
+				if (node.superClass) addDependency(node.superClass);
+				if (node.implements) for (const implement of node.implements) addDependency(implement.expression);
+			} else if (is.oneOf(node, [
+				"Property",
+				"PropertyDefinition",
+				"TSAbstractPropertyDefinition",
+				"MethodDefinition",
+				"TSAbstractMethodDefinition",
+				"TSPropertySignature",
+				"TSMethodSignature"
+			])) {
+				if (node.computed && isReferenceId(node.key)) addDependency(node.key);
+				if ("value" in node && isReferenceId(node.value)) addDependency(node.value);
+			} else switch (node.type) {
+				case "TSTypeReference":
+					addDependency(TSEntityNameToRuntime(node.typeName));
+					break;
+				case "TSTypeQuery":
+					if (seen.has(node.exprName)) return;
+					if (node.exprName.type === "TSImportType") break;
+					addDependency(TSEntityNameToRuntime(node.exprName));
+					break;
+				case "TSImportType": {
+					seen.add(node);
+					const { source, qualifier } = node;
+					const dep = importNamespace(node, qualifier, source, namespaceStmts, identifierMap, preserveImportTypeCache);
+					if (dep) addDependency(dep);
+					break;
+				}
+			}
+			if (parent && !deps.has(node) && isChildSymbol(node, parent)) children.add(node);
+		}
+	});
+	return Array.from(deps);
+	function addDependency(node) {
+		if (isThisExpression(node) || isInferred(node)) return;
+		deps.add(node);
+	}
+}
+function importNamespace(node, imported, source, namespaceStmts, identifierMap, preserveCache) {
+	if (preserveCache.get(source.value) ?? true) return;
+	const sourceText = source.value.replaceAll(/\W/g, "_");
+	const localName = `_$${isIdentifierName(source.value) ? source.value : `${sourceText}${getIdentifierIndex(identifierMap, sourceText)}`}`;
+	let local = b.identifier(localName);
+	if (namespaceStmts.has(source.value)) local = namespaceStmts.get(source.value).local;
+	else namespaceStmts.set(source.value, {
+		stmt: b.importDeclaration([b.importNamespaceSpecifier(local)], source),
+		local
+	});
+	if (imported) {
+		const importedLeft = getIdFromTSEntityName(imported);
+		if (imported.type === "ThisExpression" || importedLeft.type === "ThisExpression") throw new Error("Cannot import `this` from module.");
+		overwriteNode(importedLeft, b.tsQualifiedName(local, { ...importedLeft }));
+		local = imported;
+	}
+	let replacement = node;
+	if (node.typeArguments) {
+		overwriteNode(node, b.tsTypeReference(local, node.typeArguments));
+		replacement = local;
+	} else overwriteNode(node, local);
+	return {
+		...TSEntityNameToRuntime(local),
+		replace(newNode) {
+			overwriteNode(replacement, newNode);
+		}
+	};
+}
+function isChildSymbol(node, parent) {
+	if (node.type === "Identifier") return true;
+	if (is.oneOf(parent, ["TSPropertySignature", "TSMethodSignature"]) && parent.key === node) return true;
+	return false;
+}
+function collectInferredNames(node) {
+	const inferred = [];
+	walk(node, { enter(node) {
+		if (node.type === "TSInferType" && node.typeParameter) inferred.push(node.typeParameter.name.name);
+	} });
+	return inferred;
+}
+const REFERENCE_RE = /\/\s*<reference\s+(?:path|types)=/;
+function collectReferenceDirectives(comment, negative = false) {
+	return comment.filter((c) => REFERENCE_RE.test(c.value) !== negative);
+}
+const SOURCE_MAP_PRAGMA_RE = /^#\s*source(?:Mapping)?URL=/;
+function isSourceMapPragma(comment) {
+	return SOURCE_MAP_PRAGMA_RE.test(comment.value);
+}
+function isCjsDtsInputSyntax(node) {
+	return node.type === "TSExportAssignment" || node.type === "TSImportEqualsDeclaration" && node.moduleReference.type === "TSExternalModuleReference";
+}
+/**
+* Check if the given node is a {@link RuntimeBindingVariableDeclration}
+*/
+function isRuntimeBindingVariableDeclaration(node) {
+	return node?.type === "VariableDeclaration" && node.declarations.length === 1 && node.declarations[0].type === "VariableDeclarator" && node.declarations[0].id.type === "ArrayPattern" && isRuntimeBindingArrayExpression(node.declarations[0].init);
+}
+/**
+* Check if the given node is a {@link RuntimeBindingArrayExpression}
+*/
+function isRuntimeBindingArrayExpression(node) {
+	return node?.type === "ArrayExpression" && isRuntimeBindingArrayElements(node.elements);
+}
+/**
+* Check if the given array is a {@link RuntimeBindingArrayElements}
+*/
+function isRuntimeBindingArrayElements(elements) {
+	const [declarationId, deps, children, effect] = elements;
+	return is.NumericLiteral(declarationId) && deps?.type === "ArrowFunctionExpression" && children?.type === "ArrayExpression" && (!effect || effect.type === "CallExpression");
+}
+function runtimeBindingArrayExpression(elements) {
+	return b.arrayExpression([...elements]);
+}
+function isThisExpression(node) {
+	return is.Identifier(node, "this") || node.type === "ThisExpression" || node.type === "MemberExpression" && isThisExpression(node.object);
+}
+function isInfer(node) {
+	return is.Identifier(node, "infer");
+}
+function TSEntityNameToRuntime(node) {
+	if (node.type === "Identifier" || node.type === "ThisExpression") return node;
+	const left = TSEntityNameToRuntime(node.left);
+	return Object.assign(node, {
+		type: "MemberExpression",
+		object: left,
+		property: node.right,
+		computed: false
+	});
+}
+function getIdFromTSEntityName(node) {
+	if (node.type === "Identifier" || node.type === "ThisExpression") return node;
+	return getIdFromTSEntityName(node.left);
+}
+function isReferenceId(node) {
+	return is.oneOf(node, ["Identifier", "MemberExpression"]);
+}
+function isHelperImport(node) {
+	return node.type === "ImportDeclaration" && node.specifiers.length && node.specifiers.every((spec) => spec.type === "ImportSpecifier" && spec.imported.type === "Identifier" && ["__exportAll", "__reExport"].includes(spec.local.name));
+}
+/**
+* patch `.d.ts` suffix in import source to `.js`
+*/
+function patchImportExport(node, exportInfo, cjsDefault) {
+	if (node.type === "ExportNamedDeclaration" && !node.declaration && !node.source && !node.specifiers.length && !node.attributes?.length) return false;
+	if (node.type === "ImportDeclaration" && node.specifiers.length) {
+		for (const specifier of node.specifiers) if (isInfer(specifier.local)) specifier.local.name = "__Infer";
+	}
+	if (is.oneOf(node, [
+		"ImportDeclaration",
+		"ExportAllDeclaration",
+		"ExportNamedDeclaration"
+	])) {
+		if (node.type === "ExportAllDeclaration" && node.source && exportInfo.typeOnlyExportAllSources.has(node.source.value)) node.exportKind = "type";
+		if (node.type === "ExportNamedDeclaration" && exportInfo.typeOnlyNames.size) {
+			for (const spec of node.specifiers) {
+				const name = nameOf(spec.exported);
+				if (exportInfo.typeOnlyNames.has(name)) if (spec.type === "ExportSpecifier") spec.exportKind = "type";
+				else node.exportKind = "type";
+			}
+			normalizeTypeOnlyExport(node);
+		}
+		if (node.source?.value && RE_DTS.test(node.source.value)) {
+			node.source.value = filename_dts_to(node.source.value, "js");
+			return node;
+		}
+		if (cjsDefault && node.type === "ExportNamedDeclaration" && !node.source && node.specifiers.length === 1 && node.specifiers[0].type === "ExportSpecifier" && nameOf(node.specifiers[0].exported) === "default") {
+			const defaultExport = node.specifiers[0];
+			return b.tsExportAssignment(defaultExport.local);
+		}
+	}
+}
+function normalizeTypeOnlyExport(node) {
+	if (node.declaration || !node.specifiers.length) return;
+	for (const specifier of node.specifiers) if (specifier.type !== "ExportSpecifier" || specifier.exportKind !== "type") return;
+	node.exportKind = "type";
+	for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
+}
+/**
+* Handle `__exportAll` call
+*/
+function patchTsNamespace(nodes) {
+	const removed = /* @__PURE__ */ new Set();
+	for (const [i, node] of nodes.entries()) {
+		const result = getExportAllNamespace(node);
+		if (!result) continue;
+		const [binding, exports] = result;
+		if (!exports.properties.length) continue;
+		const namespaceExport = b.exportNamedDeclaration(null, exports.properties.filter((property) => property.type === "Property").map((property) => {
+			const local = property.value.body;
+			const exported = property.key;
+			return b.exportSpecifier(local, exported);
+		}));
+		nodes[i] = b.tsModuleDeclaration(binding, b.tsModuleBlock([namespaceExport]), {
+			kind: "namespace",
+			declare: true
+		});
+	}
+	return nodes.filter((node) => !removed.has(node));
+}
+function getExportAllNamespace(node) {
+	if (node.type !== "VariableDeclaration" || node.declarations.length !== 1 || node.declarations[0].id.type !== "Identifier" || node.declarations[0].init?.type !== "CallExpression" || node.declarations[0].init.callee.type !== "Identifier" || node.declarations[0].init.callee.name !== "__exportAll" || node.declarations[0].init.arguments.length !== 1 || node.declarations[0].init.arguments[0].type !== "ObjectExpression") return false;
+	return [node.declarations[0].id, node.declarations[0].init.arguments[0]];
+}
+/**
+* Handle `__reExport` call
+*/
+function patchReExport(nodes) {
+	const exportsNames = /* @__PURE__ */ new Map();
+	for (const [i, node] of nodes.entries()) if (node.type === "ImportDeclaration" && node.specifiers.length === 1 && node.specifiers[0].type === "ImportSpecifier" && node.specifiers[0].local.type === "Identifier" && node.specifiers[0].local.name.endsWith("_exports")) exportsNames.set(node.specifiers[0].local.name, node.specifiers[0].local.name);
+	else if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && is.Identifier(node.expression.callee, "__reExport")) {
+		const args = node.expression.arguments;
+		exportsNames.set(args[0].name, args[1].name);
+	} else if (node.type === "VariableDeclaration" && node.declarations.length === 1 && node.declarations[0].init?.type === "MemberExpression" && node.declarations[0].init.object.type === "Identifier" && exportsNames.has(node.declarations[0].init.object.name)) nodes[i] = b.tsTypeAliasDeclaration(b.identifier(node.declarations[0].id.name), b.tsTypeReference(b.tsQualifiedName(b.identifier(exportsNames.get(node.declarations[0].init.object.name)), b.identifier(node.declarations[0].init.property.name))));
+	else if (node.type === "ExportNamedDeclaration" && node.specifiers.length === 1 && node.specifiers[0].type === "ExportSpecifier" && node.specifiers[0].local.type === "Identifier" && exportsNames.has(node.specifiers[0].local.name)) node.specifiers[0].local.name = exportsNames.get(node.specifiers[0].local.name);
+	return nodes;
+}
+function rewriteImportExport(node, set) {
+	if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" && !node.declaration) {
+		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier") specifier.importKind = "value";
+		else if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
+		if (node.type === "ImportDeclaration") node.importKind = "value";
+		else if (node.type === "ExportNamedDeclaration") node.exportKind = "value";
+		return true;
+	} else if (node.type === "ExportAllDeclaration") {
+		node.exportKind = "value";
+		return true;
+	} else if (node.type === "TSImportEqualsDeclaration") {
+		if (node.moduleReference.type === "TSExternalModuleReference") set(b.importDeclaration([b.importDefaultSpecifier(node.id)], node.moduleReference.expression));
+		return true;
+	} else if (node.type === "TSExportAssignment" && node.expression.type === "Identifier") {
+		set(b.exportNamedDeclaration(null, [b.exportSpecifier(node.expression, b.identifier("default"))]));
+		return true;
+	} else if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "Identifier") {
+		set(b.exportNamedDeclaration(null, [b.exportSpecifier(node.declaration, b.identifier("default"))]));
+		return true;
+	}
+	return false;
+}
+function overwriteNode(node, newNode) {
+	for (const key of Object.keys(node)) Reflect.deleteProperty(node, key);
+	Object.assign(node, newNode);
+	return node;
+}
+function inheritNodeComments(oldNode, newNode) {
+	newNode.comments ||= [];
+	const pragmas = oldNode.comments?.filter((comment) => comment.position === "before" && comment.value.startsWith("#") && !isSourceMapPragma(comment));
+	if (pragmas) newNode.comments.unshift(...pragmas);
+	newNode.comments = newNode.comments.filter((comment) => !REFERENCE_RE.test(comment.value) && !isSourceMapPragma(comment));
+	return newNode;
+}
+function getIdentifierIndex(identifierMap, name) {
+	if (name in identifierMap) return ++identifierMap[name];
+	return identifierMap[name] = 0;
+}
+const require$1 = createRequire(import.meta.url);
+const debug$4 = createDebug("rolldown-plugin-dts:tsgo");
+function isTS70Installed() {
+	try {
+		const { versionMajorMinor } = require$1("typescript");
+		return versionMajorMinor === "7.0";
+	} catch {}
+	return false;
+}
+const spawnAsync = (...args) => new Promise((resolve, reject) => {
+	const child = spawn(...args);
+	child.on("close", () => resolve());
+	child.on("error", (error) => reject(error));
+});
+let tsgoPathCache;
+async function getTsgoPathFromNodeModules(logger) {
+	if (tsgoPathCache) return tsgoPathCache;
+	const pkgName = isTS70Installed() ? "typescript" : "@typescript/native-preview";
+	const tsgoPkg = import.meta.resolve(`${pkgName}/package.json`);
+	const { default: { version } } = await import(tsgoPkg, { with: { type: "json" } });
+	logger.info(`Emit types with ${styleText("underline", `${pkgName}@${version}`)}`);
+	const { default: getExePath } = await import(new URL("lib/getExePath.js", tsgoPkg).href);
+	return tsgoPathCache = getExePath();
+}
+async function runTsgo(logger, rootDir, tsconfig, sourcemap, tsgoPath) {
+	debug$4("[tsgo] rootDir", rootDir);
+	let tsgo;
+	if (tsgoPath) {
+		tsgo = tsgoPath;
+		debug$4("[tsgo] using custom path", tsgo);
+	} else {
+		tsgo = await getTsgoPathFromNodeModules(logger);
+		debug$4("[tsgo] using tsgo from node_modules", tsgo);
+	}
+	const tsgoDist = await mkdtemp(path.join(tmpdir(), "rolldown-plugin-dts-"));
+	debug$4("[tsgo] tsgoDist", tsgoDist);
+	const args = [
+		"--noEmit",
+		"false",
+		"--declaration",
+		"--emitDeclarationOnly",
+		"-p",
+		tsconfig,
+		"--outDir",
+		tsgoDist,
+		"--rootDir",
+		rootDir,
+		"--noCheck",
+		...sourcemap ? ["--declarationMap"] : []
+	];
+	debug$4("[tsgo] args %o", args);
+	await spawnAsync(tsgo, args, { stdio: "inherit" });
+	return {
+		path: tsgoDist,
+		async dispose() {
+			if (debug$4.enabled) debug$4("[tsgo] skip cleanup of tsgoDist", tsgoDist);
+			else {
+				debug$4("[tsgo] disposing tsgoDist", tsgoDist);
+				await rm(tsgoDist, {
+					recursive: true,
+					force: true
+				}).catch(() => {});
+			}
+		}
+	};
+}
+const debug$3 = createDebug("rolldown-plugin-dts:generate");
+const WORKER_URL = "./tsc-worker.mjs";
+function createGeneratePlugin({ generator, entry, tsconfig, tsconfigRaw, build, incremental, cwd, oxc, emitDtsOnly, vue, tsMacro, parallel, eager, tsgo, newContext, emitJs, sourcemap, logger }) {
+	const entryIncludes = entry?.filter((p) => p[0] !== "!");
+	const entryIgnores = entry?.filter((p) => p[0] === "!").map((p) => p.slice(1));
+	const entryMatcher = entry ? (file) => entryIncludes.some((p) => path.matchesGlob(file, p)) && !entryIgnores.some((p) => path.matchesGlob(file, p)) : void 0;
+	const dtsMap = /* @__PURE__ */ new Map();
+	/**
+	* A map of input id to output file name
+	*
+	* @example
+	*
+	* inputAlias = new Map([
+	*   ['/absolute/path/to/src/source_file.ts', 'dist/foo/index'],
+	* ])
+	*/
+	const inputAliasMap = /* @__PURE__ */ new Map();
+	let tscWorker;
+	let tscModule;
+	let tscContext;
+	let tsgoContext;
+	const rootDir = tsconfig ? path.dirname(tsconfig) : cwd;
+	return {
+		name: "rolldown-plugin-dts:generate",
+		async buildStart(options) {
+			if (generator === "tsgo") tsgoContext = await runTsgo(logger, rootDir, tsconfig, sourcemap, tsgo.path);
+			else if (generator === "tsc") if (parallel) tscWorker = createTscWorker();
+			else {
+				tscModule = await import("./tsc-CilQvmj4.js");
+				if (newContext) tscContext = createContext();
+			}
+			if (!Array.isArray(options.input)) for (const [name, id] of Object.entries(options.input)) {
+				debug$3("resolving input alias %s -> %s", name, id);
+				let resolved = await this.resolve(id);
+				if (!id.startsWith("./")) resolved ||= await this.resolve(`./${id}`);
+				const resolvedId = resolved?.id || id;
+				debug$3("resolved input alias %s -> %s", id, resolvedId);
+				inputAliasMap.set(resolvedId, name);
+			}
+		},
+		outputOptions(options) {
+			return {
+				...options,
+				entryFileNames(chunk) {
+					const { entryFileNames } = options;
+					const nameTemplate = resolveTemplateFn(entryFileNames || "[name].js", chunk);
+					if (chunk.name.endsWith(".d")) {
+						if (RE_DTS.test(nameTemplate)) return replaceTemplateName(nameTemplate, chunk.name.slice(0, -2));
+						if (RE_JS.test(nameTemplate)) return nameTemplate.replace(RE_JS, ".$1ts");
+					}
+					return nameTemplate;
+				}
+			};
+		},
+		resolveId(id) {
+			if (dtsMap.has(id)) {
+				debug$3("resolve dts id %s", id);
+				return { id };
+			}
+		},
+		transform: {
+			order: "pre",
+			filter: { id: {
+				include: [
+					RE_JS,
+					RE_TS,
+					RE_VUE,
+					RE_JSON
+				],
+				exclude: [
+					RE_DTS,
+					RE_NODE_MODULES,
+					RE_ROLLDOWN_RUNTIME
+				]
+			} },
+			handler(code, id) {
+				const jsFile = RE_JS.test(id);
+				if (!jsFile || emitJs) {
+					const mod = this.getModuleInfo(id);
+					const isEntry = entryMatcher ? entryMatcher(path.relative(cwd, id)) : !!mod?.isEntry;
+					const dtsId = filename_to_dts(id);
+					dtsMap.set(dtsId, {
+						code,
+						id,
+						isEntry,
+						jsFile
+					});
+					debug$3("register dts source: %s", id);
+					if (isEntry) {
+						const name = inputAliasMap.get(id);
+						this.emitFile({
+							type: "chunk",
+							id: dtsId,
+							name: name ? `${name}.d` : void 0
+						});
+					}
+				}
+				if (emitDtsOnly) {
+					if (RE_JSON.test(id)) return "{}";
+					return "export { }";
+				}
+			}
+		},
+		load: {
+			filter: { id: {
+				include: [RE_DTS],
+				exclude: [RE_NODE_MODULES]
+			} },
+			async handler(dtsId) {
+				const module = dtsMap.get(dtsId);
+				if (!module) return;
+				const { code, id, jsFile } = module;
+				if (jsFile && await access(dtsId).then(() => true).catch(() => false)) {
+					debug$3("dts file already exists for %s, skipping generation", id);
+					return;
+				}
+				let dtsCode;
+				let map;
+				debug$3("generate dts %s from %s", dtsId, id);
+				if (generator === "tsgo") {
+					if (RE_VUE.test(id)) throw new Error("tsgo does not support Vue files.");
+					const dtsPath = path.resolve(tsgoContext.path, path.relative(path.resolve(rootDir), filename_to_dts(id)));
+					if (!existsSync(dtsPath)) {
+						debug$3("[tsgo]", dtsPath, "is missing");
+						throw new Error(`tsgo did not generate dts file for ${id}, please check your tsconfig.`);
+					}
+					dtsCode = await readFile(dtsPath, "utf8");
+					const mapPath = `${dtsPath}.map`;
+					if (existsSync(mapPath)) {
+						const mapRaw = await readFile(mapPath, "utf8");
+						map = {
+							...JSON.parse(mapRaw),
+							sources: [id]
+						};
+					}
+				} else if (generator === "oxc" && !RE_VUE.test(id)) {
+					const result = isolatedDeclarationSync(id, code, oxc);
+					if (result.errors.length) {
+						const [error] = result.errors;
+						return this.error({
+							message: error.message,
+							frame: error.codeframe || void 0
+						});
+					}
+					dtsCode = result.code;
+					if (result.map) {
+						map = result.map;
+						map.sourcesContent = void 0;
+					}
+				} else {
+					const options = {
+						tsconfig,
+						tsconfigRaw,
+						build,
+						incremental,
+						cwd,
+						entries: eager ? void 0 : Array.from(dtsMap.values()).filter((v) => v.isEntry).map((v) => v.id),
+						id,
+						sourcemap,
+						vue,
+						tsMacro,
+						context: tscContext
+					};
+					let result;
+					if (parallel) result = await tscWorker.emit(options);
+					else result = tscModule.tscEmit(options);
+					if (result.error) return this.error(result.error);
+					dtsCode = result.code;
+					map = result.map;
+					if (dtsCode && RE_JSON.test(id)) if (dtsCode.includes("declare const _exports")) {
+						if (dtsCode.includes("declare const _exports: {") && !dtsCode.includes("\n}[];")) {
+							const exports = collectJsonExports(dtsCode);
+							let i = 0;
+							dtsCode += exports.map((e) => {
+								const valid = `_${e.replaceAll(/[^\w$]/g, "_")}${i++}`;
+								const jsonKey = JSON.stringify(e);
+								return `declare let ${valid}: typeof _exports[${jsonKey}]\nexport { ${valid} as ${jsonKey} }`;
+							}).join("\n");
+						}
+					} else {
+						const exportMap = collectJsonExportMap(dtsCode);
+						dtsCode += `
+declare namespace __json_default_export {
+  export { ${Array.from(exportMap.entries()).map(([exported, local]) => exported === local ? exported : `${local} as ${exported}`).join(", ")} }
+}
+export { __json_default_export as default }`;
+					}
+				}
+				return {
+					code: dtsCode || "",
+					map
+				};
+			}
+		},
+		generateBundle: emitDtsOnly ? (options, bundle) => {
+			for (const fileName of Object.keys(bundle)) if (bundle[fileName].type === "chunk" && !RE_DTS.test(fileName) && !RE_DTS_MAP.test(fileName)) delete bundle[fileName];
+		} : void 0,
+		async buildEnd() {
+			tscWorker?.kill();
+			tscWorker = void 0;
+			await tsgoContext?.dispose();
+			tsgoContext = void 0;
+			if (newContext) tscContext = void 0;
+		},
+		watchChange(id) {
+			if (tscModule) invalidateContextFile(tscContext || globalContext, id);
+		}
+	};
+}
+function createTscWorker() {
+	const childProcess = fork(new URL(WORKER_URL, import.meta.url), {
+		stdio: "inherit",
+		serialization: "advanced"
+	});
+	const pending = /* @__PURE__ */ new Map();
+	let nextId = 0;
+	childProcess.on("message", (response) => {
+		const handler = pending.get(response.id);
+		if (!handler) return;
+		pending.delete(response.id);
+		if (response.error) handler.reject(response.error);
+		else handler.resolve(response.result);
+	});
+	childProcess.on("exit", (code) => {
+		for (const handler of pending.values()) handler.reject(/* @__PURE__ */ new Error(`tsc worker exited with code ${code}`));
+		pending.clear();
+	});
+	return {
+		emit: (options) => new Promise((resolve, reject) => {
+			const id = nextId++;
+			pending.set(id, {
+				resolve,
+				reject
+			});
+			childProcess.send({
+				id,
+				options
+			});
+		}),
+		kill: () => childProcess.kill()
+	};
+}
+function collectJsonExportMap(code) {
+	const exportMap = /* @__PURE__ */ new Map();
+	const { program } = parse$1(code, {
+		sourceType: "module",
+		lang: "dts"
+	});
+	for (const decl of program.body) if (decl.type === "ExportNamedDeclaration") {
+		if (decl.declaration) {
+			if (decl.declaration.type === "VariableDeclaration") {
+				for (const vdecl of decl.declaration.declarations) if (vdecl.id.type === "Identifier") exportMap.set(vdecl.id.name, vdecl.id.name);
+			} else if (decl.declaration.type === "TSModuleDeclaration" && decl.declaration.id.type === "Identifier") exportMap.set(decl.declaration.id.name, decl.declaration.id.name);
+		} else if (decl.specifiers.length) {
+			for (const spec of decl.specifiers) if (spec.type === "ExportSpecifier" && spec.exported.type === "Identifier") exportMap.set(spec.exported.name, spec.local.type === "Identifier" ? spec.local.name : spec.exported.name);
+		}
+	}
+	return exportMap;
+}
+/** `declare const _exports` mode */
+function collectJsonExports(code) {
+	const exports = [];
+	const { program } = parse$1(code, {
+		sourceType: "module",
+		lang: "dts"
+	});
+	const members = program.body[0].declarations[0].id.typeAnnotation.typeAnnotation.members;
+	for (const member of members) if (member.key.type === "Identifier") exports.push(member.key.name);
+	else if (is.StringLiteral(member.key)) exports.push(member.key.value);
+	return exports;
+}
+const debug$2 = createDebug("rolldown-plugin-dts:options");
+let warnedTsgo = false;
+function resolveOptions({ generator, entry, cwd = process.cwd(), dtsInput = false, emitDtsOnly = false, tsconfig, tsconfigRaw: overriddenTsconfigRaw = {}, compilerOptions = {}, sourcemap, resolver = "oxc", cjsDefault = false, sideEffects = false, logger = console, build = false, incremental = false, vue = false, tsMacro = false, parallel = false, eager = false, newContext = false, emitJs, oxc, tsgo }) {
+	let resolvedTsconfig;
+	if (tsconfig === true || tsconfig == null) {
+		const { config, path } = at(cwd) || {};
+		tsconfig = path;
+		resolvedTsconfig = config;
+	} else if (typeof tsconfig === "string") {
+		tsconfig = path.resolve(cwd || process.cwd(), tsconfig);
+		resolvedTsconfig = ee(tsconfig).config;
+	} else tsconfig = void 0;
+	compilerOptions = {
+		...resolvedTsconfig?.compilerOptions,
+		...compilerOptions
+	};
+	incremental ||= compilerOptions.incremental || !!compilerOptions.tsBuildInfoFile;
+	sourcemap ??= !!compilerOptions.declarationMap;
+	compilerOptions.declarationMap = sourcemap;
+	const tsconfigRaw = {
+		...resolvedTsconfig,
+		...overriddenTsconfigRaw,
+		compilerOptions
+	};
+	if (vue || tsMacro) {
+		if (isTS70Installed()) throw new Error("TypeScript 7.0 does not yet have a stable API and is experimental. The `vue` and `tsMacro` options are not yet supported with TypeScript 7.0.");
+		if (generator && generator !== "tsc") logger.warn("The `vue` and `tsMacro` options are enabled, which requires the `tsc` generator. The `generator` option is ignored.");
+		generator = "tsc";
+	}
+	if (!generator) if (tsgo) generator = "tsgo";
+	else if (oxc || compilerOptions?.isolatedDeclarations) generator = "oxc";
+	else if (isTS70Installed()) generator = "tsgo";
+	else generator = "tsc";
+	if (generator === "tsc") try {
+		__require$1.resolve("typescript");
+	} catch {
+		throw new Error("TypeScript is not installed. You can install `typescript` package, or enable `isolatedDeclarations` in your `tsconfig.json` to use Oxc instead.");
+	}
+	else if (generator === "tsgo") {
+		if (!tsconfig) throw new Error("tsgo generator requires a tsconfig file to be specified.");
+		if (!warnedTsgo) {
+			warnedTsgo = true;
+			logger.warn("TypeScript 7.0 does not yet have a stable API and is experimental. Some options will be unavailable.");
+		}
+	}
+	if (oxc === true || !oxc) oxc = {};
+	if (oxc) {
+		oxc.stripInternal ??= !!compilerOptions?.stripInternal;
+		oxc.sourcemap = !!compilerOptions.declarationMap;
+	}
+	if (tsgo === true || !tsgo) tsgo = {};
+	emitJs ??= !!(compilerOptions.checkJs || compilerOptions.allowJs);
+	const resolved = {
+		generator,
+		entry: entry ? Array.isArray(entry) ? entry : [entry] : void 0,
+		cwd,
+		dtsInput,
+		emitDtsOnly,
+		tsconfig,
+		tsconfigRaw,
+		sourcemap,
+		resolver,
+		cjsDefault,
+		sideEffects,
+		build,
+		incremental,
+		vue,
+		tsMacro,
+		parallel,
+		eager,
+		newContext,
+		emitJs,
+		oxc,
+		tsgo,
+		logger
+	};
+	debug$2("Resolved Options: %O", resolved);
+	return resolved;
+}
+const debug$1 = createDebug("rolldown-plugin-dts:resolver");
+function isSourceFile(id) {
+	return RE_TS.test(id) || RE_VUE.test(id) || RE_JSON.test(id);
+}
+function createDtsResolvePlugin({ cwd, tsconfig, tsconfigRaw, resolver, sideEffects }) {
+	const baseDtsResolver = createResolver({
+		tsconfig,
+		resolveNodeModules: true,
+		ResolverFactory
+	});
+	const moduleSideEffects = sideEffects ? true : null;
+	return {
+		name: "rolldown-plugin-dts:resolver",
+		resolveId: {
+			order: "pre",
+			filter: [include(importerId(RE_DTS))],
+			async handler(id, importer, options) {
+				if (!importer) return;
+				const external = {
+					id,
+					external: true,
+					moduleSideEffects: sideEffects
+				};
+				const rolldownResolution = await this.resolve(id, importer, options);
+				debug$1("Rolldown resolution for dts import %O from %O: %O", id, importer, rolldownResolution);
+				if (rolldownResolution?.external) {
+					debug$1("Rolldown marked dts import as external:", id);
+					return rolldownResolution;
+				}
+				const dtsResolution = await resolveDtsPath(id, importer, rolldownResolution);
+				debug$1("Dts resolution for dts import %O from %O: %O", id, importer, dtsResolution);
+				if (!dtsResolution) {
+					if (RE_CSS.test(id)) {
+						debug$1("Externalizing css import:", id);
+						return external;
+					}
+					debug$1("Unresolvable dts import:", id, "from", importer);
+					return isFilePath(id) ? null : external;
+				}
+				if (RE_DTS.test(dtsResolution)) {
+					debug$1("Resolving dts import to declaration file:", id);
+					return {
+						id: dtsResolution,
+						moduleSideEffects
+					};
+				}
+				if (isSourceFile(dtsResolution)) {
+					debug$1("Resolving dts import to source file:", id);
+					await this.load({ id: dtsResolution });
+					return {
+						id: filename_to_dts(dtsResolution),
+						moduleSideEffects
+					};
+				}
+			}
+		}
+	};
+	async function resolveDtsPath(id, importer, rolldownResolution) {
+		let dtsPath;
+		if (resolver === "tsc") {
+			const { tscResolve } = await import("./resolver-DtsKFXi2-B8Z3WwZh.js");
+			dtsPath = tscResolve(id, importer, cwd, tsconfig, tsconfigRaw);
+		} else dtsPath = baseDtsResolver(id, importer);
+		debug$1("Using %s for dts import: %O -> %O", resolver, id, dtsPath);
+		if (dtsPath) dtsPath = path.normalize(dtsPath);
+		if (!dtsPath || !isSourceFile(dtsPath)) {
+			if (rolldownResolution && isFilePath(rolldownResolution.id) && isSourceFile(rolldownResolution.id) && !rolldownResolution.external) return rolldownResolution.id;
+			return null;
+		}
+		return dtsPath;
+	}
+}
+function isFilePath(id) {
+	return id.startsWith(".") || path.isAbsolute(id);
+}
+const debug = createDebug("rolldown-plugin-dts:options");
+function dts(options = {}) {
+	debug("resolving dts options");
+	const resolved = resolveOptions(options);
+	debug("resolved dts options %o", resolved);
+	const plugins = [];
+	if (options.dtsInput) plugins.push(createDtsInputPlugin(resolved));
+	else plugins.push(createGeneratePlugin(resolved));
+	plugins.push(createDtsResolvePlugin(resolved), createFakeJsPlugin(resolved));
+	return plugins;
+}
+//#endregion
+export { dts };