@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

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

@@ -7,21 +7,12 @@ import type { BuildContext } from "../util/build-context.ts";
 import type { AbstractNode } from "../../node/abstract-node.ts";
 import { fetchOneToManyCommaSeparatedList } from "../util/fetch-node.ts";
 
-export function buildExtendedClassIdRange(
-  buildContext: BuildContext,
-): ExtendedClassIdRange {
+export function buildExtendedClassIdRange(buildContext: BuildContext): ExtendedClassIdRange {
   const children: Array<AbstractNode> = [];
 
-  const { nodes: classIds, commaPunctuators } =
-    fetchOneToManyCommaSeparatedList<ClassId | ClassIdRange>(
-      buildContext,
-      NodeKind.CLASS_ID,
-      [ClassIdKind.SINGLE, ClassIdKind.RANGE],
-    );
+  const { nodes: classIds, commaPunctuators } = fetchOneToManyCommaSeparatedList<
+    ClassId | ClassIdRange
+  >(buildContext, NodeKind.CLASS_ID, [ClassIdKind.SINGLE, ClassIdKind.RANGE]);
 
-  return new ExtendedClassIdRange(
-    classIds,
-    commaPunctuators,
-    children,
-  );
+  return new ExtendedClassIdRange(classIds, commaPunctuators, children);
 }

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

@@ -8,21 +8,12 @@ import type { Token } from "../../node/token.ts";
 import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildExtendsModifier(
-  buildContext: BuildContext,
-): ExtendsModifier {
+export function buildExtendsModifier(buildContext: BuildContext): ExtendsModifier {
   const children: Array<AbstractNode> = [];
 
-  const extendsKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.EXTENDS,
-  );
+  const extendsKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.EXTENDS);
   children.push(extendsKeyword);
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
   children.push(identifier);
   const parameterValueList = fetchOptionalNode<ParameterValueList>(
     buildContext,
@@ -32,10 +23,5 @@ export function buildExtendsModifier(
     children.push(parameterValueList);
   }
 
-  return new ExtendsModifier(
-    extendsKeyword,
-    identifier,
-    parameterValueList,
-    children,
-  );
+  return new ExtendsModifier(extendsKeyword, identifier, parameterValueList, children);
 }

package/src/ast/build/node/build-floating-point-literal.ts

@@ -2,14 +2,8 @@ import { NumberLiteral } from "../../node/number-literal.ts";
 import { NumberLiteralKind } from "../../node/enum/number-literal-kind.ts";
 import type { Token } from "../../node/token.ts";
 
-export function buildFloatingPointLiteral(
-  token: Token,
-): NumberLiteral {
+export function buildFloatingPointLiteral(token: Token): NumberLiteral {
   const value = parseFloat(token.text);
 
-  return new NumberLiteral(
-    NumberLiteralKind.FLOATING_POINT,
-    value,
-    [token],
-  );
+  return new NumberLiteral(NumberLiteralKind.FLOATING_POINT, value, [token]);
 }

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

@@ -12,16 +12,10 @@ 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 buildForStatement(
-  buildContext: BuildContext,
-): ForStatement {
+export function buildForStatement(buildContext: BuildContext): ForStatement {
   const children: Array<AbstractNode> = [];
 
-  const forKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.FOR,
-  );
+  const forKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.FOR);
   children.push(forKeyword);
   const openParenthesisPunctuator = fetchRequiredNode<Token>(
     buildContext,
@@ -29,33 +23,24 @@ export function buildForStatement(
     TokenKind.OPEN_PARENTHESIS,
   );
   children.push(openParenthesisPunctuator);
-  const expression1 = fetchOptionalNode<AbstractExpression>(
-    buildContext,
-    NodeKind.EXPRESSION,
-  );
+  const expression1 = fetchOptionalNode<AbstractExpression>(buildContext, NodeKind.EXPRESSION);
   const semicolon1Punctuator = fetchOptionalNode<Token>(
     buildContext,
     NodeKind.TOKEN,
     TokenKind.SEMICOLON,
   );
-  let computedElementaryTypeDefinition: OptionalNode<
-    ComputedElementaryTypeDefinition
-  >;
+  let computedElementaryTypeDefinition: OptionalNode<ComputedElementaryTypeDefinition>;
   if (expression1) {
     children.push(expression1);
     if (semicolon1Punctuator) {
       children.push(semicolon1Punctuator);
     } else {
-      throw new InternalScannerError(
-        "Expected semicolon after first expression in for statement",
-      );
+      throw new InternalScannerError("Expected semicolon after first expression in for statement");
     }
   } else if (semicolon1Punctuator) {
     children.push(semicolon1Punctuator);
   } else {
-    computedElementaryTypeDefinition = fetchOptionalNode<
-      ComputedElementaryTypeDefinition
-    >(
+    computedElementaryTypeDefinition = fetchOptionalNode<ComputedElementaryTypeDefinition>(
       buildContext,
       NodeKind.STATEMENT,
       StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION,
@@ -69,10 +54,7 @@ export function buildForStatement(
     }
   }
 
-  const expression2 = fetchOptionalNode<AbstractExpression>(
-    buildContext,
-    NodeKind.EXPRESSION,
-  );
+  const expression2 = fetchOptionalNode<AbstractExpression>(buildContext, NodeKind.EXPRESSION);
   if (expression2) {
     children.push(expression2);
   }
@@ -82,10 +64,7 @@ export function buildForStatement(
     TokenKind.SEMICOLON,
   );
   children.push(semicolon2Punctuator);
-  const expression3 = fetchOptionalNode<AbstractExpression>(
-    buildContext,
-    NodeKind.EXPRESSION,
-  );
+  const expression3 = fetchOptionalNode<AbstractExpression>(buildContext, NodeKind.EXPRESSION);
   if (expression3) {
     children.push(expression3);
   }
@@ -95,10 +74,7 @@ export function buildForStatement(
     TokenKind.CLOSE_PARENTHESIS,
   );
   children.push(closeParenthesisPunctuator);
-  const statement = fetchRequiredNode<AbstractStatement>(
-    buildContext,
-    NodeKind.STATEMENT,
-  );
+  const statement = fetchRequiredNode<AbstractStatement>(buildContext, NodeKind.STATEMENT);
   children.push(statement);
 
   return new ForStatement(

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

@@ -5,9 +5,7 @@ import type { Token } from "../../node/token.ts";
 
 const DOT_SEPARATOR_REGEX = /\./g;
 
-export function buildHexadecimalLiteral(
-  token: Token,
-): NumberLiteral {
+export function buildHexadecimalLiteral(token: Token): NumberLiteral {
   const literalText = token.text;
 
   if (!literalText.startsWith("0x")) {
@@ -24,15 +22,8 @@ export function buildHexadecimalLiteral(
     );
   }
 
-  const stringValue = literalText.substring(2).trim().replaceAll(
-    DOT_SEPARATOR_REGEX,
-    "",
-  );
+  const stringValue = literalText.substring(2).trim().replaceAll(DOT_SEPARATOR_REGEX, "");
   const value = parseInt(stringValue, 16);
 
-  return new NumberLiteral(
-    NumberLiteralKind.HEXADECIMAL,
-    value,
-    [token],
-  );
+  return new NumberLiteral(NumberLiteralKind.HEXADECIMAL, value, [token]);
 }

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

@@ -1,8 +1,6 @@
 import { Identifier } from "../../node/identifier.ts";
 import type { Token } from "../../node/token.ts";
 
-export function buildIdentifier(
-  token: Token,
-): Identifier {
+export function buildIdentifier(token: Token): Identifier {
   return new Identifier(token.text, token);
 }

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

@@ -12,16 +12,10 @@ import type { OptionalNode } from "../../util/types.ts";
 import type { Token } from "../../node/token.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildIfStatement(
-  buildContext: BuildContext,
-): IfStatement {
+export function buildIfStatement(buildContext: BuildContext): IfStatement {
   const children: Array<AbstractNode> = [];
 
-  const ifKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.IF,
-  );
+  const ifKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.IF);
   children.push(ifKeyword);
   const openParenthesisPunctuator = fetchRequiredNode<Token>(
     buildContext,
@@ -29,9 +23,7 @@ export function buildIfStatement(
     TokenKind.OPEN_PARENTHESIS,
   );
   children.push(openParenthesisPunctuator);
-  const condition = fetchRequiredNode<
-    AbstractExpression | NumberLiteral | Identifier
-  >(
+  const condition = fetchRequiredNode<AbstractExpression | NumberLiteral | Identifier>(
     buildContext,
     [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
   );
@@ -42,23 +34,13 @@ export function buildIfStatement(
     TokenKind.CLOSE_PARENTHESIS,
   );
   children.push(closeParenthesisPunctuator);
-  const ifStatement = fetchRequiredNode<AbstractStatement>(
-    buildContext,
-    NodeKind.STATEMENT,
-  );
+  const ifStatement = fetchRequiredNode<AbstractStatement>(buildContext, NodeKind.STATEMENT);
   children.push(ifStatement);
-  const elseKeyword = fetchOptionalNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.ELSE,
-  );
+  const elseKeyword = fetchOptionalNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.ELSE);
   let elseStatement: OptionalNode<AbstractStatement> = undefined;
   if (elseKeyword) {
     children.push(elseKeyword);
-    elseStatement = fetchOptionalNode<AbstractStatement>(
-      buildContext,
-      NodeKind.STATEMENT,
-    );
+    elseStatement = fetchOptionalNode<AbstractStatement>(buildContext, NodeKind.STATEMENT);
     if (elseStatement) {
       children.push(elseStatement);
     } else {

package/src/ast/build/node/build-implicit-array-dimension.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 buildImplicitArrayDimension(
-  buildContext: BuildContext,
-): ImplicitArrayDimension {
+export function buildImplicitArrayDimension(buildContext: BuildContext): ImplicitArrayDimension {
   const children: Array<AbstractNode> = [];
 
   const openBracketPunctuator = fetchRequiredNode<Token>(
@@ -22,16 +20,12 @@ export function buildImplicitArrayDimension(
     TokenKind.OPEN_BRACKET,
   );
   children.push(openBracketPunctuator);
-  const rangeStart = fetchOptionalNode<
-    AbstractExpression | NumberLiteral | Identifier
-  >(
+  const rangeStart = fetchOptionalNode<AbstractExpression | NumberLiteral | Identifier>(
     buildContext,
     [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
   );
   let rangeOperator: OptionalNode<Token> = undefined;
-  let rangeEnd: OptionalNode<
-    AbstractExpression | NumberLiteral | Identifier
-  > = undefined;
+  let rangeEnd: OptionalNode<AbstractExpression | NumberLiteral | Identifier> = undefined;
   if (rangeStart) {
     children.push(rangeStart);
     rangeOperator = fetchOptionalNode<Token>(
@@ -46,12 +40,11 @@ export function buildImplicitArrayDimension(
         "Expected range operator after range start in implicit array dimension",
       );
     }
-    rangeEnd = fetchOptionalNode<
-      AbstractExpression | NumberLiteral | Identifier
-    >(
-      buildContext,
-      [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
-    );
+    rangeEnd = fetchOptionalNode<AbstractExpression | NumberLiteral | Identifier>(buildContext, [
+      NodeKind.EXPRESSION,
+      NodeKind.IDENTIFIER,
+      NodeKind.NUMBER_LITERAL,
+    ]);
     if (rangeEnd) {
       children.push(rangeEnd);
     } else {

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

@@ -2,14 +2,8 @@ import { NumberLiteral } from "../../node/number-literal.ts";
 import { NumberLiteralKind } from "../../node/enum/number-literal-kind.ts";
 import type { Token } from "../../node/token.ts";
 
-export function buildIntegerLiteral(
-  token: Token,
-): NumberLiteral {
+export function buildIntegerLiteral(token: Token): NumberLiteral {
   const value = parseInt(token.text, 10);
 
-  return new NumberLiteral(
-    NumberLiteralKind.INTEGER,
-    value,
-    [token],
-  );
+  return new NumberLiteral(NumberLiteralKind.INTEGER, value, [token]);
 }

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

@@ -9,9 +9,7 @@ import type { Token } from "../../node/token.ts";
 import { fetchRequiredNode } from "../util/fetch-node.ts";
 import type { BuildContext } from "../util/build-context.ts";
 
-export function buildLengthAttribute(
-  buildContext: BuildContext,
-): LengthAttribute {
+export function buildLengthAttribute(buildContext: BuildContext): LengthAttribute {
   const children: Array<AbstractNode> = [];
 
   const openParenthesisPunctuator = fetchRequiredNode<Token>(
@@ -22,12 +20,11 @@ export function buildLengthAttribute(
 
   children.push(openParenthesisPunctuator);
 
-  const length = fetchRequiredNode<
-    NumberLiteral | Identifier | AbstractExpression
-  >(
-    buildContext,
-    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
-  );
+  const length = fetchRequiredNode<NumberLiteral | Identifier | AbstractExpression>(buildContext, [
+    NodeKind.EXPRESSION,
+    NodeKind.IDENTIFIER,
+    NodeKind.NUMBER_LITERAL,
+  ]);
 
   children.push(length);
 

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

@@ -7,9 +7,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 buildLengthofExpression(
-  buildContext: BuildContext,
-): LengthofExpression {
+export function buildLengthofExpression(buildContext: BuildContext): LengthofExpression {
   const lengthOfKeyword = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
@@ -20,10 +18,10 @@ export function buildLengthofExpression(
     NodeKind.TOKEN,
     TokenKind.OPEN_PARENTHESIS,
   );
-  const operand = fetchRequiredNode<AbstractExpression | Identifier>(
-    buildContext,
-    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER],
-  );
+  const operand = fetchRequiredNode<AbstractExpression | Identifier>(buildContext, [
+    NodeKind.EXPRESSION,
+    NodeKind.IDENTIFIER,
+  ]);
   const closedParenthesisPunctuator = fetchRequiredNode<Token>(
     buildContext,
     NodeKind.TOKEN,
@@ -35,11 +33,6 @@ export function buildLengthofExpression(
     openParenthesisPunctuator,
     operand,
     closedParenthesisPunctuator,
-    [
-      lengthOfKeyword,
-      openParenthesisPunctuator,
-      operand,
-      closedParenthesisPunctuator,
-    ],
+    [lengthOfKeyword, openParenthesisPunctuator, operand, closedParenthesisPunctuator],
   );
 }

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

@@ -15,21 +15,12 @@ import {
 import type { OptionalNode } from "../../util/types.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildMapDeclaration(
-  buildContext: BuildContext,
-): MapDeclaration {
+export function buildMapDeclaration(buildContext: BuildContext): MapDeclaration {
   const children: Array<AbstractNode> = [];
 
-  const mapKeyword = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.MAP,
-  );
+  const mapKeyword = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.MAP);
   children.push(mapKeyword);
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
   children.push(identifier);
 
   const openParenthesisPunctuator = fetchRequiredNode<Token>(
@@ -47,10 +38,7 @@ export function buildMapDeclaration(
   if (outputElementaryType) {
     children.push(outputElementaryType);
   } else {
-    outputClassIdentifier = fetchOptionalNode<Identifier>(
-      buildContext,
-      NodeKind.IDENTIFIER,
-    );
+    outputClassIdentifier = fetchOptionalNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
     if (outputClassIdentifier) {
       children.push(outputClassIdentifier);
     } else {
@@ -73,11 +61,10 @@ export function buildMapDeclaration(
     TokenKind.OPEN_BRACE,
   );
   children.push(openBracePunctuator);
-  const { nodes: mapEntries, commaPunctuators } =
-    fetchOneToManyCommaSeparatedList<MapEntry>(
-      buildContext,
-      NodeKind.MAP_ENTRY,
-    );
+  const { nodes: mapEntries, commaPunctuators } = fetchOneToManyCommaSeparatedList<MapEntry>(
+    buildContext,
+    NodeKind.MAP_ENTRY,
+  );
 
   // now push each output value and comma punctuator to children
   for (let i = 0; i < mapEntries.length; i++) {

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

@@ -10,9 +10,7 @@ import type { OptionalNode } from "../../util/types.ts";
 import { InternalScannerError } from "../../../scanner-error.ts";
 import type { ElementaryType } from "../../node/elementary-type.ts";
 
-export function buildMapDefinition(
-  buildContext: BuildContext,
-): MapDefinition {
+export function buildMapDefinition(buildContext: BuildContext): MapDefinition {
   const children: Array<AbstractNode> = [];
 
   const reservedKeyword = fetchOptionalNode<Token>(
@@ -24,28 +22,18 @@ export function buildMapDefinition(
     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 elementaryType = fetchOptionalNode<ElementaryType>(
-    buildContext,
-    NodeKind.ELEMENTARY_TYPE,
-  );
+  const elementaryType = fetchOptionalNode<ElementaryType>(buildContext, NodeKind.ELEMENTARY_TYPE);
   let classIdentifier: OptionalNode<Identifier> | undefined;
 
   if (elementaryType) {
     children.push(elementaryType);
   } else {
-    classIdentifier = fetchOptionalNode<Identifier>(
-      buildContext,
-      NodeKind.IDENTIFIER,
-    );
+    classIdentifier = fetchOptionalNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
     if (classIdentifier) {
       children.push(classIdentifier);
     } else {
@@ -62,10 +50,7 @@ export function buildMapDefinition(
   );
   children.push(relationalLessThanPunctuator);
 
-  const mapIdentifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const mapIdentifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
   children.push(mapIdentifier);
 
   const relationalGreaterThanPunctuator = fetchRequiredNode<Token>(
@@ -75,10 +60,7 @@ export function buildMapDefinition(
   );
   children.push(relationalGreaterThanPunctuator);
 
-  const identifier = fetchRequiredNode<Identifier>(
-    buildContext,
-    NodeKind.IDENTIFIER,
-  );
+  const identifier = fetchRequiredNode<Identifier>(buildContext, NodeKind.IDENTIFIER);
   children.push(identifier);
 
   const semicolonPunctuator = fetchRequiredNode<Token>(

package/src/ast/build/node/build-map-entry.ts

@@ -7,27 +7,17 @@ import type { Token } from "../../node/token.ts";
 import { fetchRequiredNode } from "../util/fetch-node.ts";
 import { TokenKind } from "../../node/enum/token-kind.ts";
 
-export function buildMapEntry(
-  buildContext: BuildContext,
-): MapEntry {
-  const inputValue = fetchRequiredNode<NumberLiteral>(
-    buildContext,
-    NodeKind.NUMBER_LITERAL,
-  );
-  const commaPunctuator = fetchRequiredNode<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    TokenKind.COMMA,
-  );
+export function buildMapEntry(buildContext: BuildContext): MapEntry {
+  const inputValue = fetchRequiredNode<NumberLiteral>(buildContext, NodeKind.NUMBER_LITERAL);
+  const commaPunctuator = fetchRequiredNode<Token>(buildContext, NodeKind.TOKEN, TokenKind.COMMA);
   const outputValue = fetchRequiredNode<AggregateOutputValue>(
     buildContext,
     NodeKind.AGGREGATE_OUTPUT_VALUE,
   );
 
-  return new MapEntry(
+  return new MapEntry(inputValue, commaPunctuator, outputValue, [
     inputValue,
     commaPunctuator,
     outputValue,
-    [inputValue, commaPunctuator, outputValue],
-  );
+  ]);
 }

package/src/ast/build/node/build-multiple-character-literal.ts

@@ -22,11 +22,11 @@ function parseUnsignedIntFromMultipleCharacterLiteral(literal: string): number {
   let value = 0;
   for (let i = 0; i < literal.length; i++) {
     const charCode = literal.charCodeAt(i);
-    if (charCode < 0x20 || charCode > 0x7E) {
+    if (charCode < 0x20 || charCode > 0x7e) {
       throw new InternalScannerError(
-        `Invalid character ${
-          literal.charCodeAt(i)
-        } in multiple character number literal: ${literal}`,
+        `Invalid character ${literal.charCodeAt(
+          i,
+        )} in multiple character number literal: ${literal}`,
       );
     }
 
@@ -36,30 +36,25 @@ function parseUnsignedIntFromMultipleCharacterLiteral(literal: string): number {
   return value;
 }
 
-export function buildMultipleCharacterLiteral(
-  buildContext: BuildContext,
-): NumberLiteral {
-  const literals = fetchOneToManyList<Token>(
-    buildContext,
-    NodeKind.TOKEN,
-    [TokenKind.SINGLE_QUOTE, TokenKind.MULTIPLE_CHARACTER_LITERAL_CHARACTERS],
-  );
+export function buildMultipleCharacterLiteral(buildContext: BuildContext): NumberLiteral {
+  const literals = fetchOneToManyList<Token>(buildContext, NodeKind.TOKEN, [
+    TokenKind.SINGLE_QUOTE,
+    TokenKind.MULTIPLE_CHARACTER_LITERAL_CHARACTERS,
+  ]);
 
   const literalText = literals
-    .filter((token) =>
-      isToken(token) &&
-      (token.tokenKind === TokenKind.MULTIPLE_CHARACTER_LITERAL_CHARACTERS)
+    .filter(
+      (token) =>
+        isToken(token) && token.tokenKind === TokenKind.MULTIPLE_CHARACTER_LITERAL_CHARACTERS,
     )
     .map((token) =>
-      (token as Token).text.replaceAll(ESCAPED_SINGLE_QUOTE_REGEX, "'")
-        .replaceAll(ESCAPED_BACKSLASH_REGEX, "\\")
-    ).join("");
+      (token as Token).text
+        .replaceAll(ESCAPED_SINGLE_QUOTE_REGEX, "'")
+        .replaceAll(ESCAPED_BACKSLASH_REGEX, "\\"),
+    )
+    .join("");
 
   const value = parseUnsignedIntFromMultipleCharacterLiteral(literalText);
 
-  return new NumberLiteral(
-    NumberLiteralKind.MULTIPLE_CHARACTER,
-    value,
-    literals,
-  );
+  return new NumberLiteral(NumberLiteralKind.MULTIPLE_CHARACTER, value, literals);
 }

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

@@ -4,15 +4,10 @@ import type { Parameter } from "../../node/parameter.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 buildParameterList(
-  buildContext: BuildContext,
-): ParameterList {
+export function buildParameterList(buildContext: BuildContext): ParameterList {
   const children: Array<AbstractNode> = [];
 
   const openParenthesisPunctuator = fetchRequiredNode<Token>(
@@ -22,10 +17,10 @@ export function buildParameterList(
   );
   children.push(openParenthesisPunctuator);
 
-  const { nodes: parameters, commaPunctuators } =
-    fetchOneToManyCommaSeparatedList<
-      Parameter
-    >(buildContext, NodeKind.PARAMETER);
+  const { nodes: parameters, commaPunctuators } = fetchOneToManyCommaSeparatedList<Parameter>(
+    buildContext,
+    NodeKind.PARAMETER,
+  );
 
   // now push each output value and comma punctuator to children
   for (let i = 0; i < parameters.length; i++) {