@futpib/parser 1.0.3 → 1.0.6

package/build/javaScript.d.ts

@@ -0,0 +1,35 @@
+import type * as estree from 'estree';
+import { type StripMeta } from './javaScriptParser.js';
+export type JavaScriptProgram = StripMeta<estree.Program>;
+export type JavaScriptStatement = StripMeta<estree.Statement>;
+export type JavaScriptExpression = StripMeta<estree.Expression>;
+export type JavaScriptIdentifier = StripMeta<estree.Identifier>;
+export type JavaScriptLiteral = StripMeta<estree.Literal>;
+export type JavaScriptBlockStatement = StripMeta<estree.BlockStatement>;
+export type JavaScriptExpressionStatement = StripMeta<estree.ExpressionStatement>;
+export type JavaScriptVariableDeclaration = StripMeta<estree.VariableDeclaration>;
+export type JavaScriptVariableDeclarator = StripMeta<estree.VariableDeclarator>;
+export type JavaScriptIfStatement = StripMeta<estree.IfStatement>;
+export type JavaScriptWhileStatement = StripMeta<estree.WhileStatement>;
+export type JavaScriptForStatement = StripMeta<estree.ForStatement>;
+export type JavaScriptReturnStatement = StripMeta<estree.ReturnStatement>;
+export type JavaScriptThrowStatement = StripMeta<estree.ThrowStatement>;
+export type JavaScriptTryStatement = StripMeta<estree.TryStatement>;
+export type JavaScriptCatchClause = StripMeta<estree.CatchClause>;
+export type JavaScriptEmptyStatement = StripMeta<estree.EmptyStatement>;
+export type JavaScriptFunctionDeclaration = StripMeta<estree.FunctionDeclaration>;
+export type JavaScriptFunctionExpression = StripMeta<estree.FunctionExpression>;
+export type JavaScriptArrowFunctionExpression = StripMeta<estree.ArrowFunctionExpression>;
+export type JavaScriptBinaryExpression = StripMeta<estree.BinaryExpression>;
+export type JavaScriptLogicalExpression = StripMeta<estree.LogicalExpression>;
+export type JavaScriptUnaryExpression = StripMeta<estree.UnaryExpression>;
+export type JavaScriptUpdateExpression = StripMeta<estree.UpdateExpression>;
+export type JavaScriptAssignmentExpression = StripMeta<estree.AssignmentExpression>;
+export type JavaScriptConditionalExpression = StripMeta<estree.ConditionalExpression>;
+export type JavaScriptCallExpression = StripMeta<estree.SimpleCallExpression>;
+export type JavaScriptNewExpression = StripMeta<estree.NewExpression>;
+export type JavaScriptMemberExpression = StripMeta<estree.MemberExpression>;
+export type JavaScriptArrayExpression = StripMeta<estree.ArrayExpression>;
+export type JavaScriptObjectExpression = StripMeta<estree.ObjectExpression>;
+export type JavaScriptProperty = StripMeta<estree.Property>;
+export type JavaScriptThisExpression = StripMeta<estree.ThisExpression>;

package/build/javaScript.js

@@ -0,0 +1 @@
+export {};

package/build/javaScriptParser.d.ts

@@ -0,0 +1,9 @@
+import type * as estree from 'estree';
+import { type Parser } from './parser.js';
+type PositionalFields = 'loc' | 'range' | 'start' | 'end' | 'leadingComments' | 'trailingComments' | 'comments' | 'innerComments';
+export type StripMeta<T> = T extends Array<infer U> ? Array<StripMeta<U>> : T extends object ? {
+    [K in Exclude<keyof T, PositionalFields>]: StripMeta<T[K]>;
+} : T;
+export type JavaScriptProgram = StripMeta<estree.Program>;
+export declare const javaScriptProgramParser: Parser<JavaScriptProgram, string>;
+export {};

package/build/javaScriptParser.js

@@ -0,0 +1,34 @@
+import * as acorn from 'acorn';
+import { promiseCompose } from './promiseCompose.js';
+import { createRegExpParser } from './regexpParser.js';
+function stripMeta(node) {
+    if (node === null || node === undefined) {
+        return node;
+    }
+    if (typeof node !== 'object') {
+        return node;
+    }
+    if (Array.isArray(node)) {
+        return node.map(element => stripMeta(element));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'loc'
+            || key === 'range'
+            || key === 'start'
+            || key === 'end'
+            || key === 'raw'
+            || key === 'leadingComments'
+            || key === 'trailingComments'
+            || key === 'comments'
+            || key === 'innerComments') {
+            continue;
+        }
+        result[key] = stripMeta(value);
+    }
+    return result;
+}
+export const javaScriptProgramParser = promiseCompose(createRegExpParser(/[\s\S]*/), match => {
+    const ast = acorn.parse(match[0], { ecmaVersion: 'latest', sourceType: 'script' });
+    return stripMeta(ast);
+});

package/build/javaScriptUnparser.d.ts

@@ -0,0 +1,3 @@
+import { type Unparser } from './unparser.js';
+import { type JavaScriptProgram } from './javaScriptParser.js';
+export declare const javaScriptProgramUnparser: Unparser<JavaScriptProgram, string>;

package/build/javaScriptUnparser.js

@@ -0,0 +1,4 @@
+import { generate } from 'astring';
+export const javaScriptProgramUnparser = async function* (program) {
+    yield generate(program);
+};

package/build/javaScriptUnparser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/javaScriptUnparser.test.js

@@ -0,0 +1,24 @@
+import { testProp } from '@fast-check/ava';
+import { arbitraryJavaScriptProgram } from './arbitraryJavaScript.js';
+import { javaScriptProgramUnparser } from './javaScriptUnparser.js';
+import { javaScriptProgramParser } from './javaScriptParser.js';
+import { runParser } from './parser.js';
+import { runUnparser } from './unparser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+async function collectString(asyncIterable) {
+    let result = '';
+    for await (const chunk of asyncIterable) {
+        result += chunk;
+    }
+    return result;
+}
+testProp('javaScript roundtrip', [arbitraryJavaScriptProgram], async (t, program) => {
+    const source = await collectString(runUnparser(javaScriptProgramUnparser, program, stringUnparserOutputCompanion));
+    const reparsed = await runParser(javaScriptProgramParser, source, stringParserInputCompanion);
+    t.deepEqual(reparsed, program);
+}, {
+    verbose: true,
+    seed,
+});

package/build/javaUnparser.d.ts

@@ -0,0 +1,2 @@
+import { type Unparser } from './unparser.js';
+export declare const javaCompilationUnitUnparser: Unparser<unknown, string>;

package/build/javaUnparser.js

@@ -0,0 +1,519 @@
+import { escapeJavaString } from './stringEscapes.js';
+const binaryOperatorMap = {
+    PLUS: '+',
+    MINUS: '-',
+    MULTIPLY: '*',
+    DIVIDE: '/',
+    REMAINDER: '%',
+    LESS: '<',
+    GREATER: '>',
+    LESS_EQUALS: '<=',
+    GREATER_EQUALS: '>=',
+    EQUALS: '==',
+    NOT_EQUALS: '!=',
+    AND: '&&',
+    OR: '||',
+};
+const assignOperatorMap = {
+    ASSIGN: '=',
+    PLUS: '+=',
+    MINUS: '-=',
+    MULTIPLY: '*=',
+    DIVIDE: '/=',
+};
+const prefixUnaryOperatorMap = {
+    PREFIX_INCREMENT: '++',
+    PREFIX_DECREMENT: '--',
+    MINUS: '-',
+    PLUS: '+',
+    LOGICAL_COMPLEMENT: '!',
+};
+const postfixUnaryOperatorMap = {
+    POSTFIX_INCREMENT: '++',
+    POSTFIX_DECREMENT: '--',
+};
+const primitiveTypeMap = {
+    BOOLEAN: 'boolean',
+    BYTE: 'byte',
+    CHAR: 'char',
+    DOUBLE: 'double',
+    FLOAT: 'float',
+    INT: 'int',
+    LONG: 'long',
+    SHORT: 'short',
+};
+const modifierKeywordMap = {
+    PUBLIC: 'public',
+    PROTECTED: 'protected',
+    PRIVATE: 'private',
+    STATIC: 'static',
+    FINAL: 'final',
+    ABSTRACT: 'abstract',
+    SYNCHRONIZED: 'synchronized',
+    NATIVE: 'native',
+    TRANSIENT: 'transient',
+    VOLATILE: 'volatile',
+    STRICTFP: 'strictfp',
+    DEFAULT: 'default',
+    SEALED: 'sealed',
+    NON_SEALED: 'non-sealed',
+};
+function flattenName(name) {
+    if (name.qualifier) {
+        return flattenName(name.qualifier) + '.' + name.identifier;
+    }
+    return name.identifier;
+}
+function unparseType(node) {
+    switch (node.type) {
+        case 'PrimitiveType':
+            return primitiveTypeMap[node.type_];
+        case 'VoidType':
+            return 'void';
+        case 'ClassOrInterfaceType': {
+            let result = '';
+            if (node.scope) {
+                result = unparseType(node.scope) + '.';
+            }
+            result += node.name.identifier;
+            if (node.typeArguments) {
+                const typeArgs = node.typeArguments;
+                if (typeArgs.length === 0) {
+                    // Diamond is handled at the ObjectCreationExpr level
+                }
+                else {
+                    result += '<' + typeArgs.map(t => unparseType(t)).join(', ') + '>';
+                }
+            }
+            return result;
+        }
+        case 'ArrayType': {
+            // Unwind to base type + count brackets
+            let base = node;
+            let brackets = 0;
+            while (base.type === 'ArrayType') {
+                brackets++;
+                base = base.componentType;
+            }
+            return unparseType(base) + '[]'.repeat(brackets);
+        }
+        case 'WildcardType': {
+            let result = '?';
+            if (node.extendedType) {
+                result += ' extends ' + unparseType(node.extendedType);
+            }
+            if (node.superType) {
+                result += ' super ' + unparseType(node.superType);
+            }
+            return result;
+        }
+        case 'UnknownType':
+            return '';
+        default:
+            throw new Error(`Unknown type: ${node.type}`);
+    }
+}
+function unparseExpression(node) {
+    switch (node.type) {
+        case 'NameExpr':
+            return node.name.identifier;
+        case 'StringLiteralExpr':
+            return `"${escapeJavaString(node.value)}"`;
+        case 'IntegerLiteralExpr':
+            return node.value;
+        case 'NullLiteralExpr':
+            return 'null';
+        case 'BooleanLiteralExpr':
+            return node.value ? 'true' : 'false';
+        case 'ThisExpr':
+            return 'this';
+        case 'FieldAccessExpr':
+            return unparseExpression(node.scope) + '.' + node.name.identifier;
+        case 'ArrayAccessExpr':
+            return unparseExpression(node.name) + '[' + unparseExpression(node.index) + ']';
+        case 'MethodCallExpr': {
+            let result = '';
+            if (node.scope) {
+                result = unparseExpression(node.scope) + '.';
+            }
+            result += node.name.identifier;
+            result += '(' + node.arguments.map(a => unparseExpression(a)).join(', ') + ')';
+            return result;
+        }
+        case 'ObjectCreationExpr': {
+            const type_ = node.type_;
+            let result = 'new ' + unparseType(type_);
+            // Diamond operator
+            if (type_.typeArguments) {
+                const typeArgs = type_.typeArguments;
+                if (typeArgs.length === 0) {
+                    result += '<>';
+                }
+            }
+            result += '(' + node.arguments.map(a => unparseExpression(a)).join(', ') + ')';
+            return result;
+        }
+        case 'BinaryExpr':
+            return unparseExpression(node.left)
+                + ' ' + binaryOperatorMap[node.operator]
+                + ' ' + unparseExpression(node.right);
+        case 'UnaryExpr': {
+            const operator = node.operator;
+            if (prefixUnaryOperatorMap[operator]) {
+                return prefixUnaryOperatorMap[operator] + unparseExpression(node.expression);
+            }
+            if (postfixUnaryOperatorMap[operator]) {
+                return unparseExpression(node.expression) + postfixUnaryOperatorMap[operator];
+            }
+            throw new Error(`Unknown unary operator: ${operator}`);
+        }
+        case 'AssignExpr':
+            return unparseExpression(node.target)
+                + ' ' + assignOperatorMap[node.operator]
+                + ' ' + unparseExpression(node.value);
+        case 'ConditionalExpr':
+            return unparseExpression(node.condition)
+                + ' ? ' + unparseExpression(node.thenExpr)
+                + ' : ' + unparseExpression(node.elseExpr);
+        case 'CastExpr':
+            return '(' + unparseType(node.type_) + ') ' + unparseExpression(node.expression);
+        case 'EnclosedExpr':
+            return '(' + unparseExpression(node.inner) + ')';
+        case 'InstanceOfExpr':
+            return unparseExpression(node.expression)
+                + ' instanceof ' + unparseType(node.type_);
+        case 'LambdaExpr': {
+            const params = node.parameters;
+            const isEnclosing = node.isEnclosingParameters;
+            const body = node.body;
+            let paramStr;
+            if (isEnclosing) {
+                const paramParts = params.map(p => {
+                    const paramType = p.type_;
+                    const paramName = p.name.identifier;
+                    if (paramType.type === 'UnknownType') {
+                        return paramName;
+                    }
+                    return unparseType(paramType) + ' ' + paramName;
+                });
+                paramStr = '(' + paramParts.join(', ') + ')';
+            }
+            else {
+                paramStr = params[0].name.identifier;
+            }
+            let bodyStr;
+            if (body.type === 'BlockStmt') {
+                bodyStr = unparseBlockStmt(body);
+            }
+            else if (body.type === 'ExpressionStmt') {
+                bodyStr = unparseExpression(body.expression);
+            }
+            else {
+                bodyStr = unparseExpression(body);
+            }
+            return paramStr + ' -> ' + bodyStr;
+        }
+        case 'VariableDeclarationExpr':
+            return unparseVariableDeclarationExpr(node);
+        case 'MarkerAnnotationExpr':
+            return '@' + flattenName(node.name);
+        default:
+            throw new Error(`Unknown expression type: ${node.type}`);
+    }
+}
+function unparseVariableDeclarationExpr(node) {
+    const modifiers = node.modifiers;
+    const annotations = node.annotations;
+    const variables = node.variables;
+    let result = '';
+    for (const ann of annotations) {
+        result += unparseExpression(ann) + ' ';
+    }
+    for (const mod of modifiers) {
+        result += modifierKeywordMap[mod.keyword] + ' ';
+    }
+    // Type comes from first variable
+    const type_ = variables[0].type_;
+    result += unparseType(type_);
+    const varParts = variables.map(v => {
+        let varStr = ' ' + v.name.identifier;
+        if (v.initializer) {
+            varStr += ' = ' + unparseExpression(v.initializer);
+        }
+        return varStr;
+    });
+    result += varParts.join(',');
+    return result;
+}
+function unparseBlockStmt(node) {
+    const statements = node.statements;
+    if (statements.length === 0) {
+        return '{}';
+    }
+    return '{ ' + statements.map(s => unparseStatement(s)).join(' ') + ' }';
+}
+function unparseStatement(node) {
+    switch (node.type) {
+        case 'BlockStmt':
+            return unparseBlockStmt(node);
+        case 'ExpressionStmt':
+            return unparseExpression(node.expression) + ';';
+        case 'ReturnStmt': {
+            if (node.expression) {
+                return 'return ' + unparseExpression(node.expression) + ';';
+            }
+            return 'return;';
+        }
+        case 'ThrowStmt':
+            return 'throw ' + unparseExpression(node.expression) + ';';
+        case 'IfStmt': {
+            let result = 'if (' + unparseExpression(node.condition) + ') '
+                + unparseStatement(node.thenStmt);
+            if (node.elseStmt) {
+                result += ' else ' + unparseStatement(node.elseStmt);
+            }
+            return result;
+        }
+        case 'ForStmt': {
+            const init = node.initialization;
+            let initStr = '';
+            if (init.length > 0) {
+                initStr = init.map(i => unparseExpression(i)).join(', ');
+            }
+            let compareStr = '';
+            if (node.compare) {
+                compareStr = unparseExpression(node.compare);
+            }
+            const update = node.update;
+            const updateStr = update.map(u => unparseExpression(u)).join(', ');
+            return 'for (' + initStr + '; ' + compareStr + '; ' + updateStr + ') '
+                + unparseStatement(node.body);
+        }
+        case 'ForEachStmt':
+            return 'for (' + unparseVariableDeclarationExpr(node.variable) + ' : '
+                + unparseExpression(node.iterable) + ') '
+                + unparseStatement(node.body);
+        case 'TryStmt': {
+            const resources = node.resources;
+            let result = 'try';
+            if (resources.length > 0) {
+                result += ' (' + resources.map(r => unparseVariableDeclarationExpr(r)).join('; ') + ')';
+            }
+            result += ' ' + unparseBlockStmt(node.tryBlock);
+            const catchClauses = node.catchClauses;
+            for (const clause of catchClauses) {
+                const param = clause.parameter;
+                const paramType = param.type_;
+                const paramName = param.name.identifier;
+                result += ' catch (' + unparseType(paramType) + ' ' + paramName + ') '
+                    + unparseBlockStmt(clause.body);
+            }
+            if (node.finallyBlock) {
+                result += ' finally ' + unparseBlockStmt(node.finallyBlock);
+            }
+            return result;
+        }
+        case 'SwitchStmt': {
+            const entries = node.entries;
+            let result = 'switch (' + unparseExpression(node.selector) + ') {';
+            for (const entry of entries) {
+                const isDefault = entry.isDefault;
+                const labels = entry.labels;
+                const statements = entry.statements;
+                if (isDefault) {
+                    result += ' default:';
+                }
+                else {
+                    for (const label of labels) {
+                        result += ' case ' + unparseExpression(label) + ':';
+                    }
+                }
+                for (const stmt of statements) {
+                    result += ' ' + unparseStatement(stmt);
+                }
+            }
+            result += '}';
+            return result;
+        }
+        case 'ExplicitConstructorInvocationStmt': {
+            const keyword = node.isThis ? 'this' : 'super';
+            return keyword + '(' + node.arguments.map(a => unparseExpression(a)).join(', ') + ');';
+        }
+        default:
+            throw new Error(`Unknown statement type: ${node.type}`);
+    }
+}
+function unparseAnnotations(annotations) {
+    if (annotations.length === 0) {
+        return '';
+    }
+    return annotations.map(a => unparseExpression(a)).join(' ') + ' ';
+}
+function unparseModifiers(modifiers) {
+    if (modifiers.length === 0) {
+        return '';
+    }
+    return modifiers.map(m => modifierKeywordMap[m.keyword]).join(' ') + ' ';
+}
+function unparseParameter(param) {
+    let result = '';
+    result += unparseAnnotations(param.annotations);
+    result += unparseModifiers(param.modifiers);
+    const typeStr = unparseType(param.type_);
+    if (typeStr) {
+        result += typeStr;
+        if (param.isVarArgs) {
+            result += '...';
+        }
+        result += ' ';
+    }
+    result += param.name.identifier;
+    return result;
+}
+function unparseBodyDeclaration(node) {
+    switch (node.type) {
+        case 'FieldDeclaration': {
+            const variables = node.variables;
+            let result = unparseAnnotations(node.annotations);
+            result += unparseModifiers(node.modifiers);
+            result += unparseType(variables[0].type_);
+            const varParts = variables.map(v => {
+                let varStr = ' ' + v.name.identifier;
+                if (v.initializer) {
+                    varStr += ' = ' + unparseExpression(v.initializer);
+                }
+                return varStr;
+            });
+            result += varParts.join(',') + ';';
+            return result;
+        }
+        case 'MethodDeclaration': {
+            let result = unparseAnnotations(node.annotations);
+            result += unparseModifiers(node.modifiers);
+            const typeParams = node.typeParameters;
+            if (typeParams.length > 0) {
+                result += '<' + typeParams.map(tp => {
+                    let tpStr = tp.name.identifier;
+                    const bounds = tp.typeBound;
+                    if (bounds.length > 0) {
+                        tpStr += ' extends ' + bounds.map(b => unparseType(b)).join(' & ');
+                    }
+                    return tpStr;
+                }).join(', ') + '> ';
+            }
+            result += unparseType(node.type_) + ' ';
+            result += node.name.identifier;
+            result += '(' + node.parameters.map(p => unparseParameter(p)).join(', ') + ')';
+            const thrownExceptions = node.thrownExceptions;
+            if (thrownExceptions.length > 0) {
+                result += ' throws ' + thrownExceptions.map(e => unparseType(e)).join(', ');
+            }
+            if (node.body) {
+                result += ' ' + unparseBlockStmt(node.body);
+            }
+            else {
+                result += ';';
+            }
+            return result;
+        }
+        case 'ConstructorDeclaration': {
+            let result = unparseAnnotations(node.annotations);
+            result += unparseModifiers(node.modifiers);
+            result += node.name.identifier;
+            result += '(' + node.parameters.map(p => unparseParameter(p)).join(', ') + ')';
+            const thrownExceptions = node.thrownExceptions;
+            if (thrownExceptions.length > 0) {
+                result += ' throws ' + thrownExceptions.map(e => unparseType(e)).join(', ');
+            }
+            result += ' ' + unparseBlockStmt(node.body);
+            return result;
+        }
+        case 'ClassOrInterfaceDeclaration':
+        case 'EnumDeclaration':
+            return unparseTypeDeclaration(node);
+        default:
+            throw new Error(`Unknown body declaration type: ${node.type}`);
+    }
+}
+function unparseTypeDeclaration(node) {
+    switch (node.type) {
+        case 'ClassOrInterfaceDeclaration': {
+            let result = unparseAnnotations(node.annotations);
+            result += unparseModifiers(node.modifiers);
+            result += (node.isInterface ? 'interface' : 'class') + ' ';
+            result += node.name.identifier;
+            const typeParams = node.typeParameters;
+            if (typeParams.length > 0) {
+                result += '<' + typeParams.map(tp => {
+                    let tpStr = tp.name.identifier;
+                    const bounds = tp.typeBound;
+                    if (bounds.length > 0) {
+                        tpStr += ' extends ' + bounds.map(b => unparseType(b)).join(' & ');
+                    }
+                    return tpStr;
+                }).join(', ') + '>';
+            }
+            const extendedTypes = node.extendedTypes;
+            if (extendedTypes.length > 0) {
+                result += ' extends ' + extendedTypes.map(t => unparseType(t)).join(', ');
+            }
+            const implementedTypes = node.implementedTypes;
+            if (implementedTypes.length > 0) {
+                result += ' implements ' + implementedTypes.map(t => unparseType(t)).join(', ');
+            }
+            const members = node.members;
+            if (members.length === 0) {
+                result += ' {}';
+            }
+            else {
+                result += ' { ' + members.map(m => unparseBodyDeclaration(m)).join('\n') + ' }';
+            }
+            return result;
+        }
+        case 'EnumDeclaration': {
+            let result = unparseAnnotations(node.annotations);
+            result += unparseModifiers(node.modifiers);
+            result += 'enum ';
+            result += node.name.identifier;
+            result += ' {}';
+            return result;
+        }
+        default:
+            throw new Error(`Unknown type declaration type: ${node.type}`);
+    }
+}
+export const javaCompilationUnitUnparser = async function* (input) {
+    const cu = input;
+    let result = '';
+    // Package declaration
+    if (cu.packageDeclaration) {
+        const pkg = cu.packageDeclaration;
+        result += unparseAnnotations(pkg.annotations);
+        result += 'package ' + flattenName(pkg.name) + ';';
+    }
+    // Imports
+    const imports = cu.imports;
+    for (const imp of imports) {
+        if (result.length > 0) {
+            result += '\n';
+        }
+        result += 'import ';
+        if (imp.isStatic) {
+            result += 'static ';
+        }
+        result += flattenName(imp.name);
+        if (imp.isAsterisk) {
+            result += '.*';
+        }
+        result += ';';
+    }
+    // Types
+    const types = cu.types;
+    for (const type of types) {
+        if (result.length > 0) {
+            result += '\n';
+        }
+        result += unparseTypeDeclaration(type);
+    }
+    yield result;
+};

package/build/javaUnparser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/javaUnparser.test.js

@@ -0,0 +1,24 @@
+import { testProp } from '@fast-check/ava';
+import { arbitraryJavaCompilationUnit } from './arbitraryJava.js';
+import { javaCompilationUnitUnparser } from './javaUnparser.js';
+import { javaCompilationUnitParser } from './javaParser.js';
+import { runParser } from './parser.js';
+import { runUnparser } from './unparser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+async function collectString(asyncIterable) {
+    let result = '';
+    for await (const chunk of asyncIterable) {
+        result += chunk;
+    }
+    return result;
+}
+testProp('javaUnparser roundtrip', [arbitraryJavaCompilationUnit], async (t, compilationUnit) => {
+    const source = await collectString(runUnparser(javaCompilationUnitUnparser, compilationUnit, stringUnparserOutputCompanion));
+    const reparsed = await runParser(javaCompilationUnitParser, source, stringParserInputCompanion);
+    t.deepEqual(reparsed, compilationUnit);
+}, {
+    verbose: true,
+    seed,
+});