@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.4

package/dist/src/ast/build/util/token-kind-by-token-type-id-map.js

@@ -0,0 +1,309 @@
+import { TokenKind } from "../../node/enum/token-kind.js";
+import { InternalScannerError } from "../../../scanner-error.js";
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../../lezer/parser.terms.js";
+export const tokenKindByTokenTypeId = new Map();
+/**
+ * Map parsed token type ID to AST token type enum.
+ * Exhaustive switch statement to ensure all token type IDs are handled.
+ */
+Object.values(TokenTypeId).forEach((tokenTypeId) => {
+    switch (tokenTypeId) {
+        case TokenTypeId._break:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BREAK);
+            break;
+        case TokenTypeId._case:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CASE);
+            break;
+        case TokenTypeId._class:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CLASS);
+            break;
+        case TokenTypeId._const:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CONST);
+            break;
+        case TokenTypeId._default:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.DEFAULT);
+            break;
+        case TokenTypeId._do:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.DO);
+            break;
+        case TokenTypeId._else:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ELSE);
+            break;
+        case TokenTypeId._extends:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.EXTENDS);
+            break;
+        case TokenTypeId._for:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.FOR);
+            break;
+        case TokenTypeId._if:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.IF);
+            break;
+        case TokenTypeId._switch:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.SWITCH);
+            break;
+        case TokenTypeId._while:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.WHILE);
+            break;
+        case TokenTypeId.abstract:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ABSTRACT);
+            break;
+        case TokenTypeId.Addition:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ADDITION);
+            break;
+        case TokenTypeId.AlignmentBitCount8:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNMENT_BIT_COUNT_8);
+            break;
+        case TokenTypeId.AlignmentBitCount16:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNMENT_BIT_COUNT_16);
+            break;
+        case TokenTypeId.AlignmentBitCount32:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNMENT_BIT_COUNT_32);
+            break;
+        case TokenTypeId.AlignmentBitCount64:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNMENT_BIT_COUNT_64);
+            break;
+        case TokenTypeId.AlignmentBitCount128:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNMENT_BIT_COUNT_128);
+            break;
+        case TokenTypeId.aligned:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ALIGNED);
+            break;
+        case TokenTypeId.Assignment:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.ASSIGNMENT);
+            break;
+        case TokenTypeId.base64string:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BASE64_STRING);
+            break;
+        case TokenTypeId.Base64StringLiteralCharacters:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BASE64_STRING_LITERAL_CHARACTERS);
+            break;
+        case TokenTypeId.BinaryLiteral:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BINARY_LITERAL);
+            break;
+        case TokenTypeId.bit:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BIT);
+            break;
+        case TokenTypeId.BitwiseAnd:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BITWISE_AND);
+            break;
+        case TokenTypeId.BitwiseOr:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BITWISE_OR);
+            break;
+        case TokenTypeId.BitwiseShiftLeft:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BITWISE_SHIFT_LEFT);
+            break;
+        case TokenTypeId.BitwiseShiftRight:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.BITWISE_SHIFT_RIGHT);
+            break;
+        case TokenTypeId.CloseBrace:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CLOSE_BRACE);
+            break;
+        case TokenTypeId.CloseBracket:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CLOSE_BRACKET);
+            break;
+        case TokenTypeId.CloseParenthesis:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.CLOSE_PARENTHESIS);
+            break;
+        case TokenTypeId.Colon:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.COLON);
+            break;
+        case TokenTypeId.Comma:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.COMMA);
+            break;
+        case TokenTypeId.computed:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.COMPUTED);
+            break;
+        case TokenTypeId.DecimalLiteral:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.DECIMAL_LITERAL);
+            break;
+        case TokenTypeId.Division:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.DIVISION);
+            break;
+        case TokenTypeId.DoubleQuote:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.DOUBLE_QUOTE);
+            break;
+        case TokenTypeId.expandable:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.EXPANDABLE);
+            break;
+        case TokenTypeId.float:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.FLOAT);
+            break;
+        case TokenTypeId.FloatingPointLiteral:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.FLOATING_POINT_LITERAL);
+            break;
+        case TokenTypeId.HexadecimalLiteral:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.HEXADECIMAL_LITERAL);
+            break;
+        case TokenTypeId.Identifier:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.IDENTIFIER);
+            break;
+        case TokenTypeId.int:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.INT);
+            break;
+        case TokenTypeId.IntegerLiteral:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.INTEGER_LITERAL);
+            break;
+        case TokenTypeId.legacy:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.LEGACY);
+            break;
+        case TokenTypeId.lengthof:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.LENGTHOF);
+            break;
+        case TokenTypeId.LogicalAnd:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.LOGICAL_AND);
+            break;
+        case TokenTypeId.LogicalOr:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.LOGICAL_OR);
+            break;
+        case TokenTypeId.LookAhead:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.LOOK_AHEAD);
+            break;
+        case TokenTypeId.map:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.MAP);
+            break;
+        case TokenTypeId.Modulus:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.MODULUS);
+            break;
+        case TokenTypeId.MultipleCharacterLiteralCharacters:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.MULTIPLE_CHARACTER_LITERAL_CHARACTERS);
+            break;
+        case TokenTypeId.Multiplication:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.MULTIPLICATION);
+            break;
+        case TokenTypeId.OpenBrace:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.OPEN_BRACE);
+            break;
+        case TokenTypeId.OpenBracket:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.OPEN_BRACKET);
+            break;
+        case TokenTypeId.OpenParenthesis:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.OPEN_PARENTHESIS);
+            break;
+        case TokenTypeId.Period:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.PERIOD);
+            break;
+        case TokenTypeId.PostfixDecrement:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.POSTFIX_DECREMENT);
+            break;
+        case TokenTypeId.PostfixIncrement:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.POSTFIX_INCREMENT);
+            break;
+        case TokenTypeId.RangeOperator:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RANGE_OPERATOR);
+            break;
+        case TokenTypeId.reserved:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RESERVED);
+            break;
+        case TokenTypeId.RelationalEqual:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RELATIONAL_EQUAL);
+            break;
+        case TokenTypeId.RelationalGreaterThan:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RELATIONAL_GREATER_THAN);
+            break;
+        case TokenTypeId.RelationalGreaterThanOrEqual:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RELATIONAL_GREATER_THAN_OR_EQUAL);
+            break;
+        case TokenTypeId.RelationalLessThan:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RELATIONAL_LESS_THAN);
+            break;
+        case TokenTypeId.RelationalLessThanOrEqual:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RELATIONAL_LESS_THAN_OR_EQUAL);
+            break;
+        case TokenTypeId.RelationalNotEqual:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.RELATIONAL_NOT_EQUAL);
+            break;
+        case TokenTypeId.Semicolon:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.SEMICOLON);
+            break;
+        case TokenTypeId.SingleQuote:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.SINGLE_QUOTE);
+            break;
+        case TokenTypeId.Subtraction:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.SUBTRACTION);
+            break;
+        case TokenTypeId.UnaryNegation:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UNARY_NEGATION);
+            break;
+        case TokenTypeId.UnaryPlus:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UNARY_PLUS);
+            break;
+        case TokenTypeId.unsigned:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UNSIGNED);
+            break;
+        case TokenTypeId.utf16string:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF16_STRING);
+            break;
+        case TokenTypeId.utf8list:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF8_LIST);
+            break;
+        case TokenTypeId.utf8string:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF8_STRING);
+            break;
+        case TokenTypeId.utfstring:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF_STRING);
+            break;
+        case TokenTypeId.UtfPrefix:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF_PREFIX);
+            break;
+        case TokenTypeId.UtfStringLiteralCharacters:
+            tokenKindByTokenTypeId.set(tokenTypeId, TokenKind.UTF_STRING_LITERAL_CHARACTERS);
+            break;
+        // Parser tokens that do not map to AST TokenKinds
+        case TokenTypeId.AlignedModifier:
+        case TokenTypeId.AggregateOutputValue:
+        case TokenTypeId.ArrayDefinition:
+        case TokenTypeId.AssignmentExpression:
+        case TokenTypeId.ArrayElementAccess:
+        case TokenTypeId.Base64StringLiteral:
+        case TokenTypeId.BinaryExpression:
+        case TokenTypeId.BitModifier:
+        case TokenTypeId.CaseClause:
+        case TokenTypeId.ClassDefinition:
+        case TokenTypeId.ClassDeclaration:
+        case TokenTypeId.ClassId:
+        case TokenTypeId.ClassIdRange:
+        case TokenTypeId.ClassMemberAccess:
+        case TokenTypeId.Comment:
+        case TokenTypeId.CompoundStatement:
+        case TokenTypeId.ComputedArrayDefinition:
+        case TokenTypeId.ComputedElementaryTypeDefinition:
+        case TokenTypeId.DefaultClause:
+        case TokenTypeId.DoStatement:
+        case TokenTypeId.ElementaryType:
+        case TokenTypeId.ElementaryTypeDefinition:
+        case TokenTypeId.ElementaryTypeOutputValue:
+        case TokenTypeId.ExpandableModifier:
+        case TokenTypeId.ExplicitArrayDimension:
+        case TokenTypeId.ExpressionStatement:
+        case TokenTypeId.ExtendedClassIdRange:
+        case TokenTypeId.ExtendsModifier:
+        case TokenTypeId.ForStatement:
+        case TokenTypeId.IfStatement:
+        case TokenTypeId.ImplicitArrayDimension:
+        case TokenTypeId.LengthAttribute:
+        case TokenTypeId.LengthofExpression:
+        case TokenTypeId.MapDeclaration:
+        case TokenTypeId.MapDefinition:
+        case TokenTypeId.MapEntry:
+        case TokenTypeId.MultipleCharacterLiteral:
+        case TokenTypeId.Parameter:
+        case TokenTypeId.ParameterList:
+        case TokenTypeId.ParameterValueList:
+        case TokenTypeId.PartialArrayDimension:
+        case TokenTypeId.Specification:
+        case TokenTypeId.StringDefinition:
+        case TokenTypeId.SwitchStatement:
+        case TokenTypeId.UnaryExpression:
+        case TokenTypeId.UtfStringLiteral:
+        case TokenTypeId.WhileStatement:
+        case TokenTypeId.Whitespace:
+            break;
+        default: {
+            const exhaustiveCheck = tokenTypeId;
+            throw new InternalScannerError("Unreachable code reached, tokenTypeId == " + exhaustiveCheck);
+        }
+    }
+});
+// Add mapping for unknown token
+tokenKindByTokenTypeId.set(0, TokenKind.ERROR_UNKNOWN_TOKEN);

package/dist/src/ast/build-ast.d.ts

@@ -0,0 +1,13 @@
+import type { Tree } from "@lezer/common";
+import type { SdlStringInput } from "../lezer/sdl-string-input.ts";
+import type { Specification } from "./node/specification.ts";
+import type { RequiredNode } from "./util/types.ts";
+/**
+ * Process the SDL parse tree and return an abstract syntax tree.
+ *
+ * @param parseTree The parse `Tree` generated from the SDL source.
+ * @param sdlStringInput The SDL source text as an `SdlStringInput`.
+ * @param lenient If true, the AST construction will be lenient and create error tokens and nodes for parse errors in the parse tree.
+ */
+export declare function buildAst(parseTree: Tree, sdlStringInput: SdlStringInput, lenient?: boolean): RequiredNode<Specification>;
+//# sourceMappingURL=build-ast.d.ts.map

package/dist/src/ast/build-ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-ast.d.ts","sourceRoot":"","sources":["../../../src/ast/build-ast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAM7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAKpD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,IAAI,EACf,cAAc,EAAE,cAAc,EAC9B,OAAO,UAAQ,GACd,YAAY,CAAC,aAAa,CAAC,CAyE7B"}

package/dist/src/ast/build-ast.js

@@ -0,0 +1,65 @@
+import { Text } from "@codemirror/state";
+import { debugEnabled } from "../util/logger.js";
+import { TraversingVisitor } from "./visitor/traversing-visitor.js";
+import { InternalScannerError } from "../scanner-error.js";
+import { fetchRequiredNode } from "./build/util/fetch-node.js";
+import { NodeKind } from "./node/enum/node-kind.js";
+import { nodeKindByTokenTypeId } from "./build/util/node-kind-by-token-type-id-map.js";
+/**
+ * Process the SDL parse tree and return an abstract syntax tree.
+ *
+ * @param parseTree The parse `Tree` generated from the SDL source.
+ * @param sdlStringInput The SDL source text as an `SdlStringInput`.
+ * @param lenient If true, the AST construction will be lenient and create error tokens and nodes for parse errors in the parse tree.
+ */
+export function buildAst(parseTree, sdlStringInput, lenient = false) {
+    const text = Text.of(sdlStringInput.read(0, sdlStringInput.length).split("\n"));
+    const cursor = parseTree.cursor();
+    const buildContext = {
+        cursor,
+        text,
+        lenient,
+        stateStack: [{ indent: "", isEndOfSiblings: false }],
+    };
+    const nodeKind = nodeKindByTokenTypeId.get(cursor.type.id);
+    if (nodeKind === undefined) {
+        throw new InternalScannerError(`No nodeKind mapping found for token type id: ${cursor.type.id} (${cursor.type.name})`);
+    }
+    // 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]}.`);
+    }
+    const specification = fetchRequiredNode(buildContext, NodeKind.SPECIFICATION);
+    if (buildContext.stateStack.length !== 1) {
+        throw new InternalScannerError(`Expected final build context state stack length to be 1, but found ${buildContext.stateStack.length}.`);
+    }
+    if (!specification) {
+        throw new InternalScannerError(`Expected to parse a Specification node, but none was found.`);
+    }
+    if (nodeKind !== NodeKind.SPECIFICATION && !cursor.type.isError) {
+        throw new InternalScannerError(`Expected final node to be a Specification or an error, but found ${NodeKind[nodeKind]}.`);
+    }
+    // check if any unconsumed trivia remain which
+    if (buildContext.unconsumedTrivia) {
+        if (!specification.trailingTrivia) {
+            specification.trailingTrivia = [];
+        }
+        // filter from the end any empty blank line trivia
+        while (buildContext.unconsumedTrivia.length > 0 &&
+            buildContext.unconsumedTrivia[buildContext.unconsumedTrivia.length - 1].text.trim() === "") {
+            buildContext.unconsumedTrivia.pop();
+        }
+        specification.trailingTrivia.push(...buildContext.unconsumedTrivia);
+        delete buildContext.unconsumedTrivia;
+    }
+    if (debugEnabled) {
+        const dummyNodeHandler = {
+            beforeVisit: () => { },
+            visit: () => { },
+            afterVisit: () => { },
+        };
+        const traversingVisitor = new TraversingVisitor(dummyNodeHandler);
+        traversingVisitor.visit(specification);
+    }
+    return specification;
+}

package/dist/src/ast/node/abstract-array-definition.d.ts

@@ -0,0 +1,12 @@
+import type { RequiredNode } from "../util/types.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import type { StatementKind } from "./enum/statement-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { Token } from "./token.ts";
+export declare abstract class AbstractArrayDefinition extends AbstractStatement {
+    readonly identifier: RequiredNode<Identifier>;
+    readonly semicolonPunctuator: RequiredNode<Token>;
+    constructor(kind: StatementKind, identifier: RequiredNode<Identifier>, semicolonPunctuator: RequiredNode<Token>, children: Array<AbstractNode>);
+}
+//# sourceMappingURL=abstract-array-definition.d.ts.map

package/dist/src/ast/node/abstract-array-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-array-definition.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/abstract-array-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,8BAAsB,uBAAwB,SAAQ,iBAAiB;aAGnD,UAAU,EAAE,YAAY,CAAC,UAAU,CAAC;aACpC,mBAAmB,EAAE,YAAY,CAAC,KAAK,CAAC;gBAFxD,IAAI,EAAE,aAAa,EACH,UAAU,EAAE,YAAY,CAAC,UAAU,CAAC,EACpC,mBAAmB,EAAE,YAAY,CAAC,KAAK,CAAC,EACxD,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;CAIhC"}

package/dist/src/ast/node/abstract-array-definition.js

@@ -0,0 +1,10 @@
+import { AbstractStatement } from "./abstract-statement.js";
+export class AbstractArrayDefinition extends AbstractStatement {
+    identifier;
+    semicolonPunctuator;
+    constructor(kind, identifier, semicolonPunctuator, children) {
+        super(kind, children);
+        this.identifier = identifier;
+        this.semicolonPunctuator = semicolonPunctuator;
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ArrayDimensionKind } from "./enum/array-dimension-kind.ts";
+import type { Token } from "./token.ts";
+export declare abstract class AbstractArrayDimension extends AbstractCompositeNode {
+    readonly arrayDimensionKind: ArrayDimensionKind;
+    readonly openBracketPunctuator: RequiredNode<Token>;
+    readonly closeBracketPunctuator: RequiredNode<Token>;
+    constructor(arrayDimensionKind: ArrayDimensionKind, openBracketPunctuator: RequiredNode<Token>, closeBracketPunctuator: RequiredNode<Token>, children: Array<AbstractNode>);
+}
+//# sourceMappingURL=abstract-array-dimension.d.ts.map

package/dist/src/ast/node/abstract-array-dimension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-array-dimension.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/abstract-array-dimension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEpE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,8BAAsB,sBAAuB,SAAQ,qBAAqB;aAEtD,kBAAkB,EAAE,kBAAkB;aACtC,qBAAqB,EAAE,YAAY,CAAC,KAAK,CAAC;aAC1C,sBAAsB,EAAE,YAAY,CAAC,KAAK,CAAC;gBAF3C,kBAAkB,EAAE,kBAAkB,EACtC,qBAAqB,EAAE,YAAY,CAAC,KAAK,CAAC,EAC1C,sBAAsB,EAAE,YAAY,CAAC,KAAK,CAAC,EAC3D,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;CAIhC"}

package/dist/src/ast/node/abstract-array-dimension.js

@@ -0,0 +1,14 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.js";
+import { ArrayDimensionKind } from "./enum/array-dimension-kind.js";
+import { NodeKind } from "./enum/node-kind.js";
+export class AbstractArrayDimension extends AbstractCompositeNode {
+    arrayDimensionKind;
+    openBracketPunctuator;
+    closeBracketPunctuator;
+    constructor(arrayDimensionKind, openBracketPunctuator, closeBracketPunctuator, children) {
+        super(NodeKind.ARRAY_DIMENSION, children);
+        this.arrayDimensionKind = arrayDimensionKind;
+        this.openBracketPunctuator = openBracketPunctuator;
+        this.closeBracketPunctuator = closeBracketPunctuator;
+    }
+}

package/dist/src/ast/node/abstract-class-id.d.ts

@@ -0,0 +1,8 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ClassIdKind } from "./enum/class-id-kind.ts";
+export declare abstract class AbstractClassId extends AbstractCompositeNode {
+    readonly classIdKind: ClassIdKind;
+    constructor(classIdKind: ClassIdKind, children: Array<AbstractNode>);
+}
+//# sourceMappingURL=abstract-class-id.d.ts.map

package/dist/src/ast/node/abstract-class-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-class-id.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/abstract-class-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAGtD,8BAAsB,eAAgB,SAAQ,qBAAqB;aAE/C,WAAW,EAAE,WAAW;gBAAxB,WAAW,EAAE,WAAW,EACxC,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;CAIhC"}

package/dist/src/ast/node/abstract-class-id.js

@@ -0,0 +1,10 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.js";
+import { ClassIdKind } from "./enum/class-id-kind.js";
+import { NodeKind } from "./enum/node-kind.js";
+export class AbstractClassId extends AbstractCompositeNode {
+    classIdKind;
+    constructor(classIdKind, children) {
+        super(NodeKind.CLASS_ID, children);
+        this.classIdKind = classIdKind;
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Location } from "../../location.ts";
+import { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Token } from "./token.ts";
+/**
+ * Represents an abstract composite node in the abstract syntax tree.
+ * This class extends the `AbstractNode` class and provides a base for nodes
+ * that can have child nodes.
+ */
+export declare abstract class AbstractCompositeNode extends AbstractNode {
+    readonly children: Array<AbstractNode>;
+    startToken: Token | undefined;
+    endToken: Token | undefined;
+    constructor(nodeKind: NodeKind, children: Array<AbstractNode>);
+    getLocation(): Location;
+}
+//# sourceMappingURL=abstract-composite-node.d.ts.map

package/dist/src/ast/node/abstract-composite-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-composite-node.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/abstract-composite-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;GAIG;AACH,8BAAsB,qBAAsB,SAAQ,YAAY;aAM5C,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;IALxC,UAAU,EAAE,KAAK,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,KAAK,GAAG,SAAS,CAAC;gBAGjC,QAAQ,EAAE,QAAQ,EACF,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;IA8B/C,WAAW,IAAI,QAAQ;CAOxB"}

package/dist/src/ast/node/abstract-composite-node.js

@@ -0,0 +1,47 @@
+import { InternalScannerError } from "../../scanner-error.js";
+import { isCompositeNode, isToken } from "../util/types.js";
+import { AbstractNode } from "./abstract-node.js";
+import { NodeKind } from "./enum/node-kind.js";
+/**
+ * Represents an abstract composite node in the abstract syntax tree.
+ * This class extends the `AbstractNode` class and provides a base for nodes
+ * that can have child nodes.
+ */
+export class AbstractCompositeNode extends AbstractNode {
+    children;
+    startToken;
+    endToken;
+    constructor(nodeKind, children) {
+        super(nodeKind, true);
+        this.children = children;
+        if (children.length === 0) {
+            return;
+        }
+        const firstChild = children[0];
+        if (isCompositeNode(firstChild)) {
+            this.startToken = firstChild.startToken;
+        }
+        else if (isToken(firstChild)) {
+            this.startToken = firstChild;
+        }
+        else {
+            throw new InternalScannerError("Unsupported node type for start token assignment: " + NodeKind[firstChild.nodeKind]);
+        }
+        const lastChild = children[children.length - 1];
+        if (isCompositeNode(lastChild)) {
+            this.endToken = lastChild.endToken;
+        }
+        else if (isToken(lastChild)) {
+            this.endToken = lastChild;
+        }
+        else {
+            throw new InternalScannerError("Unsupported node type for end token assignment: " + NodeKind[lastChild.nodeKind]);
+        }
+    }
+    getLocation() {
+        if (!this.startToken && !this.endToken) {
+            throw new InternalScannerError("Start and end token are undefined");
+        }
+        return this.startToken?.getLocation() ?? this.endToken.getLocation();
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import type { StatementKind } from "./enum/statement-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+export declare abstract class AbstractElementaryTypeDefinition extends AbstractStatement {
+    readonly constKeyword: OptionalNode<Token>;
+    readonly elementaryType: RequiredNode<ElementaryType>;
+    readonly identifier: RequiredNode<Identifier>;
+    readonly assignmentOperator: OptionalNode<Token>;
+    readonly value: OptionalNode<AbstractExpression | NumberLiteral | Identifier>;
+    readonly semicolonPunctuator: RequiredNode<Token>;
+    constructor(kind: StatementKind, constKeyword: OptionalNode<Token>, elementaryType: RequiredNode<ElementaryType>, identifier: RequiredNode<Identifier>, assignmentOperator: OptionalNode<Token>, value: OptionalNode<AbstractExpression | NumberLiteral | Identifier>, semicolonPunctuator: RequiredNode<Token>, children: Array<AbstractNode>);
+}
+//# sourceMappingURL=abstract-elementary-type-definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-elementary-type-definition.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/abstract-elementary-type-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,8BAAsB,gCAAiC,SAAQ,iBAAiB;aAG5D,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC;aACjC,cAAc,EAAE,YAAY,CAAC,cAAc,CAAC;aAC5C,UAAU,EAAE,YAAY,CAAC,UAAU,CAAC;aACpC,kBAAkB,EAAE,YAAY,CAAC,KAAK,CAAC;aACvC,KAAK,EAAE,YAAY,CAAC,kBAAkB,GAAG,aAAa,GAAG,UAAU,CAAC;aACpE,mBAAmB,EAAE,YAAY,CAAC,KAAK,CAAC;gBANxD,IAAI,EAAE,aAAa,EACH,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,EACjC,cAAc,EAAE,YAAY,CAAC,cAAc,CAAC,EAC5C,UAAU,EAAE,YAAY,CAAC,UAAU,CAAC,EACpC,kBAAkB,EAAE,YAAY,CAAC,KAAK,CAAC,EACvC,KAAK,EAAE,YAAY,CAAC,kBAAkB,GAAG,aAAa,GAAG,UAAU,CAAC,EACpE,mBAAmB,EAAE,YAAY,CAAC,KAAK,CAAC,EACxD,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;CAIhC"}

package/dist/src/ast/node/abstract-elementary-type-definition.js

@@ -0,0 +1,18 @@
+import { AbstractStatement } from "./abstract-statement.js";
+export class AbstractElementaryTypeDefinition extends AbstractStatement {
+    constKeyword;
+    elementaryType;
+    identifier;
+    assignmentOperator;
+    value;
+    semicolonPunctuator;
+    constructor(kind, constKeyword, elementaryType, identifier, assignmentOperator, value, semicolonPunctuator, children) {
+        super(kind, children);
+        this.constKeyword = constKeyword;
+        this.elementaryType = elementaryType;
+        this.identifier = identifier;
+        this.assignmentOperator = assignmentOperator;
+        this.value = value;
+        this.semicolonPunctuator = semicolonPunctuator;
+    }
+}

package/dist/src/ast/node/abstract-expression.d.ts

@@ -0,0 +1,8 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ExpressionKind } from "./enum/expression-kind.ts";
+export declare abstract class AbstractExpression extends AbstractCompositeNode {
+    readonly expressionKind: ExpressionKind;
+    constructor(expressionKind: ExpressionKind, children: AbstractNode[]);
+}
+//# sourceMappingURL=abstract-expression.d.ts.map

package/dist/src/ast/node/abstract-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-expression.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/abstract-expression.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAG3D,8BAAsB,kBAAmB,SAAQ,qBAAqB;aAElD,cAAc,EAAE,cAAc;gBAA9B,cAAc,EAAE,cAAc,EAC9C,QAAQ,EAAE,YAAY,EAAE;CAI3B"}

package/dist/src/ast/node/abstract-expression.js

@@ -0,0 +1,10 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.js";
+import { ExpressionKind } from "./enum/expression-kind.js";
+import { NodeKind } from "./enum/node-kind.js";
+export class AbstractExpression extends AbstractCompositeNode {
+    expressionKind;
+    constructor(expressionKind, children) {
+        super(NodeKind.EXPRESSION, children);
+        this.expressionKind = expressionKind;
+    }
+}

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

@@ -0,0 +1,6 @@
+import { AbstractNode } from "./abstract-node.ts";
+import type { NodeKind } from "./enum/node-kind.ts";
+export declare abstract class AbstractLeafNode extends AbstractNode {
+    constructor(nodeKind: NodeKind);
+}
+//# sourceMappingURL=abstract-leaf-node.d.ts.map

package/dist/src/ast/node/abstract-leaf-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-leaf-node.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/abstract-leaf-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,8BAAsB,gBAAiB,SAAQ,YAAY;gBAC7C,QAAQ,EAAE,QAAQ;CAG/B"}

package/dist/src/ast/node/abstract-leaf-node.js

@@ -0,0 +1,6 @@
+import { AbstractNode } from "./abstract-node.js";
+export class AbstractLeafNode extends AbstractNode {
+    constructor(nodeKind) {
+        super(nodeKind, false);
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { Location } from "../../location.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Trivia } from "./trivia.ts";
+export declare abstract class AbstractNode {
+    readonly nodeKind: NodeKind;
+    readonly isComposite: boolean;
+    leadingTrivia: Trivia[] | undefined;
+    trailingTrivia: Trivia[] | undefined;
+    constructor(nodeKind: NodeKind, isComposite: boolean);
+    abstract getLocation(): Location;
+}
+//# sourceMappingURL=abstract-node.d.ts.map