yuku-ast 0.0.3

package/dist/index.mjs

@@ -0,0 +1,2306 @@
+//#region src/aliases.ts
+/**
+* Node types grouped under a shared alias. A visitor registered under an alias
+* name runs for every member type. Membership is by node `type`.
+*/
+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"
+	]
+};
+//#endregion
+//#region src/visitor-keys.ts
+/**
+* Child fields of each node type, in traversal order. Names are validated
+* against the AST types, so a renamed, removed, or added field fails to compile.
+*/
+const VISITOR_KEYS = {
+	Program: ["hashbang", "body"],
+	Hashbang: [],
+	Identifier: ["decorators", "typeAnnotation"],
+	PrivateIdentifier: [],
+	Literal: [],
+	TemplateElement: [],
+	Super: [],
+	ThisExpression: [],
+	ArrayPattern: [
+		"decorators",
+		"elements",
+		"typeAnnotation"
+	],
+	ObjectPattern: [
+		"decorators",
+		"properties",
+		"typeAnnotation"
+	],
+	AssignmentPattern: [
+		"decorators",
+		"left",
+		"right",
+		"typeAnnotation"
+	],
+	RestElement: [
+		"decorators",
+		"argument",
+		"typeAnnotation"
+	],
+	Property: ["key", "value"],
+	SequenceExpression: ["expressions"],
+	ParenthesizedExpression: ["expression"],
+	BinaryExpression: ["left", "right"],
+	LogicalExpression: ["left", "right"],
+	ConditionalExpression: [
+		"test",
+		"consequent",
+		"alternate"
+	],
+	UnaryExpression: ["argument"],
+	UpdateExpression: ["argument"],
+	AssignmentExpression: ["left", "right"],
+	YieldExpression: ["argument"],
+	AwaitExpression: ["argument"],
+	ArrayExpression: ["elements"],
+	ObjectExpression: ["properties"],
+	SpreadElement: ["argument"],
+	MemberExpression: ["object", "property"],
+	CallExpression: [
+		"callee",
+		"typeArguments",
+		"arguments"
+	],
+	ChainExpression: ["expression"],
+	TaggedTemplateExpression: [
+		"tag",
+		"typeArguments",
+		"quasi"
+	],
+	NewExpression: [
+		"callee",
+		"typeArguments",
+		"arguments"
+	],
+	MetaProperty: ["meta", "property"],
+	ImportExpression: ["source", "options"],
+	TemplateLiteral: ["quasis", "expressions"],
+	ExpressionStatement: ["expression"],
+	BlockStatement: ["body"],
+	IfStatement: [
+		"test",
+		"consequent",
+		"alternate"
+	],
+	SwitchStatement: ["discriminant", "cases"],
+	SwitchCase: ["test", "consequent"],
+	ForStatement: [
+		"init",
+		"test",
+		"update",
+		"body"
+	],
+	ForInStatement: [
+		"left",
+		"right",
+		"body"
+	],
+	ForOfStatement: [
+		"left",
+		"right",
+		"body"
+	],
+	WhileStatement: ["test", "body"],
+	DoWhileStatement: ["body", "test"],
+	BreakStatement: ["label"],
+	ContinueStatement: ["label"],
+	LabeledStatement: ["label", "body"],
+	WithStatement: ["object", "body"],
+	ReturnStatement: ["argument"],
+	ThrowStatement: ["argument"],
+	TryStatement: [
+		"block",
+		"handler",
+		"finalizer"
+	],
+	CatchClause: ["param", "body"],
+	DebuggerStatement: [],
+	EmptyStatement: [],
+	VariableDeclaration: ["declarations"],
+	VariableDeclarator: ["id", "init"],
+	FunctionDeclaration: [
+		"id",
+		"typeParameters",
+		"params",
+		"returnType",
+		"body"
+	],
+	FunctionExpression: [
+		"id",
+		"typeParameters",
+		"params",
+		"returnType",
+		"body"
+	],
+	TSDeclareFunction: [
+		"id",
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	TSEmptyBodyFunctionExpression: [
+		"id",
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	ArrowFunctionExpression: [
+		"typeParameters",
+		"params",
+		"returnType",
+		"body"
+	],
+	ClassDeclaration: [
+		"decorators",
+		"id",
+		"typeParameters",
+		"superClass",
+		"superTypeArguments",
+		"implements",
+		"body"
+	],
+	ClassExpression: [
+		"decorators",
+		"id",
+		"typeParameters",
+		"superClass",
+		"superTypeArguments",
+		"implements",
+		"body"
+	],
+	ClassBody: ["body"],
+	MethodDefinition: [
+		"decorators",
+		"key",
+		"value"
+	],
+	TSAbstractMethodDefinition: [
+		"decorators",
+		"key",
+		"value"
+	],
+	PropertyDefinition: [
+		"decorators",
+		"key",
+		"typeAnnotation",
+		"value"
+	],
+	TSAbstractPropertyDefinition: [
+		"decorators",
+		"key",
+		"typeAnnotation",
+		"value"
+	],
+	AccessorProperty: [
+		"decorators",
+		"key",
+		"typeAnnotation",
+		"value"
+	],
+	TSAbstractAccessorProperty: [
+		"decorators",
+		"key",
+		"typeAnnotation",
+		"value"
+	],
+	StaticBlock: ["body"],
+	Decorator: ["expression"],
+	ImportDeclaration: [
+		"specifiers",
+		"source",
+		"attributes"
+	],
+	ImportSpecifier: ["imported", "local"],
+	ImportDefaultSpecifier: ["local"],
+	ImportNamespaceSpecifier: ["local"],
+	ImportAttribute: ["key", "value"],
+	ExportNamedDeclaration: [
+		"declaration",
+		"specifiers",
+		"source",
+		"attributes"
+	],
+	ExportDefaultDeclaration: ["declaration"],
+	ExportAllDeclaration: [
+		"exported",
+		"source",
+		"attributes"
+	],
+	ExportSpecifier: ["local", "exported"],
+	JSXElement: [
+		"openingElement",
+		"children",
+		"closingElement"
+	],
+	JSXOpeningElement: [
+		"name",
+		"typeArguments",
+		"attributes"
+	],
+	JSXClosingElement: ["name"],
+	JSXFragment: [
+		"openingFragment",
+		"children",
+		"closingFragment"
+	],
+	JSXOpeningFragment: [],
+	JSXClosingFragment: [],
+	JSXIdentifier: [],
+	JSXNamespacedName: ["namespace", "name"],
+	JSXMemberExpression: ["object", "property"],
+	JSXAttribute: ["name", "value"],
+	JSXSpreadAttribute: ["argument"],
+	JSXExpressionContainer: ["expression"],
+	JSXEmptyExpression: [],
+	JSXText: [],
+	JSXSpreadChild: ["expression"],
+	TSTypeAnnotation: ["typeAnnotation"],
+	TSAnyKeyword: [],
+	TSUnknownKeyword: [],
+	TSNeverKeyword: [],
+	TSVoidKeyword: [],
+	TSNullKeyword: [],
+	TSUndefinedKeyword: [],
+	TSStringKeyword: [],
+	TSNumberKeyword: [],
+	TSBigIntKeyword: [],
+	TSBooleanKeyword: [],
+	TSSymbolKeyword: [],
+	TSObjectKeyword: [],
+	TSIntrinsicKeyword: [],
+	TSThisType: [],
+	TSTypeReference: ["typeName", "typeArguments"],
+	TSQualifiedName: ["left", "right"],
+	TSTypeQuery: ["exprName", "typeArguments"],
+	TSImportType: [
+		"source",
+		"options",
+		"qualifier",
+		"typeArguments"
+	],
+	TSTypeParameter: [
+		"name",
+		"constraint",
+		"default"
+	],
+	TSTypeParameterDeclaration: ["params"],
+	TSTypeParameterInstantiation: ["params"],
+	TSLiteralType: ["literal"],
+	TSTemplateLiteralType: ["quasis", "types"],
+	TSArrayType: ["elementType"],
+	TSIndexedAccessType: ["objectType", "indexType"],
+	TSTupleType: ["elementTypes"],
+	TSNamedTupleMember: ["label", "elementType"],
+	TSOptionalType: ["typeAnnotation"],
+	TSRestType: ["typeAnnotation"],
+	TSJSDocNullableType: ["typeAnnotation"],
+	TSJSDocNonNullableType: ["typeAnnotation"],
+	TSJSDocUnknownType: [],
+	TSUnionType: ["types"],
+	TSIntersectionType: ["types"],
+	TSConditionalType: [
+		"checkType",
+		"extendsType",
+		"trueType",
+		"falseType"
+	],
+	TSInferType: ["typeParameter"],
+	TSTypeOperator: ["typeAnnotation"],
+	TSParenthesizedType: ["typeAnnotation"],
+	TSFunctionType: [
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	TSConstructorType: [
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	TSTypePredicate: ["parameterName", "typeAnnotation"],
+	TSTypeLiteral: ["members"],
+	TSMappedType: [
+		"key",
+		"constraint",
+		"nameType",
+		"typeAnnotation"
+	],
+	TSPropertySignature: ["key", "typeAnnotation"],
+	TSMethodSignature: [
+		"key",
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	TSCallSignatureDeclaration: [
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	TSConstructSignatureDeclaration: [
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	TSIndexSignature: ["parameters", "typeAnnotation"],
+	TSTypeAliasDeclaration: [
+		"id",
+		"typeParameters",
+		"typeAnnotation"
+	],
+	TSInterfaceDeclaration: [
+		"id",
+		"typeParameters",
+		"extends",
+		"body"
+	],
+	TSInterfaceBody: ["body"],
+	TSInterfaceHeritage: ["expression", "typeArguments"],
+	TSClassImplements: ["expression", "typeArguments"],
+	TSEnumDeclaration: ["id", "body"],
+	TSEnumBody: ["members"],
+	TSEnumMember: ["id", "initializer"],
+	TSModuleDeclaration: ["id", "body"],
+	TSModuleBlock: ["body"],
+	TSParameterProperty: ["decorators", "parameter"],
+	TSAsExpression: ["expression", "typeAnnotation"],
+	TSSatisfiesExpression: ["expression", "typeAnnotation"],
+	TSTypeAssertion: ["typeAnnotation", "expression"],
+	TSNonNullExpression: ["expression"],
+	TSInstantiationExpression: ["expression", "typeArguments"],
+	TSExportAssignment: ["expression"],
+	TSNamespaceExportDeclaration: ["id"],
+	TSImportEqualsDeclaration: ["id", "moduleReference"],
+	TSExternalModuleReference: ["expression"]
+};
+//#endregion
+//#region src/predicates.ts
+function aliasGuard(name) {
+	const set = new Set(ALIAS_GROUPS[name]);
+	return (node) => node != null && set.has(node.type);
+}
+const is = {
+	...Object.fromEntries(Object.keys(VISITOR_KEYS).map((type) => [type, (node) => node != null && node.type === type])),
+	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"),
+	IdentifierReference: (node) => node?.type === "Identifier" && node.kind === "reference",
+	BindingIdentifier: (node) => node?.type === "Identifier" && node.kind === "binding",
+	LabelIdentifier: (node) => node?.type === "Identifier" && node.kind === "label",
+	IdentifierName: (node) => node?.type === "Identifier" && node.kind === "name",
+	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 src/builders.ts
+const span = {
+	start: 0,
+	end: 0
+};
+const isComputedKey = (key) => key.type !== "Identifier" && key.type !== "PrivateIdentifier";
+const b = {
+	identifier(name, kind = "reference", opts = {}) {
+		return {
+			type: "Identifier",
+			name,
+			kind,
+			...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, "name"),
+			property: b.identifier(property, "name"),
+			...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
+		};
+	}
+};
+//#endregion
+//#region src/walk/core.ts
+/** Returned up the stack when a visitor calls `remove()`. */
+const REMOVED = Symbol("yuku-ast/removed");
+/** A node viewed as its fields, for traversal and mutation by key. */
+const fieldsOf = (node) => node;
+/**
+* One per visited node, holding its own position and a link to its parent path
+* so it stays valid, ancestors included, after the visit returns. Control flow
+* and mutation delegate to the owning walker.
+*/
+var NodePath = class {
+	walker;
+	parentPath;
+	node;
+	parent;
+	key;
+	index;
+	constructor(walker, parentPath, node, parent, key, index) {
+		this.walker = walker;
+		this.parentPath = parentPath;
+		this.node = node;
+		this.parent = parent;
+		this.key = key;
+		this.index = index;
+	}
+	get state() {
+		return this.walker.state;
+	}
+	set state(value) {
+		this.walker.state = value;
+	}
+	get ancestors() {
+		const out = [];
+		for (let p = this.parentPath; p !== null; p = p.parentPath) out.push(p.node);
+		return out.reverse();
+	}
+	skip() {
+		this.walker.skipFlag = true;
+	}
+	stop() {
+		this.walker.stopFlag = true;
+	}
+	replace(next) {
+		if (next.start === 0 && next.end === 0) {
+			next.start = this.node.start;
+			next.end = this.node.end;
+		}
+		this.node = next;
+		this.walker.replacement = next;
+		const { parent, key, index } = this;
+		if (parent === null || key === null) return;
+		const fields = fieldsOf(parent);
+		if (index === null) fields[key] = next;
+		else fields[key][index] = next;
+	}
+	remove() {
+		if (this.parent === null) throw new Error("yuku-ast: cannot remove the root node");
+		this.walker.removeFlag = true;
+	}
+	insertBefore(node) {
+		this.insertSibling(node, 0);
+	}
+	insertAfter(node) {
+		this.insertSibling(node, 1);
+	}
+	insertSibling(node, offset) {
+		const { parent, key, index } = this;
+		if (parent === null || key === null || index === null) throw new Error("yuku-ast: insertBefore/insertAfter require a node in an array field");
+		const list = fieldsOf(parent)[key];
+		const at = list.indexOf(this.node);
+		if (at !== -1) list.splice(at + offset, 0, node);
+	}
+};
+/** Shared dispatch and traversal state. The sync and async drivers extend this. */
+var WalkerCore = class {
+	state;
+	skipFlag = false;
+	stopFlag = false;
+	removeFlag = false;
+	replacement = null;
+	universalEnter;
+	universalLeave;
+	concrete = /* @__PURE__ */ new Map();
+	aliasHandlers = [];
+	cache = Object.create(null);
+	constructor(visitors, state) {
+		this.state = state;
+		const entries = visitors;
+		const aliases = ALIAS_GROUPS;
+		for (const name in entries) {
+			const entry = entries[name];
+			if (!entry) continue;
+			if (name === "enter") {
+				if (typeof entry === "function") this.universalEnter = entry;
+				continue;
+			}
+			if (name === "leave") {
+				if (typeof entry === "function") this.universalLeave = entry;
+				continue;
+			}
+			const enter = typeof entry === "function" ? entry : entry.enter;
+			const leave = typeof entry === "function" ? void 0 : entry.leave;
+			const aliasTypes = aliases[name];
+			if (aliasTypes) this.aliasHandlers.push({
+				types: new Set(aliasTypes),
+				enter,
+				leave
+			});
+			else {
+				const prev = this.concrete.get(name);
+				this.concrete.set(name, {
+					enter: enter ?? prev?.enter,
+					leave: leave ?? prev?.leave
+				});
+			}
+		}
+	}
+	dispatchFor(type) {
+		const cached = this.cache[type];
+		if (cached !== void 0) return cached;
+		const enter = [];
+		const leave = [];
+		const concrete = this.concrete.get(type);
+		if (this.universalEnter) enter.push(this.universalEnter);
+		for (let i = 0; i < this.aliasHandlers.length; i++) {
+			const a = this.aliasHandlers[i];
+			if (a.enter && a.types.has(type)) enter.push(a.enter);
+		}
+		if (concrete?.enter) enter.push(concrete.enter);
+		if (concrete?.leave) leave.push(concrete.leave);
+		for (let i = this.aliasHandlers.length - 1; i >= 0; i--) {
+			const a = this.aliasHandlers[i];
+			if (a.leave && a.types.has(type)) leave.push(a.leave);
+		}
+		if (this.universalLeave) leave.push(this.universalLeave);
+		return this.cache[type] = {
+			enter,
+			leave,
+			keys: VISITOR_KEYS[type]
+		};
+	}
+	newPath(parentPath, parent, node, key, index) {
+		return new NodePath(this, parentPath, node, parent, key, index);
+	}
+};
+//#endregion
+//#region src/walk/sync.ts
+var Walker = class extends WalkerCore {
+	run(root) {
+		const result = this.visit(null, null, root, null, null);
+		return result === REMOVED ? root : result;
+	}
+	apply(handlers, node, path) {
+		this.removeFlag = false;
+		for (let i = 0; i < handlers.length; i++) {
+			this.replacement = null;
+			handlers[i](node, path);
+			if (this.replacement !== null) node = this.replacement;
+			if (this.removeFlag || this.stopFlag) break;
+		}
+		return node;
+	}
+	visit(parentPath, parent, node, key, index) {
+		if (this.stopFlag) return node;
+		const path = this.newPath(parentPath, parent, node, key, index);
+		this.skipFlag = false;
+		let dispatch = this.dispatchFor(node.type);
+		if (dispatch.enter.length > 0) {
+			const before = node;
+			node = this.apply(dispatch.enter, node, path);
+			if (this.removeFlag) return REMOVED;
+			if (this.stopFlag) return node;
+			if (node !== before) dispatch = this.dispatchFor(node.type);
+		}
+		if (!this.skipFlag && dispatch.keys.length > 0) {
+			this.descend(path, node, dispatch.keys);
+			if (this.stopFlag) return node;
+		}
+		if (dispatch.leave.length > 0) {
+			node = this.apply(dispatch.leave, node, path);
+			if (this.removeFlag) return REMOVED;
+			if (this.stopFlag) return node;
+		}
+		return node;
+	}
+	descend(path, node, keys) {
+		const fields = fieldsOf(node);
+		for (let k = 0; k < keys.length; k++) {
+			const key = keys[k];
+			const value = fields[key];
+			if (value == null) continue;
+			if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
+				const child = value[i];
+				if (child == null) continue;
+				const before = value.length;
+				if (this.visit(path, node, child, key, i) === REMOVED) {
+					value.splice(i, 1);
+					i--;
+				} else i += value.length - before;
+				if (this.stopFlag) return;
+			}
+			else {
+				if (this.visit(path, node, value, key, null) === REMOVED) fields[key] = null;
+				if (this.stopFlag) return;
+			}
+		}
+	}
+};
+/**
+* Walk an AST depth first, dispatching to typed visitors and mutating in place.
+*
+* @param root     The node to start from, usually a `Program`.
+* @param visitors Handlers keyed by node `type`, alias group, or `enter`/`leave`.
+* @param state    Optional value exposed as `path.state` throughout the walk.
+* @returns The root node, or its replacement if the root was replaced.
+*
+* @example
+* ```ts
+* walk(program, {
+*   Identifier(node) {
+*     console.log(node.name);
+*   },
+*   CallExpression(node, path) {
+*     if (node.callee.type === "MemberExpression") path.skip();
+*   },
+* });
+* ```
+*/
+function walk(root, visitors, state) {
+	return new Walker(visitors, state).run(root);
+}
+//#endregion
+//#region src/walk/async.ts
+var AsyncWalker = class extends WalkerCore {
+	async run(root) {
+		const result = await this.visit(null, null, root, null, null);
+		return result === REMOVED ? root : result;
+	}
+	async apply(handlers, node, path) {
+		this.removeFlag = false;
+		for (let i = 0; i < handlers.length; i++) {
+			this.replacement = null;
+			await handlers[i](node, path);
+			if (this.replacement !== null) node = this.replacement;
+			if (this.removeFlag || this.stopFlag) break;
+		}
+		return node;
+	}
+	async visit(parentPath, parent, node, key, index) {
+		if (this.stopFlag) return node;
+		const path = this.newPath(parentPath, parent, node, key, index);
+		this.skipFlag = false;
+		let dispatch = this.dispatchFor(node.type);
+		if (dispatch.enter.length > 0) {
+			const before = node;
+			node = await this.apply(dispatch.enter, node, path);
+			if (this.removeFlag) return REMOVED;
+			if (this.stopFlag) return node;
+			if (node !== before) dispatch = this.dispatchFor(node.type);
+		}
+		if (!this.skipFlag && dispatch.keys.length > 0) {
+			await this.descend(path, node, dispatch.keys);
+			if (this.stopFlag) return node;
+		}
+		if (dispatch.leave.length > 0) {
+			node = await this.apply(dispatch.leave, node, path);
+			if (this.removeFlag) return REMOVED;
+			if (this.stopFlag) return node;
+		}
+		return node;
+	}
+	async descend(path, node, keys) {
+		const fields = fieldsOf(node);
+		for (let k = 0; k < keys.length; k++) {
+			const key = keys[k];
+			const value = fields[key];
+			if (value == null) continue;
+			if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
+				const child = value[i];
+				if (child == null) continue;
+				const before = value.length;
+				if (await this.visit(path, node, child, key, i) === REMOVED) {
+					value.splice(i, 1);
+					i--;
+				} else i += value.length - before;
+				if (this.stopFlag) return;
+			}
+			else {
+				if (await this.visit(path, node, value, key, null) === REMOVED) fields[key] = null;
+				if (this.stopFlag) return;
+			}
+		}
+	}
+};
+/**
+* Like {@link walk}, but visitors may be `async`. Handlers are awaited one at a
+* time in depth-first order, so mutation behaves exactly as in the sync walk.
+* Reach for this only when a visitor needs to await I/O; prefer {@link walk}
+* otherwise, as awaiting has per-node overhead.
+*
+* @returns A promise of the root node, or its replacement if the root was replaced.
+*/
+function walkAsync(root, visitors, state) {
+	return new AsyncWalker(visitors, state).run(root);
+}
+//#endregion
+export { b, is, walk, walkAsync };