@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

package/dist/src/prettier/prettier-plugin-sdl.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "prettier";
+export declare const prettierPluginSdl: Plugin;
+//# sourceMappingURL=prettier-plugin-sdl.d.ts.map

package/dist/src/prettier/prettier-plugin-sdl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettier-plugin-sdl.d.ts","sourceRoot":"","sources":["../../../src/prettier/prettier-plugin-sdl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,MAAM,EAA4B,MAAM,UAAU,CAAC;AAyEzE,eAAO,MAAM,iBAAiB,EAAE,MAI/B,CAAC"}

package/dist/src/prettier/prettier-plugin-sdl.js

@@ -0,0 +1,70 @@
+import { printAbstractNode } from "./print-abstract-node.js";
+import { createLenientSdlParser } from "../lezer/create-sdl-parser.js";
+import { buildAst } from "../ast/build-ast.js";
+import { SdlStringInput } from "../lezer/sdl-string-input.js";
+import { isCompositeNode, isToken } from "../ast/util/types.js";
+import { InternalScannerError } from "../scanner-error.js";
+import { NodeKind } from "../ast/node/enum/node-kind.js";
+const languages = [
+    {
+        name: "sdl",
+        parsers: ["sdl"],
+    },
+];
+const parsers = {
+    sdl: {
+        astFormat: "sdl",
+        parse: (sdlSpecification) => {
+            const sdlStringInput = new SdlStringInput(sdlSpecification);
+            const sdlParser = createLenientSdlParser();
+            const parseTree = sdlParser.parse(sdlSpecification);
+            return buildAst(parseTree, sdlStringInput, true);
+        },
+        locStart: (node) => {
+            let token;
+            if (isCompositeNode(node)) {
+                if (!node.startToken) {
+                    throw new InternalScannerError("Composite node does not have a start token.");
+                }
+                token = node.startToken;
+            }
+            else if (isToken(node)) {
+                token = node;
+            }
+            else {
+                throw new InternalScannerError("Unsupported node for prettierPluginSdl: " + NodeKind[node.nodeKind]);
+            }
+            return token.leadingTrivia && token.leadingTrivia.length > 0
+                ? token.leadingTrivia[0].location.position
+                : token.getLocation().position;
+        },
+        locEnd: (node) => {
+            let token;
+            if (isCompositeNode(node)) {
+                if (!node.endToken) {
+                    throw new InternalScannerError("Composite node does not have an end token.");
+                }
+                token = node.endToken;
+            }
+            else if (isToken(node)) {
+                token = node;
+            }
+            else {
+                throw new InternalScannerError("Unsupported node for prettierPluginSdl: " + NodeKind[node.nodeKind]);
+            }
+            return token.trailingTrivia && token.trailingTrivia.length > 0
+                ? token.trailingTrivia[token.trailingTrivia.length - 1].location.position
+                : token.getLocation().position;
+        },
+    },
+};
+const printers = {
+    sdl: {
+        print: printAbstractNode,
+    },
+};
+export const prettierPluginSdl = {
+    languages,
+    parsers,
+    printers,
+};

package/dist/src/prettier/print-abstract-array-dimension.d.ts

@@ -0,0 +1,5 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractArrayDimension } from "../ast/node/abstract-array-dimension.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+export declare function printAbstractArrayDimension(path: AstPath<AbstractArrayDimension>, print: (path: AstPath<AbstractNode>) => Doc): Doc;
+//# sourceMappingURL=print-abstract-array-dimension.d.ts.map

package/dist/src/prettier/print-abstract-array-dimension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-abstract-array-dimension.d.ts","sourceRoot":"","sources":["../../../src/prettier/print-abstract-array-dimension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACtF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAOjE,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,OAAO,CAAC,sBAAsB,CAAC,EACrC,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,GAAG,GAC1C,GAAG,CAgDL"}

package/dist/src/prettier/print-abstract-array-dimension.js

@@ -0,0 +1,41 @@
+import { ArrayDimensionKind } from "../ast/node/enum/array-dimension-kind.js";
+import { InternalScannerError } from "../scanner-error.js";
+export function printAbstractArrayDimension(path, print) {
+    const { arrayDimensionKind } = path.node;
+    switch (arrayDimensionKind) {
+        case ArrayDimensionKind.EXPLICIT: {
+            return [
+                path.call(print, "openBracketPunctuator"),
+                path.call(print, "size"),
+                path.call(print, "closeBracketPunctuator"),
+            ];
+        }
+        case ArrayDimensionKind.PARTIAL: {
+            return [
+                path.call(print, "openBracketPunctuator"),
+                path.call(print, "innerOpenBracketPunctuator"),
+                path.call(print, "index"),
+                path.call(print, "innerCloseBracketPunctuator"),
+                path.call(print, "closeBracketPunctuator"),
+            ];
+        }
+        case ArrayDimensionKind.IMPLICIT: {
+            const node = path.node;
+            const doc = [];
+            doc.push(path.call(print, "openBracketPunctuator"));
+            if (node.rangeStart !== undefined) {
+                doc.push(path.call(print, "rangeStart"));
+            }
+            if (node.rangeOperator !== undefined) {
+                doc.push(path.call(print, "rangeOperator"));
+                doc.push(path.call(print, "rangeEnd"));
+            }
+            doc.push(path.call(print, "closeBracketPunctuator"));
+            return doc;
+        }
+        default: {
+            const exhaustiveCheck = arrayDimensionKind;
+            throw new InternalScannerError("Unreachable code reached, arrayDimensionKind == " + exhaustiveCheck);
+        }
+    }
+}

package/dist/src/prettier/print-abstract-class-id.d.ts

@@ -0,0 +1,5 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractClassId } from "../ast/node/abstract-class-id.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+export declare function printAbstractClassId(path: AstPath<AbstractClassId>, print: (path: AstPath<AbstractNode>) => Doc): Doc;
+//# sourceMappingURL=print-abstract-class-id.d.ts.map

package/dist/src/prettier/print-abstract-class-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-abstract-class-id.d.ts","sourceRoot":"","sources":["../../../src/prettier/print-abstract-class-id.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAQjE,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,EAC9B,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,GAAG,GAC1C,GAAG,CA+BL"}

package/dist/src/prettier/print-abstract-class-id.js

@@ -0,0 +1,27 @@
+import { ClassIdKind } from "../ast/node/enum/class-id-kind.js";
+import { interleaveCommaSeparatorDocs } from "./util/print-utils.js";
+import { InternalScannerError } from "../scanner-error.js";
+export function printAbstractClassId(path, print) {
+    const { classIdKind } = path.node;
+    switch (classIdKind) {
+        case ClassIdKind.SINGLE:
+            return path.call(print, "value");
+        case ClassIdKind.RANGE: {
+            return [
+                path.call(print, "startClassId"),
+                path.call(print, "rangeOperator"),
+                path.call(print, "endClassId"),
+            ];
+        }
+        case ClassIdKind.EXTENDED_RANGE: {
+            const doc = [];
+            const outputValuesDoc = path.map(print, "classIds");
+            doc.push(interleaveCommaSeparatorDocs(outputValuesDoc, path.map(print, "commaPunctuators")));
+            return doc;
+        }
+        default: {
+            const exhaustiveCheck = classIdKind;
+            throw new InternalScannerError("Unreachable code reached, classIdKind == " + exhaustiveCheck);
+        }
+    }
+}

package/dist/src/prettier/print-abstract-expression.d.ts

@@ -0,0 +1,5 @@
+import { AstPath, type Doc } from "prettier";
+import type { AbstractExpression } from "../ast/node/abstract-expression.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+export declare function printAbstractExpression(path: AstPath<AbstractExpression>, print: (path: AstPath<AbstractNode>) => Doc): Doc;
+//# sourceMappingURL=print-abstract-expression.d.ts.map

package/dist/src/prettier/print-abstract-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-abstract-expression.d.ts","sourceRoot":"","sources":["../../../src/prettier/print-abstract-expression.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,GAAG,EAAO,MAAM,UAAU,CAAC;AAElD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAiHjE,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACjC,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,GAAG,GAC1C,GAAG,CAgBL"}

package/dist/src/prettier/print-abstract-expression.js

@@ -0,0 +1,74 @@
+import { AstPath, doc } from "prettier";
+import { addBreakingWhitespace, addNonBreakingWhitespace } from "./util/print-utils.js";
+import { ExpressionKind } from "../ast/node/enum/expression-kind.js";
+import { InternalScannerError } from "../scanner-error.js";
+const { fill } = doc.builders;
+function printUnaryExpression(path, print) {
+    const unaryExpression = path.node;
+    const doc = [];
+    if (unaryExpression.unaryOperator !== undefined) {
+        doc.push(path.call(print, "unaryOperator"));
+    }
+    if (unaryExpression.openParenthesisPunctuator !== undefined) {
+        doc.push(path.call(print, "openParenthesisPunctuator"));
+    }
+    doc.push(path.call(print, "operand"));
+    if (unaryExpression.arrayElementAccess !== undefined) {
+        doc.push(...path.call(print, "arrayElementAccess"));
+    }
+    if (unaryExpression.classMemberAccess !== undefined) {
+        doc.push(...path.call(print, "classMemberAccess"));
+    }
+    if (unaryExpression.closeParenthesisPunctuator !== undefined) {
+        doc.push(path.call(print, "closeParenthesisPunctuator"));
+    }
+    if (unaryExpression.postfixOperator !== undefined) {
+        doc.push(path.call(print, "postfixOperator"));
+    }
+    return doc;
+}
+function printBinaryExpression(path, print) {
+    let subDoc = [];
+    subDoc.push(path.call(print, "leftOperand"));
+    addNonBreakingWhitespace(subDoc);
+    subDoc.push(path.call(print, "binaryOperator"));
+    let doc = [];
+    doc.push(fill(subDoc));
+    const rightDoc = path.call(print, "rightOperand");
+    if (Array.isArray(rightDoc) &&
+        rightDoc.length === 3 &&
+        rightDoc[1].type === "if-break") {
+        subDoc = addBreakingWhitespace(subDoc);
+        subDoc.push(rightDoc[0]);
+        doc.push(rightDoc[1]);
+        doc.push(rightDoc[2]);
+    }
+    else {
+        doc = addBreakingWhitespace(doc);
+        doc.push(rightDoc);
+    }
+    return doc;
+}
+function printLengthOfExpression(path, print) {
+    const doc = [];
+    doc.push(path.call(print, "lengthOfKeyword"));
+    doc.push(path.call(print, "openParenthesisPunctuator"));
+    doc.push(path.call(print, "operand"));
+    doc.push(path.call(print, "closeParenthesisPunctuator"));
+    return doc;
+}
+export function printAbstractExpression(path, print) {
+    const { expressionKind } = path.node;
+    switch (expressionKind) {
+        case ExpressionKind.BINARY:
+            return printBinaryExpression(path, print);
+        case ExpressionKind.LENGTHOF:
+            return printLengthOfExpression(path, print);
+        case ExpressionKind.UNARY:
+            return printUnaryExpression(path, print);
+        default: {
+            const exhaustiveCheck = expressionKind;
+            throw new InternalScannerError("Unreachable code reached, expressionKind == " + exhaustiveCheck);
+        }
+    }
+}

package/dist/src/prettier/print-abstract-node.d.ts

@@ -0,0 +1,5 @@
+import { type AstPath, type Doc, type ParserOptions } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { RequiredNode } from "../ast/util/types.ts";
+export declare function printAbstractNode(path: AstPath<RequiredNode<AbstractNode>>, _options: ParserOptions<AbstractNode>, print: (_path: AstPath<RequiredNode<AbstractNode>>) => Doc): Doc;
+//# sourceMappingURL=print-abstract-node.d.ts.map

package/dist/src/prettier/print-abstract-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-abstract-node.d.ts","sourceRoot":"","sources":["../../../src/prettier/print-abstract-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAItE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAwBjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAuCzD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,EACzC,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,EACrC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,KAAK,GAAG,GACzD,GAAG,CA2HL"}

package/dist/src/prettier/print-abstract-node.js

@@ -0,0 +1,144 @@
+import {} from "prettier";
+import { NodeKind } from "../ast/node/enum/node-kind.js";
+import { printAbstractExpression } from "./print-abstract-expression.js";
+import { printMapEntry } from "./print-map-entry.js";
+import { printSpecification } from "./print-specification.js";
+import { printElementaryType } from "./print-elementary-type.js";
+import { printStringLiteral } from "./print-string-literal.js";
+import { printAbstractStatement } from "./print-abstract-statement.js";
+import { addTrailingTriviaDoc, endsWithHardline, getLeadingTriviaDoc, getTrailingTriviaDoc, removeLeadingBlanklines, removeTrailingHardline, } from "./util/print-utils.js";
+import { printUnexpectedError } from "./print-unexpected-error.js";
+import { printAlignedModifier } from "./print-aligned-modifier.js";
+import { printIdentifier } from "./print-identifier.js";
+import { printLengthAttribute } from "./print-length-attribute.js";
+import { printNumberLiteral } from "./print-number-literal.js";
+import { printBitModifier } from "./print-bit-modifier.js";
+import { printAbstractClassId } from "./print-abstract-class-id.js";
+import { printExpandableModifier } from "./print-expandable-modifier.js";
+import { printExtendsModifier } from "./print-extends-modifier.js";
+import { printParameter } from "./print-parameter.js";
+import { printParameterList } from "./print-parameter-list.js";
+import { printParameterValueList } from "./print-parameter-value-list.js";
+import { printArrayElementAccess } from "./print-array-element-access.js";
+import { printClassMemberAccess } from "./print-class-member-access.js";
+import { printAggregateOutputValue } from "./print-aggregate-output-value.js";
+import { printElementaryTypeOutputValue } from "./print-elementary-type-output-value.js";
+import { printAbstractArrayDimension } from "./print-abstract-array-dimension.js";
+import { printCaseClause } from "./print-case-clause.js";
+import { printDefaultClause } from "./print-default-clause.js";
+import { printToken } from "./print-token.js";
+import { StatementKind } from "../ast/node/enum/statement-kind.js";
+import { InternalScannerError } from "../scanner-error.js";
+export function printAbstractNode(path, _options, print) {
+    const node = path.node;
+    const nodeKind = node.nodeKind;
+    let doc = [];
+    let leadingTriviaDoc = getLeadingTriviaDoc(node);
+    if (leadingTriviaDoc) {
+        // prevent extra lines at beginning of compount statement
+        if (nodeKind === NodeKind.STATEMENT &&
+            node.statementKind === StatementKind.COMPOUND) {
+            leadingTriviaDoc = removeLeadingBlanklines(leadingTriviaDoc);
+        }
+        doc.push(leadingTriviaDoc);
+    }
+    switch (nodeKind) {
+        case NodeKind.AGGREGATE_OUTPUT_VALUE:
+            doc.push(printAggregateOutputValue(path, print));
+            break;
+        case NodeKind.ALIGNED_MODIFIER:
+            doc.push(printAlignedModifier(path, print));
+            break;
+        case NodeKind.ARRAY_DIMENSION:
+            doc.push(printAbstractArrayDimension(path, print));
+            break;
+        case NodeKind.ARRAY_ELEMENT_ACCESS:
+            doc.push(printArrayElementAccess(path, print));
+            break;
+        case NodeKind.BIT_MODIFIER:
+            doc.push(printBitModifier(path, print));
+            break;
+        case NodeKind.CASE_CLAUSE:
+            doc.push(printCaseClause(path, print));
+            break;
+        case NodeKind.CLASS_ID:
+            doc.push(printAbstractClassId(path, print));
+            break;
+        case NodeKind.CLASS_MEMBER_ACCESS:
+            doc.push(printClassMemberAccess(path, print));
+            break;
+        case NodeKind.DEFAULT_CLAUSE:
+            doc.push(printDefaultClause(path, print));
+            break;
+        case NodeKind.ELEMENTARY_TYPE:
+            doc.push(printElementaryType(path, print));
+            break;
+        case NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE:
+            doc.push(printElementaryTypeOutputValue(path, print));
+            break;
+        case NodeKind.EXPRESSION:
+            doc.push(printAbstractExpression(path, print));
+            break;
+        case NodeKind.EXPANDABLE_MODIFIER:
+            doc.push(printExpandableModifier(path, print));
+            break;
+        case NodeKind.EXTENDS_MODIFIER:
+            doc.push(printExtendsModifier(path, print));
+            break;
+        case NodeKind.IDENTIFIER:
+            doc.push(printIdentifier(path, print));
+            break;
+        case NodeKind.LENGTH_ATTRIBUTE:
+            doc.push(printLengthAttribute(path, print));
+            break;
+        case NodeKind.MAP_ENTRY:
+            doc.push(printMapEntry(path, print));
+            break;
+        case NodeKind.NUMBER_LITERAL:
+            doc.push(printNumberLiteral(path, print));
+            break;
+        case NodeKind.PARAMETER:
+            doc.push(printParameter(path, print));
+            break;
+        case NodeKind.PARAMETER_LIST:
+            doc.push(printParameterList(path, print));
+            break;
+        case NodeKind.PARAMETER_VALUE_LIST:
+            doc.push(printParameterValueList(path, print));
+            break;
+        case NodeKind.SPECIFICATION:
+            doc.push(printSpecification(path, print));
+            break;
+        case NodeKind.STATEMENT:
+            doc.push(printAbstractStatement(path, print));
+            break;
+        case NodeKind.STRING_LITERAL:
+            doc.push(printStringLiteral(path, print));
+            break;
+        case NodeKind.TOKEN:
+            doc.push(printToken(path));
+            break;
+        case NodeKind.UNEXPECTED_ERROR:
+            doc.push(printUnexpectedError(path, print));
+            break;
+        default: {
+            const exhaustiveCheck = nodeKind;
+            throw new InternalScannerError("Unreachable code reached, nodeKind == " + exhaustiveCheck);
+        }
+    }
+    const trailingTriviaDoc = getTrailingTriviaDoc(node);
+    if (trailingTriviaDoc) {
+        // prevent extra lines at end of specification
+        if (nodeKind === NodeKind.SPECIFICATION &&
+            endsWithHardline(doc) &&
+            endsWithHardline(trailingTriviaDoc)) {
+            doc = removeTrailingHardline(doc);
+        }
+        doc = addTrailingTriviaDoc(doc, trailingTriviaDoc);
+    }
+    // trim unneeded arrays
+    while (Array.isArray(doc) && doc.length === 1) {
+        doc = doc[0];
+    }
+    return doc;
+}

package/dist/src/prettier/print-abstract-statement.d.ts

@@ -0,0 +1,5 @@
+import { AstPath, type Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { AbstractStatement } from "../ast/node/abstract-statement.ts";
+export declare function printAbstractStatement(path: AstPath<AbstractStatement>, print: (_path: AstPath<AbstractNode>) => Doc): Doc;
+//# sourceMappingURL=print-abstract-statement.d.ts.map

package/dist/src/prettier/print-abstract-statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-abstract-statement.d.ts","sourceRoot":"","sources":["../../../src/prettier/print-abstract-statement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,GAAG,EAAO,MAAM,UAAU,CAAC;AAQlD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAqD3E,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,OAAO,CAAC,iBAAiB,CAAC,EAChC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,GAAG,GAC3C,GAAG,CA8CL"}

package/dist/src/prettier/print-abstract-statement.js

@@ -0,0 +1,70 @@
+import { AstPath, doc } from "prettier";
+import { addIndentedStatements } from "./util/print-utils.js";
+import { printArrayDefinition } from "./print-array-definition.js";
+import { printDoStatement } from "./print-do-statement.js";
+import { printForStatement } from "./print-for-statement.js";
+import { printWhileStatement } from "./print-while-statement.js";
+import { printIfStatement } from "./print-if-statement.js";
+import { printSwitchStatement } from "./print-switch-statement.js";
+import { StatementKind } from "../ast/node/enum/statement-kind.js";
+import { printClassDeclaration } from "./print-class-declaration.js";
+import { printClassDefinition } from "./print-class-definition.js";
+import { printComputedArrayDefinition } from "./print-computed-array-definition.js";
+import { printMapDeclaration } from "./print-map-declaration.js";
+import { printStringDefinition } from "./print-string-definition.js";
+import { printMapDefinition } from "./print-map-definition.js";
+import { printComputedElementaryTypeDefinition } from "./print-computed-elementary-type-definition.js";
+import { printElementaryTypeDefinition } from "./print-elementary-type-definition.js";
+import { InternalScannerError } from "../scanner-error.js";
+const { fill } = doc.builders;
+function printCompoundStatement(path, print) {
+    let doc = [];
+    const statementsDoc = path.map(print, "statements");
+    doc = addIndentedStatements(doc, statementsDoc, path.call(print, "openBracePunctuator"), path.call(print, "closeBracePunctuator"));
+    return doc;
+}
+function printExpressionStatement(path, print) {
+    return fill([path.call(print, "expression"), path.call(print, "semicolonPunctuator")]);
+}
+export function printAbstractStatement(path, print) {
+    const abstractStatement = path.node;
+    const statementKind = abstractStatement.statementKind;
+    switch (statementKind) {
+        case StatementKind.ARRAY_DEFINITION:
+            return printArrayDefinition(path, print);
+        case StatementKind.COMPUTED_ARRAY_DEFINITION:
+            return printComputedArrayDefinition(path, print);
+        case StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION:
+            return printComputedElementaryTypeDefinition(path, print);
+        case StatementKind.CLASS_DECLARATION:
+            return printClassDeclaration(path, print);
+        case StatementKind.CLASS_DEFINITION:
+            return printClassDefinition(path, print);
+        case StatementKind.COMPOUND:
+            return printCompoundStatement(path, print);
+        case StatementKind.DO:
+            return printDoStatement(path, print);
+        case StatementKind.ELEMENTARY_TYPE_DEFINITION:
+            return printElementaryTypeDefinition(path, print);
+        case StatementKind.EXPRESSION:
+            return printExpressionStatement(path, print);
+        case StatementKind.FOR:
+            return printForStatement(path, print);
+        case StatementKind.IF:
+            return printIfStatement(path, print);
+        case StatementKind.MAP_DECLARATION:
+            return printMapDeclaration(path, print);
+        case StatementKind.MAP_DEFINITION:
+            return printMapDefinition(path, print);
+        case StatementKind.STRING_DEFINITION:
+            return printStringDefinition(path, print);
+        case StatementKind.SWITCH:
+            return printSwitchStatement(path, print);
+        case StatementKind.WHILE:
+            return printWhileStatement(path, print);
+        default: {
+            const exhaustiveCheck = statementKind;
+            throw new InternalScannerError("Unreachable code reached, statementKind == " + exhaustiveCheck);
+        }
+    }
+}

package/dist/src/prettier/print-aggregate-output-value.d.ts

@@ -0,0 +1,5 @@
+import type { AstPath, Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { AggregateOutputValue } from "../ast/node/aggregate-output-value.ts";
+export declare function printAggregateOutputValue(path: AstPath<AggregateOutputValue>, print: (path: AstPath<AbstractNode>) => Doc): doc.builders.Doc;
+//# sourceMappingURL=print-aggregate-output-value.d.ts.map

package/dist/src/prettier/print-aggregate-output-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-aggregate-output-value.d.ts","sourceRoot":"","sources":["../../../src/prettier/print-aggregate-output-value.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAGlF,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,OAAO,CAAC,oBAAoB,CAAC,EACnC,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,GAAG,GAC1C,GAAG,CAAC,QAAQ,CAAC,GAAG,CAgBlB"}

package/dist/src/prettier/print-aggregate-output-value.js

@@ -0,0 +1,11 @@
+import { addNonBreakingWhitespace, interleaveCommaSeparatorDocs } from "./util/print-utils.js";
+export function printAggregateOutputValue(path, print) {
+    const doc = [];
+    doc.push(path.call(print, "openBracePunctuator"));
+    addNonBreakingWhitespace(doc);
+    const outputValuesDoc = path.map(print, "outputValues");
+    doc.push(interleaveCommaSeparatorDocs(outputValuesDoc, path.map(print, "commaPunctuators")));
+    addNonBreakingWhitespace(doc);
+    doc.push(path.call(print, "closeBracePunctuator"));
+    return doc;
+}

package/dist/src/prettier/print-aligned-modifier.d.ts

@@ -0,0 +1,5 @@
+import type { AstPath, Doc } from "prettier";
+import type { AlignedModifier } from "../ast/node/aligned-modifier.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+export declare function printAlignedModifier(path: AstPath<AlignedModifier>, print: (path: AstPath<AbstractNode>) => Doc): Doc;
+//# sourceMappingURL=print-aligned-modifier.d.ts.map

package/dist/src/prettier/print-aligned-modifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-aligned-modifier.d.ts","sourceRoot":"","sources":["../../../src/prettier/print-aligned-modifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,EAC9B,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,GAAG,GAC1C,GAAG,CAiCL"}

package/dist/src/prettier/print-aligned-modifier.js

@@ -0,0 +1,16 @@
+export function printAlignedModifier(path, print) {
+    const alignedModifier = path.node;
+    const doc = [];
+    const d = path.call(print, "alignedKeyword");
+    doc.push(d);
+    if (alignedModifier.openParenthesisPunctuator) {
+        doc.push(path.call(print, "openParenthesisPunctuator"));
+    }
+    if (alignedModifier.bitCountModifierToken) {
+        doc.push(path.call(print, "bitCountModifierToken"));
+    }
+    if (alignedModifier.closeParenthesisPunctuator) {
+        doc.push(path.call(print, "closeParenthesisPunctuator"));
+    }
+    return doc;
+}

package/dist/src/prettier/print-array-definition.d.ts

@@ -0,0 +1,5 @@
+import { AstPath, type Doc } from "prettier";
+import type { ArrayDefinition } from "../ast/node/array-definition.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+export declare function printArrayDefinition(path: AstPath<ArrayDefinition>, print: (path: AstPath<AbstractNode>) => Doc): Doc;
+//# sourceMappingURL=print-array-definition.d.ts.map

package/dist/src/prettier/print-array-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-array-definition.d.ts","sourceRoot":"","sources":["../../../src/prettier/print-array-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,GAAG,EAAO,MAAM,UAAU,CAAC;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAIjE,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,EAC9B,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,GAAG,GAC1C,GAAG,CAgDL"}

package/dist/src/prettier/print-array-definition.js

@@ -0,0 +1,40 @@
+import { AstPath, doc } from "prettier";
+import { addBreakingWhitespace, addNonBreakingWhitespace } from "./util/print-utils.js";
+const { fill } = doc.builders;
+export function printArrayDefinition(path, print) {
+    const arrayDefinition = path.node;
+    let doc = [];
+    if (arrayDefinition.reservedKeyword) {
+        doc.push(path.call(print, "reservedKeyword"));
+        addNonBreakingWhitespace(doc);
+    }
+    if (arrayDefinition.legacyKeyword) {
+        doc.push(path.call(print, "legacyKeyword"));
+        addNonBreakingWhitespace(doc);
+    }
+    if (arrayDefinition.alignedModifier !== undefined) {
+        doc.push(path.call(print, "alignedModifier"));
+        addNonBreakingWhitespace(doc);
+    }
+    if (arrayDefinition.elementaryType !== undefined) {
+        const subDoc = [
+            path.call(print, "elementaryType"),
+            path.call(print, "lengthAttribute"),
+        ];
+        doc.push(subDoc);
+    }
+    else {
+        doc.push(path.call(print, "classIdentifier"));
+    }
+    doc = addBreakingWhitespace(doc);
+    const identifierClause = [path.call(print, "identifier")];
+    if (arrayDefinition.implicitArrayDimension) {
+        identifierClause.push(path.call(print, "implicitArrayDimension"));
+    }
+    if (arrayDefinition.dimensions) {
+        identifierClause.push(...path.map(print, "dimensions"));
+    }
+    identifierClause.push(path.call(print, "semicolonPunctuator"));
+    doc.push(identifierClause);
+    return fill(doc);
+}

package/dist/src/prettier/print-array-element-access.d.ts

@@ -0,0 +1,5 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ArrayElementAccess } from "../ast/node/array-element-access.ts";
+export declare function printArrayElementAccess(path: AstPath<ArrayElementAccess>, print: (path: AstPath<AbstractNode>) => Doc): Doc;
+//# sourceMappingURL=print-array-element-access.d.ts.map

package/dist/src/prettier/print-array-element-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-array-element-access.d.ts","sourceRoot":"","sources":["../../../src/prettier/print-array-element-access.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAE9E,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACjC,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,GAAG,GAC1C,GAAG,CAML"}

package/dist/src/prettier/print-array-element-access.js

@@ -0,0 +1,7 @@
+export function printArrayElementAccess(path, print) {
+    return [
+        path.call(print, "openBracketPunctuator"),
+        path.call(print, "index"),
+        path.call(print, "closeBracketPunctuator"),
+    ];
+}

package/dist/src/prettier/print-bit-modifier.d.ts

@@ -0,0 +1,5 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { BitModifier } from "../ast/node/bit-modifier.ts";
+export declare function printBitModifier(path: AstPath<BitModifier>, print: (path: AstPath<AbstractNode>) => Doc): Doc;
+//# sourceMappingURL=print-bit-modifier.d.ts.map

package/dist/src/prettier/print-bit-modifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print-bit-modifier.d.ts","sourceRoot":"","sources":["../../../src/prettier/print-bit-modifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG/D,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,EAC1B,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,GAAG,GAC1C,GAAG,CA0BL"}