@algorandfoundation/puya-ts 1.2.0-beta.35 → 1.2.0-beta.37

package/index.d.ts

@@ -1,5 +1,4 @@
 import { base64ToUint8Array, hexToUint8Array, uint8ArrayToBase64, uint8ArrayToHex } from './util';
-import './util/polyfills';
 export { SourceLocation } from './awst/source-location';
 export * as ptypes from './awst_build/ptypes/for-export';
 export { registerPTypes } from './awst_build/ptypes/register';

package/index.mjs

@@ -1,8 +1,8 @@
-import { o as ABICompatibleInstanceType, q as ALL_OP_ENUMS, r as AccountFunction, s as AnyPType, t as ApplicationFunctionType, u as ApplicationTxnFunction, w as ApprovalProgram, x as ArrayGeneric, y as ArrayLiteralPType, z as ArrayPType, B as AssetConfigTxnFunction, D as AssetFreezeTxnFunction, E as AssetFunction, F as AssetTransferTxnFunction, G as BaseContractClassType, H as BigIntLiteralPType, J as BigIntPType, K as BigUintFunction, M as BooleanFunction, N as BoxGeneric, Q as BoxMapGeneric, R as BoxMapPType, S as BoxPType, T as BytesFunction, U as BytesGeneric, V as BytesPType, W as ClassMethodDecoratorContext, X as ClearStateProgram, Y as ClusteredContractClassType, Z as ClusteredPrototype, _ as ContractClassPType, $ as FixedArrayGeneric, a0 as FixedArrayPType, a1 as FunctionPType, a2 as GeneratorGeneric, a3 as GeneratorType, a4 as GenericPType, a5 as GlobalMapGeneric, a6 as GlobalMapType, a7 as GlobalStateGeneric, a8 as GlobalStateType, a9 as GroupTransactionPType, aa as ImmutableObjectPType, ab as InnerTransactionPType, ac as InstanceType, ad as InternalType, ae as IntersectionPType, af as IntrinsicEnumType, ag as IntrinsicFunctionGroupType, ah as IntrinsicFunctionGroupTypeType, ai as IntrinsicFunctionType, aj as IntrinsicFunctionTypeType, ak as IterableIteratorGeneric, al as IterableIteratorType, am as ItxnParamsPType, an as KeyRegistrationTxnFunction, ao as LibClassType, ap as LibFunctionType, aq as LibObjType, ar as LocalMapGeneric, as as LocalMapType, at as LocalStateGeneric, au as LocalStateType, av as LogicSigPType, aw as MutableObjectPType, ax as MutableTuplePType, ay as NamespacePType, az as NumberPType, aA as NumericLiteralPType, aB as ObjectLiteralPType, aC as ObjectWithOptionalFieldsType, aD as PType, aE as PaymentTxnFunction, aF as PolytypeClassMethodHelper, aG as PromiseGeneric, aH as PromiseType, aI as ReadonlyArrayGeneric, aJ as ReadonlyArrayPType, aK as ReadonlyGeneric, aL as ReadonlyTuplePType, aM as ReferenceArrayGeneric, aN as ReferenceArrayType, aO as StringFunction, aP as SuperPrototypeSelector, aQ as SuperPrototypeSelectorGeneric, aR as TemplateVarFunction, aS as TransactionFunction, aT as TransactionFunctionType, aU as TransientType, aV as TypeParameterType, aW as Uint64EnumMemberLiteralType, aX as Uint64EnumMemberType, aY as Uint64EnumType, aZ as Uint64Function, a_ as UnionPType, a$ as UnsupportedType, e as accountPType, h as anyGtxnType, b0 as anyItxnParamsType, b1 as anyItxnType, b2 as anyPType, n as applicationCallGtxnType, b3 as applicationCallItxnFn, b4 as applicationCallItxnParamsType, b5 as applicationItxnType, f as applicationPType, b6 as arc28EmitFunction, b7 as arc4AbiMethodDecorator, b8 as arc4BareMethodDecorator, b9 as arc4BaseContractType, ba as assertFunction, bb as assertMatchFunction, i as assetConfigGtxnType, bc as assetConfigItxnFn, bd as assetConfigItxnParamsType, be as assetConfigItxnType, m as assetFreezeGtxnType, bf as assetFreezeItxnFn, bg as assetFreezeItxnParamsType, bh as assetFreezeItxnType, g as assetPType, j as assetTransferGtxnType, bi as assetTransferItxnFn, bj as assetTransferItxnParamsType, bk as assetTransferItxnType, bl as base64PType, bm as baseContractType, bn as bigIntPType, bo as biguintPType, bp as boolPType, bq as bytesPType, br as bzeroFunction, bs as cloneFunctionPType, bt as compileFunctionType, bu as compiledContractType, bv as compiledLogicSigType, bw as contractOptionsDecorator, bx as ecPType, by as ecdsaPType, bz as ensureBudgetFunction, bA as errFunction, bB as esSymbol, bC as inputOnlyObjects, bD as isArrayType, bE as isObjectType, bF as isTupleLike, bG as itoaMethod, bH as itxnComposePType, k as keyRegistrationGtxnType, bI as keyRegistrationItxnFn, bJ as keyRegistrationItxnParamsType, bK as keyRegistrationItxnType, bL as logFunction, bM as loggedAssertFunction, bN as loggedErrFunction, bO as logicSigBaseType, bP as logicSigOptionsDecorator, bQ as matchFunction, bR as mimcConfigurationsPType, bS as neverPType, bT as nullPType, bU as numberPType, bV as onCompleteActionType, bW as opUpFeeSourceType, p as paymentGtxnType, bX as paymentItxnFn, bY as paymentItxnParamsType, bZ as paymentItxnType, b_ as readonlyDecorator, b$ as stringPType, c0 as submitGroupItxnFunction, c1 as transactionTypeType, c2 as uint64PType, c3 as undefinedPType, c4 as unknownPType, c5 as urangeFunction, c6 as validateEncodingFunctionPType, v as voidPType, c7 as vrfVerifyPType, c8 as uint8ArrayToBigInt, c9 as uint8ArrayToBase64, ca as uint8ArrayToBase32, cb as uint8ArrayToUtf8, cc as base64ToUint8Array, cd as base32ToUint8Array, ce as bigIntToUint8Array, cf as utf8ToUint8Array } from './contract-class-model-cK8F4WVM.js';
-export { A as AbsolutePath, L as LogLevel, cg as LogSource, a as LoggingContext, ch as SourceLocation } from './contract-class-model-cK8F4WVM.js';
-import { A as ARC4ArrayType, a as ARC4BoolClass, b as ARC4EncodedType, c as ARC4InstanceType, d as ARC4StrClass, e as ARC4StructClass, f as ARC4StructType, g as ARC4TupleType, h as AddressClass, i as Arc4TupleGeneric, B as ByteClass, C as ContractProxyGeneric, j as ContractProxyType, D as DynamicArrayGeneric, k as DynamicArrayType, l as DynamicBytesConstructor, m as DynamicBytesType, S as StaticArrayGeneric, n as StaticArrayType, o as StaticBytesGeneric, p as StaticBytesType, T as TypedApplicationCallResponseGeneric, q as TypedApplicationCallResponseType, U as UFixedNxMGeneric, r as UFixedNxMType, s as UintN128Class, t as UintN16Class, u as UintN256Class, v as UintN32Class, w as UintN64Class, x as UintN8Class, y as UintNGeneric, z as UintNType, E as abiCallFunction, F as arc4AddressAlias, G as arc4BooleanType, H as arc4ByteAlias, I as arc4StringType, J as arc4StructBaseType, K as compileArc4Function, L as convertBytesFunction, M as decodeArc4Function, N as encodeArc4Function, O as methodSelectorFunction, P as sizeOfFunction, Q as uint8ArrayToHex, R as hexToUint8Array } from './options-sBHEIhey.js';
-export { V as CompileOptions, W as TypeResolver, X as processInputPaths, Y as registerPTypes, Z as typeRegistry } from './options-sBHEIhey.js';
-export { c as compile } from './compile-DGk1ftqu.js';
+import { o as ABICompatibleInstanceType, q as ALL_OP_ENUMS, r as AccountFunction, s as AnyPType, t as ApplicationFunctionType, u as ApplicationTxnFunction, w as ApprovalProgram, x as ArrayGeneric, y as ArrayLiteralPType, z as ArrayPType, B as AssetConfigTxnFunction, D as AssetFreezeTxnFunction, E as AssetFunction, F as AssetTransferTxnFunction, G as BaseContractClassType, H as BigIntLiteralPType, J as BigIntPType, K as BigUintFunction, M as BooleanFunction, N as BoxGeneric, Q as BoxMapGeneric, R as BoxMapPType, S as BoxPType, T as BytesFunction, U as BytesGeneric, V as BytesPType, W as ClassMethodDecoratorContext, X as ClearStateProgram, Y as ClusteredContractClassType, Z as ClusteredPrototype, _ as ContractClassPType, $ as FixedArrayGeneric, a0 as FixedArrayPType, a1 as FunctionPType, a2 as GeneratorGeneric, a3 as GeneratorType, a4 as GenericPType, a5 as GlobalMapGeneric, a6 as GlobalMapType, a7 as GlobalStateGeneric, a8 as GlobalStateType, a9 as GroupTransactionPType, aa as ImmutableObjectPType, ab as InnerTransactionPType, ac as InstanceType, ad as InternalType, ae as IntersectionPType, af as IntrinsicEnumType, ag as IntrinsicFunctionGroupType, ah as IntrinsicFunctionGroupTypeType, ai as IntrinsicFunctionType, aj as IntrinsicFunctionTypeType, ak as IterableIteratorGeneric, al as IterableIteratorType, am as ItxnParamsPType, an as KeyRegistrationTxnFunction, ao as LibClassType, ap as LibFunctionType, aq as LibObjType, ar as LocalMapGeneric, as as LocalMapType, at as LocalStateGeneric, au as LocalStateType, av as LogicSigPType, aw as MutableObjectPType, ax as MutableTuplePType, ay as NamespacePType, az as NumberPType, aA as NumericLiteralPType, aB as ObjectLiteralPType, aC as ObjectWithOptionalFieldsType, aD as PType, aE as PaymentTxnFunction, aF as PolytypeClassMethodHelper, aG as PromiseGeneric, aH as PromiseType, aI as ReadonlyArrayGeneric, aJ as ReadonlyArrayPType, aK as ReadonlyGeneric, aL as ReadonlyTuplePType, aM as ReferenceArrayGeneric, aN as ReferenceArrayType, aO as StringFunction, aP as SuperPrototypeSelector, aQ as SuperPrototypeSelectorGeneric, aR as TemplateVarFunction, aS as TransactionFunction, aT as TransactionFunctionType, aU as TransientType, aV as TypeParameterType, aW as Uint64EnumMemberLiteralType, aX as Uint64EnumMemberType, aY as Uint64EnumType, aZ as Uint64Function, a_ as UnionPType, a$ as UnsupportedType, e as accountPType, h as anyGtxnType, b0 as anyItxnParamsType, b1 as anyItxnType, b2 as anyPType, n as applicationCallGtxnType, b3 as applicationCallItxnFn, b4 as applicationCallItxnParamsType, b5 as applicationItxnType, f as applicationPType, b6 as arc28EmitFunction, b7 as arc4AbiMethodDecorator, b8 as arc4BareMethodDecorator, b9 as arc4BaseContractType, ba as assertFunction, bb as assertMatchFunction, i as assetConfigGtxnType, bc as assetConfigItxnFn, bd as assetConfigItxnParamsType, be as assetConfigItxnType, m as assetFreezeGtxnType, bf as assetFreezeItxnFn, bg as assetFreezeItxnParamsType, bh as assetFreezeItxnType, g as assetPType, j as assetTransferGtxnType, bi as assetTransferItxnFn, bj as assetTransferItxnParamsType, bk as assetTransferItxnType, bl as base64PType, bm as baseContractType, bn as bigIntPType, bo as biguintPType, bp as boolPType, bq as bytesPType, br as bzeroFunction, bs as cloneFunctionPType, bt as compileFunctionType, bu as compiledContractType, bv as compiledLogicSigType, bw as contractOptionsDecorator, bx as ecPType, by as ecdsaPType, bz as ensureBudgetFunction, bA as errFunction, bB as esSymbol, bC as inputOnlyObjects, bD as isArrayType, bE as isObjectType, bF as isTupleLike, bG as itoaMethod, bH as itxnComposePType, k as keyRegistrationGtxnType, bI as keyRegistrationItxnFn, bJ as keyRegistrationItxnParamsType, bK as keyRegistrationItxnType, bL as logFunction, bM as loggedAssertFunction, bN as loggedErrFunction, bO as logicSigBaseType, bP as logicSigOptionsDecorator, bQ as matchFunction, bR as mimcConfigurationsPType, bS as neverPType, bT as nullPType, bU as numberPType, bV as onCompleteActionType, bW as opUpFeeSourceType, p as paymentGtxnType, bX as paymentItxnFn, bY as paymentItxnParamsType, bZ as paymentItxnType, b_ as readonlyDecorator, b$ as stringPType, c0 as submitGroupItxnFunction, c1 as transactionTypeType, c2 as uint64PType, c3 as undefinedPType, c4 as unknownPType, c5 as urangeFunction, c6 as validateEncodingFunctionPType, v as voidPType, c7 as vrfVerifyPType, c8 as uint8ArrayToBigInt, c9 as uint8ArrayToBase64, ca as uint8ArrayToBase32, cb as uint8ArrayToUtf8, cc as base64ToUint8Array, cd as base32ToUint8Array, ce as bigIntToUint8Array, cf as utf8ToUint8Array } from './contract-class-model-BZeEDGw0.js';
+export { A as AbsolutePath, L as LogLevel, cg as LogSource, a as LoggingContext, ch as SourceLocation } from './contract-class-model-BZeEDGw0.js';
+import { A as ARC4ArrayType, a as ARC4BoolClass, b as ARC4EncodedType, c as ARC4InstanceType, d as ARC4StrClass, e as ARC4StructClass, f as ARC4StructType, g as ARC4TupleType, h as AddressClass, i as Arc4TupleGeneric, B as ByteClass, C as ContractProxyGeneric, j as ContractProxyType, D as DynamicArrayGeneric, k as DynamicArrayType, l as DynamicBytesConstructor, m as DynamicBytesType, S as StaticArrayGeneric, n as StaticArrayType, o as StaticBytesGeneric, p as StaticBytesType, T as TypedApplicationCallResponseGeneric, q as TypedApplicationCallResponseType, U as UFixedNxMGeneric, r as UFixedNxMType, s as UintN128Class, t as UintN16Class, u as UintN256Class, v as UintN32Class, w as UintN64Class, x as UintN8Class, y as UintNGeneric, z as UintNType, E as abiCallFunction, F as arc4AddressAlias, G as arc4BooleanType, H as arc4ByteAlias, I as arc4StringType, J as arc4StructBaseType, K as compileArc4Function, L as convertBytesFunction, M as decodeArc4Function, N as encodeArc4Function, O as methodSelectorFunction, P as sizeOfFunction, Q as uint8ArrayToHex, R as hexToUint8Array } from './options-DD9MApH4.js';
+export { V as CompileOptions, W as TypeResolver, X as processInputPaths, Y as registerPTypes, Z as typeRegistry } from './options-DD9MApH4.js';
+export { c as compile } from './compile-ycpMcgmJ.js';
 import 'typescript';
 import 'node:fs';
 import 'node:util';
@@ -22,13 +22,13 @@ import 'net';
 import 'change-case';
 import 'glob';
 import 'minimatch';
-import './arc4-clientgen-Dd2qW-1d.js';
+import './arc4-clientgen-qBTlCOIm.js';
 import '@algorandfoundation/algokit-utils/abi';
 import 'fs';
 import 'fs/promises';
-import './semver-T4bO0VEo.js';
+import './semver-B0p_0XuH.js';
 import 'node:url';
-import './resolve-puya-path-Bgh6DuRP.js';
+import './resolve-puya-path-Ba54kz9o.js';
 import 'signal-exit';
 import 'tar';
 import 'node:zlib';

package/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/awst_build/ptypes/for-export.ts","../src/index.ts"],"sourcesContent":["/* This file aggregates all ptypes into a single export for external consumption of the compiler api */\nexport * from './arc4-types'\nexport * from './index'\n","import {\n  base32ToUint8Array,\n  base64ToUint8Array,\n  bigIntToUint8Array,\n  hexToUint8Array,\n  uint8ArrayToBase32,\n  uint8ArrayToBase64,\n  uint8ArrayToBigInt,\n  uint8ArrayToHex,\n  uint8ArrayToUtf8,\n  utf8ToUint8Array,\n} from './util'\nimport './util/polyfills'\n\nexport { SourceLocation } from './awst/source-location'\nexport * as ptypes from './awst_build/ptypes/for-export'\nexport { registerPTypes } from './awst_build/ptypes/register'\nexport { typeRegistry } from './awst_build/type-registry'\nexport { TypeResolver } from './awst_build/type-resolver'\nexport { compile } from './compile'\nexport { processInputPaths } from './input-paths/process-input-paths'\nexport { LoggingContext, LogLevel, LogSource, LogEvent } from './logger'\nexport { CompileOptions } from './options'\nexport { AbsolutePath } from './util/absolute-path'\n\nexport const encodingUtil = {\n  utf8ToUint8Array,\n  bigIntToUint8Array,\n  hexToUint8Array,\n  base32ToUint8Array,\n  base64ToUint8Array,\n  uint8ArrayToUtf8,\n  uint8ArrayToHex,\n  uint8ArrayToBase32,\n  uint8ArrayToBase64,\n  uint8ArrayToBigInt,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACyBO,MAAM,YAAY,GAAG;IAC1B,gBAAgB;IAChB,kBAAkB;IAClB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,gBAAgB;IAChB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;;;;;"}
+{"version":3,"file":"index.mjs","sources":["../src/awst_build/ptypes/for-export.ts","../src/index.ts"],"sourcesContent":["/* This file aggregates all ptypes into a single export for external consumption of the compiler api */\nexport * from './arc4-types'\nexport * from './index'\n","import {\n  base32ToUint8Array,\n  base64ToUint8Array,\n  bigIntToUint8Array,\n  hexToUint8Array,\n  uint8ArrayToBase32,\n  uint8ArrayToBase64,\n  uint8ArrayToBigInt,\n  uint8ArrayToHex,\n  uint8ArrayToUtf8,\n  utf8ToUint8Array,\n} from './util'\n\nexport { SourceLocation } from './awst/source-location'\nexport * as ptypes from './awst_build/ptypes/for-export'\nexport { registerPTypes } from './awst_build/ptypes/register'\nexport { typeRegistry } from './awst_build/type-registry'\nexport { TypeResolver } from './awst_build/type-resolver'\nexport { compile } from './compile'\nexport { processInputPaths } from './input-paths/process-input-paths'\nexport { LoggingContext, LogLevel, LogSource, LogEvent } from './logger'\nexport { CompileOptions } from './options'\nexport { AbsolutePath } from './util/absolute-path'\n\nexport const encodingUtil = {\n  utf8ToUint8Array,\n  bigIntToUint8Array,\n  hexToUint8Array,\n  base32ToUint8Array,\n  base64ToUint8Array,\n  uint8ArrayToUtf8,\n  uint8ArrayToHex,\n  uint8ArrayToBase32,\n  uint8ArrayToBase64,\n  uint8ArrayToBigInt,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACwBO,MAAM,YAAY,GAAG;IAC1B,gBAAgB;IAChB,kBAAkB;IAClB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,gBAAgB;IAChB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;;;;;"}

package/language-server/analyser-service.d.ts

@@ -1,6 +1,5 @@
 import type * as lsp from 'vscode-languageserver';
 import type { FileWithDiagnostics } from './diagnostics-manager';
-import '../util/polyfills';
 type AnalyseServiceOptions = {
     puyaPath: string;
 };

package/{options-sBHEIhey.js → options-DD9MApH4.js}

@@ -1,4 +1,4 @@
-import { ao as LibClassType, d as Constants, bp as boolPType, co as wtypes, b$ as stringPType, a4 as GenericPType, cp as codeInvariant, aL as ReadonlyTuplePType, ax as MutableTuplePType, aD as PType, aA as NumericLiteralPType, c2 as uint64PType, bo as biguintPType, z as ArrayPType, aJ as ReadonlyArrayPType, e as accountPType, bq as bytesPType, ap as LibFunctionType, cq as invariant, _ as ContractClassPType, bu as compiledContractType, aa as ImmutableObjectPType, b5 as applicationItxnType, v as voidPType, aw as MutableObjectPType, I as InternalError, c as CodeError, cr as throwError, cs as StringConstant, ct as BytesConstant, cu as IntegerConstant, cv as BoolConstant, cw as AddressConstant, cx as MethodConstant, cy as DecimalConstant, cz as TemplateVar, cg as LogSource, L as LogLevel, cA as instanceOfAny, cB as SingleEvaluation, cC as VarExpression, cD as nodeFactory, cE as NotSupported, l as logger, cF as TupleItemExpression, cG as FieldExpression, cH as IndexExpression, cI as TupleExpression, cJ as AppStateExpression, cK as AppAccountStateExpression, cL as BoxValueExpression, cM as StateGetEx, cN as StateGet, aU as TransientType, bU as numberPType, bn as bigIntPType, b6 as arc28EmitFunction, y as ArrayLiteralPType, H as BigIntLiteralPType, cO as hasFlags, cP as BinaryBooleanOperator, ay as NamespacePType, bm as baseContractType, b9 as arc4BaseContractType, cQ as SymbolName, a_ as UnionPType, a9 as GroupTransactionPType, h as anyGtxnType, aX as Uint64EnumMemberType, aV as TypeParameterType, bB as esSymbol, c4 as unknownPType, bS as neverPType, b2 as anyPType, bT as nullPType, c3 as undefinedPType, Z as ClusteredPrototype, ae as IntersectionPType, bO as logicSigBaseType, av as LogicSigPType, aY as Uint64EnumType, a1 as FunctionPType, w as ApprovalProgram, X as ClearStateProgram, cn as isIn, R as BoxMapPType, S as BoxPType, as as LocalMapType, au as LocalStateType, a6 as GlobalMapType, a8 as GlobalStateType, aP as SuperPrototypeSelector, Y as ClusteredContractClassType, ch as SourceLocation, cR as intersectsFlags, cS as extractModuleName, cT as toSubScript, A as AbsolutePath, cU as CompilationSet, cV as ARC4ABIMethodConfig, C as ContractReference, V as BytesPType, cW as EqualityComparison, aB as ObjectLiteralPType, bE as isObjectType$1, b_ as readonlyDecorator, b7 as arc4AbiMethodDecorator, b8 as arc4BareMethodDecorator, cX as ARC4CreateOption, cY as NewArray, O as OnCompletionAction, cZ as BytesEncoding, ce as bigIntToUint8Array, c_ as FixableCodeError, c$ as UInt64BinaryOperator, d0 as tryConvertEnum, d1 as NumericComparison, d2 as UInt64UnaryOperator, bG as itoaMethod, aZ as Uint64Function, d3 as UInt64PostfixUnaryOperator, a0 as FixedArrayPType, al as IterableIteratorType, ak as IterableIteratorGeneric, f as applicationPType, g as assetPType, bV as onCompleteActionType, d4 as wrapInCodeError, cd as base32ToUint8Array, c1 as transactionTypeType, d5 as TransactionKind, bt as compileFunctionType, bv as compiledLogicSigType, d6 as LogicSigReference, ab as InnerTransactionPType, aT as TransactionFunctionType, c0 as submitGroupItxnFunction, am as ItxnParamsPType, d7 as getInnerTransactionType, d8 as getItxnParamsType, d9 as CompiledContract, da as ARC4BareMethodConfig, db as MethodSignature, cj as enumFromValue, x as ArrayGeneric, $ as FixedArrayGeneric, cm as zipStrict, bD as isArrayType, bF as isTupleLike, bQ as matchFunction, bb as assertMatchFunction, dc as BigUIntBinaryOperator, K as BigUintFunction, dd as BigUIntPostfixUnaryOperator, cf as utf8ToUint8Array, de as BytesBinaryOperator, df as IntrinsicCall, cb as uint8ArrayToUtf8, T as BytesFunction, U as BytesGeneric, cc as base64ToUint8Array, dg as enumKeyFromValue, dh as BytesUnaryOperator, bs as cloneFunctionPType, bw as contractOptionsDecorator, bz as ensureBudgetFunction, di as PuyaLibFunction, bW as opUpFeeSourceType, af as IntrinsicEnumType, bP as logicSigOptionsDecorator, ac as InstanceType, aC as ObjectWithOptionalFieldsType, c7 as vrfVerifyPType, bR as mimcConfigurationsPType, by as ecdsaPType, bx as ecPType, bl as base64PType, ag as IntrinsicFunctionGroupType, dj as Expression, ai as IntrinsicFunctionType, aM as ReferenceArrayGeneric, aN as ReferenceArrayType, dk as AppStorageKind, a$ as UnsupportedType, dl as transientTypeErrors, a7 as GlobalStateGeneric, aR as TemplateVarFunction, dm as getGroupTransactionType, bH as itxnComposePType, aW as Uint64EnumMemberLiteralType, b0 as anyItxnParamsType, c6 as validateEncodingFunctionPType, M as BooleanFunction, aO as StringFunction, aI as ReadonlyArrayGeneric, aK as ReadonlyGeneric, a2 as GeneratorGeneric, a3 as GeneratorType, aG as PromiseGeneric, aH as PromiseType, W as ClassMethodDecoratorContext, aQ as SuperPrototypeSelectorGeneric, aF as PolytypeClassMethodHelper, bL as logFunction, ba as assertFunction, bA as errFunction, bM as loggedAssertFunction, bN as loggedErrFunction, c5 as urangeFunction, br as bzeroFunction, aj as IntrinsicFunctionTypeType, q as ALL_OP_ENUMS, ah as IntrinsicFunctionGroupTypeType, a5 as GlobalMapGeneric, at as LocalStateGeneric, ar as LocalMapGeneric, N as BoxGeneric, Q as BoxMapGeneric, t as ApplicationFunctionType, r as AccountFunction, E as AssetFunction, p as paymentGtxnType, aE as PaymentTxnFunction, k as keyRegistrationGtxnType, an as KeyRegistrationTxnFunction, i as assetConfigGtxnType, B as AssetConfigTxnFunction, j as assetTransferGtxnType, F as AssetTransferTxnFunction, m as assetFreezeGtxnType, D as AssetFreezeTxnFunction, n as applicationCallGtxnType, u as ApplicationTxnFunction, aS as TransactionFunction, bX as paymentItxnFn, bI as keyRegistrationItxnFn, bc as assetConfigItxnFn, bi as assetTransferItxnFn, bf as assetFreezeItxnFn, b3 as applicationCallItxnFn, bZ as paymentItxnType, bK as keyRegistrationItxnType, be as assetConfigItxnType, bk as assetTransferItxnType, bh as assetFreezeItxnType, bY as paymentItxnParamsType, bJ as keyRegistrationItxnParamsType, bd as assetConfigItxnParamsType, bj as assetTransferItxnParamsType, bg as assetFreezeItxnParamsType, b4 as applicationCallItxnParamsType, bC as inputOnlyObjects, dn as Contract, dp as InstanceSuperMethodTarget, dq as ExpressionStatement, dr as AssertExpression, ds as VoidConstant, dt as ArrayConcat, du as ArrayPop, dv as ArrayReplace, dw as ArrayLength, dx as SizeOf, dy as UpdateInnerTransaction, dz as CheckedMaybe, dA as StageInnerTransactions, dB as SubmitInnerTransaction, dC as AssignmentExpression, dD as CommaExpression, dE as NumericComparisonExpression, dF as BytesComparisonExpression, dG as PuyaLibCall, dH as UInt64UnaryOperation, dI as UInt64PostfixUnaryOperation, dJ as BigUIntPostfixUnaryOperation, dK as BytesUnaryOperation, dL as UInt64BinaryOperation, dM as BigUIntBinaryOperation, dN as BooleanBinaryOperation, dO as Not, dP as Emit, dQ as Range, dR as Enumeration, dS as Reversed, dT as StateExists, dU as ARC4Router, dV as MethodSignatureString, dW as SubroutineID, dX as ContractMethodTarget, dY as InstanceMethodTarget, ca as uint8ArrayToBase32, ck as mkDirIfNotExists, dZ as patchErrorLocation, d_ as Goto, d$ as ReturnStatement, e0 as ContractMethod, e1 as sameSets, b as ContractClassModel, e2 as Subroutine, e3 as LogicSigClassModel, e4 as ptypeIn, e5 as expandMaybeArray, a as LoggingContext, P as PuyaError } from './contract-class-model-cK8F4WVM.js';
+import { ao as LibClassType, d as Constants, bp as boolPType, co as wtypes, b$ as stringPType, a4 as GenericPType, cp as codeInvariant, aL as ReadonlyTuplePType, ax as MutableTuplePType, aD as PType, aA as NumericLiteralPType, c2 as uint64PType, bo as biguintPType, z as ArrayPType, aJ as ReadonlyArrayPType, e as accountPType, bq as bytesPType, ap as LibFunctionType, cq as invariant, _ as ContractClassPType, bu as compiledContractType, aa as ImmutableObjectPType, b5 as applicationItxnType, v as voidPType, aw as MutableObjectPType, I as InternalError, c as CodeError, cr as throwError, cs as StringConstant, ct as BytesConstant, cu as IntegerConstant, cv as BoolConstant, cw as AddressConstant, cx as MethodConstant, cy as DecimalConstant, cz as TemplateVar, cg as LogSource, L as LogLevel, cA as instanceOfAny, cB as SingleEvaluation, cC as VarExpression, cD as nodeFactory, cE as NotSupported, l as logger, cF as TupleItemExpression, cG as FieldExpression, cH as IndexExpression, cI as TupleExpression, cJ as AppStateExpression, cK as AppAccountStateExpression, cL as BoxValueExpression, cM as StateGetEx, cN as StateGet, aU as TransientType, bU as numberPType, bn as bigIntPType, b6 as arc28EmitFunction, y as ArrayLiteralPType, H as BigIntLiteralPType, cO as hasFlags, cP as BinaryBooleanOperator, ay as NamespacePType, bm as baseContractType, b9 as arc4BaseContractType, cQ as SymbolName, a_ as UnionPType, a9 as GroupTransactionPType, h as anyGtxnType, aX as Uint64EnumMemberType, aV as TypeParameterType, bB as esSymbol, c4 as unknownPType, bS as neverPType, b2 as anyPType, bT as nullPType, c3 as undefinedPType, Z as ClusteredPrototype, ae as IntersectionPType, bO as logicSigBaseType, av as LogicSigPType, aY as Uint64EnumType, a1 as FunctionPType, w as ApprovalProgram, X as ClearStateProgram, cn as isIn, R as BoxMapPType, S as BoxPType, as as LocalMapType, au as LocalStateType, a6 as GlobalMapType, a8 as GlobalStateType, aP as SuperPrototypeSelector, Y as ClusteredContractClassType, ch as SourceLocation, cR as intersectsFlags, cS as extractModuleName, cT as toSubScript, A as AbsolutePath, cU as CompilationSet, cV as ARC4ABIMethodConfig, C as ContractReference, V as BytesPType, cW as EqualityComparison, aB as ObjectLiteralPType, bE as isObjectType$1, b_ as readonlyDecorator, b7 as arc4AbiMethodDecorator, b8 as arc4BareMethodDecorator, cX as ARC4CreateOption, cY as NewArray, O as OnCompletionAction, cZ as BytesEncoding, ce as bigIntToUint8Array, c_ as FixableCodeError, c$ as UInt64BinaryOperator, d0 as tryConvertEnum, d1 as NumericComparison, d2 as UInt64UnaryOperator, bG as itoaMethod, aZ as Uint64Function, d3 as UInt64PostfixUnaryOperator, a0 as FixedArrayPType, al as IterableIteratorType, ak as IterableIteratorGeneric, f as applicationPType, g as assetPType, bV as onCompleteActionType, d4 as wrapInCodeError, cd as base32ToUint8Array, c1 as transactionTypeType, d5 as TransactionKind, bt as compileFunctionType, bv as compiledLogicSigType, d6 as LogicSigReference, ab as InnerTransactionPType, aT as TransactionFunctionType, c0 as submitGroupItxnFunction, am as ItxnParamsPType, d7 as getInnerTransactionType, d8 as getItxnParamsType, d9 as CompiledContract, da as ARC4BareMethodConfig, db as MethodSignature, cj as enumFromValue, x as ArrayGeneric, $ as FixedArrayGeneric, cm as zipStrict, bD as isArrayType, bF as isTupleLike, bQ as matchFunction, bb as assertMatchFunction, dc as BigUIntBinaryOperator, K as BigUintFunction, dd as BigUIntPostfixUnaryOperator, cf as utf8ToUint8Array, de as BytesBinaryOperator, df as IntrinsicCall, cb as uint8ArrayToUtf8, T as BytesFunction, U as BytesGeneric, cc as base64ToUint8Array, dg as enumKeyFromValue, dh as BytesUnaryOperator, bs as cloneFunctionPType, bw as contractOptionsDecorator, bz as ensureBudgetFunction, di as PuyaLibFunction, bW as opUpFeeSourceType, af as IntrinsicEnumType, bP as logicSigOptionsDecorator, ac as InstanceType, aC as ObjectWithOptionalFieldsType, c7 as vrfVerifyPType, bR as mimcConfigurationsPType, by as ecdsaPType, bx as ecPType, bl as base64PType, ag as IntrinsicFunctionGroupType, dj as Expression, ai as IntrinsicFunctionType, aM as ReferenceArrayGeneric, aN as ReferenceArrayType, dk as AppStorageKind, a$ as UnsupportedType, dl as transientTypeErrors, a7 as GlobalStateGeneric, aR as TemplateVarFunction, dm as getGroupTransactionType, bH as itxnComposePType, aW as Uint64EnumMemberLiteralType, b0 as anyItxnParamsType, c6 as validateEncodingFunctionPType, M as BooleanFunction, aO as StringFunction, aI as ReadonlyArrayGeneric, aK as ReadonlyGeneric, a2 as GeneratorGeneric, a3 as GeneratorType, aG as PromiseGeneric, aH as PromiseType, W as ClassMethodDecoratorContext, aQ as SuperPrototypeSelectorGeneric, aF as PolytypeClassMethodHelper, bL as logFunction, ba as assertFunction, bA as errFunction, bM as loggedAssertFunction, bN as loggedErrFunction, c5 as urangeFunction, br as bzeroFunction, aj as IntrinsicFunctionTypeType, q as ALL_OP_ENUMS, ah as IntrinsicFunctionGroupTypeType, a5 as GlobalMapGeneric, at as LocalStateGeneric, ar as LocalMapGeneric, N as BoxGeneric, Q as BoxMapGeneric, t as ApplicationFunctionType, r as AccountFunction, E as AssetFunction, p as paymentGtxnType, aE as PaymentTxnFunction, k as keyRegistrationGtxnType, an as KeyRegistrationTxnFunction, i as assetConfigGtxnType, B as AssetConfigTxnFunction, j as assetTransferGtxnType, F as AssetTransferTxnFunction, m as assetFreezeGtxnType, D as AssetFreezeTxnFunction, n as applicationCallGtxnType, u as ApplicationTxnFunction, aS as TransactionFunction, bX as paymentItxnFn, bI as keyRegistrationItxnFn, bc as assetConfigItxnFn, bi as assetTransferItxnFn, bf as assetFreezeItxnFn, b3 as applicationCallItxnFn, bZ as paymentItxnType, bK as keyRegistrationItxnType, be as assetConfigItxnType, bk as assetTransferItxnType, bh as assetFreezeItxnType, bY as paymentItxnParamsType, bJ as keyRegistrationItxnParamsType, bd as assetConfigItxnParamsType, bj as assetTransferItxnParamsType, bg as assetFreezeItxnParamsType, b4 as applicationCallItxnParamsType, bC as inputOnlyObjects, dn as Contract, dp as InstanceSuperMethodTarget, dq as ExpressionStatement, dr as AssertExpression, ds as VoidConstant, dt as ArrayConcat, du as ArrayPop, dv as ArrayReplace, dw as ArrayLength, dx as SizeOf, dy as UpdateInnerTransaction, dz as CheckedMaybe, dA as StageInnerTransactions, dB as SubmitInnerTransaction, dC as AssignmentExpression, dD as CommaExpression, dE as NumericComparisonExpression, dF as BytesComparisonExpression, dG as PuyaLibCall, dH as UInt64UnaryOperation, dI as UInt64PostfixUnaryOperation, dJ as BigUIntPostfixUnaryOperation, dK as BytesUnaryOperation, dL as UInt64BinaryOperation, dM as BigUIntBinaryOperation, dN as BooleanBinaryOperation, dO as Not, dP as Emit, dQ as Range, dR as Enumeration, dS as Reversed, dT as StateExists, dU as ARC4Router, dV as MethodSignatureString, dW as SubroutineID, dX as ContractMethodTarget, dY as InstanceMethodTarget, ca as uint8ArrayToBase32, ck as mkDirIfNotExists, dZ as patchErrorLocation, d_ as Goto, d$ as ReturnStatement, e0 as ContractMethod, e1 as sameSets, b as ContractClassModel, e2 as Subroutine, e3 as LogicSigClassModel, e4 as ptypeIn, e5 as expandMaybeArray, a as LoggingContext, P as PuyaError } from './contract-class-model-BZeEDGw0.js';
 import * as fs from 'node:fs';
 import 'node:util';
 import pathe__default, { normalize } from 'pathe';
@@ -1282,16 +1282,16 @@ function isReferableExpression(expr) {
     }
     return false;
 }
+const lValueNodes = [
+    VarExpression,
+    FieldExpression,
+    IndexExpression,
+    TupleExpression,
+    AppStateExpression,
+    AppAccountStateExpression,
+    BoxValueExpression,
+];
 function requireLValue(expr) {
-    const lValueNodes = [
-        VarExpression,
-        FieldExpression,
-        IndexExpression,
-        TupleExpression,
-        AppStateExpression,
-        AppAccountStateExpression,
-        BoxValueExpression,
-    ];
     if (expr instanceof TupleItemExpression) {
         if (expr.base.wtype.immutable) {
             throw new CodeError('Expression is not a valid assignment target - object is immutable', { sourceLocation: expr.sourceLocation });
@@ -3130,6 +3130,7 @@ class AwstBuildContextImpl extends AwstBuildContext {
     typeResolver;
     typeChecker;
     #compilationSet;
+    programRoot;
     constructor(program, options, constants, nameResolver, storageDeclarations, arc4MethodConfig, contractTypes, compilationSet) {
         super();
         this.program = program;
@@ -3139,8 +3140,9 @@ class AwstBuildContextImpl extends AwstBuildContext {
         this.storageDeclarations = storageDeclarations;
         this.arc4MethodConfig = arc4MethodConfig;
         this.contractTypes = contractTypes;
+        this.programRoot = AbsolutePath.resolve({ path: this.program.getCurrentDirectory() });
         this.typeChecker = program.getTypeChecker();
-        this.typeResolver = new TypeResolver(this.typeChecker, AbsolutePath.resolve({ path: this.program.getCurrentDirectory() }));
+        this.typeResolver = new TypeResolver(this.typeChecker, this.programRoot);
         this.#compilationSet = compilationSet;
     }
     registerContractType(contractType) {
@@ -3156,33 +3158,40 @@ class AwstBuildContextImpl extends AwstBuildContext {
         }
         contractConfig.set(memberName, arc4MethodConfig);
     }
+    *iterateContractHierarchy(contractType) {
+        const seen = new Set();
+        for (const ct of [contractType, ...contractType.allBases()]) {
+            if (seen.has(ct.fullName))
+                continue;
+            seen.add(ct.fullName);
+            yield ct;
+        }
+    }
+    *iterateMethodNameToConfigMap(contractType) {
+        for (const ct of this.iterateContractHierarchy(contractType)) {
+            if (ct.equals(baseContractType) || ct.equals(arc4BaseContractType) || ct instanceof ClusteredContractClassType)
+                continue;
+            const contractMethods = this.arc4MethodConfig.get(ct.fullName);
+            if (contractMethods)
+                yield contractMethods;
+        }
+    }
     getArc4Config(contractType, memberName) {
-        if (memberName) {
-            for (const ct of [contractType, ...contractType.allBases()]) {
-                if (ct.equals(baseContractType) || ct.equals(arc4BaseContractType) || ct instanceof ClusteredContractClassType)
-                    continue;
-                const contractMethods = this.arc4MethodConfig.get(ct.fullName);
-                if (!contractMethods)
-                    continue;
-                if (contractMethods.has(memberName)) {
-                    return contractMethods.get(memberName);
-                }
+        if (memberName !== undefined) {
+            for (const methods of this.iterateMethodNameToConfigMap(contractType)) {
+                if (methods.has(memberName))
+                    return methods.get(memberName);
             }
             return undefined;
         }
-        else {
-            return Array.from([contractType, ...contractType.allBases()]
-                .toReversed()
-                .reduce((acc, ct) => {
-                if (ct.equals(baseContractType) || ct.equals(arc4BaseContractType) || ct instanceof ClusteredContractClassType)
-                    return acc;
-                const contractMethods = this.arc4MethodConfig.get(ct.fullName);
-                if (!contractMethods)
-                    return acc;
-                return new Map([...acc, ...contractMethods]);
-            }, new Map())
-                .values());
+        const result = new Map();
+        for (const methods of this.iterateMethodNameToConfigMap(contractType)) {
+            for (const [name, cfg] of methods) {
+                if (!result.has(name))
+                    result.set(name, cfg);
+            }
         }
+        return Array.from(result.values());
     }
     static forProgram(program, options) {
         return new AwstBuildContextImpl(program, options, new ConstantStore(program), new UniqueNameResolver(), new DefaultMap(), new DefaultMap(), {}, new CompilationSet());
@@ -3239,7 +3248,7 @@ class AwstBuildContextImpl extends AwstBuildContext {
         }), ptype);
     }
     getSourceLocation(node) {
-        return SourceLocation.fromNode(node, AbsolutePath.resolve({ path: this.program.getCurrentDirectory() }));
+        return SourceLocation.fromNode(node, this.programRoot);
     }
     addStorageDeclaration(declaration) {
         const contractDeclarations = this.storageDeclarations.getOrDefault(declaration.definedIn.fullName, () => new Map());
@@ -3249,23 +3258,16 @@ class AwstBuildContextImpl extends AwstBuildContext {
         contractDeclarations.set(declaration.memberName, declaration);
     }
     getStorageDeclaration(contractType, memberName) {
-        const declaration = this.storageDeclarations.get(contractType.fullName)?.get(memberName);
-        if (declaration)
-            return declaration;
-        for (const baseType of contractType.baseTypes) {
-            const baseDeclaration = this.getStorageDeclaration(baseType, memberName);
-            if (baseDeclaration)
-                return baseDeclaration;
+        for (const ct of this.iterateContractHierarchy(contractType)) {
+            const declaration = this.storageDeclarations.get(ct.fullName)?.get(memberName);
+            if (declaration)
+                return declaration;
         }
         return undefined;
     }
     getStorageDefinitionsForContract(contractType) {
         const result = new Map();
-        const seenContracts = new Set();
-        for (const ct of [contractType, ...contractType.allBases()]) {
-            if (seenContracts.has(ct.fullName))
-                continue;
-            seenContracts.add(ct.fullName);
+        for (const ct of this.iterateContractHierarchy(contractType)) {
             for (const [memberName, declaration] of this.storageDeclarations.get(ct.fullName) ?? []) {
                 if (result.has(memberName)) {
                     logger.error(result.get(memberName)?.sourceLocation, `Redefinition of app storage member, original declared in ${declaration.sourceLocation}`);
@@ -6315,14 +6317,15 @@ function getImplicitFields({ applicationProxy, methodConfig, mappedFields, sourc
     }
     // Update or possible create
     if (oca === OnCompletionAction.UpdateApplication || !hasAppId) {
-        implicitFields.set(TxnField.ApprovalProgramPages, requireInstanceBuilder(applicationProxy.memberAccess('approvalProgram', sourceLocation)).resolve());
-        implicitFields.set(TxnField.ClearStateProgramPages, requireInstanceBuilder(applicationProxy.memberAccess('clearStateProgram', sourceLocation)).resolve());
+        const proxyField = (name) => requireInstanceBuilder(applicationProxy.memberAccess(name, sourceLocation)).resolve();
+        implicitFields.set(TxnField.ApprovalProgramPages, proxyField('approvalProgram'));
+        implicitFields.set(TxnField.ClearStateProgramPages, proxyField('clearStateProgram'));
         if (!hasAppId) {
-            implicitFields.set(TxnField.GlobalNumUint, requireInstanceBuilder(applicationProxy.memberAccess('globalUints', sourceLocation)).resolve());
-            implicitFields.set(TxnField.GlobalNumByteSlice, requireInstanceBuilder(applicationProxy.memberAccess('globalBytes', sourceLocation)).resolve());
-            implicitFields.set(TxnField.LocalNumByteSlice, requireInstanceBuilder(applicationProxy.memberAccess('localBytes', sourceLocation)).resolve());
-            implicitFields.set(TxnField.LocalNumUint, requireInstanceBuilder(applicationProxy.memberAccess('localUints', sourceLocation)).resolve());
-            implicitFields.set(TxnField.ExtraProgramPages, requireInstanceBuilder(applicationProxy.memberAccess('extraProgramPages', sourceLocation)).resolve());
+            implicitFields.set(TxnField.GlobalNumUint, proxyField('globalUints'));
+            implicitFields.set(TxnField.GlobalNumByteSlice, proxyField('globalBytes'));
+            implicitFields.set(TxnField.LocalNumByteSlice, proxyField('localBytes'));
+            implicitFields.set(TxnField.LocalNumUint, proxyField('localUints'));
+            implicitFields.set(TxnField.ExtraProgramPages, proxyField('extraProgramPages'));
         }
     }
     return implicitFields;
@@ -7813,7 +7816,7 @@ class BytesFunctionBuilder extends FunctionBuilder {
                 ],
             });
             const { strategy } = parsedArgs.at(-1);
-            toFixedStrategy = strategy === undefined ? 'assert-length' : mapStringConstant(fixedConversionStrategyMap, strategy.resolve());
+            toFixedStrategy = parseToFixedStrategy(strategy);
         }
         if (!initialValue) {
             return empty;
@@ -7823,13 +7826,9 @@ class BytesFunctionBuilder extends FunctionBuilder {
             logger.error(initialValue.sourceLocation, initialValue.ptype.expressionMessage);
             bytesBuilder = empty;
         }
-        else if (initialValue.ptype.equals(uint64PType)) {
-            bytesBuilder = initialValue.toBytes(sourceLocation);
-        }
-        else if (initialValue.ptype.equals(biguintPType)) {
-            bytesBuilder = initialValue.toBytes(sourceLocation);
-        }
-        else if (initialValue.ptype.equals(stringPType)) {
+        else if (initialValue.ptype.equals(uint64PType) ||
+            initialValue.ptype.equals(biguintPType) ||
+            initialValue.ptype.equals(stringPType)) {
             bytesBuilder = initialValue.toBytes(sourceLocation);
         }
         else if (initialValue.ptype.equals(bytesPType)) {
@@ -7903,7 +7902,7 @@ class FromEncodingBuilder extends FunctionBuilder {
                 callLocation: sourceLocation,
                 argSpec: (a) => [a.passthrough(), a.obj({ length: a.required(NumericLiteralPType), strategy: a.optional(stringPType) })],
             });
-            const toFixedStrategy = strategy === undefined ? 'assert-length' : mapStringConstant(fixedConversionStrategyMap, strategy.resolve());
+            const toFixedStrategy = parseToFixedStrategy(strategy);
             if (toFixedStrategy !== 'assert-length') {
                 logger.error(sourceLocation, `Invalid strategy value of '${toFixedStrategy}'. Expected 'assert-length'`);
             }
@@ -8036,7 +8035,7 @@ class ConcatFunctionBuilder extends FunctionBuilder {
         }), bytesPType);
     }
 }
-function bytesToFixed(builder, fixedType, sourceLocation, strategy = 'assert-length') {
+function bytesToFixed(builder, fixedType, sourceLocation, strategy) {
     invariant(fixedType.length !== null, 'Should only be called for bytes with a fixed length', sourceLocation);
     const expr = builder.resolve();
     if (strategy === 'unsafe-cast') {
@@ -8084,6 +8083,9 @@ const fixedConversionStrategyMap = {
     'assert-length': 'assert-length',
     'unsafe-cast': 'unsafe-cast',
 };
+function parseToFixedStrategy(strategy) {
+    return strategy === undefined ? 'assert-length' : mapStringConstant(fixedConversionStrategyMap, strategy.resolve());
+}
 class ToFixedLengthFunctionBuilder extends FunctionBuilder {
     builder;
     constructor(builder) {
@@ -8105,18 +8107,9 @@ class ToFixedLengthFunctionBuilder extends FunctionBuilder {
             ],
         });
         const sizeConst = requireIntegerConstant(length);
-        const parsedStrategy = strategy === undefined ? 'assert-length' : mapStringConstant(fixedConversionStrategyMap, strategy.resolve());
+        const parsedStrategy = parseToFixedStrategy(strategy);
         const ptype = new BytesPType({ length: sizeConst.value });
-        if (parsedStrategy === 'assert-length') {
-            return bytesToFixed(this.builder, ptype, sourceLocation);
-        }
-        else {
-            return instanceEb(nodeFactory.reinterpretCast({
-                expr: this.builder.resolve(),
-                wtype: ptype.wtype,
-                sourceLocation,
-            }), ptype);
-        }
+        return bytesToFixed(this.builder, ptype, sourceLocation, parsedStrategy);
     }
 }
 class BytesInvertBuilder extends FunctionBuilder {
@@ -17585,6 +17578,7 @@ class TextVisitor {
     }
 }
 
+const OPTIONAL_CHAINING_MESSAGE = 'The optional chaining (?.) operator is not supported';
 class BaseVisitor {
     baseAccept = (node) => accept(this, node);
     textVisitor = new TextVisitor();
@@ -17743,7 +17737,7 @@ class BaseVisitor {
         return new SpreadExpressionBuilder(base, this.sourceLocation(node));
     }
     visitPropertyAccessExpression(node) {
-        this.logNotSupported(node.questionDotToken, 'The optional chaining (?.) operator is not supported');
+        this.logNotSupported(node.questionDotToken, OPTIONAL_CHAINING_MESSAGE);
         const target = this.baseAccept(node.expression);
         if (target instanceof NamespaceBuilder) {
             codeInvariant(!ts.isPrivateIdentifier(node.name), 'Private identifiers are not supported here', this.sourceLocation(node.name));
@@ -17753,14 +17747,14 @@ class BaseVisitor {
         return target.memberAccess(property, this.sourceLocation(node));
     }
     visitElementAccessExpression(node) {
-        this.logNotSupported(node.questionDotToken, 'The optional chaining (?.) operator is not supported');
+        this.logNotSupported(node.questionDotToken, OPTIONAL_CHAINING_MESSAGE);
         const sourceLocation = this.sourceLocation(node);
         const target = this.baseAccept(node.expression);
         const argument = this.baseAccept(node.argumentExpression);
         return target.indexAccess(requireInstanceBuilder(argument), sourceLocation);
     }
     visitCallExpression(node) {
-        this.logNotSupported(node.questionDotToken, 'The optional chaining (?.) operator is not supported');
+        this.logNotSupported(node.questionDotToken, OPTIONAL_CHAINING_MESSAGE);
         const sourceLocation = this.sourceLocation(node);
         const eb = this.baseAccept(node.expression);
         const args = node.arguments
@@ -23513,4 +23507,4 @@ class PuyaOptions {
 }
 
 export { parseCliTemplateVar as $, ARC4ArrayType as A, ByteClass as B, ContractProxyGeneric as C, DynamicArrayGeneric as D, abiCallFunction as E, arc4AddressAlias as F, arc4BooleanType as G, arc4ByteAlias as H, arc4StringType as I, arc4StructBaseType as J, compileArc4Function as K, convertBytesFunction as L, decodeArc4Function as M, encodeArc4Function as N, methodSelectorFunction as O, sizeOfFunction as P, uint8ArrayToHex as Q, hexToUint8Array as R, StaticArrayGeneric as S, TypedApplicationCallResponseGeneric as T, UFixedNxMGeneric as U, CompileOptions as V, TypeResolver as W, processInputPaths as X, registerPTypes as Y, typeRegistry as Z, defaultPuyaOptions as _, ARC4BoolClass as a, LocalsCoalescingStrategy as a0, PuyaService as a1, deserializeAndLog as a2, createTsProgram as a3, buildAwst as a4, validateAwst as a5, sleep as a6, DefaultMap as a7, relinquishThread as a8, ARC4EncodedType as b, ARC4InstanceType as c, ARC4StrClass as d, ARC4StructClass as e, ARC4StructType as f, ARC4TupleType as g, AddressClass as h, Arc4TupleGeneric as i, ContractProxyType as j, DynamicArrayType as k, DynamicBytesConstructor as l, DynamicBytesType as m, StaticArrayType as n, StaticBytesGeneric as o, StaticBytesType as p, TypedApplicationCallResponseType as q, UFixedNxMType as r, UintN128Class as s, UintN16Class as t, UintN256Class as u, UintN32Class as v, UintN64Class as w, UintN8Class as x, UintNGeneric as y, UintNType as z };
-//# sourceMappingURL=options-sBHEIhey.js.map
+//# sourceMappingURL=options-DD9MApH4.js.map