esrap 2.0.1 → 2.1.1

package/README.md

@@ -107,6 +107,7 @@ The `context` API has several methods:
 - `context.write(data: string, node?: BaseNode)` — add a string. If `node` is provided and has a standard `loc` property (with `start` and `end` properties each with a `line` and `column`), a sourcemap mapping will be created
 - `context.indent()` — increase the indentation level, typically before adding a newline
 - `context.newline()` — self-explanatory
+- `context.space()` — adds a space character, if it doesn't immediately follow a newline
 - `context.margin()` — causes the next newline to be repeated (consecutive newlines are otherwise merged into one)
 - `context.dedent()` — decrease the indentation level (again, typically before adding a newline)
 - `context.visit(node: BaseNode)` — calls the visitor corresponding to `node.type`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esrap",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "Parse in reverse",
   "repository": {
     "type": "git",
@@ -33,6 +33,7 @@
     "@vitest/ui": "^2.1.1",
     "acorn": "^8.15.0",
     "dts-buddy": "^0.6.2",
+    "oxc-parser": "^0.95.0",
     "prettier": "^3.0.3",
     "typescript": "^5.7.2",
     "vitest": "^2.1.1",
@@ -51,6 +52,8 @@
     "check": "tsc",
     "sandbox": "node test/sandbox/index.js",
     "test": "vitest --run",
-    "test:ui": "vitest --ui"
+    "test:ui": "vitest --ui",
+    "format": "pnpm lint --write",
+    "lint": "prettier --check . --ignore-path .gitignore --ignore-path .prettierignore"
   }
 }

package/src/context.js

@@ -5,10 +5,12 @@ export const margin = 0;
 export const newline = 1;
 export const indent = 2;
 export const dedent = 3;
+export const space = 4;
 
 export class Context {
 	#visitors;
 	#commands;
+	#has_newline = false;
 
 	multiline = false;
 
@@ -35,15 +37,23 @@ export class Context {
 	}
 
 	newline() {
-		this.multiline = true;
+		this.#has_newline = true;
 		this.#commands.push(newline);
 	}
 
+	space() {
+		this.#commands.push(space);
+	}
+
 	/**
 	 * @param {Context} context
 	 */
 	append(context) {
 		this.#commands.push(context.#commands);
+
+		if (this.#has_newline) {
+			this.multiline = true;
+		}
 	}
 
 	/**
@@ -59,6 +69,10 @@ export class Context {
 		} else {
 			this.#commands.push(content);
 		}
+
+		if (this.#has_newline) {
+			this.multiline = true;
+		}
 	}
 
 	/**

package/src/index.js

@@ -1,6 +1,6 @@
 /** @import { BaseNode, Command, Visitors, PrintOptions } from './types' */
 import { encode } from '@jridgewell/sourcemap-codec';
-import { Context, dedent, indent, margin, newline } from './context.js';
+import { Context, dedent, indent, margin, newline, space } from './context.js';
 
 /** @type {(str: string) => string} str */
 let btoa = () => {
@@ -91,6 +91,7 @@ export function print(node, visitors, opts = {}) {
 
 	let needs_newline = false;
 	let needs_margin = false;
+	let needs_space = false;
 
 	/** @param {Command} command */
 	function run(command) {
@@ -106,6 +107,8 @@ export function print(node, visitors, opts = {}) {
 				needs_newline = true;
 			} else if (command === margin) {
 				needs_margin = true;
+			} else if (command === space) {
+				needs_space = true;
 			} else if (command === indent) {
 				current_newline += indent_str;
 			} else if (command === dedent) {
@@ -117,9 +120,11 @@ export function print(node, visitors, opts = {}) {
 
 		if (needs_newline) {
 			append(needs_margin ? '\n' + current_newline : current_newline);
+		} else if (needs_space) {
+			append(' ');
 		}
 
-		needs_margin = needs_newline = false;
+		needs_margin = needs_newline = needs_space = false;
 
 		if (typeof command === 'string') {
 			append(command);

package/src/languages/ts/index.js

@@ -139,7 +139,6 @@ export default (options = {}) => {
 	 * @param {Context} context
 	 * @param {{ line: number, column: number } | null} prev
 	 * @param {{ line: number, column: number } | null} next
-	 * @returns {boolean} true if final comment is a line comment
 	 */
 	function flush_trailing_comments(context, prev, next) {
 		while (comment_index < comments.length) {
@@ -157,14 +156,14 @@ export default (options = {}) => {
 				comment_index += 1;
 
 				if (comment.type === 'Line') {
-					return true;
+					context.newline();
+				} else {
+					continue;
 				}
-			} else {
-				break;
 			}
-		}
 
-		return false;
+			break;
+		}
 	}
 
 	/**
@@ -226,9 +225,7 @@ export default (options = {}) => {
 			}
 
 			const next = i === nodes.length - 1 ? until : nodes[i + 1]?.loc?.start || null;
-			if (child && flush_trailing_comments(child_context, child.loc?.end || null, next)) {
-				multiline = true;
-			}
+			flush_trailing_comments(child_context, child?.loc?.end || null, next);
 
 			length += child_context.measure() + 1;
 			multiline ||= child_context.multiline;
@@ -293,7 +290,8 @@ export default (options = {}) => {
 		let prev_type = null;
 		let prev_multiline = false;
 
-		for (const child of node.body) {
+		for (let i = 0; i < node.body.length; i += 1) {
+			const child = node.body[i];
 			if (child.type === 'EmptyStatement') continue;
 
 			const child_context = context.new();
@@ -309,6 +307,12 @@ export default (options = {}) => {
 
 			context.append(child_context);
 
+			flush_trailing_comments(
+				context,
+				child.loc?.end || null,
+				node.body[i + 1]?.loc?.end ?? node.loc?.end ?? null
+			);
+
 			prev_type = child.type;
 			prev_multiline = child_context.multiline;
 		}
@@ -472,9 +476,7 @@ export default (options = {}) => {
 					? (node.loc?.end ?? null)
 					: (node.arguments[i + 1]?.loc?.start ?? null);
 
-				if (flush_trailing_comments(context, arg.loc?.end ?? null, next)) {
-					child_context.multiline = true;
-				}
+				flush_trailing_comments(context, arg.loc?.end ?? null, next);
 
 				if (!is_last) context.append(join);
 			}
@@ -503,6 +505,8 @@ export default (options = {}) => {
 				context.write('declare ');
 			}
 
+			if (node.abstract) context.write('abstract ');
+
 			context.write('class ');
 
 			if (node.id) {
@@ -569,6 +573,130 @@ export default (options = {}) => {
 			context.visit(node.body);
 		},
 
+		/**
+		 * @param {TSESTree.MethodDefinition | TSESTree.TSAbstractMethodDefinition} node
+		 * @param {Context} context
+		 */
+		'MethodDefinition|TSAbstractMethodDefinition': (node, context) => {
+			if (node.decorators) {
+				for (const decorator of node.decorators) {
+					context.visit(decorator);
+				}
+			}
+
+			// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+			if (node.abstract || node.type === 'TSAbstractMethodDefinition') {
+				context.write('abstract ');
+			}
+
+			if (node.static) {
+				context.write('static ');
+			}
+
+			if (node.kind === 'get' || node.kind === 'set') {
+				// Getter or setter
+				context.write(node.kind + ' ');
+			}
+
+			if (node.value.async) {
+				context.write('async ');
+			}
+
+			if (node.value.generator) {
+				context.write('*');
+			}
+
+			if (node.computed) context.write('[');
+			context.visit(node.key);
+			if (node.computed) context.write(']');
+
+			context.write('(');
+			sequence(
+				context,
+				node.value.params,
+				(node.value.returnType ?? node.value.body)?.loc?.start ?? node.loc?.end ?? null,
+				false
+			);
+			context.write(')');
+
+			if (node.value.returnType) context.visit(node.value.returnType);
+
+			context.write(' ');
+
+			if (node.value.body) context.visit(node.value.body);
+		},
+
+		/**
+		 * @param {TSESTree.PropertyDefinition | TSESTree.TSAbstractPropertyDefinition | TSESTree.AccessorProperty | TSESTree.TSAbstractAccessorProperty} node
+		 * @param {Context} context
+		 */
+		'PropertyDefinition|TSAbstractPropertyDefinition|AccessorProperty|TSAbstractAccessorProperty': (
+			node,
+			context
+		) => {
+			if (node.decorators) {
+				for (const decorator of node.decorators) {
+					context.visit(decorator);
+				}
+			}
+
+			if (node.accessibility) {
+				context.write(node.accessibility + ' ');
+			}
+
+			if (
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				node.abstract ||
+				node.type === 'TSAbstractPropertyDefinition' ||
+				node.type === 'TSAbstractAccessorProperty'
+			) {
+				context.write('abstract ');
+			}
+
+			if (node.static) {
+				context.write('static ');
+			}
+
+			if (
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				node.accessor ||
+				node.type === 'AccessorProperty' ||
+				node.type === 'TSAbstractAccessorProperty'
+			) {
+				context.write('accessor ');
+			}
+
+			if (node.computed) {
+				context.write('[');
+				context.visit(node.key);
+				context.write(']');
+			} else {
+				context.visit(node.key);
+			}
+
+			if (node.typeAnnotation) {
+				if (node.type === 'AccessorProperty' || node.type === 'TSAbstractAccessorProperty') {
+					context.visit(node.typeAnnotation);
+				} else {
+					context.write(': ');
+					context.visit(node.typeAnnotation.typeAnnotation);
+				}
+			}
+
+			if (node.value) {
+				context.write(' = ');
+				context.visit(node.value);
+			}
+
+			context.write(';');
+
+			flush_trailing_comments(
+				context,
+				(node.value ?? node.typeAnnotation ?? node.key).loc?.end ?? null,
+				null
+			);
+		},
+
 		/**
 		 * @param {TSESTree.RestElement | TSESTree.SpreadElement} node
 		 * @param {Context} context
@@ -579,24 +707,80 @@ export default (options = {}) => {
 
 			// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
 			if (node.typeAnnotation) context.visit(node.typeAnnotation);
+		},
+
+		/**
+		 * @param {TSESTree.TSConstructSignatureDeclaration | TSESTree.TSCallSignatureDeclaration} node
+		 * @param {Context} context
+		 */
+		'TSConstructSignatureDeclaration|TSCallSignatureDeclaration': (node, context) => {
+			if (node.type === 'TSConstructSignatureDeclaration') context.write('new');
+
+			if (node.typeParameters) {
+				context.visit(node.typeParameters);
+			}
+
+			context.write('(');
+
+			sequence(
+				context,
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				node.parameters ?? node.params,
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				(node.typeAnnotation ?? node.returnType)?.loc?.start ?? null,
+				false
+			);
+			context.write(')');
+
+			// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+			if (node.typeAnnotation || node.returnType) {
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				context.visit(node.typeAnnotation ?? node.returnType);
+			}
+		},
+
+		/**
+		 * @param {TSESTree.TSFunctionType | TSESTree.TSConstructorType} node
+		 * @param {Context} context
+		 */
+		'TSFunctionType|TSConstructorType': (node, context) => {
+			if (node.type === 'TSConstructorType') context.write('new ');
+			if (node.typeParameters) context.visit(node.typeParameters);
+
+			context.write('(');
+
+			sequence(
+				context,
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				node.parameters ?? node.params,
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				node.typeAnnotation?.typeAnnotation?.loc?.start ??
+					node.returnType?.typeAnnotation?.loc?.start ??
+					null,
+				false
+			);
+
+			context.write(') => ');
+
+			// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+			context.visit(node.typeAnnotation?.typeAnnotation ?? node.returnType?.typeAnnotation);
 		}
 	};
 
 	return {
 		_(node, context, visit) {
-			const is_statement = /(Statement|Declaration)$/.test(node.type);
-
 			if (node.loc) {
 				flush_comments_until(context, null, node.loc.start, true);
 			}
 
 			visit(node);
-
-			if (is_statement && node.loc) {
-				flush_trailing_comments(context, node.loc.end, null);
-			}
 		},
 
+		AccessorProperty:
+			shared[
+				'PropertyDefinition|TSAbstractPropertyDefinition|AccessorProperty|TSAbstractAccessorProperty'
+			],
+
 		ArrayExpression: shared['ArrayExpression|ArrayPattern'],
 
 		ArrayPattern: shared['ArrayExpression|ArrayPattern'],
@@ -802,7 +986,11 @@ export default (options = {}) => {
 
 			context.visit(node.local);
 
-			if (node.local.name !== node.exported.name) {
+			if (
+				node.local.type === 'Identifier' &&
+				node.exported.type === 'Identifier' &&
+				node.local.name !== node.exported.name
+			) {
 				context.write(' as ');
 				context.visit(node.exported);
 			}
@@ -868,7 +1056,8 @@ export default (options = {}) => {
 			context.visit(node.consequent);
 
 			if (node.alternate) {
-				context.write(' else ');
+				context.space();
+				context.write('else ');
 				context.visit(node.alternate);
 			}
 		},
@@ -948,11 +1137,19 @@ export default (options = {}) => {
 					context.visit(node.arguments[index]);
 				}
 			}
+			if (node.options) {
+				context.write(', ');
+				context.visit(node.options);
+			}
 			context.write(')');
 		},
 
 		ImportSpecifier(node, context) {
-			if (node.local.name !== node.imported.name) {
+			if (
+				node.local.type === 'Identifier' &&
+				node.imported.type === 'Identifier' &&
+				node.local.name !== node.imported.name
+			) {
 				context.visit(node.imported);
 				context.write(' as ');
 			}
@@ -1008,49 +1205,7 @@ export default (options = {}) => {
 			context.visit(node.property);
 		},
 
-		MethodDefinition(node, context) {
-			if (node.decorators) {
-				for (const decorator of node.decorators) {
-					context.visit(decorator);
-				}
-			}
-
-			if (node.static) {
-				context.write('static ');
-			}
-
-			if (node.kind === 'get' || node.kind === 'set') {
-				// Getter or setter
-				context.write(node.kind + ' ');
-			}
-
-			if (node.value.async) {
-				context.write('async ');
-			}
-
-			if (node.value.generator) {
-				context.write('*');
-			}
-
-			if (node.computed) context.write('[');
-			context.visit(node.key);
-			if (node.computed) context.write(']');
-
-			context.write('(');
-			sequence(
-				context,
-				node.value.params,
-				(node.value.returnType ?? node.value.body)?.loc?.start ?? node.loc?.end ?? null,
-				false
-			);
-			context.write(')');
-
-			if (node.value.returnType) context.visit(node.value.returnType);
-
-			context.write(' ');
-
-			if (node.value.body) context.visit(node.value.body);
-		},
+		MethodDefinition: shared['MethodDefinition|TSAbstractMethodDefinition'],
 
 		NewExpression: shared['CallExpression|NewExpression'],
 
@@ -1070,7 +1225,9 @@ export default (options = {}) => {
 
 		// @ts-expect-error this isn't a real node type, but Acorn produces it
 		ParenthesizedExpression(node, context) {
-			return context.visit(node.expression);
+			context.write('(');
+			context.visit(node.expression);
+			context.write(')');
 		},
 
 		PrivateIdentifier(node, context) {
@@ -1127,47 +1284,10 @@ export default (options = {}) => {
 			}
 		},
 
-		PropertyDefinition(node, context) {
-			if (node.decorators) {
-				for (const decorator of node.decorators) {
-					context.visit(decorator);
-				}
-			}
-
-			if (node.accessibility) {
-				context.write(node.accessibility + ' ');
-			}
-
-			if (node.static) {
-				context.write('static ');
-			}
-
-			if (node.computed) {
-				context.write('[');
-				context.visit(node.key);
-				context.write(']');
-			} else {
-				context.visit(node.key);
-			}
-
-			if (node.typeAnnotation) {
-				context.write(': ');
-				context.visit(node.typeAnnotation.typeAnnotation);
-			}
-
-			if (node.value) {
-				context.write(' = ');
-				context.visit(node.value);
-			}
-
-			context.write(';');
-
-			flush_trailing_comments(
-				context,
-				(node.value ?? node.typeAnnotation ?? node.key).loc?.end ?? null,
-				null
-			);
-		},
+		PropertyDefinition:
+			shared[
+				'PropertyDefinition|TSAbstractPropertyDefinition|AccessorProperty|TSAbstractAccessorProperty'
+			],
 
 		RestElement: shared['RestElement|SpreadElement'],
 
@@ -1372,6 +1492,18 @@ export default (options = {}) => {
 			}
 		},
 
+		TSAbstractMethodDefinition: shared['MethodDefinition|TSAbstractMethodDefinition'],
+
+		TSAbstractAccessorProperty:
+			shared[
+				'PropertyDefinition|TSAbstractPropertyDefinition|AccessorProperty|TSAbstractAccessorProperty'
+			],
+
+		TSAbstractPropertyDefinition:
+			shared[
+				'PropertyDefinition|TSAbstractPropertyDefinition|AccessorProperty|TSAbstractAccessorProperty'
+			],
+
 		TSDeclareFunction(node, context) {
 			context.write('declare ');
 
@@ -1445,6 +1577,18 @@ export default (options = {}) => {
 			context.write('undefined', node);
 		},
 
+		TSObjectKeyword(node, context) {
+			context.write('object', node);
+		},
+
+		TSBigIntKeyword(node, context) {
+			context.write('bigint', node);
+		},
+
+		TSIntrinsicKeyword(node, context) {
+			context.write('intrinsic', node);
+		},
+
 		TSArrayType(node, context) {
 			context.visit(node.elementType);
 			context.write('[]');
@@ -1475,11 +1619,70 @@ export default (options = {}) => {
 			}
 		},
 
+		TSTypeOperator(node, context) {
+			context.write(node.operator + ' ');
+			if (node.typeAnnotation) {
+				context.visit(node.typeAnnotation);
+			}
+		},
+
+		TSTemplateLiteralType(node, context) {
+			context.write('`');
+			const { quasis, types } = node;
+			for (let i = 0; i < types.length; i++) {
+				const raw = quasis[i].value.raw;
+
+				context.write(raw + '${');
+				context.visit(types[i]);
+				context.write('}');
+
+				if (/\n/.test(raw)) context.multiline = true;
+			}
+			context.write('`');
+		},
+
+		TSParameterProperty(node, context) {
+			if (node.accessibility) {
+				context.write(node.accessibility + ' ');
+			}
+
+			if (node.readonly) {
+				context.write('readonly ');
+			}
+
+			context.visit(node.parameter);
+		},
+
+		TSExportAssignment(node, context) {
+			context.write('export = ');
+			context.visit(node.expression);
+			context.write(';');
+		},
+
+		TSNamespaceExportDeclaration(node, context) {
+			context.write('export as namespace ');
+			context.visit(node.id);
+			context.write(';');
+		},
+
 		//@ts-expect-error I don't know why, but this is relied upon in the tests, but doesn't exist in the TSESTree types
 		TSExpressionWithTypeArguments(node, context) {
 			context.visit(node.expression);
 		},
 
+		TSTypeAssertion(node, context) {
+			context.write('<');
+			context.visit(node.typeAnnotation);
+			context.write('>');
+			if (EXPRESSIONS_PRECEDENCE[node.expression.type] < EXPRESSIONS_PRECEDENCE.TSTypeAssertion) {
+				context.write('(');
+				context.visit(node.expression);
+				context.write(')');
+			} else {
+				context.visit(node.expression);
+			}
+		},
+
 		TSTypeParameterInstantiation(node, context) {
 			context.write('<');
 			for (let i = 0; i < node.params.length; i++) {
@@ -1499,8 +1702,9 @@ export default (options = {}) => {
 		},
 
 		TSTypeParameter(node, context) {
+			if (node.name && node.name.type) context.visit(node.name);
 			// @ts-expect-error type mismatch TSESTree and acorn-typescript?
-			context.write(node.name, node);
+			else context.write(node.name, node);
 
 			if (node.constraint) {
 				context.write(' extends ');
@@ -1508,11 +1712,35 @@ export default (options = {}) => {
 			}
 		},
 
+		TSTypePredicate(node, context) {
+			if (node.parameterName) {
+				context.visit(node.parameterName);
+			} else if (node.typeAnnotation) {
+				context.visit(node.typeAnnotation);
+			}
+
+			if (node.asserts) {
+				context.write(' asserts ');
+			} else {
+				context.write(' is ');
+			}
+
+			if (node.typeAnnotation) {
+				context.visit(node.typeAnnotation.typeAnnotation);
+			}
+		},
+
 		TSTypeQuery(node, context) {
 			context.write('typeof ');
 			context.visit(node.exprName);
 		},
 
+		TSClassImplements(node, context) {
+			if (node.expression) {
+				context.visit(node.expression);
+			}
+		},
+
 		TSEnumMember(node, context) {
 			context.visit(node.id);
 			if (node.initializer) {
@@ -1521,25 +1749,7 @@ export default (options = {}) => {
 			}
 		},
 
-		TSFunctionType(node, context) {
-			if (node.typeParameters) context.visit(node.typeParameters);
-
-			context.write('(');
-
-			sequence(
-				context,
-				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
-				node.parameters,
-				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
-				node.typeAnnotation.typeAnnotation.loc?.start ?? null,
-				false
-			);
-
-			context.write(') => ');
-
-			// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
-			context.visit(node.typeAnnotation.typeAnnotation);
-		},
+		TSFunctionType: shared['TSFunctionType|TSConstructorType'],
 
 		TSIndexSignature(node, context) {
 			context.write('[');
@@ -1552,17 +1762,45 @@ export default (options = {}) => {
 			context.visit(node.typeAnnotation);
 		},
 
+		TSMappedType(node, context) {
+			context.write('{[');
+
+			if (node.typeParameter) {
+				context.visit(node.typeParameter);
+			} else {
+				context.visit(node.key);
+				context.write(' in ');
+				context.visit(node.constraint);
+			}
+
+			context.write(']');
+			if (node.typeAnnotation) {
+				context.write(': ');
+				context.visit(node.typeAnnotation);
+			}
+			context.write('}');
+		},
+
 		TSMethodSignature(node, context) {
 			context.visit(node.key);
 
 			context.write('(');
 
-			// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
-			sequence(context, node.parameters, node.typeAnnotation.loc?.start ?? null, false);
+			sequence(
+				context,
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				node.parameters ?? node.params,
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				(node.typeAnnotation ?? node.returnType)?.loc?.start ?? null,
+				false
+			);
 			context.write(')');
 
 			// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
-			context.visit(node.typeAnnotation);
+			if (node.typeAnnotation || node.returnType) {
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				context.visit(node.typeAnnotation ?? node.returnType);
+			}
 		},
 
 		TSTupleType(node, context) {
@@ -1585,10 +1823,18 @@ export default (options = {}) => {
 			sequence(context, node.types, node.loc?.end ?? null, false, ' &');
 		},
 
+		TSInferType(node, context) {
+			context.write('infer ');
+			context.visit(node.typeParameter);
+		},
+
 		TSLiteralType(node, context) {
 			context.visit(node.literal);
 		},
 
+		TSCallSignatureDeclaration:
+			shared['TSConstructSignatureDeclaration|TSCallSignatureDeclaration'],
+
 		TSConditionalType(node, context) {
 			context.visit(node.checkType);
 			context.write(' extends ');
@@ -1599,6 +1845,17 @@ export default (options = {}) => {
 			context.visit(node.falseType);
 		},
 
+		TSConstructSignatureDeclaration:
+			shared['TSConstructSignatureDeclaration|TSCallSignatureDeclaration'],
+
+		TSConstructorType: shared['TSFunctionType|TSConstructorType'],
+
+		TSExternalModuleReference(node, context) {
+			context.write('require(');
+			context.visit(node.expression);
+			context.write(');');
+		},
+
 		TSIndexedAccessType(node, context) {
 			context.visit(node.objectType);
 			context.write('[');
@@ -1606,6 +1863,13 @@ export default (options = {}) => {
 			context.write(']');
 		},
 
+		TSImportEqualsDeclaration(node, context) {
+			context.write('import ');
+			context.visit(node.id);
+			context.write(' = ');
+			context.visit(node.moduleReference);
+		},
+
 		TSImportType(node, context) {
 			context.write('import(');
 			context.visit(node.argument);
@@ -1617,6 +1881,20 @@ export default (options = {}) => {
 			}
 		},
 
+		TSOptionalType(node, context) {
+			context.visit(node.typeAnnotation);
+			context.write('?');
+		},
+
+		TSRestType(node, context) {
+			context.write('...');
+			context.visit(node.typeAnnotation);
+		},
+
+		TSThisType(node, context) {
+			context.write('this', node);
+		},
+
 		TSAsExpression(node, context) {
 			if (node.expression) {
 				const needs_parens =
@@ -1640,7 +1918,7 @@ export default (options = {}) => {
 			context.write(' {');
 			context.indent();
 			context.newline();
-			sequence(context, node.members, node.loc?.end ?? null, false);
+			sequence(context, node.members ?? node.body.members, node.loc?.end ?? null, false);
 			context.dedent();
 			context.newline();
 			context.write('}');
@@ -1679,7 +1957,7 @@ export default (options = {}) => {
 			context.write('interface ');
 			context.visit(node.id);
 			if (node.typeParameters) context.visit(node.typeParameters);
-			if (node.extends) {
+			if (node.extends && node.extends.length > 0) {
 				context.write(' extends ');
 				sequence(context, node.extends, node.body.loc?.start ?? null, false);
 			}
@@ -1688,6 +1966,24 @@ export default (options = {}) => {
 			context.write('}');
 		},
 
+		TSInstantiationExpression(node, context) {
+			context.visit(node.expression);
+			context.visit(node.typeArguments);
+		},
+
+		TSInterfaceHeritage(node, context) {
+			if (node.expression) {
+				context.visit(node.expression);
+			}
+		},
+
+		//@ts-expect-error I don't know why, but this is relied upon in the tests, but doesn't exist in the TSESTree types
+		TSParenthesizedType(node, context) {
+			context.write('(');
+			context.visit(node.typeAnnotation);
+			context.write(')');
+		},
+
 		TSSatisfiesExpression(node, context) {
 			if (node.expression) {
 				const needs_parens =

package/types/index.d.ts

@@ -48,6 +48,7 @@ declare module 'esrap' {
 		dedent(): void;
 		margin(): void;
 		newline(): void;
+		space(): void;
 		
 		append(context: Context): void;
 		

package/types/index.d.ts.map

@@ -34,6 +34,6 @@
 		null,
 		null
 	],
-	"mappings": ";MAGYA,QAAQA;;;;;;;;MAQfC,MAAMA;;MAENC,mBAAmBA;;;;MAIZC,OAAOA;;aAEPC,QAAQA;;;;WAwBHC,QAAQA;;;;;;MAWbC,OAAOA;;kBAEFC,YAAYA;;;;;;;;;iBCHbC,KAAKA;;;;cC7CRC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCAPC,sBAAsBA;;aAHZC,IAAIA;MCLfC,SAASA;;;;;WAKXC,QAAQA;;;;;;;kBAODC,OAAOA;;;;;;;;;;MJTZd,QAAQA;;;;;;;;MAQfC,MAAMA;;MAENC,mBAAmBA;;;;MAIZC,OAAOA;;MAEPC,QAAQA;;;;;;;;;;;aKdGO,IAAIA;MDLfC,SAASA;;;;;WAKXC,QAAQA;;;;;;;kBAODC,OAAOA;;;;;;;;;;MJTZd,QAAQA;;;;;;;;MAQfC,MAAMA;;MAENC,mBAAmBA;;;;MAIZC,OAAOA;;MAEPC,QAAQA",
+	"mappings": ";MAGYA,QAAQA;;;;;;;;MAQfC,MAAMA;;MAENC,mBAAmBA;;;;MAIZC,OAAOA;;aAEPC,QAAQA;;;;WAwBHC,QAAQA;;;;;;MAWbC,OAAOA;;kBAEFC,YAAYA;;;;;;;;;iBCHbC,KAAKA;;;;cC5CRC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCDPC,sBAAsBA;;aAHZC,IAAIA;MCLfC,SAASA;;;;;WAKXC,QAAQA;;;;;;;kBAODC,OAAOA;;;;;;;;;;MJTZd,QAAQA;;;;;;;;MAQfC,MAAMA;;MAENC,mBAAmBA;;;;MAIZC,OAAOA;;MAEPC,QAAQA;;;;;;;;;;;aKdGO,IAAIA;MDLfC,SAASA;;;;;WAKXC,QAAQA;;;;;;;kBAODC,OAAOA;;;;;;;;;;MJTZd,QAAQA;;;;;;;;MAQfC,MAAMA;;MAENC,mBAAmBA;;;;MAIZC,OAAOA;;MAEPC,QAAQA",
 	"ignoreList": []
 }