@algorandfoundation/puya-ts 1.2.0-beta.4 → 1.2.0-beta.40

package/errors.d.ts

@@ -12,7 +12,7 @@ export declare class PuyaError extends Error {
 /**
  * Any error that is 'caused' by a user of Puya
  */
-export declare abstract class UserError extends PuyaError {
+declare abstract class UserError extends PuyaError {
 }
 /**
  * Thrown when the user's code is invalid, or not supported
@@ -50,11 +50,6 @@ export declare class InternalError extends PuyaError {
 export declare class NotSupported extends CodeError {
     constructor(featureName: string, options?: PuyaErrorOptions);
 }
-/**
- * Thrown when the user's environment is not set up correctly
- */
-export declare class EnvironmentError extends UserError {
-}
 export declare const throwError: (error: Error) => never;
 export declare const wrapInCodeError: <T>(func: () => T, sourceLocation: SourceLocation) => T;
 export {};

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';
@@ -7,7 +6,7 @@ export { typeRegistry } from './awst_build/type-registry';
 export { TypeResolver } from './awst_build/type-resolver';
 export { compile } from './compile';
 export { processInputPaths } from './input-paths/process-input-paths';
-export { LoggingContext } from './logger';
+export { LoggingContext, LogLevel, LogSource, LogEvent } from './logger';
 export { CompileOptions } from './options';
 export { AbsolutePath } from './util/absolute-path';
 export declare const encodingUtil: {

package/index.mjs

@@ -1,15 +1,18 @@
-import { A as ABICompatibleInstanceType, a as ALL_OP_ENUMS, b as ARC4ArrayType, c as ARC4BoolClass, d as ARC4EncodedType, e as ARC4InstanceType, f as ARC4StrClass, g as ARC4StructClass, h as ARC4StructType, i as ARC4TupleType, j as AccountFunction, k as AddressClass, l as AnyPType, m as ApplicationFunctionType, n as ApplicationTxnFunction, o as ApprovalProgram, p as Arc4TupleGeneric, q as ArrayGeneric, r as ArrayLiteralPType, s as ArrayPType, t as AssetConfigTxnFunction, u as AssetFreezeTxnFunction, v as AssetFunction, w as AssetTransferTxnFunction, B as BaseContractClassType, x as BigIntLiteralPType, y as BigIntPType, z as BigUintFunction, D as BooleanFunction, E as BoxGeneric, F as BoxMapGeneric, G as BoxMapPType, H as BoxPType, I as ByteClass, J as BytesFunction, K as BytesGeneric, L as BytesPType, M as ClassMethodDecoratorContext, N as ClearStateProgram, O as ClusteredContractClassType, P as ClusteredPrototype, Q as ContractClassPType, R as ContractProxyGeneric, S as ContractProxyType, T as DynamicArrayGeneric, U as DynamicArrayType, V as DynamicBytesConstructor, W as DynamicBytesType, X as FixedArrayGeneric, Y as FixedArrayPType, Z as FunctionPType, _ as GeneratorGeneric, $ as GeneratorType, a0 as GenericPType, a1 as GlobalStateGeneric, a2 as GlobalStateType, a3 as GroupTransactionPType, a4 as ImmutableObjectPType, a5 as InnerTransactionPType, a6 as InstanceType, a7 as InternalType, a8 as IntersectionPType, a9 as IntrinsicEnumType, aa as IntrinsicFunctionGroupType, ab as IntrinsicFunctionGroupTypeType, ac as IntrinsicFunctionType, ad as IntrinsicFunctionTypeType, ae as IterableIteratorGeneric, af as IterableIteratorType, ag as ItxnParamsPType, ah as KeyRegistrationTxnFunction, ai as LibClassType, aj as LibFunctionType, ak as LibObjType, al as LocalStateGeneric, am as LocalStateType, an as LogicSigPType, ao as MutableObjectPType, ap as MutableTuplePType, aq as NamespacePType, ar as NumberPType, as as NumericLiteralPType, at as ObjectLiteralPType, au as ObjectWithOptionalFieldsType, av as PType, aw as PaymentTxnFunction, ax as PolytypeClassMethodHelper, ay as PromiseGeneric, az as PromiseType, aA as ReadonlyArrayGeneric, aB as ReadonlyArrayPType, aC as ReadonlyGeneric, aD as ReadonlyTuplePType, aE as ReferenceArrayGeneric, aF as ReferenceArrayType, aG as StaticArrayGeneric, aH as StaticArrayType, aI as StaticBytesGeneric, aJ as StaticBytesType, aK as StringFunction, aL as SuperPrototypeSelector, aM as SuperPrototypeSelectorGeneric, aN as TemplateVarFunction, aO as TransactionFunction, aP as TransactionFunctionType, aQ as TransientType, aR as TypeParameterType, aS as TypedApplicationCallResponseGeneric, aT as TypedApplicationCallResponseType, aU as UFixedNxMGeneric, aV as UFixedNxMType, aW as Uint64EnumMemberLiteralType, aX as Uint64EnumMemberType, aY as Uint64EnumType, aZ as Uint64Function, a_ as UintN128Class, a$ as UintN16Class, b0 as UintN256Class, b1 as UintN32Class, b2 as UintN64Class, b3 as UintN8Class, b4 as UintNGeneric, b5 as UintNType, b6 as UnionPType, b7 as UnsupportedType, b8 as abiCallFunction, b9 as accountPType, ba as anyGtxnType, bb as anyItxnParamsType, bc as anyItxnType, bd as anyPType, be as applicationCallGtxnType, bf as applicationCallItxnFn, bg as applicationCallItxnParamsType, bh as applicationItxnType, bi as applicationPType, bj as arc28EmitFunction, bk as arc4AbiMethodDecorator, bl as arc4AddressAlias, bm as arc4BareMethodDecorator, bn as arc4BaseContractType, bo as arc4BooleanType, bp as arc4ByteAlias, bq as arc4StringType, br as arc4StructBaseType, bs as arc4Uint64, bt as assertFunction, bu as assertMatchFunction, bv as assetConfigGtxnType, bw as assetConfigItxnFn, bx as assetConfigItxnParamsType, by as assetConfigItxnType, bz as assetFreezeGtxnType, bA as assetFreezeItxnFn, bB as assetFreezeItxnParamsType, bC as assetFreezeItxnType, bD as assetPType, bE as assetTransferGtxnType, bF as assetTransferItxnFn, bG as assetTransferItxnParamsType, bH as assetTransferItxnType, bI as base64PType, bJ as baseContractType, bK as bigIntPType, bL as biguintPType, bM as boolPType, bN as bytesPType, bO as bzeroFunction, bP as cloneFunctionPType, bQ as compileArc4Function, bR as compileFunctionType, bS as compiledContractType, bT as compiledLogicSigType, bU as contractOptionsDecorator, bV as convertBytesFunction, bW as decodeArc4Function, bX as ecPType, bY as ecdsaPType, bZ as encodeArc4Function, b_ as ensureBudgetFunction, b$ as errFunction, c0 as esSymbol, c1 as inputOnlyObjects, c2 as isArrayType, c3 as isObjectType, c4 as isTupleLike, c5 as itoaMethod, c6 as itxnComposePType, c7 as keyRegistrationGtxnType, c8 as keyRegistrationItxnFn, c9 as keyRegistrationItxnParamsType, ca as keyRegistrationItxnType, cb as logFunction, cc as logicSigBaseType, cd as logicSigOptionsDecorator, ce as matchFunction, cf as methodSelectorFunction, cg as mimcConfigurationsPType, ch as neverPType, ci as nullPType, cj as numberPType, ck as onCompleteActionType, cl as opUpFeeSourceType, cm as paymentGtxnType, cn as paymentItxnFn, co as paymentItxnParamsType, cp as paymentItxnType, cq as ptypeToArc4EncodedType, cr as readonlyDecorator, cs as sizeOfFunction, ct as stringPType, cu as submitGroupItxnFunction, cv as transactionTypeType, cw as uint64PType, cx as undefinedPType, cy as unknownPType, cz as urangeFunction, cA as validateEncodingFunctionPType, cB as voidPType, cC as vrfVerifyPType, cD as uint8ArrayToBigInt, cE as uint8ArrayToBase64, cF as uint8ArrayToBase32, cG as uint8ArrayToHex, cH as uint8ArrayToUtf8, cI as base64ToUint8Array, cJ as base32ToUint8Array, cK as hexToUint8Array, cL as bigIntToUint8Array, cM as utf8ToUint8Array } from './options-COFRHTFQ.js';
-export { cU as AbsolutePath, cT as CompileOptions, cS as LoggingContext, cN as SourceLocation, cQ as TypeResolver, cR as processInputPaths, cO as registerPTypes, cP as typeRegistry } from './options-COFRHTFQ.js';
-export { c as compile } from './compile-Bz8LVwK2.js';
-import 'arcsecond';
+import { o as ABICompatibleInstanceType, q as ALL_OP_ENUMS, r as AccountFunction, s as AnyPType, t as ApplicationCallTxnFunction, u as ApplicationFunction, 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 applicationCallItxnFunction, b4 as applicationCallItxnParamsType, b5 as applicationCallItxnType, 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 assetConfigItxnFunction, bd as assetConfigItxnParamsType, be as assetConfigItxnType, m as assetFreezeGtxnType, bf as assetFreezeItxnFunction, bg as assetFreezeItxnParamsType, bh as assetFreezeItxnType, g as assetPType, j as assetTransferGtxnType, bi as assetTransferItxnFunction, 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 cloneFunction, bt as compileFunction, 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 keyRegistrationItxnFunction, 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 paymentItxnFunction, 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 validateEncodingFunction, 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-pgJctz5F.js';
+export { A as AbsolutePath, L as LogLevel, cg as LogSource, a as LoggingContext, ch as SourceLocation } from './contract-class-model-pgJctz5F.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 ARC4TupleGeneric, h as ARC4TupleType, i as AddressClass, B as ByteClass, C as ContractProxyGeneric, j as ContractProxyType, D as DynamicArrayGeneric, k as DynamicArrayType, l as DynamicBytesClass, S as StaticArrayGeneric, m as StaticArrayType, n as StaticBytesGeneric, o as StaticBytesType, T as TypedApplicationCallResponseGeneric, p as TypedApplicationCallResponseType, U as UFixedNxMGeneric, q as UFixedNxMType, r as UintN128Class, s as UintN16Class, t as UintN256Class, u as UintN32Class, v as UintN64Class, w as UintN8Class, x as UintNGeneric, y as UintNType, z as abiCallFunction, E as arc4AddressAlias, F as arc4BooleanType, G as arc4ByteAlias, H as arc4StringType, I as arc4StructBaseType, J as compileArc4Function, K as convertBytesFunction, L as decodeArc4Function, M as dynamicBytesType, N as encodeArc4Function, O as methodSelectorFunction, P as sizeOfFunction, Q as uint8ArrayToHex, R as hexToUint8Array } from './options-8bOJR8qx.js';
+export { V as CompileOptions, W as TypeResolver, X as processInputPaths, Y as registerPTypes, Z as typeRegistry } from './options-8bOJR8qx.js';
+export { c as compile } from './compile-BaYaEC1Y.js';
+import 'typescript';
 import 'node:fs';
 import 'node:util';
 import 'pathe';
-import 'tslib';
-import 'node:buffer';
-import 'typescript';
 import 'node:crypto';
+import 'polytype';
 import 'node:async_hooks';
+import 'arcsecond';
+import 'tslib';
+import 'node:buffer';
 import 'cross-spawn';
 import 'util';
 import 'path';
@@ -17,12 +20,15 @@ import 'os';
 import 'crypto';
 import 'net';
 import 'change-case';
-import 'polytype';
 import 'glob';
 import 'minimatch';
-import './resolve-puya-path-DtTAMi0Y.js';
+import './arc4-clientgen-BMCeFyNd.js';
+import '@algorandfoundation/algokit-utils/abi';
 import 'fs';
+import 'fs/promises';
+import './semver-DpFo0aCr.js';
 import 'node:url';
+import './resolve-puya-path-EZBzWIlE.js';
 import 'signal-exit';
 import 'tar';
 import 'node:zlib';
@@ -40,14 +46,14 @@ var forExport = /*#__PURE__*/Object.freeze({
     ARC4StrClass: ARC4StrClass,
     ARC4StructClass: ARC4StructClass,
     ARC4StructType: ARC4StructType,
+    ARC4TupleGeneric: ARC4TupleGeneric,
     ARC4TupleType: ARC4TupleType,
     AccountFunction: AccountFunction,
     AddressClass: AddressClass,
     AnyPType: AnyPType,
-    ApplicationFunctionType: ApplicationFunctionType,
-    ApplicationTxnFunction: ApplicationTxnFunction,
+    ApplicationCallTxnFunction: ApplicationCallTxnFunction,
+    ApplicationFunction: ApplicationFunction,
     ApprovalProgram: ApprovalProgram,
-    Arc4TupleGeneric: Arc4TupleGeneric,
     ArrayGeneric: ArrayGeneric,
     ArrayLiteralPType: ArrayLiteralPType,
     ArrayPType: ArrayPType,
@@ -77,14 +83,15 @@ var forExport = /*#__PURE__*/Object.freeze({
     ContractProxyType: ContractProxyType,
     DynamicArrayGeneric: DynamicArrayGeneric,
     DynamicArrayType: DynamicArrayType,
-    DynamicBytesConstructor: DynamicBytesConstructor,
-    DynamicBytesType: DynamicBytesType,
+    DynamicBytesClass: DynamicBytesClass,
     FixedArrayGeneric: FixedArrayGeneric,
     FixedArrayPType: FixedArrayPType,
     FunctionPType: FunctionPType,
     GeneratorGeneric: GeneratorGeneric,
     GeneratorType: GeneratorType,
     GenericPType: GenericPType,
+    GlobalMapGeneric: GlobalMapGeneric,
+    GlobalMapType: GlobalMapType,
     GlobalStateGeneric: GlobalStateGeneric,
     GlobalStateType: GlobalStateType,
     GroupTransactionPType: GroupTransactionPType,
@@ -105,6 +112,8 @@ var forExport = /*#__PURE__*/Object.freeze({
     LibClassType: LibClassType,
     LibFunctionType: LibFunctionType,
     LibObjType: LibObjType,
+    LocalMapGeneric: LocalMapGeneric,
+    LocalMapType: LocalMapType,
     LocalStateGeneric: LocalStateGeneric,
     LocalStateType: LocalStateType,
     LogicSigPType: LogicSigPType,
@@ -163,9 +172,9 @@ var forExport = /*#__PURE__*/Object.freeze({
     anyItxnType: anyItxnType,
     anyPType: anyPType,
     applicationCallGtxnType: applicationCallGtxnType,
-    applicationCallItxnFn: applicationCallItxnFn,
+    applicationCallItxnFunction: applicationCallItxnFunction,
     applicationCallItxnParamsType: applicationCallItxnParamsType,
-    applicationItxnType: applicationItxnType,
+    applicationCallItxnType: applicationCallItxnType,
     applicationPType: applicationPType,
     arc28EmitFunction: arc28EmitFunction,
     arc4AbiMethodDecorator: arc4AbiMethodDecorator,
@@ -176,20 +185,19 @@ var forExport = /*#__PURE__*/Object.freeze({
     arc4ByteAlias: arc4ByteAlias,
     arc4StringType: arc4StringType,
     arc4StructBaseType: arc4StructBaseType,
-    arc4Uint64: arc4Uint64,
     assertFunction: assertFunction,
     assertMatchFunction: assertMatchFunction,
     assetConfigGtxnType: assetConfigGtxnType,
-    assetConfigItxnFn: assetConfigItxnFn,
+    assetConfigItxnFunction: assetConfigItxnFunction,
     assetConfigItxnParamsType: assetConfigItxnParamsType,
     assetConfigItxnType: assetConfigItxnType,
     assetFreezeGtxnType: assetFreezeGtxnType,
-    assetFreezeItxnFn: assetFreezeItxnFn,
+    assetFreezeItxnFunction: assetFreezeItxnFunction,
     assetFreezeItxnParamsType: assetFreezeItxnParamsType,
     assetFreezeItxnType: assetFreezeItxnType,
     assetPType: assetPType,
     assetTransferGtxnType: assetTransferGtxnType,
-    assetTransferItxnFn: assetTransferItxnFn,
+    assetTransferItxnFunction: assetTransferItxnFunction,
     assetTransferItxnParamsType: assetTransferItxnParamsType,
     assetTransferItxnType: assetTransferItxnType,
     base64PType: base64PType,
@@ -199,14 +207,15 @@ var forExport = /*#__PURE__*/Object.freeze({
     boolPType: boolPType,
     bytesPType: bytesPType,
     bzeroFunction: bzeroFunction,
-    cloneFunctionPType: cloneFunctionPType,
+    cloneFunction: cloneFunction,
     compileArc4Function: compileArc4Function,
-    compileFunctionType: compileFunctionType,
+    compileFunction: compileFunction,
     compiledContractType: compiledContractType,
     compiledLogicSigType: compiledLogicSigType,
     contractOptionsDecorator: contractOptionsDecorator,
     convertBytesFunction: convertBytesFunction,
     decodeArc4Function: decodeArc4Function,
+    dynamicBytesType: dynamicBytesType,
     ecPType: ecPType,
     ecdsaPType: ecdsaPType,
     encodeArc4Function: encodeArc4Function,
@@ -220,10 +229,12 @@ var forExport = /*#__PURE__*/Object.freeze({
     itoaMethod: itoaMethod,
     itxnComposePType: itxnComposePType,
     keyRegistrationGtxnType: keyRegistrationGtxnType,
-    keyRegistrationItxnFn: keyRegistrationItxnFn,
+    keyRegistrationItxnFunction: keyRegistrationItxnFunction,
     keyRegistrationItxnParamsType: keyRegistrationItxnParamsType,
     keyRegistrationItxnType: keyRegistrationItxnType,
     logFunction: logFunction,
+    loggedAssertFunction: loggedAssertFunction,
+    loggedErrFunction: loggedErrFunction,
     logicSigBaseType: logicSigBaseType,
     logicSigOptionsDecorator: logicSigOptionsDecorator,
     matchFunction: matchFunction,
@@ -235,10 +246,9 @@ var forExport = /*#__PURE__*/Object.freeze({
     onCompleteActionType: onCompleteActionType,
     opUpFeeSourceType: opUpFeeSourceType,
     paymentGtxnType: paymentGtxnType,
-    paymentItxnFn: paymentItxnFn,
+    paymentItxnFunction: paymentItxnFunction,
     paymentItxnParamsType: paymentItxnParamsType,
     paymentItxnType: paymentItxnType,
-    ptypeToArc4EncodedType: ptypeToArc4EncodedType,
     readonlyDecorator: readonlyDecorator,
     sizeOfFunction: sizeOfFunction,
     stringPType: stringPType,
@@ -248,7 +258,7 @@ var forExport = /*#__PURE__*/Object.freeze({
     undefinedPType: undefinedPType,
     unknownPType: unknownPType,
     urangeFunction: urangeFunction,
-    validateEncodingFunctionPType: validateEncodingFunctionPType,
+    validateEncodingFunction: validateEncodingFunction,
     voidPType: voidPType,
     vrfVerifyPType: vrfVerifyPType
 });

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 { ptypeToArc4EncodedType } from '../arc4-util'\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 } 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/language-server/compile-trigger-queue.d.ts

@@ -1,9 +1,9 @@
 import type * as lsp from 'vscode-languageserver/node';
-export type WorkspaceCompileTrigger = {
+type WorkspaceCompileTrigger = {
     type: 'workspace';
     uris: lsp.URI[];
 };
-export type FileCompileTrigger = {
+type FileCompileTrigger = {
     type: 'file';
     uris: lsp.URI[];
 };

package/language-server/puya-language-server.d.ts

@@ -1,43 +1,5 @@
-import { TextDocument } from 'vscode-languageserver-textdocument';
-import * as lsp from 'vscode-languageserver/node';
-import { LanguageServerLogSink } from '../logger/sinks/language-server-log-sink';
-import type { AnalyserService } from './analyser-service';
-import { CompileTriggerQueue } from './compile-trigger-queue';
-import { CompileWorker } from './compile-worker';
-import type { FileWithDiagnostics } from './diagnostics-manager';
-import { DiagnosticsManager } from './diagnostics-manager';
 export type LanguageServerOptions = {
     port?: number;
     customPuyaPath?: string;
 };
-export declare class PuyaLanguageServer {
-    readonly connection: lsp.Connection;
-    private readonly loggingSink;
-    readonly documents: lsp.TextDocuments<TextDocument>;
-    readonly triggers: CompileTriggerQueue;
-    readonly workspaceFolders: lsp.URI[];
-    readonly diagnosticsMgr: DiagnosticsManager;
-    readonly compileWorker: CompileWorker;
-    readonly analyserService: AnalyserService;
-    stopping: boolean;
-    constructor(connection: lsp.Connection, loggingSink: LanguageServerLogSink, puyaPath: string);
-    start(): void;
-    shutdown(): Promise<void>;
-    initialize(params: lsp.InitializeParams): lsp.InitializeResult;
-    initialized(params: lsp.InitializedParams): void;
-    fileDiagnosticsChanged(params: FileWithDiagnostics): Promise<void>;
-    documentDidChangeContent(params: lsp.TextDocumentChangeEvent<TextDocument>): void;
-    /**
-     * Bound to connection.onCodeAction and called when a user hovers over a piece of code.
-     *
-     * Params includes the text range the user is hovering over and any diagnostics known to the
-     * client at the time.
-     *
-     * Response should include actions the user can take and the command or text edits that should be
-     * invoked/applied if selected
-     * @param params
-     */
-    codeAction(params: lsp.CodeActionParams): lsp.CodeAction[];
-    configurationChange(params: lsp.DidChangeConfigurationParams): void;
-}
 export declare function startLanguageServer(options: LanguageServerOptions): Promise<void>;

package/logger/index.d.ts

@@ -9,13 +9,6 @@ export declare enum LogLevel {
     Debug = "debug",
     Critical = "critical"
 }
-export declare const logLevelToInt: {
-    critical: number;
-    error: number;
-    info: number;
-    warning: number;
-    debug: number;
-};
 export declare enum LogSource {
     Unspecified = 0,
     TypeScript = 1,