@futpib/parser 1.0.3 → 1.0.6

package/.claude/settings.local.json

@@ -0,0 +1,24 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx tsc:*)",
+      "Bash(npx ava:*)",
+      "Bash(npx tsd:*)",
+      "Bash(git show:*)",
+      "Bash(node -e:*)",
+      "WebFetch(domain:registry.npmjs.org)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "WebFetch(domain:github.com)",
+      "Bash(git clone:*)",
+      "WebFetch(domain:source.android.com)",
+      "Bash(baksmali help:*)",
+      "Bash(yarn ava:*)",
+      "Bash(yarn tsc:*)",
+      "Bash(SEED=42 yarn ava:*)",
+      "Bash(SEED=12345 yarn ava:*)",
+      "Bash(SEED=999999 yarn ava:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/.github/workflows/main.yml

@@ -38,6 +38,7 @@ jobs:
             yarn-cache-${{ runner.os }}-
       - run: yarn install --immutable
       - run: yarn build
+      - run: yarn tsd
       - run: yarn test
       - name: Generate coverage report
         if: matrix.node-version == 24

package/build/androidPackageParser.js

@@ -11,6 +11,7 @@ import { createExactSequenceParser } from './exactSequenceParser.js';
 import { createSliceBoundedParser } from './sliceBoundedParser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
 import { createExactElementParser } from './exactElementParser.js';
+import { createObjectParser } from './objectParser.js';
 import { createParserConsumedSequenceParser } from './parserConsumedSequenceParser.js';
 // https://source.android.com/docs/security/features/androidPackagesigning/v2#androidPackage-signing-block
 const uint32LEParser = promiseCompose(createFixedLengthSequenceParser(4), array => Buffer.from(array).readUInt32LE());
@@ -30,16 +31,20 @@ const createAndroidPackageSigningBlockZeroPaddingPairInnerParser = (length) => {
     return androidPackageSigningBlockZeroPaddingPairInnerParser;
 };
 const createAndroidPackageSigningBlockSignatureV2PairInnerParser = (length) => {
-    const androidPackageSigningBlockSignatureV2PairInnerParser = promiseCompose(createTupleParser([
-        createExactSequenceParser(Buffer.from('1a870971', 'hex')),
-        androidPackageSignatureV2SignersParser,
-    ]), ([_magic, signers = []]) => ({ type: 'signatureV2', signers }));
+    const androidPackageSigningBlockSignatureV2PairInnerParser = createObjectParser({
+        type: 'signatureV2',
+        _magic: createExactSequenceParser(Buffer.from('1a870971', 'hex')),
+        signers: androidPackageSignatureV2SignersParser,
+    });
     return setParserName(androidPackageSigningBlockSignatureV2PairInnerParser, 'androidPackageSigningBlockSignatureV2PairInnerParser');
 };
-const createAndroidPackageSigningBlockGenericPairInnerParser = (length) => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createFixedLengthSequenceParser(length - 4),
-]), ([id, value]) => ({ type: 'generic', pair: { id, value } }));
+const createAndroidPackageSigningBlockGenericPairInnerParser = (length) => createObjectParser({
+    type: 'generic',
+    pair: createObjectParser({
+        id: uint32LEParser,
+        value: createFixedLengthSequenceParser(length - 4),
+    }),
+});
 const createAndroidPackageSigningBlockPairInnerParser = (length) => {
     const androidPackageSigningBlockPairInnerParser = promiseCompose(createTupleParser([
         parserContext => {
@@ -82,20 +87,20 @@ export const androidPackageSigningBlockParser = createUint64LengthPrefixedParser
         pairs: genericPairs,
     };
 }));
-const androidPackageSignatureV2DigestParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createUint32LengthPrefixedParser(digestLength => createFixedLengthSequenceParser(digestLength)),
-]), ([signatureAlgorithmId, digest]) => ({ signatureAlgorithmId, digest })));
+const androidPackageSignatureV2DigestParser = createUint32LengthPrefixedParser(pairLength => createObjectParser({
+    signatureAlgorithmId: uint32LEParser,
+    digest: createUint32LengthPrefixedParser(digestLength => createFixedLengthSequenceParser(digestLength)),
+}));
 const androidPackageSignatureV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2DigestParser);
 setParserName(androidPackageSignatureV2DigestsParser, 'androidPackageSignatureV2DigestsParser');
 const androidPackageSignatureV2CertificateParser = createUint32LengthPrefixedParser(certificateLength => createFixedLengthSequenceParser(certificateLength));
 setParserName(androidPackageSignatureV2CertificateParser, 'androidPackageSignatureV2CertificateParser');
 const androidPackageSignatureV2CertificatesParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2CertificateParser);
 setParserName(androidPackageSignatureV2CertificatesParser, 'androidPackageSignatureV2CertificatesParser');
-const androidPackageSignatureV2AdditionalAttributeParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createFixedLengthSequenceParser(pairLength - 4),
-]), ([id, value]) => ({ id, value })));
+const androidPackageSignatureV2AdditionalAttributeParser = createUint32LengthPrefixedParser(pairLength => createObjectParser({
+    id: uint32LEParser,
+    value: createFixedLengthSequenceParser(pairLength - 4),
+}));
 setParserName(androidPackageSignatureV2AdditionalAttributeParser, 'androidPackageSignatureV2AdditionalAttributeParser');
 const androidPackageSignatureV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2AdditionalAttributeParser);
 setParserName(androidPackageSignatureV2AdditionalAttributesParser, 'androidPackageSignatureV2AdditionalAttributesParser');
@@ -111,26 +116,19 @@ const androidPackageSignatureV2SignedDataParser = createUint32LengthPrefixedSlic
     zeroPaddingLength: zeroPadding.length,
 })));
 setParserName(androidPackageSignatureV2SignedDataParser, 'androidPackageSignatureV2SignedDataParser');
-const androidPackageSignatureV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createUint32LengthPrefixedParser(signatureLength => createFixedLengthSequenceParser(signatureLength)),
-]), ([signatureAlgorithmId, signature,]) => ({
-    signatureAlgorithmId,
-    signature,
-})));
+const androidPackageSignatureV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => createObjectParser({
+    signatureAlgorithmId: uint32LEParser,
+    signature: createUint32LengthPrefixedParser(signatureLength => createFixedLengthSequenceParser(signatureLength)),
+}));
 const androidPackageSignatureV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2SignatureParser);
 setParserName(androidPackageSignatureV2SignaturesParser, 'androidPackageSignatureV2SignaturesParser');
 const androidPackageSignatureV2PublicKeyParser = createUint32LengthPrefixedParser(publicKeyLength => createFixedLengthSequenceParser(publicKeyLength));
 setParserName(androidPackageSignatureV2PublicKeyParser, 'androidPackageSignatureV2PublicKeyParser');
-const androidPackageSignatureV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
-    androidPackageSignatureV2SignedDataParser,
-    androidPackageSignatureV2SignaturesParser,
-    androidPackageSignatureV2PublicKeyParser,
-]), ([signedData, signatures = [], publicKey,]) => ({
-    signedData,
-    signatures,
-    publicKey,
-})));
+const androidPackageSignatureV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(createObjectParser({
+    signedData: androidPackageSignatureV2SignedDataParser,
+    signatures: androidPackageSignatureV2SignaturesParser,
+    publicKey: androidPackageSignatureV2PublicKeyParser,
+}));
 setParserName(androidPackageSignatureV2SignerParser, 'androidPackageSignatureV2SignerParser');
 const androidPackageSignatureV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2SignerParser);
 setParserName(androidPackageSignatureV2SignersParser, 'androidPackageSignatureV2SignersParser');

package/build/arbitraryDalvikBytecode.d.ts

@@ -1,4 +1,4 @@
 import * as fc from 'fast-check';
-import { type DalvikBytecode, type DalvikBytecodeOperation } from './dalvikBytecodeParser.js';
-export declare const arbitraryDalvikBytecodeOperation: fc.Arbitrary<DalvikBytecodeOperation>;
-export declare const arbitraryDalvikBytecode: fc.Arbitrary<DalvikBytecode>;
+import { type RawDalvikBytecode, type RawDalvikBytecodeOperation } from './dalvikBytecodeParser.js';
+export declare const arbitraryRawDalvikBytecodeOperation: fc.Arbitrary<RawDalvikBytecodeOperation>;
+export declare const arbitraryRawDalvikBytecode: fc.Arbitrary<RawDalvikBytecode>;

package/build/arbitraryDalvikBytecode.js

@@ -1,5 +1,5 @@
 import * as fc from 'fast-check';
-import { isoIndexIntoStringIds, isoIndexIntoTypeIds, isoIndexIntoMethodIds, isoIndexIntoFieldIds, isoIndexIntoPrototypeIds, } from './dalvikExecutableParser/typedNumbers.js';
+import { isoIndexIntoStringIds, isoIndexIntoTypeIds, isoIndexIntoMethodIds, isoIndexIntoFieldIds, isoIndexIntoPrototypeIds, isoCodeUnit, } from './dalvikExecutableParser/typedNumbers.js';
 // Arbitrary generators for typed indexes
 const arbitraryIndexIntoStringIds = fc
     .nat({ max: 65535 })
@@ -26,10 +26,16 @@ const arbitraryByteValue = fc.integer({ min: -128, max: 127 }); // 8-bit signed
 const arbitraryShortValue = fc.integer({ min: -32768, max: 32767 }); // 16-bit signed
 const arbitraryIntValue = fc.integer({ min: -2147483648, max: 2147483647 }); // 32-bit signed
 const arbitraryLongValue = fc.bigInt({ min: -9223372036854775808n, max: 9223372036854775807n }); // 64-bit signed
-// Arbitrary branch offsets (relative)
-const arbitraryBranchOffset8 = fc.integer({ min: -128, max: 127 });
-const arbitraryBranchOffset16 = fc.integer({ min: -32768, max: 32767 });
-const arbitraryBranchOffset32 = fc.integer({ min: -2147483648, max: 2147483647 });
+// Arbitrary branch offsets (relative) - wrapped as CodeUnit
+const arbitraryBranchOffsetCodeUnit8 = fc
+    .integer({ min: -128, max: 127 })
+    .map(n => isoCodeUnit.wrap(n));
+const arbitraryBranchOffsetCodeUnit16 = fc
+    .integer({ min: -32768, max: 32767 })
+    .map(n => isoCodeUnit.wrap(n));
+const arbitraryBranchOffsetCodeUnit32 = fc
+    .integer({ min: -2147483648, max: 2147483647 })
+    .map(n => isoCodeUnit.wrap(n));
 // No-operation
 const arbitraryNop = fc.constant({
     operation: 'nop',
@@ -205,31 +211,31 @@ const arbitraryThrow = fc.record({
 // Goto operations
 const arbitraryGoto = fc.record({
     operation: fc.constant('goto'),
-    branchOffset: arbitraryBranchOffset8,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit8,
 });
 const arbitraryGoto16 = fc.record({
     operation: fc.constant('goto/16'),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryGoto32 = fc.record({
     operation: fc.constant('goto/32'),
-    branchOffset: arbitraryBranchOffset32,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit32,
 });
 // Switch operations
 const arbitraryPackedSwitch = fc.record({
     operation: fc.constant('packed-switch'),
     registers: fc.tuple(arbitraryRegister8),
-    branchOffset: arbitraryBranchOffset32,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit32,
 });
 const arbitrarySparseSwitch = fc.record({
     operation: fc.constant('sparse-switch'),
     registers: fc.tuple(arbitraryRegister8),
-    branchOffset: arbitraryBranchOffset32,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit32,
 });
 const arbitraryFillArrayData = fc.record({
     operation: fc.constant('fill-array-data'),
     registers: fc.tuple(arbitraryRegister8),
-    branchOffset: arbitraryBranchOffset32,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit32,
 });
 // Payload operations
 const arbitraryPackedSwitchPayload = fc
@@ -237,14 +243,14 @@ const arbitraryPackedSwitchPayload = fc
     .chain(size => fc.record({
     operation: fc.constant('packed-switch-payload'),
     value: arbitraryIntValue,
-    branchOffsets: fc.array(arbitraryBranchOffset32, { minLength: size, maxLength: size }),
+    branchOffsetsCodeUnit: fc.array(arbitraryBranchOffsetCodeUnit32, { minLength: size, maxLength: size }),
 }));
 const arbitrarySparseSwitchPayload = fc
     .nat({ max: 20 })
     .chain(size => fc.record({
     operation: fc.constant('sparse-switch-payload'),
     keys: fc.array(arbitraryIntValue, { minLength: size, maxLength: size }),
-    branchOffsets: fc.array(arbitraryBranchOffset32, { minLength: size, maxLength: size }),
+    branchOffsetsCodeUnit: fc.array(arbitraryBranchOffsetCodeUnit32, { minLength: size, maxLength: size }),
 }));
 const arbitraryFillArrayDataPayload = fc
     .record({
@@ -262,63 +268,63 @@ const arbitraryFillArrayDataPayload = fc
 const arbitraryIfEqual = fc.record({
     operation: fc.constant('if-eq'),
     registers: fc.tuple(arbitraryRegister4, arbitraryRegister4).map(([a, b]) => [a, b].sort((x, y) => x - y)),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryIfNotEqual = fc.record({
     operation: fc.constant('if-ne'),
     registers: fc.tuple(arbitraryRegister4, arbitraryRegister4).map(([a, b]) => [a, b].sort((x, y) => x - y)),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryIfLessThan = fc.record({
     operation: fc.constant('if-lt'),
     registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryIfGreaterThanOrEqualTo = fc.record({
     operation: fc.constant('if-ge'),
     registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryIfGreaterThan = fc.record({
     operation: fc.constant('if-gt'),
     registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryIfLessThanOrEqualTo = fc.record({
     operation: fc.constant('if-le'),
     registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 // If-test-zero operations (Format 21t)
 const arbitraryIfEqualZero = fc.record({
     operation: fc.constant('if-eqz'),
     registers: fc.tuple(arbitraryRegister8),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryIfNotEqualZero = fc.record({
     operation: fc.constant('if-nez'),
     registers: fc.tuple(arbitraryRegister8),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryIfLessThanZero = fc.record({
     operation: fc.constant('if-ltz'),
     registers: fc.tuple(arbitraryRegister8),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryIfGreaterThanOrEqualToZero = fc.record({
     operation: fc.constant('if-gez'),
     registers: fc.tuple(arbitraryRegister8),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryIfGreaterThanZero = fc.record({
     operation: fc.constant('if-gtz'),
     registers: fc.tuple(arbitraryRegister8),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 const arbitraryIfLessThanOrEqualToZero = fc.record({
     operation: fc.constant('if-lez'),
     registers: fc.tuple(arbitraryRegister8),
-    branchOffset: arbitraryBranchOffset16,
+    branchOffsetCodeUnit: arbitraryBranchOffsetCodeUnit16,
 });
 // Array element operations (Format 23x)
 const createArbitraryArrayElementOperation = (operation) => fc.record({
@@ -593,7 +599,7 @@ const arbitraryIntToByte = createArbitraryUnaryOperation('int-to-byte');
 const arbitraryIntToChar = createArbitraryUnaryOperation('int-to-char');
 const arbitraryIntToShort = createArbitraryUnaryOperation('int-to-short');
 // Combine all operations
-export const arbitraryDalvikBytecodeOperation = fc.oneof(arbitraryNop, 
+export const arbitraryRawDalvikBytecodeOperation = fc.oneof(arbitraryNop, 
 // Move operations
 arbitraryMove, arbitraryMoveWide, arbitraryMoveObject, arbitraryMoveFrom16, arbitraryMoveWideFrom16, arbitraryMoveObjectFrom16, arbitraryMoveWide16, arbitraryMoveResult, arbitraryMoveResultWide, arbitraryMoveResultObject, arbitraryMoveException, 
 // Return operations
@@ -637,4 +643,4 @@ arbitraryAddIntLiteral16, arbitraryReverseSubtractIntLiteral16, arbitraryMultipl
 // Unary operations
 arbitraryNegateInt, arbitraryNotInt, arbitraryNegateLong, arbitraryNotLong, arbitraryNegateFloat, arbitraryNegateDouble, arbitraryIntToLong, arbitraryIntToFloat, arbitraryIntToDouble, arbitraryLongToInt, arbitraryLongToFloat, arbitraryLongToDouble, arbitraryFloatToInt, arbitraryFloatToLong, arbitraryFloatToDouble, arbitraryDoubleToInt, arbitraryDoubleToLong, arbitraryDoubleToFloat, arbitraryIntToByte, arbitraryIntToChar, arbitraryIntToShort);
 // Arbitrary for complete Dalvik bytecode (array of operations)
-export const arbitraryDalvikBytecode = fc.array(arbitraryDalvikBytecodeOperation, { minLength: 0, maxLength: 100 });
+export const arbitraryRawDalvikBytecode = fc.array(arbitraryRawDalvikBytecodeOperation, { minLength: 0, maxLength: 100 });

package/build/arbitraryDalvikExecutable.js

@@ -172,32 +172,70 @@ const arbitraryDalvikExecutableDebugInfo = fc.record({
     parameterNames: fc.array(fc.option(arbitraryJavaIdentifier, { nil: undefined }), { maxLength: 5 }),
     bytecode: fc.array(arbitraryDalvikExecutableDebugByteCodeValue, { maxLength: 10 }),
 });
-const arbitraryDalvikExecutableEncodedTypeAddressPair = fc.record({
-    type: arbitraryDalvikClassName,
-    address: fc.nat({ max: 65535 }),
-});
-const arbitraryDalvikExecutableEncodedCatchHandler = fc.record({
-    handlers: fc.array(arbitraryDalvikExecutableEncodedTypeAddressPair, { maxLength: 3 }),
-    catchAllAddress: fc.option(fc.nat({ max: 65535 }), { nil: undefined }),
-}).filter(handler => {
-    // A handler must have at least one typed handler OR a catch-all address
-    return handler.handlers.length > 0 || handler.catchAllAddress !== undefined;
-});
-const arbitraryDalvikExecutableTry = fc.record({
-    startAddress: fc.nat({ max: 65535 }),
-    instructionCount: fc.nat({ max: 255 }),
-    handler: arbitraryDalvikExecutableEncodedCatchHandler,
-});
+// Factory function to create arbitrary try blocks that are valid for given instruction count
+// Since addresses are now instruction indices, they must be within [0, instructionCount]
+function createArbitraryDalvikExecutableTry(instructionCount) {
+    // If no instructions, we can't have meaningful try blocks
+    if (instructionCount === 0) {
+        // Return a try block that covers the "after last instruction" position (index 0)
+        const arbitraryEmptyHandler = fc.record({
+            handlers: fc.constant([]),
+            catchAllInstructionIndex: fc.constant(0),
+        });
+        return fc.record({
+            startInstructionIndex: fc.constant(0),
+            instructionCount: fc.constant(0),
+            handler: arbitraryEmptyHandler,
+        });
+    }
+    // Addresses must be in range [0, instructionCount] (inclusive, since handler can point to end)
+    const maxAddress = instructionCount;
+    const arbitraryDalvikExecutableEncodedTypeAddressPair = fc.record({
+        type: arbitraryDalvikClassName,
+        handlerInstructionIndex: fc.nat({ max: maxAddress }),
+    });
+    const arbitraryDalvikExecutableEncodedCatchHandler = fc.record({
+        handlers: fc.array(arbitraryDalvikExecutableEncodedTypeAddressPair, { maxLength: 3 }),
+        catchAllInstructionIndex: fc.option(fc.nat({ max: maxAddress }), { nil: undefined }),
+    }).filter(handler => {
+        // A handler must have at least one typed handler OR a catch-all address
+        return handler.handlers.length > 0 || handler.catchAllInstructionIndex !== undefined;
+    });
+    // startInstructionIndex + instructionCount must not exceed instructionCount (the total)
+    return fc.tuple(fc.nat({ max: instructionCount }), fc.nat({ max: instructionCount })).chain(([start, count]) => {
+        // Adjust count so start + count <= instructionCount
+        const adjustedCount = Math.min(count, instructionCount - start);
+        return fc.record({
+            startInstructionIndex: fc.constant(start),
+            instructionCount: fc.constant(adjustedCount),
+            handler: arbitraryDalvikExecutableEncodedCatchHandler,
+        });
+    });
+}
+// Helper function to get instruction count from instructions
+// This handles both array and non-array instruction types
+function getInstructionCount(instructions) {
+    if (Array.isArray(instructions)) {
+        return instructions.length;
+    }
+    return 0; // Non-array instructions default to 0
+}
 // Generic factory function for DalvikExecutable
 export const createArbitraryDalvikExecutable = (arbitraryInstructions) => {
     // Code generator using provided instructions arbitrary
+    // First generate instructions, then generate valid tries based on instruction count
     const arbitraryDalvikExecutableCode = fc.record({
         registersSize: fc.nat({ max: 65535 }),
         insSize: fc.nat({ max: 255 }),
         outsSize: fc.nat({ max: 255 }),
         debugInfo: fc.option(arbitraryDalvikExecutableDebugInfo, { nil: undefined }),
         instructions: arbitraryInstructions,
-        tries: fc.array(arbitraryDalvikExecutableTry, { maxLength: 2 }),
+    }).chain(partialCode => {
+        const instructionCount = getInstructionCount(partialCode.instructions);
+        return fc.array(createArbitraryDalvikExecutableTry(instructionCount), { maxLength: 2 }).map(tries => ({
+            ...partialCode,
+            tries,
+        }));
     });
     // Method with access and code
     const arbitraryDalvikExecutableMethodWithAccess = fc.record({

package/build/arbitraryJava.d.ts

@@ -0,0 +1,31 @@
+import * as fc from 'fast-check';
+export declare const arbitraryJavaCompilationUnit: fc.Arbitrary<{
+    type: "CompilationUnit";
+    packageDeclaration: {
+        type: "PackageDeclaration";
+        annotations: {
+            type: "MarkerAnnotationExpr";
+            name: {
+                type: "Name";
+                identifier: string;
+                qualifier?: unknown;
+            };
+        }[];
+        name: {
+            type: "Name";
+            identifier: string;
+            qualifier?: unknown;
+        };
+    } | undefined;
+    imports: {
+        type: "ImportDeclaration";
+        isStatic: boolean;
+        isAsterisk: boolean;
+        name: {
+            type: "Name";
+            identifier: string;
+            qualifier?: unknown;
+        };
+    }[];
+    types: unknown[];
+}>;