@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

package/src/ast/build/node/build-parameter-value-list.ts

@@ -4,15 +4,10 @@ import type { AbstractExpression } from "../../node/abstract-expression.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 {
-  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 buildParameterValueList(
-  buildContext: BuildContext,
-): ParameterValueList {
+export function buildParameterValueList(buildContext: BuildContext): ParameterValueList {
   const children: Array<AbstractNode> = [];
 
   const openParenthesisPunctuator = fetchRequiredNode<Token>(
@@ -22,13 +17,10 @@ export function buildParameterValueList(
   );
   children.push(openParenthesisPunctuator);
 
-  const { nodes: values, commaPunctuators } = fetchOneToManyCommaSeparatedList<
-    AbstractExpression
-  >(buildContext, [
-    NodeKind.EXPRESSION,
-    NodeKind.IDENTIFIER,
-    NodeKind.NUMBER_LITERAL,
-  ]);
+  const { nodes: values, commaPunctuators } = fetchOneToManyCommaSeparatedList<AbstractExpression>(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+  );
 
   // now push each output value and comma punctuator to children
   for (let i = 0; i < values.length; i++) {

package/src/ast/build/node/build-parameter.ts

@@ -8,23 +8,15 @@ import type { AbstractNode } from "../../node/abstract-node.ts";
 import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
 import type { OptionalNode } from "../../util/types.ts";
 
-export function buildParameter(
-  buildContext: BuildContext,
-): Parameter {
+export function buildParameter(buildContext: BuildContext): Parameter {
   const children: Array<AbstractNode> = [];
 
-  const classIdentifier = fetchOptionalNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const classIdentifier = fetchOptionalNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
   let elementaryType: OptionalNode<ElementaryType> = undefined;
   if (classIdentifier) {
     children.push(classIdentifier);
   } else {
-    elementaryType = fetchOptionalNode<ElementaryType>(
-      buildContext,
-      NodeKind.ELEMENTARY_TYPE,
-    );
+    elementaryType = fetchOptionalNode<ElementaryType>(buildContext, NodeKind.ELEMENTARY_TYPE);
     if (elementaryType) {
       children.push(elementaryType);
     } else {
@@ -33,15 +25,7 @@ export function buildParameter(
       );
     }
   }
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
   children.push(identifier);
-  return new Parameter(
-    classIdentifier,
-    elementaryType,
-    identifier,
-    children,
-  );
+  return new Parameter(classIdentifier, elementaryType, identifier, children);
 }

package/src/ast/build/node/build-partial-array-dimension.ts

@@ -8,9 +8,7 @@ import type { Token } from "../../node/token.ts";
 import { fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildPartialArrayDimension(
-  buildContext: BuildContext,
-): PartialArrayDimension {
+export function buildPartialArrayDimension(buildContext: BuildContext): PartialArrayDimension {
   const openBracketPunctuator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
@@ -21,12 +19,11 @@ export function buildPartialArrayDimension(
     NodeKind.TOKEN,
     TokenKind.OPEN_BRACKET,
   );
-  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,
+  ]);
   const innerCloseBracketPunctuator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,

package/src/ast/build/node/build-specification.ts

@@ -7,13 +7,9 @@ import { fetchZeroToManyList } from "../util/fetch-node.ts";
 import { StatementKind } from "../../node/enum/statement-kind.ts";
 import { NodeKind } from "../../../../index.ts";
 
-export function buildSpecification(
-  buildContext: BuildContext,
-): Specification {
+export function buildSpecification(buildContext: BuildContext): Specification {
   const globals = fetchZeroToManyList<
-    | ComputedElementaryTypeDefinition
-    | MapDeclaration
-    | ClassDeclaration
+    ComputedElementaryTypeDefinition | MapDeclaration | ClassDeclaration
   >(buildContext, NodeKind.STATEMENT, [
     StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION,
     StatementKind.MAP_DECLARATION,

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

@@ -11,9 +11,7 @@ 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 buildStringDefinition(
-  buildContext: BuildContext,
-): StringDefinition {
+export function buildStringDefinition(buildContext: BuildContext): StringDefinition {
   const children: Array<AbstractNode> = [];
 
   const reservedKeyword = fetchOptionalNode<Token>(
@@ -24,19 +22,11 @@ export function buildStringDefinition(
   if (reservedKeyword) {
     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);
   }
-  const constKeyword = fetchOptionalNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.CONST,
-  );
+  const constKeyword = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.CONST);
   if (constKeyword) {
     children.push(constKeyword);
   }
@@ -47,21 +37,14 @@ export function buildStringDefinition(
   if (alignedModifier) {
     children.push(alignedModifier);
   }
-  const stringVariableKindToken = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    [
-      TokenKind.UTF16_STRING,
-      TokenKind.UTF8_STRING,
-      TokenKind.UTF8_LIST,
-      TokenKind.BASE64_STRING,
-    ],
-  );
+  const stringVariableKindToken = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, [
+    TokenKind.UTF16_STRING,
+    TokenKind.UTF8_STRING,
+    TokenKind.UTF8_LIST,
+    TokenKind.BASE64_STRING,
+  ]);
   children.push(stringVariableKindToken);
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
   children.push(identifier);
   const assignmentPunctuator = fetchOptionalNode<Token>(
     buildContext,
@@ -71,10 +54,7 @@ export function buildStringDefinition(
   let stringLiteral: OptionalNode<StringLiteral> = undefined;
   if (assignmentPunctuator) {
     children.push(assignmentPunctuator);
-    stringLiteral = fetchOptionalNode<StringLiteral>(
-      buildContext,
-      NodeKind.STRING_LITERAL,
-    );
+    stringLiteral = fetchOptionalNode<StringLiteral>(buildContext, NodeKind.STRING_LITERAL);
     if (stringLiteral) {
       children.push(stringLiteral);
     } else {

package/src/ast/build/node/build-switch-statement.ts

@@ -7,24 +7,14 @@ import { CaseClause } from "../../node/case-clause.ts";
 import { DefaultClause } from "../../node/default-clause.ts";
 import type { BuildContext } from "../util/build-context.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 type { AbstractNode } from "../../node/abstract-node.ts";
 
-export function buildSwitchStatement(
-  buildContext: BuildContext,
-): SwitchStatement {
+export function buildSwitchStatement(buildContext: BuildContext): SwitchStatement {
   const children: Array<AbstractNode> = [];
 
-  const switchKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.SWITCH,
-  );
+  const switchKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.SWITCH);
   children.push(switchKeyword);
   const openParenthesisPunctuator = fetchRequiredNode<Token>(
     buildContext,
@@ -32,9 +22,7 @@ export function buildSwitchStatement(
     TokenKind.OPEN_PARENTHESIS,
   );
   children.push(openParenthesisPunctuator);
-  const expression = fetchRequiredNode<
-    AbstractExpression | NumberLiteral | Identifier
-  >(
+  const expression = fetchRequiredNode<AbstractExpression | NumberLiteral | Identifier>(
     buildContext,
     [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
   );
@@ -51,15 +39,9 @@ export function buildSwitchStatement(
     TokenKind.OPEN_BRACE,
   );
   children.push(openBracePunctuator);
-  const caseClauses = fetchZeroToManyList<CaseClause>(
-    buildContext,
-    NodeKind.CASE_CLAUSE,
-  );
+  const caseClauses = fetchZeroToManyList<CaseClause>(buildContext, NodeKind.CASE_CLAUSE);
   children.push(...caseClauses);
-  const defaultClause = fetchOptionalNode<DefaultClause>(
-    buildContext,
-    NodeKind.DEFAULT_CLAUSE,
-  );
+  const defaultClause = fetchOptionalNode<DefaultClause>(buildContext, NodeKind.DEFAULT_CLAUSE);
   if (defaultClause) {
     children.push(defaultClause);
   }

package/src/ast/build/node/build-token.ts

@@ -5,9 +5,7 @@ import { syntacticTokenNodeProp } from "../../../lezer/props/syntactic-token-nod
 import { getLocationFromTextPosition } from "../../../util/location-utils.ts";
 import { tokenKindByTokenTypeId } from "../util/token-kind-by-token-type-id-map.ts";
 
-export function buildToken(
-  buildContext: BuildContext,
-): Token {
+export function buildToken(buildContext: BuildContext): Token {
   const { cursor, text } = buildContext;
   const tokenKind = tokenKindByTokenTypeId.get(cursor.type.id);
 
@@ -18,8 +16,8 @@ export function buildToken(
   }
 
   // Assuming the syntacticTokenNodeProp is easier to get than slicing the text each time
-  const tokenText = cursor.type.prop(syntacticTokenNodeProp) ||
-    text.sliceString(cursor.from, cursor.to);
+  const tokenText =
+    cursor.type.prop(syntacticTokenNodeProp) || text.sliceString(cursor.from, cursor.to);
   const location = getLocationFromTextPosition(text, cursor.from);
 
   return new Token(tokenKind, tokenText, location);

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

@@ -18,14 +18,10 @@ export function buildUnaryExpression(
 ): AbstractExpression | Identifier | NumberLiteral {
   const children: Array<AbstractNode> = [];
 
-  const unaryOperator = fetchOptionalNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    [
-      TokenKind.UNARY_PLUS,
-      TokenKind.UNARY_NEGATION,
-    ],
-  );
+  const unaryOperator = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, [
+    TokenKind.UNARY_PLUS,
+    TokenKind.UNARY_NEGATION,
+  ]);
 
   if (unaryOperator) {
     children.push(unaryOperator);
@@ -41,12 +37,11 @@ export function buildUnaryExpression(
     children.push(openParenthesisPunctuator);
   }
 
-  const operand = fetchRequiredNode<
-    AbstractExpression | Identifier | NumberLiteral
-  >(
-    buildContext,
-    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
-  );
+  const operand = fetchRequiredNode<AbstractExpression | Identifier | NumberLiteral>(buildContext, [
+    NodeKind.EXPRESSION,
+    NodeKind.IDENTIFIER,
+    NodeKind.NUMBER_LITERAL,
+  ]);
 
   children.push(operand);
 
@@ -86,11 +81,10 @@ export function buildUnaryExpression(
     children.push(classMemberAccess);
   }
 
-  const postfixOperator = fetchOptionalNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    [TokenKind.POSTFIX_INCREMENT, TokenKind.POSTFIX_DECREMENT],
-  );
+  const postfixOperator = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, [
+    TokenKind.POSTFIX_INCREMENT,
+    TokenKind.POSTFIX_DECREMENT,
+  ]);
 
   if (postfixOperator) {
     children.push(postfixOperator);

package/src/ast/build/node/build-unexpected-error.ts

@@ -3,12 +3,8 @@ import { UnexpectedError } from "../../node/unexpected-error.ts";
 import { fetchRequiredNode } from "../util/fetch-node.ts";
 import type { AbstractNode } from "../../node/abstract-node.ts";
 
-export function buildUnexpectedError(
-  buildContext: BuildContext,
-): UnexpectedError {
-  const unexpectedNode = fetchRequiredNode<AbstractNode>(
-    buildContext,
-  );
+export function buildUnexpectedError(buildContext: BuildContext): UnexpectedError {
+  const unexpectedNode = fetchRequiredNode<AbstractNode>(buildContext);
 
   return new UnexpectedError(unexpectedNode);
 }

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

@@ -21,90 +21,67 @@ function getStringValueFromLiteralText(
   cursor: TreeCursor,
   text: Text,
 ): string {
-  let value = literalText.replaceAll(ESCAPED_DOUBLE_QUOTE_REGEX, "'")
+  let value = literalText
+    .replaceAll(ESCAPED_DOUBLE_QUOTE_REGEX, "'")
     .replaceAll(ESCAPED_BACKSLASH_REGEX, "\\");
 
-  value = value.replaceAll(
-    FOUR_HEXADECIMAL_UNIVERSAL_CHARACTER_NAME_REGEX,
-    (match) => {
-      if (!match.startsWith("\\u")) {
-        throw new InternalScannerError(
-          `Missing prefix "\\u" in universal character name: ${match}`,
-          getLocationFromTextPosition(text, cursor.from),
-        );
-      }
+  value = value.replaceAll(FOUR_HEXADECIMAL_UNIVERSAL_CHARACTER_NAME_REGEX, (match) => {
+    if (!match.startsWith("\\u")) {
+      throw new InternalScannerError(
+        `Missing prefix "\\u" in universal character name: ${match}`,
+        getLocationFromTextPosition(text, cursor.from),
+      );
+    }
 
-      const codePoint = parseInt(match.substring(2), 16);
+    const codePoint = parseInt(match.substring(2), 16);
 
-      if (isNaN(codePoint)) {
-        throw new InternalScannerError(
-          `Unable to convert universal character name: ${codePoint} to code point number`,
-          getLocationFromTextPosition(text, cursor.from),
-        );
-      }
+    if (isNaN(codePoint)) {
+      throw new InternalScannerError(
+        `Unable to convert universal character name: ${codePoint} to code point number`,
+        getLocationFromTextPosition(text, cursor.from),
+      );
+    }
 
-      return String.fromCodePoint(0x1234);
-    },
-  );
+    return String.fromCodePoint(0x1234);
+  });
 
-  value = value.replaceAll(
-    EIGHT_HEXADECIMAL_UNIVERSAL_CHARACTER_NAME_REGEX,
-    (match) => {
-      if (!match.startsWith("\\U")) {
-        throw new InternalScannerError(
-          `Missing prefix "\\U" in universal character name: ${match}`,
-          getLocationFromTextPosition(text, cursor.from),
-        );
-      }
+  value = value.replaceAll(EIGHT_HEXADECIMAL_UNIVERSAL_CHARACTER_NAME_REGEX, (match) => {
+    if (!match.startsWith("\\U")) {
+      throw new InternalScannerError(
+        `Missing prefix "\\U" in universal character name: ${match}`,
+        getLocationFromTextPosition(text, cursor.from),
+      );
+    }
 
-      const codePoint = parseInt(match.substring(2), 16);
+    const codePoint = parseInt(match.substring(2), 16);
 
-      if (isNaN(codePoint)) {
-        throw new InternalScannerError(
-          `Unable to convert universal character name: ${match} to code point number`,
-          getLocationFromTextPosition(text, cursor.from),
-        );
-      }
+    if (isNaN(codePoint)) {
+      throw new InternalScannerError(
+        `Unable to convert universal character name: ${match} to code point number`,
+        getLocationFromTextPosition(text, cursor.from),
+      );
+    }
 
-      return String.fromCodePoint(codePoint);
-    },
-  );
+    return String.fromCodePoint(codePoint);
+  });
 
   return value;
 }
 
-export function buildUtfStringLiteral(
-  buildContext: BuildContext,
-): StringLiteral {
-  const literals = fetchOneToManyList<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    [
-      TokenKind.UTF_PREFIX,
-      TokenKind.DOUBLE_QUOTE,
-      TokenKind.UTF_STRING_LITERAL_CHARACTERS,
-    ],
-  );
+export function buildUtfStringLiteral(buildContext: BuildContext): StringLiteral {
+  const literals = fetchOneToManyList<Token>(buildContext, NodeKind.TOKEN, [
+    TokenKind.UTF_PREFIX,
+    TokenKind.DOUBLE_QUOTE,
+    TokenKind.UTF_STRING_LITERAL_CHARACTERS,
+  ]);
 
   let value = "";
 
   for (const literal of literals) {
-    if (
-      isToken(literal) &&
-      (literal.tokenKind === TokenKind.UTF_STRING_LITERAL_CHARACTERS)
-    ) {
-      value += getStringValueFromLiteralText(
-        literal.text,
-        buildContext.cursor,
-        buildContext.text,
-      );
+    if (isToken(literal) && literal.tokenKind === TokenKind.UTF_STRING_LITERAL_CHARACTERS) {
+      value += getStringValueFromLiteralText(literal.text, buildContext.cursor, buildContext.text);
     }
   }
 
-  return new StringLiteral(
-    StringLiteralKind.UTF,
-    value,
-    literals,
-    [...literals],
-  );
+  return new StringLiteral(StringLiteralKind.UTF, value, literals, [...literals]);
 }

package/src/ast/build/node/build-while-statement.ts

@@ -9,22 +9,14 @@ import { fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 import type { AbstractStatement } from "../../node/abstract-statement.ts";
 
-export function buildWhileStatement(
-  buildContext: BuildContext,
-): WhileStatement {
-  const whileKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.WHILE,
-  );
+export function buildWhileStatement(buildContext: BuildContext): WhileStatement {
+  const whileKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.WHILE);
   const openParenthesisPunctuator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
     TokenKind.OPEN_PARENTHESIS,
   );
-  const condition = fetchRequiredNode<
-    AbstractExpression | Identifier | NumberLiteral
-  >(
+  const condition = fetchRequiredNode<AbstractExpression | Identifier | NumberLiteral>(
     buildContext,
     [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
   );
@@ -33,10 +25,7 @@ export function buildWhileStatement(
     NodeKind.TOKEN,
     TokenKind.CLOSE_PARENTHESIS,
   );
-  const statement = fetchRequiredNode<AbstractStatement>(
-    buildContext,
-    NodeKind.STATEMENT,
-  );
+  const statement = fetchRequiredNode<AbstractStatement>(buildContext, NodeKind.STATEMENT);
 
   return new WhileStatement(
     whileKeyword,
@@ -44,12 +33,6 @@ export function buildWhileStatement(
     condition,
     closeParenthesisPunctuator,
     statement,
-    [
-      whileKeyword,
-      openParenthesisPunctuator,
-      condition,
-      closeParenthesisPunctuator,
-      statement,
-    ],
+    [whileKeyword, openParenthesisPunctuator, condition, closeParenthesisPunctuator, statement],
   );
 }

package/src/ast/build/util/array-dimension-kind-by-token-type-id-map.ts

@@ -4,8 +4,7 @@ import { InternalScannerError } from "../../../scanner-error.ts";
 // Generated by Lezer from the SDL grammar
 import * as TokenTypeId from "../../../lezer/parser.terms.ts";
 
-export const arrayDimensionKindByTokenTypeId: Map<number, ArrayDimensionKind> =
-  new Map();
+export const arrayDimensionKindByTokenTypeId: Map<number, ArrayDimensionKind> = new Map();
 
 /**
  * Map parsed token type ID to AST token type enum.
@@ -14,22 +13,13 @@ export const arrayDimensionKindByTokenTypeId: Map<number, ArrayDimensionKind> =
 Object.values(TokenTypeId).forEach((tokenTypeId) => {
   switch (tokenTypeId) {
     case TokenTypeId.ExplicitArrayDimension:
-      arrayDimensionKindByTokenTypeId.set(
-        tokenTypeId,
-        ArrayDimensionKind.EXPLICIT,
-      );
+      arrayDimensionKindByTokenTypeId.set(tokenTypeId, ArrayDimensionKind.EXPLICIT);
       break;
     case TokenTypeId.ImplicitArrayDimension:
-      arrayDimensionKindByTokenTypeId.set(
-        tokenTypeId,
-        ArrayDimensionKind.IMPLICIT,
-      );
+      arrayDimensionKindByTokenTypeId.set(tokenTypeId, ArrayDimensionKind.IMPLICIT);
       break;
     case TokenTypeId.PartialArrayDimension:
-      arrayDimensionKindByTokenTypeId.set(
-        tokenTypeId,
-        ArrayDimensionKind.PARTIAL,
-      );
+      arrayDimensionKindByTokenTypeId.set(tokenTypeId, ArrayDimensionKind.PARTIAL);
       break;
     case TokenTypeId.AlignedModifier:
     case TokenTypeId.AggregateOutputValue:
@@ -159,9 +149,7 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
       break;
     default: {
       const exhaustiveCheck: never = tokenTypeId;
-      throw new InternalScannerError(
-        "Unreachable code reached, tokenTypeId == " + exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, tokenTypeId == " + exhaustiveCheck);
     }
   }
 });

package/src/ast/build/util/binary-operator-kind-by-token-type-id-map.ts

@@ -4,8 +4,7 @@ import { InternalScannerError } from "../../../scanner-error.ts";
 // Generated by Lezer from the SDL grammar
 import * as TokenTypeId from "../../../lezer/parser.terms.ts";
 
-export const binaryOperatorKindByTokenTypeId: Map<number, BinaryOperatorKind> =
-  new Map();
+export const binaryOperatorKindByTokenTypeId: Map<number, BinaryOperatorKind> = new Map();
 
 /**
  * Map parsed token type ID to AST token type enum.
@@ -144,9 +143,7 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
       break;
     default: {
       const exhaustiveCheck: never = tokenTypeId;
-      throw new InternalScannerError(
-        "Unreachable code reached, tokenTypeId == " + exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, tokenTypeId == " + exhaustiveCheck);
     }
   }
 });

package/src/ast/build/util/class-id-kind-by-token-type-id-map.ts

@@ -19,10 +19,7 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
       classIdKindByTokenTypeId.set(tokenTypeId, ClassIdKind.RANGE);
       break;
     case TokenTypeId.ExtendedClassIdRange:
-      classIdKindByTokenTypeId.set(
-        tokenTypeId,
-        ClassIdKind.EXTENDED_RANGE,
-      );
+      classIdKindByTokenTypeId.set(tokenTypeId, ClassIdKind.EXTENDED_RANGE);
       break;
     case TokenTypeId.AlignedModifier:
     case TokenTypeId.AggregateOutputValue:
@@ -152,9 +149,7 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
       break;
     default: {
       const exhaustiveCheck: never = tokenTypeId;
-      throw new InternalScannerError(
-        "Unreachable code reached, tokenTypeId == " + exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, tokenTypeId == " + exhaustiveCheck);
     }
   }
 });