@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.4

package/src/ast/build/consume/consume-primitive.ts

@@ -18,8 +18,7 @@ const logger = getLogger("consumePrimitive");
 
 export function consumePrimitive(buildContext: BuildContext): AbstractNode {
   const { cursor } = buildContext;
-  const currentState =
-    buildContext.stateStack[buildContext.stateStack.length - 1];
+  const currentState = buildContext.stateStack[buildContext.stateStack.length - 1];
   const token = buildToken(buildContext);
 
   let node: AbstractNode;
@@ -44,12 +43,11 @@ export function consumePrimitive(buildContext: BuildContext): AbstractNode {
       node = buildFloatingPointLiteral(token);
       break;
     default:
-      throw new InternalScannerError(
-        `Unsupported primitive type: ${cursor.type.name}`,
-      );
+      throw new InternalScannerError(`Unsupported primitive type: ${cursor.type.name}`);
   }
   logger.debug(
-    currentState.indent + "consumed primitive node: " +
+    currentState.indent +
+      "consumed primitive node: " +
       NodeKind[node.nodeKind] +
       " " +
       token.text.replaceAll("\n", "\\n"),

package/src/ast/build/consume/consume-trivia.ts

@@ -28,13 +28,9 @@ function getBlankLineTrivia(cursor: TreeCursor, text: Text): Trivia {
  * Iterate through the syntax tree and convert comments or whitespace to Trivia
  * until a non-comment or non-whitespace parse node is found.
  */
-export function consumeTrivia(
-  buildContext: BuildContext,
-  isTrailing: boolean,
-): Trivia[] {
+export function consumeTrivia(buildContext: BuildContext, isTrailing: boolean): Trivia[] {
   const { cursor, text } = buildContext;
-  const currentState =
-    buildContext.stateStack[buildContext.stateStack.length - 1];
+  const currentState = buildContext.stateStack[buildContext.stateStack.length - 1];
 
   if (currentState.isEndOfSiblings) {
     return [];
@@ -61,7 +57,7 @@ export function consumeTrivia(
       const newLineCount = (whitespace.match(/\n/g) || []).length;
 
       // If trailing, stop at first line break
-      if (isTrailing && (newLineCount > 0)) {
+      if (isTrailing && newLineCount > 0) {
         noSibling = false;
         break;
       }
@@ -70,10 +66,7 @@ export function consumeTrivia(
         trivia.push(getBlankLineTrivia(cursor, text));
       }
     } // Otherwise stop at the first non-comment, non-whitespace node
-    else if (
-      (cursor.type.id !== Comment) &&
-      (cursor.type.id !== Whitespace)
-    ) {
+    else if (cursor.type.id !== Comment && cursor.type.id !== Whitespace) {
       noSibling = false;
       break;
     }
@@ -85,10 +78,7 @@ export function consumeTrivia(
     logger.debug(
       currentState.indent +
         `consumed ${isTrailing ? "trailing" : "leading"} trivia: ` +
-        trivia.map((triviaEntry) => triviaEntry.text.replaceAll("\n", "\\n"))
-          .join(
-            ", ",
-          ),
+        trivia.map((triviaEntry) => triviaEntry.text.replaceAll("\n", "\\n")).join(", "),
     );
   }
 

package/src/ast/build/consume/consume-white-space-and-missing-errors.ts

@@ -3,12 +3,9 @@ import type { BuildContext } from "../util/build-context.ts";
 // Generated by Lezer from the SDL grammar
 import { Whitespace } from "../../../lezer/parser.terms.ts";
 
-export function consumeWhiteSpaceAndMissingErrors(
-  buildContext: BuildContext,
-): void {
+export function consumeWhiteSpaceAndMissingErrors(buildContext: BuildContext): void {
   const { cursor } = buildContext;
-  const currentState =
-    buildContext.stateStack[buildContext.stateStack.length - 1];
+  const currentState = buildContext.stateStack[buildContext.stateStack.length - 1];
 
   if (currentState.isEndOfSiblings) {
     return;
@@ -17,7 +14,7 @@ export function consumeWhiteSpaceAndMissingErrors(
   let noSibling = true;
 
   do {
-    if ((cursor.type.id !== Whitespace) && !cursor.type.isError) {
+    if (cursor.type.id !== Whitespace && !cursor.type.isError) {
       noSibling = false;
       break;
     }

package/src/ast/build/node/build-aggregate-output-value.ts

@@ -5,15 +5,10 @@ import type { ElementaryTypeOutputValue } from "../../node/elementary-type-outpu
 import type { BuildContext } from "../util/build-context.ts";
 import type { AbstractNode } from "../../node/abstract-node.ts";
 import type { Token } from "../../node/token.ts";
-import {
-  fetchOneToManyCommaSeparatedList,
-  fetchRequiredNode,
-} from "../util/fetch-node.ts";
+import { fetchOneToManyCommaSeparatedList, fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildAggregateOutputValue(
-  buildContext: BuildContext,
-): AggregateOutputValue {
+export function buildAggregateOutputValue(buildContext: BuildContext): AggregateOutputValue {
   const children: Array<AbstractNode> = [];
 
   const openBracePunctuator = fetchRequiredNode<Token>(
@@ -23,14 +18,13 @@ export function buildAggregateOutputValue(
   );
   children.push(openBracePunctuator);
 
-  const { nodes: outputValues, commaPunctuators } =
-    fetchOneToManyCommaSeparatedList<
-      AggregateOutputValue | ElementaryTypeOutputValue | NumberLiteral
-    >(buildContext, [
-      NodeKind.AGGREGATE_OUTPUT_VALUE,
-      NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE,
-      NodeKind.NUMBER_LITERAL,
-    ]);
+  const { nodes: outputValues, commaPunctuators } = fetchOneToManyCommaSeparatedList<
+    AggregateOutputValue | ElementaryTypeOutputValue | NumberLiteral
+  >(buildContext, [
+    NodeKind.AGGREGATE_OUTPUT_VALUE,
+    NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE,
+    NodeKind.NUMBER_LITERAL,
+  ]);
 
   // now push each output value and comma punctuator to children
   for (let i = 0; i < outputValues.length; i++) {

package/src/ast/build/node/build-aligned-modifier.ts

@@ -8,15 +8,9 @@ import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
 import { isToken, type OptionalNode } from "../../util/types.ts";
 import type { BuildContext } from "../util/build-context.ts";
 
-export function buildAlignedModifier(
-  buildContext: BuildContext,
-): AlignedModifier {
+export function buildAlignedModifier(buildContext: BuildContext): AlignedModifier {
   const children: Array<AbstractNode> = [];
-  const alignedKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.ALIGNED,
-  );
+  const alignedKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.ALIGNED);
   children.push(alignedKeyword);
 
   const openParenthesisPunctuator = fetchOptionalNode<Token>(
@@ -33,17 +27,13 @@ export function buildAlignedModifier(
   if (openParenthesisPunctuator) {
     children.push(openParenthesisPunctuator);
 
-    bitCountModifierToken = fetchOptionalNode<Token>(
-      buildContext,
-      NodeKind.TOKEN,
-      [
-        TokenKind.ALIGNMENT_BIT_COUNT_8,
-        TokenKind.ALIGNMENT_BIT_COUNT_16,
-        TokenKind.ALIGNMENT_BIT_COUNT_32,
-        TokenKind.ALIGNMENT_BIT_COUNT_64,
-        TokenKind.ALIGNMENT_BIT_COUNT_128,
-      ],
-    );
+    bitCountModifierToken = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, [
+      TokenKind.ALIGNMENT_BIT_COUNT_8,
+      TokenKind.ALIGNMENT_BIT_COUNT_16,
+      TokenKind.ALIGNMENT_BIT_COUNT_32,
+      TokenKind.ALIGNMENT_BIT_COUNT_64,
+      TokenKind.ALIGNMENT_BIT_COUNT_128,
+    ]);
     if (bitCountModifierToken) {
       children.push(bitCountModifierToken);
 

package/src/ast/build/node/build-array-definition.ts

@@ -10,19 +10,13 @@ import type { LengthAttribute } from "../../node/length-attribute.ts";
 import type { BuildContext } from "../util/build-context.ts";
 import type { AbstractNode } from "../../node/abstract-node.ts";
 import type { Token } from "../../node/token.ts";
-import {
-  fetchOptionalNode,
-  fetchRequiredNode,
-  fetchZeroToManyList,
-} from "../util/fetch-node.ts";
+import { fetchOptionalNode, fetchRequiredNode, fetchZeroToManyList } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 import { InternalScannerError } from "../../../scanner-error.ts";
 import type { OptionalNode, ZeroToManyList } from "../../util/types.ts";
 import { ArrayDimensionKind } from "../../node/enum/array-dimension-kind.ts";
 
-export function buildArrayDefinition(
-  buildContext: BuildContext,
-): ArrayDefinition {
+export function buildArrayDefinition(buildContext: BuildContext): ArrayDefinition {
   const children: Array<AbstractNode> = [];
 
   const reservedKeyword = fetchOptionalNode<Token>(
@@ -34,11 +28,7 @@ export function buildArrayDefinition(
     children.push(reservedKeyword);
   }
 
-  const legacyKeyword = fetchOptionalNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.LEGACY,
-  );
+  const legacyKeyword = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.LEGACY);
   if (legacyKeyword) {
     children.push(legacyKeyword);
   }
@@ -51,45 +41,29 @@ export function buildArrayDefinition(
     children.push(alignedModifier);
   }
 
-  const elementaryType = fetchOptionalNode<ElementaryType>(
-    buildContext,
-    NodeKind.ELEMENTARY_TYPE,
-  );
+  const elementaryType = fetchOptionalNode<ElementaryType>(buildContext, NodeKind.ELEMENTARY_TYPE);
 
   let lengthAttribute: OptionalNode<LengthAttribute> = undefined;
   let classIdentifier: OptionalNode<Identifier> = undefined;
   if (elementaryType) {
     children.push(elementaryType);
-    lengthAttribute = fetchOptionalNode<LengthAttribute>(
-      buildContext,
-      NodeKind.LENGTH_ATTRIBUTE,
-    );
+    lengthAttribute = fetchOptionalNode<LengthAttribute>(buildContext, NodeKind.LENGTH_ATTRIBUTE);
     if (lengthAttribute) {
       children.push(lengthAttribute);
     } else {
       // If an elementary type is present, a length attribute must be present
-      throw new InternalScannerError(
-        "Expected LengthAttribute node after ElementaryType node",
-      );
+      throw new InternalScannerError("Expected LengthAttribute node after ElementaryType node");
     }
   } else {
-    classIdentifier = fetchOptionalNode<Identifier>(
-      buildContext,
-      NodeKind.IDENTIFIER,
-    );
+    classIdentifier = fetchOptionalNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
     if (classIdentifier) {
       children.push(classIdentifier);
     }
   }
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
   children.push(identifier);
 
-  let dimensions: ZeroToManyList<
-    ExplicitArrayDimension | PartialArrayDimension
-  > = [];
+  let dimensions: ZeroToManyList<ExplicitArrayDimension | PartialArrayDimension> = [];
   const implicitArrayDimension = fetchOptionalNode<ImplicitArrayDimension>(
     buildContext,
     NodeKind.ARRAY_DIMENSION,
@@ -98,9 +72,7 @@ export function buildArrayDefinition(
   if (implicitArrayDimension) {
     children.push(implicitArrayDimension);
   } else {
-    dimensions = fetchZeroToManyList<
-      ExplicitArrayDimension | PartialArrayDimension
-    >(
+    dimensions = fetchZeroToManyList<ExplicitArrayDimension | PartialArrayDimension>(
       buildContext,
       NodeKind.ARRAY_DIMENSION,
       [ArrayDimensionKind.EXPLICIT, ArrayDimensionKind.PARTIAL],

package/src/ast/build/node/build-array-element-access.ts

@@ -9,9 +9,7 @@ import { fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 import { Identifier } from "../../node/identifier.ts";
 
-export function buildArrayElementAccess(
-  buildContext: BuildContext,
-): ArrayElementAccess {
+export function buildArrayElementAccess(buildContext: BuildContext): ArrayElementAccess {
   const children: Array<AbstractNode> = [];
 
   const openBracketPunctuator = fetchRequiredNode<Token>(
@@ -21,12 +19,11 @@ export function buildArrayElementAccess(
   );
   children.push(openBracketPunctuator);
 
-  const index = fetchRequiredNode<
-    AbstractExpression | Identifier | NumberLiteral
-  >(
-    buildContext,
-    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
-  );
+  const index = fetchRequiredNode<AbstractExpression | Identifier | NumberLiteral>(buildContext, [
+    NodeKind.EXPRESSION,
+    NodeKind.IDENTIFIER,
+    NodeKind.NUMBER_LITERAL,
+  ]);
   children.push(index);
 
   const closeBracketPunctuator = fetchRequiredNode<Token>(
@@ -36,10 +33,5 @@ export function buildArrayElementAccess(
   );
   children.push(closeBracketPunctuator);
 
-  return new ArrayElementAccess(
-    openBracketPunctuator,
-    index,
-    closeBracketPunctuator,
-    children,
-  );
+  return new ArrayElementAccess(openBracketPunctuator, index, closeBracketPunctuator, children);
 }

package/src/ast/build/node/build-base64-string-literal.ts

@@ -10,32 +10,22 @@ import { TokenKind } from "../../node/enum/token-kind.ts";
 const ESCAPED_BACKSLASH_REGEX = /\\\\/g;
 const ESCAPED_DOUBLE_QUOTE_REGEX = /\\"/g;
 
-export function buildBase64StringLiteral(
-  buildContext: BuildContext,
-): StringLiteral {
-  const literals = fetchOneToManyList<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    [TokenKind.DOUBLE_QUOTE, TokenKind.BASE64_STRING_LITERAL_CHARACTERS],
-  );
+export function buildBase64StringLiteral(buildContext: BuildContext): StringLiteral {
+  const literals = fetchOneToManyList<Token>(buildContext, NodeKind.TOKEN, [
+    TokenKind.DOUBLE_QUOTE,
+    TokenKind.BASE64_STRING_LITERAL_CHARACTERS,
+  ]);
 
   let value = "";
 
   for (const literal of literals) {
-    if (
-      isToken(literal) &&
-      (literal.tokenKind === TokenKind.BASE64_STRING_LITERAL_CHARACTERS)
-    ) {
+    if (isToken(literal) && literal.tokenKind === TokenKind.BASE64_STRING_LITERAL_CHARACTERS) {
       value += literal.text;
     }
   }
-  value = value.replaceAll(ESCAPED_DOUBLE_QUOTE_REGEX, "'")
+  value = value
+    .replaceAll(ESCAPED_DOUBLE_QUOTE_REGEX, "'")
     .replaceAll(ESCAPED_BACKSLASH_REGEX, "\\");
 
-  return new StringLiteral(
-    StringLiteralKind.BASIC,
-    value,
-    literals,
-    [...literals],
-  );
+  return new StringLiteral(StringLiteralKind.BASIC, value, literals, [...literals]);
 }

package/src/ast/build/node/build-binary-expression.ts

@@ -8,9 +8,7 @@ import { TokenKind } from "../../node/enum/token-kind.ts";
 import { isToken } from "../../util/types.ts";
 import { BinaryOperatorKind } from "../../node/enum/binary-operator-kind.ts";
 
-function getBinaryOperatorKind(
-  token: Token,
-): BinaryOperatorKind | undefined {
+function getBinaryOperatorKind(token: Token): BinaryOperatorKind | undefined {
   const tokenKind = token.tokenKind;
 
   switch (tokenKind) {
@@ -55,41 +53,36 @@ function getBinaryOperatorKind(
   }
 }
 
-export function buildBinaryExpression(
-  buildContext: BuildContext,
-): BinaryExpression {
+export function buildBinaryExpression(buildContext: BuildContext): BinaryExpression {
   const children: Array<AbstractNode> = [];
 
-  const leftOperand = fetchRequiredNode<Token>(
-    buildContext,
-    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
-  );
+  const leftOperand = fetchRequiredNode<Token>(buildContext, [
+    NodeKind.EXPRESSION,
+    NodeKind.IDENTIFIER,
+    NodeKind.NUMBER_LITERAL,
+  ]);
   children.push(leftOperand);
 
-  const binaryOperator = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    [
-      TokenKind.ASSIGNMENT,
-      TokenKind.ADDITION,
-      TokenKind.SUBTRACTION,
-      TokenKind.MULTIPLICATION,
-      TokenKind.DIVISION,
-      TokenKind.MODULUS,
-      TokenKind.BITWISE_SHIFT_LEFT,
-      TokenKind.BITWISE_SHIFT_RIGHT,
-      TokenKind.RELATIONAL_LESS_THAN,
-      TokenKind.RELATIONAL_LESS_THAN_OR_EQUAL,
-      TokenKind.RELATIONAL_GREATER_THAN,
-      TokenKind.RELATIONAL_GREATER_THAN_OR_EQUAL,
-      TokenKind.RELATIONAL_EQUAL,
-      TokenKind.RELATIONAL_NOT_EQUAL,
-      TokenKind.BITWISE_AND,
-      TokenKind.BITWISE_OR,
-      TokenKind.LOGICAL_AND,
-      TokenKind.LOGICAL_OR,
-    ],
-  );
+  const binaryOperator = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, [
+    TokenKind.ASSIGNMENT,
+    TokenKind.ADDITION,
+    TokenKind.SUBTRACTION,
+    TokenKind.MULTIPLICATION,
+    TokenKind.DIVISION,
+    TokenKind.MODULUS,
+    TokenKind.BITWISE_SHIFT_LEFT,
+    TokenKind.BITWISE_SHIFT_RIGHT,
+    TokenKind.RELATIONAL_LESS_THAN,
+    TokenKind.RELATIONAL_LESS_THAN_OR_EQUAL,
+    TokenKind.RELATIONAL_GREATER_THAN,
+    TokenKind.RELATIONAL_GREATER_THAN_OR_EQUAL,
+    TokenKind.RELATIONAL_EQUAL,
+    TokenKind.RELATIONAL_NOT_EQUAL,
+    TokenKind.BITWISE_AND,
+    TokenKind.BITWISE_OR,
+    TokenKind.LOGICAL_AND,
+    TokenKind.LOGICAL_OR,
+  ]);
   children.push(binaryOperator);
 
   let binaryOperatorKind: BinaryOperatorKind | undefined;
@@ -97,10 +90,11 @@ export function buildBinaryExpression(
     binaryOperatorKind = getBinaryOperatorKind(binaryOperator);
   }
 
-  const rightOperand = fetchRequiredNode<Token>(
-    buildContext,
-    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
-  );
+  const rightOperand = fetchRequiredNode<Token>(buildContext, [
+    NodeKind.EXPRESSION,
+    NodeKind.IDENTIFIER,
+    NodeKind.NUMBER_LITERAL,
+  ]);
   children.push(rightOperand);
 
   return new BinaryExpression(

package/src/ast/build/node/build-binary-literal.ts

@@ -4,9 +4,7 @@ import { InternalScannerError } from "../../../scanner-error.ts";
 import type { Token } from "../../node/token.ts";
 
 const DOT_SEPARATOR_REGEX = /\./g;
-export function buildBinaryLiteral(
-  token: Token,
-): NumberLiteral {
+export function buildBinaryLiteral(token: Token): NumberLiteral {
   const literalText = token.text;
 
   if (!literalText.startsWith("0b")) {
@@ -23,15 +21,8 @@ export function buildBinaryLiteral(
     );
   }
 
-  const stringValue = literalText.substring(2).trim().replaceAll(
-    DOT_SEPARATOR_REGEX,
-    "",
-  );
+  const stringValue = literalText.substring(2).trim().replaceAll(DOT_SEPARATOR_REGEX, "");
   const value = parseInt(stringValue, 2);
 
-  return new NumberLiteral(
-    NumberLiteralKind.BINARY,
-    value,
-    [token],
-  );
+  return new NumberLiteral(NumberLiteralKind.BINARY, value, [token]);
 }

package/src/ast/build/node/build-bit-modifier.ts

@@ -11,22 +11,12 @@ import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
 import type { OptionalNode } from "../../util/types.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildBitModifier(
-  buildContext: BuildContext,
-): BitModifier {
+export function buildBitModifier(buildContext: BuildContext): BitModifier {
   const children: Array<AbstractNode> = [];
 
-  const colonPunctuator = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.COLON,
-  );
+  const colonPunctuator = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.COLON);
   children.push(colonPunctuator);
-  const bitKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.BIT,
-  );
+  const bitKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.BIT);
   children.push(bitKeyword);
   const openParenthesisPunctuator = fetchRequiredNode<Token>(
     buildContext,
@@ -34,10 +24,7 @@ export function buildBitModifier(
     TokenKind.OPEN_PARENTHESIS,
   );
   children.push(openParenthesisPunctuator);
-  const length = fetchRequiredNode<NumberLiteral>(
-    buildContext,
-    NodeKind.NUMBER_LITERAL,
-  );
+  const length = fetchRequiredNode<NumberLiteral>(buildContext, NodeKind.NUMBER_LITERAL);
   children.push(length);
   const closeParenthesisPunctuator = fetchRequiredNode<Token>(
     buildContext,
@@ -45,10 +32,7 @@ export function buildBitModifier(
     TokenKind.CLOSE_PARENTHESIS,
   );
   children.push(closeParenthesisPunctuator);
-  const identifier = fetchOptionalNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchOptionalNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
 
   let assignmentOperator: OptionalNode<Token> = undefined;
   if (identifier) {
@@ -66,10 +50,7 @@ export function buildBitModifier(
       );
     }
   }
-  const classId = fetchRequiredNode<AbstractClassId>(
-    buildContext,
-    NodeKind.CLASS_ID,
-  );
+  const classId = fetchRequiredNode<AbstractClassId>(buildContext, NodeKind.CLASS_ID);
   children.push(classId);
 
   return new BitModifier(

package/src/ast/build/node/build-case-clause.ts

@@ -6,35 +6,18 @@ import type { AbstractStatement } from "../../node/abstract-statement.ts";
 import type { BuildContext } from "../util/build-context.ts";
 import type { AbstractNode } from "../../node/abstract-node.ts";
 import type { Token } from "../../node/token.ts";
-import {
-  fetchOptionalNode,
-  fetchRequiredNode,
-  fetchZeroToManyList,
-} from "../util/fetch-node.ts";
+import { fetchOptionalNode, fetchRequiredNode, fetchZeroToManyList } from "../util/fetch-node.ts";
 import type { OptionalNode } from "../../util/types.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildCaseClause(
-  buildContext: BuildContext,
-): CaseClause {
+export function buildCaseClause(buildContext: BuildContext): CaseClause {
   const children: Array<AbstractNode> = [];
 
-  const caseKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.CASE,
-  );
+  const caseKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.CASE);
   children.push(caseKeyword);
-  const value = fetchRequiredNode<NumberLiteral>(
-    buildContext,
-    NodeKind.NUMBER_LITERAL,
-  );
+  const value = fetchRequiredNode<NumberLiteral>(buildContext, NodeKind.NUMBER_LITERAL);
   children.push(value);
-  const colonPunctuator = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.COLON,
-  );
+  const colonPunctuator = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.COLON);
   children.push(colonPunctuator);
   const openBracePunctuator = fetchOptionalNode<Token>(
     buildContext,
@@ -44,16 +27,9 @@ export function buildCaseClause(
   if (openBracePunctuator) {
     children.push(openBracePunctuator);
   }
-  const statements = fetchZeroToManyList<AbstractStatement>(
-    buildContext,
-    NodeKind.STATEMENT,
-  );
+  const statements = fetchZeroToManyList<AbstractStatement>(buildContext, NodeKind.STATEMENT);
   children.push(...statements);
-  const breakKeyword = fetchOptionalNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.BREAK,
-  );
+  const breakKeyword = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.BREAK);
   let semicolonPunctuator: OptionalNode<Token> = undefined;
   if (breakKeyword) {
     children.push(breakKeyword);
@@ -65,9 +41,7 @@ export function buildCaseClause(
     if (semicolonPunctuator) {
       children.push(semicolonPunctuator);
     } else {
-      throw new InternalScannerError(
-        "Expected semicolon punctuator ';' after break keyword.",
-      );
+      throw new InternalScannerError("Expected semicolon punctuator ';' after break keyword.");
     }
   }