@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.4

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"computed-elementary-type-definition.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/computed-elementary-type-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,gCAAgC,EAAE,MAAM,0CAA0C,CAAC;AAC5F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,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,qBAAa,gCAAiC,SAAQ,gCAAgC;aAElE,eAAe,EAAE,YAAY,CAAC,KAAK,CAAC;gBAApC,eAAe,EAAE,YAAY,CAAC,KAAK,CAAC,EACpD,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,UAAU,GAAG,aAAa,CAAC,EACpE,mBAAmB,EAAE,YAAY,CAAC,KAAK,CAAC,EACxC,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;CAahC"}

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

@@ -0,0 +1,9 @@
+import { AbstractElementaryTypeDefinition } from "./abstract-elementary-type-definition.js";
+import { StatementKind } from "./enum/statement-kind.js";
+export class ComputedElementaryTypeDefinition extends AbstractElementaryTypeDefinition {
+    computedKeyword;
+    constructor(computedKeyword, constKeyword, elementaryType, identifier, assignmentOperator, value, semicolonPunctuator, children) {
+        super(StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION, constKeyword, elementaryType, identifier, assignmentOperator, value, semicolonPunctuator, children);
+        this.computedKeyword = computedKeyword;
+    }
+}

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

@@ -0,0 +1,14 @@
+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";
+import type { Token } from "./token.ts";
+export declare class DefaultClause extends AbstractCompositeNode {
+    readonly defaultKeyword: RequiredNode<Token>;
+    readonly colonPunctuator: RequiredNode<Token>;
+    readonly openBracePunctuator: OptionalNode<Token>;
+    readonly statements: ZeroToManyList<AbstractStatement>;
+    readonly closeBracePunctuator: OptionalNode<Token>;
+    constructor(defaultKeyword: RequiredNode<Token>, colonPunctuator: RequiredNode<Token>, openBracePunctuator: OptionalNode<Token>, statements: ZeroToManyList<AbstractStatement>, closeBracePunctuator: OptionalNode<Token>, children: Array<AbstractNode>);
+}
+//# sourceMappingURL=default-clause.d.ts.map

package/dist/src/ast/node/default-clause.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-clause.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/default-clause.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACnF,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,qBAAa,aAAc,SAAQ,qBAAqB;aAEpC,cAAc,EAAE,YAAY,CAAC,KAAK,CAAC;aACnC,eAAe,EAAE,YAAY,CAAC,KAAK,CAAC;aACpC,mBAAmB,EAAE,YAAY,CAAC,KAAK,CAAC;aACxC,UAAU,EAAE,cAAc,CAAC,iBAAiB,CAAC;aAC7C,oBAAoB,EAAE,YAAY,CAAC,KAAK,CAAC;gBAJzC,cAAc,EAAE,YAAY,CAAC,KAAK,CAAC,EACnC,eAAe,EAAE,YAAY,CAAC,KAAK,CAAC,EACpC,mBAAmB,EAAE,YAAY,CAAC,KAAK,CAAC,EACxC,UAAU,EAAE,cAAc,CAAC,iBAAiB,CAAC,EAC7C,oBAAoB,EAAE,YAAY,CAAC,KAAK,CAAC,EACzD,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;CAIhC"}

package/dist/src/ast/node/default-clause.js

@@ -0,0 +1,17 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.js";
+import { NodeKind } from "./enum/node-kind.js";
+export class DefaultClause extends AbstractCompositeNode {
+    defaultKeyword;
+    colonPunctuator;
+    openBracePunctuator;
+    statements;
+    closeBracePunctuator;
+    constructor(defaultKeyword, colonPunctuator, openBracePunctuator, statements, closeBracePunctuator, children) {
+        super(NodeKind.DEFAULT_CLAUSE, children);
+        this.defaultKeyword = defaultKeyword;
+        this.colonPunctuator = colonPunctuator;
+        this.openBracePunctuator = openBracePunctuator;
+        this.statements = statements;
+        this.closeBracePunctuator = closeBracePunctuator;
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { 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 { CompoundStatement } from "./compound-statement.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+export declare class DoStatement extends AbstractStatement {
+    readonly doKeyword: RequiredNode<Token>;
+    readonly compoundStatement: RequiredNode<CompoundStatement>;
+    readonly whileKeyword: RequiredNode<Token>;
+    readonly openParenthesisPunctuator: RequiredNode<Token>;
+    readonly condition: RequiredNode<AbstractExpression | Identifier | NumberLiteral>;
+    readonly closeParenthesisPunctuator: RequiredNode<Token>;
+    readonly semicolonPunctuator: RequiredNode<Token>;
+    constructor(doKeyword: RequiredNode<Token>, compoundStatement: RequiredNode<CompoundStatement>, whileKeyword: RequiredNode<Token>, openParenthesisPunctuator: RequiredNode<Token>, condition: RequiredNode<AbstractExpression | Identifier | NumberLiteral>, closeParenthesisPunctuator: RequiredNode<Token>, semicolonPunctuator: RequiredNode<Token>, children: Array<AbstractNode>);
+}
+//# sourceMappingURL=do-statement.d.ts.map

package/dist/src/ast/node/do-statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"do-statement.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/do-statement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,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,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,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,qBAAa,WAAY,SAAQ,iBAAiB;aAE9B,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC;aAC9B,iBAAiB,EAAE,YAAY,CAAC,iBAAiB,CAAC;aAClD,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC;aACjC,yBAAyB,EAAE,YAAY,CAAC,KAAK,CAAC;aAC9C,SAAS,EAAE,YAAY,CAAC,kBAAkB,GAAG,UAAU,GAAG,aAAa,CAAC;aACxE,0BAA0B,EAAE,YAAY,CAAC,KAAK,CAAC;aAC/C,mBAAmB,EAAE,YAAY,CAAC,KAAK,CAAC;gBANxC,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,EAC9B,iBAAiB,EAAE,YAAY,CAAC,iBAAiB,CAAC,EAClD,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,EACjC,yBAAyB,EAAE,YAAY,CAAC,KAAK,CAAC,EAC9C,SAAS,EAAE,YAAY,CAAC,kBAAkB,GAAG,UAAU,GAAG,aAAa,CAAC,EACxE,0BAA0B,EAAE,YAAY,CAAC,KAAK,CAAC,EAC/C,mBAAmB,EAAE,YAAY,CAAC,KAAK,CAAC,EACxD,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;CAIhC"}

package/dist/src/ast/node/do-statement.js

@@ -0,0 +1,21 @@
+import { AbstractStatement } from "./abstract-statement.js";
+import { StatementKind } from "./enum/statement-kind.js";
+export class DoStatement extends AbstractStatement {
+    doKeyword;
+    compoundStatement;
+    whileKeyword;
+    openParenthesisPunctuator;
+    condition;
+    closeParenthesisPunctuator;
+    semicolonPunctuator;
+    constructor(doKeyword, compoundStatement, whileKeyword, openParenthesisPunctuator, condition, closeParenthesisPunctuator, semicolonPunctuator, children) {
+        super(StatementKind.DO, children);
+        this.doKeyword = doKeyword;
+        this.compoundStatement = compoundStatement;
+        this.whileKeyword = whileKeyword;
+        this.openParenthesisPunctuator = openParenthesisPunctuator;
+        this.condition = condition;
+        this.closeParenthesisPunctuator = closeParenthesisPunctuator;
+        this.semicolonPunctuator = semicolonPunctuator;
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import { AbstractElementaryTypeDefinition } from "./abstract-elementary-type-definition.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { AlignedModifier } from "./aligned-modifier.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import type { Identifier } from "./identifier.ts";
+import type { LengthAttribute } from "./length-attribute.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+export declare class ElementaryTypeDefinition extends AbstractElementaryTypeDefinition {
+    readonly reservedKeyword: OptionalNode<Token>;
+    readonly legacyKeyword: OptionalNode<Token>;
+    readonly alignedModifier: OptionalNode<AlignedModifier>;
+    readonly lengthAttribute: RequiredNode<LengthAttribute>;
+    readonly lookAheadOperator: OptionalNode<Token>;
+    readonly rangeOperator: OptionalNode<Token>;
+    readonly endValue: OptionalNode<AbstractExpression | NumberLiteral | Identifier>;
+    constructor(reservedKeyword: OptionalNode<Token>, legacyKeyword: OptionalNode<Token>, constKeyword: OptionalNode<Token>, alignedModifier: OptionalNode<AlignedModifier>, elementaryType: RequiredNode<ElementaryType>, lengthAttribute: RequiredNode<LengthAttribute>, lookAheadOperator: OptionalNode<Token>, identifier: RequiredNode<Identifier>, assignmentOperator: OptionalNode<Token>, value: OptionalNode<AbstractExpression | NumberLiteral | Identifier>, rangeOperator: OptionalNode<Token>, endValue: OptionalNode<AbstractExpression | NumberLiteral | Identifier>, semicolonPunctuator: RequiredNode<Token>, children: Array<AbstractNode>);
+}
+//# sourceMappingURL=elementary-type-definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"elementary-type-definition.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/elementary-type-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,gCAAgC,EAAE,MAAM,0CAA0C,CAAC;AAC5F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC,qBAAa,wBAAyB,SAAQ,gCAAgC;aAE1D,eAAe,EAAE,YAAY,CAAC,KAAK,CAAC;aACpC,aAAa,EAAE,YAAY,CAAC,KAAK,CAAC;aAElC,eAAe,EAAE,YAAY,CAAC,eAAe,CAAC;aAE9C,eAAe,EAAE,YAAY,CAAC,eAAe,CAAC;aAC9C,iBAAiB,EAAE,YAAY,CAAC,KAAK,CAAC;aAItC,aAAa,EAAE,YAAY,CAAC,KAAK,CAAC;aAClC,QAAQ,EAAE,YAAY,CAAC,kBAAkB,GAAG,aAAa,GAAG,UAAU,CAAC;gBAXvE,eAAe,EAAE,YAAY,CAAC,KAAK,CAAC,EACpC,aAAa,EAAE,YAAY,CAAC,KAAK,CAAC,EAClD,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,EACjB,eAAe,EAAE,YAAY,CAAC,eAAe,CAAC,EAC9D,cAAc,EAAE,YAAY,CAAC,cAAc,CAAC,EAC5B,eAAe,EAAE,YAAY,CAAC,eAAe,CAAC,EAC9C,iBAAiB,EAAE,YAAY,CAAC,KAAK,CAAC,EACtD,UAAU,EAAE,YAAY,CAAC,UAAU,CAAC,EACpC,kBAAkB,EAAE,YAAY,CAAC,KAAK,CAAC,EACvC,KAAK,EAAE,YAAY,CAAC,kBAAkB,GAAG,aAAa,GAAG,UAAU,CAAC,EACpD,aAAa,EAAE,YAAY,CAAC,KAAK,CAAC,EAClC,QAAQ,EAAE,YAAY,CAAC,kBAAkB,GAAG,aAAa,GAAG,UAAU,CAAC,EACvF,mBAAmB,EAAE,YAAY,CAAC,KAAK,CAAC,EACxC,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;CAahC"}

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

@@ -0,0 +1,21 @@
+import { AbstractElementaryTypeDefinition } from "./abstract-elementary-type-definition.js";
+import { StatementKind } from "./enum/statement-kind.js";
+export class ElementaryTypeDefinition extends AbstractElementaryTypeDefinition {
+    reservedKeyword;
+    legacyKeyword;
+    alignedModifier;
+    lengthAttribute;
+    lookAheadOperator;
+    rangeOperator;
+    endValue;
+    constructor(reservedKeyword, legacyKeyword, constKeyword, alignedModifier, elementaryType, lengthAttribute, lookAheadOperator, identifier, assignmentOperator, value, rangeOperator, endValue, semicolonPunctuator, children) {
+        super(StatementKind.ELEMENTARY_TYPE_DEFINITION, constKeyword, elementaryType, identifier, assignmentOperator, value, semicolonPunctuator, children);
+        this.reservedKeyword = reservedKeyword;
+        this.legacyKeyword = legacyKeyword;
+        this.alignedModifier = alignedModifier;
+        this.lengthAttribute = lengthAttribute;
+        this.lookAheadOperator = lookAheadOperator;
+        this.rangeOperator = rangeOperator;
+        this.endValue = endValue;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { LengthAttribute } from "./length-attribute.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { RequiredNode } from "../util/types.ts";
+export declare class ElementaryTypeOutputValue extends AbstractCompositeNode {
+    readonly elementaryType: RequiredNode<ElementaryType>;
+    readonly lengthAttribute: RequiredNode<LengthAttribute>;
+    constructor(elementaryType: RequiredNode<ElementaryType>, lengthAttribute: RequiredNode<LengthAttribute>, children: Array<AbstractNode>);
+}
+//# sourceMappingURL=elementary-type-output-value.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"elementary-type-output-value.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/elementary-type-output-value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,qBAAa,yBAA0B,SAAQ,qBAAqB;aAEhD,cAAc,EAAE,YAAY,CAAC,cAAc,CAAC;aAC5C,eAAe,EAAE,YAAY,CAAC,eAAe,CAAC;gBAD9C,cAAc,EAAE,YAAY,CAAC,cAAc,CAAC,EAC5C,eAAe,EAAE,YAAY,CAAC,eAAe,CAAC,EAC9D,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;CAIhC"}

package/dist/src/ast/node/elementary-type-output-value.js

@@ -0,0 +1,11 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.js";
+import { NodeKind } from "./enum/node-kind.js";
+export class ElementaryTypeOutputValue extends AbstractCompositeNode {
+    elementaryType;
+    lengthAttribute;
+    constructor(elementaryType, lengthAttribute, children) {
+        super(NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE, children);
+        this.elementaryType = elementaryType;
+        this.lengthAttribute = lengthAttribute;
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { Token } from "./token.ts";
+export declare class ElementaryType extends AbstractCompositeNode {
+    readonly unsignedQualifierKeyword: OptionalNode<Token>;
+    readonly typeKeyword: RequiredNode<Token>;
+    constructor(unsignedQualifierKeyword: OptionalNode<Token>, typeKeyword: RequiredNode<Token>, children: Array<AbstractNode>);
+}
+//# sourceMappingURL=elementary-type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"elementary-type.d.ts","sourceRoot":"","sources":["../../../../src/ast/node/elementary-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,qBAAa,cAAe,SAAQ,qBAAqB;aAErC,wBAAwB,EAAE,YAAY,CAAC,KAAK,CAAC;aAC7C,WAAW,EAAE,YAAY,CAAC,KAAK,CAAC;gBADhC,wBAAwB,EAAE,YAAY,CAAC,KAAK,CAAC,EAC7C,WAAW,EAAE,YAAY,CAAC,KAAK,CAAC,EAChD,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;CAIhC"}

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

@@ -0,0 +1,11 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.js";
+import { NodeKind } from "./enum/node-kind.js";
+export class ElementaryType extends AbstractCompositeNode {
+    unsignedQualifierKeyword;
+    typeKeyword;
+    constructor(unsignedQualifierKeyword, typeKeyword, children) {
+        super(NodeKind.ELEMENTARY_TYPE, children);
+        this.unsignedQualifierKeyword = unsignedQualifierKeyword;
+        this.typeKeyword = typeKeyword;
+    }
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Enum representing different kinds of array dimensions.
+ */
+export declare enum ArrayDimensionKind {
+    /** Explicit array dimension */
+    EXPLICIT = 0,
+    /** Partial array dimension */
+    PARTIAL = 1,
+    /** Implicit array dimension */
+    IMPLICIT = 2
+}
+//# sourceMappingURL=array-dimension-kind.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array-dimension-kind.d.ts","sourceRoot":"","sources":["../../../../../src/ast/node/enum/array-dimension-kind.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,+BAA+B;IAC/B,QAAQ,IAAA;IACR,8BAA8B;IAC9B,OAAO,IAAA;IACP,+BAA+B;IAC/B,QAAQ,IAAA;CACT"}

package/dist/src/ast/node/enum/array-dimension-kind.js

@@ -0,0 +1,12 @@
+/**
+ * Enum representing different kinds of array dimensions.
+ */
+export var ArrayDimensionKind;
+(function (ArrayDimensionKind) {
+    /** Explicit array dimension */
+    ArrayDimensionKind[ArrayDimensionKind["EXPLICIT"] = 0] = "EXPLICIT";
+    /** Partial array dimension */
+    ArrayDimensionKind[ArrayDimensionKind["PARTIAL"] = 1] = "PARTIAL";
+    /** Implicit array dimension */
+    ArrayDimensionKind[ArrayDimensionKind["IMPLICIT"] = 2] = "IMPLICIT";
+})(ArrayDimensionKind || (ArrayDimensionKind = {}));

package/dist/src/ast/node/enum/binary-operator-kind.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Enum representing different kinds of binary operators.
+ */
+export declare enum BinaryOperatorKind {
+    /** Assignment operator */
+    ASSIGNMENT = 0,
+    /** Multiplication operator */
+    MULTIPLY = 1,
+    /** Division operator */
+    DIVIDE = 2,
+    /** Modulus operator */
+    MODULUS = 3,
+    /** Addition operator */
+    ADD = 4,
+    /** Subtraction operator */
+    SUBTRACT = 5,
+    /** Shift left operator */
+    SHIFT_LEFT = 6,
+    /** Shift right operator */
+    SHIFT_RIGHT = 7,
+    /** Less than operator */
+    LESS_THAN = 8,
+    /** Less than or equal operator */
+    LESS_THAN_OR_EQUAL = 9,
+    /** Greater than operator */
+    GREATER_THAN = 10,
+    /** Greater than or equal operator */
+    GREATER_THAN_OR_EQUAL = 11,
+    /** Equal operator */
+    EQUAL = 12,
+    /** Not equal operator */
+    NOT_EQUAL = 13,
+    /** Bitwise AND operator */
+    BITWISE_AND = 14,
+    /** Bitwise OR operator */
+    BITWISE_OR = 15,
+    /** Logical AND operator */
+    LOGICAL_AND = 16,
+    /** Logical OR operator */
+    LOGICAL_OR = 17
+}
+//# sourceMappingURL=binary-operator-kind.d.ts.map

package/dist/src/ast/node/enum/binary-operator-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-operator-kind.d.ts","sourceRoot":"","sources":["../../../../../src/ast/node/enum/binary-operator-kind.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,0BAA0B;IAC1B,UAAU,IAAA;IACV,8BAA8B;IAC9B,QAAQ,IAAA;IACR,wBAAwB;IACxB,MAAM,IAAA;IACN,uBAAuB;IACvB,OAAO,IAAA;IACP,wBAAwB;IACxB,GAAG,IAAA;IACH,2BAA2B;IAC3B,QAAQ,IAAA;IACR,0BAA0B;IAC1B,UAAU,IAAA;IACV,2BAA2B;IAC3B,WAAW,IAAA;IACX,yBAAyB;IACzB,SAAS,IAAA;IACT,kCAAkC;IAClC,kBAAkB,IAAA;IAClB,4BAA4B;IAC5B,YAAY,KAAA;IACZ,qCAAqC;IACrC,qBAAqB,KAAA;IACrB,qBAAqB;IACrB,KAAK,KAAA;IACL,yBAAyB;IACzB,SAAS,KAAA;IACT,2BAA2B;IAC3B,WAAW,KAAA;IACX,0BAA0B;IAC1B,UAAU,KAAA;IACV,2BAA2B;IAC3B,WAAW,KAAA;IACX,0BAA0B;IAC1B,UAAU,KAAA;CACX"}

package/dist/src/ast/node/enum/binary-operator-kind.js

@@ -0,0 +1,42 @@
+/**
+ * Enum representing different kinds of binary operators.
+ */
+export var BinaryOperatorKind;
+(function (BinaryOperatorKind) {
+    /** Assignment operator */
+    BinaryOperatorKind[BinaryOperatorKind["ASSIGNMENT"] = 0] = "ASSIGNMENT";
+    /** Multiplication operator */
+    BinaryOperatorKind[BinaryOperatorKind["MULTIPLY"] = 1] = "MULTIPLY";
+    /** Division operator */
+    BinaryOperatorKind[BinaryOperatorKind["DIVIDE"] = 2] = "DIVIDE";
+    /** Modulus operator */
+    BinaryOperatorKind[BinaryOperatorKind["MODULUS"] = 3] = "MODULUS";
+    /** Addition operator */
+    BinaryOperatorKind[BinaryOperatorKind["ADD"] = 4] = "ADD";
+    /** Subtraction operator */
+    BinaryOperatorKind[BinaryOperatorKind["SUBTRACT"] = 5] = "SUBTRACT";
+    /** Shift left operator */
+    BinaryOperatorKind[BinaryOperatorKind["SHIFT_LEFT"] = 6] = "SHIFT_LEFT";
+    /** Shift right operator */
+    BinaryOperatorKind[BinaryOperatorKind["SHIFT_RIGHT"] = 7] = "SHIFT_RIGHT";
+    /** Less than operator */
+    BinaryOperatorKind[BinaryOperatorKind["LESS_THAN"] = 8] = "LESS_THAN";
+    /** Less than or equal operator */
+    BinaryOperatorKind[BinaryOperatorKind["LESS_THAN_OR_EQUAL"] = 9] = "LESS_THAN_OR_EQUAL";
+    /** Greater than operator */
+    BinaryOperatorKind[BinaryOperatorKind["GREATER_THAN"] = 10] = "GREATER_THAN";
+    /** Greater than or equal operator */
+    BinaryOperatorKind[BinaryOperatorKind["GREATER_THAN_OR_EQUAL"] = 11] = "GREATER_THAN_OR_EQUAL";
+    /** Equal operator */
+    BinaryOperatorKind[BinaryOperatorKind["EQUAL"] = 12] = "EQUAL";
+    /** Not equal operator */
+    BinaryOperatorKind[BinaryOperatorKind["NOT_EQUAL"] = 13] = "NOT_EQUAL";
+    /** Bitwise AND operator */
+    BinaryOperatorKind[BinaryOperatorKind["BITWISE_AND"] = 14] = "BITWISE_AND";
+    /** Bitwise OR operator */
+    BinaryOperatorKind[BinaryOperatorKind["BITWISE_OR"] = 15] = "BITWISE_OR";
+    /** Logical AND operator */
+    BinaryOperatorKind[BinaryOperatorKind["LOGICAL_AND"] = 16] = "LOGICAL_AND";
+    /** Logical OR operator */
+    BinaryOperatorKind[BinaryOperatorKind["LOGICAL_OR"] = 17] = "LOGICAL_OR";
+})(BinaryOperatorKind || (BinaryOperatorKind = {}));

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

@@ -0,0 +1,13 @@
+/**
+ * Enum representing different kinds of class IDs.
+ * This enum is used to categorize different types of class IDs.
+ */
+export declare enum ClassIdKind {
+    /** Single class ID */
+    SINGLE = 0,
+    /** Range class ID */
+    RANGE = 1,
+    /** Extended range class ID */
+    EXTENDED_RANGE = 2
+}
+//# sourceMappingURL=class-id-kind.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"class-id-kind.d.ts","sourceRoot":"","sources":["../../../../../src/ast/node/enum/class-id-kind.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,WAAW;IACrB,sBAAsB;IACtB,MAAM,IAAA;IACN,qBAAqB;IACrB,KAAK,IAAA;IACL,8BAA8B;IAC9B,cAAc,IAAA;CACf"}

package/dist/src/ast/node/enum/class-id-kind.js

@@ -0,0 +1,13 @@
+/**
+ * Enum representing different kinds of class IDs.
+ * This enum is used to categorize different types of class IDs.
+ */
+export var ClassIdKind;
+(function (ClassIdKind) {
+    /** Single class ID */
+    ClassIdKind[ClassIdKind["SINGLE"] = 0] = "SINGLE";
+    /** Range class ID */
+    ClassIdKind[ClassIdKind["RANGE"] = 1] = "RANGE";
+    /** Extended range class ID */
+    ClassIdKind[ClassIdKind["EXTENDED_RANGE"] = 2] = "EXTENDED_RANGE";
+})(ClassIdKind || (ClassIdKind = {}));

package/dist/src/ast/node/enum/elementary-type-kind.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Enum representing different kinds of elementary types.
+ */
+export declare enum ElementaryTypeKind {
+    /** Integer type */
+    INTEGER = 0,
+    /** Unsigned integer type */
+    UNSIGNED_INTEGER = 1,
+    /** Floating point type */
+    FLOATING_POINT = 2,
+    /** Bit type */
+    BIT = 3
+}
+//# sourceMappingURL=elementary-type-kind.d.ts.map

package/dist/src/ast/node/enum/elementary-type-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementary-type-kind.d.ts","sourceRoot":"","sources":["../../../../../src/ast/node/enum/elementary-type-kind.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,mBAAmB;IACnB,OAAO,IAAA;IACP,4BAA4B;IAC5B,gBAAgB,IAAA;IAChB,0BAA0B;IAC1B,cAAc,IAAA;IACd,eAAe;IACf,GAAG,IAAA;CACJ"}

package/dist/src/ast/node/enum/elementary-type-kind.js

@@ -0,0 +1,14 @@
+/**
+ * Enum representing different kinds of elementary types.
+ */
+export var ElementaryTypeKind;
+(function (ElementaryTypeKind) {
+    /** Integer type */
+    ElementaryTypeKind[ElementaryTypeKind["INTEGER"] = 0] = "INTEGER";
+    /** Unsigned integer type */
+    ElementaryTypeKind[ElementaryTypeKind["UNSIGNED_INTEGER"] = 1] = "UNSIGNED_INTEGER";
+    /** Floating point type */
+    ElementaryTypeKind[ElementaryTypeKind["FLOATING_POINT"] = 2] = "FLOATING_POINT";
+    /** Bit type */
+    ElementaryTypeKind[ElementaryTypeKind["BIT"] = 3] = "BIT";
+})(ElementaryTypeKind || (ElementaryTypeKind = {}));

package/dist/src/ast/node/enum/expression-kind.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Enum representing different kinds of expressions.
+ */
+export declare enum ExpressionKind {
+    /** Binary expression */
+    BINARY = 0,
+    /** Lengthof expression */
+    LENGTHOF = 1,
+    /** Unary expression */
+    UNARY = 2
+}
+//# sourceMappingURL=expression-kind.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression-kind.d.ts","sourceRoot":"","sources":["../../../../../src/ast/node/enum/expression-kind.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,cAAc;IACxB,wBAAwB;IACxB,MAAM,IAAA;IACN,0BAA0B;IAC1B,QAAQ,IAAA;IACR,uBAAuB;IACvB,KAAK,IAAA;CACN"}

package/dist/src/ast/node/enum/expression-kind.js

@@ -0,0 +1,12 @@
+/**
+ * Enum representing different kinds of expressions.
+ */
+export var ExpressionKind;
+(function (ExpressionKind) {
+    /** Binary expression */
+    ExpressionKind[ExpressionKind["BINARY"] = 0] = "BINARY";
+    /** Lengthof expression */
+    ExpressionKind[ExpressionKind["LENGTHOF"] = 1] = "LENGTHOF";
+    /** Unary expression */
+    ExpressionKind[ExpressionKind["UNARY"] = 2] = "UNARY";
+})(ExpressionKind || (ExpressionKind = {}));

package/dist/src/ast/node/enum/node-kind.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Enum representing different kinds of nodes.
+ */
+export declare enum NodeKind {
+    /** Error placeholder for unexpected node */
+    UNEXPECTED_ERROR = -1,
+    /** Output value node */
+    AGGREGATE_OUTPUT_VALUE = 0,
+    /** Aligned modifier node */
+    ALIGNED_MODIFIER = 1,
+    /** Array dimension node */
+    ARRAY_DIMENSION = 2,
+    /** Array element access node */
+    ARRAY_ELEMENT_ACCESS = 3,
+    /** Bit modifier node */
+    BIT_MODIFIER = 4,
+    /** Switch case clause node */
+    CASE_CLAUSE = 5,
+    /** Class ID node */
+    CLASS_ID = 6,
+    /** Class member access node */
+    CLASS_MEMBER_ACCESS = 7,
+    /** Switch default clause node */
+    DEFAULT_CLAUSE = 8,
+    /** Elementary type node */
+    ELEMENTARY_TYPE = 9,
+    /** Elementary type output value node */
+    ELEMENTARY_TYPE_OUTPUT_VALUE = 10,
+    /** Expandable modifier node */
+    EXPANDABLE_MODIFIER = 11,
+    /** Expression node */
+    EXPRESSION = 12,
+    /** Extends modifier node */
+    EXTENDS_MODIFIER = 13,
+    /** Identifier node */
+    IDENTIFIER = 14,
+    /** Length attribute node */
+    LENGTH_ATTRIBUTE = 15,
+    /** Map entry node */
+    MAP_ENTRY = 16,
+    /** Number literal node */
+    NUMBER_LITERAL = 17,
+    /** Parameter node */
+    PARAMETER = 18,
+    /** Parameter list node */
+    PARAMETER_LIST = 19,
+    /** Parameter value list node */
+    PARAMETER_VALUE_LIST = 20,
+    /** Specification node */
+    SPECIFICATION = 21,
+    /** Statement node */
+    STATEMENT = 22,
+    /** String literal node */
+    STRING_LITERAL = 23,
+    /** Syntax token node */
+    TOKEN = 24
+}
+//# sourceMappingURL=node-kind.d.ts.map

package/dist/src/ast/node/enum/node-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-kind.d.ts","sourceRoot":"","sources":["../../../../../src/ast/node/enum/node-kind.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,QAAQ;IAClB,4CAA4C;IAC5C,gBAAgB,KAAK;IACrB,wBAAwB;IACxB,sBAAsB,IAAA;IACtB,4BAA4B;IAC5B,gBAAgB,IAAA;IAChB,2BAA2B;IAC3B,eAAe,IAAA;IACf,gCAAgC;IAChC,oBAAoB,IAAA;IACpB,wBAAwB;IACxB,YAAY,IAAA;IACZ,8BAA8B;IAC9B,WAAW,IAAA;IACX,oBAAoB;IACpB,QAAQ,IAAA;IACR,+BAA+B;IAC/B,mBAAmB,IAAA;IACnB,iCAAiC;IACjC,cAAc,IAAA;IACd,2BAA2B;IAC3B,eAAe,IAAA;IACf,wCAAwC;IACxC,4BAA4B,KAAA;IAC5B,+BAA+B;IAC/B,mBAAmB,KAAA;IACnB,sBAAsB;IACtB,UAAU,KAAA;IACV,4BAA4B;IAC5B,gBAAgB,KAAA;IAChB,sBAAsB;IACtB,UAAU,KAAA;IACV,4BAA4B;IAC5B,gBAAgB,KAAA;IAChB,qBAAqB;IACrB,SAAS,KAAA;IACT,0BAA0B;IAC1B,cAAc,KAAA;IACd,qBAAqB;IACrB,SAAS,KAAA;IACT,0BAA0B;IAC1B,cAAc,KAAA;IACd,gCAAgC;IAChC,oBAAoB,KAAA;IACpB,yBAAyB;IACzB,aAAa,KAAA;IACb,qBAAqB;IACrB,SAAS,KAAA;IACT,0BAA0B;IAC1B,cAAc,KAAA;IACd,wBAAwB;IACxB,KAAK,KAAA;CACN"}

package/dist/src/ast/node/enum/node-kind.js

@@ -0,0 +1,58 @@
+/**
+ * Enum representing different kinds of nodes.
+ */
+export var NodeKind;
+(function (NodeKind) {
+    /** Error placeholder for unexpected node */
+    NodeKind[NodeKind["UNEXPECTED_ERROR"] = -1] = "UNEXPECTED_ERROR";
+    /** Output value node */
+    NodeKind[NodeKind["AGGREGATE_OUTPUT_VALUE"] = 0] = "AGGREGATE_OUTPUT_VALUE";
+    /** Aligned modifier node */
+    NodeKind[NodeKind["ALIGNED_MODIFIER"] = 1] = "ALIGNED_MODIFIER";
+    /** Array dimension node */
+    NodeKind[NodeKind["ARRAY_DIMENSION"] = 2] = "ARRAY_DIMENSION";
+    /** Array element access node */
+    NodeKind[NodeKind["ARRAY_ELEMENT_ACCESS"] = 3] = "ARRAY_ELEMENT_ACCESS";
+    /** Bit modifier node */
+    NodeKind[NodeKind["BIT_MODIFIER"] = 4] = "BIT_MODIFIER";
+    /** Switch case clause node */
+    NodeKind[NodeKind["CASE_CLAUSE"] = 5] = "CASE_CLAUSE";
+    /** Class ID node */
+    NodeKind[NodeKind["CLASS_ID"] = 6] = "CLASS_ID";
+    /** Class member access node */
+    NodeKind[NodeKind["CLASS_MEMBER_ACCESS"] = 7] = "CLASS_MEMBER_ACCESS";
+    /** Switch default clause node */
+    NodeKind[NodeKind["DEFAULT_CLAUSE"] = 8] = "DEFAULT_CLAUSE";
+    /** Elementary type node */
+    NodeKind[NodeKind["ELEMENTARY_TYPE"] = 9] = "ELEMENTARY_TYPE";
+    /** Elementary type output value node */
+    NodeKind[NodeKind["ELEMENTARY_TYPE_OUTPUT_VALUE"] = 10] = "ELEMENTARY_TYPE_OUTPUT_VALUE";
+    /** Expandable modifier node */
+    NodeKind[NodeKind["EXPANDABLE_MODIFIER"] = 11] = "EXPANDABLE_MODIFIER";
+    /** Expression node */
+    NodeKind[NodeKind["EXPRESSION"] = 12] = "EXPRESSION";
+    /** Extends modifier node */
+    NodeKind[NodeKind["EXTENDS_MODIFIER"] = 13] = "EXTENDS_MODIFIER";
+    /** Identifier node */
+    NodeKind[NodeKind["IDENTIFIER"] = 14] = "IDENTIFIER";
+    /** Length attribute node */
+    NodeKind[NodeKind["LENGTH_ATTRIBUTE"] = 15] = "LENGTH_ATTRIBUTE";
+    /** Map entry node */
+    NodeKind[NodeKind["MAP_ENTRY"] = 16] = "MAP_ENTRY";
+    /** Number literal node */
+    NodeKind[NodeKind["NUMBER_LITERAL"] = 17] = "NUMBER_LITERAL";
+    /** Parameter node */
+    NodeKind[NodeKind["PARAMETER"] = 18] = "PARAMETER";
+    /** Parameter list node */
+    NodeKind[NodeKind["PARAMETER_LIST"] = 19] = "PARAMETER_LIST";
+    /** Parameter value list node */
+    NodeKind[NodeKind["PARAMETER_VALUE_LIST"] = 20] = "PARAMETER_VALUE_LIST";
+    /** Specification node */
+    NodeKind[NodeKind["SPECIFICATION"] = 21] = "SPECIFICATION";
+    /** Statement node */
+    NodeKind[NodeKind["STATEMENT"] = 22] = "STATEMENT";
+    /** String literal node */
+    NodeKind[NodeKind["STRING_LITERAL"] = 23] = "STRING_LITERAL";
+    /** Syntax token node */
+    NodeKind[NodeKind["TOKEN"] = 24] = "TOKEN";
+})(NodeKind || (NodeKind = {}));

package/dist/src/ast/node/enum/number-literal-kind.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Enum representing different kinds of number literals.
+ */
+export declare enum NumberLiteralKind {
+    /** Binary number literal */
+    BINARY = 0,
+    /** Hexadecimal number literal */
+    HEXADECIMAL = 1,
+    /** Integer number literal */
+    INTEGER = 2,
+    /** Decimal number literal */
+    DECIMAL = 3,
+    /** Multiple character number literal */
+    MULTIPLE_CHARACTER = 4,
+    /** Floating point number literal */
+    FLOATING_POINT = 5
+}
+//# sourceMappingURL=number-literal-kind.d.ts.map

package/dist/src/ast/node/enum/number-literal-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-literal-kind.d.ts","sourceRoot":"","sources":["../../../../../src/ast/node/enum/number-literal-kind.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,iBAAiB;IAC3B,4BAA4B;IAC5B,MAAM,IAAA;IACN,iCAAiC;IACjC,WAAW,IAAA;IACX,6BAA6B;IAC7B,OAAO,IAAA;IACP,6BAA6B;IAC7B,OAAO,IAAA;IACP,wCAAwC;IACxC,kBAAkB,IAAA;IAClB,oCAAoC;IACpC,cAAc,IAAA;CACf"}

package/dist/src/ast/node/enum/number-literal-kind.js

@@ -0,0 +1,18 @@
+/**
+ * Enum representing different kinds of number literals.
+ */
+export var NumberLiteralKind;
+(function (NumberLiteralKind) {
+    /** Binary number literal */
+    NumberLiteralKind[NumberLiteralKind["BINARY"] = 0] = "BINARY";
+    /** Hexadecimal number literal */
+    NumberLiteralKind[NumberLiteralKind["HEXADECIMAL"] = 1] = "HEXADECIMAL";
+    /** Integer number literal */
+    NumberLiteralKind[NumberLiteralKind["INTEGER"] = 2] = "INTEGER";
+    /** Decimal number literal */
+    NumberLiteralKind[NumberLiteralKind["DECIMAL"] = 3] = "DECIMAL";
+    /** Multiple character number literal */
+    NumberLiteralKind[NumberLiteralKind["MULTIPLE_CHARACTER"] = 4] = "MULTIPLE_CHARACTER";
+    /** Floating point number literal */
+    NumberLiteralKind[NumberLiteralKind["FLOATING_POINT"] = 5] = "FLOATING_POINT";
+})(NumberLiteralKind || (NumberLiteralKind = {}));