@lightprotocol/compressed-token 0.1.2 → 0.2.0

package/dist/es/node/index.js

@@ -1,4404 +0,0 @@
-import { getIndexOrAdd, bn, padOutputStateMerkleTrees, useWallet, confirmConfig, defaultStaticAccountsStruct, toArray, LightSystemProgram, sumUpLamports, validateSufficientBalance, validateSameOwner, dedupeSigner, buildAndSignTx, sendAndConfirmTx, defaultTestStateTreeAccounts } from '@lightprotocol/stateless.js';
-import { utils, AnchorProvider, setProvider, Program } from '@coral-xyz/anchor';
-import { PublicKey, TransactionInstruction, Keypair, Connection, SystemProgram, ComputeBudgetProgram } from '@solana/web3.js';
-import require$$0, { Buffer as Buffer$1 } from 'buffer';
-import require$$0$2 from 'fs';
-import require$$0$1 from 'path';
-
-const IDL = {
-    version: '0.3.0',
-    name: 'light_compressed_token',
-    constants: [
-        {
-            name: 'PROGRAM_ID',
-            type: 'string',
-            value: '"9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE"',
-        },
-    ],
-    instructions: [
-        {
-            name: 'createMint',
-            docs: [
-                'This instruction expects a mint account to be created in a separate token program instruction',
-                'with token authority as mint authority.',
-                'This instruction creates a token pool account for that mint owned by token authority.',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                },
-                {
-                    name: 'authority',
-                    isMut: true,
-                    isSigner: true,
-                },
-                {
-                    name: 'tokenPoolPda',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'mint',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'mintAuthorityPda',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [],
-        },
-        {
-            name: 'mintTo',
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                },
-                {
-                    name: 'authority',
-                    isMut: true,
-                    isSigner: true,
-                },
-                {
-                    name: 'mintAuthorityPda',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'mint',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'tokenPoolPda',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'compressedPdaProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'merkleTree',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [
-                {
-                    name: 'publicKeys',
-                    type: {
-                        vec: 'publicKey',
-                    },
-                },
-                {
-                    name: 'amounts',
-                    type: {
-                        vec: 'u64',
-                    },
-                },
-            ],
-        },
-        {
-            name: 'transfer',
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: false,
-                    isSigner: true,
-                },
-                {
-                    name: 'authority',
-                    isMut: false,
-                    isSigner: true,
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'compressedPdaProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'tokenPoolPda',
-                    isMut: true,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'decompressTokenAccount',
-                    isMut: true,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false,
-                    isOptional: true,
-                },
-            ],
-            args: [
-                {
-                    name: 'inputs',
-                    type: 'bytes',
-                },
-                {
-                    name: 'cpiContext',
-                    type: {
-                        option: {
-                            defined: 'CompressedCpiContext',
-                        },
-                    },
-                },
-            ],
-        },
-    ],
-    types: [
-        {
-            name: 'CompressedAccountWithMerkleContext',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'compressedAccount',
-                        type: {
-                            defined: 'CompressedAccount',
-                        },
-                    },
-                    {
-                        name: 'merkleTreePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'leafIndex',
-                        type: 'u32',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'MerkleContext',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'merkleTreePubkey',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'nullifierQueuePubkey',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'leafIndex',
-                        type: 'u32',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'PackedMerkleContext',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'merkleTreePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'leafIndex',
-                        type: 'u32',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'CompressedAccount',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'owner',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'lamports',
-                        type: 'u64',
-                    },
-                    {
-                        name: 'address',
-                        type: {
-                            option: {
-                                array: ['u8', 32],
-                            },
-                        },
-                    },
-                    {
-                        name: 'data',
-                        type: {
-                            option: {
-                                defined: 'CompressedAccountData',
-                            },
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'CompressedAccountData',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'discriminator',
-                        type: {
-                            array: ['u8', 8],
-                        },
-                    },
-                    {
-                        name: 'data',
-                        type: 'bytes',
-                    },
-                    {
-                        name: 'dataHash',
-                        type: {
-                            array: ['u8', 32],
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'CompressedCpiContext',
-            docs: ['To spend multiple compressed'],
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'cpiSignatureAccountIndex',
-                        docs: [
-                            'index of the output state Merkle tree that will be used to store cpi signatures',
-                            'The transaction will fail if this index is not consistent in your transaction.',
-                        ],
-                        type: 'u8',
-                    },
-                    {
-                        name: 'execute',
-                        docs: [
-                            'The final cpi of your program needs to set execute to true.',
-                            'Execute compressed transaction will verify the proof and execute the transaction if this is true.',
-                            'If this is false the transaction will be stored in the cpi signature account.',
-                        ],
-                        type: 'bool',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'PublicTransactionEvent',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'inputCompressedAccountHashes',
-                        type: {
-                            vec: {
-                                array: ['u8', 32],
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputCompressedAccountHashes',
-                        type: {
-                            vec: {
-                                array: ['u8', 32],
-                            },
-                        },
-                    },
-                    {
-                        name: 'inputCompressedAccounts',
-                        type: {
-                            vec: {
-                                defined: 'CompressedAccountWithMerkleContext',
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputCompressedAccounts',
-                        type: {
-                            vec: {
-                                defined: 'CompressedAccount',
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputStateMerkleTreeAccountIndices',
-                        type: 'bytes',
-                    },
-                    {
-                        name: 'outputLeafIndices',
-                        type: {
-                            vec: 'u32',
-                        },
-                    },
-                    {
-                        name: 'relayFee',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'isCompress',
-                        type: 'bool',
-                    },
-                    {
-                        name: 'compressionLamports',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'pubkeyArray',
-                        type: {
-                            vec: 'publicKey',
-                        },
-                    },
-                    {
-                        name: 'message',
-                        type: {
-                            option: 'bytes',
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'InstructionDataTransfer',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'proof',
-                        type: {
-                            option: {
-                                defined: 'CompressedProof',
-                            },
-                        },
-                    },
-                    {
-                        name: 'newAddressParams',
-                        type: {
-                            vec: {
-                                defined: 'NewAddressParamsPacked',
-                            },
-                        },
-                    },
-                    {
-                        name: 'inputRootIndices',
-                        type: {
-                            vec: 'u16',
-                        },
-                    },
-                    {
-                        name: 'inputCompressedAccountsWithMerkleContext',
-                        type: {
-                            vec: {
-                                defined: 'CompressedAccountWithMerkleContext',
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputCompressedAccounts',
-                        type: {
-                            vec: {
-                                defined: 'CompressedAccount',
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputStateMerkleTreeAccountIndices',
-                        docs: [
-                            'The indices of the accounts in the output state merkle tree.',
-                        ],
-                        type: 'bytes',
-                    },
-                    {
-                        name: 'relayFee',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'compressionLamports',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'isCompress',
-                        type: 'bool',
-                    },
-                    {
-                        name: 'signerSeeds',
-                        type: {
-                            option: {
-                                vec: 'bytes',
-                            },
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'NewAddressParamsPacked',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'seed',
-                        type: {
-                            array: ['u8', 32],
-                        },
-                    },
-                    {
-                        name: 'addressQueueAccountIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'addressMerkleTreeAccountIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'addressMerkleTreeRootIndex',
-                        type: 'u16',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'NewAddressParams',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'seed',
-                        type: {
-                            array: ['u8', 32],
-                        },
-                    },
-                    {
-                        name: 'addressQueuePubkey',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'addressMerkleTreePubkey',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'addressMerkleTreeRootIndex',
-                        type: 'u16',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'CompressedProof',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'a',
-                        type: {
-                            array: ['u8', 32],
-                        },
-                    },
-                    {
-                        name: 'b',
-                        type: {
-                            array: ['u8', 64],
-                        },
-                    },
-                    {
-                        name: 'c',
-                        type: {
-                            array: ['u8', 32],
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'InputTokenDataWithContext',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'amount',
-                        type: 'u64',
-                    },
-                    {
-                        name: 'delegateIndex',
-                        type: {
-                            option: 'u8',
-                        },
-                    },
-                    {
-                        name: 'delegatedAmount',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'isNative',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'merkleTreePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'leafIndex',
-                        type: 'u32',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'CompressedTokenInstructionDataTransfer',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'proof',
-                        type: {
-                            option: {
-                                defined: 'CompressedProof',
-                            },
-                        },
-                    },
-                    {
-                        name: 'rootIndices',
-                        type: {
-                            vec: 'u16',
-                        },
-                    },
-                    {
-                        name: 'mint',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'signerIsDelegate',
-                        type: 'bool',
-                    },
-                    {
-                        name: 'inputTokenDataWithContext',
-                        type: {
-                            vec: {
-                                defined: 'InputTokenDataWithContext',
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputCompressedAccounts',
-                        type: {
-                            vec: {
-                                defined: 'TokenTransferOutputData',
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputStateMerkleTreeAccountIndices',
-                        type: 'bytes',
-                    },
-                    {
-                        name: 'isCompress',
-                        type: 'bool',
-                    },
-                    {
-                        name: 'compressionAmount',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'TokenTransferOutputData',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'owner',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'amount',
-                        type: 'u64',
-                    },
-                    {
-                        name: 'lamports',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'TokenData',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'mint',
-                        docs: ['The mint associated with this account'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'owner',
-                        docs: ['The owner of this account.'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'amount',
-                        docs: ['The amount of tokens this account holds.'],
-                        type: 'u64',
-                    },
-                    {
-                        name: 'delegate',
-                        docs: [
-                            'If `delegate` is `Some` then `delegated_amount` represents',
-                            'the amount authorized by the delegate',
-                        ],
-                        type: {
-                            option: 'publicKey',
-                        },
-                    },
-                    {
-                        name: 'state',
-                        docs: ["The account's state"],
-                        type: {
-                            defined: 'AccountState',
-                        },
-                    },
-                    {
-                        name: 'isNative',
-                        docs: [
-                            'If is_some, this is a native token, and the value logs the rent-exempt',
-                            'reserve. An Account is required to be rent-exempt, so the value is',
-                            'used by the Processor to ensure that wrapped SOL accounts do not',
-                            'drop below this threshold.',
-                        ],
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'delegatedAmount',
-                        docs: ['The amount delegated'],
-                        type: 'u64',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'TokenDataClient',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'mint',
-                        docs: ['The mint associated with this account'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'owner',
-                        docs: ['The owner of this account.'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'amount',
-                        docs: ['The amount of tokens this account holds.'],
-                        type: 'u64',
-                    },
-                    {
-                        name: 'delegate',
-                        docs: [
-                            'If `delegate` is `Some` then `delegated_amount` represents',
-                            'the amount authorized by the delegate',
-                        ],
-                        type: {
-                            option: 'publicKey',
-                        },
-                    },
-                    {
-                        name: 'state',
-                        docs: ["The account's state"],
-                        type: 'u8',
-                    },
-                    {
-                        name: 'isNative',
-                        docs: [
-                            'If is_some, this is a native token, and the value logs the rent-exempt',
-                            'reserve. An Account is required to be rent-exempt, so the value is',
-                            'used by the Processor to ensure that wrapped SOL accounts do not',
-                            'drop below this threshold.',
-                        ],
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'delegatedAmount',
-                        docs: ['The amount delegated'],
-                        type: 'u64',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'AccountState',
-            type: {
-                kind: 'enum',
-                variants: [
-                    {
-                        name: 'Uninitialized',
-                    },
-                    {
-                        name: 'Initialized',
-                    },
-                    {
-                        name: 'Frozen',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'ErrorCode',
-            type: {
-                kind: 'enum',
-                variants: [
-                    {
-                        name: 'PublicKeyAmountMissmatch',
-                    },
-                    {
-                        name: 'MissingNewAuthorityPda',
-                    },
-                    {
-                        name: 'SignerCheckFailed',
-                    },
-                    {
-                        name: 'MintCheckFailed',
-                    },
-                    {
-                        name: 'ComputeInputSumFailed',
-                    },
-                    {
-                        name: 'ComputeOutputSumFailed',
-                    },
-                    {
-                        name: 'ComputeCompressSumFailed',
-                    },
-                    {
-                        name: 'ComputeDecompressSumFailed',
-                    },
-                    {
-                        name: 'SumCheckFailed',
-                    },
-                    {
-                        name: 'DecompressRecipientUndefinedForDecompress',
-                    },
-                    {
-                        name: 'CompressedPdaUndefinedForDecompress',
-                    },
-                    {
-                        name: 'DeCompressAmountUndefinedForDecompress',
-                    },
-                    {
-                        name: 'CompressedPdaUndefinedForCompress',
-                    },
-                    {
-                        name: 'DeCompressAmountUndefinedForCompress',
-                    },
-                    {
-                        name: 'DelegateUndefined',
-                    },
-                ],
-            },
-        },
-    ],
-    errors: [
-        {
-            code: 6000,
-            name: 'SignerCheckFailed',
-            msg: 'Signer check failed',
-        },
-        {
-            code: 6001,
-            name: 'CreateTransferInstructionFailed',
-            msg: 'Create transfer instruction failed',
-        },
-    ],
-};
-
-// TODO: include owner and lamports in packing.
-/**
- * Packs Compressed Token Accounts.
- */
-function packCompressedTokenAccounts(params) {
-    const { inputCompressedTokenAccounts, outputCompressedAccountsLength, outputStateTrees, remainingAccounts = [], } = params;
-    const _remainingAccounts = remainingAccounts.slice();
-    let delegateIndex = null;
-    if (inputCompressedTokenAccounts.length > 0 &&
-        inputCompressedTokenAccounts[0].parsed.delegate) {
-        delegateIndex = getIndexOrAdd(_remainingAccounts, inputCompressedTokenAccounts[0].parsed.delegate);
-    }
-    /// TODO: move pubkeyArray to remainingAccounts
-    /// Currently just packs 'delegate' to pubkeyArray
-    const packedInputTokenData = [];
-    /// pack inputs
-    inputCompressedTokenAccounts.forEach((account) => {
-        const merkleTreePubkeyIndex = getIndexOrAdd(_remainingAccounts, account.compressedAccount.merkleTree);
-        const nullifierQueuePubkeyIndex = getIndexOrAdd(_remainingAccounts, account.compressedAccount.nullifierQueue);
-        packedInputTokenData.push({
-            amount: account.parsed.amount,
-            delegateIndex,
-            delegatedAmount: account.parsed.delegatedAmount.eq(bn(0))
-                ? null
-                : account.parsed.delegatedAmount,
-            isNative: account.parsed.isNative,
-            merkleTreePubkeyIndex,
-            nullifierQueuePubkeyIndex,
-            leafIndex: account.compressedAccount.leafIndex,
-        });
-    });
-    /// pack output state trees
-    const paddedOutputStateMerkleTrees = padOutputStateMerkleTrees(outputStateTrees, outputCompressedAccountsLength, inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    const outputStateMerkleTreeIndices = [];
-    paddedOutputStateMerkleTrees.forEach(account => {
-        const indexMerkleTree = getIndexOrAdd(_remainingAccounts, account);
-        outputStateMerkleTreeIndices.push(indexMerkleTree);
-    });
-    // to meta
-    const remainingAccountMetas = _remainingAccounts.map((account) => ({
-        pubkey: account,
-        isWritable: true,
-        isSigner: false,
-    }));
-    return {
-        inputTokenDataWithContext: packedInputTokenData,
-        outputStateMerkleTreeIndices,
-        remainingAccountMetas,
-    };
-}
-
-const POOL_SEED = Buffer.from('pool');
-const CPI_AUTHORITY_SEED = Buffer.from('cpi_authority');
-const MINT_AUTHORITY_SEED = utils.bytes.utf8.encode('mint_authority_pda');
-const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
-
-/** Address of the SPL Token program */
-const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
-/** Address of the SPL Token 2022 program */
-new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
-/** Address of the SPL Associated Token Account program */
-new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
-/** Address of the special mint for wrapped native SOL in spl-token */
-new PublicKey('So11111111111111111111111111111111111111112');
-/** Address of the special mint for wrapped native SOL in spl-token-2022 */
-new PublicKey('9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP');
-
-var Layout$1 = {};
-
-/* The MIT License (MIT)
- *
- * Copyright 2015-2018 Peter A. Bigot
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-Object.defineProperty(Layout$1, "__esModule", { value: true });
-Layout$1.s16 = Layout$1.s8 = Layout$1.nu64be = Layout$1.u48be = Layout$1.u40be = Layout$1.u32be = Layout$1.u24be = Layout$1.u16be = Layout$1.nu64 = Layout$1.u48 = Layout$1.u40 = u32 = Layout$1.u32 = Layout$1.u24 = Layout$1.u16 = u8 = Layout$1.u8 = Layout$1.offset = Layout$1.greedy = Layout$1.Constant = Layout$1.UTF8 = Layout$1.CString = Layout$1.Blob = Layout$1.Boolean = Layout$1.BitField = Layout$1.BitStructure = Layout$1.VariantLayout = Layout$1.Union = Layout$1.UnionLayoutDiscriminator = Layout$1.UnionDiscriminator = Layout$1.Structure = Layout$1.Sequence = Layout$1.DoubleBE = Layout$1.Double = Layout$1.FloatBE = Layout$1.Float = Layout$1.NearInt64BE = Layout$1.NearInt64 = Layout$1.NearUInt64BE = Layout$1.NearUInt64 = Layout$1.IntBE = Layout$1.Int = Layout$1.UIntBE = Layout$1.UInt = Layout$1.OffsetLayout = Layout$1.GreedyCount = Layout$1.ExternalLayout = Layout$1.bindConstructorLayout = Layout$1.nameWithProperty = Layout$1.Layout = Layout$1.uint8ArrayToBuffer = Layout$1.checkUint8Array = void 0;
-Layout$1.constant = Layout$1.utf8 = Layout$1.cstr = blob = Layout$1.blob = Layout$1.unionLayoutDiscriminator = Layout$1.union = Layout$1.seq = Layout$1.bits = struct = Layout$1.struct = Layout$1.f64be = Layout$1.f64 = Layout$1.f32be = Layout$1.f32 = Layout$1.ns64be = Layout$1.s48be = Layout$1.s40be = Layout$1.s32be = Layout$1.s24be = Layout$1.s16be = Layout$1.ns64 = Layout$1.s48 = Layout$1.s40 = Layout$1.s32 = Layout$1.s24 = void 0;
-const buffer_1 = require$$0;
-/* Check if a value is a Uint8Array.
- *
- * @ignore */
-function checkUint8Array(b) {
-    if (!(b instanceof Uint8Array)) {
-        throw new TypeError('b must be a Uint8Array');
-    }
-}
-Layout$1.checkUint8Array = checkUint8Array;
-/* Create a Buffer instance from a Uint8Array.
- *
- * @ignore */
-function uint8ArrayToBuffer(b) {
-    checkUint8Array(b);
-    return buffer_1.Buffer.from(b.buffer, b.byteOffset, b.length);
-}
-Layout$1.uint8ArrayToBuffer = uint8ArrayToBuffer;
-/**
- * Base class for layout objects.
- *
- * **NOTE** This is an abstract base class; you can create instances
- * if it amuses you, but they won't support the {@link
- * Layout#encode|encode} or {@link Layout#decode|decode} functions.
- *
- * @param {Number} span - Initializer for {@link Layout#span|span}.  The
- * parameter must be an integer; a negative value signifies that the
- * span is {@link Layout#getSpan|value-specific}.
- *
- * @param {string} [property] - Initializer for {@link
- * Layout#property|property}.
- *
- * @abstract
- */
-class Layout {
-    constructor(span, property) {
-        if (!Number.isInteger(span)) {
-            throw new TypeError('span must be an integer');
-        }
-        /** The span of the layout in bytes.
-         *
-         * Positive values are generally expected.
-         *
-         * Zero will only appear in {@link Constant}s and in {@link
-         * Sequence}s where the {@link Sequence#count|count} is zero.
-         *
-         * A negative value indicates that the span is value-specific, and
-         * must be obtained using {@link Layout#getSpan|getSpan}. */
-        this.span = span;
-        /** The property name used when this layout is represented in an
-         * Object.
-         *
-         * Used only for layouts that {@link Layout#decode|decode} to Object
-         * instances.  If left undefined the span of the unnamed layout will
-         * be treated as padding: it will not be mutated by {@link
-         * Layout#encode|encode} nor represented as a property in the
-         * decoded Object. */
-        this.property = property;
-    }
-    /** Function to create an Object into which decoded properties will
-     * be written.
-     *
-     * Used only for layouts that {@link Layout#decode|decode} to Object
-     * instances, which means:
-     * * {@link Structure}
-     * * {@link Union}
-     * * {@link VariantLayout}
-     * * {@link BitStructure}
-     *
-     * If left undefined the JavaScript representation of these layouts
-     * will be Object instances.
-     *
-     * See {@link bindConstructorLayout}.
-     */
-    makeDestinationObject() {
-        return {};
-    }
-    /**
-     * Calculate the span of a specific instance of a layout.
-     *
-     * @param {Uint8Array} b - the buffer that contains an encoded instance.
-     *
-     * @param {Number} [offset] - the offset at which the encoded instance
-     * starts.  If absent a zero offset is inferred.
-     *
-     * @return {Number} - the number of bytes covered by the layout
-     * instance.  If this method is not overridden in a subclass the
-     * definition-time constant {@link Layout#span|span} will be
-     * returned.
-     *
-     * @throws {RangeError} - if the length of the value cannot be
-     * determined.
-     */
-    getSpan(b, offset) {
-        if (0 > this.span) {
-            throw new RangeError('indeterminate span');
-        }
-        return this.span;
-    }
-    /**
-     * Replicate the layout using a new property.
-     *
-     * This function must be used to get a structurally-equivalent layout
-     * with a different name since all {@link Layout} instances are
-     * immutable.
-     *
-     * **NOTE** This is a shallow copy.  All fields except {@link
-     * Layout#property|property} are strictly equal to the origin layout.
-     *
-     * @param {String} property - the value for {@link
-     * Layout#property|property} in the replica.
-     *
-     * @returns {Layout} - the copy with {@link Layout#property|property}
-     * set to `property`.
-     */
-    replicate(property) {
-        const rv = Object.create(this.constructor.prototype);
-        Object.assign(rv, this);
-        rv.property = property;
-        return rv;
-    }
-    /**
-     * Create an object from layout properties and an array of values.
-     *
-     * **NOTE** This function returns `undefined` if invoked on a layout
-     * that does not return its value as an Object.  Objects are
-     * returned for things that are a {@link Structure}, which includes
-     * {@link VariantLayout|variant layouts} if they are structures, and
-     * excludes {@link Union}s.  If you want this feature for a union
-     * you must use {@link Union.getVariant|getVariant} to select the
-     * desired layout.
-     *
-     * @param {Array} values - an array of values that correspond to the
-     * default order for properties.  As with {@link Layout#decode|decode}
-     * layout elements that have no property name are skipped when
-     * iterating over the array values.  Only the top-level properties are
-     * assigned; arguments are not assigned to properties of contained
-     * layouts.  Any unused values are ignored.
-     *
-     * @return {(Object|undefined)}
-     */
-    fromArray(values) {
-        return undefined;
-    }
-}
-Layout$1.Layout = Layout;
-/* Provide text that carries a name (such as for a function that will
- * be throwing an error) annotated with the property of a given layout
- * (such as one for which the value was unacceptable).
- *
- * @ignore */
-function nameWithProperty(name, lo) {
-    if (lo.property) {
-        return name + '[' + lo.property + ']';
-    }
-    return name;
-}
-Layout$1.nameWithProperty = nameWithProperty;
-/**
- * Augment a class so that instances can be encoded/decoded using a
- * given layout.
- *
- * Calling this function couples `Class` with `layout` in several ways:
- *
- * * `Class.layout_` becomes a static member property equal to `layout`;
- * * `layout.boundConstructor_` becomes a static member property equal
- *    to `Class`;
- * * The {@link Layout#makeDestinationObject|makeDestinationObject()}
- *   property of `layout` is set to a function that returns a `new
- *   Class()`;
- * * `Class.decode(b, offset)` becomes a static member function that
- *   delegates to {@link Layout#decode|layout.decode}.  The
- *   synthesized function may be captured and extended.
- * * `Class.prototype.encode(b, offset)` provides an instance member
- *   function that delegates to {@link Layout#encode|layout.encode}
- *   with `src` set to `this`.  The synthesized function may be
- *   captured and extended, but when the extension is invoked `this`
- *   must be explicitly bound to the instance.
- *
- * @param {class} Class - a JavaScript class with a nullary
- * constructor.
- *
- * @param {Layout} layout - the {@link Layout} instance used to encode
- * instances of `Class`.
- */
-// `Class` must be a constructor Function, but the assignment of a `layout_` property to it makes it difficult to type
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-function bindConstructorLayout(Class, layout) {
-    if ('function' !== typeof Class) {
-        throw new TypeError('Class must be constructor');
-    }
-    if (Object.prototype.hasOwnProperty.call(Class, 'layout_')) {
-        throw new Error('Class is already bound to a layout');
-    }
-    if (!(layout && (layout instanceof Layout))) {
-        throw new TypeError('layout must be a Layout');
-    }
-    if (Object.prototype.hasOwnProperty.call(layout, 'boundConstructor_')) {
-        throw new Error('layout is already bound to a constructor');
-    }
-    Class.layout_ = layout;
-    layout.boundConstructor_ = Class;
-    layout.makeDestinationObject = (() => new Class());
-    Object.defineProperty(Class.prototype, 'encode', {
-        value(b, offset) {
-            return layout.encode(this, b, offset);
-        },
-        writable: true,
-    });
-    Object.defineProperty(Class, 'decode', {
-        value(b, offset) {
-            return layout.decode(b, offset);
-        },
-        writable: true,
-    });
-}
-Layout$1.bindConstructorLayout = bindConstructorLayout;
-/**
- * An object that behaves like a layout but does not consume space
- * within its containing layout.
- *
- * This is primarily used to obtain metadata about a member, such as a
- * {@link OffsetLayout} that can provide data about a {@link
- * Layout#getSpan|value-specific span}.
- *
- * **NOTE** This is an abstract base class; you can create instances
- * if it amuses you, but they won't support {@link
- * ExternalLayout#isCount|isCount} or other {@link Layout} functions.
- *
- * @param {Number} span - initializer for {@link Layout#span|span}.
- * The parameter can range from 1 through 6.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @abstract
- * @augments {Layout}
- */
-class ExternalLayout extends Layout {
-    /**
-     * Return `true` iff the external layout decodes to an unsigned
-     * integer layout.
-     *
-     * In that case it can be used as the source of {@link
-     * Sequence#count|Sequence counts}, {@link Blob#length|Blob lengths},
-     * or as {@link UnionLayoutDiscriminator#layout|external union
-     * discriminators}.
-     *
-     * @abstract
-     */
-    isCount() {
-        throw new Error('ExternalLayout is abstract');
-    }
-}
-Layout$1.ExternalLayout = ExternalLayout;
-/**
- * An {@link ExternalLayout} that determines its {@link
- * Layout#decode|value} based on offset into and length of the buffer
- * on which it is invoked.
- *
- * *Factory*: {@link module:Layout.greedy|greedy}
- *
- * @param {Number} [elementSpan] - initializer for {@link
- * GreedyCount#elementSpan|elementSpan}.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {ExternalLayout}
- */
-class GreedyCount extends ExternalLayout {
-    constructor(elementSpan = 1, property) {
-        if ((!Number.isInteger(elementSpan)) || (0 >= elementSpan)) {
-            throw new TypeError('elementSpan must be a (positive) integer');
-        }
-        super(-1, property);
-        /** The layout for individual elements of the sequence.  The value
-         * must be a positive integer.  If not provided, the value will be
-         * 1. */
-        this.elementSpan = elementSpan;
-    }
-    /** @override */
-    isCount() {
-        return true;
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        checkUint8Array(b);
-        const rem = b.length - offset;
-        return Math.floor(rem / this.elementSpan);
-    }
-    /** @override */
-    encode(src, b, offset) {
-        return 0;
-    }
-}
-Layout$1.GreedyCount = GreedyCount;
-/**
- * An {@link ExternalLayout} that supports accessing a {@link Layout}
- * at a fixed offset from the start of another Layout.  The offset may
- * be before, within, or after the base layout.
- *
- * *Factory*: {@link module:Layout.offset|offset}
- *
- * @param {Layout} layout - initializer for {@link
- * OffsetLayout#layout|layout}, modulo `property`.
- *
- * @param {Number} [offset] - Initializes {@link
- * OffsetLayout#offset|offset}.  Defaults to zero.
- *
- * @param {string} [property] - Optional new property name for a
- * {@link Layout#replicate| replica} of `layout` to be used as {@link
- * OffsetLayout#layout|layout}.  If not provided the `layout` is used
- * unchanged.
- *
- * @augments {Layout}
- */
-class OffsetLayout extends ExternalLayout {
-    constructor(layout, offset = 0, property) {
-        if (!(layout instanceof Layout)) {
-            throw new TypeError('layout must be a Layout');
-        }
-        if (!Number.isInteger(offset)) {
-            throw new TypeError('offset must be integer or undefined');
-        }
-        super(layout.span, property || layout.property);
-        /** The subordinated layout. */
-        this.layout = layout;
-        /** The location of {@link OffsetLayout#layout} relative to the
-         * start of another layout.
-         *
-         * The value may be positive or negative, but an error will thrown
-         * if at the point of use it goes outside the span of the Uint8Array
-         * being accessed.  */
-        this.offset = offset;
-    }
-    /** @override */
-    isCount() {
-        return ((this.layout instanceof UInt)
-            || (this.layout instanceof UIntBE));
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        return this.layout.decode(b, offset + this.offset);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        return this.layout.encode(src, b, offset + this.offset);
-    }
-}
-Layout$1.OffsetLayout = OffsetLayout;
-/**
- * Represent an unsigned integer in little-endian format.
- *
- * *Factory*: {@link module:Layout.u8|u8}, {@link
- *  module:Layout.u16|u16}, {@link module:Layout.u24|u24}, {@link
- *  module:Layout.u32|u32}, {@link module:Layout.u40|u40}, {@link
- *  module:Layout.u48|u48}
- *
- * @param {Number} span - initializer for {@link Layout#span|span}.
- * The parameter can range from 1 through 6.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class UInt extends Layout {
-    constructor(span, property) {
-        super(span, property);
-        if (6 < this.span) {
-            throw new RangeError('span must not exceed 6 bytes');
-        }
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        return uint8ArrayToBuffer(b).readUIntLE(offset, this.span);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        uint8ArrayToBuffer(b).writeUIntLE(src, offset, this.span);
-        return this.span;
-    }
-}
-Layout$1.UInt = UInt;
-/**
- * Represent an unsigned integer in big-endian format.
- *
- * *Factory*: {@link module:Layout.u8be|u8be}, {@link
- * module:Layout.u16be|u16be}, {@link module:Layout.u24be|u24be},
- * {@link module:Layout.u32be|u32be}, {@link
- * module:Layout.u40be|u40be}, {@link module:Layout.u48be|u48be}
- *
- * @param {Number} span - initializer for {@link Layout#span|span}.
- * The parameter can range from 1 through 6.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class UIntBE extends Layout {
-    constructor(span, property) {
-        super(span, property);
-        if (6 < this.span) {
-            throw new RangeError('span must not exceed 6 bytes');
-        }
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        return uint8ArrayToBuffer(b).readUIntBE(offset, this.span);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        uint8ArrayToBuffer(b).writeUIntBE(src, offset, this.span);
-        return this.span;
-    }
-}
-Layout$1.UIntBE = UIntBE;
-/**
- * Represent a signed integer in little-endian format.
- *
- * *Factory*: {@link module:Layout.s8|s8}, {@link
- *  module:Layout.s16|s16}, {@link module:Layout.s24|s24}, {@link
- *  module:Layout.s32|s32}, {@link module:Layout.s40|s40}, {@link
- *  module:Layout.s48|s48}
- *
- * @param {Number} span - initializer for {@link Layout#span|span}.
- * The parameter can range from 1 through 6.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class Int extends Layout {
-    constructor(span, property) {
-        super(span, property);
-        if (6 < this.span) {
-            throw new RangeError('span must not exceed 6 bytes');
-        }
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        return uint8ArrayToBuffer(b).readIntLE(offset, this.span);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        uint8ArrayToBuffer(b).writeIntLE(src, offset, this.span);
-        return this.span;
-    }
-}
-Layout$1.Int = Int;
-/**
- * Represent a signed integer in big-endian format.
- *
- * *Factory*: {@link module:Layout.s8be|s8be}, {@link
- * module:Layout.s16be|s16be}, {@link module:Layout.s24be|s24be},
- * {@link module:Layout.s32be|s32be}, {@link
- * module:Layout.s40be|s40be}, {@link module:Layout.s48be|s48be}
- *
- * @param {Number} span - initializer for {@link Layout#span|span}.
- * The parameter can range from 1 through 6.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class IntBE extends Layout {
-    constructor(span, property) {
-        super(span, property);
-        if (6 < this.span) {
-            throw new RangeError('span must not exceed 6 bytes');
-        }
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        return uint8ArrayToBuffer(b).readIntBE(offset, this.span);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        uint8ArrayToBuffer(b).writeIntBE(src, offset, this.span);
-        return this.span;
-    }
-}
-Layout$1.IntBE = IntBE;
-const V2E32 = Math.pow(2, 32);
-/* True modulus high and low 32-bit words, where low word is always
- * non-negative. */
-function divmodInt64(src) {
-    const hi32 = Math.floor(src / V2E32);
-    const lo32 = src - (hi32 * V2E32);
-    return { hi32, lo32 };
-}
-/* Reconstruct Number from quotient and non-negative remainder */
-function roundedInt64(hi32, lo32) {
-    return hi32 * V2E32 + lo32;
-}
-/**
- * Represent an unsigned 64-bit integer in little-endian format when
- * encoded and as a near integral JavaScript Number when decoded.
- *
- * *Factory*: {@link module:Layout.nu64|nu64}
- *
- * **NOTE** Values with magnitude greater than 2^52 may not decode to
- * the exact value of the encoded representation.
- *
- * @augments {Layout}
- */
-class NearUInt64 extends Layout {
-    constructor(property) {
-        super(8, property);
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        const buffer = uint8ArrayToBuffer(b);
-        const lo32 = buffer.readUInt32LE(offset);
-        const hi32 = buffer.readUInt32LE(offset + 4);
-        return roundedInt64(hi32, lo32);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        const split = divmodInt64(src);
-        const buffer = uint8ArrayToBuffer(b);
-        buffer.writeUInt32LE(split.lo32, offset);
-        buffer.writeUInt32LE(split.hi32, offset + 4);
-        return 8;
-    }
-}
-Layout$1.NearUInt64 = NearUInt64;
-/**
- * Represent an unsigned 64-bit integer in big-endian format when
- * encoded and as a near integral JavaScript Number when decoded.
- *
- * *Factory*: {@link module:Layout.nu64be|nu64be}
- *
- * **NOTE** Values with magnitude greater than 2^52 may not decode to
- * the exact value of the encoded representation.
- *
- * @augments {Layout}
- */
-class NearUInt64BE extends Layout {
-    constructor(property) {
-        super(8, property);
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        const buffer = uint8ArrayToBuffer(b);
-        const hi32 = buffer.readUInt32BE(offset);
-        const lo32 = buffer.readUInt32BE(offset + 4);
-        return roundedInt64(hi32, lo32);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        const split = divmodInt64(src);
-        const buffer = uint8ArrayToBuffer(b);
-        buffer.writeUInt32BE(split.hi32, offset);
-        buffer.writeUInt32BE(split.lo32, offset + 4);
-        return 8;
-    }
-}
-Layout$1.NearUInt64BE = NearUInt64BE;
-/**
- * Represent a signed 64-bit integer in little-endian format when
- * encoded and as a near integral JavaScript Number when decoded.
- *
- * *Factory*: {@link module:Layout.ns64|ns64}
- *
- * **NOTE** Values with magnitude greater than 2^52 may not decode to
- * the exact value of the encoded representation.
- *
- * @augments {Layout}
- */
-class NearInt64 extends Layout {
-    constructor(property) {
-        super(8, property);
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        const buffer = uint8ArrayToBuffer(b);
-        const lo32 = buffer.readUInt32LE(offset);
-        const hi32 = buffer.readInt32LE(offset + 4);
-        return roundedInt64(hi32, lo32);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        const split = divmodInt64(src);
-        const buffer = uint8ArrayToBuffer(b);
-        buffer.writeUInt32LE(split.lo32, offset);
-        buffer.writeInt32LE(split.hi32, offset + 4);
-        return 8;
-    }
-}
-Layout$1.NearInt64 = NearInt64;
-/**
- * Represent a signed 64-bit integer in big-endian format when
- * encoded and as a near integral JavaScript Number when decoded.
- *
- * *Factory*: {@link module:Layout.ns64be|ns64be}
- *
- * **NOTE** Values with magnitude greater than 2^52 may not decode to
- * the exact value of the encoded representation.
- *
- * @augments {Layout}
- */
-class NearInt64BE extends Layout {
-    constructor(property) {
-        super(8, property);
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        const buffer = uint8ArrayToBuffer(b);
-        const hi32 = buffer.readInt32BE(offset);
-        const lo32 = buffer.readUInt32BE(offset + 4);
-        return roundedInt64(hi32, lo32);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        const split = divmodInt64(src);
-        const buffer = uint8ArrayToBuffer(b);
-        buffer.writeInt32BE(split.hi32, offset);
-        buffer.writeUInt32BE(split.lo32, offset + 4);
-        return 8;
-    }
-}
-Layout$1.NearInt64BE = NearInt64BE;
-/**
- * Represent a 32-bit floating point number in little-endian format.
- *
- * *Factory*: {@link module:Layout.f32|f32}
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class Float extends Layout {
-    constructor(property) {
-        super(4, property);
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        return uint8ArrayToBuffer(b).readFloatLE(offset);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        uint8ArrayToBuffer(b).writeFloatLE(src, offset);
-        return 4;
-    }
-}
-Layout$1.Float = Float;
-/**
- * Represent a 32-bit floating point number in big-endian format.
- *
- * *Factory*: {@link module:Layout.f32be|f32be}
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class FloatBE extends Layout {
-    constructor(property) {
-        super(4, property);
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        return uint8ArrayToBuffer(b).readFloatBE(offset);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        uint8ArrayToBuffer(b).writeFloatBE(src, offset);
-        return 4;
-    }
-}
-Layout$1.FloatBE = FloatBE;
-/**
- * Represent a 64-bit floating point number in little-endian format.
- *
- * *Factory*: {@link module:Layout.f64|f64}
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class Double extends Layout {
-    constructor(property) {
-        super(8, property);
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        return uint8ArrayToBuffer(b).readDoubleLE(offset);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        uint8ArrayToBuffer(b).writeDoubleLE(src, offset);
-        return 8;
-    }
-}
-Layout$1.Double = Double;
-/**
- * Represent a 64-bit floating point number in big-endian format.
- *
- * *Factory*: {@link module:Layout.f64be|f64be}
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class DoubleBE extends Layout {
-    constructor(property) {
-        super(8, property);
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        return uint8ArrayToBuffer(b).readDoubleBE(offset);
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        uint8ArrayToBuffer(b).writeDoubleBE(src, offset);
-        return 8;
-    }
-}
-Layout$1.DoubleBE = DoubleBE;
-/**
- * Represent a contiguous sequence of a specific layout as an Array.
- *
- * *Factory*: {@link module:Layout.seq|seq}
- *
- * @param {Layout} elementLayout - initializer for {@link
- * Sequence#elementLayout|elementLayout}.
- *
- * @param {(Number|ExternalLayout)} count - initializer for {@link
- * Sequence#count|count}.  The parameter must be either a positive
- * integer or an instance of {@link ExternalLayout}.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class Sequence extends Layout {
-    constructor(elementLayout, count, property) {
-        if (!(elementLayout instanceof Layout)) {
-            throw new TypeError('elementLayout must be a Layout');
-        }
-        if (!(((count instanceof ExternalLayout) && count.isCount())
-            || (Number.isInteger(count) && (0 <= count)))) {
-            throw new TypeError('count must be non-negative integer '
-                + 'or an unsigned integer ExternalLayout');
-        }
-        let span = -1;
-        if ((!(count instanceof ExternalLayout))
-            && (0 < elementLayout.span)) {
-            span = count * elementLayout.span;
-        }
-        super(span, property);
-        /** The layout for individual elements of the sequence. */
-        this.elementLayout = elementLayout;
-        /** The number of elements in the sequence.
-         *
-         * This will be either a non-negative integer or an instance of
-         * {@link ExternalLayout} for which {@link
-         * ExternalLayout#isCount|isCount()} is `true`. */
-        this.count = count;
-    }
-    /** @override */
-    getSpan(b, offset = 0) {
-        if (0 <= this.span) {
-            return this.span;
-        }
-        let span = 0;
-        let count = this.count;
-        if (count instanceof ExternalLayout) {
-            count = count.decode(b, offset);
-        }
-        if (0 < this.elementLayout.span) {
-            span = count * this.elementLayout.span;
-        }
-        else {
-            let idx = 0;
-            while (idx < count) {
-                span += this.elementLayout.getSpan(b, offset + span);
-                ++idx;
-            }
-        }
-        return span;
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        const rv = [];
-        let i = 0;
-        let count = this.count;
-        if (count instanceof ExternalLayout) {
-            count = count.decode(b, offset);
-        }
-        while (i < count) {
-            rv.push(this.elementLayout.decode(b, offset));
-            offset += this.elementLayout.getSpan(b, offset);
-            i += 1;
-        }
-        return rv;
-    }
-    /** Implement {@link Layout#encode|encode} for {@link Sequence}.
-     *
-     * **NOTE** If `src` is shorter than {@link Sequence#count|count} then
-     * the unused space in the buffer is left unchanged.  If `src` is
-     * longer than {@link Sequence#count|count} the unneeded elements are
-     * ignored.
-     *
-     * **NOTE** If {@link Layout#count|count} is an instance of {@link
-     * ExternalLayout} then the length of `src` will be encoded as the
-     * count after `src` is encoded. */
-    encode(src, b, offset = 0) {
-        const elo = this.elementLayout;
-        const span = src.reduce((span, v) => {
-            return span + elo.encode(v, b, offset + span);
-        }, 0);
-        if (this.count instanceof ExternalLayout) {
-            this.count.encode(src.length, b, offset);
-        }
-        return span;
-    }
-}
-Layout$1.Sequence = Sequence;
-/**
- * Represent a contiguous sequence of arbitrary layout elements as an
- * Object.
- *
- * *Factory*: {@link module:Layout.struct|struct}
- *
- * **NOTE** The {@link Layout#span|span} of the structure is variable
- * if any layout in {@link Structure#fields|fields} has a variable
- * span.  When {@link Layout#encode|encoding} we must have a value for
- * all variable-length fields, or we wouldn't be able to figure out
- * how much space to use for storage.  We can only identify the value
- * for a field when it has a {@link Layout#property|property}.  As
- * such, although a structure may contain both unnamed fields and
- * variable-length fields, it cannot contain an unnamed
- * variable-length field.
- *
- * @param {Layout[]} fields - initializer for {@link
- * Structure#fields|fields}.  An error is raised if this contains a
- * variable-length field for which a {@link Layout#property|property}
- * is not defined.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @param {Boolean} [decodePrefixes] - initializer for {@link
- * Structure#decodePrefixes|property}.
- *
- * @throws {Error} - if `fields` contains an unnamed variable-length
- * layout.
- *
- * @augments {Layout}
- */
-class Structure extends Layout {
-    constructor(fields, property, decodePrefixes) {
-        if (!(Array.isArray(fields)
-            && fields.reduce((acc, v) => acc && (v instanceof Layout), true))) {
-            throw new TypeError('fields must be array of Layout instances');
-        }
-        if (('boolean' === typeof property)
-            && (undefined === decodePrefixes)) {
-            decodePrefixes = property;
-            property = undefined;
-        }
-        /* Verify absence of unnamed variable-length fields. */
-        for (const fd of fields) {
-            if ((0 > fd.span)
-                && (undefined === fd.property)) {
-                throw new Error('fields cannot contain unnamed variable-length layout');
-            }
-        }
-        let span = -1;
-        try {
-            span = fields.reduce((span, fd) => span + fd.getSpan(), 0);
-        }
-        catch (e) {
-            // ignore error
-        }
-        super(span, property);
-        /** The sequence of {@link Layout} values that comprise the
-         * structure.
-         *
-         * The individual elements need not be the same type, and may be
-         * either scalar or aggregate layouts.  If a member layout leaves
-         * its {@link Layout#property|property} undefined the
-         * corresponding region of the buffer associated with the element
-         * will not be mutated.
-         *
-         * @type {Layout[]} */
-        this.fields = fields;
-        /** Control behavior of {@link Layout#decode|decode()} given short
-         * buffers.
-         *
-         * In some situations a structure many be extended with additional
-         * fields over time, with older installations providing only a
-         * prefix of the full structure.  If this property is `true`
-         * decoding will accept those buffers and leave subsequent fields
-         * undefined, as long as the buffer ends at a field boundary.
-         * Defaults to `false`. */
-        this.decodePrefixes = !!decodePrefixes;
-    }
-    /** @override */
-    getSpan(b, offset = 0) {
-        if (0 <= this.span) {
-            return this.span;
-        }
-        let span = 0;
-        try {
-            span = this.fields.reduce((span, fd) => {
-                const fsp = fd.getSpan(b, offset);
-                offset += fsp;
-                return span + fsp;
-            }, 0);
-        }
-        catch (e) {
-            throw new RangeError('indeterminate span');
-        }
-        return span;
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        checkUint8Array(b);
-        const dest = this.makeDestinationObject();
-        for (const fd of this.fields) {
-            if (undefined !== fd.property) {
-                dest[fd.property] = fd.decode(b, offset);
-            }
-            offset += fd.getSpan(b, offset);
-            if (this.decodePrefixes
-                && (b.length === offset)) {
-                break;
-            }
-        }
-        return dest;
-    }
-    /** Implement {@link Layout#encode|encode} for {@link Structure}.
-     *
-     * If `src` is missing a property for a member with a defined {@link
-     * Layout#property|property} the corresponding region of the buffer is
-     * left unmodified. */
-    encode(src, b, offset = 0) {
-        const firstOffset = offset;
-        let lastOffset = 0;
-        let lastWrote = 0;
-        for (const fd of this.fields) {
-            let span = fd.span;
-            lastWrote = (0 < span) ? span : 0;
-            if (undefined !== fd.property) {
-                const fv = src[fd.property];
-                if (undefined !== fv) {
-                    lastWrote = fd.encode(fv, b, offset);
-                    if (0 > span) {
-                        /* Read the as-encoded span, which is not necessarily the
-                         * same as what we wrote. */
-                        span = fd.getSpan(b, offset);
-                    }
-                }
-            }
-            lastOffset = offset;
-            offset += span;
-        }
-        /* Use (lastOffset + lastWrote) instead of offset because the last
-         * item may have had a dynamic length and we don't want to include
-         * the padding between it and the end of the space reserved for
-         * it. */
-        return (lastOffset + lastWrote) - firstOffset;
-    }
-    /** @override */
-    fromArray(values) {
-        const dest = this.makeDestinationObject();
-        for (const fd of this.fields) {
-            if ((undefined !== fd.property)
-                && (0 < values.length)) {
-                dest[fd.property] = values.shift();
-            }
-        }
-        return dest;
-    }
-    /**
-     * Get access to the layout of a given property.
-     *
-     * @param {String} property - the structure member of interest.
-     *
-     * @return {Layout} - the layout associated with `property`, or
-     * undefined if there is no such property.
-     */
-    layoutFor(property) {
-        if ('string' !== typeof property) {
-            throw new TypeError('property must be string');
-        }
-        for (const fd of this.fields) {
-            if (fd.property === property) {
-                return fd;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Get the offset of a structure member.
-     *
-     * @param {String} property - the structure member of interest.
-     *
-     * @return {Number} - the offset in bytes to the start of `property`
-     * within the structure, or undefined if `property` is not a field
-     * within the structure.  If the property is a member but follows a
-     * variable-length structure member a negative number will be
-     * returned.
-     */
-    offsetOf(property) {
-        if ('string' !== typeof property) {
-            throw new TypeError('property must be string');
-        }
-        let offset = 0;
-        for (const fd of this.fields) {
-            if (fd.property === property) {
-                return offset;
-            }
-            if (0 > fd.span) {
-                offset = -1;
-            }
-            else if (0 <= offset) {
-                offset += fd.span;
-            }
-        }
-        return undefined;
-    }
-}
-Layout$1.Structure = Structure;
-/**
- * An object that can provide a {@link
- * Union#discriminator|discriminator} API for {@link Union}.
- *
- * **NOTE** This is an abstract base class; you can create instances
- * if it amuses you, but they won't support the {@link
- * UnionDiscriminator#encode|encode} or {@link
- * UnionDiscriminator#decode|decode} functions.
- *
- * @param {string} [property] - Default for {@link
- * UnionDiscriminator#property|property}.
- *
- * @abstract
- */
-class UnionDiscriminator {
-    constructor(property) {
-        /** The {@link Layout#property|property} to be used when the
-         * discriminator is referenced in isolation (generally when {@link
-         * Union#decode|Union decode} cannot delegate to a specific
-         * variant). */
-        this.property = property;
-    }
-    /** Analog to {@link Layout#decode|Layout decode} for union discriminators.
-     *
-     * The implementation of this method need not reference the buffer if
-     * variant information is available through other means. */
-    decode(b, offset) {
-        throw new Error('UnionDiscriminator is abstract');
-    }
-    /** Analog to {@link Layout#decode|Layout encode} for union discriminators.
-     *
-     * The implementation of this method need not store the value if
-     * variant information is maintained through other means. */
-    encode(src, b, offset) {
-        throw new Error('UnionDiscriminator is abstract');
-    }
-}
-Layout$1.UnionDiscriminator = UnionDiscriminator;
-/**
- * An object that can provide a {@link
- * UnionDiscriminator|discriminator API} for {@link Union} using an
- * unsigned integral {@link Layout} instance located either inside or
- * outside the union.
- *
- * @param {ExternalLayout} layout - initializes {@link
- * UnionLayoutDiscriminator#layout|layout}.  Must satisfy {@link
- * ExternalLayout#isCount|isCount()}.
- *
- * @param {string} [property] - Default for {@link
- * UnionDiscriminator#property|property}, superseding the property
- * from `layout`, but defaulting to `variant` if neither `property`
- * nor layout provide a property name.
- *
- * @augments {UnionDiscriminator}
- */
-class UnionLayoutDiscriminator extends UnionDiscriminator {
-    constructor(layout, property) {
-        if (!((layout instanceof ExternalLayout)
-            && layout.isCount())) {
-            throw new TypeError('layout must be an unsigned integer ExternalLayout');
-        }
-        super(property || layout.property || 'variant');
-        /** The {@link ExternalLayout} used to access the discriminator
-         * value. */
-        this.layout = layout;
-    }
-    /** Delegate decoding to {@link UnionLayoutDiscriminator#layout|layout}. */
-    decode(b, offset) {
-        return this.layout.decode(b, offset);
-    }
-    /** Delegate encoding to {@link UnionLayoutDiscriminator#layout|layout}. */
-    encode(src, b, offset) {
-        return this.layout.encode(src, b, offset);
-    }
-}
-Layout$1.UnionLayoutDiscriminator = UnionLayoutDiscriminator;
-/**
- * Represent any number of span-compatible layouts.
- *
- * *Factory*: {@link module:Layout.union|union}
- *
- * If the union has a {@link Union#defaultLayout|default layout} that
- * layout must have a non-negative {@link Layout#span|span}.  The span
- * of a fixed-span union includes its {@link
- * Union#discriminator|discriminator} if the variant is a {@link
- * Union#usesPrefixDiscriminator|prefix of the union}, plus the span
- * of its {@link Union#defaultLayout|default layout}.
- *
- * If the union does not have a default layout then the encoded span
- * of the union depends on the encoded span of its variant (which may
- * be fixed or variable).
- *
- * {@link VariantLayout#layout|Variant layout}s are added through
- * {@link Union#addVariant|addVariant}.  If the union has a default
- * layout, the span of the {@link VariantLayout#layout|layout
- * contained by the variant} must not exceed the span of the {@link
- * Union#defaultLayout|default layout} (minus the span of a {@link
- * Union#usesPrefixDiscriminator|prefix disriminator}, if used).  The
- * span of the variant will equal the span of the union itself.
- *
- * The variant for a buffer can only be identified from the {@link
- * Union#discriminator|discriminator} {@link
- * UnionDiscriminator#property|property} (in the case of the {@link
- * Union#defaultLayout|default layout}), or by using {@link
- * Union#getVariant|getVariant} and examining the resulting {@link
- * VariantLayout} instance.
- *
- * A variant compatible with a JavaScript object can be identified
- * using {@link Union#getSourceVariant|getSourceVariant}.
- *
- * @param {(UnionDiscriminator|ExternalLayout|Layout)} discr - How to
- * identify the layout used to interpret the union contents.  The
- * parameter must be an instance of {@link UnionDiscriminator}, an
- * {@link ExternalLayout} that satisfies {@link
- * ExternalLayout#isCount|isCount()}, or {@link UInt} (or {@link
- * UIntBE}).  When a non-external layout element is passed the layout
- * appears at the start of the union.  In all cases the (synthesized)
- * {@link UnionDiscriminator} instance is recorded as {@link
- * Union#discriminator|discriminator}.
- *
- * @param {(Layout|null)} defaultLayout - initializer for {@link
- * Union#defaultLayout|defaultLayout}.  If absent defaults to `null`.
- * If `null` there is no default layout: the union has data-dependent
- * length and attempts to decode or encode unrecognized variants will
- * throw an exception.  A {@link Layout} instance must have a
- * non-negative {@link Layout#span|span}, and if it lacks a {@link
- * Layout#property|property} the {@link
- * Union#defaultLayout|defaultLayout} will be a {@link
- * Layout#replicate|replica} with property `content`.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class Union extends Layout {
-    constructor(discr, defaultLayout, property) {
-        let discriminator;
-        if ((discr instanceof UInt)
-            || (discr instanceof UIntBE)) {
-            discriminator = new UnionLayoutDiscriminator(new OffsetLayout(discr));
-        }
-        else if ((discr instanceof ExternalLayout)
-            && discr.isCount()) {
-            discriminator = new UnionLayoutDiscriminator(discr);
-        }
-        else if (!(discr instanceof UnionDiscriminator)) {
-            throw new TypeError('discr must be a UnionDiscriminator '
-                + 'or an unsigned integer layout');
-        }
-        else {
-            discriminator = discr;
-        }
-        if (undefined === defaultLayout) {
-            defaultLayout = null;
-        }
-        if (!((null === defaultLayout)
-            || (defaultLayout instanceof Layout))) {
-            throw new TypeError('defaultLayout must be null or a Layout');
-        }
-        if (null !== defaultLayout) {
-            if (0 > defaultLayout.span) {
-                throw new Error('defaultLayout must have constant span');
-            }
-            if (undefined === defaultLayout.property) {
-                defaultLayout = defaultLayout.replicate('content');
-            }
-        }
-        /* The union span can be estimated only if there's a default
-         * layout.  The union spans its default layout, plus any prefix
-         * variant layout.  By construction both layouts, if present, have
-         * non-negative span. */
-        let span = -1;
-        if (defaultLayout) {
-            span = defaultLayout.span;
-            if ((0 <= span) && ((discr instanceof UInt)
-                || (discr instanceof UIntBE))) {
-                span += discriminator.layout.span;
-            }
-        }
-        super(span, property);
-        /** The interface for the discriminator value in isolation.
-         *
-         * This a {@link UnionDiscriminator} either passed to the
-         * constructor or synthesized from the `discr` constructor
-         * argument.  {@link
-         * Union#usesPrefixDiscriminator|usesPrefixDiscriminator} will be
-         * `true` iff the `discr` parameter was a non-offset {@link
-         * Layout} instance. */
-        this.discriminator = discriminator;
-        /** `true` if the {@link Union#discriminator|discriminator} is the
-         * first field in the union.
-         *
-         * If `false` the discriminator is obtained from somewhere
-         * else. */
-        this.usesPrefixDiscriminator = (discr instanceof UInt)
-            || (discr instanceof UIntBE);
-        /** The layout for non-discriminator content when the value of the
-         * discriminator is not recognized.
-         *
-         * This is the value passed to the constructor.  It is
-         * structurally equivalent to the second component of {@link
-         * Union#layout|layout} but may have a different property
-         * name. */
-        this.defaultLayout = defaultLayout;
-        /** A registry of allowed variants.
-         *
-         * The keys are unsigned integers which should be compatible with
-         * {@link Union.discriminator|discriminator}.  The property value
-         * is the corresponding {@link VariantLayout} instances assigned
-         * to this union by {@link Union#addVariant|addVariant}.
-         *
-         * **NOTE** The registry remains mutable so that variants can be
-         * {@link Union#addVariant|added} at any time.  Users should not
-         * manipulate the content of this property. */
-        this.registry = {};
-        /* Private variable used when invoking getSourceVariant */
-        let boundGetSourceVariant = this.defaultGetSourceVariant.bind(this);
-        /** Function to infer the variant selected by a source object.
-         *
-         * Defaults to {@link
-         * Union#defaultGetSourceVariant|defaultGetSourceVariant} but may
-         * be overridden using {@link
-         * Union#configGetSourceVariant|configGetSourceVariant}.
-         *
-         * @param {Object} src - as with {@link
-         * Union#defaultGetSourceVariant|defaultGetSourceVariant}.
-         *
-         * @returns {(undefined|VariantLayout)} The default variant
-         * (`undefined`) or first registered variant that uses a property
-         * available in `src`. */
-        this.getSourceVariant = function (src) {
-            return boundGetSourceVariant(src);
-        };
-        /** Function to override the implementation of {@link
-         * Union#getSourceVariant|getSourceVariant}.
-         *
-         * Use this if the desired variant cannot be identified using the
-         * algorithm of {@link
-         * Union#defaultGetSourceVariant|defaultGetSourceVariant}.
-         *
-         * **NOTE** The provided function will be invoked bound to this
-         * Union instance, providing local access to {@link
-         * Union#registry|registry}.
-         *
-         * @param {Function} gsv - a function that follows the API of
-         * {@link Union#defaultGetSourceVariant|defaultGetSourceVariant}. */
-        this.configGetSourceVariant = function (gsv) {
-            boundGetSourceVariant = gsv.bind(this);
-        };
-    }
-    /** @override */
-    getSpan(b, offset = 0) {
-        if (0 <= this.span) {
-            return this.span;
-        }
-        /* Default layouts always have non-negative span, so we don't have
-         * one and we have to recognize the variant which will in turn
-         * determine the span. */
-        const vlo = this.getVariant(b, offset);
-        if (!vlo) {
-            throw new Error('unable to determine span for unrecognized variant');
-        }
-        return vlo.getSpan(b, offset);
-    }
-    /**
-     * Method to infer a registered Union variant compatible with `src`.
-     *
-     * The first satisfied rule in the following sequence defines the
-     * return value:
-     * * If `src` has properties matching the Union discriminator and
-     *   the default layout, `undefined` is returned regardless of the
-     *   value of the discriminator property (this ensures the default
-     *   layout will be used);
-     * * If `src` has a property matching the Union discriminator, the
-     *   value of the discriminator identifies a registered variant, and
-     *   either (a) the variant has no layout, or (b) `src` has the
-     *   variant's property, then the variant is returned (because the
-     *   source satisfies the constraints of the variant it identifies);
-     * * If `src` does not have a property matching the Union
-     *   discriminator, but does have a property matching a registered
-     *   variant, then the variant is returned (because the source
-     *   matches a variant without an explicit conflict);
-     * * An error is thrown (because we either can't identify a variant,
-     *   or we were explicitly told the variant but can't satisfy it).
-     *
-     * @param {Object} src - an object presumed to be compatible with
-     * the content of the Union.
-     *
-     * @return {(undefined|VariantLayout)} - as described above.
-     *
-     * @throws {Error} - if `src` cannot be associated with a default or
-     * registered variant.
-     */
-    defaultGetSourceVariant(src) {
-        if (Object.prototype.hasOwnProperty.call(src, this.discriminator.property)) {
-            if (this.defaultLayout && this.defaultLayout.property
-                && Object.prototype.hasOwnProperty.call(src, this.defaultLayout.property)) {
-                return undefined;
-            }
-            const vlo = this.registry[src[this.discriminator.property]];
-            if (vlo
-                && ((!vlo.layout)
-                    || (vlo.property && Object.prototype.hasOwnProperty.call(src, vlo.property)))) {
-                return vlo;
-            }
-        }
-        else {
-            for (const tag in this.registry) {
-                const vlo = this.registry[tag];
-                if (vlo.property && Object.prototype.hasOwnProperty.call(src, vlo.property)) {
-                    return vlo;
-                }
-            }
-        }
-        throw new Error('unable to infer src variant');
-    }
-    /** Implement {@link Layout#decode|decode} for {@link Union}.
-     *
-     * If the variant is {@link Union#addVariant|registered} the return
-     * value is an instance of that variant, with no explicit
-     * discriminator.  Otherwise the {@link Union#defaultLayout|default
-     * layout} is used to decode the content. */
-    decode(b, offset = 0) {
-        let dest;
-        const dlo = this.discriminator;
-        const discr = dlo.decode(b, offset);
-        const clo = this.registry[discr];
-        if (undefined === clo) {
-            const defaultLayout = this.defaultLayout;
-            let contentOffset = 0;
-            if (this.usesPrefixDiscriminator) {
-                contentOffset = dlo.layout.span;
-            }
-            dest = this.makeDestinationObject();
-            dest[dlo.property] = discr;
-            // defaultLayout.property can be undefined, but this is allowed by buffer-layout
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            dest[defaultLayout.property] = defaultLayout.decode(b, offset + contentOffset);
-        }
-        else {
-            dest = clo.decode(b, offset);
-        }
-        return dest;
-    }
-    /** Implement {@link Layout#encode|encode} for {@link Union}.
-     *
-     * This API assumes the `src` object is consistent with the union's
-     * {@link Union#defaultLayout|default layout}.  To encode variants
-     * use the appropriate variant-specific {@link VariantLayout#encode}
-     * method. */
-    encode(src, b, offset = 0) {
-        const vlo = this.getSourceVariant(src);
-        if (undefined === vlo) {
-            const dlo = this.discriminator;
-            // this.defaultLayout is not undefined when vlo is undefined
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const clo = this.defaultLayout;
-            let contentOffset = 0;
-            if (this.usesPrefixDiscriminator) {
-                contentOffset = dlo.layout.span;
-            }
-            dlo.encode(src[dlo.property], b, offset);
-            // clo.property is not undefined when vlo is undefined
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            return contentOffset + clo.encode(src[clo.property], b, offset + contentOffset);
-        }
-        return vlo.encode(src, b, offset);
-    }
-    /** Register a new variant structure within a union.  The newly
-     * created variant is returned.
-     *
-     * @param {Number} variant - initializer for {@link
-     * VariantLayout#variant|variant}.
-     *
-     * @param {Layout} layout - initializer for {@link
-     * VariantLayout#layout|layout}.
-     *
-     * @param {String} property - initializer for {@link
-     * Layout#property|property}.
-     *
-     * @return {VariantLayout} */
-    addVariant(variant, layout, property) {
-        const rv = new VariantLayout(this, variant, layout, property);
-        this.registry[variant] = rv;
-        return rv;
-    }
-    /**
-     * Get the layout associated with a registered variant.
-     *
-     * If `vb` does not produce a registered variant the function returns
-     * `undefined`.
-     *
-     * @param {(Number|Uint8Array)} vb - either the variant number, or a
-     * buffer from which the discriminator is to be read.
-     *
-     * @param {Number} offset - offset into `vb` for the start of the
-     * union.  Used only when `vb` is an instance of {Uint8Array}.
-     *
-     * @return {({VariantLayout}|undefined)}
-     */
-    getVariant(vb, offset = 0) {
-        let variant;
-        if (vb instanceof Uint8Array) {
-            variant = this.discriminator.decode(vb, offset);
-        }
-        else {
-            variant = vb;
-        }
-        return this.registry[variant];
-    }
-}
-Layout$1.Union = Union;
-/**
- * Represent a specific variant within a containing union.
- *
- * **NOTE** The {@link Layout#span|span} of the variant may include
- * the span of the {@link Union#discriminator|discriminator} used to
- * identify it, but values read and written using the variant strictly
- * conform to the content of {@link VariantLayout#layout|layout}.
- *
- * **NOTE** User code should not invoke this constructor directly.  Use
- * the union {@link Union#addVariant|addVariant} helper method.
- *
- * @param {Union} union - initializer for {@link
- * VariantLayout#union|union}.
- *
- * @param {Number} variant - initializer for {@link
- * VariantLayout#variant|variant}.
- *
- * @param {Layout} [layout] - initializer for {@link
- * VariantLayout#layout|layout}.  If absent the variant carries no
- * data.
- *
- * @param {String} [property] - initializer for {@link
- * Layout#property|property}.  Unlike many other layouts, variant
- * layouts normally include a property name so they can be identified
- * within their containing {@link Union}.  The property identifier may
- * be absent only if `layout` is is absent.
- *
- * @augments {Layout}
- */
-class VariantLayout extends Layout {
-    constructor(union, variant, layout, property) {
-        if (!(union instanceof Union)) {
-            throw new TypeError('union must be a Union');
-        }
-        if ((!Number.isInteger(variant)) || (0 > variant)) {
-            throw new TypeError('variant must be a (non-negative) integer');
-        }
-        if (('string' === typeof layout)
-            && (undefined === property)) {
-            property = layout;
-            layout = null;
-        }
-        if (layout) {
-            if (!(layout instanceof Layout)) {
-                throw new TypeError('layout must be a Layout');
-            }
-            if ((null !== union.defaultLayout)
-                && (0 <= layout.span)
-                && (layout.span > union.defaultLayout.span)) {
-                throw new Error('variant span exceeds span of containing union');
-            }
-            if ('string' !== typeof property) {
-                throw new TypeError('variant must have a String property');
-            }
-        }
-        let span = union.span;
-        if (0 > union.span) {
-            span = layout ? layout.span : 0;
-            if ((0 <= span) && union.usesPrefixDiscriminator) {
-                span += union.discriminator.layout.span;
-            }
-        }
-        super(span, property);
-        /** The {@link Union} to which this variant belongs. */
-        this.union = union;
-        /** The unsigned integral value identifying this variant within
-         * the {@link Union#discriminator|discriminator} of the containing
-         * union. */
-        this.variant = variant;
-        /** The {@link Layout} to be used when reading/writing the
-         * non-discriminator part of the {@link
-         * VariantLayout#union|union}.  If `null` the variant carries no
-         * data. */
-        this.layout = layout || null;
-    }
-    /** @override */
-    getSpan(b, offset = 0) {
-        if (0 <= this.span) {
-            /* Will be equal to the containing union span if that is not
-             * variable. */
-            return this.span;
-        }
-        let contentOffset = 0;
-        if (this.union.usesPrefixDiscriminator) {
-            contentOffset = this.union.discriminator.layout.span;
-        }
-        /* Span is defined solely by the variant (and prefix discriminator) */
-        let span = 0;
-        if (this.layout) {
-            span = this.layout.getSpan(b, offset + contentOffset);
-        }
-        return contentOffset + span;
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        const dest = this.makeDestinationObject();
-        if (this !== this.union.getVariant(b, offset)) {
-            throw new Error('variant mismatch');
-        }
-        let contentOffset = 0;
-        if (this.union.usesPrefixDiscriminator) {
-            contentOffset = this.union.discriminator.layout.span;
-        }
-        if (this.layout) {
-            dest[this.property] = this.layout.decode(b, offset + contentOffset);
-        }
-        else if (this.property) {
-            dest[this.property] = true;
-        }
-        else if (this.union.usesPrefixDiscriminator) {
-            dest[this.union.discriminator.property] = this.variant;
-        }
-        return dest;
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        let contentOffset = 0;
-        if (this.union.usesPrefixDiscriminator) {
-            contentOffset = this.union.discriminator.layout.span;
-        }
-        if (this.layout
-            && (!Object.prototype.hasOwnProperty.call(src, this.property))) {
-            throw new TypeError('variant lacks property ' + this.property);
-        }
-        this.union.discriminator.encode(this.variant, b, offset);
-        let span = contentOffset;
-        if (this.layout) {
-            this.layout.encode(src[this.property], b, offset + contentOffset);
-            span += this.layout.getSpan(b, offset + contentOffset);
-            if ((0 <= this.union.span)
-                && (span > this.union.span)) {
-                throw new Error('encoded variant overruns containing union');
-            }
-        }
-        return span;
-    }
-    /** Delegate {@link Layout#fromArray|fromArray} to {@link
-     * VariantLayout#layout|layout}. */
-    fromArray(values) {
-        if (this.layout) {
-            return this.layout.fromArray(values);
-        }
-        return undefined;
-    }
-}
-Layout$1.VariantLayout = VariantLayout;
-/** JavaScript chose to define bitwise operations as operating on
- * signed 32-bit values in 2's complement form, meaning any integer
- * with bit 31 set is going to look negative.  For right shifts that's
- * not a problem, because `>>>` is a logical shift, but for every
- * other bitwise operator we have to compensate for possible negative
- * results. */
-function fixBitwiseResult(v) {
-    if (0 > v) {
-        v += 0x100000000;
-    }
-    return v;
-}
-/**
- * Contain a sequence of bit fields as an unsigned integer.
- *
- * *Factory*: {@link module:Layout.bits|bits}
- *
- * This is a container element; within it there are {@link BitField}
- * instances that provide the extracted properties.  The container
- * simply defines the aggregate representation and its bit ordering.
- * The representation is an object containing properties with numeric
- * or {@link Boolean} values.
- *
- * {@link BitField}s are added with the {@link
- * BitStructure#addField|addField} and {@link
- * BitStructure#addBoolean|addBoolean} methods.
-
- * @param {Layout} word - initializer for {@link
- * BitStructure#word|word}.  The parameter must be an instance of
- * {@link UInt} (or {@link UIntBE}) that is no more than 4 bytes wide.
- *
- * @param {bool} [msb] - `true` if the bit numbering starts at the
- * most significant bit of the containing word; `false` (default) if
- * it starts at the least significant bit of the containing word.  If
- * the parameter at this position is a string and `property` is
- * `undefined` the value of this argument will instead be used as the
- * value of `property`.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class BitStructure extends Layout {
-    constructor(word, msb, property) {
-        if (!((word instanceof UInt)
-            || (word instanceof UIntBE))) {
-            throw new TypeError('word must be a UInt or UIntBE layout');
-        }
-        if (('string' === typeof msb)
-            && (undefined === property)) {
-            property = msb;
-            msb = false;
-        }
-        if (4 < word.span) {
-            throw new RangeError('word cannot exceed 32 bits');
-        }
-        super(word.span, property);
-        /** The layout used for the packed value.  {@link BitField}
-         * instances are packed sequentially depending on {@link
-         * BitStructure#msb|msb}. */
-        this.word = word;
-        /** Whether the bit sequences are packed starting at the most
-         * significant bit growing down (`true`), or the least significant
-         * bit growing up (`false`).
-         *
-         * **NOTE** Regardless of this value, the least significant bit of
-         * any {@link BitField} value is the least significant bit of the
-         * corresponding section of the packed value. */
-        this.msb = !!msb;
-        /** The sequence of {@link BitField} layouts that comprise the
-         * packed structure.
-         *
-         * **NOTE** The array remains mutable to allow fields to be {@link
-         * BitStructure#addField|added} after construction.  Users should
-         * not manipulate the content of this property.*/
-        this.fields = [];
-        /* Storage for the value.  Capture a variable instead of using an
-         * instance property because we don't want anything to change the
-         * value without going through the mutator. */
-        let value = 0;
-        this._packedSetValue = function (v) {
-            value = fixBitwiseResult(v);
-            return this;
-        };
-        this._packedGetValue = function () {
-            return value;
-        };
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        const dest = this.makeDestinationObject();
-        const value = this.word.decode(b, offset);
-        this._packedSetValue(value);
-        for (const fd of this.fields) {
-            if (undefined !== fd.property) {
-                dest[fd.property] = fd.decode(b);
-            }
-        }
-        return dest;
-    }
-    /** Implement {@link Layout#encode|encode} for {@link BitStructure}.
-     *
-     * If `src` is missing a property for a member with a defined {@link
-     * Layout#property|property} the corresponding region of the packed
-     * value is left unmodified.  Unused bits are also left unmodified. */
-    encode(src, b, offset = 0) {
-        const value = this.word.decode(b, offset);
-        this._packedSetValue(value);
-        for (const fd of this.fields) {
-            if (undefined !== fd.property) {
-                const fv = src[fd.property];
-                if (undefined !== fv) {
-                    fd.encode(fv);
-                }
-            }
-        }
-        return this.word.encode(this._packedGetValue(), b, offset);
-    }
-    /** Register a new bitfield with a containing bit structure.  The
-     * resulting bitfield is returned.
-     *
-     * @param {Number} bits - initializer for {@link BitField#bits|bits}.
-     *
-     * @param {string} property - initializer for {@link
-     * Layout#property|property}.
-     *
-     * @return {BitField} */
-    addField(bits, property) {
-        const bf = new BitField(this, bits, property);
-        this.fields.push(bf);
-        return bf;
-    }
-    /** As with {@link BitStructure#addField|addField} for single-bit
-     * fields with `boolean` value representation.
-     *
-     * @param {string} property - initializer for {@link
-     * Layout#property|property}.
-     *
-     * @return {Boolean} */
-    // `Boolean` conflicts with the native primitive type
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    addBoolean(property) {
-        // This is my Boolean, not the Javascript one.
-        const bf = new Boolean(this, property);
-        this.fields.push(bf);
-        return bf;
-    }
-    /**
-     * Get access to the bit field for a given property.
-     *
-     * @param {String} property - the bit field of interest.
-     *
-     * @return {BitField} - the field associated with `property`, or
-     * undefined if there is no such property.
-     */
-    fieldFor(property) {
-        if ('string' !== typeof property) {
-            throw new TypeError('property must be string');
-        }
-        for (const fd of this.fields) {
-            if (fd.property === property) {
-                return fd;
-            }
-        }
-        return undefined;
-    }
-}
-Layout$1.BitStructure = BitStructure;
-/**
- * Represent a sequence of bits within a {@link BitStructure}.
- *
- * All bit field values are represented as unsigned integers.
- *
- * **NOTE** User code should not invoke this constructor directly.
- * Use the container {@link BitStructure#addField|addField} helper
- * method.
- *
- * **NOTE** BitField instances are not instances of {@link Layout}
- * since {@link Layout#span|span} measures 8-bit units.
- *
- * @param {BitStructure} container - initializer for {@link
- * BitField#container|container}.
- *
- * @param {Number} bits - initializer for {@link BitField#bits|bits}.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- */
-class BitField {
-    constructor(container, bits, property) {
-        if (!(container instanceof BitStructure)) {
-            throw new TypeError('container must be a BitStructure');
-        }
-        if ((!Number.isInteger(bits)) || (0 >= bits)) {
-            throw new TypeError('bits must be positive integer');
-        }
-        const totalBits = 8 * container.span;
-        const usedBits = container.fields.reduce((sum, fd) => sum + fd.bits, 0);
-        if ((bits + usedBits) > totalBits) {
-            throw new Error('bits too long for span remainder ('
-                + (totalBits - usedBits) + ' of '
-                + totalBits + ' remain)');
-        }
-        /** The {@link BitStructure} instance to which this bit field
-         * belongs. */
-        this.container = container;
-        /** The span of this value in bits. */
-        this.bits = bits;
-        /** A mask of {@link BitField#bits|bits} bits isolating value bits
-         * that fit within the field.
-         *
-         * That is, it masks a value that has not yet been shifted into
-         * position within its containing packed integer. */
-        this.valueMask = (1 << bits) - 1;
-        if (32 === bits) { // shifted value out of range
-            this.valueMask = 0xFFFFFFFF;
-        }
-        /** The offset of the value within the containing packed unsigned
-         * integer.  The least significant bit of the packed value is at
-         * offset zero, regardless of bit ordering used. */
-        this.start = usedBits;
-        if (this.container.msb) {
-            this.start = totalBits - usedBits - bits;
-        }
-        /** A mask of {@link BitField#bits|bits} isolating the field value
-         * within the containing packed unsigned integer. */
-        this.wordMask = fixBitwiseResult(this.valueMask << this.start);
-        /** The property name used when this bitfield is represented in an
-         * Object.
-         *
-         * Intended to be functionally equivalent to {@link
-         * Layout#property}.
-         *
-         * If left undefined the corresponding span of bits will be
-         * treated as padding: it will not be mutated by {@link
-         * Layout#encode|encode} nor represented as a property in the
-         * decoded Object. */
-        this.property = property;
-    }
-    /** Store a value into the corresponding subsequence of the containing
-     * bit field. */
-    decode(b, offset) {
-        const word = this.container._packedGetValue();
-        const wordValue = fixBitwiseResult(word & this.wordMask);
-        const value = wordValue >>> this.start;
-        return value;
-    }
-    /** Store a value into the corresponding subsequence of the containing
-     * bit field.
-     *
-     * **NOTE** This is not a specialization of {@link
-     * Layout#encode|Layout.encode} and there is no return value. */
-    encode(value) {
-        if ('number' !== typeof value
-            || !Number.isInteger(value)
-            || (value !== fixBitwiseResult(value & this.valueMask))) {
-            throw new TypeError(nameWithProperty('BitField.encode', this)
-                + ' value must be integer not exceeding ' + this.valueMask);
-        }
-        const word = this.container._packedGetValue();
-        const wordValue = fixBitwiseResult(value << this.start);
-        this.container._packedSetValue(fixBitwiseResult(word & ~this.wordMask)
-            | wordValue);
-    }
-}
-Layout$1.BitField = BitField;
-/**
- * Represent a single bit within a {@link BitStructure} as a
- * JavaScript boolean.
- *
- * **NOTE** User code should not invoke this constructor directly.
- * Use the container {@link BitStructure#addBoolean|addBoolean} helper
- * method.
- *
- * @param {BitStructure} container - initializer for {@link
- * BitField#container|container}.
- *
- * @param {string} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {BitField}
- */
-/* eslint-disable no-extend-native */
-class Boolean extends BitField {
-    constructor(container, property) {
-        super(container, 1, property);
-    }
-    /** Override {@link BitField#decode|decode} for {@link Boolean|Boolean}.
-     *
-     * @returns {boolean} */
-    decode(b, offset) {
-        return !!super.decode(b, offset);
-    }
-    /** @override */
-    encode(value) {
-        if ('boolean' === typeof value) {
-            // BitField requires integer values
-            value = +value;
-        }
-        super.encode(value);
-    }
-}
-Layout$1.Boolean = Boolean;
-/* eslint-enable no-extend-native */
-/**
- * Contain a fixed-length block of arbitrary data, represented as a
- * Uint8Array.
- *
- * *Factory*: {@link module:Layout.blob|blob}
- *
- * @param {(Number|ExternalLayout)} length - initializes {@link
- * Blob#length|length}.
- *
- * @param {String} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class Blob extends Layout {
-    constructor(length, property) {
-        if (!(((length instanceof ExternalLayout) && length.isCount())
-            || (Number.isInteger(length) && (0 <= length)))) {
-            throw new TypeError('length must be positive integer '
-                + 'or an unsigned integer ExternalLayout');
-        }
-        let span = -1;
-        if (!(length instanceof ExternalLayout)) {
-            span = length;
-        }
-        super(span, property);
-        /** The number of bytes in the blob.
-         *
-         * This may be a non-negative integer, or an instance of {@link
-         * ExternalLayout} that satisfies {@link
-         * ExternalLayout#isCount|isCount()}. */
-        this.length = length;
-    }
-    /** @override */
-    getSpan(b, offset) {
-        let span = this.span;
-        if (0 > span) {
-            span = this.length.decode(b, offset);
-        }
-        return span;
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        let span = this.span;
-        if (0 > span) {
-            span = this.length.decode(b, offset);
-        }
-        return uint8ArrayToBuffer(b).slice(offset, offset + span);
-    }
-    /** Implement {@link Layout#encode|encode} for {@link Blob}.
-     *
-     * **NOTE** If {@link Layout#count|count} is an instance of {@link
-     * ExternalLayout} then the length of `src` will be encoded as the
-     * count after `src` is encoded. */
-    encode(src, b, offset) {
-        let span = this.length;
-        if (this.length instanceof ExternalLayout) {
-            span = src.length;
-        }
-        if (!(src instanceof Uint8Array && span === src.length)) {
-            throw new TypeError(nameWithProperty('Blob.encode', this)
-                + ' requires (length ' + span + ') Uint8Array as src');
-        }
-        if ((offset + span) > b.length) {
-            throw new RangeError('encoding overruns Uint8Array');
-        }
-        const srcBuffer = uint8ArrayToBuffer(src);
-        uint8ArrayToBuffer(b).write(srcBuffer.toString('hex'), offset, span, 'hex');
-        if (this.length instanceof ExternalLayout) {
-            this.length.encode(span, b, offset);
-        }
-        return span;
-    }
-}
-Layout$1.Blob = Blob;
-/**
- * Contain a `NUL`-terminated UTF8 string.
- *
- * *Factory*: {@link module:Layout.cstr|cstr}
- *
- * **NOTE** Any UTF8 string that incorporates a zero-valued byte will
- * not be correctly decoded by this layout.
- *
- * @param {String} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class CString extends Layout {
-    constructor(property) {
-        super(-1, property);
-    }
-    /** @override */
-    getSpan(b, offset = 0) {
-        checkUint8Array(b);
-        let idx = offset;
-        while ((idx < b.length) && (0 !== b[idx])) {
-            idx += 1;
-        }
-        return 1 + idx - offset;
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        const span = this.getSpan(b, offset);
-        return uint8ArrayToBuffer(b).slice(offset, offset + span - 1).toString('utf-8');
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        /* Must force this to a string, lest it be a number and the
-         * "utf8-encoding" below actually allocate a buffer of length
-         * src */
-        if ('string' !== typeof src) {
-            src = String(src);
-        }
-        const srcb = buffer_1.Buffer.from(src, 'utf8');
-        const span = srcb.length;
-        if ((offset + span) > b.length) {
-            throw new RangeError('encoding overruns Buffer');
-        }
-        const buffer = uint8ArrayToBuffer(b);
-        srcb.copy(buffer, offset);
-        buffer[offset + span] = 0;
-        return span + 1;
-    }
-}
-Layout$1.CString = CString;
-/**
- * Contain a UTF8 string with implicit length.
- *
- * *Factory*: {@link module:Layout.utf8|utf8}
- *
- * **NOTE** Because the length is implicit in the size of the buffer
- * this layout should be used only in isolation, or in a situation
- * where the length can be expressed by operating on a slice of the
- * containing buffer.
- *
- * @param {Number} [maxSpan] - the maximum length allowed for encoded
- * string content.  If not provided there is no bound on the allowed
- * content.
- *
- * @param {String} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class UTF8 extends Layout {
-    constructor(maxSpan, property) {
-        if (('string' === typeof maxSpan) && (undefined === property)) {
-            property = maxSpan;
-            maxSpan = undefined;
-        }
-        if (undefined === maxSpan) {
-            maxSpan = -1;
-        }
-        else if (!Number.isInteger(maxSpan)) {
-            throw new TypeError('maxSpan must be an integer');
-        }
-        super(-1, property);
-        /** The maximum span of the layout in bytes.
-         *
-         * Positive values are generally expected.  Zero is abnormal.
-         * Attempts to encode or decode a value that exceeds this length
-         * will throw a `RangeError`.
-         *
-         * A negative value indicates that there is no bound on the length
-         * of the content. */
-        this.maxSpan = maxSpan;
-    }
-    /** @override */
-    getSpan(b, offset = 0) {
-        checkUint8Array(b);
-        return b.length - offset;
-    }
-    /** @override */
-    decode(b, offset = 0) {
-        const span = this.getSpan(b, offset);
-        if ((0 <= this.maxSpan)
-            && (this.maxSpan < span)) {
-            throw new RangeError('text length exceeds maxSpan');
-        }
-        return uint8ArrayToBuffer(b).slice(offset, offset + span).toString('utf-8');
-    }
-    /** @override */
-    encode(src, b, offset = 0) {
-        /* Must force this to a string, lest it be a number and the
-         * "utf8-encoding" below actually allocate a buffer of length
-         * src */
-        if ('string' !== typeof src) {
-            src = String(src);
-        }
-        const srcb = buffer_1.Buffer.from(src, 'utf8');
-        const span = srcb.length;
-        if ((0 <= this.maxSpan)
-            && (this.maxSpan < span)) {
-            throw new RangeError('text length exceeds maxSpan');
-        }
-        if ((offset + span) > b.length) {
-            throw new RangeError('encoding overruns Buffer');
-        }
-        srcb.copy(uint8ArrayToBuffer(b), offset);
-        return span;
-    }
-}
-Layout$1.UTF8 = UTF8;
-/**
- * Contain a constant value.
- *
- * This layout may be used in cases where a JavaScript value can be
- * inferred without an expression in the binary encoding.  An example
- * would be a {@link VariantLayout|variant layout} where the content
- * is implied by the union {@link Union#discriminator|discriminator}.
- *
- * @param {Object|Number|String} value - initializer for {@link
- * Constant#value|value}.  If the value is an object (or array) and
- * the application intends the object to remain unchanged regardless
- * of what is done to values decoded by this layout, the value should
- * be frozen prior passing it to this constructor.
- *
- * @param {String} [property] - initializer for {@link
- * Layout#property|property}.
- *
- * @augments {Layout}
- */
-class Constant extends Layout {
-    constructor(value, property) {
-        super(0, property);
-        /** The value produced by this constant when the layout is {@link
-         * Constant#decode|decoded}.
-         *
-         * Any JavaScript value including `null` and `undefined` is
-         * permitted.
-         *
-         * **WARNING** If `value` passed in the constructor was not
-         * frozen, it is possible for users of decoded values to change
-         * the content of the value. */
-        this.value = value;
-    }
-    /** @override */
-    decode(b, offset) {
-        return this.value;
-    }
-    /** @override */
-    encode(src, b, offset) {
-        /* Constants take no space */
-        return 0;
-    }
-}
-Layout$1.Constant = Constant;
-/** Factory for {@link GreedyCount}. */
-Layout$1.greedy = ((elementSpan, property) => new GreedyCount(elementSpan, property));
-/** Factory for {@link OffsetLayout}. */
-Layout$1.offset = ((layout, offset, property) => new OffsetLayout(layout, offset, property));
-/** Factory for {@link UInt|unsigned int layouts} spanning one
- * byte. */
-var u8 = Layout$1.u8 = ((property) => new UInt(1, property));
-/** Factory for {@link UInt|little-endian unsigned int layouts}
- * spanning two bytes. */
-Layout$1.u16 = ((property) => new UInt(2, property));
-/** Factory for {@link UInt|little-endian unsigned int layouts}
- * spanning three bytes. */
-Layout$1.u24 = ((property) => new UInt(3, property));
-/** Factory for {@link UInt|little-endian unsigned int layouts}
- * spanning four bytes. */
-var u32 = Layout$1.u32 = ((property) => new UInt(4, property));
-/** Factory for {@link UInt|little-endian unsigned int layouts}
- * spanning five bytes. */
-Layout$1.u40 = ((property) => new UInt(5, property));
-/** Factory for {@link UInt|little-endian unsigned int layouts}
- * spanning six bytes. */
-Layout$1.u48 = ((property) => new UInt(6, property));
-/** Factory for {@link NearUInt64|little-endian unsigned int
- * layouts} interpreted as Numbers. */
-Layout$1.nu64 = ((property) => new NearUInt64(property));
-/** Factory for {@link UInt|big-endian unsigned int layouts}
- * spanning two bytes. */
-Layout$1.u16be = ((property) => new UIntBE(2, property));
-/** Factory for {@link UInt|big-endian unsigned int layouts}
- * spanning three bytes. */
-Layout$1.u24be = ((property) => new UIntBE(3, property));
-/** Factory for {@link UInt|big-endian unsigned int layouts}
- * spanning four bytes. */
-Layout$1.u32be = ((property) => new UIntBE(4, property));
-/** Factory for {@link UInt|big-endian unsigned int layouts}
- * spanning five bytes. */
-Layout$1.u40be = ((property) => new UIntBE(5, property));
-/** Factory for {@link UInt|big-endian unsigned int layouts}
- * spanning six bytes. */
-Layout$1.u48be = ((property) => new UIntBE(6, property));
-/** Factory for {@link NearUInt64BE|big-endian unsigned int
- * layouts} interpreted as Numbers. */
-Layout$1.nu64be = ((property) => new NearUInt64BE(property));
-/** Factory for {@link Int|signed int layouts} spanning one
- * byte. */
-Layout$1.s8 = ((property) => new Int(1, property));
-/** Factory for {@link Int|little-endian signed int layouts}
- * spanning two bytes. */
-Layout$1.s16 = ((property) => new Int(2, property));
-/** Factory for {@link Int|little-endian signed int layouts}
- * spanning three bytes. */
-Layout$1.s24 = ((property) => new Int(3, property));
-/** Factory for {@link Int|little-endian signed int layouts}
- * spanning four bytes. */
-Layout$1.s32 = ((property) => new Int(4, property));
-/** Factory for {@link Int|little-endian signed int layouts}
- * spanning five bytes. */
-Layout$1.s40 = ((property) => new Int(5, property));
-/** Factory for {@link Int|little-endian signed int layouts}
- * spanning six bytes. */
-Layout$1.s48 = ((property) => new Int(6, property));
-/** Factory for {@link NearInt64|little-endian signed int layouts}
- * interpreted as Numbers. */
-Layout$1.ns64 = ((property) => new NearInt64(property));
-/** Factory for {@link Int|big-endian signed int layouts}
- * spanning two bytes. */
-Layout$1.s16be = ((property) => new IntBE(2, property));
-/** Factory for {@link Int|big-endian signed int layouts}
- * spanning three bytes. */
-Layout$1.s24be = ((property) => new IntBE(3, property));
-/** Factory for {@link Int|big-endian signed int layouts}
- * spanning four bytes. */
-Layout$1.s32be = ((property) => new IntBE(4, property));
-/** Factory for {@link Int|big-endian signed int layouts}
- * spanning five bytes. */
-Layout$1.s40be = ((property) => new IntBE(5, property));
-/** Factory for {@link Int|big-endian signed int layouts}
- * spanning six bytes. */
-Layout$1.s48be = ((property) => new IntBE(6, property));
-/** Factory for {@link NearInt64BE|big-endian signed int layouts}
- * interpreted as Numbers. */
-Layout$1.ns64be = ((property) => new NearInt64BE(property));
-/** Factory for {@link Float|little-endian 32-bit floating point} values. */
-Layout$1.f32 = ((property) => new Float(property));
-/** Factory for {@link FloatBE|big-endian 32-bit floating point} values. */
-Layout$1.f32be = ((property) => new FloatBE(property));
-/** Factory for {@link Double|little-endian 64-bit floating point} values. */
-Layout$1.f64 = ((property) => new Double(property));
-/** Factory for {@link DoubleBE|big-endian 64-bit floating point} values. */
-Layout$1.f64be = ((property) => new DoubleBE(property));
-/** Factory for {@link Structure} values. */
-var struct = Layout$1.struct = ((fields, property, decodePrefixes) => new Structure(fields, property, decodePrefixes));
-/** Factory for {@link BitStructure} values. */
-Layout$1.bits = ((word, msb, property) => new BitStructure(word, msb, property));
-/** Factory for {@link Sequence} values. */
-Layout$1.seq = ((elementLayout, count, property) => new Sequence(elementLayout, count, property));
-/** Factory for {@link Union} values. */
-Layout$1.union = ((discr, defaultLayout, property) => new Union(discr, defaultLayout, property));
-/** Factory for {@link UnionLayoutDiscriminator} values. */
-Layout$1.unionLayoutDiscriminator = ((layout, property) => new UnionLayoutDiscriminator(layout, property));
-/** Factory for {@link Blob} values. */
-var blob = Layout$1.blob = ((length, property) => new Blob(length, property));
-/** Factory for {@link CString} values. */
-Layout$1.cstr = ((property) => new CString(property));
-/** Factory for {@link UTF8} values. */
-Layout$1.utf8 = ((maxSpan, property) => new UTF8(maxSpan, property));
-/** Factory for {@link Constant} values. */
-Layout$1.constant = ((value, property) => new Constant(value, property));
-
-const encodeDecode = (layout) => {
-    const decode = layout.decode.bind(layout);
-    const encode = layout.encode.bind(layout);
-    return { decode, encode };
-};
-
-var node = {};
-
-function commonjsRequire(path) {
-	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-
-var bindings = {exports: {}};
-
-var fileUriToPath_1;
-var hasRequiredFileUriToPath;
-
-function requireFileUriToPath () {
-	if (hasRequiredFileUriToPath) return fileUriToPath_1;
-	hasRequiredFileUriToPath = 1;
-	/**
-	 * Module dependencies.
-	 */
-
-	var sep = require$$0$1.sep || '/';
-
-	/**
-	 * Module exports.
-	 */
-
-	fileUriToPath_1 = fileUriToPath;
-
-	/**
-	 * File URI to Path function.
-	 *
-	 * @param {String} uri
-	 * @return {String} path
-	 * @api public
-	 */
-
-	function fileUriToPath (uri) {
-	  if ('string' != typeof uri ||
-	      uri.length <= 7 ||
-	      'file://' != uri.substring(0, 7)) {
-	    throw new TypeError('must pass in a file:// URI to convert to a file path');
-	  }
-
-	  var rest = decodeURI(uri.substring(7));
-	  var firstSlash = rest.indexOf('/');
-	  var host = rest.substring(0, firstSlash);
-	  var path = rest.substring(firstSlash + 1);
-
-	  // 2.  Scheme Definition
-	  // As a special case, <host> can be the string "localhost" or the empty
-	  // string; this is interpreted as "the machine from which the URL is
-	  // being interpreted".
-	  if ('localhost' == host) host = '';
-
-	  if (host) {
-	    host = sep + sep + host;
-	  }
-
-	  // 3.2  Drives, drive letters, mount points, file system root
-	  // Drive letters are mapped into the top of a file URI in various ways,
-	  // depending on the implementation; some applications substitute
-	  // vertical bar ("|") for the colon after the drive letter, yielding
-	  // "file:///c|/tmp/test.txt".  In some cases, the colon is left
-	  // unchanged, as in "file:///c:/tmp/test.txt".  In other cases, the
-	  // colon is simply omitted, as in "file:///c/tmp/test.txt".
-	  path = path.replace(/^(.+)\|/, '$1:');
-
-	  // for Windows, we need to invert the path separators from what a URI uses
-	  if (sep == '\\') {
-	    path = path.replace(/\//g, '\\');
-	  }
-
-	  if (/^.+\:/.test(path)) ; else {
-	    // unix path…
-	    path = sep + path;
-	  }
-
-	  return host + path;
-	}
-	return fileUriToPath_1;
-}
-
-/**
- * Module dependencies.
- */
-
-var hasRequiredBindings;
-
-function requireBindings () {
-	if (hasRequiredBindings) return bindings.exports;
-	hasRequiredBindings = 1;
-	(function (module, exports) {
-		var fs = require$$0$2,
-		  path = require$$0$1,
-		  fileURLToPath = requireFileUriToPath(),
-		  join = path.join,
-		  dirname = path.dirname,
-		  exists =
-		    (fs.accessSync &&
-		      function(path) {
-		        try {
-		          fs.accessSync(path);
-		        } catch (e) {
-		          return false;
-		        }
-		        return true;
-		      }) ||
-		    fs.existsSync ||
-		    path.existsSync,
-		  defaults = {
-		    arrow: process.env.NODE_BINDINGS_ARROW || ' → ',
-		    compiled: process.env.NODE_BINDINGS_COMPILED_DIR || 'compiled',
-		    platform: process.platform,
-		    arch: process.arch,
-		    nodePreGyp:
-		      'node-v' +
-		      process.versions.modules +
-		      '-' +
-		      process.platform +
-		      '-' +
-		      process.arch,
-		    version: process.versions.node,
-		    bindings: 'bindings.node',
-		    try: [
-		      // node-gyp's linked version in the "build" dir
-		      ['module_root', 'build', 'bindings'],
-		      // node-waf and gyp_addon (a.k.a node-gyp)
-		      ['module_root', 'build', 'Debug', 'bindings'],
-		      ['module_root', 'build', 'Release', 'bindings'],
-		      // Debug files, for development (legacy behavior, remove for node v0.9)
-		      ['module_root', 'out', 'Debug', 'bindings'],
-		      ['module_root', 'Debug', 'bindings'],
-		      // Release files, but manually compiled (legacy behavior, remove for node v0.9)
-		      ['module_root', 'out', 'Release', 'bindings'],
-		      ['module_root', 'Release', 'bindings'],
-		      // Legacy from node-waf, node <= 0.4.x
-		      ['module_root', 'build', 'default', 'bindings'],
-		      // Production "Release" buildtype binary (meh...)
-		      ['module_root', 'compiled', 'version', 'platform', 'arch', 'bindings'],
-		      // node-qbs builds
-		      ['module_root', 'addon-build', 'release', 'install-root', 'bindings'],
-		      ['module_root', 'addon-build', 'debug', 'install-root', 'bindings'],
-		      ['module_root', 'addon-build', 'default', 'install-root', 'bindings'],
-		      // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
-		      ['module_root', 'lib', 'binding', 'nodePreGyp', 'bindings']
-		    ]
-		  };
-
-		/**
-		 * The main `bindings()` function loads the compiled bindings for a given module.
-		 * It uses V8's Error API to determine the parent filename that this function is
-		 * being invoked from, which is then used to find the root directory.
-		 */
-
-		function bindings(opts) {
-		  // Argument surgery
-		  if (typeof opts == 'string') {
-		    opts = { bindings: opts };
-		  } else if (!opts) {
-		    opts = {};
-		  }
-
-		  // maps `defaults` onto `opts` object
-		  Object.keys(defaults).map(function(i) {
-		    if (!(i in opts)) opts[i] = defaults[i];
-		  });
-
-		  // Get the module root
-		  if (!opts.module_root) {
-		    opts.module_root = exports.getRoot(exports.getFileName());
-		  }
-
-		  // Ensure the given bindings name ends with .node
-		  if (path.extname(opts.bindings) != '.node') {
-		    opts.bindings += '.node';
-		  }
-
-		  // https://github.com/webpack/webpack/issues/4175#issuecomment-342931035
-		  var requireFunc =
-		    typeof __webpack_require__ === 'function'
-		      ? __non_webpack_require__
-		      : commonjsRequire;
-
-		  var tries = [],
-		    i = 0,
-		    l = opts.try.length,
-		    n,
-		    b,
-		    err;
-
-		  for (; i < l; i++) {
-		    n = join.apply(
-		      null,
-		      opts.try[i].map(function(p) {
-		        return opts[p] || p;
-		      })
-		    );
-		    tries.push(n);
-		    try {
-		      b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
-		      if (!opts.path) {
-		        b.path = n;
-		      }
-		      return b;
-		    } catch (e) {
-		      if (e.code !== 'MODULE_NOT_FOUND' &&
-		          e.code !== 'QUALIFIED_PATH_RESOLUTION_FAILED' &&
-		          !/not find/i.test(e.message)) {
-		        throw e;
-		      }
-		    }
-		  }
-
-		  err = new Error(
-		    'Could not locate the bindings file. Tried:\n' +
-		      tries
-		        .map(function(a) {
-		          return opts.arrow + a;
-		        })
-		        .join('\n')
-		  );
-		  err.tries = tries;
-		  throw err;
-		}
-		module.exports = exports = bindings;
-
-		/**
-		 * Gets the filename of the JavaScript file that invokes this function.
-		 * Used to help find the root directory of a module.
-		 * Optionally accepts an filename argument to skip when searching for the invoking filename
-		 */
-
-		exports.getFileName = function getFileName(calling_file) {
-		  var origPST = Error.prepareStackTrace,
-		    origSTL = Error.stackTraceLimit,
-		    dummy = {},
-		    fileName;
-
-		  Error.stackTraceLimit = 10;
-
-		  Error.prepareStackTrace = function(e, st) {
-		    for (var i = 0, l = st.length; i < l; i++) {
-		      fileName = st[i].getFileName();
-		      if (fileName !== __filename) {
-		        if (calling_file) {
-		          if (fileName !== calling_file) {
-		            return;
-		          }
-		        } else {
-		          return;
-		        }
-		      }
-		    }
-		  };
-
-		  // run the 'prepareStackTrace' function above
-		  Error.captureStackTrace(dummy);
-		  dummy.stack;
-
-		  // cleanup
-		  Error.prepareStackTrace = origPST;
-		  Error.stackTraceLimit = origSTL;
-
-		  // handle filename that starts with "file://"
-		  var fileSchema = 'file://';
-		  if (fileName.indexOf(fileSchema) === 0) {
-		    fileName = fileURLToPath(fileName);
-		  }
-
-		  return fileName;
-		};
-
-		/**
-		 * Gets the root directory of a module, given an arbitrary filename
-		 * somewhere in the module tree. The "root directory" is the directory
-		 * containing the `package.json` file.
-		 *
-		 *   In:  /home/nate/node-native-module/lib/index.js
-		 *   Out: /home/nate/node-native-module
-		 */
-
-		exports.getRoot = function getRoot(file) {
-		  var dir = dirname(file),
-		    prev;
-		  while (true) {
-		    if (dir === '.') {
-		      // Avoids an infinite loop in rare cases, like the REPL
-		      dir = process.cwd();
-		    }
-		    if (
-		      exists(join(dir, 'package.json')) ||
-		      exists(join(dir, 'node_modules'))
-		    ) {
-		      // Found the 'package.json' file or 'node_modules' dir; we're done
-		      return dir;
-		    }
-		    if (prev === dir) {
-		      // Got to the top
-		      throw new Error(
-		        'Could not find module root given file: "' +
-		          file +
-		          '". Do you have a `package.json` file? '
-		      );
-		    }
-		    // Try the parent dir next
-		    prev = dir;
-		    dir = join(dir, '..');
-		  }
-		}; 
-	} (bindings, bindings.exports));
-	return bindings.exports;
-}
-
-Object.defineProperty(node, "__esModule", { value: true });
-let converter;
-{
-    try {
-        converter = requireBindings()('bigint_buffer');
-    }
-    catch (e) {
-        console.warn('bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)');
-    }
-}
-/**
- * Convert a little-endian buffer into a BigInt.
- * @param buf The little-endian buffer to convert
- * @returns A BigInt with the little-endian representation of buf.
- */
-function toBigIntLE(buf) {
-    if (converter === undefined) {
-        const reversed = Buffer.from(buf);
-        reversed.reverse();
-        const hex = reversed.toString('hex');
-        if (hex.length === 0) {
-            return BigInt(0);
-        }
-        return BigInt(`0x${hex}`);
-    }
-    return converter.toBigInt(buf, false);
-}
-var toBigIntLE_1 = node.toBigIntLE = toBigIntLE;
-/**
- * Convert a big-endian buffer into a BigInt
- * @param buf The big-endian buffer to convert.
- * @returns A BigInt with the big-endian representation of buf.
- */
-function toBigIntBE(buf) {
-    if (converter === undefined) {
-        const hex = buf.toString('hex');
-        if (hex.length === 0) {
-            return BigInt(0);
-        }
-        return BigInt(`0x${hex}`);
-    }
-    return converter.toBigInt(buf, true);
-}
-node.toBigIntBE = toBigIntBE;
-/**
- * Convert a BigInt to a little-endian buffer.
- * @param num   The BigInt to convert.
- * @param width The number of bytes that the resulting buffer should be.
- * @returns A little-endian buffer representation of num.
- */
-function toBufferLE(num, width) {
-    if (converter === undefined) {
-        const hex = num.toString(16);
-        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-        buffer.reverse();
-        return buffer;
-    }
-    // Allocation is done here, since it is slower using napi in C
-    return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
-}
-var toBufferLE_1 = node.toBufferLE = toBufferLE;
-/**
- * Convert a BigInt to a big-endian buffer.
- * @param num   The BigInt to convert.
- * @param width The number of bytes that the resulting buffer should be.
- * @returns A big-endian buffer representation of num.
- */
-function toBufferBE(num, width) {
-    if (converter === undefined) {
-        const hex = num.toString(16);
-        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-    }
-    return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
-}
-node.toBufferBE = toBufferBE;
-
-const bigInt = (length) => (property) => {
-    const layout = blob(length, property);
-    const { encode, decode } = encodeDecode(layout);
-    const bigIntLayout = layout;
-    bigIntLayout.decode = (buffer, offset) => {
-        const src = decode(buffer, offset);
-        return toBigIntLE_1(Buffer.from(src));
-    };
-    bigIntLayout.encode = (bigInt, buffer, offset) => {
-        const src = toBufferLE_1(bigInt, length);
-        return encode(src, buffer, offset);
-    };
-    return bigIntLayout;
-};
-const u64 = bigInt(8);
-
-const bool = (property) => {
-    const layout = u8(property);
-    const { encode, decode } = encodeDecode(layout);
-    const boolLayout = layout;
-    boolLayout.decode = (buffer, offset) => {
-        const src = decode(buffer, offset);
-        return !!src;
-    };
-    boolLayout.encode = (bool, buffer, offset) => {
-        const src = Number(bool);
-        return encode(src, buffer, offset);
-    };
-    return boolLayout;
-};
-
-const publicKey = (property) => {
-    const layout = blob(32, property);
-    const { encode, decode } = encodeDecode(layout);
-    const publicKeyLayout = layout;
-    publicKeyLayout.decode = (buffer, offset) => {
-        const src = decode(buffer, offset);
-        return new PublicKey(src);
-    };
-    publicKeyLayout.encode = (publicKey, buffer, offset) => {
-        const src = publicKey.toBuffer();
-        return encode(src, buffer, offset);
-    };
-    return publicKeyLayout;
-};
-
-/** Instructions defined by the program */
-var TokenInstruction;
-(function (TokenInstruction) {
-    TokenInstruction[TokenInstruction["InitializeMint"] = 0] = "InitializeMint";
-    TokenInstruction[TokenInstruction["InitializeAccount"] = 1] = "InitializeAccount";
-    TokenInstruction[TokenInstruction["InitializeMultisig"] = 2] = "InitializeMultisig";
-    TokenInstruction[TokenInstruction["Transfer"] = 3] = "Transfer";
-    TokenInstruction[TokenInstruction["Approve"] = 4] = "Approve";
-    TokenInstruction[TokenInstruction["Revoke"] = 5] = "Revoke";
-    TokenInstruction[TokenInstruction["SetAuthority"] = 6] = "SetAuthority";
-    TokenInstruction[TokenInstruction["MintTo"] = 7] = "MintTo";
-    TokenInstruction[TokenInstruction["Burn"] = 8] = "Burn";
-    TokenInstruction[TokenInstruction["CloseAccount"] = 9] = "CloseAccount";
-    TokenInstruction[TokenInstruction["FreezeAccount"] = 10] = "FreezeAccount";
-    TokenInstruction[TokenInstruction["ThawAccount"] = 11] = "ThawAccount";
-    TokenInstruction[TokenInstruction["TransferChecked"] = 12] = "TransferChecked";
-    TokenInstruction[TokenInstruction["ApproveChecked"] = 13] = "ApproveChecked";
-    TokenInstruction[TokenInstruction["MintToChecked"] = 14] = "MintToChecked";
-    TokenInstruction[TokenInstruction["BurnChecked"] = 15] = "BurnChecked";
-    TokenInstruction[TokenInstruction["InitializeAccount2"] = 16] = "InitializeAccount2";
-    TokenInstruction[TokenInstruction["SyncNative"] = 17] = "SyncNative";
-    TokenInstruction[TokenInstruction["InitializeAccount3"] = 18] = "InitializeAccount3";
-    TokenInstruction[TokenInstruction["InitializeMultisig2"] = 19] = "InitializeMultisig2";
-    TokenInstruction[TokenInstruction["InitializeMint2"] = 20] = "InitializeMint2";
-    TokenInstruction[TokenInstruction["GetAccountDataSize"] = 21] = "GetAccountDataSize";
-    TokenInstruction[TokenInstruction["InitializeImmutableOwner"] = 22] = "InitializeImmutableOwner";
-    TokenInstruction[TokenInstruction["AmountToUiAmount"] = 23] = "AmountToUiAmount";
-    TokenInstruction[TokenInstruction["UiAmountToAmount"] = 24] = "UiAmountToAmount";
-    TokenInstruction[TokenInstruction["InitializeMintCloseAuthority"] = 25] = "InitializeMintCloseAuthority";
-    TokenInstruction[TokenInstruction["TransferFeeExtension"] = 26] = "TransferFeeExtension";
-    TokenInstruction[TokenInstruction["ConfidentialTransferExtension"] = 27] = "ConfidentialTransferExtension";
-    TokenInstruction[TokenInstruction["DefaultAccountStateExtension"] = 28] = "DefaultAccountStateExtension";
-    TokenInstruction[TokenInstruction["Reallocate"] = 29] = "Reallocate";
-    TokenInstruction[TokenInstruction["MemoTransferExtension"] = 30] = "MemoTransferExtension";
-    TokenInstruction[TokenInstruction["CreateNativeMint"] = 31] = "CreateNativeMint";
-    TokenInstruction[TokenInstruction["InitializeNonTransferableMint"] = 32] = "InitializeNonTransferableMint";
-    TokenInstruction[TokenInstruction["InterestBearingMintExtension"] = 33] = "InterestBearingMintExtension";
-    TokenInstruction[TokenInstruction["CpiGuardExtension"] = 34] = "CpiGuardExtension";
-    TokenInstruction[TokenInstruction["InitializePermanentDelegate"] = 35] = "InitializePermanentDelegate";
-})(TokenInstruction || (TokenInstruction = {}));
-
-/** @internal */
-function addSigners(keys, ownerOrAuthority, multiSigners) {
-    if (multiSigners.length) {
-        keys.push({ pubkey: ownerOrAuthority, isSigner: false, isWritable: false });
-        for (const signer of multiSigners) {
-            keys.push({
-                pubkey: signer instanceof PublicKey ? signer : signer.publicKey,
-                isSigner: true,
-                isWritable: false,
-            });
-        }
-    }
-    else {
-        keys.push({ pubkey: ownerOrAuthority, isSigner: true, isWritable: false });
-    }
-    return keys;
-}
-
-/** TODO: docs */
-const approveInstructionData = struct([u8('instruction'), u64('amount')]);
-/**
- * Construct an Approve instruction
- *
- * @param account      Account to set the delegate for
- * @param delegate     Account authorized to transfer tokens from the account
- * @param owner        Owner of the account
- * @param amount       Maximum number of tokens the delegate may transfer
- * @param multiSigners Signing accounts if `owner` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-function createApproveInstruction(account, delegate, owner, amount, multiSigners = [], programId = TOKEN_PROGRAM_ID) {
-    const keys = addSigners([
-        { pubkey: account, isSigner: false, isWritable: true },
-        { pubkey: delegate, isSigner: false, isWritable: false },
-    ], owner, multiSigners);
-    const data = Buffer.alloc(approveInstructionData.span);
-    approveInstructionData.encode({
-        instruction: TokenInstruction.Approve,
-        amount: BigInt(amount),
-    }, data);
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** Buffer layout for de/serializing a mint */
-const MintLayout = struct([
-    u32('mintAuthorityOption'),
-    publicKey('mintAuthority'),
-    u64('supply'),
-    u8('decimals'),
-    bool('isInitialized'),
-    u32('freezeAuthorityOption'),
-    publicKey('freezeAuthority'),
-]);
-/** Byte length of a mint */
-const MINT_SIZE = MintLayout.span;
-
-/** TODO: docs */
-const initializeMint2InstructionData = struct([
-    u8('instruction'),
-    u8('decimals'),
-    publicKey('mintAuthority'),
-    u8('freezeAuthorityOption'),
-    publicKey('freezeAuthority'),
-]);
-/**
- * Construct an InitializeMint2 instruction
- *
- * @param mint            Token mint account
- * @param decimals        Number of decimals in token account amounts
- * @param mintAuthority   Minting authority
- * @param freezeAuthority Optional authority that can freeze token accounts
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-function createInitializeMint2Instruction(mint, decimals, mintAuthority, freezeAuthority, programId = TOKEN_PROGRAM_ID) {
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-    const data = Buffer.alloc(initializeMint2InstructionData.span);
-    initializeMint2InstructionData.encode({
-        instruction: TokenInstruction.InitializeMint2,
-        decimals,
-        mintAuthority,
-        freezeAuthorityOption: freezeAuthority ? 1 : 0,
-        freezeAuthority: freezeAuthority || new PublicKey(0),
-    }, data);
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-const sumUpTokenAmount = (accounts) => {
-    return accounts.reduce((acc, account) => acc.add(account.parsed.amount), bn(0));
-};
-const validateSameTokenOwner = (accounts) => {
-    const owner = accounts[0].parsed.owner;
-    accounts.forEach(acc => {
-        if (!acc.parsed.owner.equals(owner)) {
-            throw new Error('Token accounts must be owned by the same owner');
-        }
-    });
-};
-const parseInputTokenData = (inputCompressedTokenAccounts) => {
-    const mint = inputCompressedTokenAccounts[0].parsed.mint;
-    const currentOwner = inputCompressedTokenAccounts[0].parsed.owner;
-    const delegate = inputCompressedTokenAccounts[0].parsed.delegate;
-    return { mint, currentOwner, delegate };
-};
-function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amount) {
-    amount = bn(amount);
-    const inputAmount = sumUpTokenAmount(inputCompressedTokenAccounts);
-    const inputLamports = sumUpLamports(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    const changeAmount = inputAmount.sub(amount);
-    validateSufficientBalance(changeAmount);
-    if (changeAmount.eq(bn(0)) && inputLamports.eq(bn(0))) {
-        return [
-            {
-                owner: toAddress,
-                amount,
-                lamports: inputLamports,
-            },
-        ];
-    }
-    /// validates token program
-    validateSameOwner(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    validateSameTokenOwner(inputCompressedTokenAccounts);
-    const outputCompressedAccounts = [
-        {
-            owner: inputCompressedTokenAccounts[0].parsed.owner,
-            amount: changeAmount,
-            lamports: inputLamports,
-        },
-        {
-            owner: toAddress,
-            amount,
-            lamports: bn(0),
-        },
-    ];
-    return outputCompressedAccounts;
-}
-function createDecompressOutputState(inputCompressedTokenAccounts, amount) {
-    amount = bn(amount);
-    const inputLamports = sumUpLamports(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    const inputAmount = sumUpTokenAmount(inputCompressedTokenAccounts);
-    const changeAmount = inputAmount.sub(amount);
-    validateSufficientBalance(changeAmount);
-    /// lamports gets decompressed
-    if (changeAmount.eq(bn(0)) && inputLamports.eq(bn(0))) {
-        return [];
-    }
-    validateSameOwner(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    validateSameTokenOwner(inputCompressedTokenAccounts);
-    const tokenTransferOutputs = [
-        {
-            owner: inputCompressedTokenAccounts[0].parsed.owner,
-            amount: changeAmount,
-            lamports: inputLamports,
-        },
-    ];
-    return tokenTransferOutputs;
-}
-class CompressedTokenProgram {
-    /**
-     * @internal
-     */
-    constructor() { }
-    /**
-     * Public key that identifies the CompressedPda program
-     */
-    static programId = new PublicKey(
-    // TODO: can add check to ensure its consistent with the idl
-    '9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE');
-    static _program = null;
-    static get program() {
-        if (!this._program) {
-            this.initializeProgram();
-        }
-        return this._program;
-    }
-    /**
-     * Initializes the program statically if not already initialized.
-     */
-    static initializeProgram() {
-        if (!this._program) {
-            /// We can use a mock connection because we're using the program only for
-            /// serde and building instructions, not for interacting with the network.
-            const mockKeypair = Keypair.generate();
-            const mockConnection = new Connection('http://127.0.0.1:8899', 'confirmed');
-            const mockProvider = new AnchorProvider(mockConnection, useWallet(mockKeypair), confirmConfig);
-            setProvider(mockProvider);
-            this._program = new Program(IDL, this.programId, mockProvider);
-        }
-    }
-    /** @internal */
-    static deriveMintAuthorityPda = (authority, mint) => {
-        const [pubkey] = PublicKey.findProgramAddressSync([MINT_AUTHORITY_SEED, authority.toBuffer(), mint.toBuffer()], this.programId);
-        return pubkey;
-    };
-    /** @internal */
-    static deriveTokenPoolPda(mint) {
-        const seeds = [POOL_SEED, mint.toBuffer()];
-        const [address, _] = PublicKey.findProgramAddressSync(seeds, this.programId);
-        return address;
-    }
-    /** @internal */
-    static get deriveCpiAuthorityPda() {
-        const [address, _] = PublicKey.findProgramAddressSync([CPI_AUTHORITY_SEED], this.programId);
-        return address;
-    }
-    static async createMint(params) {
-        const { mint, authority, feePayer, rentExemptBalance } = params;
-        const createMintAccountInstruction = SystemProgram.createAccount({
-            fromPubkey: feePayer,
-            lamports: rentExemptBalance,
-            newAccountPubkey: mint,
-            programId: TOKEN_PROGRAM_ID,
-            space: MINT_SIZE,
-        });
-        const mintAuthorityPda = this.deriveMintAuthorityPda(authority, mint);
-        const initializeMintInstruction = createInitializeMint2Instruction(mint, params.decimals, mintAuthorityPda, params.freezeAuthority, TOKEN_PROGRAM_ID);
-        const fundAuthorityPdaInstruction = SystemProgram.transfer({
-            fromPubkey: feePayer,
-            toPubkey: mintAuthorityPda,
-            lamports: rentExemptBalance, // TODO: check that this is the right PDA size
-        });
-        const tokenPoolPda = this.deriveTokenPoolPda(mint);
-        const ix = await this.program.methods
-            .createMint()
-            .accounts({
-            mint,
-            feePayer,
-            authority,
-            tokenPoolPda,
-            systemProgram: SystemProgram.programId,
-            mintAuthorityPda,
-            tokenProgram: TOKEN_PROGRAM_ID,
-            cpiAuthorityPda: this.deriveCpiAuthorityPda,
-        })
-            .instruction();
-        return [
-            createMintAccountInstruction,
-            initializeMintInstruction,
-            fundAuthorityPdaInstruction,
-            ix,
-        ];
-    }
-    static async mintTo(params) {
-        const systemKeys = defaultStaticAccountsStruct();
-        const { mint, feePayer, authority, merkleTree, toPubkey, amount } = params;
-        const tokenPoolPda = this.deriveTokenPoolPda(mint);
-        const mintAuthorityPda = this.deriveMintAuthorityPda(authority, mint);
-        const amounts = toArray(amount).map(amount => bn(amount));
-        const toPubkeys = toArray(toPubkey);
-        const ix = await this.program.methods
-            .mintTo(toPubkeys, amounts)
-            .accounts({
-            feePayer,
-            authority,
-            mintAuthorityPda,
-            mint,
-            tokenPoolPda,
-            tokenProgram: TOKEN_PROGRAM_ID,
-            compressedPdaProgram: LightSystemProgram.programId,
-            registeredProgramPda: systemKeys.registeredProgramPda,
-            noopProgram: systemKeys.noopProgram,
-            accountCompressionAuthority: systemKeys.accountCompressionAuthority,
-            accountCompressionProgram: systemKeys.accountCompressionProgram,
-            merkleTree,
-            selfProgram: this.programId,
-        })
-            .instruction();
-        return ix;
-    }
-    static async transfer(params) {
-        const { payer, inputCompressedTokenAccounts, recentInputStateRootIndices, recentValidityProof, amount, outputStateTrees, toAddress, } = params;
-        const outputCompressedAccounts = createTransferOutputState(inputCompressedTokenAccounts, toAddress, amount);
-        /// Pack
-        const { inputTokenDataWithContext, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedTokenAccounts({
-            inputCompressedTokenAccounts,
-            outputCompressedAccountsLength: outputCompressedAccounts.length,
-            outputStateTrees,
-        });
-        const { mint, currentOwner } = parseInputTokenData(inputCompressedTokenAccounts);
-        const data = {
-            proof: recentValidityProof,
-            rootIndices: recentInputStateRootIndices,
-            mint,
-            signerIsDelegate: false, // TODO: implement
-            inputTokenDataWithContext,
-            outputCompressedAccounts,
-            outputStateMerkleTreeAccountIndices: Buffer$1.from(outputStateMerkleTreeIndices),
-            compressionAmount: null,
-            isCompress: false,
-        };
-        const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
-        const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
-        const instruction = await this.program.methods
-            .transfer(encodedData, null)
-            .accounts({
-            feePayer: payer,
-            authority: currentOwner,
-            cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: LightSystemProgram.programId,
-            registeredProgramPda: registeredProgramPda,
-            noopProgram: noopProgram,
-            accountCompressionAuthority: accountCompressionAuthority,
-            accountCompressionProgram: accountCompressionProgram,
-            selfProgram: this.programId,
-            tokenPoolPda: null,
-            decompressTokenAccount: null,
-            tokenProgram: null,
-        })
-            .remainingAccounts(remainingAccountMetas)
-            .instruction();
-        return [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-            instruction,
-        ];
-    }
-    static async compress(params) {
-        const { payer, owner, source, toAddress, mint, outputStateTree } = params;
-        const amount = bn(params.amount);
-        const outputCompressedAccounts = [
-            {
-                owner: toAddress,
-                amount,
-                lamports: bn(0),
-            },
-        ];
-        /// Pack
-        const { inputTokenDataWithContext, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedTokenAccounts({
-            inputCompressedTokenAccounts: [],
-            outputCompressedAccountsLength: outputCompressedAccounts.length,
-            outputStateTrees: [outputStateTree],
-        });
-        const data = {
-            proof: null,
-            rootIndices: [],
-            mint,
-            signerIsDelegate: false, // TODO: implement
-            inputTokenDataWithContext,
-            outputCompressedAccounts,
-            outputStateMerkleTreeAccountIndices: Buffer$1.from(outputStateMerkleTreeIndices),
-            compressionAmount: amount,
-            isCompress: true,
-        };
-        const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
-        const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
-        /// TODO: add support for multiSigners
-        /// TODO: validate that we don't need approveChecked
-        const approveInstruction = createApproveInstruction(source, this.deriveCpiAuthorityPda, owner, BigInt(amount.toString()));
-        const instruction = await this.program.methods
-            .transfer(encodedData, null)
-            .accounts({
-            feePayer: payer,
-            authority: owner,
-            cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: LightSystemProgram.programId,
-            registeredProgramPda: registeredProgramPda,
-            noopProgram: noopProgram,
-            accountCompressionAuthority: accountCompressionAuthority,
-            accountCompressionProgram: accountCompressionProgram,
-            selfProgram: this.programId,
-            tokenPoolPda: this.deriveTokenPoolPda(mint),
-            decompressTokenAccount: source, // token
-            tokenProgram: TOKEN_PROGRAM_ID,
-        })
-            .remainingAccounts(remainingAccountMetas)
-            .instruction();
-        return [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-            approveInstruction,
-            instruction,
-        ];
-    }
-    static async decompress(params) {
-        const { payer, inputCompressedTokenAccounts, toAddress, outputStateTree, recentValidityProof, recentInputStateRootIndices, } = params;
-        const amount = bn(params.amount);
-        const tokenTransferOutputs = createDecompressOutputState(inputCompressedTokenAccounts, amount);
-        /// Pack
-        const { inputTokenDataWithContext, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedTokenAccounts({
-            inputCompressedTokenAccounts,
-            outputCompressedAccountsLength: tokenTransferOutputs.length,
-            outputStateTrees: [outputStateTree],
-        });
-        const { mint, currentOwner } = parseInputTokenData(inputCompressedTokenAccounts);
-        const data = {
-            proof: recentValidityProof,
-            rootIndices: recentInputStateRootIndices,
-            mint,
-            signerIsDelegate: false, // TODO: implement
-            inputTokenDataWithContext,
-            outputCompressedAccounts: tokenTransferOutputs,
-            outputStateMerkleTreeAccountIndices: Buffer$1.from(outputStateMerkleTreeIndices),
-            compressionAmount: amount,
-            isCompress: false,
-        };
-        const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
-        const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
-        const instruction = await this.program.methods
-            .transfer(encodedData, null)
-            .accounts({
-            feePayer: payer,
-            authority: currentOwner,
-            cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: LightSystemProgram.programId,
-            registeredProgramPda: registeredProgramPda,
-            noopProgram: noopProgram,
-            accountCompressionAuthority: accountCompressionAuthority,
-            accountCompressionProgram: accountCompressionProgram,
-            selfProgram: this.programId,
-            tokenPoolPda: this.deriveTokenPoolPda(mint),
-            decompressTokenAccount: toAddress, // token
-            tokenProgram: TOKEN_PROGRAM_ID,
-        })
-            .remainingAccounts(remainingAccountMetas)
-            .instruction();
-        return [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-            instruction,
-        ];
-    }
-}
-
-/**
- * Compress SPL tokens
- *
- * @param rpc                   Rpc connection to use
- * @param payer                 Payer of the transaction fees
- * @param mint                  Mint of the compressed token
- * @param amount                Number of tokens to transfer
- * @param owner                 Owner of the compressed tokens.
- * @param sourceTokenAccount    Source (associated) token account
- * @param toAddress             Destination address of the recipient
- * @param merkleTree            State tree account that the compressed tokens
- *                              should be inserted into. Defaults to a default
- *                              state tree account.
- * @param confirmOptions        Options for confirming the transaction
- *
- *
- * @return Signature of the confirmed transaction
- */
-async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
-    amount = bn(amount);
-    const ixs = await CompressedTokenProgram.compress({
-        payer: payer.publicKey,
-        owner: owner.publicKey,
-        source: sourceTokenAccount,
-        toAddress,
-        amount,
-        mint,
-        outputStateTree: merkleTree,
-    });
-    const blockhashCtx = await rpc.getLatestBlockhash();
-    const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(ixs, payer, blockhashCtx.blockhash, additionalSigners);
-    const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);
-    return txId;
-}
-
-/**
- * Transfer compressed tokens from one owner to another
- *
- * @param rpc            Rpc to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint of the compressed token
- * @param amount         Number of tokens to transfer
- * @param owner          Owner of the compressed tokens
- * @param toAddress      Destination address of the recipient
- * @param merkleTree     State tree account that the compressed tokens should be
- *                       inserted into. Defaults to the default state tree account.
- * @param confirmOptions Options for confirming the transaction
- *
- *
- * @return Signature of the confirmed transaction
- */
-async function transfer(rpc, payer, mint, amount, owner, toAddress, 
-/// TODO: allow multiple
-merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
-    amount = bn(amount);
-    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, {
-        mint,
-    });
-    const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts, amount);
-    const proof = await rpc.getValidityProof(inputAccounts.map(account => bn(account.compressedAccount.hash)));
-    const ixs = await CompressedTokenProgram.transfer({
-        payer: payer.publicKey,
-        inputCompressedTokenAccounts: inputAccounts,
-        toAddress,
-        amount,
-        recentInputStateRootIndices: proof.rootIndices,
-        recentValidityProof: proof.compressedProof,
-        outputStateTrees: merkleTree,
-    });
-    const { blockhash } = await rpc.getLatestBlockhash();
-    const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(ixs, payer, blockhash, additionalSigners);
-    const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions);
-    return txId;
-}
-/**
- * Selects the minimal number of compressed token accounts for a transfer.
- *
- * 1. Sorts the accounts by amount in descending order
- * 2. Accumulates the amount until it is greater than or equal to the transfer
- *    amount
- */
-function selectMinCompressedTokenAccountsForTransfer(accounts, transferAmount) {
-    let accumulatedAmount = bn(0);
-    let accumulatedLamports = bn(0);
-    const selectedAccounts = [];
-    accounts.sort((a, b) => b.parsed.amount.cmp(a.parsed.amount));
-    for (const account of accounts) {
-        if (accumulatedAmount.gte(bn(transferAmount)))
-            break;
-        accumulatedAmount = accumulatedAmount.add(account.parsed.amount);
-        accumulatedLamports = accumulatedLamports.add(account.compressedAccount.lamports);
-        selectedAccounts.push(account);
-    }
-    if (accumulatedAmount.lt(bn(transferAmount))) {
-        throw new Error(`Not enough balance for transfer. Required: ${transferAmount.toString()}, available: ${accumulatedAmount.toString()}`);
-    }
-    return [
-        selectedAccounts,
-        accumulatedAmount,
-        accumulatedLamports.lt(bn(0)) ? accumulatedLamports : null,
-    ];
-}
-
-/**
- * Decompress compressed tokens
- *
- * @param rpc            Rpc to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint of the compressed token
- * @param amount         Number of tokens to transfer
- * @param owner          Owner of the compressed tokens
- * @param toAddress      Destination **uncompressed** (associated) token account
- *                       address.
- * @param merkleTree     State tree account that any change compressed tokens should be
- *                       inserted into. Defaults to a default state tree
- *                       account.
- * @param confirmOptions Options for confirming the transaction
- *
- *
- * @return Signature of the confirmed transaction
- */
-async function decompress(rpc, payer, mint, amount, owner, toAddress, 
-/// TODO: allow multiple
-merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
-    amount = bn(amount);
-    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, {
-        mint,
-    });
-    /// TODO: consider using a different selection algorithm
-    const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts, amount);
-    const proof = await rpc.getValidityProof(inputAccounts.map(account => bn(account.compressedAccount.hash)));
-    const ixs = await CompressedTokenProgram.decompress({
-        payer: payer.publicKey,
-        inputCompressedTokenAccounts: inputAccounts,
-        toAddress, // TODO: add explicit check that it is a token account
-        amount,
-        outputStateTree: merkleTree,
-        recentInputStateRootIndices: proof.rootIndices,
-        recentValidityProof: proof.compressedProof,
-    });
-    const { blockhash } = await rpc.getLatestBlockhash();
-    const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(ixs, payer, blockhash, additionalSigners);
-    const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions);
-    return txId;
-}
-
-/**
- * Create and initialize a new compressed token mint
- *
- * @param rpc             RPC to use
- * @param payer           Payer of the transaction and initialization fees
- * @param mintAuthority   Account or multisig that will control minting. Is signer.
- * @param decimals        Location of the decimal place
- * @param keypair         Optional keypair, defaulting to a new random one
- * @param confirmOptions  Options for confirming the transaction
- *
- * @return Address of the new mint and the transaction signature
- */
-async function createMint(rpc, payer, mintAuthority, decimals, keypair = Keypair.generate(), confirmOptions) {
-    const rentExemptBalance = await rpc.getMinimumBalanceForRentExemption(MINT_SIZE);
-    const ixs = await CompressedTokenProgram.createMint({
-        feePayer: payer.publicKey,
-        mint: keypair.publicKey,
-        decimals,
-        authority: mintAuthority.publicKey,
-        freezeAuthority: null, // TODO: add feature
-        rentExemptBalance,
-    });
-    const { blockhash } = await rpc.getLatestBlockhash();
-    const additionalSigners = dedupeSigner(payer, [mintAuthority, keypair]);
-    const tx = buildAndSignTx(ixs, payer, blockhash, additionalSigners);
-    const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
-    return { mint: keypair.publicKey, transactionSignature: txId };
-}
-
-/**
- * Mint compressed tokens to a solana address
- *
- * @param rpc            Rpc to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint for the account
- * @param destination    Address of the account to mint to
- * @param authority      Minting authority
- * @param amount         Amount to mint
- * @param merkleTree     State tree account that the compressed tokens should be
- *                       part of. Defaults to the default state tree account.
- * @param confirmOptions Options for confirming the transaction
- *
- * @return Signature of the confirmed transaction
- */
-async function mintTo(rpc, payer, mint, destination, authority, amount, merkleTree = defaultTestStateTreeAccounts().merkleTree, // DEFAULT IF NOT PROVIDED
-confirmOptions) {
-    const additionalSigners = dedupeSigner(payer, [authority]);
-    const ix = await CompressedTokenProgram.mintTo({
-        feePayer: payer.publicKey,
-        mint,
-        authority: authority.publicKey,
-        amount: amount,
-        toPubkey: destination,
-        merkleTree,
-    });
-    const { blockhash } = await rpc.getLatestBlockhash();
-    const tx = buildAndSignTx([ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }), ix], payer, blockhash, additionalSigners);
-    const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
-    return txId;
-}
-
-export { CPI_AUTHORITY_SEED, CompressedTokenProgram, IDL, MINT_AUTHORITY_SEED, POOL_SEED, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, compress, createDecompressOutputState, createMint, createTransferOutputState, decompress, mintTo, packCompressedTokenAccounts, parseInputTokenData, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };
-//# sourceMappingURL=index.js.map