@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

package/src/prettier/print-abstract-node.ts

@@ -80,8 +80,8 @@ export function printAbstractNode(
   if (leadingTriviaDoc) {
     // prevent extra lines at beginning of compount statement
     if (
-      (nodeKind === NodeKind.STATEMENT) &&
-      ((node as AbstractStatement).statementKind === StatementKind.COMPOUND)
+      nodeKind === NodeKind.STATEMENT &&
+      (node as AbstractStatement).statementKind === StatementKind.COMPOUND
     ) {
       leadingTriviaDoc = removeLeadingBlanklines(leadingTriviaDoc);
     }
@@ -90,25 +90,16 @@ export function printAbstractNode(
 
   switch (nodeKind) {
     case NodeKind.AGGREGATE_OUTPUT_VALUE:
-      doc.push(printAggregateOutputValue(
-        path as AstPath<AggregateOutputValue>,
-        print,
-      ));
+      doc.push(printAggregateOutputValue(path as AstPath<AggregateOutputValue>, print));
       break;
     case NodeKind.ALIGNED_MODIFIER:
       doc.push(printAlignedModifier(path as AstPath<AlignedModifier>, print));
       break;
     case NodeKind.ARRAY_DIMENSION:
-      doc.push(printAbstractArrayDimension(
-        path as AstPath<AbstractArrayDimension>,
-        print,
-      ));
+      doc.push(printAbstractArrayDimension(path as AstPath<AbstractArrayDimension>, print));
       break;
     case NodeKind.ARRAY_ELEMENT_ACCESS:
-      doc.push(printArrayElementAccess(
-        path as AstPath<ArrayElementAccess>,
-        print,
-      ));
+      doc.push(printArrayElementAccess(path as AstPath<ArrayElementAccess>, print));
       break;
     case NodeKind.BIT_MODIFIER:
       doc.push(printBitModifier(path as AstPath<BitModifier>, print));
@@ -120,36 +111,22 @@ export function printAbstractNode(
       doc.push(printAbstractClassId(path as AstPath<AbstractClassId>, print));
       break;
     case NodeKind.CLASS_MEMBER_ACCESS:
-      doc.push(
-        printClassMemberAccess(path as AstPath<ClassMemberAccess>, print),
-      );
+      doc.push(printClassMemberAccess(path as AstPath<ClassMemberAccess>, print));
       break;
     case NodeKind.DEFAULT_CLAUSE:
-      doc.push(printDefaultClause(
-        path as AstPath<DefaultClause>,
-        print,
-      ));
+      doc.push(printDefaultClause(path as AstPath<DefaultClause>, print));
       break;
     case NodeKind.ELEMENTARY_TYPE:
       doc.push(printElementaryType(path as AstPath<ElementaryType>, print));
       break;
     case NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE:
-      doc.push(printElementaryTypeOutputValue(
-        path as AstPath<ElementaryTypeOutputValue>,
-        print,
-      ));
+      doc.push(printElementaryTypeOutputValue(path as AstPath<ElementaryTypeOutputValue>, print));
       break;
     case NodeKind.EXPRESSION:
-      doc.push(printAbstractExpression(
-        path as AstPath<AbstractExpression>,
-        print,
-      ));
+      doc.push(printAbstractExpression(path as AstPath<AbstractExpression>, print));
       break;
     case NodeKind.EXPANDABLE_MODIFIER:
-      doc.push(printExpandableModifier(
-        path as AstPath<ExpandableModifier>,
-        print,
-      ));
+      doc.push(printExpandableModifier(path as AstPath<ExpandableModifier>, print));
       break;
     case NodeKind.EXTENDS_MODIFIER:
       doc.push(printExtendsModifier(path as AstPath<ExtendsModifier>, print));
@@ -173,18 +150,13 @@ export function printAbstractNode(
       doc.push(printParameterList(path as AstPath<ParameterList>, print));
       break;
     case NodeKind.PARAMETER_VALUE_LIST:
-      doc.push(printParameterValueList(
-        path as AstPath<ParameterValueList>,
-        print,
-      ));
+      doc.push(printParameterValueList(path as AstPath<ParameterValueList>, print));
       break;
     case NodeKind.SPECIFICATION:
       doc.push(printSpecification(path as AstPath<Specification>, print));
       break;
     case NodeKind.STATEMENT:
-      doc.push(
-        printAbstractStatement(path as AstPath<AbstractStatement>, print),
-      );
+      doc.push(printAbstractStatement(path as AstPath<AbstractStatement>, print));
       break;
     case NodeKind.STRING_LITERAL:
       doc.push(printStringLiteral(path as AstPath<StringLiteral>, print));
@@ -197,9 +169,7 @@ export function printAbstractNode(
       break;
     default: {
       const exhaustiveCheck: never = nodeKind;
-      throw new InternalScannerError(
-        "Unreachable code reached, nodeKind == " + exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, nodeKind == " + exhaustiveCheck);
     }
   }
 
@@ -207,7 +177,8 @@ export function printAbstractNode(
   if (trailingTriviaDoc) {
     // prevent extra lines at end of specification
     if (
-      (nodeKind === NodeKind.SPECIFICATION) && endsWithHardline(doc) &&
+      nodeKind === NodeKind.SPECIFICATION &&
+      endsWithHardline(doc) &&
       endsWithHardline(trailingTriviaDoc)
     ) {
       doc = removeTrailingHardline(doc);
@@ -216,7 +187,7 @@ export function printAbstractNode(
   }
 
   // trim unneeded arrays
-  while (Array.isArray(doc) && (doc.length === 1)) {
+  while (Array.isArray(doc) && doc.length === 1) {
     doc = doc[0];
   }
 

package/src/prettier/print-abstract-statement.ts

@@ -57,10 +57,7 @@ function printExpressionStatement(
   path: AstPath<ExpressionStatement>,
   print: (_path: AstPath<AbstractNode>) => Doc,
 ): Doc {
-  return fill([
-    path.call(print, "expression"),
-    path.call(print, "semicolonPunctuator"),
-  ]);
+  return fill([path.call(print, "expression"), path.call(print, "semicolonPunctuator")]);
 }
 
 export function printAbstractStatement(
@@ -73,10 +70,7 @@ export function printAbstractStatement(
     case StatementKind.ARRAY_DEFINITION:
       return printArrayDefinition(path as AstPath<ArrayDefinition>, print);
     case StatementKind.COMPUTED_ARRAY_DEFINITION:
-      return printComputedArrayDefinition(
-        path as AstPath<ComputedArrayDefinition>,
-        print,
-      );
+      return printComputedArrayDefinition(path as AstPath<ComputedArrayDefinition>, print);
     case StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION:
       return printComputedElementaryTypeDefinition(
         path as AstPath<ComputedElementaryTypeDefinition>,
@@ -91,15 +85,9 @@ export function printAbstractStatement(
     case StatementKind.DO:
       return printDoStatement(path as AstPath<DoStatement>, print);
     case StatementKind.ELEMENTARY_TYPE_DEFINITION:
-      return printElementaryTypeDefinition(
-        path as AstPath<ElementaryTypeDefinition>,
-        print,
-      );
+      return printElementaryTypeDefinition(path as AstPath<ElementaryTypeDefinition>, print);
     case StatementKind.EXPRESSION:
-      return printExpressionStatement(
-        path as AstPath<ExpressionStatement>,
-        print,
-      );
+      return printExpressionStatement(path as AstPath<ExpressionStatement>, print);
     case StatementKind.FOR:
       return printForStatement(path as AstPath<ForStatement>, print);
     case StatementKind.IF:

package/src/prettier/print-aggregate-output-value.ts

@@ -1,10 +1,7 @@
 import type { AstPath, Doc, doc } from "prettier";
 import type { AbstractNode } from "../ast/node/abstract-node.ts";
 import type { AggregateOutputValue } from "../ast/node/aggregate-output-value.ts";
-import {
-  addNonBreakingWhitespace,
-  interleaveCommaSeparatorDocs,
-} from "./util/print-utils.ts";
+import { addNonBreakingWhitespace, interleaveCommaSeparatorDocs } from "./util/print-utils.ts";
 
 export function printAggregateOutputValue(
   path: AstPath<AggregateOutputValue>,
@@ -12,20 +9,13 @@ export function printAggregateOutputValue(
 ): doc.builders.Doc {
   const doc: Doc = [];
 
-  doc.push(
-    path.call(print, "openBracePunctuator"),
-  );
+  doc.push(path.call(print, "openBracePunctuator"));
 
   addNonBreakingWhitespace(doc);
 
   const outputValuesDoc = path.map(print, "outputValues");
 
-  doc.push(
-    interleaveCommaSeparatorDocs(
-      outputValuesDoc,
-      path.map(print, "commaPunctuators"),
-    ),
-  );
+  doc.push(interleaveCommaSeparatorDocs(outputValuesDoc, path.map(print, "commaPunctuators")));
 
   addNonBreakingWhitespace(doc);
 

package/src/prettier/print-aligned-modifier.ts

@@ -17,21 +17,14 @@ export function printAlignedModifier(
     doc.push(
       path.call(
         print,
-        "openParenthesisPunctuator" as keyof AlignedModifier[
-          "openParenthesisPunctuator"
-        ],
+        "openParenthesisPunctuator" as keyof AlignedModifier["openParenthesisPunctuator"],
       ),
     );
   }
 
   if (alignedModifier.bitCountModifierToken) {
     doc.push(
-      path.call(
-        print,
-        "bitCountModifierToken" as keyof AlignedModifier[
-          "bitCountModifierToken"
-        ],
-      ),
+      path.call(print, "bitCountModifierToken" as keyof AlignedModifier["bitCountModifierToken"]),
     );
   }
 
@@ -39,9 +32,7 @@ export function printAlignedModifier(
     doc.push(
       path.call(
         print,
-        "closeParenthesisPunctuator" as keyof AlignedModifier[
-          "closeParenthesisPunctuator"
-        ],
+        "closeParenthesisPunctuator" as keyof AlignedModifier["closeParenthesisPunctuator"],
       ),
     );
   }

package/src/prettier/print-array-definition.ts

@@ -1,8 +1,5 @@
 import { AstPath, type Doc, doc } from "prettier";
-import {
-  addBreakingWhitespace,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addBreakingWhitespace, addNonBreakingWhitespace } from "./util/print-utils.ts";
 import type { ArrayDefinition } from "../ast/node/array-definition.ts";
 import type { AbstractNode } from "../ast/node/abstract-node.ts";
 
@@ -16,70 +13,37 @@ export function printArrayDefinition(
   let doc: Doc = [];
 
   if (arrayDefinition.reservedKeyword) {
-    doc.push(
-      path.call(
-        print,
-        "reservedKeyword" as keyof ArrayDefinition["reservedKeyword"],
-      ),
-    );
+    doc.push(path.call(print, "reservedKeyword" as keyof ArrayDefinition["reservedKeyword"]));
     addNonBreakingWhitespace(doc);
   }
 
   if (arrayDefinition.legacyKeyword) {
-    doc.push(
-      path.call(
-        print,
-        "legacyKeyword" as keyof ArrayDefinition["legacyKeyword"],
-      ),
-    );
+    doc.push(path.call(print, "legacyKeyword" as keyof ArrayDefinition["legacyKeyword"]));
     addNonBreakingWhitespace(doc);
   }
 
   if (arrayDefinition.alignedModifier !== undefined) {
-    doc.push(
-      path.call(
-        print,
-        "alignedModifier" as keyof ArrayDefinition["alignedModifier"],
-      ),
-    );
+    doc.push(path.call(print, "alignedModifier" as keyof ArrayDefinition["alignedModifier"]));
     addNonBreakingWhitespace(doc);
   }
 
   if (arrayDefinition.elementaryType !== undefined) {
     const subDoc: Doc = [
-      path.call(
-        print,
-        "elementaryType" as keyof ArrayDefinition["elementaryType"],
-      ),
-      path.call(
-        print,
-        "lengthAttribute" as keyof ArrayDefinition["lengthAttribute"],
-      ),
+      path.call(print, "elementaryType" as keyof ArrayDefinition["elementaryType"]),
+      path.call(print, "lengthAttribute" as keyof ArrayDefinition["lengthAttribute"]),
     ];
     doc.push(subDoc);
   } else {
-    doc.push(
-      path.call(
-        print,
-        "classIdentifier" as keyof ArrayDefinition["classIdentifier"],
-      ),
-    );
+    doc.push(path.call(print, "classIdentifier" as keyof ArrayDefinition["classIdentifier"]));
   }
 
   doc = addBreakingWhitespace(doc);
 
-  const identifierClause = [
-    path.call(print, "identifier"),
-  ];
+  const identifierClause = [path.call(print, "identifier")];
 
   if (arrayDefinition.implicitArrayDimension) {
     identifierClause.push(
-      path.call(
-        print,
-        "implicitArrayDimension" as keyof ArrayDefinition[
-          "implicitArrayDimension"
-        ],
-      ),
+      path.call(print, "implicitArrayDimension" as keyof ArrayDefinition["implicitArrayDimension"]),
     );
   }
 

package/src/prettier/print-bit-modifier.ts

@@ -1,10 +1,7 @@
 import type { AstPath, Doc } from "prettier";
 import type { AbstractNode } from "../ast/node/abstract-node.ts";
 import type { BitModifier } from "../ast/node/bit-modifier.ts";
-import {
-  addBreakingWhitespace,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addBreakingWhitespace, addNonBreakingWhitespace } from "./util/print-utils.ts";
 
 export function printBitModifier(
   path: AstPath<BitModifier>,
@@ -26,19 +23,9 @@ export function printBitModifier(
   addNonBreakingWhitespace(doc);
 
   if (bitModifier.identifier !== undefined) {
-    doc.push(
-      path.call(
-        print,
-        "identifier" as keyof BitModifier["identifier"],
-      ),
-    );
+    doc.push(path.call(print, "identifier" as keyof BitModifier["identifier"]));
     addNonBreakingWhitespace(doc);
-    doc.push(
-      path.call(
-        print,
-        "assignmentOperator" as keyof BitModifier["assignmentOperator"],
-      ),
-    );
+    doc.push(path.call(print, "assignmentOperator" as keyof BitModifier["assignmentOperator"]));
     doc = addBreakingWhitespace(doc);
   }
 

package/src/prettier/print-case-clause.ts

@@ -1,9 +1,6 @@
 import type { AstPath, Doc } from "prettier";
 import type { AbstractNode } from "../ast/node/abstract-node.ts";
-import {
-  addIndentedStatements,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addIndentedStatements, addNonBreakingWhitespace } from "./util/print-utils.ts";
 import type { CaseClause } from "../ast/node/case-clause.ts";
 
 export function printCaseClause(
@@ -16,10 +13,7 @@ export function printCaseClause(
   doc.push(path.call(print, "caseKeyword"));
   addNonBreakingWhitespace(doc);
 
-  doc.push([
-    path.call(print, "value"),
-    path.call(print, "colonPunctuator"),
-  ]);
+  doc.push([path.call(print, "value"), path.call(print, "colonPunctuator")]);
 
   const statementsDocs: Doc[] = [];
 
@@ -27,13 +21,12 @@ export function printCaseClause(
     statementsDocs.push(path.map(print, "statements"));
   }
   if (caseClause.breakKeyword !== undefined) {
-    statementsDocs.push([[
-      path.call(print, "breakKeyword" as keyof CaseClause["breakKeyword"]),
-      path.call(
-        print,
-        "semicolonPunctuator" as keyof CaseClause["semicolonPunctuator"],
-      ),
-    ]]);
+    statementsDocs.push([
+      [
+        path.call(print, "breakKeyword" as keyof CaseClause["breakKeyword"]),
+        path.call(print, "semicolonPunctuator" as keyof CaseClause["semicolonPunctuator"]),
+      ],
+    ]);
   }
 
   if (caseClause.openBracePunctuator !== undefined) {
@@ -41,14 +34,8 @@ export function printCaseClause(
     doc = addIndentedStatements(
       doc,
       statementsDocs,
-      path.call(
-        print,
-        "openBracePunctuator" as keyof CaseClause["openBracePunctuator"],
-      ),
-      path.call(
-        print,
-        "closeBracePunctuator" as keyof CaseClause["closeBracePunctuator"],
-      ),
+      path.call(print, "openBracePunctuator" as keyof CaseClause["openBracePunctuator"]),
+      path.call(print, "closeBracePunctuator" as keyof CaseClause["closeBracePunctuator"]),
     );
   } else {
     doc = addIndentedStatements(doc, statementsDocs);

package/src/prettier/print-class-declaration.ts

@@ -17,38 +17,23 @@ export function printClassDeclaration(
   let doc: Doc = [];
 
   if (classDeclaration.alignedModifier !== undefined) {
-    doc.push(
-      path.call(
-        print,
-        "alignedModifier" as keyof ClassDeclaration["alignedModifier"],
-      ),
-    );
+    doc.push(path.call(print, "alignedModifier" as keyof ClassDeclaration["alignedModifier"]));
     addNonBreakingWhitespace(doc);
   }
 
   if (classDeclaration.expandableModifier !== undefined) {
     doc.push(
-      path.call(
-        print,
-        "expandableModifier" as keyof ClassDeclaration["expandableModifier"],
-      ),
+      path.call(print, "expandableModifier" as keyof ClassDeclaration["expandableModifier"]),
     );
     addNonBreakingWhitespace(doc);
   }
 
   if (classDeclaration.abstractKeyword) {
-    doc.push(
-      path.call(
-        print,
-        "abstractKeyword" as keyof ClassDeclaration["abstractKeyword"],
-      ),
-    );
+    doc.push(path.call(print, "abstractKeyword" as keyof ClassDeclaration["abstractKeyword"]));
     addNonBreakingWhitespace(doc);
   }
 
-  doc.push(
-    path.call(print, "classKeyword"),
-  );
+  doc.push(path.call(print, "classKeyword"));
 
   addNonBreakingWhitespace(doc);
 
@@ -57,32 +42,25 @@ export function printClassDeclaration(
 
   if (classDeclaration.parameterList !== undefined) {
     identifierDoc.push(
-      path.call(
-        print,
-        "parameterList" as keyof ClassDeclaration["parameterList"],
-      ),
+      path.call(print, "parameterList" as keyof ClassDeclaration["parameterList"]),
     );
   }
   doc.push(identifierDoc);
   doc = addBreakingWhitespace(doc);
 
   if (classDeclaration.extendsModifier !== undefined) {
-    doc.push(fill(
-      path.call(
-        print,
-        "extendsModifier" as keyof ClassDeclaration["extendsModifier"],
-      ) as Doc[],
-    ));
+    doc.push(
+      fill(
+        path.call(print, "extendsModifier" as keyof ClassDeclaration["extendsModifier"]) as Doc[],
+      ),
+    );
     doc = addBreakingWhitespace(doc);
   }
 
   if (classDeclaration.bitModifier !== undefined) {
-    doc.push(fill(
-      path.call(
-        print,
-        "bitModifier" as keyof ClassDeclaration["bitModifier"],
-      ) as Doc[],
-    ));
+    doc.push(
+      fill(path.call(print, "bitModifier" as keyof ClassDeclaration["bitModifier"]) as Doc[]),
+    );
     doc = addBreakingWhitespace(doc);
   }
 

package/src/prettier/print-class-definition.ts

@@ -12,28 +12,18 @@ export function printClassDefinition(
   const doc: Doc = [];
 
   if (classDefinition.legacyKeyword) {
-    doc.push(
-      path.call(
-        print,
-        "legacyKeyword" as keyof ClassDefinition["legacyKeyword"],
-      ),
-    );
+    doc.push(path.call(print, "legacyKeyword" as keyof ClassDefinition["legacyKeyword"]));
     addNonBreakingWhitespace(doc);
   }
 
   doc.push(path.call(print, "classIdentifier"));
   addNonBreakingWhitespace(doc);
 
-  const identifierDoc = [
-    path.call(print, "identifier"),
-  ];
+  const identifierDoc = [path.call(print, "identifier")];
 
   if (classDefinition.parameterValueList !== undefined) {
     identifierDoc.push([
-      path.call(
-        print,
-        "parameterValueList" as keyof ClassDefinition["parameterValueList"],
-      ),
+      path.call(print, "parameterValueList" as keyof ClassDefinition["parameterValueList"]),
     ]);
   }
 

package/src/prettier/print-class-member-access.ts

@@ -6,8 +6,5 @@ export function printClassMemberAccess(
   path: AstPath<ClassMemberAccess>,
   print: (path: AstPath<AbstractNode>) => Doc,
 ): Doc {
-  return [
-    path.call(print, "classMemberAccessOperator"),
-    path.call(print, "memberIdentifier"),
-  ];
+  return [path.call(print, "classMemberAccessOperator"), path.call(print, "memberIdentifier")];
 }

package/src/prettier/print-computed-array-definition.ts

@@ -1,10 +1,7 @@
 import { type AstPath, type Doc, doc } from "prettier";
 import type { AbstractNode } from "../ast/node/abstract-node.ts";
 import type { ComputedArrayDefinition } from "../ast/node/computed-array-definition.ts";
-import {
-  addBreakingWhitespace,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addBreakingWhitespace, addNonBreakingWhitespace } from "./util/print-utils.ts";
 
 const { fill } = doc.builders;
 

package/src/prettier/print-computed-elementary-type-definition.ts

@@ -1,10 +1,7 @@
 import { type AstPath, type Doc, doc } from "prettier";
 import type { AbstractNode } from "../ast/node/abstract-node.ts";
 import type { ComputedElementaryTypeDefinition } from "../ast/node/computed-elementary-type-definition.ts";
-import {
-  addBreakingWhitespace,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addBreakingWhitespace, addNonBreakingWhitespace } from "./util/print-utils.ts";
 
 const { fill } = doc.builders;
 
@@ -20,12 +17,7 @@ export function printComputedElementaryTypeDefinition(
 
   if (computedElementaryTypeDefinition.constKeyword) {
     doc.push(
-      path.call(
-        print,
-        "constKeyword" as keyof ComputedElementaryTypeDefinition[
-          "constKeyword"
-        ],
-      ),
+      path.call(print, "constKeyword" as keyof ComputedElementaryTypeDefinition["constKeyword"]),
     );
     doc = addBreakingWhitespace(doc);
   }
@@ -40,18 +32,11 @@ export function printComputedElementaryTypeDefinition(
     doc.push(
       path.call(
         print,
-        "assignmentOperator" as keyof ComputedElementaryTypeDefinition[
-          "assignmentOperator"
-        ],
+        "assignmentOperator" as keyof ComputedElementaryTypeDefinition["assignmentOperator"],
       ),
     );
     doc = addBreakingWhitespace(doc);
-    doc.push(
-      path.call(
-        print,
-        "value" as keyof ComputedElementaryTypeDefinition["value"],
-      ),
-    );
+    doc.push(path.call(print, "value" as keyof ComputedElementaryTypeDefinition["value"]));
   }
 
   doc.push(path.call(print, "semicolonPunctuator"));

package/src/prettier/print-default-clause.ts

@@ -10,10 +10,7 @@ export function printDefaultClause(
   const defaultClause = path.node;
   let doc: Doc = [];
 
-  doc.push([
-    path.call(print, "defaultKeyword"),
-    path.call(print, "colonPunctuator"),
-  ]);
+  doc.push([path.call(print, "defaultKeyword"), path.call(print, "colonPunctuator")]);
 
   const statementsDoc = path.map(print, "statements");
 
@@ -22,14 +19,8 @@ export function printDefaultClause(
     doc = addIndentedStatements(
       doc,
       statementsDoc,
-      path.call(
-        print,
-        "openBracePunctuator" as keyof DefaultClause["openBracePunctuator"],
-      ),
-      path.call(
-        print,
-        "closeBracePunctuator" as keyof DefaultClause["closeBracePunctuator"],
-      ),
+      path.call(print, "openBracePunctuator" as keyof DefaultClause["openBracePunctuator"]),
+      path.call(print, "closeBracePunctuator" as keyof DefaultClause["closeBracePunctuator"]),
     );
   } else {
     doc = addIndentedStatements(doc, statementsDoc);

package/src/prettier/print-do-statement.ts

@@ -1,8 +1,5 @@
 import { AstPath, type Doc, doc } from "prettier";
-import {
-  addBreakingWhitespace,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addBreakingWhitespace, addNonBreakingWhitespace } from "./util/print-utils.ts";
 import type { AbstractNode } from "../ast/node/abstract-node.ts";
 import type { DoStatement } from "../ast/node/do-statement.ts";