@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

package/src/prettier/print-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 { ElementaryTypeDefinition } from "../ast/node/elementary-type-definition.ts";
-import {
-  addBreakingWhitespace,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addBreakingWhitespace, addNonBreakingWhitespace } from "./util/print-utils.ts";
 
 const { fill } = doc.builders;
 
@@ -17,40 +14,24 @@ export function printElementaryTypeDefinition(
 
   if (elementaryTypeDefinition.reservedKeyword) {
     doc.push(
-      path.call(
-        print,
-        "reservedKeyword" as keyof ElementaryTypeDefinition["reservedKeyword"],
-      ),
+      path.call(print, "reservedKeyword" as keyof ElementaryTypeDefinition["reservedKeyword"]),
     );
     doc = addBreakingWhitespace(doc);
   }
 
   if (elementaryTypeDefinition.legacyKeyword) {
-    doc.push(
-      path.call(
-        print,
-        "legacyKeyword" as keyof ElementaryTypeDefinition["legacyKeyword"],
-      ),
-    );
+    doc.push(path.call(print, "legacyKeyword" as keyof ElementaryTypeDefinition["legacyKeyword"]));
     doc = addBreakingWhitespace(doc);
   }
 
   if (elementaryTypeDefinition.constKeyword) {
-    doc.push(
-      path.call(
-        print,
-        "constKeyword" as keyof ElementaryTypeDefinition["constKeyword"],
-      ),
-    );
+    doc.push(path.call(print, "constKeyword" as keyof ElementaryTypeDefinition["constKeyword"]));
     doc = addBreakingWhitespace(doc);
   }
 
   if (elementaryTypeDefinition.alignedModifier !== undefined) {
     doc.push(
-      path.call(
-        print,
-        "alignedModifier" as keyof ElementaryTypeDefinition["alignedModifier"],
-      ),
+      path.call(print, "alignedModifier" as keyof ElementaryTypeDefinition["alignedModifier"]),
     );
     doc = addBreakingWhitespace(doc);
   }
@@ -60,12 +41,7 @@ export function printElementaryTypeDefinition(
 
   if (elementaryTypeDefinition.lookAheadOperator) {
     doc.push(
-      path.call(
-        print,
-        "lookAheadOperator" as keyof ElementaryTypeDefinition[
-          "lookAheadOperator"
-        ],
-      ),
+      path.call(print, "lookAheadOperator" as keyof ElementaryTypeDefinition["lookAheadOperator"]),
     );
   }
   doc = addBreakingWhitespace(doc);
@@ -77,28 +53,16 @@ export function printElementaryTypeDefinition(
     doc.push(
       path.call(
         print,
-        "assignmentOperator" as keyof ElementaryTypeDefinition[
-          "assignmentOperator"
-        ],
+        "assignmentOperator" as keyof ElementaryTypeDefinition["assignmentOperator"],
       ),
     );
     doc = addBreakingWhitespace(doc);
-    doc.push(
-      path.call(print, "value" as keyof ElementaryTypeDefinition["value"]),
-    );
+    doc.push(path.call(print, "value" as keyof ElementaryTypeDefinition["value"]));
     if (elementaryTypeDefinition.endValue !== undefined) {
       doc.push(
-        path.call(
-          print,
-          "rangeOperator" as keyof ElementaryTypeDefinition["rangeOperator"],
-        ),
-      );
-      doc.push(
-        path.call(
-          print,
-          "endValue" as keyof ElementaryTypeDefinition["endValue"],
-        ),
+        path.call(print, "rangeOperator" as keyof ElementaryTypeDefinition["rangeOperator"]),
       );
+      doc.push(path.call(print, "endValue" as keyof ElementaryTypeDefinition["endValue"]));
     }
   }
 

package/src/prettier/print-elementary-type-output-value.ts

@@ -6,8 +6,5 @@ export function printElementaryTypeOutputValue(
   path: AstPath<ElementaryTypeOutputValue>,
   print: (path: AstPath<AbstractNode>) => Doc,
 ): doc.builders.Doc {
-  return [
-    path.call(print, "elementaryType"),
-    path.call(print, "lengthAttribute"),
-  ];
+  return [path.call(print, "elementaryType"), path.call(print, "lengthAttribute")];
 }

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

@@ -14,9 +14,7 @@ export function printElementaryType(
     doc.push(
       path.call(
         print,
-        "unsignedQualifierKeyword" as keyof ElementaryType[
-          "unsignedQualifierKeyword"
-        ],
+        "unsignedQualifierKeyword" as keyof ElementaryType["unsignedQualifierKeyword"],
       ),
     );
     addNonBreakingWhitespace(doc);

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

@@ -10,31 +10,20 @@ export function printExpandableModifier(
 
   const doc: Doc = [];
 
-  doc.push(
-    path.call(print, "expandableKeyword"),
-  );
+  doc.push(path.call(print, "expandableKeyword"));
 
   if (expandableModifier.maxClassSize !== undefined) {
-    doc.push(
-      [
-        path.call(
-          print,
-          "openParenthesisPunctuator" as keyof ExpandableModifier[
-            "openParenthesisPunctuator"
-          ],
-        ),
-        path.call(
-          print,
-          "maxClassSize" as keyof ExpandableModifier["maxClassSize"],
-        ),
-        path.call(
-          print,
-          "closeParenthesisPunctuator" as keyof ExpandableModifier[
-            "closeParenthesisPunctuator"
-          ],
-        ),
-      ],
-    );
+    doc.push([
+      path.call(
+        print,
+        "openParenthesisPunctuator" as keyof ExpandableModifier["openParenthesisPunctuator"],
+      ),
+      path.call(print, "maxClassSize" as keyof ExpandableModifier["maxClassSize"]),
+      path.call(
+        print,
+        "closeParenthesisPunctuator" as keyof ExpandableModifier["closeParenthesisPunctuator"],
+      ),
+    ]);
   }
 
   return doc;

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

@@ -17,12 +17,7 @@ export function printExtendsModifier(
   doc.push(path.call(print, "identifier"));
 
   if (mapEntryList.parameterValueList !== undefined) {
-    doc.push(
-      path.call(
-        print,
-        "parameterValueList" as keyof ExtendsModifier["parameterValueList"],
-      ),
-    );
+    doc.push(path.call(print, "parameterValueList" as keyof ExtendsModifier["parameterValueList"]));
   }
 
   return doc;

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

@@ -1,8 +1,5 @@
 import { AstPath, type 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 { ForStatement } from "../ast/node/for-statement.ts";
 
@@ -20,39 +17,28 @@ export function printForStatement(
   subDoc.push(path.call(print, "openParenthesisPunctuator"));
 
   if (forStatement.expression1 !== undefined) {
-    subDoc.push(
-      path.call(print, "expression1" as keyof ForStatement["expression1"]),
-    );
+    subDoc.push(path.call(print, "expression1" as keyof ForStatement["expression1"]));
   } else if (forStatement.computedElementaryDefinition !== undefined) {
     subDoc.push(
       path.call(
         print,
-        "computedElementaryDefinition" as keyof ForStatement[
-          "computedElementaryDefinition"
-        ],
+        "computedElementaryDefinition" as keyof ForStatement["computedElementaryDefinition"],
       ),
     );
   } else if (forStatement.semicolon1Punctuator !== undefined) {
     subDoc.push(
-      path.call(
-        print,
-        "semicolon1Punctuator" as keyof ForStatement["semicolon1Punctuator"],
-      ),
+      path.call(print, "semicolon1Punctuator" as keyof ForStatement["semicolon1Punctuator"]),
     );
   }
 
   if (forStatement.expression2 !== undefined) {
     subDoc = addBreakingWhitespace(subDoc);
-    subDoc.push(
-      path.call(print, "expression2" as keyof ForStatement["expression2"]),
-    );
+    subDoc.push(path.call(print, "expression2" as keyof ForStatement["expression2"]));
   }
   subDoc.push(path.call(print, "semicolon2Punctuator"));
   if (forStatement.expression3 !== undefined) {
     subDoc = addBreakingWhitespace(subDoc);
-    subDoc.push(
-      path.call(print, "expression3" as keyof ForStatement["expression3"]),
-    );
+    subDoc.push(path.call(print, "expression3" as keyof ForStatement["expression3"]));
   }
   subDoc.push(path.call(print, "closeParenthesisPunctuator"));
   addNonBreakingWhitespace(subDoc);

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

@@ -29,10 +29,7 @@ export function printIfStatement(
   addNonBreakingWhitespace(doc);
 
   const ifSubStatement = ifStatement.ifStatement;
-  if (
-    isStatement(ifSubStatement) &&
-    (ifSubStatement.statementKind === StatementKind.COMPOUND)
-  ) {
+  if (isStatement(ifSubStatement) && ifSubStatement.statementKind === StatementKind.COMPOUND) {
     doc.push(path.call(print, "ifStatement"));
   } else {
     doc = addIndentedStatements(doc, [path.call(print, "ifStatement")]);
@@ -48,28 +45,20 @@ export function printIfStatement(
     doc = [doc];
   }
 
-  doc.push(
-    path.call(print, "elseKeyword" as keyof IfStatement["elseKeyword"]),
-  );
+  doc.push(path.call(print, "elseKeyword" as keyof IfStatement["elseKeyword"]));
   addNonBreakingWhitespace(doc);
 
   const elseSubStatement = ifStatement.elseStatement!;
   if (
     isStatement(elseSubStatement) &&
-    (elseSubStatement.statementKind !== StatementKind.COMPOUND) &&
-    (elseSubStatement.statementKind !== StatementKind.IF)
+    elseSubStatement.statementKind !== StatementKind.COMPOUND &&
+    elseSubStatement.statementKind !== StatementKind.IF
   ) {
-    doc = addIndentedStatements(
-      doc,
-      [path.call(
-        print,
-        "elseStatement" as keyof IfStatement["elseStatement"],
-      )],
-    );
-  } else {
-    doc.push(
+    doc = addIndentedStatements(doc, [
       path.call(print, "elseStatement" as keyof IfStatement["elseStatement"]),
-    );
+    ]);
+  } else {
+    doc.push(path.call(print, "elseStatement" as keyof IfStatement["elseStatement"]));
   }
 
   return doc;

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

@@ -1,10 +1,7 @@
 import type { AstPath, Doc } from "prettier";
 import type { AbstractNode } from "../ast/node/abstract-node.ts";
 import type { MapDeclaration } from "../ast/node/map-declaration.ts";
-import {
-  addIndentedStatements,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addIndentedStatements, addNonBreakingWhitespace } from "./util/print-utils.ts";
 
 export function printMapDeclaration(
   path: AstPath<MapDeclaration>,
@@ -21,25 +18,15 @@ export function printMapDeclaration(
 
   addNonBreakingWhitespace(doc);
 
-  const subDoc: Doc = [
-    path.call(print, "openParenthesisPunctuator"),
-  ];
+  const subDoc: Doc = [path.call(print, "openParenthesisPunctuator")];
 
   if (mapDeclaration.outputElementaryType !== undefined) {
     subDoc.push(
-      path.call(
-        print,
-        "outputElementaryType" as keyof MapDeclaration["outputElementaryType"],
-      ),
+      path.call(print, "outputElementaryType" as keyof MapDeclaration["outputElementaryType"]),
     );
   } else if (mapDeclaration.outputClassIdentifier !== undefined) {
     subDoc.push(
-      path.call(
-        print,
-        "outputClassIdentifier" as keyof MapDeclaration[
-          "outputClassIdentifier"
-        ],
-      ),
+      path.call(print, "outputClassIdentifier" as keyof MapDeclaration["outputClassIdentifier"]),
     );
   }
 
@@ -57,9 +44,7 @@ export function printMapDeclaration(
 
     if (mapDeclaration.commaPunctuators) {
       if (i < mapDeclaration.commaPunctuators.length) {
-        entrySubDoc.push(
-          path.call(print, "commaPunctuators", i),
-        );
+        entrySubDoc.push(path.call(print, "commaPunctuators", i));
       }
     }
 

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

@@ -1,10 +1,7 @@
 import type { AstPath, Doc } from "prettier";
 import type { AbstractNode } from "../ast/node/abstract-node.ts";
 import type { MapDefinition } from "../ast/node/map-definition.ts";
-import {
-  addBreakingWhitespace,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addBreakingWhitespace, addNonBreakingWhitespace } from "./util/print-utils.ts";
 
 export function printMapDefinition(
   path: AstPath<MapDefinition>,
@@ -14,36 +11,19 @@ export function printMapDefinition(
   let doc: Doc = [];
 
   if (mapDefinition.reservedKeyword) {
-    doc.push(
-      path.call(
-        print,
-        "reservedKeyword" as keyof MapDefinition["reservedKeyword"],
-      ),
-    );
+    doc.push(path.call(print, "reservedKeyword" as keyof MapDefinition["reservedKeyword"]));
     addNonBreakingWhitespace(doc);
   }
 
   if (mapDefinition.legacyKeyword) {
-    doc.push(
-      path.call(print, "legacyKeyword" as keyof MapDefinition["legacyKeyword"]),
-    );
+    doc.push(path.call(print, "legacyKeyword" as keyof MapDefinition["legacyKeyword"]));
     addNonBreakingWhitespace(doc);
   }
 
   if (mapDefinition.elementaryType !== undefined) {
-    doc.push(
-      path.call(
-        print,
-        "elementaryType" as keyof MapDefinition["elementaryType"],
-      ),
-    );
+    doc.push(path.call(print, "elementaryType" as keyof MapDefinition["elementaryType"]));
   } else if (mapDefinition.classIdentifier !== undefined) {
-    doc.push(
-      path.call(
-        print,
-        "classIdentifier" as keyof MapDefinition["classIdentifier"],
-      ),
-    );
+    doc.push(path.call(print, "classIdentifier" as keyof MapDefinition["classIdentifier"]));
   }
 
   doc = addBreakingWhitespace(doc);
@@ -58,10 +38,7 @@ export function printMapDefinition(
 
   doc = addBreakingWhitespace(doc);
 
-  doc.push([
-    path.call(print, "identifier"),
-    path.call(print, "semicolonPunctuator"),
-  ]);
+  doc.push([path.call(print, "identifier"), path.call(print, "semicolonPunctuator")]);
 
   return doc;
 }

package/src/prettier/print-map-entry.ts

@@ -9,10 +9,7 @@ export function printMapEntry(
 ): doc.builders.Doc {
   const doc: Doc = [];
 
-  doc.push([
-    path.call(print, "inputValue"),
-    path.call(print, "commaPunctuator"),
-  ]);
+  doc.push([path.call(print, "inputValue"), path.call(print, "commaPunctuator")]);
 
   addNonBreakingWhitespace(doc);
 

package/src/prettier/print-number-literal.ts

@@ -36,9 +36,7 @@ function printMultipleCharacterNumberLiteral(
         currentLiterals.push(path.call(print, "literals", index));
 
         // avoid empty multiple character number literals after the first one
-        if (
-          (multipleCharacterNumberLiteralsDoc.length === 0) || containsContent
-        ) {
+        if (multipleCharacterNumberLiteralsDoc.length === 0 || containsContent) {
           multipleCharacterNumberLiteralsDoc.push(currentLiterals);
         }
 
@@ -53,10 +51,7 @@ function printMultipleCharacterNumberLiteral(
     }
   });
 
-  return join(
-    " ",
-    multipleCharacterNumberLiteralsDoc,
-  );
+  return join(" ", multipleCharacterNumberLiteralsDoc);
 }
 export function printNumberLiteral(
   path: AstPath<NumberLiteral>,

package/src/prettier/print-parameter.ts

@@ -11,19 +11,9 @@ export function printParameter(
   const doc: Doc = [];
 
   if (parameter.classIdentifier !== undefined) {
-    doc.push(
-      path.call(
-        print,
-        "classIdentifier" as keyof Parameter["classIdentifier"],
-      ),
-    );
+    doc.push(path.call(print, "classIdentifier" as keyof Parameter["classIdentifier"]));
   } else if (parameter.elementaryType !== undefined) {
-    doc.push(
-      path.call(
-        print,
-        "elementaryType" as keyof Parameter["elementaryType"],
-      ),
-    );
+    doc.push(path.call(print, "elementaryType" as keyof Parameter["elementaryType"]));
   }
 
   addNonBreakingWhitespace(doc);

package/src/prettier/print-specification.ts

@@ -26,10 +26,10 @@ export function printSpecification(
     if (globalNode.nodeKind === NodeKind.STATEMENT) {
       const statementKind = (globalNode as AbstractStatement).statementKind;
       if (
-        (i > 0) &&
-        (previousStatementKind !== undefined) &&
-        ((statementKind !== previousStatementKind) ||
-          (statementKind !== StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION))
+        i > 0 &&
+        previousStatementKind !== undefined &&
+        (statementKind !== previousStatementKind ||
+          statementKind !== StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION)
       ) {
         doc.push(hardline);
       }

package/src/prettier/print-string-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 { StringDefinition } from "../ast/node/string-definition.ts";
-import {
-  addBreakingWhitespace,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addBreakingWhitespace, addNonBreakingWhitespace } from "./util/print-utils.ts";
 
 const { fill } = doc.builders;
 
@@ -16,42 +13,22 @@ export function printStringDefinition(
 
   const subDoc1: Doc = [];
   if (stringDefinition.reservedKeyword) {
-    subDoc1.push(
-      path.call(
-        print,
-        "reservedKeyword" as keyof StringDefinition["reservedKeyword"],
-      ),
-    );
+    subDoc1.push(path.call(print, "reservedKeyword" as keyof StringDefinition["reservedKeyword"]));
     addNonBreakingWhitespace(subDoc1);
   }
 
   if (stringDefinition.legacyKeyword) {
-    subDoc1.push(
-      path.call(
-        print,
-        "legacyKeyword" as keyof StringDefinition["legacyKeyword"],
-      ),
-    );
+    subDoc1.push(path.call(print, "legacyKeyword" as keyof StringDefinition["legacyKeyword"]));
     addNonBreakingWhitespace(subDoc1);
   }
 
   if (stringDefinition.constKeyword) {
-    subDoc1.push(
-      path.call(
-        print,
-        "constKeyword" as keyof StringDefinition["constKeyword"],
-      ),
-    );
+    subDoc1.push(path.call(print, "constKeyword" as keyof StringDefinition["constKeyword"]));
     addNonBreakingWhitespace(subDoc1);
   }
 
   if (stringDefinition.alignedModifier !== undefined) {
-    subDoc1.push(
-      path.call(
-        print,
-        "alignedModifier" as keyof StringDefinition["alignedModifier"],
-      ),
-    );
+    subDoc1.push(path.call(print, "alignedModifier" as keyof StringDefinition["alignedModifier"]));
     addNonBreakingWhitespace(subDoc1);
   }
 
@@ -69,12 +46,7 @@ export function printStringDefinition(
   if (stringDefinition.assignmentPunctuator !== undefined) {
     addNonBreakingWhitespace(subDoc2);
     subDoc2.push(
-      path.call(
-        print,
-        "assignmentPunctuator" as keyof StringDefinition[
-          "assignmentPunctuator"
-        ],
-      ),
+      path.call(print, "assignmentPunctuator" as keyof StringDefinition["assignmentPunctuator"]),
     );
     doc.push(subDoc2);
 
@@ -90,20 +62,14 @@ export function printStringDefinition(
         if (index > 0) {
           doc = addBreakingWhitespace(doc);
         }
-        if (index === (stringLiteralsDoc.length - 1)) {
-          doc.push([
-            stringLiteralDoc,
-            path.call(print, "semicolonPunctuator"),
-          ]);
+        if (index === stringLiteralsDoc.length - 1) {
+          doc.push([stringLiteralDoc, path.call(print, "semicolonPunctuator")]);
         } else {
           doc.push(stringLiteralDoc);
         }
       });
     } else {
-      doc.push([
-        stringLiteralsDoc,
-        path.call(print, "semicolonPunctuator"),
-      ]);
+      doc.push([stringLiteralsDoc, path.call(print, "semicolonPunctuator")]);
     }
   } else {
     subDoc2.push(path.call(print, "semicolonPunctuator"));

package/src/prettier/print-string-literal.ts

@@ -32,7 +32,7 @@ export function printStringLiteral(
         currentLiteralDoc.push(path.call(print, "literals", index));
 
         // skip any empty literals after the first literal
-        if ((doc.length === 0) || containsContent) {
+        if (doc.length === 0 || containsContent) {
           doc.push(currentLiteralDoc.join(""));
         }
 

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

@@ -1,8 +1,5 @@
 import { AstPath, type Doc } from "prettier";
-import {
-  addIndentedStatements,
-  addNonBreakingWhitespace,
-} from "./util/print-utils.ts";
+import { addIndentedStatements, addNonBreakingWhitespace } from "./util/print-utils.ts";
 import type { AbstractNode } from "../ast/node/abstract-node.ts";
 import type { SwitchStatement } from "../ast/node/switch-statement.ts";
 
@@ -26,15 +23,10 @@ export function printSwitchStatement(
 
   const casesDoc: Doc = [];
 
-  casesDoc.push(
-    ...path.map(print, "caseClauses"),
-  );
+  casesDoc.push(...path.map(print, "caseClauses"));
 
   if (switchStatement.defaultClause !== undefined) {
-    casesDoc.push(path.call(
-      print,
-      "defaultClause" as keyof SwitchStatement["defaultClause"],
-    ));
+    casesDoc.push(path.call(print, "defaultClause" as keyof SwitchStatement["defaultClause"]));
   }
 
   return addIndentedStatements(