@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.4

package/src/ast/build-ast.ts

@@ -24,9 +24,7 @@ export function buildAst(
   sdlStringInput: SdlStringInput,
   lenient = false,
 ): RequiredNode<Specification> {
-  const text = Text.of(
-    sdlStringInput.read(0, sdlStringInput.length).split("\n"),
-  );
+  const text = Text.of(sdlStringInput.read(0, sdlStringInput.length).split("\n"));
   const cursor = parseTree.cursor();
   const buildContext: BuildContext = {
     cursor,
@@ -46,16 +44,11 @@ export function buildAst(
   // check the root node is a Specification
   if (nodeKind !== NodeKind.SPECIFICATION) {
     throw new InternalScannerError(
-      `Expected start node to be a Specification, but found ${
-        NodeKind[nodeKind]
-      }.`,
+      `Expected start node to be a Specification, but found ${NodeKind[nodeKind]}.`,
     );
   }
 
-  const specification = fetchRequiredNode<Specification>(
-    buildContext,
-    NodeKind.SPECIFICATION,
-  );
+  const specification = fetchRequiredNode<Specification>(buildContext, NodeKind.SPECIFICATION);
 
   if (buildContext.stateStack.length !== 1) {
     throw new InternalScannerError(
@@ -64,16 +57,12 @@ export function buildAst(
   }
 
   if (!specification) {
-    throw new InternalScannerError(
-      `Expected to parse a Specification node, but none was found.`,
-    );
+    throw new InternalScannerError(`Expected to parse a Specification node, but none was found.`);
   }
 
-  if ((nodeKind !== NodeKind.SPECIFICATION) && (!cursor.type.isError)) {
+  if (nodeKind !== NodeKind.SPECIFICATION && !cursor.type.isError) {
     throw new InternalScannerError(
-      `Expected final node to be a Specification or an error, but found ${
-        NodeKind[nodeKind]
-      }.`,
+      `Expected final node to be a Specification or an error, but found ${NodeKind[nodeKind]}.`,
     );
   }
 
@@ -85,17 +74,13 @@ export function buildAst(
 
     // filter from the end any empty blank line trivia
     while (
-      (buildContext.unconsumedTrivia.length > 0) &&
-      (buildContext.unconsumedTrivia[
-        buildContext.unconsumedTrivia.length - 1
-      ].text.trim() === "")
+      buildContext.unconsumedTrivia.length > 0 &&
+      buildContext.unconsumedTrivia[buildContext.unconsumedTrivia.length - 1].text.trim() === ""
     ) {
       buildContext.unconsumedTrivia.pop();
     }
 
-    specification.trailingTrivia.push(
-      ...buildContext.unconsumedTrivia,
-    );
+    specification.trailingTrivia.push(...buildContext.unconsumedTrivia);
 
     delete buildContext.unconsumedTrivia;
   }

package/src/ast/node/abstract-array-dimension.ts

@@ -12,9 +12,6 @@ export abstract class AbstractArrayDimension extends AbstractCompositeNode {
     public readonly closeBracketPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.ARRAY_DIMENSION,
-      children,
-    );
+    super(NodeKind.ARRAY_DIMENSION, children);
   }
 }

package/src/ast/node/abstract-composite-node.ts

@@ -31,8 +31,7 @@ export abstract class AbstractCompositeNode extends AbstractNode {
       this.startToken = firstChild;
     } else {
       throw new InternalScannerError(
-        "Unsupported node type for start token assignment: " +
-          NodeKind[firstChild.nodeKind],
+        "Unsupported node type for start token assignment: " + NodeKind[firstChild.nodeKind],
       );
     }
     const lastChild = children[children.length - 1];
@@ -42,8 +41,7 @@ export abstract class AbstractCompositeNode extends AbstractNode {
       this.endToken = lastChild;
     } else {
       throw new InternalScannerError(
-        "Unsupported node type for end token assignment: " +
-          NodeKind[lastChild.nodeKind],
+        "Unsupported node type for end token assignment: " + NodeKind[lastChild.nodeKind],
       );
     }
   }

package/src/ast/node/abstract-elementary-type-definition.ts

@@ -8,19 +8,14 @@ import type { Identifier } from "./identifier.ts";
 import type { NumberLiteral } from "./number-literal.ts";
 import type { Token } from "./token.ts";
 
-export abstract class AbstractElementaryTypeDefinition
-  extends AbstractStatement {
+export abstract class AbstractElementaryTypeDefinition extends AbstractStatement {
   constructor(
     kind: StatementKind,
     public readonly constKeyword: OptionalNode<Token>,
     public readonly elementaryType: RequiredNode<ElementaryType>,
     public readonly identifier: RequiredNode<Identifier>,
     public readonly assignmentOperator: OptionalNode<Token>,
-    public readonly value: OptionalNode<
-      | AbstractExpression
-      | NumberLiteral
-      | Identifier
-    >,
+    public readonly value: OptionalNode<AbstractExpression | NumberLiteral | Identifier>,
     public readonly semicolonPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {

package/src/ast/node/abstract-leaf-node.ts

@@ -2,9 +2,7 @@ import { AbstractNode } from "./abstract-node.ts";
 import type { NodeKind } from "./enum/node-kind.ts";
 
 export abstract class AbstractLeafNode extends AbstractNode {
-  constructor(
-    nodeKind: NodeKind,
-  ) {
+  constructor(nodeKind: NodeKind) {
     super(nodeKind, false);
   }
 }

package/src/ast/node/abstract-node.ts

@@ -9,8 +9,7 @@ export abstract class AbstractNode {
   constructor(
     public readonly nodeKind: NodeKind,
     public readonly isComposite: boolean,
-  ) {
-  }
+  ) {}
 
   abstract getLocation(): Location;
 }

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

@@ -4,11 +4,7 @@ import { NodeKind } from "./enum/node-kind.ts";
 import type { NumberLiteral } from "./number-literal.ts";
 import type { ElementaryTypeOutputValue } from "./elementary-type-output-value.ts";
 import type { Token } from "./token.ts";
-import type {
-  OneToManyList,
-  RequiredNode,
-  ZeroToManyList,
-} from "../util/types.ts";
+import type { OneToManyList, RequiredNode, ZeroToManyList } from "../util/types.ts";
 
 export class AggregateOutputValue extends AbstractCompositeNode {
   constructor(
@@ -20,9 +16,6 @@ export class AggregateOutputValue extends AbstractCompositeNode {
     public readonly closeBracePunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.AGGREGATE_OUTPUT_VALUE,
-      children,
-    );
+    super(NodeKind.AGGREGATE_OUTPUT_VALUE, children);
   }
 }

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

@@ -13,9 +13,6 @@ export class AlignedModifier extends AbstractCompositeNode {
     public readonly alignment: number,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.ALIGNED_MODIFIER,
-      children,
-    );
+    super(NodeKind.ALIGNED_MODIFIER, children);
   }
 }

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

@@ -1,8 +1,4 @@
-import type {
-  OptionalNode,
-  RequiredNode,
-  ZeroToManyList,
-} from "../util/types.ts";
+import type { OptionalNode, RequiredNode, ZeroToManyList } from "../util/types.ts";
 import { AbstractArrayDefinition } from "./abstract-array-definition.ts";
 import type { AbstractNode } from "./abstract-node.ts";
 import type { AlignedModifier } from "./aligned-modifier.ts";
@@ -24,21 +20,11 @@ export class ArrayDefinition extends AbstractArrayDefinition {
     public readonly lengthAttribute: OptionalNode<LengthAttribute>,
     public readonly classIdentifier: OptionalNode<Identifier>,
     public readonly identifier: RequiredNode<Identifier>,
-    public readonly implicitArrayDimension: OptionalNode<
-      ImplicitArrayDimension
-    >,
-    public readonly dimensions: ZeroToManyList<
-      | ExplicitArrayDimension
-      | PartialArrayDimension
-    >,
+    public readonly implicitArrayDimension: OptionalNode<ImplicitArrayDimension>,
+    public readonly dimensions: ZeroToManyList<ExplicitArrayDimension | PartialArrayDimension>,
     semicolonPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.ARRAY_DEFINITION,
-      identifier,
-      semicolonPunctuator,
-      children,
-    );
+    super(StatementKind.ARRAY_DEFINITION, identifier, semicolonPunctuator, children);
   }
 }

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

@@ -10,15 +10,10 @@ import type { Token } from "./token.ts";
 export class ArrayElementAccess extends AbstractCompositeNode {
   constructor(
     public readonly openBracketPunctuator: RequiredNode<Token>,
-    public readonly index: RequiredNode<
-      AbstractExpression | NumberLiteral | Identifier
-    >,
+    public readonly index: RequiredNode<AbstractExpression | NumberLiteral | Identifier>,
     public readonly closeBracketPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.ARRAY_ELEMENT_ACCESS,
-      children,
-    );
+    super(NodeKind.ARRAY_ELEMENT_ACCESS, children);
   }
 }

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

@@ -9,17 +9,9 @@ import type { Token } from "./token.ts";
 
 export class BinaryExpression extends AbstractExpression {
   constructor(
-    public readonly leftOperand: RequiredNode<
-      | AbstractExpression
-      | Identifier
-      | NumberLiteral
-    >,
+    public readonly leftOperand: RequiredNode<AbstractExpression | Identifier | NumberLiteral>,
     public readonly binaryOperator: RequiredNode<Token>,
-    public readonly rightOperand: RequiredNode<
-      | AbstractExpression
-      | Identifier
-      | NumberLiteral
-    >,
+    public readonly rightOperand: RequiredNode<AbstractExpression | Identifier | NumberLiteral>,
     public readonly binaryOperatorKind: BinaryOperatorKind | undefined,
     children: Array<AbstractNode>,
   ) {

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

@@ -1,8 +1,4 @@
-import type {
-  OptionalNode,
-  RequiredNode,
-  ZeroToManyList,
-} from "../util/types.ts";
+import type { OptionalNode, RequiredNode, ZeroToManyList } from "../util/types.ts";
 import { AbstractCompositeNode } from "./abstract-composite-node.ts";
 import type { AbstractNode } from "./abstract-node.ts";
 import type { AbstractStatement } from "./abstract-statement.ts";
@@ -22,9 +18,6 @@ export class CaseClause extends AbstractCompositeNode {
     public readonly closeBracePunctuator: OptionalNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.CASE_CLAUSE,
-      children,
-    );
+    super(NodeKind.CASE_CLAUSE, children);
   }
 }

package/src/ast/node/class-declaration.ts

@@ -1,8 +1,4 @@
-import type {
-  OptionalNode,
-  RequiredNode,
-  ZeroToManyList,
-} from "../util/types.ts";
+import type { OptionalNode, RequiredNode, ZeroToManyList } from "../util/types.ts";
 import type { AbstractNode } from "./abstract-node.ts";
 import { AbstractStatement } from "./abstract-statement.ts";
 import type { AlignedModifier } from "./aligned-modifier.ts";
@@ -17,9 +13,7 @@ import type { Token } from "./token.ts";
 export class ClassDeclaration extends AbstractStatement {
   constructor(
     public readonly alignedModifier: OptionalNode<AlignedModifier>,
-    public readonly expandableModifier:
-      | OptionalNode<ExpandableModifier>
-      | undefined,
+    public readonly expandableModifier: OptionalNode<ExpandableModifier> | undefined,
     public readonly abstractKeyword: OptionalNode<Token>,
     public readonly classKeyword: RequiredNode<Token>,
     public readonly identifier: RequiredNode<Identifier>,
@@ -31,9 +25,6 @@ export class ClassDeclaration extends AbstractStatement {
     public readonly closeBracePunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.CLASS_DECLARATION,
-      children,
-    );
+    super(StatementKind.CLASS_DECLARATION, children);
   }
 }

package/src/ast/node/class-definition.ts

@@ -15,9 +15,6 @@ export class ClassDefinition extends AbstractStatement {
     public readonly semicolonPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.CLASS_DEFINITION,
-      children,
-    );
+    super(StatementKind.CLASS_DEFINITION, children);
   }
 }

package/src/ast/node/class-member-access.ts

@@ -11,9 +11,6 @@ export class ClassMemberAccess extends AbstractCompositeNode {
     public readonly memberIdentifier: RequiredNode<Identifier>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.CLASS_MEMBER_ACCESS,
-      children,
-    );
+    super(NodeKind.CLASS_MEMBER_ACCESS, children);
   }
 }

package/src/ast/node/compound-statement.ts

@@ -11,9 +11,6 @@ export class CompoundStatement extends AbstractStatement {
     public readonly closeBracePunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.COMPOUND,
-      children,
-    );
+    super(StatementKind.COMPOUND, children);
   }
 }

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

@@ -16,11 +16,6 @@ export class ComputedArrayDefinition extends AbstractArrayDefinition {
     semicolonPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.COMPUTED_ARRAY_DEFINITION,
-      identifier,
-      semicolonPunctuator,
-      children,
-    );
+    super(StatementKind.COMPUTED_ARRAY_DEFINITION, identifier, semicolonPunctuator, children);
   }
 }

package/src/ast/node/computed-elementary-type-definition.ts

@@ -8,8 +8,7 @@ import type { Identifier } from "./identifier.ts";
 import type { NumberLiteral } from "./number-literal.ts";
 import type { Token } from "./token.ts";
 
-export class ComputedElementaryTypeDefinition
-  extends AbstractElementaryTypeDefinition {
+export class ComputedElementaryTypeDefinition extends AbstractElementaryTypeDefinition {
   constructor(
     public readonly computedKeyword: RequiredNode<Token>,
     constKeyword: OptionalNode<Token>,

package/src/ast/node/default-clause.ts

@@ -1,8 +1,4 @@
-import type {
-  OptionalNode,
-  RequiredNode,
-  ZeroToManyList,
-} from "../util/types.ts";
+import type { OptionalNode, RequiredNode, ZeroToManyList } from "../util/types.ts";
 import { AbstractCompositeNode } from "./abstract-composite-node.ts";
 import type { AbstractNode } from "./abstract-node.ts";
 import type { AbstractStatement } from "./abstract-statement.ts";
@@ -18,9 +14,6 @@ export class DefaultClause extends AbstractCompositeNode {
     public readonly closeBracePunctuator: OptionalNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.DEFAULT_CLAUSE,
-      children,
-    );
+    super(NodeKind.DEFAULT_CLAUSE, children);
   }
 }

package/src/ast/node/do-statement.ts

@@ -14,11 +14,7 @@ export class DoStatement extends AbstractStatement {
     public readonly compoundStatement: RequiredNode<CompoundStatement>,
     public readonly whileKeyword: RequiredNode<Token>,
     public readonly openParenthesisPunctuator: RequiredNode<Token>,
-    public readonly condition: RequiredNode<
-      | AbstractExpression
-      | Identifier
-      | NumberLiteral
-    >,
+    public readonly condition: RequiredNode<AbstractExpression | Identifier | NumberLiteral>,
     public readonly closeParenthesisPunctuator: RequiredNode<Token>,
     public readonly semicolonPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,

package/src/ast/node/elementary-type-definition.ts

@@ -21,17 +21,9 @@ export class ElementaryTypeDefinition extends AbstractElementaryTypeDefinition {
     public readonly lookAheadOperator: OptionalNode<Token>,
     identifier: RequiredNode<Identifier>,
     assignmentOperator: OptionalNode<Token>,
-    value: OptionalNode<
-      | AbstractExpression
-      | NumberLiteral
-      | Identifier
-    >,
+    value: OptionalNode<AbstractExpression | NumberLiteral | Identifier>,
     public readonly rangeOperator: OptionalNode<Token>,
-    public readonly endValue: OptionalNode<
-      | AbstractExpression
-      | NumberLiteral
-      | Identifier
-    >,
+    public readonly endValue: OptionalNode<AbstractExpression | NumberLiteral | Identifier>,
     semicolonPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {

package/src/ast/node/elementary-type-output-value.ts

@@ -11,9 +11,6 @@ export class ElementaryTypeOutputValue extends AbstractCompositeNode {
     public readonly lengthAttribute: RequiredNode<LengthAttribute>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE,
-      children,
-    );
+    super(NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE, children);
   }
 }

package/src/ast/node/elementary-type.ts

@@ -10,9 +10,6 @@ export class ElementaryType extends AbstractCompositeNode {
     public readonly typeKeyword: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.ELEMENTARY_TYPE,
-      children,
-    );
+    super(NodeKind.ELEMENTARY_TYPE, children);
   }
 }

package/src/ast/node/expandable-modifier.ts

@@ -13,9 +13,6 @@ export class ExpandableModifier extends AbstractCompositeNode {
     public readonly closeParenthesisPunctuator: OptionalNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.EXPANDABLE_MODIFIER,
-      children,
-    );
+    super(NodeKind.EXPANDABLE_MODIFIER, children);
   }
 }

package/src/ast/node/explicit-array-dimension.ts

@@ -10,17 +10,10 @@ import type { Token } from "./token.ts";
 export class ExplicitArrayDimension extends AbstractArrayDimension {
   constructor(
     openBracketPunctuator: RequiredNode<Token>,
-    public readonly size: RequiredNode<
-      AbstractExpression | Identifier | NumberLiteral
-    >,
+    public readonly size: RequiredNode<AbstractExpression | Identifier | NumberLiteral>,
     closeBracketPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      ArrayDimensionKind.EXPLICIT,
-      openBracketPunctuator,
-      closeBracketPunctuator,
-      children,
-    );
+    super(ArrayDimensionKind.EXPLICIT, openBracketPunctuator, closeBracketPunctuator, children);
   }
 }

package/src/ast/node/expression-statement.ts

@@ -9,15 +9,10 @@ import type { RequiredNode } from "../util/types.ts";
 
 export class ExpressionStatement extends AbstractStatement {
   constructor(
-    public readonly expression: RequiredNode<
-      AbstractExpression | Identifier | NumberLiteral
-    >,
+    public readonly expression: RequiredNode<AbstractExpression | Identifier | NumberLiteral>,
     public readonly semicolonPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.EXPRESSION,
-      children,
-    );
+    super(StatementKind.EXPRESSION, children);
   }
 }

package/src/ast/node/extended-class-id-range.ts

@@ -12,9 +12,6 @@ export class ExtendedClassIdRange extends AbstractClassId {
     public readonly commaPunctuators: ZeroToManyList<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      ClassIdKind.EXTENDED_RANGE,
-      children,
-    );
+    super(ClassIdKind.EXTENDED_RANGE, children);
   }
 }

package/src/ast/node/extends-modifier.ts

@@ -13,9 +13,6 @@ export class ExtendsModifier extends AbstractCompositeNode {
     public readonly parameterValueList: OptionalNode<ParameterValueList>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.EXTENDS_MODIFIER,
-      children,
-    );
+    super(NodeKind.EXTENDS_MODIFIER, children);
   }
 }

package/src/ast/node/for-statement.ts

@@ -12,9 +12,7 @@ export class ForStatement extends AbstractStatement {
     public readonly openParenthesisPunctuator: RequiredNode<Token>,
     // either ((assignment_expression semicolon) | computed_elementary_type_definition | semicolon)
     public readonly expression1: OptionalNode<AbstractExpression>,
-    public readonly computedElementaryDefinition: OptionalNode<
-      ComputedElementaryTypeDefinition
-    >,
+    public readonly computedElementaryDefinition: OptionalNode<ComputedElementaryTypeDefinition>,
     // optional as the first semicolon can be considered part of the optional computedElementaryDefinition
     public readonly semicolon1Punctuator: OptionalNode<Token>,
     public readonly expression2: OptionalNode<AbstractExpression>,

package/src/ast/node/if-statement.ts

@@ -11,18 +11,13 @@ export class IfStatement extends AbstractStatement {
   constructor(
     public readonly ifKeyword: RequiredNode<Token>,
     public readonly openParenthesisPunctuator: RequiredNode<Token>,
-    public readonly condition: RequiredNode<
-      AbstractExpression | Identifier | NumberLiteral
-    >,
+    public readonly condition: RequiredNode<AbstractExpression | Identifier | NumberLiteral>,
     public readonly closeParenthesisPunctuator: RequiredNode<Token>,
     public readonly ifStatement: RequiredNode<AbstractStatement>,
     public readonly elseKeyword: OptionalNode<Token>,
     public readonly elseStatement: OptionalNode<AbstractStatement>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.IF,
-      children,
-    );
+    super(StatementKind.IF, children);
   }
 }

package/src/ast/node/implicit-array-dimension.ts

@@ -10,25 +10,12 @@ import type { Token } from "./token.ts";
 export class ImplicitArrayDimension extends AbstractArrayDimension {
   constructor(
     openBracketPunctuator: RequiredNode<Token>,
-    public readonly rangeStart: OptionalNode<
-      | AbstractExpression
-      | Identifier
-      | NumberLiteral
-    >,
+    public readonly rangeStart: OptionalNode<AbstractExpression | Identifier | NumberLiteral>,
     public readonly rangeOperator: OptionalNode<Token>,
-    public readonly rangeEnd: OptionalNode<
-      | AbstractExpression
-      | Identifier
-      | NumberLiteral
-    >,
+    public readonly rangeEnd: OptionalNode<AbstractExpression | Identifier | NumberLiteral>,
     closeBracketPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      ArrayDimensionKind.IMPLICIT,
-      openBracketPunctuator,
-      closeBracketPunctuator,
-      children,
-    );
+    super(ArrayDimensionKind.IMPLICIT, openBracketPunctuator, closeBracketPunctuator, children);
   }
 }

package/src/ast/node/length-attribute.ts

@@ -10,15 +10,10 @@ import type { Token } from "./token.ts";
 export class LengthAttribute extends AbstractCompositeNode {
   constructor(
     public readonly openParenthesisPunctuator: RequiredNode<Token>,
-    public readonly length: RequiredNode<
-      NumberLiteral | Identifier | AbstractExpression
-    >,
+    public readonly length: RequiredNode<NumberLiteral | Identifier | AbstractExpression>,
     public readonly closeParenthesisPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.LENGTH_ATTRIBUTE,
-      children,
-    );
+    super(NodeKind.LENGTH_ATTRIBUTE, children);
   }
 }

package/src/ast/node/length-of-expression.ts

@@ -13,9 +13,6 @@ export class LengthofExpression extends AbstractExpression {
     public readonly closeParenthesisPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      ExpressionKind.LENGTHOF,
-      children,
-    );
+    super(ExpressionKind.LENGTHOF, children);
   }
 }

package/src/ast/node/map-declaration.ts

@@ -1,9 +1,4 @@
-import type {
-  OneToManyList,
-  OptionalNode,
-  RequiredNode,
-  ZeroToManyList,
-} from "../util/types.ts";
+import type { OneToManyList, OptionalNode, RequiredNode, ZeroToManyList } from "../util/types.ts";
 import type { AbstractNode } from "./abstract-node.ts";
 import { AbstractStatement } from "./abstract-statement.ts";
 import type { ElementaryType } from "./elementary-type.ts";
@@ -26,9 +21,6 @@ export class MapDeclaration extends AbstractStatement {
     public readonly closeBracePunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.MAP_DECLARATION,
-      children,
-    );
+    super(StatementKind.MAP_DECLARATION, children);
   }
 }