ripple 0.3.44 → 0.3.45

package/src/utils/builders.js

@@ -1,1287 +0,0 @@
-/** @import * as AST from '@tsrx/core/types/estree' */
-/** @import * as ESTreeJSX from '@tsrx/core/types/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,
-};