espolar 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -70,18 +70,29 @@ interface PrintOptions<Data> {
   printers?: Printers<Data>;
   getLeadingComments?: (node: AST.Node) => Comment[] | undefined;
   getTrailingComments?: (node: AST.Node) => Comment[] | undefined;
+  /**
+   * Provide additional source range for the left parenthesis of `CallExpression` and `NewExpression`.
+   * This is useful for language tools that want to provide signature hints when user enter `(`.
+   *
+   * @notes This hook will not interact with parentheses around the callee.
+   *
+   * @param node The `CallExpression` or `NewExpression` node.
+   * @returns The source range of the left parenthesis, `undefined` if not available.
+   */
+  experimentalGetLeftParenSourceRange?: (node: AST.CallExpression | AST.NewExpression) => SourceRange | undefined;
 }
-interface PrinterContext<Data> {
+interface PrinterContext<Data = any> {
+  readonly options: PrintOptions<Data>;
   readonly source: string;
   readonly generatedOffset: number;
   write(text: string): void;
+  writeMapped(text: string, sourceStart: number, sourceEnd: number, data?: Data): void;
   writeNode(node: AST.Node | null | undefined): void;
   writeNodeList(nodes: readonly (AST.Node | null | undefined)[], separator: string): void;
   writeNodeListWithSourceGaps(nodes: readonly (AST.Node | null | undefined)[], fallbackSeparator: string): void;
-  writePreservedNode(node: AST.Node): void;
   writeSource(start: number, end: number, data: Data): void;
-  getLeadingComments: (node: AST.Node) => Comment[] | undefined;
-  getTrailingComments: (node: AST.Node) => Comment[] | undefined;
+  writePreservedNode(node: AST.Node): void;
+  appendMapping(sourceRange: SourceRange, generatedStart: number, generatedEnd: number, data?: Data): void;
 }
 type NodePrinter<Key extends AST_NODE_TYPES, Data> = (node: Extract<AST.Node, {
   type: Key;
@@ -96,4 +107,280 @@ declare function defaultIsUntouched(node: AST.Node): boolean | SourceRange;
 declare function defaultGetMappingData(node?: AST.Node | null): unknown;
 declare function defaultCombineMappingData(left: unknown, right: unknown): unknown;
 //#endregion
-export { type AST, type Comment, type NodeLike, type NodePrinter, type PrintOptions, type PrintResult, type PrinterContext, defaultCombineMappingData, defaultGetMappingData, defaultIsUntouched, print };
+//#region src/printers.d.ts
+declare const defaultPrinters: {
+  Program: typeof printProgram;
+  Identifier: typeof printIdentifier;
+  PrivateIdentifier: typeof printPrivateIdentifier;
+  Literal: typeof printLiteral;
+  ExpressionStatement: typeof printExpressionStatement;
+  EmptyStatement: typeof printEmptyStatement;
+  VariableDeclaration: typeof printVariableDeclaration;
+  VariableDeclarator: typeof printVariableDeclarator;
+  BlockStatement: typeof printBlockStatement;
+  ReturnStatement: typeof printReturnStatement;
+  ThrowStatement: typeof printThrowStatement;
+  DebuggerStatement: typeof printDebuggerStatement;
+  BreakStatement: typeof printBreakStatement;
+  ContinueStatement: typeof printContinueStatement;
+  LabeledStatement: typeof printLabeledStatement;
+  WhileStatement: typeof printWhileStatement;
+  DoWhileStatement: typeof printDoWhileStatement;
+  IfStatement: typeof printIfStatement;
+  ForStatement: typeof printForStatement;
+  ForInStatement: typeof printForInStatement;
+  ForOfStatement: typeof printForOfStatement;
+  SwitchStatement: typeof printSwitchStatement;
+  SwitchCase: typeof printSwitchCase;
+  TryStatement: typeof printTryStatement;
+  WithStatement: typeof printWithStatement;
+  FunctionDeclaration: typeof printFunctionDeclaration;
+  FunctionExpression: typeof printFunctionExpression;
+  ArrowFunctionExpression: typeof printArrowFunctionExpression;
+  UnaryExpression: typeof printUnaryExpression;
+  UpdateExpression: typeof printUpdateExpression;
+  BinaryExpression: typeof printBinaryExpression;
+  LogicalExpression: typeof printBinaryExpression;
+  AssignmentExpression: typeof printBinaryExpression;
+  ConditionalExpression: typeof printConditionalExpression;
+  YieldExpression: typeof printYieldExpression;
+  AwaitExpression: typeof printAwaitExpression;
+  SequenceExpression: typeof printSequenceExpression;
+  CallExpression: typeof printCallExpression;
+  NewExpression: typeof printNewExpression;
+  ChainExpression: typeof printChainExpression;
+  MemberExpression: typeof printMemberExpression;
+  ObjectExpression: typeof printObjectExpression;
+  ObjectPattern: typeof printObjectPattern;
+  ArrayExpression: typeof printArrayExpression;
+  ArrayPattern: typeof printArrayPattern;
+  Property: typeof printProperty;
+  SpreadElement: typeof printSpreadElement;
+  RestElement: typeof printRestElement;
+  AssignmentPattern: typeof printAssignmentPattern;
+  TemplateLiteral: typeof printTemplateLiteral;
+  TaggedTemplateExpression: typeof printTaggedTemplateExpression;
+  ThisExpression: typeof printThisExpression;
+  Super: typeof printSuper;
+  MetaProperty: typeof printMetaProperty;
+  ParenthesizedExpression: typeof printParenthesizedExpression;
+  ClassDeclaration: typeof printClassDeclaration;
+  ClassExpression: typeof printClassExpression;
+  ClassBody: typeof printClassBody;
+  StaticBlock: typeof printStaticBlock;
+  PropertyDefinition: typeof printPropertyDefinition;
+  AccessorProperty: typeof printPropertyDefinition;
+  MethodDefinition: typeof printMethodDefinition;
+  Decorator: typeof printDecorator;
+  ImportDeclaration: typeof printImportDeclaration;
+  ImportExpression: typeof printImportExpression;
+  ImportSpecifier: typeof printImportSpecifier;
+  ExportNamedDeclaration: typeof printExportNamedDeclaration;
+  ExportDefaultDeclaration: typeof printExportDefaultDeclaration;
+  ExportAllDeclaration: typeof printExportAllDeclaration;
+  ExportSpecifier: typeof printExportSpecifier;
+  TSAsExpression: typeof printTSAsExpression;
+  TSSatisfiesExpression: typeof printTSSatisfiesExpression;
+  TSTypeAssertion: typeof printTSTypeAssertion;
+  TSNonNullExpression: typeof printTSNonNullExpression;
+  TSTypeAnnotation: typeof printTSTypeAnnotation;
+  TSTypeAliasDeclaration: typeof printTSTypeAliasDeclaration;
+  TSInterfaceDeclaration: typeof printTSInterfaceDeclaration;
+  TSExpressionWithTypeArguments: typeof printTSExpressionWithTypeArguments;
+  TSClassImplements: typeof printTSExpressionWithTypeArguments;
+  TSInterfaceHeritage: typeof printTSExpressionWithTypeArguments;
+  TSFunctionType: typeof printTSFunctionType;
+  TSConstructorType: typeof printTSConstructorType;
+  TSMethodSignature: typeof printTSMethodSignature;
+  TSCallSignatureDeclaration: typeof printTSCallSignatureDeclaration;
+  TSConstructSignatureDeclaration: typeof printTSConstructSignatureDeclaration;
+  TSIndexSignature: typeof printTSIndexSignature;
+  TSPropertySignature: typeof printTSPropertySignature;
+  TSTypeParameterDeclaration: typeof printTypeParameterDeclaration;
+  TSTypeParameterInstantiation: typeof printTypeParameterInstantiation;
+  TSTypeParameter: typeof printTSTypeParameter;
+  TSTypeReference: typeof printTSTypeReference;
+  TSQualifiedName: typeof printTSQualifiedName;
+  TSUnionType: typeof printJoinedTypes;
+  TSIntersectionType: typeof printJoinedTypes;
+  TSArrayType: typeof printTSArrayType;
+  TSTupleType: typeof printTSTupleType;
+  TSNamedTupleMember: typeof printTSNamedTupleMember;
+  TSTypeLiteral: typeof printTSTypeLiteral;
+  TSTypeOperator: typeof printTSTypeOperator;
+  TSTypePredicate: typeof printTSTypePredicate;
+  TSTypeQuery: typeof printTSTypeQuery;
+  TSMappedType: typeof printTSMappedType;
+  TSConditionalType: typeof printTSConditionalType;
+  TSInferType: typeof printTSInferType;
+  TSIndexedAccessType: typeof printTSIndexedAccessType;
+  TSOptionalType: typeof printTSOptionalType;
+  TSRestType: typeof printTSRestType;
+  TSThisType: typeof printTSThisType;
+  TSLiteralType: typeof printTSLiteralType;
+  TSTemplateLiteralType: typeof printTSTemplateLiteralType;
+  TSImportType: typeof printTSImportType;
+  TSImportEqualsDeclaration: typeof printTSImportEqualsDeclaration;
+  TSExternalModuleReference: typeof printTSExternalModuleReference;
+  TSEnumDeclaration: typeof printTSEnumDeclaration;
+  TSEnumMember: typeof printTSEnumMember;
+  TSModuleDeclaration: typeof printTSModuleDeclaration;
+  TSModuleBlock: typeof printTSModuleBlock;
+  TSDeclareFunction: typeof printTSDeclareFunction;
+  TSParameterProperty: typeof printTSParameterProperty;
+  TSAbstractMethodDefinition: typeof printMethodDefinition;
+  TSAbstractPropertyDefinition: typeof printPropertyDefinition;
+  TSAbstractAccessorProperty: typeof printPropertyDefinition;
+  TSExportAssignment: typeof printTSExportAssignment;
+  TSNamespaceExportDeclaration: typeof printTSNamespaceExportDeclaration;
+  TSInstantiationExpression: typeof printTSInstantiationExpression;
+  TSParenthesizedType: typeof printTSParenthesizedType;
+  TSInterfaceBody: typeof printTSInterfaceBody;
+  TSStringKeyword: typeof printKeywordType;
+  TSNumberKeyword: typeof printKeywordType;
+  TSBooleanKeyword: typeof printKeywordType;
+  TSVoidKeyword: typeof printKeywordType;
+  TSUnknownKeyword: typeof printKeywordType;
+  TSAnyKeyword: typeof printKeywordType;
+  TSNeverKeyword: typeof printKeywordType;
+  TSNullKeyword: typeof printKeywordType;
+  TSUndefinedKeyword: typeof printKeywordType;
+  TSObjectKeyword: typeof printKeywordType;
+  TSSymbolKeyword: typeof printKeywordType;
+  TSBigIntKeyword: typeof printKeywordType;
+  TSIntrinsicKeyword: typeof printKeywordType;
+};
+declare function printProgram(program: AST.Program, context: PrinterContext): void;
+declare function printExpressionStatement(statement: AST.ExpressionStatement, context: PrinterContext): void;
+declare function printEmptyStatement(_statement: AST.EmptyStatement, context: PrinterContext): void;
+declare function printVariableDeclaration(declaration: AST.VariableDeclaration, context: PrinterContext): void;
+declare function printVariableDeclarator(declarator: AST.VariableDeclarator, context: PrinterContext): void;
+declare function printBlockStatement(block: AST.BlockStatement, context: PrinterContext): void;
+declare function printReturnStatement(statement: AST.ReturnStatement, context: PrinterContext): void;
+declare function printThrowStatement(statement: AST.ThrowStatement, context: PrinterContext): void;
+declare function printDebuggerStatement(_statement: AST.DebuggerStatement, context: PrinterContext): void;
+declare function printBreakStatement(statement: AST.BreakStatement, context: PrinterContext): void;
+declare function printContinueStatement(statement: AST.ContinueStatement, context: PrinterContext): void;
+declare function printLabeledStatement(statement: AST.LabeledStatement, context: PrinterContext): void;
+declare function printWhileStatement(statement: AST.WhileStatement, context: PrinterContext): void;
+declare function printDoWhileStatement(statement: AST.DoWhileStatement, context: PrinterContext): void;
+declare function printIfStatement(statement: AST.IfStatement, context: PrinterContext): void;
+declare function printForStatement(statement: AST.ForStatement, context: PrinterContext): void;
+declare function printForInStatement(statement: AST.ForInStatement, context: PrinterContext): void;
+declare function printForOfStatement(statement: AST.ForOfStatement, context: PrinterContext): void;
+declare function printSwitchStatement(statement: AST.SwitchStatement, context: PrinterContext): void;
+declare function printSwitchCase(case_: AST.SwitchCase, context: PrinterContext): void;
+declare function printTryStatement(statement: AST.TryStatement, context: PrinterContext): void;
+declare function printWithStatement(statement: AST.WithStatement, context: PrinterContext): void;
+declare function printIdentifier(identifier: AST.Identifier, context: PrinterContext): void;
+declare function printPrivateIdentifier(identifier: AST.PrivateIdentifier, context: PrinterContext): void;
+declare function printLiteral(literal: AST.Literal, context: PrinterContext): void;
+declare function printUnaryExpression(expr: AST.UnaryExpression, context: PrinterContext): void;
+declare function printUpdateExpression(expr: AST.UpdateExpression, context: PrinterContext): void;
+declare function printBinaryExpression(expression: AST.AssignmentExpression | AST.LogicalExpression | AST.BinaryExpression, context: PrinterContext): void;
+declare function printConditionalExpression(expr: AST.ConditionalExpression, context: PrinterContext): void;
+declare function printYieldExpression(expr: AST.YieldExpression, context: PrinterContext): void;
+declare function printAwaitExpression(expr: AST.AwaitExpression, context: PrinterContext): void;
+declare function printSequenceExpression(expr: AST.SequenceExpression, context: PrinterContext): void;
+declare function printCallExpression(expression: AST.CallExpression, context: PrinterContext): void;
+declare function printNewExpression(expression: AST.NewExpression, context: PrinterContext): void;
+declare function printChainExpression(expression: AST.ChainExpression, context: PrinterContext): void;
+declare function printMemberExpression(expression: AST.MemberExpression, context: PrinterContext): void;
+declare function printObjectExpression(object: AST.ObjectExpression, context: PrinterContext): void;
+declare function printObjectPattern(pattern: AST.ObjectPattern, context: PrinterContext): void;
+declare function printArrayExpression(array: AST.ArrayExpression, context: PrinterContext): void;
+declare function printArrayPattern(pattern: AST.ArrayPattern, context: PrinterContext): void;
+declare function printProperty(property: AST.Property | AST.PropertyDefinition, context: PrinterContext): void;
+declare function printSpreadElement(spread: AST.SpreadElement, context: PrinterContext): void;
+declare function printRestElement(rest: AST.RestElement, context: PrinterContext): void;
+declare function printAssignmentPattern(pattern: AST.AssignmentPattern, context: PrinterContext): void;
+declare function printTemplateLiteral(node: AST.TemplateLiteral, context: PrinterContext): void;
+declare function printTaggedTemplateExpression(node: AST.TaggedTemplateExpression, context: PrinterContext): void;
+declare function printThisExpression(_node: AST.ThisExpression, context: PrinterContext): void;
+declare function printSuper(_node: AST.Super, context: PrinterContext): void;
+declare function printMetaProperty(node: AST.MetaProperty, context: PrinterContext): void;
+declare function printParenthesizedExpression(node: {
+  expression: AST.Node;
+}, context: PrinterContext): void;
+declare function printFunctionDeclaration(node: AST.FunctionDeclaration, context: PrinterContext): void;
+declare function printFunctionExpression(node: AST.FunctionExpression, context: PrinterContext): void;
+declare function printArrowFunctionExpression(fn: AST.ArrowFunctionExpression, context: PrinterContext): void;
+declare function printClassDeclaration(node: AST.ClassDeclaration, context: PrinterContext): void;
+declare function printClassExpression(node: AST.ClassExpression, context: PrinterContext): void;
+declare function printClassBody(node: AST.ClassBody, context: PrinterContext): void;
+declare function printStaticBlock(node: AST.StaticBlock, context: PrinterContext): void;
+declare function printDecorator(node: AST.Decorator, context: PrinterContext): void;
+declare function printPropertyDefinition(node: AST.PropertyDefinition | AST.AccessorProperty | AST.TSAbstractAccessorProperty | AST.TSAbstractPropertyDefinition, context: PrinterContext): void;
+declare function printMethodDefinition(node: AST.MethodDefinition | AST.TSAbstractMethodDefinition, context: PrinterContext): void;
+declare function printImportDeclaration(node: AST.ImportDeclaration, context: PrinterContext): void;
+declare function printImportExpression(node: AST.ImportExpression, context: PrinterContext): void;
+declare function printImportSpecifier(node: AST.ImportSpecifier, context: PrinterContext): void;
+declare function printExportNamedDeclaration(node: AST.ExportNamedDeclaration, context: PrinterContext): void;
+declare function printExportDefaultDeclaration(node: AST.ExportDefaultDeclaration, context: PrinterContext): void;
+declare function printExportAllDeclaration(node: AST.ExportAllDeclaration, context: PrinterContext): void;
+declare function printExportSpecifier(node: AST.ExportSpecifier, context: PrinterContext): void;
+declare function printTSAsExpression(expression: AST.TSAsExpression, context: PrinterContext): void;
+declare function printTSSatisfiesExpression(expression: AST.TSSatisfiesExpression, context: PrinterContext): void;
+declare function printTSTypeAssertion(expression: AST.TSTypeAssertion, context: PrinterContext): void;
+declare function printTSNonNullExpression(expression: AST.TSNonNullExpression, context: PrinterContext): void;
+declare function printTSTypeAnnotation(annotation: AST.TSTypeAnnotation, context: PrinterContext): void;
+declare function printTSTypeAliasDeclaration(alias: AST.TSTypeAliasDeclaration, context: PrinterContext): void;
+declare function printTSInterfaceDeclaration(node: AST.TSInterfaceDeclaration, context: PrinterContext): void;
+declare function printTSExpressionWithTypeArguments(node: {
+  expression: AST.Node;
+  typeArguments?: AST.Node;
+  typeParameters?: AST.Node;
+}, context: PrinterContext): void;
+declare function printTSInterfaceBody(body: AST.TSInterfaceBody, context: PrinterContext): void;
+declare function printTSPropertySignature(signature: AST.TSPropertySignature, context: PrinterContext): void;
+declare function printTypeParameterDeclaration(declaration: AST.TSTypeParameterDeclaration, context: PrinterContext): void;
+declare function printTypeParameterInstantiation(instantiation: AST.TSTypeParameterInstantiation, context: PrinterContext): void;
+declare function printTSTypeParameter(parameter: AST.TSTypeParameter, context: PrinterContext): void;
+declare function printTSFunctionType(type: AST.TSFunctionType, context: PrinterContext): void;
+declare function printTSConstructorType(type: AST.TSConstructorType, context: PrinterContext): void;
+declare function printTSMethodSignature(signature: AST.TSMethodSignature, context: PrinterContext): void;
+declare function printTSCallSignatureDeclaration(signature: AST.TSCallSignatureDeclaration, context: PrinterContext): void;
+declare function printTSConstructSignatureDeclaration(signature: AST.TSConstructSignatureDeclaration, context: PrinterContext): void;
+declare function printTSIndexSignature(signature: AST.TSIndexSignature, context: PrinterContext): void;
+declare function printTSTypeReference(reference: AST.TSTypeReference, context: PrinterContext): void;
+declare function printTSQualifiedName(name: AST.TSQualifiedName, context: PrinterContext): void;
+declare function printJoinedTypes(joined: AST.TSUnionType | AST.TSIntersectionType, context: PrinterContext): void;
+declare function printTSArrayType(array: AST.TSArrayType, context: PrinterContext): void;
+declare function printTSTupleType(node: AST.TSTupleType, context: PrinterContext): void;
+declare function printTSNamedTupleMember(node: AST.TSNamedTupleMember, context: PrinterContext): void;
+declare function printTSTypeLiteral(literal: AST.TSTypeLiteral, context: PrinterContext): void;
+declare function printTSTypeOperator(node: AST.TSTypeOperator, context: PrinterContext): void;
+declare function printTSTypePredicate(node: AST.TSTypePredicate, context: PrinterContext): void;
+declare function printTSTypeQuery(node: AST.TSTypeQuery, context: PrinterContext): void;
+declare function printTSMappedType(node: AST.TSMappedType, context: PrinterContext): void;
+declare function printTSConditionalType(node: AST.TSConditionalType, context: PrinterContext): void;
+declare function printTSInferType(node: AST.TSInferType, context: PrinterContext): void;
+declare function printTSIndexedAccessType(node: AST.TSIndexedAccessType, context: PrinterContext): void;
+declare function printTSOptionalType(node: AST.TSOptionalType, context: PrinterContext): void;
+declare function printTSRestType(node: AST.TSRestType, context: PrinterContext): void;
+declare function printTSThisType(_node: AST.TSThisType, context: PrinterContext): void;
+declare function printTSLiteralType(literal: AST.TSLiteralType, context: PrinterContext): void;
+declare function printTSTemplateLiteralType(node: AST.TSTemplateLiteralType, context: PrinterContext): void;
+declare function printTSImportType(node: AST.TSImportType, context: PrinterContext): void;
+declare function printTSImportEqualsDeclaration(node: AST.TSImportEqualsDeclaration, context: PrinterContext): void;
+declare function printTSExternalModuleReference(node: AST.TSExternalModuleReference, context: PrinterContext): void;
+declare function printTSEnumDeclaration(node: AST.TSEnumDeclaration, context: PrinterContext): void;
+declare function printTSEnumMember(node: AST.TSEnumMember, context: PrinterContext): void;
+declare function printTSModuleDeclaration(node: AST.TSModuleDeclaration, context: PrinterContext): void;
+declare function printTSModuleBlock(node: AST.TSModuleBlock, context: PrinterContext): void;
+declare function printTSDeclareFunction(node: AST.TSDeclareFunction, context: PrinterContext): void;
+declare function printTSParameterProperty(node: AST.TSParameterProperty, context: PrinterContext): void;
+declare function printTSExportAssignment(node: AST.TSExportAssignment, context: PrinterContext): void;
+declare function printTSNamespaceExportDeclaration(node: AST.TSNamespaceExportDeclaration, context: PrinterContext): void;
+declare function printTSInstantiationExpression(node: {
+  expression: AST.Node;
+  typeArguments: AST.Node;
+}, context: PrinterContext): void;
+declare function printTSParenthesizedType(node: {
+  typeAnnotation: AST.Node;
+}, context: PrinterContext): void;
+declare function printKeywordType(node: Extract<AST.Node, {
+  type: `${string}Keyword`;
+}>, context: PrinterContext): void;
+//#endregion
+export { type AST, type Comment, type NodeLike, type NodePrinter, type PrintOptions, type PrintResult, type PrinterContext, type SourceRange, defaultCombineMappingData, defaultGetMappingData, defaultIsUntouched, defaultPrinters, print };

package/dist/index.js

@@ -282,7 +282,7 @@ function printReturnStatement(statement, context) {
 	context.write("return");
 	if (statement.argument) {
 		context.write(" ");
-		const needsParensASi = (context.getLeadingComments?.(statement.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
+		const needsParensASi = (context.options.getLeadingComments?.(statement.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
 		if (needsParensASi) context.write("(");
 		context.writeNode(statement.argument);
 		if (needsParensASi) context.write(")");
@@ -292,7 +292,7 @@ function printReturnStatement(statement, context) {
 function printThrowStatement(statement, context) {
 	context.write("throw ");
 	if (statement.argument) {
-		const needsParensASi = (context.getLeadingComments?.(statement.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
+		const needsParensASi = (context.options.getLeadingComments?.(statement.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
 		if (needsParensASi) context.write("(");
 		context.writeNode(statement.argument);
 		if (needsParensASi) context.write(")");
@@ -454,7 +454,7 @@ function printUpdateExpression(expr, context) {
 		context.write(expr.operator);
 		context.writeNode(expr.argument);
 	} else {
-		const needsParensASi = (context.getTrailingComments?.(expr.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
+		const needsParensASi = (context.options.getTrailingComments?.(expr.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
 		if (needsParensASi) context.write("(");
 		context.writeNode(expr.argument);
 		if (needsParensASi) context.write(")");
@@ -493,7 +493,7 @@ function printYieldExpression(expr, context) {
 	context.write(expr.delegate === true ? "yield*" : "yield");
 	if (expr.argument) {
 		context.write(" ");
-		const needsParensASi = (context.getLeadingComments?.(expr.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
+		const needsParensASi = (context.options.getLeadingComments?.(expr.argument))?.some((c) => commentNeedsNewline(c)) ?? false;
 		if (needsParensASi) context.write("(");
 		context.writeNode(expr.argument);
 		if (needsParensASi) context.write(")");
@@ -525,7 +525,10 @@ function printCallExpression(expression, context) {
 		context.write(")");
 	} else context.writeNode(expression.callee);
 	if (expression.typeArguments) context.writeNode(expression.typeArguments);
-	context.write(expression.optional === true ? "?.(" : "(");
+	if (expression.optional === true) context.write("?.");
+	const parenRange = context.options.experimentalGetLeftParenSourceRange?.(expression);
+	if (parenRange) context.writeMapped("(", parenRange.start, parenRange.end);
+	else context.write("(");
 	context.writeNodeList(expression.arguments, ", ");
 	context.write(")");
 }
@@ -537,7 +540,9 @@ function printNewExpression(expression, context) {
 		context.write(")");
 	} else context.writeNode(expression.callee);
 	if (expression.typeArguments) context.writeNode(expression.typeArguments);
-	context.write("(");
+	const parenRange = context.options.experimentalGetLeftParenSourceRange?.(expression);
+	if (parenRange) context.writeMapped("(", parenRange.start, parenRange.end);
+	else context.write("(");
 	context.writeNodeList(expression.arguments, ", ");
 	context.write(")");
 }
@@ -896,8 +901,8 @@ function printExportNamedDeclaration(node, context) {
 function printExportDefaultDeclaration(node, context) {
 	let decl = node.declaration;
 	if ("decorators" in decl && decl.decorators && decl.decorators.length > 0) {
-		for (const d of decl.decorators) context.writeNode(d);
-		const { decorators: _, ...rest } = decl;
+		const { decorators, ...rest } = decl;
+		for (const d of decorators) context.writeNode(d);
 		decl = rest;
 	}
 	context.write("export default ");
@@ -1385,8 +1390,6 @@ function createPrinterContext(options) {
 		...defaultPrinters,
 		...options.printers
 	};
-	const getLeadingComments = options.getLeadingComments ?? (() => void 0);
-	const getTrailingComments = options.getTrailingComments ?? (() => void 0);
 	const appendMapping = (sourceRange, generatedStart, generatedEnd, data) => {
 		pushMapping(mappings, {
 			sourceStart: sourceRange.start,
@@ -1397,6 +1400,7 @@ function createPrinterContext(options) {
 		}, combineMappingData);
 	};
 	const context = {
+		options,
 		source: options.source,
 		get generatedOffset() {
 			return generatedOffset;
@@ -1406,6 +1410,15 @@ function createPrinterContext(options) {
 			chunks.push(text);
 			generatedOffset += text.length;
 		},
+		writeMapped(text, sourceStart, sourceEnd, data) {
+			if (text.length === 0 || sourceEnd <= sourceStart) return;
+			const generatedStart = generatedOffset;
+			context.write(text);
+			appendMapping({
+				start: sourceStart,
+				end: sourceEnd
+			}, generatedStart, generatedOffset, data ?? getMappingData(null));
+		},
 		writeNode(node) {
 			if (!node) return;
 			const range = getNodeRange(node);
@@ -1418,12 +1431,12 @@ function createPrinterContext(options) {
 			}
 			const printer = printers[node.type];
 			if (!printer) throw new Error(`No printer registered for node type ${node.type}`);
-			const leadingComments = getLeadingComments(node);
+			const leadingComments = options.getLeadingComments?.(node);
 			if (leadingComments) for (const c of leadingComments) writeComment(context, c);
 			const generatedStart = generatedOffset;
 			printer(node, context);
 			const generatedEnd = generatedOffset;
-			const trailingComments = getTrailingComments(node);
+			const trailingComments = options.getTrailingComments?.(node);
 			if (trailingComments) for (const c of trailingComments) writeComment(context, c);
 			const lastMappingGeneratedEnd = mappings.at(-1)?.generatedEnd ?? 0;
 			if (range && lastMappingGeneratedEnd <= generatedStart) appendMapping(range, generatedStart, generatedEnd, getMappingData(node));
@@ -1454,13 +1467,6 @@ function createPrinterContext(options) {
 				else lastRangeEnd = void 0;
 			}
 		},
-		writePreservedNode(node) {
-			const range = getNodeRange(node);
-			if (!range) throw new Error(`Cannot preserve node ${node.type} without source offsets`);
-			context.writeSource(range.start, range.end, getMappingData(node));
-		},
-		getLeadingComments,
-		getTrailingComments,
 		writeSource(start, end, data) {
 			if (end <= start) return;
 			const generatedStart = generatedOffset;
@@ -1470,6 +1476,12 @@ function createPrinterContext(options) {
 				end
 			}, generatedStart, generatedOffset, data);
 		},
+		writePreservedNode(node) {
+			const range = getNodeRange(node);
+			if (!range) throw new Error(`Cannot preserve node ${node.type} without source offsets`);
+			context.writeSource(range.start, range.end, getMappingData(node));
+		},
+		appendMapping,
 		result() {
 			return {
 				code: chunks.join(""),
@@ -1480,4 +1492,4 @@ function createPrinterContext(options) {
 	return context;
 }
 //#endregion
-export { defaultCombineMappingData, defaultGetMappingData, defaultIsUntouched, print };
+export { defaultCombineMappingData, defaultGetMappingData, defaultIsUntouched, defaultPrinters, print };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "espolar",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -12,6 +13,10 @@
   "files": [
     "dist"
   ],
+  "license": "MIT",
+  "repository": {
+    "url": "git+https://github.com/piovium/espolar.git"
+  },
   "engines": {
     "node": ">= 26.0.0"
   },