@futpib/parser 1.0.3 → 1.0.6

package/build/arbitraryJava.js

@@ -0,0 +1,532 @@
+import * as fc from 'fast-check';
+const javaKeywords = new Set([
+    'abstract', 'assert', 'boolean', 'break', 'byte', 'case', 'catch', 'char',
+    'class', 'const', 'continue', 'default', 'do', 'double', 'else', 'enum',
+    'extends', 'final', 'finally', 'float', 'for', 'goto', 'if', 'implements',
+    'import', 'instanceof', 'int', 'interface', 'long', 'native', 'new',
+    'package', 'private', 'protected', 'public', 'return', 'short', 'static',
+    'strictfp', 'super', 'switch', 'synchronized', 'this', 'throw', 'throws',
+    'transient', 'try', 'void', 'volatile', 'while', 'true', 'false', 'null',
+    'sealed', 'non-sealed', 'record', 'yield', 'var',
+]);
+const arbitraryJavaIdentifier = fc.stringMatching(/^[a-zA-Z_][a-zA-Z0-9_]*$/).filter(id => !javaKeywords.has(id));
+const arbitrarySimpleName = fc.record({
+    type: fc.constant('SimpleName'),
+    identifier: arbitraryJavaIdentifier,
+});
+const arbitraryName = fc.nat({ max: 2 }).chain(depth => {
+    if (depth === 0) {
+        return fc.record({
+            type: fc.constant('Name'),
+            identifier: arbitraryJavaIdentifier,
+        });
+    }
+    return arbitraryJavaIdentifier.chain(identifier => {
+        const buildQualifier = (d) => {
+            if (d === 0) {
+                return fc.record({
+                    type: fc.constant('Name'),
+                    identifier: arbitraryJavaIdentifier,
+                });
+            }
+            return fc.record({
+                type: fc.constant('Name'),
+                identifier: arbitraryJavaIdentifier,
+                qualifier: buildQualifier(d - 1),
+            });
+        };
+        return fc.record({
+            type: fc.constant('Name'),
+            identifier: fc.constant(identifier),
+            qualifier: buildQualifier(depth - 1),
+        });
+    });
+});
+// Types
+const arbitraryPrimitiveType = fc.record({
+    type: fc.constant('PrimitiveType'),
+    type_: fc.oneof(fc.constant('BOOLEAN'), fc.constant('BYTE'), fc.constant('CHAR'), fc.constant('DOUBLE'), fc.constant('FLOAT'), fc.constant('INT'), fc.constant('LONG'), fc.constant('SHORT')),
+    annotations: fc.constant([]),
+});
+const arbitraryVoidType = fc.record({
+    type: fc.constant('VoidType'),
+    annotations: fc.constant([]),
+});
+const arbitraryAnnotation = fc.record({
+    type: fc.constant('MarkerAnnotationExpr'),
+    name: arbitraryName,
+});
+const arbitraryClassOrInterfaceType = fc.nat({ max: 1 }).chain(depth => {
+    const buildType = (d) => {
+        if (d === 0) {
+            return fc.record({
+                type: fc.constant('ClassOrInterfaceType'),
+                name: arbitrarySimpleName,
+                annotations: fc.constant([]),
+            });
+        }
+        return fc.record({
+            type: fc.constant('ClassOrInterfaceType'),
+            scope: buildType(d - 1),
+            name: arbitrarySimpleName,
+            annotations: fc.constant([]),
+        });
+    };
+    return buildType(depth);
+});
+// ClassOrInterfaceType with optional type arguments (for extends/implements)
+const arbitraryClassOrInterfaceTypeWithTypeArgs = fc.nat({ max: 1 }).chain(depth => {
+    const buildType = (d) => {
+        const baseFields = {
+            type: fc.constant('ClassOrInterfaceType'),
+            name: arbitrarySimpleName,
+            annotations: fc.constant([]),
+        };
+        if (d === 0) {
+            return fc.oneof(fc.record(baseFields), fc.record({
+                ...baseFields,
+                typeArguments: fc.array(fc.oneof(arbitraryPrimitiveType, fc.record({
+                    type: fc.constant('ClassOrInterfaceType'),
+                    name: arbitrarySimpleName,
+                    annotations: fc.constant([]),
+                }), fc.record({
+                    type: fc.constant('WildcardType'),
+                    annotations: fc.constant([]),
+                })), { minLength: 1, maxLength: 2 }),
+            }));
+        }
+        return fc.record({
+            ...baseFields,
+            scope: buildType(d - 1),
+        });
+    };
+    return buildType(depth);
+});
+const arbitraryNonArrayType = fc.oneof(arbitraryPrimitiveType, arbitraryClassOrInterfaceType);
+const arbitraryType = fc.oneof({ weight: 3, arbitrary: arbitraryNonArrayType }, {
+    weight: 1,
+    arbitrary: arbitraryNonArrayType.map(componentType => ({
+        type: 'ArrayType',
+        componentType,
+        origin: 'TYPE',
+        annotations: [],
+    })),
+});
+const arbitraryReturnType = fc.oneof({ weight: 3, arbitrary: arbitraryType }, { weight: 1, arbitrary: arbitraryVoidType });
+// Leaf expressions (used as operands in compound expressions to avoid precedence issues)
+const arbitraryNameExpr = fc.record({
+    type: fc.constant('NameExpr'),
+    name: arbitrarySimpleName,
+});
+const arbitraryStringLiteralExpr = fc.record({
+    type: fc.constant('StringLiteralExpr'),
+    value: fc.oneof(fc.stringMatching(/^[a-zA-Z0-9 ]*$/), fc.constantFrom('hello\nworld', 'tab\there', 'back\\slash', 'quote\ttab\nnewline')),
+});
+const arbitraryIntegerLiteralExpr = fc.record({
+    type: fc.constant('IntegerLiteralExpr'),
+    value: fc.nat({ max: 999 }).map(n => String(n)),
+});
+const arbitraryNullLiteralExpr = fc.record({
+    type: fc.constant('NullLiteralExpr'),
+});
+const arbitraryBooleanLiteralExpr = fc.record({
+    type: fc.constant('BooleanLiteralExpr'),
+    value: fc.boolean(),
+});
+const arbitraryThisExpr = fc.record({
+    type: fc.constant('ThisExpr'),
+});
+const arbitraryLeafExpression = fc.oneof(arbitraryNameExpr, arbitraryStringLiteralExpr, arbitraryIntegerLiteralExpr, arbitraryNullLiteralExpr, arbitraryBooleanLiteralExpr, arbitraryThisExpr);
+// Compound expressions (only use leaf operands)
+const arbitraryMethodCallExpr = fc.oneof(
+// Without scope
+fc.record({
+    type: fc.constant('MethodCallExpr'),
+    name: arbitrarySimpleName,
+    arguments: fc.array(arbitraryLeafExpression, { maxLength: 2 }),
+}), 
+// With scope
+fc.record({
+    type: fc.constant('MethodCallExpr'),
+    scope: arbitraryLeafExpression,
+    name: arbitrarySimpleName,
+    arguments: fc.array(arbitraryLeafExpression, { maxLength: 2 }),
+}));
+const arbitraryFieldAccessExpr = fc.record({
+    type: fc.constant('FieldAccessExpr'),
+    scope: arbitraryLeafExpression,
+    name: arbitrarySimpleName,
+});
+const arbitraryEnclosedExpr = fc.record({
+    type: fc.constant('EnclosedExpr'),
+    inner: arbitraryLeafExpression,
+});
+const arbitraryArrayAccessExpr = fc.record({
+    type: fc.constant('ArrayAccessExpr'),
+    name: arbitraryLeafExpression,
+    index: arbitraryLeafExpression,
+});
+const arbitraryObjectCreationExpr = fc.oneof(fc.record({
+    type: fc.constant('ObjectCreationExpr'),
+    type_: arbitraryClassOrInterfaceType,
+    arguments: fc.array(arbitraryLeafExpression, { maxLength: 2 }),
+}), 
+// With diamond operator (empty typeArguments)
+fc.record({
+    type: fc.constant('ObjectCreationExpr'),
+    type_: arbitraryClassOrInterfaceType.map(t => ({
+        ...t,
+        typeArguments: [],
+    })),
+    arguments: fc.array(arbitraryLeafExpression, { maxLength: 2 }),
+}));
+const arbitraryPrimaryExpression = fc.oneof(arbitraryLeafExpression, arbitraryMethodCallExpr, arbitraryFieldAccessExpr, arbitraryEnclosedExpr, arbitraryArrayAccessExpr, arbitraryObjectCreationExpr);
+const arbitraryBinaryOperator = fc.oneof(fc.constant('PLUS'), fc.constant('MINUS'), fc.constant('MULTIPLY'), fc.constant('DIVIDE'), fc.constant('REMAINDER'), fc.constant('LESS'), fc.constant('GREATER'), fc.constant('LESS_EQUALS'), fc.constant('GREATER_EQUALS'), fc.constant('EQUALS'), fc.constant('NOT_EQUALS'), fc.constant('AND'), fc.constant('OR'));
+const arbitraryBinaryExpr = fc.record({
+    type: fc.constant('BinaryExpr'),
+    left: arbitraryLeafExpression,
+    right: arbitraryLeafExpression,
+    operator: arbitraryBinaryOperator,
+});
+// UnaryExpr in parser output has NO prefix field - operator encodes prefix/postfix
+const arbitraryUnaryExpr = fc.record({
+    type: fc.constant('UnaryExpr'),
+    operator: fc.oneof(fc.constant('PREFIX_INCREMENT'), fc.constant('PREFIX_DECREMENT'), fc.constant('POSTFIX_INCREMENT'), fc.constant('POSTFIX_DECREMENT'), fc.constant('MINUS'), fc.constant('PLUS'), fc.constant('LOGICAL_COMPLEMENT')),
+    expression: arbitraryLeafExpression,
+});
+const arbitraryAssignOperator = fc.oneof(fc.constant('ASSIGN'), fc.constant('PLUS'), fc.constant('MINUS'), fc.constant('MULTIPLY'), fc.constant('DIVIDE'));
+const arbitraryAssignExpr = fc.record({
+    type: fc.constant('AssignExpr'),
+    target: arbitraryNameExpr,
+    value: arbitraryLeafExpression,
+    operator: arbitraryAssignOperator,
+});
+const arbitraryConditionalExpr = fc.record({
+    type: fc.constant('ConditionalExpr'),
+    condition: arbitraryLeafExpression,
+    thenExpr: arbitraryLeafExpression,
+    elseExpr: arbitraryLeafExpression,
+});
+const arbitraryCastExpr = fc.record({
+    type: fc.constant('CastExpr'),
+    type_: arbitraryType,
+    expression: arbitraryPrimaryExpression,
+});
+const arbitraryInstanceOfExpr = fc.record({
+    type: fc.constant('InstanceOfExpr'),
+    expression: arbitraryLeafExpression,
+    type_: fc.oneof(arbitraryClassOrInterfaceType, arbitraryNonArrayType.map(componentType => ({
+        type: 'ArrayType',
+        componentType,
+        origin: 'TYPE',
+        annotations: [],
+    }))),
+});
+// Lambda expressions
+const arbitraryLambdaExpr = fc.oneof(
+// With parenthesized params
+fc.record({
+    type: fc.constant('LambdaExpr'),
+    parameters: fc.array(fc.record({
+        type: fc.constant('Parameter'),
+        annotations: fc.constant([]),
+        modifiers: fc.constant([]),
+        isVarArgs: fc.constant(false),
+        varArgsAnnotations: fc.constant([]),
+        name: arbitrarySimpleName,
+        type_: fc.constant({ type: 'UnknownType', annotations: [] }),
+    }), { maxLength: 2 }),
+    body: fc.oneof(
+    // Expression body (wrapped in ExpressionStmt)
+    arbitraryLeafExpression.map(expr => ({
+        type: 'ExpressionStmt',
+        expression: expr,
+    })), 
+    // Block body
+    fc.constant({ type: 'BlockStmt', statements: [] })),
+    isEnclosingParameters: fc.constant(true),
+}), 
+// Single unparenthesized param
+fc.record({
+    type: fc.constant('LambdaExpr'),
+    parameters: arbitrarySimpleName.map(name => ([{
+            type: 'Parameter',
+            annotations: [],
+            modifiers: [],
+            isVarArgs: false,
+            varArgsAnnotations: [],
+            name,
+            type_: { type: 'UnknownType', annotations: [] },
+        }])),
+    body: fc.oneof(arbitraryLeafExpression.map(expr => ({
+        type: 'ExpressionStmt',
+        expression: expr,
+    })), fc.constant({ type: 'BlockStmt', statements: [] })),
+    isEnclosingParameters: fc.constant(false),
+}));
+const arbitraryExpression = fc.oneof({ weight: 4, arbitrary: arbitraryLeafExpression }, { weight: 1, arbitrary: arbitraryBinaryExpr }, { weight: 1, arbitrary: arbitraryUnaryExpr }, { weight: 1, arbitrary: arbitraryAssignExpr }, { weight: 1, arbitrary: arbitraryConditionalExpr }, { weight: 1, arbitrary: arbitraryCastExpr }, { weight: 1, arbitrary: arbitraryEnclosedExpr }, { weight: 1, arbitrary: arbitraryMethodCallExpr }, { weight: 1, arbitrary: arbitraryFieldAccessExpr }, { weight: 1, arbitrary: arbitraryObjectCreationExpr }, { weight: 1, arbitrary: arbitraryArrayAccessExpr }, { weight: 1, arbitrary: arbitraryInstanceOfExpr }, { weight: 1, arbitrary: arbitraryLambdaExpr });
+// Variable declarations
+const arbitraryVariableDeclarator = fc.record({
+    type: fc.constant('VariableDeclarator'),
+    name: arbitrarySimpleName,
+    type_: arbitraryType,
+}).chain(base => fc.oneof(fc.constant(base), arbitraryLeafExpression.map(init => ({
+    ...base,
+    initializer: init,
+}))));
+const arbitraryVariableDeclarationExpr = arbitraryType.chain(type_ => fc.record({
+    type: fc.constant('VariableDeclarationExpr'),
+    modifiers: fc.constant([]),
+    annotations: fc.constant([]),
+    variables: fc.array(fc.record({
+        type: fc.constant('VariableDeclarator'),
+        name: arbitrarySimpleName,
+        type_: fc.constant(type_),
+    }).chain(base => fc.oneof(fc.constant(base), arbitraryLeafExpression.map(init => ({
+        ...base,
+        initializer: init,
+    })))), { minLength: 1, maxLength: 2 }),
+}));
+// Statements
+const arbitraryBlockStmt = fc.record({
+    type: fc.constant('BlockStmt'),
+    statements: fc.constant([]),
+});
+const arbitraryExpressionStmt = fc.record({
+    type: fc.constant('ExpressionStmt'),
+    expression: arbitraryExpression,
+});
+const arbitraryReturnStmt = fc.oneof(fc.constant({ type: 'ReturnStmt' }), fc.record({
+    type: fc.constant('ReturnStmt'),
+    expression: arbitraryExpression,
+}));
+const arbitraryThrowStmt = fc.record({
+    type: fc.constant('ThrowStmt'),
+    expression: arbitraryExpression,
+});
+const arbitraryIfStmt = fc.oneof(fc.record({
+    type: fc.constant('IfStmt'),
+    condition: arbitraryExpression,
+    thenStmt: arbitraryBlockStmt,
+}), fc.record({
+    type: fc.constant('IfStmt'),
+    condition: arbitraryExpression,
+    thenStmt: arbitraryBlockStmt,
+    elseStmt: arbitraryBlockStmt,
+}));
+const arbitraryForStmt = fc.oneof(
+// Empty for
+fc.record({
+    type: fc.constant('ForStmt'),
+    initialization: fc.constant([]),
+    update: fc.constant([]),
+    body: arbitraryBlockStmt,
+}), 
+// For with init and compare
+fc.record({
+    type: fc.constant('ForStmt'),
+    initialization: fc.array(arbitraryVariableDeclarationExpr, { minLength: 1, maxLength: 1 }),
+    compare: arbitraryExpression,
+    update: fc.array(arbitraryExpression, { maxLength: 2 }),
+    body: arbitraryBlockStmt,
+}));
+const arbitraryForEachStmt = fc.record({
+    type: fc.constant('ForEachStmt'),
+    variable: arbitraryVariableDeclarationExpr,
+    iterable: arbitraryExpression,
+    body: arbitraryBlockStmt,
+});
+const arbitraryParameter = fc.record({
+    type: fc.constant('Parameter'),
+    modifiers: fc.constant([]),
+    annotations: fc.constant([]),
+    type_: arbitraryType,
+    isVarArgs: fc.constant(false),
+    varArgsAnnotations: fc.constant([]),
+    name: arbitrarySimpleName,
+});
+const arbitraryCatchClause = fc.record({
+    type: fc.constant('CatchClause'),
+    parameter: arbitraryParameter,
+    body: fc.record({
+        type: fc.constant('BlockStmt'),
+        statements: fc.constant([]),
+    }),
+});
+const arbitraryTryStmt = fc.oneof(
+// try-catch
+fc.record({
+    type: fc.constant('TryStmt'),
+    resources: fc.constant([]),
+    tryBlock: fc.record({
+        type: fc.constant('BlockStmt'),
+        statements: fc.constant([]),
+    }),
+    catchClauses: fc.array(arbitraryCatchClause, { minLength: 1, maxLength: 2 }),
+}), 
+// try-catch-finally
+fc.record({
+    type: fc.constant('TryStmt'),
+    resources: fc.constant([]),
+    tryBlock: fc.record({
+        type: fc.constant('BlockStmt'),
+        statements: fc.constant([]),
+    }),
+    catchClauses: fc.array(arbitraryCatchClause, { maxLength: 1 }),
+    finallyBlock: fc.record({
+        type: fc.constant('BlockStmt'),
+        statements: fc.constant([]),
+    }),
+}), 
+// try-with-resources
+fc.record({
+    type: fc.constant('TryStmt'),
+    resources: fc.array(arbitraryVariableDeclarationExpr, { minLength: 1, maxLength: 1 }),
+    tryBlock: fc.record({
+        type: fc.constant('BlockStmt'),
+        statements: fc.constant([]),
+    }),
+    catchClauses: fc.constant([]),
+}));
+const arbitrarySwitchEntry = fc.oneof(
+// case
+fc.record({
+    type: fc.constant('SwitchEntry'),
+    isDefault: fc.constant(false),
+    labels: fc.array(arbitraryExpression, { minLength: 1, maxLength: 1 }),
+    statements: fc.constant([]),
+    type_: fc.constant('STATEMENT_GROUP'),
+}), 
+// default
+fc.record({
+    type: fc.constant('SwitchEntry'),
+    isDefault: fc.constant(true),
+    labels: fc.constant([]),
+    statements: fc.constant([]),
+    type_: fc.constant('STATEMENT_GROUP'),
+}));
+const arbitrarySwitchStmt = fc.record({
+    type: fc.constant('SwitchStmt'),
+    selector: arbitraryExpression,
+    entries: fc.array(arbitrarySwitchEntry, { maxLength: 3 }),
+});
+const arbitraryExplicitConstructorInvocationStmt = fc.record({
+    type: fc.constant('ExplicitConstructorInvocationStmt'),
+    isThis: fc.boolean(),
+    arguments: fc.array(arbitraryLeafExpression, { maxLength: 2 }),
+});
+const arbitraryLocalVarDeclStmt = fc.record({
+    type: fc.constant('ExpressionStmt'),
+    expression: arbitraryVariableDeclarationExpr,
+});
+const arbitraryStatement = fc.oneof({ weight: 2, arbitrary: arbitraryBlockStmt }, { weight: 2, arbitrary: arbitraryExpressionStmt }, { weight: 2, arbitrary: arbitraryReturnStmt }, { weight: 1, arbitrary: arbitraryThrowStmt }, { weight: 1, arbitrary: arbitraryIfStmt }, { weight: 1, arbitrary: arbitraryForStmt }, { weight: 1, arbitrary: arbitraryForEachStmt }, { weight: 1, arbitrary: arbitraryTryStmt }, { weight: 1, arbitrary: arbitrarySwitchStmt }, { weight: 1, arbitrary: arbitraryExplicitConstructorInvocationStmt }, { weight: 1, arbitrary: arbitraryLocalVarDeclStmt });
+// Body declarations
+const arbitraryModifier = fc.record({
+    type: fc.constant('Modifier'),
+    keyword: fc.oneof(fc.constant('PUBLIC'), fc.constant('PROTECTED'), fc.constant('PRIVATE'), fc.constant('STATIC'), fc.constant('FINAL'), fc.constant('ABSTRACT')),
+});
+const arbitraryFieldDeclaration = arbitraryType.chain(type_ => fc.record({
+    type: fc.constant('FieldDeclaration'),
+    modifiers: fc.array(arbitraryModifier, { maxLength: 2 }),
+    annotations: fc.array(arbitraryAnnotation, { maxLength: 1 }),
+    variables: fc.array(fc.record({
+        type: fc.constant('VariableDeclarator'),
+        name: arbitrarySimpleName,
+        type_: fc.constant(type_),
+    }).chain(base => fc.oneof(fc.constant(base), arbitraryLeafExpression.map(init => ({
+        ...base,
+        initializer: init,
+    })))), { minLength: 1, maxLength: 2 }),
+}));
+const arbitraryMethodDeclaration = fc.oneof(
+// Method with body
+fc.record({
+    type: fc.constant('MethodDeclaration'),
+    modifiers: fc.array(arbitraryModifier, { maxLength: 2 }),
+    annotations: fc.array(arbitraryAnnotation, { maxLength: 1 }),
+    typeParameters: fc.constant([]),
+    type_: arbitraryReturnType,
+    name: arbitrarySimpleName,
+    parameters: fc.array(arbitraryParameter, { maxLength: 2 }),
+    thrownExceptions: fc.constant([]),
+    body: fc.record({
+        type: fc.constant('BlockStmt'),
+        statements: fc.array(arbitraryStatement, { maxLength: 2 }),
+    }),
+}), 
+// Abstract method (no body)
+fc.record({
+    type: fc.constant('MethodDeclaration'),
+    modifiers: fc.array(arbitraryModifier, { maxLength: 2 }),
+    annotations: fc.array(arbitraryAnnotation, { maxLength: 1 }),
+    typeParameters: fc.constant([]),
+    type_: arbitraryReturnType,
+    name: arbitrarySimpleName,
+    parameters: fc.array(arbitraryParameter, { maxLength: 2 }),
+    thrownExceptions: fc.constant([]),
+}));
+const arbitraryConstructorDeclaration = fc.record({
+    type: fc.constant('ConstructorDeclaration'),
+    modifiers: fc.array(arbitraryModifier, { maxLength: 1 }),
+    annotations: fc.constant([]),
+    typeParameters: fc.constant([]),
+    name: arbitrarySimpleName,
+    parameters: fc.array(arbitraryParameter, { maxLength: 2 }),
+    thrownExceptions: fc.constant([]),
+    body: fc.record({
+        type: fc.constant('BlockStmt'),
+        statements: fc.array(arbitraryStatement, { maxLength: 2 }),
+    }),
+});
+const arbitraryBodyDeclaration = fc.oneof({ weight: 2, arbitrary: arbitraryFieldDeclaration }, { weight: 2, arbitrary: arbitraryMethodDeclaration }, { weight: 1, arbitrary: arbitraryConstructorDeclaration });
+// Type declarations
+const arbitraryEnumDeclaration = fc.record({
+    type: fc.constant('EnumDeclaration'),
+    modifiers: fc.array(arbitraryModifier, { maxLength: 2 }),
+    annotations: fc.array(arbitraryAnnotation, { maxLength: 1 }),
+    name: arbitrarySimpleName,
+    implementedTypes: fc.constant([]),
+    entries: fc.constant([]),
+    members: fc.constant([]),
+});
+const arbitraryClassOrInterfaceDeclaration = fc.boolean().chain(isInterface => fc.record({
+    type: fc.constant('ClassOrInterfaceDeclaration'),
+    modifiers: fc.array(arbitraryModifier, { maxLength: 2 }),
+    annotations: fc.array(arbitraryAnnotation, { maxLength: 1 }),
+    name: arbitrarySimpleName,
+    isInterface: fc.constant(isInterface),
+    typeParameters: fc.oneof(fc.constant([]), fc.array(fc.record({
+        type: fc.constant('TypeParameter'),
+        annotations: fc.constant([]),
+        name: arbitrarySimpleName,
+        typeBound: fc.constant([]),
+    }), { minLength: 1, maxLength: 2 })),
+    extendedTypes: fc.oneof(fc.constant([]), fc.array(arbitraryClassOrInterfaceTypeWithTypeArgs, { minLength: 1, maxLength: 1 })),
+    // Interfaces always have implementedTypes: [] (parser outputs empty array for interfaces)
+    implementedTypes: isInterface
+        ? fc.constant([])
+        : fc.oneof(fc.constant([]), fc.array(arbitraryClassOrInterfaceTypeWithTypeArgs, { minLength: 1, maxLength: 2 })),
+    permittedTypes: fc.constant([]),
+    members: fc.array(arbitraryBodyDeclaration, { maxLength: 3 }),
+}));
+const arbitraryTypeDeclaration = fc.oneof({ weight: 3, arbitrary: arbitraryClassOrInterfaceDeclaration }, { weight: 1, arbitrary: arbitraryEnumDeclaration });
+// Import declaration
+const arbitraryImportDeclaration = fc.record({
+    type: fc.constant('ImportDeclaration'),
+    isStatic: fc.boolean(),
+    isAsterisk: fc.boolean(),
+    name: arbitraryName,
+});
+// Package declaration
+const arbitraryPackageDeclaration = fc.record({
+    type: fc.constant('PackageDeclaration'),
+    annotations: fc.array(arbitraryAnnotation, { maxLength: 1 }),
+    name: arbitraryName,
+});
+// Compilation unit
+export const arbitraryJavaCompilationUnit = fc.record({
+    type: fc.constant('CompilationUnit'),
+    packageDeclaration: fc.option(arbitraryPackageDeclaration, { nil: undefined }),
+    imports: fc.array(arbitraryImportDeclaration, { maxLength: 2 }),
+    types: fc.array(arbitraryTypeDeclaration, { minLength: 1, maxLength: 2 }),
+});

package/build/arbitraryJavaScript.d.ts

@@ -0,0 +1,3 @@
+import * as fc from 'fast-check';
+import { type JavaScriptProgram } from './javaScriptParser.js';
+export declare const arbitraryJavaScriptProgram: fc.Arbitrary<JavaScriptProgram>;