@futpib/parser 1.0.4 → 1.0.6

package/build/arbitraryJavaScript.js

@@ -0,0 +1,263 @@
+import * as fc from 'fast-check';
+const jsKeywords = new Set([
+    'abstract', 'arguments', 'await', 'boolean', 'break', 'byte', 'case', 'catch',
+    'char', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do',
+    'double', 'else', 'enum', 'eval', 'export', 'extends', 'false', 'final',
+    'finally', 'float', 'for', 'function', 'goto', 'if', 'implements', 'import',
+    'in', 'instanceof', 'int', 'interface', 'let', 'long', 'native', 'new',
+    'null', 'package', 'private', 'protected', 'public', 'return', 'short',
+    'static', 'super', 'switch', 'synchronized', 'this', 'throw', 'throws',
+    'transient', 'true', 'try', 'typeof', 'var', 'void', 'volatile', 'while',
+    'with', 'yield', 'undefined', 'NaN', 'Infinity',
+]);
+const arbitraryIdentifierName = fc.stringMatching(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/).filter(id => !jsKeywords.has(id));
+const arbitraryIdentifier = fc.record({
+    type: fc.constant('Identifier'),
+    name: arbitraryIdentifierName,
+});
+const arbitraryStringLiteral = fc.record({
+    type: fc.constant('Literal'),
+    value: fc.stringMatching(/^[a-zA-Z0-9 ]*$/),
+});
+const arbitraryNumberLiteral = fc.record({
+    type: fc.constant('Literal'),
+    value: fc.integer({ min: 0, max: 999 }),
+});
+const arbitraryBooleanLiteral = fc.record({
+    type: fc.constant('Literal'),
+    value: fc.boolean(),
+});
+const arbitraryNullLiteral = fc.record({
+    type: fc.constant('Literal'),
+    value: fc.constant(null),
+});
+const arbitraryThisExpression = fc.record({
+    type: fc.constant('ThisExpression'),
+});
+const arbitraryLeafExpression = fc.oneof(arbitraryIdentifier, arbitraryStringLiteral, arbitraryNumberLiteral, arbitraryBooleanLiteral, arbitraryNullLiteral, arbitraryThisExpression);
+const safeBinaryOperators = [
+    '==', '!=', '===', '!==', '<', '<=', '>', '>=',
+    '<<', '>>', '>>>',
+    '+', '-', '*', '/', '%', '**',
+    '|', '^', '&',
+    'instanceof',
+];
+const arbitraryBinaryExpression = fc.record({
+    type: fc.constant('BinaryExpression'),
+    operator: fc.oneof(...safeBinaryOperators.map(op => fc.constant(op))),
+    left: arbitraryLeafExpression,
+    right: arbitraryLeafExpression,
+});
+const arbitraryLogicalExpression = fc.record({
+    type: fc.constant('LogicalExpression'),
+    operator: fc.oneof(fc.constant('||'), fc.constant('&&'), fc.constant('??')),
+    left: arbitraryLeafExpression,
+    right: arbitraryLeafExpression,
+});
+const safeUnaryOperators = [
+    '-', '+', '!', '~', 'typeof', 'void',
+];
+const arbitraryUnaryExpression = fc.record({
+    type: fc.constant('UnaryExpression'),
+    operator: fc.oneof(...safeUnaryOperators.map(op => fc.constant(op))),
+    prefix: fc.constant(true),
+    argument: arbitraryLeafExpression,
+});
+const arbitraryUpdateExpression = fc.record({
+    type: fc.constant('UpdateExpression'),
+    operator: fc.oneof(fc.constant('++'), fc.constant('--')),
+    argument: arbitraryIdentifier,
+    prefix: fc.boolean(),
+});
+const arbitraryAssignmentExpression = fc.record({
+    type: fc.constant('AssignmentExpression'),
+    operator: fc.constant('='),
+    left: arbitraryIdentifier,
+    right: arbitraryLeafExpression,
+});
+const arbitraryConditionalExpression = fc.record({
+    type: fc.constant('ConditionalExpression'),
+    test: arbitraryLeafExpression,
+    consequent: arbitraryLeafExpression,
+    alternate: arbitraryLeafExpression,
+});
+const arbitraryCallExpression = fc.record({
+    type: fc.constant('CallExpression'),
+    callee: arbitraryIdentifier,
+    arguments: fc.array(arbitraryLeafExpression, { minLength: 0, maxLength: 3 }),
+    optional: fc.constant(false),
+});
+const arbitraryMemberExpression = fc.record({
+    type: fc.constant('MemberExpression'),
+    object: arbitraryIdentifier,
+    property: arbitraryIdentifier,
+    computed: fc.constant(false),
+    optional: fc.constant(false),
+});
+const arbitraryArrayExpression = fc.record({
+    type: fc.constant('ArrayExpression'),
+    elements: fc.array(arbitraryLeafExpression, { minLength: 0, maxLength: 3 }),
+});
+const arbitraryProperty = fc.record({
+    type: fc.constant('Property'),
+    key: arbitraryIdentifier,
+    value: arbitraryLeafExpression,
+    kind: fc.constant('init'),
+    method: fc.constant(false),
+    shorthand: fc.constant(false),
+    computed: fc.constant(false),
+});
+const arbitraryObjectExpression = fc.record({
+    type: fc.constant('ObjectExpression'),
+    properties: fc.array(arbitraryProperty, { minLength: 0, maxLength: 3 }),
+});
+const arbitraryNewExpression = fc.record({
+    type: fc.constant('NewExpression'),
+    callee: arbitraryIdentifier,
+    arguments: fc.array(arbitraryLeafExpression, { minLength: 0, maxLength: 3 }),
+});
+const arbitraryExpression = fc.oneof({ weight: 5, arbitrary: arbitraryLeafExpression }, { weight: 2, arbitrary: arbitraryBinaryExpression }, { weight: 2, arbitrary: arbitraryLogicalExpression }, { weight: 2, arbitrary: arbitraryUnaryExpression }, { weight: 1, arbitrary: arbitraryUpdateExpression }, { weight: 1, arbitrary: arbitraryAssignmentExpression }, { weight: 1, arbitrary: arbitraryConditionalExpression }, { weight: 2, arbitrary: arbitraryCallExpression }, { weight: 1, arbitrary: arbitraryMemberExpression }, { weight: 1, arbitrary: arbitraryArrayExpression }, { weight: 1, arbitrary: arbitraryObjectExpression }, { weight: 1, arbitrary: arbitraryNewExpression });
+const arbitraryExpressionStatement = arbitraryExpression
+    .filter(expr => {
+    if (expr.type === 'Literal' && typeof expr.value === 'string') {
+        return false;
+    }
+    if (expr.type === 'ObjectExpression') {
+        return false;
+    }
+    return true;
+})
+    .map(expression => ({
+    type: 'ExpressionStatement',
+    expression,
+}));
+const arbitraryVariableDeclaration = fc.record({
+    type: fc.constant('VariableDeclaration'),
+    kind: fc.constant('var'),
+    declarations: fc.array(fc.record({
+        type: fc.constant('VariableDeclarator'),
+        id: arbitraryIdentifier,
+        init: fc.oneof(fc.constant(null), arbitraryLeafExpression),
+    }), { minLength: 1, maxLength: 3 }),
+});
+const arbitraryReturnStatement = fc.record({
+    type: fc.constant('ReturnStatement'),
+    argument: fc.oneof(fc.constant(null), arbitraryLeafExpression),
+});
+const arbitraryEmptyStatement = fc.record({
+    type: fc.constant('EmptyStatement'),
+});
+const arbitraryThrowStatement = fc.record({
+    type: fc.constant('ThrowStatement'),
+    argument: arbitraryLeafExpression,
+});
+const arbitrarySimpleNonFunctionStatement = fc.oneof({ weight: 3, arbitrary: arbitraryExpressionStatement }, { weight: 2, arbitrary: arbitraryVariableDeclaration }, { weight: 1, arbitrary: arbitraryEmptyStatement }, { weight: 1, arbitrary: arbitraryThrowStatement });
+const arbitrarySimpleBlockStatement = fc.record({
+    type: fc.constant('BlockStatement'),
+    body: fc.array(arbitrarySimpleNonFunctionStatement, { minLength: 0, maxLength: 3 }),
+});
+const arbitraryFunctionBodyStatement = fc.oneof({ weight: 3, arbitrary: arbitraryExpressionStatement }, { weight: 2, arbitrary: arbitraryVariableDeclaration }, { weight: 2, arbitrary: arbitraryReturnStatement }, { weight: 1, arbitrary: arbitraryEmptyStatement }, { weight: 1, arbitrary: arbitraryThrowStatement });
+const arbitraryFunctionBodyBlockStatement = fc.record({
+    type: fc.constant('BlockStatement'),
+    body: fc.array(arbitraryFunctionBodyStatement, { minLength: 0, maxLength: 3 }),
+});
+const arbitraryArrowFunctionExpression = fc.oneof(fc.record({
+    type: fc.constant('ArrowFunctionExpression'),
+    id: fc.constant(null),
+    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    body: arbitraryFunctionBodyBlockStatement,
+    expression: fc.constant(false),
+    generator: fc.constant(false),
+    async: fc.constant(false),
+}), fc.record({
+    type: fc.constant('ArrowFunctionExpression'),
+    id: fc.constant(null),
+    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    body: arbitraryLeafExpression,
+    expression: fc.constant(true),
+    generator: fc.constant(false),
+    async: fc.constant(false),
+}));
+const arbitraryFunctionExpression = fc.record({
+    type: fc.constant('FunctionExpression'),
+    id: fc.constant(null),
+    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    body: arbitraryFunctionBodyBlockStatement,
+    expression: fc.constant(false),
+    generator: fc.constant(false),
+    async: fc.constant(false),
+});
+const arbitraryIfStatement = fc.record({
+    type: fc.constant('IfStatement'),
+    test: arbitraryLeafExpression,
+    consequent: arbitrarySimpleBlockStatement,
+    alternate: fc.oneof(fc.constant(null), arbitrarySimpleBlockStatement),
+});
+const arbitraryWhileStatement = fc.record({
+    type: fc.constant('WhileStatement'),
+    test: arbitraryLeafExpression,
+    body: arbitrarySimpleBlockStatement,
+});
+const arbitraryForStatement = fc.record({
+    type: fc.constant('ForStatement'),
+    init: fc.oneof(fc.constant(null), fc.record({
+        type: fc.constant('VariableDeclaration'),
+        kind: fc.constant('let'),
+        declarations: fc.tuple(fc.record({
+            type: fc.constant('VariableDeclarator'),
+            id: arbitraryIdentifier,
+            init: fc.oneof(fc.constant(null), arbitraryNumberLiteral),
+        })).map(([decl]) => [decl]),
+    })),
+    test: fc.oneof(fc.constant(null), arbitraryLeafExpression),
+    update: fc.oneof(fc.constant(null), arbitraryLeafExpression),
+    body: arbitrarySimpleBlockStatement,
+});
+const arbitraryCatchClause = fc.record({
+    type: fc.constant('CatchClause'),
+    param: fc.oneof(fc.constant(null), arbitraryIdentifier),
+    body: arbitrarySimpleBlockStatement,
+});
+const arbitraryTryStatement = fc.oneof(fc.record({
+    type: fc.constant('TryStatement'),
+    block: arbitrarySimpleBlockStatement,
+    handler: arbitraryCatchClause,
+    finalizer: fc.oneof(fc.constant(null), arbitrarySimpleBlockStatement),
+}), fc.record({
+    type: fc.constant('TryStatement'),
+    block: arbitrarySimpleBlockStatement,
+    handler: fc.constant(null),
+    finalizer: arbitrarySimpleBlockStatement,
+}));
+const arbitraryFunctionDeclaration = fc.record({
+    type: fc.constant('FunctionDeclaration'),
+    id: arbitraryIdentifier,
+    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    body: arbitraryFunctionBodyBlockStatement,
+    expression: fc.constant(false),
+    generator: fc.constant(false),
+    async: fc.constant(false),
+});
+const arbitraryTopLevelExpressionStatement = fc.oneof(arbitraryExpression, arbitraryArrowFunctionExpression, arbitraryFunctionExpression)
+    .filter(expr => {
+    if (expr.type === 'Literal' && typeof expr.value === 'string') {
+        return false;
+    }
+    if (expr.type === 'ObjectExpression') {
+        return false;
+    }
+    if (expr.type === 'FunctionExpression') {
+        return false;
+    }
+    return true;
+})
+    .map(expression => ({
+    type: 'ExpressionStatement',
+    expression,
+}));
+const arbitraryStatement = fc.oneof({ weight: 3, arbitrary: arbitraryTopLevelExpressionStatement }, { weight: 2, arbitrary: arbitraryVariableDeclaration }, { weight: 2, arbitrary: arbitraryIfStatement }, { weight: 1, arbitrary: arbitraryWhileStatement }, { weight: 1, arbitrary: arbitraryForStatement }, { weight: 1, arbitrary: arbitraryEmptyStatement }, { weight: 1, arbitrary: arbitraryFunctionDeclaration }, { weight: 1, arbitrary: arbitraryThrowStatement }, { weight: 1, arbitrary: arbitraryTryStatement });
+export const arbitraryJavaScriptProgram = fc.record({
+    type: fc.constant('Program'),
+    sourceType: fc.constant('script'),
+    body: fc.array(arbitraryStatement, { minLength: 0, maxLength: 5 }),
+});

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>;

package/build/arbitraryJavascript.js

@@ -0,0 +1,263 @@
+import * as fc from 'fast-check';
+const jsKeywords = new Set([
+    'abstract', 'arguments', 'await', 'boolean', 'break', 'byte', 'case', 'catch',
+    'char', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do',
+    'double', 'else', 'enum', 'eval', 'export', 'extends', 'false', 'final',
+    'finally', 'float', 'for', 'function', 'goto', 'if', 'implements', 'import',
+    'in', 'instanceof', 'int', 'interface', 'let', 'long', 'native', 'new',
+    'null', 'package', 'private', 'protected', 'public', 'return', 'short',
+    'static', 'super', 'switch', 'synchronized', 'this', 'throw', 'throws',
+    'transient', 'true', 'try', 'typeof', 'var', 'void', 'volatile', 'while',
+    'with', 'yield', 'undefined', 'NaN', 'Infinity',
+]);
+const arbitraryIdentifierName = fc.stringMatching(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/).filter(id => !jsKeywords.has(id));
+const arbitraryIdentifier = fc.record({
+    type: fc.constant('Identifier'),
+    name: arbitraryIdentifierName,
+});
+const arbitraryStringLiteral = fc.record({
+    type: fc.constant('Literal'),
+    value: fc.stringMatching(/^[a-zA-Z0-9 ]*$/),
+});
+const arbitraryNumberLiteral = fc.record({
+    type: fc.constant('Literal'),
+    value: fc.integer({ min: 0, max: 999 }),
+});
+const arbitraryBooleanLiteral = fc.record({
+    type: fc.constant('Literal'),
+    value: fc.boolean(),
+});
+const arbitraryNullLiteral = fc.record({
+    type: fc.constant('Literal'),
+    value: fc.constant(null),
+});
+const arbitraryThisExpression = fc.record({
+    type: fc.constant('ThisExpression'),
+});
+const arbitraryLeafExpression = fc.oneof(arbitraryIdentifier, arbitraryStringLiteral, arbitraryNumberLiteral, arbitraryBooleanLiteral, arbitraryNullLiteral, arbitraryThisExpression);
+const safeBinaryOperators = [
+    '==', '!=', '===', '!==', '<', '<=', '>', '>=',
+    '<<', '>>', '>>>',
+    '+', '-', '*', '/', '%', '**',
+    '|', '^', '&',
+    'instanceof',
+];
+const arbitraryBinaryExpression = fc.record({
+    type: fc.constant('BinaryExpression'),
+    operator: fc.oneof(...safeBinaryOperators.map(op => fc.constant(op))),
+    left: arbitraryLeafExpression,
+    right: arbitraryLeafExpression,
+});
+const arbitraryLogicalExpression = fc.record({
+    type: fc.constant('LogicalExpression'),
+    operator: fc.oneof(fc.constant('||'), fc.constant('&&'), fc.constant('??')),
+    left: arbitraryLeafExpression,
+    right: arbitraryLeafExpression,
+});
+const safeUnaryOperators = [
+    '-', '+', '!', '~', 'typeof', 'void',
+];
+const arbitraryUnaryExpression = fc.record({
+    type: fc.constant('UnaryExpression'),
+    operator: fc.oneof(...safeUnaryOperators.map(op => fc.constant(op))),
+    prefix: fc.constant(true),
+    argument: arbitraryLeafExpression,
+});
+const arbitraryUpdateExpression = fc.record({
+    type: fc.constant('UpdateExpression'),
+    operator: fc.oneof(fc.constant('++'), fc.constant('--')),
+    argument: arbitraryIdentifier,
+    prefix: fc.boolean(),
+});
+const arbitraryAssignmentExpression = fc.record({
+    type: fc.constant('AssignmentExpression'),
+    operator: fc.constant('='),
+    left: arbitraryIdentifier,
+    right: arbitraryLeafExpression,
+});
+const arbitraryConditionalExpression = fc.record({
+    type: fc.constant('ConditionalExpression'),
+    test: arbitraryLeafExpression,
+    consequent: arbitraryLeafExpression,
+    alternate: arbitraryLeafExpression,
+});
+const arbitraryCallExpression = fc.record({
+    type: fc.constant('CallExpression'),
+    callee: arbitraryIdentifier,
+    arguments: fc.array(arbitraryLeafExpression, { minLength: 0, maxLength: 3 }),
+    optional: fc.constant(false),
+});
+const arbitraryMemberExpression = fc.record({
+    type: fc.constant('MemberExpression'),
+    object: arbitraryIdentifier,
+    property: arbitraryIdentifier,
+    computed: fc.constant(false),
+    optional: fc.constant(false),
+});
+const arbitraryArrayExpression = fc.record({
+    type: fc.constant('ArrayExpression'),
+    elements: fc.array(arbitraryLeafExpression, { minLength: 0, maxLength: 3 }),
+});
+const arbitraryProperty = fc.record({
+    type: fc.constant('Property'),
+    key: arbitraryIdentifier,
+    value: arbitraryLeafExpression,
+    kind: fc.constant('init'),
+    method: fc.constant(false),
+    shorthand: fc.constant(false),
+    computed: fc.constant(false),
+});
+const arbitraryObjectExpression = fc.record({
+    type: fc.constant('ObjectExpression'),
+    properties: fc.array(arbitraryProperty, { minLength: 0, maxLength: 3 }),
+});
+const arbitraryNewExpression = fc.record({
+    type: fc.constant('NewExpression'),
+    callee: arbitraryIdentifier,
+    arguments: fc.array(arbitraryLeafExpression, { minLength: 0, maxLength: 3 }),
+});
+const arbitraryExpression = fc.oneof({ weight: 5, arbitrary: arbitraryLeafExpression }, { weight: 2, arbitrary: arbitraryBinaryExpression }, { weight: 2, arbitrary: arbitraryLogicalExpression }, { weight: 2, arbitrary: arbitraryUnaryExpression }, { weight: 1, arbitrary: arbitraryUpdateExpression }, { weight: 1, arbitrary: arbitraryAssignmentExpression }, { weight: 1, arbitrary: arbitraryConditionalExpression }, { weight: 2, arbitrary: arbitraryCallExpression }, { weight: 1, arbitrary: arbitraryMemberExpression }, { weight: 1, arbitrary: arbitraryArrayExpression }, { weight: 1, arbitrary: arbitraryObjectExpression }, { weight: 1, arbitrary: arbitraryNewExpression });
+const arbitraryExpressionStatement = arbitraryExpression
+    .filter(expr => {
+    if (expr.type === 'Literal' && typeof expr.value === 'string') {
+        return false;
+    }
+    if (expr.type === 'ObjectExpression') {
+        return false;
+    }
+    return true;
+})
+    .map(expression => ({
+    type: 'ExpressionStatement',
+    expression,
+}));
+const arbitraryVariableDeclaration = fc.record({
+    type: fc.constant('VariableDeclaration'),
+    kind: fc.constant('var'),
+    declarations: fc.array(fc.record({
+        type: fc.constant('VariableDeclarator'),
+        id: arbitraryIdentifier,
+        init: fc.oneof(fc.constant(null), arbitraryLeafExpression),
+    }), { minLength: 1, maxLength: 3 }),
+});
+const arbitraryReturnStatement = fc.record({
+    type: fc.constant('ReturnStatement'),
+    argument: fc.oneof(fc.constant(null), arbitraryLeafExpression),
+});
+const arbitraryEmptyStatement = fc.record({
+    type: fc.constant('EmptyStatement'),
+});
+const arbitraryThrowStatement = fc.record({
+    type: fc.constant('ThrowStatement'),
+    argument: arbitraryLeafExpression,
+});
+const arbitrarySimpleNonFunctionStatement = fc.oneof({ weight: 3, arbitrary: arbitraryExpressionStatement }, { weight: 2, arbitrary: arbitraryVariableDeclaration }, { weight: 1, arbitrary: arbitraryEmptyStatement }, { weight: 1, arbitrary: arbitraryThrowStatement });
+const arbitrarySimpleBlockStatement = fc.record({
+    type: fc.constant('BlockStatement'),
+    body: fc.array(arbitrarySimpleNonFunctionStatement, { minLength: 0, maxLength: 3 }),
+});
+const arbitraryFunctionBodyStatement = fc.oneof({ weight: 3, arbitrary: arbitraryExpressionStatement }, { weight: 2, arbitrary: arbitraryVariableDeclaration }, { weight: 2, arbitrary: arbitraryReturnStatement }, { weight: 1, arbitrary: arbitraryEmptyStatement }, { weight: 1, arbitrary: arbitraryThrowStatement });
+const arbitraryFunctionBodyBlockStatement = fc.record({
+    type: fc.constant('BlockStatement'),
+    body: fc.array(arbitraryFunctionBodyStatement, { minLength: 0, maxLength: 3 }),
+});
+const arbitraryArrowFunctionExpression = fc.oneof(fc.record({
+    type: fc.constant('ArrowFunctionExpression'),
+    id: fc.constant(null),
+    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    body: arbitraryFunctionBodyBlockStatement,
+    expression: fc.constant(false),
+    generator: fc.constant(false),
+    async: fc.constant(false),
+}), fc.record({
+    type: fc.constant('ArrowFunctionExpression'),
+    id: fc.constant(null),
+    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    body: arbitraryLeafExpression,
+    expression: fc.constant(true),
+    generator: fc.constant(false),
+    async: fc.constant(false),
+}));
+const arbitraryFunctionExpression = fc.record({
+    type: fc.constant('FunctionExpression'),
+    id: fc.constant(null),
+    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    body: arbitraryFunctionBodyBlockStatement,
+    expression: fc.constant(false),
+    generator: fc.constant(false),
+    async: fc.constant(false),
+});
+const arbitraryIfStatement = fc.record({
+    type: fc.constant('IfStatement'),
+    test: arbitraryLeafExpression,
+    consequent: arbitrarySimpleBlockStatement,
+    alternate: fc.oneof(fc.constant(null), arbitrarySimpleBlockStatement),
+});
+const arbitraryWhileStatement = fc.record({
+    type: fc.constant('WhileStatement'),
+    test: arbitraryLeafExpression,
+    body: arbitrarySimpleBlockStatement,
+});
+const arbitraryForStatement = fc.record({
+    type: fc.constant('ForStatement'),
+    init: fc.oneof(fc.constant(null), fc.record({
+        type: fc.constant('VariableDeclaration'),
+        kind: fc.constant('let'),
+        declarations: fc.tuple(fc.record({
+            type: fc.constant('VariableDeclarator'),
+            id: arbitraryIdentifier,
+            init: fc.oneof(fc.constant(null), arbitraryNumberLiteral),
+        })).map(([decl]) => [decl]),
+    })),
+    test: fc.oneof(fc.constant(null), arbitraryLeafExpression),
+    update: fc.oneof(fc.constant(null), arbitraryLeafExpression),
+    body: arbitrarySimpleBlockStatement,
+});
+const arbitraryCatchClause = fc.record({
+    type: fc.constant('CatchClause'),
+    param: fc.oneof(fc.constant(null), arbitraryIdentifier),
+    body: arbitrarySimpleBlockStatement,
+});
+const arbitraryTryStatement = fc.oneof(fc.record({
+    type: fc.constant('TryStatement'),
+    block: arbitrarySimpleBlockStatement,
+    handler: arbitraryCatchClause,
+    finalizer: fc.oneof(fc.constant(null), arbitrarySimpleBlockStatement),
+}), fc.record({
+    type: fc.constant('TryStatement'),
+    block: arbitrarySimpleBlockStatement,
+    handler: fc.constant(null),
+    finalizer: arbitrarySimpleBlockStatement,
+}));
+const arbitraryFunctionDeclaration = fc.record({
+    type: fc.constant('FunctionDeclaration'),
+    id: arbitraryIdentifier,
+    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    body: arbitraryFunctionBodyBlockStatement,
+    expression: fc.constant(false),
+    generator: fc.constant(false),
+    async: fc.constant(false),
+});
+const arbitraryTopLevelExpressionStatement = fc.oneof(arbitraryExpression, arbitraryArrowFunctionExpression, arbitraryFunctionExpression)
+    .filter(expr => {
+    if (expr.type === 'Literal' && typeof expr.value === 'string') {
+        return false;
+    }
+    if (expr.type === 'ObjectExpression') {
+        return false;
+    }
+    if (expr.type === 'FunctionExpression') {
+        return false;
+    }
+    return true;
+})
+    .map(expression => ({
+    type: 'ExpressionStatement',
+    expression,
+}));
+const arbitraryStatement = fc.oneof({ weight: 3, arbitrary: arbitraryTopLevelExpressionStatement }, { weight: 2, arbitrary: arbitraryVariableDeclaration }, { weight: 2, arbitrary: arbitraryIfStatement }, { weight: 1, arbitrary: arbitraryWhileStatement }, { weight: 1, arbitrary: arbitraryForStatement }, { weight: 1, arbitrary: arbitraryEmptyStatement }, { weight: 1, arbitrary: arbitraryFunctionDeclaration }, { weight: 1, arbitrary: arbitraryThrowStatement }, { weight: 1, arbitrary: arbitraryTryStatement });
+export const arbitraryJavascriptProgram = fc.record({
+    type: fc.constant('Program'),
+    sourceType: fc.constant('script'),
+    body: fc.array(arbitraryStatement, { minLength: 0, maxLength: 5 }),
+});

package/build/arbitraryZig.d.ts

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