@tsrx/core 0.0.1

package/src/utils/builders.js

@@ -0,0 +1,1287 @@
+/** @import * as AST from 'estree' */
+/** @import * as ESTreeJSX from 'estree-jsx' */
+
+import { regex_is_valid_identifier } from './patterns.js';
+import { sanitize_template_string } from './sanitize_template_string.js';
+
+/**
+ * @template {AST.Node} T
+ * @param {T} node
+ * @param {AST.NodeWithLocation | undefined} loc_info
+ * @param {boolean} is_deep_copy
+ * @returns {T}
+ */
+export function set_location(node, loc_info, is_deep_copy = false) {
+	if (loc_info) {
+		node.start = loc_info.start;
+		node.end = loc_info.end;
+
+		if (is_deep_copy) {
+			node.loc = {
+				start: { ...loc_info.loc.start },
+				end: { ...loc_info.loc.end },
+			};
+		} else {
+			node.loc = loc_info.loc;
+		}
+	}
+
+	return node;
+}
+
+/**
+ * @param {Array<AST.Expression | AST.SpreadElement | null>} elements
+ * @returns {AST.ArrayExpression}
+ */
+export function array(elements = []) {
+	return { type: 'ArrayExpression', elements, metadata: { path: [] } };
+}
+
+/**
+ * @param {Array<AST.Pattern | null>} elements
+ * @returns {AST.ArrayPattern}
+ */
+export function array_pattern(elements) {
+	return { type: 'ArrayPattern', elements, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.Pattern} left
+ * @param {AST.Expression} right
+ * @returns {AST.AssignmentPattern}
+ */
+export function assignment_pattern(left, right) {
+	return { type: 'AssignmentPattern', left, right, metadata: { path: [] } };
+}
+
+/**
+ * @param {Array<AST.Pattern>} params
+ * @param {AST.BlockStatement | AST.Expression} body
+ * @returns {AST.ArrowFunctionExpression}
+ */
+export function arrow(params, body, async = false) {
+	return {
+		type: 'ArrowFunctionExpression',
+		params,
+		body,
+		expression: body.type !== 'BlockStatement',
+		generator: false,
+		async,
+		metadata: /** @type {any} */ (null), // should not be used by codegen
+	};
+}
+
+/**
+ * @param {AST.Identifier} id
+ * @param {AST.Pattern[]} params
+ * @param {AST.Node[]} body
+ * @returns {AST.Component}
+ */
+export function component(id, params, body) {
+	return {
+		type: 'Component',
+		id,
+		params,
+		body,
+		css: null,
+		metadata: { path: [] },
+		default: false,
+	};
+}
+
+/**
+ * @param {AST.AssignmentOperator} operator
+ * @param {AST.Pattern} left
+ * @param {AST.Expression} right
+ * @returns {AST.AssignmentExpression}
+ */
+export function assignment(operator, left, right) {
+	return { type: 'AssignmentExpression', operator, left, right, metadata: { path: [] } };
+}
+
+/**
+ * @template T
+ * @param {T & AST.BaseFunction} func
+ * @returns {T & AST.BaseFunction}
+ */
+export function async(func) {
+	return { ...func, async: true };
+}
+
+/**
+ * @param {AST.Expression} argument
+ * @returns {AST.AwaitExpression}
+ */
+function await_builder(argument) {
+	return { type: 'AwaitExpression', argument, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.BinaryOperator} operator
+ * @param {AST.Expression} left
+ * @param {AST.Expression} right
+ * @returns {AST.BinaryExpression}
+ */
+export function binary(operator, left, right) {
+	return { type: 'BinaryExpression', operator, left, right, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.Statement[]} body
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.BlockStatement}
+ */
+export function block(body, loc_info) {
+	/** @type {AST.BlockStatement} */
+	const node = { type: 'BlockStatement', body, metadata: { path: [] } };
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {string} name
+ * @param {AST.Statement} body
+ * @returns {AST.LabeledStatement}
+ */
+export function labeled(name, body) {
+	return { type: 'LabeledStatement', label: id(name), body, metadata: { path: [] } };
+}
+
+/**
+ * @param {string | AST.Expression} callee
+ * @param {...(AST.Expression | AST.SpreadElement | false | undefined)} args
+ * @returns {AST.CallExpression}
+ */
+export function call(callee, ...args) {
+	if (typeof callee === 'string') callee = id(callee);
+	args = args.slice();
+
+	// replacing missing arguments with `void(0)`, unless they're at the end in which case remove them
+	let i = args.length;
+	let popping = true;
+	while (i--) {
+		if (!args[i]) {
+			if (popping) {
+				args.pop();
+			} else {
+				args[i] = void0;
+			}
+		} else {
+			popping = false;
+		}
+	}
+
+	return {
+		type: 'CallExpression',
+		callee,
+		arguments: /** @type {Array<AST.Expression | AST.SpreadElement>} */ (args),
+		optional: false,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {string | AST.Expression} callee
+ * @param {...(AST.Expression | AST.SpreadElement | false | undefined)} args
+ * @returns {AST.ChainExpression}
+ */
+export function maybe_call(callee, ...args) {
+	const expression = /** @type {AST.SimpleCallExpression} */ (call(callee, ...args));
+	expression.optional = true;
+
+	return {
+		type: 'ChainExpression',
+		expression,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {AST.UnaryOperator} operator
+ * @param {AST.Expression} argument
+ * @returns {AST.UnaryExpression}
+ */
+export function unary(operator, argument) {
+	return { type: 'UnaryExpression', argument, operator, prefix: true, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.Expression} test
+ * @param {AST.Expression} consequent
+ * @param {AST.Expression} alternate
+ * @returns {AST.ConditionalExpression}
+ */
+export function conditional(test, consequent, alternate) {
+	return { type: 'ConditionalExpression', test, consequent, alternate, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.LogicalOperator} operator
+ * @param {AST.Expression} left
+ * @param {AST.Expression} right
+ * @returns {AST.LogicalExpression}
+ */
+export function logical(operator, left, right) {
+	return { type: 'LogicalExpression', operator, left, right, metadata: { path: [] } };
+}
+
+/**
+ * @param {'const' | 'let' | 'var'} kind
+ * @param {AST.VariableDeclarator[]} declarations
+ * @returns {AST.VariableDeclaration}
+ */
+export function declaration(kind, declarations) {
+	return {
+		type: 'VariableDeclaration',
+		kind,
+		declarations,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {AST.Pattern | string} pattern
+ * @param {AST.Expression} [init]
+ * @returns {AST.VariableDeclarator}
+ */
+export function declarator(pattern, init) {
+	if (typeof pattern === 'string') pattern = id(pattern);
+	return { type: 'VariableDeclarator', id: pattern, init, metadata: { path: [] } };
+}
+
+/** @type {AST.EmptyStatement} */
+export const empty = {
+	type: 'EmptyStatement',
+	metadata: { path: [] },
+};
+
+/**
+ * @param {AST.Expression | AST.MaybeNamedClassDeclaration | AST.MaybeNamedFunctionDeclaration} declaration
+ * @returns {AST.ExportDefaultDeclaration}
+ */
+export function export_default(declaration) {
+	return { type: 'ExportDefaultDeclaration', declaration, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.Declaration | null} declaration
+ * @param {AST.ExportSpecifier[]} [specifiers]
+ * @param {AST.ImportAttribute[]} [attributes]
+ * @param {AST.ExportNamedDeclaration['exportKind']} [exportKind]
+ * @param {AST.Literal | null} [source]
+ * @returns {AST.ExportNamedDeclaration}
+ */
+export function export_builder(
+	declaration,
+	specifiers = [],
+	attributes = [],
+	exportKind = 'value',
+	source = null,
+) {
+	return {
+		type: 'ExportNamedDeclaration',
+		declaration,
+		specifiers,
+		attributes,
+		exportKind,
+		source,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {AST.Identifier} id
+ * @param {AST.Pattern[]} params
+ * @param {AST.BlockStatement} body
+ * @returns {AST.FunctionDeclaration}
+ */
+export function function_declaration(id, params, body, async = false) {
+	return {
+		type: 'FunctionDeclaration',
+		id,
+		params,
+		body,
+		generator: false,
+		async,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {string} name
+ * @param {AST.Statement[]} body
+ * @returns {AST.Property & { value: AST.FunctionExpression}}}
+ */
+export function get(name, body) {
+	return /** @type {AST.Property & { value: AST.FunctionExpression}} */ (
+		prop('get', key(name), function_builder(null, [], block(body)))
+	);
+}
+
+/**
+ * @param {string} name
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.Identifier}
+ */
+export function id(name, loc_info) {
+	/** @type {AST.Identifier} */
+	const node = {
+		type: 'Identifier',
+		name,
+		optional: false,
+		decorators: [],
+		metadata: { path: [] },
+	};
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {string} name
+ * @returns {AST.PrivateIdentifier}
+ */
+export function private_id(name) {
+	return { type: 'PrivateIdentifier', name, metadata: { path: [] } };
+}
+
+/**
+ * @param {string} local
+ * @returns {AST.ImportNamespaceSpecifier}
+ */
+function import_namespace(local) {
+	return {
+		type: 'ImportNamespaceSpecifier',
+		local: id(local),
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {string} name
+ * @param {AST.Expression} value
+ * @returns {AST.Property}
+ */
+export function init(name, value) {
+	return prop('init', key(name), value);
+}
+
+/**
+ * @param {boolean | string | number | bigint | false | RegExp | null | undefined} value
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.Literal}
+ */
+export function literal(value, loc_info) {
+	const node = /** @type {AST.Literal} */ ({ type: 'Literal', value, metadata: { path: [] } });
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Expression | AST.Super} object
+ * @param {string | AST.Expression | AST.PrivateIdentifier} property
+ * @param {boolean} computed
+ * @param {boolean} optional
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.MemberExpression}
+ */
+export function member(object, property, computed = false, optional = false, loc_info) {
+	if (typeof property === 'string') {
+		property = id(property);
+	}
+
+	/** @type {AST.MemberExpression} */
+	const node = {
+		type: 'MemberExpression',
+		object,
+		property,
+		computed,
+		optional,
+		metadata: { path: [] },
+	};
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Expression} expression
+ * @param {AST.Node} type_annotation
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TSAsExpression}
+ */
+export function ts_as(expression, type_annotation, loc_info) {
+	const node = /** @type {AST.TSAsExpression} */ ({
+		type: 'TSAsExpression',
+		expression,
+		typeAnnotation: type_annotation,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Expression} expression
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.ParenthesizedExpression}
+ */
+export function parenthesized(expression, loc_info) {
+	const node = /** @type {AST.ParenthesizedExpression} */ ({
+		type: 'ParenthesizedExpression',
+		expression,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Identifier | AST.MemberExpression} expr_name
+ * @param {AST.Node | null} [type_arguments]
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TSTypeQuery}
+ */
+export function ts_type_query(expr_name, type_arguments = null, loc_info) {
+	const node = /** @type {AST.TSTypeQuery} */ ({
+		type: 'TSTypeQuery',
+		exprName: expr_name,
+		typeArguments: type_arguments,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Node[]} params
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TSTypeParameterInstantiation}
+ */
+export function ts_type_parameter_instantiation(params, loc_info) {
+	const node = /** @type {AST.TSTypeParameterInstantiation} */ ({
+		type: 'TSTypeParameterInstantiation',
+		params,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Identifier | AST.Node} type_name
+ * @param {AST.Node | null} [type_arguments]
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TSTypeReference}
+ */
+export function ts_type_reference(type_name, type_arguments = null, loc_info) {
+	const node = /** @type {AST.TSTypeReference} */ ({
+		type: 'TSTypeReference',
+		typeName: type_name,
+		typeArguments: type_arguments,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Literal} literal_node
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TSLiteralType}
+ */
+export function ts_literal_type(literal_node, loc_info) {
+	const node = /** @type {AST.TSLiteralType} */ ({
+		type: 'TSLiteralType',
+		literal: literal_node,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Node[]} types
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TSIntersectionType}
+ */
+export function ts_intersection_type(types, loc_info) {
+	const node = /** @type {AST.TSIntersectionType} */ ({
+		type: 'TSIntersectionType',
+		types,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {'string' | 'number' | 'boolean' | 'any' | 'void' | 'null' | 'undefined' | 'never' | 'unknown' | 'bigint' | 'symbol' | 'object'} keyword
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TypeNode}
+ */
+export function ts_keyword_type(keyword, loc_info) {
+	/** @type {Record<string, string>} */
+	const keyword_to_type = {
+		string: 'TSStringKeyword',
+		number: 'TSNumberKeyword',
+		boolean: 'TSBooleanKeyword',
+		any: 'TSAnyKeyword',
+		void: 'TSVoidKeyword',
+		null: 'TSNullKeyword',
+		undefined: 'TSUndefinedKeyword',
+		never: 'TSNeverKeyword',
+		unknown: 'TSUnknownKeyword',
+		bigint: 'TSBigIntKeyword',
+		symbol: 'TSSymbolKeyword',
+		object: 'TSObjectKeyword',
+	};
+
+	const node = /** @type {AST.TypeNode} */ ({
+		type: keyword_to_type[keyword],
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Node} type_annotation
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TSTypeAnnotation}
+ */
+export function ts_type_annotation(type_annotation, loc_info) {
+	const node = /** @type {AST.TSTypeAnnotation} */ ({
+		type: 'TSTypeAnnotation',
+		typeAnnotation: type_annotation,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Expression} key
+ * @param {AST.Node | null} type_annotation
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TSPropertySignature}
+ */
+export function ts_property_signature(key, type_annotation = null, loc_info) {
+	const node = /** @type {AST.TSPropertySignature} */ ({
+		type: 'TSPropertySignature',
+		key,
+		accessibility: undefined,
+		computed: false,
+		optional: false,
+		readonly: false,
+		static: false,
+		kind: 'init',
+		typeAnnotation: type_annotation,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Node[]} members
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TSTypeLiteral}
+ */
+export function ts_type_literal(members, loc_info) {
+	const node = /** @type {AST.TSTypeLiteral} */ ({
+		type: 'TSTypeLiteral',
+		members,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Identifier} id
+ * @param {AST.Node} type_annotation
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TSTypeAliasDeclaration}
+ */
+export function ts_type_alias(id, type_annotation, loc_info) {
+	const node = /** @type {AST.TSTypeAliasDeclaration} */ ({
+		type: 'TSTypeAliasDeclaration',
+		id,
+		typeParameters: undefined,
+		typeAnnotation: type_annotation,
+		declare: false,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {string} path
+ * @returns {AST.Identifier | AST.MemberExpression}
+ */
+export function member_id(path) {
+	const parts = path.split('.');
+
+	/** @type {AST.Identifier | AST.MemberExpression} */
+	let expression = id(parts[0]);
+
+	for (let i = 1; i < parts.length; i += 1) {
+		expression = member(expression, id(parts[i]));
+	}
+	return expression;
+}
+
+/**
+ * @param {Array<AST.Property | AST.SpreadElement>} properties
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.ObjectExpression}
+ */
+export function object(properties, loc_info) {
+	/** @type {AST.ObjectExpression} */
+	const node = { type: 'ObjectExpression', properties, metadata: { path: [] } };
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {Array<AST.RestElement | AST.AssignmentProperty>} properties
+ * @returns {AST.ObjectPattern}
+ */
+export function object_pattern(properties) {
+	return { type: 'ObjectPattern', properties, metadata: { path: [] } };
+}
+
+/**
+ * @template {AST.Expression} Value
+ * @param {AST.Property['kind']} kind
+ * @param {AST.Expression } key
+ * @param {Value} value
+ * @param {boolean} computed
+ * @param {boolean} shorthand
+ * @returns {AST.Property}
+ */
+export function prop(kind, key, value, computed = false, shorthand = false) {
+	return {
+		type: 'Property',
+		kind,
+		key,
+		value,
+		method: false,
+		shorthand,
+		computed,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {AST.Expression | AST.PrivateIdentifier} key
+ * @param {AST.Expression | null | undefined} value
+ * @param {boolean} computed
+ * @param {boolean} is_static
+ * @returns {AST.PropertyDefinition}
+ */
+export function prop_def(key, value, computed = false, is_static = false) {
+	return {
+		type: 'PropertyDefinition',
+		key,
+		value,
+		computed,
+		static: is_static,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {string} cooked
+ * @param {boolean} tail
+ * @returns {AST.TemplateElement}
+ */
+export function quasi(cooked, tail = false) {
+	const raw = sanitize_template_string(cooked);
+	return { type: 'TemplateElement', value: { raw, cooked }, tail, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.Pattern} argument
+ * @returns {AST.RestElement}
+ */
+export function rest(argument) {
+	return { type: 'RestElement', argument, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.Expression[]} expressions
+ * @returns {AST.SequenceExpression}
+ */
+export function sequence(expressions) {
+	return { type: 'SequenceExpression', expressions, metadata: { path: [] } };
+}
+
+/**
+ * @param {string} name
+ * @param {AST.Statement[]} body
+ * @returns {AST.Property & { value: AST.FunctionExpression}}
+ */
+export function set(name, body) {
+	return /** @type {AST.Property & { value: AST.FunctionExpression}} */ (
+		prop('set', key(name), function_builder(null, [id('$$value')], block(body)))
+	);
+}
+
+/**
+ * @param {AST.Expression} argument
+ * @returns {AST.SpreadElement}
+ */
+export function spread(argument) {
+	return { type: 'SpreadElement', argument, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.Expression} expression
+ * @returns {AST.ExpressionStatement}
+ */
+export function stmt(expression) {
+	return { type: 'ExpressionStatement', expression, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.TemplateElement[]} elements
+ * @param {AST.Expression[]} expressions
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.TemplateLiteral}
+ */
+export function template(elements, expressions, loc_info) {
+	/** @type {AST.TemplateLiteral} */
+	const node = { type: 'TemplateLiteral', quasis: elements, expressions, metadata: { path: [] } };
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Expression | AST.BlockStatement} expression
+ * @param {boolean} [async]
+ * @returns {ReturnType<typeof unthunk>}
+ */
+export function thunk(expression, async = false) {
+	const fn = arrow([], expression);
+	if (async) fn.async = true;
+	return unthunk(fn);
+}
+
+/**
+ * Replace "(arg) => func(arg)" to "func"
+ * @param {AST.Expression} expression
+ * @returns {AST.Expression}
+ */
+export function unthunk(expression) {
+	if (
+		expression.type === 'ArrowFunctionExpression' &&
+		expression.async === false &&
+		expression.body.type === 'CallExpression' &&
+		expression.body.callee.type === 'Identifier' &&
+		expression.params.length === expression.body.arguments.length &&
+		expression.params.every((param, index) => {
+			const arg = /** @type {AST.SimpleCallExpression} */ (expression.body).arguments[index];
+			return param.type === 'Identifier' && arg.type === 'Identifier' && param.name === arg.name;
+		})
+	) {
+		return expression.body.callee;
+	}
+	return expression;
+}
+
+/**
+ *
+ * @param {string | AST.Expression} expression
+ * @param {AST.NodeWithLocation | undefined} loc_info
+ * @param  {...AST.Expression} args
+ * @returns {AST.NewExpression}
+ */
+function new_builder(expression, loc_info, ...args) {
+	if (typeof expression === 'string') expression = id(expression);
+
+	/** @type {AST.NewExpression} */
+	const node = {
+		callee: expression,
+		arguments: args,
+		type: 'NewExpression',
+		metadata: { path: [] },
+	};
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.UpdateOperator} operator
+ * @param {AST.Expression} argument
+ * @param {boolean} prefix
+ * @returns {AST.UpdateExpression}
+ */
+export function update(operator, argument, prefix = false) {
+	return { type: 'UpdateExpression', operator, argument, prefix, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.Expression} test
+ * @param {AST.Statement} body
+ * @returns {AST.DoWhileStatement}
+ */
+export function do_while(test, body) {
+	return { type: 'DoWhileStatement', test, body, metadata: { path: [] } };
+}
+
+const true_instance = literal(true);
+const false_instance = literal(false);
+const null_instance = literal(null);
+
+/** @type {AST.DebuggerStatement} */
+const debugger_builder = {
+	type: 'DebuggerStatement',
+	metadata: { path: [] },
+};
+
+/** @type {AST.ThisExpression} */
+const this_instance = {
+	type: 'ThisExpression',
+	metadata: { path: [] },
+};
+
+/**
+ * @param {string | AST.Pattern} pattern
+ * @param { AST.Expression} [init]
+ * @returns {AST.VariableDeclaration}
+ */
+function let_builder(pattern, init) {
+	return declaration('let', [declarator(pattern, init)]);
+}
+
+/**
+ * @param {string | AST.Pattern} pattern
+ * @param { AST.Expression} init
+ * @returns {AST.VariableDeclaration}
+ */
+function const_builder(pattern, init) {
+	return declaration('const', [declarator(pattern, init)]);
+}
+
+/**
+ * @param {string | AST.Pattern} pattern
+ * @param { AST.Expression} [init]
+ * @returns {AST.VariableDeclaration}
+ */
+function var_builder(pattern, init) {
+	return declaration('var', [declarator(pattern, init)]);
+}
+
+/**
+ *
+ * @param {AST.VariableDeclaration | AST.Expression | null} init
+ * @param {AST.Expression} test
+ * @param {AST.Expression} update
+ * @param {AST.Statement} body
+ * @returns {AST.ForStatement}
+ */
+function for_builder(init, test, update, body) {
+	return { type: 'ForStatement', init, test, update, body, metadata: { path: [] } };
+}
+
+/**
+ * @param {AST.VariableDeclaration | AST.Pattern} left
+ * @param {AST.Expression} right
+ * @param {AST.Statement} body
+ * @param {boolean} [await_flag]
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.ForOfStatement}
+ */
+export function for_of(left, right, body, await_flag = false, loc_info) {
+	/** @type {AST.ForOfStatement} */
+	const node = {
+		type: 'ForOfStatement',
+		left,
+		right,
+		body,
+		await: await_flag,
+		metadata: { path: [] },
+	};
+
+	return set_location(node, loc_info);
+}
+
+/**
+ *
+ * @param {'constructor' | 'method' | 'get' | 'set'} kind
+ * @param {AST.Expression | AST.PrivateIdentifier} key
+ * @param {AST.Pattern[]} params
+ * @param {AST.Statement[]} body
+ * @param {boolean} computed
+ * @param {boolean} is_static
+ * @returns {AST.MethodDefinition}
+ */
+export function method(kind, key, params, body, computed = false, is_static = false) {
+	return {
+		type: 'MethodDefinition',
+		key,
+		kind,
+		value: function_builder(null, params, block(body)),
+		computed,
+		static: is_static,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ *
+ * @param {AST.Identifier | null} id
+ * @param {AST.Pattern[]} params
+ * @param {AST.BlockStatement} body
+ * @param {boolean} async
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.FunctionExpression}
+ */
+function function_builder(id, params, body, async = false, loc_info) {
+	/** @type {AST.FunctionExpression} */
+	const node = {
+		type: 'FunctionExpression',
+		id,
+		params,
+		body,
+		generator: false,
+		async,
+		metadata: { path: [] },
+	};
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Expression} test
+ * @param {AST.Statement} consequent
+ * @param {AST.Statement | null} [alternate]
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.IfStatement}
+ */
+function if_builder(test, consequent, alternate, loc_info) {
+	/** @type {AST.IfStatement} */
+	const node = { type: 'IfStatement', test, consequent, alternate, metadata: { path: [] } };
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {string} as
+ * @param {string} source
+ * @param {Array<AST.ImportAttribute>} attributes
+ * @param {AST.ImportDeclaration['importKind']} importKind
+ * @returns {AST.ImportDeclaration}
+ */
+export function import_all(as, source, attributes = [], importKind = 'value') {
+	return {
+		type: 'ImportDeclaration',
+		source: literal(source),
+		specifiers: [import_namespace(as)],
+		attributes,
+		importKind,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {Array<[string, string, AST.ImportDeclaration['importKind']]>} parts
+ * @param {string} source
+ * @param {Array<AST.ImportAttribute>} attributes
+ * @param {AST.ImportDeclaration['importKind']} importKind
+ * @returns {AST.ImportDeclaration}
+ */
+export function imports(parts, source, attributes = [], importKind = 'value') {
+	return {
+		type: 'ImportDeclaration',
+		source: literal(source),
+		attributes,
+		specifiers: parts.map((p) => ({
+			type: 'ImportSpecifier',
+			imported: id(p[0]),
+			local: id(p[1]),
+			importKind: p.length > 2 ? p[2] : 'value',
+			metadata: { path: [] },
+		})),
+		importKind,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {AST.Expression | null} argument
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.ReturnStatement}
+ */
+function return_builder(argument = null, loc_info) {
+	/** @type {AST.ReturnStatement} */
+	const node = { type: 'ReturnStatement', argument, metadata: { path: [] } };
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {string} str
+ * @returns {AST.ThrowStatement}
+ */
+export function throw_error(str) {
+	return {
+		type: 'ThrowStatement',
+		argument: new_builder('Error', undefined, literal(str)),
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {AST.BlockStatement} block
+ * @param {AST.CatchClause | null} handler
+ * @param {AST.BlockStatement | null} finalizer
+ * @param {AST.BlockStatement | null} pending
+ * @returns {AST.TryStatement}
+ */
+export function try_builder(block, handler = null, finalizer = null, pending = null) {
+	return {
+		type: 'TryStatement',
+		block,
+		handler,
+		finalizer,
+		pending,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {AST.Pattern | null} param
+ * @param {AST.Pattern | null} reset_param
+ * @param {AST.BlockStatement} body
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @return {AST.CatchClause}
+ */
+export function catch_clause_builder(param, reset_param, body, loc_info) {
+	/** @type {AST.CatchClause} */
+	const node = {
+		type: 'CatchClause',
+		param,
+		resetParam: reset_param,
+		body,
+		metadata: { path: [] },
+	};
+
+	return set_location(node, loc_info);
+}
+
+export { catch_clause_builder as catch_clause };
+
+/**
+ * @param {string} name
+ * @returns {AST.Expression}
+ */
+export function key(name) {
+	return regex_is_valid_identifier.test(name) ? id(name) : literal(name);
+}
+
+/**
+ * @param {ESTreeJSX.JSXIdentifier | ESTreeJSX.JSXNamespacedName} name
+ * @param {AST.Literal | ESTreeJSX.JSXExpressionContainer | null} value
+ * @param {boolean} [shorthand]
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {ESTreeJSX.JSXAttribute}
+ */
+export function jsx_attribute(name, value = null, shorthand = false, loc_info) {
+	const node = /** @type {ESTreeJSX.JSXAttribute} */ ({
+		type: 'JSXAttribute',
+		name,
+		value,
+		shorthand,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Element} node
+ * @param {ESTreeJSX.JSXOpeningElement['attributes']} attributes
+ * @param {ESTreeJSX.JSXElement['children']} children
+ * @returns {ESTreeJSX.JSXElement}
+ */
+export function jsx_element(node, attributes = [], children = []) {
+	return {
+		...node,
+		type: 'JSXElement',
+		openingElement: {
+			...node.openingElement,
+			attributes,
+			metadata: {
+				path: [...node.metadata.path],
+			},
+		},
+		closingElement: node.closingElement
+			? {
+					...node.closingElement,
+					metadata: {
+						path: [...node.metadata.path],
+					},
+				}
+			: null,
+		children,
+	};
+}
+
+/**
+ * @param {ESTreeJSX.JSXFragment['children']} children
+ * @param {ESTreeJSX.JSXOpeningFragment['attributes']} [attributes]
+ * @returns {ESTreeJSX.JSXFragment}
+ */
+export function jsx_fragment(children = [], attributes = []) {
+	return {
+		type: 'JSXFragment',
+		openingFragment: {
+			type: 'JSXOpeningFragment',
+			attributes,
+			metadata: { path: [] },
+		},
+		closingFragment: {
+			type: 'JSXClosingFragment',
+			metadata: { path: [] },
+		},
+		children,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {AST.Expression | ESTreeJSX.JSXEmptyExpression} expression
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {ESTreeJSX.JSXExpressionContainer}
+ */
+export function jsx_expression_container(expression, loc_info) {
+	const node = /** @type {ESTreeJSX.JSXExpressionContainer} */ ({
+		type: 'JSXExpressionContainer',
+		expression,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {string} name
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {ESTreeJSX.JSXIdentifier}
+ */
+export function jsx_id(name, loc_info) {
+	/** @type {ESTreeJSX.JSXIdentifier} */
+	const node = {
+		type: 'JSXIdentifier',
+		name,
+		metadata: { path: [] },
+	};
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {ESTreeJSX.JSXIdentifier | ESTreeJSX.JSXMemberExpression} object
+ * @param {ESTreeJSX.JSXIdentifier} property
+ * @returns {ESTreeJSX.JSXMemberExpression}
+ */
+export function jsx_member(object, property) {
+	return {
+		type: 'JSXMemberExpression',
+		object,
+		property,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {AST.Expression} argument
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {ESTreeJSX.JSXSpreadAttribute}
+ */
+export function jsx_spread_attribute(argument, loc_info) {
+	const node = /** @type {ESTreeJSX.JSXSpreadAttribute} */ ({
+		type: 'JSXSpreadAttribute',
+		argument,
+		metadata: { path: [] },
+	});
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {string} value
+ * @param {string} raw
+ * @returns {ESTreeJSX.JSXText}
+ */
+export function jsx_text(value, raw) {
+	return {
+		type: 'JSXText',
+		value,
+		raw,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {AST.Expression} discriminant
+ * @param {AST.SwitchCase[]} cases
+ * @param {AST.NodeWithLocation} [loc_info]
+ * @returns {AST.SwitchStatement}
+ */
+export function switch_builder(discriminant, cases, loc_info) {
+	/** @type {AST.SwitchStatement} */
+	const node = {
+		type: 'SwitchStatement',
+		discriminant,
+		cases,
+		metadata: { path: [] },
+	};
+
+	return set_location(node, loc_info);
+}
+
+/**
+ * @param {AST.Expression | null} test
+ * @param {AST.Statement[]} consequent
+ * @returns {AST.SwitchCase}
+ */
+export function switch_case(test = null, consequent = []) {
+	return {
+		type: 'SwitchCase',
+		test,
+		consequent,
+		metadata: { path: [] },
+	};
+}
+
+export const void0 = unary('void', literal(0));
+
+/**
+ * @type {AST.BreakStatement}
+ */
+export const break_statement = {
+	type: 'BreakStatement',
+	label: null,
+	metadata: { path: [] },
+};
+
+export {
+	await_builder as await,
+	let_builder as let,
+	const_builder as const,
+	var_builder as var,
+	export_builder as export,
+	true_instance as true,
+	false_instance as false,
+	break_statement as break,
+	for_builder as for,
+	switch_builder as switch,
+	function_builder as function,
+	return_builder as return,
+	if_builder as if,
+	this_instance as this,
+	null_instance as null,
+	debugger_builder as debugger,
+	try_builder as try,
+	new_builder as new,
+};