@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.3

package/src/completion/get-potential-syntactic-tokens.ts

@@ -12,24 +12,18 @@ const logger = getLogger("getPotentialSyntacticTokens");
  *
  * @returns An array of potential syntactic tokens, or undefined if none found.
  */
-export function getPotentialSyntacticTokens(
-  cursor: TreeCursor,
-): string[] | undefined {
+export function getPotentialSyntacticTokens(cursor: TreeCursor): string[] | undefined {
   const potentialTokenTypeIds = getPotentialTokenTypeIds(cursor);
 
-  if (!potentialTokenTypeIds || (potentialTokenTypeIds.length === 0)) {
-    logger.debug(
-      "No potentialTokenTypeIds so no potential syntactic tokens",
-    );
+  if (!potentialTokenTypeIds || potentialTokenTypeIds.length === 0) {
+    logger.debug("No potentialTokenTypeIds so no potential syntactic tokens");
     return undefined;
   }
 
   const potentialSyntacticTokens: string[] = [];
 
   potentialTokenTypeIds.forEach((potentialTokenTypeId) => {
-    const syntacticTokens = potentialSyntacticTokensByTokenTypeId.get(
-      potentialTokenTypeId,
-    );
+    const syntacticTokens = potentialSyntacticTokensByTokenTypeId.get(potentialTokenTypeId);
 
     if (syntacticTokens) {
       potentialSyntacticTokens.push(...syntacticTokens);
@@ -37,18 +31,13 @@ export function getPotentialSyntacticTokens(
   });
 
   if (potentialSyntacticTokens.length === 0) {
-    logger.debug(
-      "No potential syntactic tokens",
-    );
+    logger.debug("No potential syntactic tokens");
     return undefined;
   }
 
   // sort and remove duplicates
-  const uniqueSortedTokens = Array.from(new Set(potentialSyntacticTokens))
-    .sort();
+  const uniqueSortedTokens = Array.from(new Set(potentialSyntacticTokens)).sort();
 
-  logger.debug(
-    `Potential syntactic tokens: ${uniqueSortedTokens.join(" ")}`,
-  );
+  logger.debug(`Potential syntactic tokens: ${uniqueSortedTokens.join(" ")}`);
   return uniqueSortedTokens;
 }

package/src/completion/get-potential-token-type-ids.ts

@@ -17,9 +17,7 @@ const logger = getLogger("getPotentialTokenTypeIds");
  *
  * @returns An array of potential NodeType IDs, or undefined if none found.
  */
-export function getPotentialTokenTypeIds(
-  cursor: TreeCursor,
-): number[] | undefined {
+export function getPotentialTokenTypeIds(cursor: TreeCursor): number[] | undefined {
   // No potential tokens if currently on a comment
   if (cursor.type.id === TokenTypeId.Comment) {
     logger.debug("No potential tokens in comments");
@@ -34,10 +32,7 @@ export function getPotentialTokenTypeIds(
   const parentTokenTypesIds: number[] = [];
 
   while (parentCursorClone.parent()) {
-    if (
-      (parentCursorClone.type.id !== TokenTypeId.Whitespace) &&
-      !parentCursorClone.type.isError
-    ) {
+    if (parentCursorClone.type.id !== TokenTypeId.Whitespace && !parentCursorClone.type.isError) {
       parentTokenTypesIds.unshift(parentCursorClone.type.id);
       break;
     }
@@ -53,30 +48,29 @@ export function getPotentialTokenTypeIds(
 
   while (siblingCursorClone.prevSibling()) {
     if (
-      (siblingCursorClone.type.id !== TokenTypeId.Whitespace) &&
+      siblingCursorClone.type.id !== TokenTypeId.Whitespace &&
       !siblingCursorClone.type.isError &&
-      (siblingCursorClone.type.id !== TokenTypeId.Comment)
+      siblingCursorClone.type.id !== TokenTypeId.Comment
     ) {
       previousSiblingTokenTypes.unshift(siblingCursorClone.type);
     }
   }
 
   logger.debug(
-    "parentTokenTypes: " +
-      parentTokenTypesIds.map((id) => nodeTypes[id].name).join(", "),
+    "parentTokenTypes: " + parentTokenTypesIds.map((id) => nodeTypes[id].name).join(", "),
   );
 
   if (previousSiblingTokenTypes.length > 0) {
     logger.debug(
-      "previousSiblingTokenTypes: " +
-        previousSiblingTokenTypes.map((type) => type.name).join(", "),
+      "previousSiblingTokenTypes: " + previousSiblingTokenTypes.map((type) => type.name).join(", "),
     );
   } else {
     logger.debug("No previous sibling token type found");
   }
 
-  const potentialCompletionRules = completionRulesByParentMap
-    .get(parentTokenTypesIds[parentTokenTypesIds.length - 1]);
+  const potentialCompletionRules = completionRulesByParentMap.get(
+    parentTokenTypesIds[parentTokenTypesIds.length - 1],
+  );
 
   if (!potentialCompletionRules) {
     logger.debug(
@@ -105,12 +99,7 @@ export function getPotentialTokenTypeIds(
   }
 
   // sort and remove duplicates
-  const uniqueSortedTokenTypes = Array.from(new Set(potentialTokenTypes)).sort((
-    a,
-    b,
-  ) => a - b);
-  logger.debug(
-    `Potential token types: ${uniqueSortedTokenTypes.join(" ")}`,
-  );
+  const uniqueSortedTokenTypes = Array.from(new Set(potentialTokenTypes)).sort((a, b) => a - b);
+  logger.debug(`Potential token types: ${uniqueSortedTokenTypes.join(" ")}`);
   return uniqueSortedTokenTypes;
 }

package/src/completion/rules/abstract-types.ts

@@ -166,9 +166,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/completion/rules/aggregate-output-value-rules.ts

@@ -10,39 +10,22 @@ export const aggregateOutputValueRules = [
   },
   {
     previous: TokenTypeId.OpenBrace,
-    expected: [
-      TokenTypeId.ElementaryTypeOutputValue,
-      TokenTypeId.OpenBrace,
-      ...numberLiteralTypes,
-    ],
+    expected: [TokenTypeId.ElementaryTypeOutputValue, TokenTypeId.OpenBrace, ...numberLiteralTypes],
   },
   {
     previous: TokenTypeId.Comma,
-    expected: [
-      TokenTypeId.ElementaryTypeOutputValue,
-      TokenTypeId.OpenBrace,
-      ...numberLiteralTypes,
-    ],
+    expected: [TokenTypeId.ElementaryTypeOutputValue, TokenTypeId.OpenBrace, ...numberLiteralTypes],
   },
   {
     previous: TokenTypeId.ElementaryTypeOutputValue,
-    expected: [
-      TokenTypeId.Comma,
-      TokenTypeId.CloseBrace,
-    ],
+    expected: [TokenTypeId.Comma, TokenTypeId.CloseBrace],
   },
   {
     previous: TokenTypeId.CloseBrace,
-    expected: [
-      TokenTypeId.Comma,
-      TokenTypeId.CloseBrace,
-    ],
+    expected: [TokenTypeId.Comma, TokenTypeId.CloseBrace],
   },
   ...numberLiteralTypes.map((type) => ({
     previous: type,
-    expected: [
-      TokenTypeId.Comma,
-      TokenTypeId.CloseBrace,
-    ],
+    expected: [TokenTypeId.Comma, TokenTypeId.CloseBrace],
   })),
 ];

package/src/completion/rules/aligned-modifier-rules.ts

@@ -4,9 +4,7 @@ import * as TokenTypeId from "../../lezer/parser.terms.ts";
 export const alignedModifierRules = [
   {
     previous: -1,
-    expected: [
-      TokenTypeId.aligned,
-    ],
+    expected: [TokenTypeId.aligned],
   },
   {
     previous: TokenTypeId.OpenParenthesis,

package/src/completion/rules/array-definition-rules.ts

@@ -14,19 +14,11 @@ export const arrayDefinitionRules = [
   },
   {
     previous: TokenTypeId.reserved,
-    expected: [
-      TokenTypeId.AlignedModifier,
-      TokenTypeId.ElementaryType,
-      TokenTypeId.Identifier,
-    ],
+    expected: [TokenTypeId.AlignedModifier, TokenTypeId.ElementaryType, TokenTypeId.Identifier],
   },
   {
     previous: TokenTypeId.legacy,
-    expected: [
-      TokenTypeId.AlignedModifier,
-      TokenTypeId.ElementaryType,
-      TokenTypeId.Identifier,
-    ],
+    expected: [TokenTypeId.AlignedModifier, TokenTypeId.ElementaryType, TokenTypeId.Identifier],
   },
   {
     previous: TokenTypeId.AlignedModifier,

package/src/completion/rules/array-element-access-rules.ts

@@ -14,9 +14,6 @@ export const arrayElementAccessRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.CloseBracket,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.CloseBracket, ...binaryOperatorTypes],
   })),
 ];

package/src/completion/rules/class-declaration-rules.ts

@@ -15,18 +15,11 @@ export const classDeclarationRules = [
   },
   {
     previous: TokenTypeId.AlignedModifier,
-    expected: [
-      TokenTypeId.ExpandableModifier,
-      TokenTypeId.abstract,
-      TokenTypeId._class,
-    ],
+    expected: [TokenTypeId.ExpandableModifier, TokenTypeId.abstract, TokenTypeId._class],
   },
   {
     previous: TokenTypeId.ExpandableModifier,
-    expected: [
-      TokenTypeId.abstract,
-      TokenTypeId._class,
-    ],
+    expected: [TokenTypeId.abstract, TokenTypeId._class],
   },
   {
     previous: TokenTypeId.abstract,
@@ -47,18 +40,11 @@ export const classDeclarationRules = [
   },
   {
     previous: TokenTypeId.ParameterList,
-    expected: [
-      TokenTypeId.ExtendsModifier,
-      TokenTypeId.BitModifier,
-      TokenTypeId.OpenBrace,
-    ],
+    expected: [TokenTypeId.ExtendsModifier, TokenTypeId.BitModifier, TokenTypeId.OpenBrace],
   },
   {
     previous: TokenTypeId.ExtendsModifier,
-    expected: [
-      TokenTypeId.BitModifier,
-      TokenTypeId.OpenBrace,
-    ],
+    expected: [TokenTypeId.BitModifier, TokenTypeId.OpenBrace],
   },
   {
     previous: TokenTypeId.BitModifier,
@@ -66,16 +52,10 @@ export const classDeclarationRules = [
   },
   {
     previous: TokenTypeId.OpenBrace,
-    expected: [
-      ...statementTypes,
-      TokenTypeId.CloseBrace,
-    ],
+    expected: [...statementTypes, TokenTypeId.CloseBrace],
   },
   ...statementTypes.map((type) => ({
     previous: type,
-    expected: [
-      ...statementTypes,
-      TokenTypeId.CloseBrace,
-    ],
+    expected: [...statementTypes, TokenTypeId.CloseBrace],
   })),
 ];

package/src/completion/rules/class-definition-rules.ts

@@ -4,10 +4,7 @@ import * as TokenTypeId from "../../lezer/parser.terms.ts";
 export const classDefinitionRules = [
   {
     previous: -1,
-    expected: [
-      TokenTypeId.legacy,
-      TokenTypeId.Identifier,
-    ],
+    expected: [TokenTypeId.legacy, TokenTypeId.Identifier],
   },
   {
     previous: TokenTypeId.legacy,

package/src/completion/rules/compound-statement-rules.ts

@@ -10,16 +10,10 @@ export const compoundStatementRules = [
   },
   {
     previous: TokenTypeId.OpenBrace,
-    expected: [
-      ...statementTypes,
-      TokenTypeId.CloseBrace,
-    ],
+    expected: [...statementTypes, TokenTypeId.CloseBrace],
   },
   ...statementTypes.map((type) => ({
     previous: type,
-    expected: [
-      ...statementTypes,
-      TokenTypeId.CloseBrace,
-    ],
+    expected: [...statementTypes, TokenTypeId.CloseBrace],
   })),
 ];

package/src/completion/rules/computed-elementary-type-rules.ts

@@ -23,11 +23,7 @@ export const computedElementaryTypeRules = [
   },
   // non-const has optional assignment
   {
-    previous: [
-      TokenTypeId.computed,
-      TokenTypeId.ElementaryType,
-      TokenTypeId.Identifier,
-    ],
+    previous: [TokenTypeId.computed, TokenTypeId.ElementaryType, TokenTypeId.Identifier],
     expected: [TokenTypeId.Assignment, TokenTypeId.Semicolon],
   },
   {
@@ -36,9 +32,6 @@ export const computedElementaryTypeRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.Semicolon,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.Semicolon, ...binaryOperatorTypes],
   })),
 ];

package/src/completion/rules/do-statement-rules.ts

@@ -26,10 +26,7 @@ export const doStatementRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.CloseParenthesis,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.CloseParenthesis, ...binaryOperatorTypes],
   })),
   {
     previous: TokenTypeId.CloseParenthesis,

package/src/completion/rules/elementary-type-definition-rules.ts

@@ -16,11 +16,7 @@ export const elementaryTypeDefinitionRules = [
   },
   {
     previous: TokenTypeId.reserved,
-    expected: [
-      TokenTypeId._const,
-      TokenTypeId.AlignedModifier,
-      TokenTypeId.ElementaryType,
-    ],
+    expected: [TokenTypeId._const, TokenTypeId.AlignedModifier, TokenTypeId.ElementaryType],
   },
   {
     previous: TokenTypeId._const,
@@ -52,11 +48,7 @@ export const elementaryTypeDefinitionRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: [TokenTypeId.Assignment, expressionType],
-    expected: [
-      TokenTypeId.RangeOperator,
-      TokenTypeId.Semicolon,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.RangeOperator, TokenTypeId.Semicolon, ...binaryOperatorTypes],
   })),
   { previous: TokenTypeId.RangeOperator, expected: expressionTypes },
 ];

package/src/completion/rules/elementary-type-rules.ts

@@ -4,12 +4,7 @@ import * as TokenTypeId from "../../lezer/parser.terms.ts";
 export const elementaryTypeRules = [
   {
     previous: -1,
-    expected: [
-      TokenTypeId.int,
-      TokenTypeId.unsigned,
-      TokenTypeId.float,
-      TokenTypeId.bit,
-    ],
+    expected: [TokenTypeId.int, TokenTypeId.unsigned, TokenTypeId.float, TokenTypeId.bit],
   },
   {
     previous: TokenTypeId.unsigned,

package/src/completion/rules/explicit-array-dimension-rules.ts

@@ -14,9 +14,6 @@ export const explicitArrayDimensionRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.CloseBracket,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.CloseBracket, ...binaryOperatorTypes],
   })),
 ];

package/src/completion/rules/expression-statement-rules.ts

@@ -10,10 +10,7 @@ export const expressionStatementRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.Semicolon,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.Semicolon, ...binaryOperatorTypes],
   })),
   {
     previous: TokenTypeId.AssignmentExpression,

package/src/completion/rules/for-statement-rules.ts

@@ -26,24 +26,12 @@ export const forStatementRules = [
   },
   {
     previous: TokenTypeId.Semicolon,
-    expected: [
-      TokenTypeId.AssignmentExpression,
-      ...expressionTypes,
-      TokenTypeId.CloseParenthesis,
-    ],
+    expected: [TokenTypeId.AssignmentExpression, ...expressionTypes, TokenTypeId.CloseParenthesis],
   },
-  ...expressionTypes.map((expressionType) => (
-    {
-      previous: [
-        TokenTypeId.AssignmentExpression,
-        expressionType,
-      ],
-      expected: [
-        TokenTypeId.Semicolon,
-        ...binaryOperatorTypes,
-      ],
-    }
-  )),
+  ...expressionTypes.map((expressionType) => ({
+    previous: [TokenTypeId.AssignmentExpression, expressionType],
+    expected: [TokenTypeId.Semicolon, ...binaryOperatorTypes],
+  })),
   {
     previous: TokenTypeId.CloseParenthesis,
     expected: TokenTypeId.CompoundStatement,

package/src/completion/rules/if-statement-rules.ts

@@ -1,8 +1,4 @@
-import {
-  binaryOperatorTypes,
-  expressionTypes,
-  statementTypes,
-} from "./abstract-types.ts";
+import { binaryOperatorTypes, expressionTypes, statementTypes } from "./abstract-types.ts";
 
 // Generated by Lezer from the SDL grammar
 import * as TokenTypeId from "../../lezer/parser.terms.ts";
@@ -22,10 +18,7 @@ export const ifStatementRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.CloseParenthesis,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.CloseParenthesis, ...binaryOperatorTypes],
   })),
   {
     previous: TokenTypeId.CloseParenthesis,

package/src/completion/rules/length-attribute-rules.ts

@@ -11,9 +11,6 @@ export const lengthAttributeRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.CloseParenthesis,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.CloseParenthesis, ...binaryOperatorTypes],
   })),
 ];

package/src/completion/rules/parameter-value-list-rules.ts

@@ -18,10 +18,6 @@ export const parameterValueListRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.Comma,
-      TokenTypeId.CloseParenthesis,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.Comma, TokenTypeId.CloseParenthesis, ...binaryOperatorTypes],
   })),
 ];

package/src/completion/rules/partial-array-dimension-rules.ts

@@ -18,16 +18,10 @@ export const partialArrayDimensionRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.CloseBracket,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.CloseBracket, ...binaryOperatorTypes],
   })),
   ...expressionTypes.map((expressionType) => ({
     previous: [expressionType, TokenTypeId.CloseBracket],
-    expected: [
-      TokenTypeId.CloseBracket,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.CloseBracket, ...binaryOperatorTypes],
   })),
 ];

package/src/completion/rules/string-definition-rules.ts

@@ -3,35 +3,19 @@ import * as TokenTypeId from "../../lezer/parser.terms.ts";
 
 export const stringDefinitionRules = [
   {
-    previous: [
-      TokenTypeId.utf8string,
-      TokenTypeId.Identifier,
-      TokenTypeId.Assignment,
-    ],
+    previous: [TokenTypeId.utf8string, TokenTypeId.Identifier, TokenTypeId.Assignment],
     expected: TokenTypeId.UtfStringLiteral,
   },
   {
-    previous: [
-      TokenTypeId.utf16string,
-      TokenTypeId.Identifier,
-      TokenTypeId.Assignment,
-    ],
+    previous: [TokenTypeId.utf16string, TokenTypeId.Identifier, TokenTypeId.Assignment],
     expected: TokenTypeId.UtfStringLiteral,
   },
   {
-    previous: [
-      TokenTypeId.utfstring,
-      TokenTypeId.Identifier,
-      TokenTypeId.Assignment,
-    ],
+    previous: [TokenTypeId.utfstring, TokenTypeId.Identifier, TokenTypeId.Assignment],
     expected: TokenTypeId.UtfStringLiteral,
   },
   {
-    previous: [
-      TokenTypeId.base64string,
-      TokenTypeId.Identifier,
-      TokenTypeId.Assignment,
-    ],
+    previous: [TokenTypeId.base64string, TokenTypeId.Identifier, TokenTypeId.Assignment],
     expected: TokenTypeId.Base64StringLiteral,
   },
   {
@@ -65,31 +49,19 @@ export const stringDefinitionRules = [
     ],
   },
   {
-    previous: [
-      TokenTypeId.utf8string,
-      TokenTypeId.Identifier,
-    ],
+    previous: [TokenTypeId.utf8string, TokenTypeId.Identifier],
     expected: TokenTypeId.Semicolon,
   },
   {
-    previous: [
-      TokenTypeId.utf16string,
-      TokenTypeId.Identifier,
-    ],
+    previous: [TokenTypeId.utf16string, TokenTypeId.Identifier],
     expected: TokenTypeId.Semicolon,
   },
   {
-    previous: [
-      TokenTypeId.utfstring,
-      TokenTypeId.Identifier,
-    ],
+    previous: [TokenTypeId.utfstring, TokenTypeId.Identifier],
     expected: TokenTypeId.Semicolon,
   },
   {
-    previous: [
-      TokenTypeId.base64string,
-      TokenTypeId.Identifier,
-    ],
+    previous: [TokenTypeId.base64string, TokenTypeId.Identifier],
     expected: TokenTypeId.Semicolon,
   },
   {

package/src/completion/rules/switch-statement-rules.ts

@@ -18,10 +18,7 @@ export const switchStatementRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.CloseParenthesis,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.CloseParenthesis, ...binaryOperatorTypes],
   })),
   {
     previous: TokenTypeId.CloseParenthesis,
@@ -29,19 +26,11 @@ export const switchStatementRules = [
   },
   {
     previous: TokenTypeId.OpenBrace,
-    expected: [
-      TokenTypeId.CaseClause,
-      TokenTypeId.DefaultClause,
-      TokenTypeId.CloseBrace,
-    ],
+    expected: [TokenTypeId.CaseClause, TokenTypeId.DefaultClause, TokenTypeId.CloseBrace],
   },
   {
     previous: TokenTypeId.CaseClause,
-    expected: [
-      TokenTypeId.CaseClause,
-      TokenTypeId.DefaultClause,
-      TokenTypeId.CloseBrace,
-    ],
+    expected: [TokenTypeId.CaseClause, TokenTypeId.DefaultClause, TokenTypeId.CloseBrace],
   },
   {
     previous: TokenTypeId.DefaultClause,

package/src/completion/rules/while-statement-rules.ts

@@ -1,8 +1,4 @@
-import {
-  binaryOperatorTypes,
-  expressionTypes,
-  statementTypes,
-} from "./abstract-types.ts";
+import { binaryOperatorTypes, expressionTypes, statementTypes } from "./abstract-types.ts";
 
 // Generated by Lezer from the SDL grammar
 import * as TokenTypeId from "../../lezer/parser.terms.ts";
@@ -26,10 +22,7 @@ export const whileStatementRules = [
   },
   ...expressionTypes.map((expressionType) => ({
     previous: expressionType,
-    expected: [
-      TokenTypeId.CloseParenthesis,
-      ...binaryOperatorTypes,
-    ],
+    expected: [TokenTypeId.CloseParenthesis, ...binaryOperatorTypes],
   })),
   {
     previous: TokenTypeId.CloseParenthesis,

package/src/lezer/create-sdl-parser.ts

@@ -75,9 +75,7 @@ export function createStrictSdlParser(): LezerParser {
           inputText = input.read(0, input.length);
         }
 
-        const text = Text.of(
-          inputText.split("\n"),
-        );
+        const text = Text.of(inputText.split("\n"));
 
         throw createSyntaxErrorFromTextAndPosition(text, position);
       }